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

mindspore/nn/layer/conv.py

@@ -19,7 +19,7 @@ import math
 import numpy as np
 
 from mindspore import context
-from mindspore.ops import operations as P
+from mindspore import ops
 import mindspore.common.dtype as mstype
 from mindspore.common.parameter import Parameter
 from mindspore.common.initializer import initializer, HeUniform, Uniform, _calculate_fan_in_and_fan_out
@@ -272,20 +272,20 @@ class Conv2d(_Conv):
 
         .. math::
             \begin{array}{ll} \\
-                H_{out} = \left \lceil{\frac{H_{in} - \text{dilation[0]} \times (\text{kernel_size[0]} - 1) }
-                {\text{stride[0]}}} \right \rceil \\
-                W_{out} = \left \lceil{\frac{W_{in} - \text{dilation[1]} \times (\text{kernel_size[1]} - 1) }
-                {\text{stride[1]}}} \right \rceil \\
+                H_{out} = \left \lfloor{\frac{H_{in} - \text{dilation[0]} \times (\text{kernel_size[0]} - 1) - 1}
+                {\text{stride[0]}}} \right \rfloor + 1 \\
+                W_{out} = \left \lfloor{\frac{W_{in} - \text{dilation[1]} \times (\text{kernel_size[1]} - 1) - 1}
+                {\text{stride[1]}}} \right \rfloor + 1 \\
             \end{array}
 
         pad_mode is ``'pad'``:
 
         .. math::
             \begin{array}{ll} \\
-                H_{out} = \left \lfloor{\frac{H_{in} + padding[0] + padding[1] - (\text{kernel_size[0]} - 1) \times
-                \text{dilation[0]} - 1 }{\text{stride[0]}} + 1} \right \rfloor \\
-                W_{out} = \left \lfloor{\frac{W_{in} + padding[2] + padding[3] - (\text{kernel_size[1]} - 1) \times
-                \text{dilation[1]} - 1 }{\text{stride[1]}} + 1} \right \rfloor \\
+                H_{out} = \left \lfloor{\frac{H_{in} + padding[0] + padding[1] - \text{dilation[0]} \times
+                (\text{kernel_size[0]} - 1) - 1}{\text{stride[0]}}} \right \rfloor + 1 \\
+                W_{out} = \left \lfloor{\frac{W_{in} + padding[2] + padding[3] - \text{dilation[1]} \times
+                (\text{kernel_size[1]} - 1) - 1}{\text{stride[1]}}} \right \rfloor + 1 \\
             \end{array}
 
     Raises:
@@ -351,16 +351,16 @@ class Conv2d(_Conv):
             bias_init,
             data_format,
             dtype=dtype)
-        self.conv2d = P.Conv2D(out_channel=self.out_channels,
-                               kernel_size=self.kernel_size,
-                               mode=1,
-                               pad_mode=self.pad_mode,
-                               pad=self.padding,
-                               stride=self.stride,
-                               dilation=self.dilation,
-                               group=self.group,
-                               data_format=self.data_format)
-        self.bias_add = P.BiasAdd(data_format=self.data_format)
+        self.conv2d = ops.Conv2D(out_channel=self.out_channels,
+                                 kernel_size=self.kernel_size,
+                                 mode=1,
+                                 pad_mode=self.pad_mode,
+                                 pad=self.padding,
+                                 stride=self.stride,
+                                 dilation=self.dilation,
+                                 group=self.group,
+                                 data_format=self.data_format)
+        self.bias_add = ops.BiasAdd(data_format=self.data_format)
 
     def construct(self, x):
         output = self.conv2d(x, self.weight)
@@ -476,19 +476,25 @@ class Conv1d(_Conv):
         pad_mode is ``'same'``:
 
         .. math::
-            L_{out} = \left \lceil{\frac{L_{in}}{\text{stride}}} \right \rceil
+            \begin{array}{ll} \\
+                L_{out} = \left \lceil{\frac{L_{in}}{\text{stride}}} \right \rceil \\
+            \end{array}
 
         pad_mode is ``'valid'``:
 
         .. math::
