Merge pull request #26 from JuliaGNI/output-to-f

Changed keyword output -> f.

Author: michakraus

Project.toml

@@ -20,7 +20,6 @@ ForwardDiff = "0.10.38"
 GeometricMachineLearning = "0.4"
 Latexify = "0.16.5"
 RuntimeGeneratedFunctions = "0.5"
-SafeTestsets = "0.1"
 SymbolicUtils = "<3.8.0"
 Symbolics = "5, 6"
 Zygote = "0.6.73"

src/derivatives/derivative.jl

@@ -19,16 +19,16 @@ function symbolic_differentials(sparams::NeuralNetworkParameters)
     NeuralNetworkParameters{keys(sparams)}(vals)
 end
 
-function symbolic_derivative(soutput, Dx::AbstractArray)
-    [expand_derivatives(Symbolics.scalarize(dx(soutput))) for dx in Dx]
+function symbolic_derivative(f, Dx::AbstractArray)
+    [expand_derivatives(Symbolics.scalarize(dx(f))) for dx in Dx]
 end
 
-function symbolic_derivative(soutput, dps::NamedTuple)
-    gradient_values = (symbolic_derivative(soutput, dps[key]) for key in keys(dps))
+function symbolic_derivative(f, dps::NamedTuple)
+    gradient_values = (symbolic_derivative(f, dps[key]) for key in keys(dps))
     NamedTuple{keys(dps)}(gradient_values)
 end
 
-function symbolic_derivative(soutput, dps::NeuralNetworkParameters)
-    vals = Tuple(symbolic_derivative(soutput, dp) for dp in values(dps))
+function symbolic_derivative(f, dps::NeuralNetworkParameters)
+    vals = Tuple(symbolic_derivative(f, dp) for dp in values(dps))
     NeuralNetworkParameters{keys(dps)}(vals)
 end

src/derivatives/gradient.jl

@@ -5,13 +5,17 @@ Computes and stores the gradient of a symbolic function with respect to the para
 
 # Constructors
 
-    Gradient(output, nn)
+    Gradient(f, nn)
 
-Differentiate the symbolic `output` with respect to the parameters of `nn`.
+Differentiate the symbolic `f` with respect to the parameters of `nn`.
 
     Gradient(nn)
 
-Compute the symbolic output of `nn` and differentiate it with respect to the parameters of `nn`.
+Compute the symbolic output of `nn` and differentiate it with respect to the parameters of `nn`. This does:
+
+```julia
+nn.model(nn.input, params(nn))
+```
 
 # Examples
 
@@ -29,7 +33,7 @@ nn = SymbolicNeuralNetwork(c)
 Internally the constructors are using [`symbolic_pullback`](@ref).
 """
 struct Gradient{OT, SDT, ST} <: Derivative{OT, SDT, ST} 
-    output::OT
+    f::OT
     ∇::SDT
     nn::ST
 end
@@ -39,6 +43,8 @@ end
 
 # Examples
 
+We compare this to [`symbolic_pullback`](@ref) here:
+
 ```jldoctest
 using SymbolicNeuralNetworks: SymbolicNeuralNetwork, Gradient, derivative, symbolic_pullback
 using AbstractNeuralNetworks
@@ -48,7 +54,7 @@ nn = SymbolicNeuralNetwork(c)
 g = Gradient(nn)
 ∇ = derivative(g)
 
-isequal(∇, symbolic_pullback(g.output, nn))
+isequal(∇, symbolic_pullback(g.f, nn))
 
 # output
 
@@ -67,9 +73,9 @@ function Gradient(nn::SymbolicNeuralNetwork)
 end
 
 @doc raw"""
-    symbolic_pullback(nn, output)
+    symbolic_pullback(f, nn)
 
