p85971406
/
mindspore
forked from mindspore-Ecosystem/mindspore
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

!126 resolve some issues in nn comments 

Merge pull request !126 from zhongligeng/master
This commit is contained in:
mindspore-ci-bot 2020-04-06 10:14:50 +08:00 committed by Gitee
parent 6c9e5c13c4 144a636b51
commit 32017f6da3
25 changed files with 128 additions and 150 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
mindspore/nn/layer/basic.py
View File

@ -65,7 +65,7 @@ class Dropout(Cell):
Tensor, output tensor with the same shape as the input.
Examples:
>>> x = mindspore.Tensor(np.ones([20, 16, 50]), mindspore.float32)
>>> x = Tensor(np.ones([20, 16, 50]), mindspore.float32)
>>> net = nn.Dropout(keep_prob=0.8)
>>> net(x)
"""
@ -111,7 +111,7 @@ class Flatten(Cell):
Examples:
>>> net = nn.Flatten()
>>> input = mindspore.Tensor(np.array([[[1.2, 1.2], [2.1, 2.1]], [[2.2, 2.2], [3.2, 3.2]]]), mindspore.float32)
>>> input = Tensor(np.array([[[1.2, 1.2], [2.1, 2.1]], [[2.2, 2.2], [3.2, 3.2]]]), mindspore.float32)
>>> input.shape()
(2, 2, 2)
>>> net(input)
@ -149,9 +149,6 @@ class Dense(Cell):
has_bias (bool): Specifies whether the layer uses a bias vector. Default: True.
activation (str): Regularizer function applied to the output of the layer, eg. 'relu'. Default: None.
Returns:
Tensor, output tensor.
Raises:
ValueError: If weight_init or bias_init shape is incorrect.
@ -163,7 +160,7 @@ class Dense(Cell):
Examples:
>>> net = nn.Dense(3, 4)
>>> input = mindspore.Tensor(np.random.randint(0, 255, [2, 3]), mindspore.float32)
>>> input = Tensor(np.random.randint(0, 255, [2, 3]), mindspore.float32)
>>> net(input)
[[ 2.5246444 2.2738023 0.5711005 -3.9399147 ]
[ 1.0739875 4.0155234 0.94188046 -5.459526 ]]
@ -243,8 +240,8 @@ class ClipByNorm(Cell):
Examples:
>>> net = nn.ClipByNorm()
>>> input = mindspore.Tensor(np.random.randint(0, 10, [4, 16]), mindspore.float32)
>>> clip_norm = mindspore.Tensor(np.array([100]).astype(np.float32))
>>> input = Tensor(np.random.randint(0, 10, [4, 16]), mindspore.float32)
>>> clip_norm = Tensor(np.array([100]).astype(np.float32))
>>> net(input, clip_norm)
"""
@ -290,9 +287,6 @@ class Norm(Cell):
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.
Returns:
Tensor, a Tensor of the same type as input, containing the vector or matrix norms.
Inputs:
- **input** (Tensor) - Tensor which is not empty.
@ -302,7 +296,7 @@ class Norm(Cell):
Examples:
>>> net = nn.Norm(axis=0)
>>> input = mindspore.Tensor(np.random.randint(0, 10, [4, 16]), mindspore.float32)
>>> input = Tensor(np.random.randint(0, 10, [4, 16]), mindspore.float32)
>>> net(input)
"""
def __init__(self, axis=(), keep_dims=False):
@ -344,7 +338,8 @@ class OneHot(Cell):
when indices[j] = i. Default: 1.0.
off_value (float): A scalar defining the value to fill in output[i][j]
when indices[j] != i. Default: 0.0.
dtype (:class:`mindspore.dtype`): Default: mindspore.float32.
dtype (:class:`mindspore.dtype`): Data type of 'on_value' and 'off_value', not the
data type of indices. Default: mindspore.float32.
Inputs:
- **indices** (Tensor) - A tensor of indices of data type mindspore.int32 and arbitrary shape.
@ -355,7 +350,7 @@ class OneHot(Cell):
Examples:
>>> net = nn.OneHot(depth=4, axis=1)
>>> indices = mindspore.Tensor([[1, 3], [0, 2]], dtype=mindspore.int32)
>>> indices = Tensor([[1, 3], [0, 2]], dtype=mindspore.int32)
>>> net(indices)
[[[0. 0.]
[1. 0.]

5
mindspore/nn/layer/container.py
View File

@ -86,7 +86,7 @@ class SequentialCell(Cell):
>>> relu = nn.ReLU()
>>> seq = nn.SequentialCell([conv, bn, relu])
>>>
>>> x = mindspore.Tensor(np.random.random((1, 3, 4, 4)), dtype=mindspore.float32)
>>> x = Tensor(np.random.random((1, 3, 4, 4)), dtype=mindspore.float32)
>>> seq(x)
[[[[0.02531557 0. ]
[0.04933941 0.04880078]]
@ -138,7 +138,6 @@ class SequentialCell(Cell):
return len(self._cells)
def construct(self, input_data):
"""Processes the input with the defined sequence of Cells."""
for cell in self.cell_list:
input_data = cell(input_data)
return input_data
@ -161,7 +160,7 @@ class CellList(_CellListBase, Cell):
>>> cell_ls = nn.CellList([bn])
>>> cell_ls.insert(0, conv)
>>> cell_ls.append(relu)
>>> x = mindspore.Tensor(np.random.random((1, 3, 4, 4)), dtype=mindspore.float32)
>>> x = Tensor(np.random.random((1, 3, 4, 4)), dtype=mindspore.float32)
>>> # not same as nn.SequentialCell, `cell_ls(x)` is not correct
>>> cell_ls
CellList< (0): Conv2d<input_channels=100, ..., bias_init=None>

7
mindspore/nn/layer/conv.py
View File

@ -146,9 +146,6 @@ class Conv2d(_Conv):
Initializer and string are the same as 'weight_init'. Refer to the values of
Initializer for more details. Default: 'zeros'.
Returns:
Tensor, output tensor.
Inputs:
- **input** (Tensor) - Tensor of shape :math:`(N, C_{in}, H_{in}, W_{in})`.
@ -157,7 +154,7 @@ class Conv2d(_Conv):
Examples:
>>> net = nn.Conv2d(120, 240, 4, has_bias=False, weight_init='normal')
>>> input = mindspore.Tensor(np.ones([1, 120, 1024, 640]), mindspore.float32)
>>> input = Tensor(np.ones([1, 120, 1024, 640]), mindspore.float32)
>>> net(input).shape()
(1, 240, 1024, 640)
"""
@ -277,7 +274,7 @@ class Conv2dTranspose(_Conv):
Examples:
>>> net = nn.Conv2dTranspose(3, 64, 4, has_bias=False, weight_init='normal')
>>> input = Tensor(np.ones([1, 3, 16, 50]), mstype.float32)
>>> input = Tensor(np.ones([1, 3, 16, 50]), mindspore.float32)
>>> net(input)
"""
def __init__(self,

2
mindspore/nn/layer/embedding.py
View File

@ -50,7 +50,7 @@ class Embedding(Cell):
Examples:
>>> net = nn.Embedding(20000, 768, True)
>>> input_data = mindspore.Tensor(np.ones([8, 128]), mindspore.int32)
>>> input_data = Tensor(np.ones([8, 128]), mindspore.int32)
>>>
>>> # Maps the input word IDs to word embedding.
>>> output = net(input_data)

6
mindspore/nn/layer/lstm.py
View File

@ -96,9 +96,9 @@ class LSTM(Cell):
>>> return self.lstm(inp, (h0, c0))
>>>
>>> net = LstmNet(10, 12, 2, has_bias=True, batch_first=True, bidirectional=False)
>>> input = mindspore.Tensor(np.ones([3, 5, 10]).astype(np.float32))
>>> h0 = mindspore.Tensor(np.ones([1 * 2, 3, 12]).astype(np.float32))
>>> c0 = mindspore.Tensor(np.ones([1 * 2, 3, 12]).astype(np.float32))
>>> input = Tensor(np.ones([3, 5, 10]).astype(np.float32))
>>> h0 = Tensor(np.ones([1 * 2, 3, 12]).astype(np.float32))
>>> c0 = Tensor(np.ones([1 * 2, 3, 12]).astype(np.float32))
>>> output, (hn, cn) = net(input, h0, c0)
"""
def __init__(self,

4
mindspore/nn/layer/normalization.py
View File

@ -159,7 +159,7 @@ class BatchNorm1d(_BatchNorm):
Examples:
>>> net = nn.BatchNorm1d(num_features=16)
>>> input = mindspore.Tensor(np.random.randint(0, 255, [3, 16]), mindspore.float32)
>>> input = Tensor(np.random.randint(0, 255, [3, 16]), mindspore.float32)
>>> net(input)
"""
def _check_data_dim(self, x):
@ -258,7 +258,7 @@ class LayerNorm(Cell):
Examples:
>>> x = Tensor(np.ones([20, 5, 10, 10], np.float32))
>>> shape1 = x.shape()[1:]
>>> m = LayerNorm(shape1, begin_norm_axis=1, begin_params_axis=1)
>>> m = nn.LayerNorm(shape1, begin_norm_axis=1, begin_params_axis=1)
>>> m(x)
"""
def __init__(self,

16
mindspore/nn/layer/pooling.py
View File

@ -63,8 +63,8 @@ class MaxPool2d(_PoolNd):
pad_mode for training only supports "same" and "valid".
Args:
kernel_size (int): Size of the window to take a max over.
stride (int): Stride size of the window. Default: None.
kernel_size (int): Size of the window to take a max over. Default 1.
stride (int): Stride size of the window. Default: 1.
pad_mode (str): Select the mode of the pad. The optional values are
"same" and "valid". Default: "valid".
@ -75,7 +75,7 @@ class MaxPool2d(_PoolNd):
- valid: Adopts the way of discarding. The possibly largest height and width of output will be return
without padding. Extra pixels will be discarded.
padding (int): Now is not supported, mplicit zero padding to be added on both sides. Default: 0.
padding (int): Implicit zero padding to be added on both sides. Default: 0.
Inputs:
- **input** (Tensor) - Tensor of shape :math:`(N, C_{in}, H_{in}, W_{in})`.
@ -85,7 +85,7 @@ class MaxPool2d(_PoolNd):
Examples:
>>> pool = MaxPool2d(kernel_size=3, stride=1)
>>> x = mindspore.Tensor(np.random.randint(0, 10, [1, 2, 4, 4]), mindspore.float32)
>>> x = Tensor(np.random.randint(0, 10, [1, 2, 4, 4]), mindspore.float32)
[[[[1. 5. 5. 1.]
[0. 3. 4. 8.]
[4. 2. 7. 6.]
@ -149,8 +149,8 @@ class AvgPool2d(_PoolNd):
pad_mode for training only supports "same" and "valid".
Args:
kernel_size (int): Size of the window to take a max over.
stride (int): Stride size of the window. Default: None.
kernel_size (int): Size of the window to take a max over. Default: 1.
stride (int): Stride size of the window. Default: 1.
pad_mode (str): Select the mode of the pad. The optional values are
"same", "valid". Default: "valid".
@ -161,7 +161,7 @@ class AvgPool2d(_PoolNd):
- valid: Adopts the way of discarding. The possibly largest height and width of output will be return
without padding. Extra pixels will be discarded.
padding (int): Now is not supported, implicit zero padding to be added on both sides. Default: 0.
padding (int): Implicit zero padding to be added on both sides. Default: 0.
Inputs:
- **input** (Tensor) - Tensor of shape :math:`(N, C_{in}, H_{in}, W_{in})`.
@ -171,7 +171,7 @@ class AvgPool2d(_PoolNd):
Examples:
>>> pool = AvgPool2d(kernel_size=3, stride=1)
>>> x = mindspore.Tensor(np.random.randint(0, 10, [1, 2, 4, 4]), mindspore.float32)
>>> x = Tensor(np.random.randint(0, 10, [1, 2, 4, 4]), mindspore.float32)
[[[[5. 5. 9. 9.]
[8. 4. 3. 0.]
[2. 7. 1. 2.]

31
mindspore/nn/loss/loss.py
View File

@ -86,9 +86,9 @@ class L1Loss(_Loss):
Tensor, loss float tensor.
Examples:
>>> loss = L1Loss()
>>> input_data = Tensor(np.array([1, 2, 3]), mstype.float32)
>>> target_data = Tensor(np.array([1, 2, 2]), mstype.float32)
>>> loss = nn.L1Loss()
>>> 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)
"""
def __init__(self, reduction='mean'):
@ -126,9 +126,9 @@ class MSELoss(_Loss):
Tensor, weighted loss float tensor.
Examples:
>>> loss = MSELoss()
>>> input_data = Tensor(np.array([1, 2, 3]), mstype.float32)
>>> target_data = Tensor(np.array([1, 2, 2]), mstype.float32)
>>> loss = nn.MSELoss()
>>> 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)
"""
def construct(self, base, target):
@ -171,9 +171,9 @@ class SmoothL1Loss(_Loss):
Tensor, loss float tensor.
Examples:
>>> loss = SmoothL1Loss()
>>> input_data = Tensor(np.array([1, 2, 3]), mstype.float32)
>>> target_data = Tensor(np.array([1, 2, 2]), mstype.float32)
>>> loss = nn.SmoothL1Loss()
>>> 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)
"""
def __init__(self, sigma=1.0):
@ -219,17 +219,16 @@ class SoftmaxCrossEntropyWithLogits(_Loss):
Inputs:
- **logits** (Tensor) - Tensor of shape :math:`(x_1, x_2, ..., x_R)`.
- **labels** (Tensor) - Tensor of shape :math:`(y_1, y_2, ..., y_S)`. If `sparse` is True, The type of
`labels` is mstype.int32. If `sparse` is False, the type of `labels` is same as the type of `logits`.
`labels` is mindspore.int32. If `sparse` is False, the type of `labels` is same as the type of `logits`.
Outputs:
Tensor, a tensor of the same shape as logits with the component-wise
logistic losses.
Examples:
>>> loss = SoftmaxCrossEntropyWithLogits(sparse=True)
>>> logits = Tensor(np.random.randint(0, 9, [1, 10]), mstype.float32)
>>> labels_np = np.zeros([1, 10]).astype(np.int32)
>>> labels_np[0][0] = 1
>>> loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True)
>>> logits = Tensor(np.random.randint(0, 9, [1, 10]), mindspore.float32)
>>> labels_np = np.ones([1,]).astype(np.int32)
>>> labels = Tensor(labels_np)
>>> loss(logits, labels)
"""
@ -286,8 +285,8 @@ class SoftmaxCrossEntropyExpand(Cell):
Examples:
>>> loss = SoftmaxCrossEntropyExpand(sparse=True)
>>> input_data = Tensor(np.ones([64, 512]), dtype=mstype.float32)
>>> label = Tensor(np.ones([64]), dtype=mstype.int32)
>>> input_data = Tensor(np.ones([64, 512]), dtype=mindspore.float32)
>>> label = Tensor(np.ones([64]), dtype=mindspore.int32)
>>> loss(input_data, label)
"""
def __init__(self, sparse=False):

17
mindspore/nn/metrics/accuracy.py
View File

@ -35,8 +35,8 @@ class Accuracy(EvaluationBase):
Default: 'classification'.
Examples:
>>> x = mindspore.Tensor(np.array([[0.2, 0.5], [0.3, 0.1], [0.9, 0.6]]), mindspore.float32)
>>> y = mindspore.Tensor(np.array([1, 0, 1]), mindspore.float32)
>>> x = Tensor(np.array([[0.2, 0.5], [0.3, 0.1], [0.9, 0.6]]), mindspore.float32)
>>> y = Tensor(np.array([1, 0, 1]), mindspore.float32)
>>> metric = nn.Accuracy('classification')
>>> metric.clear()
>>> metric.update(x, y)
@ -58,13 +58,14 @@ class Accuracy(EvaluationBase):
Args:
inputs: Input `y_pred` and `y`. `y_pred` and `y` are a `Tensor`, a list or an array.
`y_pred` is in most cases (not strictly) a list of floating numbers in range :math:`[0, 1]`
For 'classification' evaluation type, `y_pred` is in most cases (not strictly) a list
of floating numbers in range :math:`[0, 1]`
and the shape is :math:`(N, C)`, where :math:`N` is the number of cases and :math:`C`
is the number of categories. For 'multilabel' evaluation type, `y_pred` can only be one-hot
encoding with values 0 or 1. Indices with 1 indicate positive category. `y` contains values
of integers. The shape is :math:`(N, C)` if one-hot encoding is used. One-hot encoding
should be used when 'eval_type' is 'multilabel'. Shape can also be :math:`(N, 1)` if category
index is used in 'classification' evaluation type.
is the number of categories. Shape of `y` can be :math:`(N, C)` with values 0 and 1 if one-hot
encoding is used or the shape is :math:`(N,)` with integer values if index of category is used.
For 'multilabel' evaluation type, `y_pred` and `y` can only be one-hot encoding with
values 0 or 1. Indices with 1 indicate positive category. The shape of `y_pred` and `y`
are both :math:`(N, C)`.
Raises:
ValueError: If the number of the input is not 2.

8
mindspore/nn/metrics/error.py
View File

@ -33,8 +33,8 @@ class MAE(Metric):
The method `update` must be called with the form `update(y_pred, y)`.
Examples:
>>> x = mindspore.Tensor(np.array([0.1, 0.2, 0.6, 0.9]), mindspore.float32)
>>> y = mindspore.Tensor(np.array([0.1, 0.25, 0.7, 0.9]), mindspore.float32)
>>> x = Tensor(np.array([0.1, 0.2, 0.6, 0.9]), mindspore.float32)
>>> y = Tensor(np.array([0.1, 0.25, 0.7, 0.9]), mindspore.float32)
>>> error = nn.MAE()
>>> error.clear()
>>> error.update(x, y)
@ -95,8 +95,8 @@ class MSE(Metric):
where :math:`n` is batch size.
Examples:
>>> x = mindspore.Tensor(np.array([0.1, 0.2, 0.6, 0.9]), mindspore.float32)
>>> y = mindspore.Tensor(np.array([0.1, 0.25, 0.5, 0.9]), mindspore.float32)
>>> x = Tensor(np.array([0.1, 0.2, 0.6, 0.9]), mindspore.float32)
>>> y = Tensor(np.array([0.1, 0.25, 0.5, 0.9]), mindspore.float32)
>>> error = MSE()
>>> error.clear()
>>> error.update(x, y)

11
mindspore/nn/metrics/fbeta.py
View File

@ -33,12 +33,11 @@ class Fbeta(Metric):
beta (float): The weight of precision.
Examples:
>>> x = mindspore.Tensor(np.array([[0.2, 0.5], [0.3, 0.1], [0.9, 0.6]]))
>>> y = mindspore.Tensor(np.array([1, 0, 1]))
>>> x = Tensor(np.array([[0.2, 0.5], [0.3, 0.1], [0.9, 0.6]]))
>>> y = Tensor(np.array([1, 0, 1]))
>>> metric = nn.Fbeta(1)
>>> metric.update(x, y)
>>> fbeta = metric.eval()
[0.66666667 0.66666667]
"""
def __init__(self, beta):
super(Fbeta, self).__init__()
@ -64,7 +63,7 @@ class Fbeta(Metric):
`y_pred` is in most cases (not strictly) a list of floating numbers in range :math:`[0, 1]`
and the shape is :math:`(N, C)`, where :math:`N` is the number of cases and :math:`C`
is the number of categories. y contains values of integers. The shape is :math:`(N, C)`
if one-hot encoding is used. Shape can also be :math:`(N, 1)` if category index is used.
if one-hot encoding is used. Shape can also be :math:`(N,)` if category index is used.
"""
if len(inputs) != 2:
raise ValueError('Fbeta need 2 inputs (y_pred, y), but got {}'.format(len(inputs)))
@ -126,8 +125,8 @@ class F1(Fbeta):
F_\beta=\frac{2\cdot true\_positive}{2\cdot true\_positive + false\_negative + false\_positive}
Examples:
>>> x = mindspore.Tensor(np.array([[0.2, 0.5], [0.3, 0.1], [0.9, 0.6]]))
>>> y = mindspore.Tensor(np.array([1, 0, 1]))
>>> x = Tensor(np.array([[0.2, 0.5], [0.3, 0.1], [0.9, 0.6]]))
>>> y = Tensor(np.array([1, 0, 1]))
>>> metric = nn.F1()
>>> metric.update(x, y)
>>> fbeta = metric.eval()

3
mindspore/nn/metrics/loss.py
View File

@ -25,12 +25,11 @@ class Loss(Metric):
loss = \frac{\sum_{k=1}^{n}loss_k}{n}
Examples:
>>> x = mindspore.Tensor(np.array(0.2), mindspore.float32)
>>> x = Tensor(np.array(0.2), mindspore.float32)
>>> loss = nn.Loss()
>>> loss.clear()
>>> loss.update(x)
>>> result = loss.eval()
0.20000000298023224
"""
def __init__(self):
super(Loss, self).__init__()

18
mindspore/nn/metrics/precision.py
View File

@ -41,13 +41,12 @@ class Precision(EvaluationBase):
multilabel. Default: 'classification'.
Examples:
>>> x = mindspore.Tensor(np.array([[0.2, 0.5], [0.3, 0.1], [0.9, 0.6]]))
>>> y = mindspore.Tensor(np.array([1, 0, 1]))
>>> x = Tensor(np.array([[0.2, 0.5], [0.3, 0.1], [0.9, 0.6]]))
>>> y = Tensor(np.array([1, 0, 1]))
>>> metric = nn.Precision('classification')
>>> metric.clear()
>>> metric.update(x, y)
>>> precision = metric.eval()
[0.5 1. ]
"""
def __init__(self, eval_type='classification'):
super(Precision, self).__init__(eval_type)
@ -72,13 +71,14 @@ class Precision(EvaluationBase):
Args:
inputs: Input `y_pred` and `y`. `y_pred` and `y` are Tensor, list or numpy.ndarray.
`y_pred` is in most cases (not strictly) a list of floating numbers in range :math:`[0, 1]`
For 'classification' evaluation type, `y_pred` is in most cases (not strictly) a list
of floating numbers in range :math:`[0, 1]`
and the shape is :math:`(N, C)`, where :math:`N` is the number of cases and :math:`C`
is the number of categories. For 'multilabel' evaluation type, `y_pred` can only be one-hot
encoding with values 0 or 1. Indices with 1 indicate positive category. `y` contains values
of integers. The shape is :math:`(N, C)` if one-hot encoding is used. One-hot encoding
should be used when 'eval_type' is 'multilabel'. Shape can also be :math:`(N, 1)` if category
index is used in 'classification' evaluation type.
is the number of categories. Shape of `y` can be :math:`(N, C)` with values 0 and 1 if one-hot
encoding is used or the shape is :math:`(N,)` with integer values if index of category is used.
For 'multilabel' evaluation type, `y_pred` and `y` can only be one-hot encoding with
values 0 or 1. Indices with 1 indicate positive category. The shape of `y_pred` and `y`
are both :math:`(N, C)`.
Raises:
ValueError: If the number of input is not 2.

18
mindspore/nn/metrics/recall.py
View File

@ -41,13 +41,12 @@ class Recall(EvaluationBase):
multilabel. Default: 'classification'.
Examples:
>>> x = mindspore.Tensor(np.array([[0.2, 0.5], [0.3, 0.1], [0.9, 0.6]]))
>>> y = mindspore.Tensor(np.array([1, 0, 1]))
>>> x = Tensor(np.array([[0.2, 0.5], [0.3, 0.1], [0.9, 0.6]]))
>>> y = Tensor(np.array([1, 0, 1]))
>>> metric = nn.Recall('classification')
>>> metric.clear()
>>> metric.update(x, y)
>>> recall = metric.eval()
[1. 0.5]
"""
def __init__(self, eval_type='classification'):
super(Recall, self).__init__(eval_type)
@ -72,13 +71,14 @@ class Recall(EvaluationBase):
Args:
inputs: Input `y_pred` and `y`. `y_pred` and `y` are a `Tensor`, a list or an array.
`y_pred` is in most cases (not strictly) a list of floating numbers in range :math:`[0, 1]`
For 'classification' evaluation type, `y_pred` is in most cases (not strictly) a list
of floating numbers in range :math:`[0, 1]`
and the shape is :math:`(N, C)`, where :math:`N` is the number of cases and :math:`C`
is the number of categories. For 'multilabel' evaluation type, `y_pred` can only be one-hot
encoding with values 0 or 1. Indices with 1 indicate positive category. `y` contains values
of integers. The shape is :math:`(N, C)` if one-hot encoding is used. One-hot encoding
should be used when 'eval_type' is 'multilabel'. Shape can also be :math:`(N, 1)` if category
index is used in 'classification' evaluation type.
is the number of categories. Shape of `y` can be :math:`(N, C)` with values 0 and 1 if one-hot
encoding is used or the shape is :math:`(N,)` with integer values if index of category is used.
For 'multilabel' evaluation type, `y_pred` and `y` can only be one-hot encoding with
values 0 or 1. Indices with 1 indicate positive category. The shape of `y_pred` and `y`
are both :math:`(N, C)`.
Raises:

15
mindspore/nn/metrics/topk.py
View File

@ -33,14 +33,13 @@ class TopKCategoricalAccuracy(Metric):
ValueError: If `k` is less than 1.
Examples:
>>> x = mindspore.Tensor(np.array([[0.2, 0.5, 0.3, 0.6, 0.2], [0.1, 0.35, 0.5, 0.2, 0.],
>>> x = Tensor(np.array([[0.2, 0.5, 0.3, 0.6, 0.2], [0.1, 0.35, 0.5, 0.2, 0.],
>>> [0.9, 0.6, 0.2, 0.01, 0.3]]), mindspore.float32)
>>> y = mindspore.Tensor(np.array([2, 0, 1]), mindspore.float32)
>>> y = Tensor(np.array([2, 0, 1]), mindspore.float32)
>>> topk = nn.TopKCategoricalAccuracy(3)
>>> topk.clear()
>>> topk.update(x, y)
>>> result = topk.eval()
0.6666666666666666
"""
def __init__(self, k):
super(TopKCategoricalAccuracy, self).__init__()
@ -65,7 +64,7 @@ class TopKCategoricalAccuracy(Metric):
y_pred is in most cases (not strictly) a list of floating numbers in range :math:`[0, 1]`
and the shape is :math:`(N, C)`, where :math:`N` is the number of cases and :math:`C`
is the number of categories. y contains values of integers. The shape is :math:`(N, C)`
if one-hot encoding is used. Shape can also be :math:`(N, 1)` if category index is used.
if one-hot encoding is used. Shape can also be :math:`(N,)` if category index is used.
"""
if len(inputs) != 2:
raise ValueError('Topk need 2 inputs (y_pred, y), but got {}'.format(len(inputs)))
@ -98,9 +97,9 @@ class Top1CategoricalAccuracy(TopKCategoricalAccuracy):
Refer to class 'TopKCategoricalAccuracy' for more details.
Examples:
>>> x = mindspore.Tensor(np.array([[0.2, 0.5, 0.3, 0.6, 0.2], [0.1, 0.35, 0.5, 0.2, 0.],
>>> x = Tensor(np.array([[0.2, 0.5, 0.3, 0.6, 0.2], [0.1, 0.35, 0.5, 0.2, 0.],
>>> [0.9, 0.6, 0.2, 0.01, 0.3]]), mindspore.float32)
>>> y = mindspore.Tensor(np.array([2, 0, 1]), mindspore.float32)
>>> y = Tensor(np.array([2, 0, 1]), mindspore.float32)
>>> topk = nn.Top1CategoricalAccuracy()
>>> topk.clear()
>>> topk.update(x, y)
@ -116,9 +115,9 @@ class Top5CategoricalAccuracy(TopKCategoricalAccuracy):
Refer to class 'TopKCategoricalAccuracy' for more details.
Examples:
>>> x = mindspore.Tensor(np.array([[0.2, 0.5, 0.3, 0.6, 0.2], [0.1, 0.35, 0.5, 0.2, 0.],
>>> x = Tensor(np.array([[0.2, 0.5, 0.3, 0.6, 0.2], [0.1, 0.35, 0.5, 0.2, 0.],
>>> [0.9, 0.6, 0.2, 0.01, 0.3]]), mindspore.float32)
>>> y = mindspore.Tensor(np.array([2, 0, 1]), mindspore.float32)
>>> y = Tensor(np.array([2, 0, 1]), mindspore.float32)
>>> topk = nn.Top5CategoricalAccuracy()
>>> topk.clear()
>>> topk.update(x, y)

6
mindspore/nn/optim/adam.py
View File

@ -161,7 +161,7 @@ class Adam(Optimizer):
Examples:
>>> net = Net()
>>> loss = nn.SoftmaxCrossEntropyWithLogits()
>>> optim = Adam(params=net.trainable_params())
>>> optim = nn.Adam(params=net.trainable_params())
>>> model = Model(net, loss_fn=loss, optimizer=optim, metrics=None)
"""
@ -252,7 +252,7 @@ class AdamWeightDecay(Optimizer):
Examples:
>>> net = Net()
>>> loss = nn.SoftmaxCrossEntropyWithLogits()
>>> optim = AdamWeightDecay(params=net.trainable_params())
>>> optim = nn.AdamWeightDecay(params=net.trainable_params())
>>> model = Model(net, loss_fn=loss, optimizer=optim, metrics=None)
"""
def __init__(self, params, learning_rate=1e-3, beta1=0.9, beta2=0.999, eps=1e-6, weight_decay=0.0):
@ -306,7 +306,7 @@ class AdamWeightDecayDynamicLR(Optimizer):
Examples:
>>> net = Net()
>>> loss = nn.SoftmaxCrossEntropyWithLogits()
>>> optim = AdamWeightDecayDynamicLR(params=net.trainable_params(), decay_steps=10)
>>> optim = nn.AdamWeightDecayDynamicLR(params=net.trainable_params(), decay_steps=10)
>>> model = Model(net, loss_fn=loss, optimizer=optim, metrics=None)
"""
def __init__(self,

2
mindspore/nn/optim/ftrl.py
View File

@ -87,7 +87,7 @@ class FTRL(Optimizer):
Examples:
>>> net = Net()
>>> loss = nn.SoftmaxCrossEntropyWithLogits()
>>> opt = FTRL(net.trainable_params())
>>> opt = nn.FTRL(net.trainable_params())
>>> model = Model(net, loss_fn=loss, optimizer=opt, metrics=None)
"""
def __init__(self, params, initial_accum=0.1, learning_rate=0.001, lr_power=-0.5, l1=0.0, l2=0.0,

2
mindspore/nn/optim/lamb.py
View File

@ -163,7 +163,7 @@ class Lamb(Optimizer):
Examples:
>>> net = Net()
>>> loss = nn.SoftmaxCrossEntropyWithLogits()
>>> optim = Lamb(params=net.trainable_params(), decay_steps=10)
>>> optim = nn.Lamb(params=net.trainable_params(), decay_steps=10)
>>> model = Model(net, loss_fn=loss, optimizer=optim, metrics=None)
"""

4
mindspore/nn/optim/lars.py
View File

@ -90,8 +90,8 @@ class LARS(Cell):
Examples:
>>> net = Net()
>>> loss = nn.SoftmaxCrossEntropyWithLogits()
>>> opt = Momentum(net.trainable_params(), 0.1, 0.9)
>>> opt_lars = LARS(opt, epsilon=1e-08, hyperpara=0.02)
>>> opt = nn.Momentum(net.trainable_params(), 0.1, 0.9)
>>> opt_lars = nn.LARS(opt, epsilon=1e-08, hyperpara=0.02)
>>> model = Model(net, loss_fn=loss, optimizer=opt_lars, metrics=None)
"""

2
mindspore/nn/optim/momentum.py
View File

@ -83,7 +83,7 @@ class Momentum(Optimizer):
Examples:
>>> net = Net()
>>> loss = nn.SoftmaxCrossEntropyWithLogits()
>>> optim = Momentum(params=net.trainable_params(), learning_rate=0.1, momentum=0.9)
>>> optim = nn.Momentum(params=net.trainable_params(), learning_rate=0.1, momentum=0.9)
>>> model = Model(net, loss_fn=loss, optimizer=optim, metrics=None)
"""
def __init__(self, params, learning_rate, momentum, weight_decay=0.0, loss_scale=1.0,

2
mindspore/nn/optim/rmsprop.py
View File

@ -132,7 +132,7 @@ class RMSProp(Optimizer):
Examples:
>>> net = Net()
>>> loss = nn.SoftmaxCrossEntropyWithLogits()
>>> opt = RMSProp(params=net.trainable_params(), learning_rate=lr)
>>> opt = nn.RMSProp(params=net.trainable_params(), learning_rate=lr)
>>> model = Model(net, loss, opt)
"""
def __init__(self, params, learning_rate=0.1, decay=0.9, momentum=0.0, epsilon=1e-10,

2
mindspore/nn/optim/sgd.py
View File

@ -77,7 +77,7 @@ class SGD(Optimizer):
Examples:
>>> net = Net()
>>> loss = nn.SoftmaxCrossEntropyWithLogits()
>>> optim = SGD(params=net.trainable_params())
>>> optim = nn.SGD(params=net.trainable_params())
>>> model = Model(net, loss_fn=loss, optimizer=optim, metrics=None)
"""
def __init__(self, params, learning_rate=0.1, momentum=0.0, dampening=0.0, weight_decay=0.0, nesterov=False,

29
mindspore/nn/wrap/cell_wrapper.py
View File

@ -50,8 +50,8 @@ class WithLossCell(Cell):
>>> net_with_criterion = nn.WithLossCell(net, loss_fn)
>>>
>>> batch_size = 2
>>> data = mindspore.Tensor(np.ones([batch_size, 3, 64, 64]).astype(np.float32) * 0.01)
>>> label = mindspore.Tensor(np.ones([batch_size, 1, 1, 1]).astype(np.int32))
>>> data = Tensor(np.ones([batch_size, 3, 64, 64]).astype(np.float32) * 0.01)
>>> label = Tensor(np.ones([batch_size, 1, 1, 1]).astype(np.int32))
>>>
>>> net_with_criterion(data, label)
"""
@ -62,16 +62,6 @@ class WithLossCell(Cell):
self._loss_fn = loss_fn
def construct(self, data, label):
"""
Computes loss based on the wrapped loss cell.
Args:
data (Tensor): Tensor data to train.
label (Tensor): Tensor label data.
Returns:
Tensor, compute result.
"""
out = self._backbone(data)
return self._loss_fn(out, label)
@ -137,19 +127,6 @@ class WithGradCell(Cell):
self.network_with_loss.set_train()
def construct(self, data, label):
"""
Computes gradients based on the wrapped gradients cell.
Note:
Run in PyNative mode.
Args:
data (Tensor): Tensor data to train.
label (Tensor): Tensor label data.
Returns:
Tensor, return compute gradients.
"""
weights = self.weights
if self.sens is None:
grads = self.grad(self.network_with_loss, weights)(data, label)
@ -355,7 +332,7 @@ class ParameterUpdate(Cell):
>>> param = network.parameters_dict()['learning_rate']
>>> update = nn.ParameterUpdate(param)
>>> update.phase = "update_param"
>>> lr = mindspore.Tensor(0.001, mindspore.float32)
>>> lr = Tensor(0.001, mindspore.float32)
>>> update(lr)
"""

23
mindspore/nn/wrap/grad_reducer.py
View File

@ -120,25 +120,36 @@ class DistributedGradReducer(Cell):
ValueError: If degree is not a int or less than 0.
Examples:
>>> from mindspore.communication import get_group_size
>>> from mindspore.communication import init, get_group_size
>>> from mindspore.ops import composite as C
>>> from mindspore.ops import operations as P
>>> from mindspore.ops import functional as F
>>> from mindspore import context
>>> from mindspore import nn
>>> from mindspore import ParallelMode, ParameterTuple
>>>
>>> device_id = int(os.environ["DEVICE_ID"])
>>> context.set_context(mode=context.GRAPH_MODE, device_target="Ascend", save_graphs=True,
>>> device_id=int(device_id), enable_hccl=True)
>>> init()
>>> context.reset_auto_parallel_context()
>>> context.set_auto_parallel_context(parallel_mode=ParallelMode.DATA_PARALLEL)
>>>
>>>
>>> class TrainingWrapper(nn.Cell):
>>> def __init__(self, network, optimizer, sens=1.0):
>>> super(TrainingWrapper, self).__init__(auto_prefix=False)
>>> self.network = network
>>> self.weights = mindspore.ParameterTuple(network.trainable_params())
>>> self.network.add_flags(defer_inline=True)
>>> self.weights = ParameterTuple(network.trainable_params())
>>> self.optimizer = optimizer
>>> self.grad = C.GradOperation('grad', get_by_list=True, sens_param=True)
>>> self.sens = sens
>>> self.reducer_flag = False
>>> self.grad_reducer = None
>>> self.parallel_mode = context.get_auto_parallel_context("parallel_mode")
>>> if self.parallel_mode in [mindspore.ParallelMode.DATA_PARALLEL,
>>> mindspore.ParallelMode.HYBRID_PARALLEL]:
>>> if self.parallel_mode in [ParallelMode.DATA_PARALLEL,
>>> ParallelMode.HYBRID_PARALLEL]:
>>> self.reducer_flag = True
>>> if self.reducer_flag:
>>> mean = context.get_auto_parallel_context("mirror_mean")
@ -161,8 +172,8 @@ class DistributedGradReducer(Cell):
>>> network = Net()
>>> optimizer = nn.Momentum(network.trainable_params(), learning_rate=0.1, momentum=0.9)
>>> train_cell = TrainingWrapper(network, optimizer)
>>> inputs = mindspore.Tensor(np.ones([16, 16]).astype(np.float32))
>>> label = mindspore.Tensor(np.zeros([16, 16]).astype(np.float32))
>>> inputs = Tensor(np.ones([16, 16]).astype(np.float32))
>>> label = Tensor(np.zeros([16, 16]).astype(np.float32))
>>> grads = train_cell(inputs, label)
"""

22
mindspore/nn/wrap/loss_scale.py
View File

@ -65,9 +65,10 @@ class DynamicLossScaleUpdateCell(Cell):
>>> train_network = nn.TrainOneStepWithLossScaleCell(net_with_loss, optimizer, scale_update_cell=manager)
>>> train_network.set_train()
>>>
>>> inputs = mindspore.Tensor(np.ones([16, 16]).astype(np.float32))
>>> label = mindspore.Tensor(np.zeros([16, 16]).astype(np.float32))
>>> output = train_network(inputs, label)
>>> inputs = Tensor(np.ones([16, 16]).astype(np.float32))
>>> label = Tensor(np.zeros([16, 16]).astype(np.float32))
>>> scaling_sens = Tensor(np.full((1), np.finfo(np.float32).max), dtype=mindspore.float32)
>>> output = train_network(inputs, label, scaling_sens)
"""
def __init__(self,
@ -126,13 +127,14 @@ class FixedLossScaleUpdateCell(Cell):
Examples:
>>> net_with_loss = Net()
>>> optimizer = nn.Momentum(net_with_loss.trainable_params(), learning_rate=0.1, momentum=0.9)
>>> manager = nn.FixedLossScaleUpdateCell(loss_scale_value=2**12, scale_factor=2, scale_window=1000)
>>> manager = nn.FixedLossScaleUpdateCell(loss_scale_value=2**12)
>>> train_network = nn.TrainOneStepWithLossScaleCell(net_with_loss, optimizer, scale_update_cell=manager)
>>> train_network.set_train()
>>>
>>> inputs = mindspore.Tensor(np.ones([16, 16]).astype(np.float32))
>>> label = mindspore.Tensor(np.zeros([16, 16]).astype(np.float32))
>>> output = train_network(inputs, label)
>>> inputs = Tensor(np.ones([16, 16]).astype(np.float32))
>>> label = Tensor(np.zeros([16, 16]).astype(np.float32))
>>> scaling_sens = Tensor(np.full((1), np.finfo(np.float32).max), dtype=mindspore.float32)
>>> output = train_network(inputs, label, scaling_sens)
"""
def __init__(self, loss_scale_value):
@ -181,9 +183,9 @@ class TrainOneStepWithLossScaleCell(Cell):
>>> train_network = nn.TrainOneStepWithLossScaleCell(net_with_loss, optimizer, scale_update_cell=manager)
>>> train_network.set_train()
>>>
>>> inputs = mindspore.Tensor(np.ones([16, 16]).astype(np.float32))
>>> label = mindspore.Tensor(np.zeros([16, 16]).astype(np.float32))
>>> scaling_sens = mindspore.Tensor(np.full((1), np.finfo(np.float32).max), dtype=mindspore.float32)
>>> inputs = Tensor(np.ones([16, 16]).astype(np.float32))
>>> label = Tensor(np.zeros([16, 16]).astype(np.float32))
>>> scaling_sens = Tensor(np.full((1), np.finfo(np.float32).max), dtype=mindspore.float32)
>>> output = train_network(inputs, label, scaling_sens)
"""