mindspore 1.10.0__cp37-none-any.whl → 2.0.0rc1__cp37-none-any.whl

mindspore/nn/layer/padding.py

@@ -17,21 +17,33 @@ from __future__ import absolute_import
 
 from mindspore.common import Tensor
 from mindspore import ops
-from mindspore.ops.primitive import constexpr
+from mindspore.ops.operations import nn_ops
+from mindspore.ops.primitive import constexpr, _primexpr
 from mindspore.nn.cell import Cell
 
-__all__ = ['ConstantPad1d', 'ConstantPad2d', 'ConstantPad3d', 'ReflectionPad1d', 'ReflectionPad2d', 'ZeroPad2d']
+__all__ = ['ConstantPad1d', 'ConstantPad2d', 'ConstantPad3d', 'ReflectionPad1d', 'ReflectionPad2d', 'ReflectionPad3d',
+           'ZeroPad2d', 'ReplicationPad1d', 'ReplicationPad2d', 'ReplicationPad3d']
 
 
-@constexpr
+def _check_dim(dim, target1, target2, cls_name):
+    """check dim"""
+    def _check_func():
+        if dim not in (target1, target2):
+            raise ValueError(f"For '{cls_name}', the in_shape must have {target1} or {target2} dims, but got {dim}.")
+    _check_func()
+
+
+@_primexpr
 def _check_padding_dimension(dimension, padding):
     r"""
-    Validate the input padding and add place holders if needed.
+    Validate the input padding and add placeholders if needed.
     Note: the input 'padding' in this function is already converted to list of lists to match MirrorPad
     """
-    if dimension < len(padding):
-        raise ValueError(f"For padding with length {len(padding) * 2}, the dimension of the tensor should be at least "
-                         f"{len(padding)}, but got {dimension}")
+    def _check_padding(dimension, padding):
+        if dimension < len(padding):
+            raise ValueError(f"For padding with length {len(padding) * 2}, the dimension of the tensor should "
+                             f"be at least {len(padding)}, but got {dimension}")
+    _check_padding(dimension, padding)
     # add place holders
     if dimension > len(padding):
         padding = [(0, 0) for _ in range(dimension - len(padding))] + [x for x in padding]
@@ -40,7 +52,7 @@ def _check_padding_dimension(dimension, padding):
 
 def _swap_to_ms_padding_order(padding):
     r"""
-    Check whether the input padding is a tuple or a int converted to a tuple.
+    Check whether the input padding is a tuple or an int converted to a tuple.
     Check if the length of padding is divisible by 2.
     Convert the input padding to the format that MirrorPad would understand.
     """
@@ -53,16 +65,33 @@ def _swap_to_ms_padding_order(padding):
     return new_padding
 
 
-@constexpr
+@_primexpr
 def _check(input_shape, padding, name):
     """
     Check relationship between input shape and padding to make sure after negative dimension padding the out is
     positive.
     """
-    if len(input_shape) < len(padding):
-        msg = "For '{}', the dimension of input must more than or equal to len(padding)/2, " \
-              "but got {}".format(name, len(input_shape))
-        raise ValueError(msg)
+    def _check_len(input_shape, padding):
+        if len(input_shape) < len(padding):
+            msg = "For '{}', the dimension of input must more than or equal to len(padding)/2, " \
+                "but got {}".format(name, len(input_shape))
+            raise ValueError(msg)
+
+    def _check_item(item, input_shape, index, dim_name):
+        if item < -input_shape[index]:
+            msg = "For '{}', the shape of input after padding must be positive, the input shape is {}, " \
+                  "value of parameter 'padding' applied to the {} dimension of input must " \
+                  "no less than -{}, but got {}".format(name, input_shape, dim_name, input_shape[index], item)
+            raise ValueError(msg)
+
+    def _check_item_two(item0, item1, input_shape, index, dim_name):
+        if input_shape[index] + item0 + item1 <= 0:
+            msg = "For '{}', the shape of input after padding must be positive, the input shape is {}, " \
+                  "but the {} dimension of input shape {} plus padding {} and {} resulted in a non-positive output " \
+                  "shape.".format(name, input_shape, dim_name, input_shape[index], item0, item1)
+            raise ValueError(msg)
+
+    _check_len(input_shape, padding)
     if len(input_shape) > len(padding):
         if len(padding) == 2 and isinstance(padding[0], int):
             padding = [(0, 0) for i in range(len(input_shape) - 1)] + [padding]
