Struct AdaptiveMaxPool2D

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

Adaptive Max Pooling 2D layer

Applies max 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::{AdaptiveMaxPool2D, Layer};
use ndarray::{Array, Array4};

// Create an adaptive max pooling layer with output size 7x7
let pool = AdaptiveMaxPool2D::new((7, 7), Some("adaptive_max_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> AdaptiveMaxPool2D<F>

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

Create a new adaptive max pooling layer

Arguments

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

Returns

• A new adaptive max pooling layer

Examples found in repository

examples/new_features_showcase.rs (line 53)

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(())
}

examples/generative_models_complete.rs (line 184)

    pub fn new(config: GenerativeConfig, rng: &mut SmallRng) -> StdResult<Self> {
        let (_height, _width) = config.input_size;

        // Feature extraction layers
        let mut feature_extractor = Sequential::new();
        feature_extractor.add(Conv2D::new(1, 32, (3, 3), (2, 2), PaddingMode::Same, rng)?);
        feature_extractor.add(BatchNorm::new(32, 1e-5, 0.1, rng)?);

        feature_extractor.add(Conv2D::new(32, 64, (3, 3), (2, 2), PaddingMode::Same, rng)?);
        feature_extractor.add(BatchNorm::new(64, 1e-5, 0.1, rng)?);

        feature_extractor.add(Conv2D::new(
            64,
            128,
            (3, 3),
            (2, 2),
            PaddingMode::Same,
            rng,
        )?);
        feature_extractor.add(BatchNorm::new(128, 1e-5, 0.1, rng)?);

        feature_extractor.add(AdaptiveMaxPool2D::new((4, 4), None)?);

        // Calculate flattened feature size
        let feature_size = 128 * 4 * 4;

        // Mean head
        let mut mean_head = Sequential::new();
        mean_head.add(Dense::new(
            feature_size,
            config.hidden_dims[0],
            Some("relu"),
            rng,
        )?);
        mean_head.add(Dropout::new(0.2, rng)?);
        mean_head.add(Dense::new(
            config.hidden_dims[0],
            config.latent_dim,
            None,
            rng,
        )?);

        // Log variance head
        let mut logvar_head = Sequential::new();
        logvar_head.add(Dense::new(
            feature_size,
            config.hidden_dims[0],
            Some("relu"),
            rng,
        )?);
        logvar_head.add(Dropout::new(0.2, rng)?);
        logvar_head.add(Dense::new(
            config.hidden_dims[0],
            config.latent_dim,
            None,
            rng,
        )?);

        Ok(Self {
            feature_extractor,
            mean_head,
            logvar_head,
            config,
        })
    }

examples/object_detection_complete.rs (line 209)

    pub fn new(config: DetectionConfig, rng: &mut SmallRng) -> StdResult<Self> {
        // Feature extraction backbone (simplified ResNet-like)
        let mut feature_extractor = Sequential::new();

        // Initial conv block
        feature_extractor.add(Conv2D::new(3, 64, (7, 7), (2, 2), PaddingMode::Same, rng)?);
        feature_extractor.add(BatchNorm::new(64, 0.1, 1e-5, rng)?);
        feature_extractor.add(MaxPool2D::new((2, 2), (2, 2), None)?);

        // Feature blocks
        feature_extractor.add(Conv2D::new(
            64,
            128,
            (3, 3),
            (2, 2),
            PaddingMode::Same,
            rng,
        )?);
        feature_extractor.add(BatchNorm::new(128, 0.1, 1e-5, rng)?);

        feature_extractor.add(Conv2D::new(
            128,
            256,
            (3, 3),
            (2, 2),
            PaddingMode::Same,
            rng,
        )?);
        feature_extractor.add(BatchNorm::new(256, 0.1, 1e-5, rng)?);

        // Global pooling to fixed size
        feature_extractor.add(AdaptiveMaxPool2D::new(config.feature_map_size, None)?);

        // Classification head
        let mut classifier_head = Sequential::new();
        let feature_dim = 256 * config.feature_map_size.0 * config.feature_map_size.1;
        classifier_head.add(Dense::new(feature_dim, 512, Some("relu"), rng)?);
        classifier_head.add(Dropout::new(0.5, rng)?);
        classifier_head.add(Dense::new(512, 256, Some("relu"), rng)?);
        classifier_head.add(Dropout::new(0.3, rng)?);
        classifier_head.add(Dense::new(
            256,
            config.num_classes * config.max_objects,
            Some("softmax"),
            rng,
        )?);

        // Bounding box regression head
        let mut bbox_regressor = Sequential::new();
        bbox_regressor.add(Dense::new(feature_dim, 512, Some("relu"), rng)?);
        bbox_regressor.add(Dropout::new(0.5, rng)?);
        bbox_regressor.add(Dense::new(512, 256, Some("relu"), rng)?);
        bbox_regressor.add(Dropout::new(0.3, rng)?);
        bbox_regressor.add(Dense::new(256, 4 * config.max_objects, None, rng)?); // 4 coordinates per object

        Ok(Self {
            feature_extractor,
            classifier_head,
            bbox_regressor,
            config,
        })
    }

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 AdaptiveMaxPool2D<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