mindspore 2.6.0__cp311-cp311-win_amd64.whl → 2.7.0__cp311-cp311-win_amd64.whl

mindspore/nn/layer/basic.py

@@ -26,8 +26,6 @@ from mindspore.common.seed import _get_graph_seed
 from mindspore.common.tensor import Tensor
 from mindspore.common.initializer import initializer, HeUniform, Uniform
 from mindspore import ops
-from mindspore.ops import operations as P
-from mindspore.ops import functional as F
 from mindspore.ops.operations import _inner_ops as inner
 from mindspore.ops.primitive import constexpr, Primitive, _primexpr
 from mindspore.common.parameter import Parameter
@@ -97,13 +95,13 @@ class L1Regularizer(Cell):
         if math.isinf(scale) or math.isnan(scale):
             raise ValueError(
                 f"For '{self.cls_name}', the 'scale' can not be INF or NAN, but got {scale}.")
-        self.abs = P.Abs()
-        self.reduce_sum = P.ReduceSum()
+        self.abs = ops.Abs()
+        self.reduce_sum = ops.ReduceSum()
         self.scale = Tensor(scale, dtype=mstype.float32)
 
     def construct(self, weights):
         const_utils.check_type_valid(
-            F.dtype(weights), mstype.number_type, 'weights')
+            ops.dtype(weights), mstype.number_type, 'weights')
         l1_regularization = self.scale * self.reduce_sum(self.abs(weights))
         return l1_regularization
 
@@ -179,14 +177,14 @@ class Dropout(Cell):
                 raise ValueError(f"For '{self.cls_name}', the 'keep_prob' must be a number in range (0, 1], "
                                  f"but got {keep_prob}.")
             seed0, seed1 = _get_graph_seed(0, "dropout")
-            self.dropout = P.Dropout(keep_prob, seed0, seed1)
+            self.dropout = ops.Dropout(keep_prob, seed0, seed1)
         else:
             Validator.check_value_type('p', p, [float, int], self.cls_name)
             if p < 0 or p >= 1:
                 raise ValueError(f"For '{self.cls_name}', the 'p' must be a number in range [0, 1), "
                                  f"but got {p}.")
             seed0, seed1 = _get_graph_seed(0, "dropout")
-            self.dropout = P.Dropout(1.0 - p, seed0, seed1)
+            self.dropout = ops.Dropout(1.0 - p, seed0, seed1)
         self.p = p
         self.keep_prob = keep_prob
 
@@ -211,7 +209,7 @@ class DropoutExt(Cell):
     Dropout is a means of regularization that reduces overfitting by preventing correlations between neuronal nodes.
     The operator randomly sets some neurons output to 0 according to `p`, which means the probability of discarding
     during training. And the return will be multiplied by :math:`\frac{1}{1-p}` during training.
-    During the reasoning, this layer returns the same Tensor as the `x`.
+    During the reasoning, this layer returns the same Tensor as the `input`.
 
     This technique is proposed in paper `Dropout: A Simple Way to Prevent Neural Networks from Overfitting
     <http://www.cs.toronto.edu/~rsalakhu/papers/srivastava14a.pdf>`_ and proved to be effective to reduce
@@ -230,14 +228,13 @@ class DropoutExt(Cell):
             If set to ``True`` , will do this operation in-place. Default: ``False`` .
 
     Inputs:
-        - **x** (Tensor) - The input of Dropout.
+        - **input** (Tensor) - The input of Dropout.
 
     Outputs:
-        Tensor, output tensor with the same shape as the `x`.
+        Tensor, output tensor with the same shape as the `input`.
 
     Raises:
-        TypeError: If the dtype of `p` is not float.
-        ValueError: If length of shape of `x` is less than 1.
+        TypeError: If the dtype of `inplace` is not bool.
 
     Supported Platforms:
         ``Ascend``
@@ -261,17 +258,12 @@ class DropoutExt(Cell):
         self.inplace = inplace
         self.generator_step = Tensor(12, mstype.int64)
 
