torch.nn.AvgPool3d
new AvgPool3d(kernel_size: number | [number, number, number], options?: AvgPool3dOptions)
- readonly
kernel_size(number | [number, number, number]) - readonly
stride(number | [number, number, number]) - readonly
padding(number | [number, number, number]) - readonly
count_include_pad(boolean)
3D average pooling: reduces volumetric dimensions by taking mean over sliding window.
Applies average pooling over 3D spatial data (volumetric): scans a kernel over depth, height, and width, returning the arithmetic mean value within each kernel window. Reduces 3D spatial dimensionality with smooth downsampling. Essential for:
- Video understanding (smooth temporal downsampling in 3D CNNs)
- Medical imaging (noise reduction in 3D volumes while preserving structure)
- Point cloud processing (smooth volumetric representation)
- 3D object reconstruction (volumetric feature aggregation)
- Efficient 3D spatial compression
Similar to AvgPool2d but extends to 3D. Averages volumetric information by including all values in the 3D window. More conservative than MaxPool3d, retaining more spatial information.
When to use AvgPool3d:
- 3D data where smooth downsampling is preferred (video, medical images)
- Noise reduction in 3D feature maps
- When spatial structure should be preserved (not peak detection)
- Reducing computational burden while retaining signal
Trade-offs:
- vs MaxPool3d: AvgPool3d smooths; MaxPool3d preserves peaks
- vs adaptive pooling: AvgPool3d fixed stride/kernel; adaptive auto-adjusts
- Memory/compute: Significant overhead; carefully choose kernel/stride
- Information loss: Less than MaxPool (all values included)
Pooling mechanics: For a 3D volume [B, C, D, H, W] (batch, channels, depth, height, width):
- For each channel independently:
- Slide kernel_size³ window over spatial dimensions
- Step by stride in all 3 directions (default: kernel_size for non-overlapping)
- Compute mean value in each window
- Output: [B, C, D_out, H_out, W_out] where:
- D_out = floor((D + 2*padding_d - kernel_d) / stride_d) + 1
- H_out = floor((H + 2*padding_h - kernel_h) / stride_h) + 1
- W_out = floor((W + 2*padding_w - kernel_w) / stride_w) + 1
- Default stride: stride=kernel_size gives non-overlapping pooling
- Stride kernel: Creates overlapping windows (smoother 3D filtering)
- Anisotropic kernels: Different D/H/W values adapt to data characteristics
- Gradient: All volumetric elements get gradient (distributed equally)
- Memory intensive: 3D operations use more memory; carefully choose parameters
- Information preservation: More data retained than MaxPool (smoother signal)
- Smoothing effect: Reduces 3D spatial noise while blurring sharp features
- Memory intensive: 3D pooling uses significantly more memory than 2D
- Computational cost: Expensive operation; consider stride values carefully
- Blur: 3D spatial averaging can blur volumetric feature boundaries
- Batch size: Smaller batches may be needed due to 3D memory requirements
- Output size: Calculate using formula to predict output dimensions
Examples
// Smooth 3D downsampling for medical imaging
const pool = new torch.nn.AvgPool3d(2); // kernel=2x2x2, stride=2
const volume = torch.randn([4, 64, 32, 64, 64]); // [batch, channels, depth, height, width]
const y = pool.forward(volume); // [4, 64, 16, 32, 32] - half-resolution, smoothed// Anisotropic 3D pooling (different depth/spatial kernels for video)
const pool = new torch.nn.AvgPool3d([1, 2, 2], [1, 2, 2]); // Spatial pooling only
const x = torch.randn([8, 128, 16, 56, 56]); // [batch, channels, frames, height, width]
const y = pool.forward(x); // [8, 128, 16, 28, 28] - preserves temporal, downsamples spatial// 3D CNN with global average pooling
const conv = new torch.nn.Conv3d(1, 128, 3, { padding: 1 });
const avgpool = new torch.nn.AvgPool3d([32, 64, 64]); // Global average (match volume size)
const x = torch.randn([4, 1, 32, 64, 64]);
let y = conv.forward(x); // [4, 128, 32, 64, 64]
y = avgpool.forward(y); // [4, 128, 1, 1, 1] - global average per channel// count_include_pad=false (only average over real data, not padding)
const pool = new torch.nn.AvgPool3d(2, 2, 1, false);
const volume = torch.randn([8, 64, 16, 32, 32]);
const y = pool.forward(volume); // Averages only over valid (non-padded) regions