modifg_ops_note

mindspore/ops/__init__.py

@@ -18,17 +18,7 @@ Operators can be used in the construct function of Cell.
 
 Examples:
 
-    >>> from mindspore.ops import operations as P
-    >>> from mindspore.ops import composite as C
-    >>> from mindspore.ops import functional as F
     >>> import mindspore.ops as ops
-
-Note:
-    - The Primitive operators in operations need to be instantiated before being used.
-    - The composite operators are the pre-defined combination of operators.
-    - The functional operators are the pre-instantiated Primitive operators, which can be used directly as a function.
-    - For functional operators usage, please refer to
-      https://gitee.com/mindspore/mindspore/blob/master/mindspore/ops/functional.py
 """
 
 from .primitive import Primitive, PrimitiveWithInfer, prim_attr_register

mindspore/ops/operations/_cache_ops.py

@@ -94,7 +94,7 @@ class SearchCacheIdx(PrimitiveWithInfer):
                                                 [21, 9, -5, 1]], np.int32)), name="hashmap")
         >>> indices = Tensor(np.array([10, 2, 25, 5, 3], np.int32))
         >>> step = 0, emb_max_num = 25, cache_max_num = 10
-        >>> ops = P.SearchCacheIdx()
+        >>> ops = ops.SearchCacheIdx()
         >>> cache_idx, miss_idx, miss_emb_idx = ops(hashmap, indices, step, emb_max_num, cache_max_num)
         cache_idx : [5, 1, 10, -1, 3]
         miss_idx : [-1, -1, -1, 3, -1]

mindspore/ops/operations/_grad_ops.py

@@ -496,7 +496,7 @@ class DropoutGrad(PrimitiveWithInfer):
         Tensor, the value of generated mask for input shape.
 
     Examples:
-        >>> dropout_grad = P.DropoutGrad(keep_prob=0.5)
+        >>> dropout_grad = ops.DropoutGrad(keep_prob=0.5)
         >>> in = Tensor((20, 16, 50, 50))
         >>> out = dropout_grad(in)
     """

mindspore/ops/operations/_inner_ops.py

@@ -130,7 +130,7 @@ class Range(PrimitiveWithInfer):
         Tensor, has the same shape and dtype as `input_x`.
 
     Examples:
-        >>> range = P.Range(1.0, 8.0, 2.0)
+        >>> range = ops.Range(1.0, 8.0, 2.0)
         >>> x = Tensor(np.array([1, 2, 3, 2]), mindspore.int32)
         >>> output = range(x)
         >>> print(output)