-This takes a symbolic output that depends on the parameters in `nn` and returns the corresponding pullback (a symbolic expression).
+This takes a symbolic `f`` that depends on the parameters in `nn` and returns the corresponding pullback (a symbolic expression).
 
 This is used by [`Gradient`](@ref) and [`SymbolicPullback`](@ref).
 
@@ -89,7 +95,7 @@ spb = symbolic_pullback(output, nn)
 spb[1].L1.b
 ```
 """
-function symbolic_pullback(soutput::EqT, nn::AbstractSymbolicNeuralNetwork)::Union{AbstractArray{<:Union{NamedTuple, NeuralNetworkParameters}}, Union{NamedTuple, NeuralNetworkParameters}}
+function symbolic_pullback(f::EqT, nn::AbstractSymbolicNeuralNetwork)::Union{AbstractArray{<:Union{NamedTuple, NeuralNetworkParameters}}, Union{NamedTuple, NeuralNetworkParameters}}
     symbolic_diffs = symbolic_differentials(params(nn))
-    [symbolic_derivative(soutput_single, symbolic_diffs) for soutput_single ∈ soutput]
+    [symbolic_derivative(f_single, symbolic_diffs) for f_single ∈ f]
 end

src/derivatives/jacobian.jl

@@ -1,24 +1,27 @@
 @doc raw"""
     Jacobian <: Derivative
 
-An instance of [`Derivative`](@ref). Computes the derivatives of a neural network with respect to its inputs.
+An subtype of [`Derivative`](@ref). Computes the derivatives of a neural network with respect to its inputs.
 
 # Constructors
 
-    Jacobian(output, nn)
+    Jacobian(f, nn)
     Jacobian(nn)
 
 Compute the jacobian of a [`SymbolicNeuralNetwork`](@ref) with respect to the input arguments.
 
-The output of `Jacobian` consists of a `NamedTuple` that has the following keys:
-1. a symbolic expression of the input (keyword `x`),
-2. a symbolic expression of the output (keyword `soutput`),
-3. a symbolic expression of the gradient (keyword `s∇output`).
 
-If `output` is not supplied as an input argument than it is taken to be:
+# Keys
+
+`Jacobian` has the following keys:
+1. `nn::`[`SymbolicNeuralNetwork`](@ref),
+2. `f`: a symbolic expression to be differentiated,
+3. `□`: a symbolic expression of the Jacobian.
+
+If `f` is not supplied as an input argument than it is taken to be:
 
 ```julia 
-soutput = nn.model(nn.input, params(nn))
+f = nn.model(nn.input, params(nn))
 ```
 
 # Implementation
@@ -72,21 +75,21 @@ true
 ```
 """
 struct Jacobian{OT, SDT, ST} <: Derivative{OT, SDT, ST} 
-    output::OT
+    f::OT
     □::SDT
     nn::ST
 end
 
 derivative(j::Jacobian) = j.□
 
-function Jacobian(soutput::EqT, nn::AbstractSymbolicNeuralNetwork)
+function Jacobian(f::EqT, nn::AbstractSymbolicNeuralNetwork)
     # make differential 
     Dx = symbolic_differentials(nn.input)
 
     # Evaluation of gradient
-    s∇output = hcat([expand_derivatives.(Symbolics.scalarize(dx(soutput))) for dx in Dx]...)
+    s∇f = hcat([expand_derivatives.(Symbolics.scalarize(dx(f))) for dx in Dx]...)
 
-    Jacobian(soutput, s∇output, nn)
+    Jacobian(f, s∇f, nn)
 end
 
 function Jacobian(nn::AbstractSymbolicNeuralNetwork)

test/derivatives/jacobian.jl

@@ -28,14 +28,12 @@ function test_jacobian(n::Integer, T = Float32)
 
     _params = params(NeuralNetwork(c, T))
     input = rand(T, n)
-    f = build_nn_function(g.output, nn)
-    ∇f = build_nn_function(derivative(g), nn)
-    @test f(input, params) ≈ c(input, params)
-    @test ∇f(input, params) ≈ ForwardDiff.jacobian(input -> c(input, params), input)
+    @test build_nn_function(g.f, nn)(input, _params) ≈ c(input, _params)
+    @test build_nn_function(derivative(g), nn)(input, _params) ≈ ForwardDiff.jacobian(input -> c(input, _params), input)
 end
 
 for n ∈ 10:1
     for T ∈ (Float32, Float64)
         test_jacobian(n, T)
-    end
+    end 
 end