use crate::api::{Estimator, HasCapabilities, ModelError, Transformer, validate_transformed_shape};
use crate::data::MatrixView;
pub trait TransformerStack {
const STAGES_PERSIST: bool;
fn n_features_in(&self) -> usize;
fn n_features_out(&self) -> usize;
fn validate_handoff(&self) -> Result<(), ModelError>;
fn workspace_len(&self, rows: usize) -> Result<usize, ModelError>;
fn transform_into<'workspace>(
&self,
data: &MatrixView<'_>,
workspace: &'workspace mut [f32],
) -> Result<MatrixView<'workspace>, ModelError>;
}
fn check_handoff(produced: usize, expected: usize) -> Result<(), ModelError> {
if produced == expected {
Ok(())
} else {
Err(ModelError::FeatureDimension {
expected,
actual: produced,
})
}
}
fn stage_len(rows: usize, columns: usize) -> Result<usize, ModelError> {
rows.checked_mul(columns)
.ok_or(ModelError::OutputShapeOverflow { rows, columns })
}
fn extend_workspace(total: usize, rows: usize, columns: usize) -> Result<usize, ModelError> {
total
.checked_add(stage_len(rows, columns)?)
.ok_or(ModelError::OutputShapeOverflow { rows, columns })
}
fn validate_request<S: TransformerStack + ?Sized>(
stack: &S,
data: &MatrixView<'_>,
workspace: &[f32],
) -> Result<(), ModelError> {
stack.validate_handoff()?;
let expected_width = stack.n_features_in();
if data.columns() != expected_width {
return Err(ModelError::FeatureDimension {
expected: expected_width,
actual: data.columns(),
});
}
let expected = stack.workspace_len(data.rows())?;
if workspace.len() != expected {
return Err(ModelError::OutputLength {
expected,
actual: workspace.len(),
});
}
Ok(())
}
fn run_stage<'segment, T: Transformer>(
stage: &T,
data: &MatrixView<'_>,
segment: &'segment mut [f32],
) -> Result<MatrixView<'segment>, ModelError> {
let transformed = stage.transform_into(data, segment)?;
validate_transformed_shape(data.rows(), stage.n_features_out(), &transformed)?;
Ok(transformed)
}
macro_rules! impl_transformer_stack {
($head:ident $head_index:tt $(, $tail:ident $tail_index:tt)*) => {
impl<$head, $($tail,)*> TransformerStack for ($head, $($tail,)*)
where
$head: Transformer + HasCapabilities,
$($tail: Transformer + HasCapabilities,)*
{
const STAGES_PERSIST: bool =
$head::CAPABILITIES.artifact() $(&& $tail::CAPABILITIES.artifact())*;
fn n_features_in(&self) -> usize {
Estimator::n_features_in(&self.$head_index)
}
fn n_features_out(&self) -> usize {
let widths = [
self.$head_index.n_features_out(),
$(self.$tail_index.n_features_out(),)*
];
widths[widths.len() - 1]
}
fn validate_handoff(&self) -> Result<(), ModelError> {
let produced = self.$head_index.n_features_out();
$(
check_handoff(produced, Estimator::n_features_in(&self.$tail_index))?;
let produced = self.$tail_index.n_features_out();
)*
let _ = produced;
Ok(())
}
fn workspace_len(&self, rows: usize) -> Result<usize, ModelError> {
let total = extend_workspace(0, rows, self.$head_index.n_features_out())?;
$(let total = extend_workspace(total, rows, self.$tail_index.n_features_out())?;)*
Ok(total)
}
fn transform_into<'workspace>(
&self,
data: &MatrixView<'_>,
workspace: &'workspace mut [f32],
) -> Result<MatrixView<'workspace>, ModelError> {
validate_request(self, data, workspace)?;
let rows = data.rows();
let (segment, rest) =
workspace.split_at_mut(stage_len(rows, self.$head_index.n_features_out())?);
let produced = run_stage(&self.$head_index, data, segment)?;
$(
let (segment, rest) =
rest.split_at_mut(stage_len(rows, self.$tail_index.n_features_out())?);
let produced = run_stage(&self.$tail_index, &produced, segment)?;
)*
let _ = rest;
Ok(produced)
}
}
};
}
pub const MAX_STAGES: usize = 12;
impl_transformer_stack!(A 0);
impl_transformer_stack!(A 0, B 1);
impl_transformer_stack!(A 0, B 1, C 2);
impl_transformer_stack!(A 0, B 1, C 2, D 3);
impl_transformer_stack!(A 0, B 1, C 2, D 3, E 4);
impl_transformer_stack!(A 0, B 1, C 2, D 3, E 4, F 5);
impl_transformer_stack!(A 0, B 1, C 2, D 3, E 4, F 5, G 6);
impl_transformer_stack!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7);
impl_transformer_stack!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8);
impl_transformer_stack!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9);
impl_transformer_stack!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10);
impl_transformer_stack!(A 0, B 1, C 2, D 3, E 4, F 5, G 6, H 7, I 8, J 9, K 10, L 11);