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

mindspore/nn/layer/normalization.py

@@ -21,7 +21,6 @@ import numbers
 import hashlib
 import numpy as np
 import mindspore.ops as ops
-from mindspore.ops import operations as P
 from mindspore.ops.operations import _inner_ops as inner
 from mindspore.common.parameter import Parameter
 from mindspore.common.initializer import initializer, Initializer
@@ -98,35 +97,34 @@ class _BatchNorm(Cell):
 
         self.parallel_mode = context.get_auto_parallel_context("parallel_mode")
 
-        self.shape = P.Shape()
-        self.reduce_mean = P.ReduceMean(keep_dims=True)
-        self.square = P.Square()
-        self.sqrt = P.Sqrt()
-        self.cast = P.Cast()
-        self.dtype = P.DType()
-        self.reshape = P.Reshape()
+        self.shape = ops.Shape()
+        self.reduce_mean = ops.ReduceMean(keep_dims=True)
+        self.square = ops.Square()
+        self.sqrt = ops.Sqrt()
+        self.cast = ops.Cast()
+        self.dtype = ops.DType()
+        self.reshape = ops.Reshape()
         self._target = context.get_context("device_target")
-        self.is_graph_mode = context.get_context("mode") == context.GRAPH_MODE
         self.momentum = 1.0 - momentum
 
-        self.bn_train = P.BatchNorm(is_training=True,
-                                    epsilon=self.eps,
-                                    momentum=self.momentum,
-                                    data_format=self.format)
+        self.bn_train = ops.BatchNorm(is_training=True,
+                                      epsilon=self.eps,
+                                      momentum=self.momentum,
+                                      data_format=self.format)
 
-        self.bn_infer = P.BatchNorm(is_training=False, epsilon=self.eps, data_format=self.format)
+        self.bn_infer = ops.BatchNorm(is_training=False, epsilon=self.eps, data_format=self.format)
         if _is_in_auto_parallel_mode():
             data_parallel_strategy = ((1,), (1,))
             data_parallel_strategy_one = ((1,), ())
         else:
             data_parallel_strategy = None
             data_parallel_strategy_one = None
-        self.sub_mean = P.Sub().shard(data_parallel_strategy)
-        self.sub_var = P.Sub().shard(data_parallel_strategy)
-        self.mul_mean = P.Mul().shard(data_parallel_strategy_one)
-        self.mul_var = P.Mul().shard(data_parallel_strategy_one)
-        self.assign_sub_mean = P.AssignSub().shard(data_parallel_strategy)
-        self.assign_sub_var = P.AssignSub().shard(data_parallel_strategy)
+        self.sub_mean = ops.Sub().shard(data_parallel_strategy)
+        self.sub_var = ops.Sub().shard(data_parallel_strategy)
+        self.mul_mean = ops.Mul().shard(data_parallel_strategy_one)
+        self.mul_var = ops.Mul().shard(data_parallel_strategy_one)
+        self.assign_sub_mean = ops.AssignSub().shard(data_parallel_strategy)
+        self.assign_sub_var = ops.AssignSub().shard(data_parallel_strategy)
 
     @staticmethod
     @_primexpr
@@ -464,8 +462,8 @@ class BatchNorm3d(Cell):
                                 use_batch_statistics=use_batch_statistics,
                                 data_format="NCHW",
                                 dtype=dtype)
-        self.shape = P.Shape()
-        self.reshape = P.Reshape()
+        self.shape = ops.Shape()
+        self.reshape = ops.Reshape()
 
     @staticmethod
     @_primexpr
@@ -519,16 +517,20 @@ class SyncBatchNorm(_BatchNorm):
             parameters. When set to ``False`` , :math:`\gamma` and :math:`\beta` are unlearnable parameters.
             Default: ``True`` .
         gamma_init (Union[Tensor, str, Initializer, numbers.Number], optional): Initializer for the :math:`\gamma`
-            weight. The values of str refer to the function `initializer` including ``'zeros'`` , ``'ones'`` ,
+            weight. The values of str refer to the function :func:`mindspore.common.initializer.initializer`
+            including ``'zeros'`` , ``'ones'`` ,
             ``'xavier_uniform'`` , ``'he_uniform'`` , etc. Default: ``'ones'`` .
         beta_init (Union[Tensor, str, Initializer, numbers.Number], optional): Initializer for the :math:`\beta` weight.