-            L_{out} = \left \lceil{\frac{L_{in} - \text{dilation} \times (\text{kernel_size} - 1) }
-            {\text{stride}}} \right \rceil
+            \begin{array}{ll} \\
+                L_{out} = \left \lfloor{\frac{L_{in} - \text{dilation} \times (\text{kernel_size} - 1) - 1}
+                {\text{stride}}} \right \rfloor + 1 \\
+            \end{array}
 
         pad_mode is ``'pad'``:
 
         .. math::
-            L_{out} = \left \lfloor{\frac{L_{in} + 2 \times padding - (\text{kernel_size} - 1) \times
-            \text{dilation} - 1 }{\text{stride}} + 1} \right \rfloor
+            \begin{array}{ll} \\
+                L_{out} = \left \lfloor{\frac{L_{in} + 2 \times {padding} - \text{dilation} \times
+                (\text{kernel_size} - 1) - 1}{\text{stride}}} \right \rfloor + 1 \\
+            \end{array}
 
     Raises:
         TypeError: If `in_channels`, `out_channels`, `kernel_size`, `stride`, `padding` or `dilation` is not an int.
@@ -541,8 +547,8 @@ class Conv1d(_Conv):
         kernel_size = (1, kernel_size)
         stride = (1, stride)
         dilation = (1, dilation)
-        get_shape = P.Shape()
-        get_dtype = P.DType()
+        get_shape = ops.Shape()
+        get_dtype = ops.DType()
         if isinstance(weight_init, Tensor):
             weight_init_shape = get_shape(weight_init)
             Validator.check_equal_int(len(weight_init_shape), 3, 'weight_init_shape', self.cls_name)
@@ -566,18 +572,18 @@ class Conv1d(_Conv):
             dtype=dtype)
         self.padding = (0, 0, padding, padding)
         Validator.check_string(pad_mode, ['valid', 'same', 'pad'], 'pad_mode', self.cls_name)
-        self.conv2d = P.Conv2D(out_channel=self.out_channels,
-                               kernel_size=self.kernel_size,
-                               mode=1,
-                               pad_mode=self.pad_mode,
-                               pad=self.padding,
-                               stride=self.stride,
-                               dilation=self.dilation,
-                               group=self.group)
-        self.bias_add = P.BiasAdd()
-        self.expand_dims = P.ExpandDims()
-        self.squeeze = P.Squeeze(2)
-        self.shape = P.Shape()
+        self.conv2d = ops.Conv2D(out_channel=self.out_channels,
+                                 kernel_size=self.kernel_size,
+                                 mode=1,
+                                 pad_mode=self.pad_mode,
+                                 pad=self.padding,
+                                 stride=self.stride,
+                                 dilation=self.dilation,
+                                 group=self.group)
+        self.bias_add = ops.BiasAdd()
+        self.expand_dims = ops.ExpandDims()
+        self.squeeze = ops.Squeeze(2)
+        self.shape = ops.Shape()
 
     def construct(self, x):
         x = self.expand_dims(x, 2)
@@ -727,24 +733,24 @@ class Conv3d(_Conv):
 
         .. math::
             \begin{array}{ll} \\
-                D_{out} = \left \lfloor{\frac{D_{in} - \text{dilation[0]} \times (\text{kernel_size[0]} - 1) }
-                {\text{stride[0]}} + 1} \right \rfloor \\
-                H_{out} = \left \lfloor{\frac{H_{in} - \text{dilation[1]} \times (\text{kernel_size[1]} - 1) }
-                {\text{stride[1]}} + 1} \right \rfloor \\
-                W_{out} = \left \lfloor{\frac{W_{in} - \text{dilation[2]} \times (\text{kernel_size[2]} - 1) }
-                {\text{stride[2]}} + 1} \right \rfloor \\
+                D_{out} = \left \lfloor{\frac{D_{in} - \text{dilation[0]} \times (\text{kernel_size[0]} - 1) - 1}
+                {\text{stride[0]}}} \right \rfloor + 1 \\
+                H_{out} = \left \lfloor{\frac{H_{in} - \text{dilation[1]} \times (\text{kernel_size[1]} - 1) - 1}
+                {\text{stride[1]}}} \right \rfloor + 1 \\
+                W_{out} = \left \lfloor{\frac{W_{in} - \text{dilation[2]} \times (\text{kernel_size[2]} - 1) - 1}
+                {\text{stride[2]}}} \right \rfloor + 1 \\
             \end{array}
 
         pad_mode is ``'pad'`` :
 
         .. math::
             \begin{array}{ll} \\
