mindspore 2.4.10__cp39-cp39-win_amd64.whl → 2.6.0__cp39-cp39-win_amd64.whl

mindspore/nn/probability/bijector/bijector.py

@@ -41,15 +41,20 @@ class Bijector(Cell):
         param (dict): The parameters used to initialize the Bijector. Default: ``None`` .
 
     Note:
-        `dtype` of bijector represents the type of the distributions that the bijector could operate on.
-        When `dtype` is None, there is no enforcement on the type of input value except that the input value
-        has to be float type. During initialization, when `dtype` is None, there is no enforcement on the dtype
-        of the parameters. All parameters should have the same float type, otherwise a TypeError will be raised.
-        Specifically, the parameter type will follow the dtype of the input value, i.e. parameters of the bijector
-        will be casted into the same type as input value when `dtype` is None.
-        When `dtype` is specified, it is forcing the parameters and input value to be the same dtype as `dtype`.
-        When the type of parameters or the type of the input value is not the same as `dtype`, a TypeError will be
-        raised. Only subtype of mindspore.float_type can be used to specify bijector's `dtype`.
+        - `dtype` of bijector represents the type of the distributions that the bijector could operate on.
+        - When `dtype` is None, there is no enforcement on the type of input value except that the input value
+          has to be float type. During initialization, when `dtype` is None, there is no enforcement on the dtype
+          of the parameters. All parameters should have the same float type, otherwise a TypeError will be raised.
+
+          Specifically, the parameter type will follow the dtype of the input value.
+
+          - Parameters of the bijector will be casted into the same type as input value when `dtype` is None.
+
+          - When `dtype` is specified, it is forcing the parameters and input value to be the same dtype as `dtype`.
+            When the type of parameters or the type of the input value is not the same as `dtype`, a TypeError will be
+            raised.
+
+        - Only subtype of mindspore.float_type can be used to specify bijector's `dtype`.
 
     Supported Platforms:
         ``Ascend`` ``GPU``
@@ -226,7 +231,8 @@ class Bijector(Cell):
 
     def cast_param_by_value(self, value, para):
         """
-        Cast the parameter(s) of the bijector to be the same type of input_value.
+        Converts the data type of `para` in the input to the same type as `value`.
+        Typically used by subclasses of Bijector to convert data types of their own parameters.
 
         Args:
             value (Tensor): input value.
@@ -276,7 +282,7 @@ class Bijector(Cell):
             **kwargs (dict): the dictionary of keyword arguments forwarded to subclasses.
 
         Returns:
-            Tensor, the value of logarithm of the derivative of the forward transformation.
+            Tensor, outputs the value of a random variable after mapping.
         """
         return self._forward_log_jacobian(value, *args, **kwargs)
 

mindspore/nn/probability/bijector/gumbel_cdf.py

@@ -33,11 +33,11 @@ class GumbelCDF(Bijector):
         name (str): The name of the Bijector. Default: ``'GumbelCDF'`` .
 
     Note:
-        `scale` must be greater than zero.
-        For `inverse` and `inverse_log_jacobian`, input should be in range of (0, 1).
-        The dtype of `loc` and `scale` must be float.
-        If `loc`, `scale` are passed in as numpy.ndarray or tensor, they have to have
-        the same dtype otherwise an error will be raised.
+        - `scale` must be greater than zero.
+        - For `inverse` and `inverse_log_jacobian`, input should be in range of (0, 1).
+        - The dtype of `loc` and `scale` must be float.
+        - If `loc`, `scale` are passed in as numpy.ndarray or tensor, they have to have
+          the same dtype otherwise an error will be raised.
 
     Raises:
         TypeError: When the dtype of `loc` or `scale` is not float,

mindspore/nn/probability/bijector/invert.py

@@ -25,8 +25,8 @@ class Invert(Bijector):
 
     Args:
         bijector (Bijector): Base Bijector.
-        name (str): The name of the Bijector. Default: ``""`` . When name is set to "", it is actually
-            'Invert' + bijector.name.
+        name (str): The name of the Bijector. Default: ``""`` . When name is set to ``""``, it is actually
+            ``'Invert' + Bijector.name``.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``

mindspore/nn/probability/bijector/scalar_affine.py

