Struct LSTM

pub struct LSTM<F: Float + Debug> { /* private fields */ }

Long Short-Term Memory (LSTM) layer

Implements an LSTM layer with the following update rules: i_t = sigmoid(W_ii * x_t + b_ii + W_hi * h_(t-1) + b_hi) # input gate f_t = sigmoid(W_if * x_t + b_if + W_hf * h_(t-1) + b_hf) # forget gate g_t = tanh(W_ig * x_t + b_ig + W_hg * h_(t-1) + b_hg) # cell input o_t = sigmoid(W_io * x_t + b_io + W_ho * h_(t-1) + b_ho) # output gate c_t = f_t * c_(t-1) + i_t * g_t # cell state h_t = o_t * tanh(c_t) # hidden state

Examples

use scirs2_neural::layers::{LSTM, Layer};
use ndarray::{Array, Array3};
use rand::rngs::SmallRng;
use rand::SeedableRng;

// Create an LSTM layer with 10 input features and 20 hidden units
let mut rng = SmallRng::seed_from_u64(42);
let lstm = LSTM::new(10, 20, &mut rng).unwrap();

// Forward pass with a batch of 2 samples, sequence length 5, and 10 features
let batch_size = 2;
let seq_len = 5;
let input_size = 10;
let input = Array3::<f64>::from_elem((batch_size, seq_len, input_size), 0.1).into_dyn();
let output = lstm.forward(&input).unwrap();

// Output should have dimensions [batch_size, seq_len, hidden_size]
assert_eq!(output.shape(), &[batch_size, seq_len, 20]);

Implementations

impl<F: Float + Debug + ScalarOperand + 'static> LSTM<F>

pub fn new<R: Rng>( input_size: usize, hidden_size: usize, rng: &mut R, ) -> Result<Self>

Create a new LSTM layer

Arguments

• input_size - Number of input features
• hidden_size - Number of hidden units
• rng - Random number generator for weight initialization

Returns

• A new LSTM layer

Trait Implementations

impl<F: Float + Debug + ScalarOperand + 'static> Layer<F> for LSTM<F>

fn as_any(&self) -> &dyn Any

Get the layer as a dyn Any for downcasting

fn as_any_mut(&mut self) -> &mut dyn Any

Get the layer as a mutable dyn Any for downcasting

fn forward(&self, input: &Array<F, IxDyn>) -> Result<Array<F, IxDyn>>

Forward pass of the layer

fn backward( &self, input: &Array<F, IxDyn>, _grad_output: &Array<F, IxDyn>, ) -> Result<Array<F, IxDyn>>

Backward pass of the layer to compute gradients

fn update(&mut self, learning_rate: F) -> Result<()>

Update the layer parameters with the given gradients

fn params(&self) -> Vec<Array<F, IxDyn>>

Get the parameters of the layer

fn gradients(&self) -> Vec<Array<F, IxDyn>>

Get the gradients of the layer parameters

fn set_gradients(&mut self, _gradients: &[Array<F, IxDyn>]) -> Result<()>

Set the gradients of the layer parameters

fn set_params(&mut self, _params: &[Array<F, IxDyn>]) -> Result<()>

Set the parameters of the layer

fn set_training(&mut self, _training: bool)

Set the layer to training mode (true) or evaluation mode (false)

fn is_training(&self) -> bool

Get the current training mode

fn layer_type(&self) -> &str

Get the type of the layer (e.g., “Dense”, “Conv2D”)

fn parameter_count(&self) -> usize

Get the number of trainable parameters in this layer

fn layer_description(&self) -> String

Get a detailed description of this layer

impl<F: Float + Debug + ScalarOperand + 'static> ParamLayer<F> for LSTM<F>

fn get_parameters(&self) -> Vec<&Array<F, IxDyn>>

Get the parameters of the layer as a vector of arrays

fn get_gradients(&self) -> Vec<&Array<F, IxDyn>>

Get the gradients of the parameters

fn set_parameters(&mut self, params: Vec<Array<F, IxDyn>>) -> Result<()>

Set the parameters of the layer