Struct Dense

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

Dense (fully connected) layer for neural networks.

A dense layer is a layer where each input neuron is connected to each output neuron. It 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.

Examples

use scirs2_neural::layers::{Dense, Layer};
use ndarray::{Array, Array2};
use rand::rngs::SmallRng;
use rand::SeedableRng;

// Create a dense layer with 2 input neurons, 3 output neurons, and ReLU activation
let mut rng = SmallRng::seed_from_u64(42);
let dense = Dense::new(2, 3, Some("relu"), &mut rng).unwrap();

// Forward pass with a batch of 2 samples
let input = Array2::from_shape_vec((2, 2), vec![1.0f64, 2.0, 3.0, 4.0]).unwrap().into_dyn();
let output = dense.forward(&input).unwrap();

// Output shape should be (2, 3) - 2 samples with 3 features each
assert_eq!(output.shape(), &[2, 3]);

Dense (fully connected) layer for neural networks.

A dense layer is a layer where each input neuron is connected to each output neuron. It 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 + 'static> Dense<F>

pub fn new<R: Rng>( 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 - Optional activation function name
• rng - Random number generator for weight initialization

Returns

• A new dense layer

Examples found in repository

examples/improved_xor.rs (line 19)

    fn new() -> Result<Self> {
        let mut rng = SmallRng::seed_from_u64(42);

        // 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/model_visualization_simple.rs (line 52)

fn create_mlp_model<R: rand::Rng>(rng: &mut R) -> Result<Sequential<f64>> {
    let mut model = Sequential::new();

    // Input layer is implicitly defined by the first layer
    // Hidden layers
    model.add_layer(Dense::new(784, 128, Some("relu"), rng)?);
    model.add_layer(Dense::new(128, 64, Some("relu"), rng)?);

    // Output layer
    model.add_layer(Dense::new(64, 10, Some("softmax"), rng)?);

    Ok(model)
}

examples/advanced_callbacks.rs (line 43)

fn create_regression_model(input_dim: usize, rng: &mut SmallRng) -> Result<Sequential<f32>> {
    let mut model = Sequential::new();

    // Input layer
    let dense1 = Dense::new(input_dim, 16, Some("relu"), rng)?;
    model.add_layer(dense1);

    // Hidden layers
    let dense2 = Dense::new(16, 8, Some("relu"), rng)?;
    model.add_layer(dense2);

    // Output layer (linear activation for regression)
    let dense3 = Dense::new(8, 1, None, rng)?;
    model.add_layer(dense3);

    Ok(model)
}

examples/scheduler_optimizer.rs (line 46)

fn create_xor_model(rng: &mut SmallRng) -> Result<Sequential<f32>> {
    let mut model = Sequential::new();

    // Input layer with 2 neurons (XOR has 2 inputs)
    let dense1 = Dense::new(2, 8, Some("relu"), rng)?;
    model.add_layer(dense1);

    // Hidden layer
    let dense2 = Dense::new(8, 4, Some("relu"), rng)?;
    model.add_layer(dense2);

    // Output layer with 1 neuron (XOR has 1 output)
    let dense3 = Dense::new(4, 1, Some("sigmoid"), rng)?;
    model.add_layer(dense3);

    Ok(model)
}

examples/training_callbacks.rs (line 47)

fn create_xor_model(rng: &mut SmallRng) -> Result<Sequential<f32>> {
    let mut model = Sequential::new();

    // Input layer with 2 neurons (XOR has 2 inputs)
    let dense1 = Dense::new(2, 8, Some("relu"), rng)?;
    model.add_layer(dense1);

    // Hidden layer
    let dense2 = Dense::new(8, 4, Some("relu"), rng)?;
    model.add_layer(dense2);

    // Output layer with 1 neuron (XOR has 1 output)
    let dense3 = Dense::new(4, 1, Some("sigmoid"), rng)?;
    model.add_layer(dense3);

    Ok(model)
}

examples/model_evaluation_example.rs (lines 47-52)

    fn build(&self) -> Result<Self::Model> {
        let mut model = Sequential::new();

        let mut rng = SmallRng::seed_from_u64(42);
        model.add(Dense::<F>::new(
            self.input_dim,
            self.hidden_dim,
            Some("relu"),
            &mut rng,
        )?);

        model.add(Dropout::<F>::new(0.2, &mut rng)?);

        model.add(Dense::<F>::new(
            self.hidden_dim,
            self.output_dim,
            None,
            &mut rng,
        )?);

        Ok(model)
    }

Additional examples can be found in:

• examples/neural_network_xor.rs
• examples/visualize_training_progress.rs
• examples/neural_confusion_matrix.rs
• examples/image_classification_complete.rs
• examples/model_architecture_visualization.rs
• examples/improved_model_serialization.rs
• examples/training_loop_example.rs
• examples/advanced_training_example.rs
• examples/text_classification_complete.rs
• examples/model_visualization_cnn.rs
• examples/generative_models_complete.rs
• examples/object_detection_complete.rs
• examples/manual_xor.rs
• examples/model_serialization_example.rs
• examples/batchnorm_example.rs
• examples/dropout_example.rs
• examples/advanced_optimizers_example.rs

pub fn input_dim(&self) -> usize

Get the input dimension

pub fn output_dim(&self) -> usize

Get the output dimension

pub fn activation_name(&self) -> Option<&str>

Get the activation function name

Trait Implementations

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

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

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 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, learning_rate: F) -> Result<()>

Update the layer parameters with the given gradients

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

impl<F: Float + Debug + ScalarOperand + '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 of the layer