mindspore 2.3.0__cp39-none-any.whl → 2.3.0rc2__cp39-none-any.whl

mindspore/mint/nn/__init__.py

@@ -18,7 +18,6 @@ Neural Networks Cells.
 Predefined building blocks or computing units to construct neural networks.
 """
 from __future__ import absolute_import
-from mindspore.nn.cell import Cell
 from mindspore.nn.extend import *
 from mindspore.nn.extend import basic, embedding
 from mindspore.nn.extend import MaxPool2d
@@ -33,9 +32,9 @@ from mindspore.nn.extend import MaxPool2d
 # 5
 
 # 6
-from mindspore.nn.layer.basic import UnfoldExt as Unfold
+
 # 7
-from mindspore.nn.layer.basic import Fold
+
 # 8
 from mindspore.nn.extend.layer import normalization
 from mindspore.nn.extend.layer.normalization import *
@@ -98,7 +97,7 @@ from mindspore.nn.layer.basic import DropoutExt as Dropout
 # 37
 
 # 38
-from mindspore.nn.extend.basic import Linear
+
 # 39
 
 # 40
@@ -222,92 +221,11 @@ from mindspore.nn.extend.basic import Linear
 # 99
 
 # 100
-from mindspore.ops.auto_generate import BCEWithLogitsLoss as BCEWithLogitsLoss_prim
-
-
-class BCEWithLogitsLoss(Cell):
-    r"""
-    Adds sigmoid activation function to `input` as logits, and uses this logits to compute binary cross entropy
-    between the logits and the target.
-
-    Sets input `input` as :math:`X`, input `target` as :math:`Y`, output as :math:`L`. Then,
-
-    .. math::
-        p_{ij} = sigmoid(X_{ij}) = \frac{1}{1 + e^{-X_{ij}}}
-
-    .. math::
-        L_{ij} = -[Y_{ij} \cdot \log(p_{ij}) + (1 - Y_{ij}) \cdot \log(1 - p_{ij})]
-
-    Then,
-
-    .. math::
-        \ell(x, y) = \begin{cases}
-        L, & \text{if reduction} = \text{'none';}\\
-        \operatorname{mean}(L), & \text{if reduction} = \text{'mean';}\\
-        \operatorname{sum}(L),  & \text{if reduction} = \text{'sum'.}
-        \end{cases}
-
-    Args:
-        weight (Tensor, optional): A rescaling weight applied to the loss of each batch element.
-            If not None, it can be broadcast to a tensor with shape of `target`, data type must be float16, float32 or
-            bfloat16(only Atlas A2 series products are supported). Default: ``None`` .
-        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
-            ``'sum'`` . Default: ``'mean'`` .
-
-            - ``'none'``: no reduction will be applied.
-            - ``'mean'``: compute and return the weighted mean of elements in the output.
-            - ``'sum'``: the output elements will be summed.
-
-        pos_weight (Tensor, optional): A weight of positive examples. Must be a vector with length equal to the
-            number of classes. If not None, it must be broadcast to a tensor with shape of `input`, data type
-            must be float16, float32 or bfloat16(only Atlas A2 series products are supported). Default: ``None`` .
-
-    Inputs:
-        - **input** (Tensor) - Input `input` with shape :math:`(N, *)` where :math:`*` means, any number
-          of additional dimensions. The data type must be float16, float32 or bfloat16(only Atlas A2 series products
-          are supported).
-        - **target** (Tensor) - Ground truth label with shape :math:`(N, *)` where :math:`*` means, any number
-          of additional dimensions. The same shape and data type as `input`.
-
-    Outputs:
-        Tensor or Scalar, if `reduction` is ``'none'``, its shape is the same as `input`.
-        Otherwise, a scalar value will be returned.
-
-    Raises:
-        TypeError: If input `input` or `target` is not Tensor.
-        TypeError: If `weight` or `pos_weight` is a parameter.
-        TypeError: If data type of `reduction` is not string.
-        ValueError: If `weight` or `pos_weight` can not be broadcast to a tensor with shape of `input`.
-        ValueError: If `reduction` is not one of ``'none'``, ``'mean'``, ``'sum'``.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import mindspore as ms
-        >>> from mindspore import mint
-        >>> import numpy as np
-        >>> input = ms.Tensor(np.array([[-0.8, 1.2, 0.7], [-0.1, -0.4, 0.7]]).astype(np.float32))
-        >>> target = ms.Tensor(np.array([[0.3, 0.8, 1.2], [-0.6, 0.1, 2.2]]).astype(np.float32))
-        >>> loss = mint.nn.BCEWithLogitsLoss()
-        >>> output = loss(input, target)
-        >>> print(output)
-        0.3463612
-    """
-    def __init__(self, weight=None, reduction='mean', pos_weight=None):
-        super(BCEWithLogitsLoss, self).__init__()
-        self.bce_with_logits = BCEWithLogitsLoss_prim(reduction)
-        self.weight = weight
-        self.pos_weight = pos_weight
-
-    def construct(self, input, target):
-        out = self.bce_with_logits(input, target, self.weight, self.pos_weight)
-        return out
 
 __all__ = [
     'MaxPool2d',
     # 1
-    'BCEWithLogitsLoss',
+
     # 2
 
     # 3
@@ -317,9 +235,9 @@ __all__ = [
     # 5
 
     # 6
-    'Fold',
+
     # 7
-    'Unfold',
+
     # 8
 
     # 9
@@ -381,7 +299,7 @@ __all__ = [
     # 37
 
     # 38
-    'Linear',
+
     # 39
 
     # 40

mindspore/mint/nn/functional.py

@@ -28,11 +28,11 @@ from mindspore.ops.functional import (
 # 4
 
 # 5
-from mindspore.ops.function.nn_func import pad_ext as pad
+from mindspore.ops.functional import pad_ext as pad
 # 6
-from mindspore.ops.auto_generate import unfold_ext as unfold
+
 # 7
-from mindspore.ops.auto_generate import fold_ext as fold
+
 # 8
 from mindspore.ops.functional import layer_norm
 # 9
@@ -52,7 +52,7 @@ from mindspore.ops.function.nn_func import dropout_ext as dropout
 # 16
 
 # 17
-from mindspore.ops.function.nn_func import binary_cross_entropy
+
 # 18
 
 # 19
@@ -80,14 +80,13 @@ from mindspore.ops.function.nn_func import binary_cross_entropy
 # 30
 
 # 31
-from mindspore.ops.function.nn_func import softmax_ext as softmax
 
 # 32
 
 # 33
 
 # 34
-from mindspore.ops.function.nn_func import batch_norm_ext as batch_norm
+
 # 35
 
 # 36
@@ -95,7 +94,7 @@ from mindspore.ops.functional import gelu
 # 37
 
 # 38
-from mindspore.ops.functional import dense as linear
+
 # 39
 from mindspore.ops.functional import group_norm
 # 40
@@ -147,7 +146,6 @@ from mindspore.ops.functional import embedding
 # 63
 
 # 64
-from mindspore.ops.extend import one_hot as one_hot_ext
 
 # 65
 
@@ -206,7 +204,7 @@ from mindspore.ops.function.nn_func import avg_pool2d_ext as avg_pool2d
 # 92
 from mindspore.ops.extend import leaky_relu_ext as leaky_relu
 # 93
-from mindspore.ops.auto_generate import softplus_ext as softplus  # pylint: disable=W0611
+from mindspore.ops.function.nn_func import softplus_ext as softplus
 # 94
 from mindspore.ops.function.math_func import tanh
 # 95
@@ -220,153 +218,12 @@ from mindspore.ops.function.math_func import tanh
 # 99
 
 # 100
-from mindspore.ops.function import binary_cross_entropy_with_logits as bce_with_logits
-# 323
-
-# 324
-from mindspore.ops.auto_generate import elu_ext as elu
-# 325
-
-
-def binary_cross_entropy_with_logits(input, target, weight=None, reduction='mean', pos_weight=None):
-    r"""
-    Adds sigmoid activation function to `input` as logits, and uses this logits to compute binary cross entropy
-    between the logits and the target.
-    Consistent with the function of `mindspore.ops.binary_cross_entropy_with_logits` .
-
-    Sets input `input` as :math:`X`, input `target` as :math:`Y`, input `weight` as :math:`W`, output as :math:`L`.
-    Then,
-
-    .. math::
-
-        \begin{array}{ll} \\
-            p_{ij} = sigmoid(X_{ij}) = \frac{1}{1 + e^{-X_{ij}}} \\
-            L_{ij} = -[Y_{ij}log(p_{ij}) + (1 - Y_{ij})log(1 - p_{ij})]
-        \end{array}
-
-    :math:`i` indicates the :math:`i^{th}` sample, :math:`j` indicates the category. Then,
-
-    .. math::
-        \ell(x, y) = \begin{cases}
-        L, & \text{if reduction} = \text{'none';}\\
-        \operatorname{mean}(L), & \text{if reduction} = \text{'mean';}\\
-        \operatorname{sum}(L),  & \text{if reduction} = \text{'sum'.}
-        \end{cases}
-
-    :math:`\ell` indicates the method of calculating the loss. There are three methods:
-    the first method is to provide the loss value directly,
-    the second method is to calculate the average value of all losses,
-    and the third method is to calculate the sum of all losses.
-
-    This operator will multiply the output by the corresponding weight.
-    The tensor :math:`weight` assigns different weights to each piece of data in the batch,
-    and the tensor :math:`pos\_weight` adds corresponding weights to the positive examples of each category.
-
-    In addition, it can trade off recall and precision by adding weights to positive examples.
-    In the case of multi-label classification the loss can be described as:
-
-    .. math::
-        \begin{array}{ll} \\
-            p_{ij,c} = sigmoid(X_{ij,c}) = \frac{1}{1 + e^{-X_{ij,c}}} \\
-            L_{ij,c} = -[P_{c}Y_{ij,c} * log(p_{ij,c}) + (1 - Y_{ij,c})log(1 - p_{ij,c})]
-        \end{array}
-
-    where c is the class number (c>1 for multi-label binary classification, c=1 for single-label binary classification),
-    n is the number of the sample in the batch and :math:`P_c` is the weight of the positive answer for the class c.
-    :math:`P_c>1` increases the recall, :math:`P_c<1` increases the precision.
-
-    Args:
-        input (Tensor): Input `input` with shape :math:`(N, *)` where :math:`*` means, any number
-          of additional dimensions. The data type must be float16, float32 or bfloat16(only Atlas A2 series products
-          are supported).
-        target (Tensor): Ground truth label, has the same shape as `input`.
-          The data type must be float16, float32 or bfloat16(only Atlas A2 series products are supported).
-        weight (Tensor, optional): A rescaling weight applied to the loss of each batch element. It can be
-          broadcast to a tensor with shape of `input`. Data type must be float16, float32 or bfloat16(only
-          Atlas A2 series products are supported).
-          Default: ``None``, `weight` is a Tensor whose value is ``1``.
-        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
-            ``'sum'`` . Default: ``'mean'`` .
-
-            - ``'none'``: no reduction will be applied.
-            - ``'mean'``: compute and return the weighted mean of elements in the output.
-            - ``'sum'``: the output elements will be summed.
-        pos_weight (Tensor, optional): A weight of positive examples. Must be a vector with length equal to the
-          number of classes. It can be broadcast to a tensor with shape of `input`.
-          Data type must be float16, float32 or bfloat16(only Atlas A2 series products are supported).
-          Default: ``None``, it equals to `pos_weight` is a Tensor whose value is ``1``.
-
-    Returns:
-        Tensor or Scalar, if `reduction` is ``'none'``, it's a tensor with the same shape and type as input `input`.
-        Otherwise, the output is a Scalar.
-
-    Raises:
-        TypeError: If input `input`, `target`, `weight`, `pos_weight` is not Tensor.
-        TypeError: If data type of input `reduction` is not string.
-        ValueError: If `weight` or `pos_weight` can not be broadcast to a tensor with shape of `input`.
-        ValueError: If `reduction` is not one of ``'none'``, ``'mean'`` or ``'sum'``.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, mint
-        >>> input = Tensor(np.array([[-0.8, 1.2, 0.7], [-0.1, -0.4, 0.7]]), mindspore.float32)
-        >>> target = Tensor(np.array([[0.3, 0.8, 1.2], [-0.6, 0.1, 2.2]]), mindspore.float32)
-        >>> weight = Tensor(np.array([1.0, 1.0, 1.0]), mindspore.float32)
-        >>> pos_weight = Tensor(np.array([1.0, 1.0, 1.0]), mindspore.float32)
-        >>> output = mint.nn.functional.binary_cross_entropy_with_logits(input, target, weight, pos_weight)
-        >>> print(output)
-        0.3463612
-    """
-    return bce_with_logits(input, target, weight, pos_weight, reduction)
-
-
-def one_hot(tensor, num_classes=-1):
-    r"""
-    Computes a one-hot tensor.
-
-    The locations represented by tensor in `tensor` take value `1`, while all
-    other locations take value `0`.
-
-    Args:
-        tensor (Tensor): A tensor of indices. Tensor of shape :math:`(X_0, \ldots, X_n)`.
-            Data type must be int32 or int64.
-        num_classes (int): A scalar defining the depth of the one-hot dimension, default: ``-1``.
-
-    Returns:
-        Tensor, one-hot tensor.
-
-    Raises:
-        TypeError: If `num_classes` is not an int.
-        TypeError: If dtype of `tensor` is not int32 or int64.
-        ValueError: If `num_classes` is less than -1.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, mint
-        >>> tensor = Tensor(np.array([0, 1, 2]), mindspore.int32)
-        >>> num_classes = 3
-        >>> output = mint.nn.functional.one_hot(tensor, num_classes)
-        >>> print(output)
-        [[1 0 0]
-         [0 1 0]
-         [0 0 1]]
-    """
-    return one_hot_ext(tensor, num_classes)
-
 
 __all__ = [
     'conv_transpose2d',
     'max_pool2d',
     # 1
-    'binary_cross_entropy_with_logits',
+
     # 2
 
     # 3
@@ -376,9 +233,9 @@ __all__ = [
     # 5
     'pad',
     # 6
-    'unfold',
+
     # 7
-    'fold',
+
     # 8
     'layer_norm',
     # 9
@@ -402,7 +259,7 @@ __all__ = [
     # 18
 
     # 19
-    'binary_cross_entropy',
+
     # 20
 
     # 21
@@ -426,13 +283,13 @@ __all__ = [
     # 30
 
     # 31
-    'softmax',
+
     # 32
 
     # 33
 
     # 34
-    'batch_norm',
+
     # 35
 
     # 36
@@ -440,7 +297,7 @@ __all__ = [
     # 37
 
     # 38
-    'linear',
+
     # 39
     'group_norm',
     # 40
@@ -492,7 +349,7 @@ __all__ = [
     # 63
 
     # 64
-    'one_hot',
+
     # 65
 
     # 66
@@ -550,7 +407,7 @@ __all__ = [
     # 92
     'leaky_relu',
     # 93
-
+    'softplus',
     # 94
     'tanh',
     # 95
@@ -564,10 +421,4 @@ __all__ = [
     # 99
 
     # 100
-
-    # 323
-
-    # 324
-    'elu',
-    # 325
 ]

mindspore/mint/optim/adamw.py

@@ -86,20 +86,19 @@ class AdamW(Optimizer):
        \end{aligned}
 
     .. warning::
-        - This is an experimental optimizer API that is subject to change.
-          This module must be used with lr scheduler module in `LRScheduler Class
-          <https://www.mindspore.cn/docs/en/master/api_python/mindspore.experimental.html#lrscheduler-class>`_ .
-        - For Ascend, it is only supported on platforms above Atlas A2.
+        This is an experimental optimizer API that is subject to change.
+        This module must be used with lr scheduler module in `LRScheduler Class
+        <https://www.mindspore.cn/docs/en/master/api_python/mindspore.experimental.html#lrscheduler-class>`_ .
 
     Args:
         params (Union[list(Parameter), list(dict)]): list of parameters to optimize or dicts defining
-            parameter groups.
-        lr (float, optional): learning rate. Default: ``1e-3``.
+            parameter groups
+        lr (Union[int, float, Tensor], optional): learning rate. Default: ``1e-3``.
         betas (Tuple[float, float], optional): The exponential decay rate for the moment estimations.
             Default: ``(0.9, 0.999)``.
         eps (float, optional): term added to the denominator to improve
-            numerical stability. Must be greater than 0. Default: ``1e-8``.
-        weight_decay (float, optional): weight decay (L2 penalty). Default: ``1e-2.``.
+            numerical stability. Default: ``1e-8``.
+        weight_decay (float, optional): weight decay (L2 penalty). Default: ``0.``.
         amsgrad (bool, optional): whether to use the AMSGrad algorithm. Default: ``False``.
 
     Keyword Args:
@@ -110,14 +109,14 @@ class AdamW(Optimizer):
         - **gradients** (tuple[Tensor]) - The gradients of `params`.
 
     Raises:
-        ValueError: If the learning rate is not float.
+        ValueError: If the learning rate is not int, float or Tensor.
         ValueError: If the learning rate is less than 0.
-        ValueError: If the `eps` is less than 0.
+        ValueError: If the `eps` is less than 0.0.
         ValueError: If the `betas` not in the range of [0, 1).
         ValueError: If the `weight_decay` is less than 0.
 
     Supported Platforms:
-        ``Ascend``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> import mindspore
@@ -161,11 +160,11 @@ class AdamW(Optimizer):
         self.exp_avg = self.parameters.clone(prefix="exp_avg", init='zeros')
         self.exp_avg_sq = self.parameters.clone(prefix="exp_avg_sq", init='zeros')
         self.max_exp_avg_sq = self.parameters.clone(prefix="max_exp_avg_sq", init='zeros')
-        self.state_step = Parameter(Tensor([-1], mstype.float32), "state_step")
+        self.state_step = Parameter(Tensor([0], mstype.float32), "state_step")
         self.increase_tensor = Tensor(1, mstype.float32)
         self.assignadd = P.AssignAdd()
         self.op_cast = P.Cast()
-        self.adamw_opt = gen.AdamW()
+        self.adamw_opt = gen.AdamWeightDecayExt()
 
     def construct(self, gradients):
         self.assignadd(self.state_step, self.increase_tensor)
@@ -174,8 +173,10 @@ class AdamW(Optimizer):
             maximize = group.get("maximize")
             start_id = self.group_start_id[group_id]
             end_id = self.group_start_id[group_id + 1]
-            lr = group.get("lr")
-            grads = tuple(gradients[start_id: end_id])
+            lr = self.lrs[group_id]
+            if isinstance(group.get("lr"), float):
+                lr = self.op_cast(group.get("lr"), mstype.float32)
+            grads = tuple([grad if not maximize else F.neg(grad) for grad in gradients[start_id: end_id]])
 
             self.hyper_map(F.partial(_optim_adamw_opt, self.adamw_opt, beta1, beta2, float(lr),
                                      group.get("eps"), group.get("weight_decay"), self.state_step,

mindspore/nn/__init__.py

@@ -21,6 +21,7 @@ from __future__ import absolute_import
 
 from mindspore.nn import layer, loss, optim, wrap, grad, metrics, probability, sparse, dynamic_lr, reinforcement
 from mindspore.nn.learning_rate_schedule import *
+from mindspore.nn.generator import *
 from mindspore.nn.dynamic_lr import *
 from mindspore.nn.cell import Cell, GraphCell
 from mindspore.nn.layer import *
@@ -44,5 +45,6 @@ __all__.extend(sparse.__all__)
 __all__.extend(learning_rate_schedule.__all__)
 __all__.extend(dynamic_lr.__all__)
 __all__.extend(reinforcement.__all__)
+__all__.extend(generator.__all__)
 
 __all__.sort()