tensorlayer3/tensorlayer/layers/pooling.py

#! /usr/bin/python
# -*- coding: utf-8 -*-

import tensorlayer as tl
from tensorlayer import logging
from tensorlayer.layers.core import Module

__all__ = [
    'PoolLayer',
    'MaxPool1d',
    'MeanPool1d',
    'MaxPool2d',
    'MeanPool2d',
    'MaxPool3d',
    'MeanPool3d',
    'GlobalMaxPool1d',
    'GlobalMeanPool1d',
    'GlobalMaxPool2d',
    'GlobalMeanPool2d',
    'GlobalMaxPool3d',
    'GlobalMeanPool3d',
    'AdaptiveMeanPool1d',
    'AdaptiveMeanPool2d',
    'AdaptiveMeanPool3d',
    'AdaptiveMaxPool1d',
    'AdaptiveMaxPool2d',
    'AdaptiveMaxPool3d',
    'CornerPool2d',
]


class PoolLayer(Module):
    """
    The :class:`PoolLayer` class is a Pooling layer.
    You can choose ``tl.ops.max_pool`` and ``tl.ops.avg_pool`` for 2D input or
    ``tl.ops.max_pool3d`` and ``tl.ops.avg_pool3d`` for 3D input.

    Parameters
    ----------
    filter_size : tuple of int
        The size of the window for each dimension of the input tensor.
        Note that: len(filter_size) >= 4.
    strides : tuple of int
        The stride of the sliding window for each dimension of the input tensor.
        Note that: len(strides) >= 4.
    padding : str
        The padding algorithm type: "SAME" or "VALID".
    pool : pooling function
        One of ``tl.ops.max_pool``, ``tl.ops.avg_pool``, ``tl.ops.max_pool3d`` and ``f.ops.avg_pool3d``.
        See `TensorFlow pooling APIs <https://tensorflow.google.cn/versions/r2.0/api_docs/python/tf/nn/>`__
    name : None or str
        A unique layer name.

    Examples
    ---------
    With TensorLayer

    >>> net = tl.layers.Input([None, 50, 50, 32], name='input')
    >>> net = tl.layers.PoolLayer()(net)
    >>> output shape : [None, 25, 25, 32]

    """

    def __init__(
        self,
        filter_size=(1, 2, 2, 1),
        strides=(1, 2, 2, 1),
        padding='SAME',
        pool=tl.ops.MaxPool,
        name=None  # 'pool_pro',
    ):
        super().__init__(name)
        self.filter_size = filter_size
        self.strides = strides
        self.padding = padding
        self.pool = pool

        self.build()
        self._built = True

        logging.info(
            "PoolLayer %s: filter_size: %s strides: %s padding: %s pool: %s" %
            (self.name, str(self.filter_size), str(self.strides), self.padding, pool.__name__)
        )

    def __repr__(self):
        s = '{classname}(pool={poolname}, filter_size={strides}, padding={padding}'
        if self.name is not None:
            s += ', name=\'{name}\''
        s += ')'
        return s.format(classname=self.__class__.__name__, poolname=self.pool.__name__, **self.__dict__)

    def build(self, inputs_shape=None):
        self._pool = self.pool(ksize=self.filter_size, strides=self.strides, padding=self.padding)

    def forward(self, inputs):
        outputs = self._pool(inputs)
        return outputs


class MaxPool1d(Module):
    """Max pooling for 1D signal.

    Parameters
    ----------
    filter_size : int
        Pooling window size.
    strides : int
        Stride of the pooling operation.
    padding : str
        The padding method: 'VALID' or 'SAME'.
    data_format : str
        One of channels_last (default, [batch, length, channel]) or channels_first. The ordering of the dimensions in the inputs.
    name : None or str
        A unique layer name.

    Examples
    ---------
    With TensorLayer

    >>> net = tl.layers.Input([None, 50, 32], name='input')
    >>> net = tl.layers.MaxPool1d(filter_size=3, strides=2, padding='SAME', name='maxpool1d')(net)
    >>> output shape : [None, 25, 32]

    """

    def __init__(
        self,
        filter_size=3,
        strides=2,
        padding='SAME',
        data_format='channels_last',
        dilation_rate=1,
        name=None  # 'maxpool1d'
    ):
        super().__init__(name)
        self.filter_size = self._filter_size = filter_size
        self.strides = self._strides = strides
        self.padding = padding
        self.data_format = data_format
        self.dilation_rate = self._dilation_rate = dilation_rate

        self.build()
        self._built = True

        logging.info(
            "MaxPool1d %s: filter_size: %s strides: %s padding: %s" %
            (self.name, str(filter_size), str(strides), str(padding))
        )

    def __repr__(self):
        s = ('{classname}(filter_size={filter_size}' ', strides={strides}, padding={padding}')
        if self.dilation_rate != 1:
            s += ', dilation={dilation_rate}'
        if self.name is not None:
            s += ', name=\'{name}\''
        s += ')'
        return s.format(classname=self.__class__.__name__, **self.__dict__)

    def build(self, inputs_shape=None):
        # https://tensorflow.google.cn/versions/r2.0/api_docs/python/tf/nn/pool
        if self.data_format == 'channels_last':
            self.data_format = 'NWC'
        elif self.data_format == 'channels_first':
            self.data_format = 'NCW'
        else:
            raise Exception("unsupported data format")
        self._filter_size = [self.filter_size]
        self._strides = [self.strides]
        self._dilation_rate = [self.dilation_rate]

    def forward(self, inputs):
        outputs = tl.ops.pool(
            input=inputs,
            window_shape=self._filter_size,
            pooling_type="MAX",
            strides=self._strides,
            padding=self.padding,
            data_format=self.data_format,
            dilations=self._dilation_rate,
        )
        return outputs


