use coeus_autograd::Var;
use coeus_core::{ComputeBackend, MoiraiBackend, Scalar};
use super::{ModuleError, ParameterLoadError};
use coeus_autograd::Parameter;
pub(crate) fn prefixed_parameters<T, B, M>(prefix: &str, module: &M) -> Vec<Parameter<T, B>>
where
T: Scalar,
B: ComputeBackend + Default,
M: Module<T, B> + ?Sized,
{
module
.named_parameters()
.into_iter()
.map(|parameter| parameter.with_prefix(prefix))
.collect()
}
pub trait Module<T: Scalar, B: ComputeBackend + Default = MoiraiBackend> {
fn parameters(&self) -> Vec<Var<T, B>>;
fn named_parameters(&self) -> Vec<Parameter<T, B>> {
let parameters = self.parameters();
let names: &[&str] = match parameters.len() {
0 => &[],
1 => &["weight"],
2 => &["weight", "bias"],
count => panic!(
"invariant: module with {count} parameters must define stable hierarchical names"
),
};
parameters
.into_iter()
.zip(names)
.map(|(parameter, name)| Parameter::new(parameter, *name))
.collect()
}
fn forward(&self, input: &Var<T, B>) -> Result<Var<T, B>, ModuleError<B::Error>>;
#[inline]
fn load_parameters(&mut self, _params: &[Var<T, B>]) {}
fn load_named_parameters(
&mut self,
parameters: &[Parameter<T, B>],
) -> Result<(), ParameterLoadError> {
let expected = self.named_parameters();
if expected.len() != parameters.len() {
return Err(ParameterLoadError::Count {
expected: expected.len(),
actual: parameters.len(),
});
}
for (index, (expected, actual)) in expected.iter().zip(parameters).enumerate() {
if expected.name != actual.name {
return Err(ParameterLoadError::Name {
index,
expected: expected.name.clone(),
actual: actual.name.clone(),
});
}
}
let variables = parameters
.iter()
.map(|parameter| parameter.var.clone())
.collect::<Vec<_>>();
self.load_parameters(&variables);
Ok(())
}
#[inline]
fn zero_grad(&self) -> Result<(), B::Error> {
for p in self.parameters() {
p.zero_grad()?;
}
Ok(())
}
#[inline]
fn train(&mut self, _mode: bool) {}
#[inline]
fn eval(&mut self) {
self.train(false);
}
}