-                D_{out} = \left \lfloor{\frac{D_{in} + padding[0] + padding[1] - (\text{dilation[0]} - 1) \times
-                \text{kernel_size[0]} - 1 }{\text{stride[0]}} + 1} \right \rfloor \\
-                H_{out} = \left \lfloor{\frac{H_{in} + padding[2] + padding[3] - (\text{dilation[1]} - 1) \times
-                \text{kernel_size[1]} - 1 }{\text{stride[1]}} + 1} \right \rfloor \\
-                W_{out} = \left \lfloor{\frac{W_{in} + padding[4] + padding[5] - (\text{dilation[2]} - 1) \times
-                \text{kernel_size[2]} - 1 }{\text{stride[2]}} + 1} \right \rfloor \\
+                D_{out} = \left \lfloor{\frac{D_{in} + padding[0] + padding[1] - \text{dilation[0]} \times
+                (\text{kernel_size[0]} - 1) - 1}{\text{stride[0]}}} \right \rfloor + 1 \\
+                H_{out} = \left \lfloor{\frac{H_{in} + padding[2] + padding[3] - \text{dilation[1]} \times
+                (\text{kernel_size[1]} - 1) - 1}{\text{stride[1]}}} \right \rfloor + 1 \\
+                W_{out} = \left \lfloor{\frac{W_{in} + padding[4] + padding[5] - \text{dilation[2]} \times
+                (\text{kernel_size[2]} - 1) - 1}{\text{stride[2]}}} \right \rfloor + 1 \\
             \end{array}
 
     Raises:
@@ -812,20 +818,20 @@ class Conv3d(_Conv):
             data_format,
             dtype=dtype)
         out_channels = self.out_channels // group
-        self.conv3d = P.Conv3D(out_channel=out_channels,
-                               kernel_size=self.kernel_size,
-                               mode=1,
-                               pad_mode=self.pad_mode,
-                               pad=self.padding,
-                               stride=self.stride,
-                               dilation=self.dilation,
-                               group=1,
-                               data_format=self.data_format)
-        self.bias_add = P.BiasAdd(data_format=self.data_format)
-        self.shape = P.Shape()
-        self.concat = P.Concat(1)
-        self.split_0 = P.Split(0, self.group)
-        self.split_1 = P.Split(1, self.group)
+        self.conv3d = ops.Conv3D(out_channel=out_channels,
+                                 kernel_size=self.kernel_size,
+                                 mode=1,
+                                 pad_mode=self.pad_mode,
+                                 pad=self.padding,
+                                 stride=self.stride,
+                                 dilation=self.dilation,
+                                 group=1,
+                                 data_format=self.data_format)
+        self.bias_add = ops.BiasAdd(data_format=self.data_format)
+        self.shape = ops.Shape()
+        self.concat = ops.Concat(1)
+        self.split_0 = ops.Split(0, self.group)
+        self.split_1 = ops.Split(1, self.group)
 
     def construct(self, x):
         if self.group == 1:
@@ -935,11 +941,12 @@ class Conv3dTranspose(_Conv):
             Initializer for more details. Default: ``None`` , bias will be initialized using Uniform.
         data_format (str, optional): The optional value for data format. Currently only support ``'NCDHW'`` .
             Default: ``'NCDHW'`` .
-        dtype (:class:`mindspore.dtype`, optional): Dtype of Parameters. Default: ``mstype.float32`` .
+        dtype (:class:`mindspore.dtype`, optional): Dtype of Parameters. Should be the same as dtype of input.
+            Default: ``mstype.float32`` .
 
     Inputs:
         - **x** (Tensor) - Tensor of shape :math:`(N, C_{in}, D_{in}, H_{in}, W_{in})`.
-          Currently input data dtype only supports float16 and float32.
+          Currently input data dtype for Ascend only supports float16; for CPU/GPU only supports float16 and float32.
 
     Outputs:
         Tensor, the shape is :math:`(N, C_{out}, D_{out}, H_{out}, W_{out})`.
@@ -982,7 +989,7 @@ class Conv3dTranspose(_Conv):
         TypeError: If `in_channels`, `out_channels` or `group` is not an int.
         TypeError: If `kernel_size`, `stride`, `padding` , `dilation` or `output_padding`
                    is neither an int nor a tuple of three.