@@ -78,21 +107,9 @@ def _check(input_shape, padding, name):
         else:
             dim_name = str(index + 1) + 'th'
 
-        if item[0] < -input_shape[index]:
-            msg = "For '{}', the shape of input after padding must be positive, the input shape is {}, " \
-                  "value of parameter 'padding' applied to the {} dimension of input must " \
-                  "no less than -{}, but got {}".format(name, input_shape, dim_name, input_shape[index], item[0])
-            raise ValueError(msg)
-        if item[1] < -input_shape[index]:
-            msg = "For '{}', the shape of input after padding must be positive, the input shape is {}, " \
-                  "value of parameter 'padding' applied to the {} dimension of input must " \
-                  "no less than -{}, but got {}".format(name, input_shape, dim_name, input_shape[index], item[1])
-            raise ValueError(msg)
-        if input_shape[index] + item[0] + item[1] <= 0:
-            msg = "For '{}', the shape of input after padding must be positive, the input shape is {}, " \
-                  "but the {} dimension of input shape {} plus padding {} and {} resulted in a non-positive output " \
-                  "shape.".format(name, input_shape, dim_name, input_shape[index], item[0], item[1])
-            raise ValueError(msg)
+        _check_item(item[0], input_shape, index, dim_name)
+        _check_item(item[1], input_shape, index, dim_name)
+        _check_item_two(item[0], item[1], input_shape, index, dim_name)
     return padding
 
 
@@ -113,7 +130,7 @@ def _get_new_padding(padding):
     return new_padding, start, end
 
 
-@constexpr
+@_primexpr
 def _get_begin_size(shape, begin, end):
     """Calculate begin and size for ops.Slice."""
     size = tuple([shape[i] + begin[i] + end[i] for i in range(len(shape))])
@@ -126,12 +143,7 @@ class _ConstantPadNd(Cell):
     Using a given value to pads the last n dimensions of input tensor.
 
     Args:
-        padding(tuple, list): The padding size to pad the last n dimensions of input tensor. The padding
-            sequence is starting from the last dimension and moving forward. The length of padding must be
-            a multiple of 2. len(padding)/2 dimensions of input will be padded.
-        value(union[int, float]): Padding value.
-
-         padding (union[list, tuple]): The padding size to pad the last n dimensions of input tensor.
+        padding (union[list, tuple]): The padding size to pad the last n dimensions of input tensor.
             The padding sequence is starting from the last dimension and moving forward.
             The length of padding must be a multiple of 2. If padding is :math:`(padding_0, padding_1, padding_2,
             padding_3, ..., padding_2m, padding_{2m+1}, ...)`. The input is `x`,
@@ -185,7 +197,7 @@ class _ConstantPadNd(Cell):
                 raise ValueError(msg)
 
         else:
-            msg = "For '{}', the type of parameter 'padding' must be in [int, float], " \
+            msg = "For '{}', the type of parameter 'padding' must be in [int, tuple], " \
                   "but got {}".format(name, type(padding))
             raise TypeError(msg)
 
@@ -201,13 +213,12 @@ class _ConstantPadNd(Cell):
     def construct(self, x):
         """Construct the pad net."""
         input_shape = x.shape
-        input_type = x.dtype
         padding = _check(input_shape, self.padding, self._name)
         new_padding, start, end = _get_new_padding(padding)
-        mask = ops.Ones()(input_shape, input_type)
+        mask = ops.OnesLike()(x)
         output = ops.Pad(new_padding)(x)
         mask = ops.Pad(new_padding)(mask)
-        ones = ops.Ones()(output.shape, output.dtype)
+        ones = ops.OnesLike()(output)
         value = ops.Fill()(output.dtype, output.shape, self.value)
         output = ops.Add()(ops.Mul()(mask, output), ops.Mul()(ops.Sub()(ones, mask), value))
         slice_op = ops.Slice()