class MeanPool1d(Module):
    """Mean pooling for 1D signal.

    Parameters
    ------------
    filter_size : int
        Pooling window size.
    strides : int
        Strides of the pooling operation.
    padding : str
        The padding method: 'VALID' or 'SAME'.
    data_format : str
        One of channels_last (default, [batch, length, channel]) or channels_first. The ordering of the dimensions in the inputs.
    name : None or str
        A unique layer name.

    Examples
    ---------
    With TensorLayer

    >>> net = tl.layers.Input([None, 50, 32], name='input')
    >>> net = tl.layers.MeanPool1d(filter_size=3, strides=2, padding='SAME')(net)
    >>> output shape : [None, 25, 32]

    """

    def __init__(
        self,
        filter_size=3,
        strides=2,
        padding='SAME',
        data_format='channels_last',
        dilation_rate=1,
        name=None  # 'meanpool1d'
    ):
        super().__init__(name)
        self.filter_size = self._filter_size = filter_size
        self.strides = self._strides = strides
        self.padding = padding
        self.data_format = data_format
        self.dilation_rate = self._dilation_rate = dilation_rate

        self.build()
        self._built = True

        logging.info(
            "MeanPool1d %s: filter_size: %s strides: %s padding: %s" %
            (self.name, str(filter_size), str(strides), str(padding))
        )

    def __repr__(self):
        s = ('{classname}(filter_size={filter_size}' ', strides={strides}, padding={padding}')
        if self.dilation_rate != 1:
            s += ', dilation={dilation_rate}'
        if self.name is not None:
            s += ', name=\'{name}\''
        s += ')'
        return s.format(classname=self.__class__.__name__, **self.__dict__)

    def build(self, inputs_shape=None):
        # https://tensorflow.google.cn/versions/r2.0/api_docs/python/tf/nn/pool
        if self.data_format == 'channels_last':
            self.data_format = 'NWC'
        elif self.data_format == 'channels_first':
            self.data_format = 'NCW'
        else:
            raise Exception("unsupported data format")
        self._filter_size = [self.filter_size]
        self._strides = [self.strides]
        self._dilation_rate = [self.dilation_rate]

    def forward(self, inputs):
        outputs = tl.ops.pool(
            input=inputs, window_shape=self._filter_size, pooling_type="AVG", padding=self.padding,
            dilations=self._dilation_rate, strides=self._strides, data_format=self.data_format
        )
        return outputs


class MaxPool2d(Module):
    """Max pooling for 2D image.

    Parameters
    -----------
    filter_size : tuple of int
        (height, width) for filter size.
    strides : tuple of int
        (height, width) for strides.
    padding : str
        The padding method: 'VALID' or 'SAME'.
    data_format : str
        One of channels_last (default, [batch, height, width, channel]) or channels_first. The ordering of the dimensions in the inputs.
    name : None or str
        A unique layer name.

    Examples
    ---------
    With TensorLayer

    >>> net = tl.layers.Input([None, 50, 50, 32], name='input')
    >>> net = tl.layers.MaxPool2d(filter_size=(3, 3), strides=(2, 2), padding='SAME')(net)
    >>> output shape : [None, 25, 25, 32]

    """

    def __init__(
        self,
        filter_size=(3, 3),
        strides=(2, 2),
        padding='SAME',
        data_format='channels_last',
        name=None  # 'maxpool2d'
    ):
        super().__init__(name)
        self.filter_size = filter_size
        if strides is None:
            strides = filter_size
        self.strides = self._strides = strides
        self.padding = padding
        self.data_format = data_format

        self.build()
        self._built = True

        logging.info(
            "MaxPool2d %s: filter_size: %s strides: %s padding: %s" %
            (self.name, str(filter_size), str(strides), str(padding))
        )

    def __repr__(self):
        s = ('{classname}(filter_size={filter_size}' ', strides={strides}, padding={padding}')
        if self.name is not None:
            s += ', name=\'{name}\''
        s += ')'
        return s.format(classname=self.__class__.__name__, **self.__dict__)

    def build(self, inputs_shape=None):
        if self.data_format == 'channels_last':
            self.data_format = 'NHWC'
            self._strides = [1, self.strides[0], self.strides[1], 1]
        elif self.data_format == 'channels_first':
            self.data_format = 'NCHW'
            self._strides = [1, 1, self.strides[0], self.strides[1]]
        else:
            raise Exception("unsupported data format")

        self.max_pool = tl.ops.MaxPool(
            ksize=self.filter_size, strides=self._strides, padding=self.padding, data_format=self.data_format
        )

    def forward(self, inputs):
        outputs = self.max_pool(inputs)
        return outputs