@@ -26,11 +26,11 @@ class ScalarAffine(Bijector):
     .. math::
         Y = a * X + b
 
-    where a is the scale factor and b is the shift factor.
+    where :math:`a` is the scale factor and :math:`b` is the shift factor.
 
     Args:
-        scale (float, list, numpy.ndarray, Tensor): The scale factor. Default: ``1.0`` .
-        shift (float, list, numpy.ndarray, Tensor): The shift factor. Default: ``0.0`` .
+        scale (float, list, numpy.ndarray, Tensor): The scale factor. :math:`a` in the formula. Default: ``1.0`` .
+        shift (float, list, numpy.ndarray, Tensor): The shift factor. :math:`b` in the formula. Default: ``0.0`` .
         name (str): The name of the bijector. Default: ``'ScalarAffine'`` .
 
     Note:

mindspore/nn/probability/bijector/softplus.py

@@ -29,10 +29,11 @@ class Softplus(Bijector):
     .. math::
         Y = \frac{\log(1 + e ^ {kX})}{k}
 
-    where k is the sharpness factor.
+    where :math:`k` is the sharpness factor.
 
     Args:
-        sharpness (float, list, numpy.ndarray, Tensor): The scale factor. Default: ``1.0`` .
+        sharpness (float, list, numpy.ndarray, Tensor): The scale factor. :math:`k` in the above formula.
+            Default: ``1.0`` .
         name (str): The name of the Bijector. Default: ``'Softplus'`` .
 
     Note:

mindspore/nn/probability/distribution/beta.py

@@ -37,9 +37,9 @@ class Beta(Distribution):
 
     Args:
         concentration1 (int, float, list, numpy.ndarray, Tensor): The concentration1,
-          also know as alpha of the Beta distribution. Default: ``None`` .
+          also know as :math:`alpha` of the Beta distribution. Default: ``None`` .
         concentration0 (int, float, list, numpy.ndarray, Tensor): The concentration0, also know as
-          beta of the Beta distribution. Default: ``None`` .
+          :math:`beta` of the Beta distribution. Default: ``None`` .
         seed (int): The seed used in sampling. The global seed is used if it is None. Default: ``None`` .
         dtype (mindspore.dtype): The type of the event samples. Default: ``mstype.float32`` .
         name (str): The name of the distribution. Default: ``'Beta'`` .
@@ -51,7 +51,7 @@ class Beta(Distribution):
 
     Raises:
         ValueError: When concentration1 <= 0 or concentration0 >=1.
-        TypeError: When the input `dtype` is not a subclass of float.
+        TypeError: When the input `dtype` is not a float or a subclass of float.
 
     Supported Platforms:
         ``Ascend``

mindspore/nn/probability/distribution/categorical.py

@@ -40,7 +40,7 @@ class Categorical(Distribution):
         probs (Tensor, list, numpy.ndarray): Event probabilities. Default: ``None`` .
         seed (int): The global seed is used in sampling. Global seed is used if it is None. Default: ``None`` .
         dtype (mindspore.dtype): The type of the event samples. Default: ``mstype.int32`` .
-        name (str): The name of the distribution. Default: ``Categorical`` .
+        name (str): The name of the distribution. Default: ``'Categorical'`` .
 
     Note:
         `probs` must have rank at least 1, values are proper probabilities and sum to 1.

mindspore/nn/probability/distribution/cauchy.py

@@ -35,8 +35,10 @@ class Cauchy(Distribution):
     Where :math:`a, b` are loc and scale parameter respectively.
 
     Args:
-        loc (int, float, list, numpy.ndarray, Tensor): The location of the Cauchy distribution. Default: ``None`` .
-        scale (int, float, list, numpy.ndarray, Tensor): The scale of the Cauchy distribution. Default: ``None`` .
+        loc (int, float, list, numpy.ndarray, Tensor): The location of the Cauchy distribution.
+            :math:`a` in the formula. Default: ``None`` .
+        scale (int, float, list, numpy.ndarray, Tensor): The scale of the Cauchy distribution.
+            :math:`b` in the formula. Default: ``None`` .
         seed (int): The seed used in sampling. The global seed is used if it is None. Default: ``None`` .
         dtype (mindspore.dtype): The type of the event samples. Default: ``mstype.float32`` .
         name (str): The name of the distribution. Default: ``'Cauchy'`` .