@@ -199,7 +199,7 @@ class Quant(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor([100.0, 150.0], mstype.float32)
-        >>> quant = P.Quant(80.0, 0.0, False, "Round")
+        >>> quant = ops.Quant(80.0, 0.0, False, "Round")
         >>> y = quant(input_x)
     """
 
@@ -253,7 +253,7 @@ class Dequant(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor([100.0, 150.0], mstype.float32)
-        >>> dequant = P.Dequant(False, False)
+        >>> dequant = ops.Dequant(False, False)
         >>> y = dequant(input_x)
     """
 
@@ -289,7 +289,7 @@ class LinSpace(PrimitiveWithInfer):
         Tensor, has the same shape as `assist`.
 
     Examples:
-        >>> linspace = P.LinSpace()
+        >>> linspace = ops.LinSpace()
         >>> assist = Tensor([5, 5.5], mindspore.float32)
         >>> start = Tensor(1, mindspore.float32)
         >>> stop = Tensor(10, mindspore.float32)
@@ -329,7 +329,7 @@ class MatrixDiag(PrimitiveWithInfer):
     Examples:
         >>> x = Tensor(np.array([1, -1]), mstype.float32)
         >>> assist = Tensor(np.arange(-12, 0).reshape(3, 2, 2), mindspore.float32)
-        >>> matrix_diag = P.MatrixDiag()
+        >>> matrix_diag = ops.MatrixDiag()
         >>> result = matrix_diag(x, assist)
         >>> print(result)
         [[[-12.   11.]
@@ -383,7 +383,7 @@ class MatrixDiagPart(PrimitiveWithInfer):
     Examples:
         >>> x = Tensor([[[-1, 0], [0, 1]], [[-1, 0], [0, 1]], [[-1, 0], [0, 1]]], mindspore.float32)
         >>> assist = Tensor(np.arange(-12, 0).reshape(3, 2, 2), mindspore.float32)
-        >>> matrix_diag_part = P.MatrixDiagPart()
+        >>> matrix_diag_part = ops.MatrixDiagPart()
         >>> result = matrix_diag_part(x, assist)
         >>> print(result)
         [[12., -9.], [8., -5.], [4., -1.]]
@@ -426,7 +426,7 @@ class MatrixSetDiag(PrimitiveWithInfer):
     Examples:
         >>> x = Tensor([[[-1, 0], [0, 1]], [[-1, 0], [0, 1]], [[-1, 0], [0, 1]]], mindspore.float32)
         >>> diagonal = Tensor([[-1., 2.], [-1., 1.], [-1., 1.]], mindspore.float32)
-        >>> matrix_set_diag = P.MatrixSetDiag()
+        >>> matrix_set_diag = ops.MatrixSetDiag()
         >>> result = matrix_set_diag(x, diagonal)
         >>> print(result)
         [[[-1, 0], [0, 2]], [[-1, 0], [0, 1]], [[-1, 0], [0, 1]]]
@@ -523,7 +523,7 @@ class DynamicGRUV2(PrimitiveWithInfer):
         >>> bias_i = Tensor(np.random.rand(48).astype(np.float16))
         >>> bias_h = Tensor(np.random.rand(48).astype(np.float16))
         >>> init_h = Tensor(np.random.rand(8, 16).astype(np.float16))
-        >>> dynamic_gru_v2 = P.DynamicGRUV2()
+        >>> dynamic_gru_v2 = ops.DynamicGRUV2()
         >>> output = dynamic_gru_v2(x, weight_i, weight_h, bias_i, bias_h, None, init_h)
         >>> result = output[0].shape
         >>> print(result)
@@ -640,7 +640,7 @@ class ConfusionMulGrad(PrimitiveWithInfer):
               the shape of output is :math:`(x_1,x_4,...x_R)`.
 
     Examples:
-        >>> confusion_mul_grad = P.ConfusionMulGrad()
+        >>> confusion_mul_grad = ops.ConfusionMulGrad()
         >>> input_0 = Tensor(np.random.randint(-2, 2, (2, 3)), mindspore.float32)
         >>> input_1 = Tensor(np.random.randint(0, 4, (2, 3)), mindspore.float32)
         >>> input_2 = Tensor(np.random.randint(-4, 0, (2, 3)), mindspore.float32)

mindspore/ops/operations/_quant_ops.py

@@ -752,7 +752,7 @@ class BatchNormFoldGrad(PrimitiveWithInfer):
     Performs grad of BatchNormFold operation.
 
     Examples:
-        >>> batch_norm_fold_grad = P.BatchNormFoldGrad()
+        >>> batch_norm_fold_grad = ops.BatchNormFoldGrad()
         >>> d_batch_mean = Tensor(np.random.randint(-2., 2., (1, 2, 2, 3)), mindspore.float32)
         >>> d_batch_std = Tensor(np.random.randn(1, 2, 2, 3), mindspore.float32)
         >>> input_x = Tensor(np.random.randint(0, 256, (4, 1, 4, 6)), mindspore.float32)
@@ -809,7 +809,7 @@ class CorrectionMul(PrimitiveWithInfer):
         - **out** (Tensor) - Tensor has the same shape as x.
 
     Examples:
-        >>> correction_mul = P.CorrectionMul()
+        >>> correction_mul = ops.CorrectionMul()
         >>> input_x = Tensor(np.random.randint(-8, 12, (3, 4)), mindspore.float32)
         >>> batch_std = Tensor(np.array([1.5, 3, 2]), mindspore.float32)
         >>> running_std = Tensor(np.array([2, 1.2, 0.5]), mindspore.float32)
@@ -842,7 +842,7 @@ class CorrectionMulGrad(PrimitiveWithInfer):
     Performs grad of CorrectionMul operation.
 
     Examples:
-        >>> correction_mul_grad = P.CorrectionMulGrad()
+        >>> correction_mul_grad = ops.CorrectionMulGrad()
         >>> dout = Tensor(np.array([1.5, -2.2, 0.7, -3, 1.6, 2.8]).reshape(2, 1, 1, 3), mindspore.float32)
         >>> input_x = Tensor(np.random.randint(0, 256, (2, 1, 1, 3)), mindspore.float32)
         >>> gamma = Tensor(np.array([0.2, -0.2, 2.5, -1.]).reshape(2, 1, 2), mindspore.float32)
@@ -882,7 +882,7 @@ class CorrectionMulGradReduce(PrimitiveWithInfer):
     Performs grad reduce of CorrectionMul operation.
 
     Examples:
-        >>> correction_mul_grad_rd = P.CorrectionMulGradReduce()
+        >>> correction_mul_grad_rd = ops.CorrectionMulGradReduce()
         >>> dout = Tensor(np.array([1.5, -2.2, 0.7, -3, 1.6, 2.8]).reshape(2, 1, 1, 3), mindspore.float32)
         >>> input_x = Tensor(np.random.randint(0, 256, (2, 1, 1, 3)), mindspore.float32)
         >>> gamma = Tensor(np.array([0.2, -0.2, 2.5, -1.]).reshape(2, 1, 2), mindspore.float32)
@@ -926,7 +926,7 @@ class BatchNormFold2(PrimitiveWithInfer):
         - **y** (Tensor) - Tensor has the same shape as x.
 
     Examples:
-        >>> batch_norm_fold2 = P.BatchNormFold2()
+        >>> batch_norm_fold2 = ops.BatchNormFold2()
         >>> input_x = Tensor(np.random.randint(-6, 6, (4, 3)), mindspore.float32)
         >>> beta = Tensor(np.array([0.2, -0.1, 0.25]), mindspore.float32)
         >>> gamma = Tensor(np.array([-0.1, -0.25, 0.1]), mindspore.float32)
@@ -974,7 +974,7 @@ class BatchNormFold2Grad(PrimitiveWithInfer):
     Performs grad of CorrectionAddGrad operation.
 
     Examples:
-        >>> bnf2_grad = P.BatchNormFold2Grad()
+        >>> bnf2_grad = ops.BatchNormFold2Grad()
         >>> input_x = Tensor(np.arange(3*3*12*12).reshape(6, 3, 6, 12), mindspore.float32)
         >>> dout = Tensor(np.random.randint(-32, 32, (6, 3, 6, 12)), mindspore.float32)
         >>> gamma = Tensor(np.random.randint(-4, 4, (3, 1, 1, 2)), mindspore.float32)

mindspore/ops/operations/_thor_ops.py

@@ -82,7 +82,7 @@ class CusBatchMatMul(PrimitiveWithInfer):
     Examples:
         >>> input_x = Tensor(np.ones(shape=[2, 128, 128]), mindspore.float32)
         >>> input_y = Tensor(np.ones(shape=[2, 128, 128]), mindspore.float32)
-        >>> cus_batch_matmul = P.CusBatchMatMul()
+        >>> cus_batch_matmul = ops.CusBatchMatMul()
         >>> output = cus_batch_matmul(input_x, input_y)
     """
 
@@ -115,7 +115,7 @@ class CusCholeskyTrsm(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor(np.ones(shape=[256, 256]), mindspore.float32)
-        >>> cus_choleskytrsm = P.CusCholeskyTrsm()
+        >>> cus_choleskytrsm = ops.CusCholeskyTrsm()
         >>> output = matmul(input_x)
     """
 
@@ -151,7 +151,7 @@ class CusFusedAbsMax1(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor(np.ones(shape=[1, 3]), mindspore.float32)
-        >>> cus_fused_abs_max1 = P.CusFusedAbsMax1()
+        >>> cus_fused_abs_max1 = ops.CusFusedAbsMax1()
         >>> output = cus_fused_abs_max1(input_x)
     """
 
@@ -187,7 +187,7 @@ class CusImg2Col(PrimitiveWithInfer):
         Tensor, the shape of the output tensor is :math:`(N * H_O * W_O, C1 * K_W * K_H * C0)`.
     Examples:
         >>> input_x = Tensor(np.ones(shape=[32, 3, 224, 224]), mindspore.float16)
-        >>> cusimg2col = P.CusImg2Col()
+        >>> cusimg2col = ops.CusImg2Col()
         >>> output = cusimg2col(input_x)
     """
 
@@ -233,7 +233,7 @@ class CusMatMulCubeDenseLeft(PrimitiveWithInfer):
     Examples:
         >>> input_x = Tensor(np.ones(shape=[16, 16, 16, 16]), mindspore.float16)
         >>> input_y = Tensor(np.ones(shape=[256, 256]), mindspore.float16)
-        >>> matmulcubedenseleft = P.CusMatMulCubeDenseLeft()
+        >>> matmulcubedenseleft = ops.CusMatMulCubeDenseLeft()
         >>> output = matmulcubedenseleft(input_x, input_y)
     """
 
@@ -268,7 +268,7 @@ class CusMatMulCubeFraczRightMul(PrimitiveWithInfer):
         >>> input_x1 = Tensor(np.ones(shape=[256, 256]), mindspore.float16)
         >>> input_x2 = Tensor(np.ones(shape=[16, 16, 16, 16]), mindspore.float16)
         >>> input_x3 = Tensor(np.ones(shape=[1, ]), mindspore.float16)
-        >>> cusmatmulfraczrightmul = P.CusMatMulCubeFraczRightMul()
+        >>> cusmatmulfraczrightmul = ops.CusMatMulCubeFraczRightMul()
         >>> output = cusmatmulfraczrightmul(input_x1, input_x2, input_x3)
     """
 
@@ -307,7 +307,7 @@ class CusMatMulCube(PrimitiveWithInfer):
     Examples:
         >>> input_x = Tensor(np.ones(shape=[256, 256]), mindspore.float16)
         >>> input_y = Tensor(np.ones(shape=[256, 256]), mindspore.float16)
-        >>> cusmatmulcube = P.CusMatMulCube()
+        >>> cusmatmulcube = ops.CusMatMulCube()
         >>> output = matmul(input_x, input_y)
     """
 
@@ -349,7 +349,7 @@ class CusMatrixCombine(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor(np.ones(shape=[2, 128, 128]), mindspore.float32)
-        >>> cusmatrixcombine = P.CusMatrixCombine()
+        >>> cusmatrixcombine = ops.CusMatrixCombine()
         >>> output = cusmatrixcombine(input_x)
     """
 
@@ -383,7 +383,7 @@ class CusTranspose02314(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor(np.ones(shape=[32, 1, 224, 224, 16]), mindspore.float16)
-        >>> custranspose02314 = P.CusTranspose02314()
+        >>> custranspose02314 = ops.CusTranspose02314()
         >>> output = custranspose02314(input_x)
     """
 
@@ -429,7 +429,7 @@ class CusMatMulCubeDenseRight(PrimitiveWithInfer):
     Examples:
         >>> input_x = Tensor(np.ones(shape=[256, 256]), mindspore.float16)
         >>> input_y = Tensor(np.ones(shape=[16, 16, 16, 16]), mindspore.float16)
-        >>> cusmatmulcubedenseright = P.CusMatMulCubeDenseRight()
+        >>> cusmatmulcubedenseright = ops.CusMatMulCubeDenseRight()
         >>> output = cusmatmulcubedenseright(input_x, input_y)
     """
 
@@ -464,7 +464,7 @@ class CusMatMulCubeFraczLeftCast(PrimitiveWithInfer):
     Examples:
         >>> input_x = Tensor(np.ones(shape=[16, 16, 16, 16]), mindspore.float16)
         >>> input_y = Tensor(np.ones(shape=[256, 256]), mindspore.float16)
-        >>> cusmatmulcubefraczleftcast = P.CusMatMulCubeFraczLeftCast()
+        >>> cusmatmulcubefraczleftcast = ops.CusMatMulCubeFraczLeftCast()
         >>> output = cusmatmulcubefraczleftcast(input_x, input_y)
     """
 
@@ -494,7 +494,7 @@ class Im2Col(PrimitiveWithInfer):
         Tensor.
     Examples:
         >>> input_x = Tensor(np.random.rand(32, 3, 224, 224).astype(np.float16))
-        >>> img2col = P.CusMatMulCubeDenseLeft(kernel_size=7, pad=3, stride=2)
+        >>> img2col = ops.CusMatMulCubeDenseLeft(kernel_size=7, pad=3, stride=2)
         >>> output = img2col(input_x)
     """
 
@@ -587,7 +587,7 @@ class UpdateThorGradient(PrimitiveWithInfer):
         >>> for i in range(16):
         ...     input_x3[i,:,:,:] = temp_x3
         >>> input_x3 = Tensor(input_x3)
-        >>> update_thor_gradient = P.UpdateThorGradient(split_dim=128)
+        >>> update_thor_gradient = ops.UpdateThorGradient(split_dim=128)
         >>> output = update_thor_gradient(input_x1, input_x2, input_x3)
     """
 

mindspore/ops/operations/array_ops.py

@@ -148,7 +148,7 @@ class ExpandDims(PrimitiveWithInfer):
 
     Examples:
         >>> input_tensor = Tensor(np.array([[2, 2], [2, 2]]), mindspore.float32)
-        >>> expand_dims = P.ExpandDims()
+        >>> expand_dims = ops.ExpandDims()
         >>> output = expand_dims(input_tensor, 0)
         >>> print(output)
         [[[2. 2.]
@@ -200,7 +200,7 @@ class DType(PrimitiveWithInfer):
 
     Examples:
         >>> input_tensor = Tensor(np.array([[2, 2], [2, 2]]), mindspore.float32)
-        >>> output = P.DType()(input_tensor)
+        >>> output = ops.DType()(input_tensor)
         >>> print(output)
         Float32
     """
@@ -239,7 +239,7 @@ class SameTypeShape(PrimitiveWithInfer):
     Examples:
         >>> input_x = Tensor(np.array([[2, 2], [2, 2]]), mindspore.float32)
         >>> input_y = Tensor(np.array([[2, 2], [2, 2]]), mindspore.float32)
-        >>> output = P.SameTypeShape()(input_x, input_y)
+        >>> output = ops.SameTypeShape()(input_x, input_y)
         >>> print(output)
         [[2. 2.]
          [2. 2.]]
@@ -284,7 +284,7 @@ class Cast(PrimitiveWithInfer):
         >>> input_np = np.random.randn(2, 3, 4, 5).astype(np.float32)
         >>> input_x = Tensor(input_np)
         >>> type_dst = mindspore.float16
-        >>> cast = P.Cast()
+        >>> cast = ops.Cast()
         >>> output = cast(input_x, type_dst)
         >>> print(output.dtype)
         Float16
@@ -357,7 +357,7 @@ class IsSubClass(PrimitiveWithInfer):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> output = P.IsSubClass()(mindspore.int32,  mindspore.intc)
+        >>> output = ops.IsSubClass()(mindspore.int32,  mindspore.intc)
         >>> print(output)
         True
     """
@@ -397,7 +397,7 @@ class IsInstance(PrimitiveWithInfer):
 
     Examples:
         >>> a = 1
-        >>> output = P.IsInstance()(a, mindspore.int32)
+        >>> output = ops.IsInstance()(a, mindspore.int32)
         >>> print(output)
         False
     """
@@ -447,7 +447,7 @@ class Reshape(PrimitiveWithInfer):
 
     Examples:
         >>> input_tensor = Tensor(np.array([[-0.1, 0.3, 3.6], [0.4, 0.5, -3.2]]), mindspore.float32)
-        >>> reshape = P.Reshape()
+        >>> reshape = ops.Reshape()
         >>> output = reshape(input_tensor, (3, 2))
         >>> print(output)
         [[-0.1  0.3]
@@ -539,7 +539,7 @@ class Shape(PrimitiveWithInfer):
 
     Examples:
         >>> input_tensor = Tensor(np.ones(shape=[3, 2, 1]), mindspore.float32)
-        >>> shape = P.Shape()
+        >>> shape = ops.Shape()
         >>> output = shape(input_tensor)
         >>> print(output)
         (3, 2, 1)
@@ -572,7 +572,7 @@ class DynamicShape(Primitive):
 
     Examples:
         >>> input_tensor = Tensor(np.ones(shape=[3, 2, 1]), mindspore.float32)
-        >>> shape = P.DynamicShape()
+        >>> shape = ops.DynamicShape()
         >>> output = shape(input_tensor)
     """
 
@@ -610,7 +610,7 @@ class Squeeze(PrimitiveWithInfer):
 
     Examples:
         >>> input_tensor = Tensor(np.ones(shape=[3, 2, 1]), mindspore.float32)
-        >>> squeeze = P.Squeeze(2)
+        >>> squeeze = ops.Squeeze(2)
         >>> output = squeeze(input_tensor)
         >>> print(output)
         [[1. 1.]
@@ -669,7 +669,7 @@ class Transpose(PrimitiveWithCheck):
     Examples:
         >>> input_tensor = Tensor(np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]), mindspore.float32)
         >>> perm = (0, 2, 1)
-        >>> transpose = P.Transpose()
+        >>> transpose = ops.Transpose()
         >>> output = transpose(input_tensor, perm)
         >>> print(output)
         [[[ 1.  4.]
@@ -711,7 +711,7 @@ class Unique(Primitive):
 
     Examples:
         >>> x = Tensor(np.array([1, 2, 5, 2]), mindspore.int32)
-        >>> output = P.Unique()(x)
+        >>> output = ops.Unique()(x)
         >>> print(output)
         (Tensor(shape=[3], dtype=Int32, value= [1, 2, 5]), Tensor(shape=[4], dtype=Int32, value= [0, 1, 2, 1]))
     """
@@ -743,7 +743,7 @@ class GatherV2(PrimitiveWithCheck):
         >>> input_params = Tensor(np.array([[1, 2, 7, 42], [3, 4, 54, 22], [2, 2, 55, 3]]), mindspore.float32)
         >>> input_indices = Tensor(np.array([1, 2]), mindspore.int32)
         >>> axis = 1
-        >>> output = P.GatherV2()(input_params, input_indices, axis)
+        >>> output = ops.GatherV2()(input_params, input_indices, axis)
         >>> print(output)
         [[ 2.  7.]
          [ 4. 54.]
@@ -796,7 +796,7 @@ class SparseGatherV2(GatherV2):
         >>> input_params = Tensor(np.array([[1, 2, 7, 42], [3, 4, 54, 22], [2, 2, 55, 3]]), mindspore.float32)
         >>> input_indices = Tensor(np.array([1, 2]), mindspore.int32)
         >>> axis = 1
-        >>> out = P.SparseGatherV2()(input_params, input_indices, axis)
+        >>> out = ops.SparseGatherV2()(input_params, input_indices, axis)
     """
 
 
@@ -820,7 +820,7 @@ class Padding(PrimitiveWithInfer):
     Examples:
         >>> x = Tensor(np.array([[8], [10]]), mindspore.float32)
         >>> pad_dim_size = 4
-        >>> output = P.Padding(pad_dim_size)(x)
+        >>> output = ops.Padding(pad_dim_size)(x)
         >>> print(output)
         [[ 8.  0.  0.  0.]
          [10.  0.  0.  0.]]
@@ -865,7 +865,7 @@ class UniqueWithPad(PrimitiveWithInfer):
     Examples:
         >>> x = Tensor(np.array([1, 1, 5, 5, 4, 4, 3, 3, 2, 2,]), mindspore.int32)
         >>> pad_num = 8
-        >>> output = P.UniqueWithPad()(x, pad_num)
+        >>> output = ops.UniqueWithPad()(x, pad_num)
         >>> print(output)
         (Tensor(shape=[10], dtype=Int32, value= [1, 5, 4, 3, 2, 8, 8, 8, 8, 8]),
          Tensor(shape=[10], dtype=Int32, value= [0, 0, 1, 1, 2, 2, 3, 3, 4, 4]))
@@ -911,7 +911,7 @@ class Split(PrimitiveWithInfer):
         ``Ascend`` ``GPU``
 
     Examples:
-        >>> split = P.Split(1, 2)
+        >>> split = ops.Split(1, 2)
         >>> x = Tensor(np.array([[1, 1, 1, 1], [2, 2, 2, 2]]), mindspore.int32)
         >>> output = split(x)
         >>> print(output)
@@ -973,7 +973,7 @@ class Rank(PrimitiveWithInfer):
 
     Examples:
         >>> input_tensor = Tensor(np.array([[2, 2], [2, 2]]), mindspore.float32)
-        >>> rank = P.Rank()
+        >>> rank = ops.Rank()
         >>> output = rank(input_tensor)
         >>> print(output)
         2
@@ -1009,7 +1009,7 @@ class TruncatedNormal(PrimitiveWithInfer):
 
     Examples:
         >>> shape = (1, 2, 3)
-        >>> truncated_normal = P.TruncatedNormal()
+        >>> truncated_normal = ops.TruncatedNormal()
         >>> output = truncated_normal(shape)
     """
 
@@ -1048,7 +1048,7 @@ class Size(PrimitiveWithInfer):
 
     Examples:
         >>> input_tensor = Tensor(np.array([[2, 2], [2, 2]]), mindspore.float32)
-        >>> size = P.Size()
+        >>> size = ops.Size()
         >>> output = size(input_tensor)
         >>> print(output)
         4
@@ -1090,7 +1090,7 @@ class Fill(PrimitiveWithInfer):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> fill = P.Fill()
+        >>> fill = ops.Fill()
         >>> output = fill(mindspore.float32, (2, 2), 1)
         >>> print(output)
         [[1. 1.]
@@ -1139,8 +1139,8 @@ class Ones(PrimitiveWithInfer):
         ``Ascend`` ``GPU``
 
     Examples:
-        >>> from mindspore.ops import operations as P
-        >>> ones = P.Ones()
+        >>> from mindspore.ops import operations as ops
+        >>> ones = ops.Ones()
         >>> output = ones((2, 2), mindspore.float32)
         >>> print(output)
         [[1.0, 1.0],
@@ -1192,8 +1192,8 @@ class Zeros(PrimitiveWithInfer):
         ``Ascend`` ``GPU``
 
     Examples:
-        >>> from mindspore.ops import operations as P
-        >>> zeros = P.Zeros()
+        >>> from mindspore.ops import operations as ops
+        >>> zeros = ops.Zeros()
         >>> output = zeros((2, 2), mindspore.float32)
         >>> print(output)
         [[0.0, 0.0],
@@ -1243,7 +1243,7 @@ class OnesLike(PrimitiveWithInfer):
         ``Ascend`` ``GPU``
 
     Examples:
-        >>> oneslike = P.OnesLike()
+        >>> oneslike = ops.OnesLike()
         >>> x = Tensor(np.array([[0, 1], [2, 1]]).astype(np.int32))
         >>> output = oneslike(x)
         >>> print(output)
@@ -1279,7 +1279,7 @@ class ZerosLike(PrimitiveWithCheck):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> zeroslike = P.ZerosLike()
+        >>> zeroslike = ops.ZerosLike()
         >>> x = Tensor(np.array([[0, 1], [2, 1]]).astype(np.float32))
         >>> output = zeroslike(x)
         >>> print(output)
@@ -1313,7 +1313,7 @@ class TupleToArray(PrimitiveWithInfer):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> type = P.TupleToArray()((1,2,3))
+        >>> type = ops.TupleToArray()((1,2,3))
         >>> print(type)
         [1 2 3]
     """
@@ -1359,7 +1359,7 @@ class ScalarToArray(PrimitiveWithInfer):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> op = P.ScalarToArray()
+        >>> op = ops.ScalarToArray()
         >>> data = 1.0
         >>> output = op(data)
         >>> print(output)
@@ -1395,7 +1395,7 @@ class ScalarToTensor(PrimitiveWithInfer):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> op = P.ScalarToTensor()
+        >>> op = ops.ScalarToTensor()
         >>> data = 1
         >>> output = op(data, mindspore.float32)
         >>> print(output)
@@ -1441,7 +1441,7 @@ class InvertPermutation(PrimitiveWithInfer):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> invert = P.InvertPermutation()
+        >>> invert = ops.InvertPermutation()
         >>> input_data = (3, 4, 0, 2, 1)
         >>> output = invert(input_data)
         >>> print(output)
@@ -1510,7 +1510,7 @@ class Argmax(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor(np.array([2.0, 3.1, 1.2]), mindspore.float32)
-        >>> output = P.Argmax(output_type=mindspore.int32)(input_x)
+        >>> output = ops.Argmax(output_type=mindspore.int32)(input_x)
         >>> print(output)
         1
     """
@@ -1562,7 +1562,7 @@ class Argmin(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor(np.array([2.0, 3.1, 1.2]), mindspore.float32)
-        >>> index = P.Argmin()(input_x)
+        >>> index = ops.Argmin()(input_x)
         >>> print(index)
         2
     """
@@ -1623,7 +1623,7 @@ class ArgMaxWithValue(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor(np.random.rand(5), mindspore.float32)
-        >>> index, output = P.ArgMaxWithValue()(input_x)
+        >>> index, output = ops.ArgMaxWithValue()(input_x)
     """
 
     @prim_attr_register
@@ -1678,7 +1678,7 @@ class ArgMinWithValue(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor(np.random.rand(5), mindspore.float32)
-        >>> output = P.ArgMinWithValue()(input_x)
+        >>> output = ops.ArgMinWithValue()(input_x)
         >>> print(output)
         (Tensor(shape=[], dtype=Int32, value= 2), Tensor(shape=[], dtype=Float32, value= 0.0595638))
     """
@@ -1735,7 +1735,7 @@ class Tile(PrimitiveWithInfer):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> tile = P.Tile()
+        >>> tile = ops.Tile()
         >>> input_x = Tensor(np.array([[1, 2], [3, 4]]), mindspore.float32)
         >>> multiples = (2, 3)
         >>> output = tile(input_x, multiples)
@@ -1816,7 +1816,7 @@ class UnsortedSegmentSum(PrimitiveWithInfer):
         >>> input_x = Tensor([1, 2, 3, 4], mindspore.float32)
         >>> segment_ids = Tensor([0, 0, 1, 2], mindspore.int32)
         >>> num_segments = 4
-        >>> output = P.UnsortedSegmentSum()(input_x, segment_ids, num_segments)
+        >>> output = ops.UnsortedSegmentSum()(input_x, segment_ids, num_segments)
         >>> print(output)
         [3. 3. 4. 0.]
     """
@@ -1894,7 +1894,7 @@ class UnsortedSegmentMin(PrimitiveWithInfer):
         >>> input_x = Tensor(np.array([[1, 2, 3], [4, 5, 6], [4, 2, 1]]).astype(np.float32))
         >>> segment_ids = Tensor(np.array([0, 1, 1]).astype(np.int32))
         >>> num_segments = 2
-        >>> unsorted_segment_min = P.UnsortedSegmentMin()
+        >>> unsorted_segment_min = ops.UnsortedSegmentMin()
         >>> output = unsorted_segment_min(input_x, segment_ids, num_segments)
         >>> print(output)
         [[1. 2. 3.]
@@ -1953,7 +1953,7 @@ class UnsortedSegmentMax(PrimitiveWithInfer):
         >>> input_x = Tensor(np.array([[1, 2, 3], [4, 5, 6], [4, 2, 1]]).astype(np.float32))
         >>> segment_ids = Tensor(np.array([0, 1, 1]).astype(np.int32))
         >>> num_segments = 2
-        >>> unsorted_segment_max = P.UnsortedSegmentMax()
+        >>> unsorted_segment_max = ops.UnsortedSegmentMax()
         >>> output = unsorted_segment_max(input_x, segment_ids, num_segments)
         >>> print(output)
         [[1. 2. 3.]
@@ -2009,7 +2009,7 @@ class UnsortedSegmentProd(PrimitiveWithInfer):
         >>> input_x = Tensor(np.array([[1, 2, 3], [4, 5, 6], [4, 2, 1]]).astype(np.float32))
         >>> segment_ids = Tensor(np.array([0, 1, 0]).astype(np.int32))
         >>> num_segments = 2
-        >>> unsorted_segment_prod = P.UnsortedSegmentProd()
+        >>> unsorted_segment_prod = ops.UnsortedSegmentProd()
         >>> output = unsorted_segment_prod(input_x, segment_ids, num_segments)
         >>> print(output)
         [[4. 4. 3.]
@@ -2075,7 +2075,7 @@ class Concat(PrimitiveWithInfer):
     Examples:
         >>> data1 = Tensor(np.array([[0, 1], [2, 1]]).astype(np.int32))
         >>> data2 = Tensor(np.array([[0, 1], [2, 1]]).astype(np.int32))
-        >>> op = P.Concat()
+        >>> op = ops.Concat()
         >>> output = op((data1, data2))
         >>> print(output)
         [[0 1]
@@ -2129,7 +2129,7 @@ class ParallelConcat(PrimitiveWithInfer):
     Examples:
         >>> data1 = Tensor(np.array([[0, 1]]).astype(np.int32))
         >>> data2 = Tensor(np.array([[2, 1]]).astype(np.int32))
-        >>> op = P.ParallelConcat()
+        >>> op = ops.ParallelConcat()
         >>> output = op((data1, data2))
         >>> print(output)
         [[0 1]
@@ -2216,7 +2216,7 @@ class Pack(PrimitiveWithInfer):
     Examples:
         >>> data1 = Tensor(np.array([0, 1]).astype(np.float32))
         >>> data2 = Tensor(np.array([2, 3]).astype(np.float32))
-        >>> pack = P.Pack()
+        >>> pack = ops.Pack()
         >>> output = pack([data1, data2])
         >>> print(output)
         [[0. 1.]
@@ -2269,7 +2269,7 @@ class Unpack(PrimitiveWithInfer):
         ``Ascend``
 
     Examples:
-        >>> unpack = P.Unpack()
+        >>> unpack = ops.Unpack()
         >>> input_x = Tensor(np.array([[1, 1, 1, 1], [2, 2, 2, 2]]))
         >>> output = unpack(input_x)
         >>> print(output)
@@ -2330,7 +2330,7 @@ class Slice(PrimitiveWithInfer):
         >>> data = Tensor(np.array([[[1, 1, 1], [2, 2, 2]],
         ...                         [[3, 3, 3], [4, 4, 4]],
         ...                         [[5, 5, 5], [6, 6, 6]]]).astype(np.int32))
-        >>> slice = P.Slice()
+        >>> slice = ops.Slice()
         >>> output = slice(data, (1, 0, 0), (1, 1, 3))
         >>> print(output)
         [[[3 3 3]]]
@@ -2385,7 +2385,7 @@ class ReverseV2(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor(np.array([[1, 2, 3, 4], [5, 6, 7, 8]]), mindspore.int32)
-        >>> op = P.ReverseV2(axis=[1])
+        >>> op = ops.ReverseV2(axis=[1])
         >>> output = op(input_x)
         >>> print(output)
         [[4 3 2 1]
@@ -2427,7 +2427,7 @@ class Rint(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor(np.array([-1.6, -0.1, 1.5, 2.0]), mindspore.float32)
-        >>> op = P.Rint()
+        >>> op = ops.Rint()
         >>> output = op(input_x)
         >>> print(output)
         [-2.  0.  2.  2.]
@@ -2489,7 +2489,7 @@ class Select(PrimitiveWithInfer):
         ``Ascend`` ``GPU``
 
     Examples:
-        >>> select = P.Select()
+        >>> select = ops.Select()
         >>> input_cond = Tensor([True, False])
         >>> input_x = Tensor([2,3], mindspore.float32)
         >>> input_y = Tensor([1,2], mindspore.float32)
@@ -2628,7 +2628,7 @@ class StridedSlice(PrimitiveWithInfer):
     Examples
         >>> input_x = Tensor([[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]],
         ...                   [[5, 5, 5], [6, 6, 6]]], mindspore.float32)
-        >>> slice = P.StridedSlice()
+        >>> slice = ops.StridedSlice()
         >>> output = slice(input_x, (1, 0, 0), (2, 1, 3), (1, 1, 1))
         >>> print(output)
         [[[3. 3. 3.]]]
@@ -2773,7 +2773,7 @@ class Diag(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor([1, 2, 3, 4])
-        >>> diag = P.Diag()
+        >>> diag = ops.Diag()
         >>> output = diag(input_x)
         >>> print(output)
         [[1, 0, 0, 0],
@@ -2826,7 +2826,7 @@ class DiagPart(PrimitiveWithInfer):
         ...                   [0, 2, 0, 0],
         ...                   [0, 0, 3, 0],
         ...                   [0, 0, 0, 4]])
-        >>> diag_part = P.DiagPart()
+        >>> diag_part = ops.DiagPart()
         >>> output = diag_part(input_x)
         >>> print(output)
         [1 2 3 4]
@@ -2879,7 +2879,7 @@ class Eye(PrimitiveWithInfer):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> eye = P.Eye()
+        >>> eye = ops.Eye()
         >>> output = eye(2, 2, mindspore.int32)
         >>> print(output)
         [[1 0]
@@ -2918,7 +2918,7 @@ class ScatterNd(PrimitiveWithInfer):
         ``Ascend`` ``GPU``
 
     Examples:
-        >>> op = P.ScatterNd()
+        >>> op = ops.ScatterNd()
         >>> indices = Tensor(np.array([[0, 1], [1, 1]]), mindspore.int32)
         >>> update = Tensor(np.array([3.2, 1.1]), mindspore.float32)
         >>> shape = (3, 3)
@@ -2975,7 +2975,7 @@ class ResizeNearestNeighbor(PrimitiveWithInfer):
 
     Examples:
         >>> input_tensor = Tensor(np.array([[[[-0.1, 0.3, 3.6], [0.4, 0.5, -3.2]]]]), mindspore.float32)
-        >>> resize = P.ResizeNearestNeighbor((2, 2))
+        >>> resize = ops.ResizeNearestNeighbor((2, 2))
         >>> output = resize(input_tensor)
         >>> print(output)
         [[[[-0.1  0.3]
@@ -3020,7 +3020,7 @@ class GatherNd(PrimitiveWithInfer):
     Examples:
         >>> input_x = Tensor(np.array([[-0.1, 0.3, 3.6], [0.4, 0.5, -3.2]]), mindspore.float32)
         >>> indices = Tensor(np.array([[0, 0], [1, 1]]), mindspore.int32)
-        >>> op = P.GatherNd()
+        >>> op = ops.GatherNd()
         >>> output = op(input_x, indices)
         >>> print(output)
         [-0.1  0.5]
@@ -3061,7 +3061,7 @@ class TensorScatterUpdate(PrimitiveWithInfer):
         >>> input_x = Tensor(np.array([[-0.1, 0.3, 3.6], [0.4, 0.5, -3.2]]), mindspore.float32)
         >>> indices = Tensor(np.array([[0, 0], [1, 1]]), mindspore.int32)
         >>> update = Tensor(np.array([1.0, 2.2]), mindspore.float32)
-        >>> op = P.TensorScatterUpdate()
+        >>> op = ops.TensorScatterUpdate()
         >>> output = op(input_x, indices, update)
         >>> print(output)
         [[ 1.   0.3  3.6]
@@ -3120,7 +3120,7 @@ class ScatterUpdate(_ScatterOp_Dynamic):
         >>> indices = Tensor(np.array([0, 1]), mindspore.int32)
         >>> np_updates = np.array([[2.0, 1.2, 1.0], [3.0, 1.2, 1.0]])
         >>> updates = Tensor(np_updates, mindspore.float32)
-        >>> op = P.ScatterUpdate()
+        >>> op = ops.ScatterUpdate()
         >>> output = op(input_x, indices, updates)
         >>> print(output)
         [[2.  1.2 1. ]
@@ -3164,7 +3164,7 @@ class ScatterNdUpdate(_ScatterNdOp):
         >>> input_x = mindspore.Parameter(Tensor(np_x, mindspore.float32), name="x")
         >>> indices = Tensor(np.array([[0, 0], [1, 1]]), mindspore.int32)
         >>> update = Tensor(np.array([1.0, 2.2]), mindspore.float32)
-        >>> op = P.ScatterNdUpdate()
+        >>> op = ops.ScatterNdUpdate()
         >>> output = op(input_x, indices, update)
         >>> print(output)
         [[ 1.   0.3  3.6]
@@ -3215,7 +3215,7 @@ class ScatterMax(_ScatterOp):
         >>> input_x = Parameter(Tensor(np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]), mindspore.float32), name="input_x")
         >>> indices = Tensor(np.array([[0, 0], [1, 1]]), mindspore.int32)
         >>> update = Tensor(np.ones([2, 2, 3]) * 88, mindspore.float32)
-        >>> scatter_max = P.ScatterMax()
+        >>> scatter_max = ops.ScatterMax()
         >>> output = scatter_max(input_x, indices, update)
         >>> print(output)
         [[88. 88. 88.]
@@ -3260,7 +3260,7 @@ class ScatterMin(_ScatterOp):
         >>> input_x = Parameter(Tensor(np.array([[0.0, 1.0, 2.0], [0.0, 0.0, 0.0]]), mindspore.float32), name="input_x")
         >>> indices = Tensor(np.array([[0, 0], [1, 1]]), mindspore.int32)
         >>> update = Tensor(np.ones([2, 2, 3]), mindspore.float32)
-        >>> scatter_min = P.ScatterMin()
+        >>> scatter_min = ops.ScatterMin()
         >>> output = scatter_min(input_x, indices, update)
         >>> print(output)
         [[0. 1. 1.]
@@ -3299,7 +3299,7 @@ class ScatterAdd(_ScatterOp_Dynamic):
         >>> input_x = Parameter(Tensor(np.array([[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]]), mindspore.float32), name="x")
         >>> indices = Tensor(np.array([[0, 1], [1, 1]]), mindspore.int32)
         >>> updates = Tensor(np.ones([2, 2, 3]), mindspore.float32)
-        >>> scatter_add = P.ScatterAdd()
+        >>> scatter_add = ops.ScatterAdd()
         >>> output = scatter_add(input_x, indices, updates)
         >>> print(output)
         [[1. 1. 1.]
@@ -3345,7 +3345,7 @@ class ScatterSub(_ScatterOp):
         >>> input_x = Parameter(Tensor(np.array([[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]]), mindspore.float32), name="x")
         >>> indices = Tensor(np.array([[0, 1]]), mindspore.int32)
         >>> updates = Tensor(np.array([[[1.0, 1.0, 1.0], [2.0, 2.0, 2.0]]]), mindspore.float32)
-        >>> scatter_sub = P.ScatterSub()
+        >>> scatter_sub = ops.ScatterSub()
         >>> output = scatter_sub(input_x, indices, updates)
         >>> print(output)
         [[-1.0, -1.0, -1.0], [-1.0, -1.0, -1.0]]
@@ -3383,7 +3383,7 @@ class ScatterMul(_ScatterOp):
         >>> input_x = Parameter(Tensor(np.array([[1.0, 1.0, 1.0], [2.0, 2.0, 2.0]]), mindspore.float32), name="x")
         >>> indices = Tensor(np.array([0, 1]), mindspore.int32)
         >>> updates = Tensor(np.array([[2.0, 2.0, 2.0], [2.0, 2.0, 2.0]]), mindspore.float32)
-        >>> scatter_mul = P.ScatterMul()
+        >>> scatter_mul = ops.ScatterMul()
         >>> output = scatter_mul(input_x, indices, updates)
         >>> print(output)
         [[2. 2. 2.]
@@ -3422,7 +3422,7 @@ class ScatterDiv(_ScatterOp):
         >>> input_x = Parameter(Tensor(np.array([[6.0, 6.0, 6.0], [2.0, 2.0, 2.0]]), mindspore.float32), name="x")
         >>> indices = Tensor(np.array([0, 1]), mindspore.int32)
         >>> updates = Tensor(np.array([[2.0, 2.0, 2.0], [2.0, 2.0, 2.0]]), mindspore.float32)
-        >>> scatter_div = P.ScatterDiv()
+        >>> scatter_div = ops.ScatterDiv()
         >>> output = scatter_div(input_x, indices, updates)
         >>> print(output)
         [[3. 3. 3.]
@@ -3461,7 +3461,7 @@ class ScatterNdAdd(_ScatterNdOp):
         >>> input_x = Parameter(Tensor(np.array([1, 2, 3, 4, 5, 6, 7, 8]), mindspore.float32), name="x")
         >>> indices = Tensor(np.array([[2], [4], [1], [7]]), mindspore.int32)
         >>> updates = Tensor(np.array([6, 7, 8, 9]), mindspore.float32)
-        >>> scatter_nd_add = P.ScatterNdAdd()
+        >>> scatter_nd_add = ops.ScatterNdAdd()
         >>> output = scatter_nd_add(input_x, indices, updates)
         >>> print(output)
         [ 1. 10.  9.  4. 12.  6.  7. 17.]
@@ -3499,7 +3499,7 @@ class ScatterNdSub(_ScatterNdOp):
         >>> input_x = Parameter(Tensor(np.array([1, 2, 3, 4, 5, 6, 7, 8]), mindspore.float32), name="x")
         >>> indices = Tensor(np.array([[2], [4], [1], [7]]), mindspore.int32)
         >>> updates = Tensor(np.array([6, 7, 8, 9]), mindspore.float32)
-        >>> scatter_nd_sub = P.ScatterNdSub()
+        >>> scatter_nd_sub = ops.ScatterNdSub()
         >>> output = scatter_nd_sub(input_x, indices, updates)
         >>> print(output)
         [ 1. -6. -3.  4. -2.  6.  7. -1.]
@@ -3534,7 +3534,7 @@ class ScatterNonAliasingAdd(_ScatterNdOp):
         >>> input_x = Parameter(Tensor(np.array([1, 2, 3, 4, 5, 6, 7, 8]), mindspore.float32), name="x")
         >>> indices = Tensor(np.array([[2], [4], [1], [7]]), mindspore.int32)
         >>> updates = Tensor(np.array([6, 7, 8, 9]), mindspore.float32)
-        >>> scatter_non_aliasing_add = P.ScatterNonAliasingAdd()
+        >>> scatter_non_aliasing_add = ops.ScatterNonAliasingAdd()
         >>> output = scatter_non_aliasing_add(input_x, indices, updates)
         >>> print(output)
         [ 1. 10.  9.  4. 12.  6.  7. 17.]
@@ -3580,7 +3580,7 @@ class SpaceToDepth(PrimitiveWithInfer):
     Examples:
         >>> x = Tensor(np.random.rand(1,3,2,2), mindspore.float32)
         >>> block_size = 2
-        >>> space_to_depth = P.SpaceToDepth(block_size)
+        >>> space_to_depth = ops.SpaceToDepth(block_size)
         >>> output = space_to_depth(x)
         >>> print(output)
         (1, 12, 1, 1)
@@ -3641,7 +3641,7 @@ class DepthToSpace(PrimitiveWithInfer):
     Examples:
         >>> x = Tensor(np.random.rand(1,12,1,1), mindspore.float32)
         >>> block_size = 2
-        >>> depth_to_space = P.DepthToSpace(block_size)
+        >>> depth_to_space = ops.DepthToSpace(block_size)
         >>> output = depth_to_space(x)
         >>> print(output.shape)
         (1, 3, 2, 2)
@@ -3710,7 +3710,7 @@ class SpaceToBatch(PrimitiveWithInfer):
     Examples:
         >>> block_size = 2
         >>> paddings = [[0, 0], [0, 0]]
-        >>> space_to_batch = P.SpaceToBatch(block_size, paddings)
+        >>> space_to_batch = ops.SpaceToBatch(block_size, paddings)
         >>> input_x = Tensor(np.array([[[[1, 2], [3, 4]]]]), mindspore.float32)
         >>> output = space_to_batch(input_x)
         >>> print(output)
@@ -3787,7 +3787,7 @@ class BatchToSpace(PrimitiveWithInfer):
     Examples:
         >>> block_size = 2
         >>> crops = [[0, 0], [0, 0]]
-        >>> batch_to_space = P.BatchToSpace(block_size, crops)
+        >>> batch_to_space = ops.BatchToSpace(block_size, crops)
         >>> input_x = Tensor(np.array([[[[1]]], [[[2]]], [[[3]]], [[[4]]]]), mindspore.float32)
         >>> output = batch_to_space(input_x)
         >>> print(output)
@@ -3868,7 +3868,7 @@ class SpaceToBatchND(PrimitiveWithInfer):
     Examples:
         >>> block_shape = [2, 2]
         >>> paddings = [[0, 0], [0, 0]]
-        >>> space_to_batch_nd = P.SpaceToBatchND(block_shape, paddings)
+        >>> space_to_batch_nd = ops.SpaceToBatchND(block_shape, paddings)
         >>> input_x = Tensor(np.array([[[[1, 2], [3, 4]]]]), mindspore.float32)
         >>> output = space_to_batch_nd(input_x)
         >>> print(output)
@@ -3967,7 +3967,7 @@ class BatchToSpaceND(PrimitiveWithInfer):
     Examples:
         >>> block_shape = [2, 2]
         >>> crops = [[0, 0], [0, 0]]
-        >>> batch_to_space_nd = P.BatchToSpaceND(block_shape, crops)
+        >>> batch_to_space_nd = ops.BatchToSpaceND(block_shape, crops)
         >>> input_x = Tensor(np.array([[[[1]]], [[[2]]], [[[3]]], [[[4]]]]), mindspore.float32)
         >>> output = batch_to_space_nd(input_x)
         >>> print(output)
@@ -4050,7 +4050,7 @@ class BroadcastTo(PrimitiveWithInfer):
     Examples:
         >>> shape = (2, 3)
         >>> input_x = Tensor(np.array([1, 2, 3]).astype(np.float32))
-        >>> broadcast_to = P.BroadcastTo(shape)
+        >>> broadcast_to = ops.BroadcastTo(shape)
         >>> output = broadcast_to(input_x)
         >>> print(output)
         [[1. 2. 3.]
@@ -4107,7 +4107,7 @@ class Meshgrid(PrimitiveWithInfer):
         >>> y = np.array([5, 6, 7]).astype(np.int32)
         >>> z = np.array([8, 9, 0, 1, 2]).astype(np.int32)
         >>> inputs = (x, y, z)
-        >>> meshgrid = P.Meshgrid(indexing="xy")
+        >>> meshgrid = ops.Meshgrid(indexing="xy")
         >>> meshgrid(inputs)
         (Tensor(shape=[3, 4, 6], dtype=UInt32, value=
          [[[1, 1, 1, 1, 1],
@@ -4203,7 +4203,7 @@ class InplaceUpdate(PrimitiveWithInfer):
         >>> indices = (0, 1)
         >>> x = Tensor(np.array([[1, 2], [3, 4], [5, 6]]), mindspore.float32)
         >>> v = Tensor(np.array([[0.5, 1.0], [1.0, 1.5]]), mindspore.float32)
-        >>> inplace_update = P.InplaceUpdate(indices)
+        >>> inplace_update = ops.InplaceUpdate(indices)
         >>> output = inplace_update(x, v)
         >>> print(output)
         [[0.5 1. ]
@@ -4262,7 +4262,7 @@ class ReverseSequence(PrimitiveWithInfer):
     Examples:
         >>> x = Tensor(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), mindspore.float32)
         >>> seq_lengths = Tensor(np.array([1, 2, 3]))
-        >>> reverse_sequence = P.ReverseSequence(seq_dim=1)
+        >>> reverse_sequence = ops.ReverseSequence(seq_dim=1)
         >>> output = reverse_sequence(x, seq_lengths)
         >>> print(output)
         [[1. 2. 3.]
@@ -4322,7 +4322,7 @@ class EditDistance(PrimitiveWithInfer):
         >>> from mindspore import context
         >>> from mindspore import Tensor
         >>> import mindspore.nn as nn
-        >>> import mindspore.ops.operations as P
+        >>> import mindspore.ops.operations as ops
         >>> context.set_context(mode=context.GRAPH_MODE)
         >>> class EditDistance(nn.Cell):
         ...     def __init__(self, hypothesis_shape, truth_shape, normalize=True):
@@ -4437,7 +4437,7 @@ class Sort(PrimitiveWithInfer):
 
     Examples:
         >>> x = Tensor(np.array([[8, 2, 1], [5, 9, 3], [4, 6, 7]]), mindspore.float16)
-        >>> sort = P.Sort()
+        >>> sort = ops.Sort()
         >>> output = sort(x)
         >>> print(output)
         (Tensor(shape=[3, 3], dtype=Float16, value=
@@ -4489,7 +4489,7 @@ class EmbeddingLookup(PrimitiveWithInfer):
         >>> input_params = Tensor(np.array([[8, 9], [10, 11], [12, 13], [14, 15]]), mindspore.float32)
         >>> input_indices = Tensor(np.array([[5, 2], [8, 5]]), mindspore.int32)
         >>> offset = 4
-        >>> output = P.EmbeddingLookup()(input_params, input_indices, offset)
+        >>> output = ops.EmbeddingLookup()(input_params, input_indices, offset)
         >>> print(output)
         [[[10. 11.]
           [ 0.  0.]]
@@ -4545,7 +4545,7 @@ class GatherD(PrimitiveWithInfer):
         >>> x = Tensor(np.array([[1, 2], [3, 4]]), mindspore.int32)
         >>> index = Tensor(np.array([[0, 0], [1, 0]]), mindspore.int32)
         >>> dim = 1
-        >>> output = P.GatherD()(x, dim, index)
+        >>> output = ops.GatherD()(x, dim, index)
         >>> print(output)
         [[1 1]
          [4 3]]
@@ -4594,7 +4594,7 @@ class Identity(PrimitiveWithInfer):
 
     Examples:
         >>> x = Tensor(np.array([1, 2, 3, 4]), mindspore.int64)
-        >>> output = P.Identity()(x)
+        >>> output = ops.Identity()(x)
         >>> print(output)
         [1 2 3 4]
     """

mindspore/ops/operations/comm_ops.py

@@ -78,13 +78,13 @@ class AllReduce(PrimitiveWithInfer):
         >>> from mindspore import Tensor
         >>> from mindspore.ops.operations.comm_ops import ReduceOp
         >>> import mindspore.nn as nn
-        >>> import mindspore.ops.operations as P
+        >>> import mindspore.ops.operations as ops
         >>>
         >>> init()
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
-        ...         self.allreduce_sum = P.AllReduce(ReduceOp.SUM, group="nccl_world_group")
+        ...         self.allreduce_sum = ops.AllReduce(ReduceOp.SUM, group="nccl_world_group")
         ...
         ...     def construct(self, x):
         ...         return self.allreduce_sum(x)
@@ -134,7 +134,7 @@ class Send(PrimitiveWithInfer):
         - **input_x** (Tensor) - The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
 
     Examples:
-        >>> import mindspore.ops.operations as P
+        >>> import mindspore.ops.operations as ops
         >>> import mindspore.nn as nn
         >>> from mindspore.communication import init
         >>> from mindspore import Tensor
@@ -144,8 +144,8 @@ class Send(PrimitiveWithInfer):
         >>> class Net(nn.Cell):
         >>>     def __init__(self):
         >>>         super(Net, self).__init__()
-        >>>         self.depend = P.Depend()
-        >>>         self.send = P.Send(st_tag=0, dest_rank=8, group="hccl_world_group")
+        >>>         self.depend = ops.Depend()
+        >>>         self.send = ops.Send(st_tag=0, dest_rank=8, group="hccl_world_group")
         >>>
         >>>     def construct(self, x):
         >>>         out = self.depend(x, self.send(x))
@@ -191,7 +191,7 @@ class Receive(PrimitiveWithInfer):
         - **input_x** (Tensor) - The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
 
     Examples:
-        >>> import mindspore.ops.operations as P
+        >>> import mindspore.ops.operations as ops
         >>> import mindspore.nn as nn
         >>> from mindspore.communication import init
         >>> from mindspore import Tensor
@@ -201,7 +201,7 @@ class Receive(PrimitiveWithInfer):
         >>> class Net(nn.Cell):
         >>>     def __init__(self):
         >>>         super(Net, self).__init__()
-        >>>         self.recv = P.Receive(st_tag=0, src_rank=0, shape=[2, 8], dtype=np.float32,
+        >>>         self.recv = ops.Receive(st_tag=0, src_rank=0, shape=[2, 8], dtype=np.float32,
         >>>                               group="hccl_world_group")
         >>>
         >>>     def construct(self, x):
@@ -253,7 +253,7 @@ class AllGather(PrimitiveWithInfer):
         ``Ascend`` ``GPU``
 
     Examples:
-        >>> import mindspore.ops.operations as P
+        >>> import mindspore.ops.operations as ops
         >>> import mindspore.nn as nn
         >>> from mindspore.communication import init
         >>> from mindspore import Tensor
@@ -262,7 +262,7 @@ class AllGather(PrimitiveWithInfer):
         ... class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
-        ...         self.allgather = P.AllGather(group="nccl_world_group")
+        ...         self.allgather = ops.AllGather(group="nccl_world_group")
         ...
         ...     def construct(self, x):
         ...         return self.allgather(x)
@@ -373,14 +373,14 @@ class ReduceScatter(PrimitiveWithInfer):
         >>> from mindspore.communication import init
         >>> from mindspore.ops.operations.comm_ops import ReduceOp
         >>> import mindspore.nn as nn
-        >>> import mindspore.ops.operations as P
+        >>> import mindspore.ops.operations as ops
         >>> import numpy as np
         >>>
         >>> init()
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
-        ...         self.reducescatter = P.ReduceScatter(ReduceOp.SUM)
+        ...         self.reducescatter = ops.ReduceScatter(ReduceOp.SUM)
         ...
         ...     def construct(self, x):
         ...         return self.reducescatter(x)
@@ -493,14 +493,14 @@ class Broadcast(PrimitiveWithInfer):
         >>> from mindspore import Tensor
         >>> from mindspore.communication import init
         >>> import mindspore.nn as nn
-        >>> import mindspore.ops.operations as P
+        >>> import mindspore.ops.operations as ops
         >>> import numpy as np
         >>>
         >>> init()
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
-        ...         self.broadcast = P.Broadcast(1)
+        ...         self.broadcast = ops.Broadcast(1)
         ...
         ...     def construct(self, x):
         ...         return self.broadcast((x,))

mindspore/ops/operations/control_ops.py

@@ -57,7 +57,7 @@ class ControlDepend(Primitive):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
         ...         self.control_depend = P.ControlDepend()
-        ...         self.softmax = P.Softmax()
+        ...         self.softmax = ops.Softmax()
         ...
         ...     def construct(self, x, y):
         ...         mul = x * y
@@ -104,12 +104,12 @@ class GeSwitch(PrimitiveWithInfer):
         >>> class Net(nn.Cell):
         ... 	def __init__(self):
         ...         super(Net, self).__init__()
-        ...         self.square = P.Square()
-        ...         self.add = P.TensorAdd()
+        ...         self.square = ops.Square()
+        ...         self.add = ops.TensorAdd()
         ...         self.value = Tensor(np.full((1), 3), mindspore.float32)
-        ...         self.switch = P.GeSwitch()
-        ...         self.merge = P.Merge()
-        ...         self.less = P.Less()
+        ...         self.switch = ops.GeSwitch()
+        ...         self.merge = ops.Merge()
+        ...         self.less = ops.Less()
         ...
         ...     def construct(self, x, y):
         ...         cond = self.less(x, y)
@@ -159,7 +159,7 @@ class Merge(PrimitiveWithInfer):
         tuple. Output is tuple(`data`, `output_index`). The `data` has the same shape of `inputs` element.
 
     Examples:
-        >>> merge = P.Merge()
+        >>> merge = ops.Merge()
         >>> input_x = Tensor(np.linspace(0, 8, 8).reshape(2, 4), mindspore.float32)
         >>> input_y = Tensor(np.random.randint(-4, 4, (2, 4)), mindspore.float32)
         >>> result = merge((input_x, input_y))

mindspore/ops/operations/debug_ops.py

@@ -55,8 +55,8 @@ class ScalarSummary(PrimitiveWithInfer):
         >>> class SummaryDemo(nn.Cell):
         ...     def __init__(self,):
         ...         super(SummaryDemo, self).__init__()
-        ...         self.summary = P.ScalarSummary()
-        ...         self.add = P.TensorAdd()
+        ...         self.summary = ops.ScalarSummary()
+        ...         self.add = ops.TensorAdd()
         ...
         ...     def construct(self, x, y):
         ...         name = "x"
@@ -97,7 +97,7 @@ class ImageSummary(PrimitiveWithInfer):
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
-        ...         self.summary = P.ImageSummary()
+        ...         self.summary = ops.ImageSummary()
         ...
         ...     def construct(self, x):
         ...         name = "image"
@@ -138,8 +138,8 @@ class TensorSummary(PrimitiveWithInfer):
         >>> class SummaryDemo(nn.Cell):
         ...     def __init__(self,):
         ...         super(SummaryDemo, self).__init__()
-        ...         self.summary = P.TensorSummary()
-        ...         self.add = P.TensorAdd()
+        ...         self.summary = ops.TensorSummary()
+        ...         self.add = ops.TensorAdd()
         ...
         ...     def construct(self, x, y):
         ...         x = self.add(x, y)
@@ -180,8 +180,8 @@ class HistogramSummary(PrimitiveWithInfer):
         >>> class SummaryDemo(nn.Cell):
         ...     def __init__(self,):
         ...         super(SummaryDemo, self).__init__()
-        ...         self.summary = P.HistogramSummary()
-        ...         self.add = P.TensorAdd()
+        ...         self.summary = ops.HistogramSummary()
+        ...         self.add = ops.TensorAdd()
         ...
         ...     def construct(self, x, y):
         ...         x = self.add(x, y)
@@ -234,8 +234,8 @@ class InsertGradientOf(PrimitiveWithInfer):
         ...
         ...     return ret
         ...
-        >>> clip = P.InsertGradientOf(clip_gradient)
-        >>> grad_all = C.GradOperation(get_all=True)
+        >>> clip = ops.InsertGradientOf(clip_gradient)
+        >>> grad_all = ops.GradOperation(get_all=True)
         >>> def InsertGradientOfClipDemo():
         ...     def clip_test(x, y):
         ...         x = clip(x)
@@ -289,7 +289,7 @@ class HookBackward(PrimitiveWithInfer):
         ...     print(grad_out)
         ...
         >>> grad_all = GradOperation(get_all=True)
-        >>> hook = P.HookBackward(hook_fn)
+        >>> hook = ops.HookBackward(hook_fn)
         >>> def hook_test(x, y):
         ...     z = x * y
         ...     z = hook(z)
@@ -341,7 +341,7 @@ class Print(PrimitiveWithInfer):
         >>> class PrintDemo(nn.Cell):
         ...     def __init__(self):
         ...         super(PrintDemo, self).__init__()
-        ...         self.print = P.Print()
+        ...         self.print = ops.Print()
         ...
         ...     def construct(self, x, y):
         ...         self.print('Print Tensor x and Tensor y:', x, y)
@@ -382,8 +382,8 @@ class Assert(PrimitiveWithInfer):
         >>> class AssertDemo(nn.Cell):
         ...     def __init__(self):
         ...         super(AssertDemo, self).__init__()
-        ...         self.assert1 = P.Assert(summarize=10)
-        ...         self.add = P.TensorAdd()
+        ...         self.assert1 = ops.Assert(summarize=10)
+        ...         self.add = ops.TensorAdd()
         ...
         ...     def construct(self, x, y):
         ...         data = self.add(x, y)

mindspore/ops/operations/image_ops.py

@@ -60,7 +60,7 @@ class CropAndResize(PrimitiveWithInfer):
         >>> class CropAndResizeNet(nn.Cell):
         ...     def __init__(self, crop_size):
         ...         super(CropAndResizeNet, self).__init__()
-        ...         self.crop_and_resize = P.CropAndResize()
+        ...         self.crop_and_resize = ops.CropAndResize()
         ...         self.crop_size = crop_size
         ...
         ...     def construct(self, x, boxes, box_index):

mindspore/ops/operations/inner_ops.py

@@ -36,7 +36,7 @@ class ScalarCast(PrimitiveWithInfer):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> scalar_cast = P.ScalarCast()
+        >>> scalar_cast = ops.ScalarCast()
         >>> output = scalar_cast(255.0, mindspore.int32)
         >>> print(output)
         255

mindspore/ops/operations/math_ops.py

@@ -139,7 +139,7 @@ class TensorAdd(_MathBinaryOp):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> add = P.TensorAdd()
+        >>> add = ops.TensorAdd()
         >>> input_x = Tensor(np.array([1,2,3]).astype(np.float32))
         >>> input_y = Tensor(np.array([4,5,6]).astype(np.float32))
         >>> output = add(input_x, input_y)
@@ -180,7 +180,7 @@ class AssignAdd(PrimitiveWithInfer):
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
-        ...         self.AssignAdd = P.AssignAdd()
+        ...         self.AssignAdd = ops.AssignAdd()
         ...         self.variable = mindspore.Parameter(initializer(1, [1], mindspore.int64), name="global_step")
         ...
         ...     def construct(self, x):
@@ -235,7 +235,7 @@ class AssignSub(PrimitiveWithInfer):
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
-        ...         self.AssignSub = P.AssignSub()
+        ...         self.AssignSub = ops.AssignSub()
         ...         self.variable = mindspore.Parameter(initializer(1, [1], mindspore.int32), name="global_step")
         ...
         ...     def construct(self, x):
@@ -358,7 +358,7 @@ class ReduceMean(_Reduce):
 
     Examples:
         >>> input_x = Tensor(np.random.randn(3, 4, 5, 6).astype(np.float32))
-        >>> op = P.ReduceMean(keep_dims=True)
+        >>> op = ops.ReduceMean(keep_dims=True)
         >>> output = op(input_x, 1)
         >>> result = output.shape
         >>> print(result)
@@ -396,7 +396,7 @@ class ReduceSum(_Reduce):
 
     Examples:
         >>> input_x = Tensor(np.random.randn(3, 4, 5, 6).astype(np.float32))
-        >>> op = P.ReduceSum(keep_dims=True)
+        >>> op = ops.ReduceSum(keep_dims=True)
         >>> output = op(input_x, 1)
         >>> output.shape
         (3, 1, 5, 6)
@@ -440,7 +440,7 @@ class ReduceAll(_Reduce):
 
     Examples:
         >>> input_x = Tensor(np.array([[True, False], [True, True]]))
-        >>> op = P.ReduceAll(keep_dims=True)
+        >>> op = ops.ReduceAll(keep_dims=True)
         >>> output = op(input_x, 1)
         >>> print(output)
         [[False]
@@ -482,7 +482,7 @@ class ReduceAny(_Reduce):
 
     Examples:
         >>> input_x = Tensor(np.array([[True, False], [True, True]]))
-        >>> op = P.ReduceAny(keep_dims=True)
+        >>> op = ops.ReduceAny(keep_dims=True)
         >>> output = op(input_x, 1)
         >>> print(output)
         [[ True]
@@ -524,7 +524,7 @@ class ReduceMax(_Reduce):
 
     Examples:
         >>> input_x = Tensor(np.random.randn(3, 4, 5, 6).astype(np.float32))
-        >>> op = P.ReduceMax(keep_dims=True)
+        >>> op = ops.ReduceMax(keep_dims=True)
         >>> output = op(input_x, 1)
         >>> result = output.shape
         >>> print(result)
@@ -572,7 +572,7 @@ class ReduceMin(_Reduce):
 
     Examples:
         >>> input_x = Tensor(np.random.randn(3, 4, 5, 6).astype(np.float32))
-        >>> op = P.ReduceMin(keep_dims=True)
+        >>> op = ops.ReduceMin(keep_dims=True)
         >>> output = op(input_x, 1)
         >>> result = output.shape
         >>> print(result)
@@ -611,7 +611,7 @@ class ReduceProd(_Reduce):
 
     Examples:
         >>> input_x = Tensor(np.random.randn(3, 4, 5, 6).astype(np.float32))
-        >>> op = P.ReduceProd(keep_dims=True)
+        >>> op = ops.ReduceProd(keep_dims=True)
         >>> output = op(input_x, 1)
         >>> reuslt = output.shape
         >>> print(result)
@@ -641,13 +641,13 @@ class CumProd(PrimitiveWithInfer):
     Examples:
         >>> a, b, c, = 1, 2, 3
         >>> input_x = Tensor(np.array([a, b, c]).astype(np.float32))
-        >>> op0 = P.CumProd()
+        >>> op0 = ops.CumProd()
         >>> output0 = op0(input_x, 0) # output=[a, a * b, a * b * c]
-        >>> op1 = P.CumProd(exclusive=True)
+        >>> op1 = ops.CumProd(exclusive=True)
         >>> output1 = op1(input_x, 0) # output=[1, a, a * b]
-        >>> op2 = P.CumProd(reverse=True)
+        >>> op2 = ops.CumProd(reverse=True)
         >>> output2 = op2(input_x, 0) # output=[a * b * c, b * c, c]
-        >>> op3 = P.CumProd(exclusive=True, reverse=True)
+        >>> op3 = ops.CumProd(exclusive=True, reverse=True)
         >>> output3 = op3(input_x, 0) # output=[b * c, c, 1]
         >>> print(output0)
         [1. 2. 6.]
@@ -705,7 +705,7 @@ class MatMul(PrimitiveWithInfer):
     Examples:
         >>> input_x1 = Tensor(np.ones(shape=[1, 3]), mindspore.float32)
         >>> input_x2 = Tensor(np.ones(shape=[3, 4]), mindspore.float32)
-        >>> matmul = P.MatMul()
+        >>> matmul = ops.MatMul()
         >>> output = matmul(input_x1, input_x2)
     """
 
@@ -787,7 +787,7 @@ class BatchMatMul(MatMul):
     Examples:
         >>> input_x = Tensor(np.ones(shape=[2, 4, 1, 3]), mindspore.float32)
         >>> input_y = Tensor(np.ones(shape=[2, 4, 3, 4]), mindspore.float32)
-        >>> batmatmul = P.BatchMatMul()
+        >>> batmatmul = ops.BatchMatMul()
         >>> output = batmatmul(input_x, input_y)
         >>> print(output)
         [[[[3. 3. 3. 3.]]
@@ -801,7 +801,7 @@ class BatchMatMul(MatMul):
         >>>
         >>> input_x = Tensor(np.ones(shape=[2, 4, 3, 1]), mindspore.float32)
         >>> input_y = Tensor(np.ones(shape=[2, 4, 3, 4]), mindspore.float32)
-        >>> batmatmul = P.BatchMatMul(transpose_a=True)
+        >>> batmatmul = ops.BatchMatMul(transpose_a=True)
         >>> output = batmatmul(input_x, input_y)
         >>> print(output)
         [[[[3. 3. 3. 3.]]
@@ -848,7 +848,7 @@ class CumSum(PrimitiveWithInfer):
 
     Examples:
         >>> input = Tensor(np.array([[3, 4, 6, 10],[1, 6, 7, 9],[4, 3, 8, 7],[1, 3, 7, 9]]).astype(np.float32))
-        >>> cumsum = P.CumSum()
+        >>> cumsum = ops.CumSum()
         >>> output = cumsum(input, 1)
         >>> print(output)
         [[ 3.  7. 13. 23.]
@@ -898,7 +898,7 @@ class AddN(PrimitiveWithInfer):
         >>> class NetAddN(nn.Cell):
         ...     def __init__(self):
         ...         super(NetAddN, self).__init__()
-        ...         self.addN = P.AddN()
+        ...         self.addN = ops.AddN()
         ...
         ...     def construct(self, *z):
         ...         return self.addN(z)
@@ -984,7 +984,7 @@ class AccumulateNV2(PrimitiveWithInfer):
         >>> class NetAccumulateNV2(nn.Cell):
         ...     def __init__(self):
         ...         super(NetAccumulateNV2, self).__init__()
-        ...         self.accumulateNV2 = P.AccumulateNV2()
+        ...         self.accumulateNV2 = ops.AccumulateNV2()
         ...
         ...     def construct(self, *z):
         ...         return self.accumulateNV2(z)
@@ -1043,7 +1043,7 @@ class Neg(PrimitiveWithInfer):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> neg = P.Neg()
+        >>> neg = ops.Neg()
         >>> input_x = Tensor(np.array([1, 2, -1, 2, 0, -3.5]), mindspore.float32)
         >>> output = neg(input_x)
         >>> print(output)
@@ -1094,7 +1094,7 @@ class InplaceAdd(PrimitiveWithInfer):
         >>> indices = (0, 1)
         >>> input_x = Tensor(np.array([[1, 2], [3, 4], [5, 6]]), mindspore.float32)
         >>> input_v = Tensor(np.array([[0.5, 1.0], [1.0, 1.5]]), mindspore.float32)
-        >>> inplaceAdd = P.InplaceAdd(indices)
+        >>> inplaceAdd = ops.InplaceAdd(indices)
         >>> output = inplaceAdd(input_x, input_v)
         >>> print(output)
         [[1.5 3. ]
@@ -1156,7 +1156,7 @@ class InplaceSub(PrimitiveWithInfer):
         >>> indices = (0, 1)
         >>> input_x = Tensor(np.array([[1, 2], [3, 4], [5, 6]]), mindspore.float32)
         >>> input_v = Tensor(np.array([[0.5, 1.0], [1.0, 1.5]]), mindspore.float32)
-        >>> inplaceSub = P.InplaceSub(indices)
+        >>> inplaceSub = ops.InplaceSub(indices)
         >>> output = inplaceSub(input_x, input_v)
         >>> print(output)
         [[0.5 1. ]
@@ -1222,7 +1222,7 @@ class Sub(_MathBinaryOp):
     Examples:
         >>> input_x = Tensor(np.array([1, 2, 3]), mindspore.int32)
         >>> input_y = Tensor(np.array([4, 5, 6]), mindspore.int32)
-        >>> sub = P.Sub()
+        >>> sub = ops.Sub()
         >>> output = sub(input_x, input_y)
         >>> print(output)
         [-3 -3 -3]
@@ -1265,7 +1265,7 @@ class Mul(_MathBinaryOp):
     Examples:
         >>> input_x = Tensor(np.array([1.0, 2.0, 3.0]), mindspore.float32)
         >>> input_y = Tensor(np.array([4.0, 5.0, 6.0]), mindspore.float32)
-        >>> mul = P.Mul()
+        >>> mul = ops.Mul()
         >>> output = mul(input_x, input_y)
         >>> print(output)
         [ 4. 10. 18.]
@@ -1308,7 +1308,7 @@ class SquaredDifference(_MathBinaryOp):
     Examples:
         >>> input_x = Tensor(np.array([1.0, 2.0, 3.0]), mindspore.float32)
         >>> input_y = Tensor(np.array([2.0, 4.0, 6.0]), mindspore.float32)
-        >>> squared_difference = P.SquaredDifference()
+        >>> squared_difference = ops.SquaredDifference()
         >>> output = squared_difference(input_x, input_y)
         >>> print(output)
         [1. 4. 9.]
@@ -1334,7 +1334,7 @@ class Square(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor(np.array([1.0, 2.0, 3.0]), mindspore.float32)
-        >>> square = P.Square()
+        >>> square = ops.Square()
         >>> output = square(input_x)
         >>> print(output)
         [1. 4. 9.]
@@ -1376,7 +1376,7 @@ class Rsqrt(PrimitiveWithInfer):
 
     Examples:
         >>> input_tensor = Tensor([[4, 4], [9, 9]], mindspore.float32)
-        >>> rsqrt = P.Rsqrt()
+        >>> rsqrt = ops.Rsqrt()
         >>> output = rsqrt(input_tensor)
         >>> print(output)
         [[0.5      0.5     ]
@@ -1419,7 +1419,7 @@ class Sqrt(PrimitiveWithCheck):
 
     Examples:
         >>> input_x = Tensor(np.array([1.0, 4.0, 9.0]), mindspore.float32)
-        >>> sqrt = P.Sqrt()
+        >>> sqrt = ops.Sqrt()
         >>> output = sqrt(input_x)
         >>> print(output)
         [1. 2. 3.]
@@ -1457,7 +1457,7 @@ class Reciprocal(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor(np.array([1.0, 2.0, 4.0]), mindspore.float32)
-        >>> reciprocal = P.Reciprocal()
+        >>> reciprocal = ops.Reciprocal()
         >>> output = reciprocal(input_x)
         >>> print(output)
         [1.   0.5  0.25]
@@ -1515,14 +1515,14 @@ class Pow(_MathBinaryOp):
     Examples:
         >>> input_x = Tensor(np.array([1.0, 2.0, 4.0]), mindspore.float32)
         >>> input_y = 3.0
-        >>> pow = P.Pow()
+        >>> pow = ops.Pow()
         >>> output = pow(input_x, input_y)
         >>> print(output)
         [ 1.  8. 64.]
         >>>
         >>> input_x = Tensor(np.array([1.0, 2.0, 4.0]), mindspore.float32)
         >>> input_y = Tensor(np.array([2.0, 4.0, 3.0]), mindspore.float32)
-        >>> pow = P.Pow()
+        >>> pow = ops.Pow()
         >>> output = pow(input_x, input_y)
         >>> print(output)
         [ 1. 16. 64.]
@@ -1553,7 +1553,7 @@ class Exp(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor(np.array([1.0, 2.0, 4.0]), mindspore.float32)
-        >>> exp = P.Exp()
+        >>> exp = ops.Exp()
         >>> output = exp(input_x)
         >>> print(output)
         [ 2.718282  7.389056 54.598152]
@@ -1595,7 +1595,7 @@ class Expm1(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor(np.array([0.0, 1.0, 2.0, 4.0]), mindspore.float32)
-        >>> expm1 = P.Expm1()
+        >>> expm1 = ops.Expm1()
         >>> output = expm1(input_x)
         >>> print(output)
         [ 0.        1.718282  6.389056 53.598152]
@@ -1637,7 +1637,7 @@ class HistogramFixedWidth(PrimitiveWithInfer):
     Examples:
         >>> x = Tensor([-1.0, 0.0, 1.5, 2.0, 5.0, 15], mindspore.float16)
         >>> range = Tensor([0.0, 5.0], mindspore.float16)
-        >>> hist = P.HistogramFixedWidth(5)
+        >>> hist = ops.HistogramFixedWidth(5)
         >>> output = hist(x, range)
         >>> print(output)
         [2 1 1 0 2]
@@ -1677,7 +1677,7 @@ class Log(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor(np.array([1.0, 2.0, 4.0]), mindspore.float32)
-        >>> log = P.Log()
+        >>> log = ops.Log()
         >>> output = log(input_x)
         >>> print(output)
         [0.        0.6931472 1.38629444]
@@ -1718,7 +1718,7 @@ class Log1p(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor(np.array([1.0, 2.0, 4.0]), mindspore.float32)
-        >>> log1p = P.Log1p()
+        >>> log1p = ops.Log1p()
         >>> output = log1p(input_x)
         >>> print(output)
         [0.6931472 1.0986123 1.609438 ]
@@ -1752,7 +1752,7 @@ class Erf(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor(np.array([-1, 0, 1, 2, 3]), mindspore.float32)
-        >>> erf = P.Erf()
+        >>> erf = ops.Erf()
         >>> output = erf(input_x)
         >>> print(output)
         [-0.8427168   0.          0.8427168   0.99530876  0.99997765]
@@ -1786,7 +1786,7 @@ class Erfc(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor(np.array([-1, 0, 1, 2, 3]), mindspore.float32)
-        >>> erfc = P.Erfc()
+        >>> erfc = ops.Erfc()
         >>> output = erfc(input_x)
         >>> print(output)
         [1.8427168e+00 1.0000000e+00 1.5728319e-01 4.6912432e-03 2.2351742e-05]
@@ -1832,7 +1832,7 @@ class Minimum(_MathBinaryOp):
     Examples:
         >>> input_x = Tensor(np.array([1.0, 5.0, 3.0]), mindspore.float32)
         >>> input_y = Tensor(np.array([4.0, 2.0, 6.0]), mindspore.float32)
-        >>> minimum = P.Minimum()
+        >>> minimum = ops.Minimum()
         >>> output = minimum(input_x, input_y)
         >>> print(output)
         [1. 2. 3.]
@@ -1875,7 +1875,7 @@ class Maximum(_MathBinaryOp):
     Examples:
         >>> input_x = Tensor(np.array([1.0, 5.0, 3.0]), mindspore.float32)
         >>> input_y = Tensor(np.array([4.0, 2.0, 6.0]), mindspore.float32)
-        >>> maximum = P.Maximum()
+        >>> maximum = ops.Maximum()
         >>> output = maximum(input_x, input_y)
         >>> print(output)
         [4. 5. 6.]
@@ -1918,7 +1918,7 @@ class RealDiv(_MathBinaryOp):
     Examples:
         >>> input_x = Tensor(np.array([1.0, 2.0, 3.0]), mindspore.float32)
         >>> input_y = Tensor(np.array([4.0, 5.0, 6.0]), mindspore.float32)
-        >>> realdiv = P.RealDiv()
+        >>> realdiv = ops.RealDiv()
         >>> output = realdiv(input_x, input_y)
         >>> print(output)
         [0.25 0.4  0.5 ]
@@ -1962,7 +1962,7 @@ class Div(_MathBinaryOp):
     Examples:
         >>> input_x = Tensor(np.array([-4.0, 5.0, 6.0]), mindspore.float32)
         >>> input_y = Tensor(np.array([3.0, 2.0, 3.0]), mindspore.float32)
-        >>> div = P.Div()
+        >>> div = ops.Div()
         >>> output = div(input_x, input_y)
         >>> print(output)
         [-1.3333334  2.5        2.        ]
@@ -2004,7 +2004,7 @@ class DivNoNan(_MathBinaryOp):
     Examples:
         >>> input_x = Tensor(np.array([-1.0, 0., 1.0, 5.0, 6.0]), mindspore.float32)
         >>> input_y = Tensor(np.array([0., 0., 0., 2.0, 3.0]), mindspore.float32)
-        >>> div_no_nan = P.DivNoNan()
+        >>> div_no_nan = ops.DivNoNan()
         >>> output = div_no_nan(input_x, input_y)
         >>> print(output)
         [0.  0.  0.  2.5 2. ]
@@ -2053,7 +2053,7 @@ class FloorDiv(_MathBinaryOp):
     Examples:
         >>> input_x = Tensor(np.array([2, 4, -1]), mindspore.int32)
         >>> input_y = Tensor(np.array([3, 3, 3]), mindspore.int32)
-        >>> floor_div = P.FloorDiv()
+        >>> floor_div = ops.FloorDiv()
         >>> output = floor_div(input_x, input_y)
         >>> print(output)
         [ 0  1 -1]
@@ -2088,7 +2088,7 @@ class TruncateDiv(_MathBinaryOp):
     Examples:
         >>> input_x = Tensor(np.array([2, 4, -1]), mindspore.int32)
         >>> input_y = Tensor(np.array([3, 3, 3]), mindspore.int32)
-        >>> truncate_div = P.TruncateDiv()
+        >>> truncate_div = ops.TruncateDiv()
         >>> output = truncate_div(input_x, input_y)
         >>> print(output)
         [0 1 0]
@@ -2122,7 +2122,7 @@ class TruncateMod(_MathBinaryOp):
     Examples:
         >>> input_x = Tensor(np.array([2, 4, -1]), mindspore.int32)
         >>> input_y = Tensor(np.array([3, 3, 3]), mindspore.int32)
-        >>> truncate_mod = P.TruncateMod()
+        >>> truncate_mod = ops.TruncateMod()
         >>> output = truncate_mod(input_x, input_y)
         >>> print(output)
         [ 2  1 -1]
@@ -2157,7 +2157,7 @@ class Mod(_MathBinaryOp):
     Examples:
         >>> input_x = Tensor(np.array([-4.0, 5.0, 6.0]), mindspore.float32)
         >>> input_y = Tensor(np.array([3.0, 2.0, 3.0]), mindspore.float32)
-        >>> mod = P.Mod()
+        >>> mod = ops.Mod()
         >>> output = mod(input_x, input_y)
         >>> print(output)
         [-1.  1.  0.]
@@ -2186,7 +2186,7 @@ class Floor(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor(np.array([1.1, 2.5, -1.5]), mindspore.float32)
-        >>> floor = P.Floor()
+        >>> floor = ops.Floor()
         >>> output = floor(input_x)
         >>> print(output)
         [ 1.  2. -2.]
@@ -2231,7 +2231,7 @@ class FloorMod(_MathBinaryOp):
     Examples:
         >>> input_x = Tensor(np.array([2, 4, -1]), mindspore.int32)
         >>> input_y = Tensor(np.array([3, 3, 3]), mindspore.int32)
-        >>> floor_mod = P.FloorMod()
+        >>> floor_mod = ops.FloorMod()
         >>> output = floor_mod(input_x, input_y)
         >>> print(output)
         [2 1 2]
@@ -2253,7 +2253,7 @@ class Ceil(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor(np.array([1.1, 2.5, -1.5]), mindspore.float32)
-        >>> ceil_op = P.Ceil()
+        >>> ceil_op = ops.Ceil()
         >>> output = ceil_op(input_x)
         >>> print(output)
         [ 2.  3. -1.]
@@ -2298,7 +2298,7 @@ class Xdivy(_MathBinaryOp):
     Examples:
         >>> input_x = Tensor(np.array([2, 4, -1]), mindspore.float32)
         >>> input_y = Tensor(np.array([2, 2, 2]), mindspore.float32)
-        >>> xdivy = P.Xdivy()
+        >>> xdivy = ops.Xdivy()
         >>> output = xdivy(input_x, input_y)
         >>> print(output)
         [ 1.   2.  -0.5]
@@ -2337,7 +2337,7 @@ class Xlogy(_MathBinaryOp):
     Examples:
         >>> input_x = Tensor(np.array([-5, 0, 4]), mindspore.float32)
         >>> input_y = Tensor(np.array([2, 2, 2]), mindspore.float32)
-        >>> xlogy = P.Xlogy()
+        >>> xlogy = ops.Xlogy()
         >>> output = xlogy(input_x, input_y)
         >>> print(output)
         [-3.465736   0.        2.7725887]
@@ -2361,7 +2361,7 @@ class Acosh(PrimitiveWithInfer):
         ``Ascend``
 
     Examples:
-        >>> acosh = P.Acosh()
+        >>> acosh = ops.Acosh()
         >>> input_x = Tensor(np.array([1.0, 1.5, 3.0, 100.0]), mindspore.float32)
         >>> output = acosh(input_x)
     """
@@ -2392,7 +2392,7 @@ class Cosh(PrimitiveWithInfer):
         ``Ascend``
 
     Examples:
-        >>> cosh = P.Cosh()
+        >>> cosh = ops.Cosh()
         >>> input_x = Tensor(np.array([0.24, 0.83, 0.31, 0.09]), mindspore.float32)
         >>> output = cosh(input_x)
         >>> print(output)
@@ -2425,7 +2425,7 @@ class Asinh(PrimitiveWithInfer):
         ``Ascend``
 
     Examples:
-        >>> asinh = P.Asinh()
+        >>> asinh = ops.Asinh()
         >>> input_x = Tensor(np.array([-5.0, 1.5, 3.0, 100.0]), mindspore.float32)
         >>> output = asinh(input_x)
         >>> print(output)
@@ -2458,7 +2458,7 @@ class Sinh(PrimitiveWithInfer):
         ``Ascend``
 
     Examples:
-        >>> sinh = P.Sinh()
+        >>> sinh = ops.Sinh()
         >>> input_x = Tensor(np.array([0.62, 0.28, 0.43, 0.62]), mindspore.float32)
         >>> output = sinh(input_x)
         >>> print(output)
@@ -2515,13 +2515,13 @@ class Equal(_LogicBinaryOp):
 
     Examples:
         >>> input_x = Tensor(np.array([1, 2, 3]), mindspore.float32)
-        >>> equal = P.Equal()
+        >>> equal = ops.Equal()
         >>> equal(input_x, 2.0)
         [False, True, False]
         >>>
         >>> input_x = Tensor(np.array([1, 2, 3]), mindspore.int32)
         >>> input_y = Tensor(np.array([1, 2, 4]), mindspore.int32)
-        >>> equal = P.Equal()
+        >>> equal = ops.Equal()
         >>> output = equal(input_x, input_y)
         >>> print(output)
         [ True  True False]
@@ -2565,7 +2565,7 @@ class ApproximateEqual(_LogicBinaryOp):
     Examples:
         >>> x1 = Tensor(np.array([1, 2, 3]), mindspore.float32)
         >>> x2 = Tensor(np.array([2, 4, 6]), mindspore.float32)
-        >>> approximate_equal = P.ApproximateEqual(2.)
+        >>> approximate_equal = ops.ApproximateEqual(2.)
         >>> output = approximate_equal(x1, x2)
         >>> print(output)
         [ True  True  False]
@@ -2606,7 +2606,7 @@ class EqualCount(PrimitiveWithInfer):
     Examples:
         >>> input_x = Tensor(np.array([1, 2, 3]), mindspore.int32)
         >>> input_y = Tensor(np.array([1, 2, 4]), mindspore.int32)
-        >>> equal_count = P.EqualCount()
+        >>> equal_count = ops.EqualCount()
         >>> output = equal_count(input_x, input_y)
         >>> print(output)
         [2]
@@ -2651,14 +2651,14 @@ class NotEqual(_LogicBinaryOp):
 
     Examples:
         >>> input_x = Tensor(np.array([1, 2, 3]), mindspore.float32)
-        >>> not_equal = P.NotEqual()
+        >>> not_equal = ops.NotEqual()
         >>> output = not_equal(input_x, 2.0)
         >>> print(output)
         [ True False  True]
         >>>
         >>> input_x = Tensor(np.array([1, 2, 3]), mindspore.int32)
         >>> input_y = Tensor(np.array([1, 2, 4]), mindspore.int32)
-        >>> not_equal = P.NotEqual()
+        >>> not_equal = ops.NotEqual()
         >>> output = not_equal(input_x, input_y)
         >>> print(output)
         [False False  True]
@@ -2694,7 +2694,7 @@ class Greater(_LogicBinaryOp):
     Examples:
         >>> input_x = Tensor(np.array([1, 2, 3]), mindspore.int32)
         >>> input_y = Tensor(np.array([1, 1, 4]), mindspore.int32)
-        >>> greater = P.Greater()
+        >>> greater = ops.Greater()
         >>> output = greater(input_x, input_y)
         >>> print(output)
         [False  True False]
@@ -2735,7 +2735,7 @@ class GreaterEqual(_LogicBinaryOp):
     Examples:
         >>> input_x = Tensor(np.array([1, 2, 3]), mindspore.int32)
         >>> input_y = Tensor(np.array([1, 1, 4]), mindspore.int32)
-        >>> greater_equal = P.GreaterEqual()
+        >>> greater_equal = ops.GreaterEqual()
         >>> output = greater_equal(input_x, input_y)
         >>> print(output)
         [ True  True False]
@@ -2776,7 +2776,7 @@ class Less(_LogicBinaryOp):
     Examples:
         >>> input_x = Tensor(np.array([1, 2, 3]), mindspore.int32)
         >>> input_y = Tensor(np.array([1, 1, 4]), mindspore.int32)
-        >>> less = P.Less()
+        >>> less = ops.Less()
         >>> output = less(input_x, input_y)
         >>> print(output)
         [False False  True]
@@ -2817,7 +2817,7 @@ class LessEqual(_LogicBinaryOp):
     Examples:
         >>> input_x = Tensor(np.array([1, 2, 3]), mindspore.int32)
         >>> input_y = Tensor(np.array([1, 1, 4]), mindspore.int32)
-        >>> less_equal = P.LessEqual()
+        >>> less_equal = ops.LessEqual()
         >>> output = less_equal(input_x, input_y)
         >>> print(output)
         [ True False  True]
@@ -2847,7 +2847,7 @@ class LogicalNot(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor(np.array([True, False, True]), mindspore.bool_)
-        >>> logical_not = P.LogicalNot()
+        >>> logical_not = ops.LogicalNot()
         >>> output = logical_not(input_x)
         >>> print(output)
         [False  True False]
@@ -2891,7 +2891,7 @@ class LogicalAnd(_LogicBinaryOp):
     Examples:
         >>> input_x = Tensor(np.array([True, False, True]), mindspore.bool_)
         >>> input_y = Tensor(np.array([True, True, False]), mindspore.bool_)
-        >>> logical_and = P.LogicalAnd()
+        >>> logical_and = ops.LogicalAnd()
         >>> output = logical_and(input_x, input_y)
         >>> print(output)
         [ True False False]
@@ -2926,7 +2926,7 @@ class LogicalOr(_LogicBinaryOp):
     Examples:
         >>> input_x = Tensor(np.array([True, False, True]), mindspore.bool_)
         >>> input_y = Tensor(np.array([True, True, False]), mindspore.bool_)
-        >>> logical_or = P.LogicalOr()
+        >>> logical_or = ops.LogicalOr()
         >>> output = logical_or(input_x, input_y)
         >>> print(output)
         [ True  True  True]
@@ -2950,7 +2950,7 @@ class IsNan(PrimitiveWithInfer):
         ``GPU``
 
     Examples:
-        >>> is_nan = P.IsNan()
+        >>> is_nan = ops.IsNan()
         >>> input_x = Tensor(np.array([np.log(-1), 1, np.log(0)]), mindspore.float32)
         >>> result = is_nan(input_x)
     """
@@ -2981,7 +2981,7 @@ class IsInf(PrimitiveWithInfer):
         ``GPU``
 
     Examples:
-        >>> is_inf = P.IsInf()
+        >>> is_inf = ops.IsInf()
         >>> input_x = Tensor(np.array([np.log(-1), 1, np.log(0)]), mindspore.float32)
         >>> result = is_inf(input_x)
     """
@@ -3012,7 +3012,7 @@ class IsFinite(PrimitiveWithInfer):
         ``Ascend`` ``GPU``
 
     Examples:
-        >>> is_finite = P.IsFinite()
+        >>> is_finite = ops.IsFinite()
         >>> input_x = Tensor(np.array([np.log(-1), 1, np.log(0)]), mindspore.float32)
         >>> output = is_finite(input_x)
         >>> print(output)
@@ -3047,7 +3047,7 @@ class FloatStatus(PrimitiveWithInfer):
         ``GPU``
 
     Examples:
-        >>> float_status = P.FloatStatus()
+        >>> float_status = ops.FloatStatus()
         >>> input_x = Tensor(np.array([np.log(-1), 1, np.log(0)]), mindspore.float32)
         >>> result = float_status(input_x)
         >>> print(result)
@@ -3083,7 +3083,7 @@ class NPUAllocFloatStatus(PrimitiveWithInfer):
         ``Ascend``
 
     Examples:
-        >>> alloc_status = P.NPUAllocFloatStatus()
+        >>> alloc_status = ops.NPUAllocFloatStatus()
         >>> output = alloc_status()
         >>> print(output)
         [0. 0. 0. 0. 0. 0. 0. 0.]
@@ -3120,8 +3120,8 @@ class NPUGetFloatStatus(PrimitiveWithInfer):
         ``Ascend``
 
     Examples:
-        >>> alloc_status = P.NPUAllocFloatStatus()
-        >>> get_status = P.NPUGetFloatStatus()
+        >>> alloc_status = ops.NPUAllocFloatStatus()
+        >>> get_status = ops.NPUGetFloatStatus()
         >>> init = alloc_status()
         >>> output = get_status(init)
         >>> print(output)
@@ -3165,9 +3165,9 @@ class NPUClearFloatStatus(PrimitiveWithInfer):
         ``Ascend``
 
     Examples:
-        >>> alloc_status = P.NPUAllocFloatStatus()
-        >>> get_status = P.NPUGetFloatStatus()
-        >>> clear_status = P.NPUClearFloatStatus()
+        >>> alloc_status = ops.NPUAllocFloatStatus()
+        >>> get_status = ops.NPUGetFloatStatus()
+        >>> clear_status = ops.NPUClearFloatStatus()
         >>> init = alloc_status()
         >>> flag = get_status(init)
         >>> output = clear_status(init)
@@ -3205,7 +3205,7 @@ class Cos(PrimitiveWithInfer):
         ``Ascend`` ``GPU``
 
     Examples:
-        >>> cos = P.Cos()
+        >>> cos = ops.Cos()
         >>> input_x = Tensor(np.array([0.24, 0.83, 0.31, 0.09]), mindspore.float32)
         >>> output = cos(input_x)
         >>> print(output)
@@ -3238,7 +3238,7 @@ class ACos(PrimitiveWithInfer):
         ``Ascend`` ``GPU``
 
     Examples:
-        >>> acos = P.ACos()
+        >>> acos = ops.ACos()
         >>> input_x = Tensor(np.array([0.74, 0.04, 0.30, 0.56]), mindspore.float32)
         >>> output = acos(input_x)
     """
@@ -3269,7 +3269,7 @@ class Sin(PrimitiveWithInfer):
         ``Ascend`` ``GPU``
 
     Examples:
-        >>> sin = P.Sin()
+        >>> sin = ops.Sin()
         >>> input_x = Tensor(np.array([0.62, 0.28, 0.43, 0.62]), mindspore.float32)
         >>> output = sin(input_x)
         >>> print(output)
@@ -3302,7 +3302,7 @@ class Asin(PrimitiveWithInfer):
         ``Ascend`` ``GPU``
 
     Examples:
-        >>> asin = P.Asin()
+        >>> asin = ops.Asin()
         >>> input_x = Tensor(np.array([0.74, 0.04, 0.30, 0.56]), mindspore.float32)
         >>> output = asin(input_x)
         >>> print(output)
@@ -3359,7 +3359,7 @@ class NMSWithMask(PrimitiveWithInfer):
         >>> bbox[:, 2] += bbox[:, 0]
         >>> bbox[:, 3] += bbox[:, 1]
         >>> inputs = Tensor(bbox, mindspore.float32)
-        >>> nms = P.NMSWithMask(0.5)
+        >>> nms = ops.NMSWithMask(0.5)
         >>> output_boxes, indices, mask = nms(inputs)
     """
 
@@ -3398,7 +3398,7 @@ class Abs(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor(np.array([-1.0, 1.0, 0.0]), mindspore.float32)
-        >>> abs = P.Abs()
+        >>> abs = ops.Abs()
         >>> output = abs(input_x)
         >>> print(output)
         [1. 1. 0.]
@@ -3445,7 +3445,7 @@ class Sign(PrimitiveWithInfer):
 
     Examples:
          >>> input_x = Tensor(np.array([[2.0, 0.0, -1.0]]), mindspore.float32)
-         >>> sign = P.Sign()
+         >>> sign = ops.Sign()
          >>> output = sign(input_x)
          >>> print(output)
          [[ 1.  0. -1.]]
@@ -3478,7 +3478,7 @@ class Round(PrimitiveWithInfer):
 
     Examples:
          >>> input_x = Tensor(np.array([0.8, 1.5, 2.3, 2.5, -4.5]), mindspore.float32)
-         >>> round = P.Round()
+         >>> round = ops.Round()
          >>> output = round(input_x)
          >>> print(output)
          [ 1.  2.  2.  2. -4.]
@@ -3512,7 +3512,7 @@ class Tan(PrimitiveWithInfer):
         ``Ascend``
 
     Examples:
-        >>> tan = P.Tan()
+        >>> tan = ops.Tan()
         >>> input_x = Tensor(np.array([-1.0, 0.0, 1.0]), mindspore.float32)
         >>> output = tan(input_x)
         [-1.5574081 0. 1.5574081]
@@ -3546,9 +3546,9 @@ class Atan(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor(np.array([1.047, 0.785]), mindspore.float32)
-        >>> tan = P.Tan()
+        >>> tan = ops.Tan()
         >>> output_y = tan(input_x)
-        >>> atan = P.Atan()
+        >>> atan = ops.Atan()
         >>> output = atan(output_y)
         >>> print(output)
         [1.047     0.7850001]
@@ -3581,7 +3581,7 @@ class Atanh(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor(np.array([1.047, 0.785]), mindspore.float32)
-        >>> atanh = P.Atanh()
+        >>> atanh = ops.Atanh()
         >>> output = atanh(input_x)
         >>> print(output)
         [1.8869909 1.058268 ]
@@ -3624,7 +3624,7 @@ class Atan2(_MathBinaryOp):
     Examples:
         >>> input_x = Tensor(np.array([0, 1]), mindspore.float32)
         >>> input_y = Tensor(np.array([1, 1]), mindspore.float32)
-        >>> atan2 = P.Atan2()
+        >>> atan2 = ops.Atan2()
         >>> output = atan2(input_x, input_y)
         >>> print(output)
         [0.        0.7853982]
@@ -3652,7 +3652,7 @@ class SquareSumAll(PrimitiveWithInfer):
     Examples:
         >>> input_x1 = Tensor(np.array([0, 0, 2, 0]), mindspore.float32)
         >>> input_x2 = Tensor(np.array([0, 0, 2, 4]), mindspore.float32)
-        >>> square_sum_all = P.SquareSumAll()
+        >>> square_sum_all = ops.SquareSumAll()
         >>> output = square_sum_all(input_x1, input_x2)
         >>> print(output)
         (Tensor(shape=[], dtype=Float32, value= 4),
@@ -3697,7 +3697,7 @@ class BitwiseAnd(_BitwiseBinaryOp):
     Examples:
         >>> input_x1 = Tensor(np.array([0, 0, 1, -1, 1, 1, 1]), mindspore.int16)
         >>> input_x2 = Tensor(np.array([0, 1, 1, -1, -1, 2, 3]), mindspore.int16)
-        >>> bitwise_and = P.BitwiseAnd()
+        >>> bitwise_and = ops.BitwiseAnd()
         >>> output = bitwise_and(input_x1, input_x2)
         >>> print(output)
         [ 0  0  1 -1  1  0  1]
@@ -3727,7 +3727,7 @@ class BitwiseOr(_BitwiseBinaryOp):
     Examples:
         >>> input_x1 = Tensor(np.array([0, 0, 1, -1, 1, 1, 1]), mindspore.int16)
         >>> input_x2 = Tensor(np.array([0, 1, 1, -1, -1, 2, 3]), mindspore.int16)
-        >>> bitwise_or = P.BitwiseOr()
+        >>> bitwise_or = ops.BitwiseOr()
         >>> boutput = itwise_or(input_x1, input_x2)
         >>> print(output)
         [ 0  1  1 -1 -1  3  3]
@@ -3757,7 +3757,7 @@ class BitwiseXor(_BitwiseBinaryOp):
     Examples:
         >>> input_x1 = Tensor(np.array([0, 0, 1, -1, 1, 1, 1]), mindspore.int16)
         >>> input_x2 = Tensor(np.array([0, 1, 1, -1, -1, 2, 3]), mindspore.int16)
-        >>> bitwise_xor = P.BitwiseXor()
+        >>> bitwise_xor = ops.BitwiseXor()
         >>> output = bitwise_xor(input_x1, input_x2)
         >>> print(output)
         [ 0  1  0  0 -2  3  2]
@@ -3779,7 +3779,7 @@ class BesselI0e(PrimitiveWithInfer):
         ``Ascend``
 
     Examples:
-        >>> bessel_i0e = P.BesselI0e()
+        >>> bessel_i0e = ops.BesselI0e()
         >>> input_x = Tensor(np.array([0.24, 0.83, 0.31, 0.09]), mindspore.float32)
         >>> output = bessel_i0e(input_x)
         >>> print(output)
@@ -3813,7 +3813,7 @@ class BesselI1e(PrimitiveWithInfer):
         ``Ascend``
 
     Examples:
-        >>> bessel_i1e = P.BesselI1e()
+        >>> bessel_i1e = ops.BesselI1e()
         >>> input_x = Tensor(np.array([0.24, 0.83, 0.31, 0.09]), mindspore.float32)
         >>> output = bessel_i1e(input_x)
         >>> print(output)
@@ -3847,7 +3847,7 @@ class Inv(PrimitiveWithInfer):
         ``Ascend``
 
     Examples:
-        >>> inv = P.Inv()
+        >>> inv = ops.Inv()
         >>> input_x = Tensor(np.array([0.25, 0.4, 0.31, 0.52]), mindspore.float32)
         >>> output = inv(input_x)
         >>> print(output)
@@ -3881,7 +3881,7 @@ class Invert(PrimitiveWithInfer):
         ``Ascend``
 
     Examples:
-        >>> invert = P.Invert()
+        >>> invert = ops.Invert()
         >>> input_x = Tensor(np.array([25, 4, 13, 9]), mindspore.int16)
         >>> output = invert(input_x)
         >>> print(output)
@@ -3915,7 +3915,7 @@ class Eps(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor([4, 1, 2, 3], mindspore.float32)
-        >>> output = P.Eps()(input_x)
+        >>> output = ops.Eps()(input_x)
         >>> print(output)
         [1.5258789e-05 1.5258789e-05 1.5258789e-05 1.5258789e-05]
     """

mindspore/ops/operations/nn_ops.py

@@ -91,7 +91,7 @@ class Flatten(PrimitiveWithInfer):
 
     Examples:
         >>> input_tensor = Tensor(np.ones(shape=[1, 2, 3, 4]), mindspore.float32)
-        >>> flatten = P.Flatten()
+        >>> flatten = ops.Flatten()
         >>> output = flatten(input_tensor)
         >>> print(output.shape)
         (1, 24)
@@ -138,7 +138,7 @@ class Softmax(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor(np.array([1, 2, 3, 4, 5]), mindspore.float32)
-        >>> softmax = P.Softmax()
+        >>> softmax = ops.Softmax()
         >>> output = softmax(input_x)
         >>> print(output)
         [0.01165623 0.03168492 0.08612854 0.23412167 0.6364086 ]
@@ -192,7 +192,7 @@ class LogSoftmax(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor(np.array([1, 2, 3, 4, 5]), mindspore.float32)
-        >>> log_softmax = P.LogSoftmax()
+        >>> log_softmax = ops.LogSoftmax()
         >>> output = log_softmax(input_x)
         >>> print(output)
         [-4.4519143 -3.4519143 -2.4519143 -1.4519144 -0.4519144]
@@ -233,7 +233,7 @@ class Softplus(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor(np.array([1, 2, 3, 4, 5]), mindspore.float32)
-        >>> softplus = P.Softplus()
+        >>> softplus = ops.Softplus()
         >>> output = softplus(input_x)
         >>> print(output)
         [1.3132615 2.126928  3.0485873 4.01815   5.0067153]
@@ -272,7 +272,7 @@ class Softsign(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor(np.array([0, -1, 2, 30, -30]), mindspore.float32)
-        >>> softsign = P.Softsign()
+        >>> softsign = ops.Softsign()
         >>> output = softsign(input_x)
         >>> print(output)
         [ 0.        -0.5         0.6666667  0.9677419 -0.9677419]
@@ -308,7 +308,7 @@ class ReLU(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor(np.array([[-1.0, 4.0, -8.0], [2.0, -5.0, 9.0]]), mindspore.float32)
-        >>> relu = P.ReLU()
+        >>> relu = ops.ReLU()
         >>> output = relu(input_x)
         >>> print(output)
         [[0. 4. 0.]
@@ -345,7 +345,7 @@ class ReLU6(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor(np.array([[-1.0, 4.0, -8.0], [2.0, -5.0, 9.0]]), mindspore.float32)
-        >>> relu6 = P.ReLU6()
+        >>> relu6 = ops.ReLU6()
         >>> result = relu6(input_x)
         >>> print(result)
         [[0. 4. 0.]
@@ -383,7 +383,7 @@ class ReLUV2(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor(np.array([[[[1, -2], [-3, 4]], [[-5, 6], [7, -8]]]]), mindspore.float32)
-        >>> relu_v2 = P.ReLUV2()
+        >>> relu_v2 = ops.ReLUV2()
         >>> output, mask= relu_v2(input_x)
         >>> print(output)
         [[[[1. 0.]
@@ -464,7 +464,7 @@ class Elu(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor(np.array([[-1.0, 4.0, -8.0], [2.0, -5.0, 9.0]]), mindspore.float32)
-        >>> elu = P.Elu()
+        >>> elu = ops.Elu()
         >>> output = elu(input_x)
         >>> print(output)
         [[-0.63212055  4.         -0.99966455]
@@ -508,7 +508,7 @@ class HSwish(PrimitiveWithInfer):
         ``GPU``
 
     Examples:
-        >>> hswish = P.HSwish()
+        >>> hswish = ops.HSwish()
         >>> input_x = Tensor(np.array([-1, -2, 0, 2, 1]), mindspore.float16)
         >>> result = hswish(input_x)
         >>> print(result)
@@ -549,7 +549,7 @@ class Sigmoid(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor(np.array([1, 2, 3, 4, 5]), mindspore.float32)
-        >>> sigmoid = P.Sigmoid()
+        >>> sigmoid = ops.Sigmoid()
         >>> output = sigmoid(input_x)
         >>> print(output)
         [0.7310586  0.880797   0.95257413 0.98201376 0.9933072 ]
@@ -590,7 +590,7 @@ class HSigmoid(PrimitiveWithInfer):
         ``GPU``
 
     Examples:
-        >>> hsigmoid = P.HSigmoid()
+        >>> hsigmoid = ops.HSigmoid()
         >>> input_x = Tensor(np.array([-1, -2, 0, 2, 1]), mindspore.float16)
         >>> result = hsigmoid(input_x)
         >>> print(result)
@@ -631,7 +631,7 @@ class Tanh(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor(np.array([1, 2, 3, 4, 5]), mindspore.float32)
-        >>> tanh = P.Tanh()
+        >>> tanh = ops.Tanh()
         >>> output = tanh(input_x)
         >>> print(output)
         [0.7615941 0.9640276 0.9950547 0.9993293 0.9999092]
@@ -697,11 +697,11 @@ class FusedBatchNorm(Primitive):
         >>> import numpy as np
         >>> from mindspore import Parameter
         >>> from mindspore import Tensor
-        >>> from mindspore.ops import operations as P
+        >>> from mindspore.ops import operations as ops
         >>> class FusedBatchNormNet(nn.Cell):
         >>>     def __init__(self):
         >>>         super(FusedBatchNormNet, self).__init__()
-        >>>         self.fused_batch_norm = P.FusedBatchNorm()
+        >>>         self.fused_batch_norm = ops.FusedBatchNorm()
         >>>         self.scale = Parameter(Tensor(np.ones([64]), mindspore.float32), name="scale")
         >>>         self.bias = Parameter(Tensor(np.ones([64]), mindspore.float32), name="bias")
         >>>         self.mean = Parameter(Tensor(np.ones([64]), mindspore.float32), name="mean")
@@ -794,11 +794,11 @@ class FusedBatchNormEx(PrimitiveWithInfer):
         >>> import numpy as np
         >>> from mindspore import Parameter
         >>> from mindspore import Tensor
-        >>> from mindspore.ops import operations as P
+        >>> from mindspore.ops import operations as ops
         >>> class FusedBatchNormExNet(nn.Cell):
         >>>     def __init__(self):
         >>>         super(FusedBatchNormExNet, self).__init__()
-        >>>         self.fused_batch_norm_ex = P.FusedBatchNormEx()
+        >>>         self.fused_batch_norm_ex = ops.FusedBatchNormEx()
         >>>         self.scale = Parameter(Tensor(np.ones([64]), mindspore.float32), name="scale")
         >>>         self.bias = Parameter(Tensor(np.ones([64]), mindspore.float32), name="bias")
         >>>         self.mean = Parameter(Tensor(np.ones([64]), mindspore.float32), name="mean")
@@ -874,7 +874,7 @@ class BNTrainingReduce(PrimitiveWithInfer):
 
     Examples:
         >>> input_x = Tensor(np.ones([128, 3, 32, 3]), mindspore.float32)
-        >>> bn_training_reduce = P.BNTrainingReduce()
+        >>> bn_training_reduce = ops.BNTrainingReduce()
         >>> output = bn_training_reduce(input_x)
         >>> print(output)
         ([1.22880000e+04, 1.22880000e+04, 1.22880000e+04],
@@ -940,7 +940,7 @@ class BNTrainingUpdate(PrimitiveWithInfer):
         >>> offset = Tensor(np.ones([2]), mindspore.float32)
         >>> mean = Tensor(np.ones([2]), mindspore.float32)
         >>> variance = Tensor(np.ones([2]), mindspore.float32)
-        >>> bn_training_update = P.BNTrainingUpdate()
+        >>> bn_training_update = ops.BNTrainingUpdate()
         >>> output = bn_training_update(input_x, sum, square_sum, scale, offset, mean, variance)
         >>> print(output)
         ([[[[2.73200464e+00, 2.73200464e+00],
@@ -1041,7 +1041,7 @@ class BatchNorm(PrimitiveWithInfer):
         >>> bias = Tensor(np.ones([2]), mindspore.float32)
         >>> mean = Tensor(np.ones([2]), mindspore.float32)
         >>> variance = Tensor(np.ones([2]), mindspore.float32)
-        >>> batch_norm = P.BatchNorm()
+        >>> batch_norm = ops.BatchNorm()
         >>> output = batch_norm(input_x, scale, bias, mean, variance)
         >>> print(output)
         ([[1.0, 1.0],
@@ -1147,7 +1147,7 @@ class Conv2D(PrimitiveWithInfer):
     Examples:
         >>> input = Tensor(np.ones([10, 32, 32, 32]), mindspore.float32)
         >>> weight = Tensor(np.ones([32, 32, 3, 3]), mindspore.float32)
-        >>> conv2d = P.Conv2D(out_channel=32, kernel_size=3)
+        >>> conv2d = ops.Conv2D(out_channel=32, kernel_size=3)
         >>> output = conv2d(input, weight)
         >>> print(output.shape)
         (10, 32, 30, 30)
@@ -1295,7 +1295,7 @@ class DepthwiseConv2dNative(PrimitiveWithInfer):
     Examples:
         >>> input = Tensor(np.ones([10, 32, 32, 32]), mindspore.float32)
         >>> weight = Tensor(np.ones([1, 32, 3, 3]), mindspore.float32)
-        >>> depthwise_conv2d = P.DepthwiseConv2dNative(channel_multiplier = 3, kernel_size = (3, 3))
+        >>> depthwise_conv2d = ops.DepthwiseConv2dNative(channel_multiplier = 3, kernel_size = (3, 3))
         >>> output = depthwise_conv2d(input, weight)
         >>> print(output.shape)
         (10, 96, 30, 30)
@@ -1508,7 +1508,7 @@ class MaxPool(_Pool):
 
     Examples:
         >>> input_tensor = Tensor(np.arange(1 * 3 * 3 * 4).reshape((1, 3, 3, 4)), mindspore.float32)
-        >>> maxpool_op = P.MaxPool(padding="VALID", ksize=2, strides=1)
+        >>> maxpool_op = ops.MaxPool(padding="VALID", ksize=2, strides=1)
         >>> output_tensor = maxpool_op(input_tensor)
     """
 
@@ -1563,7 +1563,7 @@ class MaxPoolWithArgmax(_Pool):
 
     Examples:
         >>> input_tensor = Tensor(np.arange(1 * 3 * 3 * 4).reshape((1, 3, 3, 4)), mindspore.float32)
-        >>> maxpool_arg_op = P.MaxPoolWithArgmax(padding="VALID", ksize=2, strides=1)
+        >>> maxpool_arg_op = ops.MaxPoolWithArgmax(padding="VALID", ksize=2, strides=1)
         >>> output_tensor, argmax = maxpool_arg_op(input_tensor)
     """
 
@@ -1649,11 +1649,11 @@ class AvgPool(_Pool):
         >>> import mindspore.nn as nn
         >>> import numpy as np
         >>> from mindspore import Tensor
-        >>> from mindspore.ops import operations as P
+        >>> from mindspore.ops import operations as ops
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
-        ...         self.avgpool_op = P.AvgPool(padding="VALID", ksize=2, strides=1)
+        ...         self.avgpool_op = ops.AvgPool(padding="VALID", ksize=2, strides=1)
         ...
         ...     def construct(self, x):
         ...         result = self.avgpool_op(x)
@@ -1720,7 +1720,7 @@ class Conv2DBackpropInput(PrimitiveWithInfer):
         >>> dout = Tensor(np.ones([10, 32, 30, 30]), mindspore.float32)
         >>> weight = Tensor(np.ones([32, 32, 3, 3]), mindspore.float32)
         >>> x = Tensor(np.ones([10, 32, 32, 32]))
-        >>> conv2d_backprop_input = P.Conv2DBackpropInput(out_channel=32, kernel_size=3)
+        >>> conv2d_backprop_input = ops.Conv2DBackpropInput(out_channel=32, kernel_size=3)
         >>> output = conv2d_backprop_input(dout, weight, F.shape(x))
         >>> print(output.shape)
         (10, 32, 32, 32)
@@ -1840,7 +1840,7 @@ class BiasAdd(PrimitiveWithInfer):
     Examples:
         >>> input_x = Tensor(np.arange(6).reshape((2, 3)), mindspore.float32)
         >>> bias = Tensor(np.random.random(3).reshape((3,)), mindspore.float32)
-        >>> bias_add = P.BiasAdd()
+        >>> bias_add = ops.BiasAdd()
         >>> output = bias_add(input_x, bias)
         >>> print(output)
         [[0.4662124 1.2493685 2.3611782]
@@ -1890,7 +1890,7 @@ class TopK(PrimitiveWithInfer):
         ``Ascend`` ``GPU``
 
     Examples:
-        >>> topk = P.TopK(sorted=True)
+        >>> topk = ops.TopK(sorted=True)
         >>> input_x = Tensor([1, 2, 3, 4, 5], mindspore.float16)
         >>> k = 3
         >>> values, indices = topk(input_x, k)
@@ -1944,7 +1944,7 @@ class SoftmaxCrossEntropyWithLogits(PrimitiveWithInfer):
     Examples:
         >>> logits = Tensor([[2, 4, 1, 4, 5], [2, 1, 2, 4, 3]], mindspore.float32)
         >>> labels = Tensor([[0, 0, 0, 0, 1], [0, 0, 0, 1, 0]], mindspore.float32)
-        >>> softmax_cross = P.SoftmaxCrossEntropyWithLogits()
+        >>> softmax_cross = ops.SoftmaxCrossEntropyWithLogits()
         >>> loss, dlogits = softmax_cross(logits, labels)
         >>> print(loss)
         [0.5899297  0.52374405]
@@ -2125,7 +2125,7 @@ class SmoothL1Loss(PrimitiveWithInfer):
         ``Ascend`` ``GPU``
 
     Examples:
-        >>> loss = P.SmoothL1Loss()
+        >>> loss = ops.SmoothL1Loss()
         >>> input_data = Tensor(np.array([1, 2, 3]), mindspore.float32)
         >>> target_data = Tensor(np.array([1, 2, 2]), mindspore.float32)
         >>> output = loss(input_data, target_data)
@@ -2172,7 +2172,7 @@ class L2Loss(PrimitiveWithInfer):
 
     Examples
         >>> input_x = Tensor(np.array([1, 2, 3]), mindspore.float16)
-        >>> l2_loss = P.L2Loss()
+        >>> l2_loss = ops.L2Loss()
         >>> output = l2_loss(input_x)
         >>> print(output)
         7.0
@@ -2212,7 +2212,7 @@ class DataFormatDimMap(PrimitiveWithInfer):
 
     Examples:
         >>> x = Tensor([0, 1, 2, 3], mindspore.int32)
-        >>> dfdm = P.DataFormatDimMap()
+        >>> dfdm = ops.DataFormatDimMap()
         >>> output = dfdm(x)
         >>> print(output)
         [0 3 1 2]
@@ -2261,7 +2261,7 @@ class RNNTLoss(PrimitiveWithInfer):
         >>> labels = np.array([[1, 2]]).astype(np.int32)
         >>> input_length = np.array([T] * B).astype(np.int32)
         >>> label_length = np.array([len(l) for l in labels]).astype(np.int32)
-        >>> rnnt_loss = P.RNNTLoss(blank_label=blank)
+        >>> rnnt_loss = ops.RNNTLoss(blank_label=blank)
         >>> costs, grads = rnnt_loss(Tensor(acts), Tensor(labels), Tensor(input_length), Tensor(label_length))
     """
 
@@ -2324,7 +2324,7 @@ class SGD(PrimitiveWithCheck):
         ``Ascend`` ``GPU``
 
     Examples:
-        >>> sgd = P.SGD()
+        >>> sgd = ops.SGD()
         >>> parameters = Tensor(np.array([2, -0.5, 1.7, 4]), mindspore.float32)
         >>> gradient = Tensor(np.array([1, -1, 0.5, 2]), mindspore.float32)
         >>> learning_rate = Tensor(0.01, mindspore.float32)
@@ -2406,7 +2406,7 @@ class ApplyRMSProp(PrimitiveWithInfer):
         ``Ascend`` ``GPU``
 
     Examples:
-        >>> apply_rms = P.ApplyRMSProp()
+        >>> apply_rms = ops.ApplyRMSProp()
         >>> input_x = Tensor(1., mindspore.float32)
         >>> mean_square = Tensor(2., mindspore.float32)
         >>> moment = Tensor(1., mindspore.float32)
@@ -2508,7 +2508,7 @@ class ApplyCenteredRMSProp(PrimitiveWithInfer):
         ``Ascend`` ``GPU``
 
     Examples:
-        >>> centered_rms_prop = P.ApplyCenteredRMSProp()
+        >>> centered_rms_prop = ops.ApplyCenteredRMSProp()
         >>> input_x = Tensor(np.arange(-2, 2).astype(np.float32).reshape(2, 2), mindspore.float32)
         >>> mean_grad = Tensor(np.arange(4).astype(np.float32).reshape(2, 2), mindspore.float32)
         >>> mean_square = Tensor(np.arange(-3, 1).astype(np.float32).reshape(2, 2), mindspore.float32)
@@ -2605,7 +2605,7 @@ class LayerNorm(Primitive):
         >>> input_x = Tensor(np.array([[1, 2, 3], [1, 2, 3]]), mindspore.float32)
         >>> gamma = Tensor(np.ones([3]), mindspore.float32)
         >>> beta = Tensor(np.ones([3]), mindspore.float32)
-        >>> layer_norm = P.LayerNorm()
+        >>> layer_norm = ops.LayerNorm()
         >>> output, mean, variance = layer_norm(input_x, gamma, beta)
         >>> print(output)
         [[-0.2247448  1.         2.2247448]
@@ -2650,7 +2650,7 @@ class L2Normalize(PrimitiveWithInfer):
         ``Ascend``
 
     Examples:
-        >>> l2_normalize = P.L2Normalize()
+        >>> l2_normalize = ops.L2Normalize()
         >>> input_x = Tensor(np.random.randint(-256, 256, (2, 3, 4)), mindspore.float32)
         >>> output = l2_normalize(input_x)
         >>> print(output)
@@ -2697,7 +2697,7 @@ class DropoutGenMask(Primitive):
         ``Ascend``
 
     Examples:
-        >>> dropout_gen_mask = P.DropoutGenMask()
+        >>> dropout_gen_mask = ops.DropoutGenMask()
         >>> shape = (2, 4, 5)
         >>> keep_prob = Tensor(0.5, mindspore.float32)
         >>> output = dropout_gen_mask(shape, keep_prob)
@@ -2738,8 +2738,8 @@ class DropoutDoMask(PrimitiveWithInfer):
         >>> x = Tensor(np.ones([2, 2, 3]), mindspore.float32)
         >>> shape = (2, 2, 3)
         >>> keep_prob = Tensor(0.5, mindspore.float32)
-        >>> dropout_gen_mask = P.DropoutGenMask()
-        >>> dropout_do_mask = P.DropoutDoMask()
+        >>> dropout_gen_mask = ops.DropoutGenMask()
+        >>> dropout_do_mask = ops.DropoutDoMask()
         >>> mask = dropout_gen_mask(shape, keep_prob)
         >>> output = dropout_do_mask(x, mask, keep_prob)
         >>> print(output)
@@ -2810,7 +2810,7 @@ class ResizeBilinear(PrimitiveWithInfer):
 
     Examples:
         >>> tensor = Tensor([[[[1, 2, 3, 4, 5], [1, 2, 3, 4, 5]]]], mindspore.float32)
-        >>> resize_bilinear = P.ResizeBilinear((5, 5))
+        >>> resize_bilinear = ops.ResizeBilinear((5, 5))
         >>> output = resize_bilinear(tensor)
         >>> print(output)
         [[[[1. 2. 3. 4. 5.]
@@ -2870,7 +2870,7 @@ class OneHot(PrimitiveWithInfer):
     Examples:
         >>> indices = Tensor(np.array([0, 1, 2]), mindspore.int32)
         >>> depth, on_value, off_value = 3, Tensor(1.0, mindspore.float32), Tensor(0.0, mindspore.float32)
-        >>> onehot = P.OneHot()
+        >>> onehot = ops.OneHot()
         >>> output = onehot(indices, depth, on_value, off_value)
         >>> print(output)
         [[1. 0. 0.]
@@ -2929,7 +2929,7 @@ class Gelu(PrimitiveWithInfer):
 
     Examples:
         >>> tensor = Tensor(np.array([1.0, 2.0, 3.0]), mindspore.float32)
-        >>> gelu = P.Gelu()
+        >>> gelu = ops.Gelu()
         >>> result = gelu(tensor)
         >>> print(result)
         [0.841192  1.9545976  2.9963627]
@@ -2974,7 +2974,7 @@ class GetNext(PrimitiveWithInfer):
         ``Ascend`` ``GPU``
 
     Examples:
-        >>> get_next = P.GetNext([mindspore.float32, mindspore.int32], [[32, 1, 28, 28], [10]], 2, 'shared_name')
+        >>> get_next = ops.GetNext([mindspore.float32, mindspore.int32], [[32, 1, 28, 28], [10]], 2, 'shared_name')
         >>> feature, label = get_next()
     """
 
@@ -3026,11 +3026,11 @@ class PReLU(PrimitiveWithInfer):
         >>> import mindspore.nn as nn
         >>> import numpy as np
         >>> from mindspore import Tensor
-        >>> from mindspore.ops import operations as P
+        >>> from mindspore.ops import operations as ops
         >>> class Net(nn.Cell):
         >>>     def __init__(self):
         >>>         super(Net, self).__init__()
-        >>>         self.prelu = P.PReLU()
+        >>>         self.prelu = ops.PReLU()
         >>>     def construct(self, input_x, weight):
         >>>         result = self.prelu(input_x, weight)
         >>>         return result
@@ -3214,7 +3214,7 @@ class SigmoidCrossEntropyWithLogits(PrimitiveWithInfer):
     Examples:
         >>> logits = Tensor(np.array([[-0.8, 1.2, 0.7], [-0.1, -0.4, 0.7]]).astype(np.float32))
         >>> labels = Tensor(np.array([[0.3, 0.8, 1.2], [-0.6, 0.1, 2.2]]).astype(np.float32))
-        >>> sigmoid = P.SigmoidCrossEntropyWithLogits()
+        >>> sigmoid = ops.SigmoidCrossEntropyWithLogits()
         >>> output = sigmoid(logits, labels)
         >>> print(output)
         [[0.6111007   0.5032824   0.26318604]
@@ -3257,7 +3257,7 @@ class Pad(PrimitiveWithInfer):
 
     Examples:
         >>> input_tensor = Tensor(np.array([[-0.1, 0.3, 3.6], [0.4, 0.5, -3.2]]), mindspore.float32)
-        >>> pad_op = P.Pad(((1, 2), (2, 1)))
+        >>> pad_op = ops.Pad(((1, 2), (2, 1)))
         >>> output = pad_op(input_tensor)
         >>> print(output)
         [[ 0.   0.   0.   0.   0.   0. ],
@@ -3325,13 +3325,13 @@ class MirrorPad(PrimitiveWithInfer):
 
     Examples:
         >>> from mindspore import Tensor
-        >>> from mindspore.ops import operations as P
+        >>> from mindspore.ops import operations as ops
         >>> import mindspore.nn as nn
         >>> import numpy as np
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
-        ...         self.pad = P.MirrorPad(mode="REFLECT")
+        ...         self.pad = ops.MirrorPad(mode="REFLECT")
         ...     def construct(self, x, paddings):
         ...         return self.pad(x, paddings)
         ...
@@ -3411,7 +3411,7 @@ class ROIAlign(PrimitiveWithInfer):
     Examples:
         >>> input_tensor = Tensor(np.array([[[[1., 2.], [3., 4.]]]]), mindspore.float32)
         >>> rois = Tensor(np.array([[0, 0.2, 0.3, 0.2, 0.3]]), mindspore.float32)
-        >>> roi_align = P.ROIAlign(2, 2, 0.5, 2)
+        >>> roi_align = ops.ROIAlign(2, 2, 0.5, 2)
         >>> output = roi_align(input_tensor, rois)
         >>> print(output)
         [[[[1.775 2.025]
@@ -3501,11 +3501,11 @@ class Adam(PrimitiveWithInfer):
         >>> import numpy as np
         >>> import mindspore.nn as nn
         >>> from mindspore import Tensor, Parameter
-        >>> from mindspore.ops import operations as P
+        >>> from mindspore.ops import operations as ops
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
-        ...         self.apply_adam = P.Adam()
+        ...         self.apply_adam = ops.Adam()
         ...         self.var = Parameter(Tensor(np.ones([2, 2]).astype(np.float32)), name="var")
         ...         self.m = Parameter(Tensor(np.ones([2, 2]).astype(np.float32)), name="m")
         ...         self.v = Parameter(Tensor(np.ones([2, 2]).astype(np.float32)), name="v")
@@ -3604,12 +3604,12 @@ class AdamNoUpdateParam(PrimitiveWithInfer):
         >>> import mindspore as ms
         >>> import mindspore.nn as nn
         >>> from mindspore import Tensor, Parameter
-        >>> from mindspore.ops import operations as P
+        >>> from mindspore.ops import operations as ops
         >>>
         >>> class Net(nn.Cell):
         >>>     def __init__(self):
         >>>         super(Net, self).__init__()
-        >>>         self.adam = P.AdamNoUpdateParam()
+        >>>         self.adam = ops.AdamNoUpdateParam()
         >>>         self.m = Parameter(Tensor(np.array([[0.1, 0.1, 0.1], [0.2, 0.2, 0.2]]).astype(np.float32)),
         >>>                            name="m")
         >>>         self.v = Parameter(Tensor(np.array([[0.1, 0.1, 0.1], [0.2, 0.2, 0.2]]).astype(np.float32)),
@@ -3717,12 +3717,12 @@ class FusedSparseAdam(PrimitiveWithInfer):
         >>> import numpy as np
         >>> import mindspore.nn as nn
         >>> from mindspore import Tensor, Parameter
-        >>> from mindspore.ops import operations as P
+        >>> from mindspore.ops import operations as ops
         >>> import mindspore.common.dtype as mstype
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
-        ...         self.sparse_apply_adam = P.FusedSparseAdam()
+        ...         self.sparse_apply_adam = ops.FusedSparseAdam()
         ...         self.var = Parameter(Tensor(np.ones([3, 1, 2]).astype(np.float32)), name="var")
         ...         self.m = Parameter(Tensor(np.ones([3, 1, 2]).astype(np.float32)), name="m")
         ...         self.v = Parameter(Tensor(np.ones([3, 1, 2]).astype(np.float32)), name="v")
@@ -3855,12 +3855,12 @@ class FusedSparseLazyAdam(PrimitiveWithInfer):
         >>> import numpy as np
         >>> import mindspore.nn as nn
         >>> from mindspore import Tensor, Parameter
-        >>> from mindspore.ops import operations as P
+        >>> from mindspore.ops import operations as ops
         >>> import mindspore.common.dtype as mstype
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
-        ...         self.sparse_apply_lazyadam = P.FusedSparseLazyAdam()
+        ...         self.sparse_apply_lazyadam = ops.FusedSparseLazyAdam()
         ...         self.var = Parameter(Tensor(np.ones([3, 1, 2]).astype(np.float32)), name="var")
         ...         self.m = Parameter(Tensor(np.ones([3, 1, 2]).astype(np.float32)), name="m")
         ...         self.v = Parameter(Tensor(np.ones([3, 1, 2]).astype(np.float32)), name="v")
@@ -3969,11 +3969,11 @@ class FusedSparseFtrl(PrimitiveWithInfer):
         >>> import numpy as np
         >>> from mindspore import Parameter
         >>> from mindspore import Tensor
-        >>> from mindspore.ops import operations as P
+        >>> from mindspore.ops import operations as ops
         >>> class SparseApplyFtrlNet(nn.Cell):
         ...     def __init__(self):
         ...         super(SparseApplyFtrlNet, self).__init__()
-        ...         self.sparse_apply_ftrl = P.FusedSparseFtrl(lr=0.01, l1=0.0, l2=0.0, lr_power=-0.5)
+        ...         self.sparse_apply_ftrl = ops.FusedSparseFtrl(lr=0.01, l1=0.0, l2=0.0, lr_power=-0.5)
         ...         self.var = Parameter(Tensor(np.random.rand(3, 1, 2).astype(np.float32)), name="var")
         ...         self.accum = Parameter(Tensor(np.random.rand(3, 1, 2).astype(np.float32)), name="accum")
         ...         self.linear = Parameter(Tensor(np.random.rand(3, 1, 2).astype(np.float32)), name="linear")
@@ -4068,11 +4068,11 @@ class FusedSparseProximalAdagrad(PrimitiveWithInfer):
         >>> import numpy as np
         >>> import mindspore.nn as nn
         >>> from mindspore import Tensor, Parameter
-        >>> from mindspore.ops import operations as P
+        >>> from mindspore.ops import operations as ops
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
-        ...         self.sparse_apply_proximal_adagrad = P.FusedSparseProximalAdagrad()
+        ...         self.sparse_apply_proximal_adagrad = ops.FusedSparseProximalAdagrad()
         ...         self.var = Parameter(Tensor(np.random.rand(3, 1, 2).astype(np.float32)), name="var")
         ...         self.accum = Parameter(Tensor(np.random.rand(3, 1, 2).astype(np.float32)), name="accum")
         ...         self.lr = Tensor(0.01, mstype.float32)
@@ -4162,11 +4162,11 @@ class KLDivLoss(PrimitiveWithInfer):
         >>> import mindspore.nn as nn
         >>> import numpy as np
         >>> from mindspore import Tensor
-        >>> from mindspore.ops import operations as P
+        >>> from mindspore.ops import operations as ops
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
-        ...         self.kldiv_loss = P.KLDivLoss()
+        ...         self.kldiv_loss = ops.KLDivLoss()
         ...     def construct(self, x, y):
         ...         result = self.kldiv_loss(x, y)
         ...         return result
@@ -4241,11 +4241,11 @@ class BinaryCrossEntropy(PrimitiveWithInfer):
         >>> import mindspore.nn as nn
         >>> import numpy as np
         >>> from mindspore import Tensor
-        >>> from mindspore.ops import operations as P
+        >>> from mindspore.ops import operations as ops
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
-        ...         self.binary_cross_entropy = P.BinaryCrossEntropy()
+        ...         self.binary_cross_entropy = ops.BinaryCrossEntropy()
         ...     def construct(self, x, y, weight):
         ...         result = self.binary_cross_entropy(x, y, weight)
         ...         return result
@@ -4341,12 +4341,12 @@ class ApplyAdaMax(PrimitiveWithInfer):
         >>> import numpy as np
         >>> import mindspore.nn as nn
         >>> from mindspore import Tensor, Parameter
-        >>> from mindspore.ops import operations as P
+        >>> from mindspore.ops import operations as ops
         >>> import mindspore.common.dtype as mstype
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
-        ...         self.apply_ada_max = P.ApplyAdaMax()
+        ...         self.apply_ada_max = ops.ApplyAdaMax()
         ...         self.var = Parameter(Tensor(np.random.rand(2, 2).astype(np.float32)), name="var")
         ...         self.m = Parameter(Tensor(np.random.rand(2, 2).astype(np.float32)), name="m")
         ...         self.v = Parameter(Tensor(np.random.rand(2, 2).astype(np.float32)), name="v")
@@ -4473,12 +4473,12 @@ class ApplyAdadelta(PrimitiveWithInfer):
         >>> import numpy as np
         >>> import mindspore.nn as nn
         >>> from mindspore import Tensor, Parameter
-        >>> from mindspore.ops import operations as P
+        >>> from mindspore.ops import operations as ops
         >>> import mindspore.common.dtype as mstype
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
-        ...         self.apply_adadelta = P.ApplyAdadelta()
+        ...         self.apply_adadelta = ops.ApplyAdadelta()
         ...         self.var = Parameter(Tensor(np.random.rand(2, 2).astype(np.float32)), name="var")
         ...         self.accum = Parameter(Tensor(np.random.rand(2, 2).astype(np.float32)), name="accum")
         ...         self.accum_update = Parameter(Tensor(np.random.rand(2, 2).astype(np.float32)), name="accum_update")
@@ -4585,12 +4585,12 @@ class ApplyAdagrad(PrimitiveWithInfer):
         >>> import numpy as np
         >>> import mindspore.nn as nn
         >>> from mindspore import Tensor, Parameter
-        >>> from mindspore.ops import operations as P
+        >>> from mindspore.ops import operations as ops
         >>> import mindspore.common.dtype as mstype
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
-        ...         self.apply_adagrad = P.ApplyAdagrad()
+        ...         self.apply_adagrad = ops.ApplyAdagrad()
         ...         self.var = Parameter(Tensor(np.random.rand(2, 2).astype(np.float32)), name="var")
         ...         self.accum = Parameter(Tensor(np.random.rand(2, 2).astype(np.float32)), name="accum")
         ...     def construct(self, lr, grad):
@@ -4678,12 +4678,12 @@ class ApplyAdagradV2(PrimitiveWithInfer):
         >>> import numpy as np
         >>> import mindspore.nn as nn
         >>> from mindspore import Tensor, Parameter
-        >>> from mindspore.ops import operations as P
+        >>> from mindspore.ops import operations as ops
         >>> import mindspore.common.dtype as mstype
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
-        ...         self.apply_adagrad_v2 = P.ApplyAdagradV2(epsilon=1e-6)
+        ...         self.apply_adagrad_v2 = ops.ApplyAdagradV2(epsilon=1e-6)
         ...         self.var = Parameter(Tensor(np.random.rand(2, 2).astype(np.float32)), name="var")
         ...         self.accum = Parameter(Tensor(np.random.rand(2, 2).astype(np.float32)), name="accum")
         ...     def construct(self, lr, grad):
@@ -4772,12 +4772,12 @@ class SparseApplyAdagrad(PrimitiveWithInfer):
         >>> import numpy as np
         >>> import mindspore.nn as nn
         >>> from mindspore import Tensor, Parameter
-        >>> from mindspore.ops import operations as P
+        >>> from mindspore.ops import operations as ops
         >>> import mindspore.common.dtype as mstype
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
-        ...         self.sparse_apply_adagrad = P.SparseApplyAdagrad(lr=1e-8)
+        ...         self.sparse_apply_adagrad = ops.SparseApplyAdagrad(lr=1e-8)
         ...         self.var = Parameter(Tensor(np.ones([1, 1, 1]).astype(np.float32)), name="var")
         ...         self.accum = Parameter(Tensor(np.ones([1, 1, 1]).astype(np.float32)), name="accum")
         ...     def construct(self, grad, indices):
@@ -4867,12 +4867,12 @@ class SparseApplyAdagradV2(PrimitiveWithInfer):
         >>> import numpy as np
         >>> import mindspore.nn as nn
         >>> from mindspore import Tensor, Parameter
-        >>> from mindspore.ops import operations as P
+        >>> from mindspore.ops import operations as ops
         >>> import mindspore.common.dtype as mstype
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
-        ...         self.sparse_apply_adagrad_v2 = P.SparseApplyAdagradV2(lr=1e-8, epsilon=1e-6)
+        ...         self.sparse_apply_adagrad_v2 = ops.SparseApplyAdagradV2(lr=1e-8, epsilon=1e-6)
         ...         self.var = Parameter(Tensor(np.ones([1, 1, 1]).astype(np.float32)), name="var")
         ...         self.accum = Parameter(Tensor(np.ones([1, 1, 1]).astype(np.float32)), name="accum")
         ...
@@ -4962,11 +4962,11 @@ class ApplyProximalAdagrad(PrimitiveWithInfer):
         >>> import numpy as np
         >>> import mindspore.nn as nn
         >>> from mindspore import Tensor, Parameter
-        >>> from mindspore.ops import operations as P
+        >>> from mindspore.ops import operations as ops
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
-        ...         self.apply_proximal_adagrad = P.ApplyProximalAdagrad()
+        ...         self.apply_proximal_adagrad = ops.ApplyProximalAdagrad()
         ...         self.var = Parameter(Tensor(np.random.rand(2, 2).astype(np.float32)), name="var")
         ...         self.accum = Parameter(Tensor(np.random.rand(2, 2).astype(np.float32)), name="accum")
         ...         self.lr = 0.01
@@ -5076,11 +5076,11 @@ class SparseApplyProximalAdagrad(PrimitiveWithCheck):
         >>> import numpy as np
         >>> import mindspore.nn as nn
         >>> from mindspore import Tensor, Parameter
-        >>> from mindspore.ops import operations as P
+        >>> from mindspore.ops import operations as ops
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
-        ...         self.sparse_apply_proximal_adagrad = P.SparseApplyProximalAdagrad()
+        ...         self.sparse_apply_proximal_adagrad = ops.SparseApplyProximalAdagrad()
         ...         self.var = Parameter(Tensor(np.random.rand(1, 2).astype(np.float32)), name="var")
         ...         self.accum = Parameter(Tensor(np.random.rand(1, 2).astype(np.float32)), name="accum")
         ...         self.lr = 0.01
@@ -5175,11 +5175,11 @@ class ApplyAddSign(PrimitiveWithInfer):
         >>> import numpy as np
         >>> import mindspore.nn as nn
         >>> from mindspore import Tensor, Parameter
-        >>> from mindspore.ops import operations as P
+        >>> from mindspore.ops import operations as ops
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
-        ...         self.apply_add_sign = P.ApplyAddSign()
+        ...         self.apply_add_sign = ops.ApplyAddSign()
         ...         self.var = Parameter(Tensor(np.random.rand(2, 2).astype(np.float32)), name="var")
         ...         self.m = Parameter(Tensor(np.random.rand(2, 2).astype(np.float32)), name="m")
         ...         self.lr = 0.001
@@ -5293,11 +5293,11 @@ class ApplyPowerSign(PrimitiveWithInfer):
         >>> import numpy as np
         >>> import mindspore.nn as nn
         >>> from mindspore import Tensor, Parameter
-        >>> from mindspore.ops import operations as P
+        >>> from mindspore.ops import operations as ops
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
-        ...         self.apply_power_sign = P.ApplyPowerSign()
+        ...         self.apply_power_sign = ops.ApplyPowerSign()
         ...         self.var = Parameter(Tensor(np.random.rand(2, 2).astype(np.float32)), name="var")
         ...         self.m = Parameter(Tensor(np.random.rand(2, 2).astype(np.float32)), name="m")
         ...         self.lr = 0.001
@@ -5393,11 +5393,11 @@ class ApplyGradientDescent(PrimitiveWithInfer):
         >>> import numpy as np
         >>> import mindspore.nn as nn
         >>> from mindspore import Tensor, Parameter
-        >>> from mindspore.ops import operations as P
+        >>> from mindspore.ops import operations as ops
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
-        ...         self.apply_gradient_descent = P.ApplyGradientDescent()
+        ...         self.apply_gradient_descent = ops.ApplyGradientDescent()
         ...         self.var = Parameter(Tensor(np.random.rand(2, 2).astype(np.float32)), name="var")
         ...         self.alpha = 0.001
         ...     def construct(self, delta):
@@ -5471,11 +5471,11 @@ class ApplyProximalGradientDescent(PrimitiveWithInfer):
         >>> import numpy as np
         >>> import mindspore.nn as nn
         >>> from mindspore import Tensor, Parameter
-        >>> from mindspore.ops import operations as P
+        >>> from mindspore.ops import operations as ops
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
-        ...         self.apply_proximal_gradient_descent = P.ApplyProximalGradientDescent()
+        ...         self.apply_proximal_gradient_descent = ops.ApplyProximalGradientDescent()
         ...         self.var = Parameter(Tensor(np.random.rand(2, 2).astype(np.float32)), name="var")
         ...         self.alpha = 0.001
         ...         self.l1 = 0.0
@@ -5555,18 +5555,17 @@ class LARSUpdate(PrimitiveWithInfer):
 
     Examples:
         >>> from mindspore import Tensor
-        >>> from mindspore.ops import operations as P
-        >>> from mindspore.ops import functional as F
+        >>> from mindspore.ops import operations as ops
         >>> import mindspore.nn as nn
         >>> import numpy as np
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
-        ...         self.lars = P.LARSUpdate()
-        ...         self.reduce = P.ReduceSum()
+        ...         self.lars = ops.LARSUpdate()
+        ...         self.reduce = ops.ReduceSum()
         ...     def construct(self, weight, gradient):
-        ...         w_square_sum = self.reduce(F.square(weight))
-        ...         grad_square_sum = self.reduce(F.square(gradient))
+        ...         w_square_sum = self.reduce(ops.square(weight))
+        ...         grad_square_sum = self.reduce(ops.square(gradient))
         ...         grad_t = self.lars(weight, gradient, w_square_sum, grad_square_sum, 0.0, 1.0)
         ...         return grad_t
         ...
@@ -5649,11 +5648,11 @@ class ApplyFtrl(PrimitiveWithInfer):
         >>> import numpy as np
         >>> from mindspore import Parameter
         >>> from mindspore import Tensor
-        >>> from mindspore.ops import operations as P
+        >>> from mindspore.ops import operations as ops
         >>> class ApplyFtrlNet(nn.Cell):
         ...     def __init__(self):
         ...         super(ApplyFtrlNet, self).__init__()
-        ...         self.apply_ftrl = P.ApplyFtrl()
+        ...         self.apply_ftrl = ops.ApplyFtrl()
         ...         self.lr = 0.001
         ...         self.l1 = 0.0
         ...         self.l2 = 0.0
@@ -5748,11 +5747,11 @@ class SparseApplyFtrl(PrimitiveWithCheck):
         >>> import numpy as np
         >>> from mindspore import Parameter
         >>> from mindspore import Tensor
-        >>> from mindspore.ops import operations as P
+        >>> from mindspore.ops import operations as ops
         >>> class SparseApplyFtrlNet(nn.Cell):
         ...     def __init__(self):
         ...         super(SparseApplyFtrlNet, self).__init__()
-        ...         self.sparse_apply_ftrl = P.SparseApplyFtrl(lr=0.01, l1=0.0, l2=0.0, lr_power=-0.5)
+        ...         self.sparse_apply_ftrl = ops.SparseApplyFtrl(lr=0.01, l1=0.0, l2=0.0, lr_power=-0.5)
         ...         self.var = Parameter(Tensor(np.random.rand(1, 1).astype(np.float32)), name="var")
         ...         self.accum = Parameter(Tensor(np.random.rand(1, 1).astype(np.float32)), name="accum")
         ...         self.linear = Parameter(Tensor(np.random.rand(1, 1).astype(np.float32)), name="linear")
@@ -5853,11 +5852,11 @@ class SparseApplyFtrlV2(PrimitiveWithInfer):
         >>> import numpy as np
         >>> from mindspore import Parameter
         >>> from mindspore import Tensor
-        >>> from mindspore.ops import operations as P
+        >>> from mindspore.ops import operations as ops
         >>> class SparseApplyFtrlV2Net(nn.Cell):
         ...     def __init__(self):
         ...         super(SparseApplyFtrlV2Net, self).__init__()
-        ...         self.sparse_apply_ftrl_v2 = P.SparseApplyFtrlV2(lr=0.01, l1=0.0, l2=0.0,
+        ...         self.sparse_apply_ftrl_v2 = ops.SparseApplyFtrlV2(lr=0.01, l1=0.0, l2=0.0,
         ...                                                         l2_shrinkage=0.0, lr_power=-0.5)
         ...         self.var = Parameter(Tensor(np.random.rand(1, 2).astype(np.float32)), name="var")
         ...         self.accum = Parameter(Tensor(np.random.rand(1, 2).astype(np.float32)), name="accum")
@@ -5932,7 +5931,7 @@ class Dropout(PrimitiveWithInfer):
         - **mask** (Tensor) - with the same shape as the input tensor.
 
     Examples:
-        >>> dropout = P.Dropout(keep_prob=0.5)
+        >>> dropout = ops.Dropout(keep_prob=0.5)
         >>> x = Tensor((20, 16, 50, 50), mindspore.float32)
         >>> output, mask = dropout(x)
         >>> print(output)
@@ -5994,7 +5993,7 @@ class CTCLoss(PrimitiveWithInfer):
         >>> labels_indices = Tensor(np.array([[0, 0], [1, 0]]), mindspore.int64)
         >>> labels_values = Tensor(np.array([2, 2]), mindspore.int32)
         >>> sequence_length = Tensor(np.array([2, 2]), mindspore.int32)
-        >>> ctc_loss = P.CTCLoss()
+        >>> ctc_loss = ops.CTCLoss()
         >>> loss, gradient = ctc_loss(inputs, labels_indices, labels_values, sequence_length)
         >>> print(loss)
         [0.69121575	0.5381993 ]
@@ -6072,7 +6071,7 @@ class CTCGreedyDecoder(PrimitiveWithInfer):
         ...    def __init__(self):
         ...        super(CTCGreedyDecoderNet, self).__init__()
         ...        self.ctc_greedy_decoder = P.CTCGreedyDecoder()
-        ...        self.assert_op = P.Assert(300)
+        ...        self.assert_op = ops.Assert(300)
         ...
         ...    def construct(self, inputs, sequence_length):
         ...        out = self.ctc_greedy_decoder(inputs,sequence_length)
@@ -6175,7 +6174,7 @@ class BasicLSTMCell(PrimitiveWithInfer):
         >>> c = Tensor(np.random.rand(1, 2).astype(np.float16))
         >>> w = Tensor(np.random.rand(34, 8).astype(np.float16))
         >>> b = Tensor(np.random.rand(8, ).astype(np.float16))
-        >>> lstm = P.BasicLSTMCell(keep_prob=1.0, forget_bias=1.0, state_is_tuple=True, activation='tanh')
+        >>> lstm = ops.BasicLSTMCell(keep_prob=1.0, forget_bias=1.0, state_is_tuple=True, activation='tanh')
         >>> output = lstm(x, h, c, w, b)
         >>> print(output)
         (Tensor(shape=[1, 2], dtype=Float16, value=
@@ -6288,13 +6287,13 @@ class DynamicRNN(PrimitiveWithInfer):
         >>> import numpy as np
         >>> from mindspore import Parameter
         >>> from mindspore import Tensor
-        >>> from mindspore.ops import operations as P
+        >>> from mindspore.ops import operations as ops
         >>> import mindspore.context as context
         >>> context.set_context(mode=context.GRAPH_MODE)
         >>> class DynamicRNNNet(nn.Cell):
         >>>     def __init__(self):
         >>>         super(DynamicRNNNet, self).__init__()
-        >>>         self.dynamic_rnn = P.DynamicRNN()
+        >>>         self.dynamic_rnn = ops.DynamicRNN()
         >>>
         >>>     def construct(self, x, w, b, init_h, init_c):
         >>>         out = self.dynamic_rnn(x, w, b, None, init_h, init_c)
@@ -6395,7 +6394,7 @@ class InTopK(PrimitiveWithInfer):
     Examples:
         >>> x1 = Tensor(np.array([[1, 8, 5, 2, 7], [4, 9, 1, 3, 5]]), mindspore.float32)
         >>> x2 = Tensor(np.array([1, 3]), mindspore.int32)
-        >>> in_top_k = P.InTopK(3)
+        >>> in_top_k = ops.InTopK(3)
         >>> output = in_top_k(x1, x2)
         >>> print(output)
         [ True  False]
@@ -6442,7 +6441,7 @@ class LRN(PrimitiveWithInfer):
 
     Examples:
         >>> x = Tensor(np.random.rand(1, 2, 2, 2), mindspore.float32)
-        >>> lrn = P.LRN()
+        >>> lrn = ops.LRN()
         >>> output = lrn(x)
         >>> print(output)
         [[[[0.18990143 0.59475636]

mindspore/ops/operations/other_ops.py

@@ -47,7 +47,7 @@ class Assign(PrimitiveWithCheck):
         ...         self.y = mindspore.Parameter(Tensor([1.0], mindspore.float32), name="y")
         ...
         ...     def construct(self, x):
-        ...         P.Assign()(self.y, x)
+        ...         ops.Assign()(self.y, x)
         ...         return self.y
         ...
         >>> x = Tensor([2.0], mindspore.float32)
@@ -85,7 +85,7 @@ class InplaceAssign(PrimitiveWithInfer):
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
-        ...         self.inplace_assign = P.InplaceAssign()
+        ...         self.inplace_assign = ops.InplaceAssign()
         ...
         ...     def construct(self, x):
         ...         val = x - 1.0
@@ -129,7 +129,7 @@ class BoundingBoxEncode(PrimitiveWithInfer):
     Examples:
         >>> anchor_box = Tensor([[4,1,2,1],[2,2,2,3]],mindspore.float32)
         >>> groundtruth_box = Tensor([[3,1,2,2],[1,2,1,4]],mindspore.float32)
-        >>> boundingbox_encode = P.BoundingBoxEncode(means=(0.0, 0.0, 0.0, 0.0), stds=(1.0, 1.0, 1.0, 1.0))
+        >>> boundingbox_encode = ops.BoundingBoxEncode(means=(0.0, 0.0, 0.0, 0.0), stds=(1.0, 1.0, 1.0, 1.0))
         >>> output = boundingbox_encode(anchor_box, groundtruth_box)
         >>> print(output)
         [[ 5.0000000e-01  5.0000000e-01 -6.5504000e+04  6.9335938e-01]
@@ -185,7 +185,7 @@ class BoundingBoxDecode(PrimitiveWithInfer):
     Examples:
         >>> anchor_box = Tensor([[4,1,2,1],[2,2,2,3]],mindspore.float32)
         >>> deltas = Tensor([[3,1,2,2],[1,2,1,4]],mindspore.float32)
-        >>> boundingbox_decode = P.BoundingBoxDecode(means=(0.0, 0.0, 0.0, 0.0), stds=(1.0, 1.0, 1.0, 1.0),
+        >>> boundingbox_decode = ops.BoundingBoxDecode(means=(0.0, 0.0, 0.0, 0.0), stds=(1.0, 1.0, 1.0, 1.0),
         ...                                          max_shape=(768, 1280), wh_ratio_clip=0.016)
         >>> output = boundingbox_decode(anchor_box, deltas)
         >>> print(output)
@@ -245,11 +245,11 @@ class CheckValid(PrimitiveWithInfer):
         >>> import mindspore.nn as nn
         >>> import numpy as np
         >>> from mindspore import Tensor
-        >>> from mindspore.ops import operations as P
+        >>> from mindspore.ops import operations as ops
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
-        ...         self.check_valid = P.CheckValid()
+        ...         self.check_valid = ops.CheckValid()
         ...     def construct(self, x, y):
         ...         valid_result = self.check_valid(x, y)
         ...         return valid_result
@@ -313,7 +313,7 @@ class IOU(PrimitiveWithInfer):
         ``Ascend`` ``GPU``
 
     Examples:
-        >>> iou = P.IOU()
+        >>> iou = ops.IOU()
         >>> anchor_boxes = Tensor(np.random.randint(1.0, 5.0, [3, 4]), mindspore.float16)
         >>> gt_boxes = Tensor(np.random.randint(1.0, 5.0, [3, 4]), mindspore.float16)
         >>> output = iou(anchor_boxes, gt_boxes)
@@ -363,16 +363,16 @@ class MakeRefKey(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> from mindspore.ops import functional as F
+        >>> from mindspore.ops import functional as ops
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
         ...         self.y = mindspore.Parameter(Tensor(np.ones([6, 8, 10]), mindspore.int32), name="y")
-        ...         self.make_ref_key = P.MakeRefKey("y")
+        ...         self.make_ref_key = ops.MakeRefKey("y")
         ...
         ...     def construct(self, x):
         ...         key = self.make_ref_key()
-        ...         ref = F.make_ref(key, x, self.y)
+        ...         ref = ops.make_ref(key, x, self.y)
         ...         return ref * x
         ...
         >>> x = Tensor(np.ones([3, 4, 5]), mindspore.int32)
@@ -451,7 +451,7 @@ class CheckBprop(PrimitiveWithInfer):
     Examples:
         >>> input_x = (Tensor(np.array([[2, 2], [2, 2]]), mindspore.float32),)
         >>> input_y = (Tensor(np.array([[2, 2], [2, 2]]), mindspore.float32),)
-        >>> out = P.CheckBprop()(input_x, input_y)
+        >>> out = ops.CheckBprop()(input_x, input_y)
     """
 
     @prim_attr_register
@@ -519,7 +519,7 @@ class ConfusionMatrix(PrimitiveWithInfer):
         Tensor, the confusion matrix, with shape (`num_classes`, `num_classes`).
 
     Examples:
-        >>> confusion_matrix = P.ConfusionMatrix(4)
+        >>> confusion_matrix = ops.ConfusionMatrix(4)
         >>> labels = Tensor([0, 1, 1, 3], mindspore.int32)
         >>> predictions = Tensor([1, 2, 1, 3], mindspore.int32)
         >>> output = confusion_matrix(labels, predictions)
@@ -567,7 +567,7 @@ class PopulationCount(PrimitiveWithInfer):
         ``Ascend``
 
     Examples:
-        >>> population_count = P.PopulationCount()
+        >>> population_count = ops.PopulationCount()
         >>> x_input = Tensor([0, 1, 3], mindspore.int16)
         >>> output = population_count(x_input)
         >>> print(output)

mindspore/ops/operations/random_ops.py

@@ -39,7 +39,7 @@ class StandardNormal(PrimitiveWithInfer):
 
     Examples:
         >>> shape = (4, 16)
-        >>> stdnormal = P.StandardNormal(seed=2)
+        >>> stdnormal = ops.StandardNormal(seed=2)
         >>> output = stdnormal(shape)
         >>> result = output.shape
         >>> print(result)
@@ -90,7 +90,7 @@ class StandardLaplace(PrimitiveWithInfer):
 
     Examples:
         >>> shape = (4, 16)
-        >>> stdlaplace = P.StandardLaplace(seed=2)
+        >>> stdlaplace = ops.StandardLaplace(seed=2)
         >>> output = stdlaplace(shape)
         >>> result = output.shape
         >>> print(result)
@@ -148,7 +148,7 @@ class Gamma(PrimitiveWithInfer):
         >>> shape = (2, 2)
         >>> alpha = Tensor(1.0, mstype.float32)
         >>> beta = Tensor(1.0, mstype.float32)
-        >>> gamma = P.Gamma(seed=3)
+        >>> gamma = ops.Gamma(seed=3)
         >>> output = gamma(shape, alpha, beta)
         >>> print(output)
         [[0.21962446 0.33740655]
@@ -206,7 +206,7 @@ class Poisson(PrimitiveWithInfer):
     Examples:
         >>> shape = (4, 16)
         >>> mean = Tensor(5.0, mstype.float32)
-        >>> poisson = P.Poisson(seed=5)
+        >>> poisson = ops.Poisson(seed=5)
         >>> output = poisson(shape, mean)
     """
 
@@ -265,7 +265,7 @@ class UniformInt(PrimitiveWithInfer):
         >>> shape = (2, 4)
         >>> minval = Tensor(1, mstype.int32)
         >>> maxval = Tensor(5, mstype.int32)
-        >>> uniform_int = P.UniformInt(seed=10)
+        >>> uniform_int = ops.UniformInt(seed=10)
         >>> output = uniform_int(shape, minval, maxval)
         >>> print(output)
         [[4 2 1 3]
@@ -318,7 +318,7 @@ class UniformReal(PrimitiveWithInfer):
 
     Examples:
         >>> shape = (2, 2)
-        >>> uniformreal = P.UniformReal(seed=2)
+        >>> uniformreal = ops.UniformReal(seed=2)
         >>> output = uniformreal(shape)
         >>> print(output)
         [[0.4359949 0.18508208]
@@ -374,7 +374,7 @@ class RandomChoiceWithMask(PrimitiveWithInfer):
         ``Ascend`` ``GPU``
 
     Examples:
-        >>> rnd_choice_mask = P.RandomChoiceWithMask()
+        >>> rnd_choice_mask = ops.RandomChoiceWithMask()
         >>> input_x = Tensor(np.ones(shape=[240000, 4]).astype(np.bool))
         >>> output_y, output_mask = rnd_choice_mask(input_x)
         >>> result = output_y.shape
@@ -426,7 +426,7 @@ class RandomCategorical(PrimitiveWithInfer):
         >>> class Net(nn.Cell):
         ...   def __init__(self, num_sample):
         ...     super(Net, self).__init__()
-        ...     self.random_categorical = P.RandomCategorical(mindspore.int64)
+        ...     self.random_categorical = ops.RandomCategorical(mindspore.int64)
         ...     self.num_sample = num_sample
         ...   def construct(self, logits, seed=0):
         ...     return self.random_categorical(logits, self.num_sample, seed)
@@ -502,7 +502,7 @@ class Multinomial(PrimitiveWithInfer):
 
     Examples:
         >>> input = Tensor([0., 9., 4., 0.], mstype.float32)
-        >>> multinomial = P.Multinomial(seed=10)
+        >>> multinomial = ops.Multinomial(seed=10)
         >>> output = multinomial(input, 2)
     """
 
@@ -561,7 +561,7 @@ class UniformCandidateSampler(PrimitiveWithInfer):
             each of sampled_candidates. Shape: (num_sampled, ).
 
     Examples:
-        >>> sampler = P.UniformCandidateSampler(1, 3, False, 4)
+        >>> sampler = ops.UniformCandidateSampler(1, 3, False, 4)
         >>> output1, output2, output3 = sampler(Tensor(np.array([[1],[3],[4],[6],[3]], dtype=np.int32)))
         >>> print(output1, output2, output3)
         [1, 1, 3], [[0.75], [0.75], [0.75], [0.75], [0.75]], [0.75, 0.75, 0.75]

mindspore/ops/operations/sparse_ops.py

@@ -38,7 +38,7 @@ class SparseToDense(PrimitiveWithInfer):
         >>> indices = Tensor([[0, 1], [1, 2]])
         >>> values = Tensor([1, 2], dtype=ms.float32)
         >>> dense_shape = (3, 4)
-        >>> out = P.SparseToDense()(indices, values, dense_shape)
+        >>> out = ops.SparseToDense()(indices, values, dense_shape)
     """
 
     @prim_attr_register