-            The values of str refer to the function `initializer` including ``'zeros'`` , ``'ones'`` ,
+            The values of str refer to the function :func:`mindspore.common.initializer.initializer`
+            including ``'zeros'`` , ``'ones'`` ,
             ``'xavier_uniform'`` , ``'he_uniform'`` , etc. Default: ``'zeros'`` .
         moving_mean_init (Union[Tensor, str, Initializer, numbers.Number], optional): Initializer for the moving mean.
-            The values of str refer to the function `initializer` including ``'zeros'`` , ``'ones'`` ,
+            The values of str refer to the function :func:`mindspore.common.initializer.initializer`
+            including ``'zeros'`` , ``'ones'`` ,
             ``'xavier_uniform'`` , ``'he_uniform'`` , etc. Default: ``'zeros'`` .
         moving_var_init (Union[Tensor, str, Initializer, numbers.Number], optional): Initializer for the moving
-            variance. The values of str refer to the function `initializer` including ``'zeros'`` , ``'ones'`` ,
+            variance. The values of str refer to the function :func:`mindspore.common.initializer.initializer`
+            including ``'zeros'`` , ``'ones'`` ,
             ``'xavier_uniform'`` , ``'he_uniform'`` , etc. Default: ``'ones'`` .
         use_batch_statistics (bool, optional): If ``true`` , use the mean value and variance value of current batch
             data. If ``false`` , use the mean value and variance value of specified value. If ``None`` , training
@@ -651,9 +653,9 @@ class SyncBatchNorm(_BatchNorm):
                 rank_list_name = '_'.join('%s' % id for id in sub_group)
                 group_dict = _syncbatchnorm_group_dict()
                 if rank_list_name not in group_dict:
-                    md5 = hashlib.md5()
-                    md5.update(rank_list_name.encode('utf-8'))
-                    hash_name = md5.hexdigest()
+                    sha256 = hashlib.sha256()
+                    sha256.update(rank_list_name.encode('utf-8'))
+                    hash_name = sha256.hexdigest()
                     self.group_name = str(self.group_device_num) + '_' + hash_name
                     group_dict[rank_list_name] = self.group_name
                     management.create_group(self.group_name, sub_group)
@@ -705,10 +707,12 @@ class LayerNorm(Cell):
         begin_params_axis (int): The begin axis of the parameter input :math:`(\gamma, \beta)` to
             apply LayerNorm, the value should be in [-1, R). Default: ``-1`` .
         gamma_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the :math:`\gamma` weight.
-            The values of str refer to the function `initializer` including ``'zeros'`` , ``'ones'`` ,
+            The values of str refer to the function :func:`mindspore.common.initializer.initializer`
+            including ``'zeros'`` , ``'ones'`` ,
             ``'xavier_uniform'`` , ``'he_uniform'`` , etc. Default: ``'ones'`` .
         beta_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the :math:`\beta` weight.
-            The values of str refer to the function `initializer` including ``'zeros'`` , ``'ones'`` ,
+            The values of str refer to the function :func:`mindspore.common.initializer.initializer`
+            including ``'zeros'`` , ``'ones'`` ,
             ``'xavier_uniform'`` , ``'he_uniform'`` , etc. Default: ``'zeros'`` .
         epsilon (float): A value added to the denominator for numerical stability(:math:`\epsilon`). Default: ``1e-7`` .
         dtype (:class:`mindspore.dtype`): Dtype of Parameters. Default: ``mstype.float32`` .
@@ -766,9 +770,9 @@ class LayerNorm(Cell):
             gamma_init, normalized_shape, dtype=dtype), name="gamma")
         self.beta = Parameter(initializer(
             beta_init, normalized_shape, dtype=dtype), name="beta")
-        self.layer_norm = P.LayerNorm(begin_norm_axis=self.begin_norm_axis,
-                                      begin_params_axis=self.begin_params_axis,
-                                      epsilon=self.epsilon)
+        self.layer_norm = ops.LayerNorm(begin_norm_axis=self.begin_norm_axis,
+                                        begin_params_axis=self.begin_params_axis,
+                                        epsilon=self.epsilon)
 
     def construct(self, input_x):
         y, _, _ = self.layer_norm(input_x, self.gamma.astype(input_x.dtype), self.beta.astype(input_x.dtype))