mindspore/nn/probability/distribution/exponential.py

@@ -35,15 +35,14 @@ class Exponential(Distribution):
     where :math:`\lambda` is the rate of the distribution.
 
     Args:
-        rate (int, float, list, numpy.ndarray, Tensor): The inverse scale. Default: ``None`` .
-        seed (int): The seed used in sampling. The global seed is used if it is None. Default: ``None`` .
-        dtype (mindspore.dtype): The type of the event samples. Default: ``mstype.float32`` .
-        name (str): The name of the distribution. Default: ``'Exponential'`` .
+        rate (int, float, list, numpy.ndarray, Tensor, optional): The inverse scale. :math:`\lambda` in the formula. Default: ``None`` .
+        seed (int, optional): The seed used in sampling. The global seed is used if it is None. Default: ``None`` .
+        dtype (mindspore.dtype, optional): The type of the event samples. Default: ``mstype.float32`` .
+        name (str, optional): The name of the distribution. Default: ``'Exponential'`` .
 
     Note:
-        `rate` must be strictly greater than 0.
-        `dist_spec_args` is `rate`.
-        `dtype` must be a float type because Exponential distributions are continuous.
+        - `rate` must be strictly greater than 0.
+        - `dtype` must be a float type because Exponential distributions are continuous.
 
     Raises:
         ValueError: When rate <= 0.

mindspore/nn/probability/distribution/gamma.py

@@ -39,9 +39,9 @@ class Gamma(Distribution):
 
     Args:
         concentration (int, float, list, numpy.ndarray, Tensor): The concentration,
-          also know as alpha of the Gamma distribution. Default: ``None`` .
+          also know as :math:`\alpha` of the Gamma distribution. Default: ``None`` .
         rate (int, float, list, numpy.ndarray, Tensor): The rate, also know as
-          beta of the Gamma distribution. Default: ``None`` .
+          :math:`\beta` of the Gamma distribution. Default: ``None`` .
         seed (int): The seed used in sampling. The global seed is used if it is None. Default: ``None`` .
         dtype (mindspore.dtype): The type of the event samples. Default: ``mstype.float32`` .
         name (str): The name of the distribution. Default: ``'Gamma'`` .

mindspore/nn/probability/distribution/gumbel.py

@@ -37,8 +37,8 @@ class Gumbel(TransformedDistribution):
     Where :math:`a, b` are loc and scale parameter respectively.
 
     Args:
-        loc (int, float, list, numpy.ndarray, Tensor): The location of Gumbel distribution.
-        scale (int, float, list, numpy.ndarray, Tensor): The scale of Gumbel distribution.
+        loc (int, float, list, numpy.ndarray, Tensor): The location of Gumbel distribution. :math:`a` in the formula.
+        scale (int, float, list, numpy.ndarray, Tensor): The scale of Gumbel distribution. :math:`b` in the formula.
         seed (int): the seed used in sampling. The global seed is used if it is None. Default: ``0`` .
         dtype (mindspore.dtype): type of the distribution. Default: ``mstype.float32`` .
         name (str): the name of the distribution. Default: ``'Gumbel'`` .

mindspore/nn/probability/distribution/half_normal.py

@@ -36,9 +36,11 @@ class HalfNormal(Distribution):
     where :math:`\mu, \sigma` are the mean and the standard deviation of the half normal distribution respectively.
 
     Args:
-        mean (Union[int, float, list, numpy.ndarray, Tensor], optional): The mean of the distribution.
+        mean (Union[int, float, list, numpy.ndarray, Tensor], optional):
+            The mean of the distribution. :math:`\mu` in the formula.
             If this arg is ``None`` , then the mean of the distribution will be passed in runtime. Default: ``None`` .
-        sd (Union[int, float, list, numpy.ndarray, Tensor], optional): The standard deviation of the distribution.
+        sd (Union[int, float, list, numpy.ndarray, Tensor], optional):
+            The standard deviation of the distribution. :math:`\sigma` in the formula.
             If this arg is ``None`` , then the sd of the distribution will be passed in runtime. Default: ``None`` .
         seed (int, optional): The seed used in sampling. The global seed is used if it is None. Default: ``None`` .
         dtype (mindspore.dtype, optional): The type of the event samples. Default: ``mstype.float32`` .