-    def construct(self, x):
+    def construct(self, input):
         if not self.training or self.p == 0:
-            return x
+            return input
 
         seed, offset = default_generator._step(self.generator_step)  # pylint: disable=protected-access
-        out, _ = ops.auto_generate.dropout_ext_op(x, self.p, seed, offset)
-
-        if self.inplace:
-            x.copy_(out)
-            return x
-        return out
+        return ops.auto_generate.func_dropout_ext_op(input, self.p, self.training, self.inplace, seed, offset)
 
 
 class Dropout1d(Cell):
@@ -336,7 +328,7 @@ class Dropout1d(Cell):
         if not self.training or self.prob == 0:
             return x
 
-        out = F.dropout1d(x, self.prob)
+        out = ops.dropout1d(x, self.prob)
         return out
 
 
@@ -377,7 +369,7 @@ class Dropout2d(Cell):
             raise ValueError(f"For '{self.cls_name}', the 'p' must be a number in range [0, 1], "
                              f"but got {p}.")
         self.keep_prob = 1.0 - p
-        self.dropout2d = P.Dropout2D(self.keep_prob)
+        self.dropout2d = ops.Dropout2D(self.keep_prob)
 
     def construct(self, x):
         if not self.training or self.keep_prob == 1:
@@ -428,7 +420,7 @@ class Dropout3d(Cell):
             raise ValueError(f"For '{self.cls_name}', the 'p' must be a number in range [0, 1], "
                              f"but got {p}.")
         self.keep_prob = 1.0 - p
-        self.dropout3d = P.Dropout3D(self.keep_prob)
+        self.dropout3d = ops.Dropout3D(self.keep_prob)
 
     def construct(self, x):
         if not self.training or self.keep_prob == 1:
@@ -476,8 +468,8 @@ class Upsample(Cell):
         self.recompute_scale_factor = recompute_scale_factor
 
     def construct(self, x):
-        out = F.interpolate(x, self.size, self.scale_factor, self.mode,
-                            self.align_corners, self.recompute_scale_factor)
+        out = ops.interpolate(x, self.size, self.scale_factor, self.mode,
+                              self.align_corners, self.recompute_scale_factor)
         return out
 
 
@@ -577,11 +569,11 @@ class Flatten(Cell):
             raise ValueError("'start_dim' or 'end_dim' out of range.")
 
     def construct(self, x):
-        x_rank = F.rank(x)
+        x_rank = ops.rank(x)
         ndim = x_rank if x_rank != 0 else 1
         self.check_axis_valid(self.start_dim, ndim)
         self.check_axis_valid(self.end_dim, ndim)
-        return F.flatten(x, start_dim=self.start_dim, end_dim=self.end_dim)
+        return ops.flatten(x, start_dim=self.start_dim, end_dim=self.end_dim)
 
 
 class Identity(Cell):
@@ -641,10 +633,12 @@ class Dense(Cell):
         in_channels (int): The number of channels in the input space.
         out_channels (int): The number of channels in the output space.
         weight_init (Union[Tensor, str, Initializer, numbers.Number], optional): The trainable weight_init parameter.
-            The dtype is same as `x`. The values of str refer to the function `initializer`. Default: ``None`` ,
+            The dtype is same as `x`. The values of str refer to the function
+            :func:`mindspore.common.initializer.initializer`. Default: ``None`` ,
             weight will be initialized using HeUniform.
         bias_init (Union[Tensor, str, Initializer, numbers.Number], optional): The trainable bias_init parameter.
-            The dtype is same as `x`. The values of str refer to the function `initializer`. Default: ``None`` ,
+            The dtype is same as `x`. The values of str refer to the function
+            :func:`mindspore.common.initializer.initializer`. Default: ``None`` ,
             bias will be initialized using Uniform.
         has_bias (bool, optional): Specifies whether the layer uses a bias vector :math:`\text{bias}`.
             Default: ``True``.
@@ -704,8 +698,8 @@ class Dense(Cell):
             out_channels, "out_channels", self.cls_name)
         self.has_bias = Validator.check_bool(
             has_bias, "has_bias", self.cls_name)
