params now used as function instead of as a keyword.

Author: benedict-96

docs/src/double_derivative.md

@@ -18,7 +18,7 @@
 ```@example jacobian_gradient
 using AbstractNeuralNetworks
 using SymbolicNeuralNetworks
-using SymbolicNeuralNetworks: Jacobian, Gradient, derivative
+using SymbolicNeuralNetworks: Jacobian, Gradient, derivative, params
 using Latexify: latexify
 
 c = Chain(Dense(2, 1, tanh; use_bias = false))
@@ -92,7 +92,7 @@ x = \begin{pmatrix} 1 \\ 0 \end{pmatrix}, \quad W = \begin{bmatrix} 1 & 0 \\ 0 &
 ```
 
 ```@example jacobian_gradient
-built_function = build_nn_function(derivative(g), nn.params, nn.input)
+built_function = build_nn_function(derivative(g), params(nn), nn.input)
 
 x = [1., 0.]
 ps = NeuralNetworkParameters((L1 = (W = [1. 0.; 0. 1.], b = [0., 0.]), ))

docs/src/symbolic_neural_networks.md

@@ -6,7 +6,7 @@ We first call the symbolic neural network that only consists of one layer:
 
 ```@example snn
 using SymbolicNeuralNetworks
-using AbstractNeuralNetworks: Chain, Dense, initialparameters
+using AbstractNeuralNetworks: Chain, Dense, initialparameters, params
 
 input_dim = 2
 output_dim = 1
@@ -23,7 +23,7 @@ using Symbolics
 using Latexify: latexify
 
 @variables sinput[1:input_dim]
-soutput = nn.model(sinput, nn.params)
+soutput = nn.model(sinput, params(nn))
 
 soutput
 ```
@@ -101,7 +101,7 @@ We now compare the neural network-approximated curve to the original one:
 fig = Figure()
 ax = Axis3(fig[1, 1])
 
-surface!(x_vec, y_vec, [c([x, y], nn_cpu.params)[1] for x in x_vec, y in y_vec]; alpha = .8, colormap = :darkterrain, transparency = true)
+surface!(x_vec, y_vec, [c([x, y], params(nn_cpu))[1] for x in x_vec, y in y_vec]; alpha = .8, colormap = :darkterrain, transparency = true)
 fig
 ```
 

scripts/pullback_comparison.jl

@@ -19,16 +19,16 @@ output = rand(1, batch_size)
 # output sensitivities
 _do = 1.
 
-# spb(nn_cpu.params, nn.model, (input, output))[2](_do)
-# zpb(nn_cpu.params, nn.model, (input, output))[2](_do)
-# @time spb_evaluated = spb(nn_cpu.params, nn.model, (input, output))[2](_do)
-# @time zpb_evaluated = zpb(nn_cpu.params, nn.model, (input, output))[2](_do)[1].params
+# spb(params(nn_cpu), nn.model, (input, output))[2](_do)
+# zpb(params(nn_cpu), nn.model, (input, output))[2](_do)
+# @time spb_evaluated = spb(params(nn_cpu), nn.model, (input, output))[2](_do)
+# @time zpb_evaluated = zpb(params(nn_cpu), nn.model, (input, output))[2](_do)[1].params
 # @assert values(spb_evaluated) .≈ values(zpb_evaluated)
 
 function timenn(pb, params, model, input, output, _do = 1.)
     pb(params, model, (input, output))[2](_do)
     @time pb(params, model, (input, output))[2](_do)
 end
 
-timenn(spb, nn_cpu.params, nn.model, input, output)
-timenn(zpb, nn_cpu.params, nn.model, input, output)
+timenn(spb, params(nn_cpu), nn.model, input, output)
+timenn(zpb, params(nn_cpu), nn.model, input, output)

src/build_function/build_function.jl

