Struct AdaptiveAvgPool2D

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

Adaptive Average Pooling 2D layer

Applies average pooling with adaptive output size. The output size is specified, and the pooling kernel size and stride are computed automatically.

Examples

use scirs2_neural::layers::{AdaptiveAvgPool2D, Layer};
use ndarray::{Array, Array4};

// Create an adaptive average pooling layer with output size 7x7
let pool = AdaptiveAvgPool2D::new((7, 7), Some("adaptive_pool")).unwrap();

// Forward pass with a batch of 2 samples, each with 3 channels and size 32x32
let batch_size = 2;
let channels = 3;
let height = 32;
let width = 32;
let input = Array4::<f64>::from_elem((batch_size, channels, height, width), 0.1).into_dyn();
let output = pool.forward(&input).unwrap();

// Output should have dimensions [batch_size, channels, 7, 7]
assert_eq!(output.shape(), &[batch_size, channels, 7, 7]);

Implementations

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

pub fn new(output_size: (usize, usize), name: Option<&str>) -> Result<Self>

Create a new adaptive average pooling layer

Arguments

• output_size - Desired output spatial size (height, width)
• name - Optional name for the layer

Returns

• A new adaptive average pooling layer

Examples found in repository

examples/new_features_showcase.rs (line 43)

fn demonstrate_adaptive_pooling() -> Result<(), Box<dyn std::error::Error>> {
    println!("🔧 Adaptive Pooling Layers Demonstration");
    println!("========================================\n");

    // Create input tensor: batch_size=2, channels=3, height=32, width=32
    let input = Array4::<f64>::from_elem((2, 3, 32, 32), 1.5);
    println!("Input shape: {:?}", input.shape());

    // Adaptive Average Pooling to 7x7
    println!("\n1. Adaptive Average Pooling (32x32 → 7x7):");
    let adaptive_avg_pool = AdaptiveAvgPool2D::new((7, 7), Some("adaptive_avg_7x7"))?;
    let avg_output = adaptive_avg_pool.forward(&input.clone().into_dyn())?;
    println!("   Output shape: {:?}", avg_output.shape());
    println!(
        "   Layer description: {}",
        adaptive_avg_pool.layer_description()
    );

    // Adaptive Max Pooling to 4x4
    println!("\n2. Adaptive Max Pooling (32x32 → 4x4):");
    let adaptive_max_pool = AdaptiveMaxPool2D::new((4, 4), Some("adaptive_max_4x4"))?;
    let max_output = adaptive_max_pool.forward(&input.into_dyn())?;
    println!("   Output shape: {:?}", max_output.shape());
    println!(
        "   Layer description: {}",
        adaptive_max_pool.layer_description()
    );

    // Non-square adaptive pooling
    println!("\n3. Non-square Adaptive Pooling (32x32 → 3x5):");
    let non_square_pool = AdaptiveAvgPool2D::new((3, 5), Some("non_square"))?;
    let non_square_output =
        non_square_pool.forward(&Array4::<f64>::from_elem((1, 2, 16, 20), 2.0).into_dyn())?;
    println!("   Input shape: [1, 2, 16, 20]");
    println!("   Output shape: {:?}", non_square_output.shape());

    println!("✅ Adaptive pooling demonstration completed!\n");
    Ok(())
}

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

Get the name of the layer

Trait Implementations

impl<F: Float + Debug + ScalarOperand + Send + Sync + 'static> Layer<F> for AdaptiveAvgPool2D<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 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 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