Struct MlpClassifier 

pub struct MlpClassifier {
    pub w1: Vec<f32>,
    pub b1: Vec<f32>,
    pub w2: Vec<f32>,
    pub b2: Vec<f32>,
    /* private fields */
}

A small two-layer MLP classifier: input → linear → ReLU → linear → logits.

Weights are stored row-major:

• w1 has shape [input_dim, hidden_dim]
• w2 has shape [hidden_dim, output_dim]

Fields

w1: Vec<f32>

Input-to-hidden weights, shape [input_dim, hidden_dim].

b1: Vec<f32>

Hidden bias, length hidden_dim.

w2: Vec<f32>

Hidden-to-output weights, shape [hidden_dim, output_dim].

b2: Vec<f32>

Output bias, length output_dim.

Implementations

impl MlpClassifier

pub fn new( input_dim: usize, hidden_dim: usize, output_dim: usize, seed: u32, ) -> Self

Create a fresh classifier with Xavier-like random weights.

pub fn forward(&self, x: &[f32]) -> MlpForward

Forward pass for a single input vector.

pub fn forward_hidden(&self, x: &[f32]) -> Vec<f32>

Hidden state (post-ReLU) for a single input vector, without the hidden-to-output projection. Useful for FFN-head diagnostics and confidence-gated routing where logits may not be needed.

pub fn predict(&self, x: &[f32]) -> usize

Predicted class (argmax over logits).

pub fn probabilities(&self, x: &[f32]) -> Vec<f32>

Class probabilities for a single input vector.

pub fn loss(&self, x: &[f32], target: usize) -> f32

Cross-entropy loss for a single input/target pair.

pub fn backward(&self, x: &[f32], target: usize) -> MlpGradients

Back-propagation for a single input/target pair.

pub fn apply_sgd(&mut self, grad: &MlpGradients, lr: f32)

Apply a single SGD step using the supplied gradients.

pub fn forward_batch(&self, x: &[f32], batch_size: usize) -> MlpForwardBatch

Forward pass for a batch of inputs.

x is a row-major flat buffer of shape [batch_size, input_dim].

pub fn loss_batch(&self, x: &[f32], targets: &[usize], batch_size: usize) -> f32

Cross-entropy loss averaged over a batch.

pub fn backward_batch( &self, x: &[f32], targets: &[usize], batch_size: usize, ) -> (MlpGradients, Vec<f32>, f32)

Back-propagation for a batch of input/target pairs.

Returns gradients averaged over the batch, the input gradient dx as a row-major [batch_size, input_dim] buffer, and the average cross-entropy loss. A single SGD/Adam step with the returned gradients is equivalent to one step per mini-batch (not one step per example).

pub fn flatten_params(&self) -> Vec<f32>

Flatten all learnable parameters into one vector, ordered [w1, b1, w2, b2].

pub fn flatten_grad(&self, grad: &MlpGradients) -> Vec<f32>

Flatten the gradients for a single example in the same order as Self::flatten_params.

pub fn load_flat_params(&mut self, params: &[f32])

Restore parameters from a flat vector produced by Self::flatten_params.

Trait Implementations

impl Clone for MlpClassifier

fn clone(&self) -> MlpClassifier

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MlpClassifier

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

Formats the value using the given formatter.