use crate::module::{prefixed_parameters, Module, ModuleError};
use coeus_autograd::Var;
use coeus_core::{ComputeBackend, MoiraiBackend, Scalar};
pub struct Sequential<T: Scalar, B: ComputeBackend + Default = MoiraiBackend> {
layers: Vec<Box<dyn Module<T, B>>>,
}
impl<T: Scalar, B: ComputeBackend + Default> Sequential<T, B> {
pub fn new() -> Self {
Self { layers: Vec::new() }
}
pub fn add<M: Module<T, B> + 'static>(&mut self, module: M) -> &mut Self {
self.layers.push(Box::new(module));
self
}
#[inline]
pub fn len(&self) -> usize {
self.layers.len()
}
#[inline]
pub fn is_empty(&self) -> bool {
self.layers.is_empty()
}
}
impl<T: Scalar, B: ComputeBackend + Default> Default for Sequential<T, B> {
fn default() -> Self {
Self::new()
}
}
impl<T: Scalar, B: ComputeBackend + Default> Module<T, B> for Sequential<T, B> {
fn parameters(&self) -> Vec<Var<T, B>> {
self.layers.iter().flat_map(|m| m.parameters()).collect()
}
fn named_parameters(&self) -> Vec<coeus_autograd::Parameter<T, B>> {
self.layers
.iter()
.enumerate()
.flat_map(|(index, module)| {
prefixed_parameters(&format!("layers.{index}"), module.as_ref())
})
.collect()
}
fn forward(&self, input: &Var<T, B>) -> Result<Var<T, B>, ModuleError<B::Error>> {
self.layers
.iter()
.try_fold(input.clone(), |x, module| module.forward(&x))
}
fn train(&mut self, mode: bool) {
for m in &mut self.layers {
m.train(mode);
}
}
fn load_parameters(&mut self, params: &[Var<T, B>]) {
let mut offset = 0;
for m in &mut self.layers {
let n = m.parameters().len();
m.load_parameters(¶ms[offset..offset + n]);
offset += n;
}
}
}
#[derive(Clone, Copy, Debug)]
pub struct StaticSeq<H, T>(pub H, pub T);
impl<
ScalarType: Scalar,
B: ComputeBackend + Default,
H: Module<ScalarType, B>,
T: Module<ScalarType, B>,
> Module<ScalarType, B> for StaticSeq<H, T>
{
#[inline]
fn parameters(&self) -> Vec<Var<ScalarType, B>> {
let mut params = self.0.parameters();
params.extend(self.1.parameters());
params
}
fn named_parameters(&self) -> Vec<coeus_autograd::Parameter<ScalarType, B>> {
let mut parameters = prefixed_parameters("head", &self.0);
parameters.extend(prefixed_parameters("tail", &self.1));
parameters
}
#[inline]
fn forward(
&self,
input: &Var<ScalarType, B>,
) -> Result<Var<ScalarType, B>, ModuleError<B::Error>> {
let out = self.0.forward(input)?;
self.1.forward(&out)
}
#[inline]
fn train(&mut self, mode: bool) {
self.0.train(mode);
self.1.train(mode);
}
#[inline]
fn load_parameters(&mut self, params: &[Var<ScalarType, B>]) {
let n0 = self.0.parameters().len();
self.0.load_parameters(¶ms[..n0]);
self.1.load_parameters(¶ms[n0..]);
}
}
pub trait ModuleExt<T: Scalar, B: ComputeBackend + Default>: Module<T, B> {
fn append<M: Module<T, B>>(self, next: M) -> StaticSeq<Self, M>
where
Self: Sized;
}
impl<T: Scalar, B: ComputeBackend + Default, M: Module<T, B>> ModuleExt<T, B> for M {
#[inline]
fn append<Next: Module<T, B>>(self, next: Next) -> StaticSeq<Self, Next> {
StaticSeq(self, next)
}
}