class MeanPool2d(Module):
    """Mean pooling for 2D image [batch, height, width, channel].

    Parameters
    -----------
    filter_size : tuple of int
        (height, width) for filter size.
    strides : tuple of int
        (height, width) for strides.
    padding : str
        The padding method: 'VALID' or 'SAME'.
    data_format : str
        One of channels_last (default, [batch, height, width, channel]) or channels_first. The ordering of the dimensions in the inputs.
    name : None or str
        A unique layer name.

    Examples
    ---------
    With TensorLayer

    >>> net = tl.layers.Input([None, 50, 50, 32], name='input')
    >>> net = tl.layers.MeanPool2d(filter_size=(3, 3), strides=(2, 2), padding='SAME')(net)
    >>> output shape : [None, 25, 25, 32]

    """

    def __init__(
        self,
        filter_size=(3, 3),
        strides=(2, 2),
        padding='SAME',
        data_format='channels_last',
        name=None  # 'meanpool2d'
    ):
        super().__init__(name)
        self.filter_size = filter_size
        if strides is None:
            strides = filter_size
        self.strides = self._strides = strides
        self.padding = padding
        self.data_format = data_format

        self.build()
        self._built = True

        logging.info(
            "MeanPool2d %s: filter_size: %s strides: %s padding: %s" %
            (self.name, str(filter_size), str(strides), str(padding))
        )

    def __repr__(self):
        s = ('{classname}(filter_size={filter_size}' ', strides={strides}, padding={padding}')
        if self.name is not None:
            s += ', name=\'{name}\''
        s += ')'
        return s.format(classname=self.__class__.__name__, **self.__dict__)

    def build(self, inputs_shape=None):
        if self.data_format == 'channels_last':
            self.data_format = 'NHWC'
            self._strides = [1, self.strides[0], self.strides[1], 1]
        elif self.data_format == 'channels_first':
            self.data_format = 'NCHW'
            self._strides = [1, 1, self.strides[0], self.strides[1]]
        else:
            raise Exception("unsupported data format")
        self.avg_pool = tl.ops.AvgPool(
            ksize=self.filter_size, strides=self._strides, padding=self.padding, data_format=self.data_format
        )

    def forward(self, inputs):
        outputs = self.avg_pool(inputs)
        return outputs


class MaxPool3d(Module):
    """Max pooling for 3D volume.

    Parameters
    ------------
    filter_size : tuple of int
        Pooling window size.
    strides : tuple of int
        Strides of the pooling operation.
    padding : str
        The padding method: 'VALID' or 'SAME'.
    data_format : str
        One of channels_last (default, [batch, depth, height, width, channel]) or channels_first. The ordering of the dimensions in the inputs.
    name : None or str
        A unique layer name.

    Returns
    -------
    :class:`tf.Tensor`
        A max pooling 3-D layer with a output rank as 5.

    Examples
    ---------
    With TensorLayer

    >>> net = tl.layers.Input([None, 50, 50, 50, 32], name='input')
    >>> net = tl.layers.MaxPool3d(filter_size=(3, 3, 3), strides=(2, 2, 2), padding='SAME')(net)
    >>> output shape : [None, 25, 25, 25, 32]

    """

    def __init__(
        self,
        filter_size=(3, 3, 3),
        strides=(2, 2, 2),
        padding='VALID',
        data_format='channels_last',
        name=None  # 'maxpool3d'
    ):
        super().__init__(name)
        self.filter_size = filter_size
        self.strides = self._strides = strides
        self.padding = padding
        self.data_format = data_format

        self.build()
        self._built = True

        logging.info(
            "MaxPool3d %s: filter_size: %s strides: %s padding: %s" %
            (self.name, str(filter_size), str(strides), str(padding))
        )

    def __repr__(self):
        s = ('{classname}(filter_size={filter_size}' ', strides={strides}, padding={padding}')
        if self.name is not None:
            s += ', name=\'{name}\''
        s += ')'
        return s.format(classname=self.__class__.__name__, **self.__dict__)

    def build(self, inputs_shape=None):
        if self.data_format == 'channels_last':
            self.data_format = 'NDHWC'
            self._strides = [1, self.strides[0], self.strides[1], self.strides[2], 1]
        elif self.data_format == 'channels_first':
            self.data_format = 'NCDHW'
            self._strides = [1, 1, self.strides[0], self.strides[1], self.strides[2]]
        else:
            raise Exception("unsupported data format")

    def forward(self, inputs):
        outputs = tl.ops.max_pool3d(
            input=inputs,
            ksize=self.filter_size,
            strides=self._strides,
            padding=self.padding,
            data_format=self.data_format,
        )
        return outputs