-        TypeError: If input data type is not float16 or float32.
+        TypeError: If input data type is not supported.For CPU/GPU: not float16 or float32;for ASCEND, not float16.
         ValueError: If `in_channels`, `out_channels`, `kernel_size`, `stride` or `dilation` is less than 1.
         ValueError: If `padding` is less than 0.
         ValueError: If `pad_mode` is not one of ``'same'``, ``'valid'``, ``'pad'``.
@@ -997,9 +1004,9 @@ class Conv3dTranspose(_Conv):
         >>> import mindspore
         >>> from mindspore import Tensor, nn
         >>> import numpy as np
-        >>> x = Tensor(np.ones([32, 16, 10, 32, 32]), mindspore.float32)
+        >>> x = Tensor(np.ones([32, 16, 10, 32, 32]), mindspore.float16)
         >>> conv3d_transpose = nn.Conv3dTranspose(in_channels=16, out_channels=3, kernel_size=(4, 6, 2),
-        ...                                       pad_mode='pad')
+        ...                                       pad_mode='pad', dtype=mindspore.float16)
         >>> output = conv3d_transpose(x)
         >>> print(output.shape)
         (32, 3, 13, 37, 33)
@@ -1032,7 +1039,7 @@ class Conv3dTranspose(_Conv):
         if isinstance(padding, tuple):
             Validator.check_equal_int(len(padding), 6, 'padding size', self.cls_name)
         self.output_padding = _check_3d_int_or_tuple("output_padding", output_padding, self.cls_name,
-                                                     greater_zero=False)
+                                                     greater_zero=False, pad_value=0)
         super(Conv3dTranspose, self).__init__(
             in_channels,
             out_channels,
@@ -1048,19 +1055,19 @@ class Conv3dTranspose(_Conv):
             data_format,
             transposed=True,
             dtype=dtype)
-        self.conv3d_transpose = P.Conv3DTranspose(in_channel=self.in_channels,
-                                                  out_channel=self.out_channels,
-                                                  kernel_size=self.kernel_size,
-                                                  mode=1,
-                                                  pad_mode=self.pad_mode,
-                                                  pad=self.padding,
-                                                  stride=self.stride,
-                                                  dilation=self.dilation,
-                                                  group=self.group,
-                                                  output_padding=self.output_padding,
-                                                  data_format=self.data_format)
-        self.bias_add = P.BiasAdd(data_format=self.data_format)
-        self.shape = P.Shape()
+        self.conv3d_transpose = ops.Conv3DTranspose(in_channel=self.in_channels,
+                                                    out_channel=self.out_channels,
+                                                    kernel_size=self.kernel_size,
+                                                    mode=1,
+                                                    pad_mode=self.pad_mode,
+                                                    pad=self.padding,
+                                                    stride=self.stride,
+                                                    dilation=self.dilation,
+                                                    group=self.group,
+                                                    output_padding=self.output_padding,
+                                                    data_format=self.data_format)
+        self.bias_add = ops.BiasAdd(data_format=self.data_format)
+        self.shape = ops.Shape()
 
     def construct(self, x):
         output = self.conv3d_transpose(x, self.weight)
@@ -1219,7 +1226,7 @@ class Conv2dTranspose(_Conv):
         >>> output = net(x).shape
         >>> print(output)
         (1, 64, 19, 53)