-        self.reshape = P.Reshape()
-        self.shape_op = P.Shape()
+        self.reshape = ops.Reshape()
+        self.shape_op = ops.Shape()
 
         if isinstance(weight_init, Tensor):
             if weight_init.ndim != 2 or weight_init.shape[0] != out_channels or \
@@ -731,9 +725,9 @@ class Dense(Cell):
                 bias_init = Uniform(scale=bound)
             self.bias = Parameter(initializer(
                 bias_init, [out_channels], dtype=dtype), name="bias")
-            self.bias_add = P.BiasAdd()
+            self.bias_add = ops.BiasAdd()
 
-        self.matmul = P.MatMul(transpose_b=True)
+        self.matmul = ops.MatMul(transpose_b=True)
         self.activation = get_activation(activation) if isinstance(
             activation, str) else activation
         if activation is not None and not isinstance(self.activation, (Cell, Primitive)):
@@ -751,7 +745,7 @@ class Dense(Cell):
         if self.activation_flag:
             x = self.activation(x)
         if len(x_shape) != 2:
-            out_shape = x_shape[:-1] + (F.shape(x)[-1],)
+            out_shape = x_shape[:-1] + (ops.shape(x)[-1],)
             x = self.reshape(x, out_shape)
         return x
 
@@ -789,11 +783,13 @@ class Linear(Cell):
         bias (bool, optional): Specifies whether the layer uses a bias vector :math:`\text{bias}`. Default: ``True``.
         weight_init (Union[Tensor, str, Initializer, numbers.Number], optional):
             The trainable weight_init parameter. The dtype
-            is same as `x`. The values of str refer to the function `initializer`. Default: ``None`` ,
+            is same as `x`. The values of str refer to the function :func:`mindspore.common.initializer.initializer`.
+            Default: ``None`` ,
             weight will be initialized using HeUniform.
         bias_init (Union[Tensor, str, Initializer, numbers.Number], optional):
             The trainable bias_init parameter. The dtype is
-            same as `x`. The values of str refer to the function `initializer`. Default: ``None`` ,
+            same as `x`. The values of str refer to the function :func:`mindspore.common.initializer.initializer`.
+            Default: ``None`` ,
             bias will be initialized using Uniform.
         dtype (:class:`mindspore.dtype`, optional): Data type of Parameter. Default: ``None`` .
             If `dtype` is ``None`` , `dtype` is set to ``mstype.float32`` when initializing the method.
@@ -847,7 +843,7 @@ class Linear(Cell):
             out_features, "out_features", self.cls_name)
         self.has_bias = Validator.check_bool(
             bias, "has_bias", self.cls_name)
-        self.dense = P.Dense()
+        self.dense = ops.Dense()
         if dtype is None:
             dtype = mstype.float32
         if isinstance(weight_init, Tensor):
@@ -890,7 +886,7 @@ class Linear(Cell):
 def _is_equal_one(x):
     if x is None:
         return False
-    return F.equal(F.reduce_mean(x), 1.0)
+    return ops.equal(ops.reduce_mean(x), 1.0)
 
 
 @constexpr
@@ -983,12 +979,12 @@ class Norm(Cell):
             "keep_dims", keep_dims, [bool], self.cls_name)
         self.axis = axis
         self.keep_dims = keep_dims
-        self.reduce_sum = P.ReduceSum(True)
-        self.sqrt = P.Sqrt()
-        self.squeeze = P.Squeeze(self.axis)
+        self.reduce_sum = ops.ReduceSum(True)
+        self.sqrt = ops.Sqrt()
+        self.squeeze = ops.Squeeze(self.axis)
 
     def construct(self, x):
-        x = self.sqrt(self.reduce_sum(F.square(x), self.axis))
+        x = self.sqrt(self.reduce_sum(ops.square(x), self.axis))
 
         if not self.keep_dims:
             x = self.squeeze(x)
