1use crate::module::{prefixed_parameters, Module, ModuleError};
9use coeus_autograd::Var;
10use coeus_core::{ComputeBackend, MoiraiBackend, Scalar};
11
12pub struct Sequential<T: Scalar, B: ComputeBackend + Default = MoiraiBackend> {
25 layers: Vec<Box<dyn Module<T, B>>>,
27}
28
29impl<T: Scalar, B: ComputeBackend + Default> Sequential<T, B> {
30 pub fn new() -> Self {
32 Self { layers: Vec::new() }
33 }
34
35 pub fn add<M: Module<T, B> + 'static>(&mut self, module: M) -> &mut Self {
39 self.layers.push(Box::new(module));
40 self
41 }
42
43 #[inline]
45 pub fn len(&self) -> usize {
46 self.layers.len()
47 }
48
49 #[inline]
51 pub fn is_empty(&self) -> bool {
52 self.layers.is_empty()
53 }
54}
55
56impl<T: Scalar, B: ComputeBackend + Default> Default for Sequential<T, B> {
57 fn default() -> Self {
58 Self::new()
59 }
60}
61
62impl<T: Scalar, B: ComputeBackend + Default> Module<T, B> for Sequential<T, B> {
63 fn parameters(&self) -> Vec<Var<T, B>> {
64 self.layers.iter().flat_map(|m| m.parameters()).collect()
65 }
66
67 fn named_parameters(&self) -> Vec<coeus_autograd::Parameter<T, B>> {
68 self.layers
69 .iter()
70 .enumerate()
71 .flat_map(|(index, module)| {
72 prefixed_parameters(&format!("layers.{index}"), module.as_ref())
73 })
74 .collect()
75 }
76
77 fn forward(&self, input: &Var<T, B>) -> Result<Var<T, B>, ModuleError<B::Error>> {
78 self.layers
79 .iter()
80 .try_fold(input.clone(), |x, module| module.forward(&x))
81 }
82
83 fn train(&mut self, mode: bool) {
84 for m in &mut self.layers {
85 m.train(mode);
86 }
87 }
88
89 fn load_parameters(&mut self, params: &[Var<T, B>]) {
90 let mut offset = 0;
91 for m in &mut self.layers {
92 let n = m.parameters().len();
93 m.load_parameters(¶ms[offset..offset + n]);
94 offset += n;
95 }
96 }
97}
98
99#[derive(Clone, Copy, Debug)]
113pub struct StaticSeq<H, T>(pub H, pub T);
114
115impl<
116 ScalarType: Scalar,
117 B: ComputeBackend + Default,
118 H: Module<ScalarType, B>,
119 T: Module<ScalarType, B>,
120 > Module<ScalarType, B> for StaticSeq<H, T>
121{
122 #[inline]
123 fn parameters(&self) -> Vec<Var<ScalarType, B>> {
124 let mut params = self.0.parameters();
125 params.extend(self.1.parameters());
126 params
127 }
128
129 fn named_parameters(&self) -> Vec<coeus_autograd::Parameter<ScalarType, B>> {
130 let mut parameters = prefixed_parameters("head", &self.0);
131 parameters.extend(prefixed_parameters("tail", &self.1));
132 parameters
133 }
134
135 #[inline]
136 fn forward(
137 &self,
138 input: &Var<ScalarType, B>,
139 ) -> Result<Var<ScalarType, B>, ModuleError<B::Error>> {
140 let out = self.0.forward(input)?;
141 self.1.forward(&out)
142 }
143
144 #[inline]
145 fn train(&mut self, mode: bool) {
146 self.0.train(mode);
147 self.1.train(mode);
148 }
149
150 #[inline]
151 fn load_parameters(&mut self, params: &[Var<ScalarType, B>]) {
152 let n0 = self.0.parameters().len();
153 self.0.load_parameters(¶ms[..n0]);
154 self.1.load_parameters(¶ms[n0..]);
155 }
156}
157
158pub trait ModuleExt<T: Scalar, B: ComputeBackend + Default>: Module<T, B> {
160 fn append<M: Module<T, B>>(self, next: M) -> StaticSeq<Self, M>
162 where
163 Self: Sized;
164}
165
166impl<T: Scalar, B: ComputeBackend + Default, M: Module<T, B>> ModuleExt<T, B> for M {
167 #[inline]
168 fn append<Next: Module<T, B>>(self, next: Next) -> StaticSeq<Self, Next> {
169 StaticSeq(self, next)
170 }
171}