mindspore 2.3.0__cp310-cp310-win_amd64.whl → 2.4.0__cp310-cp310-win_amd64.whl

mindspore/mint/nn/functional.py

@@ -14,7 +14,8 @@
 # ============================================================================
 """mint nn functional."""
 from __future__ import absolute_import
-from mindspore.ops.extend import max_pool2d
+import mindspore.ops as ops
+from mindspore.ops.function.nn_func import max_pool2d_ext as max_pool2d
 from mindspore.ops.functional import (
     conv_transpose2d,
     grid_sample
@@ -26,7 +27,7 @@ from mindspore.ops.functional import (
 # 3
 
 # 4
-
+from mindspore.ops.function.nn_func import interpolate_ext as interpolate
 # 5
 from mindspore.ops.function.nn_func import pad_ext as pad
 # 6
@@ -36,7 +37,7 @@ from mindspore.ops.auto_generate import fold_ext as fold
 # 8
 from mindspore.ops.functional import layer_norm
 # 9
-from mindspore.ops.function.nn_func import interpolate_ext as interpolate
+
 # 10
 
 # 11
@@ -50,11 +51,9 @@ from mindspore.ops.function.nn_func import dropout_ext as dropout
 # 15
 
 # 16
-
-# 17
-from mindspore.ops.function.nn_func import binary_cross_entropy
+from mindspore.ops.function.nn_func import log_softmax_ext as log_softmax
 # 18
-
+from mindspore.ops.auto_generate import prelu
 # 19
 
 # 20
@@ -147,7 +146,6 @@ from mindspore.ops.functional import embedding
 # 63
 
 # 64
-from mindspore.ops.extend import one_hot as one_hot_ext
 
 # 65
 
@@ -204,7 +202,7 @@ from mindspore.ops.function.nn_func import avg_pool2d_ext as avg_pool2d
 # 91
 
 # 92
-from mindspore.ops.extend import leaky_relu_ext as leaky_relu
+from mindspore.ops.auto_generate import leaky_relu_ext as leaky_relu
 # 93
 from mindspore.ops.auto_generate import softplus_ext as softplus  # pylint: disable=W0611
 # 94
@@ -218,14 +216,107 @@ from mindspore.ops.function.math_func import tanh
 # 98
 
 # 99
-
+from mindspore.ops.auto_generate import selu_ext as selu  # pylint: disable=W0611
 # 100
-from mindspore.ops.function import binary_cross_entropy_with_logits as bce_with_logits
+from mindspore.ops.auto_generate import softshrink  # pylint: disable=W0611
+# 220
+from mindspore.ops.function.nn_func import hardshrink  # pylint: disable=W0611
+# 221
+from mindspore.ops.function.nn_func import hardsigmoid  # pylint: disable=W0611
+# 222
+from mindspore.ops.function.nn_func import hardswish  # pylint: disable=W0611
+# 267
+from mindspore.ops.auto_generate import mish_ext as mish  # pylint: disable=W0611
+# 238
+from mindspore.ops.auto_generate import l1_loss_ext as l1_loss  # pylint: disable=W0611
+
+# 257
+
+# 258
+from mindspore.ops.function.nn_func import mse_loss_ext as mse_loss
+# 259
+
 # 323
 
 # 324
 from mindspore.ops.auto_generate import elu_ext as elu
-# 325
+
+# 556
+from mindspore.ops.function.nn_func import logsigmoid_ext as logsigmoid
+
+from mindspore.ops.auto_generate import adaptive_avg_pool1d
+
+from mindspore.ops.functional import adaptive_avg_pool2d_ext as adaptive_avg_pool2d
+
+
+def binary_cross_entropy(input, target, weight=None, reduction='mean'):
+    r"""
+    Computes the binary cross entropy(Measure the difference information between two probability distributions) between
+    predictive value `input` and target value `target`.
+
+    Set `input` as :math:`x`, `target` as :math:`y`, output as :math:`\ell(x, y)`, the
+    weight of nth batch of binary cross entropy is :math:`w_n`.
+    Let,
+
+    .. math::
+        L = \{l_1,\dots,l_N\}^\top, \quad
+        l_n = - w_n \left[ y_n \cdot \log x_n + (1 - y_n) \cdot \log (1 - x_n) \right]
+
+    In which, :math:`L` indicates the loss of all `batch_size`, :math:`l` indicates the loss of one `batch_size`,
+    and :math:`n` indicates one `batch_size` in the :math:`1-N` range. 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}
+
+    .. warning::
+        - The value of `input` must range from `0` to `l`.
+
+    Args:
+        input (Tensor): The predictive value whose data type must be float16 or float32.
+        target (Tensor): The target value which has the same shape and data type as `input`.
+            And the data type is float16 or float32.
+        weight (Tensor, optional): A rescaling weight applied to the loss of each batch element.
+            Its shape must be able to broadcast to that of `input` and `target`.
+            And it must have the same shape and data type as `input`. Default: ``None`` . If set to ``None`` ,
+            the loss function
+            will not consider any sample weights, and each sample will be treated as having equal importance
+            when calculating the loss.
+        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.
+
+    Returns:
+        Tensor or Scalar. Returns Tensor that has the same dtype and shape as `input` if `reduction` is ``'none'``.
+        Otherwise, returns a scalar Tensor.
+
+    Raises:
+        TypeError: If `input`, `target` or `weight` is not a Tensor.
+        TypeError: If dtype of `input`, `target` or `weight` (if given) is neither float16 nor float32.
+        ValueError: If `reduction` is not one of ``'none'``, ``'mean'`` or ``'sum'``.
+        ValueError: If shape of `target` is not the same as `input` or `weight` (if given).
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.array([0.2, 0.7, 0.1]), mindspore.float32)
+        >>> target = Tensor(np.array([0., 1., 0.]), mindspore.float32)
+        >>> weight = Tensor(np.array([1, 2, 2]), mindspore.float32)
+        >>> output = mint.nn.functional.binary_cross_entropy(input, target, weight)
+        >>> print(output)
+        0.38240486
+    """
+    return ops.function.binary_cross_entropy(input, target, weight, reduction)
 
 
 def binary_cross_entropy_with_logits(input, target, weight=None, reduction='mean', pos_weight=None):
@@ -317,11 +408,11 @@ def binary_cross_entropy_with_logits(input, target, weight=None, reduction='mean
         >>> 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)
+        >>> output = mint.nn.functional.binary_cross_entropy_with_logits(input, target, weight, 'mean', pos_weight)
         >>> print(output)
         0.3463612
     """
-    return bce_with_logits(input, target, weight, pos_weight, reduction)
+    return ops.function.binary_cross_entropy_with_logits(input, target, weight, pos_weight, reduction)
 
 
 def one_hot(tensor, num_classes=-1):
@@ -359,7 +450,7 @@ def one_hot(tensor, num_classes=-1):
          [0 1 0]
          [0 0 1]]
     """
-    return one_hot_ext(tensor, num_classes)
+    return ops.function.array_func.one_hot_ext(tensor, num_classes)
 
 
 __all__ = [
@@ -372,7 +463,7 @@ __all__ = [
     # 3
 
     # 4
-
+    "interpolate",
     # 5
     'pad',
     # 6
@@ -382,7 +473,7 @@ __all__ = [
     # 8
     'layer_norm',
     # 9
-    'interpolate',
+
     # 10
 
     # 11
@@ -396,11 +487,11 @@ __all__ = [
     # 15
 
     # 16
-
+    'log_softmax',
     # 17
 
     # 18
-
+    'prelu',
     # 19
     'binary_cross_entropy',
     # 20
@@ -570,4 +661,19 @@ __all__ = [
     # 324
     'elu',
     # 325
+
+    #556
+    'logsigmoid',
+
+    # 257
+
+    # 258
+    'mse_loss',
+    # 259
+
+    'adaptive_avg_pool1d',
+
+    'adaptive_avg_pool2d',
+
+
 ]

mindspore/mint/nn/layer/__init__.py

@@ -0,0 +1,39 @@
+# Copyright 2024 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""
+Layer.
+
+The high-level components(Cells) used to construct the neural network.
+"""
+from __future__ import absolute_import
+
+from mindspore.mint.nn.layer import normalization
+from mindspore.mint.nn.layer import activation
+from mindspore.mint.nn.layer import pooling
+from mindspore.mint.nn.layer.normalization import GroupNorm
+from mindspore.mint.nn.layer.normalization import BatchNorm1d
+from mindspore.mint.nn.layer.normalization import BatchNorm2d
+from mindspore.mint.nn.layer.normalization import BatchNorm3d
+from mindspore.mint.nn.layer.normalization import LayerNorm
+from mindspore.mint.nn.layer.activation import LogSigmoid
+from mindspore.mint.nn.layer.activation import SiLU
+from mindspore.mint.nn.layer.pooling import AdaptiveAvgPool1d
+from mindspore.mint.nn.layer.pooling import AdaptiveAvgPool2d
+
+
+__all__ = []
+__all__.extend(normalization.__all__)
+__all__.extend(activation.__all__)
+__all__.extend(pooling.__all__)

mindspore/mint/nn/layer/activation.py

@@ -0,0 +1,133 @@
+# Copyright 2020-2024 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""activation layer for mint"""
+from __future__ import absolute_import
+from __future__ import division
+
+from mindspore import mint
+from mindspore.nn.cell import Cell
+
+
+class SiLU(Cell):
+    r"""
+    Calculates the SiLU activation function element-wise. It is also sometimes referred to as Swish
+    function.
+
+    The SiLU function is defined as follows:
+
+    .. math::
+
+        \text{SiLU}(x) = x * \sigma(x),
+
+    where :math:`x_i` is an element of the input, :math:`\sigma(x)` is Sigmoid function.
+
+    .. math::
+
+        \text{sigmoid}(x_i) = \frac{1}{1 + \exp(-x_i)},
+
+    SiLU Activation Function Graph:
+
+    .. image:: ../images/SiLU.png
+        :align: center
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Inputs:
+        - **input** (Tensor) - `input` is :math:`x` in the preceding formula.
+          Input with the data type float16 or float32. Tensor of any dimension.
+
+    Outputs:
+        Tensor, with the same type and shape as the `input`.
+
+    Raises:
+        TypeError: If dtype of `input` is neither float16 nor float32.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, mint
+        >>> import numpy as np
+        >>> input = Tensor(np.array([-1, 2, -3, 2, -1]), mindspore.float16)
+        >>> silu = mint.nn.SiLU()
+        >>> output = silu(input)
+        >>> print(output)
+        [-0.269  1.762  -0.1423  1.762  -0.269]
+    """
+
+    def __init__(self):
+        """Initialize SiLU."""
+        super(SiLU, self).__init__()
+
+    def construct(self, x):
+        return mint.nn.functional.silu(x)
+
+
+class LogSigmoid(Cell):
+    r"""
+    Applies logsigmoid activation element-wise. The input is a Tensor with any valid shape.
+
+    Logsigmoid is defined as:
+
+    .. math::
+        \text{logsigmoid}(x_{i}) = \log(\frac{1}{1 + \exp(-x_i)}),
+
+    where :math:`x_{i}` is the element of the input.
+
+    LogSigmoid Activation Function Graph:
+
+    .. image:: ../images/LogSigmoid.png
+        :align: center
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Inputs:
+        - **input** (Tensor) - The input of LogSigmoid with data type of bfloat16, float16 or float32.
+          The shape is :math:`(*)` where :math:`*` means, any number of additional dimensions.
+
+    Outputs:
+        Tensor, with the same type and shape as the `input`.
+
+    Raises:
+        TypeError: If dtype of `input` is not bfloat16, float16 and float32.
+        TypeError: If `input` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor
+        >>> net = mint.nn.LogSigmoid()
+        >>> input = Tensor([1.0, 2.0, 3.0], mindspore.float32)
+        >>> output = net(input)
+        >>> print(output)
+        [-0.31326166 -0.12692806 -0.04858734]
+    """
+    def __init__(self):
+        """Initialize LogSigmoid."""
+        super(LogSigmoid, self).__init__()
+
+    def construct(self, input):
+        return mint.nn.functional.logsigmoid(input)
+
+
+__all__ = [
+    'LogSigmoid',
+    'SiLU',
+]