@@ -911,9 +915,9 @@ class _InstanceNorm(Cell):
         self.beta = Parameter(initializer(
             beta_init, num_features, dtype=dtype), name="beta", requires_grad=affine)
 
-        self.shape = P.Shape()
+        self.shape = ops.Shape()
         self.momentum = momentum
-        self.instance_bn = P.InstanceNorm(epsilon=self.eps, momentum=self.momentum)
+        self.instance_bn = ops.InstanceNorm(epsilon=self.eps, momentum=self.momentum)
 
     def construct(self, x):
         self._check_input_dim(self.shape(x), self.cls_name)
@@ -968,10 +972,12 @@ class InstanceNorm1d(_InstanceNorm):
             running_mean and running_var computation. Default: ``0.1`` .
         affine (bool): A bool value. When set to True, gamma and beta can be learned. Default: ``True`` .
         gamma_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the gamma weight.
-            The values of str refer to the function `initializer` including ``'zeros'`` , ``'ones'`` , etc.
+            The values of str refer to the function :func:`mindspore.common.initializer.initializer`
+            including ``'zeros'`` , ``'ones'`` , etc.
             When initialized with Tensor, the shape should be :math:`(C)`. Default: ``'ones'`` .
         beta_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the beta weight.
-            The values of str refer to the function `initializer` including ``'zeros'`` , ``'ones'`` , etc.
+            The values of str refer to the function :func:`mindspore.common.initializer.initializer`
+            including ``'zeros'`` , ``'ones'`` , etc.
             When initialized with Tensor, the shape should be :math:`(C)`. Default: ``'zeros'`` .
         dtype (:class:`mindspore.dtype`): Dtype of Parameters. Default: ``mstype.float32`` .
 
@@ -1046,10 +1052,12 @@ class InstanceNorm2d(_InstanceNorm):
             running_mean and running_var computation. Default: ``0.1`` .
         affine (bool): A bool value. When set to ``True`` , gamma and beta can be learned. Default: ``True`` .
         gamma_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the gamma weight.
-            The values of str refer to the function `initializer` including ``'zeros'`` , ``'ones'`` , etc.
+            The values of str refer to the function :func:`mindspore.common.initializer.initializer`
+            including ``'zeros'`` , ``'ones'`` , etc.
             When initialized with Tensor, the shape should be :math:`(C)`. Default: ``'ones'`` .
         beta_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the beta weight.
-            The values of str refer to the function `initializer` including ``'zeros'`` , ``'ones'`` , etc.
+            The values of str refer to the function :func:`mindspore.common.initializer.initializer`
+            including ``'zeros'`` , ``'ones'`` , etc.
             When initialized with Tensor, the shape should be :math:`(C)`. Default: ``'zeros'`` .
         dtype (:class:`mindspore.dtype`): Dtype of Parameters. Default: ``mstype.float32`` .
 
@@ -1123,10 +1131,12 @@ class InstanceNorm3d(_InstanceNorm):
             running_mean and running_var computation. Default: ``0.1`` .
         affine (bool): A bool value. When set to ``True`` , gamma and beta can be learned. Default: ``True`` .
         gamma_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the gamma weight.
-            The values of str refer to the function `initializer` including ``'zeros'`` , ``'ones'`` , etc.
+            The values of str refer to the function :func:`mindspore.common.initializer.initializer`
+            including ``'zeros'`` , ``'ones'`` , etc.
             When initialized with Tensor, the shape should be :math:`(C)`. Default: ``'ones'`` .
         beta_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the beta weight.
-            The values of str refer to the function `initializer` including ``'zeros'`` , ``'ones'`` , etc.
+            The values of str refer to the function :func:`mindspore.common.initializer.initializer`
+            including ``'zeros'`` , ``'ones'`` , etc.
             When initialized with Tensor, the shape should be :math:`(C)`. Default: ``'zeros'`` .
         dtype (:class:`mindspore.dtype`): Dtype of Parameters. Default: ``mstype.float32`` .
 
