From 569693af52883835c558b6106d83f9ba96447dd4 Mon Sep 17 00:00:00 2001 From: lihongkang <[lihongkang1@huawei.com]> Date: Sat, 12 Sep 2020 16:03:28 +0800 Subject: [PATCH] fix bugs --- mindspore/nn/layer/basic.py | 6 ++++-- mindspore/nn/layer/conv.py | 4 ++-- mindspore/nn/loss/loss.py | 7 +++++-- mindspore/ops/operations/array_ops.py | 30 +++++++++++---------------- mindspore/ops/operations/math_ops.py | 10 ++++----- mindspore/ops/operations/nn_ops.py | 7 ++++--- 6 files changed, 32 insertions(+), 32 deletions(-) diff --git a/mindspore/nn/layer/basic.py b/mindspore/nn/layer/basic.py index 17caa5165d3..df33f1b26b9 100644 --- a/mindspore/nn/layer/basic.py +++ b/mindspore/nn/layer/basic.py @@ -335,7 +335,7 @@ class Norm(Cell): Computes the norm of vectors, currently including Euclidean norm, i.e., :math:`L_2`-norm. Args: - axis (tuple): The axis over which to compute vector norms. Default: (). + axis (Union[tuple, int]): The axis over which to compute vector norms. Default: (). keep_dims (bool): If True, the axis indicated in `axis` are kept with size 1. Otherwise, the dimensions in `axis` are removed from the output shape. Default: False. @@ -348,12 +348,14 @@ class Norm(Cell): Examples: >>> net = nn.Norm(axis=0) - >>> input = Tensor(np.random.randint(0, 10, [4, 16]), mindspore.float32) + >>> input = Tensor(np.random.randint(0, 10, [2, 4]), mindspore.float32) >>> net(input) + [2.236068 9.848858 4. 5.656854] """ def __init__(self, axis=(), keep_dims=False): super(Norm, self).__init__() + validator.check_value_type("keep_dims", keep_dims, [bool], self.cls_name) self.axis = axis self.keep_dims = keep_dims self.reduce_sum = P.ReduceSum(True) diff --git a/mindspore/nn/layer/conv.py b/mindspore/nn/layer/conv.py index 9cc8bce3c25..341f9fa74e8 100644 --- a/mindspore/nn/layer/conv.py +++ b/mindspore/nn/layer/conv.py @@ -884,8 +884,8 @@ class DepthwiseConv2d(Cell): Tensor of shape :math:`(N, C_{out}, H_{out}, W_{out})`. Examples: - >>> net = nn.DepthwiseConv2d(120, 240, 4, has_bias=False, weight_init='normal') - >>> input = Tensor(np.ones([1, 120, 1024, 640]), mindspore.float32) + >>> net = nn.DepthwiseConv2d(240, 240, 4, group=None, has_bias=False, weight_init='normal') + >>> input = Tensor(np.ones([1, 240, 1024, 640]), mindspore.float32) >>> net(input).shape (1, 240, 1024, 640) """ diff --git a/mindspore/nn/loss/loss.py b/mindspore/nn/loss/loss.py index 645e371a977..cc0e0fcab6d 100644 --- a/mindspore/nn/loss/loss.py +++ b/mindspore/nn/loss/loss.py @@ -83,8 +83,10 @@ class L1Loss(_Loss): Default: "mean". Inputs: - - **input_data** (Tensor) - Tensor of shape :math:`(x_1, x_2, ..., x_R)`. - - **target_data** (Tensor) - Tensor of shape :math:`(y_1, y_2, ..., y_S)`. + - **input_data** (Tensor) - Tensor of shape :math:`(x_1, x_2, ..., x_R)`. The data type should be float16 or + float32. + - **target_data** (Tensor) - Tensor of shape :math:`(y_1, y_2, ..., y_S)`. The data type should be float16 or + float32. Outputs: Tensor, loss float tensor. @@ -94,6 +96,7 @@ class L1Loss(_Loss): >>> input_data = Tensor(np.array([1, 2, 3]), mindspore.float32) >>> target_data = Tensor(np.array([1, 2, 2]), mindspore.float32) >>> loss(input_data, target_data) + 0.33333334 """ def __init__(self, reduction='mean'): super(L1Loss, self).__init__(reduction) diff --git a/mindspore/ops/operations/array_ops.py b/mindspore/ops/operations/array_ops.py index 119c14e1c11..3002b5beaa6 100644 --- a/mindspore/ops/operations/array_ops.py +++ b/mindspore/ops/operations/array_ops.py @@ -300,6 +300,7 @@ class IsSubClass(PrimitiveWithInfer): Examples: >>> result = P.IsSubClass()(mindspore.int32, mindspore.intc) + True """ @prim_attr_register @@ -1099,7 +1100,7 @@ class InvertPermutation(PrimitiveWithInfer): - **input_x** (Union(tuple[int], list[int]) - The input is constructed by multiple integers, i.e., :math:`(y_1, y_2, ..., y_S)` representing the indices. The values must include 0. There can be no duplicate values or negative values. - Only constant value is allowed. + Only constant value is allowed. The maximum value msut be equal to length of input_x. Outputs: tuple[int]. It has the same length as the input. @@ -1599,7 +1600,7 @@ class Concat(PrimitiveWithInfer): Note: The input data is a tuple of tensors. These tensors have the same rank `R`. Set the given axis as `m`, and - :math:`0 \le m < N`. Set the number of input tensors as `N`. For the :math:`i`-th tensor :math:`t_i`, it has + :math:`0 \le m < R`. Set the number of input tensors as `N`. For the :math:`i`-th tensor :math:`t_i`, it has the shape of :math:`(x_1, x_2, ..., x_{mi}, ..., x_R)`. :math:`x_{mi}` is the :math:`m`-th dimension of the :math:`i`-th tensor. Then, the shape of the output tensor is @@ -3451,7 +3452,8 @@ class InplaceUpdate(PrimitiveWithInfer): Updates specified rows with values in `v`. Args: - indices (Union[int, tuple]): Indices into the left-most dimension of `x`. + indices (Union[int, tuple]): Indices into the left-most dimension of `x`, and determines which rows of x + to update with v. It is a int or tuple, whose value is in [0, the first dimension size of x). Inputs: - **x** (Tensor) - A tensor which to be inplace updated. It can be one of the following data types: @@ -3463,22 +3465,14 @@ class InplaceUpdate(PrimitiveWithInfer): Tensor, with the same type and shape as the input `x`. Examples: - >>> x = Tensor(np.arange(24).reshape(3, 4, 2), mindspore.float32) - >>> v = Tensor(np.arange(-8, 8).reshape(2, 4, 2), mindspore.float32) - >>> inplace_update = P.InplaceUpdate((0, 2)) + >>> 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) >>> result = inplace_update(x, v) - [[[-8. -7.] - [-6. -5.] - [-4. -3.] - [-2. -1.]] - [[ 8. 9.] - [10. 11.] - [12. 13.] - [14. 15.]] - [[ 0. 1.] - [ 2. 3.] - [ 4. 5.] - [ 6. 7.]]] + [[0.5, 1.0], + [1.0, 1.5], + [5.0, 6.0]] """ @prim_attr_register diff --git a/mindspore/ops/operations/math_ops.py b/mindspore/ops/operations/math_ops.py index c3202d18ea9..53109f98f34 100644 --- a/mindspore/ops/operations/math_ops.py +++ b/mindspore/ops/operations/math_ops.py @@ -965,7 +965,7 @@ class InplaceAdd(PrimitiveWithInfer): the first dimension, which must be the same as indices's size. It has the same data type with `input_x`. Outputs: - Tensor, has the same shape and dtype as input. + Tensor, has the same shape and dtype as input_x. Examples: >>> indices = (0, 1) @@ -1011,7 +1011,7 @@ class InplaceAdd(PrimitiveWithInfer): class InplaceSub(PrimitiveWithInfer): """ - Subtracts v into specified rows of x. Computes y = x; y[i, :] -= v; return y. + Subtracts v into specified rows of x. Computes y = x; y[i, :] -= v. Args: indices (Union[int, tuple]): Indices into the left-most dimension of x, and determines which rows of x @@ -1023,7 +1023,7 @@ class InplaceSub(PrimitiveWithInfer): the first dimension, which must be the same as indices's size. It has the same data type with `input_x`. Outputs: - Tensor, has the same shape and dtype as input. + Tensor, has the same shape and dtype as input_x. Examples: >>> indices = (0, 1) @@ -1496,7 +1496,7 @@ class Log(PrimitiveWithInfer): Returns the natural logarithm of a tensor element-wise. Inputs: - - **input_x** (Tensor) - The input tensor. + - **input_x** (Tensor) - The input tensor. With float16 or float32 data type. The value must be greater than 0. Outputs: Tensor, has the same shape as the `input_x`. @@ -1533,7 +1533,7 @@ class Log1p(PrimitiveWithInfer): Returns the natural logarithm of one plus the input tensor element-wise. Inputs: - - **input_x** (Tensor) - The input tensor. With float16 or float32 data type. + - **input_x** (Tensor) - The input tensor. With float16 or float32 data type. The value must be greater than -1. Outputs: Tensor, has the same shape as the `input_x`. diff --git a/mindspore/ops/operations/nn_ops.py b/mindspore/ops/operations/nn_ops.py index f72a8a9e767..14cc67750d0 100644 --- a/mindspore/ops/operations/nn_ops.py +++ b/mindspore/ops/operations/nn_ops.py @@ -5541,7 +5541,8 @@ class InTopK(PrimitiveWithInfer): Inputs: - **x1** (Tensor) - A 2D Tensor defines the predictions of a batch of samples with float16 or float32 data type. - - **x2** (Tensor) - A 1D Tensor defines the labels of a batch of samples with int32 data type. + - **x2** (Tensor) - A 1D Tensor defines the labels of a batch of samples with int32 data type. The size of x2 + must be equal to x1's first dimension. Outputs: Tensor has 1 dimension of type bool and the same shape with `x2`. For labeling sample `i` in `x2`, @@ -5568,8 +5569,8 @@ class InTopK(PrimitiveWithInfer): return mstype.tensor_type(mstype.bool_) def infer_shape(self, x1_shape, x2_shape): - validator.check("x1", len(x1_shape), "", 2, Rel.EQ, self.name) - validator.check("x2", len(x2_shape), "", 1, Rel.EQ, self.name) + validator.check("x1 shape", len(x1_shape), "", 2, Rel.EQ, self.name) + validator.check("x2 shape", len(x2_shape), "", 1, Rel.EQ, self.name) validator.check("size of x2", x2_shape[0], "x1's first dimension", x1_shape[0], Rel.EQ, self.name) return x2_shape