@@ -52,7 +54,7 @@ class HalfNormal(Distribution):
 
     Raises:
         ValueError: When sd <= 0.
-        TypeError: When the input `dtype` is not a subclass of float.
+        TypeError: When the input `dtype` is not a float or a subclass of float.
 
     Supported Platforms:
         ``CPU``

mindspore/nn/probability/distribution/logistic.py

@@ -36,8 +36,10 @@ class Logistic(Distribution):
     where :math:`a, b` are loc and scale parameter respectively.
 
     Args:
-        loc (float, list, numpy.ndarray, Tensor): The location of the Logistic distribution. Default: ``None`` .
-        scale (float, list, numpy.ndarray, Tensor): The scale of the Logistic distribution. Default: ``None`` .
+        loc (float, list, numpy.ndarray, Tensor): The location of the Logistic distribution.
+            :math:`a` in the formula. Default: ``None`` .
+        scale (float, list, numpy.ndarray, Tensor): The scale of the Logistic distribution.
+            :math:`b` in the formula. Default: ``None`` .
         seed (int): The seed used in sampling. The global seed is used if it is None. Default: ``None`` .
         dtype (mindspore.dtype): The type of the event samples. Default: ``mstype.float32`` .
         name (str): The name of the distribution. Default: ``'Logistic'`` .
@@ -49,7 +51,7 @@ class Logistic(Distribution):
 
     Raises:
         ValueError: When scale <= 0.
-        TypeError: When the input `dtype` is not a subclass of float.
+        TypeError: When the input `dtype` is not a float or a subclass of float.
 
     Supported Platforms:
         ``Ascend`` ``GPU``

mindspore/nn/probability/distribution/poisson.py

@@ -36,7 +36,7 @@ class Poisson(Distribution):
     where :math:`\lambda` is the rate of the distribution.
 
     Args:
-        rate (list, numpy.ndarray, Tensor): The rate of the Poisson distribution. Default: ``None`` .
+        rate (list, numpy.ndarray, Tensor): The rate of the Poisson distribution. :math:`\lambda` in the formula. Default: ``None`` .
         seed (int): The seed used in sampling. The global seed is used if it is ``None`` . Default: ``None`` .
         dtype (mindspore.dtype): The type of the event samples. Default: ``mstype.float32`` .
         name (str): The name of the distribution. Default: ``'Poisson'`` .

mindspore/nn/probability/distribution/uniform.py

@@ -36,8 +36,10 @@ class Uniform(Distribution):
     Where :math:`a, b` are the lower and upper bound respectively.
 
     Args:
-        low (int, float, list, numpy.ndarray, Tensor): The lower bound of the distribution. Default: ``None`` .
-        high (int, float, list, numpy.ndarray, Tensor): The upper bound of the distribution. Default: ``None`` .
+        low (int, float, list, numpy.ndarray, Tensor): The lower bound of the distribution.
+            :math:`a` in the formula. Default: ``None`` .
+        high (int, float, list, numpy.ndarray, Tensor): The upper bound of the distribution.
+            :math:`b` in the formula. Default: ``None`` .
         seed (int): The seed uses in sampling. The global seed is used if it is ``None`` . Default: ``None`` .
         dtype (mindspore.dtype): The type of the event samples. Default: ``mstype.float32`` .
         name (str): The name of the distribution. Default: ``'Uniform'`` .
@@ -49,7 +51,7 @@ class Uniform(Distribution):
 
     Raises:
         ValueError: When high <= low.
-        TypeError: When the input `dtype` is not a subclass of float.
+        TypeError: When the input `dtype` is not a float or a subclass of float.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``

mindspore/nn/reinforcement/_tensors_queue.py

@@ -34,7 +34,7 @@ class TensorsQueue(Cell):
         dtype (mindspore.dtype): the data type in the TensorsQueue. Each tensor should have the same dtype.
         shapes (tuple[int64]): the shape of each element in TensorsQueue.
         size (int): the size of the TensorsQueue.
