From 3cc750fdce151d765d13d1715a71bb2ff96b5aa3 Mon Sep 17 00:00:00 2001 From: zhouneng Date: Fri, 15 May 2020 17:25:21 +0800 Subject: [PATCH] =?UTF-8?q?=E4=B8=BAmindspore.ops.operations=E5=8C=85?= =?UTF-8?q?=E5=92=8Cmindspore.nn=E5=8C=85=E6=B7=BB=E5=8A=A0Examples?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- mindspore/nn/layer/quant.py | 41 ++++++ mindspore/ops/operations/_quant_ops.py | 100 +++++++++++-- mindspore/ops/operations/array_ops.py | 10 ++ mindspore/ops/operations/control_ops.py | 6 + mindspore/ops/operations/math_ops.py | 32 +++++ mindspore/ops/operations/nn_ops.py | 177 +++++++++++++++++++++++- mindspore/ops/operations/other_ops.py | 20 +++ 7 files changed, 375 insertions(+), 11 deletions(-) diff --git a/mindspore/nn/layer/quant.py b/mindspore/nn/layer/quant.py index fe1c0e9f45..911e10f4e0 100644 --- a/mindspore/nn/layer/quant.py +++ b/mindspore/nn/layer/quant.py @@ -62,6 +62,10 @@ class FakeQuantWithMinMax(Cell): Outputs: Tensor, with the same type and shape as the `x`. + Examples: + >>> fake_quant = nn.FakeQuantWithMinMax() + >>> input_x = Tensor(np.array([[1, 2, 1], [-2, 0, -1]]), mindspore.float32) + >>> result = fake_quant(input_x) """ def __init__(self, @@ -182,6 +186,12 @@ class Conv2dBatchNormQuant(Cell): Outputs: Tensor of shape :math:`(N, C_{out}, H_{out}, W_{out})`. + + Examples: + >>> batchnorm_quant = nn.Conv2dBatchNormQuant(1, 6, kernel_size= (2, 2), stride=(1, 1), pad_mode="valid", + >>> dilation=(1, 1)) + >>> input_x = Tensor(np.random.randint(-2, 2, (2, 1, 1, 3)), mindspore.float32) + >>> result = batchnorm_quant(input_x) """ def __init__(self, @@ -339,6 +349,11 @@ class Conv2dQuant(_Conv): Outputs: Tensor of shape :math:`(N, C_{out}, H_{out}, W_{out})`. + Examples: + >>> conv2d_quant = nn.Conv2dQuant(1, 6, kernel_size= (2, 2), stride=(1, 1), pad_mode="valid", + >>> dilation=(1, 1)) + >>> input_x = Tensor(np.random.randint(-2, 2, (2, 1, 1, 3)), mindspore.float32) + >>> result = conv2d_quant(input_x) """ def __init__(self, @@ -412,6 +427,11 @@ class DenseQuant(Cell): Outputs: Tensor of shape :math:`(N, C_{out}, H_{out}, W_{out})`. + + Examples: + >>> dense_quant = nn.DenseQuant(3, 6) + >>> input_x = Tensor(np.random.randint(-2, 2, (2, 3)), mindspore.float32) + >>> result = dense_quant(input_x) """ def __init__( @@ -503,6 +523,10 @@ class ReLUQuant(Cell): Outputs: Tensor, with the same type and shape as the `x`. + Examples: + >>> relu_quant = nn.ReLUQuant() + >>> input_x = Tensor(np.array([[1, 2, 0], [-1, -2, 1]]), mindspore.float32) + >>> result = relu_quant(input_x) """ def __init__(self, @@ -546,6 +570,10 @@ class ReLU6Quant(Cell): Outputs: Tensor, with the same type and shape as the `x`. + Examples: + >>> relu6_quant = nn.ReLU6Quant(4, 1) + >>> input_x = Tensor(np.array([[1, 2, -1], [-2, 0, -1]]), mindspore.float32) + >>> result = relu6_quant(input_x) """ def __init__(self, num_bits=8, quant_delay=0, symmetric=False, @@ -584,6 +612,10 @@ class HSwishQuant(Cell): Outputs: Tensor, with the same type and shape as the `x`. + Examples: + >>> hswish_quant = nn.HSwishQuant(4, 1) + >>> input_x = Tensor(np.array([[1, 2, 1], [-2, 0, -1]]), mindspore.float32) + >>> result = hswish_quant(input_x) """ def __init__(self, @@ -633,6 +665,10 @@ class HSigmoidQuant(Cell): Outputs: Tensor, with the same type and shape as the `x`. + Examples: + >>> hsigmoid_quant = nn.HSigmoidQuant(4, 1) + >>> input_x = Tensor(np.array([[1, 2, 1], [-2, 0, -1]]), mindspore.float32) + >>> result = hsigmoid_quant(input_x) """ def __init__(self, @@ -682,6 +718,11 @@ class TensorAddQuant(Cell): Outputs: Tensor, with the same type and shape as the `x`. + Examples: + >>> add_quant = nn.TensorAddQuant() + >>> input_x = Tensor(np.array([[1, 2, 1], [-2, 0, -1]]), mindspore.float32) + >>> input_y = Tensor(np.random.randint(-2, 2, (2, 3)), mindspore.float32) + >>> result = add_quant(input_x, input_y) """ def __init__(self, diff --git a/mindspore/ops/operations/_quant_ops.py b/mindspore/ops/operations/_quant_ops.py index 2d07549fd0..9bc55d7ed1 100644 --- a/mindspore/ops/operations/_quant_ops.py +++ b/mindspore/ops/operations/_quant_ops.py @@ -98,7 +98,17 @@ class FakeQuantWithMinMax(PrimitiveWithInfer): class FakeQuantWithMinMaxGrad(PrimitiveWithInfer): - """Performs grad of FakeQuantWithMinMax operation.""" + r""" + Performs grad of FakeQuantWithMinMax operation. + + Examples: + >>> fake_min_max_grad = P.FakeQuantWithMinMaxGrad() + >>> dout = Tensor(np.array([[-2.3, 1.2], [5.7, 0.2]]), mindspore.float32) + >>> input_x = Tensor(np.array([[18, -23], [0.2, 6]]), mindspore.float32) + >>> _min = Tensor(np.array([-4]), mindspore.float32) + >>> _max = Tensor(np.array([2]), mindspore.float32) + >>> result = fake_min_max_grad(dout, input_x, _min, _max) + """ support_quant_bit = [4, 8] @prim_attr_register @@ -149,10 +159,11 @@ class FakeQuantWithMinMaxPerChannel(PrimitiveWithInfer): - Tensor, has the same type as input. Examples: - >>> input_tensor = Tensor(np.random.rand(3,4,5,5), mstype.float32) - >>> min_tensor = Tensor(np.array([-6.0, -6.5, -4.0, -5.0]), mstype.float32) - >>> max_tensor = Tensor(np.array([6.0, 6.5, 4.0, 5.0]), mstype.float32) - >>> output_tensor = P.FakeQuantWithMinMax(num_bits=8)(input_tensor, min_tensor, max_tensor) + >>> fake_quant = P.FakeQuantWithMinMaxPerChannel() + >>> input_x = Tensor(np.array([3, 4, 5, -2, -3, -1]).reshape(3, 2), mindspore.float32) + >>> _min = Tensor(np.linspace(-2, 2, 12).reshape(3, 2, 2), mindspore.float32) + >>> _max = Tensor(np.linspace(8, 12, 12).reshape(3, 2, 2), mindspore.float32) + >>> result = fake_quant(input_x, _min, _max) """ support_quant_bit = [4, 8] channel_idx = 0 @@ -190,7 +201,17 @@ class FakeQuantWithMinMaxPerChannel(PrimitiveWithInfer): class FakeQuantWithMinMaxPerChannelGrad(PrimitiveWithInfer): - """Performs grad of FakeQuantWithMinMaxPerChannel operation.""" + r""" + Performs grad of FakeQuantWithMinMaxPerChannel operation. + + Examples: + >>> fqmmpc_grad = P.FakeQuantWithMinMaxPerChannelGrad() + >>> input_x = Tensor(np.random.randint(-4, 4, (2, 3, 4)), mindspore.float32) + >>> dout = Tensor(np.random.randint(-2, 2, (2, 3, 4)), mindspore.float32) + >>> _min = Tensor(np.random.randint(-8, 2, (2, 3, 4)), mindspore.float32) + >>> _max = Tensor(np.random.randint(-2, 8, (2, 3, 4)), mindspore.float32) + >>> result = fqmmpc_grad(dout, input_x, _min, _max) + """ support_quant_bit = [4, 8] @prim_attr_register @@ -243,6 +264,13 @@ class BatchNormFold(PrimitiveWithInfer): - **running_mean** (Tensor) - Tensor of shape :math:`(C,)`. - **running_std** (Tensor) - Tensor of shape :math:`(C,)`. + Examples: + >>> batch_norm_fold = P.BatchNormFold() + >>> input_x = Tensor(np.array([1, 2, -1, -2, -2, 1]).reshape(2, 3), mindspore.float32) + >>> mean = Tensor(np.array([0.5, -1, 1,]), mindspore.float32) + >>> variance = Tensor(np.array([0.36, 0.4, 0.49]), mindspore.float32) + >>> global_step = Tensor(np.arange(6), mindspore.int32) + >>> batch_mean, batch_std, running_mean, running_std = batch_norm_fold(input_x, mean, variance, global_step) """ channel = 1 @@ -273,7 +301,19 @@ class BatchNormFold(PrimitiveWithInfer): class BatchNormFoldGrad(PrimitiveWithInfer): - """Performs grad of BatchNormFold operation.""" + r""" + Performs grad of BatchNormFold operation. + + Examples: + >>> batch_norm_fold_grad = P.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) + >>> batch_mean = Tensor(np.random.randint(-8., 8., (1, 2, 2, 3)), mindspore.float32) + >>> batch_std = Tensor(np.random.randint(0, 12, (1, 2, 2, 3)), mindspore.float32) + >>> global_step = Tensor([2], mindspore.int32) + >>> result = batch_norm_fold_grad(d_batch_mean, d_batch_std, input_x, batch_mean, batch_std, global_step) + """ channel = 1 @prim_attr_register @@ -321,6 +361,12 @@ class CorrectionMul(PrimitiveWithInfer): Outputs: - **out** (Tensor) - Tensor has the same shape as x. + Examples: + >>> correction_mul = P.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) + >>> out = correction_mul(input_x, batch_std, running_std) """ channel = 0 @@ -343,7 +389,17 @@ class CorrectionMul(PrimitiveWithInfer): class CorrectionMulGrad(PrimitiveWithInfer): - """Performs grad of CorrectionMul operation.""" + r""" + Performs grad of CorrectionMul operation. + + Examples: + >>> correction_mul_grad = P.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) + >>> running_std = Tensor(np.array([1.2, 0.1, 0.7, 2.3]).reshape(2, 1, 2), mindspore.float32) + >>> result = correction_mul_grad(dout, input_x, gamma, running_std) + """ channel = 0 @prim_attr_register @@ -385,6 +441,18 @@ class BatchNormFold2(PrimitiveWithInfer): Outputs: - **y** (Tensor) - Tensor has the same shape as x. + Examples: + >>> batch_norm_fold2 = P.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) + >>> batch_std = Tensor(np.array([0.1, 0.2, 0.1]), mindspore.float32) + >>> batch_mean = Tensor(np.array([0, 0.05, 0.2]), mindspore.float32) + >>> running_std = Tensor(np.array([0.1, 0.1, 0.3]), mindspore.float32) + >>> running_mean = Tensor(np.array([-0.1, 0, -0.1]), mindspore.float32) + >>> global_step = Tensor(np.random.randint(1, 8, (8, )), mindspore.int32) + >>> result = batch_norm_fold2(input_x, beta, gamma, batch_std, batch_mean, + >>> running_std, running_mean, global_step) """ channel = 1 @@ -418,7 +486,21 @@ class BatchNormFold2(PrimitiveWithInfer): class BatchNormFold2Grad(PrimitiveWithInfer): - """Performs grad of CorrectionAddGrad operation.""" + r""" + Performs grad of CorrectionAddGrad operation. + + Examples: + >>> bnf2_grad = P.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) + >>> batch_std = Tensor(np.random.randint(0, 8, (3, 1, 1, 2)), mindspore.float32) + >>> batch_mean = Tensor(np.random.randint(-6, 6, (3, 1, 1, 2)), mindspore.float32) + >>> running_std = Tensor(np.linspace(0, 2, 6).reshape(3, 1, 1, 2), mindspore.float32) + >>> running_mean = Tensor(np.random.randint(-3, 3, (3, 1, 1, 2)), mindspore.float32) + >>> global_step = Tensor(np.array([-2]), mindspore.int32) + >>> result = bnf2_grad(dout, input_x, gamma, batch_std, batch_mean, running_std, running_mean, global_step) + """ channel = 1 @prim_attr_register diff --git a/mindspore/ops/operations/array_ops.py b/mindspore/ops/operations/array_ops.py index fbaf6bb2d5..6226477fc5 100644 --- a/mindspore/ops/operations/array_ops.py +++ b/mindspore/ops/operations/array_ops.py @@ -1156,6 +1156,16 @@ class Tile(PrimitiveWithInfer): Such as set the shape of `input_x` as :math:`(1, ..., x_1, x_2, ..., x_S)`, then the shape of their corresponding positions can be multiplied, and the shape of Outputs is :math:`(1*y_1, ..., x_S*y_R)`. + + Examples: + >>> tile = P.Tile() + >>> input_x = Tensor(np.array([[1, 2], [3, 4]]), mindspore.float32) + >>> multiples = (2, 3) + >>> result = tile(input_x, multiples) + [[1. 2. 1. 2. 1. 2.] + [3. 4. 3. 4. 3. 4.] + [1. 2. 1. 2. 1. 2.] + [3. 4. 3. 4. 3. 4.]] """ @prim_attr_register diff --git a/mindspore/ops/operations/control_ops.py b/mindspore/ops/operations/control_ops.py index 3f8d50857a..8475ac6618 100644 --- a/mindspore/ops/operations/control_ops.py +++ b/mindspore/ops/operations/control_ops.py @@ -144,6 +144,12 @@ class Merge(PrimitiveWithInfer): Outputs: tuple. Output is tuple(`data`, `output_index`). The `data` has the same shape of `inputs` element. + + Examples: + >>> merge = P.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)) """ @prim_attr_register diff --git a/mindspore/ops/operations/math_ops.py b/mindspore/ops/operations/math_ops.py index fc92bfc8fb..895dda508e 100644 --- a/mindspore/ops/operations/math_ops.py +++ b/mindspore/ops/operations/math_ops.py @@ -713,6 +713,12 @@ class Neg(PrimitiveWithInfer): Outputs: Tensor, has the same shape and dtype as input. + + Examples: + >>> neg = P.Neg() + >>> input_x = Tensor(np.array([1, 2, -1, 2, 0, -3.5]), mindspore.float32) + >>> result = neg(input_x) + [-1. -2. 1. -2. 0. 3.5] """ @prim_attr_register @@ -1623,6 +1629,7 @@ class LogicalOr(_LogicBinaryOp): def infer_dtype(self, x_dtype, y_dtype): return _LogicBinaryOp.do_infer_dtype(x_dtype, y_dtype, (mstype.bool_,), self.name) + class IsNan(PrimitiveWithInfer): """ Judging which elements are nan for each position @@ -1632,6 +1639,11 @@ class IsNan(PrimitiveWithInfer): Outputs: Tensor, has the same shape of input, and the dtype is bool. + + Examples: + >>> is_nan = P.IsNan() + >>> input_x = Tensor(np.array([np.log(-1), 1, np.log(0)]), mindspore.float32) + >>> result = is_nan(input_x) """ @prim_attr_register @@ -1645,6 +1657,7 @@ class IsNan(PrimitiveWithInfer): def infer_dtype(self, x_dtype): return mstype.bool_ + class IsInf(PrimitiveWithInfer): """ Judging which elements are inf or -inf for each position @@ -1654,6 +1667,11 @@ class IsInf(PrimitiveWithInfer): Outputs: Tensor, has the same shape of input, and the dtype is bool. + + Examples: + >>> is_inf = P.IsInf() + >>> input_x = Tensor(np.array([np.log(-1), 1, np.log(0)]), mindspore.float32) + >>> result = is_inf(input_x) """ @prim_attr_register @@ -1667,6 +1685,7 @@ class IsInf(PrimitiveWithInfer): def infer_dtype(self, x_dtype): return mstype.bool_ + class IsFinite(PrimitiveWithInfer): """ Judging which elements are finite for each position @@ -1676,6 +1695,12 @@ class IsFinite(PrimitiveWithInfer): Outputs: Tensor, has the same shape of input, and the dtype is bool. + + Examples: + >>> is_finite = P.IsFinite() + >>> input_x = Tensor(np.array([np.log(-1), 1, np.log(0)]), mindspore.float32) + >>> result = is_finite(input_x) + [False True False] """ @prim_attr_register @@ -1691,6 +1716,7 @@ class IsFinite(PrimitiveWithInfer): validator.check_tensor_type_same({'x': x_dtype}, mstype.number_type + (mstype.bool_,), self.name) return mstype.bool_ + class FloatStatus(PrimitiveWithInfer): """ Determine if the elements contains nan, inf or -inf. `0` for normal, `1` for overflow. @@ -1701,6 +1727,11 @@ class FloatStatus(PrimitiveWithInfer): Outputs: Tensor, has the shape of `(1,)`, and has the same dtype of input `mindspore.dtype.float32` or `mindspore.dtype.float16`. + + Examples: + >>> float_status = P.FloatStatus() + >>> input_x = Tensor(np.array([np.log(-1), 1, np.log(0)]), mindspore.float32) + >>> result = float_status(input_x) """ @prim_attr_register @@ -1714,6 +1745,7 @@ class FloatStatus(PrimitiveWithInfer): def infer_dtype(self, x_dtype): return x_dtype + class NPUAllocFloatStatus(PrimitiveWithInfer): """ Allocates a flag to store the overflow status. diff --git a/mindspore/ops/operations/nn_ops.py b/mindspore/ops/operations/nn_ops.py index 2f5ca0b55c..4c5a3b1334 100644 --- a/mindspore/ops/operations/nn_ops.py +++ b/mindspore/ops/operations/nn_ops.py @@ -393,6 +393,10 @@ class HSwish(PrimitiveWithInfer): Outputs: Tensor, with the same type and shape as the `input_data`. + Examples: + >>> hswish = P.HSwish() + >>> input_x = Tensor(np.array([-1, -2, 0, 2, 1]), mindspore.float16) + >>> result = hswish(input_x) """ @prim_attr_register def __init__(self): @@ -406,7 +410,6 @@ class HSwish(PrimitiveWithInfer): return x_dtype - class Sigmoid(PrimitiveWithInfer): r""" Sigmoid activation function. @@ -462,6 +465,10 @@ class HSigmoid(PrimitiveWithInfer): Outputs: Tensor, with the same type and shape as the `input_data`. + Examples: + >>> hsigmoid = P.HSigmoid() + >>> input_x = Tensor(np.array([-1, -2, 0, 2, 1]), mindspore.float16) + >>> result = hsigmoid(input_x) """ @prim_attr_register @@ -883,7 +890,7 @@ class DepthwiseConv2dNative(PrimitiveWithInfer): h_out = math.ceil(x_shape[2] / stride_h) w_out = math.ceil(x_shape[3] / stride_w) - pad_needed_h = max(0, (h_out - 1) * stride_h+ dilation_h * (kernel_size_h - 1) + 1 - x_shape[2]) + pad_needed_h = max(0, (h_out - 1) * stride_h + dilation_h * (kernel_size_h - 1) + 1 - x_shape[2]) pad_top = math.floor(pad_needed_h / 2) pad_bottom = pad_needed_h - pad_top @@ -1138,6 +1145,33 @@ class AvgPool(_Pool): Outputs: Tensor, with shape :math:`(N, C_{out}, H_{out}, W_{out})`. + + Examples: + >>> import mindspore + >>> import mindspore.nn as nn + >>> import numpy as np + >>> from mindspore import Tensor + >>> from mindspore.ops import operations as P + >>> class Net(nn.Cell): + >>> def __init__(self): + >>> super(Net, self).__init__() + >>> self.avgpool_op = P.AvgPool(padding="VALID", ksize=2, strides=1) + >>> + >>> def construct(self, x): + >>> result = self.avgpool_op(x) + >>> return result + >>> + >>> input_x = Tensor(np.arange(1 * 3 * 3 * 4).reshape(1, 3, 3, 4), mindspore.float32) + >>> net = Net() + >>> result = net(input_x) + [[[[ 2.5 3.5 4.5] + [ 6.5 7.5 8.5]] + + [[ 14.5 15.5 16.5] + [ 18.5 19.5 20.5]] + + [[ 26.5 27.5 28.5] + [ 30.5 31.5 32.5]]]] """ @prim_attr_register @@ -1590,6 +1624,16 @@ class SGD(PrimitiveWithInfer): Outputs: Tensor, parameters to be updated. + + Examples: + >>> sgd = P.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) + >>> accum = Tensor(np.array([0.1, 0.3, -0.2, -0.1]), mindspore.float32) + >>> momentum = Tensor(0.1, mindspore.float32) + >>> stat = Tensor(np.array([1.5, -0.3, 0.2, -0.7]), mindspore.float32) + >>> result = sgd(parameters, gradient, learning_rate, accum, momentum, stat) """ @prim_attr_register @@ -1620,6 +1664,7 @@ class SGD(PrimitiveWithInfer): validator.check_tensor_type_same({"stat": stat_dtype}, valid_types, self.name) return parameters_dtype + class ApplyRMSProp(PrimitiveWithInfer): """ Optimizer that implements the Root Mean Square prop(RMSProp) algorithm. @@ -1659,6 +1704,18 @@ class ApplyRMSProp(PrimitiveWithInfer): Outputs: Tensor, parameters to be update. + + Examples: + >>> apply_rms = P.ApplyRMSProp() + >>> input_x = Tensor(np.random.randint(0, 256, (3, 3)),mindspore.float32) + >>> mean_square = Tensor(np.random.randint(0, 256, (3, 3)), mindspore.float32) + >>> moment = Tensor(np.random.randn(3, 3), mindspore.float32) + >>> grad = Tensor(np.random.randint(-32, 16, (3, 3)), mindspore.float32 ) + >>> learning_rate = 0.9 + >>> decay = 0.0 + >>> momentum = 1e-10 + >>> epsilon = 0.001 + >>> result = apply_rms(input_x, mean_square, moment, grad, learning_rate, decay, momentum, epsilon) """ @prim_attr_register @@ -1729,6 +1786,20 @@ class ApplyCenteredRMSProp(PrimitiveWithInfer): Outputs: Tensor, parameters to be update. + + Examples: + >>> centered_rms_prop = P.ApplyCenteredRMSProp() + >>> input_x = Tensor(np.random.randint(0, 256, (3, 3)),mindspore.float32) + >>> mean_grad = Tensor(np.random.randint(-8, 8, (3, 3)), mindspore.float32) + >>> mean_square = Tensor(np.random.randint(0, 256, (3, 3)), mindspore.float32) + >>> moment = Tensor(np.random.randn(3, 3), mindspore.float32) + >>> grad = Tensor(np.random.randint(-32, 16, (3, 3)), mindspore.float32 ) + >>> learning_rate = 0.9 + >>> decay = 0.0 + >>> momentum = 1e-10 + >>> epsilon = 0.001 + >>> result = centered_rms_prop(input_x, mean_grad, mean_square, moment, grad, + >>> learning_rate, decay, momentum, epsilon) """ @prim_attr_register @@ -1827,6 +1898,18 @@ class L2Normalize(PrimitiveWithInfer): Outputs: Tensor, with the same type and shape as the input. + + Examples: + >>> l2_normalize = P.L2Normalize() + >>> input_x = Tensor(np.random.randint(-256, 256, (2, 3, 4)), mindspore.float32) + >>> result = l2_normalize(input_x) + [[[-0.47247353 -0.30934513 -0.4991462 0.8185567 ] + [-0.08070751 -0.9961299 -0.5741758 0.09262337] + [-0.9916556 -0.3049123 0.5730487 -0.40579924] + + [[-0.88134485 0.9509498 -0.86651784 0.57442576] + [ 0.99673784 0.08789381 -0.8187321 0.9957012 ] + [ 0.12891524 -0.9523804 -0.81952125 0.91396334]]] """ @prim_attr_register @@ -2138,6 +2221,32 @@ class PReLU(PrimitiveWithInfer): Tensor, with the same type as `input_x`. Detailed information, please refer to `nn.PReLU`. + + Examples: + >>> import mindspore + >>> import mindspore.nn as nn + >>> import numpy as np + >>> from mindspore import Tensor + >>> from mindspore.ops import operations as P + >>> class Net(nn.Cell): + >>> def __init__(self): + >>> super(Net, self).__init__() + >>> self.prelu = P.PReLU() + >>> def construct(self, input_x, weight): + >>> result = self.prelu(input_x, weight) + >>> return result + >>> + >>> input_x = Tensor(np.random.randint(-3, 3, (2, 3, 2)), mindspore.float32) + >>> weight = Tensor(np.array([0.1, 0.6, -0.3]), mindspore.float32) + >>> net = Net() + >>> result = net(input_x, weight) + [[[-0.1 1. ] + [ 0. 2. ] + [0. 0. ]] + + [[-0.2 -0.1 ] + [2. -1.8000001] + [0.6 0.6 ]]] """ @prim_attr_register @@ -2547,6 +2656,27 @@ class BinaryCrossEntropy(PrimitiveWithInfer): Outputs: Tensor or Scalar, if `reduction` is 'none', then output is a tensor and same shape as `input_x`. Otherwise it is a scalar. + + Examples: + >>> import mindspore + >>> import mindspore.nn as nn + >>> import numpy as np + >>> from mindspore import Tensor + >>> from mindspore.ops import operations as P + >>> class Net(nn.Cell): + >>> def __init__(self): + >>> super(Net, self).__init__() + >>> self.binary_cross_entropy = P.BinaryCrossEntropy() + >>> def construct(self, x, y, weight): + >>> result = self.binary_cross_entropy(x, y, weight) + >>> return result + >>> + >>> net = Net() + >>> input_x = Tensor(np.array([0.2, 0.7, 0.1]), mindspore.float32) + >>> input_y = Tensor(np.array([0., 1., 0.]), mindspore.float32) + >>> weight = Tensor(np.array([1, 2, 2]), mindspore.float32) + >>> result = net(input_x, input_y, weight) + 0.38240486 """ @prim_attr_register @@ -2726,6 +2856,37 @@ class ApplyFtrl(PrimitiveWithInfer): Outputs: Tensor, representing the updated var. + + Examples: + >>> import mindspore + >>> import mindspore.nn as nn + >>> import numpy as np + >>> from mindspore import Parameter + >>> from mindspore import Tensor + >>> from mindspore.ops import operations as P + >>> class ApplyFtrlNet(nn.Cell): + >>> def __init__(self): + >>> super(ApplyFtrlNet, self).__init__() + >>> self.apply_ftrl = P.ApplyFtrl() + >>> self.lr = 0.001 + >>> self.l1 = 0.0 + >>> self.l2 = 0.0 + >>> self.lr_power = -0.5 + >>> self.var = Parameter(Tensor(np.random.rand(3, 3).astype(np.float32)), name="var") + >>> self.accum = Parameter(Tensor(np.random.rand(3, 3).astype(np.float32)), name="accum") + >>> self.linear = Parameter(Tensor(np.random.rand(3, 3).astype(np.float32)), name="linear") + >>> + >>> def construct(self, grad): + >>> out = self.apply_ftrl(self.var, self.accum, self.linear, grad, self.lr, self.l1, self.l2, + >>> self.lr_power) + >>> return out + >>> + >>> net = ApplyFtrlNet() + >>> input_x = Tensor(np.random.randint(-4, 4, (3, 3)), mindspore.float32) + >>> result = net(input_x) + [[0.67455846 0.14630564 0.160499 ] + [0.16329421 0.00415689 0.05202988] + [0.18672481 0.17418946 0.36420345]] """ @prim_attr_register @@ -2780,6 +2941,18 @@ class ConfusionMulGrad(PrimitiveWithInfer): the shape of output is :math:`(x_1,x_3,...,x_R)`. - If axis is tuple(int), set as (2,3), and keep_dims is false, the shape of output is :math:`(x_1,x_4,...x_R)`. + + Examples: + >>> confusion_mul_grad = P.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) + >>> output_0, output_1 = confusion_mul_grad(input_0, input_1, input_2) + output_0: + [[ 3. 1. 0.] + [-6. 2. -2.]] + output_1: + -3.0 """ @prim_attr_register diff --git a/mindspore/ops/operations/other_ops.py b/mindspore/ops/operations/other_ops.py index 87162e4e6a..8f853c7918 100644 --- a/mindspore/ops/operations/other_ops.py +++ b/mindspore/ops/operations/other_ops.py @@ -168,6 +168,26 @@ class CheckValid(PrimitiveWithInfer): Outputs: Tensor, the valided tensor. + + Examples: + >>> import mindspore + >>> import mindspore.nn as nn + >>> import numpy as np + >>> from mindspore import Tensor + >>> from mindspore.ops import operations as P + >>> class Net(nn.Cell): + >>> def __init__(self): + >>> super(Net, self).__init__() + >>> self.check_valid = P.CheckValid() + >>> def construct(self, x, y): + >>> valid_result = self.check_valid(x, y) + >>> return valid_result + >>> + >>> bboxes = Tensor(np.linspace(0, 6, 12).reshape(3, 4), mindspore.float32) + >>> img_metas = Tensor(np.array([2, 1, 3]), mindspore.float32) + >>> net = Net() + >>> result = net(bboxes, img_metas) + [True False False] """ @prim_attr_register