Struct Dense 

pub struct Dense<F: Float + Debug + Send + Sync> { /* private fields */ }

Dense (fully connected) layer for neural networks.

A dense layer performs the operation: y = activation(W * x + b), where W is the weight matrix, x is the input vector, b is the bias vector, and activation is the activation function.

Implementations

impl<F: Float + Debug + ScalarOperand + Send + Sync + 'static> Dense<F>

pub fn new<R: Rng + RngCore>( input_dim: usize, output_dim: usize, activation_name: Option<&str>, rng: &mut R, ) -> Result<Self>

Create a new dense layer.

Arguments

• input_dim - Number of input features
• output_dim - Number of output features
• activation_name - Optional activation function name
• rng - Random number generator for weight initialization

Examples found in repository

examples/improved_xor.rs (line 17)

    fn new() -> Result<Self> {
        let mut rng = SmallRng::from_seed([42; 32]);
        // Create two layers: 2 inputs -> 5 hidden -> 1 output
        let hidden_layer = Dense::new(2, 5, Some("relu"), &mut rng)?;
        let output_layer = Dense::new(5, 1, None, &mut rng)?;
        Ok(Self {
            hidden_layer,
            output_layer,
        })
    }

examples/manual_xor.rs (line 22)

fn main() -> Result<()> {
    println!("Manual XOR Neural Network Example");
    // Create a simple dataset for XOR problem
    let inputs = Array::from_shape_vec(
        IxDyn(&[4, 2]),
        vec![0.0f32, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 1.0],
    )?;
    let targets = Array::from_shape_vec(IxDyn(&[4, 1]), vec![0.0f32, 1.0, 1.0, 0.0])?;
    println!("XOR problem dataset:");
    println!("Inputs:\n{inputs:?}");
    println!("Targets:\n{targets:?}");
    // Create neural network layers
    let mut rng = SmallRng::from_seed([42; 32]);
    let mut hidden_layer = Dense::new(2, 4, Some("relu"), &mut rng)?;
    let mut output_layer = Dense::new(4, 1, None, &mut rng)?;
    // Create loss function
    let loss_fn = MeanSquaredError::new();
    // Training parameters
    let learning_rate = 0.5f32;
    let num_epochs = 10000;
    println!("\nTraining for {num_epochs} epochs");
    for epoch in 0..num_epochs {
        // Forward pass through the network
        let hidden_output = hidden_layer.forward(&inputs)?;
        let final_output = output_layer.forward(&hidden_output)?;
        // Compute loss
        let loss = loss_fn.forward(&final_output, &targets)?;
        if epoch % 500 == 0 || epoch == num_epochs - 1 {
            println!("Epoch {}/{num_epochs}: loss = {loss:.6}", epoch + 1);
        }
        // Backward pass
        let output_grad = loss_fn.backward(&final_output, &targets)?;
        let hidden_grad = output_layer.backward(&hidden_output, &output_grad)?;
        let _input_grad = hidden_layer.backward(&inputs, &hidden_grad)?;
        // Update parameters
        hidden_layer.update(learning_rate)?;
        output_layer.update(learning_rate)?;
    }
    // Evaluate the model
    println!("\nEvaluation:");
    let hidden_output = hidden_layer.forward(&inputs)?;
    let final_output = output_layer.forward(&hidden_output)?;
    println!("Predictions:\n{final_output:.3?}");
    // Test with individual inputs
    println!("\nTesting with specific inputs:");
    let test_cases = vec![
        (0.0f32, 0.0f32),
        (0.0f32, 1.0f32),
        (1.0f32, 0.0f32),
        (1.0f32, 1.0f32),
    ];
    for (x1, x2) in test_cases {
        let test_input = Array::from_shape_vec(IxDyn(&[1, 2]), vec![x1, x2])?;
        let hidden_output = hidden_layer.forward(&test_input)?;
        let prediction = output_layer.forward(&hidden_output)?;
        let expected = if (x1 == 1.0 && x2 == 0.0) || (x1 == 0.0 && x2 == 1.0) {
            1.0
        } else {
            0.0
        };
        println!(
            "Input: [{x1:.1}, {x2:.1}], Predicted: {:.3}, Expected: {expected:.1}",
            prediction[[0, 0]]
        );
    }
    Ok(())
}

pub fn input_dim(&self) -> usize

Get the input dimension

pub fn output_dim(&self) -> usize

Get the output dimension

Trait Implementations

impl<F: Float + Debug + ScalarOperand + Send + Sync + 'static> Clone for Dense<F>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Float + Debug + ScalarOperand + Send + Sync + 'static> Debug for Dense<F>

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

Formats the value using the given formatter.

impl<F: Float + Debug + ScalarOperand + Send + Sync + 'static> Layer<F> for Dense<F>

fn forward(&self, input: &Array<F, IxDyn>) -> Result<Array<F, IxDyn>>

Forward pass of the layer

fn backward( &self, _input: &Array<F, IxDyn>, grad_output: &Array<F, IxDyn>, ) -> Result<Array<F, IxDyn>>

Backward pass of the layer to compute gradients

fn update(&mut self, learningrate: F) -> Result<()>

Update the layer parameters with the given learning rate

fn as_any(&self) -> &dyn Any

Get the layer as a dyn Any for downcasting

fn as_any_mut(&mut self) -> &mut dyn Any

Get the layer as a mutable dyn Any for downcasting

fn layer_type(&self) -> &str

Get the type of the layer (e.g., “Dense”, “Conv2D”)

fn parameter_count(&self) -> usize

Get the number of trainable parameters in this layer

fn layer_description(&self) -> String

Get a detailed description of this layer

fn params(&self) -> Vec<Array<F, IxDyn>>

Get the parameters of the layer

fn gradients(&self) -> Vec<Array<F, IxDyn>>

Get the gradients of the layer parameters

fn set_gradients(&mut self, _gradients: &[Array<F, IxDyn>]) -> Result<()>

Set the gradients of the layer parameters

fn set_params(&mut self, _params: &[Array<F, IxDyn>]) -> Result<()>

Set the parameters of the layer

fn set_training(&mut self, _training: bool)

Set the layer to training mode (true) or evaluation mode (false)

fn is_training(&self) -> bool

Get the current training mode

fn inputshape(&self) -> Option<Vec<usize>>

Get the input shape if known

fn outputshape(&self) -> Option<Vec<usize>>

Get the output shape if known

fn name(&self) -> Option<&str>

Get the name of the layer if set

impl<F: Float + Debug + ScalarOperand + Send + Sync + 'static> ParamLayer<F> for Dense<F>

fn get_parameters(&self) -> Vec<Array<F, IxDyn>>

Get the parameters of the layer as a vector of arrays

fn get_gradients(&self) -> Vec<Array<F, IxDyn>>

Get the gradients of the parameters

fn set_parameters(&mut self, params: Vec<Array<F, IxDyn>>) -> Result<()>

Set the parameters

impl<F: Float + Debug + Send + Sync> Send for Dense<F>

impl<F: Float + Debug + Send + Sync> Sync for Dense<F>