fix docstring, up flux and version

Project.toml

@@ -1,13 +1,13 @@
 name = "RecurrentLayers"
 uuid = "78449bcf-6750-4b78-9e82-63d4a1ccdf8c"
 authors = ["Francesco Martinuzzi"]
-version = "0.1.5"
+version = "0.2.0"
 
 [deps]
 Flux = "587475ba-b771-5e3f-ad9e-33799f191a9c"
 
 [compat]
-Flux = "0.14, 0.15"
+Flux = "0.16"
 julia = "1.10"
 
 [extras]

docs/pages.jl

@@ -2,7 +2,7 @@ pages=[
         "Home" => "index.md",
         "API Documentation" => [
             "Cells" => "api/cells.md",
-            "Cell Wrappers" => "api/wrappers.md",
+            "Layers" => "api/layers.md",
         ],
         "Roadmap" => "roadmap.md"
     ]

src/fastrnn_cell.jl

@@ -37,18 +37,19 @@ h_t &= \alpha \tilde{h}_t + \beta h_{t-1}
 
 # Forward
 
-    fastrnncell(inp, [state])
-
-The arguments of the forward pass are:
+    fastrnncell(inp, state)
+    fastrnncell(inp)
 
+## Arguments
 - `inp`: The input to the fastrnncell. It should be a vector of size `input_size`
   or a matrix of size `input_size x batch_size`.
 - `state`: The hidden state of the FastRNN. It should be a vector of size
   `hidden_size` or a matrix of size `hidden_size x batch_size`.
   If not provided, it is assumed to be a vector of zeros.
 
-Returns a tuple `(output, state)`, where both elements are given by the updated state `new_state`, 
-a tensor of size `hidden_size` or `hidden_size x batch_size`.
+## Returns
+- A tuple `(output, state)`, where both elements are given by the updated state `new_state`, 
+  a tensor of size `hidden_size` or `hidden_size x batch_size`.
 """
 function FastRNNCell((input_size, hidden_size)::Pair, activation=tanh_fast;
     init_kernel = glorot_uniform,
@@ -113,17 +114,18 @@ h_t &= \alpha \tilde{h}_t + \beta h_{t-1}
 
 # Forward
 
-    fastrnn(inp, [state])
-
-The arguments of the forward pass are:
+    fastrnn(inp, state)
+    fastrnn(inp)
 
+## Arguments
 - `inp`: The input to the fastrnn. It should be a vector of size `input_size x len`
   or a matrix of size `input_size x len x batch_size`.
 - `state`: The hidden state of the FastRNN. If given, it is a vector of size
   `hidden_size` or a matrix of size `hidden_size x batch_size`.
   If not provided, it is assumed to be a vector of zeros.
 
-Returns new hidden states `new_states` as an array of size `hidden_size x len x batch_size`.
+## Returns
+- New hidden states `new_states` as an array of size `hidden_size x len x batch_size`.
 """
 function FastRNN((input_size, hidden_size)::Pair, activation = tanh_fast;
     kwargs...)
@@ -176,18 +178,20 @@ h_t &= \big((\zeta (1 - z_t) + \nu) \odot \tilde{h}_t\big) + z_t \odot h_{t-1}
 
 # Forward
 
-    fastgrnncell(inp, [state])
+    fastgrnncell(inp, state)
+    fastgrnncell(inp)
 
-The arguments of the forward pass are:
+## Arguments
 
 - `inp`: The input to the fastgrnncell. It should be a vector of size `input_size`
   or a matrix of size `input_size x batch_size`.
 - `state`: The hidden state of the FastGRNN. It should be a vector of size
   `hidden_size` or a matrix of size `hidden_size x batch_size`.
   If not provided, it is assumed to be a vector of zeros.
 
-Returns a tuple `(output, state)`, where both elements are given by the updated state `new_state`, 
-a tensor of size `hidden_size` or `hidden_size x batch_size`.
+## Returns
+- A tuple `(output, state)`, where both elements are given by the updated state `new_state`, 
+  a tensor of size `hidden_size` or `hidden_size x batch_size`.
 """
 function FastGRNNCell((input_size, hidden_size)::Pair, activation=tanh_fast;
     init_kernel = glorot_uniform,
@@ -257,18 +261,19 @@ h_t &= \big((\zeta (1 - z_t) + \nu) \odot \tilde{h}_t\big) + z_t \odot h_{t-1}
 
 # Forward
 
-    fastgrnn(inp, [state])
+    fastgrnn(inp, state)
+    fastgrnn(inp)
 
-The arguments of the forward pass are:
+## Arguments
 
 - `inp`: The input to the fastgrnn. It should be a vector of size `input_size`
   or a matrix of size `input_size x batch_size`.
 - `state`: The hidden state of the FastGRNN. It should be a vector of size
   `hidden_size` or a matrix of size `hidden_size x batch_size`.
   If not provided, it is assumed to be a vector of zeros.
 
-Returns a tuple `(output, state)`, where both elements are given by the updated state `new_state`, 
-a tensor of size `hidden_size` or `hidden_size x batch_size`.
+## Returns
+- New hidden states `new_states` as an array of size `hidden_size x len x batch_size`.
 """
 function FastGRNN((input_size, hidden_size)::Pair, activation = tanh_fast;
     kwargs...)