-        """
+    """
 
     def __init__(self,
                  in_channels,
@@ -1265,7 +1272,7 @@ class Conv2dTranspose(_Conv):
 
         self.in_channels = in_channels
         self.out_channels = out_channels
-        self.shape = P.Shape()
+        self.shape = ops.Shape()
         Validator.check_string(pad_mode, ['valid', 'same', 'pad'], 'pad_mode', self.cls_name)
         self.is_valid = self.pad_mode == 'valid'
         self.is_same = self.pad_mode == 'same'
@@ -1273,15 +1280,15 @@ class Conv2dTranspose(_Conv):
         self.output_padding = output_padding
 
         # cause Conv2DTranspose's out_channel refers to Conv2D's out_channel.
-        self.conv2d_transpose = P.Conv2DTranspose(out_channel=in_channels,
-                                                  kernel_size=kernel_size,
-                                                  mode=1,
-                                                  pad_mode=pad_mode,
-                                                  pad=padding,
-                                                  stride=stride,
-                                                  dilation=dilation,
-                                                  group=group)
-        self.bias_add = P.BiasAdd()
+        self.conv2d_transpose = ops.Conv2DTranspose(out_channel=in_channels,
+                                                    kernel_size=kernel_size,
+                                                    mode=1,
+                                                    pad_mode=pad_mode,
+                                                    pad=padding,
+                                                    stride=stride,
+                                                    dilation=dilation,
+                                                    group=group)
+        self.bias_add = ops.BiasAdd()
         if isinstance(self.padding, int):
             self.padding_top, self.padding_bottom, self.padding_left, self.padding_right = (self.padding,) * 4
         else:
@@ -1308,7 +1315,7 @@ class Conv2dTranspose(_Conv):
             if not self.is_pad and (self.output_padding[0] > 0 or self.output_padding[1] > 0):
                 raise ValueError("when output_padding is not zero, pad_mode must be 'pad'")
 
-            pad = P.Pad(paddings=((0, 0), (0, 0), (0, self.output_padding[0]), (0, self.output_padding[1])))
+            pad = ops.Pad(paddings=((0, 0), (0, 0), (0, self.output_padding[0]), (0, self.output_padding[1])))
             return pad(conv2d_trans_ret)
 
         if self.output_padding == 0:
@@ -1320,7 +1327,7 @@ class Conv2dTranspose(_Conv):
             raise ValueError("output_padding must be in range of [0, max(stride_w, dilation_w)).")
         if not self.is_pad and self.output_padding > 0:
             raise ValueError("when output_padding is not zero, pad_mode must be 'pad'")
-        pad = P.Pad(paddings=((0, 0), (0, 0), (0, self.output_padding), (0, self.output_padding)))
+        pad = ops.Pad(paddings=((0, 0), (0, 0), (0, self.output_padding), (0, self.output_padding)))
         return pad(conv2d_trans_ret)
 
 
@@ -1444,8 +1451,8 @@ class Conv1dTranspose(_Conv):
         kernel_size = (1, kernel_size)
         stride = (1, stride)
         dilation = (1, dilation)
-        get_shape = P.Shape()
-        get_dtype = P.DType()
+        get_shape = ops.Shape()
+        get_dtype = ops.DType()
         if isinstance(weight_init, Tensor):
             weight_init_shape = get_shape(weight_init)
             Validator.check_equal_int(len(weight_init_shape), 3, 'weight_init_shape', self.cls_name)
@@ -1473,24 +1480,24 @@ class Conv1dTranspose(_Conv):
         self.padding = (0, 0, padding, padding)
         self.in_channels = in_channels
         self.out_channels = out_channels
-        self.shape = P.Shape()
+        self.shape = ops.Shape()
         Validator.check_string(pad_mode, ['valid', 'same', 'pad'], 'pad_mode', self.cls_name)
         self.is_valid = self.pad_mode == 'valid'
         self.is_same = self.pad_mode == 'same'
         self.is_pad = self.pad_mode == 'pad'
 
         # cause Conv2DBackpropInput's out_channel refers to Conv2D's out_channel.
-        self.conv2d_transpose = P.Conv2DBackpropInput(out_channel=in_channels,
-                                                      kernel_size=kernel_size,
-                                                      mode=1,
-                                                      pad_mode=pad_mode,
-                                                      pad=self.padding,
-                                                      stride=stride,
-                                                      dilation=dilation,
-                                                      group=group)
-        self.bias_add = P.BiasAdd()
-        self.expand_dims = P.ExpandDims()
-        self.squeeze = P.Squeeze(2)
+        self.conv2d_transpose = ops.Conv2DBackpropInput(out_channel=in_channels,
+                                                        kernel_size=kernel_size,
+                                                        mode=1,
+                                                        pad_mode=pad_mode,
+                                                        pad=self.padding,
+                                                        stride=stride,
+                                                        dilation=dilation,
+                                                        group=group)
+        self.bias_add = ops.BiasAdd()
+        self.expand_dims = ops.ExpandDims()
+        self.squeeze = ops.Squeeze(2)
 
     def shard(self, strategy):
         self.conv2d_transpose.shard(strategy)

mindspore/nn/layer/dense.py

@@ -18,7 +18,7 @@ from __future__ import absolute_import
 
 import math
 
-import mindspore.ops as P
+from mindspore import ops
 import mindspore.common.dtype as mstype
 from mindspore.common.tensor import Tensor
 from mindspore.common.initializer import initializer, Uniform
@@ -41,9 +41,9 @@ def check_dense_inputs_same_shape(input1, input2, prim_name=None):
 @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)}'")
 
 
 @_primexpr
