use crate::module::{prefixed_parameters, Module, ModuleError};
use crate::rnn::validation;
use coeus_autograd::Var;
use coeus_core::Scalar;
#[derive(Clone)]
pub struct Bidirectional<M> {
pub forward_module: M,
pub backward_module: M,
}
impl<M> Bidirectional<M> {
pub fn new(forward_module: M, backward_module: M) -> Self {
Self {
forward_module,
backward_module,
}
}
}
impl<T, B, M> Module<T, B> for Bidirectional<M>
where
T: Scalar,
B: coeus_ops::BackendOps<T> + Default,
M: Module<T, B>,
B::DeviceBuffer<T>:
coeus_core::CpuAddressableStorage<T> + coeus_core::CpuAddressableStorageMut<T>,
{
fn parameters(&self) -> Vec<Var<T, B>> {
let mut p = self.forward_module.parameters();
p.extend(self.backward_module.parameters());
p
}
fn named_parameters(&self) -> Vec<coeus_autograd::Parameter<T, B>> {
let mut parameters = prefixed_parameters("forward", &self.forward_module);
parameters.extend(prefixed_parameters("backward", &self.backward_module));
parameters
}
fn forward(&self, x: &Var<T, B>) -> Result<Var<T, B>, ModuleError<B::Error>> {
let (batch, sequence) = validation::sequence_layout(x.tensor.shape(), "Bidirectional")?;
let fwd = self.forward_module.forward(x)?;
validation::child_sequence_output(
fwd.tensor.shape(),
batch,
sequence,
"Bidirectional",
"forward output",
)?;
let rev_x = coeus_autograd::flip(x, 1)?;
let bwd_rev = self.backward_module.forward(&rev_x)?;
validation::child_sequence_output(
bwd_rev.tensor.shape(),
batch,
sequence,
"Bidirectional",
"backward output",
)?;
validation::matching_child_outputs(fwd.tensor.shape(), bwd_rev.tensor.shape())?;
let bwd = coeus_autograd::flip(&bwd_rev, 1)?;
Ok(coeus_autograd::cat(&[&fwd, &bwd], 2)?)
}
}