class MeanPool3d(Module):
    """Mean pooling for 3D volume.

    Parameters
    ------------
    filter_size : tuple of int
        Pooling window size.
    strides : tuple of int
        Strides of the pooling operation.
    padding : str
        The padding method: 'VALID' or 'SAME'.
    data_format : str
        One of channels_last (default, [batch, depth, height, width, channel]) or channels_first. The ordering of the dimensions in the inputs.
    name : None or str
        A unique layer name.

    Returns
    -------
    :class:`tf.Tensor`
        A mean pooling 3-D layer with a output rank as 5.

    Examples
    ---------
    With TensorLayer

    >>> net = tl.layers.Input([None, 50, 50, 50, 32], name='input')
    >>> net = tl.layers.MeanPool3d(filter_size=(3, 3, 3), strides=(2, 2, 2), padding='SAME')(net)
    >>> output shape : [None, 25, 25, 25, 32]

    """

    def __init__(
        self,
        filter_size=(3, 3, 3),
        strides=(2, 2, 2),
        padding='VALID',
        data_format='channels_last',
        name=None  # 'meanpool3d'
    ):
        super().__init__(name)
        self.filter_size = filter_size
        self.strides = self._strides = strides
        self.padding = padding
        self.data_format = data_format

        self.build()
        self._built = True

        logging.info(
            "MeanPool3d %s: filter_size: %s strides: %s padding: %s" %
            (self.name, str(filter_size), str(strides), str(padding))
        )

    def __repr__(self):
        s = ('{classname}(filter_size={filter_size}' ', strides={strides}, padding={padding}')
        if self.name is not None:
            s += ', name=\'{name}\''
        s += ')'
        return s.format(classname=self.__class__.__name__, **self.__dict__)

    def build(self, inputs_shape=None):
        self._strides = [1, self.strides[0], self.strides[1], self.strides[2], 1]
        if self.data_format == 'channels_last':
            self.data_format = 'NDHWC'
        elif self.data_format == 'channels_first':
            self.data_format = 'NCDHW'
        else:
            raise Exception("unsupported data format")

    def forward(self, inputs):
        outputs = tl.ops.avg_pool3d(
            input=inputs,
            ksize=self.filter_size,
            strides=self._strides,
            padding=self.padding,
            data_format=self.data_format,
        )
        return outputs


class GlobalMaxPool1d(Module):
    """The :class:`GlobalMaxPool1d` class is a 1D Global Max Pooling layer.

    Parameters
    ------------
    data_format : str
        One of channels_last (default, [batch, length, channel]) or channels_first. The ordering of the dimensions in the inputs.
    name : None or str
        A unique layer name.

    Examples
    ---------
    With TensorLayer

    >>> net = tl.layers.Input([None, 100, 30], name='input')
    >>> net = tl.layers.GlobalMaxPool1d()(net)
    >>> output shape : [None, 30]

    """

    def __init__(
        self,
        data_format="channels_last",
        name=None  # 'globalmaxpool1d'
    ):
        super().__init__(name)

        self.data_format = data_format

        self.build()
        self._built = True

        logging.info("GlobalMaxPool1d %s" % self.name)

    def __repr__(self):
        s = '{classname}('
        if self.name is not None:
            s += 'name=\'{name}\''
        s += ')'
        return s.format(classname=self.__class__.__name__, **self.__dict__)

    def build(self, inputs_shape=None):
        if self.data_format == 'channels_last':
            self.reduce_max = tl.ReduceMax(axis=1)
        elif self.data_format == 'channels_first':
            self.reduce_max = tl.ReduceMax(axis=2)
        else:
            raise ValueError(
                "`data_format` should have one of the following values: [`channels_last`, `channels_first`]"
            )

    def forward(self, inputs):
        outputs = self.reduce_max(inputs)
        return outputs


class GlobalMeanPool1d(Module):
    """The :class:`GlobalMeanPool1d` class is a 1D Global Mean Pooling layer.

    Parameters
    ------------
    data_format : str
        One of channels_last (default, [batch, length, channel]) or channels_first. The ordering of the dimensions in the inputs.
    name : None or str
        A unique layer name.

    Examples
    ---------
    With TensorLayer

    >>> net = tl.layers.Input([None, 100, 30], name='input')
    >>> net = tl.layers.GlobalMeanPool1d()(net)
    >>> output shape : [None, 30]

    """

    def __init__(
        self,
        data_format='channels_last',
        name=None  # 'globalmeanpool1d'
    ):
        super().__init__(name)
        self.data_format = data_format

        self.build()
        self._built = True

        logging.info("GlobalMeanPool1d %s" % self.name)

    def __repr__(self):
        s = '{classname}('
        if self.name is not None:
            s += 'name=\'{name}\''
        s += ')'
        return s.format(classname=self.__class__.__name__, **self.__dict__)

    def build(self, inputs_shape=None):
        if self.data_format == 'channels_last':
            self.reduce_mean = tl.ReduceMean(axis=1)
        elif self.data_format == 'channels_first':
            self.reduce_mean = tl.ReduceMean(axis=2)
        else:
            raise ValueError(
                "`data_format` should have one of the following values: [`channels_last`, `channels_first`]"
            )

    def forward(self, inputs):
        outputs = self.reduce_mean(inputs)
        return outputs


