Ctrl+K

max_pool2d#

ivy.max_pool2d(x, kernel, strides, padding, /, *, data_format='NHWC', dilation=1, ceil_mode=False, out=None)[source]#

Compute a 2-D max pool given 4-D input x.

Parameters:

  • x (Union[Array, NativeArray]) – Input image [batch_size,h,w,d_in].

  • kernel (Union[int, Tuple[int, ...]]) – Size of the kernel i.e., the sliding window for each dimension of input. [h,w].

  • strides (Union[int, Tuple[int, ...]]) – The stride of the sliding window for each dimension of input.

  • padding (Union[str, int, Tuple[int], List[Tuple[int, int]]]) – SAME” or “VALID” indicating the algorithm, or list indicating the per-dimension paddings.

  • data_format (str, default: 'NHWC') – NHWC” or “NCHW”. Defaults to “NHWC”.

  • dilation (Union[int, Tuple[int, ...]], default: 1) – The stride between elements within a sliding window, must be > 0.

  • ceil_mode (bool, default: False) – If True, ceil is used instead of floor to compute the output shape. This ensures that every element in ‘x’ is covered by a sliding window.

  • out (Optional[Array], default: None) – optional output array, for writing the result to.

Return type:

Array

Returns:

  • ret – The result of the pooling operation.

  • Both the description and the type hints above assumes an array input

  • for simplicity, but this function is *nestable, and therefore*

  • also accepts ivy.Container instances in place of any of

  • the arguments.

Examples

>>> x = ivy.arange(12.).reshape((2, 1, 3, 2))
>>> print(ivy.max_pool2d(x, (2, 2), (1, 1), 'SAME'))
ivy.array([[[[ 2.,  3.],
         [ 4.,  5.],
         [ 4.,  5.]]],
[[[ 8., 9.],

[10., 11.], [10., 11.]]]])

>>> x = ivy.arange(48.).reshape((2, 4, 3, 2))
>>> print(ivy.max_pool2d(x, 3, 1, 'VALID'))
ivy.array([[[[16., 17.]],

[[22., 23.]]],

[[[40., 41.]],

[[46., 47.]]]])

Array.max_pool2d(self, kernel, strides, padding, /, *, data_format='NHWC', dilation=1, ceil_mode=False, out=None)[source]#

ivy.Array instance method variant of ivy.max_pool2d. This method simply wraps the function, and so the docstring for ivy.max_pool2d also applies to this method with minimal changes.

Parameters:

  • self (Array) – Input image [batch_size,h,w,d_in].

  • kernel (Union[int, Tuple[int, ...]]) – The size of the window for each dimension of the input tensor.

  • strides (Union[int, Tuple[int, ...]]) – The stride of the sliding window for each dimension of input.

  • padding (Union[str, int, Tuple[int], List[Tuple[int, int]]]) – “SAME” or “VALID” indicating the algorithm, or list indicating the per-dimension paddings.

  • data_format (str, default: 'NHWC') – “NHWC” or “NCHW”. Defaults to “NHWC”.

  • dilaton – The stride between elements within a sliding window, must be > 0.

  • ceil_mode (bool, default: False) – If True, ceil is used instead of floor to compute the output shape. This ensures that every element is covered by a sliding window.

  • out (Optional[Array], default: None) – optional output array, for writing the result to. It must have a shape that the inputs broadcast to.

Return type:

Array

Returns:

ret – The result of the max pooling operation.

Examples

>>> x = ivy.arange(12.).reshape((2, 1, 3, 2))
>>> print(x.max_pool2d((2, 2), (1, 1), 'SAME'))
ivy.array([[[[ 2.,  3.],
         [ 4.,  5.],
         [ 4.,  5.]]],
[[[ 8., 9.],

[10., 11.], [10., 11.]]]])

>>> x = ivy.arange(48.).reshape((2, 4, 3, 2))
>>> print(x.max_pool2d(3, 1, 'VALID'))
ivy.array([[[[16., 17.]],

[[22., 23.]]],

[[[40., 41.]],

[[46., 47.]]]])

Container.max_pool2d(self, kernel, strides, padding, /, *, data_format='NHWC', dilation=1, ceil_mode=False, key_chains=None, to_apply=True, prune_unapplied=False, map_sequences=False, out=None)[source]#

ivy.Container instance method variant of ivy.max_pool2d. This method simply wraps the function, and so the docstring for ivy.max_pool2d also applies to this method with minimal changes.

Parameters:

  • x – Input image [batch_size,h,w,d_in].

  • kernel (Union[int, Tuple[int, ...], Container]) – The size of the window to take a max over.

  • strides (Union[int, Tuple[int, ...], Container]) – The stride of the sliding window for each dimension of input.

  • padding (Union[str, int, Tuple[int], List[Tuple[int, int]], Container]) – “SAME” or “VALID” indicating the algorithm, or list indicating the per-dimension paddings.

  • data_format (Union[str, Container], default: 'NHWC') – “NHWC” or “NCHW”. Defaults to “NHWC”.

  • dilaton – The stride between elements within a sliding window, must be > 0.

  • ceil_mode (Union[bool, Container], default: False) – If True, ceil is used instead of floor to compute the output shape. This ensures that every element is covered by a sliding window.

  • out (Optional[Container], default: None) – optional output array, for writing the result to. It must have a shape that the inputs broadcast to.

Return type:

Container

Returns:

ret – The result of the pooling operation.

Examples

>>> a = ivy.arange(24.).reshape((1, 2, 3, 4))
>>> b = ivy.arange(48.).reshape((2, 4, 3, 2))
>>> x = ivy.Container(a=a, b=b)
>>> y = x.max_pool2d(3, 1, "VALID")
>>> print(y)
{
    a: ivy.array([], shape=(1, 0, 1, 4)),
    b: ivy.array([[[[16., 17.]],
                   [[22., 23.]]],
                 [[[40., 41.]],
                   [[46., 47.]]]])
}
On this page