@@ -1193,11 +1203,13 @@ class GroupNorm(Cell):
         affine (bool): A bool value, this layer will have learnable affine parameters when set to ``true`` .
             Default: ``True`` .
         gamma_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the gamma weight.
-            The values of str refer to the function `initializer` including ``'zeros'`` , ``'ones'`` ,
+            The values of str refer to the function :func:`mindspore.common.initializer.initializer`
+            including ``'zeros'`` , ``'ones'`` ,
             ``'xavier_uniform'`` , ``'he_uniform'`` , etc. Default: ``'ones'`` . If gamma_init is a Tensor, the shape
             must be :math:`(num\_channels)`.
         beta_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the beta weight.
-            The values of str refer to the function `initializer` including ``'zeros'`` , ``'ones'`` ,
+            The values of str refer to the function :func:`mindspore.common.initializer.initializer`
+            including ``'zeros'`` , ``'ones'`` ,
             ``'xavier_uniform'`` , ``'he_uniform'`` , etc. Default: ``'zeros'`` . If beta_init is a Tensor, the shape
             must be :math:`(num\_channels)`.
         dtype (:class:`mindspore.dtype`): Dtype of Parameters. Default: ``mstype.float32`` .

mindspore/nn/layer/pooling.py

@@ -15,8 +15,6 @@
 """pooling"""
 from __future__ import absolute_import
 
-from mindspore.ops import operations as P
-from mindspore.ops import functional as F
 import mindspore.ops as ops
 from mindspore._checkparam import _check_3d_int_or_tuple
 from mindspore import _checkparam as validator
@@ -27,6 +25,7 @@ from mindspore.common import dtype as mstype
 from mindspore.nn.cell import Cell
 from mindspore._c_expression import MSContext
 from mindspore.ops.auto_generate import avg_pool1d_ext
+from mindspore.ops.function.nn_func import max_pool2d_ext
 
 
 __all__ = ['AvgPool3d', 'MaxPool3d', 'AvgPool2d', 'MaxPool2d', 'AvgPool1d', 'MaxPool1d', 'FractionalMaxPool2d',
@@ -413,13 +412,13 @@ class MaxPool3d(_PoolNd):
             if pad_mode.upper() != "PAD":
                 raise ValueError(f"For {self.cls_name}, the pad_mode must be 'pad' when dilation is not 1 "
                                  f"or return_indices is True, but got pad_mode:{pad_mode}.")
-            self.max_pool = P.MaxPool3DWithArgmax(ksize=kernel_size, strides=stride, pads=padding,
-                                                  dilation=dilation, ceil_mode=ceil_mode)
+            self.max_pool = ops.MaxPool3DWithArgmax(ksize=kernel_size, strides=stride, pads=padding,
+                                                    dilation=dilation, ceil_mode=ceil_mode)
         else:
             self.only_pad = False
             ceil_mode = None if not ceil_mode else True
-            self.max_pool = P.MaxPool3D(kernel_size=kernel_size, strides=stride, pad_mode=pad_mode, pad_list=padding,
-                                        ceil_mode=ceil_mode)
+            self.max_pool = ops.MaxPool3D(kernel_size=kernel_size, strides=stride, pad_mode=pad_mode, pad_list=padding,
+                                          ceil_mode=ceil_mode)
 
     def construct(self, x):
         expand_batch = False
@@ -567,18 +566,18 @@ class MaxPool2d(_PoolNd):
                 stride = (1, self.stride, self.stride)
             self.padding = _check_maxpool_padding(padding, 2, self.cls_name)
             dilation = _cal_dilation(dilation, 2, self.cls_name)
-            self.max_pool = P.MaxPool3DWithArgmax(ksize=kernel_size, strides=stride, pads=self.padding,
-                                                  dilation=dilation, ceil_mode=ceil_mode)
+            self.max_pool = ops.MaxPool3DWithArgmax(ksize=kernel_size, strides=stride, pads=self.padding,
+                                                    dilation=dilation, ceil_mode=ceil_mode)
         else:
             self.use_pad = False
             if padding != 0 or dilation != 1 or return_indices or ceil_mode:
                 raise ValueError(f"For MaxPool2d, the parameter 'padding', 'dilation', 'return_indices', 'ceil_mode' "
                                  f"can not be set to non-default value when pad_mode is not 'pad', "
                                  f"but got pad_mode:{pad_mode}.")
-            self.max_pool = P.MaxPool(kernel_size=self.kernel_size,
-                                      strides=self.stride,
-                                      pad_mode=self.pad_mode,
-                                      data_format=self.format)
+            self.max_pool = ops.MaxPool(kernel_size=self.kernel_size,
+                                        strides=self.stride,
+                                        pad_mode=self.pad_mode,
+                                        data_format=self.format)
 
     def construct(self, x):
         expand_batch = False
@@ -686,20 +685,16 @@ class MaxPool2dExt(Cell):
                  ceil_mode=False):
         """Initialize MaxPool2d."""
         super(MaxPool2dExt, self).__init__()