class GlobalMaxPool2d(Module):
    """The :class:`GlobalMaxPool2d` class is a 2D Global Max Pooling layer.

    Parameters
    ------------
    data_format : str
        One of channels_last (default, [batch, height, width, channel]) or channels_first. The ordering of the dimensions in the inputs.
    name : None or str
        A unique layer name.

    Examples
    ---------
    With TensorLayer

    >>> net = tl.layers.Input([None, 100, 100, 30], name='input')
    >>> net = tl.layers.GlobalMaxPool2d()(net)
    >>> output shape : [None, 30]

    """

    def __init__(
        self,
        data_format='channels_last',
        name=None  # 'globalmaxpool2d'
    ):
        super().__init__(name)
        self.data_format = data_format

        self.build()
        self._built = True

        logging.info("GlobalMaxPool2d %s" % self.name)

    def __repr__(self):
        s = '{classname}('
        if self.name is not None:
            s += 'name=\'{name}\''
        s += ')'
        return s.format(classname=self.__class__.__name__, **self.__dict__)

    def build(self, inputs_shape=None):
        if self.data_format == 'channels_last':
            self.reduce_max = tl.ReduceMax(axis=[1, 2])
        elif self.data_format == 'channels_first':
            self.reduce_max = tl.ReduceMax(axis=[2, 3])
        else:
            raise ValueError(
                "`data_format` should have one of the following values: [`channels_last`, `channels_first`]"
            )

    def forward(self, inputs):
        outputs = self.reduce_max(inputs)
        return outputs


class GlobalMeanPool2d(Module):
    """The :class:`GlobalMeanPool2d` class is a 2D Global Mean Pooling layer.

    Parameters
    ------------
    data_format : str
        One of channels_last (default, [batch, height, width, channel]) or channels_first. The ordering of the dimensions in the inputs.
    name : None or str
        A unique layer name.

    Examples
    ---------
    With TensorLayer

    >>> net = tl.layers.Input([None, 100, 100, 30], name='input')
    >>> net = tl.layers.GlobalMeanPool2d()(net)
    >>> output shape : [None, 30]

    """

    def __init__(
        self,
        data_format='channels_last',
        name=None  # 'globalmeanpool2d'
    ):
        super().__init__(name)

        self.data_format = data_format

        self.build()
        self._built = True

        logging.info("GlobalMeanPool2d %s" % self.name)

    def __repr__(self):
        s = '{classname}('
        if self.name is not None:
            s += 'name=\'{name}\''
        s += ')'
        return s.format(classname=self.__class__.__name__, **self.__dict__)

    def build(self, inputs_shape=None):
        if self.data_format == 'channels_last':
            self.reduce_mean = tl.ReduceMean(axis=[1, 2])
        elif self.data_format == 'channels_first':
            self.reduce_mean = tl.ReduceMean(axis=[2, 3])
        else:
            raise ValueError(
                "`data_format` should have one of the following values: [`channels_last`, `channels_first`]"
            )

    def forward(self, inputs):
        outputs = self.reduce_mean(inputs)
        return outputs


class GlobalMaxPool3d(Module):
    """The :class:`GlobalMaxPool3d` class is a 3D Global Max Pooling layer.

    Parameters
    ------------
    data_format : str
        One of channels_last (default, [batch, depth, height, width, channel]) or channels_first. The ordering of the dimensions in the inputs.
    name : None or str
        A unique layer name.

    Examples
    ---------
    With TensorLayer

    >>> net = tl.layers.Input([None, 100, 100, 100, 30], name='input')
    >>> net = tl.layers.GlobalMaxPool3d()(net)
    >>> output shape : [None, 30]

    """

    def __init__(
        self,
        data_format='channels_last',
        name=None  # 'globalmaxpool3d'
    ):
        super().__init__(name)

        self.data_format = data_format

        self.build()
        self._built = True

        logging.info("GlobalMaxPool3d %s" % self.name)

    def __repr__(self):
        s = '{classname}('
        if self.name is not None:
            s += 'name=\'{name}\''
        s += ')'
        return s.format(classname=self.__class__.__name__, **self.__dict__)

    def build(self, inputs_shape=None):
        if self.data_format == 'channels_last':
            self.reduce_max = tl.ReduceMax(axis=[1, 2, 3])
        elif self.data_format == 'channels_first':
            self.reduce_max = tl.ReduceMax(axis=[2, 3, 4])
        else:
            raise ValueError(
                "`data_format` should have one of the following values: [`channels_last`, `channels_first`]"
            )

    def forward(self, inputs):
        outputs = self.reduce_max(inputs)
        return outputs


