Struct engram::nn::DenseLayer

pub struct DenseLayer {
    pub weights: Tensor,
    pub biases: Tensor,
    pub d_weights: Option<Tensor>,
    pub d_biases: Option<Tensor>,
    pub input: Option<Tensor>,
    pub output: Option<Tensor>,
    pub activation: Activation,
    pub eval: bool,
}

Fields

weights: Tensor

biases: Tensor

d_weights: Option<Tensor>

d_biases: Option<Tensor>

input: Option<Tensor>

output: Option<Tensor>

activation: Activation

eval: bool

Implementations

impl DenseLayer

pub fn new( f_in: usize, f_out: usize, initializer: Initializer, activation: Activation ) -> Self

Create a new layer with the given number of input and output features.

Examples

let layer = DenseLayer::new(3, 2, Initializer::Xavier, Activation::ReLU);

pub fn default(f_in: usize, f_out: usize) -> Self

Create a new layer with the given number of input and output features, using Xavier initialization and ReLU activation as defaults.

Examples

let layer = DenseLayer::default(4, 7);

Trait Implementations

impl Clone for DenseLayer

fn clone(&self) -> DenseLayer

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DenseLayer

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

Formats the value using the given formatter.

impl Layer for DenseLayer

fn forward(&mut self, input: &Tensor) -> Tensor

Forward pass through the layer, returning the output.

Examples

let mut layer = DenseLayer::default(3, 2);
let input = tensor![1.0, 2.0, 3.0];
let output = layer.forward(&input);

fn backward(&mut self, target: &Tensor, loss_fn: &Loss) -> f64

Backpropagate through the layer, returning the average loss.

Examples

let mut layer = DenseLayer::default(3, 2);
let input = tensor![1.0, 2.0, 3.0];
let output = layer.forward(&input);
let target = tensor![1.0, 0.0];
let loss = layer.backward(&target, &Loss::MSE);

fn weights(&self) -> &Tensor

fn biases(&self) -> &Tensor

fn update_parameters(&mut self, optimizer: &mut dyn Optimizer)

fn regularization_loss(&self, reg: &dyn Regularization) -> f64

fn apply_regularization(&mut self, reg: &dyn Regularization)

fn eval(&mut self)

fn train(&mut self)