@@ -430,6 +441,8 @@ class _ReflectionPadNd(Cell):
 
     def construct(self, x):
         input_shape = x.shape
+        if not self.padding:
+            return x
         padding = _check_padding_dimension(len(input_shape), self.padding)
         x = ops.MirrorPad(mode='REFLECT')(x, Tensor(padding))
         return x
@@ -442,14 +455,14 @@ class ReflectionPad1d(_ReflectionPadNd):
     Args:
         padding (union[int, tuple]): The padding size to pad the last dimension of input tensor.
             If padding is an integer: all directions will be padded with the same size.
-            If padding is a tuple: uses :math:`(pad_{left}, pad_{right})` to pad.
+            If padding is a tuple: uses :math:`(pad\_left, pad\_right)` to pad.
 
     Inputs:
         - **x** (Tensor) - 2D or 3D, shape: :math:`(C, W_{in})` or :math:`(N, C, W_{in})`.
 
     Outputs:
         Tensor, after padding. Shape: :math:`(C, W_{out})` or :math:`(N, C, W_{out})`,
-        where :math:`W_{out} = W_{in} + pad_{left} + pad_{right}`.
+        where :math:`W_{out} = W_{in} + pad\_left + pad\_right`.
 
     Raises:
         TypeError: If 'padding' is not a tuple or int.
@@ -494,7 +507,7 @@ class ReflectionPad2d(_ReflectionPadNd):
             If padding is a tuple: uses :math:`(pad\_left, pad\_right, pad\_up, pad\_down)` to pad.
 
     Inputs:
-        - **x** (Tensor) - 3D or 4D, shape: :math:`(C, H_{in}, W_{out})` or :math:`(N, C, H_{out}, W_{out})`.
+        - **x** (Tensor) - 3D or 4D, shape: :math:`(C, H_{in}, W_{in})` or :math:`(N, C, H_{in}, W_{in})`.
 
     Outputs:
         Tensor, after padding. Shape: :math:`(C, H_{out}, W_{out})` or :math:`(N, C, H_{out}, W_{out})`,
@@ -537,6 +550,70 @@ class ReflectionPad2d(_ReflectionPadNd):
         super(ReflectionPad2d, self).__init__(padding, 'ReflectionPad2d')
 
 