-        name (string): the name of this TensorsQueue. Default: "TQ".
+        name (str): the name of this TensorsQueue. Default: "TQ".
 
     Raises:
         TypeError: If `dtype` is not mindspore number type.

mindspore/nn/reinforcement/tensor_array.py

@@ -34,7 +34,7 @@ class TensorArray(Cell):
         element_shape (tuple[int]): the shape of each tensor in a TensorArray.
         dynamic_size (bool): if ``true`` , the size of TensorArray can be increased. Default: ``True`` .
         size (int): if dynamic_size=False, `size` means the max_size of the TensorArray.
-        name (string): the name of this TensorArray. Default: ``"TA"`` .
+        name (str): the name of this TensorArray. Default: ``"TA"`` .
 
     Supported Platforms:
         ``GPU`` ``CPU``

mindspore/nn/utils/init.py

@@ -23,19 +23,21 @@ from mindspore.common.parameter import Parameter
 @contextmanager
 def no_init_parameters():
     r"""
-     In scenarios where a checkpoint is loaded, parameters within the network instantiation will be
-     instantiated and occupy physical memory. Loading a checkpoint will replace the parameter values.
-     Decorator can be applied during network instantiation to add an attribute `init_param` to all
-     parameters within the current Cell, setting it to `init_param=False` .
-     When `init_param=False` is detected, the initialization of the parameters is skipped,
-     and the parameters are assigned values directly from the checkpoint during loading,
-     which can optimize performance and reduce physical memory usage.
+    This interface is used to skip parameter initialization.
 
-     Note:
-         Initialization of parameters created with `initializer` can only be skipped.
-         Parameters created by `Tensor` or `numpy` cannot be skipped.
+    In scenarios where a checkpoint is loaded, parameters within the network instantiation will be
+    instantiated and occupy physical memory. Loading a checkpoint will replace the parameter values.
+    Decorator can be applied during network instantiation to add an attribute `init_param` to all
+    parameters within the current Cell, setting it to `init_param=False` .
+    When `init_param=False` is detected, the initialization of the parameters is skipped,
+    and the parameters are assigned values directly from the checkpoint during loading,
+    which can optimize performance and reduce physical memory usage.
 
-     Examples:
+    Note:
+        Initialization of parameters created with `initializer` can only be skipped.
+        Parameters created by `Tensor` or `numpy` cannot be skipped.
+
+    Examples:
         >>> import mindspore as ms
         >>> from mindspore import nn, ops, load_checkpoint
         >>> from mindspore.common.initializer import initializer

mindspore/nn/wrap/__init__.py

@@ -20,8 +20,8 @@ Use the Wrapper to combine the loss or build the training steps.
 from __future__ import absolute_import
 
 from mindspore.nn.wrap.cell_wrapper import ForwardValueAndGrad, TrainOneStepCell, WithLossCell, WithGradCell, \
-    WithEvalCell, ParameterUpdate, GetNextSingleOp, VirtualDatasetCellTriple, MicroBatchInterleaved, PipelineCell, \
-    GradAccumulationCell
+    WithEvalCell, ParameterUpdate, GetNextSingleOp, VirtualDatasetCellTriple, GradAccumulationCell, \
+    MicroBatchInterleaved, PipelineCell
 from mindspore.nn.wrap.loss_scale import TrainOneStepWithLossScaleCell,\
     DynamicLossScaleUpdateCell, FixedLossScaleUpdateCell
 from mindspore.nn.wrap.grad_reducer import DistributedGradReducer, PipelineGradReducer
@@ -34,16 +34,16 @@ __all__ = [
     "TrainOneStepCell",
     "WithLossCell",
     "WithGradCell",
-    "MicroBatchInterleaved",
-    "PipelineCell",
     "WithEvalCell",
     "GetNextSingleOp",
     "TrainOneStepWithLossScaleCell",
     "DistributedGradReducer",
-    "PipelineGradReducer",
     "ParameterUpdate",
     "DynamicLossScaleUpdateCell",
     "FixedLossScaleUpdateCell",
     "VirtualDatasetCellTriple",
-    "GradAccumulationCell"
+    "GradAccumulationCell",
+    "MicroBatchInterleaved",
+    "PipelineCell",
+    "PipelineGradReducer"
     ]