+        self.kernel_size = kernel_size
+        self.stride = stride if (stride is not None) else kernel_size
+        self.padding = padding
+        self.dilation = dilation
         self.return_indices = return_indices
-        strides = stride if (stride is not None) else kernel_size
-        if return_indices:
-            self.max_pool_func_ = ops.auto_generate.gen_ops_prim.MaxPoolWithIndices(kernel_size, strides, padding,
-                                                                                    dilation, ceil_mode)
-        else:
-            self.max_pool_func_ = ops.auto_generate.gen_ops_prim.MaxPoolWithMask(kernel_size, strides, padding,
-                                                                                 dilation, ceil_mode)
+        self.ceil_mode = ceil_mode
 
     def construct(self, input):
-        out, indices = self.max_pool_func_(input)
-        if self.return_indices:
-            return out, indices
-        return out
+        return max_pool2d_ext(input, self.kernel_size, self.stride, self.padding,
+                              self.dilation, self.ceil_mode, self.return_indices)
 
 
 class MaxPool1d(_PoolNd):
@@ -815,8 +810,8 @@ class MaxPool1d(_PoolNd):
             self.stride = (1, 1, stride)
             self.padding = _check_maxpool_padding(padding, 1, self.cls_name)
             dilation = _cal_dilation(dilation, 1, self.cls_name)
-            self.max_pool = P.MaxPool3DWithArgmax(ksize=self.kernel_size, strides=self.stride, pads=self.padding,
-                                                  dilation=dilation, ceil_mode=ceil_mode)
+            self.max_pool = ops.MaxPool3DWithArgmax(ksize=self.kernel_size, strides=self.stride, pads=self.padding,
+                                                    dilation=dilation, ceil_mode=ceil_mode)
 
         else:
             self.use_pad = False
@@ -824,13 +819,13 @@ class MaxPool1d(_PoolNd):
                 raise ValueError(f"For MaxPool1d, the parameter 'padding', 'dilation', 'return_indices', 'ceil_mode' "
                                  f"can not be set to non-default value when pad_mode is not 'pad', "
                                  f"but got pad_mode:{pad_mode}.")
-            self.max_pool = P.MaxPool(kernel_size=self.kernel_size,
-                                      strides=self.stride,
-                                      pad_mode=self.pad_mode)
-            self.shape = F.shape
-            self.reduce_mean = P.ReduceMean(keep_dims=True)
-            self.expand = P.ExpandDims()
-            self.squeeze = P.Squeeze(2)
+            self.max_pool = ops.MaxPool(kernel_size=self.kernel_size,
+                                        strides=self.stride,
+                                        pad_mode=self.pad_mode)
+            self.shape = ops.shape
+            self.reduce_mean = ops.ReduceMean(keep_dims=True)
+            self.expand = ops.ExpandDims()
+            self.squeeze = ops.Squeeze(2)
 
     def construct(self, x):
         expand_batch = False
@@ -1010,8 +1005,8 @@ class AvgPool3d(_PoolNd):
         if divisor_override is not None and divisor_override <= 0:
             raise ValueError(f"For '{self.cls_name}', the 'divisor_override' must be > 0, but got {divisor_override}.")
         divisor_override = 0 if divisor_override is None else divisor_override
-        self.avg_pool = P.AvgPool3D(self.kernel_size, self.stride, pad_mode, padding, ceil_mode, count_include_pad,
-                                    divisor_override)
+        self.avg_pool = ops.AvgPool3D(self.kernel_size, self.stride, pad_mode, padding, ceil_mode, count_include_pad,
+                                      divisor_override)
 
     def construct(self, x):
         expand_batch = False