@@ -19,7 +19,7 @@ The functions mentioned in the implementation section were adjusted ad-hoc to de
 Other problems may occur. In case you bump into one please [open an issue on github](https://github.com/JuliaGNI/SymbolicNeuralNetworks.jl/issues).
 """
 function build_nn_function(eq::EqT, nn::AbstractSymbolicNeuralNetwork)
-    build_nn_function(eq, nn.params, nn.input)
+    build_nn_function(eq, params(nn), nn.input)
 end
 
 function build_nn_function(eq::EqT, sparams::NeuralNetworkParameters, sinput::Symbolics.Arr)
@@ -40,16 +40,16 @@ Build a function that can process a matrix. This is used as a starting point for
 
 ```jldoctest
 using SymbolicNeuralNetworks: _build_nn_function, SymbolicNeuralNetwork
-using AbstractNeuralNetworks
+using AbstractNeuralNetworks: params, Chain, Dense, NeuralNetwork
 import Random
 Random.seed!(123)
 
 c = Chain(Dense(2, 1, tanh))
 nn = NeuralNetwork(c)
 snn = SymbolicNeuralNetwork(nn)
-eq = c(snn.input, snn.params)
-built_function = _build_nn_function(eq, snn.params, snn.input)
-built_function([1. 2.; 3. 4.], nn.params, 1)
+eq = c(snn.input, params(snn))
+built_function = _build_nn_function(eq, params(snn), snn.input)
+built_function([1. 2.; 3. 4.], params(nn), 1)
 
 # output
 

src/build_function/build_function_arrays.jl

@@ -7,17 +7,17 @@ Build an executable function based on an array of symbolic equations `eqs`.
 
 ```jldoctest
 using SymbolicNeuralNetworks: build_nn_function, SymbolicNeuralNetwork
-using AbstractNeuralNetworks: Chain, Dense, NeuralNetwork
+using AbstractNeuralNetworks: Chain, Dense, NeuralNetwork, params
 import Random
 Random.seed!(123)
 
 ch = Chain(Dense(2, 1, tanh))
 nn = NeuralNetwork(ch)
 snn = SymbolicNeuralNetwork(nn)
-eqs = [(a = ch(snn.input, snn.params), b = ch(snn.input, snn.params).^2), (c = ch(snn.input, snn.params).^3, )]
-funcs = build_nn_function(eqs, snn.params, snn.input)
+eqs = [(a = ch(snn.input, params(snn)), b = ch(snn.input, params(snn)).^2), (c = ch(snn.input, params(snn)).^3, )]
+funcs = build_nn_function(eqs, params(snn), snn.input)
 input = [1., 2.]
-funcs_evaluated = funcs(input, nn.params)
+funcs_evaluated = funcs(input, params(nn))
 
 # output
 
@@ -44,17 +44,17 @@ Return a function that takes an input, (optionally) an output and neural network
 
 ```jldoctest
 using SymbolicNeuralNetworks: build_nn_function, SymbolicNeuralNetwork
-using AbstractNeuralNetworks: Chain, Dense, NeuralNetwork
+using AbstractNeuralNetworks: Chain, Dense, NeuralNetwork, params
 import Random
 Random.seed!(123)
 
 c = Chain(Dense(2, 1, tanh))
 nn = NeuralNetwork(c)
 snn = SymbolicNeuralNetwork(nn)
-eqs = (a = c(snn.input, snn.params), b = c(snn.input, snn.params).^2)
-funcs = build_nn_function(eqs, snn.params, snn.input)
+eqs = (a = c(snn.input, params(snn)), b = c(snn.input, params(snn)).^2)
+funcs = build_nn_function(eqs, params(snn), snn.input)
 input = [1., 2.]
-funcs_evaluated = funcs(input, nn.params)
+funcs_evaluated = funcs(input, params(nn))
 
 # output
 
@@ -83,14 +83,14 @@ Return an executable function for each entry in `eqs`. This still has to be proc
 
 ```jldoctest
 using SymbolicNeuralNetworks: function_valued_parameters, SymbolicNeuralNetwork
-using AbstractNeuralNetworks: Chain, Dense, initialparameters, NeuralNetworkParameters
+using AbstractNeuralNetworks: Chain, Dense, initialparameters, NeuralNetworkParameters, params
 import Random
 Random.seed!(123)
 
 c = Chain(Dense(2, 1, tanh))
 nn = SymbolicNeuralNetwork(c)
-eqs = (a = c(nn.input, nn.params), b = c(nn.input, nn.params).^2)
-funcs = function_valued_parameters(eqs, nn.params, nn.input)
+eqs = (a = c(nn.input, params(nn)), b = c(nn.input, params(nn)).^2)
+funcs = function_valued_parameters(eqs, params(nn), nn.input)
 input = [1., 2.]
 ps = initialparameters(c) |> NeuralNetworkParameters
 a = c(input, ps)

src/build_function/build_function_double_input.jl

@@ -13,7 +13,7 @@ Also compare this to [`build_nn_function(::EqT, ::AbstractSymbolicNeuralNetwork)
 See the *extended help section* of [`build_nn_function(::EqT, ::AbstractSymbolicNeuralNetwork)`](@ref).
 """
 function build_nn_function(eqs, nn::AbstractSymbolicNeuralNetwork, soutput)
-    build_nn_function(eqs, nn.params, nn.input, soutput)
+    build_nn_function(eqs, params(nn), nn.input, soutput)
 end
 
 function build_nn_function(eq::EqT, sparams::NeuralNetworkParameters, sinput::Symbolics.Arr, soutput::Symbolics.Arr)

src/derivatives/gradient.jl

@@ -75,7 +75,7 @@ function Gradient(output::EqT, nn::SymbolicNeuralNetwork)
 end
 
 function Gradient(nn::SymbolicNeuralNetwork)
-    Gradient(nn.model(nn.input, nn.params), nn)
+    Gradient(nn.model(nn.input, params(nn)), nn)
 end
 
 @doc raw"""
@@ -90,12 +90,13 @@ This is used by [`Gradient`](@ref) and [`SymbolicPullback`](@ref).
 ```jldoctest
 using SymbolicNeuralNetworks: SymbolicNeuralNetwork, symbolic_pullback
 using AbstractNeuralNetworks
+using AbstractNeuralNetworks: params
 using LinearAlgebra: norm
 using Latexify: latexify
 
 c = Chain(Dense(2, 1, tanh))
 nn = SymbolicNeuralNetwork(c)
-output = c(nn.input, nn.params)
+output = c(nn.input, params(nn))
 spb = symbolic_pullback(output, nn)
 
 spb[1].L1.b |> latexify
@@ -113,6 +114,6 @@ L"\begin{equation}
 ```
 """
 function symbolic_pullback(soutput::EqT, nn::AbstractSymbolicNeuralNetwork)::Union{AbstractArray{<:Union{NamedTuple, NeuralNetworkParameters}}, Union{NamedTuple, NeuralNetworkParameters}}
-    symbolic_diffs = symbolic_differentials(nn.params)
+    symbolic_diffs = symbolic_differentials(params(nn))
     [symbolic_derivative(soutput_single, symbolic_diffs) for soutput_single ∈ soutput]
 end

src/derivatives/jacobian.jl

@@ -18,7 +18,7 @@ The output of `Jacobian` consists of a `NamedTuple` that has the following keys:
 If `output` is not supplied as an input argument than it is taken to be:
 
 ```julia 
-soutput = nn.model(nn.input, nn.params)
+soutput = nn.model(nn.input, params(nn))
 ```
 
 # Implementation
@@ -82,7 +82,7 @@ derivative(j::Jacobian) = j.□
 function Jacobian(nn::AbstractSymbolicNeuralNetwork)
 
     # Evaluation of the symbolic output
-    soutput = nn.model(nn.input, nn.params)
+    soutput = nn.model(nn.input, params(nn))
 
     Jacobian(soutput, nn)
 end

src/derivatives/pullback.jl

@@ -41,7 +41,7 @@ We note the following seeming peculiarity:
 
 ```jldoctest
 using SymbolicNeuralNetworks
-using AbstractNeuralNetworks
+using AbstractNeuralNetworks: Chain, Dense, NeuralNetwork, FeedForwardLoss, params
 using Symbolics
 import Random
 Random.seed!(123)
@@ -52,13 +52,13 @@ snn = SymbolicNeuralNetwork(nn)
 loss = FeedForwardLoss()
 pb = SymbolicPullback(snn, loss)
 input_output = (rand(2), rand(1))
-loss_and_pullback = pb(nn.params, nn.model, input_output)
+loss_and_pullback = pb(params(nn), nn.model, input_output)
 # note that we apply the second argument to another input `1`
 pb_values = loss_and_pullback[2](1)
 
 @variables soutput[1:SymbolicNeuralNetworks.output_dimension(nn.model)]
-symbolic_pullbacks = SymbolicNeuralNetworks.symbolic_pullback(loss(nn.model, snn.params, snn.input, soutput), snn)
-pb_values2 = build_nn_function(symbolic_pullbacks, snn.params, snn.input, soutput)(input_output[1], input_output[2], nn.params)
+symbolic_pullbacks = SymbolicNeuralNetworks.symbolic_pullback(loss(nn.model, params(snn), snn.input, soutput), snn)
+pb_values2 = build_nn_function(symbolic_pullbacks, params(snn), snn.input, soutput)(input_output[1], input_output[2], params(nn))
 
 pb_values == (pb_values2 |> SymbolicNeuralNetworks._get_contents |> SymbolicNeuralNetworks._get_params)
 
@@ -88,9 +88,9 @@ end
 
 function SymbolicPullback(nn::SymbolicNeuralNetwork, loss::NetworkLoss)
     @variables soutput[1:output_dimension(nn.model)]
-    symbolic_loss = loss(nn.model, nn.params, nn.input, soutput)
+    symbolic_loss = loss(nn.model, params(nn), nn.input, soutput)
     symbolic_pullbacks = symbolic_pullback(symbolic_loss, nn)
-    pbs_executable = build_nn_function(symbolic_pullbacks, nn.params, nn.input, soutput)
+    pbs_executable = build_nn_function(symbolic_pullbacks, params(nn), nn.input, soutput)
     function pbs(input, output, params)
         pullback(::Union{Real, AbstractArray{<:Real}}) = _get_contents(_get_params(pbs_executable(input, output, params)))
         pullback
@@ -106,7 +106,7 @@ SymbolicPullback(nn::SymbolicNeuralNetwork) = SymbolicPullback(nn, AbstractNeura
 Return the `NamedTuple` that's equivalent to the `NeuralNetworkParameters`.
 """
 _get_params(nt::NamedTuple) = nt
-_get_params(ps::NeuralNetworkParameters) = ps.params
+_get_params(ps::NeuralNetworkParameters) = params(ps)
 _get_params(ps::NamedTuple{(:params,), Tuple{NT}}) where {NT<:NamedTuple} = ps.params
 _get_params(ps::AbstractArray{<:Union{NamedTuple, NeuralNetworkParameters}}) = [_get_params(nt) for nt in ps]
 

src/symbolic_neuralnet/symbolic_neuralnet.jl

@@ -31,7 +31,7 @@ end
 
 function SymbolicNeuralNetwork(nn::NeuralNetwork)
     cache = Dict()
-    sparams = symbolize!(cache, nn.params, :W)
+    sparams = symbolize!(cache, params(nn), :W)
     @variables sinput[1:input_dimension(nn.model)]
 
     SymbolicNeuralNetwork(nn.architecture, nn.model, sparams, sinput)
@@ -54,6 +54,8 @@ function SymbolicNeuralNetwork(d::AbstractExplicitLayer)
     SymbolicNeuralNetwork(UnknownArchitecture(), d)
 end
 
+params(snn::AbstractSymbolicNeuralNetwork) = snn.params
+
 apply(snn::AbstractSymbolicNeuralNetwork, x, args...) = snn(x, args...)
 
 input_dimension(::AbstractExplicitLayer{M}) where M = M 
@@ -68,5 +70,5 @@ function Base.show(io::IO, snn::SymbolicNeuralNetwork)
     print(io, "\nModel = ")
     print(io, snn.model)
     print(io, "\nSymbolic Params = ")
-    print(io, snn.params)
+    print(io, params(snn))
 end