Struct Layer 

pub struct Layer { /* private fields */ }

A dense layer: y = activation(Wx + b).

Weights use row-major layout with shape (out_dim, in_dim).

Implementations

impl Layer

pub fn activation(&self) -> Activation

Returns this layer’s activation.

impl Layer

pub fn new_with_rng<R: Rng + ?Sized>( in_dim: usize, out_dim: usize, init: Init, activation: Activation, rng: &mut R, ) -> Result<Self>

pub fn in_dim(&self) -> usize

Returns the input dimension.

pub fn out_dim(&self) -> usize

Returns the output dimension.

pub fn forward(&self, inputs: &[f32], outputs: &mut [f32])

Forward pass for a single sample.

Computes:

• z = W * inputs + b
• outputs = activation(z)

Shape contract:

• inputs.len() == self.in_dim
• outputs.len() == self.out_dim

pub fn backward( &self, inputs: &[f32], outputs: &[f32], d_outputs: &[f32], d_inputs: &mut [f32], d_weights: &mut [f32], d_biases: &mut [f32], )

Backward pass for a single sample.

This uses overwrite semantics:

• d_inputs is overwritten (and internally zeroed before accumulation)
• d_weights is overwritten
• d_biases is overwritten

Inputs:

• inputs: the same inputs passed to forward
• outputs: the outputs previously produced by forward (post-activation)
• d_outputs: upstream gradient dL/d(outputs)

Shape contract:

• inputs.len() == self.in_dim
• outputs.len() == self.out_dim
• d_outputs.len() == self.out_dim
• d_inputs.len() == self.in_dim
• d_weights.len() == self.weights.len()
• d_biases.len() == self.out_dim

pub fn backward_accumulate( &self, inputs: &[f32], outputs: &[f32], d_outputs: &[f32], d_inputs: &mut [f32], d_weights: &mut [f32], d_biases: &mut [f32], )

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

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

• d_inputs is overwritten (and internally zeroed before accumulation)
• d_weights is accumulated into (+=)
• d_biases is accumulated into (+=)

This is useful for mini-batch training where you sum gradients over multiple samples.

Shape contract:

• inputs.len() == self.in_dim
• outputs.len() == self.out_dim
• d_outputs.len() == self.out_dim
• d_inputs.len() == self.in_dim
• d_weights.len() == self.weights.len()
• d_biases.len() == self.out_dim

pub fn sgd_step(&mut self, d_weights: &[f32], d_biases: &[f32], lr: f32)

Applies an SGD update: param -= lr * d_param.

Shape contract:

• d_weights.len() == self.weights.len()
• d_biases.len() == self.biases.len()

Trait Implementations

impl Clone for Layer

fn clone(&self) -> Layer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Layer

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

Formats the value using the given formatter.

impl From<&Layer> for SerializedLayer

fn from(layer: &Layer) -> Self

Converts to this type from the input type.