@@ -1272,15 +1267,15 @@ class AvgPool2d(_PoolNd):
                 stride = (1,) + self.stride
             elif isinstance(self.stride, int):
                 stride = (1, self.stride, self.stride)
-            self.avg_pool = P.AvgPool3D(kernel_size=kernel_size, strides=stride, pad_mode=pad_mode, pad=padding,
-                                        ceil_mode=ceil_mode,
-                                        count_include_pad=count_include_pad, divisor_override=divisor_override)
+            self.avg_pool = ops.AvgPool3D(kernel_size=kernel_size, strides=stride, pad_mode=pad_mode, pad=padding,
+                                          ceil_mode=ceil_mode,
+                                          count_include_pad=count_include_pad, divisor_override=divisor_override)
         else:
             self.is_expand = False
-            self.avg_pool = P.AvgPool(kernel_size=self.kernel_size,
-                                      strides=self.stride,
-                                      pad_mode=self.pad_mode,
-                                      data_format=self.format)
+            self.avg_pool = ops.AvgPool(kernel_size=self.kernel_size,
+                                        strides=self.stride,
+                                        pad_mode=self.pad_mode,
+                                        data_format=self.format)
 
     def construct(self, x):
         expand_batch = False
@@ -1396,21 +1391,21 @@ class AvgPool1d(_PoolNd):
             self.is_expand_3d = True
             kernel_size = (1, 1, self.kernel_size)
             stride = (1, 1, self.stride)
-            self.avg_pool = P.AvgPool3D(kernel_size=kernel_size, strides=stride, pad_mode=pad_mode, pad=padding,
-                                        ceil_mode=ceil_mode,
-                                        count_include_pad=count_include_pad)
+            self.avg_pool = ops.AvgPool3D(kernel_size=kernel_size, strides=stride, pad_mode=pad_mode, pad=padding,
+                                          ceil_mode=ceil_mode,
+                                          count_include_pad=count_include_pad)
         else:
             self.is_expand_3d = False
             self.kernel_size = (1, self.kernel_size)
             self.stride = (1, self.stride)
-            self.avg_pool = P.AvgPool(kernel_size=self.kernel_size,
-                                      strides=self.stride,
-                                      pad_mode=self.pad_mode)
-            self.shape = F.shape
-            self.reduce_mean = P.ReduceMean(keep_dims=True)
-            self.slice = P.Slice()
-            self.expand = P.ExpandDims()
-            self.squeeze = P.Squeeze(2)
+            self.avg_pool = ops.AvgPool(kernel_size=self.kernel_size,
+                                        strides=self.stride,
+                                        pad_mode=self.pad_mode)
+            self.shape = ops.shape
+            self.reduce_mean = ops.ReduceMean(keep_dims=True)
+            self.slice = ops.Slice()
+            self.expand = ops.ExpandDims()
+            self.squeeze = ops.Squeeze(2)
 
     def construct(self, x):
         expand_batch = False
@@ -1510,11 +1505,11 @@ class AdaptiveAvgPool1d(Cell):
         super(AdaptiveAvgPool1d, self).__init__()
         validator.check_value_type('output_size', output_size, [int], self.cls_name)
         validator.check_int(output_size, 1, validator.GE, "output_size", self.cls_name)
-        self.shape = F.shape
-        self.expand = P.ExpandDims()
-        self.squeeze = P.Squeeze(2)
+        self.shape = ops.shape
+        self.expand = ops.ExpandDims()
+        self.squeeze = ops.Squeeze(2)
         self.output_size = output_size
-        self.dtype = P.DType()
+        self.dtype = ops.DType()
 
     def construct(self, input):
         _adaptive_shape_check(self.shape(input), self.output_size, self.cls_name)
@@ -1528,7 +1523,7 @@ class AdaptiveAvgPool1d(Cell):
         kernel_size = (1, kernel_size)
 
         input = self.expand(input, 2)
-        avg_pool = P.AvgPool(kernel_size=kernel_size, strides=stride)
+        avg_pool = ops.AvgPool(kernel_size=kernel_size, strides=stride)
         input = avg_pool(input)
         input = self.squeeze(input)
 
