fix: test and docs fixes

Author: MartinuzziFrancesco

docs/src/tutorials/scratch.md

@@ -56,7 +56,7 @@ ps_s, st_s = setup(rng, esn_scratch)
 rng = MersenneTwister(17)
 ps, st = setup(rng, esn)
 
-ps_s.layer_1.input_matrix == ps.cell.input_matrix
+ps_s.layer_1.input_matrix == ps.reservoir.input_matrix
 ```
 
 Both the models can be trained using [`train!`](@ref), and predictions can be

ext/RCCellularAutomataExt.jl

@@ -30,10 +30,10 @@ function encoding(rm::RandomMaps, input_vector, tot_encoded_vector)
 end
 
 function single_encoding(input_vector, encoded_vector, map)
-    @assert length(map) == length(input_vector) """
-        RandomMaps mismatch: map length = $(length(map)) but input length = $(length(input_vector)).
-        (Build RandomMaps with in_dims = size(input, 1) used at training time.)
-        """
+    @assert length(map)==length(input_vector) """
+      RandomMaps mismatch: map length = $(length(map)) but input length = $(length(input_vector)).
+      (Build RandomMaps with in_dims = size(input, 1) used at training time.)
+      """
     new_enc_vec = copy(encoded_vector)
 
     for i in 1:size(input_vector, 1)

ext/RCLIBSVMExt.jl

@@ -7,7 +7,7 @@ import ReservoirComputing: train
 
 function train(svr::LIBSVM.AbstractSVR,
         states::AbstractArray, target::AbstractArray)
-    @assert size(states, 2) == size(target, 2) "states and target must share columns."
+    @assert size(states, 2)==size(target, 2) "states and target must share columns."
     perm_states = permutedims(states)
     size_target = size(target, 1)
 

ext/RCMLJLinearModelsExt.jl

@@ -5,7 +5,7 @@ using MLJLinearModels
 function ReservoirComputing.train(regressor::MLJLinearModels.GeneralizedLinearRegression,
         states::AbstractMatrix{<:Real}, target::AbstractMatrix{<:Real};
         kwargs...)
-    @assert size(states, 2) == size(target, 2) "states and target must share the same number of columns."
+    @assert size(states, 2)==size(target, 2) "states and target must share the same number of columns."
 
     if regressor.fit_intercept
         throw(ArgumentError("fit_intercept=true not supported here. \

src/inits/esn_inits.jl

@@ -86,7 +86,7 @@ end
 function apply_scale!(input_matrix::AbstractArray,
         scaling::Tuple{<:Number, <:Number}, ::Type{T}) where {T}
     lower, upper = T(scaling[1]), T(scaling[2])
-    @assert lower < upper "lower < upper required"
+    @assert lower<upper "lower < upper required"
     scale = upper - lower
     @. input_matrix = input_matrix * scale + lower
     return input_matrix
@@ -95,7 +95,7 @@ end
 function apply_scale!(input_matrix::AbstractMatrix,
         scaling::AbstractVector, ::Type{T}) where {T <: Number}
     ncols = size(input_matrix, 2)
-    @assert length(scaling) == ncols "need one scaling per column"
+    @assert length(scaling)==ncols "need one scaling per column"
     for (idx, col) in enumerate(eachcol(input_matrix))
         apply_scale!(col, scaling[idx], T)
     end
@@ -2020,9 +2020,9 @@ function block_diagonal(rng::AbstractRNG, ::Type{T}, dims::Integer...;
         \n"
     end
     weights = isa(weight, AbstractVector) ? T.(weight) : fill(T(weight), num_blocks)
-    @assert length(weights) == num_blocks "
-        weight vector must have length = number of blocks
-    "
+    @assert length(weights)==num_blocks "
+      weight vector must have length = number of blocks
+  "
     reservoir_matrix = DeviceAgnostic.zeros(rng, T, n_rows, n_cols)
     for block in 1:num_blocks
         row_start = (block - 1) * block_size + 1

src/layers/basic.jl

@@ -44,7 +44,7 @@ before this layer (logically inserting a [`Collect`](@ref) right before it).
 
 - In ESN workflows, readout weights are typically replaced via ridge regression in
   [`train!`](@ref). Therefore, how `LinearReadout` gets initialized is of no consequence.
-  Additionally, the dimesions will also not be taken into account, as [`train!`](@ref)
+  Additionally, the dimensions will also not be taken into account, as [`train!`](@ref)
   will replace the weights.
 - If you set `include_collect=false`, make sure a [`Collect`](@ref) appears earlier in the chain.
   Otherwise training may operate on the post-readout signal,
@@ -60,7 +60,8 @@ before this layer (logically inserting a [`Collect`](@ref) right before it).
     include_collect <: StaticBool
 end
 
-function LinearReadout(mapping::Pair{<:IntegerType, <:IntegerType}, activation = identity; kwargs...)
+function LinearReadout(
+        mapping::Pair{<:IntegerType, <:IntegerType}, activation = identity; kwargs...)
     return LinearReadout(first(mapping), last(mapping), activation; kwargs...)
 end
 

src/layers/lux_layers.jl

@@ -11,7 +11,7 @@ Base.show(io::IO, wf::WrappedFunction) = print(io, "WrappedFunction(", wf.func,
 @doc raw"""
     StatefulLayer(cell::AbstractReservoirRecurrentCell)
 
-A lightweight wrapper that makes a recurrent cell carry its imput state to the
+A lightweight wrapper that makes a recurrent cell carry its input state to the
 next step.
 
 ## Arguments

src/predict.jl

@@ -60,7 +60,7 @@ end
 
 function predict(rc::AbstractLuxLayer, data::AbstractMatrix, ps, st)
     T = size(data, 2)
-    @assert T ≥ 1 "data must have at least one time step (columns)."
+    @assert T≥1 "data must have at least one time step (columns)."
 
     y1, st = apply(rc, data[:, 1], ps, st)
     Y = similar(y1, size(y1, 1), T)

src/reservoircomputer.jl

@@ -29,7 +29,8 @@ features, and install trained readout weights.
 - `(y, st′)` where `y` is the readout output and `st′` contains the updated
   states of the reservoir, modifiers, and readout.
 """
-@concrete struct ReservoirComputer <: AbstractReservoirComputer{(:reservoir, :states_modifiers, :readout)}
+@concrete struct ReservoirComputer <:
+                 AbstractReservoirComputer{(:reservoir, :states_modifiers, :readout)}
     reservoir::Any
     states_modifiers::Any
     readout::Any
@@ -72,7 +73,8 @@ function (rc::AbstractReservoirComputer)(inp, ps, st)
     return out, merge(new_st, (readout = st_ro,))
 end
 
-function collectstates(rc::AbstractReservoirComputer, data::AbstractMatrix, ps, st::NamedTuple)
+function collectstates(
+        rc::AbstractReservoirComputer, data::AbstractMatrix, ps, st::NamedTuple)
     newst = st
     collected = Any[]
     for inp in eachcol(data)
@@ -130,7 +132,8 @@ function is provided, it is called to create a new initial hidden state.
   Same as above, but also returns the unchanged `ps` for convenience.
 
 """
-function resetcarry!(rng::AbstractRNG, rc::AbstractReservoirComputer, st; init_carry = nothing)
+function resetcarry!(
+        rng::AbstractRNG, rc::AbstractReservoirComputer, st; init_carry = nothing)
     carry = get(st.reservoir, :carry, nothing)
     if carry === nothing
         outd = rc.reservoir.cell.out_dims

src/states.jl

@@ -1,6 +1,7 @@
 
-@inline function _apply_tomatrix(states_mod::F, states::AbstractMatrix) where {F <:
-                                                                               Function}
+@inline function _apply_tomatrix(
+        states_mod::F, states::AbstractMatrix) where {F <:
+                                                      Function}
     cols = axes(states, 2)
     states_1 = states_mod(states[:, first(cols)])
     new_states = similar(states_1, length(states_1), length(cols))
@@ -54,11 +55,12 @@ point with the input that it receives.
 esn = ReservoirChain(
     Extend(
         StatefulLayer(
-        ESNCell(3 => 300; init_reservoir = rand_sparse(; radius = 1.2, sparsity = 6/300))
+        ESNCell(
+        3 => 300; init_reservoir = rand_sparse(; radius = 1.2, sparsity = 6 / 300))
     )
     ),
     NLAT2(),
-    LinearReadout(300+3 => 3)
+    LinearReadout(300 + 3 => 3)
 )
 ```