@@ -1008,14 +1004,15 @@ class OneHot(Cell):
     def __init__(self, axis=-1, depth=1, on_value=1.0, off_value=0.0, dtype=mstype.float32):
         """Initialize OneHot."""
         super(OneHot, self).__init__()
-        self.onehot = P.OneHot(axis)
+        self.onehot = ops.OneHot(axis)
         self.depth = depth
         self.dtype = dtype
         self.on_value = on_value
         self.off_value = off_value
 
     def construct(self, indices):
-        return self.onehot(indices, self.depth, F.cast(self.on_value, self.dtype), F.cast(self.off_value, self.dtype))
+        return self.onehot(indices, self.depth, ops.cast(self.on_value, self.dtype),
+                           ops.cast(self.off_value, self.dtype))
 
 
 class Pad(Cell):
@@ -1171,10 +1168,10 @@ class Pad(Cell):
             raise ValueError(f"For '{self.cls_name}', only 'paddings' up to 4 dims is supported, but got "
                              f"{len(paddings)}.")
         if mode == "CONSTANT":
-            self.pad = P.Pad(self.paddings)
+            self.pad = ops.Pad(self.paddings)
         else:
             self.paddings = Tensor(np.array(self.paddings), dtype=mstype.int64)
-            self.pad = P.MirrorPad(mode=mode)
+            self.pad = ops.MirrorPad(mode=mode)
 
     def construct(self, x):
         if self.mode == "CONSTANT":
@@ -1340,7 +1337,7 @@ class Fold(Cell):
 def tril(x_shape, x_dtype, k):
     Validator.check_int(len(x_shape), 1, Validator.GE, "x rank", "tril")
     Validator.check_is_int(k, "k value", "tril")
-    value = F.cast(P.Tril(diagonal=k)(F.ones(x_shape, x_dtype)), x_dtype)
+    value = ops.cast(ops.Tril(diagonal=k)(ops.ones(x_shape, x_dtype)), x_dtype)
     return value
 
 
@@ -1354,9 +1351,9 @@ class Tril(Cell):
     def __init__(self):
         """Initialize Tril."""
         super(Tril, self).__init__()
-        self.dtype = P.DType()
-        self.mul = P.Mul()
-        self.cast = P.Cast()
+        self.dtype = ops.DType()
+        self.mul = ops.Mul()
+        self.cast = ops.Cast()
 
     def construct(self, x, k=0):
         assist = tril(x.shape, self.dtype(x), k)
@@ -1369,7 +1366,7 @@ class Tril(Cell):
 def triu(x_shape, x_dtype, k):
     Validator.check_int(len(x_shape), 1, Validator.GE, "x rank", "triu")
     Validator.check_is_int(k, "k value", "triu")
-    value = F.cast(P.Triu(k)(F.ones(x_shape, x_dtype)), x_dtype)
+    value = ops.cast(ops.Triu(k)(ops.ones(x_shape, x_dtype)), x_dtype)
     return value
 
 
@@ -1383,9 +1380,9 @@ class Triu(Cell):
     def __init__(self):
         """Initialize Triu."""
         super(Triu, self).__init__()
-        self.dtype = P.DType()
-        self.mul = P.Mul()
-        self.cast = P.Cast()
+        self.dtype = ops.DType()
+        self.mul = ops.Mul()
+        self.cast = ops.Cast()
 
     def construct(self, x, k=0):
         assist = triu(x.shape, self.dtype(x), k)
@@ -1398,14 +1395,14 @@ class Triu(Cell):
 def _get_matrix_diag_assist(x_shape, x_dtype):
     """Get matrix diag assist"""
     Validator.check_int(len(x_shape), 1, Validator.GE, "x rank", "_get_matrix_diag_assist")
-    base_eye = F.reshape(
-        F.eye(x_shape[-1], x_shape[-1], x_dtype), (x_shape[-1] * x_shape[-1],))
+    base_eye = ops.reshape(
+        ops.eye(x_shape[-1], x_shape[-1], x_dtype), (x_shape[-1] * x_shape[-1],))
     if len(x_shape) == 1:
