From 4a1b4af0ea9bf923e28bb8f90bf400e042138054 Mon Sep 17 00:00:00 2001 From: dinglinhe Date: Sat, 31 Jul 2021 14:58:00 +0800 Subject: [PATCH] update docs for standardization of import information --- mindspore/ops/composite/base.py | 2 +- mindspore/ops/composite/random_ops.py | 4 +- mindspore/ops/operations/_inner_ops.py | 4 +- mindspore/ops/operations/array_ops.py | 2 +- mindspore/ops/operations/comm_ops.py | 12 +- mindspore/ops/operations/nn_ops.py | 171 ++++++++++--------------- mindspore/ops/operations/other_ops.py | 6 +- mindspore/ops/primitive.py | 11 +- 8 files changed, 90 insertions(+), 122 deletions(-) diff --git a/mindspore/ops/composite/base.py b/mindspore/ops/composite/base.py index 150408fdba1..45d28bd5e0d 100644 --- a/mindspore/ops/composite/base.py +++ b/mindspore/ops/composite/base.py @@ -209,7 +209,7 @@ class GradOperation(GradOperation_): ``Ascend`` ``GPU`` ``CPU`` Examples: - >>> from mindspore.common import ParameterTuple + >>> from mindspore import ParameterTuple >>> class Net(nn.Cell): ... def __init__(self): ... super(Net, self).__init__() diff --git a/mindspore/ops/composite/random_ops.py b/mindspore/ops/composite/random_ops.py index 93b874fdfce..2d29a362c36 100644 --- a/mindspore/ops/composite/random_ops.py +++ b/mindspore/ops/composite/random_ops.py @@ -110,9 +110,9 @@ def laplace(shape, mean, lambda_param, seed=None): ``Ascend`` Examples: + >>> import mindspore >>> from mindspore import Tensor - >>> from mindspore.ops import composite as C - >>> import mindspore.common.dtype as mindspore + >>> from mindspore import ops as ops >>> shape = (2, 3) >>> mean = Tensor(1.0, mindspore.float32) >>> lambda_param = Tensor(1.0, mindspore.float32) diff --git a/mindspore/ops/operations/_inner_ops.py b/mindspore/ops/operations/_inner_ops.py index ab2a1609cdd..07acdef27f4 100755 --- a/mindspore/ops/operations/_inner_ops.py +++ b/mindspore/ops/operations/_inner_ops.py @@ -395,7 +395,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 ops + >>> import mindspore.ops as ops >>> import mindspore.nn as nn >>> from mindspore.communication import init >>> from mindspore import Tensor @@ -452,7 +452,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 ops + >>> import mindspore.ops as ops >>> import mindspore.nn as nn >>> from mindspore.communication import init >>> from mindspore import Tensor diff --git a/mindspore/ops/operations/array_ops.py b/mindspore/ops/operations/array_ops.py index 81282df727d..ae362fbddfe 100755 --- a/mindspore/ops/operations/array_ops.py +++ b/mindspore/ops/operations/array_ops.py @@ -5518,7 +5518,7 @@ class EditDistance(PrimitiveWithInfer): >>> from mindspore import context >>> from mindspore import Tensor >>> import mindspore.nn as nn - >>> import mindspore.ops.operations as ops + >>> import mindspore.ops as ops >>> class EditDistance(nn.Cell): ... def __init__(self, hypothesis_shape, truth_shape, normalize=True): ... super(EditDistance, self).__init__() diff --git a/mindspore/ops/operations/comm_ops.py b/mindspore/ops/operations/comm_ops.py index 4af07a3abe5..19826bd2263 100644 --- a/mindspore/ops/operations/comm_ops.py +++ b/mindspore/ops/operations/comm_ops.py @@ -88,9 +88,9 @@ class AllReduce(PrimitiveWithInfer): >>> import numpy as np >>> from mindspore.communication import init >>> from mindspore import Tensor - >>> from mindspore.ops.operations.comm_ops import ReduceOp + >>> from mindspore.ops import ReduceOp >>> import mindspore.nn as nn - >>> import mindspore.ops.operations as ops + >>> import mindspore.ops as ops >>> >>> init() >>> class Net(nn.Cell): @@ -158,7 +158,7 @@ class AllGather(PrimitiveWithInfer): Examples: >>> # This example should be run with two devices. Refer to the tutorial > Distributed Training on mindspore.cn >>> import numpy as np - >>> import mindspore.ops.operations as ops + >>> import mindspore.ops as ops >>> import mindspore.nn as nn >>> from mindspore.communication import init >>> from mindspore import Tensor, context @@ -348,9 +348,9 @@ class ReduceScatter(PrimitiveWithInfer): >>> # This example should be run with two devices. Refer to the tutorial > Distributed Training on mindspore.cn >>> from mindspore import Tensor, context >>> from mindspore.communication import init - >>> from mindspore.ops.operations.comm_ops import ReduceOp + >>> from mindspore.ops import ReduceOp >>> import mindspore.nn as nn - >>> import mindspore.ops.operations as ops + >>> import mindspore.ops as ops >>> import numpy as np >>> >>> context.set_context(mode=context.GRAPH_MODE) @@ -482,7 +482,7 @@ class Broadcast(PrimitiveWithInfer): >>> from mindspore import context >>> from mindspore.communication import init >>> import mindspore.nn as nn - >>> import mindspore.ops.operations as ops + >>> import mindspore.ops as ops >>> import numpy as np >>> >>> context.set_context(mode=context.GRAPH_MODE) diff --git a/mindspore/ops/operations/nn_ops.py b/mindspore/ops/operations/nn_ops.py index f98bf0e6f37..49be3591e0f 100755 --- a/mindspore/ops/operations/nn_ops.py +++ b/mindspore/ops/operations/nn_ops.py @@ -831,7 +831,7 @@ class HSigmoid(Primitive): Examples: >>> hsigmoid = ops.HSigmoid() - >>> input_x = Tensor(np.array([-1, -2, 0, 2, 1]), mstype.float16) + >>> input_x = Tensor(np.array([-1, -2, 0, 2, 1]), mindspore.float16) >>> result = hsigmoid(input_x) >>> print(result) [0.3333 0.1666 0.5 0.8335 0.6665] @@ -2043,15 +2043,14 @@ class Conv2DBackpropInput(Primitive): Examples: >>> import numpy as np + >>> import mindspore >>> from mindspore import Tensor - >>> from mindspore.common import dtype as mstype - >>> import mindspore.ops.functional as F >>> import mindspore.ops as ops - >>> dout = Tensor(np.ones([10, 32, 30, 30]), mstype.float32) - >>> weight = Tensor(np.ones([32, 32, 3, 3]), mstype.float32) + >>> dout = Tensor(np.ones([10, 32, 30, 30]), mindspore.float32) + >>> weight = Tensor(np.ones([32, 32, 3, 3]), mindspore.float32) >>> input_x = Tensor(np.ones([10, 32, 32, 32])) >>> conv2d_backprop_input = ops.Conv2DBackpropInput(out_channel=32, kernel_size=3) - >>> output = conv2d_backprop_input(dout, weight, F.shape(input_x)) + >>> output = conv2d_backprop_input(dout, weight, ops.shape(input_x)) >>> print(output.shape) (10, 32, 32, 32) """ @@ -2161,7 +2160,7 @@ class Conv2DTranspose(Conv2DBackpropInput): >>> weight = Tensor(np.ones([32, 32, 3, 3]), mindspore.float32) >>> x = Tensor(np.ones([10, 32, 32, 32])) >>> conv2d_transpose_input = ops.Conv2DTranspose(out_channel=32, kernel_size=3) - >>> output = conv2d_transpose_input(dout, weight, F.shape(x)) + >>> output = conv2d_transpose_input(dout, weight, ops.shape(x)) >>> print(output.shape) (10, 32, 32, 32) """ @@ -2203,8 +2202,8 @@ class BiasAdd(Primitive): ``Ascend`` ``GPU`` ``CPU`` Examples: - >>> input_x = Tensor(np.arange(6).reshape((2, 3)), mstype.float32) - >>> bias = Tensor(np.random.random(3).reshape((3,)), mstype.float32) + >>> input_x = Tensor(np.arange(6).reshape((2, 3)), mindspore.float32) + >>> bias = Tensor(np.random.random(3).reshape((3,)), mindspore.float32) >>> bias_add = ops.BiasAdd() >>> output = bias_add(input_x, bias) >>> print(output.shape) @@ -4600,10 +4599,8 @@ class FusedSparseAdam(PrimitiveWithInfer): Examples: >>> import numpy as np - >>> import mindspore.nn as nn - >>> from mindspore import Tensor, Parameter - >>> from mindspore.ops import operations as ops - >>> import mindspore.common.dtype as mstype + >>> import mindspore + >>> from mindspore import Tensor, Parameter, nn, ops >>> class Net(nn.Cell): ... def __init__(self): ... super(Net, self).__init__() @@ -4617,14 +4614,14 @@ class FusedSparseAdam(PrimitiveWithInfer): ... return out ... >>> net = Net() - >>> beta1_power = Tensor(0.9, mstype.float32) - >>> beta2_power = Tensor(0.999, mstype.float32) - >>> lr = Tensor(0.001, mstype.float32) - >>> beta1 = Tensor(0.9, mstype.float32) - >>> beta2 = Tensor(0.999, mstype.float32) - >>> epsilon = Tensor(1e-8, mstype.float32) - >>> gradient = Tensor(np.random.rand(2, 1, 2), mstype.float32) - >>> indices = Tensor([0, 1], mstype.int32) + >>> beta1_power = Tensor(0.9, mindspore.float32) + >>> beta2_power = Tensor(0.999, mindspore.float32) + >>> lr = Tensor(0.001, mindspore.float32) + >>> beta1 = Tensor(0.9, mindspore.float32) + >>> beta2 = Tensor(0.999, mindspore.float32) + >>> epsilon = Tensor(1e-8, mindspore.float32) + >>> gradient = Tensor(np.random.rand(2, 1, 2), mindspore.float32) + >>> indices = Tensor([0, 1], mindspore.int32) >>> output = net(beta1_power, beta2_power, lr, beta1, beta2, epsilon, gradient, indices) >>> print(net.var.asnumpy()) [[[0.9996963 0.9996977 ]] @@ -4749,10 +4746,8 @@ class FusedSparseLazyAdam(PrimitiveWithInfer): Examples: >>> import numpy as np - >>> import mindspore.nn as nn - >>> from mindspore import Tensor, Parameter - >>> from mindspore.ops import operations as ops - >>> import mindspore.common.dtype as mstype + >>> import mindspore + >>> from mindspore import Tensor, Parameter, nn, ops >>> class Net(nn.Cell): ... def __init__(self): ... super(Net, self).__init__() @@ -4766,14 +4761,14 @@ class FusedSparseLazyAdam(PrimitiveWithInfer): ... return out ... >>> net = Net() - >>> beta1_power = Tensor(0.9, mstype.float32) - >>> beta2_power = Tensor(0.999, mstype.float32) - >>> lr = Tensor(0.001, mstype.float32) - >>> beta1 = Tensor(0.9, mstype.float32) - >>> beta2 = Tensor(0.999, mstype.float32) - >>> epsilon = Tensor(1e-8, mstype.float32) - >>> gradient = Tensor(np.random.rand(2, 1, 2), mstype.float32) - >>> indices = Tensor([0, 1], mstype.int32) + >>> beta1_power = Tensor(0.9, mindspore.float32) + >>> beta2_power = Tensor(0.999, mindspore.float32) + >>> lr = Tensor(0.001, mindspore.float32) + >>> beta1 = Tensor(0.9, mindspore.float32) + >>> beta2 = Tensor(0.999, mindspore.float32) + >>> epsilon = Tensor(1e-8, mindspore.float32) + >>> gradient = Tensor(np.random.rand(2, 1, 2), mindspore.float32) + >>> indices = Tensor([0, 1], mindspore.int32) >>> output = net(beta1_power, beta2_power, lr, beta1, beta2, epsilon, gradient, indices) >>> print(net.var.asnumpy()) [[[0.9996866 0.9997078]] @@ -4989,19 +4984,17 @@ class FusedSparseProximalAdagrad(PrimitiveWithInfer): Examples: >>> import numpy as np - >>> import mindspore.nn as nn - >>> import mindspore.common.dtype as mstype - >>> from mindspore import Tensor, Parameter - >>> from mindspore.ops import operations as ops + >>> import mindspore + >>> from mindspore import Tensor, Parameter, nn, ops >>> class Net(nn.Cell): ... def __init__(self): ... super(Net, self).__init__() ... 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) - ... self.l1 = Tensor(0.0, mstype.float32) - ... self.l2 = Tensor(0.0, mstype.float32) + ... self.lr = Tensor(0.01, mindspore.float32) + ... self.l1 = Tensor(0.0, mindspore.float32) + ... self.l2 = Tensor(0.0, mindspore.float32) ... def construct(self, grad, indices): ... out = self.sparse_apply_proximal_adagrad(self.var, self.accum, self.lr, self.l1, ... self.l2, grad, indices) @@ -5292,11 +5285,8 @@ class ApplyAdaMax(PrimitiveWithInfer): Examples: >>> import numpy as np - >>> import mindspore.nn as nn - >>> from mindspore import Tensor - >>> from mindspore import Parameter - >>> from mindspore.ops import operations as ops - >>> import mindspore.common.dtype as mstype + >>> import mindspore + >>> from mindspore import Tensor, Parameter, nn, ops >>> class Net(nn.Cell): ... def __init__(self): ... super(Net, self).__init__() @@ -5312,11 +5302,11 @@ class ApplyAdaMax(PrimitiveWithInfer): ... return out ... >>> net = Net() - >>> beta1_power =Tensor(0.9, mstype.float32) - >>> lr = Tensor(0.001, mstype.float32) - >>> beta1 = Tensor(0.9, mstype.float32) - >>> beta2 = Tensor(0.99, mstype.float32) - >>> epsilon = Tensor(1e-10, mstype.float32) + >>> beta1_power =Tensor(0.9, mindspore.float32) + >>> lr = Tensor(0.001, mindspore.float32) + >>> beta1 = Tensor(0.9, mindspore.float32) + >>> beta2 = Tensor(0.99, mindspore.float32) + >>> epsilon = Tensor(1e-10, mindspore.float32) >>> grad = Tensor(np.array([[0.3, 0.7], [0.1, 0.8]]).astype(np.float32)) >>> output = net(beta1_power, lr, beta1, beta2, epsilon, grad) >>> print(output) @@ -5434,11 +5424,8 @@ class ApplyAdadelta(PrimitiveWithInfer): Examples: >>> import numpy as np - >>> import mindspore.nn as nn - >>> from mindspore import Tensor - >>> from mindspore import Parameter - >>> from mindspore.ops import operations as ops - >>> import mindspore.common.dtype as mstype + >>> import mindspore + >>> from mindspore import Tensor, Parameter, nn, ops >>> class Net(nn.Cell): ... def __init__(self): ... super(Net, self).__init__() @@ -5455,9 +5442,9 @@ class ApplyAdadelta(PrimitiveWithInfer): ... return out ... >>> net = Net() - >>> lr = Tensor(0.001, mstype.float32) - >>> rho = Tensor(0.0, mstype.float32) - >>> epsilon = Tensor(1e-6, mstype.float32) + >>> lr = Tensor(0.001, mindspore.float32) + >>> rho = Tensor(0.0, mindspore.float32) + >>> epsilon = Tensor(1e-6, mindspore.float32) >>> grad = Tensor(np.array([[0.3, 0.7], [0.1, 0.8]]).astype(np.float32)) >>> output = net(lr, rho, epsilon, grad) >>> print(output) @@ -5556,11 +5543,8 @@ class ApplyAdagrad(PrimitiveWithInfer): Examples: >>> import numpy as np - >>> import mindspore.nn as nn - >>> from mindspore import Tensor - >>> from mindspore import Parameter - >>> from mindspore.ops import operations as ops - >>> import mindspore.common.dtype as mstype + >>> import mindspore + >>> from mindspore import Tensor, Parameter, nn, ops >>> class Net(nn.Cell): ... def __init__(self): ... super(Net, self).__init__() @@ -5574,7 +5558,7 @@ class ApplyAdagrad(PrimitiveWithInfer): ... return out ... >>> net = Net() - >>> lr = Tensor(0.001, mstype.float32) + >>> lr = Tensor(0.001, mindspore.float32) >>> grad = Tensor(np.array([[0.3, 0.7], [0.1, 0.8]]).astype(np.float32)) >>> output = net(lr, grad) >>> print(output) @@ -5661,11 +5645,8 @@ class ApplyAdagradV2(PrimitiveWithInfer): Examples: >>> import numpy as np - >>> import mindspore.nn as nn - >>> from mindspore import Tensor - >>> from mindspore import Parameter - >>> from mindspore.ops import operations as ops - >>> import mindspore.common.dtype as mstype + >>> import mindspore + >>> from mindspore import Tensor, Parameter, nn, ops >>> class Net(nn.Cell): ... def __init__(self): ... super(Net, self).__init__() @@ -5679,7 +5660,7 @@ class ApplyAdagradV2(PrimitiveWithInfer): ... return out ... >>> net = Net() - >>> lr = Tensor(0.001, mstype.float32) + >>> lr = Tensor(0.001, mindspore.float32) >>> grad = Tensor(np.array([[0.3, 0.7], [0.1, 0.8]]).astype(np.float32)) >>> output = net(lr, grad) >>> print(output) @@ -5767,11 +5748,8 @@ class SparseApplyAdagrad(PrimitiveWithInfer): Examples: >>> import numpy as np - >>> import mindspore.nn as nn - >>> from mindspore import Tensor - >>> from mindspore import Parameter - >>> from mindspore.ops import operations as ops - >>> import mindspore.common.dtype as mstype + >>> import mindspore + >>> from mindspore import Tensor, Parameter, nn, ops >>> class Net(nn.Cell): ... def __init__(self): ... super(Net, self).__init__() @@ -5784,7 +5762,7 @@ class SparseApplyAdagrad(PrimitiveWithInfer): ... >>> net = Net() >>> grad = Tensor(np.array([[[0.7]]]).astype(np.float32)) - >>> indices = Tensor([0], mstype.int32) + >>> indices = Tensor([0], mindspore.int32) >>> output = net(grad, indices) >>> print(output) (Tensor(shape=[1, 1, 1], dtype=Float32, value= @@ -5871,11 +5849,8 @@ class SparseApplyAdagradV2(PrimitiveWithInfer): Examples: >>> import numpy as np - >>> import mindspore.nn as nn - >>> from mindspore import Tensor - >>> from mindspore import Parameter - >>> from mindspore.ops import operations as ops - >>> import mindspore.common.dtype as mstype + >>> import mindspore + >>> from mindspore import Tensor, Parameter, nn, ops >>> class Net(nn.Cell): ... def __init__(self): ... super(Net, self).__init__() @@ -5889,7 +5864,7 @@ class SparseApplyAdagradV2(PrimitiveWithInfer): ... >>> net = Net() >>> grad = Tensor(np.array([[0.7]]).astype(np.float32)) - >>> indices = Tensor(np.ones([1]), mstype.int32) + >>> indices = Tensor(np.ones([1]), mindspore.int32) >>> output = net(grad, indices) >>> print(output) (Tensor(shape=[1, 1], dtype=Float32, value= @@ -8054,11 +8029,10 @@ class Conv3D(PrimitiveWithInfer): Examples: >>> import numpy as np - >>> from mindspore import Tensor - >>> from mindspore.common import dtype as mstype - >>> import mindspore.ops as ops - >>> input_tensor = Tensor(np.ones([16, 3, 10, 32, 32]), mstype.float16) - >>> weight = Tensor(np.ones([32, 3, 4, 3, 3]), mstype.float16) + >>> import mindspore + >>> from mindspore import Tensor, ops + >>> input_tensor = Tensor(np.ones([16, 3, 10, 32, 32]), mindspore.float16) + >>> weight = Tensor(np.ones([32, 3, 4, 3, 3]), mindspore.float16) >>> conv3d = ops.Conv3D(out_channel=32, kernel_size=(4, 3, 3)) >>> output = conv3d(input_tensor, weight) >>> print(output.shape) @@ -8242,15 +8216,13 @@ class Conv3DBackpropInput(PrimitiveWithInfer): Examples: >>> import numpy as np - >>> from mindspore import Tensor - >>> from mindspore.common import dtype as mstype - >>> import mindspore.ops.functional as F - >>> import mindspore.ops as ops - >>> dout = Tensor(np.ones([16, 32, 10, 32, 32]), mstype.float16) - >>> weight = Tensor(np.ones([32, 32, 4, 6, 2]), mstype.float16) + >>> import mindspore + >>> from mindspore import Tensor, ops + >>> dout = Tensor(np.ones([16, 32, 10, 32, 32]), mindspore.float16) + >>> weight = Tensor(np.ones([32, 32, 4, 6, 2]), mindspore.float16) >>> x = Tensor(np.ones([16, 32, 13, 37, 33])) >>> conv3d_backprop_input = ops.Conv3DBackpropInput(out_channel=4, kernel_size=(4, 6, 2)) - >>> output = conv3d_backprop_input(dout, weight, F.shape(x)) + >>> output = conv3d_backprop_input(dout, weight, ops.shape(x)) >>> print(output.shape) (16, 32, 13, 37, 33) """ @@ -8539,11 +8511,10 @@ class Conv3DTranspose(PrimitiveWithInfer): Examples: >>> import numpy as np - >>> from mindspore import Tensor - >>> from mindspore.common import dtype as mstype - >>> import mindspore.ops as ops - >>> input_x = Tensor(np.ones([32, 16, 10, 32, 32]), mstype.float16) - >>> weight = Tensor(np.ones([16, 3, 4, 6, 2]), mstype.float16) + >>> import mindspore + >>> from mindspore import Tensor, ops + >>> input_x = Tensor(np.ones([32, 16, 10, 32, 32]), mindspore.float16) + >>> weight = Tensor(np.ones([16, 3, 4, 6, 2]), mindspore.float16) >>> conv3d_transpose = ops.Conv3DTranspose(in_channel=16, out_channel=3, kernel_size=(4, 6, 2)) >>> output = conv3d_transpose(input_x, weight) >>> print(output.shape) @@ -8715,7 +8686,7 @@ class SoftShrink(Primitive): ``Ascend`` Examples: - >>> input_x = Tensor(np.array([[ 0.5297, 0.7871, 1.1754], [ 0.7836, 0.6218, -1.1542]]), mstype.float16) + >>> input_x = Tensor(np.array([[ 0.5297, 0.7871, 1.1754], [ 0.7836, 0.6218, -1.1542]]), mindspore.float16) >>> softshrink = ops.SoftShrink() >>> output = softshrink(input_x) >>> print(output) diff --git a/mindspore/ops/operations/other_ops.py b/mindspore/ops/operations/other_ops.py index 0d3277ced8c..9c44f386a09 100644 --- a/mindspore/ops/operations/other_ops.py +++ b/mindspore/ops/operations/other_ops.py @@ -444,13 +444,13 @@ class Depend(Primitive): >>> import numpy as np >>> import mindspore >>> import mindspore.nn as nn - >>> import mindspore.ops.operations as P + >>> import mindspore.ops as ops >>> from mindspore import Tensor >>> class Net(nn.Cell): ... def __init__(self): ... super(Net, self).__init__() - ... self.softmax = P.Softmax() - ... self.depend = P.Depend() + ... self.softmax = ops.Softmax() + ... self.depend = ops.Depend() ... ... def construct(self, x, y): ... mul = x * y diff --git a/mindspore/ops/primitive.py b/mindspore/ops/primitive.py index 289c98fd27c..b47752b753e 100644 --- a/mindspore/ops/primitive.py +++ b/mindspore/ops/primitive.py @@ -303,17 +303,14 @@ class Primitive(Primitive_): Args: mode (bool): Specifies whether the primitive is recomputed. Default: True. Examples: - >>> import mindspore as ms - >>> from mindspore.common.tensor import Tensor - >>> import mindspore.ops as ops - >>> import mindspore.ops.operator as P - >>> import mindspore.nn as nn >>> import numpy as np + >>> import mindspore as ms + >>> from mindspore import Tensor, ops, nn >>> class NetRecompute(nn.Cell): ... def __init__(self): ... super(NetRecompute,self).__init__() - ... self.relu = P.ReLU().recompute() - ... self.sqrt = P.Sqrt() + ... self.relu = ops.ReLU().recompute() + ... self.sqrt = ops.Sqrt() ... def construct(self, x): ... out = self.relu(x) ... return self.sqrt(out)