Struct Bidirectional 

pub struct Bidirectional<F: Float + Debug + Send + Sync> { /* private fields */ }

Bidirectional RNN wrapper for recurrent layers

This layer wraps a recurrent layer to enable bidirectional processing. It processes the input sequence in both forward and backward directions, and concatenates the results.

Examples

use scirs2_neural::layers::{Layer, recurrent::{Bidirectional, RNN, rnn::RecurrentActivation}};
use scirs2_core::ndarray::{Array, Array3};
use scirs2_core::random::rngs::SmallRng;
use scirs2_core::random::SeedableRng;

// Create RNN layers for forward and backward directions
let mut rng = scirs2_core::random::rng();
let forward_rnn = RNN::new(10, 20, RecurrentActivation::Tanh, &mut rng).unwrap();
let backward_rnn = RNN::new(10, 20, RecurrentActivation::Tanh, &mut rng).unwrap();

// Wrap them in a bidirectional layer
let birnn = Bidirectional::new(Box::new(forward_rnn), Some(Box::new(backward_rnn)), None).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 = birnn.forward(&input).unwrap();

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

Implementations

impl<F: Float + Debug + ScalarOperand + Send + Sync + 'static> Bidirectional<F>

pub fn new( forward_layer: Box<dyn Layer<F> + Send + Sync>, backward_layer: Option<Box<dyn Layer<F> + Send + Sync>>, name: Option<&str>, ) -> Result<Self>

Create a new bidirectional wrapper

Arguments

• forward_layer - The recurrent layer to use in forward direction
• backward_layer - Optional recurrent layer for backward direction (if None, forward layer will be used)
• name - Optional name for the layer

Returns

• A new bidirectional layer

pub fn new_with_single_layer( layer: Box<dyn Layer<F> + Send + Sync>, name: Option<&str>, ) -> Result<Self>

Create a new bidirectional wrapper with a single layer This constructor is for backward compatibility

pub fn name(&self) -> Option<&str>

Get the name of the layer

Trait Implementations

impl<F: Float + Debug + ScalarOperand + Send + Sync + 'static> Layer<F> for Bidirectional<F>

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, learningrate: F) -> Result<()>

Update the layer parameters with the given learning rate

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 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

fn inputshape(&self) -> Option<Vec<usize>>

Get the input shape if known

fn outputshape(&self) -> Option<Vec<usize>>

Get the output shape if known

fn name(&self) -> Option<&str>

Get the name of the layer if set