-        assist = F.reshape(base_eye, x_shape + (x_shape[-1],))
+        assist = ops.reshape(base_eye, x_shape + (x_shape[-1],))
     else:
-        assist = F.reshape(
-            F.tile(base_eye, x_shape[:-1]), x_shape + (x_shape[-1],))
-    value = F.cast(assist, x_dtype)
+        assist = ops.reshape(
+            ops.tile(base_eye, x_shape[:-1]), x_shape + (x_shape[-1],))
+    value = ops.cast(assist, x_dtype)
     return value
 
 
@@ -1413,13 +1410,13 @@ def _get_matrix_diag_assist(x_shape, x_dtype):
 def _get_matrix_diag_part_assist(x_shape, x_dtype):
     """Get matrix diag part assist"""
     Validator.check_int(len(x_shape), 2, Validator.GE, "x rank", "_get_matrix_diag_part_assist")
-    base_eye = F.reshape(
-        F.eye(x_shape[-2], x_shape[-1], x_dtype), (x_shape[-2] * x_shape[-1],))
+    base_eye = ops.reshape(
+        ops.eye(x_shape[-2], x_shape[-1], x_dtype), (x_shape[-2] * x_shape[-1],))
     if len(x_shape) <= 2:
-        assist = F.reshape(base_eye, x_shape)
+        assist = ops.reshape(base_eye, x_shape)
     else:
-        assist = F.reshape(F.tile(base_eye, x_shape[:-2]), x_shape)
-    value = F.cast(assist, x_dtype)
+        assist = ops.reshape(ops.tile(base_eye, x_shape[:-2]), x_shape)
+    value = ops.cast(assist, x_dtype)
     return value
 
 
@@ -1434,10 +1431,10 @@ class MatrixDiag(Cell):
         """Initialize MatrixDiag."""
         super(MatrixDiag, self).__init__()
         self.matrix_diag = inner.MatrixDiag()
-        self.dtype = P.DType()
+        self.dtype = ops.DType()
 
     def construct(self, input_x):
-        x_shape = F.shape(input_x)
+        x_shape = ops.shape(input_x)
         x_dtype = self.dtype(input_x)
         assist = _get_matrix_diag_assist(x_shape, x_dtype)
         out_matrix_diag = self.matrix_diag(input_x, assist)
@@ -1455,10 +1452,10 @@ class MatrixDiagPart(Cell):
         """Initialize MatrixDiagPart."""
         super(MatrixDiagPart, self).__init__()
         self.matrix_diag_part = inner.MatrixDiagPart()
-        self.dtype = P.DType()
+        self.dtype = ops.DType()
 
     def construct(self, input_x):
-        x_shape = F.shape(input_x)
+        x_shape = ops.shape(input_x)
         x_dtype = self.dtype(input_x)
         assist = _get_matrix_diag_part_assist(x_shape, x_dtype)
         out_matrix_diag_part = self.matrix_diag_part(input_x, assist)
@@ -1516,10 +1513,10 @@ class MatrixSetDiag(Cell):
         """Initialize MatrixSetDiag."""
         super(MatrixSetDiag, self).__init__()
         self.matrix_set_diag = inner.MatrixSetDiag()
-        self.dtype = P.DType()
+        self.dtype = ops.DType()
 
     def construct(self, input_x, diagonal):
-        x_shape = F.shape(input_x)
+        x_shape = ops.shape(input_x)
         x_dtype = self.dtype(input_x)
         assist = _get_matrix_diag_part_assist(x_shape, x_dtype)
         out_matrix_set_diag = self.matrix_set_diag(input_x, diagonal, assist)
@@ -1545,7 +1542,7 @@ class Roll(Cell):
             "shift", shift, [int, tuple, list], self.cls_name)
         Validator.check_value_type(
             "axis", axis, [int, tuple, list], self.cls_name)
-        self.shape_op = P.Shape()
+        self.shape_op = ops.Shape()
         self.shift = shift
         self.axis = axis
         self.op_list = []