@@ -73,9 +73,11 @@ class BiDense(Cell):
         in2_channels (int): The number of channels in the input2 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 values of str refer to the function `initializer`. Default: ``None`` .
+            The values of str refer to the function :func:`mindspore.common.initializer.initializer`.
+            Default: ``None`` .
         bias_init (Union[Tensor, str, Initializer, numbers.Number]): The trainable bias_init parameter.
-            The values of str refer to the function `initializer`. Default: ``None`` .
+            The values of str refer to the function :func:`mindspore.common.initializer.initializer`.
+            Default: ``None`` .
         has_bias (bool): Specifies whether the layer uses :math:`\text{bias}` vector. Default: ``True`` .
         dtype (:class:`mindspore.dtype`): Dtype of Parameters. Default: ``mstype.float32`` .
 
@@ -170,8 +172,8 @@ class BiDense(Cell):
                                      f"be equal to 1, and the first dim must be equal to 'out_channels'. But got "
                                      f"'bias_init': {bias_init}, 'out_channels': {out_channels}.")
             self.bias = Parameter(initializer(bias_init, [out_channels], dtype=dtype), name="bias")
-            self.bias_add = P.BiasAdd()
-        self.matmul = P.MatMul()
+            self.bias_add = ops.BiasAdd()
+        self.matmul = ops.MatMul()
 
     def construct(self, input1, input2):
         _check_is_tensor("input1", input1, self.cls_name)

mindspore/nn/layer/embedding.py

@@ -19,8 +19,6 @@ import mindspore.common.dtype as mstype
 import mindspore.ops as ops
 from mindspore import log as logger
 from mindspore.common.tensor import Tensor
-from mindspore.ops import operations as P
-from mindspore.ops import functional as F
 from mindspore.common.parameter import Parameter
 from mindspore.common.parameter import _get_unique_parameter_key
 from mindspore.common.initializer import initializer, Normal
@@ -130,17 +128,17 @@ class Embedding(Cell):
             self.init_tensor = Tensor(self.init_tensor, init_tensor_type)
         self.embedding_table = Parameter(
             self.init_tensor, name='embedding_table')
-        self.expand = P.ExpandDims()
-        self.reshape_flat = P.Reshape()
+        self.expand = ops.ExpandDims()
+        self.reshape_flat = ops.Reshape()
         self.shp_flat = (-1,)
-        self.gather = P.Gather()
-        self.one_hot = P.OneHot()
+        self.gather = ops.Gather()
+        self.one_hot = ops.OneHot()
         self.on_value = Tensor(1.0, self.dtype)
         self.off_value = Tensor(0.0, self.dtype)
-        self.array_mul = P.MatMul()
-        self.reshape = P.Reshape()
-        self.get_shp = P.Shape()
-        self.concat = P.Concat()
+        self.array_mul = ops.MatMul()
+        self.reshape = ops.Reshape()
+        self.get_shp = ops.Shape()
+        self.concat = ops.Concat()
 
     def construct(self, ids):
         out_shape = self.get_shp(ids) + (self.embedding_size,)
@@ -311,9 +309,9 @@ class EmbeddingLookup(Cell):
 
     Note:
         When 'target' is set to 'CPU', this module will use
-        P.EmbeddingLookup().set_device('CPU') which
+        ops.EmbeddingLookup().set_device('CPU') which
         specified 'offset = 0' to lookup table.
-        When 'target' is set to 'DEVICE', this module will use P.Gather() which
+        When 'target' is set to 'DEVICE', this module will use ops.Gather() which
         specified 'axis = 0' to lookup table.
         In field slice mode, the manual_shapes must be given. It is a tuple ,where
         the element is vocab[i], vocab[i] is the row numbers for i-th part.