class GlobalMeanPool3d(Module):
    """The :class:`GlobalMeanPool3d` class is a 3D Global Mean Pooling layer.

    Parameters
    ------------
    data_format : str
        One of channels_last (default, [batch, depth, height, width, channel]) or channels_first. The ordering of the dimensions in the inputs.
    name : None or str
        A unique layer name.

    Examples
    ---------
    With TensorLayer

    >>> net = tl.layers.Input([None, 100, 100, 100, 30], name='input')
    >>> net = tl.layers.GlobalMeanPool3d()(net)
    >>> output shape : [None, 30]

    """

    def __init__(
        self,
        data_format='channels_last',
        name=None  # 'globalmeanpool3d'
    ):
        super().__init__(name)
        self.data_format = data_format

        self.build()
        self._built = True

        logging.info("GlobalMeanPool3d %s" % self.name)

    def __repr__(self):
        s = '{classname}('
        if self.name is not None:
            s += 'name=\'{name}\''
        s += ')'
        return s.format(classname=self.__class__.__name__, **self.__dict__)

    def build(self, inputs_shape=None):
        pass

    def forward(self, inputs):
        if self.data_format == 'channels_last':
            outputs = tl.reduce_mean(input_tensor=inputs, axis=[1, 2, 3])
        elif self.data_format == 'channels_first':
            outputs = tl.reduce_mean(input_tensor=inputs, axis=[2, 3, 4])
        else:
            raise ValueError(
                "`data_format` should have one of the following values: [`channels_last`, `channels_first`]"
            )
        return outputs


class CornerPool2d(Module):
    """Corner pooling for 2D image [batch, height, width, channel], see `here <https://arxiv.org/abs/1808.01244>`__.

    Parameters
    ----------
    mode : str
        TopLeft for the top left corner,
        Bottomright for the bottom right corner.
    name : None or str
        A unique layer name.

    Examples
    ---------
    With TensorLayer

    >>> net = tl.layers.Input([None, 32, 32, 8], name='input')
    >>> net = tl.layers.CornerPool2d(mode='TopLeft',name='cornerpool2d')(net)
    >>> output shape : [None, 32, 32, 8]

    """

    def __init__(
        self,
        mode='TopLeft',
        name=None  # 'cornerpool2d'
    ):
        super().__init__(name)
        self.mode = mode
        self.build()
        self._built = True

        logging.info("CornerPool2d %s : mode: %s" % (self.name, str(mode)))

    def __repr__(self):
        s = ('{classname}(mode={mode}')
        if self.name is not None:
            s += ', name=\'{name}\''
        s += ')'
        return s.format(classname=self.__class__.__name__, **self.__dict__)

    def build(self, inputs_shape=None):
        pass

    def forward(self, inputs):
        _, input_width, input_height, _ = tl.get_tensor_shape(inputs)
        # input_width = inputs.shape[2]
        # input_height = inputs.shape[1]
        batch_min = tl.reduce_min(inputs)
        if self.mode == 'TopLeft':
            temp_bottom = tl.pad(
                inputs, tl.constant([[0, 0], [0, input_height - 1], [0, 0], [0, 0]]), constant_values=batch_min
            )
            temp_right = tl.pad(
                inputs, tl.constant([[0, 0], [0, 0], [0, input_width - 1], [0, 0]]), constant_values=batch_min
            )
            temp_bottom = tl.ops.max_pool(temp_bottom, ksize=(input_height, 1), strides=(1, 1), padding='VALID')
            temp_right = tl.ops.max_pool(temp_right, ksize=(1, input_width), strides=(1, 1), padding='VALID')
            outputs = tl.add(temp_bottom, temp_right)  #, name=self.name)
        elif self.mode == 'BottomRight':
            temp_top = tl.pad(
                inputs, tl.constant([[0, 0], [input_height - 1, 0], [0, 0], [0, 0]]), constant_values=batch_min
            )
            temp_left = tl.pad(
                inputs, tl.constant([[0, 0], [0, 0], [input_width - 1, 0], [0, 0]]), constant_values=batch_min
            )
            temp_top = tl.ops.max_pool(temp_top, ksize=(input_height, 1), strides=(1, 1), padding='VALID')
            temp_left = tl.ops.max_pool(temp_left, ksize=(1, input_width), strides=(1, 1), padding='VALID')
            outputs = tl.add(temp_top, temp_left)
        else:
            outputs = tl.identity(inputs)
        return outputs


class AdaptiveMeanPool1d(Module):
    """The :class:`AdaptiveMeanPool1d` class is a 1D Adaptive Mean Pooling layer.

    Parameters
    ------------
    output_size : int
        The target output size. It must be an integer.
    data_format : str
        One of channels_last (default, [batch,  width, channel]) or channels_first. The ordering of the dimensions in the inputs.
    name : None or str
        A unique layer name.

    Examples
    ---------
    With TensorLayer

    >>> net = tl.layers.Input([None, 32, 3], name='input')
    >>> net = tl.layers.AdaptiveMeanPool1d(output_size=16)(net)
    >>> output shape : [None, 16, 3]

    """

    def __init__(self, output_size, data_format='channels_last', name=None):
        super(AdaptiveMeanPool1d, self).__init__(name)
        self.output_size = output_size
        self.data_format = data_format

        self.build()
        self._built = True

        logging.info("AdaptiveMeanPool1d %s: output_size: %s " % (self.name, str(output_size)))

    def __repr__(self):
        s = ('{classname}(output_size={output_size}')
        if self.name is not None:
            s += ', name=\'{name}\''
        s += ')'
        return s.format(classname=self.__class__.__name__, **self.__dict__)

    def build(self, inputs_shape=None):
        if self.data_format == 'channels_last':
            self.data_format = 'NWC'
        elif self.data_format == 'channels_first':
            self.data_format = 'NCW'
        else:
            raise Exception("unsupported data format")

        self.adaptivemeanpool1d = tl.ops.AdaptiveMeanPool1D(output_size=self.output_size, data_format=self.data_format)

    def forward(self, inputs):

        outputs = self.adaptivemeanpool1d(inputs)
        return outputs