src/indrnn_cell.jl

@@ -33,18 +33,19 @@ See [`IndRNN`](@ref) for a layer that processes entire sequences.
 
 # Forward
 
-    indrnncell(inp, [state])
-
-The arguments of the forward pass are:
+    indrnncell(inp, state)
+    indrnncell(inp)
 
+## Arguments
 - `inp`: The input to the indrnncell. It should be a vector of size `input_size`
   or a matrix of size `input_size x batch_size`.
 - `state`: The hidden state of the IndRNNCell. It should be a vector of size
   `hidden_size` or a matrix of size `hidden_size x batch_size`.
   If not provided, it is assumed to be a vector of zeros.
 
-Returns a tuple `(output, state)`, where both elements are given by the updated state `new_state`, 
-a tensor of size `hidden_size` or `hidden_size x batch_size`.
+## Returns
+- A tuple `(output, state)`, where both elements are given by the updated state `new_state`, 
+  a tensor of size `hidden_size` or `hidden_size x batch_size`.
 """
 function IndRNNCell((input_size, hidden_size)::Pair, σ=relu;
     init_kernel = glorot_uniform,
@@ -96,17 +97,18 @@ See [`IndRNNCell`](@ref) for a layer that processes a single sequence.
 ```
 # Forward
 
-    indrnn(inp, [state])
-
-The arguments of the forward pass are:
+    indrnn(inp, state)
+    indrnn(inp)
 
+## Arguments
 - `inp`: The input to the indrnn. It should be a vector of size `input_size x len`
   or a matrix of size `input_size x len x batch_size`.
 - `state`: The hidden state of the IndRNN. If given, it is a vector of size
   `hidden_size` or a matrix of size `hidden_size x batch_size`.
   If not provided, it is assumed to be a vector of zeros.
 
-Returns new hidden states `new_states` as an array of size `hidden_size x len x batch_size`.
+## Returns
+- New hidden states `new_states` as an array of size `hidden_size x len x batch_size`.
 """
 function IndRNN((input_size, hidden_size)::Pair, σ = tanh; kwargs...)
     cell = IndRNNCell(input_size, hidden_size, σ; kwargs...)

src/lightru_cell.jl

@@ -34,18 +34,19 @@ h_t         &= (1 - f_t) \odot h_{t-1} + f_t \odot \tilde{h}_t.
 
 # Forward
 
-    lightrucell(inp, [state])
-
-The arguments of the forward pass are:
+    lightrucell(inp, state)
+    lightrucell(inp)
 
+## Arguments
 - `inp`: The input to the lightrucell. It should be a vector of size `input_size`
   or a matrix of size `input_size x batch_size`.
 - `state`: The hidden state of the LightRUCell. It should be a vector of size
   `hidden_size` or a matrix of size `hidden_size x batch_size`.
   If not provided, it is assumed to be a vector of zeros.
 
-Returns a tuple `(output, state)`, where both elements are given by the updated state `new_state`, 
-a tensor of size `hidden_size` or `hidden_size x batch_size`.
+## Returns
+- A tuple `(output, state)`, where both elements are given by the updated state `new_state`, 
+  a tensor of size `hidden_size` or `hidden_size x batch_size`.
 """
 function LightRUCell((input_size, hidden_size)::Pair;
     init_kernel = glorot_uniform,
@@ -107,17 +108,18 @@ h_t         &= (1 - f_t) \odot h_{t-1} + f_t \odot \tilde{h}_t.
 
 # Forward
 
-    lightru(inp, [state])
-
-The arguments of the forward pass are:
+    lightru(inp, state)
+    lightru(inp)
 
+## Arguments
 - `inp`: The input to the lightru. It should be a vector of size `input_size x len`
   or a matrix of size `input_size x len x batch_size`.
 - `state`: The hidden state of the LightRU. If given, it is a vector of size
   `hidden_size` or a matrix of size `hidden_size x batch_size`.
   If not provided, it is assumed to be a vector of zeros.
 
-Returns new hidden states `new_states` as an array of size `hidden_size x len x batch_size`.
+## Returns
+- New hidden states `new_states` as an array of size `hidden_size x len x batch_size`.
 """
 function LightRU((input_size, hidden_size)::Pair; kwargs...)
     cell = LightRUCell(input_size => hidden_size; kwargs...)