@@ -1591,7 +1586,7 @@ class AdaptiveAvgPool2d(Cell):
     def __init__(self, output_size):
         """Initialize AdaptiveAvgPool2d."""
         super(AdaptiveAvgPool2d, self).__init__()
-        self.adaptive_avgpool2d = P.AdaptiveAvgPool2D(output_size)
+        self.adaptive_avgpool2d = ops.AdaptiveAvgPool2D(output_size)
 
     def construct(self, input):
         return self.adaptive_avgpool2d(input)
@@ -1728,11 +1723,11 @@ class AdaptiveMaxPool1d(Cell):
         super(AdaptiveMaxPool1d, self).__init__()
         validator.check_int(output_size, 1, validator.GE, "output_size", self.cls_name)
         validator.check_value_type('output_size', output_size, [int], self.cls_name)
-        self.expand = P.ExpandDims()
-        self.squeeze = P.Squeeze(2)
+        self.expand = ops.ExpandDims()
+        self.squeeze = ops.Squeeze(2)
         self.output_size = output_size
-        self.shape = F.shape
-        self.dtype = P.DType()
+        self.shape = ops.shape
+        self.dtype = ops.DType()
 
     def construct(self, x):
         _adaptive_shape_check(self.shape(x), self.output_size, self.cls_name)
@@ -1745,7 +1740,7 @@ class AdaptiveMaxPool1d(Cell):
         stride = (1, width // self.output_size)
         kernel_size = (1, kernel_size)
 
-        max_pool = P.MaxPool(kernel_size=kernel_size, strides=stride)
+        max_pool = ops.MaxPool(kernel_size=kernel_size, strides=stride)
         x = self.expand(x, 2)
         x = max_pool(x)
         x = self.squeeze(x)

mindspore/nn/layer/rnn_cells.py

@@ -19,7 +19,7 @@ from functools import wraps
 import math
 import numpy as np
 
-import mindspore.ops as P
+import mindspore.ops as ops
 import mindspore.common.dtype as mstype
 from mindspore import log as logger
 from mindspore.common.tensor import Tensor
@@ -40,17 +40,17 @@ def _check_input_dtype(input_dtype, param_name, allow_dtypes, cls_name):
 @constexpr(check=False)
 def _check_is_tensor(param_name, input_data, cls_name):
     """Internal function, used to check whether the input data is Tensor."""
-    if input_data is not None and not isinstance(P.typeof(input_data), mstype.TensorType):
+    if input_data is not None and not isinstance(ops.typeof(input_data), mstype.TensorType):
         raise TypeError(f"For '{cls_name}', the '{param_name}' must be '{mstype.TensorType}', "
-                        f"but got '{P.typeof(input_data)}'")
+                        f"but got '{ops.typeof(input_data)}'")
 
 
 @constexpr
 def _check_is_tuple(param_name, input_data, cls_name):
     """Internal function, used to check whether the input data is Tensor."""
-    if input_data is not None and not isinstance(P.typeof(input_data), mstype.Tuple):
+    if input_data is not None and not isinstance(ops.typeof(input_data), mstype.Tuple):
         raise TypeError(f"For '{cls_name}', the '{param_name}' must be '{mstype.Tuple}', "
-                        f"but got '{P.typeof(input_data)}'")
+                        f"but got '{ops.typeof(input_data)}'")
 
 
 @constexpr
@@ -78,41 +78,41 @@ def _check_lstmcell_init(func):
 def _rnn_tanh_cell(inputs, hidden, w_ih, w_hh, b_ih, b_hh):
     """RNN cell function with tanh activation"""
     if b_ih is None:
-        igates = P.MatMul(False, True)(inputs, w_ih)
-        hgates = P.MatMul(False, True)(hidden, w_hh)
+        igates = ops.MatMul(False, True)(inputs, w_ih)
+        hgates = ops.MatMul(False, True)(hidden, w_hh)
     else:
-        igates = P.MatMul(False, True)(inputs, w_ih) + b_ih
-        hgates = P.MatMul(False, True)(hidden, w_hh) + b_hh
-    return P.Tanh()(igates + hgates)
+        igates = ops.MatMul(False, True)(inputs, w_ih) + b_ih
+        hgates = ops.MatMul(False, True)(hidden, w_hh) + b_hh
+    return ops.Tanh()(igates + hgates)
 
 
 def _rnn_relu_cell(inputs, hidden, w_ih, w_hh, b_ih, b_hh):
     """RNN cell function with relu activation"""
     if b_ih is None:
-        igates = P.MatMul(False, True)(inputs, w_ih)
-        hgates = P.MatMul(False, True)(hidden, w_hh)
+        igates = ops.MatMul(False, True)(inputs, w_ih)
+        hgates = ops.MatMul(False, True)(hidden, w_hh)
     else:
-        igates = P.MatMul(False, True)(inputs, w_ih) + b_ih
-        hgates = P.MatMul(False, True)(hidden, w_hh) + b_hh
-    return P.ReLU()(igates + hgates)
+        igates = ops.MatMul(False, True)(inputs, w_ih) + b_ih
+        hgates = ops.MatMul(False, True)(hidden, w_hh) + b_hh
+    return ops.ReLU()(igates + hgates)
 
 
 def _lstm_cell(inputs, hidden, w_ih, w_hh, b_ih, b_hh):
     """LSTM cell function"""
     hx, cx = hidden
     if b_ih is None:
-        gates = P.MatMul(False, True)(inputs, w_ih) + P.MatMul(False, True)(hx, w_hh)
+        gates = ops.MatMul(False, True)(inputs, w_ih) + ops.MatMul(False, True)(hx, w_hh)
     else:
-        gates = P.MatMul(False, True)(inputs, w_ih) + P.MatMul(False, True)(hx, w_hh) + b_ih + b_hh
-    ingate, forgetgate, cellgate, outgate = P.Split(1, 4)(gates)
+        gates = ops.MatMul(False, True)(inputs, w_ih) + ops.MatMul(False, True)(hx, w_hh) + b_ih + b_hh
+    ingate, forgetgate, cellgate, outgate = ops.Split(1, 4)(gates)
 
-    ingate = P.Sigmoid()(ingate)
-    forgetgate = P.Sigmoid()(forgetgate)
-    cellgate = P.Tanh()(cellgate)
-    outgate = P.Sigmoid()(outgate)
+    ingate = ops.Sigmoid()(ingate)
+    forgetgate = ops.Sigmoid()(forgetgate)
+    cellgate = ops.Tanh()(cellgate)
+    outgate = ops.Sigmoid()(outgate)
 
     cy = (forgetgate * cx) + (ingate * cellgate)
-    hy = outgate * P.Tanh()(cy)
+    hy = outgate * ops.Tanh()(cy)
 
     return hy, cy
 
@@ -120,17 +120,17 @@ def _lstm_cell(inputs, hidden, w_ih, w_hh, b_ih, b_hh):
 def _gru_cell(inputs, hidden, w_ih, w_hh, b_ih, b_hh):
     """GRU cell function"""
     if b_ih is None:
-        gi = P.MatMul(False, True)(inputs, w_ih)
-        gh = P.MatMul(False, True)(hidden, w_hh)
+        gi = ops.MatMul(False, True)(inputs, w_ih)
+        gh = ops.MatMul(False, True)(hidden, w_hh)
     else:
-        gi = P.MatMul(False, True)(inputs, w_ih) + b_ih
-        gh = P.MatMul(False, True)(hidden, w_hh) + b_hh
-    i_r, i_i, i_n = P.Split(1, 3)(gi)
-    h_r, h_i, h_n = P.Split(1, 3)(gh)
-
-    resetgate = P.Sigmoid()(i_r + h_r)
-    inputgate = P.Sigmoid()(i_i + h_i)
-    newgate = P.Tanh()(i_n + resetgate * h_n)
+        gi = ops.MatMul(False, True)(inputs, w_ih) + b_ih
+        gh = ops.MatMul(False, True)(hidden, w_hh) + b_hh
+    i_r, i_i, i_n = ops.Split(1, 3)(gi)
+    h_r, h_i, h_n = ops.Split(1, 3)(gh)
+
+    resetgate = ops.Sigmoid()(i_r + h_r)
+    inputgate = ops.Sigmoid()(i_i + h_i)
+    newgate = ops.Tanh()(i_n + resetgate * h_n)
     hy = newgate + inputgate * (hidden - newgate)
 
     return hy