@@ -1562,7 +1559,7 @@ class Roll(Cell):
                 Validator.check_is_int(s_axis, "axis", "Roll")
             for s_shift in self.shift:
                 Validator.check_is_int(s_shift, "shift", "Roll")
-            self.roll = P.Roll(self.shift, self.axis)
+            self.roll = ops.Roll(self.shift, self.axis)
             self.gpu = True
             if len(self.shift) != len(self.axis):
                 raise ValueError(f"For '{self.cls_name}', the shape of 'shift' and the shape of 'axis' must be "
@@ -1571,7 +1568,7 @@ class Roll(Cell):
         else:
             if not isinstance(self.axis, (list, tuple)):
                 self.op_list.append(
-                    (P.Roll(shifts=self.shift, dims=0), self.axis))
+                    (ops.Roll(shifts=self.shift, dims=0), self.axis))
             else:
                 if len(self.shift) != len(self.axis):
                     raise ValueError(f"For '{self.cls_name}', the shape of 'shift' and the shape of 'axis' must be "
@@ -1579,7 +1576,7 @@ class Roll(Cell):
                                      f"and the length of 'axis' {len(self.axis)}.")
                 for idx, _ in enumerate(self.axis):
                     self.op_list.append(
-                        (P.Roll(shifts=self.shift[idx], dims=0), self.axis[idx]))
+                        (ops.Roll(shifts=self.shift[idx], dims=0), self.axis[idx]))
 
     def construct(self, input_x):
         dim = len(self.shape_op(input_x))
@@ -1642,8 +1639,8 @@ class Unflatten(Cell):
     def __init__(self, axis, unflattened_size):
         """Initialize Unflatten."""
         super(Unflatten, self).__init__()
-        self.shape = P.Shape()
-        self.reshape = P.Reshape()
+        self.shape = ops.Shape()
+        self.reshape = ops.Reshape()
         Validator.check_is_int(axis, 'axis', 'Unflatten')
         Validator.check_value_type(
             'unflattended_size', unflattened_size, (list, tuple), 'Unflatten')

mindspore/nn/layer/channel_shuffle.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 # ============================================================================
 """channel shuffle"""
-from mindspore.ops import operations as P
+from mindspore import ops
 from mindspore.nn.cell import Cell
 
 __all__ = ['ChannelShuffle']
@@ -78,9 +78,9 @@ class ChannelShuffle(Cell):
             raise ValueError(f"For ChannelShuffle, the param `groups` must be larger than 0, but got {groups}.")
 
         self.groups = groups
-        self.shape = P.Shape()
-        self.reshape = P.Reshape()
-        self.transpose = P.Transpose()
+        self.shape = ops.Shape()
+        self.reshape = ops.Reshape()
+        self.transpose = ops.Transpose()
 
     def construct(self, x):
         x_shape = self.shape(x)

mindspore/nn/layer/combined.py

@@ -164,9 +164,11 @@ class DenseBnAct(Cell):
         in_channels (int): The number of channels in the input space.
         out_channels (int): The number of channels in the output space.
         weight_init (Union[Tensor, str, Initializer, numbers.Number]): The trainable weight_init parameter. The dtype
-            is same as `x`. The values of str refer to the function `initializer`. Default: ``'normal'`` .
+            is same as `x`. The values of str refer to the function :func:`mindspore.common.initializer.initializer`.
+            Default: ``'normal'`` .
         bias_init (Union[Tensor, str, Initializer, numbers.Number]): The trainable bias_init parameter. The dtype is
-            same as `x`. The values of str refer to the function `initializer`. Default: ``'zeros'`` .
+            same as `x`. The values of str refer to the function :func:`mindspore.common.initializer.initializer`.
+            Default: ``'zeros'`` .
         has_bias (bool): Specifies whether the layer uses a bias vector. Default: ``True`` .
         has_bn (bool): Specifies to use batchnorm or not. Default: ``False`` .
         momentum (float): Momentum for moving average for batchnorm, must be [0, 1]. Default: ``0.9`` .