class AdaptiveMeanPool2d(Module):
    """The :class:`AdaptiveMeanPool2d` class is a 2D Adaptive Mean Pooling layer.

    Parameters
    ------------
    output_size : int or list or  tuple
        The target output size. It cloud be an int \[int,int]\(int, int).
    data_format : str
        One of channels_last (default, [batch,  height, width, channel]) or channels_first. The ordering of the dimensions in the inputs.
    name : None or str
        A unique layer name.

    Examples
    ---------
    With TensorLayer

    >>> net = tl.layers.Input([None,32, 32, 3], name='input')
    >>> net = tl.layers.AdaptiveMeanPool2d(output_size=16)(net)
    >>> output shape : [None,16, 16, 3]

    """

    def __init__(self, output_size, data_format='channels_last', name=None):
        super(AdaptiveMeanPool2d, self).__init__(name)
        self.output_size = output_size
        self.data_format = data_format

        self.build()
        self._built = True

        logging.info("AdaptiveMeanPool2d %s: output_size: %s " % (self.name, str(output_size)))

    def __repr__(self):
        s = ('{classname}(output_size={output_size}')
        if self.name is not None:
            s += ', name=\'{name}\''
        s += ')'
        return s.format(classname=self.__class__.__name__, **self.__dict__)

    def build(self, inputs_shape=None):
        if self.data_format == 'channels_last':
            self.data_format = 'NHWC'
        elif self.data_format == 'channels_first':
            self.data_format = 'NCHW'
        else:
            raise Exception("unsupported data format")

        if isinstance(self.output_size, int):
            self.output_size = (self.output_size, ) * 2

        self.adaptivemeanpool2d = tl.ops.AdaptiveMeanPool2D(output_size=self.output_size, data_format=self.data_format)

    def forward(self, inputs):

        outputs = self.adaptivemeanpool2d(inputs)
        return outputs


class AdaptiveMeanPool3d(Module):
    """The :class:`AdaptiveMeanPool3d` class is a 3D Adaptive Mean Pooling layer.

        Parameters
        ------------
        output_size : int or list or  tuple
            The target output size. It cloud be an int \[int,int,int]\(int, int, int).
        data_format : str
            One of channels_last (default, [batch,  depth, height, width, channel]) or channels_first. The ordering of the dimensions in the inputs.
        name : None or str
            A unique layer name.

        Examples
        ---------
        With TensorLayer

        >>> net = tl.layers.Input([None,32, 32, 32, 3], name='input')
        >>> net = tl.layers.AdaptiveMeanPool3d(output_size=16)(net)
        >>> output shape : [None, 16, 16, 16, 3]

        """

    def __init__(self, output_size, data_format='channels_last', name=None):
        super(AdaptiveMeanPool3d, self).__init__(name)
        self.output_size = output_size
        self.data_format = data_format

        self.build()
        self._built = True

        logging.info("AdaptiveMeanPool3d %s: output_size: %s " % (self.name, str(output_size)))

    def __repr__(self):
        s = ('{classname}(output_size={output_size}')
        if self.name is not None:
            s += ', name=\'{name}\''
        s += ')'
        return s.format(classname=self.__class__.__name__, **self.__dict__)

    def build(self, inputs_shape=None):
        if self.data_format == 'channels_last':
            self.data_format = 'NDHWC'
        elif self.data_format == 'channels_first':
            self.data_format = 'NCDHW'
        else:
            raise Exception("unsupported data format")

        if isinstance(self.output_size, int):
            self.output_size = (self.output_size, ) * 3

        self.adaptivemeanpool3d = tl.ops.AdaptiveMeanPool3D(output_size=self.output_size, data_format=self.data_format)

    def forward(self, inputs):

        outputs = self.adaptivemeanpool3d(inputs)
        return outputs


