From d20e26ed0156dd1862972cf460353bd1d91582f3 Mon Sep 17 00:00:00 2001 From: "Documenter.jl" Date: Thu, 14 Dec 2023 23:55:57 +0000 Subject: [PATCH] build based on 0906e41 --- .../api/Accelerator_Support/LuxAMDGPU.md | 35 + .../PR467/api/Accelerator_Support/LuxCUDA.md | 35 + .../api/Accelerator_Support/LuxDeviceUtils.md | 125 + previews/PR467/api/Building_Blocks/LuxCore.md | 270 +++ previews/PR467/api/Building_Blocks/LuxLib.md | 260 +++ .../api/Building_Blocks/WeightInitializers.md | 458 ++++ .../api/Domain_Specific_Modeling/Boltz.md | 300 +++ previews/PR467/api/Lux/contrib.md | 667 ++++++ previews/PR467/api/Lux/flux_to_lux.md | 111 + previews/PR467/api/Lux/layers.md | 2053 +++++++++++++++++ previews/PR467/api/Lux/utilities.md | 248 ++ .../api/Testing_Functionality/LuxTestUtils.md | 141 ++ previews/PR467/api/index.md | 76 + previews/PR467/ecosystem.md | 422 ++++ previews/PR467/introduction/citation.md | 33 + previews/PR467/introduction/index.md | 240 ++ previews/PR467/introduction/overview.md | 41 + previews/PR467/introduction/resources.md | 19 + previews/PR467/manual/debugging.md | 339 +++ .../PR467/manual/dispatch_custom_input.md | 162 ++ .../PR467/manual/freezing_model_parameters.md | 163 ++ previews/PR467/manual/gpu_management.md | 139 ++ previews/PR467/manual/interface.md | 297 +++ previews/PR467/manual/migrate_from_flux.md | 176 ++ previews/PR467/manual/weight_initializers.md | 142 ++ previews/PR467/siteinfo.js | 1 + .../advanced/1_GravitationalWaveForm-24.png | Bin 0 -> 59020 bytes .../advanced/1_GravitationalWaveForm-35.png | Bin 0 -> 82286 bytes .../advanced/1_GravitationalWaveForm-48.png | Bin 0 -> 12042 bytes .../advanced/1_GravitationalWaveForm-50.png | Bin 0 -> 89867 bytes .../advanced/1_GravitationalWaveForm.md | 547 +++++ previews/PR467/tutorials/beginner/1_Basics.md | 811 +++++++ .../beginner/2_PolynomialFitting-12.png | Bin 0 -> 29171 bytes .../beginner/2_PolynomialFitting-30.png | Bin 0 -> 31421 bytes .../tutorials/beginner/2_PolynomialFitting.md | 233 ++ .../PR467/tutorials/beginner/3_SimpleRNN.md | 272 +++ .../tutorials/beginner/trained_model.jld2 | Bin 0 -> 11307 bytes previews/PR467/tutorials/index.md | 129 ++ .../tutorials/intermediate/1_NeuralODE.md | 436 ++++ .../intermediate/2_BayesianNN-22.png | Bin 0 -> 53210 bytes .../intermediate/2_BayesianNN-29.png | Bin 0 -> 54943 bytes .../tutorials/intermediate/2_BayesianNN-8.png | Bin 0 -> 21242 bytes .../tutorials/intermediate/2_BayesianNN.md | 359 +++ .../tutorials/intermediate/3_HyperNet.md | 250 ++ .../PR467/tutorials/intermediate/results.gif | Bin 0 -> 284766 bytes 45 files changed, 9990 insertions(+) create mode 100644 previews/PR467/api/Accelerator_Support/LuxAMDGPU.md create mode 100644 previews/PR467/api/Accelerator_Support/LuxCUDA.md create mode 100644 previews/PR467/api/Accelerator_Support/LuxDeviceUtils.md create mode 100644 previews/PR467/api/Building_Blocks/LuxCore.md create mode 100644 previews/PR467/api/Building_Blocks/LuxLib.md create mode 100644 previews/PR467/api/Building_Blocks/WeightInitializers.md create mode 100644 previews/PR467/api/Domain_Specific_Modeling/Boltz.md create mode 100644 previews/PR467/api/Lux/contrib.md create mode 100644 previews/PR467/api/Lux/flux_to_lux.md create mode 100644 previews/PR467/api/Lux/layers.md create mode 100644 previews/PR467/api/Lux/utilities.md create mode 100644 previews/PR467/api/Testing_Functionality/LuxTestUtils.md create mode 100644 previews/PR467/api/index.md create mode 100644 previews/PR467/ecosystem.md create mode 100644 previews/PR467/introduction/citation.md create mode 100644 previews/PR467/introduction/index.md create mode 100644 previews/PR467/introduction/overview.md create mode 100644 previews/PR467/introduction/resources.md create mode 100644 previews/PR467/manual/debugging.md create mode 100644 previews/PR467/manual/dispatch_custom_input.md create mode 100644 previews/PR467/manual/freezing_model_parameters.md create mode 100644 previews/PR467/manual/gpu_management.md create mode 100644 previews/PR467/manual/interface.md create mode 100644 previews/PR467/manual/migrate_from_flux.md create mode 100644 previews/PR467/manual/weight_initializers.md create mode 100644 previews/PR467/siteinfo.js create mode 100644 previews/PR467/tutorials/advanced/1_GravitationalWaveForm-24.png create mode 100644 previews/PR467/tutorials/advanced/1_GravitationalWaveForm-35.png create mode 100644 previews/PR467/tutorials/advanced/1_GravitationalWaveForm-48.png create mode 100644 previews/PR467/tutorials/advanced/1_GravitationalWaveForm-50.png create mode 100644 previews/PR467/tutorials/advanced/1_GravitationalWaveForm.md create mode 100644 previews/PR467/tutorials/beginner/1_Basics.md create mode 100644 previews/PR467/tutorials/beginner/2_PolynomialFitting-12.png create mode 100644 previews/PR467/tutorials/beginner/2_PolynomialFitting-30.png create mode 100644 previews/PR467/tutorials/beginner/2_PolynomialFitting.md create mode 100644 previews/PR467/tutorials/beginner/3_SimpleRNN.md create mode 100644 previews/PR467/tutorials/beginner/trained_model.jld2 create mode 100644 previews/PR467/tutorials/index.md create mode 100644 previews/PR467/tutorials/intermediate/1_NeuralODE.md create mode 100644 previews/PR467/tutorials/intermediate/2_BayesianNN-22.png create mode 100644 previews/PR467/tutorials/intermediate/2_BayesianNN-29.png create mode 100644 previews/PR467/tutorials/intermediate/2_BayesianNN-8.png create mode 100644 previews/PR467/tutorials/intermediate/2_BayesianNN.md create mode 100644 previews/PR467/tutorials/intermediate/3_HyperNet.md create mode 100644 previews/PR467/tutorials/intermediate/results.gif diff --git a/previews/PR467/api/Accelerator_Support/LuxAMDGPU.md b/previews/PR467/api/Accelerator_Support/LuxAMDGPU.md new file mode 100644 index 0000000000..7c4cc8c98f --- /dev/null +++ b/previews/PR467/api/Accelerator_Support/LuxAMDGPU.md @@ -0,0 +1,35 @@ + + + +# LuxAMDGPU + + + + +`LuxAMDGPU` is meant to be used as a trigger package for all `AMDGPU` dependencies in `Lux`. Users requiring AMDGPU support should install `LuxAMDGPU` and load it alongside `Lux`. + + + + +## Index + +- [`LuxAMDGPU.functional`](#LuxAMDGPU.functional-Tuple{}) + + + + +## API + +
+# LuxAMDGPU.functional — Method. + + + +```julia +functional() +``` + +Check if LuxAMDGPU is functional. + +
+
diff --git a/previews/PR467/api/Accelerator_Support/LuxCUDA.md b/previews/PR467/api/Accelerator_Support/LuxCUDA.md new file mode 100644 index 0000000000..e8df00654f --- /dev/null +++ b/previews/PR467/api/Accelerator_Support/LuxCUDA.md @@ -0,0 +1,35 @@ + + + + + +# LuxCUDA + + +`LuxCUDA` is meant to be used as a trigger package for all `CUDA` dependencies in `Lux`. Users requiring CUDA support should install `LuxCUDA` and load it alongside `Lux`. + + + + +## Index + +- [`LuxCUDA.functional`](#LuxCUDA.functional-Tuple{}) + + + + +## API Reference + +
+# LuxCUDA.functional — Method. + + + +```julia +functional() +``` + +Check if LuxCUDA is functional. + +
+
diff --git a/previews/PR467/api/Accelerator_Support/LuxDeviceUtils.md b/previews/PR467/api/Accelerator_Support/LuxDeviceUtils.md new file mode 100644 index 0000000000..98b79a25ec --- /dev/null +++ b/previews/PR467/api/Accelerator_Support/LuxDeviceUtils.md @@ -0,0 +1,125 @@ + + + + + +# LuxDeviceUtils + + +`LuxDeviceUtils.jl` is a lightweight package defining rules for transferring data across devices. Most users should directly use Lux.jl instead. + + + + +## Index + +- [`LuxDeviceUtils.cpu_device`](#LuxDeviceUtils.cpu_device) +- [`LuxDeviceUtils.gpu_backend!`](#LuxDeviceUtils.gpu_backend!) +- [`LuxDeviceUtils.gpu_device`](#LuxDeviceUtils.gpu_device) +- [`LuxDeviceUtils.reset_gpu_device!`](#LuxDeviceUtils.reset_gpu_device!) +- [`LuxDeviceUtils.supported_gpu_backends`](#LuxDeviceUtils.supported_gpu_backends) + + + + +## Preferences + +
+# LuxDeviceUtils.gpu_backend! — Function. + + + +```julia +gpu_backend!() = gpu_backend!("") +gpu_backend!(backend) = gpu_backend!(string(backend)) +gpu_backend!(backend::AbstractLuxGPUDevice) +gpu_backend!(backend::String) +``` + +Creates a `LocalPreferences.toml` file with the desired GPU backend. + +If `backend == ""`, then the `gpu_backend` preference is deleted. Otherwise, `backend` is validated to be one of the possible backends and the preference is set to `backend`. + +If a new backend is successfully set, then the Julia session must be restarted for the change to take effect. + +
+
+ + + +## Data Transfer + +
+# LuxDeviceUtils.cpu_device — Function. + + + +```julia +cpu_device() -> LuxCPUDevice() +``` + +Return a `LuxCPUDevice` object which can be used to transfer data to CPU. + +
+
+
+# LuxDeviceUtils.gpu_device — Function. + + + +```julia +gpu_device(; force_gpu_usage::Bool=false) -> AbstractLuxDevice() +``` + +Selects GPU device based on the following criteria: + +1. If `gpu_backend` preference is set and the backend is functional on the system, then that device is selected. +2. Otherwise, an automatic selection algorithm is used. We go over possible device backends in the order specified by `supported_gpu_backends()` and select the first functional backend. +3. If no GPU device is functional and `force_gpu_usage` is `false`, then `cpu_device()` is invoked. +4. If nothing works, an error is thrown. + +
+
+ + + +## Miscellaneous + +
+# LuxDeviceUtils.reset_gpu_device! — Function. + + + +```julia +reset_gpu_device!() +``` + +Resets the selected GPU device. This is useful when automatic GPU selection needs to be run again. + +
+
+
+# LuxDeviceUtils.supported_gpu_backends — Function. + + + +```julia +supported_gpu_backends() -> Tuple{String, ...} +``` + +Return a tuple of supported GPU backends. + +::: warning + +This is not the list of functional backends on the system, but rather backends which `Lux.jl` supports. + +::: + +::: danger + +`Metal.jl` support is **extremely** experimental and most things are not expected to work. + +::: + +
+
diff --git a/previews/PR467/api/Building_Blocks/LuxCore.md b/previews/PR467/api/Building_Blocks/LuxCore.md new file mode 100644 index 0000000000..a132b7958c --- /dev/null +++ b/previews/PR467/api/Building_Blocks/LuxCore.md @@ -0,0 +1,270 @@ + + + +# LuxCore + + +`LuxCore.jl` defines the abstract layers for Lux. Allows users to be compatible with the entirely of `Lux.jl` without having such a heavy dependency. If you are depending on `Lux.jl` directly, you do not need to depend on `LuxCore.jl` (all the functionality is exported via `Lux.jl`). + + + + +## Index + +- [`LuxCore.AbstractExplicitContainerLayer`](#LuxCore.AbstractExplicitContainerLayer) +- [`LuxCore.AbstractExplicitLayer`](#LuxCore.AbstractExplicitLayer) +- [`LuxCore.apply`](#LuxCore.apply) +- [`LuxCore.check_fmap_condition`](#LuxCore.check_fmap_condition) +- [`LuxCore.contains_lux_layer`](#LuxCore.contains_lux_layer) +- [`LuxCore.display_name`](#LuxCore.display_name) +- [`LuxCore.initialparameters`](#LuxCore.initialparameters) +- [`LuxCore.initialstates`](#LuxCore.initialstates) +- [`LuxCore.parameterlength`](#LuxCore.parameterlength) +- [`LuxCore.setup`](#LuxCore.setup) +- [`LuxCore.statelength`](#LuxCore.statelength) +- [`LuxCore.testmode`](#LuxCore.testmode) +- [`LuxCore.trainmode`](#LuxCore.trainmode) +- [`LuxCore.update_state`](#LuxCore.update_state) + + + + +## Abstract Types + +
+# LuxCore.AbstractExplicitLayer — Type. + + + +```julia +abstract type AbstractExplicitLayer +``` + +Abstract Type for all Lux Layers + +Users implementing their custom layer, **must** implement + + * `initialparameters(rng::AbstractRNG, layer::CustomAbstractExplicitLayer)` – This returns a `NamedTuple` containing the trainable parameters for the layer. + * `initialstates(rng::AbstractRNG, layer::CustomAbstractExplicitLayer)` – This returns a NamedTuple containing the current state for the layer. For most layers this is typically empty. Layers that would potentially contain this include `BatchNorm`, `LSTM`, `GRU` etc. + +Optionally: + + * `parameterlength(layer::CustomAbstractExplicitLayer)` – These can be automatically calculated, but it is recommended that the user defines these. + * `statelength(layer::CustomAbstractExplicitLayer)` – These can be automatically calculated, but it is recommended that the user defines these. + +See also [`AbstractExplicitContainerLayer`](LuxCore#LuxCore.AbstractExplicitContainerLayer) + +
+
+
+# LuxCore.AbstractExplicitContainerLayer — Type. + + + +```julia +abstract type AbstractExplicitContainerLayer{layers} <: AbstractExplicitLayer +``` + +Abstract Container Type for certain Lux Layers. `layers` is a tuple containing fieldnames for the layer, and constructs the parameters and states using those. + +Users implementing their custom layer can extend the same functions as in [`AbstractExplicitLayer`](LuxCore#LuxCore.AbstractExplicitLayer). + +::: tip + +Advanced structure manipulation of these layers post construction is possible via `Functors.fmap`. For a more flexible interface, we recommend using the experimental feature [`Lux.Experimental.@layer_map`](@ref). + +::: + +
+
+ + + +## General + +
+# LuxCore.apply — Function. + + + +```julia +apply(model, x, ps, st) +``` + +Simply calls `model(x, ps, st)` + +
+
+
+# LuxCore.check_fmap_condition — Function. + + + +```julia +check_fmap_condition(cond, tmatch, x) -> Bool +``` + +`fmap`s into the structure `x` and see if `cond` is statisfied for any of the leaf elements. + +**Arguments** + +``` +* `cond` - A function that takes a single argument and returns a `Bool`. +* `tmatch` - A shortcut to check if `x` is of type `tmatch`. Can be disabled by passing + `nothing`. +* `x` - The structure to check. +``` + +**Returns** + +A Boolean Value + +
+
+
+# LuxCore.contains_lux_layer — Function. + + + +```julia +contains_lux_layer(l) -> Bool +``` + +Check if the structure `l` is a Lux AbstractExplicitLayer or a container of such a layer. + +
+
+
+# LuxCore.display_name — Function. + + + +```julia +display_name(layer::AbstractExplicitLayer) +``` + +Printed Name of the `layer`. If the `layer` has a field `name` that is used, else the type name is used. + +
+
+
+# LuxCore.setup — Function. + + + +```julia +setup(rng::AbstractRNG, layer) +``` + +Shorthand for getting the parameters and states of the layer `l`. Is equivalent to `(initialparameters(rng, l), initialstates(rng, l))`. + +::: warning + +This function is not pure, it mutates `rng`. + +::: + +
+
+ + + +## Parameters + +
+# LuxCore.initialparameters — Function. + + + +```julia +initialparameters(rng::AbstractRNG, layer) +``` + +Generate the initial parameters of the layer `l`. + +
+
+
+# LuxCore.parameterlength — Function. + + + +```julia +parameterlength(layer) +``` + +Return the total number of parameters of the layer `l`. + +
+
+ + + +## States + +
+# LuxCore.initialstates — Function. + + + +```julia +initialstates(rng::AbstractRNG, layer) +``` + +Generate the initial states of the layer `l`. + +
+
+
+# LuxCore.statelength — Function. + + + +```julia +statelength(layer) +``` + +Return the total number of states of the layer `l`. + +
+
+
+# LuxCore.testmode — Function. + + + +```julia +testmode(st::NamedTuple) +``` + +Make all occurances of `training` in state `st` – `Val(false)`. + +
+
+
+# LuxCore.trainmode — Function. + + + +```julia +trainmode(st::NamedTuple) +``` + +Make all occurances of `training` in state `st` – `Val(true)`. + +
+
+
+# LuxCore.update_state — Function. + + + +```julia +update_state(st::NamedTuple, key::Symbol, value; + layer_check=_default_layer_check(key)) +``` + +Recursively update all occurances of the `key` in the state `st` with the `value`. + +
+
diff --git a/previews/PR467/api/Building_Blocks/LuxLib.md b/previews/PR467/api/Building_Blocks/LuxLib.md new file mode 100644 index 0000000000..333e461406 --- /dev/null +++ b/previews/PR467/api/Building_Blocks/LuxLib.md @@ -0,0 +1,260 @@ + + + +# LuxLib + + +Backend for Lux.jl + + + + + + +## Index + +- [`LuxLib.alpha_dropout`](#LuxLib.alpha_dropout) +- [`LuxLib.batchnorm`](#LuxLib.batchnorm) +- [`LuxLib.dropout`](#LuxLib.dropout) +- [`LuxLib.groupnorm`](#LuxLib.groupnorm) +- [`LuxLib.instancenorm`](#LuxLib.instancenorm) +- [`LuxLib.layernorm`](#LuxLib.layernorm) + + + + +## Dropout + +
+# LuxLib.alpha_dropout — Function. + + + +```julia +alpha_dropout(rng::AbstractRNG, x, p, ::Val{training}) +alpha_dropout(rng::AbstractRNG, x, p, ::Val{training}, α, A, B) +``` + +Alpha Dropout: Dropout ensuring that the mean and variance of the output remains same as the input. For details see [1]. Use the second call signature to avoid recomputing the constants for a fixed dropout probability. + +**Arguments** + + * `rng`: Random number generator + * `x`: Input Array + * `p`: Probability of an element to be dropped out + * `Val(training)`: If `true` then dropout is applied on `x` with probability `p`. Else, `x` is returned + * `α`: `-1.7580993408473766`. Computed at limit x tends to infinity, `selu(x) = -λβ = α` + * `A`: Scaling factor for the mean + * `B`: Scaling factor for the variance + +**Returns** + + * Output Array after applying alpha dropout + * Updated state for the random number generator + +**References** + +[1] Klambauer, Günter, et al. "Self-normalizing neural networks." Advances in neural information processing systems 30 (2017). + +
+
+
+# LuxLib.dropout — Function. + + + +```julia +dropout(rng::AbstractRNG, x, p, ::Val{training}, invp; dims) +dropout(rng::AbstractRNG, x, mask, p, ::Val{training}, ::Val{update_mask}, invp; + dims) +``` + +Dropout: Simple Way to prevent Neural Networks for Overfitting. For details see [1]. + +**Arguments** + + * `rng`: Random number generator + * `x`: Input Array + * `mask`: Dropout Mask. If not used then it is constructed automatically + * `p`: Probability of an element to be dropped out + * `Val(training)`: If `true` then dropout is applied on `x` with probability `p` along `dims`. Else, `x` is returned + * `Val(update_mask)`: If `true` then the mask is generated and used. Else, the `mask` provided is directly used + * `invp`: Inverse of the probability + +**Keyword Arguments** + + * `dims`: Dimensions along which dropout is applied + * `invp`: Inverse of the probability ($\frac{1}{p}$) + +**Returns** + + * Output Array after applying dropout + * Dropout Mask (if `training == false`, the returned value is meaningless) + * Updated state for the random number generator + +**References** + +[1] Srivastava, Nitish, et al. "Dropout: a simple way to prevent neural networks from overfitting." The journal of machine learning research 15.1 (2014): 1929-1958. + +
+
+ + + +## Normalization + +
+# LuxLib.batchnorm — Function. + + + +```julia +batchnorm(x, scale, bias, running_mean, running_var; momentum, epsilon, training) +``` + +Batch Normalization. For details see [1]. + +Batch Normalization computes the mean and variance for each $D_1 \times ... \times D_{N - 2} \times 1 \times D_N$ input slice and normalises the input accordingly. + +**Arguments** + + * `x`: Input to be Normalized + * `scale`: Scale factor ($\gamma$) (can be `nothing`) + * `bias`: Bias factor ($\beta$) (can be `nothing`) + * `running_mean`: Running mean (can be `nothing`) + * `running_var`: Running variance (can be `nothing`) + +**Keyword Arguments** + + * `momentum`: Momentum for updating running mean and variance + * `epsilon`: Value added to the denominator for numerical stability + * `training`: Set to `Val(true)` if running in training mode + +**Returns** + +Normalized Array of same size as `x`. And a Named Tuple containing the updated running mean and variance. + +**Performance Considerations** + +If the input array is `2D`, `4D`, or `5D` `CuArray` with element types `Float16`, `Float32` and `Float64`, then the CUDNN code path will be used. In all other cases, a broadcasting fallback is used which is not highly optimized. + +**References** + +[1] Ioffe, Sergey, and Christian Szegedy. "Batch normalization: Accelerating deep network training by reducing internal covariate shift." International conference on machine learning. PMLR, 2015. + +
+
+
+# LuxLib.groupnorm — Function. + + + +```julia +groupnorm(x, scale, bias; groups, epsilon) +``` + +Group Normalization. For details see [1]. + +This op is similar to batch normalization, but statistics are shared across equally-sized groups of channels and not shared across batch dimension. Thus, group normalization does not depend on the batch composition and does not require maintaining internal state for storing statistics. + +**Arguments** + + * `x`: Input to be Normalized + * `scale`: Scale factor ($\gamma$) (can be `nothing`) + * `bias`: Bias factor ($\beta$) (can be `nothing`) + +**Keyword Arguments** + + * `groups`: Number of groups + * `epsilon`: Value added to the denominator for numerical stability + +**Returns** + +The normalized array is returned. + +**Performance Considerations** + +The most common case of this Op – `x` is a 4D array – is optimized using KernelAbstractions and has a fast custom backwards pass implemented. All other cases have a fallback implementation which is not especially optimized. + +We have tested the code path for `Float16` and it works, but gradient accumulation is extremely fragile. Hence, for `Float16` inputs, it uses the fallback implementation. + +If the batch size is small (< 16), then the fallback implementation will be faster than the KA version. However, this customization is not possible using the direct `groupnorm` interface. + +**References** + +[1] Wu, Yuxin, and Kaiming He. "Group normalization." Proceedings of the European conference on computer vision (ECCV). 2018. + +
+
+
+# LuxLib.instancenorm — Function. + + + +```julia +instancenorm(x, scale, bias; epsilon, training) +``` + +Instance Normalization. For details see [1]. + +Instance Normalization computes the mean and variance for each $D_1 \times ... \times D_{N - 2} \times 1 \times 1$ input slice and normalises the input accordingly. + +**Arguments** + + * `x`: Input to be Normalized (must be atleast 3D) + * `scale`: Scale factor ($\gamma$) (can be `nothing`) + * `bias`: Bias factor ($\beta$) (can be `nothing`) + +**Keyword Arguments** + + * `epsilon`: Value added to the denominator for numerical stability + * `training`: Set to `Val(true)` if running in training mode + +**Returns** + +Normalized Array of same size as `x`. And a Named Tuple containing the updated running mean and variance. + +**References** + +[1] Ulyanov, Dmitry, Andrea Vedaldi, and Victor Lempitsky. "Instance normalization: The missing ingredient for fast stylization." arXiv preprint arXiv:1607.08022 (2016). + +
+
+
+# LuxLib.layernorm — Function. + + + +```julia +layernorm(x, scale, bias; dims, epsilon) +``` + +Layer Normalization. For details see [1]. + +Given an input array $x$, this layer computes + +$$ +y = \frac{x - \mathbb{E}[x]}{\sqrt{Var[x] + \epsilon}} * \gamma + \beta +$$ + +**Arguments** + + * `x`: Input to be Normalized + * `scale`: Scale factor ($\gamma$) (can be `nothing`) + * `bias`: Bias factor ($\beta$) (can be `nothing`) + +**Keyword Arguments** + + * `dims`: Dimensions along which the mean and std of `x` is computed + * `epsilon`: Value added to the denominator for numerical stability + +**Returns** + +Normalized Array of same size as `x`. + +**References** + +[1] Ba, Jimmy Lei, Jamie Ryan Kiros, and Geoffrey E. Hinton. "Layer normalization." arXiv preprint arXiv:1607.06450 (2016). + +
+
diff --git a/previews/PR467/api/Building_Blocks/WeightInitializers.md b/previews/PR467/api/Building_Blocks/WeightInitializers.md new file mode 100644 index 0000000000..42877d44d7 --- /dev/null +++ b/previews/PR467/api/Building_Blocks/WeightInitializers.md @@ -0,0 +1,458 @@ + + + + + +# WeightInitializers + + +This package is a light dependency providing common weight initialization schemes for deep learning models. + + + + +## Index + +- [`WeightInitializers.glorot_normal`](#WeightInitializers.glorot_normal) +- [`WeightInitializers.glorot_uniform`](#WeightInitializers.glorot_uniform) +- [`WeightInitializers.kaiming_normal`](#WeightInitializers.kaiming_normal) +- [`WeightInitializers.kaiming_uniform`](#WeightInitializers.kaiming_uniform) +- [`WeightInitializers.ones16`](#WeightInitializers.ones16) +- [`WeightInitializers.ones32`](#WeightInitializers.ones32) +- [`WeightInitializers.ones64`](#WeightInitializers.ones64) +- [`WeightInitializers.onesC16`](#WeightInitializers.onesC16) +- [`WeightInitializers.onesC32`](#WeightInitializers.onesC32) +- [`WeightInitializers.onesC64`](#WeightInitializers.onesC64) +- [`WeightInitializers.rand16`](#WeightInitializers.rand16) +- [`WeightInitializers.rand32`](#WeightInitializers.rand32) +- [`WeightInitializers.rand64`](#WeightInitializers.rand64) +- [`WeightInitializers.randC16`](#WeightInitializers.randC16) +- [`WeightInitializers.randC32`](#WeightInitializers.randC32) +- [`WeightInitializers.randC64`](#WeightInitializers.randC64) +- [`WeightInitializers.randn16`](#WeightInitializers.randn16) +- [`WeightInitializers.randn32`](#WeightInitializers.randn32) +- [`WeightInitializers.randn64`](#WeightInitializers.randn64) +- [`WeightInitializers.randnC16`](#WeightInitializers.randnC16) +- [`WeightInitializers.randnC32`](#WeightInitializers.randnC32) +- [`WeightInitializers.randnC64`](#WeightInitializers.randnC64) +- [`WeightInitializers.truncated_normal`](#WeightInitializers.truncated_normal) +- [`WeightInitializers.zeros16`](#WeightInitializers.zeros16) +- [`WeightInitializers.zeros32`](#WeightInitializers.zeros32) +- [`WeightInitializers.zeros64`](#WeightInitializers.zeros64) +- [`WeightInitializers.zerosC16`](#WeightInitializers.zerosC16) +- [`WeightInitializers.zerosC32`](#WeightInitializers.zerosC32) +- [`WeightInitializers.zerosC64`](#WeightInitializers.zerosC64) + + + + +## API Reference + + + + +### Main Functions + +
+# WeightInitializers.glorot_normal — Function. + + + +```julia +glorot_normal([::AbstractRNG=_default_rng()], [T=Float32], size...; + gain = 1) -> AbstractArray{T, length(size)} +``` + +Return an `AbstractArray{T}` of the given `size` containing random numbers drawn from a normal distribution with standard deviation `gain * sqrt(2 / (fan_in + fan_out))`. This method is described in [1] and also known as Xavier initialization. + +**References** + +[1] Glorot, Xavier, and Yoshua Bengio. "Understanding the difficulty of training deep feedforward neural networks." *Proceedings of the thirteenth international conference on artificial intelligence and statistics*. 2010. + +
+
+
+# WeightInitializers.glorot_uniform — Function. + + + +```julia +glorot_uniform([::AbstractRNG=_default_rng()], [T=Float32], size...; + gain = 1) -> AbstractArray{T, length(size)} +``` + +Return an `AbstractArray{T}` of the given `size` containing random numbers drawn from a uniform distribution on the interval $[-x, x]$, where `x = gain * sqrt(6 / (fan_in + fan_out))`. This method is described in [1] and also known as Xavier initialization. + +**References** + +[1] Glorot, Xavier, and Yoshua Bengio. "Understanding the difficulty of training deep feedforward neural networks." *Proceedings of the thirteenth international conference on artificial intelligence and statistics*. 2010. + +
+
+
+# WeightInitializers.kaiming_normal — Function. + + + +```julia +kaiming_normal([::AbstractRNG=_default_rng()], [T=Float32], size...; + gain = √T(2)) -> AbstractArray{T, length(size)} +``` + +Return an `AbstractArray{T}` of the given `size` containing random numbers taken from a normal distribution standard deviation `gain / sqrt(fan_in)` + +**References** + +[1] He, Kaiming, et al. "Delving deep into rectifiers: Surpassing human-level performance on imagenet classification." *Proceedings of the IEEE international conference on computer vision*. 2015. + +
+
+
+# WeightInitializers.kaiming_uniform — Function. + + + +```julia +kaiming_uniform([::AbstractRNG=_default_rng()], [T=Float32], size...; + gain = √T(2)) -> AbstractArray{T, length(size)} +``` + +Return an `AbstractArray{T}` of the given `size` containing random numbers drawn from a uniform distribution on the interval `[-x, x]`, where `x = gain * sqrt(3/fan_in)`. + +**References** + +[1] He, Kaiming, et al. "Delving deep into rectifiers: Surpassing human-level performance on imagenet classification." *Proceedings of the IEEE international conference on computer vision*. 2015. + +
+
+
+# WeightInitializers.truncated_normal — Function. + + + +```julia +truncated_normal([::AbstractRNG=_default_rng()], [T=Float32], size...; mean = 0, + std = 1, lo = -2, hi = 2) -> AbstractArray{T, length(size)} +``` + +Return an `AbstractArray{T}` of the given `size` where each element is drawn from a truncated normal distribution. The numbers are distributed like `filter(x -> lo ≤ x ≤ hi, mean .+ std .* randn(100))`. + +
+
+ + + +### Commonly Used Wrappers + +
+# WeightInitializers.zeros16 — Function. + + + +```julia +zeros16([::AbstractRNG=_default_rng()], size...; kwargs...) -> AbstractArray{Float16, length(size)} +``` + +Return an `AbstractArray{Float16}` of the given `size` containing an AbstractArray of zeros. + +
+
+
+# WeightInitializers.ones16 — Function. + + + +```julia +ones16([::AbstractRNG=_default_rng()], size...; kwargs...) -> AbstractArray{Float16, length(size)} +``` + +Return an `AbstractArray{Float16}` of the given `size` containing an AbstractArray of ones. + +
+
+
+# WeightInitializers.rand16 — Function. + + + +```julia +rand16([::AbstractRNG=_default_rng()], size...; kwargs...) -> AbstractArray{Float16, length(size)} +``` + +Return an `AbstractArray{Float16}` of the given `size` containing random numbers from a uniform distribution. + +
+
+
+# WeightInitializers.randn16 — Function. + + + +```julia +randn16([::AbstractRNG=_default_rng()], size...; kwargs...) -> AbstractArray{Float16, length(size)} +``` + +Return an `AbstractArray{Float16}` of the given `size` containing random numbers from a standard normal distribution. + +
+
+
+# WeightInitializers.zeros32 — Function. + + + +```julia +zeros32([::AbstractRNG=_default_rng()], size...; kwargs...) -> AbstractArray{Float32, length(size)} +``` + +Return an `AbstractArray{Float32}` of the given `size` containing an AbstractArray of zeros. + +
+
+
+# WeightInitializers.ones32 — Function. + + + +```julia +ones32([::AbstractRNG=_default_rng()], size...; kwargs...) -> AbstractArray{Float32, length(size)} +``` + +Return an `AbstractArray{Float32}` of the given `size` containing an AbstractArray of ones. + +
+
+
+# WeightInitializers.rand32 — Function. + + + +```julia +rand32([::AbstractRNG=_default_rng()], size...; kwargs...) -> AbstractArray{Float32, length(size)} +``` + +Return an `AbstractArray{Float32}` of the given `size` containing random numbers from a uniform distribution. + +
+
+
+# WeightInitializers.randn32 — Function. + + + +```julia +randn32([::AbstractRNG=_default_rng()], size...; kwargs...) -> AbstractArray{Float32, length(size)} +``` + +Return an `AbstractArray{Float32}` of the given `size` containing random numbers from a standard normal distribution. + +
+
+
+# WeightInitializers.zeros64 — Function. + + + +```julia +zeros64([::AbstractRNG=_default_rng()], size...; kwargs...) -> AbstractArray{Float64, length(size)} +``` + +Return an `AbstractArray{Float64}` of the given `size` containing an AbstractArray of zeros. + +
+
+
+# WeightInitializers.ones64 — Function. + + + +```julia +ones64([::AbstractRNG=_default_rng()], size...; kwargs...) -> AbstractArray{Float64, length(size)} +``` + +Return an `AbstractArray{Float64}` of the given `size` containing an AbstractArray of ones. + +
+
+
+# WeightInitializers.rand64 — Function. + + + +```julia +rand64([::AbstractRNG=_default_rng()], size...; kwargs...) -> AbstractArray{Float64, length(size)} +``` + +Return an `AbstractArray{Float64}` of the given `size` containing random numbers from a uniform distribution. + +
+
+
+# WeightInitializers.randn64 — Function. + + + +```julia +randn64([::AbstractRNG=_default_rng()], size...; kwargs...) -> AbstractArray{Float64, length(size)} +``` + +Return an `AbstractArray{Float64}` of the given `size` containing random numbers from a standard normal distribution. + +
+
+
+# WeightInitializers.zerosC16 — Function. + + + +```julia +zerosC16([::AbstractRNG=_default_rng()], size...; kwargs...) -> AbstractArray{ComplexF16, length(size)} +``` + +Return an `AbstractArray{ComplexF16}` of the given `size` containing an AbstractArray of zeros. + +
+
+
+# WeightInitializers.onesC16 — Function. + + + +```julia +onesC16([::AbstractRNG=_default_rng()], size...; kwargs...) -> AbstractArray{ComplexF16, length(size)} +``` + +Return an `AbstractArray{ComplexF16}` of the given `size` containing an AbstractArray of ones. + +
+
+
+# WeightInitializers.randC16 — Function. + + + +```julia +randC16([::AbstractRNG=_default_rng()], size...; kwargs...) -> AbstractArray{ComplexF16, length(size)} +``` + +Return an `AbstractArray{ComplexF16}` of the given `size` containing random numbers from a uniform distribution. + +
+
+
+# WeightInitializers.randnC16 — Function. + + + +```julia +randnC16([::AbstractRNG=_default_rng()], size...; kwargs...) -> AbstractArray{ComplexF16, length(size)} +``` + +Return an `AbstractArray{ComplexF16}` of the given `size` containing random numbers from a standard normal distribution. + +
+
+
+# WeightInitializers.zerosC32 — Function. + + + +```julia +zerosC32([::AbstractRNG=_default_rng()], size...; kwargs...) -> AbstractArray{ComplexF32, length(size)} +``` + +Return an `AbstractArray{ComplexF32}` of the given `size` containing an AbstractArray of zeros. + +
+
+
+# WeightInitializers.onesC32 — Function. + + + +```julia +onesC32([::AbstractRNG=_default_rng()], size...; kwargs...) -> AbstractArray{ComplexF32, length(size)} +``` + +Return an `AbstractArray{ComplexF32}` of the given `size` containing an AbstractArray of ones. + +
+
+
+# WeightInitializers.randC32 — Function. + + + +```julia +randC32([::AbstractRNG=_default_rng()], size...; kwargs...) -> AbstractArray{ComplexF32, length(size)} +``` + +Return an `AbstractArray{ComplexF32}` of the given `size` containing random numbers from a uniform distribution. + +
+
+
+# WeightInitializers.randnC32 — Function. + + + +```julia +randnC32([::AbstractRNG=_default_rng()], size...; kwargs...) -> AbstractArray{ComplexF32, length(size)} +``` + +Return an `AbstractArray{ComplexF32}` of the given `size` containing random numbers from a standard normal distribution. + +
+
+
+# WeightInitializers.zerosC64 — Function. + + + +```julia +zerosC64([::AbstractRNG=_default_rng()], size...; kwargs...) -> AbstractArray{ComplexF64, length(size)} +``` + +Return an `AbstractArray{ComplexF64}` of the given `size` containing an AbstractArray of zeros. + +
+
+
+# WeightInitializers.onesC64 — Function. + + + +```julia +onesC64([::AbstractRNG=_default_rng()], size...; kwargs...) -> AbstractArray{ComplexF64, length(size)} +``` + +Return an `AbstractArray{ComplexF64}` of the given `size` containing an AbstractArray of ones. + +
+
+
+# WeightInitializers.randC64 — Function. + + + +```julia +randC64([::AbstractRNG=_default_rng()], size...; kwargs...) -> AbstractArray{ComplexF64, length(size)} +``` + +Return an `AbstractArray{ComplexF64}` of the given `size` containing random numbers from a uniform distribution. + +
+
+
+# WeightInitializers.randnC64 — Function. + + + +```julia +randnC64([::AbstractRNG=_default_rng()], size...; kwargs...) -> AbstractArray{ComplexF64, length(size)} +``` + +Return an `AbstractArray{ComplexF64}` of the given `size` containing random numbers from a standard normal distribution. + +
+
diff --git a/previews/PR467/api/Domain_Specific_Modeling/Boltz.md b/previews/PR467/api/Domain_Specific_Modeling/Boltz.md new file mode 100644 index 0000000000..42971990f8 --- /dev/null +++ b/previews/PR467/api/Domain_Specific_Modeling/Boltz.md @@ -0,0 +1,300 @@ + + + + + +# Boltz + + +Accelerate ⚡ your ML research using pre-built Deep Learning Models with Lux. + + + + +## Index + +- [`Boltz.ClassTokens`](#Boltz.ClassTokens) +- [`Boltz.MultiHeadAttention`](#Boltz.MultiHeadAttention) +- [`Boltz.ViPosEmbedding`](#Boltz.ViPosEmbedding) +- [`Boltz._fast_chunk`](#Boltz._fast_chunk) +- [`Boltz._flatten_spatial`](#Boltz._flatten_spatial) +- [`Boltz._seconddimmean`](#Boltz._seconddimmean) +- [`Boltz._vgg_block`](#Boltz._vgg_block) +- [`Boltz._vgg_classifier_layers`](#Boltz._vgg_classifier_layers) +- [`Boltz._vgg_convolutional_layers`](#Boltz._vgg_convolutional_layers) +- [`Boltz.transformer_encoder`](#Boltz.transformer_encoder) +- [`Boltz.vgg`](#Boltz.vgg) + + + + +# Computer Vision Models + + + + +## Classification Models: Native Lux Models + + +| MODEL NAME | FUNCTION | NAME | PRETRAINED | TOP 1 ACCURACY (%) | TOP 5 ACCURACY (%) | +| ------------------:| --------------------:| -----------:|:----------:|:------------------:|:------------------:| +| VGG | `vgg` | `:vgg11` | ✅ | 67.35 | 87.91 | +| VGG | `vgg` | `:vgg13` | ✅ | 68.40 | 88.48 | +| VGG | `vgg` | `:vgg16` | ✅ | 70.24 | 89.80 | +| VGG | `vgg` | `:vgg19` | ✅ | 71.09 | 90.27 | +| VGG | `vgg` | `:vgg11_bn` | ✅ | 69.09 | 88.94 | +| VGG | `vgg` | `:vgg13_bn` | ✅ | 69.66 | 89.49 | +| VGG | `vgg` | `:vgg16_bn` | ✅ | 72.11 | 91.02 | +| VGG | `vgg` | `:vgg19_bn` | ✅ | 72.95 | 91.32 | +| Vision Transformer | `vision_transformer` | `:tiny` | 🚫 | | | +| Vision Transformer | `vision_transformer` | `:small` | 🚫 | | | +| Vision Transformer | `vision_transformer` | `:base` | 🚫 | | | +| Vision Transformer | `vision_transformer` | `:large` | 🚫 | | | +| Vision Transformer | `vision_transformer` | `:huge` | 🚫 | | | +| Vision Transformer | `vision_transformer` | `:giant` | 🚫 | | | +| Vision Transformer | `vision_transformer` | `:gigantic` | 🚫 | | | + + + + +## Building Blocks + +
+# Boltz.ClassTokens — Type. + + + +```julia +ClassTokens(dim; init=Lux.zeros32) +``` + +Appends class tokens to an input with embedding dimension `dim` for use in many vision transformer namels. + +
+
+
+# Boltz.MultiHeadAttention — Type. + + + +```julia +MultiHeadAttention(in_planes::Int, number_heads::Int; qkv_bias::Bool=false, + attention_dropout_rate::T=0.0f0, + projection_dropout_rate::T=0.0f0) where {T} +``` + +Multi-head self-attention layer + +
+
+
+# Boltz.ViPosEmbedding — Type. + + + +```julia +ViPosEmbedding(embedsize, npatches; + init = (rng, dims...) -> randn(rng, Float32, dims...)) +``` + +Positional embedding layer used by many vision transformer-like namels. + +
+
+
+# Boltz.transformer_encoder — Function. + + + +```julia +transformer_encoder(in_planes, depth, number_heads; mlp_ratio = 4.0f0, dropout = 0.0f0) +``` + +Transformer as used in the base ViT architecture. ([reference](https://arxiv.org/abs/2010.11929)). + +**Arguments** + + * `in_planes`: number of input channels + * `depth`: number of attention blocks + * `number_heads`: number of attention heads + * `mlp_ratio`: ratio of MLP layers to the number of input channels + * `dropout_rate`: dropout rate + +
+
+
+# Boltz.vgg — Function. + + + +```julia +vgg(imsize; config, inchannels, batchnorm = false, nclasses, fcsize, dropout) +``` + +Create a VGG model ([reference](https://arxiv.org/abs/1409.1556v6)). + +**Arguments** + + * `imsize`: input image width and height as a tuple + * `config`: the configuration for the convolution layers + * `inchannels`: number of input channels + * `batchnorm`: set to `true` to use batch normalization after each convolution + * `nclasses`: number of output classes + * `fcsize`: intermediate fully connected layer size (see `Metalhead._vgg_classifier_layers`) + * `dropout`: dropout level between fully connected layers + +
+
+ + + +### Non-Public API + +
+# Boltz._seconddimmean — Function. + + + +```julia +_seconddimmean(x) +``` + +Computes the mean of `x` along dimension `2` + +
+
+
+# Boltz._fast_chunk — Function. + + + +```julia +_fast_chunk(x::AbstractArray, ::Val{n}, ::Val{dim}) +``` + +Type-stable and faster version of `MLUtils.chunk` + +
+
+
+# Boltz._flatten_spatial — Function. + + + +```julia +_flatten_spatial(x::AbstractArray{T, 4}) +``` + +Flattens the first 2 dimensions of `x`, and permutes the remaining dimensions to (2, 1, 3) + +
+
+
+# Boltz._vgg_block — Function. + + + +```julia +_vgg_block(input_filters, output_filters, depth, batchnorm) +``` + +A VGG block of convolution layers ([reference](https://arxiv.org/abs/1409.1556v6)). + +**Arguments** + + * `input_filters`: number of input feature maps + * `output_filters`: number of output feature maps + * `depth`: number of convolution/convolution + batch norm layers + * `batchnorm`: set to `true` to include batch normalization after each convolution + +
+
+
+# Boltz._vgg_classifier_layers — Function. + + + +```julia +_vgg_classifier_layers(imsize, nclasses, fcsize, dropout) +``` + +Create VGG classifier (fully connected) layers ([reference](https://arxiv.org/abs/1409.1556v6)). + +**Arguments** + + * `imsize`: tuple `(width, height, channels)` indicating the size after the convolution layers (see `Metalhead._vgg_convolutional_layers`) + * `nclasses`: number of output classes + * `fcsize`: input and output size of the intermediate fully connected layer + * `dropout`: the dropout level between each fully connected layer + +
+
+
+# Boltz._vgg_convolutional_layers — Function. + + + +```julia +_vgg_convolutional_layers(config, batchnorm, inchannels) +``` + +Create VGG convolution layers ([reference](https://arxiv.org/abs/1409.1556v6)). + +**Arguments** + + * `config`: vector of tuples `(output_channels, num_convolutions)` for each block (see `Metalhead._vgg_block`) + * `batchnorm`: set to `true` to include batch normalization after each convolution + * `inchannels`: number of input channels + +
+
+ + + +## Classification Models: Imported from Metalhead.jl + + +:::tip + + +You need to load `Flux` and `Metalhead` before using these models. + + +::: + + +| MODEL NAME | FUNCTION | NAME | PRETRAINED | TOP 1 ACCURACY (%) | TOP 5 ACCURACY (%) | +| ----------:| -----------:| ---------------------:|:----------:|:------------------:|:------------------:| +| AlexNet | `alexnet` | `:alexnet` | ✅ | 54.48 | 77.72 | +| ResNet | `resnet` | `:resnet18` | 🚫 | 68.08 | 88.44 | +| ResNet | `resnet` | `:resnet34` | 🚫 | 72.13 | 90.91 | +| ResNet | `resnet` | `:resnet50` | 🚫 | 74.55 | 92.36 | +| ResNet | `resnet` | `:resnet101` | 🚫 | 74.81 | 92.36 | +| ResNet | `resnet` | `:resnet152` | 🚫 | 77.63 | 93.84 | +| ConvMixer | `convmixer` | `:small` | 🚫 | | | +| ConvMixer | `convmixer` | `:base` | 🚫 | | | +| ConvMixer | `convmixer` | `:large` | 🚫 | | | +| DenseNet | `densenet` | `:densenet121` | 🚫 | | | +| DenseNet | `densenet` | `:densenet161` | 🚫 | | | +| DenseNet | `densenet` | `:densenet169` | 🚫 | | | +| DenseNet | `densenet` | `:densenet201` | 🚫 | | | +| GoogleNet | `googlenet` | `:googlenet` | 🚫 | | | +| MobileNet | `mobilenet` | `:mobilenet_v1` | 🚫 | | | +| MobileNet | `mobilenet` | `:mobilenet_v2` | 🚫 | | | +| MobileNet | `mobilenet` | `:mobilenet_v3_small` | 🚫 | | | +| MobileNet | `mobilenet` | `:mobilenet_v3_large` | 🚫 | | | +| ResNeXT | `resnext` | `:resnext50` | 🚫 | | | +| ResNeXT | `resnext` | `:resnext101` | 🚫 | | | +| ResNeXT | `resnext` | `:resnext152` | 🚫 | | | + + +These models can be created using `(; pretrained = )` + + + + +### Preprocessing + + +All the pretrained models require that the images be normalized with the parameters `mean = [0.485f0, 0.456f0, 0.406f0]` and `std = [0.229f0, 0.224f0, 0.225f0]`. + diff --git a/previews/PR467/api/Lux/contrib.md b/previews/PR467/api/Lux/contrib.md new file mode 100644 index 0000000000..2ee979a6bb --- /dev/null +++ b/previews/PR467/api/Lux/contrib.md @@ -0,0 +1,667 @@ + + + +# Experimental Features + + + + +All features listed on this page are **experimental** which means: + + +1. No SemVer Guarantees. We use code here to iterate fast and most users should wait for these features to be marked non-experimental. +2. The code will probably be moved into a separate repository in the future. +3. Expect edge-cases and report them. It will help us move these features out of experimental sooner. +4. None of the features are exported. + + +:::warning + + +Starting v"0.5.2" all Experimental features need to be accessed via `Lux.Experimental.`. Direct access via `Lux.` will be removed in v"0.6". + + +::: + + + + +## Index + +- [`Lux.Experimental.DebugLayer`](#Lux.Experimental.DebugLayer) +- [`Lux.Experimental.FrozenLayer`](#Lux.Experimental.FrozenLayer) +- [`Lux.Experimental.StatefulLuxLayer`](#Lux.Experimental.StatefulLuxLayer) +- [`Lux.Experimental.TrainState`](#Lux.Experimental.TrainState) +- [`Lux.Experimental.apply_gradients`](#Lux.Experimental.apply_gradients) +- [`Lux.Experimental.compute_gradients`](#Lux.Experimental.compute_gradients) +- [`Lux.Experimental.freeze`](#Lux.Experimental.freeze) +- [`Lux.Experimental.layer_map`](#Lux.Experimental.layer_map) +- [`Lux.Experimental.share_parameters`](#Lux.Experimental.share_parameters) +- [`Lux.Experimental.unfreeze`](#Lux.Experimental.unfreeze) +- [`Lux.Experimental.@compact`](#Lux.Experimental.@compact) +- [`Lux.Experimental.@debug_mode`](#Lux.Experimental.@debug_mode) +- [`Lux.Experimental.@layer_map`](#Lux.Experimental.@layer_map) + + + + +## Training + + +Helper Functions making it easier to train `Lux.jl` models. + + +Lux.Training is meant to be simple and provide extremely basic functionality. We provide basic building blocks which can be seamlessly composed to create complex training pipelines. + +
+# Lux.Experimental.TrainState — Type. + + + +```julia +TrainState +``` + +Training State containing: + + * `model`: `Lux` model. + * `parameters`: Trainable Variables of the `model`. + * `states`: Non-trainable Variables of the `model`. + * `optimizer_state`: Optimizer State. + * `step`: Number of updates of the parameters made. + + +source
+ +
+
+
+# Lux.Experimental.compute_gradients — Function. + + + +```julia +compute_gradients(ad::ADTypes.AbstractADType, objective_function::Function, data, + ts::TrainState) +``` + +Compute the gradients of the objective function wrt parameters stored in `ts`. + +**Arguments** + + * `ad`: Backend (from [ADTypes.jl](https://github.com/SciML/ADTypes.jl)) used to compute the gradients. + * `objective_function`: Objective function. The function must take 4 inputs – model, parameters, states and data. The function must return 3 values – loss, updated_state, and any computed statistics. + * `data`: Data used to compute the gradients. + * `ts`: Current Training State. See [`TrainState`](contrib#Lux.Experimental.TrainState). + +**Return** + +A 4-Tuple containing: + + * `grads`: Computed Gradients. + * `loss`: Loss from the objective function. + * `stats`: Any computed statistics from the objective function. + * `ts`: Updated Training State. + + +source
+ +
+
+
+# Lux.Experimental.apply_gradients — Function. + + + +```julia +apply_gradients(ts::TrainState, grads) +``` + +Update the parameters stored in `ts` using the gradients `grads`. + +**Arguments** + + * `ts`: `TrainState` object. + * `grads`: Gradients of the loss function wrt `ts.params`. + +**Returns** + +Updated `TrainState` object. + + +source
+ +
+
+ + + +## Parameter Freezing + + +:::info + + +In the long term, this will be supported via [Optimisers.jl](https://github.com/FluxML/Optimisers.jl/pull/49). + + +::: + +
+# Lux.Experimental.FrozenLayer — Type. + + + +```julia +FrozenLayer(l::AbstractExplicitLayer, which_params::Union{Tuple, Nothing}) +``` + +Freeze the parameters with name `which_params` of the layer `l`. + +:::tip + +It is always recommended to use the [`Lux.Experimental.freeze`](contrib#Lux.Experimental.freeze) function instead of directly using the `FrozenLayer` constructor. + +::: + +:::warning + +There are no checks for `which_params`. For example, if the original layer has parameters named `(:weight, :bias)`, and `which_params`is set to`(:myweight,)` then none of the parameters are frozen and no error is thrown. + +::: + +**Arguments** + + * `l`: Lux AbstractExplicitLayer. + * `which_params`: Parameter Names to be Frozen. Can be set to `nothing`, in which case all parameters are frozen. + +**Input** + + * `x`: Input to the layer `l`. + +**Returns** + + * Output of the inner layer `l` + * Updated State + +**Parameters** + + * Parameters of the layer `l` excluding `which_params`. + +**States** + + * `frozen_params`: Parameters that are frozen, i.e., `which_params`. + * `states`: The state of the inner layer `l`. + +**Note on Internal Layer Implementation** + +The inner layer should work with `NamedTuple` parameters. In order to support custom parameter types, users need to implement `Lux._merge(::CustomParamType, ::NamedTuple)`. + +**Example** + +```julia +m = Lux.Experimental.FrozenLayer(Dense(2 => 2), (:weight,)) +``` + +See also [`Lux.Experimental.freeze`](contrib#Lux.Experimental.freeze), [`Lux.Experimental.unfreeze`](contrib#Lux.Experimental.unfreeze). + + +source
+ +
+
+
+# Lux.Experimental.freeze — Function. + + + +```julia +freeze(l::AbstractExplicitLayer, which_params::Union{Tuple, Nothing} = nothing) +``` + +Constructs a version of `l` with `which_params` frozen. If `which_params` is nothing, then all parameters are frozen. + + +source
+ + +``` +freeze(l::AbstractExplicitLayer, ps, st::NamedTuple, + which_params::Union{Tuple, Nothing} = nothing) +``` + +Construct a [`Lux.Experimental.FrozenLayer`](contrib#Lux.Experimental.FrozenLayer) for `l` with the current parameters and states. If `which_params` is nothing, then all parameters are frozen. + + +source
+ +
+
+
+# Lux.Experimental.unfreeze — Function. + + + +```julia +unfreeze(l::FrozenLayer) +``` + +Unfreezes the layer `l`. + + +source
+ + +``` +unfreeze(l::FrozenLayer, ps, st::NamedTuple) +``` + +Unwraps a [`Lux.Experimental.FrozenLayer`](contrib#Lux.Experimental.FrozenLayer) `l` with the current parameters and states. + + +source
+ +
+
+ +For detailed usage example look at the [manual page](../../manual/freezing_model_parameters). + + + + +## Map over Layer + +
+# Lux.Experimental.layer_map — Function. + + + +```julia +layer_map(f::Function, l::AbstractExplicitLayer, ps, st::NamedTuple, + name::String="model") +``` + +Map the function `f` over the model `l`, with the parameters `ps` and states `st`. This is different from `Functors.fmap` since it zips the layers, parameters, and states and invokes the function on all of them together. + +**Call Signature for `f`** + + * Must take 4 inputs – `AbstractExplicitLayer`, Corresponding Parameters, Corresponding States, and the name of the layer. + * Must return a tuple of 3 elements – `AbstractExplicitLayer`, new parameters and the new states. + +:::tip + +We recommend using the macro `Lux.@layer_map` instead of this function. It automatically sets the `name` of the layer to be the variable name. + +::: + +**Example** + +```julia +using Lux, Random, Setfield + +c = Parallel(+; chain=Chain(; dense_1=Dense(2 => 3), bn=BatchNorm(3), + dense_2=Dense(3 => 5)), + dense_3=Dense(5 => 1)) + +rng = Random.default_rng() +ps, st = Lux.setup(rng, c) + +# Makes parameters of Dense Layers inside Chain zero +function zero_dense_params(l, ps, st, name) + if l isa Dense + println("zeroing params of $name") + @set! ps.weight = zero.(ps.weight) + @set! ps.bias = zero.(ps.bias) + end + return l, ps, st +end + +Lux.layer_map(zero_dense_params, c, ps, st) +``` + + +source
+ +
+
+
+# Lux.Experimental.@layer_map — Macro. + + + +```julia +@layer_map func layer ps st +``` + +See the documentation of [`Lux.Experimental.layer_map`](contrib#Lux.Experimental.layer_map) for more details. This macro eliminates the need to the set the layer name, and uses the variable name as the starting point. + +**Example** + +```julia +using Lux, Random, Setfield + +c = Parallel(+; chain=Chain(; dense_1=Dense(2 => 3), bn=BatchNorm(3), + dense_2=Dense(3 => 5)), + dense_3=Dense(5 => 1)) + +rng = Random.default_rng() +ps, st = Lux.setup(rng, c) + +# Makes parameters of Dense Layers inside Chain zero +function zero_dense_params(l, ps, st, name) + if l isa Dense + println("zeroing params of $name") + @set! ps.weight = zero.(ps.weight) + @set! ps.bias = zero.(ps.bias) + end + return l, ps, st +end + +Lux.@layer_map zero_dense_params c ps st +``` + + +source
+ +
+
+ + + +## Debugging Functionality + + +Model not working properly! Here are some functionalities to help you debug you Lux model. + +
+# Lux.Experimental.@debug_mode — Macro. + + + +```julia +@debug_mode layer kwargs... +``` + +Recurses into the `layer` and replaces the inner most non Container Layers with a [`Lux.Experimental.DebugLayer`](contrib#Lux.Experimental.DebugLayer). + +See [`Lux.Experimental.DebugLayer`](contrib#Lux.Experimental.DebugLayer) for details about the Keyword Arguments. + + +source
+ +
+
+
+# Lux.Experimental.DebugLayer — Type. + + + +```julia +DebugLayer(layer::AbstractExplicitLayer; nan_check::Symbol=:both, + error_check::Bool=true, location::String="") +``` + +::: danger + +This layer is only meant to be used for debugging. If used for actual training or inference, will lead to extremely bad performance. + +::: + +A wrapper over Lux layers that adds checks for NaNs and errors. This is useful for debugging. + +**Arguments** + + * `layer`: The layer to be wrapped. + +**Keyword Arguments** + + * `nan_check`: Whether to check for NaNs in the input, parameters, and states. Can be `:both`, `:forward`, `:backward`, or `:none`. + * `error_check`: Whether to check for errors in the layer. If `true`, will throw an error if the layer fails. + * `location`: The location of the layer. Use [`Lux.Experimental.@debug_mode`](contrib#Lux.Experimental.@debug_mode) to construct this layer to populate this value correctly. + +**Inputs** + + * `x`: The input to the layer. + +**Outputs** + + * `y`: The output of the layer. + * `st`: The updated states of the layer. + +If `nan_check` is enabled and NaNs are detected then a `DomainError` is thrown. If `error_check` is enabled, then any errors in the layer are thrown with useful information to track where the error originates. + +::: warning + +`nan_check` for the backward mode only works with ChainRules Compatible Reverse Mode AD Tools currently. + +::: + +See [`Lux.Experimental.@debug_mode`](contrib#Lux.Experimental.@debug_mode) to construct this layer. + + +source
+ +
+
+ + + +## Tied Parameters + +
+# Lux.Experimental.share_parameters — Function. + + + +```julia +share_parameters(ps, sharing) +share_parameters(ps, sharing, new_parameters) +``` + +Updates the parameters in `ps` with a common set of parameters `new_parameters` that are shared between each list in the nested list `sharing`. (That was kind of a mouthful, the example should make it clear). + +**Arguments** + + * `ps`: Original parameters. + * `sharing`: A nested list of lists of accessors of `ps` which need to shate the parameters (See the example for details). (Each list in the list must be disjoint) + * `new_parameters`: If passed the length of `new_parameters` must be equal to the length of `sharing`. For each vector in `sharing` the corresponding parameter in `new_parameters` will be used. (If not passed, the parameters corresponding to the first element of each vector in `sharing` will be used). + +**Returns** + +Updated Parameters having the same structure as `ps`. + +**Example** + +```julia +model = Chain(; + d1=Dense(2 => 4, tanh), + d3=Chain(; l1=Dense(4 => 2), l2=Dense(2 => 4)), + d2=Dense(4 => 2)) + +ps, st = Lux.setup(Xoshiro(0), model) + +# share parameters of (d1 and d3.l1) and (d3.l2 and d2) +ps = Lux.share_parameters(ps, (("d3.l2", "d1"), ("d2", "d3.l1"))) +``` + + +source
+ +
+
+ + + +## Stateful Layer + +
+# Lux.Experimental.StatefulLuxLayer — Type. + + + +```julia +StatefulLuxLayer(model, ps, st) +``` + +::: warning + +This is not a Lux.AbstractExplicitLayer + +::: + +A convenience wrapper over Lux layers which stores the parameters and states internally. Most users should not be using this version. This comes handy when Lux internally uses the `@compact` to construct models and in SciML codebases where propagating state might involving [`Box`ing](https://github.com/JuliaLang/julia/issues/15276). + +For a motivating example, see the Neural ODE tutorial. + +::: warning + +State is mutated in place. An additional caveat is that the updated state from `model` must have the same type as `st`. + +::: + +**Arguments** + + * `model`: A Lux layer + * `ps`: The parameters of the layer. This can be set to `nothing`, if the user provides the parameters on function call + * `st`: The state of the layer + +**Inputs** + + * `x`: The input to the layer + * `ps`: The parameters of the layer. Optional, defaults to `s.ps` + +**Outputs** + + * `y`: The output of the layer + + +source
+ +
+
+ + + +## Compact Layer API + +
+# Lux.Experimental.@compact — Macro. + + + +```julia +@compact(kw...) do x + ... +end +@compact(forward::Function; name=nothing, dispatch=nothing, parameters...) +``` + +Creates a layer by specifying some `parameters`, in the form of keywords, and (usually as a `do` block) a function for the forward pass. You may think of `@compact` as a specialized `let` block creating local variables that are trainable in Lux. Declared variable names may be used within the body of the `forward` function. Note that unlike typical Lux models, the forward function doesn't need to explicitly manage states. + +**Reserved Kwargs:** + +1. `name`: The name of the layer. +2. `dispatch`: The constructed layer has the type `Lux.Experimental.CompactLuxLayer{dispatch}` which can be used for custom dispatches. Based on how Julia Types work, this must be a `isbits` type. + +**Examples** + +Here is a linear model: + +```julia +using Lux, Random +import Lux.Experimental: @compact + +r = @compact(w=rand(3)) do x + return w .* x +end +ps, st = Lux.setup(Xoshiro(0), r) +r([1, 1, 1], ps, st) # x is set to [1, 1, 1]. +``` + +Here is a linear model with bias and activation: + +```julia +d_in = 5 +d_out = 7 +d = @compact(W=randn(d_out, d_in), b=zeros(d_out), act=relu) do x + y = W * x + return act.(y .+ b) +end +ps, st = Lux.setup(Xoshiro(0), d) +d(ones(5, 10), ps, st) # 7×10 Matrix as output. + +ps_dense = (; weight=ps.W, bias=ps.b) +first(d([1, 2, 3, 4, 5], ps, st)) ≈ +first(Dense(d_in => d_out, relu)([1, 2, 3, 4, 5], ps_dense, NamedTuple())) # Equivalent to a dense layer +``` + +Finally, here is a simple MLP: + +```julia +n_in = 1 +n_out = 1 +nlayers = 3 + +model = @compact(w1=Dense(n_in, 128), + w2=[Dense(128, 128) for i in 1:nlayers], + w3=Dense(128, n_out), + act=relu) do x + embed = act(w1(x)) + for w in w2 + embed = act(w(embed)) + end + out = w3(embed) + return out +end + +ps, st = Lux.setup(Xoshiro(0), model) + +model(randn(n_in, 32), ps, st) # 1×32 Matrix as output. +``` + +We can train this model just like any Lux model: + +```julia +using Optimisers, Zygote + +x_data = collect(-2.0f0:0.1f0:2.0f0)' +y_data = 2 .* x_data .- x_data .^ 3 +optim = Optimisers.setup(Adam(), ps) + +for epoch in 1:1000 + loss, gs = Zygote.withgradient(ps -> sum(abs2, first(model(x_data, ps, st)) .- y_data), + ps) + @show epoch, loss + Optimisers.update!(optim, ps, gs[1]) +end +``` + +You may also specify a `name` for the model, which will be used instead of the default printout, which gives a verbatim representation of the code used to construct the model: + +```julia +model = @compact(w=rand(3), name="Linear(3 => 1)") do x + return sum(w .* x) +end + +println(model) # "Linear(3 => 1)()" +``` + +This can be useful when using `@compact` to hierarchically construct complex models to be used inside a `Chain`. + +:::tip Type Stability + +If your input function `f` is type-stable but the generated model is not type stable, it should be treated as a bug. We will appreciate issues if you find such cases. + +::: + +:::warning Parameter Count + +Array Parameter don't print the number of parameters on the side. However, they do account for the total number of parameters printed at the bottom. + +::: + + +source
+ +
+
diff --git a/previews/PR467/api/Lux/flux_to_lux.md b/previews/PR467/api/Lux/flux_to_lux.md new file mode 100644 index 0000000000..a5efb3f92a --- /dev/null +++ b/previews/PR467/api/Lux/flux_to_lux.md @@ -0,0 +1,111 @@ + + + +# Flux Models to Lux Models + + + + +Accessing these functions require manually loading `Flux`, i.e., `using Flux` must be present somewhere in the code for these to be used. + + + + +## Index + +- [`Lux.FluxLayer`](#Lux.FluxLayer) +- [`Lux.transform`](#Lux.transform) + + + + +## Functions + +
+# Lux.transform — Function. + + + +```julia +transform(l; preserve_ps_st::Bool=false, force_preserve::Bool=false) +``` + +Convert a Flux Model to Lux Model. + +:::warning + +`transform` always ingores the `active` field of some of the Flux layers. This is almost never going to be supported. + +::: + +**Arguments** + + * `l`: Flux l or any generic Julia function / object. + +**Keyword Arguments** + + * `preserve_ps_st`: Set to `true` to preserve the states and parameters of the l. This attempts the best possible way to preserve the original model. But it might fail. If you need to override possible failures, set `force_preserve` to `true`. + * `force_preserve`: Some of the transformations with state and parameters preservation haven't been implemented yet, in these cases, if `force_transform` is `false` a warning will be printed and a core Lux layer will be returned. Else, it will create a [`FluxLayer`](flux_to_lux#Lux.FluxLayer). + +**Examples** + +```julia +import Flux +using Lux, Metalhead, Random + +m = ResNet(18) +m2 = transform(m.layers) + +x = randn(Float32, 224, 224, 3, 1); + +ps, st = Lux.setup(Random.default_rng(), m2); + +m2(x, ps, st) +``` + + +source
+ +
+
+ + + +## Layers + +
+# Lux.FluxLayer — Type. + + + +```julia +FluxLayer(layer) +``` + +Serves as a compatibility layer between Flux and Lux. This uses `Optimisers.destructure` API internally. + +:::warning + +Lux was written to overcome the limitations of `destructure` + `Flux`. It is recommended to rewrite your l in Lux instead of using this layer. + +::: + +:::warning + +Introducing this Layer in your model will lead to type instabilities, given the way `Optimisers.destructure` works. + +::: + +**Arguments** + + * `layer`: Flux layer + +**Parameters** + + * `p`: Flattened parameters of the `layer` + + +source
+ +
+
diff --git a/previews/PR467/api/Lux/layers.md b/previews/PR467/api/Lux/layers.md new file mode 100644 index 0000000000..f734db2ca6 --- /dev/null +++ b/previews/PR467/api/Lux/layers.md @@ -0,0 +1,2053 @@ + + + +# Built-In Layers + + + + + + +## Index + +- [`Lux.AdaptiveMaxPool`](#Lux.AdaptiveMaxPool) +- [`Lux.AdaptiveMeanPool`](#Lux.AdaptiveMeanPool) +- [`Lux.AlphaDropout`](#Lux.AlphaDropout) +- [`Lux.BatchNorm`](#Lux.BatchNorm) +- [`Lux.Bilinear`](#Lux.Bilinear) +- [`Lux.BranchLayer`](#Lux.BranchLayer) +- [`Lux.Chain`](#Lux.Chain) +- [`Lux.Conv`](#Lux.Conv) +- [`Lux.ConvTranspose`](#Lux.ConvTranspose) +- [`Lux.CrossCor`](#Lux.CrossCor) +- [`Lux.Dense`](#Lux.Dense) +- [`Lux.Dropout`](#Lux.Dropout) +- [`Lux.Embedding`](#Lux.Embedding) +- [`Lux.FlattenLayer`](#Lux.FlattenLayer) +- [`Lux.GRUCell`](#Lux.GRUCell) +- [`Lux.GlobalMaxPool`](#Lux.GlobalMaxPool) +- [`Lux.GlobalMeanPool`](#Lux.GlobalMeanPool) +- [`Lux.GroupNorm`](#Lux.GroupNorm) +- [`Lux.InstanceNorm`](#Lux.InstanceNorm) +- [`Lux.LSTMCell`](#Lux.LSTMCell) +- [`Lux.LayerNorm`](#Lux.LayerNorm) +- [`Lux.MaxPool`](#Lux.MaxPool) +- [`Lux.Maxout`](#Lux.Maxout) +- [`Lux.MeanPool`](#Lux.MeanPool) +- [`Lux.NoOpLayer`](#Lux.NoOpLayer) +- [`Lux.PairwiseFusion`](#Lux.PairwiseFusion) +- [`Lux.Parallel`](#Lux.Parallel) +- [`Lux.RNNCell`](#Lux.RNNCell) +- [`Lux.Recurrence`](#Lux.Recurrence) +- [`Lux.RepeatedLayer`](#Lux.RepeatedLayer) +- [`Lux.ReshapeLayer`](#Lux.ReshapeLayer) +- [`Lux.Scale`](#Lux.Scale) +- [`Lux.SelectDim`](#Lux.SelectDim) +- [`Lux.SkipConnection`](#Lux.SkipConnection) +- [`Lux.StatefulRecurrentCell`](#Lux.StatefulRecurrentCell) +- [`Lux.Upsample`](#Lux.Upsample) +- [`Lux.VariationalHiddenDropout`](#Lux.VariationalHiddenDropout) +- [`Lux.WeightNorm`](#Lux.WeightNorm) +- [`Lux.WrappedFunction`](#Lux.WrappedFunction) +- [`Lux.PixelShuffle`](#Lux.PixelShuffle) + + + + +## Containers + +
+# Lux.BranchLayer — Type. + + + +```julia +BranchLayer(layers...) +BranchLayer(; name=nothing, layers...) +``` + +Takes an input `x` and passes it through all the `layers` and returns a tuple of the outputs. + +**Arguments** + + * Layers can be specified in two formats: + + * A list of `N` Lux layers + * Specified as `N` keyword arguments. + +**Keyword Arguments** + + * `name`: Name of the layer (optional) + +**Inputs** + + * `x`: Will be directly passed to each of the `layers` + +**Returns** + + * Tuple: `(layer_1(x), layer_2(x), ..., layer_N(x))` (naming changes if using the kwargs API) + * Updated state of the `layers` + +**Parameters** + + * Parameters of each `layer` wrapped in a NamedTuple with `fields = layer_1, layer_2, ..., layer_N` (naming changes if using the kwargs API) + +**States** + + * States of each `layer` wrapped in a NamedTuple with `fields = layer_1, layer_2, ..., layer_N` (naming changes if using the kwargs API) + +:::tip Comparison with Parallel + +This is slightly different from [`Parallel(nothing, layers...)`](layers#Lux.Parallel) + + * If the input is a tuple, `Parallel` will pass each element individually to each layer. + * `BranchLayer` essentially assumes 1 input comes in and is branched out into `N` outputs. + +::: + +**Example** + +An easy way to replicate an input to an NTuple is to do + +```julia +l = BranchLayer(NoOpLayer(), NoOpLayer(), NoOpLayer()) +``` + + +source
+ +
+
+
+# Lux.Chain — Type. + + + +```julia +Chain(layers...; name=nothing, disable_optimizations::Bool = false) +Chain(; layers..., name=nothing, disable_optimizations::Bool = false) +``` + +Collects multiple layers / functions to be called in sequence on a given input. + +**Arguments** + + * Layers can be specified in two formats: + + * A list of `N` Lux layers + * Specified as `N` keyword arguments. + +**Keyword Arguments** + + * `disable_optimizations`: Prevents any structural optimization + * `name`: Name of the layer (optional) + +**Inputs** + +Input `x` is passed sequentially to each layer, and must conform to the input requirements of the internal layers. + +**Returns** + + * Output after sequentially applying all the layers to `x` + * Updated model states + +**Parameters** + + * Parameters of each `layer` wrapped in a NamedTuple with `fields = layer_1, layer_2, ..., layer_N` (naming changes if using the kwargs API) + +**States** + + * States of each `layer` wrapped in a NamedTuple with `fields = layer_1, layer_2, ..., layer_N` (naming changes if using the kwargs API) + +**Optimizations** + +Performs a few optimizations to generate reasonable architectures. Can be disabled using keyword argument `disable_optimizations`. + + * All sublayers are recursively optimized. + * If a function `f` is passed as a layer and it doesn't take 3 inputs, it is converted to a [`WrappedFunction`](layers#Lux.WrappedFunction)(`f`) which takes only one input. + * If the layer is a Chain, it is flattened. + * [`NoOpLayer`](layers#Lux.NoOpLayer)s are removed. + * If there is only 1 layer (left after optimizations), then it is returned without the `Chain` wrapper. + * If there are no layers (left after optimizations), a [`NoOpLayer`](layers#Lux.NoOpLayer) is returned. + +**Miscellaneous Properties** + + * Allows indexing. We can access the `i`th layer using `m[i]`. We can also index using ranges or arrays. + +**Example** + +```julia +c = Chain(Dense(2, 3, relu), BatchNorm(3), Dense(3, 2)) +``` + + +source
+ +
+
+
+# Lux.PairwiseFusion — Type. + + + +```julia +PairwiseFusion(connection, layers...; name=nothing) +PairwiseFusion(connection; name=nothing, layers...) +``` + +``` +x1 → layer1 → y1 ↘ + connection → layer2 → y2 ↘ + x2 ↗ connection → y3 + x3 ↗ +``` + +**Arguments** + + * `connection`: Takes 2 inputs and combines them + * `layers`: `AbstractExplicitLayer`s. Layers can be specified in two formats: + + * A list of `N` Lux layers + * Specified as `N` keyword arguments. + +**Keyword Arguments** + + * `name`: Name of the layer (optional) + +**Inputs** + +Layer behaves differently based on input type: + +1. If the input `x` is a tuple of length `N + 1`, then the `layers` must be a tuple of length `N`. The computation is as follows + +```julia +y = x[1] +for i in 1:N + y = connection(x[i + 1], layers[i](y)) +end +``` + +2. Any other kind of input + +```julia +y = x +for i in 1:N + y = connection(x, layers[i](y)) +end +``` + +**Returns** + + * See Inputs section for how the return value is computed + * Updated model state for all the contained layers + +**Parameters** + + * Parameters of each `layer` wrapped in a NamedTuple with `fields = layer_1, layer_2, ..., layer_N` (naming changes if using the kwargs API) + +**States** + + * States of each `layer` wrapped in a NamedTuple with `fields = layer_1, layer_2, ..., layer_N` (naming changes if using the kwargs API) + + +source
+ +
+
+
+# Lux.Parallel — Type. + + + +```julia +Parallel(connection, layers...; name=nothing) +Parallel(connection; name=nothing, layers...) +``` + +Create a layer which passes an input to each path in `layers`, before reducing the output with `connection`. + +**Arguments** + + * `connection`: An `N`-argument function that is called after passing the input through each layer. If `connection = nothing`, we return a tuple `Parallel(nothing, f, g)(x, y) = (f(x), g(y))` + * Layers can be specified in two formats: + + * A list of `N` Lux layers + * Specified as `N` keyword arguments. + +**Keyword Arguments** + + * `name`: Name of the layer (optional) + +**Inputs** + + * `x`: If `x` is not a tuple, then return is computed as `connection([l(x) for l in layers]...)`. Else one is passed to each layer, thus `Parallel(+, f, g)(x, y) = f(x) + g(y)`. + +**Returns** + + * See the Inputs section for how the output is computed + * Updated state of the `layers` + +**Parameters** + + * Parameters of each `layer` wrapped in a NamedTuple with `fields = layer_1, layer_2, ..., layer_N` (naming changes if using the kwargs API) + +**States** + + * States of each `layer` wrapped in a NamedTuple with `fields = layer_1, layer_2, ..., layer_N` (naming changes if using the kwargs API) + +See also [`SkipConnection`](layers#Lux.SkipConnection) which is `Parallel` with one identity. + + +source
+ +
+
+
+# Lux.SkipConnection — Type. + + + +```julia +SkipConnection(layer, connection; name=nothing) +``` + +Create a skip connection which consists of a layer or [`Chain`](layers#Lux.Chain) of consecutive layers and a shortcut connection linking the block's input to the output through a user-supplied 2-argument callable. The first argument to the callable will be propagated through the given `layer` while the second is the unchanged, "skipped" input. + +The simplest "ResNet"-type connection is just `SkipConnection(layer, +)`. + +**Arguments** + + * `layer`: Layer or `Chain` of layers to be applied to the input + * `connection`: + + * A 2-argument function that takes `layer(input)` and the input OR + * An AbstractExplicitLayer that takes `(layer(input), input)` as input + +**Keyword Arguments** + + * `name`: Name of the layer (optional) + +**Inputs** + + * `x`: Will be passed directly to `layer` + +**Returns** + + * Output of `connection(layer(input), input)` + * Updated state of `layer` + +**Parameters** + + * Parameters of `layer` OR + * If `connection` is an AbstractExplicitLayer, then NamedTuple with fields `:layers` and `:connection` + +**States** + + * States of `layer` OR + * If `connection` is an AbstractExplicitLayer, then NamedTuple with fields `:layers` and `:connection` + +See [`Parallel`](layers#Lux.Parallel) for a more general implementation. + + +source
+ +
+
+
+# Lux.RepeatedLayer — Type. + + + +```julia +RepeatedLayer(model; repeats::Val = Val(10), input_injection::Val = Val(false)) +``` + +Iteratively applies `model` for `repeats` number of times. The initial input is passed into the model repeatedly if `input_injection = Val(true)`. This layer unrolls the computation, however, semantically this is same as: + +1. `input_injection = Val(false)` + +```julia +res = x +for i in 1:repeats + res, st = model(res, ps, st) +end +``` + +2. `input_injection = Val(true)` + +```julia +res = x +for i in 1:repeats + res, st = model((res, x), ps, st) +end +``` + +It is expected that `repeats` will be a reasonable number below `20`, beyond that compile times for gradients might be unreasonably high. + +**Arguments** + + * `model` must be an `AbstractExplicitLayer` + +**Keyword Arguments** + + * `repeats`: Number of times to apply the model + * `input_injection`: If `true`, then the input is passed to the model along with the output + +**Inputs** + + * `x`: Input as described above + +**Returns** + + * Output is computed by as described above + * Updated state of the `model` + +**Parameters** + + * Parameters of `model` + +**States** + + * State of `model` + + +source
+ +
+
+ + + +## Convolutional Layers + +
+# Lux.Conv — Type. + + + +```julia +Conv(k::NTuple{N,Integer}, (in_chs => out_chs)::Pair{<:Integer,<:Integer}, + activation=identity; init_weight=glorot_uniform, init_bias=zeros32, stride=1, + pad=0, dilation=1, groups=1, use_bias=true) +``` + +Standard convolutional layer. + +Image data should be stored in WHCN order (width, height, channels, batch). In other words, a `100 x 100` RGB image would be a `100 x 100 x 3 x 1` array, and a batch of 50 would be a `100 x 100 x 3 x 50` array. This has `N = 2` spatial dimensions, and needs a kernel size like `(5, 5)`, a 2-tuple of integers. To take convolutions along `N` feature dimensions, this layer expects as input an array with `ndims(x) == N + 2`, where `size(x, N + 1) == in_chs` is the number of input channels, and `size(x, ndims(x))` is the number of observations in a batch. + +:::warning + +Frameworks like [`Pytorch`](https://pytorch.org/docs/stable/generated/torch.nn.Conv2d.html#torch.nn.Conv2d) perform cross-correlation in their convolution layers + +::: + +**Arguments** + + * `k`: Tuple of integers specifying the size of the convolutional kernel. Eg, for 2D convolutions `length(k) == 2` + * `in_chs`: Number of input channels + * `out_chs`: Number of input and output channels + * `activation`: Activation Function + +**Keyword Arguments** + + * `init_weight`: Controls the initialization of the weight parameter + * `init_bias`: Controls the initialization of the bias parameter + * `stride`: Should each be either single integer, or a tuple with `N` integers + * `dilation`: Should each be either single integer, or a tuple with `N` integers + * `pad`: Specifies the number of elements added to the borders of the data array. It can be + + * a single integer for equal padding all around, + * a tuple of `N` integers, to apply the same padding at begin/end of each spatial dimension, + * a tuple of `2*N` integers, for asymmetric padding, or + * the singleton `SamePad()`, to calculate padding such that `size(output,d) == size(x,d) / stride` (possibly rounded) for each spatial dimension. + * Periodic padding can achieved by pre-empting the layer with a `WrappedFunction(x -> NNlib.circular_pad(x, N_pad; dims=pad_dims))` + * `groups`: Expected to be an `Int`. It specifies the number of groups to divide a convolution into (set `groups = in_chs` for Depthwise Convolutions). `in_chs` and `out_chs` must be divisible by `groups`. + * `use_bias`: Trainable bias can be disabled entirely by setting this to `false`. + * `allow_fast_activation`: If `true`, then certain activations can be approximated with a faster version. The new activation function will be given by `NNlib.fast_act(activation)` + +**Inputs** + + * `x`: Data satisfying `ndims(x) == N + 2 && size(x, N - 1) == in_chs`, i.e. `size(x) = (I_N, ..., I_1, C_in, N)` + +**Returns** + + * Output of the convolution `y` of size `(O_N, ..., O_1, C_out, N)` where + +$$ +O_i = floor\left(\frac{I_i + pad[i] + pad[(i + N) \% length(pad)] - dilation[i] \times (k[i] - 1)}{stride[i]} + 1\right) +$$ + + * Empty `NamedTuple()` + +**Parameters** + + * `weight`: Convolution kernel + * `bias`: Bias (present if `use_bias=true`) + + +source
+ +
+
+
+# Lux.ConvTranspose — Type. + + + +```julia +ConvTranspose(k::NTuple{N,Integer}, (in_chs => out_chs)::Pair{<:Integer,<:Integer}, + activation=identity; init_weight=glorot_uniform, init_bias=zeros32, + stride=1, pad=0, dilation=1, groups=1, use_bias=true) +``` + +Standard convolutional transpose layer. + +**Arguments** + + * `k`: Tuple of integers specifying the size of the convolutional kernel. Eg, for 2D convolutions `length(k) == 2` + * `in_chs`: Number of input channels + * `out_chs`: Number of input and output channels + * `activation`: Activation Function + +**Keyword Arguments** + + * `init_weight`: Controls the initialization of the weight parameter + * `init_bias`: Controls the initialization of the bias parameter + * `stride`: Should each be either single integer, or a tuple with `N` integers + * `dilation`: Should each be either single integer, or a tuple with `N` integers + * `pad`: Specifies the number of elements added to the borders of the data array. It can be + + * a single integer for equal padding all around, + * a tuple of `N` integers, to apply the same padding at begin/end of each spatial dimension, + * a tuple of `2*N` integers, for asymmetric padding, or + * the singleton `SamePad()`, to calculate padding such that `size(output,d) == size(x,d) * stride` (possibly rounded) for each spatial dimension. + * `groups`: Expected to be an `Int`. It specifies the number of groups to divide a convolution into (set `groups = in_chs` for Depthwise Convolutions). `in_chs` and `out_chs` must be divisible by `groups`. + * `use_bias`: Trainable bias can be disabled entirely by setting this to `false`. + * `allow_fast_activation`: If `true`, then certain activations can be approximated with a faster version. The new activation function will be given by `NNlib.fast_act(activation)` + +**Inputs** + + * `x`: Data satisfying `ndims(x) == N + 2 && size(x, N - 1) == in_chs`, i.e. `size(x) = (I_N, ..., I_1, C_in, N)` + +**Returns** + + * Output of the convolution transpose `y` of size `(O_N, ..., O_1, C_out, N)` where + * Empty `NamedTuple()` + +**Parameters** + + * `weight`: Convolution Transpose kernel + * `bias`: Bias (present if `use_bias=true`) + + +source
+ +
+
+
+# Lux.CrossCor — Type. + + + +```julia +CrossCor(k::NTuple{N,Integer}, (in_chs => out_chs)::Pair{<:Integer,<:Integer}, + activation=identity; init_weight=glorot_uniform, init_bias=zeros32, stride=1, + pad=0, dilation=1, use_bias=true) +``` + +Cross Correlation layer. + +Image data should be stored in WHCN order (width, height, channels, batch). In other words, a `100 x 100` RGB image would be a `100 x 100 x 3 x 1` array, and a batch of 50 would be a `100 x 100 x 3 x 50` array. This has `N = 2` spatial dimensions, and needs a kernel size like `(5, 5)`, a 2-tuple of integers. To take convolutions along `N` feature dimensions, this layer expects as input an array with `ndims(x) == N + 2`, where `size(x, N + 1) == in_chs` is the number of input channels, and `size(x, ndims(x))` is the number of observations in a batch. + +**Arguments** + + * `k`: Tuple of integers specifying the size of the convolutional kernel. Eg, for 2D convolutions `length(k) == 2` + * `in_chs`: Number of input channels + * `out_chs`: Number of input and output channels + * `activation`: Activation Function + +**Keyword Arguments** + + * `init_weight`: Controls the initialization of the weight parameter + * `init_bias`: Controls the initialization of the bias parameter + * `stride`: Should each be either single integer, or a tuple with `N` integers + * `dilation`: Should each be either single integer, or a tuple with `N` integers + * `pad`: Specifies the number of elements added to the borders of the data array. It can be + + * a single integer for equal padding all around, + * a tuple of `N` integers, to apply the same padding at begin/end of each spatial dimension, + * a tuple of `2*N` integers, for asymmetric padding, or + * the singleton `SamePad()`, to calculate padding such that `size(output,d) == size(x,d) / stride` (possibly rounded) for each spatial dimension. + * `use_bias`: Trainable bias can be disabled entirely by setting this to `false`. + * `allow_fast_activation`: If `true`, then certain activations can be approximated with a faster version. The new activation function will be given by `NNlib.fast_act(activation)` + +**Inputs** + + * `x`: Data satisfying `ndims(x) == N + 2 && size(x, N - 1) == in_chs`, i.e. `size(x) = (I_N, ..., I_1, C_in, N)` + +**Returns** + + * Output of the convolution `y` of size `(O_N, ..., O_1, C_out, N)` where + +$$ +O_i = floor\left(\frac{I_i + pad[i] + pad[(i + N) \% length(pad)] - dilation[i] \times (k[i] - 1)}{stride[i]} + 1\right) +$$ + + * Empty `NamedTuple()` + +**Parameters** + + * `weight`: Convolution kernel + * `bias`: Bias (present if `use_bias=true`) + + +source
+ +
+
+ + + +## Dropout Layers + +
+# Lux.AlphaDropout — Type. + + + +```julia +AlphaDropout(p::Real) +``` + +AlphaDropout layer. + +**Arguments** + + * `p`: Probability of Dropout + + * if `p = 0` then [`NoOpLayer`](layers#Lux.NoOpLayer) is returned. + * if `p = 1` then `WrappedLayer(Base.Fix1(broadcast, zero))` is returned. + +**Inputs** + + * `x`: Must be an AbstractArray + +**Returns** + + * `x` with dropout mask applied if `training=Val(true)` else just `x` + * State with updated `rng` + +**States** + + * `rng`: Pseudo Random Number Generator + * `training`: Used to check if training/inference mode + +Call [`Lux.testmode`](../Building_Blocks/LuxCore#LuxCore.testmode) to switch to test mode. + +See also [`Dropout`](layers#Lux.Dropout), [`VariationalHiddenDropout`](layers#Lux.VariationalHiddenDropout) + + +source
+ +
+
+
+# Lux.Dropout — Type. + + + +```julia +Dropout(p; dims=:) +``` + +Dropout layer. + +**Arguments** + + * `p`: Probability of Dropout (if `p = 0` then [`NoOpLayer`](layers#Lux.NoOpLayer) is returned) + +**Keyword Arguments** + + * To apply dropout along certain dimension(s), specify the `dims` keyword. e.g. `Dropout(p; dims = 3)` will randomly zero out entire channels on WHCN input (also called 2D dropout). + +**Inputs** + + * `x`: Must be an AbstractArray + +**Returns** + + * `x` with dropout mask applied if `training=Val(true)` else just `x` + * State with updated `rng` + +**States** + + * `rng`: Pseudo Random Number Generator + * `training`: Used to check if training/inference mode + +Call [`Lux.testmode`](../Building_Blocks/LuxCore#LuxCore.testmode) to switch to test mode. + +See also [`AlphaDropout`](layers#Lux.AlphaDropout), [`VariationalHiddenDropout`](layers#Lux.VariationalHiddenDropout) + + +source
+ +
+
+
+# Lux.VariationalHiddenDropout — Type. + + + +```julia +VariationalHiddenDropout(p; dims=:) +``` + +VariationalHiddenDropout layer. The only difference from Dropout is that the `mask` is retained until [`Lux.update_state(l, :update_mask, Val(true))`](../Building_Blocks/LuxCore#LuxCore.update_state) is called. + +**Arguments** + + * `p`: Probability of Dropout (if `p = 0` then [`NoOpLayer`](layers#Lux.NoOpLayer) is returned) + +**Keyword Arguments** + + * To apply dropout along certain dimension(s), specify the `dims` keyword. e.g. `VariationalHiddenDropout(p; dims = 3)` will randomly zero out entire channels on WHCN input (also called 2D dropout). + +**Inputs** + + * `x`: Must be an AbstractArray + +**Returns** + + * `x` with dropout mask applied if `training=Val(true)` else just `x` + * State with updated `rng` + +**States** + + * `rng`: Pseudo Random Number Generator + * `training`: Used to check if training/inference mode + * `mask`: Dropout mask. Initilly set to nothing. After every run, contains the mask applied in that call + * `update_mask`: Stores whether new mask needs to be generated in the current call + +Call [`Lux.testmode`](../Building_Blocks/LuxCore#LuxCore.testmode) to switch to test mode. + +See also [`AlphaDropout`](layers#Lux.AlphaDropout), [`Dropout`](layers#Lux.Dropout) + + +source
+ +
+
+ + + +## Pooling Layers + +
+# Lux.AdaptiveMaxPool — Type. + + + +```julia +AdaptiveMaxPool(out::NTuple) +``` + +Adaptive Max Pooling layer. Calculates the necessary window size such that its output has `size(y)[1:N] == out`. + +**Arguments** + + * `out`: Size of the first `N` dimensions for the output + +**Inputs** + + * `x`: Expects as input an array with `ndims(x) == N+2`, i.e. channel and batch dimensions, after the `N` feature dimensions, where `N = length(out)`. + +**Returns** + + * Output of size `(out..., C, N)` + * Empty `NamedTuple()` + +See also [`MaxPool`](layers#Lux.MaxPool), [`AdaptiveMeanPool`](layers#Lux.AdaptiveMeanPool). + + +source
+ +
+
+
+# Lux.AdaptiveMeanPool — Type. + + + +```julia +AdaptiveMeanPool(out::NTuple) +``` + +Adaptive Mean Pooling layer. Calculates the necessary window size such that its output has `size(y)[1:N] == out`. + +**Arguments** + + * `out`: Size of the first `N` dimensions for the output + +**Inputs** + + * `x`: Expects as input an array with `ndims(x) == N+2`, i.e. channel and batch dimensions, after the `N` feature dimensions, where `N = length(out)`. + +**Returns** + + * Output of size `(out..., C, N)` + * Empty `NamedTuple()` + +See also [`MeanPool`](layers#Lux.MeanPool), [`AdaptiveMaxPool`](layers#Lux.AdaptiveMaxPool). + + +source
+ +
+
+
+# Lux.GlobalMaxPool — Type. + + + +```julia +GlobalMaxPool() +``` + +Global Max Pooling layer. Transforms (w,h,c,b)-shaped input into (1,1,c,b)-shaped output, by performing max pooling on the complete (w,h)-shaped feature maps. + +**Inputs** + + * `x`: Data satisfying `ndims(x) > 2`, i.e. `size(x) = (I_N, ..., I_1, C, N)` + +**Returns** + + * Output of the pooling `y` of size `(1, ..., 1, C, N)` + * Empty `NamedTuple()` + +See also [`MaxPool`](layers#Lux.MaxPool), [`AdaptiveMaxPool`](layers#Lux.AdaptiveMaxPool), [`GlobalMeanPool`](layers#Lux.GlobalMeanPool) + + +source
+ +
+
+
+# Lux.GlobalMeanPool — Type. + + + +```julia +GlobalMeanPool() +``` + +Global Mean Pooling layer. Transforms (w,h,c,b)-shaped input into (1,1,c,b)-shaped output, by performing mean pooling on the complete (w,h)-shaped feature maps. + +**Inputs** + + * `x`: Data satisfying `ndims(x) > 2`, i.e. `size(x) = (I_N, ..., I_1, C, N)` + +**Returns** + + * Output of the pooling `y` of size `(1, ..., 1, C, N)` + * Empty `NamedTuple()` + +See also [`MeanPool`](layers#Lux.MeanPool), [`AdaptiveMeanPool`](layers#Lux.AdaptiveMeanPool), [`GlobalMaxPool`](layers#Lux.GlobalMaxPool) + + +source
+ +
+
+
+# Lux.MaxPool — Type. + + + +```julia +MaxPool(window::NTuple; pad=0, stride=window) +``` + +Max pooling layer, which replaces all pixels in a block of size `window` with the maximum value. + +**Arguments** + + * `window`: Tuple of integers specifying the size of the window. Eg, for 2D pooling `length(window) == 2` + +**Keyword Arguments** + + * `stride`: Should each be either single integer, or a tuple with `N` integers + * `pad`: Specifies the number of elements added to the borders of the data array. It can be + + * a single integer for equal padding all around, + * a tuple of `N` integers, to apply the same padding at begin/end of each spatial dimension, + * a tuple of `2*N` integers, for asymmetric padding, or + * the singleton `SamePad()`, to calculate padding such that `size(output,d) == size(x,d) / stride` (possibly rounded) for each spatial dimension. + +**Inputs** + + * `x`: Data satisfying `ndims(x) == N + 2`, i.e. `size(x) = (I_N, ..., I_1, C, N)` + +**Returns** + + * Output of the pooling `y` of size `(O_N, ..., O_1, C, N)` where + +$$ + O_i = floor\left(\frac{I_i + pad[i] + pad[(i + N) \% length(pad)] - dilation[i] \times (k[i] - 1)}{stride[i]} + 1\right) +$$ + + * Empty `NamedTuple()` + +See also [`Conv`](layers#Lux.Conv), [`MeanPool`](layers#Lux.MeanPool), [`GlobalMaxPool`](layers#Lux.GlobalMaxPool), [`AdaptiveMaxPool`](layers#Lux.AdaptiveMaxPool) + + +source
+ +
+
+
+# Lux.MeanPool — Type. + + + +```julia +MeanPool(window::NTuple; pad=0, stride=window) +``` + +Mean pooling layer, which replaces all pixels in a block of size `window` with the mean value. + +**Arguments** + + * `window`: Tuple of integers specifying the size of the window. Eg, for 2D pooling `length(window) == 2` + +**Keyword Arguments** + + * `stride`: Should each be either single integer, or a tuple with `N` integers + * `pad`: Specifies the number of elements added to the borders of the data array. It can be + + * a single integer for equal padding all around, + * a tuple of `N` integers, to apply the same padding at begin/end of each spatial dimension, + * a tuple of `2*N` integers, for asymmetric padding, or + * the singleton `SamePad()`, to calculate padding such that `size(output,d) == size(x,d) / stride` (possibly rounded) for each spatial dimension. + +**Inputs** + + * `x`: Data satisfying `ndims(x) == N + 2`, i.e. `size(x) = (I_N, ..., I_1, C, N)` + +**Returns** + + * Output of the pooling `y` of size `(O_N, ..., O_1, C, N)` where + +$$ + O_i = floor\left(\frac{I_i + pad[i] + pad[(i + N) \% length(pad)] - dilation[i] \times (k[i] - 1)}{stride[i]} + 1\right) +$$ + + * Empty `NamedTuple()` + +See also [`Conv`](layers#Lux.Conv), [`MaxPool`](layers#Lux.MaxPool), [`GlobalMeanPool`](layers#Lux.GlobalMeanPool), [`AdaptiveMeanPool`](layers#Lux.AdaptiveMeanPool) + + +source
+ +
+
+ + + +## Recurrent Layers + +
+# Lux.GRUCell — Type. + + + +```julia +GRUCell((in_dims, out_dims)::Pair{<:Int,<:Int}; use_bias=true, train_state::Bool=false, + init_weight::Tuple{Function,Function,Function}=(glorot_uniform, glorot_uniform, + glorot_uniform), + init_bias::Tuple{Function,Function,Function}=(zeros32, zeros32, zeros32), + init_state::Function=zeros32) +``` + +Gated Recurrent Unit (GRU) Cell + +$$ +\begin{align} + r &= \sigma(W_{ir} \times x + W_{hr} \times h_{prev} + b_{hr})\\ + z &= \sigma(W_{iz} \times x + W_{hz} \times h_{prev} + b_{hz})\\ + n &= \tanh(W_{in} \times x + b_{in} + r \cdot (W_{hn} \times h_{prev} + b_{hn}))\\ + h_{new} &= (1 - z) \cdot n + z \cdot h_{prev} +\end{align} +$$ + +**Arguments** + + * `in_dims`: Input Dimension + * `out_dims`: Output (Hidden State) Dimension + * `use_bias`: Set to false to deactivate bias + * `train_state`: Trainable initial hidden state can be activated by setting this to `true` + * `init_bias`: Initializer for bias. Must be a tuple containing 3 functions + * `init_weight`: Initializer for weight. Must be a tuple containing 3 functions + * `init_state`: Initializer for hidden state + +**Inputs** + + * Case 1a: Only a single input `x` of shape `(in_dims, batch_size)`, `train_state` is set to `false` - Creates a hidden state using `init_state` and proceeds to Case 2. + * Case 1b: Only a single input `x` of shape `(in_dims, batch_size)`, `train_state` is set to `true` - Repeats `hidden_state` from parameters to match the shape of `x` and proceeds to Case 2. + * Case 2: Tuple `(x, (h, ))` is provided, then the output and a tuple containing the updated hidden state is returned. + +**Returns** + + * Tuple containing + + * Output $h_{new}$ of shape `(out_dims, batch_size)` + * Tuple containing new hidden state $h_{new}$ + * Updated model state + +**Parameters** + + * `weight_i`: Concatenated Weights to map from input space $\\left\\\{ W_{ir}, W_{iz}, W_{in} \\right\\\}$. + * `weight_h`: Concatenated Weights to map from hidden space $\\left\\\{ W_{hr}, W_{hz}, W_{hn} \\right\\\}$. + * `bias_i`: Bias vector ($b_{in}$; not present if `use_bias=false`). + * `bias_h`: Concatenated Bias vector for the hidden space $\\left\\\{ b_{hr}, b_{hz}, b_{hn} \\right\\\}$ (not present if `use_bias=false`). + * `hidden_state`: Initial hidden state vector (not present if `train_state=false`) $\\left\\\{ b_{hr}, b_{hz}, b_{hn} \\right\\\}$. + +**States** + + * `rng`: Controls the randomness (if any) in the initial state generation + + +source
+ +
+
+
+# Lux.LSTMCell — Type. + + + +```julia +LSTMCell(in_dims => out_dims; use_bias::Bool=true, train_state::Bool=false, + train_memory::Bool=false, + init_weight=(glorot_uniform, glorot_uniform, glorot_uniform, glorot_uniform), + init_bias=(zeros32, zeros32, ones32, zeros32), init_state=zeros32, + init_memory=zeros32) +``` + +Long Short-Term (LSTM) Cell + +$$ +\begin{align} + i &= \sigma(W_{ii} \times x + W_{hi} \times h_{prev} + b_{i})\\ + f &= \sigma(W_{if} \times x + W_{hf} \times h_{prev} + b_{f})\\ + g &= tanh(W_{ig} \times x + W_{hg} \times h_{prev} + b_{g})\\ + o &= \sigma(W_{io} \times x + W_{ho} \times h_{prev} + b_{o})\\ + c_{new} &= f \cdot c_{prev} + i \cdot g\\ + h_{new} &= o \cdot tanh(c_{new}) +\end{align} +$$ + +**Arguments** + + * `in_dims`: Input Dimension + * `out_dims`: Output (Hidden State & Memory) Dimension + * `use_bias`: Set to false to deactivate bias + * `train_state`: Trainable initial hidden state can be activated by setting this to `true` + * `train_memory`: Trainable initial memory can be activated by setting this to `true` + * `init_bias`: Initializer for bias. Must be a tuple containing 4 functions + * `init_weight`: Initializer for weight. Must be a tuple containing 4 functions + * `init_state`: Initializer for hidden state + * `init_memory`: Initializer for memory + +**Inputs** + + * Case 1a: Only a single input `x` of shape `(in_dims, batch_size)`, `train_state` is set to `false`, `train_memory` is set to `false` - Creates a hidden state using `init_state`, hidden memory using `init_memory` and proceeds to Case 2. + * Case 1b: Only a single input `x` of shape `(in_dims, batch_size)`, `train_state` is set to `true`, `train_memory` is set to `false` - Repeats `hidden_state` vector from the parameters to match the shape of `x`, creates hidden memory using `init_memory` and proceeds to Case 2. + * Case 1c: Only a single input `x` of shape `(in_dims, batch_size)`, `train_state` is set to `false`, `train_memory` is set to `true` - Creates a hidden state using `init_state`, repeats the memory vector from parameters to match the shape of `x` and proceeds to Case 2. + * Case 1d: Only a single input `x` of shape `(in_dims, batch_size)`, `train_state` is set to `true`, `train_memory` is set to `true` - Repeats the hidden state and memory vectors from the parameters to match the shape of `x` and proceeds to Case 2. + * Case 2: Tuple `(x, (h, c))` is provided, then the output and a tuple containing the updated hidden state and memory is returned. + +**Returns** + + * Tuple Containing + + * Output $h_{new}$ of shape `(out_dims, batch_size)` + * Tuple containing new hidden state $h_{new}$ and new memory $c_{new}$ + * Updated model state + +**Parameters** + + * `weight_i`: Concatenated Weights to map from input space $\{ W_{ii}, W_{if}, W_{ig}, W_{io} \}$. + * `weight_h`: Concatenated Weights to map from hidden space $\{ W_{hi}, W_{hf}, W_{hg}, W_{ho} \}$ + * `bias`: Bias vector (not present if `use_bias=false`) + * `hidden_state`: Initial hidden state vector (not present if `train_state=false`) + * `memory`: Initial memory vector (not present if `train_memory=false`) + +**States** + + * `rng`: Controls the randomness (if any) in the initial state generation + + +source
+ +
+
+
+# Lux.RNNCell — Type. + + + +```julia +RNNCell(in_dims => out_dims, activation=tanh; bias::Bool=true, + train_state::Bool=false, init_bias=zeros32, init_weight=glorot_uniform, + init_state=ones32) +``` + +An Elman RNNCell cell with `activation` (typically set to `tanh` or `relu`). + +$h_{new} = activation(weight_{ih} \times x + weight_{hh} \times h_{prev} + bias)$ + +**Arguments** + + * `in_dims`: Input Dimension + * `out_dims`: Output (Hidden State) Dimension + * `activation`: Activation function + * `bias`: Set to false to deactivate bias + * `train_state`: Trainable initial hidden state can be activated by setting this to `true` + * `init_bias`: Initializer for bias + * `init_weight`: Initializer for weight + * `init_state`: Initializer for hidden state + +**Inputs** + + * Case 1a: Only a single input `x` of shape `(in_dims, batch_size)`, `train_state` is set to `false` - Creates a hidden state using `init_state` and proceeds to Case 2. + * Case 1b: Only a single input `x` of shape `(in_dims, batch_size)`, `train_state` is set to `true` - Repeats `hidden_state` from parameters to match the shape of `x` and proceeds to Case 2. + * Case 2: Tuple `(x, (h, ))` is provided, then the output and a tuple containing the updated hidden state is returned. + +**Returns** + + * Tuple containing + + * Output $h_{new}$ of shape `(out_dims, batch_size)` + * Tuple containing new hidden state $h_{new}$ + * Updated model state + +**Parameters** + + * `weight_ih`: Maps the input to the hidden state. + * `weight_hh`: Maps the hidden state to the hidden state. + * `bias`: Bias vector (not present if `use_bias=false`) + * `hidden_state`: Initial hidden state vector (not present if `train_state=false`) + +**States** + + * `rng`: Controls the randomness (if any) in the initial state generation + + +source
+ +
+
+
+# Lux.Recurrence — Type. + + + +```julia +Recurrence(cell; + ordering::AbstractTimeSeriesDataBatchOrdering=BatchLastIndex(), + return_sequence::Bool=false) +``` + +Wraps a recurrent cell (like [`RNNCell`](layers#Lux.RNNCell), [`LSTMCell`](layers#Lux.LSTMCell), [`GRUCell`](layers#Lux.GRUCell)) to automatically operate over a sequence of inputs. + +:::warning + +This is completely distinct from `Flux.Recur`. It doesn't make the `cell` stateful, rather allows operating on an entire sequence of inputs at once. See [`StatefulRecurrentCell`](layers#Lux.StatefulRecurrentCell) for functionality similar to `Flux.Recur`. + +::: + +**Arguments** + + * `cell`: A recurrent cell. See [`RNNCell`](layers#Lux.RNNCell), [`LSTMCell`](layers#Lux.LSTMCell), [`GRUCell`](layers#Lux.GRUCell), for how the inputs/outputs of a recurrent cell must be structured. + +**Keyword Arguments** + + * `return_sequence`: If `true` returns the entire sequence of outputs, else returns only the last output. Defaults to `false`. + * `ordering`: The ordering of the batch and time dimensions in the input. Defaults to `BatchLastIndex()`. Alternatively can be set to `TimeLastIndex()`. + +**Inputs** + + * If `x` is a + + * Tuple or Vector: Each element is fed to the `cell` sequentially. + * Array (except a Vector): It is spliced along the penultimate dimension and each slice is fed to the `cell` sequentially. + +**Returns** + + * Output of the `cell` for the entire sequence. + * Update state of the `cell`. + +**Parameters** + + * Same as `cell`. + +**States** + + * Same as `cell`. + + +source
+ +
+
+
+# Lux.StatefulRecurrentCell — Type. + + + +```julia +StatefulRecurrentCell(cell) +``` + +Wraps a recurrent cell (like [`RNNCell`](layers#Lux.RNNCell), [`LSTMCell`](layers#Lux.LSTMCell), [`GRUCell`](layers#Lux.GRUCell)) and makes it stateful. + +:::tip + +This is very similar to `Flux.Recur` + +::: + +To avoid undefined behavior, once the processing of a single sequence of data is complete, update the state with `Lux.update_state(st, :carry, nothing)`. + +**Arguments** + + * `cell`: A recurrent cell. See [`RNNCell`](layers#Lux.RNNCell), [`LSTMCell`](layers#Lux.LSTMCell), [`GRUCell`](layers#Lux.GRUCell), for how the inputs/outputs of a recurrent cell must be structured. + +**Inputs** + + * Input to the `cell`. + +**Returns** + + * Output of the `cell` for the entire sequence. + * Update state of the `cell` and updated `carry`. + +**Parameters** + + * Same as `cell`. + +**States** + + * NamedTuple containing: + + * `cell`: Same as `cell`. + * `carry`: The carry state of the `cell`. + + +source
+ +
+
+ + + +## Linear Layers + +
+# Lux.Bilinear — Type. + + + +```julia +Bilinear((in1_dims, in2_dims) => out, activation=identity; init_weight=glorot_uniform, + init_bias=zeros32, use_bias::Bool=true, allow_fast_activation::Bool=true) +Bilinear(in12_dims => out, activation=identity; init_weight=glorot_uniform, + init_bias=zeros32, use_bias::Bool=true, allow_fast_activation::Bool=true) +``` + +Create a fully connected layer between two inputs and an output, and otherwise similar to [`Dense`](layers#Lux.Dense). Its output, given vectors `x` & `y`, is another vector `z` with, for all `i in 1:out`: + +`z[i] = activation(x' * W[i, :, :] * y + bias[i])` + +If `x` and `y` are matrices, then each column of the output `z = B(x, y)` is of this form, with `B` the Bilinear layer. + +**Arguments** + + * `in1_dims`: number of input dimensions of `x` + * `in2_dims`: number of input dimensions of `y` + * `in12_dims`: If specified, then `in1_dims = in2_dims = in12_dims` + * `out`: number of output dimensions + * `activation`: activation function + +**Keyword Arguments** + + * `init_weight`: initializer for the weight matrix (`weight = init_weight(rng, out_dims, in1_dims, in2_dims)`) + * `init_bias`: initializer for the bias vector (ignored if `use_bias=false`) + * `use_bias`: Trainable bias can be disabled entirely by setting this to `false` + * `allow_fast_activation`: If `true`, then certain activations can be approximated with a faster version. The new activation function will be given by `NNlib.fast_act(activation)` + +**Input** + + * A 2-Tuple containing + + * `x` must be an AbstractArray with `size(x, 1) == in1_dims` + * `y` must be an AbstractArray with `size(y, 1) == in2_dims` + * If the input is an AbstractArray, then `x = y` + +**Returns** + + * AbstractArray with dimensions `(out_dims, size(x, 2))` + * Empty `NamedTuple()` + +**Parameters** + + * `weight`: Weight Matrix of size `(out_dims, in1_dims, in2_dims)` + * `bias`: Bias of size `(out_dims, 1)` (present if `use_bias=true`) + + +source
+ +
+
+
+# Lux.Dense — Type. + + + +```julia +Dense(in_dims => out_dims, activation=identity; init_weight=glorot_uniform, + init_bias=zeros32, bias::Bool=true) +``` + +Create a traditional fully connected layer, whose forward pass is given by: `y = activation.(weight * x .+ bias)` + +**Arguments** + + * `in_dims`: number of input dimensions + * `out_dims`: number of output dimensions + * `activation`: activation function + +**Keyword Arguments** + + * `init_weight`: initializer for the weight matrix (`weight = init_weight(rng, out_dims, in_dims)`) + * `init_bias`: initializer for the bias vector (ignored if `use_bias=false`) + * `use_bias`: Trainable bias can be disabled entirely by setting this to `false` + * `allow_fast_activation`: If `true`, then certain activations can be approximated with a faster version. The new activation function will be given by `NNlib.fast_act(activation)` + +**Input** + + * `x` must be an AbstractArray with `size(x, 1) == in_dims` + +**Returns** + + * AbstractArray with dimensions `(out_dims, ...)` where `...` are the dimensions of `x` + * Empty `NamedTuple()` + +**Parameters** + + * `weight`: Weight Matrix of size `(out_dims, in_dims)` + * `bias`: Bias of size `(out_dims, 1)` (present if `use_bias=true`) + + +source
+ +
+
+
+# Lux.Embedding — Type. + + + +```julia +Embedding(in_dims => out_dims; init_weight=randn32) +``` + +A lookup table that stores embeddings of dimension `out_dims` for a vocabulary of size `in_dims`. + +This layer is often used to store word embeddings and retrieve them using indices. + +:::warning + +Unlike `Flux.Embedding`, this layer does not support using `OneHotArray` as an input. + +::: + +**Arguments** + + * `in_dims`: number of input dimensions + * `out_dims`: number of output dimensions + +**Keyword Arguments** + + * `init_weight`: initializer for the weight matrix (`weight = init_weight(rng, out_dims, in_dims)`) + +**Input** + + * Integer OR + * Abstract Vector of Integers OR + * Abstract Array of Integers + +**Returns** + + * Returns the embedding corresponding to each index in the input. For an N dimensional input, an N + 1 dimensional output is returned. + * Empty `NamedTuple()` + + +source
+ +
+
+
+# Lux.Scale — Type. + + + +```julia +Scale(dims, activation=identity; init_weight=ones32, init_bias=zeros32, bias::Bool=true) +``` + +Create a Sparsely Connected Layer with a very specific structure (only Diagonal Elements are non-zero). The forward pass is given by: `y = activation.(weight .* x .+ bias)` + +**Arguments** + + * `dims`: size of the learnable scale and bias parameters. + * `activation`: activation function + +**Keyword Arguments** + + * `init_weight`: initializer for the weight matrix (`weight = init_weight(rng, out_dims, in_dims)`) + * `init_bias`: initializer for the bias vector (ignored if `use_bias=false`) + * `use_bias`: Trainable bias can be disabled entirely by setting this to `false` + * `allow_fast_activation`: If `true`, then certain activations can be approximated with a faster version. The new activation function will be given by `NNlib.fast_act(activation)` + +**Input** + + * `x` must be an Array of size `(dims..., B)` or `(dims...[0], ..., dims[k])` for `k ≤ size(dims)` + +**Returns** + + * Array of size `(dims..., B)` or `(dims...[0], ..., dims[k])` for `k ≤ size(dims)` + * Empty `NamedTuple()` + +**Parameters** + + * `weight`: Weight Array of size `(dims...)` + * `bias`: Bias of size `(dims...)` + + +source
+ +
+
+ + + +## Misc. Helper Layers + +
+# Lux.FlattenLayer — Type. + + + +```julia +FlattenLayer() +``` + +Flattens the passed array into a matrix. + +**Inputs** + + * `x`: AbstractArray + +**Returns** + + * AbstractMatrix of size `(:, size(x, ndims(x)))` + * Empty `NamedTuple()` + + +source
+ +
+
+
+# Lux.Maxout — Type. + + + +```julia +Maxout(layers...) +Maxout(; layers...) +Maxout(f::Function, n_alts::Int) +``` + +This contains a number of internal layers, each of which receives the same input. Its output is the elementwise maximum of the the internal layers' outputs. + +Maxout over linear dense layers satisfies the univeral approximation theorem. See [1]. + +See also [`Parallel`](layers#Lux.Parallel) to reduce with other operators. + +**Arguments** + + * Layers can be specified in three formats: + + * A list of `N` Lux layers + * Specified as `N` keyword arguments. + * A no argument function `f` and an integer `n_alts` which specifies the number of layers. + +**Inputs** + + * `x`: Input that is passed to each of the layers + +**Returns** + + * Output is computed by taking elementwise `max` of the outputs of the individual layers. + * Updated state of the `layers` + +**Parameters** + + * Parameters of each `layer` wrapped in a NamedTuple with `fields = layer_1, layer_2, ..., layer_N` (naming changes if using the kwargs API) + +**States** + + * States of each `layer` wrapped in a NamedTuple with `fields = layer_1, layer_2, ..., layer_N` (naming changes if using the kwargs API) + +**References** + +[1] Goodfellow, Warde-Farley, Mirza, Courville & Bengio "Maxout Networks" [https://arxiv.org/abs/1302.4389](https://arxiv.org/abs/1302.4389) + + +source
+ +
+
+
+# Lux.NoOpLayer — Type. + + + +```julia +NoOpLayer() +``` + +As the name suggests does nothing but allows pretty printing of layers. Whatever input is passed is returned. + + +source
+ +
+
+
+# Lux.ReshapeLayer — Type. + + + +```julia +ReshapeLayer(dims) +``` + +Reshapes the passed array to have a size of `(dims..., :)` + +**Arguments** + + * `dims`: The new dimensions of the array (excluding the last dimension). + +**Inputs** + + * `x`: AbstractArray of any shape which can be reshaped in `(dims..., size(x, ndims(x)))` + +**Returns** + + * AbstractArray of size `(dims..., size(x, ndims(x)))` + * Empty `NamedTuple()` + + +source
+ +
+
+
+# Lux.SelectDim — Type. + + + +```julia +SelectDim(dim, i) +``` + +Return a view of all the data of the input `x` where the index for dimension `dim` equals `i`. Equivalent to `view(x,:,:,...,i,:,:,...)` where `i` is in position `d`. + +**Arguments** + + * `dim`: Dimension for indexing + * `i`: Index for dimension `dim` + +**Inputs** + + * `x`: AbstractArray that can be indexed with `view(x,:,:,...,i,:,:,...)` + +**Returns** + + * `view(x,:,:,...,i,:,:,...)` where `i` is in position `d` + * Empty `NamedTuple()` + + +source
+ +
+
+
+# Lux.WrappedFunction — Type. + + + +```julia +WrappedFunction(f) +``` + +Wraps a stateless and parameter less function. Might be used when a function is added to `Chain`. For example, `Chain(x -> relu.(x))` would not work and the right thing to do would be `Chain((x, ps, st) -> (relu.(x), st))`. An easier thing to do would be `Chain(WrappedFunction(Base.Fix1(broadcast, relu)))` + +**Arguments** + + * `f::Function`: A stateless and parameterless function + +**Inputs** + + * `x`: s.t `hasmethod(f, (typeof(x),))` is `true` + +**Returns** + + * Output of `f(x)` + * Empty `NamedTuple()` + + +source
+ +
+
+ + + +## Normalization Layers + +
+# Lux.BatchNorm — Type. + + + +```julia +BatchNorm(chs::Integer, activation=identity; init_bias=zeros32, init_scale=ones32, + affine=true, track_stats=true, epsilon=1f-5, momentum=0.1f0, + allow_fast_activation::Bool=true) +``` + +[Batch Normalization](https://arxiv.org/abs/1502.03167) layer. + +`BatchNorm` computes the mean and variance for each $D_1 × ... × D_{N-2} × 1 × D_N$ input slice and normalises the input accordingly. + +**Arguments** + + * `chs`: Size of the channel dimension in your data. Given an array with `N` dimensions, call the `N-1`th the channel dimension. For a batch of feature vectors this is just the data dimension, for `WHCN` images it's the usual channel dimension. + * `activation`: After normalization, elementwise activation `activation` is applied. + +**Keyword Arguments** + + * If `track_stats=true`, accumulates mean and variance statistics in training phase that will be used to renormalize the input in test phase. + * `epsilon`: a value added to the denominator for numerical stability + * `momentum`: the value used for the `running_mean` and `running_var` computation + * `allow_fast_activation`: If `true`, then certain activations can be approximated with a faster version. The new activation function will be given by `NNlib.fast_act(activation)` + * If `affine=true`, it also applies a shift and a rescale to the input through to learnable per-channel bias and scale parameters. + + * `init_bias`: Controls how the `bias` is initiliazed + * `init_scale`: Controls how the `scale` is initiliazed + +**Inputs** + + * `x`: Array where `size(x, N - 1) = chs` and `ndims(x) > 2` + +**Returns** + + * `y`: Normalized Array + * Update model state + +**Parameters** + + * `affine=true` + + * `bias`: Bias of shape `(chs,)` + * `scale`: Scale of shape `(chs,)` + * `affine=false` - Empty `NamedTuple()` + +**States** + + * Statistics if `track_stats=true` + + * `running_mean`: Running mean of shape `(chs,)` + * `running_var`: Running variance of shape `(chs,)` + * Statistics if `track_stats=false` + + * `running_mean`: nothing + * `running_var`: nothing + * `training`: Used to check if training/inference mode + +Use `Lux.testmode` during inference. + +**Example** + +```julia +m = Chain(Dense(784 => 64), BatchNorm(64, relu), Dense(64 => 10), BatchNorm(10)) +``` + +:::warning + +Passing a batch size of 1, during training will result in NaNs. + +::: + +See also [`BatchNorm`](layers#Lux.BatchNorm), [`InstanceNorm`](layers#Lux.InstanceNorm), [`LayerNorm`](layers#Lux.LayerNorm), [`WeightNorm`](layers#Lux.WeightNorm) + + +source
+ +
+
+
+# Lux.GroupNorm — Type. + + + +```julia +GroupNorm(chs::Integer, groups::Integer, activation=identity; init_bias=zeros32, + init_scale=ones32, affine=true, epsilon=1f-5, + allow_fast_activation::Bool=true) +``` + +[Group Normalization](https://arxiv.org/abs/1803.08494) layer. + +**Arguments** + + * `chs`: Size of the channel dimension in your data. Given an array with `N` dimensions, call the `N-1`th the channel dimension. For a batch of feature vectors this is just the data dimension, for `WHCN` images it's the usual channel dimension. + * `groups` is the number of groups along which the statistics are computed. The number of channels must be an integer multiple of the number of groups. + * `activation`: After normalization, elementwise activation `activation` is applied. + +**Keyword Arguments** + + * `epsilon`: a value added to the denominator for numerical stability + * `allow_fast_activation`: If `true`, then certain activations can be approximated with a faster version. The new activation function will be given by `NNlib.fast_act(activation)` + * If `affine=true`, it also applies a shift and a rescale to the input through to learnable per-channel bias and scale parameters. + + * `init_bias`: Controls how the `bias` is initiliazed + * `init_scale`: Controls how the `scale` is initiliazed + +**Inputs** + + * `x`: Array where `size(x, N - 1) = chs` and `ndims(x) > 2` + +**Returns** + + * `y`: Normalized Array + * Update model state + +**Parameters** + + * `affine=true` + + * `bias`: Bias of shape `(chs,)` + * `scale`: Scale of shape `(chs,)` + * `affine=false` - Empty `NamedTuple()` + +**States** + + * `training`: Used to check if training/inference mode + +Use `Lux.testmode` during inference. + +**Example** + +```julia +m = Chain(Dense(784 => 64), GroupNorm(64, 4, relu), Dense(64 => 10), GroupNorm(10, 5)) +``` + +:::warning + +GroupNorm doesn't have CUDNN support. The GPU fallback is not very efficient. + +::: + +See also [`GroupNorm`](layers#Lux.GroupNorm), [`InstanceNorm`](layers#Lux.InstanceNorm), [`LayerNorm`](layers#Lux.LayerNorm), [`WeightNorm`](layers#Lux.WeightNorm) + + +source
+ +
+
+
+# Lux.InstanceNorm — Type. + + + +```julia +InstanceNorm(chs::Integer, activation=identity; init_bias=zeros32, init_scale=ones32, + affine=true, epsilon=1f-5, allow_fast_activation::Bool=true) +``` + +Instance Normalization. For details see [1]. + +Instance Normalization computes the mean and variance for each $D_1 \times ... \times D_{N - 2} \times 1 \times 1$` input slice and normalises the input accordingly. + +**Arguments** + + * `chs`: Size of the channel dimension in your data. Given an array with `N` dimensions, call the `N-1`th the channel dimension. For a batch of feature vectors this is just the data dimension, for `WHCN` images it's the usual channel dimension. + * `activation`: After normalization, elementwise activation `activation` is applied. + +**Keyword Arguments** + + * `epsilon`: a value added to the denominator for numerical stability + * `allow_fast_activation`: If `true`, then certain activations can be approximated with a faster version. The new activation function will be given by `NNlib.fast_act(activation)` + * If `affine=true`, it also applies a shift and a rescale to the input through to learnable per-channel bias and scale parameters. + + * `init_bias`: Controls how the `bias` is initiliazed + * `init_scale`: Controls how the `scale` is initiliazed + +**Inputs** + + * `x`: Array where `size(x, N - 1) = chs` and `ndims(x) > 2` + +**Returns** + + * `y`: Normalized Array + * Update model state + +**Parameters** + + * `affine=true` + + * `bias`: Bias of shape `(chs,)` + * `scale`: Scale of shape `(chs,)` + * `affine=false` - Empty `NamedTuple()` + +**States** + + * `training`: Used to check if training/inference mode + +Use `Lux.testmode` during inference. + +**Example** + +```julia +m = Chain(Dense(784 => 64), InstanceNorm(64, relu), Dense(64 => 10), InstanceNorm(10, 5)) +``` + +**References** + +[1] Ulyanov, Dmitry, Andrea Vedaldi, and Victor Lempitsky. "Instance normalization: The missing ingredient for fast stylization." arXiv preprint arXiv:1607.08022 (2016). + +:::warning + +InstanceNorm doesn't have CUDNN support. The GPU fallback is not very efficient. + +::: + +See also [`BatchNorm`](layers#Lux.BatchNorm), [`GroupNorm`](layers#Lux.GroupNorm), [`LayerNorm`](layers#Lux.LayerNorm), [`WeightNorm`](layers#Lux.WeightNorm) + + +source
+ +
+
+
+# Lux.LayerNorm — Type. + + + +```julia +LayerNorm(shape::NTuple{N, Int}, activation=identity; epsilon=1f-5, dims=Colon(), + affine::Bool=true, init_bias=zeros32, init_scale=ones32,) +``` + +Computes mean and standard deviation over the whole input array, and uses these to normalize the whole array. Optionally applies an elementwise affine transformation afterwards. + +Given an input array $x$, this layer computes + +$$ +y = \frac{x - \mathbb{E}[x]}{\sqrt{Var[x] + \epsilon}} * \gamma + \beta +$$ + +where $\gamma$ & $\beta$ are trainable parameters if `affine=true`. + +:::warning + +As of v0.5.0, the doc used to say `affine::Bool=false`, but the code actually had `affine::Bool=true` as the default. Now the doc reflects the code, so please check whether your assumptions about the default (if made) were invalid. + +::: + +**Arguments** + + * `shape`: Broadcastable shape of input array excluding the batch dimension. + * `activation`: After normalization, elementwise activation `activation` is applied. + +**Keyword Arguments** + + * `allow_fast_activation`: If `true`, then certain activations can be approximated with a faster version. The new activation function will be given by `NNlib.fast_act(activation)` + * `epsilon`: a value added to the denominator for numerical stability. + * `dims`: Dimensions to normalize the array over. + * If `affine=true`, it also applies a shift and a rescale to the input through to learnable per-channel bias and scale parameters. + + * `init_bias`: Controls how the `bias` is initiliazed + * `init_scale`: Controls how the `scale` is initiliazed + +**Inputs** + + * `x`: AbstractArray + +**Returns** + + * `y`: Normalized Array + * Empty NamedTuple() + +**Parameters** + + * `affine=false`: Empty `NamedTuple()` + * `affine=true` + + * `bias`: Bias of shape `(shape..., 1)` + * `scale`: Scale of shape `(shape..., 1)` + + +source
+ +
+
+
+# Lux.WeightNorm — Type. + + + +```julia +WeightNorm(layer::AbstractExplicitLayer, which_params::NTuple{N,Symbol}, + dims::Union{Tuple,Nothing}=nothing) +``` + +Applies [weight normalization](https://arxiv.org/abs/1602.07868) to a parameter in the given layer. + +$w = g\frac{v}{\|v\|}$ + +Weight normalization is a reparameterization that decouples the magnitude of a weight tensor from its direction. This updates the parameters in `which_params` (e.g. `weight`) using two parameters: one specifying the magnitude (e.g. `weight_g`) and one specifying the direction (e.g. `weight_v`). + +**Arguments** + + * `layer` whose parameters are being reparameterized + * `which_params`: parameter names for the parameters being reparameterized + * By default, a norm over the entire array is computed. Pass `dims` to modify the dimension. + +**Inputs** + + * `x`: Should be of valid type for input to `layer` + +**Returns** + + * Output from `layer` + * Updated model state of `layer` + +**Parameters** + + * `normalized`: Parameters of `layer` that are being normalized + * `unnormalized`: Parameters of `layer` that are not being normalized + +**States** + + * Same as that of `layer` + + +source
+ +
+
+ + + +## Upsampling + +
+# Lux.PixelShuffle — Function. + + + +```julia +PixelShuffle(r::Int) +``` + +Pixel shuffling layer with upscale factor `r`. Usually used for generating higher resolution images while upscaling them. + +See `NNlib.pixel_shuffle` for more details. + +PixelShuffle is not a Layer, rather it returns a [`WrappedFunction`](layers#Lux.WrappedFunction) with the function set to `Base.Fix2(pixel_shuffle, r)` + +**Arguments** + + * `r`: Upscale factor + +**Inputs** + + * `x`: For 4D-arrays representing N images, the operation converts input size(x) == (W, H, r^2 x C, N) to output of size (r x W, r x H, C, N). For D-dimensional data, it expects ndims(x) == D+2 with channel and batch dimensions, and divides the number of channels by r^D. + +**Returns** + + * Output of size `(r x W, r x H, C, N)` for 4D-arrays, and `(r x W, r x H, ..., C, N)` for D-dimensional data, where `D = ndims(x) - 2` + + +source
+ +
+
+
+# Lux.Upsample — Type. + + + +```julia +Upsample(mode = :nearest; [scale, size]) +Upsample(scale, mode = :nearest) +``` + +Upsampling Layer. + +**Layer Construction** + +**Option 1** + + * `mode`: Set to `:nearest`, `:linear`, `:bilinear` or `:trilinear` + +Exactly one of two keywords must be specified: + + * If `scale` is a number, this applies to all but the last two dimensions (channel and batch) of the input. It may also be a tuple, to control dimensions individually. + * Alternatively, keyword `size` accepts a tuple, to directly specify the leading dimensions of the output. + +**Option 2** + + * If `scale` is a number, this applies to all but the last two dimensions (channel and batch) of the input. It may also be a tuple, to control dimensions individually. + * `mode`: Set to `:nearest`, `:bilinear` or `:trilinear` + +Currently supported upsampling `mode`s and corresponding NNlib's methods are: + + * `:nearest` -> `NNlib.upsample_nearest` + * `:bilinear` -> `NNlib.upsample_bilinear` + * `:trilinear` -> `NNlib.upsample_trilinear` + +**Inputs** + + * `x`: For the input dimensions look into the documentation for the corresponding `NNlib` function + + * As a rule of thumb, `:nearest` should work with arrays of arbitrary dimensions + * `:bilinear` works with 4D Arrays + * `:trilinear` works with 5D Arrays + +**Returns** + + * Upsampled Input of size `size` or of size `(I_1 x scale[1], ..., I_N x scale[N], C, N)` + * Empty `NamedTuple()` + + +source
+ +
+
diff --git a/previews/PR467/api/Lux/utilities.md b/previews/PR467/api/Lux/utilities.md new file mode 100644 index 0000000000..f7fb088c5c --- /dev/null +++ b/previews/PR467/api/Lux/utilities.md @@ -0,0 +1,248 @@ + + + +# Utilities + + + + + + +## Index + +- [`Lux.cpu`](#Lux.cpu) +- [`Lux.disable_stacktrace_truncation!`](#Lux.disable_stacktrace_truncation!) +- [`Lux.f16`](#Lux.f16) +- [`Lux.f32`](#Lux.f32) +- [`Lux.f64`](#Lux.f64) +- [`Lux.foldl_init`](#Lux.foldl_init) +- [`Lux.gpu`](#Lux.gpu) +- [`Lux.istraining`](#Lux.istraining) +- [`Lux.multigate`](#Lux.multigate) +- [`Lux.replicate`](#Lux.replicate) + + + + +## Device Management / Data Transfer + +
+# Lux.cpu — Function. + + + +```julia +cpu(x) +``` + +Transfer `x` to CPU. + +::: warning + +This function has been deprecated. Use [`cpu_device`](../Accelerator_Support/LuxDeviceUtils#LuxDeviceUtils.cpu_device) instead. + +::: + + +source
+ +
+
+
+# Lux.gpu — Function. + + + +```julia +gpu(x) +``` + +Transfer `x` to GPU determined by the backend set using [`Lux.gpu_backend!`](../Accelerator_Support/LuxDeviceUtils#LuxDeviceUtils.gpu_backend!). + +:::warning + +This function has been deprecated. Use [`gpu_device`](../Accelerator_Support/LuxDeviceUtils#LuxDeviceUtils.gpu_device) instead. Using this function inside performance critical code will cause massive slowdowns due to type inference failure. + +::: + + +source
+ +
+
+ +:::warning + + +For detailed API documentation on Data Transfer check out the [LuxDeviceUtils.jl](../LuxDeviceUtils/) + + +::: + + + + +## Weight Initialization + + +:::warning + + +For API documentation on Initialization check out the [WeightInitializers.jl](../WeightInitializers/) + + +::: + + + + +## Miscellaneous Utilities + +
+# Lux.foldl_init — Function. + + + +```julia +foldl_init(op, x) +foldl_init(op, x, init) +``` + +Exactly same as `foldl(op, x; init)` in the forward pass. But, gives gradients wrt `init` in the backward pass. + + +source
+ +
+
+
+# Lux.istraining — Function. + + + +```julia +istraining(::Val{training}) +istraining(st::NamedTuple) +``` + +Returns `true` if `training` is `true` or if `st` contains a `training` field with value `true`. Else returns `false`. + +Method undefined if `st.training` is not of type `Val`. + + +source
+ +
+
+
+# Lux.multigate — Function. + + + +```julia +multigate(x::AbstractArray, ::Val{N}) +``` + +Split up `x` into `N` equally sized chunks (along dimension `1`). + + +source
+ +
+
+
+# Lux.replicate — Function. + + + +```julia +replicate(rng::AbstractRNG) +replicate(rng::CUDA.RNG) +``` + +Creates a copy of the `rng` state depending on its type. + + +source
+ +
+
+ + + +## Updating Floating Point Precision + + +By default, Lux uses Float32 for all parameters and states. To update the precision simply pass the parameters / states / arrays into one of the following functions. + +
+# Lux.f16 — Function. + + + +```julia +f16(m) +``` + +Converts the `eltype` of `m` *floating point* values to `Float16`. Recurses into structs marked with `Functors.@functor`. + + +source
+ +
+
+
+# Lux.f32 — Function. + + + +```julia +f32(m) +``` + +Converts the `eltype` of `m` *floating point* values to `Float32`. Recurses into structs marked with `Functors.@functor`. + + +source
+ +
+
+
+# Lux.f64 — Function. + + + +```julia +f64(m) +``` + +Converts the `eltype` of `m` *floating point* values to `Float64`. Recurses into structs marked with `Functors.@functor`. + + +source
+ +
+
+ + + +## Truncated Stacktraces + +
+# Lux.disable_stacktrace_truncation! — Function. + + + +```julia +disable_stacktrace_truncation!(; disable::Bool=true) +``` + +An easy way to update `TruncatedStacktraces.VERBOSE` without having to load it manually. + +Effectively does `TruncatedStacktraces.VERBOSE[] = disable` + + +source
+ +
+
diff --git a/previews/PR467/api/Testing_Functionality/LuxTestUtils.md b/previews/PR467/api/Testing_Functionality/LuxTestUtils.md new file mode 100644 index 0000000000..e978fcdd4e --- /dev/null +++ b/previews/PR467/api/Testing_Functionality/LuxTestUtils.md @@ -0,0 +1,141 @@ + + + + + +# LuxTestUtils + + +:::warning + + +This is a testing package. Hence, we don't use features like weak dependencies to reduce load times. It is recommended that you exclusively use this package for testing and not add a dependency to it in your main package Project.toml. + + +::: + + +Implements utilities for testing **gradient correctness** and **dynamic dispatch** of Lux.jl models. + + + + +## Index + +- [`LuxTestUtils.@jet`](#LuxTestUtils.@jet) +- [`LuxTestUtils.@test_gradients`](#LuxTestUtils.@test_gradients) + + + + +## Testing using JET.jl + +
+# LuxTestUtils.@jet — Macro. + + + +```julia +@jet f(args...) call_broken=false opt_broken=false +``` + +Run JET tests on the function `f` with the arguments `args...`. If `JET` fails to compile or julia version is < 1.7, then the macro will be a no-op. + +**Keyword Arguments** + + * `call_broken`: Marks the test_call as broken. + * `opt_broken`: Marks the test_opt as broken. + +All additional arguments will be forwarded to `@JET.test_call` and `@JET.test_opt`. + +:::tip + +Instead of specifying `target_modules` with every call, you can set preferences for `target_modules` using `Preferences.jl`. For example, to set `target_modules` to `(Lux, LuxLib)` we can run: + +```julia +using Preferences + +set_preferences!(Base.UUID("ac9de150-d08f-4546-94fb-7472b5760531"), + "target_modules" => ["Lux", "LuxLib"]) +``` + +::: + +**Example** + +```julia +using LuxTestUtils + +@testset "Showcase JET Testing" begin + @jet sum([1, 2, 3]) target_modules=(Base, Core) + + @jet sum(1, 1) target_modules=(Base, Core) opt_broken=true +end +``` + +
+
+ + + +## Gradient Correctness + +
+# LuxTestUtils.@test_gradients — Macro. + + + +```julia +@test_gradients f args... [kwargs...] +``` + +Compare the gradients computed by Zygote.jl (Reverse Mode AD) against: + + * Tracker.jl (Reverse Mode AD) + * ReverseDiff.jl (Reverse Mode AD) + * ForwardDiff.jl (Forward Mode AD) + * FiniteDifferences.jl (Finite Differences) + +:::tip + +This function is completely compatible with Test.jl + +::: + +**Arguments** + + * `f`: The function to test. + * `args...`: Inputs to `f` wrt which the gradients are computed. + +**Keyword Arguments** + + * `gpu_testing`: Disables ForwardDiff, ReverseDiff and FiniteDifferences tests. (Default: `false`) + * `soft_fail`: If `true`, the test will not fail if any of the gradients are incorrect, instead it will show up as broken. (Default: `false`) + * `skip_(tracker|reverse_diff|forward_diff|finite_differences)`: Skip the corresponding gradient computation and check. (Default: `false`) + * `large_arrays_skip_(forward_diff|finite_differences)`: Skip the corresponding gradient computation and check for large arrays. (Forward Mode and Finite Differences are not efficient for large arrays.) (Default: `true`) + * `large_array_length`: The length of the array above which the gradient computation is considered large. (Default: 25) + * `max_total_array_size`: Treat as large array if the total size of all arrays is greater than this value. (Default: 100) + * `(tracker|reverse_diff|forward_diff|finite_differences)_broken`: Mark the corresponding gradient test as broken. (Default: `false`) + +**Keyword Arguments for `check_approx`** + + * `atol`: Absolute tolerance for gradient comparisons. (Default: `0.0`) + * `rtol`: Relative tolerance for gradient comparisons. (Default: `atol > 0 ? 0.0 : √eps(typeof(atol))`) + * `nans`: Whether or not NaNs are considered equal. (Default: `false`) + +**Example** + +```julia +using LuxTestUtils + +x = randn(10) + +@testset "Showcase Gradient Testing" begin + @test_gradients sum abs2 x + + @test_gradients prod x +end +``` + +
+
diff --git a/previews/PR467/api/index.md b/previews/PR467/api/index.md new file mode 100644 index 0000000000..49d33d429a --- /dev/null +++ b/previews/PR467/api/index.md @@ -0,0 +1,76 @@ + + + +# API Reference + +- [LuxAMDGPU](Accelerator_Support/LuxAMDGPU#LuxAMDGPU) + - [Index](Accelerator_Support/LuxAMDGPU#Index) + - [API](Accelerator_Support/LuxAMDGPU#API) +- [LuxCUDA](Accelerator_Support/LuxCUDA#LuxCUDA) + - [Index](Accelerator_Support/LuxCUDA#Index) + - [API Reference](Accelerator_Support/LuxCUDA#API-Reference) +- [LuxDeviceUtils](Accelerator_Support/LuxDeviceUtils#LuxDeviceUtils) + - [Index](Accelerator_Support/LuxDeviceUtils#Index) + - [Preferences](Accelerator_Support/LuxDeviceUtils#Preferences) + - [Data Transfer](Accelerator_Support/LuxDeviceUtils#Data-Transfer) + - [Miscellaneous](Accelerator_Support/LuxDeviceUtils#Miscellaneous) +- [LuxCore](Building_Blocks/LuxCore#LuxCore) + - [Index](Building_Blocks/LuxCore#Index) + - [Abstract Types](Building_Blocks/LuxCore#Abstract-Types) + - [General](Building_Blocks/LuxCore#General) + - [Parameters](Building_Blocks/LuxCore#Parameters) + - [States](Building_Blocks/LuxCore#States) +- [LuxLib](Building_Blocks/LuxLib#LuxLib) + - [Index](Building_Blocks/LuxLib#Index) + - [Dropout](Building_Blocks/LuxLib#Dropout) + - [Normalization](Building_Blocks/LuxLib#Normalization) +- [WeightInitializers](Building_Blocks/WeightInitializers#WeightInitializers) + - [Index](Building_Blocks/WeightInitializers#Index) + - [API Reference](Building_Blocks/WeightInitializers#API-Reference) + - [Main Functions](Building_Blocks/WeightInitializers#Main-Functions) + - [Commonly Used Wrappers](Building_Blocks/WeightInitializers#Commonly-Used-Wrappers) +- [Boltz](Domain_Specific_Modeling/Boltz#Boltz) + - [Index](Domain_Specific_Modeling/Boltz#Index) +- [Computer Vision Models](Domain_Specific_Modeling/Boltz#Computer-Vision-Models) + - [Classification Models: Native Lux Models](Domain_Specific_Modeling/Boltz#Classification-Models:-Native-Lux-Models) + - [Building Blocks](Domain_Specific_Modeling/Boltz#Building-Blocks) + - [Non-Public API](Domain_Specific_Modeling/Boltz#Non-Public-API) + - [Classification Models: Imported from Metalhead.jl](Domain_Specific_Modeling/Boltz#Classification-Models:-Imported-from-Metalhead.jl) + - [Preprocessing](Domain_Specific_Modeling/Boltz#Preprocessing) +- [Experimental Features](Lux/contrib#Experimental-Features) + - [Index](Lux/contrib#Index) + - [Training](Lux/contrib#Training) + - [Parameter Freezing](Lux/contrib#Parameter-Freezing) + - [Map over Layer](Lux/contrib#Map-over-Layer) + - [Debugging Functionality](Lux/contrib#Debugging-Functionality) + - [Tied Parameters](Lux/contrib#Tied-Parameters) + - [Stateful Layer](Lux/contrib#Stateful-Layer) + - [Compact Layer API](Lux/contrib#Compact-Layer-API) +- [Flux Models to Lux Models](Lux/flux_to_lux#Flux-Models-to-Lux-Models) + - [Index](Lux/flux_to_lux#Index) + - [Functions](Lux/flux_to_lux#Functions) + - [Layers](Lux/flux_to_lux#Layers) +- [Built-In Layers](Lux/layers#Built-In-Layers) + - [Index](Lux/layers#Index) + - [Containers](Lux/layers#Containers) + - [Convolutional Layers](Lux/layers#Convolutional-Layers) + - [Dropout Layers](Lux/layers#Dropout-Layers) + - [Pooling Layers](Lux/layers#Pooling-Layers) + - [Recurrent Layers](Lux/layers#Recurrent-Layers) + - [Linear Layers](Lux/layers#Linear-Layers) + - [Misc. Helper Layers](Lux/layers#Misc.-Helper-Layers) + - [Normalization Layers](Lux/layers#Normalization-Layers) + - [Upsampling](Lux/layers#Upsampling) +- [Utilities](Lux/utilities#Utilities) + - [Index](Lux/utilities#Index) + - [Device Management / Data Transfer](Lux/utilities#Device-Management-/-Data-Transfer) + - [Weight Initialization](Lux/utilities#Weight-Initialization) + - [Miscellaneous Utilities](Lux/utilities#Miscellaneous-Utilities) + - [Updating Floating Point Precision](Lux/utilities#Updating-Floating-Point-Precision) + - [Truncated Stacktraces](Lux/utilities#Truncated-Stacktraces) +- [LuxTestUtils](Testing_Functionality/LuxTestUtils#LuxTestUtils) + - [Index](Testing_Functionality/LuxTestUtils#Index) + - [Testing using JET.jl](Testing_Functionality/LuxTestUtils#Testing-using-JET.jl) + - [Gradient Correctness](Testing_Functionality/LuxTestUtils#Gradient-Correctness) +- [API Reference](index#API-Reference) + diff --git a/previews/PR467/ecosystem.md b/previews/PR467/ecosystem.md new file mode 100644 index 0000000000..18a33d5cf6 --- /dev/null +++ b/previews/PR467/ecosystem.md @@ -0,0 +1,422 @@ +--- +layout: page +--- + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/previews/PR467/introduction/citation.md b/previews/PR467/introduction/citation.md new file mode 100644 index 0000000000..2a8af0df97 --- /dev/null +++ b/previews/PR467/introduction/citation.md @@ -0,0 +1,33 @@ + + + +# Citation + + +If you found this library to be useful in academic work, then please cite: + + +```bibtex +@software{pal2023lux, + author = {Pal, Avik}, + title = {{Lux: Explicit Parameterization of Deep Neural Networks in Julia}}, + month = {April}, + year = 2023, + note = {If you use this software, please cite it as below.}, + publisher = {Zenodo}, + version = {v0.5.0}, + doi = {10.5281/zenodo.7808904}, + url = {https://doi.org/10.5281/zenodo.7808904} +} +``` + + +```bibtex +@thesis{pal2023efficient, + title = {{On Efficient Training \& Inference of Neural Differential Equations}}, + author = {Pal, Avik}, + year = {2023}, + school = {Massachusetts Institute of Technology} +} +``` + diff --git a/previews/PR467/introduction/index.md b/previews/PR467/introduction/index.md new file mode 100644 index 0000000000..27ea05be82 --- /dev/null +++ b/previews/PR467/introduction/index.md @@ -0,0 +1,240 @@ + + + +# Getting Started + + + + +## Installation + + +Install [Julia v1.6 or above](https://julialang.org/downloads/). Lux.jl is available through the Julia package manager. You can enter it by pressing `]` in the REPL and then typing + + +```julia +pkg> add Lux +``` + + +Alternatively, you can also do + + +```julia +import Pkg; Pkg.add("Lux") +``` + + +:::tip + + +The Julia Compiler is always improving. As such, we recommend using the latest stable version of Julia instead of the LTS. + + +::: + + + + +## Quickstart + + +:::tip PRE-REQUISITES + + +You need to install `Optimisers` and `Zygote` if not done already. `Pkg.add(["Optimisers", "Zygote"])` + + +::: + + +```julia +using Lux, Random, Optimisers, Zygote +# using LuxCUDA, LuxAMDGPU, Metal # Optional packages for GPU support +``` + + +We take randomness very seriously + + +```julia +# Seeding +rng = Random.default_rng() +Random.seed!(rng, 0) +``` + + +``` +Random.TaskLocalRNG() +``` + + +Build the model + + +```julia +# Construct the layer +model = Chain(Dense(128, 256, tanh), Chain(Dense(256, 1, tanh), Dense(1, 10))) +``` + + +``` +Chain( + layer_1 = Dense(128 => 256, tanh_fast), # 33_024 parameters + layer_2 = Dense(256 => 1, tanh_fast), # 257 parameters + layer_3 = Dense(1 => 10), # 20 parameters +) # Total: 33_301 parameters, + # plus 0 states. +``` + + +Models don't hold parameters and states so initialize them. From there on, we just use our standard AD and Optimisers API. + + +```julia +# Get the device determined by Lux +device = gpu_device() + +# Parameter and State Variables +ps, st = Lux.setup(rng, model) .|> device + +# Dummy Input +x = rand(rng, Float32, 128, 2) |> device + +# Run the model +y, st = Lux.apply(model, x, ps, st) + +# Gradients +## Pullback API to capture change in state +(l, st_), pb = pullback(p -> Lux.apply(model, x, p, st), ps) +gs = pb((one.(l), nothing))[1] + +# Optimization +st_opt = Optimisers.setup(Adam(0.0001f0), ps) +st_opt, ps = Optimisers.update(st_opt, ps, gs) +``` + + +``` +((layer_1 = (weight = Leaf(Adam(0.0001, (0.9, 0.999), 1.0e-8), (Float32[0.00313608 0.00806096 … 0.00476192 0.00732118; -0.00447309 -0.0119719 … -0.00822211 -0.0110335; … ; -0.00294453 -0.00749935 … -0.00426221 -0.00678769; 0.000750543 0.00195163 … 0.00120731 0.00178011], Float32[9.83485f-7 6.49782f-6 … 2.26756f-6 5.3599f-6; 2.00083f-6 1.43324f-5 … 6.76022f-6 1.21738f-5; … ; 8.67016f-7 5.62395f-6 … 1.81662f-6 4.60721f-6; 5.63307f-8 3.80882f-7 … 1.45758f-7 3.16876f-7], (0.81, 0.998001))), bias = Leaf(Adam(0.0001, (0.9, 0.999), 1.0e-8), (Float32[0.00954525; -0.0146331; … ; -0.00881351; 0.00233261;;], Float32[9.11106f-6; 2.14125f-5; … ; 7.76769f-6; 5.44098f-7;;], (0.81, 0.998001)))), layer_2 = (weight = Leaf(Adam(0.0001, (0.9, 0.999), 1.0e-8), (Float32[-0.0104967 0.0714637 … -0.0224641 0.108277], Float32[1.10179f-5 0.000510699 … 5.04628f-5 0.00117238], (0.81, 0.998001))), bias = Leaf(Adam(0.0001, (0.9, 0.999), 1.0e-8), (Float32[0.178909;;], Float32[0.0032008;;], (0.81, 0.998001)))), layer_3 = (weight = Leaf(Adam(0.0001, (0.9, 0.999), 1.0e-8), (Float32[-0.105128; -0.105128; … ; -0.105128; -0.105128;;], Float32[0.00110518; 0.00110518; … ; 0.00110518; 0.00110518;;], (0.81, 0.998001))), bias = Leaf(Adam(0.0001, (0.9, 0.999), 1.0e-8), (Float32[0.2; 0.2; … ; 0.2; 0.2;;], Float32[0.00399995; 0.00399995; … ; 0.00399995; 0.00399995;;], (0.81, 0.998001))))), (layer_1 = (weight = Float32[-0.11044693 0.10963185 … 0.097855344 -0.009167461; -0.0110904 0.07588978 … -0.03180492 0.088967875; … ; 0.01864451 -0.034903362 … -0.016194405 0.019176451; -0.09216565 -0.047490627 … -0.08869007 0.009417342], bias = Float32[-9.999999f-5; 9.999998f-5; … ; 9.999999f-5; -9.9999954f-5;;]), layer_2 = (weight = Float32[0.05391791 -0.103956826 … -0.050862882 0.020512676], bias = Float32[-0.0001;;]), layer_3 = (weight = Float32[-0.6546853; 0.6101978; … ; 0.41120994; 0.5494141;;], bias = Float32[-0.0001; -0.0001; … ; -0.0001; -0.0001;;]))) +``` + + + + +## Defining Custom Layers + + +```julia +using Lux, Random, Optimisers, Zygote +# using LuxCUDA, LuxAMDGPU, Metal # Optional packages for GPU support +import Lux.Experimental: @compact +``` + + +We will define a custom MLP using the `@compact` macro. The macro takes in a list of parameters, layers and states, and a function defining the forward pass of the neural network. + + +```julia +n_in = 1 +n_out = 1 +nlayers = 3 + +model = @compact(w1=Dense(n_in, 128), + w2=[Dense(128, 128) for i in 1:nlayers], + w3=Dense(128, n_out), + act=relu) do x + embed = act(w1(x)) + for w in w2 + embed = act(w(embed)) + end + out = w3(embed) + return out +end +``` + + +``` +@compact( + w1 = Dense(1 => 128), # 256 parameters + w2 = NamedTuple( + 1 = Dense(128 => 128), # 16_512 parameters + 2 = Dense(128 => 128), # 16_512 parameters + 3 = Dense(128 => 128), # 16_512 parameters + ), + w3 = Dense(128 => 1), # 129 parameters + act = relu, +) do x + embed = act(w1(x)) + for w = w2 + embed = act(w(embed)) + end + out = w3(embed) + return out +end # Total: 49_921 parameters, + # plus 1 states. +``` + + +We can initialize the model and train it with the same code as before! + + +```julia +ps, st = Lux.setup(Xoshiro(0), model) + +model(randn(n_in, 32), ps, st) # 1×32 Matrix as output. + +x_data = collect(-2.0f0:0.1f0:2.0f0)' +y_data = 2 .* x_data .- x_data .^ 3 +st_opt = Optimisers.setup(Adam(), ps) + +for epoch in 1:1000 + global st # Put this in a function in real use-cases + (loss, st), pb = Zygote.pullback(ps) do p + y, st_ = model(x_data, p, st) + return sum(abs2, y .- y_data), st_ + end + gs = only(pb((one(loss), nothing))) + epoch % 100 == 1 && println("Epoch: $(epoch) | Loss: $(loss)") + Optimisers.update!(st_opt, ps, gs) +end +``` + + +``` +Epoch: 1 | Loss: 84.32512 +Epoch: 101 | Loss: 0.08861052 +Epoch: 201 | Loss: 0.007037298 +Epoch: 301 | Loss: 0.005391656 +Epoch: 401 | Loss: 0.014058021 +Epoch: 501 | Loss: 0.0022117028 +Epoch: 601 | Loss: 0.0015865607 +Epoch: 701 | Loss: 0.21984956 +Epoch: 801 | Loss: 0.00019668281 +Epoch: 901 | Loss: 0.0018975141 +``` + + + + +## Additional Packages + + +`LuxDL` hosts various packages that provide additional functionality for Lux.jl. All packages mentioned in this documentation are available via the Julia General Registry. + + +You can install all those packages via `import Pkg; Pkg.add()`. + + + + +## GPU Support + + +GPU Support for Lux.jl requires loading additional packages: + + + * [`LuxCUDA.jl`](https://github.com/LuxDL/LuxCUDA.jl) for CUDA support. + * [`LuxAMDGPU.jl`](https://github.com/LuxDL/LuxAMDGPU.jl) for AMDGPU support. + * [`Metal.jl`](https://github.com/JuliaGPU/Metal.jl) for Apple Metal support. + diff --git a/previews/PR467/introduction/overview.md b/previews/PR467/introduction/overview.md new file mode 100644 index 0000000000..e8d92dbeb3 --- /dev/null +++ b/previews/PR467/introduction/overview.md @@ -0,0 +1,41 @@ + + + +# Why we wrote Lux? + + +Julia already has quite a few well established Neural Network Frameworks – [Flux](https://fluxml.ai/) & [KNet](https://denizyuret.github.io/Knet.jl/latest/). However, certain design elements – **Coupled Model and Parameters** & **Internal Mutations** – associated with these frameworks make them less compiler and user friendly. Making changes to address these problems in the respective frameworks would be too disruptive for users. Here comes in `Lux`: a neural network framework built completely using pure functions to make it both compiler and autodiff friendly. + + + + +## Design Principles + + + * **Layers must be immutable** – cannot store any parameter/state but rather store the information to construct them + * **Layers are pure functions** + * **Layers return a Tuple containing the result and the updated state** + * **Given same inputs the outputs must be same** – yes this must hold true even for stochastic functions. Randomness must be controlled using `rng`s passed in the state. + * **Easily extensible** + + + + +## Why use Lux over Flux? + + + * **Neural Networks for SciML**: For SciML Applications (Neural ODEs, Deep Equilibrium Models) solvers typically expect a monolithic parameter vector. Flux enables this via its `destructure` mechanism, but `destructure` comes with various [edge cases and limitations](https://fluxml.ai/Optimisers.jl/dev/api/#Optimisers.destructure). Lux forces users to make an explicit distinction between state variables and parameter variables to avoid these issues. Also, it comes battery-included for distributed training using [FluxMPI.jl](https://github.com/avik-pal/FluxMPI.jl) *(I know :P the naming)* + * **Sensible display of Custom Layers** – Ever wanted to see Pytorch like Network printouts or wondered how to extend the pretty printing of Flux's layers? Lux handles all of that by default. + * **Truly immutable models** - No *unexpected internal mutations* since all layers are implemented as pure functions. All layers are also *deterministic* given the parameters and state: if a layer is supposed to be stochastic (say `Dropout`), the state must contain a seed which is then updated after the function call. + * **Easy Parameter Manipulation** – By separating parameter data and layer structures, Lux makes implementing `WeightNorm`, `SpectralNorm`, etc. downright trivial. Without this separation, it is much harder to pass such parameters around without mutations which AD systems don't like. + + + + +## Why not use Lux? + + + * **Small Neural Networks on CPU** – Lux is developed for training large neural networks. For smaller architectures, we recommend using [SimpleChains.jl](https://github.com/PumasAI/SimpleChains.jl). + * **Lux won't magically speed up your code (yet)** – Lux shares the same backend with Flux and so if your primary desire to shift is driven by performance, you will be disappointed. + * **XLA Support** – Lux doesn't compile to XLA which means no TPU support unfortunately. + diff --git a/previews/PR467/introduction/resources.md b/previews/PR467/introduction/resources.md new file mode 100644 index 0000000000..e202904e59 --- /dev/null +++ b/previews/PR467/introduction/resources.md @@ -0,0 +1,19 @@ + + + +# Resources to Get Started + + + * Go through the [Quickstart Example](index). + * Read the introductory tutorials on [Julia](https://jump.dev/JuMP.jl/stable/tutorials/getting_started/getting_started_with_julia/#Getting-started-with-Julia) and [Lux](../tutorials/). + * Go through the examples sorted based on their complexity in the documentation. + + +:::warning HAVE MORE QUESTIONS? + + +For usage related questions, please use [Github Discussions](https://github.com/avik-pal/Lux.jl/discussions) or [JuliaLang Discourse (machine learning domain)](https://discourse.julialang.org/c/domain/ml/) which allows questions and answers to be indexed. To report bugs use [github issues](https://github.com/LuxDL/Lux.jl/issues) or even better send in a [pull request](https://github.com/LuxDL/Lux.jl/pulls). + + +::: + diff --git a/previews/PR467/manual/debugging.md b/previews/PR467/manual/debugging.md new file mode 100644 index 0000000000..955e3d0f2d --- /dev/null +++ b/previews/PR467/manual/debugging.md @@ -0,0 +1,339 @@ + + + +# Debugging Lux Models + + +Debugging DNNs can be very painful. Especially with the gigantic stacktraces for Lux, it is even harder to pin-point to which particular layer errored out. This page describes some useful tools that ship with Lux, that can help you debug your models. + + +:::tip TL;DR + + +Simply wrap your model with `Lux.Experimental.@debug`!! + + +::: + + +:::warning DON'T FORGET + + +Remember to use the non Debug mode model after you finish debugging. Debug mode models are way slower. + + +::: + + +Let us construct a model which has an obviously incorrect dimension. In this example, you will see how easy it is to pin-point the problematic layer. + + + + +## Incorrect Model Specification: Dimension Mismatch Problems + + +```julia +using Lux, Random + +model = Chain(Dense(1 => 16, relu), Chain(Dense(16 => 3), Dense(1 => 1)), + BatchNorm(1); disable_optimizations=true) + +model_debug = Lux.Experimental.@debug_mode model +``` + + +``` +Chain( + layer_1 = DebugLayer( + layer = Dense(1 => 16, relu), # 32 parameters + ), + layer_2 = Chain( + layer_1 = DebugLayer( + layer = Dense(16 => 3), # 51 parameters + ), + layer_2 = DebugLayer( + layer = Dense(1 => 1), # 2 parameters + ), + ), + layer_3 = DebugLayer( + layer = BatchNorm(1, affine=true, track_stats=true), # 2 parameters, plus 3 + ), +) # Total: 87 parameters, + # plus 3 states. +``` + + +Note that we can use the parameters and states for `model` itself in `model_debug`, no need to make any changes. If you ran the original model this is the kind of error you would see: + + +```julia +rng = Xoshiro(0) + +ps, st = Lux.setup(rng, model) +x = randn(rng, Float32, 1, 1) + +try + model(x, ps, st) +catch e + println(e) +end +``` + + +``` +DimensionMismatch("A has dimensions (1,1) but B has dimensions (3,1)") +``` + + +Ofcourse, this error will come with a detailed stacktrace, but it is still not very useful. Now let's try using the debug mode model: + + +```julia +try + model_debug(x, ps, st) +catch e + println(e) +end +``` + + +``` +[ Info: Input Type: Matrix{Float32} | Input Structure: (1, 1) +[ Info: Running Layer: Dense(1 => 16, relu) at location model.layers.layer_1! +[ Info: Output Type: Matrix{Float32} | Output Structure: (16, 1) +[ Info: Input Type: Matrix{Float32} | Input Structure: (16, 1) +[ Info: Running Layer: Dense(16 => 3) at location model.layers.layer_2.layers.layer_1! +[ Info: Output Type: Matrix{Float32} | Output Structure: (3, 1) +[ Info: Input Type: Matrix{Float32} | Input Structure: (3, 1) +[ Info: Running Layer: Dense(1 => 1) at location model.layers.layer_2.layers.layer_2! +┌ Error: Layer Dense(1 => 1) failed!! This layer is present at location model.layers.layer_2.layers.layer_2 +└ @ Lux.Experimental /var/lib/buildkite-agent/builds/gpuci-11/julialang/lux-dot-jl/src/contrib/debug.jl:113 +DimensionMismatch("A has dimensions (1,1) but B has dimensions (3,1)") +``` + + +See now we know that `model.layers.layer_2.layers.layer_2` is the problematic layer. Let us fix that layer and see what happens: + + +```julia +model = Chain(Dense(1 => 16, relu), + Chain(Dense(16 => 3), // [!code --] + Chain(Dense(16 => 1), // [!code ++] + Dense(1 => 1)), + BatchNorm(1); disable_optimizations=true) +``` + + +```julia +model_fixed = Chain(Dense(1 => 16, relu), Chain(Dense(16 => 1), Dense(1 => 1)), + BatchNorm(1); disable_optimizations=true) + +ps, st = Lux.setup(rng, model_fixed) + +model_fixed(x, ps, st) +``` + + +``` +(Float32[0.0;;], (layer_1 = NamedTuple(), layer_2 = (layer_1 = NamedTuple(), layer_2 = NamedTuple()), layer_3 = (running_mean = Float32[-0.01397949], running_var = Float32[NaN], training = Val{true}()))) +``` + + +Voila!! We have tracked down and fixed the problem. + + + + +## Tracking down NaNs + + +Have you encountered those pesky little NaNs in your training? They are very hard to track down. We will create an artificially simulate NaNs in our model and see how we can track the offending layer. + + +We can set `nan_check` to `:forward`, `:backward` or `:both` to check for NaNs in the debug model. (or even disable it by setting it to `:none`) + + +```julia +model = Chain(Dense(1 => 16, relu), Chain(Dense(16 => 1), Dense(1 => 1)), + BatchNorm(1); disable_optimizations=true) + +ps, st = Lux.setup(rng, model) + +model_debug = Lux.Experimental.@debug_mode model nan_check=:both +``` + + +``` +Chain( + layer_1 = DebugLayer( + layer = Dense(1 => 16, relu), # 32 parameters + ), + layer_2 = Chain( + layer_1 = DebugLayer( + layer = Dense(16 => 1), # 17 parameters + ), + layer_2 = DebugLayer( + layer = Dense(1 => 1), # 2 parameters + ), + ), + layer_3 = DebugLayer( + layer = BatchNorm(1, affine=true, track_stats=true), # 2 parameters, plus 3 + ), +) # Total: 53 parameters, + # plus 3 states. +``` + + +Let us set a value in the parameter to `NaN`: + + +```julia +ps.layer_2.layer_2.weight[1, 1] = NaN +``` + + +``` +NaN +``` + + +Now let us run the model + + +```julia +model(x, ps, st) +``` + + +``` +(Float32[NaN;;], (layer_1 = NamedTuple(), layer_2 = (layer_1 = NamedTuple(), layer_2 = NamedTuple()), layer_3 = (running_mean = Float32[NaN], running_var = Float32[NaN], training = Val{true}()))) +``` + + +Ah as expected our output is `NaN`. But is is not very clear how to track where the first `NaN` occurred. Let's run the debug model and check: + + +```julia +try + model_debug(x, ps, st) +catch e + println(e) +end +``` + + +``` +[ Info: Input Type: Matrix{Float32} | Input Structure: (1, 1) +[ Info: Running Layer: Dense(1 => 16, relu) at location model.layers.layer_1! +[ Info: Output Type: Matrix{Float32} | Output Structure: (16, 1) +[ Info: Input Type: Matrix{Float32} | Input Structure: (16, 1) +[ Info: Running Layer: Dense(16 => 1) at location model.layers.layer_2.layers.layer_1! +[ Info: Output Type: Matrix{Float32} | Output Structure: (1, 1) +[ Info: Input Type: Matrix{Float32} | Input Structure: (1, 1) +[ Info: Running Layer: Dense(1 => 1) at location model.layers.layer_2.layers.layer_2! +DomainError((weight = Float32[NaN;;], bias = Float32[0.0;;]), "NaNs detected in parameters of layer Dense(1 => 1) at location model.layers.layer_2.layers.layer_2") +``` + + +And we have figured it out! The first `NaN` occurred in the parameters of `model.layers.layer_2.layers.layer_2`! But what if NaN occurs in the reverse pass! Let us define a custom layer and introduce a fake NaN in the backward pass. + + +```julia +using ChainRulesCore, Zygote + +const CRC = ChainRulesCore + +offending_layer(x) = 2 .* x +``` + + +``` +offending_layer (generic function with 1 method) +``` + + +```julia +model = Chain(Dense(1 => 16, relu), Chain(Dense(16 => 1), offending_layer), + BatchNorm(1); disable_optimizations=true) + +ps, st = Lux.setup(rng, model) + +model(x, ps, st) +``` + + +``` +(Float32[0.0;;], (layer_1 = NamedTuple(), layer_2 = (layer_1 = NamedTuple(), layer_2 = NamedTuple()), layer_3 = (running_mean = Float32[-0.092828535], running_var = Float32[NaN], training = Val{true}()))) +``` + + +Let us define a custom backward pass to introduce some NaNs: + + +```julia +function CRC.rrule(::typeof(offending_layer), x) + y = offending_layer(x) + function ∇offending_layer(Δ) + Δ[1] = NaN + return NoTangent(), Δ + end + return y, ∇offending_layer +end +``` + + +Let us compute the gradient of the layer now: + + +```julia +Zygote.gradient(ps -> sum(first(model(x, ps, st))), ps) +``` + + +``` +((layer_1 = (weight = Float32[0.0; NaN; … ; NaN; 0.0;;], bias = Float32[0.0; NaN; … ; NaN; 0.0;;]), layer_2 = (layer_1 = (weight = Float32[NaN NaN … NaN NaN], bias = Float32[NaN;;]), layer_2 = nothing), layer_3 = (scale = Float32[0.0], bias = Fill(1.0f0, 1))),) +``` + + +Oh no!! A `NaN` is present in the gradient of `ps`. Let us run the debug model and see where the `NaN` occurred: + + +```julia +model_debug = Lux.Experimental.@debug_mode model nan_check=:both + +try + Zygote.gradient(ps -> sum(first(model_debug(x, ps, st))), ps) +catch e + println(e) +end +``` + + +``` +[ Info: Input Type: Matrix{Float32} | Input Structure: (1, 1) +[ Info: Running Layer: Dense(1 => 16, relu) at location model.layers.layer_1! +[ Info: Output Type: Matrix{Float32} | Output Structure: (16, 1) +[ Info: Input Type: Matrix{Float32} | Input Structure: (16, 1) +[ Info: Running Layer: Dense(16 => 1) at location model.layers.layer_2.layers.layer_1! +[ Info: Output Type: Matrix{Float32} | Output Structure: (1, 1) +[ Info: Input Type: Matrix{Float32} | Input Structure: (1, 1) +[ Info: Running Layer: WrappedFunction(offending_layer) at location model.layers.layer_2.layers.layer_2! +[ Info: Output Type: Matrix{Float32} | Output Structure: (1, 1) +[ Info: Input Type: Matrix{Float32} | Input Structure: (1, 1) +[ Info: Running Layer: BatchNorm(1, affine=true, track_stats=true) at location model.layers.layer_3! +[ Info: Output Type: Matrix{Float32} | Output Structure: (1, 1) +DomainError(Float32[NaN;;], "NaNs detected in pullback output for WrappedFunction(offending_layer) at location model.layers.layer_2.layers.layer_2!") +``` + + +And there you go our debug layer prints that the problem is in `WrappedFunction(offending_layer) at location model.layers.layer_2.layers.layer_2`! Once we fix the pullback of the layer, we will fix the NaNs. + + + + +## Conclusion + + +In this manual section, we have discussed tracking down errors in Lux models. We have covered tracking incorrect model specifications and NaNs in forward and backward passes. However, remember that this is an **Experimental** feature, and there might be edge cases that don't work correctly. If you find any such cases, please open an issue on GitHub! + diff --git a/previews/PR467/manual/dispatch_custom_input.md b/previews/PR467/manual/dispatch_custom_input.md new file mode 100644 index 0000000000..9195e98b5c --- /dev/null +++ b/previews/PR467/manual/dispatch_custom_input.md @@ -0,0 +1,162 @@ + + + +# Dispatching on Custom Input Types + + + + +## Which function should participate in dispatch? + + + * Defining a dispatch on `(::Layer)(x::MyInputType, ps, st::NamedTuple)` is inconvenient, since it requires the user to define a new method for every layer type. + * `(::AbstractExplicitLayer)(x::MyInputType, ps, st::NamedTuple)` doesn't work. + * Instead, we need to define the dispatch on `Lux.apply(::AbstractExplicitLayer, x::MyInputType, ps, st::NamedTuple)`. + + + + +## Concrete Example + + +Consider [Neural ODEs](https://implicit-layers-tutorial.org/neural_odes/). In these models, often time we want to every iteration of the neural network to take the current time as input. Here, we won't go through implementing an entire Neural ODE model. Instead we will define a time dependent version of [`Chain`](../api/Lux/layers#Lux.Chain). + + + + +### Time-Dependent Chain Implementation + + +```julia +using Lux, Random + +struct TDChain{L <: NamedTuple} <: Lux.AbstractExplicitContainerLayer{(:layers,)} + layers::L +end + +function (l::TDChain)((x, t)::Tuple, ps, st::NamedTuple) + # Concatenate along the 2nd last dimension + sz = ntuple(i -> i == ndims(x) - 1 ? 1 : size(x, i), ndims(x)) + t_ = ones(eltype(x), sz) .* t # Needs to be modified for GPU + for name in keys(l.layers) + x, st_ = Lux.apply(getfield(l.layers, name), cat(x, t_; dims=ndims(x) - 1), + getfield(ps, name), getfield(st, name)) + st = merge(st, NamedTuple{(name,)}((st_,))) + end + return x, st +end + +model = Chain(Dense(3, 4), TDChain((; d1=Dense(5, 4), d2=Dense(5, 4))), Dense(4, 1)) +``` + + +``` +Chain( + layer_1 = Dense(3 => 4), # 16 parameters + layer_2 = TDChain( + layers = NamedTuple( + d1 = Dense(5 => 4), # 24 parameters + d2 = Dense(5 => 4), # 24 parameters + ), + ), + layer_3 = Dense(4 => 1), # 5 parameters +) # Total: 69 parameters, + # plus 0 states. +``` + + + + +### Running the TDChain + + +```julia +rng = MersenneTwister(0) +ps, st = Lux.setup(rng, model) +x = randn(rng, Float32, 3, 2) + +try + model(x, ps, st) +catch e + Base.showerror(stdout, e) +end +``` + + +``` +MethodError: no method matching (::Main.TDChain{NamedTuple{(:d1, :d2), Tuple{Dense{true, typeof(identity), typeof(glorot_uniform), typeof(zeros32)}, Dense{true, typeof(identity), typeof(glorot_uniform), typeof(zeros32)}}}})(::Matrix{Float32}, ::NamedTuple{(:d1, :d2), Tuple{NamedTuple{(:weight, :bias), Tuple{Matrix{Float32}, Matrix{Float32}}}, NamedTuple{(:weight, :bias), Tuple{Matrix{Float32}, Matrix{Float32}}}}}, ::NamedTuple{(:d1, :d2), Tuple{NamedTuple{(), Tuple{}}, NamedTuple{(), Tuple{}}}}) + +Closest candidates are: + (::Main.TDChain)(!Matched::Tuple, ::Any, ::NamedTuple) + @ Main dispatch_custom_input.md:29 +``` + + + + +### Writing the Correct Dispatch Rules + + + * Create a Custom Layer storing the time. + + +```julia +struct ArrayAndTime{A <: AbstractArray, T <: Real} + array::A + time::T +end +``` + + + * Define the dispatch on `Lux.apply(::AbstractExplicitLayer, x::ArrayAndTime, ps, st::NamedTuple)`. + + +```julia +function Lux.apply(layer::Lux.AbstractExplicitLayer, x::ArrayAndTime, ps, st::NamedTuple) + y, st = layer(x.array, ps, st) + return ArrayAndTime(y, x.time), st +end + +function Lux.apply(layer::TDChain, x::ArrayAndTime, ps, st::NamedTuple) + y, st = layer((x.array, x.time), ps, st) + return ArrayAndTime(y, x.time), st +end +``` + + + * Run the model. + + +```julia +xt = ArrayAndTime(x, 10.0f0) + +model(xt, ps, st)[1] +``` + + +``` +Main.ArrayAndTime{Matrix{Float32}, Float32}(Float32[4.8016562 5.174927], 10.0f0) +``` + + + + +### Using the Same Input for Non-TD Models + + +Writing proper dispatch means we can simply replace the `TDChain` with a `Chain` (of course with dimension corrections) and the pipeline still works. + + +```julia +model = Chain(Dense(3, 4), Chain((; d1=Dense(4, 4), d2=Dense(4, 4))), Dense(4, 1)) + +ps, st = Lux.setup(rng, model) + +model(xt, ps, st)[1] +``` + + +``` +Main.ArrayAndTime{Matrix{Float32}, Float32}(Float32[-0.08124366 -1.1121564], 10.0f0) +``` + diff --git a/previews/PR467/manual/freezing_model_parameters.md b/previews/PR467/manual/freezing_model_parameters.md new file mode 100644 index 0000000000..4b13f7121f --- /dev/null +++ b/previews/PR467/manual/freezing_model_parameters.md @@ -0,0 +1,163 @@ + + + +# Freezing Model Parameters + + +::: warning + + +API for freezing parameters should be considered experimental at this point. + + +::: + + +In this manual entry, we will go over how to freeze certain parameters in a model. + + + + +## Freezing Layers of a Particular Kind + + +To freeze a particular kind of layer, let's say [`Dense`](../api/Lux/layers#Lux.Dense) in the following example. We can use [`Lux.Experimental.@layer_map`](../api/Lux/contrib#Lux.Experimental.@layer_map) and freeze layers if they are of type `Dense`. + + +```julia +using Lux, Random + +rng = Random.default_rng() +Random.seed!(rng, 0) + +model = Chain(Dense(3, 4), Chain(Dense(4, 4), Dropout(0.5f0), BatchNorm(4)), + Dense(4, 1); disable_optimizations=true) + +ps, st = Lux.setup(rng, model) + +x = randn(rng, Float32, 3, 2) + +model(x, ps, st) + +function freeze_dense(d::Lux.Dense, ps, st, ::String) + return Lux.freeze(d, ps, st, (:weight, :bias)) +end +freeze_dense(l, ps, st, name) = (l, ps, st) + +model_frozen, ps_frozen, st_frozen = Lux.Experimental.@layer_map freeze_dense model ps st + +model_frozen(x, ps_frozen, st_frozen) +``` + + +``` +(Float32[1.7641534 -1.7641534], (layer_1 = (frozen_params = (weight = Float32[-0.026350189 -0.5554656 -0.35653266; -0.17461072 0.6705545 0.29924855; -0.8935247 -0.42453378 -0.3020351; -0.7988979 -0.7666331 -0.7104237], bias = Float32[0.0; 0.0; 0.0; 0.0;;]), states = NamedTuple()), layer_2 = (layer_1 = (frozen_params = (weight = Float32[-0.47289538 -0.680748 0.1764085 0.34383082; 0.42747158 -0.13819042 -0.109261915 -0.6143286; -0.35790488 -0.20881107 0.70390546 0.48137343; 0.82561636 0.38187847 0.05779423 -0.35181466], bias = Float32[0.0; 0.0; 0.0; 0.0;;]), states = NamedTuple()), layer_2 = (rng = Random.Xoshiro(0x87711e5ce1a49ffe, 0xa210b60ecab6b8c5, 0x436c749552fc8172, 0x03e9c7d813a9f096), training = Val{true}()), layer_3 = (running_mean = Float32[-0.04517859, 0.03484953, -0.004917746, 0.0074841487], running_var = Float32[0.94082206, 0.92428976, 0.90048367, 0.90112025], training = Val{true}())), layer_3 = (frozen_params = (weight = Float32[0.3981135 0.45468387 -0.07694905 0.8353388], bias = Float32[0.0;;]), states = NamedTuple()))) +``` + + + + +## Freezing by Layer Name + + +When the function in `layer_map` is called, the 4th argument is the name of the layer. For example, if you want to freeze the 1st layer inside the inner Chain. The name for this would be `.layer_2.layer_1`. + + +:::code-group + + +```julia [Freezing by Layer Name] + +function freeze_by_name(d, ps, st, name::String) + if name == "model.layer_2.layer_1" + return Lux.Experimental.freeze(d, ps, st, (:weight, :bias)) + else + return d, ps, st + end +end + +``` + + +```julia [Freezing by Layer Type] + +function freeze_dense(d::Dense, ps, st, ::String) + return Lux.Experimental.freeze(d, ps, st, (:weight, :bias)) +end +freeze_dense(l, ps, st, _) = (l, ps, st) + +``` + + +::: + + + + +## Freezing Part of the Parameters + + +Instead of freezing all the parameters, we can simply specify `(:weight,)` to freeze only the `weight` parameter while training the `bias` parameter. + + +::: code-group + + +```julia [Freezing Some Parameters of a Layer] + +function freeze_by_name(d, ps, st, name::String) + if name == "model.layer_2.layer_1" + return Lux.freeze(d, ps, st, (:weight,)) + else + return d, ps, st + end +end + +``` + + +```julia [Freezing All Parameters of a Layer] + +function freeze_by_name(d, ps, st, name::String) + if name == "model.layer_2.layer_1" + return Lux.freeze(d, ps, st, (:weight, :bias)) + else + return d, ps, st + end +end + +``` + + +::: + + + + +## Freezing Part of a Chain + + +Starting `v0.4.22`, we can directly index into a `Chain`. So freezing a part of a `Chain`, is extremely easy. + + +```julia +using Lux, Random + +rng = Random.default_rng() +Random.seed!(rng, 0) + +model = Chain(Dense(3, 4), Dense(4, 4), Dropout(0.5f0), BatchNorm(4), Dense(4, 1)) + +model_frozen = Chain(model[1:2], Lux.freeze(model[3:4]), model[5]) +ps, st = Lux.setup(rng, model_frozen) + +x = randn(rng, Float32, 3, 2) + +model_frozen(x, ps, st) +``` + + +``` +(Float32[1.7641534 -1.7641534], (layer_1 = NamedTuple(), layer_2 = NamedTuple(), layer_3 = (frozen_params = (layer_3 = NamedTuple(), layer_4 = (scale = Float32[1.0, 1.0, 1.0, 1.0], bias = Float32[0.0, 0.0, 0.0, 0.0])), states = (layer_3 = (rng = Random.Xoshiro(0x87711e5ce1a49ffe, 0xa210b60ecab6b8c5, 0x436c749552fc8172, 0x03e9c7d813a9f096), training = Val{true}()), layer_4 = (running_mean = Float32[-0.04517859, 0.03484953, -0.004917746, 0.0074841487], running_var = Float32[0.94082206, 0.92428976, 0.90048367, 0.90112025], training = Val{true}()))), layer_4 = NamedTuple())) +``` + diff --git a/previews/PR467/manual/gpu_management.md b/previews/PR467/manual/gpu_management.md new file mode 100644 index 0000000000..244029eb58 --- /dev/null +++ b/previews/PR467/manual/gpu_management.md @@ -0,0 +1,139 @@ + + + +# GPU Management + + +::: info + + +Starting from `v0.5`, Lux has transitioned to a new GPU management system. The old system using `cpu` and `gpu` functions is still in place but will be removed in `v0.6`. Using the old functions might lead to performance regressions if used inside performance critical code. + + +::: + + +`Lux.jl` can handle multiple GPU backends. Currently, the following backends are supported: + + +```julia +using Lux, LuxCUDA, LuxAMDGPU # Important to load trigger packages + +supported_gpu_backends() +``` + + +``` +("CUDA", "AMDGPU", "Metal") +``` + + +::: danger Metal Support + + +Support for Metal GPUs should be considered extremely experimental at this point. + + +::: + + + + +## Automatic Backend Management (Recommended Approach) + + +Automatic Backend Management is done by two simple functions: `cpu_device` and `gpu_device`. + + +1. [`cpu_device`](../api/Accelerator_Support/LuxDeviceUtils#LuxDeviceUtils.cpu_device): This is a simple function and just returns a `LuxCPUDevice` object. + + +```julia +cdev = cpu_device() +``` + + +``` +(::LuxCPUDevice) (generic function with 5 methods) +``` + + +```julia +x_cpu = randn(Float32, 3, 2) +``` + + +``` +3×2 Matrix{Float32}: + 0.433884 0.229779 + -0.459193 -1.95972 + -0.541064 -1.40102 +``` + + +2. [`gpu_device`](../api/Accelerator_Support/LuxDeviceUtils#LuxDeviceUtils.gpu_device): This function performs automatic GPU device selection and returns an object. + + 1. If no GPU is available, it returns a `LuxCPUDevice` object. + 2. If a LocalPreferences file is present, then the backend specified in the file is used. To set a backend, use `Lux.gpu_backend!()`. + + 1. If the trigger package corresponding to the device is not loaded, then a warning is displayed. + 2. If no LocalPreferences file is present, then the first working GPU with loaded trigger package is used. + + +```julia +gdev = gpu_device() + +x_gpu = x_cpu |> gdev +``` + + +``` +3×2 CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}: + 0.433884 0.229779 + -0.459193 -1.95972 + -0.541064 -1.40102 +``` + + +```julia +(x_gpu |> cdev) ≈ x_cpu +``` + + +``` +true +``` + + + + +## Manual Backend Management + + +Automatic Device Selection can be circumvented by directly using `LuxCPUDevice` and `AbstractLuxGPUDevice` objects. + + +```julia +cdev = LuxCPUDevice() + +x_cpu = randn(Float32, 3, 2) + +if LuxCUDA.functional() + gdev = LuxCUDADevice() + x_gpu = x_cpu |> gdev +elseif LuxAMDGPU.functional() + gdev = LuxAMDGPUDevice() + x_gpu = x_cpu |> gdev +else + @info "No GPU is available. Using CPU." + x_gpu = x_cpu +end + +(x_gpu |> cdev) ≈ x_cpu +``` + + +``` +true +``` + diff --git a/previews/PR467/manual/interface.md b/previews/PR467/manual/interface.md new file mode 100644 index 0000000000..8648568bd1 --- /dev/null +++ b/previews/PR467/manual/interface.md @@ -0,0 +1,297 @@ + + + +# Lux Interface + + +:::tip + + +If you just want to define compatibility with Lux without actually using any of the other functionality provided by Lux (like layers), it is recommended to depend on `LuxCore.jl` instead of `Lux.jl`. `LuxCore.jl` is a significantly lighter dependency. + + +::: + + +First let's set the expectations straight. + + + * Do you **have to** follow the interface? *No*. + * **Should you** follow it? *Probably yes*. + * **Why?** It provides the ability for frameworks built on top of Lux to be cross compatible. Additionally, any new functionality built into Lux, will just work for your framework. + + +::: warning + + +The interface is optional for frameworks being developed independent of Lux. All functionality in the core library (and officially supported ones) **must** adhere to the interface + + +::: + + + + +## Layer Interface + + + + +### Singular Layer + + +If the layer doesn't contain any other Lux layer, then it is a `Singular Layer`. This means it should optionally subtype `Lux.AbstractExplicitLayer` but mandatorily define all the necessary functions mentioned in the docstrings. Consider a simplified version of [`Dense`](../api/Lux/layers#Lux.Dense) called `Linear`. + + +First, setup the architectural details for this layer. Note, that the architecture doesn't contain any mutable structure like arrays. When in doubt, remember, once constructed a model architecture cannot change. + + +::: tip + + +For people coming from Flux.jl background this might be weird. We recommend checking out [the Flux to Lux migration guide](migrate_from_flux) first before proceeding. + + +::: + + +```julia +using Lux, Random + +struct Linear{F1, F2} <: Lux.AbstractExplicitLayer + in_dims::Int + out_dims::Int + init_weight::F1 + init_bias::F2 +end + +function Linear(in_dims::Int, out_dims::Int; init_weight=Lux.glorot_uniform, + init_bias=Lux.zeros32) + return Linear{typeof(init_weight), typeof(init_bias)}(in_dims, out_dims, init_weight, + init_bias) +end + +l = Linear(2, 4) +``` + + +``` +Linear() +``` + + +Next, we need to implement functions which return the parameters and states for the layer. In case of `Linear`, the parameters are `weight` and `bias` while the states are empty. States become important when defining layers like [`BatchNorm`](../api/Lux/layers#Lux.BatchNorm), [`WeightNorm`](../api/Lux/layers#Lux.WeightNorm), etc. The recommended data structure for returning parameters is a NamedTuple, though anything satisfying the [Parameter Interface](#parameter-interface) is valid. + + +```julia +function Lux.initialparameters(rng::AbstractRNG, l::Linear) + return (weight=l.init_weight(rng, l.out_dims, l.in_dims), + bias=l.init_bias(rng, l.out_dims, 1)) +end + +Lux.initialstates(::AbstractRNG, ::Linear) = NamedTuple() +``` + + +You could also implement `Lux.parameterlength` and `Lux.statelength` to prevent wasteful reconstruction of the parameters and states. + + +```julia +# This works +println("Parameter Length: ", Lux.parameterlength(l), "; State Length: ", + Lux.statelength(l)) + +# But still recommened to define these +Lux.parameterlength(l::Linear) = l.out_dims * l.in_dims + l.out_dims + +Lux.statelength(::Linear) = 0 +``` + + +``` +Parameter Length: 12; State Length: 0 +``` + + +::: tip + + +You might notice that we don't pass in a `PRNG` for these functions. If your parameter length and/or state length depend on a random number generator, you should think **really hard** about what you are trying to do and why. + + +::: + + +Now, we need to define how the layer works. For this you make your layer a function with exactly 3 arguments – `x` the input, `ps` the parameters, and `st` the states. This function must return two things – `y` the output, and `st_new` the updated state. + + +```julia +function (l::Linear)(x::AbstractMatrix, ps, st::NamedTuple) + y = ps.weight * x .+ ps.bias + return y, st +end +``` + + +Finally, let's run this layer. If you have made this far into the documentation, we don't feel you need a refresher on that. + + +```julia +rng = Random.default_rng() +Random.seed!(rng, 0) + +ps, st = Lux.setup(rng, l) + +println("Parameter Length: ", Lux.parameterlength(l), "; State Length: ", + Lux.statelength(l)) + +x = randn(rng, Float32, 2, 1) + +Lux.apply(l, x, ps, st) # or `l(x, ps, st)` +``` + + +``` +(Float32[-0.15276335; 0.45325348; 1.0207279; 0.78226817;;], NamedTuple()) +``` + + + + +### Container Layer + + +If your layer comprises of other Lux layers, then it is a `Container Layer`. Note that you could treat it as a [`Singular Layer`](#singular-layer), and it is still fine. FWIW, if you cannot subtype your layer with `Lux.AbstractExplicitContainerLayer` then you should go down the [`Singular Layer`](#singular-layer) route. But subtyping allows us to bypass some of these common definitions. Let us now define a layer, which is basically a composition of two linear layers. + + +```julia +struct ComposedLinear{L1, L2} <: Lux.AbstractExplicitContainerLayer{(:linear_1, :linear_2)} + linear_1::L1 + linear_2::L2 +end + +function (cl::ComposedLinear)(x::AbstractMatrix, ps, st::NamedTuple) + # To access the parameters and states for `linear_1` we do `ps.linear_1` and + # `st.linear_1`. Similarly for `linear_2` + y, st_l1 = cl.linear_1(x, ps.linear_1, st.linear_1) + y, st_l2 = cl.linear_2(y, ps.linear_2, st.linear_2) + # Finally, we need to return the new state which has the exact structure as `st` + return y, (linear_1 = st_l1, linear_2 = st_l2) +end +``` + + +Here, you will notice we have passed `(:linear_1, :linear_2)` to the supertype. It essentially informs the type that, `.linear_1` and `.linear_2` are Lux layers and we need to construct parameters and states for those. Let's construct these and see: + + +```julia +model = ComposedLinear(Linear(2, 4), Linear(4, 2)) +display(model) + +ps, st = Lux.setup(rng, model) + +println("Parameters: ", ps) +println("States: ", st) + +println("Parameter Length: ", Lux.parameterlength(model), "; State Length: ", + Lux.statelength(model)) + +x = randn(rng, Float32, 2, 1) + +Lux.apply(model, x, ps, st) # or `model(x, ps, st)` +``` + + +``` +(Float32[1.3410565; 0.78000563;;], (linear_1 = NamedTuple(), linear_2 = NamedTuple())) +``` + + + + +## Parameter Interface + + +We accept any parameter type as long as we can fetch the parameters using `getproperty(obj, :parameter_name)`. This allows us to simultaneously support `NamedTuple`s and `ComponentArray`s. Let us go through a concrete example of what it means. Consider [`Dense`](../api/Lux/layers#Lux.Dense) which expects two parameters named `weight` and `bias`. + + +::: info + + +If you are defining your own parameter type, it is your responsibility to make sure that it works with the AutoDiff System you are using. + + +::: + + +```julia +using Lux, Random + +d = Dense(2, 3) +rng = Random.default_rng() +Random.seed!(rng, 0) + +ps_default, st = Lux.setup(rng, d) + +x = randn(rng, Float32, 2, 1) + +println("Result with `NamedTuple` parameters: ", first(d(x, ps_default, st))) +``` + + +``` +Result with `NamedTuple` parameters: Float32[1.135916; 0.7668784; -1.0876652;;] +``` + + +Let, us define a custom parameter type with fields `myweight` and `mybias` but if we try to access `weight` we get back `myweight`, similar for `bias`. + + +::: warning + + +This is for demonstrative purposes, don't try this at home! + + +::: + + +```julia +struct DenseLayerParameters{W, B} + myweight::W + mybias::B +end + +function Base.getproperty(ps::DenseLayerParameters, x::Symbol) + if x == :weight + return getfield(ps, :myweight) + elseif x == :bias + return getfield(ps, :mybias) + end + return getfield(ps, x) +end + +ps = DenseLayerParameters(ps_default.weight, ps_default.bias) + +println("Result with `DenseLayerParameters` parameters: ", first(d(x, ps, st))) +``` + + +``` +Result with `DenseLayerParameters` parameters: Float32[1.135916; 0.7668784; -1.0876652;;] +``` + + +The takeaway from this shouldn't be – *lets define weird parameter types*. Simply because you can do weird things like this doesn't mean you should, since it only leads to bugs. + + +Instead this shows the flexibility you have for how your parameters can be structured. + + + + +## State Interface + + +States are always type constrained to be `NamedTuple`. The structure of the input state **must** match that of the output state, i.e. `keys(st_in) == keys(st_out)`. This doesn't imply that types of the input and output state match. To generate efficient code, we often do dispatch on the state, for example, [`Dropout`](../api/Lux/layers#Lux.Dropout), [`BatchNorm`](../api/Lux/layers#Lux.BatchNorm), etc. + diff --git a/previews/PR467/manual/migrate_from_flux.md b/previews/PR467/manual/migrate_from_flux.md new file mode 100644 index 0000000000..dfdf56efaf --- /dev/null +++ b/previews/PR467/manual/migrate_from_flux.md @@ -0,0 +1,176 @@ + + + +# Migrating from Flux to Lux + + +For the core library layers like [`Dense`](../api/Lux/layers#Lux.Dense), [`Conv`](../api/Lux/layers#Lux.Conv), etc. we have intentionally kept the API very similar to Flux. In most cases, replacing `using Flux` with `using Lux` should be enough to get you started. We cover the additional changes that you will have to make in the following example. + + +:::code-group + + +```julia{1,7,9,11} [Lux] +using Lux, Random, NNlib, Zygote + +model = Chain(Dense(2 => 4), BatchNorm(4, relu), Dense(4 => 2)) +rng = Random.default_rng() +x = randn(rng, Float32, 2, 4) + +ps, st = Lux.setup(rng, model) + +model(x, ps, st) + +gradient(ps -> sum(first(model(x, ps, st))), ps) +``` + + +```julia [Flux] +using Flux, Random, NNlib, Zygote + +model = Chain(Dense(2 => 4), BatchNorm(4, relu), Dense(4 => 2)) +rng = Random.default_rng() +x = randn(rng, Float32, 2, 4) + + + +model(x) + +gradient(model -> sum(model(x)), model) +``` + + +::: + + + + +## Implementing Custom Layers + + +Flux and Lux operate under extremely different design philosophies regarding how layers should be implemented. A summary of the differences would be: + + + * Flux stores everything in a single struct and relies on `Functors.@functor` and `Flux.trainable` to distinguish between trainable and non-trainable parameters. + * Lux relies on the user to define `Lux.initialparameters` and `Lux.initialstates` to distinguish between trainable parameters (called "parameters") and non-trainable parameters (called "states"). Additionally, Lux layers define the model architecture, hence device transfer utilities like [`gpu_device`](../api/Accelerator_Support/LuxDeviceUtils#LuxDeviceUtils.gpu_device), [`cpu_device`](../api/Accelerator_Support/LuxDeviceUtils#LuxDeviceUtils.cpu_device), etc. cannot be applied on Lux layers, instead they need to be applied on the parameters and states. + + +Let's work through a concrete example to demonstrate this. We will implement a very simple layer that computes $A \times B \times x$ where $A$ is not trainable and $B$ is trainable. + + +:::code-group + + +```julia [Lux] +using Lux, Random, NNlib, Zygote + +struct LuxLinear <: Lux.AbstractExplicitLayer + init_A + init_B +end + +function LuxLinear(A::AbstractArray, B::AbstractArray) + # Storing Arrays or any mutable structure inside a Lux Layer is not recommended + # instead we will convert this to a function to perform lazy initialization + return LuxLinear(() -> copy(A), () -> copy(B)) +end + +# `B` is a parameter +Lux.initialparameters(::AbstractRNG, layer::LuxLinear) = (B=layer.init_B(),) + +# `A` is a state +Lux.initialstates(::AbstractRNG, layer::LuxLinear) = (A=layer.init_A(),) + +(l::LuxLinear)(x, ps, st) = st.A * ps.B * x, st +``` + + +```julia [Flux] +using Flux, Random, NNlib, Zygote, Optimisers + +struct FluxLinear + A + B +end + + + + + + + +# `A` is not trainable +Optimisers.trainable(f::FluxLinear) = (B=f.B,) + +# Needed so that both `A` and `B` can be transfered between devices +Flux.@functor FluxLinear + +(l::FluxLinear)(x) = l.A * l.B * x +``` + + +::: + + +Now let us run the model. + + +:::code-group + + +```julia{2,5,7,9} [Lux] +rng = Random.default_rng() +model = LuxLinear(randn(rng, 2, 4), randn(rng, 4, 2)) +x = randn(rng, 2, 1) + +ps, st = Lux.setup(rng, model) + +model(x, ps, st) + +gradient(ps -> sum(first(model(x, ps, st))), ps) +``` + + +```julia [Flux] +rng = Random.default_rng() +model = FluxLinear(randn(rng, 2, 4), randn(rng, 4, 2)) +x = randn(rng, 2, 1) + + + +model(x) + +gradient(model -> sum(model(x)), model) +``` + + +::: + + +To reiterate some important points: + + + * Don't store mutables like Arrays inside a Lux Layer. + * Parameters and States should be constructured inside the respective `initial*` functions. + + + + +## Certain Important Implementation Details + + + + +### Training/Inference Mode + + +Flux supports a mode called `:auto` which automatically decides if the user is training the model or running inference. This is the default mode for `Flux.BatchNorm`, `Flux.GroupNorm`, `Flux.Dropout`, etc. Lux doesn't support this mode (specifically to keep code simple and do exactly what the user wants), hence our default mode is `training`. This can be changed using `Lux.testmode`. + + + + +## Can we still use Flux Layers? + + +If you have `Flux` loaded in your code, you can use the function [`Lux.transform`](../api/Lux/flux_to_lux#Lux.transform) to automatically convert your model to `Lux`. Note that in case a native Lux counterpart isn't available, we fallback to using `Optimisers.destructure`. + diff --git a/previews/PR467/manual/weight_initializers.md b/previews/PR467/manual/weight_initializers.md new file mode 100644 index 0000000000..41e7ee73c1 --- /dev/null +++ b/previews/PR467/manual/weight_initializers.md @@ -0,0 +1,142 @@ + + + +# Initializing Weights + + +`WeightInitializers.jl` provides common weight initialization schemes for deep learning models. + + +```julia +using WeightInitializers, Random + +# Fixing rng +rng = Random.MersenneTwister(42) +``` + + +``` +Random.MersenneTwister(42) +``` + + +```julia +# Explicit rng call +weights = kaiming_normal(rng, 2, 5) +``` + + +``` +2×5 Matrix{Float32}: + -0.351662 0.0171745 1.12442 -0.296372 -1.67094 + -0.281053 -0.18941 -0.724099 0.0987538 0.634549 +``` + + +```julia +# Default rng call +weights = kaiming_normal(2, 5) +``` + + +``` +2×5 Matrix{Float32}: + -0.227513 -0.265372 0.265788 1.29955 -0.192836 + 0.687611 0.454679 -0.433656 0.20548 0.292002 +``` + + +```julia +# Passing kwargs (if needed) with explicit rng call +weights_cl = kaiming_normal(rng; gain=1.0) +weights = weights_cl(2, 5) +``` + + +``` +2×5 Matrix{Float64}: + 0.484056 0.231723 0.164379 0.306147 0.18365 + 0.0836414 0.666965 -0.396323 -0.711329 -0.382971 +``` + + +```julia +# Passing kwargs (if needed) with default rng call +weights_cl = kaiming_normal(; gain=1.0) +weights = weights_cl(2, 5) +``` + + +``` +2×5 Matrix{Float64}: + -0.160876 -0.187646 0.18794 0.918918 -0.136356 + 0.486214 0.321506 -0.306641 0.145296 0.206476 +``` + + +To generate weights directly on GPU, pass in a `CUDA.RNG`. (Note that this is currently implemented only for NVIDIA GPUs) + + +```julia +using LuxCUDA + +weights = kaiming_normal(CUDA.default_rng(), 2, 5) +``` + + +``` +2×5 CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}: + -0.213496 -0.49103 0.451456 -0.489177 0.889007 + 0.88201 -0.355084 0.0521268 0.866306 0.514173 +``` + + +You can also generate Complex Numbers: + + +```julia +weights = kaiming_normal(CUDA.default_rng(), ComplexF32, 2, 5) +``` + + +``` +2×5 CuArray{ComplexF32, 2, CUDA.Mem.DeviceBuffer}: + -0.499214-0.434981im 0.132929-0.301037im … 0.0539812+0.00325513im + 0.103728-0.211376im 0.133132-0.234198im 0.985273-0.267039im +``` + + + + +## Quick examples + + +The package is meant to be working with deep learning libraries such as (F)Lux. All the methods take as input the chosen `rng` type and the dimension for the array. + + +```julia +weights = init(rng, dims...) +``` + + +The `rng` is optional, if not specified a default one will be used. + + +```julia +weights = init(dims...) +``` + + +If there is the need to use keyword arguments the methods can be called with just the `rng` (optionally) and the keywords to get in return a function behaving like the two examples above. + + +```julia +weights_init = init(rng; kwargs...) +weights = weights_init(rng, dims...) + +# Or + +weights_init = init(; kwargs...) +weights = weights_init(dims...) +``` + diff --git a/previews/PR467/siteinfo.js b/previews/PR467/siteinfo.js new file mode 100644 index 0000000000..7ea2ab52ae --- /dev/null +++ b/previews/PR467/siteinfo.js @@ -0,0 +1 @@ +var DOCUMENTER_CURRENT_VERSION = "previews/PR467"; diff --git a/previews/PR467/tutorials/advanced/1_GravitationalWaveForm-24.png b/previews/PR467/tutorials/advanced/1_GravitationalWaveForm-24.png new file mode 100644 index 0000000000000000000000000000000000000000..48e43e6dd18310ce13dce80c14a00f519de2b759 GIT binary patch literal 59020 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 XoBPGJEFXP!1YBy$+BeG3R-yj|F}k7? literal 0 HcmV?d00001 diff --git a/previews/PR467/tutorials/advanced/1_GravitationalWaveForm-35.png b/previews/PR467/tutorials/advanced/1_GravitationalWaveForm-35.png new file mode 100644 index 0000000000000000000000000000000000000000..3909b38e324235d644971a3ace21aec10e91f7ae GIT binary patch literal 82286 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 C6$ZhLK2NK2D& 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

j__vKq@lr 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 literal 0 HcmV?d00001 diff --git a/previews/PR467/tutorials/advanced/1_GravitationalWaveForm-50.png b/previews/PR467/tutorials/advanced/1_GravitationalWaveForm-50.png new file mode 100644 index 0000000000000000000000000000000000000000..7f60d3dd4b9884529e3fa0d6f594d7cb21287cb1 GIT binary patch literal 89867 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 qVuzE< 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

N`ewiG-ZSZzF5=37st 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 A?EnA( literal 0 HcmV?d00001 diff --git a/previews/PR467/tutorials/beginner/2_PolynomialFitting-30.png b/previews/PR467/tutorials/beginner/2_PolynomialFitting-30.png new file mode 100644 index 0000000000000000000000000000000000000000..b9f5cfe7099695951561266f77f36f65bb3398d0 GIT binary patch literal 31421 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 Hn+N?jp_@mI literal 0 HcmV?d00001 diff --git a/previews/PR467/tutorials/beginner/2_PolynomialFitting.md b/previews/PR467/tutorials/beginner/2_PolynomialFitting.md new file mode 100644 index 0000000000..300476c222 --- /dev/null +++ b/previews/PR467/tutorials/beginner/2_PolynomialFitting.md @@ -0,0 +1,233 @@ + + + + + +# Fitting a Polynomial using MLP + + +In this tutorial we will fit a MultiLayer Perceptron (MLP) on data generated from a polynomial. + + + + +## Package Imports + + +```julia +using Lux, LuxAMDGPU, LuxCUDA, Optimisers, Random, Statistics, Zygote +using CairoMakie, MakiePublication +``` + + + + +## Dataset + + +Generate 128 datapoints from the polynomial $y = x^2 - 2x$. + + +```julia +function generate_data(rng::AbstractRNG) + x = reshape(collect(range(-2.0f0, 2.0f0, 128)), (1, 128)) + y = evalpoly.(x, ((0, -2, 1),)) .+ randn(rng, (1, 128)) .* 0.1f0 + return (x, y) +end +``` + + +``` +generate_data (generic function with 1 method) +``` + + +Initialize the random number generator and fetch the dataset. + + +```julia +rng = MersenneTwister() +Random.seed!(rng, 12345) + +(x, y) = generate_data(rng) +``` + + +``` +(Float32[-2.0 -1.968504 -1.9370079 -1.9055119 -1.8740157 -1.8425196 -1.8110236 -1.7795275 -1.7480315 -1.7165354 -1.6850394 -1.6535434 -1.6220472 -1.5905511 -1.5590551 -1.527559 -1.496063 -1.464567 -1.4330709 -1.4015749 -1.3700787 -1.3385826 -1.3070866 -1.2755905 -1.2440945 -1.2125984 -1.1811024 -1.1496063 -1.1181102 -1.0866141 -1.0551181 -1.023622 -0.992126 -0.96062994 -0.92913383 -0.8976378 -0.86614174 -0.8346457 -0.8031496 -0.77165353 -0.7401575 -0.70866144 -0.6771653 -0.6456693 -0.61417323 -0.5826772 -0.5511811 -0.51968503 -0.48818898 -0.4566929 -0.42519686 -0.39370078 -0.36220473 -0.33070865 -0.2992126 -0.26771653 -0.23622048 -0.20472442 -0.17322835 -0.14173229 -0.11023622 -0.07874016 -0.047244094 -0.015748031 0.015748031 0.047244094 0.07874016 0.11023622 0.14173229 0.17322835 0.20472442 0.23622048 0.26771653 0.2992126 0.33070865 0.36220473 0.39370078 0.42519686 0.4566929 0.48818898 0.51968503 0.5511811 0.5826772 0.61417323 0.6456693 0.6771653 0.70866144 0.7401575 0.77165353 0.8031496 0.8346457 0.86614174 0.8976378 0.92913383 0.96062994 0.992126 1.023622 1.0551181 1.0866141 1.1181102 1.1496063 1.1811024 1.2125984 1.2440945 1.2755905 1.3070866 1.3385826 1.3700787 1.4015749 1.4330709 1.464567 1.496063 1.527559 1.5590551 1.5905511 1.6220472 1.6535434 1.6850394 1.7165354 1.7480315 1.7795275 1.8110236 1.8425196 1.8740157 1.9055119 1.9370079 1.968504 2.0], [8.11723579535073 7.8972862806322315 7.667572185253954 7.493641443881164 7.328542256257643 7.1081451188446065 6.754145700236098 6.73844851250885 6.698323804024227 6.3637494708272655 6.270117709011731 6.2419372753805 5.816280759896085 5.718319527208828 5.741347639508506 5.258118446989299 5.268165780092538 5.195746082529355 5.032704772846244 4.733409783966572 4.520239616672976 4.369386593776045 4.107888442446331 4.182845399340577 4.002249800810884 3.8969011895086174 3.910820824989613 3.646440085736948 3.3343752660206305 3.3980378243437745 3.1887817476268587 2.9930802717826603 3.018980452144523 2.690492107796345 2.8576513349182378 2.4778283273281008 2.452401424624867 2.401875695877283 2.2896425232872755 2.2812518842985035 1.9742292519472466 1.7663454774622869 1.7829663021691418 1.6248666914928798 1.635090436697959 1.4887378757184528 1.4396068206428336 1.5047223947023354 1.2439428212858357 1.1770575798169982 1.0519113712665473 0.8008025630753797 0.8011788202541421 0.7702484835053167 0.9010273188596704 0.48114290312426095 0.4605012716399809 0.42308333113261615 0.2890108900859864 0.3324716507588617 0.2126899641074972 0.2560113968739265 0.08350192481301627 0.046225582753114294 -0.16118930624459 -0.013928769802494537 -0.030805824695545894 -0.10629780224701328 -0.17643440564041185 -0.2494508100897751 -0.3322350480467481 -0.45414851684613733 -0.6965624404632386 -0.38861245182183696 -0.4708530312086873 -0.6274991143463677 -0.5617763080815885 -0.6438360803492721 -0.7565600800322707 -0.5662591600023589 -0.6591533520776037 -0.9166793344639054 -0.8520467822193756 -0.9507226194240974 -1.0248823046771698 -0.97772916365376 -0.8199294436184201 -0.9080088282844027 -0.9682665790685976 -1.031816361263047 -0.9296919748814573 -1.1145618706755287 -1.2139119971536336 -1.0157839085777947 -0.9417175810509869 -0.9783498813733602 -0.9123675448444001 -1.138088633455826 -1.1212038088290894 -0.911429094488635 -1.023486657428913 -0.9287179111905346 -1.0396518660677925 -1.0370046468920306 -0.9846375721966646 -0.833026219703481 -0.8200258902651266 -0.789500663251252 -0.9068267920931062 -0.7284236770750803 -0.7093213401368348 -0.7048862544448803 -0.6215870033126495 -0.5892481295457608 -0.8462913756395639 -0.5544688796856879 -0.5805399434794658 -0.5761396334948753 -0.5851955365208916 -0.5561461874821676 -0.1969227628706652 -0.34073487813889014 -0.2738635064414512 -0.1425063756241582 -0.18330825579933746 -0.054321035831595324 -0.21213293699653427 0.049985105882301]) +``` + + +Let's visualize the dataset + + +```julia +with_theme(theme_web()) do + fig = Figure() + ax = CairoMakie.Axis(fig[1, 1]; xlabel="x", ylabel="y") + + l = lines!(ax, x[1, :], x -> evalpoly(x, (0, -2, 1)); linewidth=3) + s = scatter!(ax, x[1, :], y[1, :]; markersize=8, color=:orange, + strokecolor=:black, strokewidth=1) + + axislegend(ax, [l, s], ["True Quadratic Function", "Data Points"]) + + return fig +end +``` + + +![](2_PolynomialFitting-12.png) + + + + +## Neural Network + + +For this problem, you should not be using a neural network. But let's still do that! + + +```julia +model = Chain(Dense(1 => 16, relu), Dense(16 => 1)) +``` + + +``` +Chain( + layer_1 = Dense(1 => 16, relu), # 32 parameters + layer_2 = Dense(16 => 1), # 17 parameters +) # Total: 49 parameters, + # plus 0 states. +``` + + + + +## Optimizer + + +We will use Adam from Optimisers.jl + + +```julia +opt = Adam(0.03f0) +``` + + +``` +Adam(0.03, (0.9, 0.999), 1.0e-8) +``` + + + + +## Loss Function + + +We will use the `Lux.Training` API so we need to ensure that our loss function takes 4 inputs – model, parameters, states and data. The function must return 3 values – loss, updated_state, and any computed statistics. + + +```julia +function loss_function(model, ps, st, data) + y_pred, st = Lux.apply(model, data[1], ps, st) + mse_loss = mean(abs2, y_pred .- data[2]) + return mse_loss, st, () +end +``` + + +``` +loss_function (generic function with 1 method) +``` + + + + +## Training + + +First we will create a [`Lux.Experimental.TrainState`](../../api/Lux/contrib#Lux.Experimental.TrainState) which is essentially a convenience wrapper over parameters, states and optimizer states. + + +```julia +tstate = Lux.Training.TrainState(rng, model, opt) +``` + + +``` +Lux.Experimental.TrainState{Lux.Chain{NamedTuple{(:layer_1, :layer_2), Tuple{Lux.Dense{true, typeof(NNlib.relu), typeof(WeightInitializers.glorot_uniform), typeof(WeightInitializers.zeros32)}, Lux.Dense{true, typeof(identity), typeof(WeightInitializers.glorot_uniform), typeof(WeightInitializers.zeros32)}}}, Nothing}, NamedTuple{(:layer_1, :layer_2), Tuple{NamedTuple{(:weight, :bias), Tuple{CUDA.CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}, CUDA.CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}, NamedTuple{(:weight, :bias), Tuple{CUDA.CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}, CUDA.CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}}}, NamedTuple{(:layer_1, :layer_2), Tuple{NamedTuple{(), Tuple{}}, NamedTuple{(), Tuple{}}}}, NamedTuple{(:layer_1, :layer_2), Tuple{NamedTuple{(:weight, :bias), Tuple{Optimisers.Leaf{Optimisers.Adam, Tuple{CUDA.CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}, CUDA.CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}, Tuple{Float32, Float32}}}, Optimisers.Leaf{Optimisers.Adam, Tuple{CUDA.CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}, CUDA.CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}, Tuple{Float32, Float32}}}}}, NamedTuple{(:weight, :bias), Tuple{Optimisers.Leaf{Optimisers.Adam, Tuple{CUDA.CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}, CUDA.CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}, Tuple{Float32, Float32}}}, Optimisers.Leaf{Optimisers.Adam, Tuple{CUDA.CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}, CUDA.CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}, Tuple{Float32, Float32}}}}}}}}(Chain(), (layer_1 = (weight = Float32[0.36222202; 0.23371002; -0.49825558; -0.18142056; -0.13757975; -0.50849473; 0.13773328; -0.035294008; 0.21778254; 0.04964345; -0.56594235; -0.45329624; -0.08787567; 0.5648949; 0.5260752; -0.07562564;;], bias = Float32[0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0;;]), layer_2 = (weight = Float32[-0.14330137 -0.39328107 -0.18253882 -0.55998546 -0.5919335 -0.3069779 -0.39085856 -0.4838621 0.3979575 0.5851314 0.24242708 0.35374007 0.10175798 0.29761198 -0.34761065 -0.05758927], bias = Float32[0.0;;])), (layer_1 = NamedTuple(), layer_2 = NamedTuple()), (layer_1 = (weight = Leaf(Adam(0.03, (0.9, 0.999), 1.0e-8), (Float32[0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0;;], Float32[0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0;;], (0.9, 0.999))), bias = Leaf(Adam(0.03, (0.9, 0.999), 1.0e-8), (Float32[0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0;;], Float32[0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0;;], (0.9, 0.999)))), layer_2 = (weight = Leaf(Adam(0.03, (0.9, 0.999), 1.0e-8), (Float32[0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0], Float32[0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0], (0.9, 0.999))), bias = Leaf(Adam(0.03, (0.9, 0.999), 1.0e-8), (Float32[0.0;;], Float32[0.0;;], (0.9, 0.999))))), 0) +``` + + +Now we will use Zygote for our AD requirements. + + +```julia +vjp_rule = Lux.Training.AutoZygote() +``` + + +``` +ADTypes.AutoZygote() +``` + + +Finally the training loop. + + +```julia +function main(tstate::Lux.Experimental.TrainState, vjp, data, epochs) + data = data .|> gpu_device() + for epoch in 1:epochs + grads, loss, stats, tstate = Lux.Training.compute_gradients(vjp, + loss_function, data, tstate) + println("Epoch: $(epoch) || Loss: $(loss)") + tstate = Lux.Training.apply_gradients(tstate, grads) + end + return tstate +end + +dev_cpu = cpu_device() +dev_gpu = gpu_device() + +tstate = main(tstate, vjp_rule, (x, y), 250) +y_pred = dev_cpu(Lux.apply(tstate.model, dev_gpu(x), tstate.parameters, tstate.states)[1]) +``` + + +``` +1×128 Matrix{Float32}: + 7.93183 7.76661 7.60138 7.43616 7.27094 7.10571 6.94049 6.77526 6.61004 6.44482 6.27959 6.11437 5.94914 5.78392 5.61869 5.45347 5.28825 5.12302 4.9578 4.79257 4.62735 4.46213 4.29696 4.14682 4.01403 3.88123 3.74844 3.61565 3.48286 3.35007 3.21728 3.08449 2.9517 2.82191 2.70562 2.58933 2.47304 2.35675 2.24045 2.12416 2.00787 1.89158 1.77932 1.67136 1.5634 1.45544 1.34748 1.2629 1.18945 1.116 1.04255 0.969101 0.895651 0.822201 0.748752 0.675301 0.601852 0.528402 0.454952 0.381502 0.308053 0.234603 0.161153 0.0877032 0.0142532 -0.0591969 -0.132646 -0.206096 -0.279546 -0.352996 -0.426446 -0.499896 -0.570314 -0.604514 -0.638714 -0.672914 -0.707113 -0.741313 -0.775513 -0.809713 -0.843913 -0.878112 -0.912312 -0.946512 -0.980712 -0.986986 -0.984269 -0.981553 -0.978836 -0.97612 -0.973403 -0.970686 -0.96797 -0.965253 -0.962536 -0.95982 -0.957103 -0.954386 -0.95167 -0.938959 -0.914586 -0.890214 -0.865841 -0.841469 -0.817097 -0.792724 -0.768352 -0.74398 -0.719607 -0.695235 -0.670862 -0.64649 -0.622118 -0.597745 -0.573373 -0.549001 -0.524628 -0.500256 -0.475883 -0.451511 -0.427139 -0.402766 -0.378394 -0.354022 -0.32965 -0.305277 -0.280905 -0.256532 +``` + + +Let's plot the results + + +```julia +with_theme(theme_web()) do + fig = Figure() + ax = CairoMakie.Axis(fig[1, 1]; xlabel="x", ylabel="y") + + l = lines!(ax, x[1, :], x -> evalpoly(x, (0, -2, 1)); linewidth=3) + s1 = scatter!(ax, x[1, :], y[1, :]; markersize=8, color=:orange, + strokecolor=:black, strokewidth=1) + s2 = scatter!(ax, x[1, :], y_pred[1, :]; markersize=8, color=:green, + strokecolor=:black, strokewidth=1) + + axislegend(ax, [l, s1, s2], ["True Quadratic Function", "Actual Data", "Predictions"]) + + return fig +end +``` + + +![](2_PolynomialFitting-30.png) + + +--- + + +*This page was generated using [Literate.jl](https://github.com/fredrikekre/Literate.jl).* + diff --git a/previews/PR467/tutorials/beginner/3_SimpleRNN.md b/previews/PR467/tutorials/beginner/3_SimpleRNN.md new file mode 100644 index 0000000000..bf18544c7e --- /dev/null +++ b/previews/PR467/tutorials/beginner/3_SimpleRNN.md @@ -0,0 +1,272 @@ + + + + + +# Training a Simple LSTM + + +In this tutorial we will go over using a recurrent neural network to classify clockwise and anticlockwise spirals. By the end of this tutorial you will be able to: + + +1. Create custom Lux models. +2. Become familiar with the Lux recurrent neural network API. +3. Training using Optimisers.jl and Zygote.jl. + + + + +## Package Imports + + +```julia +using Lux, LuxAMDGPU, LuxCUDA, JLD2, MLUtils, Optimisers, Zygote, Random, Statistics +``` + + + + +## Dataset + + +We will use MLUtils to generate 500 (noisy) clockwise and 500 (noisy) anticlockwise spirals. Using this data we will create a `MLUtils.DataLoader`. Our dataloader will give us sequences of size 2 × seq*len × batch*size and we need to predict a binary value whether the sequence is clockwise or anticlockwise. + + +```julia +function get_dataloaders(; dataset_size=1000, sequence_length=50) + # Create the spirals + data = [MLUtils.Datasets.make_spiral(sequence_length) for _ in 1:dataset_size] + # Get the labels + labels = vcat(repeat([0.0f0], dataset_size ÷ 2), repeat([1.0f0], dataset_size ÷ 2)) + clockwise_spirals = [reshape(d[1][:, 1:sequence_length], :, sequence_length, 1) + for d in data[1:(dataset_size ÷ 2)]] + anticlockwise_spirals = [reshape(d[1][:, (sequence_length + 1):end], :, + sequence_length, 1) for d in data[((dataset_size ÷ 2) + 1):end]] + x_data = Float32.(cat(clockwise_spirals..., anticlockwise_spirals...; dims=3)) + # Split the dataset + (x_train, y_train), (x_val, y_val) = splitobs((x_data, labels); at=0.8, shuffle=true) + # Create DataLoaders + return ( + # Use DataLoader to automatically minibatch and shuffle the data + DataLoader(collect.((x_train, y_train)); batchsize=128, shuffle=true), + # Don't shuffle the validation data + DataLoader(collect.((x_val, y_val)); batchsize=128, shuffle=false)) +end +``` + + +``` +get_dataloaders (generic function with 1 method) +``` + + + + +## Creating a Classifier + + +We will be extending the `Lux.AbstractExplicitContainerLayer` type for our custom model since it will contain a lstm block and a classifier head. + + +We pass the fieldnames `lstm_cell` and `classifier` to the type to ensure that the parameters and states are automatically populated and we don't have to define `Lux.initialparameters` and `Lux.initialstates`. + + +To understand more about container layers, please look at [Container Layer](http://lux.csail.mit.edu/stable/manual/interface/#container-layer). + + +```julia +struct SpiralClassifier{L, C} <: + Lux.AbstractExplicitContainerLayer{(:lstm_cell, :classifier)} + lstm_cell::L + classifier::C +end +``` + + +We won't define the model from scratch but rather use the [`Lux.LSTMCell`](../../api/Lux/layers#Lux.LSTMCell) and [`Lux.Dense`](../../api/Lux/layers#Lux.Dense). + + +```julia +function SpiralClassifier(in_dims, hidden_dims, out_dims) + return SpiralClassifier(LSTMCell(in_dims => hidden_dims), + Dense(hidden_dims => out_dims, sigmoid)) +end +``` + + +``` +Main.var"##292".SpiralClassifier +``` + + +We can use default Lux blocks – `Recurrence(LSTMCell(in_dims => hidden_dims)` – instead of defining the following. But let's still do it for the sake of it. + + +Now we need to define the behavior of the Classifier when it is invoked. + + +```julia +function (s::SpiralClassifier)(x::AbstractArray{T, 3}, ps::NamedTuple, + st::NamedTuple) where {T} + # First we will have to run the sequence through the LSTM Cell + # The first call to LSTM Cell will create the initial hidden state + # See that the parameters and states are automatically populated into a field called + # `lstm_cell` We use `eachslice` to get the elements in the sequence without copying, + # and `Iterators.peel` to split out the first element for LSTM initialization. + x_init, x_rest = Iterators.peel(eachslice(x; dims=2)) + (y, carry), st_lstm = s.lstm_cell(x_init, ps.lstm_cell, st.lstm_cell) + # Now that we have the hidden state and memory in `carry` we will pass the input and + # `carry` jointly + for x in x_rest + (y, carry), st_lstm = s.lstm_cell((x, carry), ps.lstm_cell, st_lstm) + end + # After running through the sequence we will pass the output through the classifier + y, st_classifier = s.classifier(y, ps.classifier, st.classifier) + # Finally remember to create the updated state + st = merge(st, (classifier=st_classifier, lstm_cell=st_lstm)) + return vec(y), st +end +``` + + + + +## Defining Accuracy, Loss and Optimiser + + +Now let's define the binarycrossentropy loss. Typically it is recommended to use `logitbinarycrossentropy` since it is more numerically stable, but for the sake of simplicity we will use `binarycrossentropy`. + + +```julia +function xlogy(x, y) + result = x * log(y) + return ifelse(iszero(x), zero(result), result) +end + +function binarycrossentropy(y_pred, y_true) + y_pred = y_pred .+ eps(eltype(y_pred)) + return mean(@. -xlogy(y_true, y_pred) - xlogy(1 - y_true, 1 - y_pred)) +end + +function compute_loss(x, y, model, ps, st) + y_pred, st = model(x, ps, st) + return binarycrossentropy(y_pred, y), y_pred, st +end + +matches(y_pred, y_true) = sum((y_pred .> 0.5) .== y_true) +accuracy(y_pred, y_true) = matches(y_pred, y_true) / length(y_pred) +``` + + +``` +accuracy (generic function with 1 method) +``` + + +Finally lets create an optimiser given the model parameters. + + +```julia +function create_optimiser(ps) + opt = Optimisers.ADAM(0.01f0) + return Optimisers.setup(opt, ps) +end +``` + + +``` +create_optimiser (generic function with 1 method) +``` + + + + +## Training the Model + + +```julia +function main() + # Get the dataloaders + (train_loader, val_loader) = get_dataloaders() + + # Create the model + model = SpiralClassifier(2, 8, 1) + rng = Random.default_rng() + Random.seed!(rng, 0) + ps, st = Lux.setup(rng, model) + + dev = gpu_device() + ps = ps |> dev + st = st |> dev + + # Create the optimiser + opt_state = create_optimiser(ps) + + for epoch in 1:25 + # Train the model + for (x, y) in train_loader + x = x |> dev + y = y |> dev + (loss, y_pred, st), back = pullback(compute_loss, x, y, model, ps, st) + gs = back((one(loss), nothing, nothing))[4] + opt_state, ps = Optimisers.update(opt_state, ps, gs) + + println("Epoch [$epoch]: Loss $loss") + end + + # Validate the model + st_ = Lux.testmode(st) + for (x, y) in val_loader + x = x |> dev + y = y |> dev + (loss, y_pred, st_) = compute_loss(x, y, model, ps, st_) + acc = accuracy(y_pred, y) + println("Validation: Loss $loss Accuracy $acc") + end + end + + return (ps, st) |> cpu_device() +end + +ps_trained, st_trained = main() +``` + + +``` +((lstm_cell = (weight_i = Float32[-0.86272717 -0.41855848; -0.25488144 -0.7554576; 0.81194 0.88417614; -0.060717788 0.07492258; -0.14560787 -0.6214816; 0.28726992 0.5537099; -0.8367183 0.07488654; 0.075617455 0.05023421; -0.040271394 0.07460806; -0.66295916 0.45245522; 1.1590421 -0.018638581; -0.01557015 0.08727935; -0.110131375 0.2460007; -0.8505593 0.3206255; -0.12882546 -0.27065384; 1.2144328 0.09751672; 0.6813812 -0.6274693; 0.1293985 -0.3447592; 0.45775387 -0.32473627; -0.55330116 0.51749605; 0.5830506 -0.8373983; 0.10388149 0.29229292; 0.87125045 -0.6382833; 0.9539108 0.6227838; -1.2410213 -0.1012869; 0.47866508 0.64182436; 1.0552616 0.6757573; -0.44898742 -0.16007604; 0.74126303 -0.70206606; -0.341981 0.7310612; -0.2194576 0.6099811; 0.6072436 -0.29751343], weight_h = Float32[-0.50946385 -0.05523664 0.29770398 -0.26363647 0.29633534 0.012232294 -0.6989898 0.54875237; -0.6525128 0.21763317 -0.06245941 0.6320603 0.38221428 0.3103854 0.13104562 -0.045845363; 0.015181419 0.061839134 -0.035465762 0.56445 -0.7394898 0.31571454 -0.6398872 -0.15911295; 0.039155457 -0.26865736 0.8871453 -0.094318725 0.91217947 0.09090359 0.28053853 0.90808827; -0.37011993 0.470783 0.77929926 0.31376335 0.40195578 0.63747793 -0.33727193 -0.07779043; -0.0617414 -0.33530304 0.33102867 -0.09426428 -0.28914702 -0.21894546 -0.49396008 0.039075524; -0.78993565 0.37350705 0.6901891 0.5135023 -0.81103915 0.63807184 0.025485966 -0.62420785; 0.68960416 0.31033367 1.0685257 -1.308396 0.8083266 0.16446306 -0.7174788 1.1411937; -0.16245641 0.47428873 0.42176875 -0.5011314 0.45832467 0.6811534 0.17607468 0.6355338; -0.4195751 -0.18595439 -0.3819232 -0.009000218 0.24216515 -0.0007663722 -0.7473917 0.74570787; -0.15016524 0.55291617 -0.046573695 0.52833015 -0.51834303 0.29471338 -0.2700799 -0.37396914; 0.05758925 0.88249654 0.28809658 -0.10861943 0.82896286 0.63699615 0.3919894 0.49989682; 0.6509513 0.48971224 0.37300846 -0.07026526 0.92157966 0.17078571 -0.6615836 0.4424281; -0.09841804 0.44286194 0.08741717 0.08902475 0.6085442 -0.015684843 -0.13743892 -0.4014785; -0.83457863 0.32618842 0.08230981 -0.39875147 -0.26210332 0.8022466 -0.37039688 0.41628498; -0.638079 0.7882055 0.4106253 1.0490699 -0.08921659 0.8163901 -0.10338864 0.7615437; 0.14755537 -0.6404792 -0.0524175 -0.43854266 -0.35584763 -0.21768114 -0.1640769 0.17505576; -0.44021055 0.2299016 0.19706605 0.7161957 0.39706978 -0.35587388 -0.36145315 0.66713595; -0.55504405 0.7082947 0.09374417 -0.43020275 -0.311629 0.74164724 0.049625102 0.6035831; -0.77624804 0.34035936 -0.16733459 0.5050406 -0.697383 -0.13940461 -0.19988883 -0.19642702; -0.26993096 -0.6649897 0.39980587 -0.6425923 -0.16876264 0.26472154 0.24972232 -0.12285314; -0.72799456 -0.4254808 0.5353063 -0.47821805 -0.14081313 0.02959711 -0.44370294 0.21856986; 0.48440346 -0.1820644 -0.6614255 0.26411277 0.33903366 0.072495595 -0.52249295 -0.4151637; -0.42017907 0.35773116 0.22188015 0.3761333 -0.29926494 -0.18965238 -0.7500703 0.03684805; -0.6523269 0.55150455 0.26986343 -0.4483836 0.59605986 0.43549046 -0.9571445 0.868551; -0.6051633 0.27267644 0.069127336 0.4296392 -0.26480246 0.56443334 -0.41518083 -0.30549547; -0.81930685 -0.2757817 0.46150422 -0.2717487 0.2410456 0.011440669 -0.89222074 0.74751216; 0.2677257 0.27393195 1.0197583 -0.90465415 0.24737261 0.18145163 -1.1270729 0.48435083; -0.36578697 0.27589232 0.7692802 -0.42792156 0.4506358 0.90219325 -1.1877058 0.70722985; 0.4454312 0.39083883 -0.6898794 0.63207716 -1.204451 -0.37854874 -0.15158348 -0.056801792; -0.43034446 0.51790494 -0.2561045 0.71443653 -0.81789225 -0.12550327 0.086710185 -0.083881766; -0.55260825 0.75048345 0.68683296 -0.53730565 0.6441924 0.058408502 -0.4945418 0.64423424], bias = Float32[0.28972942; 0.27388766; 0.13954552; 0.32456166; 0.34409583; 0.12031705; 0.01085326; 0.9734937; 0.38004303; 0.15640971; 0.008482361; 0.35706598; 0.43170792; 0.06847647; -0.013940505; 0.3173626; 0.8432516; 1.1305679; 1.1577541; 0.7688083; 0.6890515; 1.2385406; 0.6430483; 0.9121523; 0.4754116; 0.046972442; 0.300515; 0.620378; 0.63237596; 0.015998563; -0.11815498; 0.8805222;;]), classifier = (weight = Float32[-1.4337368 0.7590189 1.2381686 1.2605945 -0.93391955 0.116178356 -0.2640183 1.230137], bias = Float32[-0.63698786;;])), (lstm_cell = (rng = Random.Xoshiro(0x2026f555c226bf09, 0x8a6bb764b93cadda, 0x5ba3c10439600514, 0x446f763658f71987),), classifier = NamedTuple())) +``` + + + + +## Saving the Model + + +We can save the model using JLD2 (and any other serialization library of your choice) Note that we transfer the model to CPU before saving. Additionally, we recommend that you don't save the model + + +```julia +@save "trained_model.jld2" {compress = true} ps_trained st_trained +``` + + +Let's try loading the model + + +```julia +@load "trained_model.jld2" ps_trained st_trained +``` + + +``` +2-element Vector{Symbol}: + :ps_trained + :st_trained +``` + + +--- + + +*This page was generated using [Literate.jl](https://github.com/fredrikekre/Literate.jl).* + diff --git a/previews/PR467/tutorials/beginner/trained_model.jld2 b/previews/PR467/tutorials/beginner/trained_model.jld2 new file mode 100644 index 0000000000000000000000000000000000000000..28352529bbe1d039be47bc494e999fb60f32f5ee GIT binary patch literal 11307 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 +import { VPTeamPage, VPTeamPageTitle, VPTeamMembers, VPTeamPageSection } from 'vitepress/theme' + +const beginners = [ + { + avatar: 'https://github.com/LuxDL.png', + name: 'Julia & Lux for the Uninitiated', + desc: 'A tutorial on how to get started with Julia and Lux for those who have never used Julia before.', + links: [ + { + icon: { + svg: '' + }, + link: 'beginner/1_Basics' } + ] + }, + { + avatar: 'https://github.com/LuxDL.png', + name: 'Fitting a Polynomial using MLP', + desc: 'Learn the Basics of Lux by fitting a Multi-Layer Perceptron to a Polynomial.', + links: [ + { + icon: { + svg: '' + }, + link: 'beginner/2_PolynomialFitting' } + ] + }, + { + avatar: 'https://github.com/LuxDL.png', + name: 'Training a Simple LSTM', + desc: 'Learn the API for defining Recurrent Models in Lux.', + links: [ + { + icon: { + svg: '' + }, + link: 'beginner/3_SimpleRNN' } + ] + } +]; + +const intermediate = [ + { + avatar: 'https://github.com/LuxDL.png', + name: 'MNIST Classification using Neural ODE', + desc: 'Train a Neural ODE to classify MNIST Images.', + links: [ + { + icon: { + svg: '' + }, + link: 'intermediate/1_NeuralODE' } + ] + }, + { + avatar: 'https://github.com/LuxDL.png', + name: 'Bayesian Neural Networks', + desc: 'Figure out how to use Probabilistic Programming Frameworks like Turing with Lux.', + links: [ + { + icon: { + svg: '' + }, + link: 'intermediate/2_BayesianNN' } + ] + }, + { + avatar: 'https://github.com/LuxDL.png', + name: 'Training a HyperNetwork', + desc: 'In this tutorial we will train a hypernetwork to work on multiple datasets by predicting neural network parameters.', + links: [ + { + icon: { + svg: '' + }, + link: 'intermediate/3_HyperNet' } + ] + } +]; + +const advanced = [ + { + avatar: 'https://github.com/LuxDL.png', + name: 'Neural ODE to Model Gravitational Waveforms', + desc: 'Training a Neural ODE to fit simulated data of gravitational waveforms.', + links: [ + { + icon: { + svg: '' + }, + link: 'advanced/1_GravitationalWaveForm' } + ] + } +]; + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/previews/PR467/tutorials/intermediate/1_NeuralODE.md b/previews/PR467/tutorials/intermediate/1_NeuralODE.md new file mode 100644 index 0000000000..b51473ed5e --- /dev/null +++ b/previews/PR467/tutorials/intermediate/1_NeuralODE.md @@ -0,0 +1,436 @@ + + + + + +# MNIST Classification using Neural ODEs + + +To understand Neural ODEs, users should look up [these lecture notes](https://book.sciml.ai/notes/11-Differentiable_Programming_and_Neural_Differential_Equations/). We recommend users to directly use [DiffEqFlux.jl](https://docs.sciml.ai/DiffEqFlux/stable/), instead of implementing Neural ODEs from scratch. + + + + +## Package Imports + + +```julia +using Lux, ComponentArrays, SciMLSensitivity, LuxAMDGPU, LuxCUDA, Optimisers, + OrdinaryDiffEq, Random, Statistics, Zygote, OneHotArrays, InteractiveUtils +import MLDatasets: MNIST +import MLUtils: DataLoader, splitobs +CUDA.allowscalar(false) +``` + + + + +## Loading MNIST + + +```julia +function loadmnist(batchsize, train_split) + # Load MNIST: Only 1500 for demonstration purposes + N = 1500 + dataset = MNIST(; split=:train) + imgs = dataset.features[:, :, 1:N] + labels_raw = dataset.targets[1:N] + + # Process images into (H,W,C,BS) batches + x_data = Float32.(reshape(imgs, size(imgs, 1), size(imgs, 2), 1, size(imgs, 3))) + y_data = onehotbatch(labels_raw, 0:9) + (x_train, y_train), (x_test, y_test) = splitobs((x_data, y_data); at=train_split) + + return ( + # Use DataLoader to automatically minibatch and shuffle the data + DataLoader(collect.((x_train, y_train)); batchsize, shuffle=true), + # Don't shuffle the test data + DataLoader(collect.((x_test, y_test)); batchsize, shuffle=false)) +end +``` + + +``` +loadmnist (generic function with 1 method) +``` + + + + +## Define the Neural ODE Layer + + +The NeuralODE is a ContainerLayer, which stores a `model`. The parameters and states of the NeuralODE are same as those of the underlying model. + + +```julia +struct NeuralODE{M <: Lux.AbstractExplicitLayer, So, Se, T, K} <: + Lux.AbstractExplicitContainerLayer{(:model,)} + model::M + solver::So + sensealg::Se + tspan::T + kwargs::K +end + +function NeuralODE(model::Lux.AbstractExplicitLayer; solver=Tsit5(), tspan=(0.0f0, 1.0f0), + sensealg=InterpolatingAdjoint(; autojacvec=ZygoteVJP()), kwargs...) + return NeuralODE(model, solver, sensealg, tspan, kwargs) +end +``` + + +``` +Main.var"##292".NeuralODE +``` + + +OrdinaryDiffEq.jl can deal with non-Vector Inputs! However, certain discrete sensitivities like `ReverseDiffAdjoint` can't handle non-Vector inputs. Hence, we need to convert the input and output of the ODE solver to a Vector. + + +```julia +function (n::NeuralODE)(x, ps, st) + function dudt(u, p, t) + u_, st = n.model(reshape(u, size(x)), p, st) + return vec(u_) + end + prob = ODEProblem{false}(ODEFunction{false}(dudt), vec(x), n.tspan, ps) + return solve(prob, n.solver; sensealg=n.sensealg, n.kwargs...), st +end + +@views diffeqsol_to_array(l::Int, x::ODESolution) = reshape(last(x.u), (l, :)) +@views diffeqsol_to_array(l::Int, x::AbstractMatrix) = reshape(x[:, end], (l, :)) +``` + + +``` +diffeqsol_to_array (generic function with 2 methods) +``` + + + + +## Create and Initialize the Neural ODE Layer + + +```julia +function create_model(model_fn=NeuralODE; dev=gpu_device(), use_named_tuple::Bool=false, + sensealg=InterpolatingAdjoint(; autojacvec=ZygoteVJP())) + # Construct the Neural ODE Model + model = Chain(FlattenLayer(), + Dense(784 => 20, tanh), + model_fn(Chain(Dense(20 => 10, tanh), Dense(10 => 10, tanh), Dense(10 => 20, tanh)); + save_everystep=false, reltol=1.0f-3, abstol=1.0f-3, save_start=false, + sensealg), + Base.Fix1(diffeqsol_to_array, 20), + Dense(20 => 10)) + + rng = Random.default_rng() + Random.seed!(rng, 0) + + ps, st = Lux.setup(rng, model) + ps = (use_named_tuple ? ps : ComponentArray(ps)) |> dev + st = st |> dev + + return model, ps, st +end +``` + + +``` +create_model (generic function with 2 methods) +``` + + + + +## Define Utility Functions + + +```julia +logitcrossentropy(y_pred, y) = mean(-sum(y .* logsoftmax(y_pred); dims=1)) + +function loss(x, y, model, ps, st) + y_pred, st = model(x, ps, st) + return logitcrossentropy(y_pred, y), st +end + +function accuracy(model, ps, st, dataloader; dev=gpu_device()) + total_correct, total = 0, 0 + st = Lux.testmode(st) + cpu_dev = cpu_device() + for (x, y) in dataloader + target_class = onecold(y) + predicted_class = onecold(cpu_dev(first(model(dev(x), ps, st)))) + total_correct += sum(target_class .== predicted_class) + total += length(target_class) + end + return total_correct / total +end +``` + + +``` +accuracy (generic function with 1 method) +``` + + + + +## Training + + +```julia +function train(model_function; cpu::Bool=false, kwargs...) + dev = cpu ? cpu_device() : gpu_device() + model, ps, st = create_model(model_function; dev, kwargs...) + + # Training + train_dataloader, test_dataloader = loadmnist(128, 0.9) + + opt = Adam(0.001f0) + st_opt = Optimisers.setup(opt, ps) + + ### Warmup the Model + img = dev(train_dataloader.data[1][:, :, :, 1:1]) + lab = dev(train_dataloader.data[2][:, 1:1]) + loss(img, lab, model, ps, st) + (l, _), back = pullback(p -> loss(img, lab, model, p, st), ps) + back((one(l), nothing)) + + ### Lets train the model + nepochs = 9 + for epoch in 1:nepochs + stime = time() + for (x, y) in train_dataloader + x = dev(x) + y = dev(y) + (l, st), back = pullback(p -> loss(x, y, model, p, st), ps) + ### We need to add `nothing`s equal to the number of returned values - 1 + gs = back((one(l), nothing))[1] + st_opt, ps = Optimisers.update(st_opt, ps, gs) + end + ttime = time() - stime + + println("[$epoch/$nepochs] \t Time $(round(ttime; digits=2))s \t Training Accuracy: " * + "$(round(accuracy(model, ps, st, train_dataloader; dev) * 100; digits=2))% \t " * + "Test Accuracy: $(round(accuracy(model, ps, st, test_dataloader; dev) * 100; digits=2))%") + end +end + +train(NeuralODE) +``` + + +``` +[1/9] Time 6.44s Training Accuracy: 49.19% Test Accuracy: 41.33% +[2/9] Time 0.38s Training Accuracy: 70.89% Test Accuracy: 66.67% +[3/9] Time 0.46s Training Accuracy: 77.63% Test Accuracy: 71.33% +[4/9] Time 0.32s Training Accuracy: 80.74% Test Accuracy: 74.67% +[5/9] Time 0.33s Training Accuracy: 82.37% Test Accuracy: 77.33% +[6/9] Time 0.44s Training Accuracy: 84.59% Test Accuracy: 79.33% +[7/9] Time 0.43s Training Accuracy: 85.78% Test Accuracy: 80.67% +[8/9] Time 0.46s Training Accuracy: 86.81% Test Accuracy: 82.67% +[9/9] Time 0.43s Training Accuracy: 87.33% Test Accuracy: 82.67% + +``` + + +We can also change the sensealg and train the model! `GaussAdjoint` allows you to use any arbitrary parameter structure and not just a flat vector (`ComponentArray`). + + +```julia +train(NeuralODE; sensealg=GaussAdjoint(; autojacvec=ZygoteVJP()), use_named_tuple=true) +``` + + +``` +[1/9] Time 2.78s Training Accuracy: 49.26% Test Accuracy: 38.67% +[2/9] Time 0.35s Training Accuracy: 69.26% Test Accuracy: 64.0% +[3/9] Time 0.43s Training Accuracy: 78.0% Test Accuracy: 72.0% +[4/9] Time 0.43s Training Accuracy: 80.15% Test Accuracy: 74.67% +[5/9] Time 0.33s Training Accuracy: 82.37% Test Accuracy: 77.33% +[6/9] Time 0.33s Training Accuracy: 84.52% Test Accuracy: 78.67% +[7/9] Time 0.33s Training Accuracy: 85.85% Test Accuracy: 80.0% +[8/9] Time 0.43s Training Accuracy: 86.59% Test Accuracy: 82.0% +[9/9] Time 0.43s Training Accuracy: 87.48% Test Accuracy: 82.0% + +``` + + +But remember some AD backends like `ReverseDiff` is not GPU compatible. For a model this size, you will notice that training time is significantly lower for training on CPU than on GPU. + + +```julia +train(NeuralODE; sensealg=InterpolatingAdjoint(; autojacvec=ReverseDiffVJP()), cpu=true) +``` + + +``` +[1/9] Time 6.59s Training Accuracy: 50.96% Test Accuracy: 43.33% +[2/9] Time 0.12s Training Accuracy: 69.63% Test Accuracy: 66.0% +[3/9] Time 0.07s Training Accuracy: 77.93% Test Accuracy: 71.33% +[4/9] Time 0.09s Training Accuracy: 80.74% Test Accuracy: 76.67% +[5/9] Time 0.09s Training Accuracy: 82.52% Test Accuracy: 78.0% +[6/9] Time 0.09s Training Accuracy: 84.07% Test Accuracy: 78.67% +[7/9] Time 0.09s Training Accuracy: 85.33% Test Accuracy: 80.67% +[8/9] Time 0.09s Training Accuracy: 86.59% Test Accuracy: 81.33% +[9/9] Time 0.1s Training Accuracy: 87.7% Test Accuracy: 82.0% + +``` + + +For completeness, let's also test out discrete sensitivities! + + +```julia +train(NeuralODE; sensealg=ReverseDiffAdjoint(), cpu=true) +``` + + +``` +[1/9] Time 4.76s Training Accuracy: 50.96% Test Accuracy: 43.33% +[2/9] Time 4.28s Training Accuracy: 69.63% Test Accuracy: 66.0% +[3/9] Time 4.27s Training Accuracy: 77.93% Test Accuracy: 71.33% +[4/9] Time 4.28s Training Accuracy: 80.74% Test Accuracy: 76.67% +[5/9] Time 4.98s Training Accuracy: 82.52% Test Accuracy: 78.0% +[6/9] Time 5.55s Training Accuracy: 84.07% Test Accuracy: 78.67% +[7/9] Time 5.71s Training Accuracy: 85.33% Test Accuracy: 80.67% +[8/9] Time 5.72s Training Accuracy: 86.59% Test Accuracy: 81.33% +[9/9] Time 5.67s Training Accuracy: 87.7% Test Accuracy: 82.0% + +``` + + + + +## Alternate Implementation using Stateful Layer + + +Starting `v0.5.5`, Lux provides a `Lux.Experimental.StatefulLuxLayer` which can be used to avoid the [`Box`ing of `st`](https://github.com/JuliaLang/julia/issues/15276). + + +```julia +struct StatefulNeuralODE{M <: Lux.AbstractExplicitLayer, So, Se, T, K} <: + Lux.AbstractExplicitContainerLayer{(:model,)} + model::M + solver::So + sensealg::Se + tspan::T + kwargs::K +end + +function StatefulNeuralODE(model::Lux.AbstractExplicitLayer; solver=Tsit5(), + tspan=(0.0f0, 1.0f0), sensealg=InterpolatingAdjoint(; autojacvec=ZygoteVJP()), + kwargs...) + return StatefulNeuralODE(model, solver, sensealg, tspan, kwargs) +end + +function (n::StatefulNeuralODE)(x, ps, st) + st_model = Lux.Experimental.StatefulLuxLayer(n.model, ps, st) + dudt(u, p, t) = st_model(u, p) + prob = ODEProblem{false}(ODEFunction{false}(dudt), x, n.tspan, ps) + return solve(prob, n.solver; sensealg=n.sensealg, n.kwargs...), st_model.st +end +``` + + + + +## Train the new Stateful Neural ODE + + +```julia +train(StatefulNeuralODE) +``` + + +``` +[1/9] Time 1.27s Training Accuracy: 51.63% Test Accuracy: 45.33% +[2/9] Time 0.53s Training Accuracy: 70.89% Test Accuracy: 66.0% +[3/9] Time 0.3s Training Accuracy: 77.56% Test Accuracy: 72.67% +[4/9] Time 0.37s Training Accuracy: 80.67% Test Accuracy: 76.0% +[5/9] Time 0.37s Training Accuracy: 82.81% Test Accuracy: 78.0% +[6/9] Time 0.38s Training Accuracy: 84.3% Test Accuracy: 80.0% +[7/9] Time 0.38s Training Accuracy: 85.56% Test Accuracy: 80.0% +[8/9] Time 0.38s Training Accuracy: 86.89% Test Accuracy: 82.0% +[9/9] Time 0.38s Training Accuracy: 87.78% Test Accuracy: 82.67% + +``` + + +We might not see a significant difference in the training time, but let us investigate the type stabilities of the layers. + + + + +## Type Stability + + +```julia +model, ps, st = create_model(NeuralODE) + +model_stateful, ps_stateful, st_stateful = create_model(StatefulNeuralODE) + +x = gpu_device()(ones(Float32, 28, 28, 1, 3)); +``` + + +NeuralODE is not type stable due to the boxing of `st` + + +```julia +@code_warntype model(x, ps, st) +``` + + +``` +MethodInstance for (::Lux.Chain{NamedTuple{(:layer_1, :layer_2, :layer_3, :layer_4, :layer_5), Tuple{Lux.FlattenLayer, Lux.Dense{true, typeof(NNlib.tanh_fast), typeof(WeightInitializers.glorot_uniform), typeof(WeightInitializers.zeros32)}, Main.var"##292".NeuralODE{Lux.Chain{NamedTuple{(:layer_1, :layer_2, :layer_3), Tuple{Lux.Dense{true, typeof(NNlib.tanh_fast), typeof(WeightInitializers.glorot_uniform), typeof(WeightInitializers.zeros32)}, Lux.Dense{true, typeof(NNlib.tanh_fast), typeof(WeightInitializers.glorot_uniform), typeof(WeightInitializers.zeros32)}, Lux.Dense{true, typeof(NNlib.tanh_fast), typeof(WeightInitializers.glorot_uniform), typeof(WeightInitializers.zeros32)}}}, Nothing}, OrdinaryDiffEq.Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, SciMLSensitivity.InterpolatingAdjoint{0, true, Val{:central}, SciMLSensitivity.ZygoteVJP}, Tuple{Float32, Float32}, Base.Pairs{Symbol, Real, NTuple{4, Symbol}, NamedTuple{(:save_everystep, :reltol, :abstol, :save_start), Tuple{Bool, Float32, Float32, Bool}}}}, Lux.WrappedFunction{Base.Fix1{typeof(Main.var"##292".diffeqsol_to_array), Int64}}, Lux.Dense{true, typeof(identity), typeof(WeightInitializers.glorot_uniform), typeof(WeightInitializers.zeros32)}}}, Nothing})(::CUDA.CuArray{Float32, 4, CUDA.Mem.DeviceBuffer}, ::ComponentArrays.ComponentVector{Float32, CUDA.CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, Tuple{ComponentArrays.Axis{(layer_1 = 1:0, layer_2 = ViewAxis(1:15700, Axis(weight = ViewAxis(1:15680, ShapedAxis((20, 784), NamedTuple())), bias = ViewAxis(15681:15700, ShapedAxis((20, 1), NamedTuple())))), layer_3 = ViewAxis(15701:16240, Axis(layer_1 = ViewAxis(1:210, Axis(weight = ViewAxis(1:200, ShapedAxis((10, 20), NamedTuple())), bias = ViewAxis(201:210, ShapedAxis((10, 1), NamedTuple())))), layer_2 = ViewAxis(211:320, Axis(weight = ViewAxis(1:100, ShapedAxis((10, 10), NamedTuple())), bias = ViewAxis(101:110, ShapedAxis((10, 1), NamedTuple())))), layer_3 = ViewAxis(321:540, Axis(weight = ViewAxis(1:200, ShapedAxis((20, 10), NamedTuple())), bias = ViewAxis(201:220, ShapedAxis((20, 1), NamedTuple())))))), layer_4 = 16241:16240, layer_5 = ViewAxis(16241:16450, Axis(weight = ViewAxis(1:200, ShapedAxis((10, 20), NamedTuple())), bias = ViewAxis(201:210, ShapedAxis((10, 1), NamedTuple())))))}}}, ::NamedTuple{(:layer_1, :layer_2, :layer_3, :layer_4, :layer_5), Tuple{NamedTuple{(), Tuple{}}, NamedTuple{(), Tuple{}}, NamedTuple{(:layer_1, :layer_2, :layer_3), Tuple{NamedTuple{(), Tuple{}}, NamedTuple{(), Tuple{}}, NamedTuple{(), Tuple{}}}}, NamedTuple{(), Tuple{}}, NamedTuple{(), Tuple{}}}}) + from (c::Lux.Chain)(x, ps, st::NamedTuple) @ Lux /var/lib/buildkite-agent/builds/gpuci-11/julialang/lux-dot-jl/src/layers/containers.jl:478 +Arguments + c::Lux.Chain{NamedTuple{(:layer_1, :layer_2, :layer_3, :layer_4, :layer_5), Tuple{Lux.FlattenLayer, Lux.Dense{true, typeof(NNlib.tanh_fast), typeof(WeightInitializers.glorot_uniform), typeof(WeightInitializers.zeros32)}, Main.var"##292".NeuralODE{Lux.Chain{NamedTuple{(:layer_1, :layer_2, :layer_3), Tuple{Lux.Dense{true, typeof(NNlib.tanh_fast), typeof(WeightInitializers.glorot_uniform), typeof(WeightInitializers.zeros32)}, Lux.Dense{true, typeof(NNlib.tanh_fast), typeof(WeightInitializers.glorot_uniform), typeof(WeightInitializers.zeros32)}, Lux.Dense{true, typeof(NNlib.tanh_fast), typeof(WeightInitializers.glorot_uniform), typeof(WeightInitializers.zeros32)}}}, Nothing}, OrdinaryDiffEq.Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, SciMLSensitivity.InterpolatingAdjoint{0, true, Val{:central}, SciMLSensitivity.ZygoteVJP}, Tuple{Float32, Float32}, Base.Pairs{Symbol, Real, NTuple{4, Symbol}, NamedTuple{(:save_everystep, :reltol, :abstol, :save_start), Tuple{Bool, Float32, Float32, Bool}}}}, Lux.WrappedFunction{Base.Fix1{typeof(Main.var"##292".diffeqsol_to_array), Int64}}, Lux.Dense{true, typeof(identity), typeof(WeightInitializers.glorot_uniform), typeof(WeightInitializers.zeros32)}}}, Nothing} + x::CUDA.CuArray{Float32, 4, CUDA.Mem.DeviceBuffer} + ps::ComponentArrays.ComponentVector{Float32, CUDA.CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, Tuple{ComponentArrays.Axis{(layer_1 = 1:0, layer_2 = ViewAxis(1:15700, Axis(weight = ViewAxis(1:15680, ShapedAxis((20, 784), NamedTuple())), bias = ViewAxis(15681:15700, ShapedAxis((20, 1), NamedTuple())))), layer_3 = ViewAxis(15701:16240, Axis(layer_1 = ViewAxis(1:210, Axis(weight = ViewAxis(1:200, ShapedAxis((10, 20), NamedTuple())), bias = ViewAxis(201:210, ShapedAxis((10, 1), NamedTuple())))), layer_2 = ViewAxis(211:320, Axis(weight = ViewAxis(1:100, ShapedAxis((10, 10), NamedTuple())), bias = ViewAxis(101:110, ShapedAxis((10, 1), NamedTuple())))), layer_3 = ViewAxis(321:540, Axis(weight = ViewAxis(1:200, ShapedAxis((20, 10), NamedTuple())), bias = ViewAxis(201:220, ShapedAxis((20, 1), NamedTuple())))))), layer_4 = 16241:16240, layer_5 = ViewAxis(16241:16450, Axis(weight = ViewAxis(1:200, ShapedAxis((10, 20), NamedTuple())), bias = ViewAxis(201:210, ShapedAxis((10, 1), NamedTuple())))))}}} + st::Core.Const((layer_1 = NamedTuple(), layer_2 = NamedTuple(), layer_3 = (layer_1 = NamedTuple(), layer_2 = NamedTuple(), layer_3 = NamedTuple()), layer_4 = NamedTuple(), layer_5 = NamedTuple())) +Body::TUPLE{CUDA.CUARRAY{FLOAT32, 2, CUDA.MEM.DEVICEBUFFER}, NAMEDTUPLE{(:LAYER_1, :LAYER_2, :LAYER_3, :LAYER_4, :LAYER_5), _A} WHERE _A<:TUPLE{NAMEDTUPLE{(), TUPLE{}}, NAMEDTUPLE{(), TUPLE{}}, ANY, NAMEDTUPLE{(), TUPLE{}}, NAMEDTUPLE{(), TUPLE{}}}} +1 ─ %1 = Base.getproperty(c, :layers)::NamedTuple{(:layer_1, :layer_2, :layer_3, :layer_4, :layer_5), Tuple{Lux.FlattenLayer, Lux.Dense{true, typeof(NNlib.tanh_fast), typeof(WeightInitializers.glorot_uniform), typeof(WeightInitializers.zeros32)}, Main.var"##292".NeuralODE{Lux.Chain{NamedTuple{(:layer_1, :layer_2, :layer_3), Tuple{Lux.Dense{true, typeof(NNlib.tanh_fast), typeof(WeightInitializers.glorot_uniform), typeof(WeightInitializers.zeros32)}, Lux.Dense{true, typeof(NNlib.tanh_fast), typeof(WeightInitializers.glorot_uniform), typeof(WeightInitializers.zeros32)}, Lux.Dense{true, typeof(NNlib.tanh_fast), typeof(WeightInitializers.glorot_uniform), typeof(WeightInitializers.zeros32)}}}, Nothing}, OrdinaryDiffEq.Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, SciMLSensitivity.InterpolatingAdjoint{0, true, Val{:central}, SciMLSensitivity.ZygoteVJP}, Tuple{Float32, Float32}, Base.Pairs{Symbol, Real, NTuple{4, Symbol}, NamedTuple{(:save_everystep, :reltol, :abstol, :save_start), Tuple{Bool, Float32, Float32, Bool}}}}, Lux.WrappedFunction{Base.Fix1{typeof(Main.var"##292".diffeqsol_to_array), Int64}}, Lux.Dense{true, typeof(identity), typeof(WeightInitializers.glorot_uniform), typeof(WeightInitializers.zeros32)}}} +│ %2 = Lux.applychain(%1, x, ps, st)::TUPLE{CUDA.CUARRAY{FLOAT32, 2, CUDA.MEM.DEVICEBUFFER}, NAMEDTUPLE{(:LAYER_1, :LAYER_2, :LAYER_3, :LAYER_4, :LAYER_5), _A} WHERE _A<:TUPLE{NAMEDTUPLE{(), TUPLE{}}, NAMEDTUPLE{(), TUPLE{}}, ANY, NAMEDTUPLE{(), TUPLE{}}, NAMEDTUPLE{(), TUPLE{}}}} +└── return %2 + + +``` + + +We avoid the problem entirely by using `StatefulNeuralODE` + + +```julia +@code_warntype model_stateful(x, ps_stateful, st_stateful) +``` + + +``` +MethodInstance for (::Lux.Chain{NamedTuple{(:layer_1, :layer_2, :layer_3, :layer_4, :layer_5), Tuple{Lux.FlattenLayer, Lux.Dense{true, typeof(NNlib.tanh_fast), typeof(WeightInitializers.glorot_uniform), typeof(WeightInitializers.zeros32)}, Main.var"##292".StatefulNeuralODE{Lux.Chain{NamedTuple{(:layer_1, :layer_2, :layer_3), Tuple{Lux.Dense{true, typeof(NNlib.tanh_fast), typeof(WeightInitializers.glorot_uniform), typeof(WeightInitializers.zeros32)}, Lux.Dense{true, typeof(NNlib.tanh_fast), typeof(WeightInitializers.glorot_uniform), typeof(WeightInitializers.zeros32)}, Lux.Dense{true, typeof(NNlib.tanh_fast), typeof(WeightInitializers.glorot_uniform), typeof(WeightInitializers.zeros32)}}}, Nothing}, OrdinaryDiffEq.Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, SciMLSensitivity.InterpolatingAdjoint{0, true, Val{:central}, SciMLSensitivity.ZygoteVJP}, Tuple{Float32, Float32}, Base.Pairs{Symbol, Real, NTuple{4, Symbol}, NamedTuple{(:save_everystep, :reltol, :abstol, :save_start), Tuple{Bool, Float32, Float32, Bool}}}}, Lux.WrappedFunction{Base.Fix1{typeof(Main.var"##292".diffeqsol_to_array), Int64}}, Lux.Dense{true, typeof(identity), typeof(WeightInitializers.glorot_uniform), typeof(WeightInitializers.zeros32)}}}, Nothing})(::CUDA.CuArray{Float32, 4, CUDA.Mem.DeviceBuffer}, ::ComponentArrays.ComponentVector{Float32, CUDA.CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, Tuple{ComponentArrays.Axis{(layer_1 = 1:0, layer_2 = ViewAxis(1:15700, Axis(weight = ViewAxis(1:15680, ShapedAxis((20, 784), NamedTuple())), bias = ViewAxis(15681:15700, ShapedAxis((20, 1), NamedTuple())))), layer_3 = ViewAxis(15701:16240, Axis(layer_1 = ViewAxis(1:210, Axis(weight = ViewAxis(1:200, ShapedAxis((10, 20), NamedTuple())), bias = ViewAxis(201:210, ShapedAxis((10, 1), NamedTuple())))), layer_2 = ViewAxis(211:320, Axis(weight = ViewAxis(1:100, ShapedAxis((10, 10), NamedTuple())), bias = ViewAxis(101:110, ShapedAxis((10, 1), NamedTuple())))), layer_3 = ViewAxis(321:540, Axis(weight = ViewAxis(1:200, ShapedAxis((20, 10), NamedTuple())), bias = ViewAxis(201:220, ShapedAxis((20, 1), NamedTuple())))))), layer_4 = 16241:16240, layer_5 = ViewAxis(16241:16450, Axis(weight = ViewAxis(1:200, ShapedAxis((10, 20), NamedTuple())), bias = ViewAxis(201:210, ShapedAxis((10, 1), NamedTuple())))))}}}, ::NamedTuple{(:layer_1, :layer_2, :layer_3, :layer_4, :layer_5), Tuple{NamedTuple{(), Tuple{}}, NamedTuple{(), Tuple{}}, NamedTuple{(:layer_1, :layer_2, :layer_3), Tuple{NamedTuple{(), Tuple{}}, NamedTuple{(), Tuple{}}, NamedTuple{(), Tuple{}}}}, NamedTuple{(), Tuple{}}, NamedTuple{(), Tuple{}}}}) + from (c::Lux.Chain)(x, ps, st::NamedTuple) @ Lux /var/lib/buildkite-agent/builds/gpuci-11/julialang/lux-dot-jl/src/layers/containers.jl:478 +Arguments + c::Lux.Chain{NamedTuple{(:layer_1, :layer_2, :layer_3, :layer_4, :layer_5), Tuple{Lux.FlattenLayer, Lux.Dense{true, typeof(NNlib.tanh_fast), typeof(WeightInitializers.glorot_uniform), typeof(WeightInitializers.zeros32)}, Main.var"##292".StatefulNeuralODE{Lux.Chain{NamedTuple{(:layer_1, :layer_2, :layer_3), Tuple{Lux.Dense{true, typeof(NNlib.tanh_fast), typeof(WeightInitializers.glorot_uniform), typeof(WeightInitializers.zeros32)}, Lux.Dense{true, typeof(NNlib.tanh_fast), typeof(WeightInitializers.glorot_uniform), typeof(WeightInitializers.zeros32)}, Lux.Dense{true, typeof(NNlib.tanh_fast), typeof(WeightInitializers.glorot_uniform), typeof(WeightInitializers.zeros32)}}}, Nothing}, OrdinaryDiffEq.Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, SciMLSensitivity.InterpolatingAdjoint{0, true, Val{:central}, SciMLSensitivity.ZygoteVJP}, Tuple{Float32, Float32}, Base.Pairs{Symbol, Real, NTuple{4, Symbol}, NamedTuple{(:save_everystep, :reltol, :abstol, :save_start), Tuple{Bool, Float32, Float32, Bool}}}}, Lux.WrappedFunction{Base.Fix1{typeof(Main.var"##292".diffeqsol_to_array), Int64}}, Lux.Dense{true, typeof(identity), typeof(WeightInitializers.glorot_uniform), typeof(WeightInitializers.zeros32)}}}, Nothing} + x::CUDA.CuArray{Float32, 4, CUDA.Mem.DeviceBuffer} + ps::ComponentArrays.ComponentVector{Float32, CUDA.CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, Tuple{ComponentArrays.Axis{(layer_1 = 1:0, layer_2 = ViewAxis(1:15700, Axis(weight = ViewAxis(1:15680, ShapedAxis((20, 784), NamedTuple())), bias = ViewAxis(15681:15700, ShapedAxis((20, 1), NamedTuple())))), layer_3 = ViewAxis(15701:16240, Axis(layer_1 = ViewAxis(1:210, Axis(weight = ViewAxis(1:200, ShapedAxis((10, 20), NamedTuple())), bias = ViewAxis(201:210, ShapedAxis((10, 1), NamedTuple())))), layer_2 = ViewAxis(211:320, Axis(weight = ViewAxis(1:100, ShapedAxis((10, 10), NamedTuple())), bias = ViewAxis(101:110, ShapedAxis((10, 1), NamedTuple())))), layer_3 = ViewAxis(321:540, Axis(weight = ViewAxis(1:200, ShapedAxis((20, 10), NamedTuple())), bias = ViewAxis(201:220, ShapedAxis((20, 1), NamedTuple())))))), layer_4 = 16241:16240, layer_5 = ViewAxis(16241:16450, Axis(weight = ViewAxis(1:200, ShapedAxis((10, 20), NamedTuple())), bias = ViewAxis(201:210, ShapedAxis((10, 1), NamedTuple())))))}}} + st::Core.Const((layer_1 = NamedTuple(), layer_2 = NamedTuple(), layer_3 = (layer_1 = NamedTuple(), layer_2 = NamedTuple(), layer_3 = NamedTuple()), layer_4 = NamedTuple(), layer_5 = NamedTuple())) +Body::Tuple{CUDA.CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}, NamedTuple{(:layer_1, :layer_2, :layer_3, :layer_4, :layer_5), Tuple{NamedTuple{(), Tuple{}}, NamedTuple{(), Tuple{}}, NamedTuple{(:layer_1, :layer_2, :layer_3), Tuple{NamedTuple{(), Tuple{}}, NamedTuple{(), Tuple{}}, NamedTuple{(), Tuple{}}}}, NamedTuple{(), Tuple{}}, NamedTuple{(), Tuple{}}}}} +1 ─ %1 = Base.getproperty(c, :layers)::NamedTuple{(:layer_1, :layer_2, :layer_3, :layer_4, :layer_5), Tuple{Lux.FlattenLayer, Lux.Dense{true, typeof(NNlib.tanh_fast), typeof(WeightInitializers.glorot_uniform), typeof(WeightInitializers.zeros32)}, Main.var"##292".StatefulNeuralODE{Lux.Chain{NamedTuple{(:layer_1, :layer_2, :layer_3), Tuple{Lux.Dense{true, typeof(NNlib.tanh_fast), typeof(WeightInitializers.glorot_uniform), typeof(WeightInitializers.zeros32)}, Lux.Dense{true, typeof(NNlib.tanh_fast), typeof(WeightInitializers.glorot_uniform), typeof(WeightInitializers.zeros32)}, Lux.Dense{true, typeof(NNlib.tanh_fast), typeof(WeightInitializers.glorot_uniform), typeof(WeightInitializers.zeros32)}}}, Nothing}, OrdinaryDiffEq.Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, SciMLSensitivity.InterpolatingAdjoint{0, true, Val{:central}, SciMLSensitivity.ZygoteVJP}, Tuple{Float32, Float32}, Base.Pairs{Symbol, Real, NTuple{4, Symbol}, NamedTuple{(:save_everystep, :reltol, :abstol, :save_start), Tuple{Bool, Float32, Float32, Bool}}}}, Lux.WrappedFunction{Base.Fix1{typeof(Main.var"##292".diffeqsol_to_array), Int64}}, Lux.Dense{true, typeof(identity), typeof(WeightInitializers.glorot_uniform), typeof(WeightInitializers.zeros32)}}} +│ %2 = Lux.applychain(%1, x, ps, st)::Tuple{CUDA.CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}, NamedTuple{(:layer_1, :layer_2, :layer_3, :layer_4, :layer_5), Tuple{NamedTuple{(), Tuple{}}, NamedTuple{(), Tuple{}}, NamedTuple{(:layer_1, :layer_2, :layer_3), Tuple{NamedTuple{(), Tuple{}}, NamedTuple{(), Tuple{}}, NamedTuple{(), Tuple{}}}}, NamedTuple{(), Tuple{}}, NamedTuple{(), Tuple{}}}}} +└── return %2 + + +``` + + +Note, that we still recommend using this layer internally and not exposing this as the default API to the users. + + +--- + + +*This page was generated using [Literate.jl](https://github.com/fredrikekre/Literate.jl).* + diff --git a/previews/PR467/tutorials/intermediate/2_BayesianNN-22.png b/previews/PR467/tutorials/intermediate/2_BayesianNN-22.png new file mode 100644 index 0000000000000000000000000000000000000000..0dcf73b752ba5f70b461cf76d214171441f415bd GIT binary patch literal 53210 zcmcF~V|ZL`xb*~0)7ZA1HfYSowrw^x8>g`wr?G7|wlQ%U+xEBnUf214pFiixT$7o} zp6rJ=)>?PCf}A)a93C791VWUQ5K#hwAT>ZBh+nXfz$d8C@VUS*7$a$M5zza;pPY`O z1Q3V>Bq<`K;+}D`=BA;nPW)WDNpiN(g{kCw(LPwdJb;Saf`Ejw=)*py4 zZQSpusIeU!u!cdnu(3j}>jDZQ);{x)h8dHyMacJi(Hpx$of%%|TpvlXA|RlJP@oZ2 zB_y#yzzd;x=s=VJ5?H($0~BH4?KeCGVb}l?3yDA>*nihqeugE54agxygdqjK$Clqs z5<~(U5WLX=rX(MJSN?0?4GePf;eP;kekwU1f_;emzw0uT<&-U6lvv*M z*;?C2&}UXwR(AFzXHgXBTkfyv)QnNDCX{)B^yIa2a(QfFAB75lyRvGn@=nxZ zW4(|vRD}ZN1juFkJ?~v6Qh-466r9Rea{`yp^1vGf4O%c=vTE%Ng%TH=KSDm%@8Ey! zLq^D_fDp(UoYk%*G+#!C?S>MZv-|?@uZ*`ko=0#W2ThTB zYY!5AJnrlBF(-MLvBP=v=Jd;rOd}Onioe;%o&*cNZV18wiysoE#(n(f430oz`@>ZEr?v&FT@bA_dan1Yr2ENq?!m8+c3CrJu`;b>mMx;W z43>D@%_=vfz{L2Q0zoLyzcqbIiJbfS&5N8`uHjanjUZeE1hTTQZL8$l{uGq*bzD`I z>@_pdzN*?jqAj#3_3?Nh7wQmsHBt7vrwzu>!~4>v+7CCDT5T$qRPmii7JvMK?Wy2L zit$sJc~BsHP}#4E2Ho{|51I3_P^ZtME6Um2AIN@?pvBmi9yn`VSzQ zDr==`x}U(^C;Rj-gP(qYgyRm5u5YX-XHw)G?{H1=rArox9*q(! z*S~f7oB2K;B}PEjd>-;>`6~3af{P)P=&!kr zID1_goYFu9DM%H3(DR}bPlS7(M-CLX^?jnq>%2SYle{}R>fU8OSD~!>jK`t85;rn| zSn(kGsfakoPY8~Z{_xlz=JUS;Eh&Q;+-N?i3q?LZ+bvy?Uk&;DU^(I@b|1H_sKujA zn~#qEQ=|{q(&9thMgW}JYd~Lu7IZ(#y$b~!OW~UaCB0Ama!f0$&$r4 z!sU0=f7M_-C|3^&!T_^<(DNx}kZ$fANB$vN?u(--SET>z>zaz@q10p9is~?Z)WF1? zE1hZIS{c8kpfmgwd_V_z4iN-kXmUCS%p79Q{4|u;ydQ3a8EYY9m^ty2oCUtvjXU3K z5~(3eOTUFhrP_XXu*p^b5_ptt-ySuvGnoQdS13KEamdA|r`@w1Q5d^{>->HqtupXD1KebOE1T^5zA=f zQzVgL1#w!s6C15VNk?z$urli*CjTdO+Z~rmuX610!=^G{te+lE&PenI!||Q47AOJ# zwzxjcSP{|U>z_WEZQ%pBTm*jpDx-~C9BTAaZ5~KG&T@|?JCJ`fmw6V8qLu#J+D-D6 z{+M|)4Q_tZ>WD?lY5swA*=MLPIaHtgVNm`XG1Cu03|C72C*OfqS#&dLxfcJG}eF$B{0o+LAY(7G*u+l2%P5^&!|E{%x6Jb=ctC6>!4$U`j@zo|L3=JePV_Q09#rUD33x4}bvvFE3h&n2CosO$4F zDqAYL^Ei>M8f%~#XX{-{Hf1S&K1?ah=?7fAy*^*>jURWK4aZYrGwH;t@S#Balr{hA zQ5Mf~pL9ywKGs@UZQMFIohWe*r+8TwSF}51#4eoptP(GvM?kot@>2JxB9B?uz7QHN z+x_)wmH^X7(H>1mLilM^UQbgqwXyN;aJHyzA$GWWp8*;X;Rb7A`gPi+q2d{763niE z6f@p>LBnN`(c9zDOO%rIhKkF&vbuF3QZ<)c`*^9omKfE`x8M}iz(FIB8~dw;TYRTx zIldFpLgH9l$imo|)pP_y5}PHzMx)$(GOMAfsjayg2fw$5;CB@owzB)x#rCD%SDw4E zT()UHPIssXA>E~|z$CG%u%E@2c3o^fg_Z3m8=`T;^)nmg?WdSSmgAd1?~C6Ln1wX7 zw2pRmZgz$f;^WbLd|rVtL|U@@_oh<-KGjzti5zHlGyQpzYOUO)w&rXjBGp zT!G=^#YUx{;7DNo-_V0hO-*reaj}{8=BB1-=;_H5hU4Pm%*@QznouM9jcPPVP@F4- z$l@d@2wY0c$1>aUTRf^XPLM&MoZTVR(8F13Zca{#W`^P}DOpdiohl1z_1@W(WR)2$ zY=Y)W39_Kqqd`$PsI#>_*ar@?No5M7`@M~E+lpmNKCqS?dC8-d;mWmQsWqZ0FNH2Y zw9gc?Qc&;a(C{#$Zfku@OG{2pPII#c1sbDf?M}k@*4EbD$x`6C*<=x_0bNW^HJw*EV zwA1weq$n3Y zQSVhr6WnfF9zsMeD-*cf1EtU32l7)EY_bIg)OUQN zJ{%%4n-A!hahg)F_UNAzoKPX(YQJtR99-{D&d<-!&djtf?Ck9Py>$2S@%g02J{J^{ z<>W-)y*)2Uq5L6O6I`W#@Zw|=t66IT71fyB9kyp5{Uw!aGFyGM-9vds6cOa`C72#7 zLtQ1Fi@3I3Xe_hinNAYV&ub8}p1{*_v0)~8kJ=ZWz(pmQDl^Jwv97mt0l77bEDY&Uc!OfZv-FFG{b)ad)#f^z`IJuhYB5Zle>3<8u`3iHgZ z@#hy8C5mPd5fG*h?B14!CMM+M<<*sx@C1B$iDJ&9$llxX^WA@6tUgmBBpg1UEFH_k zIQh3)TbdCG+!Qy4bRPfFp_FYoRVTt$=Q!18S&A*M=Xsl#mU^6s%M(91(y0h*(@koh zu{dF4e9l-H5^wkoSgi~UpSbFD-nsMJ2rN>h(1@@wgSsVPFOkGau$oWkG~1JUW6_|} z(a}*+QEkKpjHcMxyJf#^$9#f-puV|fq{Wb8Rslo7LTiGSTe0GX)I>!&`@8qU`~NQG zWhB8*T3ga*b=K#X26EZig*C>no^D_(^p81!nWPP;n6Vg?lEojXvuMn}hIqYj>WChy z?GCUE90RsaClTupMi5NU+m*4Exp_)Tin^NGfWc=OS=moP-H&Ml0+bXK&>!{9KXVt# z5$+xz^9Xtc^7_6!Jl*18m4QH(AW(#hO?LphgTr)u{N!v*N4bH{IjSuG|%^CBP`BC?`EW8nGoUxO(3@i&FNai7U>Z+6pNb9@CEy(uYUe z(LF8Ml!pE^)Vf9l{1aZ-({ze^_ z^p~1_FX(#npl=xlti_Llu6o!|U=8aHdnavN;XolE5Y?;z)xcL;+Ts3w(U}4tR$N?2 zwBaKxZyN-d4FT;Y9E81@0%h|Fg6}pqb2Bpm=MlcS$x;F@=81wN+>WlKN_ZVlJ8MWx z?=yuhoMdK_J3e^nguH9oNkJQFm|ByTucHfK2{Hc8Lzxe(9{ERF-*6YPKj6haZC90& z1_=MoQMk&ag#~hVdJIo9b93q1!gF??ClvxF9Di@%Qv%+%{Z!TtN}XBkO?ysTTiag& zYoCI1y*QM8b+Aqjj4tj={1Z!;{a?YlV?*8P`;;8YMY_lh>R|WJ8~2P=GXj_SE#(WU zP3$ukRU`xCDn zp0_xlo#xdLhixj?YzgS2ce?ejZyn51Arvk^E=MHQ{<3IWg9B}s75az#pXc}#%&|X~ zFhK4r)g`=N7mfTZq>OhRi?=vXbw9KCo5}R81wPq=o$<>d6sRG^*fwAjLa-i2L05ml>33e#?@%nPQFgbnr& z)^CbTJ}(hvr}qMBRxX0OgXz2&V!u_pwhbRdHauG+BeFxf96JRSh3ETD30cNqC-oHe z+NC$YVA@gC-p0p zdD=ej3PmPnI{XR42*l%TJ3A(7Z?ER{slj`Xv6y!0THbfT@kzUtcGqP_P4b`Mr<0SS z?r!a{zofKtmHCtFxatN9HLg}JhY1_)9T6lAT1mFPkZvy3nOl2%PgH9(f++F}C$6u4 zMn}}u)g?IV2BHJuE1qyO!CQlLRkpx{Zj)thL&Di~TNOGyP1jSTD;qhnysy)LdH0}+ zao)9^F`4y@8eUX-sp$%`dBXnnBM=Z+TUb=r)YLRJop+O)o0;kHyG5^0{r&oVHQsde zGmZ>0(Mx*9YTLaX)+js(^oIa+q*3l99-YzQsj75~@crTq1{x8wMN@SYJEN+sARAee zDRyvd$pFOOB=igZ?^K1YGBEN;iXz>f)`$Y3})Jhyk>n`B0GUfv*KLwUj%ZB;cj zJQr;?)CgKi%6K}nsX#_y3zSj-O)4q*!p+WJy*DOS>pI?w@_tHPQD0RKK1|Akw zZS(tOA)>aPj*_CF+v0cPZtaqkKpB%@S)k2mwn%HyZrQ3d;LfMy((qg6-IJ}sVTom< zwRPhGIQZD0$*{1MCOcrpp1X)Wu1i(jG|MM08D2EY#2^rDg;F2Uk`3=GbRX7kXv^SN-G%GwjF9l2`E1M_qwn%;WlY*K3@Ra491SB}s zuq(s+tL~W&^moq=f}L!j**Zm%a~1tPn2fj0slER5J@HCe0#aA1E9K7WsgL)ml9f_0YFL)pSKvJ>ZP3OJ)YJ5%CmCobp(iZ`JPU|0;82i^Z{vV-8r_^YE z-3FCV)i9xLwDfHrD_Q*6?u915XZ$PY(V-OxZtN&`?vS4<}Gdw=xYI zuyA3^^_%3Y*{t)64vM&JjQ`5GYW0a|XPYwx^M_ZOvjh}*l?_Y1#(Cxa6n!3DP|ud| zR;i&b;!=CR?_sw~8->v5G!E6E(CV^G$Ydj9MO3m|{767R3oGcz;LyqzJF zVBfAn5h<(kox&Zq&z~ij8F+n8G)#OuQv<&ZJl(>Szpd5QFm<|SYgx?AkIsaPwvQV3@o5RzPVyp)y%1sXkDGXmz~i$5|Fo{X}#OG3{r z*Gn6b@SnHq5K%|wem_TPlm#!>dA&m@Q#Bncc!K8GIHWJM-YoCC1L^Vc*ob)*1~=10 za$iG{+wP`%>-66r0x6igP8PptS(k;jJx6R0ZnEx?LN>zw7BcM#s&RjD0C5vr*M#@w z9L^3(H5YbbVkop2dN!105cnlmsI)`E^7i zROSTOvyY!P6J1O!z4X^+>DIj?!yTLZQSUh+-^RJFt2r-QZ={WC9s)+C zcx!LX<~@0TvgzMbe9Bw!i1qjPj~I*|r(w?SGg8f&PO)!3$RQcl1Dg+z{A*IJa2Bxu z>WD~3fkw;sswyQVB`X_Mu)EGr^n5d(&f)j&)7aQJJnOW$P$4ipJbb%UvTXz>PvpzH zK5AzDcWfvz06m4sy-k}?&tU_I0E@o{o;Zr@s~5@y!#jt-kRX6t@{mW0mj>cD^fP-iwiGCcf+g#{Ay z@c8(6t0S%j`*co5p0_utKWz3+g?0S*61B9{;qj5y=QF&xvhnluE3$T4YI>7=|M0e( zuGhdOyekt9bI%X`EWZ961-~f5!Edf76CLC+l;7(zJ_)|gwtjQe7@sZ`K%2V2jI{e! zGz;V+7w+wOdB*poSE6Lo!8tj9w+C02SJuQM7dS}IqU z(Z*}9q;@8Vt@Iuazx-^yv%_kd44*BH5(~V2=|&{b*wAqLV)35EcaKECIb>7|9}3x5ml}?^!ie7;;DcoVT*Vjg$!|IBEdSY9B<04dfW#HSBZx9=fe?(B`y% zt(Z|DX^!E*0$yE!>u)f`EW>bUee)DjqIqyWO`ivYtMuv*a1$&ML7=~CUTu?eC8G25 znb}1A?w=F-j|gJCIkK}?7O-$}xtz1)k)1Cp6k(s{HhTvH18198;b8J2$0r_M?-P)T z`CqP>V4;OoRgwMME7{$>8(UfonN@Ls^Xqvj>ho>B*BrZ0`55X>->qTl(=z9?!?^ZF zThpGVM#xy&Z7HRf>`_7LvfRg0A1R!s+~OaVBk2j>LZQso2)mW*$KWIV(DTp1_ z$xMFTv+-^a174UJpAv9ZmgImE!CmvV#>97q7a%0JRAxd32JJ=r6u%W7dXeEPb(Z!I+#_YO1iV~DwX}3%VqgF;tJ!hWqc(bG z7+$&-KOKv>^~=n_-<=rNJQ_;h`|p!Y^>ArlPvvyCf*$7JUMv@SAEi zsz9GVfT}fE;o$kQcs;gucXv)aO?SncYDBGX@Z-m(dBNo&oanO z%bg~b;(3ZA=f}p$f6)7B$RJE(4sTGcFs?aD4t9|E?H`4VOilthJv}14sK)yG^76{F zb&h@&2013WqZ0JnZ$N5}U8SGBxnBeil4jT&8CegHK6{!2PsWtzp?hDMNE_!BrGSrI zj=Aw8ru;zwDZuY?Fm?9u@WsWY_tD#$?WrLz@9b!vzKy?N+5+-NGwTNkfKcTmh8INsfbm zF6%`qX`2f=A9u4D85?7dWmS-&T=W_7hv(zQN-JP3?bzhGg>$dvgacxZV9CUZ1D>_V(2gtE{3T^Lu$r zOiYNsPzuO@+NL!w9(a9T`#ThesS&&9i_YMJaz_Q8tK(iYIeJyY`y}+cJoV~;IGG&x z_FusF5Uft0Y$2un;UIJHcNm|Bq_%eYMkFq&t!-upQx8t$Det-+v@l|*F)d2pmVM05 z&dk#+1!hN(Aj!?#RH4E7KWLqZ(!s;XGyIFm2Qr}u3iUFh^)9vb_k>&)!8*Z1v{P}PFB z`?Cj4?d*&bmx`<1yORsVLcJdgvoqQgUBv?2YNth?j=FAa;2=Tq2?-S_VU?Ysoklen zp-!*eP??Z7oSoD~nirU&D<)WwjqCs4I zd_TjK*49>+<3@h3JB*0_=ZCSU>q$YfnovLZdyY2O*TRw#&#gWzm^`1k;?0jpyeY}a zXWiRPz*Z*qR*^0^fA#9D-)ajnxY+X`NVH!VKOUJ0Dt>%xXs7B5+IGG21h0WPt{sKx zl8?~{UT*`chqB7^BNS*ve0kw8@qQ>MDss7>XxL?(wV9fm6ED>j9i3`Re+<=!gkooB zr_@Dd1N|Wh;&(h-HN~Qb1Q7zqErBybbaS)G_uc2Y%XV`AT0AOEOOHQ#auV9#XS2r@ z&eYPx1jK!A^#8R0*_aHd5)_W}rI=-EwW$_9)ZP6B}0wvg0*f6wz{rlu~EiK9UW@c=!Efv^}f zde$}%2f)Qcjhv<>nflV{zk5YikT5@t0S4fKhauj)>$*Uh+v7X)F%C z$=uhB`J&P>m1`9q}30?A!}L zK&GqOHENDItAC}n@{3z^UXpfd3sE63?>QMuvFnYkQubo_r0x@bU5E4zNKQAm=x&@|{bX z!oouR#Sc$Ki~Ap_kp|gQP^~XehBUE@@x_)7^ z_}3>ROG{0)WPCIi(VO$Ki|eUd2f7sEZRtJa#?E&TLGdDJGWh&kh?Sj_JRr{)|a2-U>{=cS$Tn$C6MBb zIR%1xX9Q?ldS+|h>gONvwPUHH(wG?G0IskSNL-b1!m={Uovc*zxRkKLCoaeOC8}7G zNB7FPsv;&Zz!%&(d4#kwGO5yY=(G6%PL2KgPo`qhKYJf#PVaO~ zc0Cvk5}rOimTan`ey{fK+c~@=)OpL^{Nlj1`-~;;$TE#IF#;!d)FLJ1-O zp~gAuLJ<|TAO1P}cm)^4nvz0CJ8F^we)HW84^NhQaPRue7I0QHfJ;NOOfk14_U8~KEjI7=Q=BTw67Z8Nvi=0k1DxA~>ZPWDz=jxN z0T6!hMnxT|J3WKt^v}42q7|pdfbILOym)xOOaaftC?WdLy1(m$mJEAmtB(wdgFkn! z#aOJKZT5^~*V@V=vgZk16@FEO%_hyM3Qie(08EyOsw!p-*vDQ`6G04sk2=@1tCN&^oz7qe z;bDjK^d*F1d7f*h3)Q~$SCxXA8rH-0Mo`0l&3qyQ0>sJ9jfDSIW(E^c4i=h>`)MzU zUOg{YZ)gN9nGxQ}>3BGNA~Yb3$5NenfKg+MYu*b75<*U#YCUT5)nj7lQ?Cp(*|go4 zNqr@{yBNZAp#?+u<}NecqT2L8T{YTm$#-5ABtBsTkw&;`&1=<4y_T(UBU>~$2v8x2 zrds3J^#sV#eU<sECFA z^(^E5#Sm+ajLh^A%?A z010lnm`O@3TUH1pDCt!WH=zKrLhpB{s;U}g@4VV)Qi%?CJu4A=i$?mu_w9cuX z{l(2*qS?nwR9t-Dh!=zf1EarQP*knKpl)qF`}7oN;|hUg?Q~(FV^tc5N`UMN@}FEM zEe>U8uct5bZ64N~UzAddJJ(_;oR+~zYQ?%v5}RYqpz6{><0By@9^W8@A`DP_4FB2W;fPI{xr#5@kffWL3pZ>GKpI zQzRxwt1SVhtPWq5z&Xv&X}!j@hH4` zj-mY(lxX22qoZ5|(c$64ez<%&HJf=P8T0}jS|6wO$)LpDY^B*opSSM6b9s;{xdU5tgPZZZI@?f*X(SO zdYzH4XW!V_-;OJ$)sR9N|CWsoIWu9^&%dnrOd}a;b6rOT+b~ZAw7G5%DBz}M;*8OQ z#*! zvzsiKW*W~pT$!1<@(ImlZ=|Omb!JrKXs{}4Z)4Y5m0?v>Iq`(JffxF<@-!u3#z}OW ziiF80s;kRKOI_r#*&|?MqtxC(JU9r5GH!r7^I2OTPlbi??d|=I~;v<4@$&rj6oqrmpPJ{#)k)rpePgJ2s(>3w?gC`=h@xth`8Tp0^Yg03jLX+dl`>i=uv@d@iIr5Z?3#x>|dwKAFI}(jh+1U}(&?+4r)o=6GoWYbt z0H*TDP>jl|&O77&+?xa~90C-AC#Bx>z$?edZ_kPa@duC$_%JYb*o9!vq>Y)d2WF&f z6wC0c;4G28eD;WC)AIefcg`dQfy&+mq^2X-KIY;`uulQHD^1|lcFEmK8ks$M7~|*V z21!ZDcfY1?SU_NQ+wS38NrQ2vw%DdmKT_KVFECD9@b#4dqkk73YiarYjLT@VqfL^1 zK5YgrMMv$+hm6O|!FbDpHDn`-?G}Y|G!RL?ktjQlG-L_{A~XO=1G1zxw{w2KH*Y`_ z4L*10VY>mPuPsdvBKW)5+^t<)=+V_?{}W~NA^#AudGuKZBESCNbF<*2xSmYC{ixoY z6vCFZk&|C0Cf+vj;AQb?I2Ssd;YbBhA?bhlVy$QBtzvw29;@V9{4s*uHM{ z>$g+^%mn65TQn3TNI0x-6W!Ax_Wljw-wIS8gYDvn3!V0fR|ZCcI)m^f-4htXiqtNmc7y9me+g<{tPqNrQY>4>>JuZ zu`NzsSXVP-o}Y;&(+A<-Fel&L8a{1;cL|Sd%R*EOy#`+P1Dt6QDja@q3_ozVk!=czAC^ z6f6GoM^F-c(Ez|!5Fm2#=tO%$l$-P1JfL~#oRv<9#tnsxu4r9jvAX6qB(gPHv+A;c z_-I^Vn?fXM{H5^;FYo5&bZ-8>uj6M$KBu)+yuCZV$J(@&8kipaT(wAR*mBf3Jd=kE z)qKLQo@8X2M-w~-hJ+~U=w#&6KeYprrwEZM(9nsF2nmygMRDa4XKMFfk+tWW z&8Xz~lY((4<)3A~EhuX}26=HqNxcNU?dIZG*pqEO*Nhz>AW-zuTz{V(7oY3_=3qv9 zr0q_W+`d;;O=f;Mb>2~+{c5l^x~H>EqF5l6%~DCy))p~pVZiKMz!M`X1j^jE?uWDW z4WPrc`3gAm_-+Fd6j*{Y)@!g}V7vx{t0SJSW=q^?$Ix!2Ngd<)#=U-n6)n-m`5D~E z(9o|`Ts}`WeW@b|EH52Z_RY=SbUM0`#yf7mQ}4e!Ry5S|2b~=lNUTds<@tq{c8l;I za4n4)O+_sa0ht=1_uHPid=ObpW-B*pAaR*lK@j=rXq!4%s3{5DPqOh^OP-s=uuJtj zuK8C;9%6=(YC9^DXkwqsH?)x6&5#rHPI>Ra3dJA|UW4zYGQU1=0)!b5|APEw)4#sn z%*w}C!XA+Wa>=_pJ%oW!Bqc}3gq~gwnS&}jFV@ttlM@?WB0FQ_*<0+V?c(xLp(?c( zPS?4`$uTK?m9=J`n-&cQJ(g*Y#0m(sA2}?`etx*h3p4FK-42Z{AFzUrE_kA`1$@^u zIOV~%NK3(CZx?R`3P?Q;+EOPopWx+w{nu6aX&5zI0m)(J? zl&bZYF=JKU_8wwOK>G)I=4$HblDS9LI17zJs>DG2HRcEP|?3R1@7dQ z&c=l^Mn)44Ag6Dd{SYR*PRElkD$G|Z=~P>gJ|zs(U`Sd+(@TBGXYvYY9T$E@mEuf2 z6F2yjmfn&y-aaBGCka(lpQ$e1Q%Y~-g5khT=WeXp{sp39N<9T$2n_(e@iG9mqP0~> z8Bk$u13B~#TKM+Js8do>5~a>k6FQtIs@n`u7a^a{Zu17|h5&OrY0ENNoRVFbG(Ynq zwlazLJ-9a~!m{4!(6XwG##ilY#L0xw}jJrcr6fSIAvw5HT zR?WVfqVF?CX$x(4+HNK1p)TIbit({@3*k|MsljV*j!sT_WMt6ZZx50Q8JU@sx=3?i zAPx;wGcwvrq`ej)a{^rm8_pC+7wwOwQXb}Z5?6#f91WpMd2Byrci0d*3$)29x@;E= zmf)JsE%jDF4sfGfES5Gl{wGhIYmp;9flqXTEl)YA% zDAjhwz*ti4cxP|DG3`oW$(uCoOG@6silokopiJJ`#=cCtgV_YeY5*RJtcMt#5(ZK; zYzg!Aap0Qd+3vj0@4TGai)qu2JWcG&8fHOt@dBuP)m>#aU$wP0xq`>P0)Xrktbaqj zvz9|ma&mGI;Dk{A>30k?WX=len6m|j+3Tima16KhEOT=nQo;NHTxIwrHAX3diYtvN z>u)iIw1r6xlS%#t(~#3NRhxAJU;Qw*Bk|gf%~m6J!@OCOn%OLE!Kq8BlA{@gEWQUJ z@ZigZgYv zsxQ1CXvpr%?IPiCu7)I7B` z6g0{!W8IRI`0gHRA|fIvMgyL(5CG|qR<%L@TAQ6_xjuxTv@|g;Kf&$8C7~qtytW9L zgV1+b9hvUqMKT1K)2;6ZT+6FHT5Vp)HCQmudu1o-Rkdpj&MC5v3yMkSI{Nbq$qKr- z`l?9^s+19fE!M~GvBSN?+$`@04l84(J3z0e=<`ZaUEw^X5yWsuid}r?_>eL&p?0dF z7?8wyxR%UKPj{}TK?GvIdt98A;NfdDPTn`r@fiLc8ChfFyvj--bEgDl$`bI$StMr= z7=HiGv^nBQT#!r4RCqBT5fF`(l@ReeqHX#!HWb^_nuUTbgWTfin08eyqsx4V_MwNy zQ3-uJzO5z=7B(9@m5OS=y1LoIJnj&EbHXsuGPhh>8qS<}Rgx>L2eQ>nrD|X5kOc!P zfiYFtQcD)O&1CL|A93g#K>XX4>X4vFSa~N53=ANSCX4d>GN45ay1Qqq0Q~g zM!T!Cy;4qA?hKsCqh6uAg1-^_E=_~+v)_nwad8SLeZ;e|U`uOkqzzSu5ZrHz(;=H? zW510nDJcn}PY41i{lxs*{D+y0ayo16+KAA&wjxRJFI&6gv~9=HZO0Mm61I=zjPlk# z$nboskH}T)_0G-|YU;pbQ>v*t1Vg&nX5tnWW^uP>W?zZ+&{#e7H!-_>8UbpYG)Fqp zqjOl1X0^XtO0G21zLUhff-T{;wzqw#%%ZNM+%oonGHu28tCUjE##r z1l;*S*Yyp6Z2#%v8A1ps%RBH2@89~t?=Dc#PD}gy=B+}-TKfulRNTVChfPDqn4Xot zij4QGG+yYdLr7@Hbm+Z)ABdNh9&vb_$-*YXz=CadZcI@b9s;CK;jNPH(M8qJndj2p zdP{-GgB}k9@&{(lHmdTN#%5Pp+d~Bbk~wrfe$dLSoyiK;qqd=3wlhA;5dJ=Q+ODI6 zd98UGya8)r@h`*MIN2Rdp;xnEVxFXoQvnR?>q15PM`tpiNC-fc?Sd&iB0nQ)u;?fr z=8*y%-vw{oPTwmuqUg+1YVY_E-I{={!58A>WM05mS(?kRv1J&4x2!Bj02S}o^H+@f zDkOvm=MI!;dRQ)6O8H4>R>m$3R9SC>=UJuCMf6n^FcOB8Amf@_lJ^b12un|>pcc_b zD4wso2IZ{(i;Q_49UZN#tjf#F>l@y0Pb1$ef#7J^k}bjGlfMI~of5@&v1QhLw(z#Y zZJ@K;;=CF4YERK*FTcc#i^%8OfD8$U;$O-c z_^eOA%<4QIsByx;tM@O-jr!$-CZe zw6&i)B?VG>Hk{9?W0%_fs^gV+q1qOsYq_-xw=W*FgzW- zljotcPvk;hGj9CDmgPDyrcMEO32DE%s*F)=3QVV!)u<`|-&dyht#i2~q&nqlV{I>O79Gth8}V?4Eb=vdy9To1Uvrg^94j zdtw#@9A<20BtKMOvwv~)@Yz+M!@z_y4|l-=?k1hIZ0vx4ApW$^H#v} zBm5e*Y{RkDolkCXx7=7!->zCaZ8_VV!p*2X2Dk^$RE%-&l~1O6juVTzApiy5m=dg z_)1#bKZY~HdXxUz-vV3sCO7mh7IxZ0J9SKT-3RKFy^p&T2RwPnQL z-;c0;82vw50AQz?bX52xDR(~g=_0_fuS)p^HFO5XEePYc1%Gu-RP)p^-JQK^^3v-f zGpe4@(wa!qV$xd1V__NLjIV{WY#wPtMF!&N37+Dbs1N%iSzjIq(BlUv5Ve_QdDtKe zf%jQK zIf3C82EHzzX>BDM(tAN=>U+Dxk!6K^yzf1v+`hp^$=ou9Rf7TrUg7UUAu66?Ydm_o zw`&DkZ&y9*+o+K~DYaS14pij^g6bhRzi6=QPQlj=i#??ijP{D%!W@*1RqcA9R-${% z1~Kr990?7K0sRjYAmPuKOz6DjobrdUixLimNFUE)>8GZo{22J<@1-NST+`$4A0|m` z_Qf!ftzShRmcw@R^cM4~<3E3j==zuv`k3#r9R#bX$%iv(nZw z^+{`EF1lmRV?)Geu4)Yp1@lU?R@U2ewBB(S@V_-?^sse^(nX8Lzz*qU+Y9V=_O{}_ zR!;7$O+9jk$v_D#+tvzIG=QJ3*4b*SN&PHryn7<#5sSjRJ>9^!FaR6_A`y_A0L5T? zdwWMmNAZ=W7uJPeq#};!X=M|y3Z>vG3TrjxvU2i@^7D$yf#)*dxhk^X*FC;x7k);% zL^3$Z4vwbYwXu$N32?LXGUB3V-_(CrDtPOPZo&mcr=|6>v4vP#xDubYMJf_2U2?ay zjA^e7tAhjmeeXTx(D!YnoHT63vohP8DqaxSu4Ys7Ne=!WQ*RX&SJy;~HiQtI;O-jS zT@x(0ySuv++zIaP?(UMH!QI{6rE$*w{&CN}m$64bFnDNISFfs?bJna);JZp(`UM6m zKfU~5B!W`X1Fa}OTybM*ZmPPhDz~7b(k%D;g3`>an(CtRk@c5mrlsQ|_TgX^hc*l@ zgpuXMGixzd)$Rm}tdX|lA8FPr}!=N=tAV95LB35-UU!ira&JVY@qX%?3S z$l^?xE*EB7_mAmY%GGgH9TU#cO}Ar%1U_ViJ|P4BQh?{@7^>3zDH>Yy#2Yb5QM95? zp#E6pJ>lj$=H)u3rS7(ZaTSn}W~dw~D`lNld}v&7W2VTktZ*f&C<&15iA{SiZ8VM! z-gkU4h?uzy$;hkMs#fg>Qczajd85!|0>BDsZ;lleHm#K!7io>k)Fpri^TI#@@9V_K zy=6)z#ek4;gIcQ&5VK;?lIx&AA?idS+8ht>TYTHsI7Y`%S@w9hB^yk2`%IWIDo0-} zOH=tvNq%_m$`r9hlW8H(3$HGFm@6Y0Q$d?+;*WhuSz1G}>S5p@uIuRjO^QR5=^(;e6a?nSX@-GdqLNB>>WUf2>^Z;Z0Qvhr?m!s ztMxPinui^{+=1 zWUE7RtmW6|Jg*f-PCFw$@8bUwTiIbE%4VNgI{PvZ4E_ygaTa|{S0fST%T%zKbBPhMzPW2cUxdzL{I@B~Am$nJ{Uhr1{!%8L}NgOa-apTg-gofcZZo z_Wjy)7Ho{vXgxAUM!Woyk_4e#imxIhakFo)(V3@7NFCl5v0q3!*;hX5mOC@YM#dT= z08@$f6;%Z20Yis@d^bTOF1}(bbu@IiZ}e~5h%k^Sq3)Xlc%eUNslR?o_B=U3yvarg zloqobcv50y!k*hvDX>0w5qwHi+;rr*k&zWWj}Mns(xJOris51IDQXeH#M)$J=qFXs z6&q|A8*lnq5At&~?fd=QNo@&D7@SsVz^O5-ivm{o@Xk~JgU;4;eX{cCGQKu~scV8) z14wl!b1_WnPU^8;G$Pv}WyMiSKCMQ7>=_s}uy8Kw(LsZ1A?y?5xSzKE3i-}sLX(g~ zKz7#>*HE%X#iyw%=q{LB=2>t`FWRPN*Ofg}^`+RiK?=xCJvGTw8#c7*5Y=h$#mUb- zvBywRe=CRY!WZ-i>AL)mjE{u$!lWN2y0cg(nljO)tdgKpZ`oLPT+(6#SAjbz+VhjP ztd4!^s&R(Mwy31~YI>=#Eea8+yYeL?T=w@mBO}dH(?@r&N$aSqie43LRJD!r;G&Jc z&oEJ1q{g#F{yY(3BYX`M8nfD+cZ~+Gk5t&~D`-8~#^q>@}Lsq8CMgqX_N;fUj^x4oyoe*&gbD zZ$w^)1PgQbgVzcCBtbZ+Fh5fbMxYfmb~e0JDi$=Ynwp{+#I33dP9_&r%+|ef^GWeE z>cNBtlq5lE5X)e&I66v|O;v=sKuioWH+XH$=|^vd(**dfTc%iVXMu=Zu{`ck2c zO#ytvm?>G;%&yhRmuh0PQWGehH$rVE!LVZnzTyTC5-L-rnqSnXbx&0) zX&~rRU!Vpwm=-5Ry*CWHX<=FnJE{?nP~?NcIfInbjURY|yn1I+G3~T9Z>9=|{Imfn zEz|g92)pB5kb#ge0SK@`?b(Dg3CWDi*b5U`dOr8_LP)2A1@J*U@9}_e2Pw2qpD9vz z4}6V04c)U7FxYvzrzCkACwaTxu9s zt0FKGS|~gGf<{xsbK>)N8SUqUZL*YFki5m-;fpzOX?`6=SLb$(wUvmYhp~!@yN8B} z*Q&c#$MA!-o0F4Bj?H0r@+O6j42{G%X?l16jaJ$5w+qkMS=VtWt8*i^NqjJ5P8)Kl z+`+g~Xed$gusx^{k||I^dU&#>nQ(2B*TvtSNdfRBh>i98t3Mct^CM4wGn;Q@_I;MQ+pXF}bZsoHg<5|E!EQ;fRrJ)I^Y~a{tu3yK9=-D_0i`P( zb8_|+oTaO3XJE+G8;o-_VmLeADDGi+eI8LC76DhSz9(ArG-bY_46nw@y4P@N>?0>0 z9HvIHqZa0lL7FXHFqa%QqZ(dMifz?VMq*M#&0KH}NocTT!WJre=jBxMrz28?RHM#( z`n<#KCp9{LD6iwe*pkC8w5R+Bh7K`4+w1$w_GQlpj^9svcVv*lVoeSKzvmrZ`@-?8 znOYSOd7KEOK8#n0XsQ( zP>8-5eQUr7cWbF28FOe{!p0HV(nOX&4Fc6^SNr=x&xB#Xf&8S4;ww}@pz!Z`(?XUK zWD3+EkYkc&@l5k*xcQh{Ur6YTM$fu5!`4+#2HJOFBk*~9%y-i6HKvIOi&sxQQUW_% z1+~d}cwY_bRwB3}nwk)BZES+Pe3W0`8~#zBj{1AFsyR6%h**IdEg;wOXcfwPua~kzjpQvD{T@|sg{40fVlb-OOSi-&I zkFM7NVo{nTS7&E+b#;V0AzkElAucX+Yir{M@4^{tpuz=#W)KmIo0>UDzt)(ye>nE` zn)VM)eAa(X2yvI2JYQa}W8@a4JK=UDZYC}P#2y82kk%jN#&WvsU}tAni$MKnrj(~V zLJWc`Ut=?j7MKH`4hB~@EE*n_Slr)21^O_6J(6hd7L$8T=)!23xy_q^05nqI8!GBT zFV=Z0{-v?#lc}n_rSgOV{0~4-MUBSJiQN2zXVi-vYi7k6BKndmV@BfKE(+vg)KYZ;TAMfLt3exHM4NPzE z67iU7ZXTZQ@KHn}0cMJQR?wiJg@lviioAB_joMqn&M4CP?;9dh@Ns$En`OF{LK!>k z=XtaI1`L|}-neWs{_~wvE^)_tWy^6Y!fYcOn_Vc;L#u=&TnvctbA?frSg}0SVKzzj z!eiB82#_Z=9f*k!GAf8{%AOoL`g`xTI}|i1H?$W5BwhCmui=kuh3i^KE>qi}cYf|h zA@HH8xIM!xP@ruiOBn5oEW*ZWN*58$kSt+J97k_{HxL#!8mQC!j*J2)VnVU@tZATA zRokt)G~)N_UoXYcNsk~iNmla2AK!5(a16KN{BbO}lV=HRjWhUC|`YKI#B zQ0+4|`fTpT*19cjH3H)UW3>kH@t@<;H zV8ML(GCe)rV0L+a7U?+yLV-!fz`$X{J(tn81z&gzz9kYTZ9oB*0?;vft)5Ny(FBb0 z67Y{%J(tneRv0x;rk#Pa@X)jLY8#UD0$3?ONKU=^MpkDxb~H7vuh;O?vp3AL1q7T= zss_hK?=3h)Mj#LD?FxEcBg2#UL4LMP--{Gz*=X9t%4W>l=WjNC3}i)tJ)UT-`$BN* z+$c--ZalOCe~iWT+h7@OGc651k$ve1qZAPE8A)U}bif3y)ZkvTtsKh8?0@2`^cSjH zXoP7$;ja3ay6I5UD`0mtO2v8Rp7LIHX5@v3dM!I@6e9k&$6<2a%KeK_MQ$?1bX%$c zd$?XqP{VE5y5hZnrCq#A`yc)^Cw}w4^7<79C$9)?M9R(v=#mT$YjYm=tI2FaY!EK! zVCVWr_tQbgc*e(Y+bW06v(2S06+*FC-qqc02Re$s?~WtbCl@{_@Kc@om|3e1c&VI?C*t`68u#iZD)nZKsM-y!lua_1RcD<0i zIBA@&32$Np@bgm8!o;FR(TN`6I6^PIjg@st% zjX!o+9;+J9^~dklwB^&YYa;AWNpM;$Z8FHGC*>=vg7z~ycJZ*(+++le`5v2yw!KVN5!?%S=* zrSjpyL2^=(hL+aL(>>Ndm84rB>y*g#*60d8ctr7rZn|<%Qq|R(2Gs1n%DXWa@+Bu= z=#8db95uR!iF3wg*GS3Ql%<+)a}QZkBP=A(x;DwC?^`o1%=s(%4d>Z0;XhtYqHtG$`r&IwC}rHd!z+@NzECHf7JyC!H*~rAAm2ong4m zA1ZJr;rb9&KXd;M@i%#FT@8&EH&}2Co?T4eXVnEc_`A>jI2Vu6RG9fhCim?CmILbW zG8LkZdS#Nx%tOdS_!nN9qV~M*rtaz_B?{_)RW&sjz^CKs-q870>6N5JpA~;s|9n>; z5_tp7k3SeAv&fM1&{X>k0}k1^`0&bIik}a&wH0M5M(w>})lznW9L6~7x4OSk*+o}V z058Vc*#qtT4m#D0Ip>YB_gsdG+lSNO^NVjw&z9v!c|ow%8wKDI#*|G#b9)xI!;% zSvO|vn2?W>0n8+^_tJYd@p$G?2cgQjvu{yb4~-uu-MLETuN)j9#U(9fbE%mT#pfwI zl#e_<92=Lm?h|c-34$M%%KxYjKOEOv#H6HtcXf%YEi%BQe-`3J0xz$%H6~CYBi*$^ ze?bkW6YOB1s^B1N8d+JezP=$&j?%bPfPqZX&Re+b2-$2lZUo6Xs&;>iAjo0OPHrG zOwWNt$qMMN{y{vx5(+x*%{||{k)s-c(jl$QX^*WdC?~W(4`Sw6e zBXfeOr%9KA52%C=~2le@rtC zIPxO=>BD1gY?LuI9Kd{0q zu}A#%@8RJgqi$z=A^Df!UOL@Q_sML%=PI?+N3BLoj>8XWSLZtQSBu)u>$Q4ckb2Jl zt>5MIyi*x@mms)&zx&B^7C*Yfm6@?$R76j2WPMg#x2&s-3lgG68-R_tba3Lun3A%7#!~Mr(*iKPO}z7*WT_IQS&~!Qo&|cG`EnO?i>WD81?Uka#_C@2| zI+^$vX6#Vgl7W4-^B3!QScs3&1N$b;hKtbfx0|<3jYLTbxZvj(AD(yIHffJj&xLy_ z9Nq3p(HtnnQs_4x^!Xd)HAxKDpMx*;;;pr3blJ>KfUl7o%}7lmI+=bgtm}i)vNdfy z1St1=|L?th(OdX$T!9J)wm<%<(&cMhmLJbnR8V9|+J*+KmTkGxr1M~OBAK9p{37d_ zgl7Ml!;?i~Bpk)~b-i2XTwGi{KYKz4`k#{he$(pK=z2aIP7t704i+=Awe#g=kk$KG zUx9dw`7bzo@+ul$_TqxZ8c*Z|kYNeVXKIAvC9B$=Yqvy<2P=hIij01-F&)X99t7tH zF#h_5)!tUYR^HI`6G(uVT3^QVUo8AsI?g2x#DiL{J4yD2?WoZ-iZS)dUr7HL*Jb&9 z1ql(KuEe@+MCjiH&d&87B&)=MlRe$(Zm-&NG`hjheMASr&~2J}9gjyV19!l2$)=u^ zRe+}DeRVx9UZ9`?Jj_#!`*ZhEfua!3A6XV?CA{IJ2 z&|$c{yCdAG>k76DmF_b7v&ma4Plxwi`;(lBjt0Q=zkd^NQ(4nv7|_5@=*~j3wk^$3 z)@$Kr-Wcw8cG8c<@lRb>ZK$|wrr3DYDj60q$J(6t|QOObZRi@ zQywKKR@VageJ@ziMb#z4JbO?FeM1?&TsOdtb&JMV8M4xIqcdzQdBakIO!vt0YS~n& zU_b57d3<$Diw36x4YU>3ERog{9lj)aH?cf>lPd*=V|)Y`#XTf4-U^JGYAo%j#D_zA z5N^N>9-dud(%_;aUzyxnHw1`AVx8FLyy>+X_4?YIu17;e3HN=#u2~ncJn&tDu|Pv) zFIT|@QOwz2e&}}@^)A8M3n)t1`}*Fz*yTeJbiQ-(p(8g^v2B}*fqyiD>MG?%PIY+I zCipoRiaGUr+mXDevVvKk=g?1|!DdAjt%xhAo)Wet>n4o9x95>Pnwjx)j>ZhTUy-ie z|K2)!uNxGOtkZ9OM#?aeZaPv5zB7LvsbzPK4ZgF^*U_tTyki94?2xmQf8qYlZ zP&?q_*^ml?oDQD-RtA`$96ZaW9p9=Y0k>EESVTx@aOPgVW;(M)5WG`j3Bl-VU5tK; zHl~J(OG9U4ahG>y)jDw5r*O|7EhlyWfJc#z%!nC%4-S-)dyXh?2$FV^;IBaI4>Z z0w~_*M{SR=BiR;ObodhDGgNqOnkO5VyGwgG9KB9#)Agc6{=6gwTcU0@H58+4;7C#nXe zeT_O|ssgcthF)MMlX|W`3xOwo@gwXAQKyWWji~ER2$+vd zQ{6+mo{dZM6rZ{(SEuu*ob{@;_AS_E!{;)7BDBv(R0S`t zqVHt=IJp0pCr4)6AS3OAfG|j+aJb_*F?8S~U~$w4O2HIf?9Kx7tQ4Jc$~M+{sm;4$P#(KGJ<)n}?&=A3=5>#(q6ANPUbAs-ga?C(u~#m%OjUE7= zgDfKt9g?yz|99ZMsF^p<&k+T$u@kY)cE>t-8RLHKvx8H?*+X*jywruyZD+p`dk)`y|}x^2Dm zC#LQ)-$lrhd2`)x^On3f!hyB*L|ba6+~D&BEaA*D!+H;I{Lr~NxKD&Plr!VL(nvlR zF-isF^?7BXU6Z6l(yy-ohYpQ4qz>ah?90$d{CHi%9POu5MH`L@;_yI|IeG7*|HWwW z3(wU3wcL*sb%x1<+j@^RX@(Z%rCtsWjhzeT!9mpy*YdeiqsL$>%biFj&zzOWvs0N( z(u#@GRt3g!2l6OKDmgM@mw-bx1N~$%JX~A`psc;#8OYBk{qiL=7#@p3z4p({jh;1` z0~bCpJ@xP3KW0E`;_>!+JNW{>#DWXK?^rWhlM7N#W>erh zDaGo9#>!FNOEc?^5nBYPzdn=h=(?)S6inuoRXPQ=w?j_TU!j`mU>aD+tfXXuqg-?v zfdIsXBOoG#R5Jm*I5X4iqm`N8W@){;!2hXa1=L z)wdq9us9)8ty(n4`5KqCOp)S!an3qDA#8P6956TC*(=BmYs_Xq!fM}oti&22`D8pWLZtB=qwV7eyB zm>dR4-eH1FIt4i_d`Iw8g!wbd??B|X-b_L?Y+qWG3BHZbz z7kK=bNcvbiP9KpYnyfaDZZBQbCvt2oOAX%6r<~$vKm-TMApT)&PGBv&G-zg%@Mms-4 ztW^j3;m(NM!pk|J-p4L^MEY$PpXnarmX-7Okaf1Q&S=_EBOV(1H4_(DTxz03x+Op$ z1u2#Rqo+3~^A()7YeK;I02E~K_w$t|D}bnG6ubs(q<4p6YRb#&>pVK4+@5as+nf#o zpO(~AKADAu&%K8V-{woADJc6BD}kb*1i9jWX=ck+Qd@WaIqh%W1xFUk^21)JMN|}k z<$X`BL<+uZx$z3lLIiT~6W;1im2+gRck?)vkaTa8pY}wtt51j2Z0pGGyrLrqOt(#@ z>MuUxj0;7kO)8hS+EAd_3Kgeny_dCBsz?(=5Vf84(~iFT-Gp4zsd6Y-bQ>mhAP2hZ zo_C6wTA_k{pJHvUFrw7!vw@M$Ap^n@cwT9aeze@YGfP#m&+f%K;KQBBRWHwxBgU8$4z5GQ>R0uoB9=Z!DoOk(QCfK=mmcNNgB7-%_U1ZQQ>{ zGPC64glF1KIPO<^vjS@iN;RLyFp)nSHRZ3&%m(D6JeGgIL*iCp3`7>TYQv~UiRX^A z8!84-S>Hn*vPL6CM0v8|3l1AvC2<|Q&QeXSuCO+ip zSfitzhyMOWN(mK0O_9pp09a76@y?+(DTrIUI>o#sM7$+ioeVq;SO{IN%-+Lmg3lUD zN4s@-7tO%)#NPR-MM+lN%$MUYn-z(R}-24BBt zDytH5C`tbG>{2xFjH5ajyUZU1xwmPuPfr-oWbhAJ9^qHy?UU+~Guml9D>!BPqYcl< zZm!90W{R@)5r-AStor0A)hRBO%{_ZNjkX)|pljDD`iaNO)N=elpzL|6;Jt+WaIs)x zXK$*kv_6?DThUm*otvLeOHJ+kRRSzq0df`~YXLq0wN;j1kM@8G3UFz3uR9y!(66sY zymgRO&^!uSXRWj#WF+UW9E<}oTQ&$(K$Sa9$UMJ3)l+ihcg@X((YacAV_$;WbE z=$nxOK2f*4iMhUDF!n8Hi?MDBD~t)2sK(OYHfT4x$pD8-(*tKgol$`Z-Zjo76M41t3&Idl{? z98svsN;$eJH_|Q94-Bw&Y=4jlj(3+@Tfs9jcByK9r#O)@X(-|1imy{=FZ^~?%7}GM zGteoCqG$DFQ(|XZBHpyf*)m&jlBdgeJ}YEdCpkq<|L?pNHk5=9(QM`TvkwP$-v!&gWU&4~MI%bKHev3Hw~wqOJHxd;G zw=)yzqJ)xW^y1G3F~tRSlui(6HNtM{O6<3WFvu@4Rb zlP3aQz0`n@r4!0nyS~_8@oapuw9=f&k*ucPAJ;)=a?O8%=a1ZzRPogK0i0M}>@8}?F$!fGDO)-P-W6Yl$M+x*j5k* zFg1#P|8;k}VMECGRfq=12;;-BD6iTTf>YA#xP2xmgjV?>d!qj*Y{7teX?0x{2t|5 zam*n7-QzE|bhl|_Yaq}x7`|cFs(X{iC3mQL*E_ec^mvjCRwrvFSn5;gmxhn>uc^=h zaF*`FqD=tn2$#e&HQ!#-VNoLOT2s!_S(!Myye(7Yp=6P*T>iTZ2laidUPf>9Qqw{z z1@PdWl(u>rpJ6@M;#Z(P+-ug`m6%z6HpmWP-H5sD_8lNb3eprIRRAm`3kt}fXL}^R zKGuFR5btmXH}j&_oxS7~KUDCRD_S+`8tTarF>j=-lP38P5zVfwcTrhKM&%i(YK=GV zWDtgo)!+}t$-CP;k>hSqOgRs{&cf3xRVbAqEC=OOG)Vnphrr5 zE)X$K2@7f0-Jg+fAds%o%d-j=Lr@Lwl)|Zd&A;(-ejjS2@b7dQgnJhQzdQ~P*JT1j zm%i4TgM=DH;spYL^tcOl zT}2VA?N8E)u;H~9elrxX_Rv$RamrDV~)oK2qjRJ9H{-p%@_!_;4_~ah|~1zg@V&s;I=n*WDvKy((gfRKcDT(Q29wBamF1n9e0k*uein?{o*IJAb1 z!108OP~qgpg#k3s4}QKtLzqDSnS4q}h*ABnWw<^b0cxNynO$+-QI_-e*7nLE7i_sW zNE#E2>8GMd#K7Wk%vdQx<%WZ$I^oCY{OW*h25l0MvpXilNe&sOt=#dVX=rV0Qcx@P z38FktVExaZ-;x=FuG$yJ=fXuJ^W}4cA^a9)z6bjUoSZEZ6cSu(P;yi6c~j!sA?Zs| zg{_z_9A`9Lv!rOtCkikU2#_Hx06-o~W%RZGta)_#T#W>jrmt}sm41Lh8f+`}7(H{E z_14>7ud=oP)J&0guo(w2Z0y89&9oMeE!a1GY}J#8o6D_>Ml?LWy2bWwYOYS{?{ABZ z0{=O(Z&r~^kr3?}Er>lOdk~k4F;#MZL42LetTO6tt40u@Eo)&PT~^=CqdJfu{B;|9 zXY)9GF9@VIA!uoZ;rl*c3PIQs4JJrZT%ViUkYCkQqphSlTwH995Ls7-{{gh0&6FVo zt7}t7W!a(y{xs>DGoyGcBe-x@PYA3(s^T(25vyu!WMss>01?1|&B(!RyDP3t~K3&9gyj1XuhGBH8}yd*3EUhc}GI9Arfj6^f4Xx_qv<%3tEjQ#~yzF#fv7clB+E zml?KcBL~7dHwh4AAqs<_KTT9)`o0pfP8BR%uas6*MMXv?4jTgw9*(ZAK0hZjGc)@_ zKhR-##G>y2ZR`{LJZudLIox0Ubf#2FGLY6PDaxoNH@ypcucoY&n5K)33_M)$RCNJM zDkX<2x)(28hHbNZVvBU%3~t*SVfM__%=TFBWBoCJd3=##wW`l!U$$>fU3a|U~?MRXZ3(p0a|43m!PVQh5;ES+Qzg% z-|&Bd^%a3fl>lpaT__G#A0+53rX0IW zv3bIQ6r?}U6{ZjElnlIQ{S!H}W^ca1;SuRFWjUe-@JbgucI8B$!IabP;JD~-)zbM{ zVwg}7-Stk7^$jC!yT1PW_+p^Z5ZCI(S<NL07?k6LXa9Pa+it1ni3{!j zy0&UoS(WwBVc#O@(?#<3ODBSL_y*V;hV(3Vnk1=W<3X@Zk%fE&g)F!m9C#-eY8zv3 zucSTIYH;uIiDmn6y&-G;$Q${a$_ZLr8ZRRi9nS7-9O3nw8=mCVQe<^>wv?J1!&@N) zj~-n zeY;dax(DpE6# z`~&9^&x9@|(52HbuenR&zk((5;DauqVxileDesr^TG=_RQFG-_f4Q6z7G(6rHkaP4avX(O9@ZF|z>edA0itJ)+HphxLHy`pkPtSWx zV|2eB_cYyUronl5(BH*DKBoTd zgXi}B`KyObNe6@U7$lc&Pl0m-?XnK6Pcgm?r$#&*_`nQ<*+l=peL(>W;vM^AUEPrA z=r<)h6PD${C_!^JU%qMS-oz1TUS1ywiL0KjQpK`6FtXQUECcHKC@9Xy=wU^THH@@xA|$ z!&YrHRDT0gm_P^{uFS&|QycTg+Ukp;{vc}stk0pV*tlNUEM_xrUzyyYINf|b$XiNu zh=N)B;=VGWV_cp|W}62Y5O1rOwO7@33ps{Pl3f&c3m~GK@qO}V-T6*R;FBj-(&^)gBZHo(qdFcl#9%m zxadIJaQ{7aSrT{SV{wKziS&Kawn1NVObz*B_GjUFoMAAyoQCF~rzk#pNiqSe>3vO*2Rdz+Zqv7_7{f z9XTRwEw9!yDfKR5GPNn_P>YA)eaP}G@)8-t zC3b1ms)Kx=k4@rA!DW0Bg$b~*UHgQBYye9nvEk~3&)aY9q9}ErUEcw)X-f3Je58EQ z6%^{s=FBnUI*+9jC9B@|ck8mocd`W64SA(!z-&hRTcB^U$O^X3lk&&%dzU>m$gn~1CNyYRn-{75;NNhGus-urUkDPrCBWY z!a1@2p%2=&svAwME|iPCvQHFBi=TV{25D9S`v>+ns@4!QDDP=0N|noE#7)^_YOD9I8yT{%LW&CX6w zZ#P|Q9i#G>hX5h|rnjqdzBeD*gKX^H}=|^lJhMYRJNjm*kU);0@B7W%9295^35g+v zfxyd0NBOr{!P9O`!OKI|(U~;?58D<%`WUc$41PWc-a9-5tkIQ7zd;Lilx_qK@VL3c zZDc~T18y|r#*S`a)%xz>DiuP6iOt8^%6sj`^jXIV2D9YXBV-be>S-+mJmQ?$h|eu=i}pp9b!Lkmtw1G@O(O zcwYnrLMtmZGL%=vUkwdS{7!GoEHz4-dUi9I&9wA%b34Dg2e^|YP5d&nBwX&*BuzL$ zg8Fq+|Kd`}NH?B!x}B7NEA4!K(Ltni#~J5Uxn=5PzV$jRix#P{Gc5S5IDA(N^zK((IC_dy(O48E-osa9hx-SN&7EqPD|PTrxq}Dq&)hUW|c2^!W67x^o_P1h;p_STkyFGQ_=rtYSm4QaIq)Ie3)CPbfyyPacB5sb-PkJ%^gS)!{vB7W2+d{=0H;3JO zXXOa@BtxI1(l*60v~OP4_haXGWBgI-{>9NvBq2+S$X?Wd}{R0%$g+p{t$5V?xL+f@E)&Kd+N>x2~IAyDV<3 zmeC@a`gbN?EP9n}_kM1O-F^)e9_QOy>v6Mt>J5fUD*sW2zjNWk@Jfl5RID;3@9@qm zWj8OW>EoJFr9j*h*=c8@U(3%{nXg*AZ|z*#ah{?SI<&#a<-+FhKGat{af5TDHJ$ef z1R9La!oXn14M?^mBK<1JsI%gEcXa94b}|ulW`#xM@v=Imhc49gm|@*Qr}Z19x>BFh3g~e`LWsib=jYtNY%x<(2CU*M<`_&(H<}S6cU^XpUqt1J*yMHos zK0d#|itH#snDvC~dsNu#I49!7wemZY{WTLHhB18NLR$RdL z(O*EWk^b=`uqHvNRb=OjAFkh}LTSB0-$nlrym1o1i%@fg>V6*AuE=w$3?Y~p=~UKk zC1V>~@BelBluBuE_&~8M4`)7B z92ltU535^W2P&)|vH#Hde0+ufl0gUN@vqP)>2)Ofe7I&SmYFW6vZxnJTcIUKrD4qO z)!gaj+iEx}*Z}$`F^@p_S-z>H{Zk<`#q2=^f93eT-T%bZe1s(pfi~7>)|Lk{MNe8Y z!;{0)x4b74j`5b{0d0|fWtbb-{ky+vyL~n}46b{BT=Ts;$A&ca2|{~x6nK(;eL?{2WR zJaUfY_`avLd*1&nQ+|<$^+Um3pP2`SMw{SpqxYuOPg-#Q{ZiV-@J6>yxV?)=j&@;I z5LO+N@fUVjPV%xNr$@NW#M<+DHa9f19&RV1d_dzoehdYu$ESwLZV_TWh}isTL}bFX ztE(fsoI4+sWD5y^L)f?n*3=HqbCHxo|nIu2(eP10u{k{(X7mCnT z?82O$2HoQun256e|5)g%K<+?`-dYaPyzI2qVf6C3`1V9YSyRyh#iHxFmOIzlySkP+ z)w+cltuH^cNJl`w@7YQ`W=pdV*tEzBHhN?*NH;7d`Z^z00Jcv<^+%mtF9}qx=1(!z z)qPu)4gh$?3cRl2T>lOPrYP5Zz{h!O=->SAXVXlIx3WbWATUL(PTNzzP`dX%Ofmg< z-3{O3844#co#@QoF@Gmyt<=dqhU2@@v+CGHB8>}^An)D2%q-pekRT)w2>T2=>fwix(UVZj>3N;y{PS!{ z0eQR}C>9MSw8cj2WnN9MbDz1fDWYN|12|U~d;^uwIg{sXB{=HLGL@;6t`7&QbVd=} zZE829XYqTBR{*%8CikaswkfIK2-mFl$R|_q-Ct)LBMH6frIo+#*a{PS}>+N%6|g6-4U!^ z-R>wrzhgQvlmi`|u{X`h-2^Cp_odOp{ni_a$5KU(cu^`*Z+&UnZNoV?wzz&G2TP-6 zSEEye$g4Jlz1O(8OBU64cV~akdle@bUk?joOrf_rKbrcZPpekB)a(WJ>tKH<%FWeR z6cUP7E*~doLkK(vG!SK#XRG4*sAAVXpF!prZ2H}6zW-MXpaoacjy=W6B_q2xXCoV_ zx3$wevwCQ3d~m;)A9ee^tBM}!EUL2F`rUOD9glZJXl*uk58#1Elh?n7SKl>%4IkUt z5uv56fWV*EDkv@<9H*D3p$BBoO_u$JI;$(KjMDbMtp4qn19L7mGE$d;v{}WbBR{nMz$k*C8DY?DBW=`b1fy758!w!qJO z3eC2gKfvw-q9-@UI_+x{?BT6rFP*CC%X5N=#Avk)LAvwaZj}mAHYi7N#pj`xJxA<7}zLY7zI3K0Vw(rbYu&HedMn zu94T`(o*xro)4EYXKD~Vi0;pBXq85T$7=H;@5;x&8o`g()rl;!?JEwbe3LnIsiy6k5?Xz_#q{mCfMA3Z) z5R}|Rh*<)wSPz*^q0xtJ9=8X;F6WN+YH;&c7|f)kG-VnLP_AN`q?8mpZd5|TY(*Ew zri1NTYn}6PQFn`-{uUaV)6(eZDTP^=HxF-N6FWVI$?I!od;Jb2&ustt@9m3W?47?; z-IMINrH#U|D$}VN)9T8jW@&hytFzu`^j+t4Ui8B4Nh5$Bkjl{sUq)IG{BX_Ydv-d0 zZY!vjfxfBDH{I*RK=udf*11h3@0j5LOn@zs@mxX4Ys?KnS1C@rN_qRm$*{;mBOsU-;ESjmDX zisS7W-fdvxz2}}DKEekXDPjPzK#S3JW?zgV&E^OJf+rNDe>UM~KVU7>XJ}qSBUTYF zVAEZwWYhej8)cmK_?UVOAwTX?UNw6<=N*z94cq)Roi;MLu*!l5kD_yj87 z(-EvE4>(yYsNeRD=EWJIN4{FMd&9tPx!z@h>`z-uA_TX&praf0KJwPw$^^hnQDYb+$${0i(MkXt$!T$ka zXBJa_iiqfVUasP0P`e>#i~~YaKB?fJAEA&!dU&#LfzS^d>e-m?HnC-YpL%&SQrxMA zwxER)&Z;L&5kwkMp@9jwv1(=Y6{tA3KNNd-px^$)J|{f%_7Z2z5+!moz367lq664$ zlfWoaqnn!2fvWjE&_uCuri&Dhg^(ZE3*@PntnJWGctJrRHbbWWL(^BrMe%-bFDSb7 z(nxoQbgOiCw{&+m$Vzv2Bi-H7Al;30hjha;-{1f9%&UC^GqW>$-{)NCitwJEUr5(E zuW&r68Cb-`Z-$4%s|@3ae1ODse9hPQH3|{_Va~Cz^gLHc@G3g=f=C>7qRZn{%tEqB z30^Qpry^n(r*ilU8|&>pBb+*$RvCND-p`3=JCC0d7bvH@?H>!MRG%A-JDj z+sIS&d!H_>*;oEtKmLl|pt-+usDXFMU<~LsvbK)b{^Mr$_u{j$9>P63e7xv|+eNFi zxKigYjP;x}x#=azlRApZkNyQk`*T@;n7QvK%GA|?w6NGwRqoX{LhYl6CWUI0v06u~ z4iLz{jg+meVgTJvr04r-WCWmp>OD|nlDU!#E!UegFcBj{>-pkA(OD!O(0iyO`Ic2< zG-%(VDhi|z6O2zyp#^*cfx^PWO<3Q7O!*Hv1S{4Plaud=MHA2QXfWx%ypI1##LvrL zlA!S18$I;8Jt002d_m-IPYr&3rr^o7e#?@GgV~J7B7Ir?_$~uinD7%zOX9wvQ)5OX z(cUQ7r3u;I@VkNpjxrmLa-Cf;^1`E!owO9d6bPQw6{2N=)m-q=Tdyi~+W@%^nOXe3 znQjVVf^-rQnf)nJv3YU9UJ0FFVNx%RT9=I;qIq$3wJ&b7AqcKxA!SPGj(9oPCX#s7 zeeIV*^9w&lk{34BRJX4E*PN+03A?9=`8<{sipyd;O1!xlPKkbM_zaIpXWthB{I-GR zPnXYUnVHQgLPaaGm(t*KD7Ad&KyIfG4Y#Y>3gzj9UeNqu1t4Ye0f7S4M*CV@4V>w@ zk+50&c)xUcUYOg(!K@GWlL-{kai6G$E&BKaVpQU6GjDic9WC!-elL})&_1TvK}du7 zClcT6t@Cdi0@4RDX!SeT)9w6lw-@hpDRO3gjyMye`KDeP`8LHY*Jb{f6${Gr36UF@ z%1>riT;ua{B#EoQd@1Q!Ay-Yd-YMnmpg9GrJ_SoOx;q88n{ zE4Iz$*x(-4&-_bcrRnnqz{e6>Yd=IMBrH%`@qN>5vP8dLepZ)S^&r&;5 z>ATZdq$!iYSo$fI2a}kfVSpw4i)(Rz#29pm@Xr62*lzdz=RZvXa#_1=W!M? zvSWb2PnVV!728{c6y3Nn8dx(dwY97GAbQT8b-O8 zpV4x3SA#%VLFE~oD1qN$-;u<0yKAU7P1=A7Q1CbZNYNB)LXHCZbNPKVhC@xZsr@vl zXscp3HZ~p~Yp<`J8?;W(&)*QRU|f*E+ytJtKXQ$zTlG8snJ@jw2R=?X|5>etFOL1W1f3*475zC8&ntiaZ>KhK7Rtb8>QE zh=5njf8eq4d|rnFQlsscX<~W1m@iVPLf9GadLXyFoEnfFbr)W>?~U%@#l2?vmf~P@ zG(N{ugoSsbHxbQ0oD{t*R|J-S#2dr6ZMFVh#&hhRW$WVQB;V4ot^o2^VU)M4z>{=< z0Ts_4J*g(f6E1>4n6M6Ph31zE)F2Qne00PRF~_*g_h5nIZo?W*PEJ6x&iig!@Z*Q@ z%YUXpP#&OiAzpmS$=9XBzWe?Cvw#o5a|@<61?>1|@?fNzRN^gL88XuZu4hk5(vpxF zMrEz^Pn$JWg3h-Hu|izr-dKiYh|xqLr|MDP=#ft|!M^AY;ne8asjOr3L;uWOPJC?7 zv~HmaVbT>8zk&frmL)KQDei>r=Lgn-&j~?-X7cF+4h?RBIso$X})@GX}=Wv_1PL0J6?xS&yaM4xEbQrqbHVEJH^LOG>v0*+y?h zN+=u$n|L#+Vn}Z9=~lk9DYN?+r#r7R5);Fr7$UZnsQkA=6)uhj^~9@VEA8GYQ?-PP z1gQqBnZEHX!+zEp!<0qd6r;})NC=;fY%z{(^HoX|hhFD0*HHk#ff?Yoyu2(t*=9uq zQYRaJj@EB&w>*p9&pTz5sRDjkd5YeczWEhxPbUe7oMJoVb1Zi)EkLgzOgnC(%QDP3 zn1MXt)29^(J#-vjxA+dS4QsGTQq@4?hXG}Ym7lnxgqwc=fek;SA6o`~k^y}y4nE!O zduwvbHjp*8!~ZRhzzE;r_QSbA5)0Ey6!V0=Eo7|$=OnDdNK_r|J(e{IU04WmVkM?v z>-9Q17@p$%W5UM`WHfeGJ_n+v>ff!0 z)K03k)H%r!#&0@sB@7s@r?E(j>RgW|4=S3J;3E+PkKh+@@%tzrnvwDJ3l8I>mJMH_ zz!`M(Eh``%F1;t1(vi9{7jq|!XQGvuPmHzLuf~v)W=u$cz7Gk!nd@CIoFFs`fW*a6 z*e$c{&V^4rxvk>!O}PgwNXWd}AcCq$5Fj7SN8EgNi0J>#9&{P7u6RcacszeL8GNW06u~fKUK00pEUk@*U6X^#2j}DkO9$z z6Gj_JCxxXFdQO7iV<*I$8xx?4=i^KNM)LgziB$C4ub8YD4KM9jV;cH`Z+3P9F~0Jl z6rzPgv`Qii0$x4VcEkn6BC0XGK5w#Gf-OIzN~=lGNDJf=3HheDDGq$p#6lY?IA?`G z&E@!su;b%z#rIaHrTyy1$LT&*43l$jjS)lf_vIE|mEo~a;iie$1ZsJ}!`?$r?;v7{ zX&@+=jfh|zykdP&-)nA3#CWN;N#|1AZym`-*gN%m0`dAzJt@wyv2k8S#o5Kt($;p* z_k$q+u%by*V#G>E9$+iXzqmTu5-BQ zYbw4pF9D6s&!vLGl%gVP0v>(FO;w-x`V@41_iu(wKUl>yBA^6^z`lP%`+#~zQBZ`v zvS_)TW3-5vBJ&Gih=yV$qhoA;K$=X5xnG0R6?~hFl;e6)AgFb?d`gV zV?oLX5x0?wvCdS-2a66$uw?1aWKg)!Cmb0F7Mc*4MN4BH-U;z>uF1D%$ll#S zZ|bg`6P1Q_sBhz@#ZILGxtx5;eL0=UYn#&my5(!*h(zD?@dF}$iis0@)iMV)6m}N4Lpm9R^Jy--%kEaU)0=w8=EiAk38}d zHyXjP?Fa~)Zz2McFTEpv&lEF+UuK3eNuiT<1 z{i?UMvGLjZ*7_Z*2Wcw5lFX>Q-s@M&GHqKlYKPF5=b&%#^v+k(B_lG57>jEofjXZAVa4_n(p2yYT)U2QsMqjLF& z;;cR6#sceHjtRk`!`CZZW!#Jb={l^PYUR9MT{WpwiiqKz^WPXxXaOhpo*pjyW)dhK zM2adNr(C}a^H{-O{o<*Y)i3=^TS2SAL?q3J_=XXq@|2W+w4Le5^zB8*7pBe>S-2R;RU& z9z|k2{ch09N=`{>wq62^|IrHyFgb0sS{!$4JMG~KzoQT(J-}5|*bJhIz1R2i+KFhp zk|~Rd${Ec4j_=b@c5LcnTbgB0{!LfsIk(JWNzVBazK#ySG6EtkB`Ep%XpQN_aUxdoOP43vg) z!Ln0O^ysc0K*bigiqM3*UCU-AMsvKYKA5KB-)vQ>2|_1#hU0bTD>)!&HAyj(5Hz%O zZikgDfsTJ;_h^CLfSp+%XJA3jADNr&+Mahm5R$AE!RppYUud72zrKv0ZT8}z;IWhM zsFBvO*w+0$N={FW8rtdy?jxO+ro|S zT|ikG1zoefJQL-%v^;F}hXYUta9}g*J@W;lCsXLU-;W>9X2K_V0t-?X9dm}`RZz)~ zt+iC9LYrM%JNa<<7}!%aNkr9;JIuct=9-n6Urez?z>*RY8d_RHSSPe+a&pToEH?~l z@8S;=V_7_AX+}R59)zGMlcUnvzDkgR&p5L#N?xrLog#n6OFmd%a zlPyl+s!5m1f1)k6O9ae(B-c@JJJGuX6J%*+MH$*x>E~mzc(S~#H45ufB*RK)A$RO9 zAUj4?&K)~!D-5=&BX%Wa=`2lU5<_1H8WXqQb!uuW@5PlRX)iO=&sidoKwaCw4gB7A z$a4?Q@jqEklW5|>KB^7xoJi(WULz@Y*G@LL?9m8@`wE!ysz&!x`u;5!I)F>Jv9XCX zp@Kq$ScUKyPm!-1wV*Kwl2Y+xccqtXLK3<W%n_TRf7D7%d8}Sm$N| zif2Uw>_Mq*#@)#kRsbG1JG%sfMfc}HL5tDCVOiIx;>>XA;D zJ-ix&@85#Hk?5cxWk^tY!6R1TU=oN>RRM_7Z+{q#eIf8BrYO=Mt!X~aU!_`WjA6&_ z9n*iPSh=XnTJcEhE#^bS9a3pq3NI11!jq$yt6BfK$WWQa!fe<97coakk+(mNgClHP zV|Hnt$Q4{pL`Lt^W`9$K68~{AZRY?tJJ!JQxw+@{1@&*|+QDh0OP*bV=!YcsBG+~z zCc6~*vS+C(F>ok6d_^r$`}vJDG=^K#eS37X?OisDrp-2ij4M&f**Q*~Pj5w#QX0U+ z8;mBfcLyVbi|R+Yq70pg%az0w2?gJ;yo-E=b_Zc0m8AeHox&QaH5G4bn0!k)!Wu zf;>@HANuLox!NYY18KTD=VrHR`CPQ%rmb&B-F8;e`Wu;$%^D=z1o6- zG+bd}A)(~gsW|1=ysZ^oVLnw3S@>apd15r7ILufM<>0gS*Mzy-itzFhO1HgBSR=Lu zldCEbeu<;5w|LNj@O=%0vs$WZpBa-(fxp=Itu}<@fL0$7(FHeRT-F1s;N>MO{LVGh z6DPRW!ie-@Vbty*Zf0(&28`afM2ndg&>$mFFO&-)R2Zlo+5}uwgTEQOL2nB7KMknLn9vKj9CCggB$% z$%{xN2*t+4{AN|Qqhn&Kl*(<;kZ`p|AThrC(w4ClBVKl}$o5U?kD~bbY_MJL$GcI& zh1EY94a}cuiwdqt@X~6Fn8w&R)b%?zCcK)qxldl_xqv`R0s+sX-vPpaicVcuH`0aR z_X2R|WYBo@6K$)GTRRLY83-GvD@FV}2yalYELCijezU(zF(83t&W_bl&t+bwx<0+5 z$Cv*+NV`rScK$qSncj_BS66Fg1rgdZ-h78h^~z#%kVGGivgX_U{k71_eRg5HzwTPr z>IdDQqn0;aPe}!ZfAtn4SzoiWvV0HzU>RFlisw&Nqrlzc_^`{PjgvODP9g}4bDbuvFvVuvGJxXXBgQB-<^OPM2kfslHawUc0*lpu1 zG$q$MV(x1&o+f*1x{RLhKQ%N6f+NKxDpZFS!~Q=Ppu>kC{Y6bP)z%i}j`kbsfmq?j z1QF>5Ct2)4i}CP{*WLL2!$t4IS#edB`Pj~r{J~w7c6}D%)BP#E3;ct&@cic`8zwus z{<$3zs3|V4Uh0-J6X`hHv!E&)At{9z`j=*VLs@bG61tk>sekSnPd{?|^{o)Eo_Z-o zIMa0%W20j<_lbDdSQ!}+dnNoQ1ObxDK0E?~?MlN__uTcIn%gOrR=e?8m9epMNRKvB zCMQ1cseGFk$;+3Hia80nFW!yml@X&6D@}9<>`+Lo|JQ2!t()S$yKKZZqL^>Lqg_7x z5@bb8;T%c2^Xutlg(*nw6QR=@Y<$y2B8T|`v_1ZMB2-d5r6-L^4sH7Fr?PXqt|%j7 zVthlk4J29IS7V{-iP>;qs7v7KUP?;qDtw8ptr(bABJ7bNrMmac!sJEYHeJ>c@A~AT zNbN&-`U7C;ki?+LNH3k3q?XNPXCW_Z<$M1R1;K<NIhkANkTk2aY+cW3PNtPml! z)>5|MPgPyl)lS}|LK1R%IuqXx0ibDB=4@wY@BFWdE}^dW6CF1$P;aqwwtd8o1Txo< z;V%eT$Tal*UU~p0q8%@Ag-UtV8d6Y<>NUu@^+pPL!?WeIr6sHruIN5TK!NxlBN?P46Ddxv=lmr7HX zeBXWZA*wCX%-yd&Q6s&{q_`t1qTK90aQ>E)0Od4|?bgNewfF8*=2u&zB3<3Ngmm5R z%z9w*2@9(N1^;#107GH)yL@-$jzRXwm;hQ8CK6+>ux`uTbnS2$u)j;KX&uy(um@Cr z+RC=R<@Ad{1I8X&zojUGpUy}}=4>6h9okmqG}2k27BaX!z>~s{usu!A78DdzQDFgA z_4%tfVN8XKkMC6E0&4z%K&oF1_~gfG^W_woD_QdwCqsk+9;Cz4lp`o-Z&OBB69}#g zOHLLSF9`ZHZ@BX^d#BWrG`|`xwjyrUC(TC@JKN)7zOYxcqz?a#QBqRE=PWN&I6>nL zo`gf_U!QTxDy5SVgL%ZKfxfJsYB#AA7Jj6mlZqSWc6WcFmLu4aYXjM1VD`M8ygc02O@0X>_|nBiwbZy$Lgo*ynW z|8UY0x@~6>mt?E9EPn(K`5h%)A9TJ$FZ?GS9 zXTGnbBw#Zgoh#d~)bILiF-=j)fdJwXBt4n1{rJAz#`Y}bw=hgDhVvux*RK(50dL|^ zk}tBS5~jU%ean;ZQoq6*#3~}*;^)`B`=@A2%CGyL7P}&Ao9d@5Eew2y8G3oSK`-x_ zv3gDbNlr*ep>#43q|Q!827AoSpYy9-r*$OEl@&ZUdzT%W{)B-p*rR!~G1&T)8aWlO z%8;SLsNVOs6lA39l=evTH1ZSb4ktPFay5AV&reHhCZsp_B3?!)@UKxOp1<#pWCYSw znWW@oE@1A%$q9TINW>8mjvRbx;jEsts z(sH#yU}0flTpaqmgS&r8s^;(Q!TqCS#N}o0;T^EU#YXjKU{@)33LqxOD5Te_HMdcf zDhLQHC}unzHOlU#E=e1k<>Gz5l~pv#-&dfQRGe-si$0b8Amh}C1n-%gs%L0a7I~~w z1`F!^SSIh^1;ioCueV>IpkOc64IZ8>)wlBlIh*Ce0e);6u6l+x5>|Z3q&tEQ+2w{U z>}Ra$li2(|1Ho}yr_5Q=O|!auW9vXS^nBF%j#^hb{J5QKwY1W*2Y5RC5y_s=Y9a$J zV5&|?Na*F|g@J(q0|QgO?f*t11SvDYo@WVHk)Q&TVo17BwVf{R2V*42m>%HkO3KMF zG2hkK&8j3UU+$Aj>vAkC1zMG+18oJlGPK?W%OlTh$gl<$78WqkNlHzv%+D7li>;P> z|A=*f2K)QU8px8G6)?AbyVZ#2b1AMXO;pd&M+|mY^YC;q>P@4LwnpZ-9sShw_#D`G zvK6IzLM$M$-pbirnuoUX?=7_ZdrI0eAhz(_gq>UA)0Q5g;p4*x0GPl3ZBlk<7%>ZI zgh?70(=CItMnmiz$Nj`ib9HI287HgL^LtomrnyC)?lrwhUx~$wcFfKHWZkCQSypyB zzwU;7l=OLkPXoMu_V$%6>Vv@*wl*D;v-L)Y(~$tK_>6)8bj(o=5ni6XMp`Rx^Z9Ob zxUAZ1^Ymwq9Ca6~eUh;5J#oPXVrgO2$#OgncMW%Q)a-ybuyDJSoxYMQ%`b$HW%PU<~#@)34%5hbW> z9*H8;)D#6!M1KhIzd?638s$(ZG$kcvV8E}v(2P`ouZ-naz)kX@5zwzp%n>xQpE-I+ zuWhny&-V522d^19ES6;i6I?l8BZsdY;7rX<^Ny_D_C2)N8L}=gqS7#)rE=_g{rLfR zW_w6jfAaPwgIs0TTLv&=5% z60-?TnBP@B4v&|SH(f`#huy;40-*c1awH^d6BCcxC2%e~bU=ZIczR}TcJ}p+T6^i* zs>R8ym^c~z`Kj$Le5-1&gWIY_;wQyT9*Li}^Q^r~Y17N+IR9^!zDrTZ@(qc`jm;4W z1tAGZvxIBJ*Jfa@Zffmc;>>Q!QN*q|6u2QrEk#? z&>0X@I6N_N_uPp){|!1oa(%fwLhP#nmM5a%I2Cr;c=H>PoOA5)0Ix7w?(4uNgZNNZ z|FUHMn1Jia=(&#t=#iHOnzPS>8v)Gj13#h$1qb&cg!oT<7radn}SCb8>nQ7XrK?8G4+QpXn~U{@XPq3<*8lIH}oR!Wg+=>L~l(~(_7I5 z;>J&1j`5@hZxlKWwc-1x-&eGBNx+cst{|v(@f4gJt1`CME1nhkHhEErrs{BY5{pL6 z%FC%bSJ0srB`3*ne+Sjl(gIVu*`k9(2L_hEKAavndwO_0$ot~j3(CojhoHr;cR1OY zON{>EZFawqEB^WQ{ZGhsbw!zan~GWx7YCuao!`tXMQWDs_yW$cf{(<;%hRB$%4mO| zn6yMhfr6Y~`+YAyG;>JgaG1`k++_6($IeUHr6sfX=<&?nL)fL(dT7B;nlA?8SxsD8R<=^@ zSQweLu3>eI9}uA9OLVlB&Q+)JS8kpgYRbhm_{HbX7|1815|C4_u3k-K*`UA=)6u2v z9zC*sEo8JjuXL!%(!^7#F3-3~wn{9!p?ci!pJh7)lM)DB$$otBAQ=K!pbfkMN%q0~L;`j5lJ6ROh($WL6m8hvYU+;L=x_f)+>7;^&%WW-anHg_f zoHKN_v>w_1B3=VPS(UZx0!oLig$0b7!6PeBZ^;4f+TjEzcX?%{Yh}JNyt-f`zrzz(JU9^ugk*^y9P##OK}a=yjZ*-O%##<8XY;$q96& zsmjvA;>GMURs6%r5;@h?dm$k(DRjV*dpq0pSpO>n_VFz3-|oOc)K6RX7kR|1-(O`p zImLQ<-rDFRdIh-H*}Ff>XT$xh?(%rPuTk-6VGcBijCm)t$-W%m^VGaV>wI&)DnaGu z{Bat>D?v4(SM6_Aap$$1ck5KFzRWZF`xV9c%_?AIJFxj4f_}2vYbZItu;8|>P-n)x*vR<&@-%1n zmr1vY>GzD2>O}vJ_((EyVqzo~nr4UsB%nG|L~H-}IMAiI6O3Ts7at#Qv^+iCQt~4P z6s)YO+TQ?@RG%Grew4Jm1EadCt~-yLBjEG%je z(x=O^!Qt`os0eS-qF_>Xm|RKc$NZceZ6F?7AU&xnBrMF-xXB{Q1-5=7z{=-?74?Q>aj* z%}U3xo=Y?_`x|&np^nz3#7jRj5)uc&cAcF&Luj{i@7gtp&w2+Nx)$*JO zYH>LZOIb8T=vUQn$4a$sHx3Q|`Ln-@h=QIzT!Q_<*9VJK1Pz^aXcXFw-}O@{*Ltaz zh2dl%6eGA;g>K&Akp{TPF@R>Ba&&YhB9e#J8XEKNXYI=1zP?!L4LZMD8M7ZcnZf|A z4TIG%jg2Jv#y@)J0pf`W^ZjZxq3{oy?+bk`O=}=R*voXgF0zE`;tt#eWmO3`Ey3Bw zHMO;WCgi_*xjt|9F59iIe)V+L=R(OVESy`<3R2iNsu`=ONaf|_6-dGOui#kx3kmHr zJ72e`)NT8_%I`dyBFtsWpby8T^~gvjH>BqJS{4=#b_n`&IE)znl_p9YToM|tO(kdt=WeIrM1G?Ok+kP$q0Rb;BM0AS}LRDyCRPjYJ znY@~Ug1Kf+u>anGHY0e*_%h1pDT|r{`o)LW<8r5~W90kiFMh8w`BR^VKX_(jElTi5 z#Vp}QLbS^E?Rluv<_Erk85^qGGZGdDOv#}GDOO*lpVh!ONQrE0j|YoEZEo)xZ3(T7 z>&IrD&$9&LEA<3|UC4gp^D`Q zbrjyYuH5VV2L3ccKcqY)@8kp#+FPbmMXt{)^@PTB<~pj0SrF@#LP#knDC%uifN`20 zC3TlZn`?u=KWIJ_qz{1n8rs_FnVByKQ~Bc2L?&i$KCQI>vd`9AFx>C$wWLS(2L{^b z=b=^$-tt*}yqE_tVPubg3IakKNWrAcr!1S4lA>cA;9Ov!$3#hK59!&qCztJtEXTpX zLBqhIebfqcFb6#%>Cr&}{XI}wbpG!EK4=VX3f#fMa?Y6l0al~}$g*tF-wt2GZJC_l z#bG8HJ9h$Y7geR0ok9Uqi`Cto<>#ricTjL&|K=UO)~9jTcki;P*L)w)NZB1vey?c@ zBVM*}6@T#Wj7Ubv1)T8G)3wE;C&$K+kGb1}=NBc;Y9$3j#LhPd4`9^#-tPdrusUn4 za91U95%>3|3#4=Trpg_$kKFS3H1y~8unqNTO2>l(12I_6xe>8WRlth)6mqihmn4%Gu zG|zMX z=8M9?{lvz`cH{w=X8?FXiXOVjte4?;J#@Jvna$_6?)xl}3((N#f+r81wK3ww^#8gz zIP?YpzAPovBu&Y^9WY)AtdP;64?K)Ju2rpWWT zt)T$Cqb86e!-~KJAf6Uowr%{sSbLwg$AGk@^pl|R7Poy9QG-crbr1NdLoe8{Gz&AP z33ZjE>+9z0TUBf~bW3ydiCd$AT~b#?6Q?7sJ#x3{kPf1URB@;{&uY@K!#wWNB% z;s1L_HV*@;Dy^!@{^ILx>)DDIo6>D;yVU7(x;F;!78p~BziPSh^e&SmsOpSv+Bbg{ z)Q$d4+8#Md;9;;9OxYGmN%f%Vl{FFN7=3fY;?lz5Gd~^jul~=Uj(D*pe5X~zM)~A&A9{V$-P0yQK1fY7E4hOJ&pUE)YPPafNs>U?cNWq zzkeI^`tS+$czASH>B~olhHgxK#hLsl7!7frS*Db}R#tK}uTQ?Y$xch3I9s`Uys;`5 zen|rS8;ILR)nCy_W#QoTzOE?I&NCgEAs$MiQMTcrR%@5-S2JCB>TK^n)#<`>X9z2h zq(c$ckEj^FWwbEoXhL+`&uAHCFVc>aGh+U(EC~s}sFzQwDLW~uWt|1+G`z^kn4~29;bDEC?f2p%+8~}Jf4_EpKOCPhuLcX$Hlk4MhI)P!M0{Rn znt>YM!1VN$3t$FQ-ymyRg8*5U$UXUYh#KA$iZC>;z=y5vb0Ze8AVO*PHJvg&K9ChJ z%q`OSQ9-5lS@GVT@szPnoWdB}L*I+PFQ(P^fyRpOH2;ZMYZ*xc$TbWJ+3;(cVx&Mn z{I}^7jQTc+wC3UA(bF?KuU2!;2L`8lKU@~#BkDZI0dwA&q6sq-EG-S(a;*j(9i4Xd z^mn*Fh)55pP=aS}^v~a;1h1_}X{Ke7(9%Be(v}zlfpRKGaQNx@T(-?#?%xSZ%{CmM zq_yEe!_0`xOPXtsNAmd0g8UBaZBC`rWN4K{yX=P~A3HgUn5{{=PmE==a2hFJzQVOajbyDqegjxmr*)1sZy{lgZiHlgHF5{Vu(B zdr~rnh;HM{K2KglL>LBF_rF(@yhPz-@Hi!80Wxr?j#7<%#ZXD@g=(jAsirkMGMG zHWhlKMr0Cc>|2PpjGd89CcBVW#)%JOZR)TVr(JVe>vgP;LE7zs(oXdN$5ytGk~*IjyWTkr=Pe?+qF6ktMKN&W7mOU|xsV zsvsPo{jlXd+`p4jUyx97u7yIsgzmID?iMTNxB8M$Q4LK0&aoau0d_#Q=H}5K7R zZ||Wq8S9fZ3iZF4K|!1efycQ1P5ZMBNy3`f=ltdg0+jv3{OB2KqG<1w>BvR|1cZ!? z)q=t~c6OO40-kk1+TE-F3r9mUQk3T8>90NtiW{)VCISf4*Fu2FNt6V$7Tmk}dKmEY z*RNl3VPWHll0U$*))t{p|2FM9#MWJ&Cvzk4xe&CqDYdk_$k<&Mm~7q!hGI|~W*(az zhDHj3?`oK20u9bI;cUR>Y7zhR*tVYP5JZ317Or~aA38$RsdeY0?y`k%sy3Fz}h=K=fV+56%m6b z#A19|qgs|_K!|XS-OP^Q370A}uz7*3dz%1;r=_7Y#4avcLk2HO7fF*qAxgsLWdV>l41)1w5@$uSQHc#jr}8*`n|o%nHfb$9tZpLcF_|B zDXgfNL|p+7P{5NR9EQ+RE?|*BC17ELY8@{MDZ!+IFnOJ6I#RZ@LjUo!ITYmN86OMP z5D*cywOYSWQx0xIfR_CA;^QL{HFeSTwHq?B3Go;Hx`u{+UO7|=2?<<*WlhyNKpZuE zzTVNxD@Xj_^(B#acD}=Anx&5IgL}_}iytg5J~BLPKv+76gwJs#PnsLGa0=F?j1Ru} zp1P2ufi>C1cxpkO|I+y=J$RgJd1Tk=oBp;erOwE7yaGl5M$OTZU7XB~K;;%PBn{QXCe0Do!PxNujcb7_toWB(X@ z8jPBrnre_)Onu7d`wF}RX zwB_S*q2eOEhVf;A(|**Ag7-f}6asG9BD-CC zY!c(&o9>f`U)tP=2YFTWVNgf>^}09he?<^6rX;XO%T)=R_t%+Op%7>^I#SNJct!v% zeem^ladB}^PY+K}kgKb!2K5n&rhzPWy5a;wB1B~xOWE=}XENIn7L+n#2aC?UUW!*Y zN`|O7S3zk_LEb7hC*%O12FIr&cM2Et&&0S$*xjVACQCJ_i$(FFX0x+)iC4?rXuieLdLbkj)h%rF|nj!QOxr5@U*Yz zB;~XH2h&j$q(+&DOn%8?k{o=ZDfFXjY@B<1;0zJTOHM9IPBuIDLH?ILI*RngC(Op~ z?Usg%=xv~HXHYrgD!0>7t<~?Xb4$NMw+;JPA?FFOsQ%E@;PQHtM@A7gh=YS;lnVb0 zPPEqi7Jlw-L!N*2>ZdL~$5$1lbyPZF;?u@!Y5nV!_EXZtt^l8_b&kR~dMF>7rwqjz zWjyNry>&0}WTw;+4CLgZN=q%>amv&xdVv1ri>&OJGfcqv7#{RUg8^ttkjMjwmB`bR z8w(n0w9$k(S(h(3T22W#kD6sQG!|L@bW6!IGF`1)u~L~H(T2il6vD0js;taP!ftYR z*xu+i+Z!tb?BEIIM?HrKeRikKf%Aoi4g+cL)hMu@14FUo9axz2jg3s^HWlLLh^g(< zBjFM!^nQQ8Q48`*%4xI}KaeLHQqoGOp~uSD(QqayDB~nU&`3-dW)CE!k7-6YCqH4i zuzN^`Wd$f*Ft1a+_ko6m{b_Ncu9lm^xk)54aCL2rijp%n2H1dRWMpIjLI?~ke8Xd6 z6n0jc7~I@&ROfCyJ?nhDZwYvzz}(FU&v=9>kj9z!qvB$TFTO}XFR*saL77FtqVCD(47Da)!0YxqIE_j>3!9C0zOs0{273LV*h<|UH#_TEI>5;l zNnGDJb^pHba;&abv*hD5uK;?*;QTqcyv)1XM*M|Ps!$0{2x!i9-L~wx`HB8Eh%aV; zD1`ARMOSpJ{X^tba_H7+%V6Q_Id9ob1DF5ve4>bJe?5KIvZ9=olDjxTwykAMS5$1Z zfB%EF(7&yl{?tQCe6Kq1y#QuMOj468?v$hKP-s76YUCh+>0yI&K1WqkU=H(mO9TStFrYUxOti%TSY^aIJqYQyfNm1*} zSI6?7<7d5fMC-B|og06M(+RCl>T9A_(b zzKd1|{Wbx(v;b?zG90;0vpQ@&>EHfFVbE5olcCSCLqoKV05GeehJ$mYX^uH1GU1TD zidwJ7&8>Ty9KE8>&f-H`8n7JX{Q_E>qDIIC-eVxH%E{>ph>-_YuZ+x0z`>}^YJsWT z3FddUy=mMyaH3!H;`|Ito23S>i=%6I(mQAMF(zu*PvTK}ckGuU&us!%gDps0nSR%5 zFdc`hbD}OT*Q(N$iP#ITcbhN=Mvo$-BH+~2RA5316n&Hw6o6M)7Po`Y!4n=A2y_;Y zJ)KhFt0kzxRs6jKym^eglE^BQcUEIIly^dXMwIB>3bd;Ngm8bc#`lQ_h`>HIuIc$# zNFyA2uM^}m)#HG~@{s;NPW<4ui?j3S*x0Z!>%1li1db+O9vV$8Xg>ysBE^@1^v*$c zgxoF*MKMl1@=+0l$2>!ZrUw;n9Q}gYtB{W^ghtsoCjhDE^*WQZUre4PdN3*RSqQkrfS1FaP>CQP1|x^j1Dg%L&c)?+3M4o(v;iWqo<9 zw~_`|ga){{f?oe4U;Li65#sjqs;)~*wqDGIFp zdD!wLV$)9t>~&9jyi@4m=xC_t^fIk%Kr1!r28>xj&v?2uXqA8};K0G4e`U1<8z1?X zwIqC0xl}uk&#!>;lbv)f5ff2Z&Xzt?Oxu562c5=?(;P-_cJT1Xul_FfAYUY4n7Way z7*Y$oa|oNmpO9l+Yg-pSGNUqj>#r)+nS^xQO&Z|mlVKJ1zv^%)M^Jb_IAmmYRGufo z-3f1fDN6oMNZ?QG|KIaMA?QJcG*p;B{D8z^VdK*k;b;$hmzEBF|4g?} zifTB6e}Kf}aj`_yD7dix9iR^U-(ORC7-S+0H1#9en7I5^GjVCpvi**m78?YKi_eK* zpJ{!$Bo{IVbR_K=f0$EEfK6*7`@e_l9AA)w5V+Q7ZYKiPltPuTqxsdq0uh?IM$X>Z z`LB%4Z82i_p-<6NUmF4oJ!G2as_N?JW(U2Y0?*-F)8-Deo(^{jOp5j+rv|F!Ez2Y% z5hTK@uH+dP9|@U`NhT<$c;3(j7UFIT1u-p2UnZpbk3NY1{q5aw_<^e)VZ*Vbi*rzb z!Qk{QIQL<@{5hMdzM&2dE_9r&!uCU-VLX<<9|#!2PWm|ZEGI_T_1lG%>shN}e{_Hd z-8)=owBt#$}BZ z$~T}S1^NFCh{u^PF*bIycJ7cZrY9#CM)%NHnXTb*i|B6{x{q4G4EvWRi=keTZSVZn z8y`%>!Nt~+jqfj~0EYR0m0f#Ol4lry%}kGJ*~~Ii&`J|2)VlU&Sb*0LT1^r zR?92Sq$yd>RtYqbH5)FNOex0-bGzbPyoI+ds`EV+$t_-sDH zD{U=l5_%|qoh3{CaNLg5eJKjvC2QLk|I?=zte-lqoVfrj+7pl7j zBZtb@zALxDe@P7u?L6%=+pf5>va+-k;BDlyx#;dzC~ztdK@V&8_E&UFYnSc#)NjNT zj6hf&9UWnYdPr@2Aq|;}686l8+2_NtIsze;3lJHhH&(z@2pu$q1BuY}S->&~!8{Zr zDC(|UZ#RTVO`U#sFn2FjT@1Mcxw)3$OsCj;drPHK?C5;DK{}6BXqKj{R8qSEmTCuv zlbzk88{Yk2S$n65`1~K+GuQkQh{a+F>yDW@;qlj!#+GOXKPQu~#mnbt2AjqCpMBTe z-7SA6krvg&$>C;wLR^s=Gmp-wwf(zl*+cGmq2*P}pc%nUXhohI577{&koo{nL zJmGK?Icq-*aD?@)JMXbK>;NL1N}=2_KbNw;HAfR#$%w6ez?r?GsHjM?54vE36O+0MwoxSAUZq^(h+Y4o7an*M?iGIGmKm?%#Bv4>rAVgp_ z+(-a8BO@m!&dN((=~#u0G1UA!%e0UimqXocTlvL{in+~`h9*V3T^n3sju_QIeYFn*J05Z2Acg}nGYipy>XrA9G>2eJ8ZZw%d1<+edx$sj)Q%lR%ZQG`%reM-k*R5MS#M!to`3#Q} zu*oV8kF{V$7&H>Hz+gB`vxbTLkkCz|J&;HMfa$&z^+xpwpv1Wtj|Nvu*`9+e4j_n{ zol#NSAYo?1hLpGCejy?8L%*K{UItjkgI`ru1yfaeE>QBJ?~@gCQoRR!ofI}~6>Lk;vMv=at?f!1;kIYieAV%uC^~UpJ;88e>j9 z`iZmUi-jwNq&gq~RE_QctP}V(+gH-Z48Beq?1`DM!dHj63-^fY; zpl~>xO=YUkQ7^Sf*1@hC#L`kWiNyS0Ls(cYmkY9Nukc2o?XY2tTV83Y93+5Lbl`4Z-!r*f z^I9>stxx*Pw=_nqf;8?V8jCgclRa6LBx1AKJYE-o zec-YsVWb7;BYZqV!2`<6%YzC>2u3O^m8O$tTUuHq61u*=KAfBKYPOc`tt03MX(-(I zm&lumP(!~?5g^&#{~;;=ahc2$x~^)q+CYcu$Z9@+1o$0L?SWrsus7Z;9z?1F0E-Uk z8xo*d;k5QWpv&Y_qLlaUt5;KeeP@pDMk)-5XH_w<9{5%8r&e6Q{_y5aJ6G2}iNty| z7^#-&KG${GX>M)3JE8{9?*NMxX=8{O1|Z=Wy= lmGcim{#Q-)ub17Q*84VA9s6*!wFp!j^7jk!tsq6D{RtJa((M2M literal 0 HcmV?d00001 diff --git a/previews/PR467/tutorials/intermediate/2_BayesianNN-29.png b/previews/PR467/tutorials/intermediate/2_BayesianNN-29.png new file mode 100644 index 0000000000000000000000000000000000000000..6ba498cb4830f7efca45149655e648ee7f58f563 GIT binary patch literal 54943 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 literal 0 HcmV?d00001 diff --git a/previews/PR467/tutorials/intermediate/2_BayesianNN-8.png b/previews/PR467/tutorials/intermediate/2_BayesianNN-8.png new file mode 100644 index 0000000000000000000000000000000000000000..a485a2cc5702082bbb7496835d7006a77395551b GIT binary patch literal 21242 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 + +# Bayesian Neural Network + + +We borrow this tutorial from the [official Turing Docs](https://turing.ml/dev/tutorials/03-bayesian-neural-network/). We will show how the explicit parameterization of Lux enables first-class composability with packages which expect flattened out parameter vectors. + + +We will use [Turing.jl](https://turing.ml) with [Lux.jl](https://lux.csail.mit.edu/stable) to implement implementing a classification algorithm. Lets start by importing the relevant libraries. + + +```julia +# Import libraries +using Lux, Turing, CairoMakie, Random, ReverseDiff, Functors, MakiePublication + +# Hide sampling progress +Turing.setprogress!(false); + +# Use reverse_diff due to the number of parameters in neural networks +Turing.setadbackend(:reversediff) +``` + + +``` +:reversediff +``` + + + + +## Generating data + + +Our goal here is to use a Bayesian neural network to classify points in an artificial dataset. The code below generates data points arranged in a box-like pattern and displays a graph of the dataset we'll be working with. + + +```julia +# Number of points to generate +N = 80 +M = round(Int, N / 4) +rng = Random.default_rng() +Random.seed!(rng, 1234) + +# Generate artificial data +x1s = rand(rng, Float32, M) * 4.5f0; +x2s = rand(rng, Float32, M) * 4.5f0; +xt1s = Array([[x1s[i] + 0.5f0; x2s[i] + 0.5f0] for i in 1:M]) +x1s = rand(rng, Float32, M) * 4.5f0; +x2s = rand(rng, Float32, M) * 4.5f0; +append!(xt1s, Array([[x1s[i] - 5.0f0; x2s[i] - 5.0f0] for i in 1:M])) + +x1s = rand(rng, Float32, M) * 4.5f0; +x2s = rand(rng, Float32, M) * 4.5f0; +xt0s = Array([[x1s[i] + 0.5f0; x2s[i] - 5.0f0] for i in 1:M]) +x1s = rand(rng, Float32, M) * 4.5f0; +x2s = rand(rng, Float32, M) * 4.5f0; +append!(xt0s, Array([[x1s[i] - 5.0f0; x2s[i] + 0.5f0] for i in 1:M])) + +# Store all the data for later +xs = [xt1s; xt0s] +ts = [ones(2 * M); zeros(2 * M)] + +# Plot data points + +function plot_data() + x1 = first.(xt1s) + y1 = last.(xt1s) + x2 = first.(xt0s) + y2 = last.(xt0s) + + fig = with_theme(theme_web()) do + fig = Figure() + ax = CairoMakie.Axis(fig[1, 1]; xlabel="x", ylabel="y") + + scatter!(ax, x1, y1; markersize=8, color=:red, strokecolor=:black, strokewidth=1) + scatter!(ax, x2, y2; markersize=8, color=:blue, strokecolor=:black, strokewidth=1) + + return fig + end + + return fig +end + +plot_data() +``` + + +![](2_BayesianNN-8.png) + + + + +## Building the Neural Network + + +The next step is to define a feedforward neural network where we express our parameters as distributions, and not single points as with traditional neural networks. For this we will use `Dense` to define liner layers and compose them via `Chain`, both are neural network primitives from `Lux`. The network `nn` we will create will have two hidden layers with `tanh` activations and one output layer with `sigmoid` activation, as shown below. + + +The `nn` is an instance that acts as a function and can take data, parameters and current state as inputs and output predictions. We will define distributions on the neural network parameters. + + +```julia +# Construct a neural network using Lux +nn = Chain(Dense(2 => 3, tanh), Dense(3 => 2, tanh), Dense(2 => 1, sigmoid)) + +# Initialize the model weights and state +ps, st = Lux.setup(rng, nn) + +Lux.parameterlength(nn) # number of paraemters in NN +``` + + +``` +20 +``` + + +The probabilistic model specification below creates a parameters variable, which has IID normal variables. The parameters represents all parameters of our neural net (weights and biases). + + +```julia +# Create a regularization term and a Gaussian prior variance term. +alpha = 0.09 +sig = sqrt(1.0 / alpha) +``` + + +``` +3.3333333333333335 +``` + + +Construct named tuple from a sampled parameter vector. We could also use ComponentArrays here and simply broadcast to avoid doing this. But let's do it this way to avoid dependencies. + + +```julia +function vector_to_parameters(ps_new::AbstractVector, ps::NamedTuple) + @assert length(ps_new) == Lux.parameterlength(ps) + i = 1 + function get_ps(x) + z = reshape(view(ps_new, i:(i + length(x) - 1)), size(x)) + i += length(x) + return z + end + return fmap(get_ps, ps) +end + +# Specify the probabilistic model. +@model function bayes_nn(xs, ts) + global st + + # Sample the parameters + nparameters = Lux.parameterlength(nn) + parameters ~ MvNormal(zeros(nparameters), sig .* ones(nparameters)) + + # Forward NN to make predictions + preds, st = nn(xs, vector_to_parameters(parameters, ps), st) + + # Observe each prediction. + for i in 1:length(ts) + ts[i] ~ Bernoulli(preds[i]) + end +end +``` + + +``` +bayes_nn (generic function with 2 methods) +``` + + +Inference can now be performed by calling sample. We use the HMC sampler here. + + +```julia +# Perform inference. +N = 5000 +ch = sample(bayes_nn(reduce(hcat, xs), ts), HMC(0.05, 4), N) +``` + + +``` +Chains MCMC chain (5000×30×1 Array{Float64, 3}): + +Iterations = 1:1:5000 +Number of chains = 1 +Samples per chain = 5000 +Wall duration = 61.34 seconds +Compute duration = 61.34 seconds +parameters = parameters[1], parameters[2], parameters[3], parameters[4], parameters[5], parameters[6], parameters[7], parameters[8], parameters[9], parameters[10], parameters[11], parameters[12], parameters[13], parameters[14], parameters[15], parameters[16], parameters[17], parameters[18], parameters[19], parameters[20] +internals = lp, n_steps, is_accept, acceptance_rate, log_density, hamiltonian_energy, hamiltonian_energy_error, numerical_error, step_size, nom_step_size + +Summary Statistics + parameters mean std mcse ess_bulk ess_tail rhat ess_per_sec + Symbol Float64 Float64 Float64 Float64 Float64 Float64 Float64 + + parameters[1] -2.0521 0.7625 0.1721 20.6080 90.3161 1.0078 0.3360 + parameters[2] -3.0083 3.1557 0.9621 12.7726 21.0999 1.5426 0.2082 + parameters[3] 1.3245 0.8417 0.2430 13.3461 24.3246 1.4587 0.2176 + parameters[4] -1.4877 1.0772 0.2493 15.1287 26.2870 1.1494 0.2466 + parameters[5] 0.7760 0.5463 0.1115 27.1685 102.1179 1.2247 0.4429 + parameters[6] 3.4906 1.7171 0.4559 14.8031 45.0051 1.0628 0.2413 + parameters[7] -3.9710 1.4956 0.3945 15.0640 45.7012 1.1078 0.2456 + parameters[8] -3.4420 1.3931 0.3730 14.6316 21.0172 1.4495 0.2385 + parameters[9] -4.5405 3.0887 0.9352 12.0159 20.0739 1.6221 0.1959 + parameters[10] -3.2319 2.7507 0.8110 12.1252 22.4200 1.3478 0.1977 + parameters[11] -3.5758 1.4822 0.4076 13.6637 33.8975 1.1729 0.2228 + parameters[12] -1.0570 2.4954 0.7492 11.7223 21.0856 1.9121 0.1911 + parameters[13] 2.9443 1.5863 0.4630 12.8882 20.7551 1.4709 0.2101 + parameters[14] 1.7753 3.9004 1.1683 11.7170 20.8646 1.4595 0.1910 + parameters[15] -2.5492 0.9557 0.2088 22.5673 38.5675 1.1274 0.3679 + parameters[16] 1.3716 2.0800 0.5691 14.0441 34.5833 1.1682 0.2290 + parameters[17] -0.4643 1.9644 0.5871 11.5634 21.2536 1.8976 0.1885 + parameters[18] 1.1676 1.4714 0.3611 16.5438 23.5525 1.0044 0.2697 + parameters[19] -5.9863 0.9522 0.1526 38.9319 54.0819 1.0467 0.6347 + parameters[20] -1.7391 1.2860 0.2821 21.6130 50.2786 1.0414 0.3524 + +Quantiles + parameters 2.5% 25.0% 50.0% 75.0% 97.5% + Symbol Float64 Float64 Float64 Float64 Float64 + + parameters[1] -3.3949 -2.6340 -2.0720 -1.4720 -0.6806 + parameters[2] -10.8256 -4.7942 -1.1807 -0.8554 -0.4700 + parameters[3] 0.2152 0.6476 1.1033 1.9170 3.1882 + parameters[4] -5.7669 -1.7303 -1.3366 -0.9107 -0.3575 + parameters[5] -0.4868 0.5344 0.8637 1.1188 1.7370 + parameters[6] 0.6259 2.2367 3.5342 4.5333 6.7872 + parameters[7] -6.6437 -5.1932 -3.9708 -2.7398 -1.3800 + parameters[8] -5.8277 -4.4686 -3.5359 -2.5644 -0.2680 + parameters[9] -11.4662 -7.0356 -3.2984 -2.0051 -0.8413 + parameters[10] -8.1245 -4.8659 -3.5562 -1.3859 2.0080 + parameters[11] -6.4989 -4.7170 -3.5606 -2.3902 -1.0114 + parameters[12] -4.6375 -3.1774 -1.3213 0.7895 4.0594 + parameters[13] 0.8759 1.7717 2.6272 3.5623 6.9655 + parameters[14] -5.8894 -2.1307 3.2297 4.9656 7.0390 + parameters[15] -4.6926 -3.0672 -2.5009 -1.9073 -0.9006 + parameters[16] -2.5810 -0.0622 0.9090 2.9472 5.4754 + parameters[17] -3.6208 -2.0939 -0.6436 1.0709 3.5339 + parameters[18] -2.1827 0.1799 1.2132 2.2497 3.7561 + parameters[19] -7.7264 -6.5933 -6.0417 -5.4946 -3.7762 + parameters[20] -4.6060 -2.5530 -1.6430 -0.8152 0.5254 + +``` + + +Now we extract the parameter samples from the sampled chain as θ (this is of size `5000 x 20` where `5000` is the number of iterations and `20` is the number of parameters). We'll use these primarily to determine how good our model's classifier is. + + +```julia +# Extract all weight and bias parameters. +θ = MCMCChains.group(ch, :parameters).value; +``` + + + + +## Prediction Visualization + + +```julia +# A helper to run the nn through data `x` using parameters `θ` +nn_forward(x, θ) = first(nn(x, vector_to_parameters(θ, ps), st)) + +# Plot the data we have. +fig = plot_data() + +# Find the index that provided the highest log posterior in the chain. +_, i = findmax(ch[:lp]) + +# Extract the max row value from i. +i = i.I[1] + +# Plot the posterior distribution with a contour plot +x1_range = collect(range(-6; stop=6, length=25)) +x2_range = collect(range(-6; stop=6, length=25)) +Z = [nn_forward([x1, x2], θ[i, :])[1] for x1 in x1_range, x2 in x2_range] +contour!(x1_range, x2_range, Z) +fig +``` + + +![](2_BayesianNN-22.png) + + +The contour plot above shows that the MAP method is not too bad at classifying our data. Now we can visualize our predictions. + + +$$ +p(\tilde{x} | X, \alpha) = \int_{\theta} p(\tilde{x} | \theta) p(\theta | X, \alpha) \approx \sum_{\theta \sim p(\theta | X, \alpha)}f_{\theta}(\tilde{x}) +$$ + + +The `nn_predict` function takes the average predicted value from a network parameterized by weights drawn from the MCMC chain. + + +```julia +# Return the average predicted value across multiple weights. +nn_predict(x, θ, num) = mean([first(nn_forward(x, view(θ, i, :))) for i in 1:10:num]) +``` + + +``` +nn_predict (generic function with 1 method) +``` + + +Next, we use the `nn_predict` function to predict the value at a sample of points where the x1 and x2 coordinates range between -6 and 6. As we can see below, we still have a satisfactory fit to our data, and more importantly, we can also see where the neural network is uncertain about its predictions much easier–-those regions between cluster boundaries. + + +Plot the average prediction. + + +```julia +fig = plot_data() + +n_end = 1500 +x1_range = collect(range(-6; stop=6, length=25)) +x2_range = collect(range(-6; stop=6, length=25)) +Z = [nn_predict([x1, x2], θ, n_end)[1] for x1 in x1_range, x2 in x2_range] +contour!(x1_range, x2_range, Z) +fig +``` + + +![](2_BayesianNN-29.png) + + +Suppose we are interested in how the predictive power of our Bayesian neural network evolved between samples. In that case, the following graph displays an animation of the contour plot generated from the network weights in samples 1 to 5,000. + + +```julia +fig = plot_data() +Z = [first(nn_forward([x1, x2], θ[1, :])) for x1 in x1_range, x2 in x2_range] +c = contour!(x1_range, x2_range, Z) +record(fig, "results.gif", 1:250:size(θ, 1)) do i + fig.current_axis[].title = "Iteration: $i" + Z = [first(nn_forward([x1, x2], θ[i, :])) for x1 in x1_range, x2 in x2_range] + c[3] = Z + return fig +end +``` + + +``` +"results.gif" +``` + + +![](results.gif) + + +--- + + +*This page was generated using [Literate.jl](https://github.com/fredrikekre/Literate.jl).* + diff --git a/previews/PR467/tutorials/intermediate/3_HyperNet.md b/previews/PR467/tutorials/intermediate/3_HyperNet.md new file mode 100644 index 0000000000..d36486f9e3 --- /dev/null +++ b/previews/PR467/tutorials/intermediate/3_HyperNet.md @@ -0,0 +1,250 @@ + + + + + +# Training a HyperNetwork on MNIST and FashionMNIST + + + + +## Package Imports + + +```julia +using Lux, ComponentArrays, LuxAMDGPU, LuxCUDA, MLDatasets, MLUtils, OneHotArrays, + Optimisers, Random, Setfield, Statistics, Zygote +CUDA.allowscalar(false) +``` + + + + +## Loading Datasets + + +```julia +function _load_dataset(dset, n_train::Int, n_eval::Int, batchsize::Int) + imgs, labels = dset(:train)[1:n_train] + x_train, y_train = reshape(imgs, 28, 28, 1, n_train), onehotbatch(labels, 0:9) + + imgs, labels = dset(:test)[1:n_eval] + x_test, y_test = reshape(imgs, 28, 28, 1, n_eval), onehotbatch(labels, 0:9) + + return (DataLoader((x_train, y_train); batchsize=min(batchsize, n_train), shuffle=true), + DataLoader((x_test, y_test); batchsize=min(batchsize, n_eval), shuffle=false)) +end + +function load_datasets(n_train=1024, n_eval=32, batchsize=256) + return _load_dataset.((MNIST, FashionMNIST), n_train, n_eval, batchsize) +end +``` + + +``` +load_datasets (generic function with 4 methods) +``` + + + + +## Implement a HyperNet Layer + + +```julia +struct HyperNet{W <: Lux.AbstractExplicitLayer, C <: Lux.AbstractExplicitLayer, A} <: + Lux.AbstractExplicitContainerLayer{(:weight_generator, :core_network)} + weight_generator::W + core_network::C + ca_axes::A +end + +function HyperNet(w::Lux.AbstractExplicitLayer, c::Lux.AbstractExplicitLayer) + ca_axes = Lux.initialparameters(Random.default_rng(), c) |> ComponentArray |> getaxes + return HyperNet(w, c, ca_axes) +end + +function Lux.initialparameters(rng::AbstractRNG, h::HyperNet) + return (weight_generator=Lux.initialparameters(rng, h.weight_generator),) +end + +function (hn::HyperNet)(x, ps, st::NamedTuple) + ps_new, st_ = hn.weight_generator(x, ps.weight_generator, st.weight_generator) + @set! st.weight_generator = st_ + return ComponentArray(vec(ps_new), hn.ca_axes), st +end + +function (hn::HyperNet)((x, y)::T, ps, st::NamedTuple) where {T <: Tuple} + ps_ca, st = hn(x, ps, st) + pred, st_ = hn.core_network(y, ps_ca, st.core_network) + @set! st.core_network = st_ + return pred, st +end +``` + + + + +## Create and Initialize the HyperNet + + +```julia +function create_model() + # Doesn't need to be a MLP can have any Lux Layer + core_network = Chain(FlattenLayer(), Dense(784, 256, relu), Dense(256, 10)) + weight_generator = Chain(Embedding(2 => 32), + Dense(32, 64, relu), + Dense(64, Lux.parameterlength(core_network))) + + model = HyperNet(weight_generator, core_network) + + rng = Random.default_rng() + Random.seed!(rng, 0) + + ps, st = Lux.setup(rng, model) .|> gpu_device() + + return model, ps, st +end +``` + + +``` +create_model (generic function with 1 method) +``` + + + + +## Define Utility Functions + + +```julia +logitcrossentropy(y_pred, y) = mean(-sum(y .* logsoftmax(y_pred); dims=1)) + +function loss(data_idx, x, y, model, ps, st) + y_pred, st = model((data_idx, x), ps, st) + return logitcrossentropy(y_pred, y), st +end + +function accuracy(model, ps, st, dataloader, data_idx) + total_correct, total = 0, 0 + st = Lux.testmode(st) + dev = gpu_device() + cpu_dev = cpu_device() + for (x, y) in dataloader + x = x |> dev + y = y |> dev + target_class = onecold(cpu_dev(y)) + predicted_class = onecold(cpu_dev(model((data_idx, x), ps, st)[1])) + total_correct += sum(target_class .== predicted_class) + total += length(target_class) + end + return total_correct / total +end +``` + + +``` +accuracy (generic function with 1 method) +``` + + + + +## Training + + +```julia +function train() + model, ps, st = create_model() + + # Training + dataloaders = load_datasets() + + opt = Adam(0.001f0) + st_opt = Optimisers.setup(opt, ps) + + dev = gpu_device() + + ### Warmup the Model + img, lab = dev(dataloaders[1][1].data[1][:, :, :, 1:1]), + dev(dataloaders[1][1].data[2][:, 1:1]) + loss(1, img, lab, model, ps, st) + (l, _), back = pullback(p -> loss(1, img, lab, model, p, st), ps) + back((one(l), nothing)) + + ### Lets train the model + nepochs = 9 + for epoch in 1:nepochs + for data_idx in 1:2 + train_dataloader, test_dataloader = dataloaders[data_idx] + + stime = time() + for (x, y) in train_dataloader + x = x |> dev + y = y |> dev + (l, st), back = pullback(p -> loss(data_idx, x, y, model, p, st), ps) + gs = back((one(l), nothing))[1] + st_opt, ps = Optimisers.update(st_opt, ps, gs) + end + ttime = time() - stime + + train_acc = round(accuracy(model, ps, st, train_dataloader, data_idx) * 100; + digits=2) + test_acc = round(accuracy(model, ps, st, test_dataloader, data_idx) * 100; + digits=2) + + data_name = data_idx == 1 ? "MNIST" : "FashionMNIST" + + println("[$epoch/$nepochs] \t $data_name Time $(round(ttime; digits=2))s \t " * + "Training Accuracy: $(train_acc)% \t Test Accuracy: $(test_acc)%") + end + end + + for data_idx in 1:2 + train_dataloader, test_dataloader = dataloaders[data_idx] + train_acc = round(accuracy(model, ps, st, train_dataloader, data_idx) * 100; + digits=2) + test_acc = round(accuracy(model, ps, st, test_dataloader, data_idx) * 100; digits=2) + + data_name = data_idx == 1 ? "MNIST" : "FashionMNIST" + + println("[FINAL] \t $data_name Training Accuracy: $(train_acc)% \t " * + "Test Accuracy: $(test_acc)%") + end +end + +train() +``` + + +``` +[1/9] MNIST Time 3.73s Training Accuracy: 48.14% Test Accuracy: 43.75% +[1/9] FashionMNIST Time 0.04s Training Accuracy: 50.0% Test Accuracy: 43.75% +[2/9] MNIST Time 0.08s Training Accuracy: 70.9% Test Accuracy: 62.5% +[2/9] FashionMNIST Time 0.04s Training Accuracy: 54.59% Test Accuracy: 50.0% +[3/9] MNIST Time 0.03s Training Accuracy: 81.45% Test Accuracy: 68.75% +[3/9] FashionMNIST Time 0.03s Training Accuracy: 55.86% Test Accuracy: 71.88% +[4/9] MNIST Time 0.03s Training Accuracy: 89.36% Test Accuracy: 87.5% +[4/9] FashionMNIST Time 0.07s Training Accuracy: 58.5% Test Accuracy: 50.0% +[5/9] MNIST Time 0.03s Training Accuracy: 91.5% Test Accuracy: 81.25% +[5/9] FashionMNIST Time 0.03s Training Accuracy: 72.95% Test Accuracy: 62.5% +[6/9] MNIST Time 0.03s Training Accuracy: 92.19% Test Accuracy: 93.75% +[6/9] FashionMNIST Time 0.03s Training Accuracy: 70.21% Test Accuracy: 71.88% +[7/9] MNIST Time 0.05s Training Accuracy: 95.31% Test Accuracy: 90.62% +[7/9] FashionMNIST Time 0.03s Training Accuracy: 72.46% Test Accuracy: 62.5% +[8/9] MNIST Time 0.03s Training Accuracy: 96.58% Test Accuracy: 90.62% +[8/9] FashionMNIST Time 0.03s Training Accuracy: 77.05% Test Accuracy: 68.75% +[9/9] MNIST Time 0.03s Training Accuracy: 97.27% Test Accuracy: 90.62% +[9/9] FashionMNIST Time 0.04s Training Accuracy: 78.32% Test Accuracy: 68.75% +[FINAL] MNIST Training Accuracy: 96.0% Test Accuracy: 96.88% +[FINAL] FashionMNIST Training Accuracy: 78.32% Test Accuracy: 68.75% + +``` + + +--- + + +*This page was generated using [Literate.jl](https://github.com/fredrikekre/Literate.jl).* + diff --git a/previews/PR467/tutorials/intermediate/results.gif b/previews/PR467/tutorials/intermediate/results.gif new file mode 100644 index 0000000000000000000000000000000000000000..7dcbc9bf9684cdc6c12f158bc5c9ad6b81e73eb9 GIT binary patch literal 284766 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�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

S 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 literal 0 HcmV?d00001 diff --git a/previews/PR467/tutorials/advanced/1_GravitationalWaveForm.md b/previews/PR467/tutorials/advanced/1_GravitationalWaveForm.md new file mode 100644 index 0000000000..62b9774205 --- /dev/null +++ b/previews/PR467/tutorials/advanced/1_GravitationalWaveForm.md @@ -0,0 +1,547 @@ + + + + + +# Training a Neural ODE to Model Gravitational Waveforms + + +This code is adapted from [Astroinformatics/ScientificMachineLearning](https://github.com/Astroinformatics/ScientificMachineLearning/blob/c93aac3a460d70b4cce98836b677fd9b732e94b7/neuralode_gw.ipynb) + + +The code has been minimally adapted from [Keith et. al. 2021](https://arxiv.org/abs/2102.12695) which originally used Flux.jl + + + + +## Package Imports + + +```julia +using Lux, ComponentArrays, LineSearches, LuxAMDGPU, LuxCUDA, OrdinaryDiffEq, + Optimization, OptimizationOptimJL, Random, SciMLSensitivity +using CairoMakie, MakiePublication +CUDA.allowscalar(false) +``` + + + + +## Define some Utility Functions + + +::: tip + + +This section can be skipped. It defines functions to simulate the model, however, from a scientific machine learning perspective, isn't super relevant. + + +::: + + +We need a very crude 2-body path. Assume the 1-body motion is a newtonian 2-body position vector $r = r_1 - r_2$ and use Newtonian formulas to get $r_1$, $r_2$ (e.g. Theoretical Mechanics of Particles and Continua 4.3) + + +```julia +function one2two(path, m₁, m₂) + M = m₁ + m₂ + r₁ = m₂ / M .* path + r₂ = -m₁ / M .* path + return r₁, r₂ +end +``` + + +``` +one2two (generic function with 1 method) +``` + + +Next we define a function to perform the change of variables: $(\chi(t),\phi(t)) \mapsto (x(t),y(t))$ + + +```julia +@views function soln2orbit(soln, model_params=nothing) + @assert size(soln, 1) ∈ [2, 4] "size(soln,1) must be either 2 or 4" + + if size(soln, 1) == 2 + χ = soln[1, :] + ϕ = soln[2, :] + + @assert length(model_params)==3 "model_params must have length 3 when size(soln,2) = 2" + p, M, e = model_params + else + χ = soln[1, :] + ϕ = soln[2, :] + p = soln[3, :] + e = soln[4, :] + end + + r = p ./ (1 .+ e .* cos.(χ)) + x = r .* cos.(ϕ) + y = r .* sin.(ϕ) + + orbit = vcat(x', y') + return orbit +end +``` + + +``` +soln2orbit (generic function with 2 methods) +``` + + +This function uses second-order one-sided difference stencils at the endpoints; see https://doi.org/10.1090/S0025-5718-1988-0935077-0 + + +```julia +function d_dt(v::AbstractVector, dt) + a = -3 / 2 * v[1] + 2 * v[2] - 1 / 2 * v[3] + b = (v[3:end] .- v[1:(end - 2)]) / 2 + c = 3 / 2 * v[end] - 2 * v[end - 1] + 1 / 2 * v[end - 2] + return [a; b; c] / dt +end +``` + + +``` +d_dt (generic function with 1 method) +``` + + +This function uses second-order one-sided difference stencils at the endpoints; see https://doi.org/10.1090/S0025-5718-1988-0935077-0 + + +```julia +function d2_dt2(v::AbstractVector, dt) + a = 2 * v[1] - 5 * v[2] + 4 * v[3] - v[4] + b = v[1:(end - 2)] .- 2 * v[2:(end - 1)] .+ v[3:end] + c = 2 * v[end] - 5 * v[end - 1] + 4 * v[end - 2] - v[end - 3] + return [a; b; c] / (dt^2) +end +``` + + +``` +d2_dt2 (generic function with 1 method) +``` + + +Now we define a function to compute the trace-free moment tensor from the orbit + + +```julia +function orbit2tensor(orbit, component, mass=1) + x = orbit[1, :] + y = orbit[2, :] + + Ixx = x .^ 2 + Iyy = y .^ 2 + Ixy = x .* y + trace = Ixx .+ Iyy + + if component[1] == 1 && component[2] == 1 + tmp = Ixx .- trace ./ 3 + elseif component[1] == 2 && component[2] == 2 + tmp = Iyy .- trace ./ 3 + else + tmp = Ixy + end + + return mass .* tmp +end + +function h_22_quadrupole_components(dt, orbit, component, mass=1) + mtensor = orbit2tensor(orbit, component, mass) + mtensor_ddot = d2_dt2(mtensor, dt) + return 2 * mtensor_ddot +end + +function h_22_quadrupole(dt, orbit, mass=1) + h11 = h_22_quadrupole_components(dt, orbit, (1, 1), mass) + h22 = h_22_quadrupole_components(dt, orbit, (2, 2), mass) + h12 = h_22_quadrupole_components(dt, orbit, (1, 2), mass) + return h11, h12, h22 +end + +function h_22_strain_one_body(dt::T, orbit) where {T} + h11, h12, h22 = h_22_quadrupole(dt, orbit) + + h₊ = h11 - h22 + hₓ = T(2) * h12 + + scaling_const = √(T(π) / 5) + return scaling_const * h₊, -scaling_const * hₓ +end + +function h_22_quadrupole_two_body(dt, orbit1, mass1, orbit2, mass2) + h11_1, h12_1, h22_1 = h_22_quadrupole(dt, orbit1, mass1) + h11_2, h12_2, h22_2 = h_22_quadrupole(dt, orbit2, mass2) + h11 = h11_1 + h11_2 + h12 = h12_1 + h12_2 + h22 = h22_1 + h22_2 + return h11, h12, h22 +end + +function h_22_strain_two_body(dt::T, orbit1, mass1, orbit2, mass2) where {T} + # compute (2,2) mode strain from orbits of BH 1 of mass1 and BH2 of mass 2 + + @assert abs(mass1 + mass2 - 1.0)<1e-12 "Masses do not sum to unity" + + h11, h12, h22 = h_22_quadrupole_two_body(dt, orbit1, mass1, orbit2, mass2) + + h₊ = h11 - h22 + hₓ = T(2) * h12 + + scaling_const = √(T(π) / 5) + return scaling_const * h₊, -scaling_const * hₓ +end + +function compute_waveform(dt::T, soln, mass_ratio, model_params=nothing) where {T} + @assert mass_ratio≤1 "mass_ratio must be <= 1" + @assert mass_ratio≥0 "mass_ratio must be non-negative" + + orbit = soln2orbit(soln, model_params) + if mass_ratio > 0 + m₂ = inv(T(1) + mass_ratio) + m₁ = mass_ratio * m₂ + + orbit₁, orbit₂ = one2two(orbit, m₁, m₂) + waveform = h_22_strain_two_body(dt, orbit1, mass1, orbit2, mass2) + else + waveform = h_22_strain_one_body(dt, orbit) + end + return waveform +end +``` + + +``` +compute_waveform (generic function with 2 methods) +``` + + + + +## Simulating the True Model + + +`RelativisticOrbitModel` defines system of odes which describes motion of point like particle in schwarzschild background, uses + + +$$ +u[1] = \chi +$$ + + +$$ +u[2] = \phi +$$ + + +where, $p$, $M$, and $e$ are constants + + +```julia +function RelativisticOrbitModel(u, (p, M, e), t) + χ, ϕ = u + + numer = (p - 2 - 2 * e * cos(χ)) * (1 + e * cos(χ))^2 + denom = sqrt((p - 2)^2 - 4 * e^2) + + χ̇ = numer * sqrt(p - 6 - 2 * e * cos(χ)) / (M * (p^2) * denom) + ϕ̇ = numer / (M * (p^(3 / 2)) * denom) + + return [χ̇, ϕ̇] +end + +mass_ratio = 0.0 # test particle +u0 = Float64[π, 0.0] # initial conditions +datasize = 250 +tspan = (0.0f0, 6.0f4) # timespace for GW waveform +tsteps = range(tspan[1], tspan[2]; length=datasize) # time at each timestep +dt_data = tsteps[2] - tsteps[1] +dt = 100.0 +const ode_model_params = [100.0, 1.0, 0.5]; # p, M, e +``` + + +Let's simulate the true model and plot the results using `OrdinaryDiffEq.jl` + + +```julia +prob = ODEProblem(RelativisticOrbitModel, u0, tspan, ode_model_params) +soln = Array(solve(prob, RK4(); saveat=tsteps, dt, adaptive=false)) +waveform = first(compute_waveform(dt_data, soln, mass_ratio, ode_model_params)) + +fig = with_theme(theme_web()) do + fig = Figure() + ax = CairoMakie.Axis(fig[1, 1]; xlabel="Time", ylabel="Waveform") + + l = lines!(ax, tsteps, waveform; linewidth=2, alpha=0.75) + s = scatter!(ax, tsteps, waveform; markershape=:circle, markeralpha=0.25, alpha=0.5) + + axislegend(ax, [[l, s]], ["Waveform Data"]) + + return fig +end +``` + + +![](1_GravitationalWaveForm-24.png) + + + + +## Defiing a Neural Network Model + + +Next, we define the neural network model that takes 1 input (time) and has two outputs. We'll make a function `ODE_model` that takes the initial conditions, neural network parameters and a time as inputs and returns the derivatives. + + +It is typically never recommended to use globals but incase you do use them, make sure to mark them as `const`. + + +We will deviate from the standard Neural Network initialization and use `WeightInitializers.jl`, + + +```julia +const nn = Chain(Base.Fix1(broadcast, cos), + Dense(1 => 32, cos; init_weight=truncated_normal(; std=1e-4)), + Dense(32 => 32, cos; init_weight=truncated_normal(; std=1e-4)), + Dense(32 => 2; init_weight=truncated_normal(; std=1e-4))) +ps, st = Lux.setup(MersenneTwister(), nn) +``` + + +``` +((layer_1 = NamedTuple(), layer_2 = (weight = Float32[5.635502f-5; 4.0171617f-5; 2.1480564f-5; 6.888898f-7; -1.2643259f-5; -0.00022938297; 0.00014955924; 2.0773472f-5; -1.6969487f-5; -0.00012078954; 0.00010557361; -7.6435994f-5; 5.351154f-5; -3.318486f-5; 1.3116906f-5; 2.2391245f-5; 0.000121185454; -4.319386f-5; -3.4525332f-5; 3.8561942f-5; 5.9622143f-5; -3.7966474f-5; 1.2598501f-5; 5.7723948f-5; -0.00010184914; -7.433061f-5; 0.00012786902; -8.049825f-5; -0.00012392172; -2.837854f-5; 5.885079f-5; -1.1600321f-5;;], bias = Float32[0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0;;]), layer_3 = (weight = Float32[2.7190586f-6 -1.3763527f-5 -7.314501f-5 -5.3091826f-5 1.5296626f-5 2.7777802f-5 -1.306534f-5 2.8641198f-5 0.000115917035 -0.00014745329 6.1839106f-5 1.7537284f-5 1.5366286f-5 -7.824159f-5 -8.921899f-6 -6.5771026f-5 -2.431146f-6 -2.10072f-5 -0.00010635138 -2.9730154f-5 -0.00010291568 0.000237551 4.6607485f-5 -0.00016343244 8.603541f-7 0.000118550844 5.854826f-6 9.538283f-6 -0.000116330935 -0.0001535512 0.00014066865 7.370844f-5; -0.00014683523 0.00011144161 3.7047696f-5 -6.0655246f-5 4.2522337f-5 -5.5084678f-5 3.0840936f-6 6.5386084f-5 0.00019472155 6.555565f-5 -9.014391f-5 4.287828f-5 -4.87812f-6 -7.840199f-5 3.740734f-5 6.475603f-5 -7.5973265f-5 4.2239967f-6 1.8523557f-5 -4.6490466f-5 -8.761148f-5 8.237294f-5 -1.6116099f-5 -5.1957177f-5 -6.03383f-5 -4.737442f-5 0.00026095423 -8.737501f-6 -0.00012013562 -1.3160007f-5 9.894281f-5 2.476497f-5; 0.00013307903 -6.947044f-5 7.8798475f-6 -7.655558f-5 3.392771f-5 1.701137f-6 -3.973889f-6 0.00032406513 -7.483503f-5 -0.00018742781 0.00012094456 -5.431447f-5 4.2091433f-5 -5.8868733f-5 3.5829213f-5 -1.2990392f-5 0.00016339861 0.00013918837 -4.3501364f-5 6.668708f-5 -0.00011951071 -3.8869515f-5 2.4747993f-5 6.698902f-5 -1.6457661f-5 -7.1882546f-6 -9.141684f-5 0.00027522494 2.5253821f-5 -2.871228f-5 -4.1327523f-5 -4.946071f-5; -9.834853f-5 -2.3414796f-5 -0.00021584533 8.5832595f-5 -3.5089102f-5 3.931146f-5 -2.2765853f-5 -0.00010890992 -0.00023468229 -0.00014448358 -7.400856f-5 0.00026580686 6.895787f-5 0.00010961942 -0.00013251152 1.9509533f-5 8.896801f-5 -0.00013134613 0.00014241059 -0.00012616669 -3.2281635f-6 0.00012028363 -3.5586876f-5 0.00017776412 -1.4574934f-5 2.0386773f-5 -6.3982494f-5 0.00012377536 -8.684805f-5 -8.560809f-7 0.00020622008 0.00016215604; -5.0804425f-5 1.7603166f-5 -8.6611486f-5 -7.3370145f-5 8.551076f-5 -0.00025757554 -5.2533105f-5 2.403409f-5 4.0954546f-5 5.1748364f-5 5.580645f-5 0.00014649282 0.00015291102 -2.5457697f-5 0.00014471104 -0.00011556096 9.512173f-5 0.00011694306 -7.768403f-5 2.2847033f-5 -0.00011562443 0.0001277744 5.6976103f-5 9.457695f-5 -6.25588f-5 -7.304494f-5 5.165263f-5 7.456447f-5 -4.975089f-5 -8.014233f-5 0.00012106548 0.00019247073; 0.00017953034 0.00021149487 -4.188639f-5 -2.7837466f-5 -5.1753148f-5 -1.13966225f-5 8.234786f-5 -6.655811f-5 -5.5829005f-5 0.00017181008 0.000119170305 -7.359459f-5 -4.2085344f-6 -4.224559f-5 0.00018064215 1.0210327f-5 8.797343f-5 -7.389826f-5 -2.9729687f-5 0.00015903091 2.0468298f-5 -0.00016050575 0.00016982271 4.945115f-5 7.1651935f-5 0.00010947186 -5.0374452f-5 9.836249f-5 7.159872f-5 9.2084796f-5 -5.7709407f-5 0.0001536741; 5.6799716f-5 -4.05666f-5 -0.0001316371 -1.3990832f-5 7.727372f-5 -4.6031037f-5 0.000132854 -4.2118143f-5 0.00013113594 8.51302f-5 -6.618347f-5 4.607778f-5 -4.8634265f-5 1.7748733f-5 9.9184756f-5 0.000121707584 6.835345f-5 0.0001359352 -0.00021700372 7.3928066f-5 7.241228f-5 7.9098674f-5 0.0001324151 7.5843054f-6 3.697982f-5 7.262571f-5 0.00017065568 -4.314335f-5 0.00020268139 -5.7425652f-5 4.1203362f-5 3.2639426f-5; -5.4698994f-5 1.2401724f-5 -8.9193156f-5 -2.8532181f-6 9.042418f-6 8.283154f-5 4.8609545f-5 -7.517092f-5 4.424046f-5 1.03528355f-5 0.000100464014 0.00012721267 -0.0001220878 6.630836f-5 7.069001f-5 -4.5382134f-5 4.012951f-5 5.6754532f-5 -7.074434f-5 -6.0485592f-5 5.3060932f-5 3.253815f-6 9.571223f-5 0.00023285365 -9.2094204f-5 9.886567f-5 -1.597629f-5 -2.8452964f-6 -7.7236786f-5 -0.00010246595 8.412728f-5 -0.00010336577; -1.4930167f-6 3.786655f-5 2.0300256f-5 2.3760074f-5 -0.00012740404 0.00014637008 5.349861f-5 0.00013343088 -2.304003f-5 0.00015473031 -5.845802f-5 0.000101792735 -7.742412f-5 -0.00014608815 -0.00016346278 4.7591857f-5 -5.8451f-5 -3.8587725f-5 6.73186f-5 0.00014078504 -2.7156362f-5 8.0022546f-5 3.4092154f-5 -4.657721f-5 3.619689f-5 5.650471f-5 5.067915f-5 -2.5619342f-5 -4.4313794f-5 -0.00013135272 4.334251f-5 1.9583911f-5; 0.00021302074 0.00014018606 -3.6351412f-5 7.457662f-5 -4.195017f-5 -7.782448f-5 -4.546386f-5 -7.19947f-5 2.2504351f-5 0.0001990627 0.00016777401 -3.9674793f-5 6.9190787f-7 4.5942875f-6 -8.50255f-5 -6.228195f-5 5.0525945f-5 2.7371405f-5 -0.00020181008 5.3808035f-5 3.8483513f-6 0.0001273425 -7.0796734f-5 0.00011234 5.052951f-5 -4.2769025f-5 4.6522422f-7 0.00021697635 -0.00013943654 -0.00013885397 6.649341f-6 7.3771305f-5; 0.00015949934 6.374916f-5 -4.9936325f-6 3.4587723f-5 -0.00012995322 0.00014051955 0.00030220096 0.00011187897 4.3839806f-5 6.633033f-5 5.3422118f-5 1.9555493f-5 2.0278874f-5 0.0002561147 -3.556383f-5 0.00019262296 -0.00018797736 8.4749554f-5 -1.1352112f-5 -0.0001714288 1.316911f-5 -0.00010218143 -0.0001232853 -0.00012704325 -6.3103114f-5 -0.00010207985 -4.254906f-5 -2.4989558f-5 -5.046627f-5 1.3588075f-5 9.7987664f-5 8.179853f-5; -7.3357354f-5 -0.00012167851 0.00012063308 2.3196244f-5 8.83085f-5 -1.2446532f-5 -9.684689f-6 2.980065f-5 5.571014f-5 -7.35403f-5 3.7765865f-5 1.4704204f-5 1.2491583f-5 -7.881948f-5 -0.00012921085 -7.8520015f-6 0.00016108407 -0.00011248321 -0.00021102175 8.694363f-5 3.2276323f-5 4.455601f-5 9.225959f-5 -8.110172f-5 -8.755921f-5 0.00021031615 0.00019002671 -2.1503896f-5 0.00012898492 0.00013956525 3.5843485f-5 -0.00020603678; -7.00998f-5 -0.00022536215 -7.302453f-5 -0.00012287963 -5.6744917f-5 -0.00010672222 9.8666525f-5 -1.4034164f-5 -0.000113641465 1.817901f-5 3.2320615f-5 0.0001908105 5.4409074f-6 1.2769628f-5 -2.7347487f-5 2.8692104f-5 -0.00017634375 -6.191061f-5 -0.00016948488 6.622894f-5 0.0002710066 -5.7206893f-5 6.0409575f-6 -7.0100723f-6 0.000112814996 -0.00013144666 2.278554f-5 -7.6852535f-5 0.00011269706 7.068575f-6 -3.849101f-5 -4.947006f-5; 6.905037f-5 1.2416058f-5 -9.187296f-5 0.0001384613 9.542726f-6 4.514289f-5 -0.0002188806 9.323757f-5 -9.554883f-6 5.8600373f-5 -0.00011198117 9.396026f-7 -5.241627f-5 5.0335784f-5 -5.5882687f-5 -9.06565f-5 -0.00012704064 0.0001036793 0.00016243206 -7.241642f-6 -2.0957317f-5 8.067355f-5 -6.346058f-5 7.360709f-5 -2.5792577f-5 0.00010988256 0.00012545224 -2.4568715f-5 6.459336f-6 -3.9510844f-5 -7.2757095f-5 -2.8118159f-6; -9.137523f-5 4.9068014f-5 -8.741126f-5 1.3070343f-5 -7.1319606f-5 9.7308155f-5 -6.19269f-5 -0.000101316764 -6.0616818f-5 1.2437648f-5 0.00010053482 4.27062f-5 0.00015936886 6.0191032f-5 -5.168395f-6 -4.1755873f-5 -1.6000713f-5 -8.433511f-5 0.00017146491 3.4969704f-5 -0.00011390826 -0.00011244536 -0.00020004262 5.7847432f-5 -0.00015938621 4.854946f-5 -0.00019384043 0.000107601525 -0.00012226813 2.3393113f-5 -9.906755f-6 -2.6569369f-5; -0.00014111941 4.0602972f-5 3.6215744f-5 -8.588301f-5 -9.192123f-5 8.79319f-5 8.53882f-5 -0.00021399991 7.3509684f-5 -3.880575f-5 3.6970927f-5 9.790701f-6 6.968623f-5 0.00020454178 -6.867959f-5 -0.00010126311 3.5089422f-5 -1.0461683f-5 3.1515865f-5 6.162818f-5 0.000114835144 9.508571f-5 8.945246f-5 -0.00013468802 7.513577f-5 -7.464076f-5 -0.00010506843 3.5234116f-5 8.621814f-5 -0.0001330709 6.908736f-5 -2.6424557f-5; -0.00010142811 -9.064446f-5 0.000114123184 -0.00018349438 0.0001353512 -3.621096f-5 2.9312192f-5 0.00012140133 0.000104322266 0.00019622376 -8.272362f-6 -0.00012756042 6.1610044f-5 0.00010408144 0.00017071827 3.5407927f-5 2.3633182f-5 1.9978885f-5 -0.0001303095 -5.026693f-6 -2.8280061f-5 9.929897f-5 7.752122f-5 -4.347049f-5 -5.5944598f-5 4.280858f-5 -4.9529135f-5 0.00015286043 -8.6369255f-5 -0.00017987638 -9.5665804f-5 -2.5325706f-5; -7.870217f-5 3.5501733f-5 -0.00010604536 -3.875108f-5 1.300564f-5 -1.8529667f-5 -4.2343814f-5 -2.9035153f-5 -4.1089344f-5 0.00016813289 -0.00011104555 3.283631f-5 0.000109708395 8.0630816f-5 0.00013991176 -2.411568f-6 4.0799725f-5 0.00028925427 5.0819897f-5 0.00026167353 -0.00019713122 2.7635528f-5 0.00014777921 4.9126364f-5 -1.8100363f-5 5.7542715f-5 -7.368096f-5 0.0002157803 1.2110864f-5 -2.1809463f-5 5.662835f-5 9.9258184f-5; -0.000105990846 3.781285f-5 3.9934846f-5 5.1985426f-5 5.136043f-5 3.5874014f-5 -4.271389f-5 -2.3506203f-5 0.00021073241 9.390601f-5 -5.3790222f-6 -0.00011097694 0.0001374873 -0.0001554244 4.753598f-5 0.00015492518 -0.00022018101 0.00019984324 -6.8034883f-6 9.352279f-5 -4.777991f-5 -8.0045165f-6 -0.00011356324 -6.853572f-5 -3.0359657f-5 0.0001001968 1.3386641f-6 -5.832262f-5 7.0218586f-5 -0.00017497576 -0.000101189595 -4.790334f-5; 0.0001836489 0.00018468013 2.349273f-7 4.414485f-5 3.6248483f-5 6.220992f-5 0.00011165314 0.00017643804 2.5115214f-6 -8.576507f-5 -5.7251666f-5 -0.00010488029 2.9965722f-5 2.8247345f-5 -0.00012450696 -0.00018724863 -3.8098705f-8 -7.166318f-5 8.5244756f-5 -9.3639275f-5 7.772723f-5 7.625239f-5 5.2730105f-5 -1.8729522f-6 -6.9317125f-6 -9.664815f-6 9.604714f-6 -2.9745988f-5 -3.2692282f-5 -2.2556364f-5 -9.4343675f-5 -4.642749f-5; -0.00019195504 -0.00018536708 -0.0002366632 -7.997218f-5 -3.135302f-5 0.00011455849 -9.503763f-6 -0.00010714609 9.4947216f-5 2.5778767f-5 2.8453365f-5 -8.720764f-6 4.1206582f-5 -2.2873011f-5 0.00012557495 -1.6440257f-6 -6.37697f-5 -3.2295462f-5 -0.00017526446 9.615896f-5 -0.00010432762 -2.9534327f-5 4.3847667f-5 8.279828f-6 -0.00021931481 -8.11803f-5 1.9595394f-5 -8.457949f-5 6.3986113f-6 8.670133f-6 -0.00018193571 3.026123f-5; 4.002292f-5 -4.2936797f-5 -4.5870638f-5 0.00012441607 1.9765575f-5 -1.1334759f-5 5.082588f-5 5.4915534f-5 4.553485f-5 0.00014748538 -3.5363646f-5 3.58562f-5 -3.1226464f-5 -9.0085705f-5 8.297926f-5 9.1411486f-5 -8.2109735f-5 1.8311113f-5 -0.00011563201 -3.3617467f-5 0.00010919656 -5.4240998f-5 -2.5123256f-5 2.6134763f-5 -0.000107647866 0.00017332663 -7.380768f-5 -7.8524106f-5 9.61084f-5 3.0200268f-5 0.00018404711 0.00014643604; -3.958132f-5 1.747575f-5 3.1453004f-5 -5.6766996f-5 -0.00010947453 -4.72801f-5 -6.6795685f-5 0.00017471121 -6.2836657f-6 -0.00025699713 -4.287635f-5 -0.00016051138 -4.349476f-5 -0.00019743665 -0.000139192 -5.066276f-6 -5.940459f-5 -0.00026425652 -2.9184324f-5 -0.00015446919 0.000101497004 3.0928077f-5 2.4196681f-6 9.58104f-5 6.686461f-5 4.8276757f-5 -0.00012450495 0.0001194005 0.00011352333 -4.4953384f-5 -1.0787791f-5 7.100724f-5; 4.2453332f-5 -9.166294f-5 7.8840356f-5 -0.00020546587 -3.4318582f-5 9.830515f-6 4.1941687f-5 2.2657523f-5 0.000102690225 2.8926583f-5 0.00010723287 -3.5916208f-5 2.4836152f-5 -0.00011567534 4.6849284f-5 -6.108183f-5 -1.952071f-5 4.1427164f-5 5.2504406f-6 -8.5740554f-5 5.0600785f-5 8.920277f-5 4.0430892f-5 9.543256f-5 -1.9076911f-5 0.00013887638 7.818393f-5 1.14969325f-5 1.4247367f-5 -0.00015943071 7.308622f-5 2.566946f-5; -3.594752f-6 -7.927186f-5 8.7337154f-5 2.7207552f-5 -7.547398f-5 5.1841f-5 -8.839189f-5 -1.7800918f-5 0.00011422129 0.00013905554 2.4307117f-5 0.00024592763 -3.249313f-5 3.4702967f-5 0.0001701057 -7.011432f-5 -0.000121732155 0.00011992142 0.00015152777 -0.00015564685 0.00013438996 9.658255f-5 0.00020633145 9.719457f-5 7.599935f-5 -5.934318f-5 6.430654f-5 0.00020364791 0.00018978206 -0.00022610907 -3.3609624f-5 0.00012932751; -4.6301888f-5 -5.5147044f-5 2.327207f-5 3.2311298f-5 0.00020798402 -4.3601896f-5 4.8774193f-5 -3.6779442f-5 -0.0001398156 -0.000120326826 0.00011149406 3.126537f-5 8.6457785f-6 8.9597306f-5 -0.00012166655 0.00011254855 -2.3336395f-5 0.00013792008 0.00020396934 -5.6711397f-5 -1.4244952f-5 3.2763404f-5 -1.745084f-5 -0.00014979565 -9.578473f-5 -3.5976263f-5 -8.228777f-5 -2.7251215f-5 -7.231685f-5 -0.00015078665 -0.00027402356 0.00023444601; -8.808405f-5 -0.0001513162 -7.479862f-5 -6.593512f-5 0.0001551076 0.00017721509 -2.2907243f-6 -2.8855735f-5 4.30137f-6 4.604346f-5 6.305568f-5 3.093491f-5 6.931074f-5 -0.00011667681 6.806094f-6 -5.102271f-5 0.0001330436 -3.561935f-5 0.00018510624 -7.332004f-6 -9.114906f-5 -4.0152023f-5 -1.078743f-5 -0.00010333228 8.677988f-5 -3.115848f-5 6.964822f-5 -9.5702504f-5 -7.30696f-5 5.816094f-6 -0.00016888122 5.929533f-5; -0.00021231677 0.00010216033 -3.2738844f-5 -4.112667f-5 7.2911054f-5 -0.00020309302 8.457355f-5 5.4292515f-5 1.8665863f-6 0.00019338132 6.2082477f-6 -5.3270534f-5 -6.858694f-5 -2.6549867f-5 7.909162f-6 -0.00011927468 -4.622705f-6 0.00019095017 -0.00019058166 -0.00020289462 3.2128562f-6 2.6580265f-5 6.0652335f-5 -0.00012545678 4.0008577f-5 -0.00014439182 2.1390517f-5 6.18114f-5 6.207182f-5 0.00015283977 -0.00010888634 -2.75119f-5; -2.9657362f-5 2.8501567f-5 -6.5320826f-5 -6.144453f-5 -2.4131756f-5 -4.7993817f-5 -0.00016772581 -4.9863032f-5 -0.00017944597 0.00010495391 -0.00017331804 6.0694507f-5 9.9785415f-5 -9.116979f-5 -7.230078f-5 4.4135395f-5 -0.00013348278 4.6375644f-5 4.8194986f-5 2.1314245f-5 6.80517f-5 -0.00016626233 -2.0966358f-5 -0.0001460753 4.2911306f-5 -0.00011681841 2.8328115f-5 1.0603087f-5 -3.4256598f-5 5.531557f-5 0.00017346354 9.5810115f-5; 3.8990083f-6 0.00011764982 -6.717987f-5 4.6595287f-6 0.000118665565 -5.8496807f-5 0.00015895952 1.0621327f-5 -0.00013873668 0.000103959734 5.429217f-5 -1.3709834f-5 4.397593f-5 -1.1461108f-5 -2.2241533f-5 -0.000113666545 -0.00013437457 -1.8249646f-5 0.00010628034 -5.5521723f-5 5.5646815f-5 -6.74253f-5 -0.00012891945 2.6769298f-5 -8.409246f-5 0.000100006044 5.7221674f-5 -0.00017142581 0.00010914445 5.693836f-5 0.0001007126 5.0276776f-5; -7.439727f-5 -0.00019028691 -6.259671f-5 9.507476f-5 0.00010864896 3.9875955f-5 9.184858f-5 6.716355f-5 1.1485953f-5 1.3490126f-5 0.00011449734 4.3964577f-5 -0.0001549222 3.8674847f-5 -6.229885f-5 -1.3606411f-5 8.086145f-5 -2.7131156f-5 -7.609631f-5 -0.00013389958 -0.0001318757 -3.2846936f-5 0.00012994453 8.40737f-5 -2.308563f-5 0.00011894771 4.646576f-6 6.288576f-6 -8.165544f-5 0.00020370641 -0.0001277675 -7.940606f-6; -4.9011735f-5 2.8589398f-5 3.7095546f-5 4.4438926f-5 -0.00010343502 -0.00016040701 -7.664081f-5 -2.4551255f-5 -6.7864466f-6 0.00013880258 3.8520873f-5 0.00021151222 -4.911463f-5 -9.531738f-5 -5.325542f-5 -1.6407475f-5 5.082316f-5 -0.0002488136 -6.985078f-5 0.00026013353 -0.00010028673 -9.618523f-6 -9.0806316f-5 -7.097391f-5 -6.130593f-5 3.5089484f-5 -1.0862903f-5 -7.053148f-6 0.00013524963 0.00011714864 0.00013119902 -8.2201106f-5], bias = Float32[0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0;;]), layer_4 = (weight = Float32[0.00011729452 -1.4272392f-5 -0.00014561896 -2.0451576f-5 0.00010014997 -7.499308f-5 0.00014979244 -8.357954f-5 1.6085101f-5 -0.00015283708 7.4908785f-5 2.8636248f-5 4.1611715f-5 4.018966f-5 7.611188f-5 8.2176855f-5 -0.000106256164 1.0169477f-5 9.457265f-5 -0.0001264163 -8.101415f-5 6.1695673f-6 8.436727f-5 -0.00010268962 3.7077189f-6 4.03418f-5 -0.0002519508 -8.9883586f-5 0.00013275303 -1.0694383f-5 -0.00014424612 2.3104933f-5; -2.2961114f-5 4.4588553f-5 -3.58845f-5 0.00012472125 0.00013704039 6.210461f-5 -9.523679f-5 -7.875061f-5 7.3519084f-5 -0.0002675586 -2.8746037f-5 3.358335f-5 -0.00012574204 -8.296152f-5 9.717545f-5 6.1506864f-5 8.6867f-5 0.00013188846 0.0001366923 -2.7689643f-5 -0.00011801422 -0.00017058228 0.00021869506 -1.2945733f-5 -0.00014845471 4.8980335f-5 -0.00010383409 -3.8381688f-5 2.0879309f-6 0.00011721091 -0.00016717664 -5.118802f-5], bias = Float32[0.0; 0.0;;])), (layer_1 = NamedTuple(), layer_2 = NamedTuple(), layer_3 = NamedTuple(), layer_4 = NamedTuple())) +``` + + +Similar to most DL frameworks, Lux defaults to using `Float32`, however, in this case we need Float64 + + +```julia +const params = ComponentArray{Float64}(ps) +``` + + +``` +ComponentVector{Float64}(layer_1 = Float64[], layer_2 = (weight = [5.635502020595595e-5; 4.017161700176075e-5; 2.148056410078425e-5; 6.888898269608035e-7; -1.2643258742173202e-5; -0.0002293829747941345; 0.0001495592441642657; 2.0773471987922676e-5; -1.6969486750895157e-5; -0.00012078954023309052; 0.00010557360656093806; -7.64359938330017e-5; 5.3511539590545e-5; -3.318486051284708e-5; 1.311690630245721e-5; 2.239124478364829e-5; 0.0001211854541907087; -4.319386061979458e-5; -3.4525332011980936e-5; 3.856194234685972e-5; 5.9622143453452736e-5; -3.7966474337736145e-5; 1.2598500688909553e-5; 5.772394797531888e-5; -0.00010184913844568655; -7.433060818584636e-5; 0.00012786901788786054; -8.049824828049168e-5; -0.00012392172357067466; -2.8378539354889654e-5; 5.8850790082942694e-5; -1.1600321158766747e-5;;], bias = [0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0;;]), layer_3 = (weight = [2.719058556976961e-6 -1.3763527022092603e-5 -7.314501272048801e-5 -5.309182597557083e-5 1.5296625861083157e-5 2.7777801733464003e-5 -1.3065339771856088e-5 2.8641197786782868e-5 0.00011591703514568508 -0.00014745329099241644 6.183910591062158e-5 1.7537284293211997e-5 1.536628587928135e-5 -7.824158819857985e-5 -8.921899279812351e-6 -6.577102612936869e-5 -2.431145958325942e-6 -2.1007199393352494e-5 -0.00010635137732606381 -2.973015398310963e-5 -0.00010291567741660401 0.00023755099391564727 4.6607485273852944e-5 -0.00016343244351446629 8.603540777585295e-7 0.0001185508444905281 5.854826213180786e-6 9.538282938592602e-6 -0.00011633093527052552 -0.00015355119830928743 0.00014066864969208837 7.370844105025753e-5; -0.00014683522749692202 0.00011144160816911608 3.704769551404752e-5 -6.065524576115422e-5 4.252233702572994e-5 -5.5084678024286404e-5 3.084093577854219e-6 6.53860843158327e-5 0.00019472154963295907 6.555565050803125e-5 -9.01439125300385e-5 4.28782805101946e-5 -4.878119852946838e-6 -7.840198668418452e-5 3.740733882295899e-5 6.47560300421901e-5 -7.597326475661248e-5 4.22399671151652e-6 1.8523556718719192e-5 -4.649046604754403e-5 -8.76114791026339e-5 8.237294241553172e-5 -1.61160987772746e-5 -5.195717676542699e-5 -6.033830140950158e-5 -4.737441850011237e-5 0.0002609542279969901 -8.737501048017293e-6 -0.0001201356208184734 -1.3160007256374229e-5 9.894280810840428e-5 2.4764969566604123e-5; 0.0001330790255451575 -6.947044312255457e-5 7.879847544245422e-6 -7.655558147234842e-5 3.392771031940356e-5 1.7011369664032827e-6 -3.973888851760421e-6 0.00032406512764282525 -7.483502849936485e-5 -0.00018742780957836658 0.00012094456178601831 -5.4314470617100596e-5 4.2091432987945154e-5 -5.886873259441927e-5 3.582921272027306e-5 -1.2990391951461788e-5 0.00016339861031156033 0.00013918837066739798 -4.350136441644281e-5 6.6687076468952e-5 -0.00011951071064686403 -3.886951526510529e-5 2.474799293850083e-5 6.6989021433983e-5 -1.6457661331514828e-5 -7.1882545853441115e-6 -9.14168413146399e-5 0.000275224942015484 2.5253821149817668e-5 -2.8712280254694633e-5 -4.132752292207442e-5 -4.946070839650929e-5; -9.834852971835062e-5 -2.3414795577991754e-5 -0.00021584532805718482 8.583259477745742e-5 -3.5089102311758325e-5 3.93114605685696e-5 -2.2765852918382734e-5 -0.00010890991688938811 -0.00023468228755518794 -0.00014448357978835702 -7.400855974992737e-5 0.0002658068551681936 6.895786646055058e-5 0.00010961941734421998 -0.0001325115154031664 1.950953264895361e-5 8.896800864022225e-5 -0.00013134612527210265 0.00014241058670450002 -0.0001261666911887005 -3.2281634503306122e-6 0.00012028362834826112 -3.558687603799626e-5 0.0001777641155058518 -1.4574933629774023e-5 2.0386773030622862e-5 -6.398249388439581e-5 0.00012377536040730774 -8.68480492499657e-5 -8.560808737456682e-7 0.0002062200801447034 0.00016215603682212532; -5.080442497273907e-5 1.7603166270419024e-5 -8.661148604005575e-5 -7.337014540098608e-5 8.551075734430924e-5 -0.0002575755352154374 -5.253310519037768e-5 2.403409052931238e-5 4.095454642083496e-5 5.174836405785754e-5 5.580644938163459e-5 0.00014649282093159854 0.00015291101590264589 -2.5457697120145895e-5 0.00014471104077529162 -0.00011556095705600455 9.512172982795164e-5 0.00011694306158460677 -7.768403156660497e-5 2.2847032596473582e-5 -0.00011562443251023069 0.0001277744013350457 5.6976103223860264e-5 9.457694977754727e-5 -6.255879998207092e-5 -7.304493919946253e-5 5.1652630645548925e-5 7.456447201548144e-5 -4.975089177605696e-5 -8.014233026187867e-5 0.00012106548092560843 0.00019247073214501143; 0.0001795303396647796 0.00021149487292859703 -4.188638922641985e-5 -2.783746640488971e-5 -5.175314799998887e-5 -1.1396622539905366e-5 8.234786218963563e-5 -6.65581101202406e-5 -5.582900485023856e-5 0.00017181008297484368 0.00011917030496988446 -7.359458686551079e-5 -4.2085343920916785e-6 -4.224558870191686e-5 0.00018064214964397252 1.0210326763626654e-5 8.797342889010906e-5 -7.389826350845397e-5 -2.972968650283292e-5 0.00015903091116342694 2.0468298316700384e-5 -0.00016050574777182192 0.0001698227133601904 4.945115142618306e-5 7.165193528635427e-5 0.00010947186092380434 -5.03744522575289e-5 9.836249228101224e-5 7.159871893236414e-5 9.208479605149478e-5 -5.770940697402693e-5 0.00015367410378530622; 5.679971582139842e-5 -4.056659963680431e-5 -0.00013163710536900908 -1.39908315759385e-5 7.727371848886833e-5 -4.603103661793284e-5 0.00013285399472806603 -4.211814302834682e-5 0.00013113593740854412 8.51302029332146e-5 -6.61834710626863e-5 4.607778100762516e-5 -4.863426511292346e-5 1.7748732716427185e-5 9.918475552694872e-5 0.00012170758418506011 6.835345266154036e-5 0.0001359352027066052 -0.00021700371871702373 7.392806583084166e-5 7.241228013299406e-5 7.909867417765781e-5 0.00013241509441286325 7.584305421914905e-6 3.697982174344361e-5 7.262571307364851e-5 0.00017065567953977734 -4.3143350922036916e-5 0.00020268138905521482 -5.7425651903031394e-5 4.120336234336719e-5 3.2639425626257434e-5; -5.469899406307377e-5 1.2401724234223366e-5 -8.919315587263554e-5 -2.8532181204354856e-6 9.042418241733685e-6 8.283153874799609e-5 4.860954504692927e-5 -7.517092308262363e-5 4.424045982887037e-5 1.0352835488447454e-5 0.00010046401439467445 0.00012721266830340028 -0.0001220878039021045 6.630836287513375e-5 7.069001003401354e-5 -4.53821339760907e-5 4.012951103504747e-5 5.675453212461434e-5 -7.074433960951865e-5 -6.0485592257464305e-5 5.3060932259541005e-5 3.2538150662730914e-6 9.571223199600354e-5 0.00023285365023184568 -9.209420386468992e-5 9.88656684057787e-5 -1.5976289432728663e-5 -2.8452964215830434e-6 -7.723678572801873e-5 -0.00010246595047647133 8.412727765971795e-5 -0.0001033657681546174; -1.493016725362395e-6 3.7866549973841757e-5 2.030025643762201e-5 2.3760074327583425e-5 -0.00012740404054056853 0.00014637007552664727 5.3498610213864595e-5 0.00013343087630346417 -2.30400291911792e-5 0.00015473031089641154 -5.8458019339013845e-5 0.0001017927352222614 -7.742411980871111e-5 -0.0001460881467210129 -0.00016346278425771743 4.7591856855433434e-5 -5.8451001677894965e-5 -3.858772470266558e-5 6.731860048603266e-5 0.00014078503591008484 -2.7156362193636596e-5 8.002254617167637e-5 3.409215423744172e-5 -4.657721001422033e-5 3.6196888686390594e-5 5.650470848195255e-5 5.067915117251687e-5 -2.5619341613491997e-5 -4.4313794205663726e-5 -0.0001313527172897011 4.3342508433852345e-5 1.95839111256646e-5; 0.0002130207431036979 0.00014018606452737004 -3.6351411836221814e-5 7.457662286469713e-5 -4.195017027086578e-5 -7.782447937643155e-5 -4.5463861169992015e-5 -7.199469837360084e-5 2.2504351363750175e-5 0.00019906270608771592 0.00016777400742284954 -3.9674792787991464e-5 6.919078714417992e-7 4.594287474901648e-6 -8.50255019031465e-5 -6.228194979485124e-5 5.0525944971013814e-5 2.737140493991319e-5 -0.00020181007857900113 5.380803486332297e-5 3.848351298074704e-6 0.00012734250049106777 -7.079673378029838e-5 0.00011233999975956976 5.0529510190244764e-5 -4.276902473066002e-5 4.652242182601185e-7 0.00021697634656447917 -0.00013943653902970254 -0.0001388539676554501 6.649340775766177e-6 7.377130532404408e-5; 0.00015949933731462806 6.374916119966656e-5 -4.9936325012822635e-6 3.458772334852256e-5 -0.00012995321594644338 0.00014051955076865852 0.0003022009623236954 0.00011187897325726226 4.3839805584866554e-5 6.633032899117097e-5 5.3422118071466684e-5 1.9555493054213002e-5 2.027887421718333e-5 0.0002561146975494921 -3.5563829442253336e-5 0.00019262295973021537 -0.00018797736265696585 8.474955393467098e-5 -1.1352111869200598e-5 -0.00017142879369203 1.3169110388844274e-5 -0.0001021814314299263 -0.00012328529555816203 -0.00012704325490631163 -6.310311437118798e-5 -0.00010207985178567469 -4.2549061618046835e-5 -2.4989558369270526e-5 -5.046627120464109e-5 1.3588074580184184e-5 9.798766404855996e-5 8.179852738976479e-5; -7.335735426750034e-5 -0.00012167850945843384 0.00012063307804055512 2.319624400115572e-5 8.830850129015744e-5 -1.2446532309695613e-5 -9.684688848210499e-6 2.9800650736433454e-5 5.5710141168674454e-5 -7.354030094575137e-5 3.7765865272376686e-5 1.4704203749715816e-5 1.2491583220253233e-5 -7.881948113208637e-5 -0.00012921084999106824 -7.85200154496124e-6 0.00016108406998682767 -0.00011248321243328974 -0.00021102174650877714 8.694363350514323e-5 3.227632259950042e-5 4.455601083463989e-5 9.22595863812603e-5 -8.110172348096967e-5 -8.75592086231336e-5 0.0002103161532431841 0.00019002670887857676 -2.1503896277863532e-5 0.00012898491695523262 0.00013956525071989745 3.584348451113328e-5 -0.00020603678422048688; -7.009979890426621e-5 -0.00022536214964929968 -7.302453013835475e-5 -0.00012287963181734085 -5.67449169466272e-5 -0.00010672221833374351 9.86665254458785e-5 -1.4034164451004472e-5 -0.00011364146484993398 1.8179009202867746e-5 3.232061499147676e-5 0.00019081050413660705 5.440907443698961e-6 1.276962757401634e-5 -2.7347487048245966e-5 2.8692104024230503e-5 -0.0001763437467161566 -6.191060674609616e-5 -0.00016948487609624863 6.622893852181733e-5 0.00027100660372525454 -5.7206892961403355e-5 6.040957487130072e-6 -7.010072295088321e-6 0.0001128149961004965 -0.00013144666445441544 2.278553984069731e-5 -7.685253513045609e-5 0.0001126970601035282 7.068575087032514e-6 -3.849100903607905e-5 -4.947006164002232e-5; 6.90503729856573e-5 1.2416057870723307e-5 -9.187295654555783e-5 0.00013846129877492785 9.542725820210762e-6 4.514288957579993e-5 -0.00021888059563934803 9.323756967205554e-5 -9.554883035889361e-6 5.8600373449735343e-5 -0.00011198117135791108 9.396026143804193e-7 -5.241627150098793e-5 5.033578418078832e-5 -5.588268686551601e-5 -9.065649646800011e-5 -0.00012704063556157053 0.00010367929644417018 0.00016243205755017698 -7.2416419243381824e-6 -2.0957317246939056e-5 8.06735479272902e-5 -6.346058216877282e-5 7.360708696069196e-5 -2.5792576707317494e-5 0.00010988255962729454 0.00012545223580673337 -2.4568715161876753e-5 6.45933596388204e-6 -3.951084363507107e-5 -7.275709504028782e-5 -2.811815875247703e-6; -9.137523011304438e-5 4.906801405013539e-5 -8.74112593010068e-5 1.3070342902210541e-5 -7.131960592232645e-5 9.730815509101376e-5 -6.192689761519432e-5 -0.00010131676390301436 -6.061681779101491e-5 1.2437648365448695e-5 0.00010053481673821807 4.2706200474640355e-5 0.00015936886484269053 6.01910323894117e-5 -5.168395091459388e-6 -4.175587309873663e-5 -1.6000713003450073e-5 -8.433510811300948e-5 0.00017146491154562682 3.4969703847309574e-5 -0.00011390825966373086 -0.00011244536290178075 -0.00020004261750727892 5.784743188996799e-5 -0.00015938621072564274 4.854946018895134e-5 -0.00019384043116588145 0.0001076015250873752 -0.00012226813123561442 2.3393113224301487e-5 -9.906754712574184e-6 -2.6569368856144138e-5; -0.00014111940981820226 4.0602972148917615e-5 3.621574433054775e-5 -8.588300988776609e-5 -9.192123252432793e-5 8.79318977240473e-5 8.538820111425593e-5 -0.00021399991237558424 7.350968371611089e-5 -3.880574877257459e-5 3.697092688526027e-5 9.790701369638555e-6 6.968623347347602e-5 0.00020454177865758538 -6.867959018563852e-5 -0.00010126311099156737 3.508942245389335e-5 -1.0461682904860936e-5 3.1515864975517616e-5 6.162818317534402e-5 0.00011483514390420169 9.508570656180382e-5 8.945245645008981e-5 -0.0001346880162600428 7.513577293138951e-5 -7.464076043106616e-5 -0.00010506842954782769 3.523411578498781e-5 8.621814049547538e-5 -0.00013307090557646006 6.90873566782102e-5 -2.642455729073845e-5; -0.00010142810788238421 -9.064446203410625e-5 0.00011412318417569622 -0.00018349438323639333 0.00013535120524466038 -3.6210960388416424e-5 2.9312192054931074e-5 0.00012140133185312152 0.00010432226554257795 0.0001962237583938986 -8.272361810668372e-6 -0.00012756041542161256 6.161004421301186e-5 0.0001040814386215061 0.00017071826732717454 3.540792749845423e-5 2.3633181626792066e-5 1.9978884665761143e-5 -0.0001303095050388947 -5.02669308843906e-6 -2.8280061087571084e-5 9.929897350957617e-5 7.752121746307239e-5 -4.3470488890307024e-5 -5.5944597988855094e-5 4.280858047422953e-5 -4.952913513989188e-5 0.00015286043344531208 -8.636925485916436e-5 -0.00017987638420891017 -9.566580411046743e-5 -2.5325705792056397e-5; -7.870217086747289e-5 3.550173278199509e-5 -0.00010604535782476887 -3.875108086504042e-5 1.3005639630137011e-5 -1.8529666704125702e-5 -4.2343814129708335e-5 -2.9035152692813426e-5 -4.108934444957413e-5 0.00016813288675621152 -0.00011104554869234562 3.283630940131843e-5 0.00010970839502988383 8.06308162282221e-5 0.00013991176092531532 -2.4115679480019026e-6 4.0799724956741557e-5 0.0002892542688641697 5.081989729660563e-5 0.00026167352916672826 -0.00019713121582753956 2.763552765827626e-5 0.00014777921023778617 4.912636359222233e-5 -1.8100363377016038e-5 5.754271478508599e-5 -7.368095975834876e-5 0.00021578029554802924 1.2110864190617576e-5 -2.180946285079699e-5 5.662834882969037e-5 9.925818449119106e-5; -0.00010599084635032341 3.7812849768670276e-5 3.99348464270588e-5 5.198542567086406e-5 5.136042818776332e-5 3.58740144292824e-5 -4.2713891161838546e-5 -2.350620343349874e-5 0.00021073241077829152 9.390601189807057e-5 -5.379022240958875e-6 -0.00011097693641204387 0.00013748729543294758 -0.00015542439359705895 4.753598113893531e-5 0.0001549251755932346 -0.0002201810129918158 0.00019984324171673506 -6.803488304285565e-6 9.352278721053153e-5 -4.777991125592962e-5 -8.004516530490946e-6 -0.0001135632410296239 -6.853572267573327e-5 -3.0359657102962956e-5 0.00010019679757533595 1.3386641057877569e-6 -5.8322621043771505e-5 7.021858618827537e-5 -0.00017497576482128352 -0.00010118959471583366 -4.790334060089663e-5; 0.00018364889547228813 0.00018468013149686158 2.3492729894769582e-7 4.4144850107841194e-5 3.624848250183277e-5 6.220991781447083e-5 0.00011165314208483323 0.00017643804312683642 2.5115214157267474e-6 -8.576506661484018e-5 -5.725166556658223e-5 -0.00010488028783584014 2.9965722205815837e-5 2.824734474415891e-5 -0.0001245069579454139 -0.0001872486318461597 -3.8098704635558533e-8 -7.166317664086819e-5 8.524475560989231e-5 -9.363927529193461e-5 7.772722892696038e-5 7.62523923185654e-5 5.2730105380760506e-5 -1.8729522253124742e-6 -6.93171250532032e-6 -9.664814569987357e-6 9.6047142505995e-6 -2.9745988285867497e-5 -3.269228182034567e-5 -2.2556363546755165e-5 -9.434367530047894e-5 -4.642748899641447e-5; -0.00019195504137314856 -0.0001853670837590471 -0.00023666319611947984 -7.997218199307099e-5 -3.1353021768154576e-5 0.00011455849016783759 -9.50376306718681e-6 -0.00010714608652051538 9.494721598457545e-5 2.5778766939765774e-5 2.8453365302993916e-5 -8.720763617020566e-6 4.1206581954611465e-5 -2.2873011403135024e-5 0.0001255749521078542 -1.6440257013528026e-6 -6.37697012280114e-5 -3.229546200600453e-5 -0.0001752644602674991 9.615896124159917e-5 -0.00010432762064738199 -2.9534327040892094e-5 4.384766725706868e-5 8.279827852675226e-6 -0.00021931481023784727 -8.118029654724523e-5 1.9595394405769184e-5 -8.457949297735468e-5 6.398611276381416e-6 8.670132956467569e-6 -0.00018193571304436773 3.0261229767347686e-5; 4.0022918255999684e-5 -4.293679739930667e-5 -4.587063813232817e-5 0.0001244160666828975 1.9765575416386127e-5 -1.1334758710290771e-5 5.08258817717433e-5 5.491553383762948e-5 4.5534849050454795e-5 0.000147485377965495 -3.536364602041431e-5 3.585619924706407e-5 -3.122646376141347e-5 -9.008570486912504e-5 8.297926251543686e-5 9.141148620983586e-5 -8.210973464883864e-5 1.8311113308300264e-5 -0.00011563200678210706 -3.3617467124713585e-5 0.00010919656051555648 -5.424099799711257e-5 -2.512325590942055e-5 2.6134763174923137e-5 -0.00010764786566141993 0.00017332662537228316 -7.380767783615738e-5 -7.852410635678098e-5 9.610840061213821e-5 3.020026815647725e-5 0.0001840471086325124 0.00014643603935837746; -3.958131856052205e-5 1.7475749700679444e-5 3.145300433970988e-5 -5.676699584000744e-5 -0.00010947453120024875 -4.728010026155971e-5 -6.679568468825892e-5 0.0001747112110024318 -6.2836656979925465e-6 -0.0002569971256889403 -4.2876348743448034e-5 -0.0001605113793630153 -4.349476148490794e-5 -0.00019743664597626776 -0.00013919199409428984 -5.066276116849622e-6 -5.9404588682809845e-5 -0.00026425652322359383 -2.9184324375819415e-5 -0.00015446919132955372 0.00010149700392503291 3.092807673965581e-5 2.4196681351895677e-6 9.58103992161341e-5 6.686460983473808e-5 4.827675729757175e-5 -0.00012450494978111237 0.00011940050171688199 0.0001135233324021101 -4.495338362175971e-5 -1.0787791325128637e-5 7.100724178599194e-5; 4.2453331843717024e-5 -9.166294330498204e-5 7.884035585448146e-5 -0.00020546586893033236 -3.431858203839511e-5 9.830515409703366e-6 4.1941686504287645e-5 2.265752300445456e-5 0.00010269022459397092 2.8926582672283985e-5 0.00010723286686697975 -3.591620770748705e-5 2.4836152078933083e-5 -0.00011567534238565713 4.6849283535266295e-5 -6.108183151809499e-5 -1.95207103388384e-5 4.142716352362186e-5 5.250440608506324e-6 -8.5740553913638e-5 5.0600785471033305e-5 8.920276741264388e-5 4.043089211336337e-5 9.543255873722956e-5 -1.9076911485171877e-5 0.0001388763776049018 7.818393351044506e-5 1.1496932529553305e-5 1.424736728949938e-5 -0.0001594307104824111 7.308622298296541e-5 2.5669460228527896e-5; -3.5947518881584983e-6 -7.92718565207906e-5 8.733715367270634e-5 2.7207552193431184e-5 -7.54739812691696e-5 5.1841001550201327e-5 -8.83918910403736e-5 -1.7800917703425512e-5 0.00011422129318816587 0.00013905554078519344 2.4307117200805806e-5 0.0002459276292938739 -3.2493131584487855e-5 3.470296724117361e-5 0.00017010570445563644 -7.011432171566412e-5 -0.00012173215509392321 0.00011992141662631184 0.00015152776904869825 -0.000155646848725155 0.00013438996393233538 9.65825529419817e-5 0.00020633144595194608 9.719457011669874e-5 7.599934906465933e-5 -5.9343179600546136e-5 6.43065432086587e-5 0.00020364791271276772 0.00018978206207975745 -0.0002261090703541413 -3.3609623642405495e-5 0.00012932751269545406; -4.6301887778099626e-5 -5.514704389497638e-5 2.3272070393431932e-5 3.23112981277518e-5 0.00020798401965294033 -4.3601896322797984e-5 4.877419269178063e-5 -3.6779441870749e-5 -0.00013981560186948627 -0.00012032682570861652 0.00011149406054755673 3.126536830677651e-5 8.645778507343493e-6 8.959730621427298e-5 -0.00012166654778411612 0.0001125485505326651 -2.3336395315709524e-5 0.00013792008394375443 0.0002039693354163319 -5.6711396609898657e-5 -1.424495167157147e-5 3.276340430602431e-5 -1.7450840459787287e-5 -0.00014979565457906574 -9.578472963767126e-5 -3.597626346163452e-5 -8.22877700557001e-5 -2.72512152150739e-5 -7.231684867292643e-5 -0.00015078665455803275 -0.00027402356499806046 0.00023444600810762495; -8.808405254967511e-5 -0.00015131619875319302 -7.479861960746348e-5 -6.593512080144137e-5 0.0001551075984025374 0.00017721508629620075 -2.2907242964720353e-6 -2.8855734854005277e-5 4.301370154280448e-6 4.604346031555906e-5 6.305568240350112e-5 3.0934908863855526e-5 6.931074312888086e-5 -0.00011667681246763095 6.806094006606145e-6 -5.102271097712219e-5 0.00013304360618349165 -3.561934863682836e-5 0.00018510624067857862 -7.33200386093813e-6 -9.114905697060749e-5 -4.0152022847905755e-5 -1.0787430255732033e-5 -0.00010333227692171931 8.677988080307841e-5 -3.115848085144535e-5 6.964821659494191e-5 -9.570250404067338e-5 -7.3069597419817e-5 5.816094017063733e-6 -0.00016888121899683028 5.929532926529646e-5; -0.0002123167651006952 0.00010216033115284517 -3.273884431109764e-5 -4.112667011213489e-5 7.291105430340394e-5 -0.00020309301908127964 8.457354851998389e-5 5.42925154149998e-5 1.8665863308342523e-6 0.00019338131824042648 6.20824766883743e-6 -5.3270534408511594e-5 -6.85869381413795e-5 -2.6549867470748723e-5 7.909162377472967e-6 -0.00011927467858185992 -4.622705091605894e-6 0.00019095017341896892 -0.00019058166071772575 -0.00020289461826905608 3.212856199752423e-6 2.6580264602671377e-5 6.0652335378108546e-5 -0.00012545677600428462 4.000857734354213e-5 -0.00014439181541092694 2.1390516849351116e-5 6.181139906402677e-5 6.207182013895363e-5 0.0001528397697256878 -0.00010888634278671816 -2.7511900043464266e-5; -2.9657361665158533e-5 2.8501566703198478e-5 -6.532082625199109e-5 -6.144453072920442e-5 -2.4131755708367564e-5 -4.7993817133829e-5 -0.00016772581147961318 -4.986303247278556e-5 -0.00017944596766028553 0.00010495391325093806 -0.00017331803974229842 6.069450682844035e-5 9.978541493183002e-5 -9.116979344980791e-5 -7.230078335851431e-5 4.413539500092156e-5 -0.00013348278298508376 4.6375644160434604e-5 4.819498644792475e-5 2.1314244804671034e-5 6.805169687140733e-5 -0.00016626232536509633 -2.096635762427468e-5 -0.00014607529737986624 4.291130608180538e-5 -0.00011681840987876058 2.832811514963396e-5 1.0603086593619082e-5 -3.425659815547988e-5 5.5315569625236094e-5 0.00017346354434266686 9.581011545378715e-5; 3.899008333974052e-6 0.00011764981900341809 -6.717986980220303e-5 4.659528713091277e-6 0.00011866556451423094 -5.8496807469055057e-5 0.00015895951946731657 1.062132741935784e-5 -0.00013873667921870947 0.00010395973367849365 5.4292169807013124e-5 -1.3709834092878737e-5 4.397593147587031e-5 -1.1461108442745171e-5 -2.2241532860789448e-5 -0.00011366654507583007 -0.00013437456800602376 -1.8249646018375643e-5 0.00010628034215187654 -5.552172297029756e-5 5.564681487157941e-5 -6.742530240444466e-5 -0.0001289194478886202 2.676929761946667e-5 -8.409246220253408e-5 0.0001000060437945649 5.722167406929657e-5 -0.0001714258105494082 0.0001091444501071237 5.693835919373669e-5 0.00010071259748656303 5.0276776164537296e-5; -7.439727050950751e-5 -0.00019028691167477518 -6.259670772124082e-5 9.507476352155209e-5 0.00010864895739359781 3.98759548261296e-5 9.184858208755031e-5 6.716354982927442e-5 1.1485953109513503e-5 1.3490125638782047e-5 0.00011449734302004799 4.396457734401338e-5 -0.000154922207002528 3.8674847019137815e-5 -6.229885184438899e-5 -1.3606410902866628e-5 8.086144953267649e-5 -2.713115645747166e-5 -7.609630847582594e-5 -0.00013389957894105464 -0.00013187569857109338 -3.2846935937413946e-5 0.00012994452845305204 8.40736975078471e-5 -2.3085629436536692e-5 0.00011894771159859374 4.6465761442959774e-6 6.2885760598874185e-6 -8.165543840732425e-5 0.00020370641141198575 -0.00012776750372722745 -7.940606337797362e-6; -4.901173451798968e-5 2.8589398425538093e-5 3.7095545849297196e-5 4.443892612471245e-5 -0.0001034350207191892 -0.00016040701302699745 -7.664081203984097e-5 -2.4551254682592116e-5 -6.786446647311095e-6 0.00013880258484277874 3.8520873204106465e-5 0.00021151221881154925 -4.911463111056946e-5 -9.531738032819703e-5 -5.325541860656813e-5 -1.6407475413870998e-5 5.082316056359559e-5 -0.0002488135942257941 -6.985077925492078e-5 0.00026013352908194065 -0.00010028672841144726 -9.618523108656518e-6 -9.080631571123376e-5 -7.097391062416136e-5 -6.130593101261184e-5 3.508948429953307e-5 -1.0862902854569256e-5 -7.05314778315369e-6 0.00013524963287636638 0.0001171486364910379 0.0001311990199610591 -8.220110612455755e-5], bias = [0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0; 0.0;;]), layer_4 = (weight = [0.00011729451944120228 -1.4272392036218662e-5 -0.00014561896387021989 -2.0451576347113587e-5 0.00010014996951213107 -7.499307685066015e-5 0.00014979243860580027 -8.357954357052222e-5 1.6085101378848776e-5 -0.00015283707762137055 7.490878488169983e-5 2.863624831661582e-5 4.161171455052681e-5 4.0189661376643926e-5 7.611187902512029e-5 8.217685535782948e-5 -0.00010625616414472461 1.0169476809096523e-5 9.457264968659729e-5 -0.00012641630019061267 -8.101415005512536e-5 6.169567313918378e-6 8.436726784566417e-5 -0.00010268962068948895 3.707718860823661e-6 4.03418016503565e-5 -0.00025195081252604723 -8.988358604256064e-5 0.00013275303354021162 -1.069438258127775e-5 -0.00014424612163566053 2.310493255208712e-5; -2.2961114154895768e-5 4.458855255506933e-5 -3.5884499084204435e-5 0.00012472124944906682 0.0001370403915643692 6.210461287992075e-5 -9.523679182166234e-5 -7.87506069173105e-5 7.351908425334841e-5 -0.0002675585856195539 -2.8746037060045637e-5 3.358335015946068e-5 -0.0001257420371985063 -8.296151645481586e-5 9.717544890008867e-5 6.150686385808513e-5 8.686700311955065e-5 0.00013188846060074866 0.00013669229520019144 -2.768964259303175e-5 -0.00011801422078860924 -0.00017058227967936546 0.00021869505872018635 -1.2945733033120632e-5 -0.00014845471014268696 4.898033512290567e-5 -0.00010383409244241193 -3.838168777292594e-5 2.087930852212594e-6 0.0001172109114122577 -0.00016717663675080985 -5.1188020734116435e-5], bias = [0.0; 0.0;;])) +``` + + +Now we define a system of odes which describes motion of point like particle with Newtonian physics, uses + + +$$ +u[1] = \chi +$$ + + +$$ +u[2] = \phi +$$ + + +where, $p$, $M$, and $e$ are constants + + +```julia +function ODE_model(u, nn_params, t) + χ, ϕ = u + p, M, e = ode_model_params + + # In this example we know that `st` is am empty NamedTuple hence we can safely ignore + # it, however, in general, we should use `st` to store the state of the neural network. + y = 1 .+ first(nn([first(u)], nn_params, st)) + + numer = (1 + e * cos(χ))^2 + denom = M * (p^(3 / 2)) + + χ̇ = (numer / denom) * y[1] + ϕ̇ = (numer / denom) * y[2] + + return [χ̇, ϕ̇] +end +``` + + +``` +ODE_model (generic function with 1 method) +``` + + +Let us now simulate the neural network model and plot the results. We'll use the untrained neural network parameters to simulate the model. + + +```julia +prob_nn = ODEProblem(ODE_model, u0, tspan, params) +soln_nn = Array(solve(prob_nn, RK4(); u0, p=params, saveat=tsteps, dt, adaptive=false)) +waveform_nn = first(compute_waveform(dt_data, soln_nn, mass_ratio, ode_model_params)) + +fig = with_theme(theme_web()) do + fig = Figure() + ax = CairoMakie.Axis(fig[1, 1]; xlabel="Time", ylabel="Waveform") + + l1 = lines!(ax, tsteps, waveform; linewidth=2, alpha=0.75) + s1 = scatter!(ax, tsteps, waveform; markershape=:circle, markeralpha=0.25, alpha=0.5) + + l2 = lines!(ax, tsteps, waveform_nn; linewidth=2, alpha=0.75) + s2 = scatter!(ax, tsteps, waveform_nn; markershape=:circle, markeralpha=0.25, alpha=0.5) + + axislegend(ax, [[l1, s1], [l2, s2]], + ["Waveform Data", "Waveform Neural Net (Untrained)"]; position=:lb) + + return fig +end +``` + + +![](1_GravitationalWaveForm-35.png) + + + + +## Setting Up for Training the Neural Network + + +Next, we define the objective (loss) function to be minimized when training the neural differential equations. + + +```julia +function loss(θ) + pred = Array(solve(prob_nn, RK4(); u0, p=θ, saveat=tsteps, dt, adaptive=false)) + pred_waveform = first(compute_waveform(dt_data, pred, mass_ratio, ode_model_params)) + loss = sum(abs2, waveform .- pred_waveform) + return loss, pred_waveform +end +``` + + +``` +loss (generic function with 1 method) +``` + + +Warmup the loss function + + +```julia +loss(params) +``` + + +``` +(0.17552953785202197, [-0.024250475722112225, -0.023466476917028994, -0.02268247811194522, -0.021357780463992768, -0.01946468010737091, -0.016962962470289108, -0.01379982765019496, -0.009906927817058929, -0.005202630429967592, 0.00040833865792949924, 0.007025706710341177, 0.014732740626736686, 0.02354870086658099, 0.03330057105280758, 0.043344982794820235, 0.05191057660961681, 0.05470663287012312, 0.042653315714343526, 0.002209370482077575, -0.06602234647253413, -0.11024711218030575, -0.07651765836010002, -0.007136204108359924, 0.0385912072872617, 0.054148460011303315, 0.05290003928240442, 0.04484479772790305, 0.03486175594939493, 0.024996337158097272, 0.016012653494110952, 0.008128799216186464, 0.0013462051128350675, -0.004413955526439855, -0.009251302542988057, -0.013262950828515481, -0.01653222403598635, -0.019130042098010502, -0.021111827600193818, -0.022519652134183714, -0.023383107597038613, -0.023720266644397678, -0.023538024124272066, -0.02283334654087682, -0.02159096947325195, -0.019785445421651046, -0.017378824291598566, -0.014319857163159398, -0.0105433994575132, -0.005969579028756049, -0.0005052432269651193, 0.005948711072888915, 0.013481687928148186, 0.022125493700690464, 0.0317513027938766, 0.041817504273508735, 0.05079561148761304, 0.05492154681440164, 0.0460112114149308, 0.010754444612784072, -0.05499958878471732, -0.1080755750748387, -0.08613880590650298, -0.017205608169297597, 0.03377125080758276, 0.05319950149527278, 0.05373952667280481, 0.04630721558700483, 0.036430510411694865, 0.02646775302181639, 0.01732087563522051, 0.009258175706804074, 0.0023101408954251997, -0.0036047727544698894, -0.008575459730235562, -0.012709523018016932, -0.016085025255850257, -0.018782220714304125, -0.020852380926707104, -0.02234508215791166, -0.023287796507123218, -0.02370305067100446, -0.023598445554858422, -0.022971745649023944, -0.021811325242075377, -0.02009336020011907, -0.017778786812505366, -0.014824371967106698, -0.011160144387373446, -0.006716456394262995, -0.0013940845137818394, 0.004897601986330397, 0.012259022382696777, 0.020727485818904275, 0.030217644553396514, 0.04027042231233175, 0.049576242634149385, 0.05483904716444791, 0.04872485420136051, 0.018450671194625918, -0.043771101974171125, -0.1038210379251917, -0.09455563645529233, -0.027860868599012076, 0.0281427173821811, 0.05180611904796513, 0.05440207755339701, 0.047720121360413544, 0.03800183202563716, 0.027963836093034364, 0.01865399116304388, 0.010418619963371652, 0.003295428763402536, -0.0027693519133588944, -0.007883071167579043, -0.012135667725324956, -0.015624888231939192, -0.018417929518939048, -0.020581687728021467, -0.022156951181431368, -0.02318150053211984, -0.023674105445247316, -0.023646745589568325, -0.023099259393895007, -0.02201907798676162, -0.02038711251953672, -0.018164945397193436, -0.015311635680614787, -0.011759527467893268, -0.007441736959164752, -0.002260371032490515, 0.003873369926986912, 0.011063178976656167, 0.019357233989665976, 0.02870013996045932, 0.03871297026839423, 0.048271106735969765, 0.05449679996961276, 0.050858272347465365, 0.025278215648835492, -0.032614575047662075, -0.09767293767116887, -0.10144226826986955, -0.03892782551588425, 0.021666540378546272, 0.04991492452935269, 0.054855575763345266, 0.04907039580485204, 0.039572867238813904, 0.029476526591820384, 0.02001976301198408, 0.011603037425849774, 0.0043102357970249945, -0.0019171405812029964, -0.00716474512459697, -0.011547096934926197, -0.015146275625237118, -0.018043017362456837, -0.0202944759265419, -0.021957978490229155, -0.023062786521035418, -0.02363388990265816, -0.023683794801829923, -0.023214228961828884, -0.02221537480467364, -0.020665577440531678, -0.01853887850512064, -0.0157820114991732, -0.012340008762642903, -0.008147590088826838, -0.003105123323972452, 0.002875919184746044, 0.009896232169578198, 0.01801222119091354, 0.02720230777212156, 0.037151005570143315, 0.046895896721844944, 0.053934439219241764, 0.05246634845576025, 0.03125671014967647, -0.021787958211688774, -0.0898715331433992, -0.10652514077614915, -0.050185366455250596, 0.014329431543112777, 0.04745953930594704, 0.05506889319145044, 0.0503423492105518, 0.04113352398310678, 0.031014225872082114, 0.021407694733474994, 0.012816967362041687, 0.005347263951323519, -0.001033361805415379, -0.006431486460857474, -0.01093932409938482, -0.014653797002458854, -0.017647973436907206, -0.019997613319157576, -0.0217458947546408, -0.022932577247420902, -0.023581454455461465, -0.023709482002722118, -0.023317533709883896, -0.022397535441095365, -0.020935481814515714, -0.018895041562148912, -0.016237574901000643, -0.012903880940762035, -0.008832549995208208, -0.003926225124180661, 0.00190276261224977, 0.008755101328938643, 0.01669638453047612, 0.025726050564640585, 0.03558913584976988, 0.045465797104099474, 0.05318160691372298, 0.05360890624099591, 0.03641112812764702, -0.011476882360520059, -0.08072918214369429, -0.10959464569413441, -0.061352690538567727, 0.0061235927818339845, 0.04438749492403786, 0.054999910788528304, 0.051518312400457296, 0.04268127749240753, 0.03256450103868846, 0.022824375618331134, 0.014058747293480642, 0.006413087794280031, -0.00013030971469560668, -0.005675078746735206, -0.010312782363905489, -0.014143267201848695, -0.017241329457516514, -0.019685554464235522, -0.021521233811634243, -0.022790171009133903, -0.02351788924008501, -0.023723417415738208, -0.02340912623499192, -0.022568780279096656, -0.02118989860199076, -0.019238489283695835, -0.016677597952530793, -0.01345050361962903, -0.009498084535788086, -0.005545665451947121]) +``` + + +Now let us define a callback function to store the loss over time + + +```julia +const losses = Float64[] + +function callback(θ, l, pred_waveform) + push!(losses, l) + println("Training || Iteration: $(length(losses)) || Loss: $(l)") + return false +end +``` + + +``` +callback (generic function with 1 method) +``` + + + + +## Training the Neural Network + + +Training uses the BFGS optimizers. This seems to give good results because the Newtonian model seems to give a very good initial guess + + +```julia +adtype = Optimization.AutoZygote() +optf = Optimization.OptimizationFunction((x, p) -> loss(x), adtype) +optprob = Optimization.OptimizationProblem(optf, params) +res = Optimization.solve(optprob, + BFGS(; initial_stepnorm=0.01, linesearch=LineSearches.BackTracking()); + callback, maxiters=1000) +``` + + +``` +retcode: Success +u: ComponentVector{Float64}(layer_1 = Float64[], layer_2 = (weight = [5.635502020582857e-5; 4.0171617001711914e-5; 2.1480564100776426e-5; 6.888898269604602e-7; -1.2643258742170077e-5; -0.00022938297479414304; 0.00014955924416409049; 2.0773471987913663e-5; -1.696948675087535e-5; -0.00012078954023277064; 0.0001055736065608919; -7.643599383292235e-5; 5.351153959055319e-5; -3.3184860512813735e-5; 1.3116906302428466e-5; 2.239124478364405e-5; 0.00012118545419059399; -4.319386061968359e-5; -3.452533201198606e-5; 3.856194234683004e-5; 5.9622143453449185e-5; -3.7966474337702324e-5; 1.259850068888149e-5; 5.772394797524209e-5; -0.0001018491384456334; -7.433060818573544e-5; 0.00012786901788773664; -8.049824828033944e-5; -0.00012392172357053246; -2.8378539354928424e-5; 5.8850790082864307e-5; -1.1600321158751488e-5;;], bias = [1.4647746052962445e-16; 5.604488559961802e-17; 9.555241531054678e-18; 4.0113198533035956e-19; -3.260212007322134e-18; 9.194942393374807e-18; 1.95252593852959e-16; 1.0760377910828373e-17; -2.2420844252249162e-17; -3.595619377858101e-16; 5.3700237514524436e-17; -8.905846765579657e-17; -1.0230648121063061e-17; -3.7000959460502024e-17; 3.217678467466186e-17; 4.714557915924939e-18; 1.2823845791466463e-16; -1.2431274106204747e-16; 5.295320973657044e-18; 3.170931559052515e-17; 6.372217058176089e-18; -3.857382914182745e-17; 3.165031665387273e-17; 8.850958784533327e-17; -6.236940314379065e-17; -1.2681828089802485e-16; 1.3742258439294816e-16; -1.7590165094391387e-16; -1.6211658989146877e-16; 4.4790949931244885e-17; 8.95452917022887e-17; -1.741321125928941e-17;;]), layer_3 = (weight = [2.7181582766366748e-6 -1.3764427302433345e-5 -7.314591300082909e-5 -5.309272625591204e-5 1.5295725580741986e-5 2.7776901453138152e-5 -1.3066240052190772e-5 2.864029750644178e-5 0.00011591613486534396 -0.0001474541912727534 6.183820563028362e-5 1.753638401287248e-5 1.5365385598940967e-5 -7.824248847892074e-5 -8.922799560153512e-6 -6.577192640970976e-5 -2.432046238662869e-6 -2.100809967369316e-5 -0.00010635227760640468 -2.973105426345041e-5 -0.00010291657769694416 0.00023755009363530649 4.6606584993511776e-5 -0.00016343334379480655 8.594537974203436e-7 0.00011854994421018852 5.853925932844344e-6 9.537382658253281e-6 -0.00011633183555086223 -0.0001535520985896284 0.00014066774941174813 7.370754076991637e-5; -0.00014683450385021666 0.00011144233181582179 3.7048419160753485e-5 -6.065452211444815e-5 4.2523060672435974e-5 -5.5083954377592784e-5 3.084817224555e-6 6.538680796253868e-5 0.00019472227327966513 6.555637415473387e-5 -9.014318888333505e-5 4.2879004156899286e-5 -4.877396206241444e-6 -7.840126303747869e-5 3.740806246966502e-5 6.475675368889607e-5 -7.597254110990986e-5 4.2247203582221496e-6 1.8524280365424982e-5 -4.6489742400838316e-5 -8.761075545592866e-5 8.237366606223747e-5 -1.611537513056857e-5 -5.195645311872172e-5 -6.0337577762797974e-5 -4.737369485340761e-5 0.00026095495164369227 -8.736777401312755e-6 -0.00012013489717177094 -1.3159283609668348e-5 9.894353175510954e-5 2.4765693213310157e-5; 0.00013308083591859549 -6.946863274911564e-5 7.881657917685041e-6 -7.655377109890853e-5 3.392952069284336e-5 1.7029473398119488e-6 -3.972078478333803e-6 0.00032406693801626495 -7.483321812592514e-5 -0.00018742599920493542 0.00012094637215945158 -5.431266024366416e-5 4.2093243361383344e-5 -5.8866922220980024e-5 3.583102309371285e-5 -1.2988581578022193e-5 0.00016340042068499144 0.00013919018104083676 -4.349955404300361e-5 6.668888684239102e-5 -0.00011950890027342624 -3.886770489166625e-5 2.4749803311940628e-5 6.699083180742091e-5 -1.6455850958081094e-5 -7.186444211907497e-6 -9.141503094120971e-5 0.0002752267523889201 2.5255631523248454e-5 -2.871046988125522e-5 -4.132571254863658e-5 -4.945889802306948e-5; -9.834823420723665e-5 -2.3414500066877646e-5 -0.00021584503254607065 8.583289028857168e-5 -3.5088806800644095e-5 3.931175607967876e-5 -2.2765557407270646e-5 -0.00010890962137827388 -0.00023468199204407375 -0.00014448328427724418 -7.40082642388142e-5 0.0002658071506793073 6.895816197166457e-5 0.00010961971285533414 -0.00013251121989205222 1.9509828160067818e-5 8.896830415133508e-5 -0.0001313458297609886 0.0001424108822156141 -0.00012616639567758644 -3.227867939216699e-6 0.00012028392385937526 -3.558658052688203e-5 0.0001777644110169657 -1.4574638118660768e-5 2.0387068541736583e-5 -6.398219837328314e-5 0.00012377565591842134 -8.684775373885293e-5 -8.557853626314886e-7 0.00020622037565581726 0.00016215633233323954; -5.0802295060883955e-5 1.7605296182275227e-5 -8.660935612819875e-5 -7.336801548912876e-5 8.551288725616645e-5 -0.00025757340530361655 -5.25309752785359e-5 2.40362204411694e-5 4.095667633269207e-5 5.1750493969704724e-5 5.5808579293484165e-5 0.00014649495084345182 0.0001529131458145012 -2.5455567208289346e-5 0.00014471317068714883 -0.00011555882714414758 9.512385973979874e-5 0.0001169451914964628 -7.768190165474847e-5 2.284916250832987e-5 -0.00011562230259837584 0.00012777653124690204 5.6978233135717466e-5 9.457907968940228e-5 -6.25566700702208e-5 -7.304280928760905e-5 5.165476055739488e-5 7.456660192733427e-5 -4.9748761864210315e-5 -8.014020035002191e-5 0.00012106761083746335 0.00019247286205686866; 0.00017953518073818772 0.0002114997140020076 -4.188154815300745e-5 -2.783262533147656e-5 -5.174830692657597e-5 -1.139178146657574e-5 8.235270326301328e-5 -6.65532690468281e-5 -5.582416377682586e-5 0.00017181492404823366 0.00011917514604327988 -7.358974579210692e-5 -4.203693318683076e-6 -4.224074762850546e-5 0.00018064699071738543 1.0215167837039005e-5 8.79782699634989e-5 -7.389342243504377e-5 -2.9724845429421666e-5 0.00015903575223683768 2.047313939010789e-5 -0.0001605009066984111 0.00016982755443360333 4.945599249959092e-5 7.165677635975095e-5 0.00010947670199720873 -5.036961118414171e-5 9.836733335441512e-5 7.160356000575291e-5 9.208963712490667e-5 -5.7704565900619274e-5 0.00015367894485871915; 5.6804396214051816e-5 -4.056191924414856e-5 -0.00013163242497635162 -1.3986151183280307e-5 7.72783988815263e-5 -4.6026356225354196e-5 0.00013285867512069044 -4.211346263568929e-5 0.00013114061780120185 8.513488332585073e-5 -6.617879067004497e-5 4.608246140027453e-5 -4.862958472026958e-5 1.7753413109083712e-5 9.918943591960667e-5 0.00012171226457771755 6.835813305417634e-5 0.00013593988309926056 -0.00021699903832436733 7.393274622349761e-5 7.241696052564687e-5 7.910335457031383e-5 0.0001324197748055212 7.588985814568063e-6 3.698450213608611e-5 7.263039346629834e-5 0.0001706603599324108 -4.313867052938852e-5 0.0002026860694478498 -5.742097151037442e-5 4.120804273602014e-5 3.264410601891542e-5; -5.469777674525562e-5 1.2402941552042143e-5 -8.91919385548163e-5 -2.852000802616067e-6 9.043635559553041e-6 8.283275606579459e-5 4.8610762364739795e-5 -7.516970576480437e-5 4.424167714668967e-5 1.0354052806261077e-5 0.00010046523171248943 0.00012721388562121736 -0.00012208658658428625 6.630958019295276e-5 7.069122735183291e-5 -4.538091665827148e-5 4.013072835286105e-5 5.675574944243302e-5 -7.074312229169967e-5 -6.048437493964548e-5 5.3062149577359e-5 3.2550323840919377e-6 9.571344931382292e-5 0.00023285486754966376 -9.209298654687464e-5 9.886688572359596e-5 -1.597507211491574e-5 -2.8440791037661994e-6 -7.723556841020543e-5 -0.00010246473315865221 8.412849497753601e-5 -0.00010336455083679803; -1.4919562113945119e-6 3.786761048781018e-5 2.030131695159083e-5 2.376113484155241e-5 -0.00012740298002659954 0.00014637113604059804 5.349967072782583e-5 0.00013343193681743305 -2.303896867721032e-5 0.00015473137141037546 -5.845695882504872e-5 0.00010179379573622834 -7.742305929474314e-5 -0.0001460870862070443 -0.00016346172374374847 4.7592917369402245e-5 -5.844994116393107e-5 -3.8586664188697246e-5 6.731966100000122e-5 0.00014078609642405326 -2.7155301679668842e-5 8.002360668564484e-5 3.4093214751410645e-5 -4.65761495002525e-5 3.619794920035598e-5 5.650576899591961e-5 5.0680211686480196e-5 -2.561828109952526e-5 -4.4312733691700065e-5 -0.00013135165677573242 4.334356894782013e-5 1.958497163963354e-5; 0.00021302259940729116 0.00014018792083096425 -3.634955553262696e-5 7.457847916829226e-5 -4.194831396727074e-5 -7.782262307286818e-5 -4.546200486641039e-5 -7.199284207000597e-5 2.2506207667345137e-5 0.00019906456239130222 0.000167775863726438 -3.967293648439985e-5 6.937641750352081e-7 4.59614377849612e-6 -8.502364559955148e-5 -6.228009349125641e-5 5.052780127460008e-5 2.7373261243507198e-5 -0.00020180822227540667 5.380989116691721e-5 3.850207601667696e-6 0.00012734435679466206 -7.079487747670335e-5 0.00011234185606316288 5.053136649383363e-5 -4.276716842706821e-5 4.67080521845383e-7 0.0002169782028680704 -0.00013943468272611666 -0.00013885211135185538 6.651197079359225e-6 7.377316162763913e-5; 0.00015950157980826977 6.375140369330938e-5 -4.9913900076385934e-6 3.458996584216655e-5 -0.00012995097345279953 0.00014052179326226426 0.0003022032048173231 0.00011188121575090596 4.384204807851034e-5 6.633257148480435e-5 5.3424360565102564e-5 1.9557735547852755e-5 2.028111671082526e-5 0.00025611694004313526 -3.556158694860946e-5 0.000192625202223859 -0.00018797512016333252 8.475179642831363e-5 -1.1349869375557461e-5 -0.00017142655119838709 1.3171352882485688e-5 -0.00010217918893628335 -0.00012328305306451818 -0.00012704101241267006 -6.310087187755152e-5 -0.00010207760929203472 -4.254681912441473e-5 -2.498731587563124e-5 -5.0464028711008265e-5 1.3590317073827603e-5 9.798990654220145e-5 8.18007698834087e-5; -7.33562897289923e-5 -0.00012167744491992524 0.00012063414257906411 2.3197308539664885e-5 8.830956582866654e-5 -1.2445467771204707e-5 -9.683624309709095e-6 2.9801715274942474e-5 5.571120570718352e-5 -7.35392364072473e-5 3.776692981088198e-5 1.4705268288222952e-5 1.2492647758761408e-5 -7.88184165935776e-5 -0.00012920978545255917 -7.850937006452247e-6 0.00016108513452533176 -0.00011248214789478123 -0.0002110206819702684 8.694469804365185e-5 3.227738713800835e-5 4.455707537314856e-5 9.226065091976941e-5 -8.110065894246166e-5 -8.755814408462802e-5 0.00021031721778169132 0.00019002777341708027 -2.1502831739356623e-5 0.00012898598149373646 0.00013956631525840633 3.584454904964124e-5 -0.00020603571968197778; -7.010209437912935e-5 -0.00022536444512416396 -7.30268256132199e-5 -0.00012288192729220635 -5.674721242149259e-5 -0.00010672451380856983 9.866422997102965e-5 -1.403645992586965e-5 -0.00011364376032479928 1.8176713728013106e-5 3.2318319516619554e-5 0.0001908082086617459 5.4386119688355905e-6 1.2767332099151662e-5 -2.7349782523111337e-5 2.8689808549365372e-5 -0.0001763460421910112 -6.191290222096027e-5 -0.00016948717157111323 6.622664304695292e-5 0.00027100430825039183 -5.720918843626779e-5 6.0386620122646895e-6 -7.0123677699513445e-6 0.00011281270062563871 -0.00013144895992927685 2.2783244365843978e-5 -7.685483060531676e-5 0.00011269476462867414 7.066279612167611e-6 -3.849330451094198e-5 -4.947235711488773e-5; 6.905085399338504e-5 1.241653887845127e-5 -9.187247553782967e-5 0.0001384617797826561 9.543206827938953e-6 4.514337058351992e-5 -0.00021888011463162325 9.323805067978368e-5 -9.554402028161193e-6 5.860085445746129e-5 -0.00011198069035018462 9.400836221077214e-7 -5.241579049326016e-5 5.033626518851636e-5 -5.588220585778782e-5 -9.065601546027197e-5 -0.00012704015455384455 0.00010367977745189812 0.00016243253855790504 -7.2411609166102e-6 -2.0956836239211402e-5 8.06740289350182e-5 -6.346010116104462e-5 7.360756796841967e-5 -2.5792095699590904e-5 0.00010988304063502191 0.00012545271681445907 -2.4568234154149554e-5 6.459816971607856e-6 -3.9510362627342975e-5 -7.275661403256014e-5 -2.8113348675195095e-6; -9.137746395955842e-5 4.906578020362022e-5 -8.741349314752282e-5 1.3068109055694196e-5 -7.132183976884267e-5 9.730592124453575e-5 -6.192913146169435e-5 -0.00010131899774953038 -6.061905163753104e-5 1.2435414518942981e-5 0.00010053258289170985 4.270396662812826e-5 0.00015936663099617624 6.0188798542896155e-5 -5.170628937975605e-6 -4.175810694525261e-5 -1.6002946849955724e-5 -8.433734195952447e-5 0.0001714626776991113 3.496747000079432e-5 -0.0001139104935102446 -0.00011244759674829604 -0.00020004485135379516 5.7845198043454065e-5 -0.00015938844457215155 4.8547226342439035e-5 -0.00019384266501238588 0.00010759929124086358 -0.00012227036508211957 2.3390879377785733e-5 -9.908988559088003e-6 -2.6571602702660383e-5; -0.00014111897824744952 4.060340371967055e-5 3.621617590130085e-5 -8.588257831701293e-5 -9.19208009535748e-5 8.793232929479308e-5 8.538863268500595e-5 -0.00021399948080483112 7.3510115286864e-5 -3.880531720182347e-5 3.6971358456011864e-5 9.791132940390899e-6 6.968666504422878e-5 0.0002045422102283384 -6.867915861488538e-5 -0.00010126267942081428 3.508985402464446e-5 -1.0461251334108033e-5 3.151629654627062e-5 6.162861474609698e-5 0.00011483557547495435 9.508613813255679e-5 8.945288802084295e-5 -0.00013468758468929007 7.513620450214122e-5 -7.464032886031378e-5 -0.00010506799797707682 3.5234547355740067e-5 8.621857206622639e-5 -0.000133070474005707 6.908778824896287e-5 -2.64241257199853e-5; -0.00010142721003293006 -9.064356418465165e-5 0.00011412408202515118 -0.00018349348538693823 0.00013535210309411543 -3.621006253897686e-5 2.9313089904379557e-5 0.00012140222970257649 0.00010432316339203296 0.00019622465624334937 -8.271463961216576e-6 -0.0001275595175721592 6.161094206246608e-5 0.00010408233647096086 0.0001707191651766296 3.540882534790917e-5 2.363407947624282e-5 1.9979782515215683e-5 -0.00013030860718943996 -5.025795238984413e-6 -2.827916323811705e-5 9.929987135903081e-5 7.752211531252744e-5 -4.346959104085292e-5 -5.594370013940307e-5 4.2809478323682986e-5 -4.952823729044162e-5 0.00015286133129476523 -8.636835700971378e-5 -0.0001798754863594553 -9.566490626101337e-5 -2.532480794260135e-5; -7.869796513593768e-5 3.5505938513532446e-5 -0.00010604115209322993 -3.8746875133500834e-5 1.3009845361676375e-5 -1.852546097265858e-5 -4.233960839819954e-5 -2.9030946961274435e-5 -4.108513871803495e-5 0.000168137092487731 -0.00011104134296082137 3.284051513284996e-5 0.00010971260076141946 8.063502195976016e-5 0.0001399159666568547 -2.4073622164630066e-6 4.080393068826092e-5 0.0002892584745957067 5.0824103028143586e-5 0.00026167773489826576 -0.00019712701009600485 2.7639733389813862e-5 0.00014778341596932554 4.913056932375732e-5 -1.809615764549074e-5 5.754692051661798e-5 -7.36767540268317e-5 0.00021578450127955991 1.2115069922136012e-5 -2.1805257119258514e-5 5.663255456122518e-5 9.926239022273046e-5; -0.00010599082686523518 3.78128692537585e-5 3.993486591214703e-5 5.198544515595229e-5 5.136044767285155e-5 3.587403391437031e-5 -4.271387167675045e-5 -2.3506183948410515e-5 0.0002107324302633798 9.390603138315872e-5 -5.379002755870711e-6 -0.00011097691692695566 0.00013748731491803584 -0.00015542437411197069 4.7536000624023545e-5 0.00015492519507832286 -0.00022018099350672762 0.00019984326120182333 -6.803468819197338e-6 9.352280669561979e-5 -4.77798917708414e-5 -8.004497045402719e-6 -0.00011356322154453563 -6.853570319064504e-5 -3.0359637617874795e-5 0.00010019681706042416 1.338683590875887e-6 -5.832260155868331e-5 7.021860567336351e-5 -0.00017497574533619525 -0.00010118957523074544 -4.7903321115808394e-5; 0.0001836496138187196 0.0001846808498432934 2.356456453798022e-7 4.4145568454273404e-5 3.624920084826493e-5 6.221063616089065e-5 0.0001116538604312602 0.00017643876147326856 2.5122397621588944e-6 -8.57643482684114e-5 -5.725094722015264e-5 -0.00010487956948940931 2.9966440552247376e-5 2.8248063090590872e-5 -0.00012450623959898166 -0.00018724791349972758 -3.7380358206800007e-8 -7.166245829443642e-5 8.524547395632423e-5 -9.363855694550275e-5 7.772794727339176e-5 7.625311066499727e-5 5.273082372719267e-5 -1.8722338788810436e-6 -6.930994158890546e-6 -9.664096223556442e-6 9.605432597027865e-6 -2.97452699394368e-5 -3.269156347391707e-5 -2.2555645200323134e-5 -9.434295695404752e-5 -4.64267706499823e-5; -0.00019195960084596208 -0.00018537164323186297 -0.00023666775559229742 -7.997674146588925e-5 -3.13575812409726e-5 0.00011455393069509753 -9.508322539971837e-6 -0.000107150645993333 9.49426565117576e-5 2.577420746696919e-5 2.8448805830192213e-5 -8.725323089830149e-6 4.1202022481797466e-5 -2.287757087595166e-5 0.0001255703926350362 -1.6485851741703248e-6 -6.377426070080784e-5 -3.230002147882001e-5 -0.0001752690197403156 9.615440176878309e-5 -0.00010433218012019497 -2.9538886513708224e-5 4.384310778425065e-5 8.27526837986191e-6 -0.00021931936971065008 -8.11848560200553e-5 1.959083493297522e-5 -8.458405245016331e-5 6.3940518035859715e-6 8.6655734836505e-6 -0.00018194027251718084 3.025667029452962e-5; 4.002542534088633e-5 -4.2934290314418744e-5 -4.58681310474393e-5 0.0001244185737677867 1.9768082501275235e-5 -1.1332251625444294e-5 5.082838885661436e-5 5.4918040922518377e-5 4.5537356135343805e-5 0.00014748788505037234 -3.536113893553412e-5 3.585870633194856e-5 -3.1223956676526554e-5 -9.00831977842367e-5 8.298176960032596e-5 9.14139932947247e-5 -8.210722756396133e-5 1.8313620393187986e-5 -0.0001156294996972188 -3.361496003982555e-5 0.00010919906760044284 -5.4238490912224504e-5 -2.5120748824531442e-5 2.6137270259809666e-5 -0.00010764535857653911 0.00017332913245716788 -7.380517075128142e-5 -7.8521599271897e-5 9.611090769701499e-5 3.0202775241365833e-5 0.00018404961571739882 0.00014643854644326657; -3.958508578811415e-5 1.747198247308541e-5 3.1449237112114424e-5 -5.677076306760346e-5 -0.0001094782984278446 -4.728386748909085e-5 -6.679945191582736e-5 0.00017470744377483632 -6.287432925588216e-6 -0.0002570008929165183 -4.288011597103033e-5 -0.00016051514659060412 -4.3498528712500426e-5 -0.00019744041320386244 -0.00013919576132188563 -5.070043344445028e-6 -5.940835591038775e-5 -0.0002642602904511874 -2.9188091603413967e-5 -0.00015447295855714792 0.00010149323669744125 3.092430951206156e-5 2.4159009075937405e-6 9.580663198854217e-5 6.686084260715483e-5 4.827299006998254e-5 -0.00012450871700868827 0.00011939673448929396 0.00011351956517453302 -4.495715084935474e-5 -1.079155855272039e-5 7.100347455839606e-5; 4.2454614694892504e-5 -9.166166045380589e-5 7.884163870565809e-5 -0.00020546458607915554 -3.4317299187218345e-5 9.831798260858085e-6 4.194296935545507e-5 2.2658805855631203e-5 0.00010269150744514763 2.8927865523454675e-5 0.00010723414971815191 -3.5914924856312684e-5 2.483743493010871e-5 -0.00011567405953448076 4.685056638644305e-5 -6.108054866691838e-5 -1.9519427487667746e-5 4.1428446374797894e-5 5.251723459682644e-6 -8.57392710624618e-5 5.060206832220863e-5 8.92040502638201e-5 4.043217496454013e-5 9.543384158840497e-5 -1.907562863399942e-5 0.00013887766045607634 7.818521636161502e-5 1.1498215380727402e-5 1.4248650140669751e-5 -0.00015942942763123462 7.308750583414075e-5 2.5670743079704664e-5; -3.5893567108258006e-6 -7.926646134345519e-5 8.734254885004377e-5 2.721294737076943e-5 -7.546858609183163e-5 5.184639672744748e-5 -8.838649586307448e-5 -1.7795522526088013e-5 0.00011422668836550362 0.0001390609359625062 2.4312512378124555e-5 0.0002459330244712019 -3.2487736407154605e-5 3.4708362418509944e-5 0.00017011109963297442 -7.010892653832675e-5 -0.00012172675991661067 0.00011992681180364684 0.00015153316422603446 -0.00015564145354781932 0.0001343953591096674 9.658794811931745e-5 0.0002063368411292841 9.719996529403117e-5 7.600474424197943e-5 -5.933778442321755e-5 6.431193838596834e-5 0.00020365330789009461 0.00018978745725706887 -0.00022610367517680443 -3.36042284650733e-5 0.0001293329078727921; -4.630299353907501e-5 -5.5148149655952325e-5 2.3270964632455567e-5 3.231019236677526e-5 0.0002079829138919639 -4.360300208375554e-5 4.8773086930812153e-5 -3.6780547631725364e-5 -0.00013981670763046268 -0.00012032793146958781 0.00011149295478658421 3.126426254580209e-5 8.644672746368e-6 8.959620045329684e-5 -0.0001216676535450926 0.00011254744477168875 -2.3337501076680755e-5 0.0001379189781827786 0.0002039682296553558 -5.671250237087464e-5 -1.4246057432546712e-5 3.276229854504831e-5 -1.745194622076376e-5 -0.000149796760340041 -9.578583539864407e-5 -3.5977369222609055e-5 -8.228887581667071e-5 -2.7252320976048094e-5 -7.231795443389743e-5 -0.00015078776031900897 -0.00027402467075903565 0.00023444490234664849; -8.808457955584642e-5 -0.00015131672575936458 -7.479914661363527e-5 -6.593564780761324e-5 0.00015510707139636558 0.00017721455929003806 -2.2912513026400106e-6 -2.885626186017705e-5 4.3008431481086496e-6 4.604293330938973e-5 6.30551553973312e-5 3.0934381857684686e-5 6.931021612270949e-5 -0.00011667733947380262 6.8055670004343266e-6 -5.102323798329395e-5 0.0001330430791773223 -3.5619875642999894e-5 0.00018510571367240698 -7.332530867109721e-6 -9.114958397677875e-5 -4.0152549854077354e-5 -1.0787957261903858e-5 -0.0001033328039278906 8.677935379690836e-5 -3.115900785761624e-5 6.964768958877289e-5 -9.57030310468441e-5 -7.30701244259862e-5 5.815567010892023e-6 -0.0001688817460030015 5.929480225912463e-5; -0.00021231833980108017 0.00010215875645245941 -3.274041901148397e-5 -4.1128244812521475e-5 7.290947960301745e-5 -0.0002030945937816391 8.457197381960884e-5 5.429094071461344e-5 1.8650116304478286e-6 0.00019337974354004738 6.206672968456596e-6 -5.327210910889515e-5 -6.858851284176461e-5 -2.655144217113473e-5 7.907587677086486e-6 -0.00011927625328224624 -4.6242797919849045e-6 0.0001909485987185833 -0.0001905832354181117 -0.0002028961929694419 3.211281499367681e-6 2.6578689902285547e-5 6.065076067772205e-5 -0.00012545835070466952 4.000700264316091e-5 -0.00014439339011131067 2.1388942148972966e-5 6.180982436364354e-5 6.207024543857495e-5 0.00015283819502530163 -0.00010888791748710296 -2.7513474743850774e-5; -2.9659907459040456e-5 2.8499020909315264e-5 -6.532337204587527e-5 -6.144707652308895e-5 -2.413430150225198e-5 -4.7996362927670094e-5 -0.00016772835727347924 -4.986557826666975e-5 -0.00017944851345416983 0.00010495136745706554 -0.00017332058553617377 6.069196103456064e-5 9.978286913794782e-5 -9.117233924369154e-5 -7.230332915239873e-5 4.413284920703744e-5 -0.00013348532877895618 4.637309836655161e-5 4.81924406540412e-5 2.131169901078772e-5 6.804915107752572e-5 -0.0001662648711589797 -2.0968903418159095e-5 -0.00014607784317374804 4.290876028792939e-5 -0.00011682095567264056 2.8325569355762912e-5 1.060054079973989e-5 -3.425914394935173e-5 5.531302383135222e-5 0.00017346099854878517 9.580756965990272e-5; 3.899742324739051e-6 0.00011765055299418346 -6.717913581143739e-5 4.660262703857041e-6 0.00011866629850499665 -5.8496073478301945e-5 0.000158960253458077 1.06220614101235e-5 -0.00013873594522794381 0.00010396046766925589 5.429290379777621e-5 -1.370910010211438e-5 4.397666546663538e-5 -1.1460374451979673e-5 -2.2240798870023722e-5 -0.00011366581108506444 -0.00013437383401526153 -1.824891202761033e-5 0.000106281076142642 -5.552098897953216e-5 5.564754886234432e-5 -6.742456841367925e-5 -0.0001289187138978545 2.6770031610231633e-5 -8.409172821177081e-5 0.00010000677778532934 5.72224080600584e-5 -0.00017142507655864398 0.00010914518409788575 5.6939093184502254e-5 0.00010071333147732795 5.0277510155303025e-5; -7.439707222377557e-5 -0.00019028671338904317 -6.259650943550869e-5 9.507496180728424e-5 0.00010864915567932995 3.9876153111858345e-5 9.184878037328102e-5 6.716374811500654e-5 1.1486151395245634e-5 1.3490323924513246e-5 0.00011449754130577941 4.3964775629745145e-5 -0.00015492200871679608 3.8675045304869893e-5 -6.229865355865685e-5 -1.360621261713451e-5 8.08616478184077e-5 -2.7130958171739633e-5 -7.609611019009386e-5 -0.00013389938065532262 -0.0001318755002853615 -3.2846737651681894e-5 0.00012994472673878417 8.407389579357904e-5 -2.3085431150805213e-5 0.00011894790988432553 4.646774430027068e-6 6.2887743456191475e-6 -8.165524012159309e-5 0.00020370660969771783 -0.00012776730544149557 -7.940408052065223e-6; -4.901234214720819e-5 2.8588790796319275e-5 3.7094938220078154e-5 4.4438318495493315e-5 -0.00010343562834840829 -0.00016040762065620617 -7.664141966905565e-5 -2.4551862311811172e-5 -6.7870542765301735e-6 0.00013880197721356243 3.8520265574889524e-5 0.0002115116111823312 -4.911523873978804e-5 -9.531798795741593e-5 -5.325602623578723e-5 -1.640808304309004e-5 5.082255293437935e-5 -0.00024881420185501283 -6.985138688413967e-5 0.00026013292145272185 -0.00010028733604066567 -9.619130737875367e-6 -9.080692334045285e-5 -7.097451825337982e-5 -6.130653864182889e-5 3.5088876670315017e-5 -1.086351048378516e-5 -7.053755412371544e-6 0.00013524902524715023 0.00011714802886181895 0.00013119841233184061 -8.220171375377664e-5], bias = [-9.002803412137362e-10; 7.236467060715021e-10; 1.8103734398931161e-9; 2.955111142576637e-10; 2.129911857321294e-9; 4.8410734131483365e-9; 4.680392658194427e-9; 1.2173178194191045e-9; 1.0605139689831874e-9; 1.8563035951378427e-9; 2.242493644005874e-9; 1.0645385091669622e-9; -2.2954748655008407e-9; 4.810077282144142e-10; -2.233846516343582e-9; 4.315707531648987e-10; 8.978494550864041e-10; 4.205731539586537e-9; 1.9485088234116134e-11; 7.183464322149553e-10; -4.55947281826752e-9; 2.5070848892378094e-9; -3.767227596023795e-9; 1.2828511768211886e-9; 5.395177338256656e-9; -1.1057609765259324e-9; -5.270061718489041e-10; -1.5747003865720937e-9; -2.5457938845429877e-9; 7.339907657630952e-10; 1.9828573214816282e-10; -6.076292191353722e-10;;]), layer_4 = (weight = [-0.0005678108105556385 -0.0006993777278232675 -0.000830724231103939 -0.0007055569224954025 -0.0005849552738890603 -0.0007600978534774475 -0.0005353124260821616 -0.0007686848562086851 -0.0006690202202959891 -0.0008379423429505816 -0.0006101964484753806 -0.000656469073409539 -0.0006434935133333457 -0.0006449156815602889 -0.0006089933534747448 -0.0006029284886030347 -0.0007913614924451741 -0.000674935449465918 -0.0005905326985575699 -0.0008115216357639335 -0.0007661190016072868 -0.0006789356363403519 -0.0006007377471616415 -0.0007877949287790737 -0.0006813969573304083 -0.0006447635180466162 -0.0009370561536992946 -0.0007749888742561285 -0.0005523521690760009 -0.0006957997179081457 -0.0008293514689333311 -0.0006620004071321995; 0.00021627503999493595 0.0002838247087197735 0.00020335163323807387 0.00036395740921790347 0.0003762765155882181 0.0003013405745518325 0.00014399920044847785 0.00016048554119608855 0.00031275523550882025 -2.832245395850749e-5 0.0002104900834714485 0.000272819501432717 0.00011349408143090731 0.00015627464219689953 0.00033641156913259294 0.0003007430228658964 0.00032610315668059694 0.00037112447431152763 0.0003759284556980935 0.0002115465134978329 0.00012122176695009943 6.865383052356075e-5 0.0004579311032879508 0.00022629041349831312 9.078121658425965e-5 0.00028821648569015096 0.00013540206559647916 0.00020085445184509886 0.00024132404068669504 0.00035644706741681944 7.205952341790141e-5 0.00018804813678617233], bias = [-0.0006851053482529556; 0.00023923616050095537;;])) +``` + + + + +## Visualizing the Results + + +Let us now plot the loss over time + + +```julia +fig = with_theme(theme_web()) do + fig = Figure() + ax = CairoMakie.Axis(fig[1, 1]; xlabel="Iteration", ylabel="Loss") + + lines!(ax, losses; linewidth=2, alpha=0.75) + + return fig +end +``` + + +![](1_GravitationalWaveForm-48.png) + + +Finally let us visualize the results + + +```julia +prob_nn = ODEProblem(ODE_model, u0, tspan, res.u) +soln_nn = Array(solve(prob_nn, RK4(); u0, p=res.u, saveat=tsteps, dt, adaptive=false)) +waveform_nn_trained = first(compute_waveform(dt_data, soln_nn, mass_ratio, + ode_model_params)) + +fig = with_theme(theme_web()) do + fig = Figure() + ax = CairoMakie.Axis(fig[1, 1]; xlabel="Time", ylabel="Waveform") + + l1 = lines!(ax, tsteps, waveform; linewidth=2, alpha=0.75) + s1 = scatter!(ax, tsteps, waveform; markershape=:circle, markeralpha=0.25, alpha=0.5) + + l2 = lines!(ax, tsteps, waveform_nn; linewidth=2, alpha=0.75) + s2 = scatter!(ax, tsteps, waveform_nn; markershape=:circle, markeralpha=0.25, alpha=0.5) + + l3 = lines!(ax, tsteps, waveform_nn_trained; linewidth=2, alpha=0.75) + s3 = scatter!(ax, tsteps, waveform_nn_trained; markershape=:circle, markeralpha=0.25, + alpha=0.5) + + axislegend(ax, [[l1, s1], [l2, s2], [l3, s3]], + ["Waveform Data", "Waveform Neural Net (Untrained)", "Waveform Neural Net"]; + position=:lb) + + return fig +end +``` + + +![](1_GravitationalWaveForm-50.png) + + +--- + + +*This page was generated using [Literate.jl](https://github.com/fredrikekre/Literate.jl).* + diff --git a/previews/PR467/tutorials/beginner/1_Basics.md b/previews/PR467/tutorials/beginner/1_Basics.md new file mode 100644 index 0000000000..5d2a9dcf7b --- /dev/null +++ b/previews/PR467/tutorials/beginner/1_Basics.md @@ -0,0 +1,811 @@ + + + + + +# Julia & Lux for the Uninitiated + + +This is a quick intro to [Lux](https://github.com/avik-pal/Lux.jl) loosely based on: + + +1. [PyTorch's tutorial](https://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html). +2. [Flux's tutorial](https://fluxml.ai/Flux.jl/stable/tutorials/2020-09-15-deep-learning-flux/). +3. [Flax's tutorial](https://flax.readthedocs.io/en/latest/notebooks/jax_for_the_impatient.html). + + +It introduces basic Julia programming, as well `Zygote`, a source-to-source automatic differentiation (AD) framework in Julia. We'll use these tools to build a very simple neural network. Let's start with importing `Lux.jl` + + +```julia +using Lux, Random +``` + + +Now let us control the randomness in our code using proper Pseudo Random Number Generator (PRNG) + + +```julia +rng = Random.default_rng() +Random.seed!(rng, 0) +``` + + +``` +Random.TaskLocalRNG() +``` + + + + +## Arrays + + +The starting point for all of our models is the `Array` (sometimes referred to as a `Tensor` in other frameworks). This is really just a list of numbers, which might be arranged into a shape like a square. Let's write down an array with three elements. + + +```julia +x = [1, 2, 3] +``` + + +``` +3-element Vector{Int64}: + 1 + 2 + 3 +``` + + +Here's a matrix – a square array with four elements. + + +```julia +x = [1 2; 3 4] +``` + + +``` +2×2 Matrix{Int64}: + 1 2 + 3 4 +``` + + +We often work with arrays of thousands of elements, and don't usually write them down by hand. Here's how we can create an array of 5×3 = 15 elements, each a random number from zero to one. + + +```julia +x = rand(rng, 5, 3) +``` + + +``` +5×3 Matrix{Float64}: + 0.455238 0.746943 0.193291 + 0.547642 0.746801 0.116989 + 0.773354 0.97667 0.899766 + 0.940585 0.0869468 0.422918 + 0.0296477 0.351491 0.707534 +``` + + +There's a few functions like this; try replacing `rand` with `ones`, `zeros`, or `randn`. + + +By default, Julia works stores numbers is a high-precision format called `Float64`. In ML we often don't need all those digits, and can ask Julia to work with `Float32` instead. We can even ask for more digits using `BigFloat`. + + +```julia +x = rand(BigFloat, 5, 3) +``` + + +``` +5×3 Matrix{BigFloat}: + 0.981339 0.793159 0.459019 + 0.043883 0.624384 0.56055 + 0.164786 0.524008 0.0355555 + 0.414769 0.577181 0.621958 + 0.00823197 0.30215 0.655881 +``` + + +```julia +x = rand(Float32, 5, 3) +``` + + +``` +5×3 Matrix{Float32}: + 0.567794 0.369178 0.342539 + 0.0985227 0.201145 0.587206 + 0.776598 0.148248 0.0851708 + 0.723731 0.0770206 0.839303 + 0.404728 0.230954 0.679087 +``` + + +We can ask the array how many elements it has. + + +```julia +length(x) +``` + + +``` +15 +``` + + +Or, more specifically, what size it has. + + +```julia +size(x) +``` + + +``` +(5, 3) +``` + + +We sometimes want to see some elements of the array on their own. + + +```julia +x +``` + + +``` +5×3 Matrix{Float32}: + 0.567794 0.369178 0.342539 + 0.0985227 0.201145 0.587206 + 0.776598 0.148248 0.0851708 + 0.723731 0.0770206 0.839303 + 0.404728 0.230954 0.679087 +``` + + +```julia +x[2, 3] +``` + + +``` +0.58720636f0 +``` + + +This means get the second row and the third column. We can also get every row of the third column. + + +```julia +x[:, 3] +``` + + +``` +5-element Vector{Float32}: + 0.34253937 + 0.58720636 + 0.085170805 + 0.8393034 + 0.67908657 +``` + + +We can add arrays, and subtract them, which adds or subtracts each element of the array. + + +```julia +x + x +``` + + +``` +5×3 Matrix{Float32}: + 1.13559 0.738356 0.685079 + 0.197045 0.40229 1.17441 + 1.5532 0.296496 0.170342 + 1.44746 0.154041 1.67861 + 0.809456 0.461908 1.35817 +``` + + +```julia +x - x +``` + + +``` +5×3 Matrix{Float32}: + 0.0 0.0 0.0 + 0.0 0.0 0.0 + 0.0 0.0 0.0 + 0.0 0.0 0.0 + 0.0 0.0 0.0 +``` + + +Julia supports a feature called *broadcasting*, using the `.` syntax. This tiles small arrays (or single numbers) to fill bigger ones. + + +```julia +x .+ 1 +``` + + +``` +5×3 Matrix{Float32}: + 1.56779 1.36918 1.34254 + 1.09852 1.20114 1.58721 + 1.7766 1.14825 1.08517 + 1.72373 1.07702 1.8393 + 1.40473 1.23095 1.67909 +``` + + +We can see Julia tile the column vector `1:5` across all rows of the larger array. + + +```julia +zeros(5, 5) .+ (1:5) +``` + + +``` +5×5 Matrix{Float64}: + 1.0 1.0 1.0 1.0 1.0 + 2.0 2.0 2.0 2.0 2.0 + 3.0 3.0 3.0 3.0 3.0 + 4.0 4.0 4.0 4.0 4.0 + 5.0 5.0 5.0 5.0 5.0 +``` + + +The x' syntax is used to transpose a column `1:5` into an equivalent row, and Julia will tile that across columns. + + +```julia +zeros(5, 5) .+ (1:5)' +``` + + +``` +5×5 Matrix{Float64}: + 1.0 2.0 3.0 4.0 5.0 + 1.0 2.0 3.0 4.0 5.0 + 1.0 2.0 3.0 4.0 5.0 + 1.0 2.0 3.0 4.0 5.0 + 1.0 2.0 3.0 4.0 5.0 +``` + + +We can use this to make a times table. + + +```julia +(1:5) .* (1:5)' +``` + + +``` +5×5 Matrix{Int64}: + 1 2 3 4 5 + 2 4 6 8 10 + 3 6 9 12 15 + 4 8 12 16 20 + 5 10 15 20 25 +``` + + +Finally, and importantly for machine learning, we can conveniently do things like matrix multiply. + + +```julia +W = randn(5, 10) +x = rand(10) +W * x +``` + + +``` +5-element Vector{Float64}: + 1.2197981041108443 + -2.62625877100596 + -2.8573820474674845 + -2.4319346874291314 + 1.0108668577150213 +``` + + +Julia's arrays are very powerful, and you can learn more about what they can do [here](https://docs.julialang.org/en/v1/manual/arrays/). + + + + +### CUDA Arrays + + +CUDA functionality is provided separately by the [CUDA.jl package](https://github.com/JuliaGPU/CUDA.jl). If you have a GPU and LuxCUDA is installed, Lux will provide CUDA capabilities. For additional details on backends see the manual section. + + +You can manually add `CUDA`. Once CUDA is loaded you can move any array to the GPU with the `cu` function (or the `gpu` function exported by `Lux``), and it supports all of the above operations with the same syntax. + + +```julia +using LuxCUDA +if LuxCUDA.functional() + x_cu = cu(rand(5, 3)) + @show x_cu +end +``` + + +``` +5×3 CUDA.CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}: + 0.156884 0.0477006 0.936583 + 0.223491 0.00936433 0.0797554 + 0.798997 0.531904 0.696969 + 0.467399 0.754429 0.247236 + 0.24153 0.710188 0.80918 +``` + + + + +## (Im)mutability + + +Lux as you might have read is [Immutable by convention](http://lux.csail.mit.edu/dev/introduction/overview/#Design-Principles) which means that the core library is built without any form of mutation and all functions are pure. However, we don't enforce it in any form. We do **strongly recommend** that users extending this framework for their respective applications don't mutate their arrays. + + +```julia +x = reshape(1:8, 2, 4) +``` + + +``` +2×4 reshape(::UnitRange{Int64}, 2, 4) with eltype Int64: + 1 3 5 7 + 2 4 6 8 +``` + + +To update this array, we should first copy the array. + + +```julia +x_copy = copy(x) +view(x_copy, :, 1) .= 0 + +println("Original Array ", x) +println("Mutated Array ", x_copy) +``` + + +``` +Original Array [1 3 5 7; 2 4 6 8] +Mutated Array [0 3 5 7; 0 4 6 8] + +``` + + +Note that our current default AD engine (Zygote) is unable to differentiate through this mutation, however, for these specialized cases it is quite trivial to write custom backward passes. (This problem will be fixed once we move towards Enzyme.jl) + + + + +## Managing Randomness + + +We rely on the Julia StdLib `Random` for managing the randomness in our execution. First, we create an PRNG (pseudorandom number generator) and seed it. + + +```julia +rng = Random.default_rng() # Creates a Xoshiro PRNG +Random.seed!(rng, 0) +``` + + +``` +Random.TaskLocalRNG() +``` + + +If we call any function that relies on `rng` and uses it via `randn`, `rand`, etc. `rng` will be mutated. As we have already established we care a lot about immutability, hence we should use `Lux.replicate` on PRNGs before using them. + + +First, let us run a random number generator 3 times with the `replicate`d rng. + + +```julia +for i in 1:3 + println("Iteration $i ", rand(Lux.replicate(rng), 10)) +end +``` + + +``` +Iteration 1 [0.4552384158732863, 0.5476424498276177, 0.7733535276924052, 0.9405848223512736, 0.02964765308691042, 0.74694291453392, 0.7468008914093891, 0.9766699015845924, 0.08694684883050086, 0.35149138733595564] +Iteration 2 [0.4552384158732863, 0.5476424498276177, 0.7733535276924052, 0.9405848223512736, 0.02964765308691042, 0.74694291453392, 0.7468008914093891, 0.9766699015845924, 0.08694684883050086, 0.35149138733595564] +Iteration 3 [0.4552384158732863, 0.5476424498276177, 0.7733535276924052, 0.9405848223512736, 0.02964765308691042, 0.74694291453392, 0.7468008914093891, 0.9766699015845924, 0.08694684883050086, 0.35149138733595564] + +``` + + +As expected we get the same output. We can remove the `replicate` call and we will get different outputs. + + +```julia +for i in 1:3 + println("Iteration $i ", rand(rng, 10)) +end +``` + + +``` +Iteration 1 [0.4552384158732863, 0.5476424498276177, 0.7733535276924052, 0.9405848223512736, 0.02964765308691042, 0.74694291453392, 0.7468008914093891, 0.9766699015845924, 0.08694684883050086, 0.35149138733595564] +Iteration 2 [0.018743665453639813, 0.8601828553599953, 0.6556360448565952, 0.7746656838366666, 0.7817315740767116, 0.5553797706980106, 0.1261990389976131, 0.4488101521328277, 0.624383955429775, 0.05657739601024536] +Iteration 3 [0.19597391412112541, 0.6830945313415872, 0.6776220912718907, 0.6456416023530093, 0.6340362477836592, 0.5595843665394066, 0.5675557670686644, 0.34351700231383653, 0.7237308297251812, 0.3691778381831775] + +``` + + + + +## Automatic Differentiation + + +Julia has quite a few (maybe too many) AD tools. For the purpose of this tutorial, we will use: + + +1. [ForwardDiff.jl](https://github.com/JuliaDiff/ForwardDiff.jl) – For Jacobian-Vector Product (JVP) +2. [Zygote.jl](https://github.com/FluxML/Zygote.jl) – For Vector-Jacobian Product (VJP) + + +*Slight Detour*: We have had several questions regarding if we will be considering any other AD system for the reverse-diff backend. For now we will stick to Zygote.jl, however once we have tested Lux extensively with [Enzyme.jl](https://github.com/EnzymeAD/Enzyme.jl), we will make the switch. + + +Even though, theoretically, a VJP (Vector-Jacobian product - reverse autodiff) and a JVP (Jacobian-Vector product - forward-mode autodiff) are similar—they compute a product of a Jacobian and a vector—they differ by the computational complexity of the operation. In short, when you have a large number of parameters (hence a wide matrix), a JVP is less efficient computationally than a VJP, and, conversely, a JVP is more efficient when the Jacobian matrix is a tall matrix. + + +```julia +using ComponentArrays, ForwardDiff, Zygote +``` + + + + +### Gradients + + +For our first example, consider a simple function computing $f(x) = \frac{1}{2}x^T x$, where $\nabla f(x) = x$ + + +```julia +f(x) = x' * x / 2 +∇f(x) = x # `∇` can be typed as `\nabla` +v = randn(rng, Float32, 4) +``` + + +``` +4-element Vector{Float32}: + -0.4051151 + -0.4593922 + 0.92155594 + 1.1871622 +``` + + +Let's use AbstractDifferentiation and Zygote to compute the gradients. + + +```julia +println("Actual Gradient: ", ∇f(v)) +println("Computed Gradient via Reverse Mode AD (Zygote): ", only(Zygote.gradient(f, v))) +println("Computed Gradient via Forward Mode AD (ForwardDiff): ", ForwardDiff.gradient(f, v)) +``` + + +``` +Actual Gradient: Float32[-0.4051151, -0.4593922, 0.92155594, 1.1871622] +Computed Gradient via Reverse Mode AD (Zygote): Float32[-0.4051151, -0.4593922, 0.92155594, 1.1871622] +Computed Gradient via Forward Mode AD (ForwardDiff): Float32[-0.4051151, -0.4593922, 0.92155594, 1.1871622] + +``` + + +Note that `AD.gradient` will only work for scalar valued outputs. + + + + +### Jacobian-Vector Product + + +I will defer the discussion on forward-mode AD to [https://book.sciml.ai/notes/08/](https://book.sciml.ai/notes/08/). Here let us just look at a mini example on how to use it. + + +```julia +f(x) = x .* x ./ 2 +x = randn(rng, Float32, 5) +v = ones(Float32, 5) +``` + + +``` +5-element Vector{Float32}: + 1.0 + 1.0 + 1.0 + 1.0 + 1.0 +``` + + +Construct the pushforward function. We will write out the function here but in practice we recommend using [SparseDiffTools.auto_jacvec](https://docs.sciml.ai/SparseDiffTools/stable/#Jacobian-Vector-and-Hessian-Vector-Products)! + + +First we need to create a Tag for ForwardDiff. It is enough to know that this is something that you must do. For more details, see the [ForwardDiff Documentation](https://juliadiff.org/ForwardDiff.jl/dev/user/advanced/#Custom-tags-and-tag-checking)! + + +```julia +struct TestTag end +``` + + +Going in the details of what is function is doing is beyond the scope of this tutorial. But in short, it is constructing a new Dual Vector with the partials set to the input to the pushforward function. When this is propagated through the original function we get the value and the jvp + + +```julia +function pushforward_forwarddiff(f, x) + T = eltype(x) + function pushforward(v) + v_ = reshape(v, axes(x)) + y = ForwardDiff.Dual{ + ForwardDiff.Tag{TestTag, T}, + T, + 1, + }.(x, ForwardDiff.Partials.(tuple.(v_))) + res = vec(f(y)) + return ForwardDiff.value.(res), vec(ForwardDiff.partials.(res, 1)) + end + return pushforward +end + +pf_f = pushforward_forwarddiff(f, x) +``` + + +``` +(::Main.var"##292".var"#pushforward#1"{typeof(Main.var"##292".f), Vector{Float32}, DataType}) (generic function with 1 method) +``` + + +Compute the jvp. + + +```julia +val, jvp = pf_f(v) +println("Computed Value: f(", x, ") = ", val) +println("JVP: ", jvp[1]) +``` + + +``` +Computed Value: f(Float32[-0.877497, 1.1953009, -0.057005208, 0.25055695, 0.09351656]) = Float32[0.3850005, 0.71437216, 0.0016247969, 0.031389393, 0.0043726736] +JVP: -0.877497 + +``` + + + + +### Vector-Jacobian Product + + +Using the same function and inputs, let us compute the VJP. + + +```julia +val, pb_f = Zygote.pullback(f, x) +``` + + +``` +(Float32[0.3850005, 0.71437216, 0.0016247969, 0.031389393, 0.0043726736], Zygote.var"#75#76"{Zygote.Pullback{Tuple{typeof(Main.var"##292".f), Vector{Float32}}, Tuple{Zygote.Pullback{Tuple{typeof(Base.Broadcast.materialize), Vector{Float32}}, Tuple{}}, Zygote.var"#3802#back#1205"{Zygote.var"#1201#1204"{Vector{Float32}, Vector{Float32}}}, Zygote.var"#3866#back#1231"{Zygote.ZBack{ChainRules.var"#slash_pullback_scalar#1560"{Vector{Float32}, Int64}}}}}}(∂(f))) +``` + + +Compute the vjp. + + +```julia +vjp = only(pb_f(v)) +println("Computed Value: f(", x, ") = ", val) +println("VJP: ", vjp[1]) +``` + + +``` +Computed Value: f(Float32[-0.877497, 1.1953009, -0.057005208, 0.25055695, 0.09351656]) = Float32[0.3850005, 0.71437216, 0.0016247969, 0.031389393, 0.0043726736] +VJP: -0.877497 + +``` + + + + +## Linear Regression + + +Finally, now let us consider a linear regression problem. From a set of data-points $\{ (x_i, y_i), i \in \{ 1, \dots, k \}, x_i \in \mathbb{R}^n, y_i \in \mathbb{R}^m \}$, we try to find a set of parameters $W$ and $b$, s.t. $f_{W,b}(x) = Wx + b$, which minimizes the mean squared error: + + +$$ +L(W, b) \longrightarrow \sum_{i = 1}^{k} \frac{1}{2} \| y_i - f_{W,b}(x_i) \|_2^2 +$$ + + +We can write `f` from scratch, but to demonstrate `Lux`, let us use the `Dense` layer. + + +```julia +model = Dense(10 => 5) + +rng = Random.default_rng() +Random.seed!(rng, 0) +``` + + +``` +Random.TaskLocalRNG() +``` + + +Let us initialize the parameters and states (in this case it is empty) for the model. + + +```julia +ps, st = Lux.setup(rng, model) +ps = ps |> ComponentArray +``` + + +``` +ComponentVector{Float32}(weight = Float32[-0.5583162 0.3457679 0.50863314 0.60294497 0.23095794 0.16602759 5.5791984f-6 0.61324424 -0.35419345 0.039559156; -0.05661944 -0.4899126 0.31236076 0.47100115 -0.5062956 -0.20445547 -0.03762182 0.5370978 0.22614014 0.27704597; 0.5198015 0.55730057 -0.34535396 -0.21587563 -0.12729146 -0.51019937 0.46597028 0.2918885 0.20849374 -0.4068233; 0.06026341 -0.11202827 0.31218112 0.14536527 -0.3413506 0.40088427 -0.48716235 -0.15096173 0.42526972 -0.3576447; 0.23414856 -0.5949539 -0.26137677 0.21756552 0.34443143 0.25046515 -0.049256783 -0.48404032 0.08254115 -0.5224755], bias = Float32[0.0; 0.0; 0.0; 0.0; 0.0;;]) +``` + + +Set problem dimensions. + + +```julia +n_samples = 20 +x_dim = 10 +y_dim = 5 +``` + + +``` +5 +``` + + +Generate random ground truth W and b. + + +```julia +W = randn(rng, Float32, y_dim, x_dim) +b = randn(rng, Float32, y_dim) +``` + + +``` +5-element Vector{Float32}: + 0.68468636 + -0.57578707 + 0.0594993 + -0.9436797 + 1.5164032 +``` + + +Generate samples with additional noise. + + +```julia +x_samples = randn(rng, Float32, x_dim, n_samples) +y_samples = W * x_samples .+ b .+ 0.01f0 .* randn(rng, Float32, y_dim, n_samples) +println("x shape: ", size(x_samples), "; y shape: ", size(y_samples)) +``` + + +``` +x shape: (10, 20); y shape: (5, 20) + +``` + + +For updating our parameters let's use [Optimisers.jl](https://github.com/FluxML/Optimisers.jl). We will use Stochastic Gradient Descent (SGD) with a learning rate of `0.01`. + + +```julia +using Optimisers + +opt = Optimisers.Descent(0.01f0) +``` + + +``` +Descent(0.01f0) +``` + + +Initialize the initial state of the optimiser + + +```julia +opt_state = Optimisers.setup(opt, ps) +``` + + +``` +Leaf(Descent(0.01), nothing) +``` + + +Define the loss function + + +```julia +mse(model, ps, st, X, y) = sum(abs2, model(X, ps, st)[1] .- y) +mse(weight, bias, X, y) = sum(abs2, weight * X .+ bias .- y) +loss_function(ps, X, y) = mse(model, ps, st, X, y) + +println("Loss Value with ground true parameters: ", mse(W, b, x_samples, y_samples)) + +for i in 1:100 + # In actual code, don't use globals. But here I will simply for the sake of + # demonstration + global ps, st, opt_state + # Compute the gradient + gs = gradient(loss_function, ps, x_samples, y_samples)[1] + # Update model parameters + opt_state, ps = Optimisers.update(opt_state, ps, gs) + if i % 10 == 1 || i == 100 + println("Loss Value after $i iterations: ", + mse(model, ps, st, x_samples, y_samples)) + end +end +``` + + +``` +Loss Value with ground true parameters: 0.009175307 +Loss Value after 1 iterations: 165.57005 +Loss Value after 11 iterations: 4.351237 +Loss Value after 21 iterations: 0.6856849 +Loss Value after 31 iterations: 0.15421417 +Loss Value after 41 iterations: 0.041469414 +Loss Value after 51 iterations: 0.014032223 +Loss Value after 61 iterations: 0.006883738 +Loss Value after 71 iterations: 0.004938521 +Loss Value after 81 iterations: 0.004391277 +Loss Value after 91 iterations: 0.0042331247 +Loss Value after 100 iterations: 0.0041888584 + +``` + + +--- + + +*This page was generated using [Literate.jl](https://github.com/fredrikekre/Literate.jl).* + diff --git a/previews/PR467/tutorials/beginner/2_PolynomialFitting-12.png b/previews/PR467/tutorials/beginner/2_PolynomialFitting-12.png new file mode 100644 index 0000000000000000000000000000000000000000..a58322afa2ec243e49116a482cda9e6b9eada1e6 GIT binary patch literal 29171 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