:nosearch:

.. _op_ai_onnx_MaxPool-12:

MaxPool - version 12
====================

This page documents version **12** of operator **MaxPool**. See :doc:`MaxPool` for the latest version (since version 22).

- **Domain**: ``ai.onnx``
- **Since version**: 12

MaxPool consumes an input tensor X and applies max pooling across
the tensor according to kernel sizes, stride sizes, and pad lengths.
max pooling consisting of computing the max on all values of a
subset of the input tensor according to the kernel size and downsampling the
data into the output tensor Y for further processing. The output spatial shape is calculated differently
depending on whether explicit padding is used, where pads is employed, or auto padding is used, where auto_pad is utilized.
With explicit padding (https://pytorch.org/docs/stable/generated/torch.nn.MaxPool2d.html?highlight=maxpool#torch.nn.MaxPool2d):

.. code-block::

    output_spatial_shape[i] = floor((input_spatial_shape[i] + pad_shape[i] - dilation[i] * (kernel_shape[i] - 1) - 1) / strides_spatial_shape[i] + 1)

or

.. code-block::

    output_spatial_shape[i] = ceil((input_spatial_shape[i] + pad_shape[i] - dilation[i] * (kernel_shape[i] - 1) - 1) / strides_spatial_shape[i] + 1)

if ceil_mode is enabled. ``pad_shape[i]`` is the sum of pads along axis ``i``.

``auto_pad`` is a DEPRECATED attribute. If you are using them currently, the output spatial shape will be following when ceil_mode is enabled:

.. code-block::

    VALID: output_spatial_shape[i] = ceil((input_spatial_shape[i] - ((kernel_spatial_shape[i] - 1) * dilations[i] + 1) + 1) / strides_spatial_shape[i])
    SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides_spatial_shape[i])

or when ceil_mode is disabled (https://www.tensorflow.org/api_docs/python/tf/keras/layers/AveragePooling2D):

.. code-block::

    VALID: output_spatial_shape[i] = floor((input_spatial_shape[i] - ((kernel_spatial_shape[i] - 1) * dilations[i] + 1)) / strides_spatial_shape[i]) + 1
    SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = floor((input_spatial_shape[i] - 1) / strides_spatial_shape[i]) + 1

And pad shape will be following if ``SAME_UPPER`` or ``SAME_LOWER``:

.. code-block::

    pad_shape[i] = (output_spatial_shape[i] - 1) * strides_spatial_shape[i] + ((kernel_spatial_shape[i] - 1) * dilations[i] + 1) - input_spatial_shape[i]

The output of each pooling window is maximum number of elements exclude pad.

**Inputs**

- **X** (*T*): Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size. Optionally, if dimension denotation is in effect, the operation expects the input data tensor to arrive with the dimension denotation of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].

**Outputs**

- **Y** (*T*): Output data tensor from average or max pooling across the input tensor. Dimensions will vary based on various kernel, stride, and pad sizes. Floor value of the dimension is used
- **Indices** (*I*): Indices tensor from max pooling across the input tensor. The dimensions of indices are the same as output tensor. The values in indices of are the indices of the selected values during pooling. The indices are computed as flatten 1-D tensor, and the indices do not consider padding. So the values in indices are in [0, N x C x D1 x ... x Dn).

**Type Constraints**

- **T**: Constrain input and output types to float and 8 bit tensors.
  Allowed types: tensor(double), tensor(float), tensor(float16), tensor(int8), tensor(uint8).
- **I**: Constrain index tensor to int64
  Allowed types: tensor(int64).

Differences with previous version (11)
--------------------------------------

**SchemaDiff**: ``MaxPool`` (domain ``'ai.onnx'``)

* old version: 11
* new version: 12
* breaking: no

**Type constraints:**

* changed 'T': added types: ['tensor(int8)', 'tensor(uint8)']

**Documentation:**

* line similarity: 0.63 (+13/-10 lines)

.. code-block:: diff

    --- MaxPool v11
    +++ MaxPool v12
    @@ -3,28 +3,31 @@
      the tensor according to kernel sizes, stride sizes, and pad lengths.
      max pooling consisting of computing the max on all values of a
      subset of the input tensor according to the kernel size and downsampling the
    - data into the output tensor Y for further processing. The output spatial shape will be following:
    + data into the output tensor Y for further processing. The output spatial shape is calculated differently
    + depending on whether explicit padding is used, where pads is employed, or auto padding is used, where auto_pad is utilized.
    + With explicit padding (https://pytorch.org/docs/stable/generated/torch.nn.MaxPool2d.html?highlight=maxpool#torch.nn.MaxPool2d):
      ```
    - output_spatial_shape[i] = floor((input_spatial_shape[i] + pad_shape[i] - ((kernel_spatial_shape[i] - 1) * dilations[i] + 1)) / strides_spatial_shape[i] + 1)
    + output_spatial_shape[i] = floor((input_spatial_shape[i] + pad_shape[i] - dilation[i] * (kernel_shape[i] - 1) - 1) / strides_spatial_shape[i] + 1)
      ```
      or
      ```
    - output_spatial_shape[i] = ceil((input_spatial_shape[i] + pad_shape[i] - ((kernel_spatial_shape[i] - 1) * dilations[i] + 1)) / strides_spatial_shape[i] + 1)
    + output_spatial_shape[i] = ceil((input_spatial_shape[i] + pad_shape[i] - dilation[i] * (kernel_shape[i] - 1) - 1) / strides_spatial_shape[i] + 1)
      ```
    - if ceil_mode is enabled
    + if ceil_mode is enabled. `pad_shape[i]` is the sum of pads along axis `i`.
     
    - ```
    - * pad_shape[i] is sum of pads along axis i
    - ```
    -
    - `auto_pad` is a DEPRECATED attribute. If you are using them currently, the output spatial shape will be following:
    + `auto_pad` is a DEPRECATED attribute. If you are using them currently, the output spatial shape will be following when ceil_mode is enabled:
      ```
      VALID: output_spatial_shape[i] = ceil((input_spatial_shape[i] - ((kernel_spatial_shape[i] - 1) * dilations[i] + 1) + 1) / strides_spatial_shape[i])
      SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides_spatial_shape[i])
    + ```
    + or when ceil_mode is disabled (https://www.tensorflow.org/api_docs/python/tf/keras/layers/AveragePooling2D):
    + ```
    + VALID: output_spatial_shape[i] = floor((input_spatial_shape[i] - ((kernel_spatial_shape[i] - 1) * dilations[i] + 1)) / strides_spatial_shape[i]) + 1
    + SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = floor((input_spatial_shape[i] - 1) / strides_spatial_shape[i]) + 1
      ```
      And pad shape will be following if `SAME_UPPER` or `SAME_LOWER`:
      ```
      pad_shape[i] = (output_spatial_shape[i] - 1) * strides_spatial_shape[i] + ((kernel_spatial_shape[i] - 1) * dilations[i] + 1) - input_spatial_shape[i]
      ```
    - The output of each pooling window is maximum number of elements exclude pad.
    + The output of each pooling window is maximum number of elements exclude pad.