mindspore 2.2.11__cp39-cp39-win_amd64.whl → 2.3.0__cp39-cp39-win_amd64.whl

mindspore/nn/layer/activation.py

@@ -64,7 +64,7 @@ __all__ = ['Softmin',
 
 class CELU(Cell):
     r"""
-    Continuously differentiable exponential linear units activation function.
+    CELU Activation Operator.
 
     Applies the continuously differentiable exponential linear units function element-wise.
 
@@ -72,9 +72,11 @@ class CELU(Cell):
 
         \text{CELU}(x) = \max(0,x) + \min(0, \alpha * (\exp(x/\alpha) - 1))
 
+    For more details, refer to `CELU <https://arxiv.org/abs/1704.07483>`_ .
+
     CELU Activation Function Graph:
 
-    .. image:: images/CELU.png
+    .. image:: ../images/CELU.png
         :align: center
 
     Args:
@@ -91,7 +93,7 @@ class CELU(Cell):
         TypeError: If `alpha` is not a float.
         ValueError: If `alpha` has the value of 0.
         TypeError: If `x` is not a Tensor.
-        TypeError: If the dtype of 'input_x' is neither float16 nor float32.
+        TypeError: If the dtype of `x` is neither float16 nor float32.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -234,25 +236,24 @@ class Softmax(Cell):
     Softmax is defined as:
 
     .. math::
-        \text{softmax}(x_{i}) =  \frac{\exp(x_i)}{\sum_{j=0}^{n-1}\exp(x_j)},
+        \text{softmax}(input_{i}) =  \frac{\exp(input_i)}{\sum_{j=0}^{n-1}\exp(input_j)},
 
-    where :math:`x_{i}` is the :math:`i`-th slice in the given dimension of the input Tensor.
+    where :math:`input_{i}` is the :math:`i`-th slice in the given dimension of the input Tensor.
 
     Args:
-        axis (Union[int, tuple[int]]): The axis to apply Softmax operation, if the dimension of input `x` is x.ndim,
-            the range of axis is `[-x.ndim, x.ndim)`, -1 means the last dimension. Default: ``-1`` .
+        axis (int, optional): The axis to apply Softmax operation, if the dimension of `input` is input.ndim,
+            the range of axis is `[-input.ndim, input.ndim)`, -1 means the last dimension. Default: ``-1`` .
 
     Inputs:
-        - **x** (Tensor) - The input of Softmax with data type of float16 or float32.
+        - **input** (Tensor) - The input of Softmax.
 
     Outputs:
-        Tensor, which has the same type and shape as `x` with values in the range[0,1].
+        Tensor, which has the same type and shape as `input` with values in the range[0, 1].
 
     Raises:
         TypeError: If `axis` is neither an int nor a tuple.
-        TypeError: If dtype of `x` is neither float16 nor float32.
         ValueError: If `axis` is a tuple whose length is less than 1.
-        ValueError: If `axis` is a tuple whose elements are not all in range [-len(x), len(x)).
+        ValueError: If `axis` is a tuple whose elements are not all in range `[-input.ndim, input.ndim)`.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -262,9 +263,9 @@ class Softmax(Cell):
         >>> from mindspore import Tensor, nn
         >>> import numpy as np
         >>> # axis = -1(default), and the sum of return value is 1.0.
-        >>> x = Tensor(np.array([-1, -2, 0, 2, 1]), mindspore.float16)
+        >>> input = Tensor(np.array([-1, -2, 0, 2, 1]), mindspore.float16)
         >>> softmax = nn.Softmax()
-        >>> output = softmax(x)
+        >>> output = softmax(input)
         >>> print(output)
         [0.03168 0.01166 0.0861  0.636   0.2341 ]
     """
@@ -274,13 +275,13 @@ class Softmax(Cell):
         super(Softmax, self).__init__()
         self.softmax = P.Softmax(axis)
 
-    def construct(self, x):
-        return self.softmax(x)
+    def construct(self, input):
+        return self.softmax(input)
 
 
 class LogSoftmax(Cell):
     r"""
-    Applies the LogSoftmax function to n-dimensional input tensor.
+    Applies the LogSoftmax function to n-dimensional input tensor element-wise.
 
     The input is transformed by the Softmax function and then by the log function to lie in range[-inf,0).
 
@@ -330,9 +331,8 @@ class LogSoftmax(Cell):
 
 class ELU(Cell):
     r"""
-    Exponential Linear Unit activation function.
-
     Applies the exponential linear unit function element-wise.
+
     The activation function is defined as:
 
     .. math::
@@ -346,21 +346,22 @@ class ELU(Cell):
 
     ELU Activation Function Graph:
 
-    .. image:: images/ELU.png
+    .. image:: ../images/ELU.png
         :align: center
 
     Args:
         alpha (float): The alpha value of ELU, the data type is float. Default: ``1.0`` .
+            Only alpha equal to ``1.0`` is supported currently.
 
     Inputs:
-        - **x** (Tensor) - The input of ELU is a Tensor of any dimension with data type of float16 or float32.
+        - **input_x** (Tensor) - The input of ELU is a Tensor of any dimension with data type of float16 or float32.
 
     Outputs:
-        Tensor, with the same type and shape as the `x`.
+        Tensor, with the same type and shape as the `input_x`.
 
     Raises:
         TypeError: If `alpha` is not a float.
-        TypeError: If dtype of `x` is neither float16 nor float32.
+        TypeError: If dtype of `input_x` is neither float16 nor float32.
         ValueError: If `alpha` is not equal to 1.0.
 
     Supported Platforms:
@@ -388,13 +389,13 @@ class ELU(Cell):
 
 class ReLU(Cell):
     r"""
-    Rectified Linear Unit activation function.
+    Applies ReLU (Rectified Linear Unit activation function) element-wise.
 
     .. math::
 
-        \text{ReLU}(x) = (x)^+ = \max(0, x),
+        \text{ReLU}(input) = (input)^+ = \max(0, input),
 
-    It returns element-wise :math:`\max(0, x)`.
+    It returns element-wise :math:`\max(0, input)`.
 
     .. note::
         The neurons with the negative output
@@ -402,29 +403,28 @@ class ReLU(Cell):
 
     ReLU Activation Function Graph:
 
-    .. image:: images/ReLU.png
+    .. image:: ../images/ReLU.png
         :align: center
 
     Inputs:
-        - **x** (Tensor) - The input of ReLU is a Tensor of any dimension. The data type is `number <https://www.mind
-          spore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_ .
+        - **input** (Tensor) - The input of ReLU is a Tensor of any dimension.
 
     Outputs:
-        Tensor, with the same type and shape as the `x`.
+        Tensor, with the same type and shape as the `input`.
 
     Raises:
-        TypeError: If dtype of `x` is not a number.
+        TypeError: If dtype of `input` is not supported.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore
         >>> from mindspore import Tensor, nn
-        >>> import numpy as np
-        >>> x = Tensor(np.array([-1, 2, -3, 2, -1]), mindspore.float16)
+        >>> input = Tensor(np.array([-1, 2, -3, 2, -1]), mindspore.float16)
         >>> relu = nn.ReLU()
-        >>> output = relu(x)
+        >>> output = relu(input)
         >>> print(output)
         [0. 2. 0. 2. 0.]
     """
@@ -440,7 +440,7 @@ class ReLU(Cell):
 
 class ReLU6(Cell):
     r"""
-    Compute ReLU6 activation function.
+    Compute ReLU6 activation function element-wise.
 
     ReLU6 is similar to ReLU with a upper limit of 6, which if the inputs are greater than 6, the outputs
     will be suppressed to 6.
@@ -452,7 +452,7 @@ class ReLU6(Cell):
 
     ReLU6 Activation Function Graph:
 
-    .. image:: images/ReLU6.png
+    .. image:: ../images/ReLU6.png
         :align: center
 
     Inputs:
@@ -505,7 +505,7 @@ class LeakyReLU(Cell):
 
     LeakyReLU Activation Function Graph:
 
-    .. image:: images/LeakyReLU.png
+    .. image:: ../images/LeakyReLU.png
         :align: center
 
     Args:
@@ -547,8 +547,7 @@ class LeakyReLU(Cell):
 
 class RReLU(Cell):
     r"""
-
-    Randomized Leaky ReLU activation function.
+    Applies RReLU (Randomized Leaky ReLU activation function) element-wise.
 
     The activation function is defined as:
 
@@ -575,7 +574,7 @@ class RReLU(Cell):
         TypeError: If `lower` is not a float or an int.
         TypeError: If `upper` is not a float or an int.
         TypeError: If `x` is not a Tensor.
-        TypeError: If `x` is not a Tensor of mindspore.float16 or mindpore.float32.
+        TypeError: If `x` is not a Tensor of mindspore.float16 or mindspore.float32.
         ValueError: If `lower` is greater than upper.
 
     Supported Platforms:
@@ -621,11 +620,11 @@ class RReLU(Cell):
 
 class SeLU(Cell):
     r"""
-    Activation function SeLU (Scaled exponential Linear Unit).
+    Applies activation function SeLU (Scaled exponential Linear Unit) element-wise.
 
     SeLU Activation Function Graph:
 
-    .. image:: images/SeLU.png
+    .. image:: ../images/SeLU.png
         :align: center
 
     Refer to :func:`mindspore.ops.selu` for more details.
@@ -656,15 +655,13 @@ class SeLU(Cell):
 
 class SiLU(Cell):
     r"""
-    Sigmoid Linear Unit activation function.
-
     Applies the silu linear unit function element-wise.
 
     .. math::
 
         \text{SiLU}(x) = x * \sigma(x),
 
-    where :math:`x_i` is input, :math:`\sigma(x)` is Sigmoid function.
+    where :math:`x_i` is an element of the input, :math:`\sigma(x)` is Sigmoid function.
 
     .. math::
 
@@ -672,17 +669,18 @@ class SiLU(Cell):
 
     SiLU Activation Function Graph:
 
-    .. image:: images/SiLU.png
+    .. image:: ../images/SiLU.png
         :align: center
 
     Inputs:
-        - **x** (Tensor) - Input with the data type float16 or float32.
+        - **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 `x`.
+        Tensor, with the same type and shape as the `input`.
 
     Raises:
-        TypeError: If dtype of `x` is neither float16 nor float32.
+        TypeError: If dtype of `input` is neither float16 nor float32.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -691,9 +689,9 @@ class SiLU(Cell):
         >>> import mindspore
         >>> from mindspore import Tensor, nn
         >>> import numpy as np
-        >>> x = Tensor(np.array([-1, 2, -3, 2, -1]), mindspore.float16)
+        >>> input = Tensor(np.array([-1, 2, -3, 2, -1]), mindspore.float16)
         >>> silu = nn.SiLU()
-        >>> output = silu(x)
+        >>> output = silu(input)
         >>> print(output)
         [-0.269  1.762  -0.1423  1.762  -0.269]
     """
@@ -720,7 +718,7 @@ class Tanh(Cell):
 
     Tanh Activation Function Graph:
 
-    .. image:: images/Tanh.png
+    .. image:: ../images/Tanh.png
         :align: center
 
     Inputs:
@@ -757,9 +755,7 @@ class Tanh(Cell):
 
 class Tanhshrink(Cell):
     r"""
-    Tanhshrink activation function.
-
-    The tanhshrink function is evaluated by element and returns a new tensor.
+    Applies Tanhshrink activation function element-wise and returns a new tensor.
 
     Tanh function is defined as:
 
@@ -782,7 +778,7 @@ class Tanhshrink(Cell):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> import mindspore
+        >>> import mindspore as ms
         >>> from mindspore import Tensor, nn
         >>> import numpy as np
         >>> x = Tensor(np.array([1, 2, 3, 2, 1]), ms.float16)
@@ -815,7 +811,7 @@ class Hardtanh(Cell):
 
     Hardtanh Activation Function Graph:
 
-    .. image:: images/Hardtanh.png
+    .. image:: ../images/Hardtanh.png
         :align: center
 
     Note:
@@ -868,8 +864,6 @@ class Hardtanh(Cell):
 
 class GELU(Cell):
     r"""
-    Gaussian error linear unit activation function.
-
     Applies GELU function to each element of the input. The input is a Tensor with any valid shape.
 
     GELU is defined as:
@@ -883,7 +877,7 @@ class GELU(Cell):
 
     GELU Activation Function Graph:
 
-    .. image:: images/GELU.png
+    .. image:: ../images/GELU.png
         :align: center
 
     Args:
@@ -898,14 +892,14 @@ class GELU(Cell):
             :math:`x * P(X <= x) = 0.5 * x * (1 + erf(x / \sqrt(2)))`, where P(X) ~ N(0, 1).
 
     Inputs:
-        - **x** (Tensor) - The input of GELU with data type of float16 or float32.
+        - **x** (Tensor) - The input of GELU with data type of float16, float32, or float64.
           The shape is :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
 
     Outputs:
         Tensor, with the same type and shape as the `x`.
 
     Raises:
-        TypeError: If dtype of `x` is neither float16 nor float32.
+        TypeError: If dtype of `x` is not one of float16, float32, or float64.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -942,8 +936,6 @@ class GELU(Cell):
 
 class FastGelu(Cell):
     r"""
-    Fast Gaussian error linear unit activation function.
-
     Applies FastGelu function to each element of the input. The input is a Tensor with any valid shape.
 
     FastGelu is defined as:
@@ -956,7 +948,7 @@ class FastGelu(Cell):
 
     FastGelu Activation Function Graph:
 
-    .. image:: images/FastGelu.png
+    .. image:: ../images/FastGelu.png
         :align: center
 
     Inputs:
@@ -995,9 +987,7 @@ class FastGelu(Cell):
 
 class Sigmoid(Cell):
     r"""
-    Sigmoid activation function.
-
-    Applies sigmoid-type activation element-wise.
+    Applies sigmoid activation function element-wise.
 
     Sigmoid function is defined as:
 
@@ -1005,23 +995,23 @@ class Sigmoid(Cell):
 
         \text{sigmoid}(x_i) = \frac{1}{1 + \exp(-x_i)},
 
-    where :math:`x_i` is the element of the input.
+    where :math:`x_i` is the element of `x`.
 
     Sigmoid Activation Function Graph:
 
-    .. image:: images/Sigmoid.png
+    .. image:: ../images/Sigmoid.png
         :align: center
 
     Inputs:
-        - **input_x** (Tensor) - Tensor of any dimension, the data type is
-          float16, float32, float64, complex64 or complex128.
+        - **input** (Tensor) - `input` is :math:`x` in the preceding formula. Tensor of any dimension,
+          the data type is float16, float32, float64, complex64 or complex128.
 
     Outputs:
-        Tensor, with the same type and shape as the `input_x`.
+        Tensor, with the same type and shape as the `input`.
 
     Raises:
-        TypeError: If dtype of `input_x` is not float16, float32, float64, complex64 or complex128.
-        TypeError: If `input_x` is not a Tensor.
+        TypeError: If dtype of `input` is not float16, float32, float64, complex64 or complex128.
+        TypeError: If `input` is not a Tensor.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -1030,9 +1020,9 @@ class Sigmoid(Cell):
         >>> import mindspore
         >>> from mindspore import Tensor, nn
         >>> import numpy as np
-        >>> x = Tensor(np.array([-1, -2, 0, 2, 1]), mindspore.float16)
+        >>> input = Tensor(np.array([-1, -2, 0, 2, 1]), mindspore.float16)
         >>> sigmoid = nn.Sigmoid()
-        >>> output = sigmoid(x)
+        >>> output = sigmoid(input)
         >>> print(output)
         [0.2688  0.11914 0.5     0.881   0.7305 ]
     """
@@ -1048,11 +1038,11 @@ class Sigmoid(Cell):
 
 class Softsign(Cell):
     r"""
-    Softsign activation function.
+    Applies softsign activation function element-wise.
 
     Softsign Activation Function Graph:
 
-    .. image:: images/Softsign.png
+    .. image:: ../images/Softsign.png
         :align: center
 
     Refer to :func:`mindspore.ops.softsign` for more details.
@@ -1082,9 +1072,7 @@ class Softsign(Cell):
 
 class PReLU(Cell):
     r"""
-    PReLU activation function.
-
-    Applies the PReLU function element-wise.
+    Applies PReLU activation function element-wise.
 
     PReLU is defined as:
 
@@ -1100,7 +1088,7 @@ class PReLU(Cell):
 
     PReLU Activation Function Graph:
 
-    .. image:: images/PReLU.png
+    .. image:: ../images/PReLU.png
         :align: center
 
     Args:
@@ -1178,7 +1166,7 @@ class PReLU(Cell):
 
 class HSwish(Cell):
     r"""
-    Applies hswish-type activation element-wise. The input is a Tensor with any valid shape.
+    Applies hswish-type activation element-wise.
 
     Hard swish is defined as:
 
@@ -1187,7 +1175,7 @@ class HSwish(Cell):
 
     HSwish Activation Function Graph:
 
-    .. image:: images/HSwish.png
+    .. image:: ../images/HSwish.png
         :align: center
 
     Inputs:
@@ -1225,7 +1213,7 @@ class HSwish(Cell):
 
 class HSigmoid(Cell):
     r"""
-    Hard sigmoid activation function. Calculates the output according to the input elements.
+    Applies Hard sigmoid activation function element-wise.
 
     Hard sigmoid is defined as:
 
@@ -1234,7 +1222,7 @@ class HSigmoid(Cell):
 
     HSigmoid Activation Function Graph:
 
-    .. image:: images/HSigmoid.png
+    .. image:: ../images/HSigmoid.png
         :align: center
 
     Inputs:
@@ -1282,7 +1270,7 @@ class LogSigmoid(Cell):
 
     LogSigmoid Activation Function Graph:
 
-    .. image:: images/LogSigmoid.png
+    .. image:: ../images/LogSigmoid.png
         :align: center
 
     Inputs:
@@ -1378,7 +1366,7 @@ class SoftShrink(Cell):
 
     SoftShrink Activation Function Graph:
 
-    .. image:: images/Softshrink.png
+    .. image:: ../images/Softshrink.png
         :align: center
 
     Args:
@@ -1424,7 +1412,7 @@ class SoftShrink(Cell):
 
 class HShrink(Cell):
     r"""
-    Hard Shrink activation function. Calculates the output according to the input elements.
+    Applies Hard Shrink activation function element-wise.
 
     The formula is defined as follows:
 
@@ -1438,7 +1426,7 @@ class HShrink(Cell):
 
     HShrink Activation Function Graph:
 
-    .. image:: images/HShrink.png
+    .. image:: ../images/HShrink.png
         :align: center
 
     Args:
@@ -1478,7 +1466,8 @@ class HShrink(Cell):
 
 
 class Threshold(Cell):
-    r"""Thresholds each element of the input Tensor.
+    r"""
+    Thresholds each element of the input Tensor.
 
     The formula is defined as follows:
 
@@ -1497,7 +1486,7 @@ class Threshold(Cell):
         - **input_x** (Tensor) - The input of Threshold with data type of float16 or float32.
 
     Outputs:
-        Tensor, the same shape and data type as the input.
+        Tensor, the same shape and data type as the `input_x`.
 
     Raises:
         TypeError: If `threshold` is not a float or an int.
@@ -1528,13 +1517,14 @@ class Threshold(Cell):
 
 class Mish(Cell):
     r"""
-    Computes MISH(A Self Regularized Non-Monotonic Neural Activation Function) of input tensors element-wise.
+    Computes MISH (A Self Regularized Non-Monotonic Neural Activation Function)
+    of input tensors element-wise.
 
     Refer to :func:`mindspore.ops.mish` for more details.
 
     Mish Activation Function Graph:
 
-    .. image:: images/Mish.png
+    .. image:: ../images/Mish.png
         :align: center
 
     Supported Platforms: