ShiyuW
/
mindspore2022
forked from huawei/mindspore2022
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

update docs for standardization of import information

This commit is contained in:
dinglinhe 2021-07-31 14:58:00 +08:00
parent 335210b160
commit 4a1b4af0ea
8 changed files with 90 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
mindspore/ops/composite/base.py
View File

@ -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__()

4
mindspore/ops/composite/random_ops.py
View File

@ -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)

4
mindspore/ops/operations/_inner_ops.py
View File

@ -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

2
mindspore/ops/operations/array_ops.py
View File

@ -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__()

12
mindspore/ops/operations/comm_ops.py
View File

@ -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)

171
mindspore/ops/operations/nn_ops.py
View File

@ -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)

6
mindspore/ops/operations/other_ops.py
View File

@ -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

11
mindspore/ops/primitive.py
View File

@ -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)