@@ -407,10 +405,10 @@ class EmbeddingLookup(Cell):
             raise ValueError(f"For '{self.cls_name}', 'sparse' must be True when 'target' is \"CPU\", "
                              f"but got 'sparse': {sparse} and 'target': {target}")
         if sparse:
-            self.gatherv2 = P.SparseGatherV2()
+            self.gatherv2 = ops.SparseGatherV2()
         else:
-            self.gatherv2 = P.Gather()
-        self.embeddinglookup = P.EmbeddingLookup().set_device('CPU')
+            self.gatherv2 = ops.Gather()
+        self.embeddinglookup = ops.EmbeddingLookup().set_device('CPU')
         self.is_ps_server = False
         enable_ps = _get_ps_context("enable_ps")
         if enable_ps:
@@ -422,13 +420,13 @@ class EmbeddingLookup(Cell):
         parallel_mode = _get_parallel_mode()
         is_auto_parallel = parallel_mode in (
             ParallelMode.SEMI_AUTO_PARALLEL, ParallelMode.AUTO_PARALLEL)
-        self.gather_revert = P.Gather()
-        self.reshape_first = P.Reshape()
-        self.reshape = P.Reshape()
-        self.unique = P.Unique()
-        self.shape = P.Shape()
+        self.gather_revert = ops.Gather()
+        self.reshape_first = ops.Reshape()
+        self.reshape = ops.Reshape()
+        self.unique = ops.Unique()
+        self.shape = ops.Shape()
         if is_auto_parallel:
-            self.unique = P.Unique().shard(((1,),))
+            self.unique = ops.Unique().shard(((1,),))
         if self.cache_enable and enable_ps:
             self._set_voacb_cache_enable_for_ps(
                 vocab_cache_size, embedding_size, vocab_size, param_init, dtype=dtype)
@@ -582,12 +580,12 @@ class EmbeddingLookup(Cell):
 
             # Add EmbeddingLookup ops on different servers.
             if self.target == 'CPU':
-                embedding_lookup = P.EmbeddingLookup().set_device('CPU')
+                embedding_lookup = ops.EmbeddingLookup().set_device('CPU')
             else:
                 if self.sparse:
-                    embedding_lookup = P.SparseGatherV2()
+                    embedding_lookup = ops.SparseGatherV2()
                 else:
-                    embedding_lookup = P.Gather()
+                    embedding_lookup = ops.Gather()
                 embedding_lookup.add_prim_attr(
                     'offset', self.embedding_offset[i])
             embedding_lookup.add_prim_attr('rank_id', i)
@@ -596,7 +594,7 @@ class EmbeddingLookup(Cell):
 
         # For now unique operation is not applied,
         # so we need to reduce the lookup results from different servers with AddN.