+class ReflectionPad3d(_ReflectionPadNd):
+    r"""
+    Pad the given tensor in a reflecting way using the input boundaries as the axis of symmetry.
+
+    Note:
+        ReflectionPad3d has not supported 5D tensor yet.
+
+    Args:
+        padding (union[int, tuple]): The padding size to pad the input tensor.
+            If padding is an integer: all directions will be padded with the same size.
+            If padding is a tuple: uses :math:`(pad\_left, pad\_right, pad\_up, pad\_down, pad\_front, pad\_back)`
+            to pad.
+
+    Inputs:
+        - **x** (Tensor) - 4D Tensor, shape: :math:`(N, D_{in}, H_{in}, W_{in})`.
+
+    Outputs:
+        Tensor, after padding. Shape: :math:`(N, D_{out}, H_{out}, W_{out})`,
+        where :math:`D_{out} = D_{in} + pad\_front + pad\_back`, :math:`H_{out} = H_{in} + pad\_up + pad\_down`
+        :math:`W_{out} = W_{in} + pad\_left + pad\_right`.
+
+    Raises:
+        TypeError: If 'padding' is not a tuple or int.
+        TypeError: If there is an element in 'padding' that is not int.
+        ValueError: If the length of 'padding' is not divisible by 2.
+        ValueError: If there is an element in 'padding' that is negative.
+        ValueError: If the there is a dimension mismatch between the padding and the tensor.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor
+        >>> from mindspore.nn import ReflectionPad3d
+        >>> arr = np.arange(8).astype(np.float32).reshape((1, 2, 2, 2))
+        >>> x = Tensor(arr)
+        >>> # x has shape (1, 2, 2, 2)
+        >>> padding = (1, 1, 1, 0, 0, 1)
+        >>> pad3d = ReflectionPad3d(padding)
+        >>> out = pad3d(x)
+        >>> # The first dimension of x remains the same.
+        >>> # The second dimension of x: D_out = D_in + pad_front + pad_back = 2 + 0 + 1 = 3
+        >>> # The third dimension of x: H_out = H_in + pad_up + pad_down = 2 + 1 + 0 = 3
+        >>> # The last dimension of x: W_out = W_in + pad_left + pad_right = 2 + 1 + 1 = 4
+        >>> # The shape of out is (1, 3, 3, 4)
+        >>> print(out)
+        [[[[3. 2. 3. 2.]
+           [1. 0. 1. 0.]
+           [3. 2. 3. 2.]]
+          [[7. 6. 7. 6.]
+           [5. 4. 5. 4.]
+           [7. 6. 7. 6.]]
+          [[3. 2. 3. 2.]
+           [1. 0. 1. 0.]
+           [3. 2. 3. 2.]]]]
+    """
+
+    def __init__(self, padding):
+        if isinstance(padding, int):
+            padding = (padding, padding, padding, padding, padding, padding)
+        super(ReflectionPad3d, self).__init__(padding, 'ReflectionPad3d')
+
+
 class ZeroPad2d(_ConstantPadNd):
     r"""
     Pads the last two dimensions of input tensor with zero.
@@ -585,3 +662,254 @@ class ZeroPad2d(_ConstantPadNd):
     def __init__(self, padding):
         value = 0
         super(ZeroPad2d, self).__init__(padding, value, name='ZeroPad2d')
+
+
+class _ReplicationPadNd(Cell):
+    r"""
+    Using a given padding to do replication pad on the given tensor.
+    Work as a parent class, and only accepts tuple as padding input.
+    """
+
+    def __init__(self, padding, name="ReplicationPadNd"):
+        super(_ReplicationPadNd, self).__init__()
+        self.name = name
+        if not isinstance(padding, tuple):
+            raise TypeError(f"For '{self.name}' the input 'padding' must be an integer or tuple, "
+                            f"but got {type(padding).__name__}")
+        if len(padding) % 2 != 0:
+            raise ValueError(f"For '{self.name}' the length of input 'padding' must be divisible by 2, "
+                             f"but got padding of length {len(padding)}. ")
+        if not all(isinstance(i, int) for i in padding):
+            raise TypeError(f"For '{self.name}' every element in 'padding' must be integer, "
+                            f"but got {padding}. ")
+        self.padding = padding
+        self.padv3 = nn_ops.PadV3(mode="edge")
+
+    @staticmethod
+    @_primexpr
+    def _check_input_dim(shape, cls_name):
+        raise NotImplementedError
+
+    @staticmethod
+    @constexpr
+    def _need_expend_dim(x):
+        raise NotImplementedError
+
+    def construct(self, x):
+        self._check_input_dim(x.shape, self.name)
+        need_expend_dims = self._need_expend_dim(x)
+        if need_expend_dims:
+            x = x.expand_dims(0)
+            x = self.padv3(x, self.padding, None)
+            x = x.squeeze(0)
+        else:
+            x = self.padv3(x, self.padding, None)
+        return x
+
+
+class ReplicationPad1d(_ReplicationPadNd):
+    r"""
+    Pad on W dimension of input `x` according to `padding`.
+
+    Args:
+        padding (union[int, tuple]): The padding size to pad the last dimension of `x` .
+
+            - If `padding` is an integer, all directions will be padded with the same size.
+            - If `padding` is a tuple, uses :math:`(pad_{left}, pad_{right})` to pad.
+
+    Inputs:
+        - **x** (Tensor) - 2D or 3D, shape: :math:`(C, W_{in})` or :math:`(N, C, W_{in})`.
+
+    Outputs:
+        Tensor, after padding. Shape: :math:`(C, W_{out})` or :math:`(N, C, W_{out})`,
+        where :math:`W_{out} = W_{in} + pad_{left} + pad_{right}`
+
+    Raises:
+        TypeError: If `padding` is neither a tuple nor an int.
+        TypeError: If there is an element in `padding` that is not int.
+        ValueError: If `padding` is tuple and the length of `padding` is not divisible by 2.
+        ValueError: If `padding` is tuple and there is a dimension mismatch between the padding and the tensor.
+
+    Supported Platforms:
+        ``GPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> import mindspore
+        >>> from mindspore import Tensor
+        >>> from mindspore.nn import ReplicationPad1d
+        >>> pad1d = ReplicationPad1d(2)
+        >>> input = Tensor(np.arange(0, 8).reshape(1, 2, 4), mindspore.float32)
+        >>> print(input)
+        [[[0. 1. 2. 3.]
+          [4. 5. 6. 7.]]]
+        >>> out = pad1d(input)
+        >>> print(out)
+        [[[0. 0. 0. 1. 2. 3. 3. 3.]
+          [4. 4. 4. 5. 6. 7. 7. 7.]]]
+        >>> pad1d = ReplicationPad1d((3, 1))
+        >>> out = pad1d(input)
+        >>> print(out)
+        [[[0. 0. 0. 0. 1. 2. 3. 3.]
+          [4. 4. 4. 4. 5. 6. 7. 7.]]]
+    """
+
+    def __init__(self, padding):
+        if isinstance(padding, int):
+            padding = (padding, padding)
+        super(ReplicationPad1d, self).__init__(padding, name="ReplicationPad1d")
+
+    @staticmethod
+    @_primexpr
+    def _check_input_dim(shape, cls_name):
+        dim = len(shape)
+        _check_dim(dim, 2, 3, cls_name)
+
+    def _need_expend_dim(self, x):
+        input_shape = x.shape
+        return 1 if len(input_shape) == 2 else 0
+
+
+class ReplicationPad2d(_ReplicationPadNd):
+    r"""
+    Pad on HW dimension of input `x` according to `padding`.
+
+    Args:
+        padding (union[int, tuple]): The padding size to pad the last two dimension of `x` .
+
+            - If `padding` is an integer, all directions will be padded with the same size.
+            - If `padding` is a tuple, uses :math:`(pad_{left}, pad_{right}, pad_{up}, pad_{down})` to pad.
+
+    Inputs:
+        - **x** (Tensor) - 3D or 4D, shape: :math:`(C, H_{in}, W_{in})` or :math:`(N, C, H_{in}, W_{in})`.
+
+    Outputs:
+        Tensor, after padding. Shape: :math:`(C, H_{out}, W_{out})` or :math:`(N, C, H_{out}, W_{out})`,
+        where :math:`H_{out} = H_{in} + pad_{up} + pad_{down}`, :math:`W_{out} = W_{in} + pad_{left} + pad_{right}`.
+
+    Raises:
+        TypeError: If `padding` is neither a tuple nor an int.
+        TypeError: If there is an element in `padding` that is not int.
+        ValueError: If `padding` is tuple and the length of `padding` is not divisible by 2.
+        ValueError: If `padding` is tuple and there is a dimension mismatch between the padding and the tensor.
+
+    Supported Platforms:
+        ``GPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> import mindspore
+        >>> from mindspore import Tensor
+        >>> from mindspore.nn import ReplicationPad2d
+        >>> pad2d = ReplicationPad2d(2)
+        >>> input = Tensor(np.arange(0, 9).reshape(1, 1, 3, 3), mindspore.float32)
+        >>> print(input)
+        [[[[0. 1. 2.]
+           [3. 4. 5.]
+           [6. 7. 8.]]]]
+        >>> out = pad2d(input)
+        >>> print(out)
+        [[[[0. 0. 0. 1. 2. 2. 2.]
+           [0. 0. 0. 1. 2. 2. 2.]
+           [0. 0. 0. 1. 2. 2. 2.]
+           [3. 3. 3. 4. 5. 5. 5.]
+           [6. 6. 6. 7. 8. 8. 8.]
+           [6. 6. 6. 7. 8. 8. 8.]
+           [6. 6. 6. 7. 8. 8. 8.]]]]
+        >>> pad2d = ReplicationPad2d((1, 1, 2, 0))
+        >>> out = pad2d(input)
+        >>> print(out)
+        [[[[0. 0. 1. 2. 2.]
+           [0. 0. 1. 2. 2.]
+           [0. 0. 1. 2. 2.]
+           [3. 3. 4. 5. 5.]
+           [6. 6. 7. 8. 8.]]]]
+    """
+
+    def __init__(self, padding):
+        if isinstance(padding, int):
+            padding = (padding, padding, padding, padding)
+        super(ReplicationPad2d, self).__init__(padding, name="ReplicationPad2d")
+
+    @staticmethod
+    @_primexpr
+    def _check_input_dim(shape, cls_name):
+        dim = len(shape)
+        _check_dim(dim, 3, 4, cls_name)
+
+    def _need_expend_dim(self, x):
+        input_shape = x.shape
+        return 1 if len(input_shape) == 3 else 0
+
+
+class ReplicationPad3d(_ReplicationPadNd):
+    r"""
+    Pad on DHW dimension of input `x` according to `padding`.
+
+    Args:
+        padding (union[int, tuple]): The padding size to pad the last three dimension of `x` .
+
+            - If `padding` is an integer, all directions will be padded with the same size.
+            - If `padding` is a tuple, uses :math:`(pad_{left}, pad_{right}, pad_{up}, pad_{down},
+              pad_{front}, pad_{back})` to pad.
+
+    Inputs:
+        - **x** (Tensor) - 4D or 5D,
+          shape: :math:`(C, D_{in}, H_{in}, W_{in})` or :math:`(N, C, D_{in}, H_{in}, W_{in})`.
+
+    Outputs:
+        Tensor, after padding, shape: :math:`(C, D_{out}, H_{out}, W_{out})` or
+        :math:`(N, C, D_{out}, H_{out}, W_{out})`, where
+        :math:`D_{out} = D_{in} + pad_{front} + pad_{back}`,
+        :math:`H_{out} = H_{in} + pad_{up} + pad_{down}`,
+        :math:`W_{out} = W_{in} + pad_{left} + pad_{right}`.
+
+    Raises:
+        TypeError: If `padding` is neither a tuple nor an int.
+        TypeError: If there is an element in `padding` that is not int.
+        ValueError: If `padding` is tuple and the length of `padding` is not divisible by 2.
+        ValueError: If `padding` is tuple and there is a dimension mismatch between the padding and the tensor.
+
+    Supported Platforms:
+        ``GPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> import mindspore
+        >>> from mindspore import Tensor
+        >>> from mindspore.nn import ReplicationPad3d
+        >>> pad3d = ReplicationPad3d(1)
+        >>> input = Tensor(np.arange(0, 9).reshape(1, 1, 1, 3, 3), mindspore.float32)
+        >>> out = pad3d(input)
+        >>> print(out)
+        [[[[[0. 0. 1. 2. 2.]
+            [0. 0. 1. 2. 2.]
+            [3. 3. 4. 5. 5.]
+            [6. 6. 7. 8. 8.]
+            [6. 6. 7. 8. 8.]]
+           [[0. 0. 1. 2. 2.]
+            [0. 0. 1. 2. 2.]
+            [3. 3. 4. 5. 5.]
+            [6. 6. 7. 8. 8.]
+            [6. 6. 7. 8. 8.]]
+           [[0. 0. 1. 2. 2.]
+            [0. 0. 1. 2. 2.]
+            [3. 3. 4. 5. 5.]
+            [6. 6. 7. 8. 8.]
+            [6. 6. 7. 8. 8.]]]]]
+    """
+
+    def __init__(self, padding):
+        if isinstance(padding, int):
+            padding = (padding, padding, padding, padding, padding, padding)
+        super(ReplicationPad3d, self).__init__(padding, name="ReplicationPad3d")
+
+    @staticmethod
+    @_primexpr
+    def _check_input_dim(shape, cls_name):
+        dim = len(shape)
+        _check_dim(dim, 4, 5, cls_name)
+
+    def _need_expend_dim(self, x):
+        input_shape = x.shape
+        return 1 if len(input_shape) == 4 else 0