src/ligru_cell.jl

@@ -36,18 +36,19 @@ h_t &= z_t \odot h_{t-1} + (1 - z_t) \odot \tilde{h}_t
 
 # Forward
 
-    ligrucell(inp, [state])
-
-The arguments of the forward pass are:
+    ligrucell(inp, state)
+    ligrucell(inp)
 
+## Arguments
 - `inp`: The input to the ligrucell. It should be a vector of size `input_size`
   or a matrix of size `input_size x batch_size`.
 - `state`: The hidden state of the LiGRUCell. It should be a vector of size
   `hidden_size` or a matrix of size `hidden_size x batch_size`.
   If not provided, it is assumed to be a vector of zeros.
 
-Returns a tuple `(output, state)`, where both elements are given by the updated state `new_state`, 
-a tensor of size `hidden_size` or `hidden_size x batch_size`.
+## Returns
+- A tuple `(output, state)`, where both elements are given by the updated state `new_state`, 
+  a tensor of size `hidden_size` or `hidden_size x batch_size`.
 """
 function LiGRUCell((input_size, hidden_size)::Pair;
     init_kernel = glorot_uniform,
@@ -107,17 +108,18 @@ h_t &= z_t \odot h_{t-1} + (1 - z_t) \odot \tilde{h}_t
 
 # Forward
 
-    ligru(inp, [state])
-
-The arguments of the forward pass are:
+    ligru(inp, state)
+    ligru(inp)
 
+## Arguments
 - `inp`: The input to the ligru. It should be a vector of size `input_size x len`
   or a matrix of size `input_size x len x batch_size`.
 - `state`: The hidden state of the LiGRU. If given, it is a vector of size
   `hidden_size` or a matrix of size `hidden_size x batch_size`.
   If not provided, it is assumed to be a vector of zeros.
 
-Returns new hidden states `new_states` as an array of size `hidden_size x len x batch_size`.
+## Returns
+- New hidden states `new_states` as an array of size `hidden_size x len x batch_size`.
 """
 function LiGRU((input_size, hidden_size)::Pair; kwargs...)
     cell = LiGRUCell(input_size => hidden_size; kwargs...)

src/mgu_cell.jl

@@ -34,18 +34,19 @@ h_t         &= (1 - f_t) \odot h_{t-1} + f_t \odot \tilde{h}_t
 
 # Forward
 
-    mgucell(inp, [state])
-
-The arguments of the forward pass are:
+    mgucell(inp, state)
+    mgucell(inp)
 
+## Arguments
 - `inp`: The input to the mgucell. It should be a vector of size `input_size`
   or a matrix of size `input_size x batch_size`.
 - `state`: The hidden state of the MGUCell. It should be a vector of size
   `hidden_size` or a matrix of size `hidden_size x batch_size`.
   If not provided, it is assumed to be a vector of zeros.
 
-Returns a tuple `(output, state)`, where both elements are given by the updated state `new_state`, 
-a tensor of size `hidden_size` or `hidden_size x batch_size`.
+## Returns
+- A tuple `(output, state)`, where both elements are given by the updated state `new_state`, 
+  a tensor of size `hidden_size` or `hidden_size x batch_size`.
 """
 function MGUCell((input_size, hidden_size)::Pair;
     init_kernel = glorot_uniform,
@@ -106,17 +107,18 @@ h_t         &= (1 - f_t) \odot h_{t-1} + f_t \odot \tilde{h}_t
 
 # Forward
 
-    mgu(inp, [state])
-
-The arguments of the forward pass are:
+    mgu(inp, state)
+    mgu(inp)
 
+## Arguments
 - `inp`: The input to the mgu. It should be a vector of size `input_size x len`
   or a matrix of size `input_size x len x batch_size`.
 - `state`: The hidden state of the MGU. If given, it is a vector of size
   `hidden_size` or a matrix of size `hidden_size x batch_size`.
   If not provided, it is assumed to be a vector of zeros.
 
-Returns new hidden states `new_states` as an array of size `hidden_size x len x batch_size`.
+## Returns
+- New hidden states `new_states` as an array of size `hidden_size x len x batch_size`.
 """
 function MGU((input_size, hidden_size)::Pair; kwargs...)
     cell = MGUCell(input_size => hidden_size; kwargs...)