Struct Mlp 

pub struct Mlp { /* private fields */ }

A feed-forward multi-layer perceptron composed of dense layers.

Implementations

impl Mlp

pub fn input_dim(&self) -> usize

Returns the expected input dimension.

pub fn output_dim(&self) -> usize

Returns the produced output dimension.

pub fn num_layers(&self) -> usize

Returns the number of layers.

pub fn layer(&self, idx: usize) -> Option<&Layer>

Returns a reference to a layer by index.

This is primarily useful for inspection and debugging.

pub fn scratch(&self) -> Scratch

Allocate a Scratch buffer suitable for this model.

pub fn scratch_batch(&self, batch_size: usize) -> BatchScratch

Allocate a BatchScratch buffer suitable for this model and a fixed batch size.

pub fn backprop_scratch_batch(&self, batch_size: usize) -> BatchBackpropScratch

Allocate a BatchBackpropScratch buffer suitable for this model and a fixed batch size.

pub fn gradients(&self) -> Gradients

Allocate a Gradients buffer suitable for this model.

pub fn trainer(&self) -> Trainer

Convenience constructor: allocate all training buffers.

pub fn forward<'a>(&self, input: &[f32], scratch: &'a mut Scratch) -> &'a [f32]

Forward pass for a single sample.

Writes intermediate activations into scratch and returns the final output slice.

Shape contract:

• input.len() == self.input_dim()
• scratch must be built for this Mlp (same layer count and output sizes)

pub fn forward_batch<'a>( &self, inputs: &[f32], scratch: &'a mut BatchScratch, ) -> &'a [f32]

Forward pass for a contiguous batch.

Writes intermediate activations into scratch and returns the final output buffer for the whole batch (flat row-major).

Shape contract:

• inputs.len() == batch_size * self.input_dim()
• scratch must be built for this Mlp and the same batch_size

pub fn backward<'a>( &self, input: &[f32], scratch: &Scratch, grads: &'a mut Gradients, ) -> &'a [f32]

Backward pass for a single sample, using the internal d_output buffer.

You must call forward first using the same input and scratch.

Before calling this, write the upstream gradient dL/d(output) into grads.d_output_mut().

Overwrite semantics:

• grads is overwritten with gradients for this sample.

Returns dL/d(input).

pub fn backward_accumulate<'a>( &self, input: &[f32], scratch: &Scratch, grads: &'a mut Gradients, ) -> &'a [f32]

Backward pass for a single sample (parameter accumulation semantics).

This is identical to backward except that parameter gradients are accumulated:

• grads.d_weights and grads.d_biases are accumulated into (+=)
• grads.d_layer_outputs and grads.d_input are overwritten

This is useful for mini-batch training.

You must call forward first using the same input and scratch. Before calling this, write the upstream gradient dL/d(output) into grads.d_output_mut().

pub fn backward_batch( &self, inputs: &[f32], scratch: &BatchScratch, d_outputs: &[f32], grads: &mut Gradients, backprop_scratch: &mut BatchBackpropScratch, )

Backward pass for a contiguous batch.

This overwrites grads with the mean parameter gradients over the batch.

Inputs:

• inputs: flat row-major with shape (batch_size, input_dim)
• scratch: activations from forward_batch
• d_outputs: flat row-major upstream gradients with shape (batch_size, output_dim)

pub fn sgd_step(&mut self, grads: &Gradients, lr: f32)

Applies an SGD update to all layers.

pub fn predict_into( &self, input: &[f32], scratch: &mut Scratch, out: &mut [f32], ) -> Result<()>

Shape-safe, non-allocating inference.

This validates shapes and returns Result instead of panicking. Internally it uses the low-level forward hot path.

pub fn predict_one_into( &self, input: &[f32], scratch: &mut Scratch, out: &mut [f32], ) -> Result<()>

Shape-safe, non-allocating inference for a single input.

Alias of Mlp::predict_into.

impl Mlp

pub fn evaluate( &self, data: &Dataset, loss_fn: Loss, metrics: &[Metric], ) -> Result<EvalReport>

Evaluate a dataset with a loss and optional metrics.

pub fn fit( &mut self, train: &Dataset, val: Option<&Dataset>, cfg: FitConfig, ) -> Result<FitReport>

Train the model on a dataset.

This is a “batteries included” API intended to be easy to use. Internally it still uses allocation-free forward/backward via scratch buffers.

pub fn predict(&self, data: &Dataset) -> Result<Vec<f32>>

Predict outputs for all inputs in data.

Returns a flat buffer with shape (len, output_dim).

pub fn predict_inputs(&self, inputs: &Inputs) -> Result<Vec<f32>>

Predict outputs for inputs (X).

Returns a flat buffer with shape (len, output_dim).

pub fn evaluate_mse(&self, data: &Dataset) -> Result<f32>

Evaluate mean MSE over a dataset.

This is a convenience wrapper around evaluate.

impl Mlp

pub fn to_json_string_pretty(&self) -> Result<String>

Serialize the model to a pretty-printed JSON string.

pub fn to_json_string(&self) -> Result<String>

Serialize the model to a compact JSON string.

pub fn from_json_str(s: &str) -> Result<Self>

Parse a model from a JSON string.

pub fn save_json<P: AsRef<Path>>(&self, path: P) -> Result<()>

Save the model to a JSON file (pretty-printed).

pub fn load_json<P: AsRef<Path>>(path: P) -> Result<Self>

Load a model from a JSON file.

Trait Implementations

impl Clone for Mlp

fn clone(&self) -> Mlp

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Mlp

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<&Mlp> for SerializedMlp

fn from(model: &Mlp) -> Self

Converts to this type from the input type.

impl TryFrom<SerializedMlp> for Mlp

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: SerializedMlp) -> Result<Self, Self::Error>

Performs the conversion.