Implementation:Tensorflow Tfjs Pooling Layers

Knowledge Sources	Tensorflow_Tfjs TensorFlow.js API
Domains	Deep_Learning, Layers_API
Last Updated	2026-02-10 06:00 GMT

Overview

The pooling.ts module implements all pooling layers for the TensorFlow.js Layers API, covering 1D, 2D, and 3D spatial pooling as well as global pooling operations. The architecture uses abstract base classes (Pooling1D, Pooling2D, Pooling3D, GlobalPooling1D, GlobalPooling2D) with concrete max and average pooling subclasses.

Standalone utility functions pool2d() and pool3d() perform the actual pooling computation, handling data format conversion and delegating to TF.js core operations (tfc.maxPool, tfc.avgPool, tfc.maxPool3d, tfc.avgPool3d).

Code Reference

Source Location

tfjs-layers/src/layers/pooling.ts (View on GitHub)

Key Signatures

// Utility functions
export function pool2d(x: Tensor, poolSize: [number, number], strides?: [number, number],
    padding?: PaddingMode, dataFormat?: DataFormat, poolMode?: PoolMode): Tensor;
export function pool3d(x: Tensor5D, poolSize: [number, number, number],
    strides?: [number, number, number], padding?: PaddingMode,
    dataFormat?: DataFormat, poolMode?: PoolMode): Tensor;

// Abstract base classes
export abstract class Pooling1D extends Layer { ... }
export abstract class Pooling2D extends Layer { ... }
export abstract class Pooling3D extends Layer { ... }
export abstract class GlobalPooling1D extends Layer { ... }
export abstract class GlobalPooling2D extends Layer { ... }

// Concrete 1D pooling
export class MaxPooling1D extends Pooling1D { static className = 'MaxPooling1D'; }
export class AveragePooling1D extends Pooling1D { static className = 'AveragePooling1D'; }

// Concrete 2D pooling
export class MaxPooling2D extends Pooling2D { static className = 'MaxPooling2D'; }
export class AveragePooling2D extends Pooling2D { static className = 'AveragePooling2D'; }

// Concrete 3D pooling
export class MaxPooling3D extends Pooling3D { static className = 'MaxPooling3D'; }
export class AveragePooling3D extends Pooling3D { static className = 'AveragePooling3D'; }

// Global pooling
export class GlobalAveragePooling1D extends GlobalPooling1D { static className = 'GlobalAveragePooling1D'; }
export class GlobalMaxPooling1D extends GlobalPooling1D { static className = 'GlobalMaxPooling1D'; }
export class GlobalAveragePooling2D extends GlobalPooling2D { static className = 'GlobalAveragePooling2D'; }
export class GlobalMaxPooling2D extends GlobalPooling2D { static className = 'GlobalMaxPooling2D'; }

Import

import { MaxPooling2D, AveragePooling2D, GlobalAveragePooling2D } from './layers/pooling';

Layer Details

Layer	Input Rank	Config	Description
MaxPooling1D	3	poolSize, strides, padding	Max pool over 1D sequence
AveragePooling1D	3	poolSize, strides, padding	Average pool over 1D sequence
MaxPooling2D	4	poolSize, strides, padding, dataFormat	Max pool over 2D spatial data
AveragePooling2D	4	poolSize, strides, padding, dataFormat	Average pool over 2D spatial data
MaxPooling3D	5	poolSize, strides, padding, dataFormat	Max pool over 3D spatial data
AveragePooling3D	5	poolSize, strides, padding, dataFormat	Average pool over 3D spatial data
GlobalAveragePooling1D	3	None	Global average across time axis
GlobalMaxPooling1D	3	None	Global max across time axis
GlobalAveragePooling2D	4	dataFormat	Global average across spatial axes
GlobalMaxPooling2D	4	dataFormat	Global max across spatial axes

I/O Contract

Input

• Pooling1D: Rank-3 tensor [batch, steps, features]. Default poolSize=2, strides=poolSize, padding='valid'.
• Pooling2D: Rank-4 tensor [batch, height, width, channels] (channelsLast) or [batch, channels, height, width] (channelsFirst). Default poolSize=[2,2].
• Pooling3D: Rank-5 tensor. Default poolSize=[2,2,2].
• GlobalPooling1D: Rank-3 tensor. Reduces the time dimension.
• GlobalPooling2D: Rank-4 tensor. Reduces both spatial dimensions.

Output

• Spatial pooling: Same rank as input with reduced spatial dimensions according to poolSize, strides, and padding.
• GlobalPooling1D: Rank-2 tensor [batch, features].
• GlobalPooling2D: Rank-2 tensor [batch, channels].

Output Shape Computation

For spatial pooling layers, the output size along each spatial axis is computed as: floor((inputSize - poolSize) / stride) + 1 (valid padding) or ceil(inputSize / stride) (same padding).

Usage Examples

import * as tf from '@tensorflow/tfjs';

// Standard CNN with max pooling
const model = tf.sequential();
model.add(tf.layers.conv2d({
  inputShape: [28, 28, 1], filters: 32, kernelSize: 3, activation: 'relu'
}));
model.add(tf.layers.maxPooling2d({ poolSize: 2, strides: 2 }));
model.add(tf.layers.conv2d({ filters: 64, kernelSize: 3, activation: 'relu' }));
model.add(tf.layers.maxPooling2d({ poolSize: 2 }));

// Global average pooling (common in modern architectures)
model.add(tf.layers.globalAveragePooling2d());
model.add(tf.layers.dense({ units: 10, activation: 'softmax' }));

// 1D pooling for sequence data
const seqModel = tf.sequential();
seqModel.add(tf.layers.conv1d({
  inputShape: [100, 16], filters: 32, kernelSize: 3
}));
seqModel.add(tf.layers.averagePooling1d({ poolSize: 2 }));
seqModel.add(tf.layers.globalMaxPooling1d());

Related Pages

• Tensorflow_Tfjs_Convolutional_Layers - Convolutional layers typically paired with pooling layers; provides preprocessConv2DInput used by pool2d
• Tensorflow_Tfjs_Exports_Layers - Public API factory functions for all pooling layers
• Tensorflow_Tfjs_Backend_Operations - Backend utilities for data format handling