Struct Softmax

pub struct Softmax { /* private fields */ }

Softmax activation function.

The softmax function is defined as: f(x_i) = exp(x_i) / sum_j(exp(x_j))

It transforms a vector of real values into a probability distribution.

Examples

use scirs2_neural::activations::{Softmax, Activation};
use ndarray::arr1;

// Create softmax activation for 1D array (axis 0)
let softmax = Softmax::new(0);
let input = arr1(&[1.0f64, 2.0, 3.0]).into_dyn();
let output = softmax.forward(&input).unwrap();

// Check that the output sums to 1.0
let sum: f64 = output.sum();
assert!((sum - 1.0).abs() < 1e-6);

// Check that all values are between 0 and 1
for val in output.iter() {
    assert!(*val >= 0.0 && *val <= 1.0);
}

Implementations

impl Softmax

pub fn new(axis: usize) -> Self

Create a new Softmax activation function.

Arguments

• axis - The axis along which to compute the softmax.

Examples found in repository

examples/test_softmax.rs (line 11)

fn main() {
    println!("Testing softmax implementation...\n");

    // Test case 1: Simple 1D array
    let input = arr1(&[1.0, 2.0, 3.0]);
    println!("Input: {:?}", input);

    let softmax = Softmax::new(0);
    let output = softmax.forward(&input.clone().into_dyn()).unwrap();
    println!("Softmax output: {:?}", output);

    // Verify that output sums to 1
    let sum: f64 = output.sum();
    println!("Sum of softmax: {}", sum);
    assert!((sum - 1.0).abs() < 1e-6, "Softmax should sum to 1");

    // Test case 2: 2D array (batch processing)
    println!("\nTest case 2: 2D batch");
    let input_2d = arr2(&[[1.0, 2.0, 3.0], [3.0, 2.0, 1.0], [2.0, 2.0, 2.0]]);
    println!("Input 2D:\n{:?}", input_2d);

    // Apply softmax along axis 1 (row-wise)
    let softmax_2d = Softmax::new(1);
    let output_2d = softmax_2d.forward(&input_2d.clone().into_dyn()).unwrap();
    println!("Softmax output 2D:\n{:?}", output_2d);

    // Verify each row sums to 1
    for i in 0..output_2d.shape()[0] {
        let row_sum: f64 = output_2d.slice(ndarray::s![i, ..]).sum();
        println!("Row {} sum: {}", i, row_sum);
        assert!((row_sum - 1.0).abs() < 1e-6, "Each row should sum to 1");
    }

    // Test case 3: Gradient computation
    println!("\nTest case 3: Gradient computation");
    let grad_output = arr1(&[0.1, 0.2, 0.3]).into_dyn();
    let forward_output = softmax.forward(&input.clone().into_dyn()).unwrap();
    let grad_input = softmax.backward(&grad_output, &forward_output).unwrap();
    println!("Gradient input: {:?}", grad_input);

    println!("\nAll tests passed!");
}

Trait Implementations

impl<F: Float + Debug> Activation<F> for Softmax

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

Apply the activation function to the input

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

Compute the derivative of the activation function with respect to the input

impl Clone for Softmax

fn clone(&self) -> Softmax

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Softmax

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

Formats the value using the given formatter.

impl Default for Softmax

fn default() -> Self

Returns the “default value” for a type.

impl Copy for Softmax