-        self.reduce_lookup_result = P.AddN()
+        self.reduce_lookup_result = ops.AddN()
 
     def _do_server_embedding_lookup(self, indices):
         '''
@@ -647,7 +645,7 @@ class EmbeddingLookup(Cell):
             else:
                 out = self.gatherv2(self.embedding_table, indices, 0)
         if self.max_norm is not None:
-            axis = _make_axis_range(F.rank(indices), F.rank(out))
+            axis = _make_axis_range(ops.rank(indices), ops.rank(out))
             clip_by_norm = ClipByNorm(axis)
             out = clip_by_norm(out, self.max_norm)
         return out
@@ -660,9 +658,9 @@ class MultiFieldEmbeddingLookup(EmbeddingLookup):
 
     Note:
         When 'target' is set to 'CPU', this module will use
-        P.EmbeddingLookup().set_device('CPU') which
+        ops.EmbeddingLookup().set_device('CPU') which
         specified 'offset = 0' to lookup table.
-        When 'target' is set to 'DEVICE', this module will use P.Gather() which
+        When 'target' is set to 'DEVICE', this module will use ops.Gather() which
         specified 'axis = 0' to lookup table.
         The vectors with the same field_ids  will be combined by the `operator`, such as 'SUM', 'MAX' and
         'MEAN'. Ensure the input_values of the padded id is zero, so that they can be ignored. The final
@@ -753,29 +751,29 @@ class MultiFieldEmbeddingLookup(EmbeddingLookup):
             field_size, 'field_size', self.cls_name)
         self.operator = operator
 
-        self.mul = P.Mul()
-        self.inf_mask_mul = P.Mul()
-        self.bias_add = P.Add()
-        self.inf_add = P.Add()
+        self.mul = ops.Mul()
+        self.inf_mask_mul = ops.Mul()
+        self.bias_add = ops.Add()
+        self.inf_add = ops.Add()
         self.merge_op = None
-        self.count_op = P.UnsortedSegmentSum()
-        self.abs = P.Abs()
-        self.equal = P.Equal()
-        self.add = P.Add()
-        self.cast = P.Cast()
-        self.div_no_nan = P.DivNoNan()
-        self.expand = P.ExpandDims()
-        self.max_mask_mul = P.Mul()
-        self.max_no_equal = P.NotEqual()
+        self.count_op = ops.UnsortedSegmentSum()
+        self.abs = ops.Abs()
+        self.equal = ops.Equal()
+        self.add = ops.Add()
+        self.cast = ops.Cast()
+        self.div_no_nan = ops.DivNoNan()
+        self.expand = ops.ExpandDims()
+        self.max_mask_mul = ops.Mul()
+        self.max_no_equal = ops.NotEqual()
 
         Validator.check_string(
             operator, ['SUM', 'MAX', 'MEAN'], 'operator', self.cls_name)
         if operator == MultiFieldEmbeddingLookup.OPERATOR_SUM:
-            self.merge_op = P.UnsortedSegmentSum()
+            self.merge_op = ops.UnsortedSegmentSum()
         elif operator == MultiFieldEmbeddingLookup.OPERATOR_MAX:
-            self.merge_op = P.UnsortedSegmentMax()
+            self.merge_op = ops.UnsortedSegmentMax()
         else:
-            self.merge_op = P.UnsortedSegmentSum()
+            self.merge_op = ops.UnsortedSegmentSum()
 
 
         parallel_mode = _get_parallel_mode()
@@ -822,16 +820,16 @@ class MultiFieldEmbeddingLookup(EmbeddingLookup):
         self.negative_inf_value = -3.402823466E+38
 
     def construct(self, input_indices, input_values, field_ids):
-        _check_input_2d(F.shape(input_indices), "input_indices", self.cls_name)
-        _check_input_2d(F.shape(input_values), "input_values", self.cls_name)
-        _check_input_2d(F.shape(field_ids), "field_ids", self.cls_name)
-        _check_input_dtype(F.dtype(input_indices), "input_indices", [mstype.int32, mstype.int64], self.cls_name)
-        _check_input_dtype(F.dtype(input_values), "input_values", [mstype.float32], self.cls_name)
-        _check_input_dtype(F.dtype(field_ids), "field_ids", [mstype.int32], self.cls_name)
+        _check_input_2d(ops.shape(input_indices), "input_indices", self.cls_name)
+        _check_input_2d(ops.shape(input_values), "input_values", self.cls_name)
+        _check_input_2d(ops.shape(field_ids), "field_ids", self.cls_name)
+        _check_input_dtype(ops.dtype(input_indices), "input_indices", [mstype.int32, mstype.int64], self.cls_name)
+        _check_input_dtype(ops.dtype(input_values), "input_values", [mstype.float32], self.cls_name)
+        _check_input_dtype(ops.dtype(field_ids), "field_ids", [mstype.int32], self.cls_name)
 
         batch_size = self.shape(input_indices)[0]
         num_segments = batch_size * self.field_size
-        bias = F.tuple_to_array(F.make_range(0, num_segments, self.field_size))
+        bias = ops.tuple_to_array(ops.make_range(0, num_segments, self.field_size))
         bias = self.reshape(bias, (batch_size, -1))
         field_ids = self.bias_add(field_ids, bias)
 
@@ -848,7 +846,7 @@ class MultiFieldEmbeddingLookup(EmbeddingLookup):
             else:
                 out = self.gatherv2(self.embedding_table, input_indices, 0)
         if self.max_norm is not None:
-            axis = _make_axis_range(F.rank(input_indices), F.rank(out))
+            axis = _make_axis_range(ops.rank(input_indices), ops.rank(out))
             clip_by_norm = ClipByNorm(axis)
             out = clip_by_norm(out, self.max_norm)