mindspore 2.0.0rc1__cp38-none-any.whl → 2.2.0__cp38-none-any.whl

mindspore/nn/layer/padding.py

@@ -73,22 +73,22 @@ def _check(input_shape, padding, name):
     """
     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))
+            msg = f"For '{name}', the dimension of input must more than or equal to len(padding)/2, " \
+                  f"but got {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)
+            msg = f"For '{name}', the shape of input after padding must be positive, the input shape is " \
+                  f"{input_shape}, value of parameter 'padding' applied to the {dim_name} dimension of input must " \
+                  f"no less than -{input_shape[index]}, but got {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)
+            msg = f"For '{name}', the shape of input after padding must be positive, the input shape is " \
+                  f"{input_shape}, but the {dim_name} dimension of input shape {input_shape[index]} plus padding " \
+                  f"{item0} and {item1} resulted in a non-positive output shape."
             raise ValueError(msg)
 
     _check_len(input_shape, padding)
@@ -113,13 +113,14 @@ def _check(input_shape, padding, name):
     return padding
 
 
-@constexpr
+@_primexpr
 def _get_new_padding(padding):
     """get non-negative padding and make negative position."""
     new_padding = [[item[0], item[1]] for item in padding]
     start = [0 for i in range(len(new_padding))]
     end = [0 for i in range(len(new_padding))]
-    for index, item in enumerate(new_padding):
+    for index in range(len(new_padding)):
+        item = new_padding[index]
         if item[0] < 0:
             start[index] = item[0]
             new_padding[index][0] = 0
@@ -180,30 +181,30 @@ class _ConstantPadNd(Cell):
 
         elif isinstance(padding, tuple):
             if len(padding) % 2 != 0:
-                msg = "For '{}', the length of parameter 'padding' with tuple type must be a multiple of 2, " \
-                      "but got {}".format(name, len(padding))
+                msg = f"For '{name}', the length of parameter 'padding' with tuple type must be a multiple of 2, " \
+                      f"but got {len(padding)}"
                 raise ValueError(msg)
             if name == 'ConstantPad1d' and len(padding) != 2:
-                msg = "For '{}', the length of parameter 'padding' with tuple type must equal to 2." \
-                      "but got {}".format(name, len(padding))
+                msg = f"For '{name}', the length of parameter 'padding' with tuple type must equal to 2." \
+                      f"but got {len(padding)}"
                 raise ValueError(msg)
             if name in ['ConstantPad2d', 'ZeroPad2d'] and len(padding) > 4:
-                msg = "For '{}', the length of parameter 'padding' with tuple type must no more than 4." \
-                      "but got {}".format(name, len(padding))
+                msg = f"For '{name}', the length of parameter 'padding' with tuple type must no more than 4." \
+                      f"but got {len(padding)}"
                 raise ValueError(msg)
             if name == 'ConstantPad3d' and len(padding) > 6:
-                msg = "For '{}', the length of parameter 'padding' with tuple type must no more than 6." \
-                      "but got {}".format(name, len(padding))
+                msg = f"For '{name}', the length of parameter 'padding' with tuple type must no more than 6." \
+                      f"but got {len(padding)}"
                 raise ValueError(msg)
 
         else:
-            msg = "For '{}', the type of parameter 'padding' must be in [int, tuple], " \
-                  "but got {}".format(name, type(padding))
+            msg = f"For '{name}', the type of parameter 'padding' must be in [int, tuple], " \
+                  f"but got {type(padding)}"
             raise TypeError(msg)
 
         if not isinstance(value, (int, float)):
-            msg = "For '{}', the type of parameter 'value' must be in [int, float], " \
-                  "but got {}".format(name, type(value))
+            msg = f"For '{name}', the type of parameter 'value' must be in [int, float], " \
+                  f"but got {type(value)}"
             raise TypeError(msg)
 
         self.value = value
@@ -219,7 +220,7 @@ class _ConstantPadNd(Cell):
         output = ops.Pad(new_padding)(x)
         mask = ops.Pad(new_padding)(mask)
         ones = ops.OnesLike()(output)
-        value = ops.Fill()(output.dtype, output.shape, self.value)
+        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()
         begin, size = _get_begin_size(output.shape, start, end)
@@ -253,14 +254,13 @@ class ConstantPad1d(_ConstantPadNd):
 
     Examples:
         >>> import numpy as np
-        >>> from mindspore import Tensor
-        >>> from mindspore.nn import ConstantPad1d
+        >>> import mindspore as ms
         >>> x = np.ones(shape=(1, 2, 3, 4)).astype(np.float32)
-        >>> x = Tensor(x)
+        >>> x = ms.Tensor(x)
         >>> # padding is tuple
         >>> padding = (0, 1)
         >>> value = 0.5
-        >>> pad1d = ConstantPad1d(padding, value)
+        >>> pad1d = ms.nn.ConstantPad1d(padding, value)
         >>> out = pad1d(x)
         >>> print(out)
         [[[[1.  1.  1.  1.  0.5]
@@ -274,7 +274,7 @@ class ConstantPad1d(_ConstantPadNd):
         >>> # padding is int
         >>> padding = 1
         >>> value = 0.5
-        >>> pad1d = ConstantPad1d(padding, value)
+        >>> pad1d = ms.nn.ConstantPad1d(padding, value)
         >>> out = pad1d(x)
         >>> print(out)
         [[[[0.5 1.  1.  1.  1.  0.5]
@@ -288,7 +288,7 @@ class ConstantPad1d(_ConstantPadNd):
         >>> # padding is negative
         >>> padding = (-1, 0)
         >>> value = 0.5
-        >>> pad1d = ConstantPad1d(padding, value)
+        >>> pad1d = ms.nn.ConstantPad1d(padding, value)
         >>> out = pad1d(x)
         >>> print(out)
         [[[[1. 1. 1.]
@@ -332,13 +332,12 @@ class ConstantPad2d(_ConstantPadNd):
 
     Examples:
         >>> import numpy as np
-        >>> from mindspore import Tensor
-        >>> from mindspore.nn import ConstantPad2d
+        >>> import mindspore as ms
         >>> x = np.ones(shape=(1, 2, 3, 4)).astype(np.float32)
-        >>> x = Tensor(x)
+        >>> x = ms.Tensor(x)
         >>> padding = (-1, 1, 0, 1)
         >>> value = 0.5
-        >>> pad2d = ConstantPad2d(padding, value)
+        >>> pad2d = ms.nn.ConstantPad2d(padding, value)
         >>> out = pad2d(x)
         >>> print(out)
         [[[[1.  1.  1.  0.5]
@@ -386,13 +385,12 @@ class ConstantPad3d(_ConstantPadNd):
 
     Examples:
         >>> import numpy as np
-        >>> from mindspore import Tensor
-        >>> from mindspore.nn import ConstantPad3d
+        >>> import mindspore as ms
         >>> x = np.ones(shape=(1, 2, 3, 4)).astype(np.float32)
-        >>> x = Tensor(x)
+        >>> x = ms.Tensor(x)
         >>> padding = (-1, 1, 0, 1, 1, 0)
         >>> value = 0.5
-        >>> pad3d = ConstantPad3d(padding, value)
+        >>> pad3d = ms.nn.ConstantPad3d(padding, value)
         >>> out = pad3d(x)
         >>> print(out)
         [[[[0.5 0.5 0.5 0.5]
@@ -476,14 +474,13 @@ class ReflectionPad1d(_ReflectionPadNd):
 
     Examples:
         >>> import numpy as np
-        >>> from mindspore import Tensor
-        >>> from mindspore.nn import ReflectionPad1d
-        >>> x = Tensor(np.array([[[0, 1, 2, 3], [4, 5, 6, 7]]]).astype(np.float32))
+        >>> import mindspore as ms
+        >>> x = ms.Tensor(np.array([[[0, 1, 2, 3], [4, 5, 6, 7]]]).astype(np.float32))
         >>> # x has shape (1, 2, 4)
         >>> padding = (3, 1)
         >>> # The first and the second dimension of x remain the same.
         >>> # The third dimension of x: W_out = W_in + pad_left + pad_right = 4 + 3 + 1 = 8
-        >>> pad1d = ReflectionPad1d(padding)
+        >>> pad1d = ms.nn.ReflectionPad1d(padding)
         >>> out = pad1d(x)
         >>> # The shape of out is (1, 2, 8)
         >>> print(out)
@@ -525,12 +522,11 @@ class ReflectionPad2d(_ReflectionPadNd):
 
     Examples:
         >>> import numpy as np
-        >>> from mindspore import Tensor
-        >>> from mindspore.nn import ReflectionPad2d
-        >>> x = Tensor(np.array([[[0, 1, 2], [3, 4, 5], [6, 7, 8]]]).astype(np.float32))
+        >>> import mindspore as ms
+        >>> x = ms.Tensor(np.array([[[0, 1, 2], [3, 4, 5], [6, 7, 8]]]).astype(np.float32))
         >>> # x has shape (1, 3, 3)
         >>> padding = (1, 1, 2, 0)
-        >>> pad2d = ReflectionPad2d(padding)
+        >>> pad2d = ms.nn.ReflectionPad2d(padding)
         >>> # The first dimension of x remains the same.
         >>> # The second dimension of x: H_out = H_in + pad_up + pad_down = 3 + 1 + 1 = 5
         >>> # The third dimension of x: W_out = W_in + pad_left + pad_right = 3 + 2 + 0 = 5
@@ -583,13 +579,12 @@ class ReflectionPad3d(_ReflectionPadNd):
 
     Examples:
         >>> import numpy as np
-        >>> from mindspore import Tensor
-        >>> from mindspore.nn import ReflectionPad3d
+        >>> import mindspore as ms
         >>> arr = np.arange(8).astype(np.float32).reshape((1, 2, 2, 2))
-        >>> x = Tensor(arr)
+        >>> x = ms.Tensor(arr)
         >>> # x has shape (1, 2, 2, 2)
         >>> padding = (1, 1, 1, 0, 0, 1)
-        >>> pad3d = ReflectionPad3d(padding)
+        >>> pad3d = ms.nn.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
@@ -639,12 +634,11 @@ class ZeroPad2d(_ConstantPadNd):
 
     Examples:
         >>> import numpy as np
-        >>> from mindspore import Tensor
-        >>> from mindspore.nn import ZeroPad2d
+        >>> import mindspore as ms
         >>> x = np.ones(shape=(1, 2, 3, 4)).astype(np.float32)
-        >>> x = Tensor(x)
+        >>> x = ms.Tensor(x)
         >>> padding = (-1, 1, 0, 1)
-        >>> pad = ZeroPad2d(padding)
+        >>> pad = ms.nn.ZeroPad2d(padding)
         >>> out = pad(x)
         >>> print(out)
         [[[[1. 1. 1. 0.]
@@ -735,11 +729,9 @@ class ReplicationPad1d(_ReplicationPadNd):
 
     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)
+        >>> import mindspore as ms
+        >>> pad1d = ms.nn.ReplicationPad1d(2)
+        >>> input = ms.Tensor(np.arange(0, 8).reshape(1, 2, 4), ms.float32)
         >>> print(input)
         [[[0. 1. 2. 3.]
           [4. 5. 6. 7.]]]
@@ -747,7 +739,7 @@ class ReplicationPad1d(_ReplicationPadNd):
         >>> print(out)
         [[[0. 0. 0. 1. 2. 3. 3. 3.]
           [4. 4. 4. 5. 6. 7. 7. 7.]]]
-        >>> pad1d = ReplicationPad1d((3, 1))
+        >>> pad1d = ms.nn.ReplicationPad1d((3, 1))
         >>> out = pad1d(input)
         >>> print(out)
         [[[0. 0. 0. 0. 1. 2. 3. 3.]
@@ -798,11 +790,9 @@ class ReplicationPad2d(_ReplicationPadNd):
 
     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)
+        >>> import mindspore as ms
+        >>> pad2d = ms.nn.ReplicationPad2d(2)
+        >>> input = ms.Tensor(np.arange(0, 9).reshape(1, 1, 3, 3), ms.float32)
         >>> print(input)
         [[[[0. 1. 2.]
            [3. 4. 5.]
@@ -816,7 +806,7 @@ class ReplicationPad2d(_ReplicationPadNd):
            [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))
+        >>> pad2d = ms.nn.ReplicationPad2d((1, 1, 2, 0))
         >>> out = pad2d(input)
         >>> print(out)
         [[[[0. 0. 1. 2. 2.]
@@ -875,11 +865,9 @@ class ReplicationPad3d(_ReplicationPadNd):
 
     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)
+        >>> import mindspore as ms
+        >>> pad3d = ms.nn.ReplicationPad3d(1)
+        >>> input = ms.Tensor(np.arange(0, 9).reshape(1, 1, 1, 3, 3), ms.float32)
         >>> out = pad3d(input)
         >>> print(out)
         [[[[[0. 0. 1. 2. 2.]