Changed keyword output -> f and fixed SymbolicUtils version.

Author: benedict-96

Project.toml

@@ -10,16 +10,20 @@ LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 RuntimeGeneratedFunctions = "7e49a35a-f44a-4d26-94aa-eba1b4ca6b47"
 Symbolics = "0c5d862f-8b57-4792-8d23-62f2024744c7"
 
+[weakdeps]
+SymbolicUtils = "d1185830-fcd6-423d-90d6-eec64667417b"
+
 [compat]
 AbstractNeuralNetworks = "0.3, 0.4, 0.5"
 Documenter = "1.8.0"
 ForwardDiff = "0.10.38"
 GeometricMachineLearning = "0.3.7"
 Latexify = "0.16.5"
 RuntimeGeneratedFunctions = "0.5"
+SymbolicUtils = "<3.8.0"
 Symbolics = "5, 6"
 Zygote = "0.6.73"
-julia = "1.6"
+julia = "1.10"
 
 [extras]
 Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"

src/derivatives/derivative.jl

@@ -1,7 +1,7 @@
 """
     Derivative
 """
-abstract type Derivative{ST, OT, SDT} end
+abstract type Derivative{ST, FT, SDT} end
 
 derivative(::DT) where {DT <: Derivative} = error("No method of function `derivative` defined for type $(DT).")
 
@@ -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
 
@@ -40,9 +44,9 @@ L"\begin{equation}
 
 Internally the constructors are using [`symbolic_pullback`](@ref).
 """
-struct Gradient{ST, OT, SDT} <: Derivative{ST, OT, SDT} 
+struct Gradient{ST, FT, SDT} <: Derivative{ST, FT, SDT} 
     nn::ST
-    output::OT
+    f::FT
     ∇::SDT
 end
 
@@ -51,6 +55,8 @@ end
 
 # Examples
 
+We compare this to [`symbolic_pullback`](@ref) here:
+
 ```jldoctest
 using SymbolicNeuralNetworks: SymbolicNeuralNetwork, Gradient, derivative, symbolic_pullback
 using AbstractNeuralNetworks
@@ -60,7 +66,7 @@ nn = SymbolicNeuralNetwork(c)
 g = Gradient(nn)
 ∇ = derivative(g)
 
-isequal(∇, symbolic_pullback(g.output, nn))
+isequal(∇, symbolic_pullback(g.f, nn))
 
 # output
 
@@ -79,9 +85,9 @@ function Gradient(nn::SymbolicNeuralNetwork)
 end
 
 @doc raw"""
-    symbolic_pullback(nn, output)
+    symbolic_pullback(nn, f)
 
-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).
 
@@ -113,7 +119,7 @@ L"\begin{equation}
 "
 ```
 """
-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
@@ -71,9 +74,9 @@ jacobian1(input, ps) ≈ [analytic_jacobian(i, j) for j ∈ 1:output_dim, i ∈
 true
 ```
 """
-struct Jacobian{ST, OT, SDT} <: Derivative{ST, OT, SDT} 
+struct Jacobian{ST, FT, SDT} <: Derivative{ST, FT, SDT} 
     nn::ST
-    output::OT
+    f::FT
     □::SDT
 end
 
@@ -87,12 +90,12 @@ function Jacobian(nn::AbstractSymbolicNeuralNetwork)
     Jacobian(soutput, nn)
 end
 
-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(nn, soutput, s∇output)
+    Jacobian(nn, f, s∇f)
 end

test/derivatives/jacobian.jl

@@ -28,7 +28,7 @@ function test_jacobian(n::Integer, T = Float32)
 
     params = NeuralNetwork(c, T).params
     input = rand(T, n)
-    @test build_nn_function(g.output, nn)(input, params) ≈ c(input, params)
+    @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