mindspore.mint.nn.functional.avg_pool2d

mindspore.mint.nn.functional.avg_pool2d(input, kernel_size, stride=None, padding=0, ceil_mode=False, count_include_pad=True, divisor_override=None)

Applies a 2D average pooling over an input Tensor which can be regarded as a composition of 2D input planes. Typically the input is of shape \((N, C, H_{in}, W_{in})\) , outputs regional average in the \((H_{in}, W_{in})\) -dimension. Given kernel size \((kH, kW)\) and stride , the operation is as follows.

Note

On the Atlas platform, when calculating the input, the precision is degraded from float32 to float16.

\[\text{output}(N_i, C_j, h, w) = \frac{1}{kH * kW} \sum_{m=0}^{kH-1} \sum_{n=0}^{kW-1} \text{input}(N_i, C_j, stride[0] \times h + m, stride[1] \times w + n)\]

Parameters

• input (Tensor) – Tensor of shape \((N, C, H_{in}, W_{in})\) or \((C, H_{in}, W_{in})\).

• kernel_size (Union[int, tuple[int], list[int]]) – The size of kernel used to take the average value. Can be a single number or a tuple \((kH, kW)\) .

• stride (Union[int, tuple[int], list[int]], optional) – The distance of kernel moving. Can be a single number or a tuple \((sH, sW)\) . Default: None, where its value is equal to kernel_size.

• padding (Union[int, tuple[int], list[int]], optional) – Implicit zero padding to be added on both sides. Can be a single number or a tuple \((padH, padW)\) . Default: 0.

• ceil_mode (bool, optional) – If True, apply ceil instead of floor to compute the output shape. Default: False.

• count_include_pad (bool, optional) – If True, include the zero-padding in the averaging calculation. Default: True .

• divisor_override (int, optional) – If specified, it will be used as divisor in the averaging calculation, otherwise size of pooling region will be used. Default: None.

Returns

Tensor, with shape \((N, C, H_{out}, W_{out})\) or \((C, H_{out}, W_{out})\).

\[\begin{split}\begin{array}{ll} \\ H_{out} = \frac{H_{in} + 2 \times padding[0] - kernel\_size[0]}{stride[0]} + 1 \\ W_{out} = \frac{W_{in} + 2 \times padding[1] - kernel\_size[1]}{stride[1]} + 1 \end{array}\end{split}\]

Raises

• TypeError – If input is not a Tensor.

• TypeError – If kernel_size or stride is neither int nor tuple.

• TypeError – If ceil_mode or count_include_pad is not a bool.

• TypeError – If divisor_override is not an int or None.

• ValueError – If the dimension of input is not equal to 3 or 4.

• ValueError – If kernel_size or stride is less than 1.

• ValueError – If value of padding is less than 0.

• ValueError – If kernel_size, padding or stride is a tuple whose length is not equal to 1 or 2.

Supported Platforms:

Ascend

Examples

>>> import mindspore
>>> import numpy as np
>>> from mindspore import Tensor, mint
>>> x = Tensor(np.arange(1 * 3 * 3 * 4).reshape(1, 3, 3, 4), mindspore.float32)
>>> output = mint.nn.functional.avg_pool2d(x, kernel_size=2, stride=1)
>>> print(output)
[[[[ 2.5   3.5   4.5]
   [ 6.5   7.5   8.5]]
  [[14.5  15.5  16.5]
   [18.5  19.5  20.5]]
  [[26.5  27.5  28.5]
   [30.5  31.5  32.5]]]]