class AdaptiveMaxPool1d(Module):
    """The :class:`AdaptiveMaxPool1d` class is a 1D Adaptive Max Pooling layer.

        Parameters
        ------------
        output_size : int
            The target output size. It must be an integer.
        data_format : str
            One of channels_last (default, [batch,  width, channel]) or channels_first. The ordering of the dimensions in the inputs.
        name : None or str
            A unique layer name.

        Examples
        ---------
        With TensorLayer

        >>> net = tl.layers.Input([None, 32, 3], name='input')
        >>> net = tl.layers.AdaptiveMaxPool1d(output_size=16)(net)
        >>> output shape : [None, 16, 3]

        """

    def __init__(self, output_size, data_format='channels_last', name=None):
        super(AdaptiveMaxPool1d, self).__init__(name)
        self.output_size = output_size
        self.data_format = data_format

        self.build()
        self._built = True

        logging.info("AdaptiveMaxPool1d %s: output_size: %s " % (self.name, str(output_size)))

    def __repr__(self):
        s = ('{classname}(output_size={output_size}')
        if self.name is not None:
            s += ', name=\'{name}\''
        s += ')'
        return s.format(classname=self.__class__.__name__, **self.__dict__)

    def build(self, inputs_shape=None):
        if self.data_format == 'channels_last':
            self.data_format = 'NWC'
        elif self.data_format == 'channels_first':
            self.data_format = 'NCW'
        else:
            raise Exception("unsupported data format")

        self.adaptivemaxpool1d = tl.ops.AdaptiveMaxPool1D(output_size=self.output_size, data_format=self.data_format)

    def forward(self, inputs):

        outputs = self.adaptivemaxpool1d(inputs)
        return outputs


class AdaptiveMaxPool2d(Module):
    """The :class:`AdaptiveMaxPool2d` class is a 2D Adaptive Max Pooling layer.

        Parameters
        ------------
        output_size : int or list or  tuple
            The target output size. It cloud be an int \[int,int]\(int, int).
        data_format : str
            One of channels_last (default, [batch, height, width, channel]) or channels_first. The ordering of the dimensions in the inputs.
        name : None or str
            A unique layer name.

        Examples
        ---------
        With TensorLayer

        >>> net = tl.layers.Input([None, 32, 32, 3], name='input')
        >>> net = tl.layers.AdaptiveMaxPool2d(output_size=16)(net)
        >>> output shape : [None, 16, 16, 3]

    """

    def __init__(self, output_size, data_format='channels_last', name=None):
        super(AdaptiveMaxPool2d, self).__init__(name)
        self.output_size = output_size
        self.data_format = data_format

        self.build()
        self._built = True

        logging.info("AdaptiveMaxPool1d %s: output_size: %s " % (self.name, str(output_size)))

    def __repr__(self):
        s = ('{classname}(output_size={output_size}')
        if self.name is not None:
            s += ', name=\'{name}\''
        s += ')'
        return s.format(classname=self.__class__.__name__, **self.__dict__)

    def build(self, inputs_shape=None):
        if self.data_format == 'channels_last':
            self.data_format = 'NHWC'
        elif self.data_format == 'channels_first':
            self.data_format = 'NCHW'
        else:
            raise Exception("unsupported data format")
        if isinstance(self.output_size, int):
            self.output_size = (self.output_size, ) * 2

        self.adaptivemaxpool2d = tl.ops.AdaptiveMaxPool2D(output_size=self.output_size, data_format=self.data_format)

    def forward(self, inputs):

        outputs = self.adaptivemaxpool2d(inputs)
        return outputs


class AdaptiveMaxPool3d(Module):
    """The :class:`AdaptiveMaxPool3d` class is a 3D Adaptive Max Pooling layer.

        Parameters
        ------------
        output_size : int or list or  tuple
            The target output size. It cloud be an int \[int,int,int]\(int, int, int).
        data_format : str
            One of channels_last (default, [batch,  depth, height, width, channel]) or channels_first. The ordering of the dimensions in the inputs.
        name : None or str
            A unique layer name.

        Examples
        ---------
        With TensorLayer

        >>> net = tl.layers.Input([None,32, 32, 32, 3], name='input')
        >>> net = tl.layers.AdaptiveMaxPool3d(output_size=16)(net)
        >>> output shape : [None, 16, 16, 16, 3]

        """

    def __init__(self, output_size, data_format='channels_last', name=None):
        super(AdaptiveMaxPool3d, self).__init__(name)
        self.output_size = output_size
        self.data_format = data_format

        self.build()
        self._built = True

        logging.info("AdaptiveMaxPool3d %s: output_size: %s " % (self.name, str(output_size)))

    def __repr__(self):
        s = ('{classname}(output_size={output_size}')
        if self.name is not None:
            s += ', name=\'{name}\''
        s += ')'
        return s.format(classname=self.__class__.__name__, **self.__dict__)

    def build(self, inputs_shape=None):
        if self.data_format == 'channels_last':
            self.data_format = 'NDHWC'
        elif self.data_format == 'channels_first':
            self.data_format = 'NCDHW'
        else:
            raise Exception("unsupported data format")

        if isinstance(self.output_size, int):
            self.output_size = (self.output_size, ) * 3

        self.adaptivemaxpool3d = tl.ops.AdaptiveMaxPool3D(output_size=self.output_size, data_format=self.data_format)

    def forward(self, inputs):

        outputs = self.adaptivemaxpool3d(inputs)
        return outputs