!26833 add chinese api of probability

Merge pull request !26833 from byweng/master

docs/api/api_python/nn/probability/bijector/mindspore.nn.probability.bijector.Bijector.txt

@@ -0,0 +1,88 @@
+Class mindspore.nn.probability.bijector.Bijector(is_constant_jacobian=False, is_injective=True, name=None, dtype=None, param=None)
+
+    Bijector类。
+
+    参数：
+        is_constant_jacobian (bool)：Bijector是否具有常数导数。默认值：False。
+        is_injective (bool)：Bijector是否为一对一映射。默认值：True。
+        name (str)：Bijector名称。默认值：None。
+        dtype (mindspore.dtype)：Bijector可以操作的分布的数据类型。默认值：None。
+        param (dict)：用于初始化Bijector的参数。默认值：None。
+
+    支持平台：
+        ``Ascend`` ``GPU``
+
+    注：
+        Bijector的`dtype`为None时，输入值必须是float类型，除此之外没有其他强制要求。在初始化过程中，当`dtype`为None时，对参数的数据类型没有强制要求。但所有参数都应具有相同的float类型，否则将引发TypeError。
+        具体来说，参数类型跟随输入值的数据类型，即当`dtype`为None时，Bijector的参数将被强制转换为与输入值相同的类型。
+        当指定了`dtype`时，参数和输入值的`dtype`必须相同。
+        当参数类型或输入值类型与`dtype`不相同时，将引发TypeError。只能使用mindspore的float数据类型来指定Bijector的`dtype`。
+    
+
+cast_param_by_value(value, para)
+
+        将Bijector的参数para的数据类型转换为与value相同的类型。
+        参数：
+        value (Tensor)：输入数据。
+        para (Tensor)：Bijector参数。
+        
+
+construct(name, *args, **kwargs)
+
+        重写Cell中的`construct`。
+
+        注：
+            支持的函数包括：
+            'forward'、'inverse'、'forward_log_jacobian'、'inverse_log_jacobian'。
+
+        参数：
+            name (str)：函数名称。
+            *args (list)：函数所需的位置参数列表。
+            **kwargs (dict)：函数所需的关键字参数字典。
+        
+
+forward(value, *args, **kwargs)
+
+        正变换：将输入值转换为另一个分布。
+        
+        参数：
+            value (Tensor)：输入。
+            *args (list)：函数所需的位置参数列表。
+            **kwargs (dict)：函数所需的关键字参数字典。
+        
+
+forward_log_jacobian(value, *args, **kwargs)
+
+        对正变换导数取对数。
+        
+        参数：
+            value (Tensor)：输入。
+            *args (list)：函数所需的位置参数列表。
+            **kwargs (dict)：函数所需的关键字参数字典。
+        
+
+inverse(value, *args, **kwargs)
+
+        逆变换：将输入值转换回原始分布。
+        
+        参数：
+            value (Tensor)：输入。
+            *args (list)：函数所需的位置参数列表。
+            **kwargs (dict)：函数所需的关键字参数字典。
+        
+
+inverse_log_jacobian(value, *args, **kwargs)
+
+        对逆变换的导数取对数。
+        
+        参数：
+            value (Tensor)：输入。
+            *args (list)：函数所需的位置参数列表。
+            **kwargs (dict)：函数所需的关键字参数字典。
+        
+
+shape_mapping(shape)
+映射shape。
+
+参数：
+    shape (tuple)：Tensor的形状。

docs/api/api_python/nn/probability/bijector/mindspore.nn.probability.bijector.Exp.txt

@@ -0,0 +1,35 @@
+Class mindspore.nn.probability.bijector.Exp(name='Exp')
+
+    指数Bijector（Exponential Bijector）。
+    此Bijector执行如下操作：
+
+    .. math::
+        Y = \exp(x).
+
+    参数：
+        name (str)：Bijector名称。默认值：'Exp'。
+
+    支持平台：
+        ``Ascend`` ``GPU``
+
+    示例：
+        >>> import mindspore
+        >>> import mindspore.nn as nn
+        >>> from mindspore import Tensor
+        >>>
+        >>> # 初始化指数Bijector。
+        >>> exp_bijector = nn.probability.bijector.Exp()
+        >>> value = Tensor([1, 2, 3], dtype=mindspore.float32)
+        >>> ans1 = exp_bijector.forward(value)
+        >>> print(ans1.shape)
+        (3,)
+        >>> ans2 = exp_bijector.inverse(value)
+        >>> print(ans2.shape)
+        (3,)
+        >>> ans3 = exp_bijector.forward_log_jacobian(value)
+        >>> print(ans3.shape)
+        (3,)
+        >>> ans4 = exp_bijector.inverse_log_jacobian(value)
+        >>> print(ans4.shape)
+        (3,)
+

docs/api/api_python/nn/probability/bijector/mindspore.nn.probability.bijector.GumbelCDF.txt

@@ -0,0 +1,49 @@
+Class mindspore.nn.probability.bijector.GumbelCDF(loc=0.0, scale=1.0, name='GumbelCDF')
+
+    GumbelCDF Bijector。
+    此Bijector执行如下操作：
+
+    .. math::
+        Y = \exp(-\exp(\frac{-(X - loc)}{scale}))
+
+    参数：
+        loc (float, list, numpy.ndarray, Tensor)：位移因子，即上述公式中的loc。默认值：0.0。
+        scale (float, list, numpy.ndarray, Tensor)：比例因子，即上述公式中的scale。默认值：1.0。
+        name (str)：Bijector名称。默认值：'GumbelCDF'。
+
+    支持平台：
+        ``Ascend`` ``GPU``
+
+    注：
+        `scale`必须大于零。
+        对于`inverse`和`inverse_log_jacobian`，输入应在(0, 1)范围内。
+        `loc`和`scale`的数据类型必须为float。
+        如果`loc`、`scale`作为numpy.ndarray或Tensor传入，则它们必须具有相同的数据类型，否则将引发错误。
+
+    异常：
+        TypeError：`loc`或`scale`的数据类型不为float，或`loc`和`scale`的数据类型不相同。
+
+    示例：
+        >>> import mindspore
+        >>> import mindspore.nn as nn
+        >>> import mindspore.nn.probability.bijector as msb
+        >>> from mindspore import Tensor
+        >>>
+        >>> # 初始化GumbelCDF Bijector，loc设置为1.0和scale设置为2.0。
+        >>> gumbel_cdf = msb.GumbelCDF(1.0, 2.0)
+        >>> # 在网络中使用ScalarAffinebijector。
+        >>> x = Tensor([1, 2, 3], dtype=mindspore.float32)
+        >>> y = Tensor([0.1, 0.2, 0.3], dtype=mindspore.float32)
+        >>> ans1 = gumbel_cdf.forward(x)
+        >>> print(ans1.shape)
+        (3,)
+        >>> ans2 = gumbel_cdf.inverse(y)
+        >>> print(ans2.shape)
+        (3,)
+        >>> ans3 = gumbel_cdf.forward_log_jacobian(x)
+        >>> print(ans3.shape)
+        (3,)
+        >>> ans4 = gumbel_cdf.inverse_log_jacobian(y)
+        >>> print(ans4.shape)
+        (3,)
+

docs/api/api_python/nn/probability/bijector/mindspore.nn.probability.bijector.Invert.txt

@@ -0,0 +1,66 @@
+Class mindspore.nn.probability.bijector.Invert(bijector, name='')
+
+    反转Bijector（Invert Bijector），计算输入Bijector的反函数。
+
+    参数：
+        Bijector (Bijector)：基础Bijector（Base Bijector）。
+        name (str)：Bijector名称。默认值：""。当name设置为""时，它实际上是'Invert' + Bijector.name。
+
+    支持平台：
+        ``Ascend`` ``GPU``
+
+    示例：
+        >>> import numpy as np
+        >>> import mindspore
+        >>> import mindspore.nn as nn
+        >>> import mindspore.nn.probability.bijector as msb
+        >>> from mindspore import Tensor
+        >>> class Net(nn.Cell):
+        ...     def __init__(self):
+        ...         super(Net, self).__init__()
+        ...         self.origin = msb.ScalarAffine(scale=2.0, shift=1.0)
+        ...         self.invert = msb.Invert(self.origin)
+        ...
+        ...     def construct(self, x_):
+        ...         return self.invert.forward(x_)
+        >>> forward = Net()
+        >>> x = np.array([2.0, 3.0, 4.0, 5.0]).astype(np.float32)
+        >>> ans = forward(Tensor(x, dtype=mindspore.float32))
+        >>> print(ans.shape)
+        (4,)
+    
+
+bijector
+        返回基础Bijector。
+
+forward(x)
+
+        逆变换：将输入值转换回原始分布。
+        
+        参数：
+        x (Tensor)：输入。
+        
+
+forward_log_jacobian(x)
+
+        逆变换导数的对数。
+        
+        参数：
+        x (Tensor)：输入。
+        
+
+inverse(y)
+
+        正变换：将输入值转换为另一个分布。
+        
+        参数：
+        y (Tensor)：输入。
+        
+
+inverse_log_jacobian(y)
+
+        正变换导数的对数。
+        
+        参数：
+        y (Tensor)：输入。
+        

docs/api/api_python/nn/probability/bijector/mindspore.nn.probability.bijector.PowerTransform.txt

@@ -0,0 +1,49 @@
+Class mindspore.nn.probability.bijector.PowerTransform(power=0.0, name='PowerTransform')
+
+    乘方Bijector（Power Bijector）。
+    此Bijector执行如下操作：
+
+    .. math::
+        Y = g(X) = (1 + X * c)^{1 / c}, X >= -1 / c
+
+    其中幂c >= 0。
+
+    Power Bijector将输入从`[-1/c, inf]`映射到`[0, inf]`。
+
+    当`c=0`时，此Bijector等于Exp Bijector。
+
+    参数：
+        power (float, list, numpy.ndarray, Tensor)：比例因子。默认值：0。
+        name (str)：Bijector名称。默认值：'PowerTransform'。
+
+    支持平台：
+        ``Ascend`` ``GPU``
+
+    注：
+        `power`的数据类型必须为float。
+
+    异常：
+        ValueError：`power`小于0或静态未知。
+        TypeError：`power`的数据类型不是float。
+
+    示例：
+        >>> import mindspore
+        >>> import mindspore.nn as nn
+        >>> import mindspore.nn.probability.bijector as msb
+        >>> from mindspore import Tensor
+        >>> # 初始化PowerTransform Bijector。
+        >>> powertransform = msb.PowerTransform(0.5)
+        >>> value = Tensor([1, 2, 3], dtype=mindspore.float32)
+        >>> ans1 = powertransform.forward(value)
+        >>> print(ans1.shape)
+        (3,)
+        >>> ans2 = powertransform.inverse(value)
+        >>> print(ans2.shape)
+        (3,)
+        >>> ans3 = powertransform.forward_log_jacobian(value)
+        >>> print(ans3.shape)
+        (3,)
+        >>> ans4 = powertransform.inverse_log_jacobian(value)
+        >>> print(ans4.shape)
+        (3,)
+

docs/api/api_python/nn/probability/bijector/mindspore.nn.probability.bijector.ScalarAffine.txt

@@ -0,0 +1,46 @@
+Class mindspore.nn.probability.bijector.ScalarAffine(scale=1.0, shift=0.0, name='ScalarAffine')
+
+    标量仿射Bijector（Scalar Affine Bijector）。
+    此Bijector执行如下操作：
+
+    .. math::
+        Y = a * X + b
+
+    其中a是比例因子，b是移位因子。
+
+    参数：
+        scale (float, list, numpy.ndarray, Tensor)：比例因子。默认值：1.0。
+        shift (float, list, numpy.ndarray, Tensor)：移位因子。默认值：0.0。
+        name (str)：Bijector名称。默认值：'ScalarAffine'。
+
+    支持平台：
+        ``Ascend`` ``GPU``
+
+    注：
+        `shift`和`scale`的数据类型必须为float。
+        如果`shift`、`scale`作为numpy.ndarray或Tensor传入，则它们必须具有相同的数据类型，否则将引发错误。
+
+    异常：
+        TypeError：`shift`或`scale`的数据类型不为float，或`shift`和`scale`的数据类型不相同。
+
+    示例：
+        >>> import mindspore
+        >>> import mindspore.nn as nn
+        >>> from mindspore import Tensor
+        >>>
+        >>> # 初始化ScalarAffine Bijector，scale设置为1.0，shift设置为2.0。
+        >>> scalaraffine = nn.probability.bijector.ScalarAffine(1.0, 2.0)
+        >>> value = Tensor([1, 2, 3], dtype=mindspore.float32)
+        >>> ans1 = scalaraffine.forward(value)
+        >>> print(ans1.shape)
+        (3,)
+        >>> ans2 = scalaraffine.inverse(value)
+        >>> print(ans2.shape)
+        (3,)
+        >>> ans3 = scalaraffine.forward_log_jacobian(value)
+        >>> print(ans3.shape)
+        ()
+        >>> ans4 = scalaraffine.inverse_log_jacobian(value)
+        >>> print(ans4.shape)
+        ()
+

docs/api/api_python/nn/probability/bijector/mindspore.nn.probability.bijector.Softplus.txt

@@ -0,0 +1,46 @@
+Class mindspore.nn.probability.bijector.Softplus(sharpness=1.0, name='Softplus')
+
+    Softplus Bijector。
+    此Bijector执行如下操作：
+
+    .. math::
+        Y = \frac{\log(1 + e ^ {kX})}{k}
+
+    其中k是锐度因子。
+
+    参数：
+        sharpness (float, list, numpy.ndarray, Tensor)：锐度因子，上述公式中的k。默认值：1.0。
+        name (str)：Bijector名称。默认值：'Softplus'。
+
+    支持平台：
+        ``Ascend`` ``GPU``
+
+    注：
+        `sharpness`的数据类型必须为float。
+
+    异常：
+        TypeError：sharpness的数据类型不为float。
+
+    示例：
+        >>> import mindspore
+        >>> import mindspore.nn as nn
+        >>> import mindspore.nn.probability.bijector as msb
+        >>> from mindspore import Tensor
+        >>>
+        >>> # 初始化Softplus Bijector，sharpness设置为2.0。
+        >>> softplus = msb.Softplus(2.0)
+        >>> # 在网络中使用ScalarAffine Bijector。
+        >>> value = Tensor([1, 2, 3], dtype=mindspore.float32)
+        >>> ans1 = softplus.forward(value)
+        >>> print(ans1.shape)
+        (3,)
+        >>> ans2 = softplus.inverse(value)
+        >>> print(ans2.shape)
+        (3,)
+        >>> ans3 = softplus.forward_log_jacobian(value)
+        >>> print(ans3.shape)
+        (3,)
+        >>> ans4 = softplus.inverse_log_jacobian(value)
+        >>> print(ans4.shape)
+        (3,)
+

docs/api/api_python/nn/probability/distribution/mindspore.nn.probability.distribution.Bernoulli.txt

@@ -0,0 +1,102 @@
+Class mindspore.nn.probability.distribution.Bernoulli(probs=None, seed=None, dtype=mindspore.int32, name='Bernoulli')
+
+    伯努利分布（Bernoulli Distribution）。
+
+    参数：
+        probs (float, list, numpy.ndarray, Tensor)：结果是1的概率。默认值：None。
+        seed (int)：采样时使用的种子。如果为None，则使用全局种子。默认值：None。
+        dtype (mindspore.dtype)：采样结果的数据类型。默认值：mindspore.int32.
+        name (str)：分布的名称。默认值：'Bernoulli'。
+
+    支持平台：
+        ``Ascend`` ``GPU``
+
+    注：
+        `probs`必须是合适的概率（0<p<1）。
+
+    示例：
+        >>> import mindspore
+        >>> import mindspore.nn as nn
+        >>> import mindspore.nn.probability.distribution as msd
+        >>> from mindspore import Tensor
+        >>> # 初始化伯努利分布，probs设置为1。
+        >>> b1 = msd.Bernoulli(0.5, dtype=mindspore.int32)
+        >>> # 伯努利分布可以在没有参数的情况下初始化。
+        >>> # 在这种情况下，`probs`必须在函数调用过程中通过参数传入。
+        >>> b2 = msd.Bernoulli(dtype=mindspore.int32)
+        >>> # 下面是用于测试的Tensor
+        >>> value = Tensor([1, 0, 1], dtype=mindspore.int32)
+        >>> probs_a = Tensor([0.6], dtype=mindspore.float32)
+        >>> probs_b = Tensor([0.2, 0.3, 0.4], dtype=mindspore.float32)
+        >>>
+        >>> # 公共接口对应的概率函数的私有接口，包括`prob`、`log_prob`、`cdf`、`log_cdf`、`survival_function`、`log_survival`，它们具有相同的参数，如下所示。
+        >>> # 参数：
+        >>> #     value (Tensor)：要评估的值。
+        >>> #     probs1 (Tensor)：成功的概率。默认值：self.probs.
+        >>> # 下面是调用`prob`的示例（通过将`prob`替换为函数的名称，可以对其他概率函数进行类似的调用）：
+        >>> ans = b1.prob(value)
+        >>> print(ans.shape)
+        (3,)
+        >>> # 评估关于分布b的`prob`。
+        >>> ans = b1.prob(value, probs_b)
+        >>> print(ans.shape)
+        (3,)
+        >>> # `probs`必须在函数调用期间传入。
+        >>> ans = b2.prob(value, probs_a)
+        >>> print(ans.shape)
+        (3,)
+        >>>
+        >>> # 函数`mean`、`sd`、`var`和`entropy`具有相同的参数。
+        >>> # 参数：
+        >>> #     probs1 (Tensor)：成功的概率。默认值：self.probs.
+        >>> # 下面是调用`mean的`示例。`sd`、`var`和`entropy`与`mean`类似。
+        >>> ans = b1.mean() # return 0.5
+        >>> print(ans.shape)
+        ()
+        >>> ans = b1.mean(probs_b) # return probs_b
+        >>> print(ans.shape)
+        (3,)
+        >>> # `probs`必须在函数调用期间传入。
+        >>> ans = b2.mean(probs_a)
+        >>> print(ans.shape)
+        (1,)
+        >>>
+        >>> # `kl_loss`和`cross_entropy`的接口如下：
+        >>> # 参数：
+        >>> #     dist (str)：分布的名称。仅支持'Bernoulli'。
+        >>> #     probs1_b (Tensor)：分布b成功的概率。
+        >>> #     probs1_a (Tensor)：分布a成功的概率。默认值：self.probs.
+        >>> # 下面是调用kl_loss的示例。`cross_entropy`也类似。
+        >>> ans = b1.kl_loss('Bernoulli', probs_b)
+        >>> print(ans.shape)
+        (3,)
+        >>> ans = b1.kl_loss('Bernoulli', probs_b, probs_a)
+        >>> print(ans.shape)
+        (3,)
+        >>> # 必须传入额外的`probs_a`。
+        >>> ans = b2.kl_loss('Bernoulli', probs_b, probs_a)
+        >>> print(ans.shape)
+        (3,)
+        >>>
+        >>> # `sample`示例。
+        >>> # 参数：
+        >>> #     shape (tuple)：样本的shape。默认值：()。
+        >>> #     probs1 (Tensor)：成功的概率。默认值：self.probs.
+        >>> ans = b1.sample()
+        >>> print(ans.shape)
+        ()
+        >>> ans = b1.sample((2,3))
+        >>> print(ans.shape)
+        (2, 3)
+        >>> ans = b1.sample((2,3), probs_b)
+        >>> print(ans.shape)
+        (2, 3, 3)
+        >>> ans = b2.sample((2,3), probs_a)
+        >>> print(ans.shape)
+        (2, 3, 1)
+    
+
+probs
+
+        返回结果为1的概率。
+        

docs/api/api_python/nn/probability/distribution/mindspore.nn.probability.distribution.Beta.txt

@@ -0,0 +1,116 @@
+Class mindspore.nn.probability.distribution.Beta(concentration1=None, concentration0=None, seed=None, dtype=mindspore.float32, name='Beta')
+
+    贝塔分布（Beta Distribution）。
+
+    参数：
+        concentration1 (list, numpy.ndarray, Tensor)：贝塔分布的alpha。
+        concentration0 (list, numpy.ndarray, Tensor)：贝塔分布的beta。
+        seed (int)：采样时使用的种子。如果为None，则使用全局种子。默认值：None。
+        dtype (mindspore.dtype)：采样结果的数据类型。默认值：mindspore.float32。
+        name (str)：分布的名称。默认值：'Beta'。
+
+    支持平台：
+        ``Ascend``
+
+    注：
+        `concentration1`和`concentration0`必须大于零。
+        `dtype`必须是float，因为贝塔分布是连续的。
+
+    示例：
+        >>> import mindspore
+        >>> import mindspore.nn as nn
+        >>> import mindspore.nn.probability.distribution as msd
+        >>> from mindspore import Tensor
+        >>>
+        >>> # 初始化concentration1为3.0和concentration0为4.0的贝塔分布。
+        >>> b1 = msd.Beta([3.0], [4.0], dtype=mindspore.float32)
+        >>>
+        >>> # Beta分布可以在没有参数的情况下初始化。
+        >>> # 在这种情况下，`concentration1`和`concentration0`必须通过参数传入。
+        >>> b2 = msd.Beta(dtype=mindspore.float32)
+        >>> # 下面是用于测试的Tensor
+        >>> value = Tensor([0.1, 0.5, 0.8], dtype=mindspore.float32)
+        >>> c1_a = Tensor([2.0], dtype=mindspore.float32)
+        >>> c0_a = Tensor([2.0, 2.0, 2.0], dtype=mindspore.float32)
+        >>> c1_b = Tensor([1.0], dtype=mindspore.float32)
+        >>> c0_b = Tensor([1.0, 1.5, 2.0], dtype=mindspore.float32)
+        >>>
+        >>> # 公共接口对应的概率函数的私有接口（包括`prob`和`log_prob`）的参数相同，如下所示。
+        >>> # 参数：
+        >>> #     value (Tensor)：要评估的值。
+        >>> #     concentration1 (Tensor)：分布的concentration1。默认值：self._concentration1。
+        >>> #     concentration0 (Tensor)：分布的concentration0。默认值：self._concentration0。
+        >>> # 下面是`prob`的示例（通过将'prob'替换为函数的名称，可以对其他概率函数进行类似的调用）：
+        >>> ans = b1.prob(value)
+        >>> print(ans.shape)
+        (3,)
+        >>> # 根据分布b进行评估。
+        >>> ans = b1.prob(value, concentration1_b, concentration0_b)
+        >>> print(ans.shape)
+        (3,)
+        >>> # 在函数调用期间必须传入`concentration1`和`concentration0`
+        >>> ans = b2.prob(value, concentration1=c1_a, concentration0=c0_a)
+        >>> print(ans.shape)
+        (3,)
+        >>>
+        >>> # 函数`mean`、`sd`、`mode`、`var`和`entropy`具有相同的参数。
+        >>> # 参数：
+        >>> #     concentration1 (Tensor)：分布的concentration1。默认值：self._concentration1。
+        >>> #     concentration0 (Tensor)：分布的concentration0。默认值：self._concentration0。
+        >>> # 下面是调研`mean`的示例（`sd`、`mode`、`var`和`entropy`的示例与`mean`相似）：
+        >>> ans = b1.mean()
+        >>> print(ans.shape)
+        (1,)
+        >>> ans = b1.mean(concentration1=c1_b, concentration0=c0_b)
+        >>> print(ans.shape)
+        (3,)
+        >>> # `concentration1`和`concentration0`必须在函数调用期间传入。
+        >>> ans = b2.mean(concentration1=c1_a, concentration0=c0_a)
+        >>> print(ans.shape)
+        (3,)
+        >>>
+        >>> # 'kl_loss'和'cross_entropy'的接口相同：
+        >>> # 参数：
+        >>> #     dist (str)：分布的类型。仅支持"Beta"。
+        >>> #     concentration1_b (Tensor)：分布b的concentration1。
+        >>> #     concentration0_b (Tensor)：分布b的concentration0。
+        >>> #     concentration1_a (Tensor)：分布a的concentration1。
+        >>> #       默认值：self._concentration1。
+        >>> #     concentration0_a (Tensor)：分布a的concentration0。
+        >>> #       默认值：self._concentration0。
+        >>> # 下面是`kl_loss`示例（`cross_entropy`也类似）：
+        >>> ans = b1.kl_loss('Beta', concentration1_b=c1_b, concentration0_b=c0_b)
+        >>> print(ans.shape)
+        (3,)
+        >>> ans = b1.kl_loss('Beta', concentration1_b=c1_b, concentration0_b=c0_b, concentration1_a=c1_a, concentration0_a=c0_a)
+        >>> print(ans.shape)
+        (3,)
+        >>>
+        >>> # `sample`示例。
+        >>> # 参数：
+        >>> #     shape (tuple)：样本的shape。默认值：()
+        >>> #     concentration1 (Tensor)：分布的concentration1。默认值：self._concentration1。
+        >>> #     concentration0 (Tensor)：分布的concentration0。默认值：self._concentration0。
+        >>> ans = b1.sample()
+        >>> print(ans.shape)
+        (1,)
+        >>> ans = b1.sample((2,3))
+        >>> print(ans.shape)
+        (2, 3, 1)
+        >>> ans = b1.sample((2,3), concentration1=c1_b, concentration0=c0_b)
+        >>> print(ans.shape)
+        (2, 3, 3)
+        >>> ans = b2.sample((2,3), concentration1=c1_a, concentration0=c0_a)
+        >>> print(ans.shape)
+        (2, 3, 3)
+    
+
+concentration0
+
+        返回concentration0（也称为贝塔分布的beta）。
+        
+
+concentration1
+
+        返回concentration1（也称为贝塔分布的alpha）。
+

docs/api/api_python/nn/probability/distribution/mindspore.nn.probability.distribution.Categorical.txt

@@ -0,0 +1,83 @@
+Class mindspore.nn.probability.distribution.Categorical(probs=None, seed=None, dtype=mindspore.int32, name='Categorical')
+
+    分类分布。
+
+    参数：
+        probs (Tensor, list, numpy.ndarray)：事件概率。
+        seed (int)：采样时使用的种子。如果为None，则使用全局种子。默认值：None。
+        dtype (mindspore.dtype)：事件样例的类型。默认值：mindspore.int32.
+        name (str)：分布的名称。默认值：Categorical。
+
+    支持平台：
+        ``Ascend`` ``GPU``
+
+    注：
+        `probs`的秩必须至少为1，值是合适的概率，并且总和为1。
+
+    示例：
+        >>> import mindspore
+        >>> import mindspore.nn as nn
+        >>> import mindspore.nn.probability.distribution as msd
+        >>> from mindspore import Tensor
+        >>> # 初始化probs为[0.2, 0.8]的类别分布。
+        >>> ca1 = msd.Categorical(probs=[0.2, 0.8], dtype=mindspore.int32)
+        >>> # 类别分布可以在没有参数的情况下初始化。
+        >>> # 在这种情况下，`probs`必须在函数调用过程中通过参数传入。
+        >>> ca2 = msd.Categorical(dtype=mindspore.int32)
+        >>> # 下面是用于测试的Tensor
+        >>> value = Tensor([1, 0], dtype=mindspore.int32)
+        >>> probs_a = Tensor([0.5, 0.5], dtype=mindspore.float32)
+        >>> probs_b = Tensor([0.35, 0.65], dtype=mindspore.float32)
+        >>> # 公共接口所对应的概率函数的私有接口，包括`prob`、`log_prob`、`cdf`、`log_cdf`、`survival_function`、`log_survival`，如下所示。
+        >>> # 参数：
+        >>> #     value (Tensor)：要评估的值。
+        >>> #     probs (Tensor)：事件概率。默认值：self.probs.
+        >>> # `prob`示例。
+        >>> # 通过将`prob`替换为函数的名称，可以对其他概率函数进行类似的调用。
+        >>> ans = ca1.prob(value)
+        >>> print(ans.shape)
+        (2,)
+        >>> # 评估关于分布b的`prob`。
+        >>> ans = ca1.prob(value, probs_b)
+        >>> print(ans.shape)
+        (2,)
+        >>> # `probs`必须在函数调用期间传入。
+        >>> ans = ca2.prob(value, probs_a)
+        >>> print(ans.shape)
+        (2,)
+        >>> # 函数`mean`、`sd`、`var`和`entropy`具有相同的参数。
+        >>> # 参数：
+        >>> #     probs (Tensor)：事件概率。默认值：self.probs.
+        >>> # `mean`示例。`sd`、`var`和`entropy`是相似的。
+        >>> ans = ca1.mean() # return 0.8
+        >>> print(ans.shape)
+        (1,)
+        >>> ans = ca1.mean(probs_b)
+        >>> print(ans.shape)
+        (1,)
+        >>> # `probs`必须在函数调用期间传入。
+        >>> ans = ca2.mean(probs_a)
+        >>> print(ans.shape)
+        (1,)
+        >>> # `kl_loss`和`cross_entropy`的接口如下：
+        >>> # 参数：
+        >>> #     dist (str)：分布的名称。仅支持'Categorical'。
+        >>> #     probs_b (Tensor)：分布b的事件概率。
+        >>> #     probs (Tensor)：分布a的事件概率。默认值：self.probs.
+        >>> # kl_loss示例。`cross_entropy`也类似。
+        >>> ans = ca1.kl_loss('Categorical', probs_b)
+        >>> print(ans.shape)
+        ()
+        >>> ans = ca1.kl_loss('Categorical', probs_b, probs_a)
+        >>> print(ans.shape)
+        ()
+        >>> # 必须传入额外的`probs`。
+        >>> ans = ca2.kl_loss('Categorical', probs_b, probs_a)
+        >>> print(ans.shape)
+        ()
+    
+
+probs
+
+        返回事件概率。
+        

docs/api/api_python/nn/probability/distribution/mindspore.nn.probability.distribution.Cauchy.txt

@@ -0,0 +1,114 @@
+Class mindspore.nn.probability.distribution.Cauchy(loc=None, scale=None, seed=None, dtype=mindspore.float32, name='Cauchy')
+
+    柯西分布（Cauchy distribution）。
+
+    参数：
+        loc (int, float, list, numpy.ndarray, Tensor)：柯西分布的位置。
+        scale (int, float, list, numpy.ndarray, Tensor)：柯西分布的比例。
+        seed (int)：采样时使用的种子。如果为None，则使用全局种子。默认值：None。
+        dtype (mindspore.dtype)：事件样例的类型。默认值：mindspore.float32。
+        name (str)：分布的名称。默认值：'Cauchy'。
+
+    支持平台：
+        ``Ascend``
+
+    注：
+        `scale`必须大于零。
+        `dtype`必须是float，因为柯西分布是连续的。
+        GPU后端不支持柯西分布。
+
+    示例：
+        >>> import mindspore
+        >>> import mindspore.nn as nn
+        >>> import mindspore.nn.probability.distribution as msd
+        >>> from mindspore import Tensor
+        >>> # 初始化loc为3.0和scale为4.0的柯西分布。
+        >>> cauchy1 = msd.Cauchy(3.0, 4.0, dtype=mindspore.float32)
+        >>> # 柯西分布可以在没有参数的情况下初始化。
+        >>> # 在这种情况下，'loc'和'scale'必须通过参数传入。
+        >>> cauchy2 = msd.Cauchy(dtype=mindspore.float32)
+        >>> # 下面是用于测试的Tensor
+        >>> value = Tensor([1.0, 2.0, 3.0], dtype=mindspore.float32)
+        >>> loc_a = Tensor([2.0], dtype=mindspore.float32)
+        >>> scale_a = Tensor([2.0, 2.0, 2.0], dtype=mindspore.float32)
+        >>> loc_b = Tensor([1.0], dtype=mindspore.float32)
+        >>> scale_b = Tensor([1.0, 1.5, 2.0], dtype=mindspore.float32)
+        >>> # 公共接口对应的概率函数的私有接口，包括`prob`、`log_prob`、`cdf`、`log_cdf`、`survival_function`、`log_survival`，具有以下相同的参数。
+        >>> # 参数：
+        >>> #     value (Tensor)：要评估的值。
+        >>> #     loc (Tensor)：分布的位置。默认值：self.loc.
+        >>> #     scale (Tensor)：分布的比例。默认值：self.scale.
+        >>> # `prob`示例。
+        >>> # 通过将'prob'替换为函数的名称，可以对其他概率函数进行类似的调用
+        >>> ans = cauchy1.prob(value)
+        >>> print(ans.shape)
+        (3,)
+        >>> # 根据分布b进行评估。
+        >>> ans = cauchy1.prob(value, loc_b, scale_b)
+        >>> print(ans.shape)
+        (3,)
+        >>> # 在函数调用期间必须传入`loc`和`scale`
+        >>> ans = cauchy2.prob(value, loc_a, scale_a)
+        >>> print(ans.shape)
+        (3,)
+        >>> # 函数`mode`和`entropy`具有相同的参数。
+        >>> # 参数：
+        >>> #     loc (Tensor)：分布的位置。默认值：self.loc.
+        >>> #     scale (Tensor)：分布的比例。默认值：self.scale.
+        >>> # `mode`示例。
+        >>> ans = cauchy1.mode() # return 3.0
+        >>> print(ans.shape)
+        ()
+        >>> ans = cauchy1.mode(loc_b, scale_b) # return loc_b
+        >>> print(ans.shape)
+        (3,)
+        >>> # 在函数调用期间必须传入`loc`和`scale`。
+        >>> ans = cauchy2.mode(loc_a, scale_a)
+        >>> print(ans.shape)
+        (3,)
+        >>> # 'kl_loss'和'cross_entropy'的接口相同：
+        >>> # 参数：
+        >>> #     dist (str)：分布的类型。仅支持"Cauchy"。
+        >>> #     loc_b (Tensor)：分布b的位置。
+        >>> #     scale_b (Tensor)：分布b的比例。
+        >>> #     loc (Tensor)：分布a的位置。默认值：self.loc.
+        >>> #     scale (Tensor)：分布a的比例。默认值：self.scale.
+        >>> # `kl_loss`示例。`cross_entropy`也类似。
+        >>> ans = cauchy1.kl_loss('Cauchy', loc_b, scale_b)
+        >>> print(ans.shape)
+        (3,)
+        >>> ans = cauchy1.kl_loss('Cauchy', loc_b, scale_b, loc_a, scale_a)
+        >>> print(ans.shape)
+        (3,)
+        >>> # 必须传入额外的`loc`和`scale`。
+        >>> ans = cauchy2.kl_loss('Cauchy', loc_b, scale_b, loc_a, scale_a)
+        >>> print(ans.shape)
+        (3,)
+        >>> # `sample`示例。
+        >>> # 参数：
+        >>> #     shape (tuple)：样本的shape。默认值：()
+        >>> #     loc (Tensor)：分布的位置。默认值：self.loc.
+        >>> #     scale (Tensor)：分布的比例。默认值：self.scale.
+        >>> ans = cauchy1.sample()
+        >>> print(ans.shape)
+        ()
+        >>> ans = cauchy1.sample((2,3))
+        >>> print(ans.shape)
+        (2, 3)
+        >>> ans = cauchy1.sample((2,3), loc_b, scale_b)
+        >>> print(ans.shape)
+        (2, 3, 3)
+        >>> ans = cauchy2.sample((2,3), loc_a, scale_a)
+        >>> print(ans.shape)
+        (2, 3, 3)
+    
+
+loc
+
+        返回分布位置。
+        
+
+scale
+
+        返回分布比例。
+        

docs/api/api_python/nn/probability/distribution/mindspore.nn.probability.distribution.Distribution.txt

@@ -0,0 +1,184 @@
+Class mindspore.nn.probability.distribution.Distribution(seed, dtype, name, param)
+
+    所有分布的基类。
+
+    参数：
+        seed (int)：采样时使用的种子。如果为None，则使用0。
+        dtype (mindspore.dtype)：事件样例的类型。
+        name (str)：分布的名称。
+        param (dict)：用于初始化分布的参数。
+
+    支持平台：
+        ``Ascend`` ``GPU``
+
+    注：
+        派生类必须重写`_mean`、`_prob`和`_log_prob`等操作。必填参数必须通过`args`或`kwargs`传入，如`_prob`的`value`。
+    
+
+cdf(value, *args, **kwargs)
+
+        在给定值下评估累积分布函数（Cumulatuve Distribution Function, CDF）。
+
+        参数：
+            value (Tensor)：要评估的值。
+            *args (list)：传递给子类的位置参数列表。
+            **kwargs (dict)：传递给子类的关键字参数字典。
+        
+
+construct(name, *args, **kwargs)
+
+        重写Cell中的`construct`。
+
+        注：
+            支持的函数包括：
+            'prob'、'log_prob'、'cdf', 'log_cdf'、'survival_function'、'log_survival'、
+            'var'、'sd'、'mode'、'mean'、'entropy'、'kl_loss'、'cross_entropy'、'sample'、
+            'get_dist_args'、'get_dist_type'。
+
+        参数：
+            name (str)：函数名称。
+            *args (list)：函数所需的位置参数列表。
+            **kwargs (dict)：函数所需的关键字参数字典。
+        
+
+cross_entropy(dist, *args, **kwargs)
+
+        评估分布a和b之间的交叉熵。
+
+        参数：
+            dist (str)：分布的类型。
+            *args (list)：传递给子类的位置参数列表。
+            **kwargs (dict)：传递给子类的关键字参数字典。
+        
+
+entropy(*args, **kwargs)
+
+        计算熵。
+
+        参数：
+            *args (list)：传递给子类的位置参数列表。
+            **kwargs (dict)：传递给子类的关键字参数字典。
+        
+
+get_dist_args(*args, **kwargs)
+
+        检查默认参数的可用性和有效性。
+
+        参数：
+            *args (list)：传递给子类的位置参数列表。
+            **kwargs (dict)：传递给子类的关键字参数字典。
+
+        注：
+           传递给字类的参数的顺序应该与通过`_add_parameter`初始化默认参数的顺序相同。
+        
+
+get_dist_type()
+
+        返回分布类型。
+        
+
+kl_loss(dist, *args, **kwargs)
+
+        评估KL散度，即KL(a||b)。
+
+        参数：
+            dist (str)：分布的类型。
+            *args (list)：传递给子类的位置参数列表。
+            **kwargs (dict)：传递给子类的关键字参数字典。
+        
+
+log_cdf(value, *args, **kwargs)
+
+        计算给定值对于的cdf的对数。
+
+        参数：
+            value (Tensor)：要评估的值。
+            *args (list)：传递给子类的位置参数列表。
+            **kwargs (dict)：传递给子类的关键字参数字典。
+        
+
+log_prob(value, *args, **kwargs)
+
+        计算给定值对应的概率的对数（pdf或pmf）。
+
+        参数：
+            value (Tensor)：要评估的值。
+            *args (list)：传递给子类的位置参数列表。
+            **kwargs (dict)：传递给子类的关键字参数字典。
+        
+
+log_survival(value, *args, **kwargs)
+
+        计算给定值对应的剩余函数的对数。
+
+        参数：
+            value (Tensor)：要评估的值。
+            *args (list)：传递给子类的位置参数列表。
+            **kwargs (dict)：传递给子类的关键字参数字典。
+        
+
+mean(*args, **kwargs)
+
+        评估平均值。
+
+        参数：
+            *args (list)：传递给子类的位置参数列表。
+            **kwargs (dict)：传递给子类的关键字参数字典。
+        
+
+mode(*args, **kwargs)
+
+        评估模式。
+
+        参数：
+            *args (list)：传递给子类的位置参数列表。
+            **kwargs (dict)：传递给子类的关键字参数字典。
+        
+
+prob(value, *args, **kwargs)
+
+        评估给定值下的概率（Probability Density Function或Probability Mass Function）。
+
+        参数：
+            value (Tensor)：要评估的值。
+            *args (list)：传递给子类的位置参数列表。
+            **kwargs (dict)：传递给子类的关键字参数字典。
+        
+
+sample(*args, **kwargs)
+
+        采样函数。
+
+        参数：
+            shape（tuple）：样本的shape。
+            *args (list)：传递给子类的位置参数列表。
+            **kwargs (dict)：传递给子类的关键字参数字典。
+        
+
+sd(*args, **kwargs)
+
+        标准差评估。
+
+        参数：
+            *args (list)：传递给子类的位置参数列表。
+            **kwargs (dict)：传递给子类的关键字参数字典。
+        
+
+survival_function(value, *args, **kwargs)
+
+        计算给定值对应的剩余函数。
+
+        参数：
+            value (Tensor)：要评估的值。
+            *args (list)：传递给子类的位置参数列表。
+            **kwargs (dict)：传递给子类的关键字参数字典。
+        
+
+var(*args, **kwargs)
+
+        评估方差。
+
+        参数：
+            *args (list)：传递给子类的位置参数列表。
+            **kwargs (dict)：传递给子类的关键字参数字典。
+        

docs/api/api_python/nn/probability/distribution/mindspore.nn.probability.distribution.Exponential.txt

@@ -0,0 +1,100 @@
+Class mindspore.nn.probability.distribution.Exponential(rate=None, seed=None, dtype=mindspore.float32, name='Exponential')
+
+    示例类：指数分布（Exponential Distribution）。
+
+    参数：
+        rate (float, list, numpy.ndarray, Tensor)： 逆指数。默认值：None。
+        seed (int)： 采样时使用的种子。如果为None，则使用全局种子。默认值：None。
+        dtype (mindspore.dtype)： 事件样例的类型。默认值：mindspore.float32。
+        name (str)： 分布的名称。默认值：'Exponential'。
+
+    支持平台：
+        ``Ascend`` ``GPU``
+
+    注：
+        `rate`必须大于0。
+        `dtype`必须是float，因为指数分布是连续的。
+
+    示例：
+        >>> import mindspore
+        >>> import mindspore.nn as nn
+        >>> import mindspore.nn.probability.distribution as msd
+        >>> from mindspore import Tensor
+        >>> # 初始化rate为0.5的指数分布。
+        >>> e1 = msd.Exponential(0.5, dtype=mindspore.float32)
+        >>> # 指数分布可以在没有参数的情况下初始化。
+        >>> # 在这种情况下，`rate`必须在函数调用期间通过`args`传入。
+        >>> e2 = msd.Exponential(dtype=mindspore.float32)
+        >>> # 下面是用于测试的Tensor
+        >>> value = Tensor([1, 2, 3], dtype=mindspore.float32)
+        >>> rate_a = Tensor([0.6], dtype=mindspore.float32)
+        >>> rate_b = Tensor([0.2, 0.5, 0.4], dtype=mindspore.float32)
+        >>> # 公共接口对应的概率函数的私有接口，包括`prob`、`log_prob`、`cdf`、`log_cdf`、`survival_function`、`log_survival`，如下所示。
+        >>> # 参数：
+        >>> #     value (Tensor)：要评估的值。
+        >>> #     rate (Tensor)：分布的率参数。默认值：self.rate.
+        >>> # `prob`示例。
+        >>> # 通过将`prob`替换为函数的名称，可以对其他概率函数进行类似的调用。
+        >>> ans = e1.prob(value)
+        >>> print(ans.shape)
+        (3,)
+        >>> # 根据分布b进行评估。
+        >>> ans = e1.prob(value, rate_b)
+        >>> print(ans.shape)
+        (3,)
+        >>> # `rate`必须在函数调用期间传入。
+        >>> ans = e2.prob(value, rate_a)
+        >>> print(ans.shape)
+        (3,)
+        >>> # 函数`mean`、`sd`、`var`和`entropy`具有相同的参数，如下所示。
+        >>> # 参数：
+        >>> #     rate (Tensor)：分布的率参数。默认值：self.rate.
+        >>> # `mean`示例。`sd`、`var`和`entropy`是相似的。
+        >>> ans = e1.mean() # return 2
+        >>> print(ans.shape)
+        ()
+        >>> ans = e1.mean(rate_b) # return 1 / rate_b
+        >>> print(ans.shape)
+        (3,)
+        >>> # `rate`必须在函数调用期间传入。
+        >>> ans = e2.mean(rate_a)
+        >>> print(ans.shape)
+        (1,)
+        >>> # `kl_loss`和`cross_entropy`的接口相同。
+        >>> # 参数：
+        >>> #     dist (str)：分布的名称。仅支持'Exponential'。
+        >>> #     rate_b (Tensor)：分布b的率参数。
+        >>> #     rate_a (Tensor)：分布a的率参数。默认值：self.rate.
+        >>> # `kl_loss`示例。`cross_entropy`也类似。
+        >>> ans = e1.kl_loss('Exponential', rate_b)
+        >>> print(ans.shape)
+        (3,)
+        >>> ans = e1.kl_loss('Exponential', rate_b, rate_a)
+        >>> print(ans.shape)
+        (3,)
+        >>> # 必须传入额外的`rate`。
+        >>> ans = e2.kl_loss('Exponential', rate_b, rate_a)
+        >>> print(ans.shape)
+        (3,)
+        >>> # `sample`示例。
+        >>> # 参数：
+        >>> #     shape (tuple)：样本的shape。默认值：()
+        >>> #     probs1 (Tensor)：分布的率参数。默认值：self.rate.
+        >>> ans = e1.sample()
+        >>> print(ans.shape)
+        ()
+        >>> ans = e1.sample((2,3))
+        >>> print(ans.shape)
+        (2, 3)
+        >>> ans = e1.sample((2,3), rate_b)
+        >>> print(ans.shape)
+        (2, 3, 3)
+        >>> ans = e2.sample((2,3), rate_a)
+        >>> print(ans.shape)
+        (2, 3, 1)
+    
+
+rate
+
+        返回`rate`。
+        

docs/api/api_python/nn/probability/distribution/mindspore.nn.probability.distribution.Gamma.txt

@@ -0,0 +1,114 @@
+Class mindspore.nn.probability.distribution.Gamma(concentration=None, rate=None, seed=None, dtype=mindspore.float32, name='Gamma')
+
+    伽马分布（Gamma distribution）。
+
+    参数：
+        concentration (list, numpy.ndarray, Tensor)：浓度，也被称为伽马分布的alpha。默认值：None。
+        rate (list, numpy.ndarray, Tensor)：逆尺度参数，也被称为伽马分布的beta。默认值：None。
+        seed (int)：采样时使用的种子。如果为None，则使用全局种子。默认值：None。
+        dtype (mindspore.dtype)：事件样例的类型。默认值：mindspore.float32。
+        name (str)：分布的名称。默认值：'Gamma'。
+
+    支持平台：
+        ``Ascend``
+
+    注：
+        `concentration`和`rate`必须大于零。
+        `dtype`必须是float，因为伽马分布是连续的。
+
+    示例：
+        >>> import mindspore
+        >>> import mindspore.nn as nn
+        >>> import mindspore.nn.probability.distribution as msd
+        >>> from mindspore import Tensor
+        >>> # 初始化concentration为3.0和rate为4.0的伽马分布。
+        >>> g1 = msd.Gamma([3.0], [4.0], dtype=mindspore.float32)
+        >>> # 伽马分布可以在没有参数的情况下初始化。
+        >>> # 在这种情况下，`concentration`和`rate`必须通过参数传入。
+        >>> g2 = msd.Gamma(dtype=mindspore.float32)
+        >>> # 下面是用于测试的Tensor
+        >>> value = Tensor([1.0, 2.0, 3.0], dtype=mindspore.float32)
+        >>> concentration_a = Tensor([2.0], dtype=mindspore.float32)
+        >>> rate_a = Tensor([2.0, 2.0, 2.0], dtype=mindspore.float32)
+        >>> concentration_b = Tensor([1.0], dtype=mindspore.float32)
+        >>> rate_b = Tensor([1.0, 1.5, 2.0], dtype=mindspore.float32)
+        >>>
+        >>> # 公共接口对应的概率函数的私有接口，包括`prob`、`log_prob`、`cdf`、`log_cdf`、`survival_function`、`log_survival`，具有以下相同的参数。
+        >>> # 参数：
+        >>> #     value (Tensor)：要评估的值。
+        >>> #     concentration (Tensor)：分布的浓度。默认值：self._concentration。
+        >>> #     rate (Tensor)：分布的逆尺度。默认值：self._rate。
+        >>> # `prob`示例。
+        >>> # 通过将'prob'替换为函数的名称，可以对其他概率函数进行类似的调用
+        >>> ans = g1.prob(value)
+        >>> print(ans.shape)
+        (3,)
+        >>> # 根据分布b进行评估。
+        >>> ans = g1.prob(value, concentration_b, rate_b)
+        >>> print(ans.shape)
+        (3,)
+        >>> # 在g2的函数调用期间必须传入`concentration`和`rate`。
+        >>> ans = g2.prob(value, concentration_a, rate_a)
+        >>> print(ans.shape)
+        (3,)
+        >>> # 函数`mean`、`sd`、`mode`、`var`和`entropy`具有相同的参数。
+        >>> # 参数：
+        >>> #     concentration (Tensor)：分布的浓度。默认值：self._concentration。
+        >>> #     rate (Tensor)：分布的逆尺度。默认值：self._rate。
+        >>># `mean`、`sd`、`mode`、`var`和`entropy`的示例相似。
+        >>> ans = g1.mean()
+        >>> print(ans.shape)
+        (1,)
+        >>> ans = g1.mean(concentration_b, rate_b)
+        >>> print(ans.shape)
+        (3,)
+        >>> # 在函数调用期间必须传入`concentration`和`rate`。
+        >>> ans = g2.mean(concentration_a, rate_a)
+        >>> print(ans.shape)
+        (3,)
+        >>> # 'kl_loss'和'cross_entropy'的接口相同：
+        >>> # 参数：
+        >>> #     dist (str)：分布的类型。仅支持"Gamma"。
+        >>> #     concentration_b (Tensor)：分布b的浓度。
+        >>> #     rate_b (Tensor)：分布b的逆尺度。
+        >>> #     concentration_a (Tensor)：分布a的浓度。默认值：self._concentration。
+        >>> #     rate_a (Tensor)：分布a的逆尺度。默认值：self._rate。
+        >>> # `kl_loss`示例。`cross_entropy`也类似。
+        >>> ans = g1.kl_loss('Gamma', concentration_b, rate_b)
+        >>> print(ans.shape)
+        (3,)
+        >>> ans = g1.kl_loss('Gamma', concentration_b, rate_b, concentration_a, rate_a)
+        >>> print(ans.shape)
+        (3,)
+        >>> # 必须传入额外的`concentration`和`rate`。
+        >>> ans = g2.kl_loss('Gamma', concentration_b, rate_b, concentration_a, rate_a)
+        >>> print(ans.shape)
+        (3,)
+        >>> # `sample`示例。
+        >>> # 参数：
+        >>> #     shape (tuple)：样本的shape。默认值：()
+        >>> #     concentration (Tensor)：分布的浓度。默认值：self._concentration。
+        >>> #     rate (Tensor)：分布的逆尺度。默认值：self._rate。
+        >>> ans = g1.sample()
+        >>> print(ans.shape)
+        (1,)
+        >>> ans = g1.sample((2,3))
+        >>> print(ans.shape)
+        (2, 3, 1)
+        >>> ans = g1.sample((2,3), concentration_b, rate_b)
+        >>> print(ans.shape)
+        (2, 3, 3)
+        >>> ans = g2.sample((2,3), concentration_a, rate_a)
+        >>> print(ans.shape)
+        (2, 3, 3)
+    
+
+concentration
+
+        返回分布的浓度（也称为伽马分布的alpha）。
+        
+
+rate
+
+        返回分布的逆尺度（也称为伽马分布的beta）。
+        

docs/api/api_python/nn/probability/distribution/mindspore.nn.probability.distribution.Geometric.txt

@@ -0,0 +1,103 @@
+Class mindspore.nn.probability.distribution.Geometric(probs=None, seed=None, dtype=mindspore.int32, name='Geometric')
+
+    几何分布（Geometric Distribution）。
+
+    它代表在第一次成功之前有k次失败，即在第一次成功实现时，总共有k+1个伯努利试验。
+
+    参数：
+        probs (float, list, numpy.ndarray, Tensor)：成功的概率。默认值：None。
+        seed (int)：采样时使用的种子。如果为None，则使用全局种子。默认值：None。
+        dtype (mindspore.dtype)：事件样例的类型。默认值：mindspore.int32.
+        name (str)：分布的名称。默认值：'Geometric'。
+
+    支持平台：
+        ``Ascend`` ``GPU``
+
+    注：
+        `probs`必须是合适的概率（0<p<1）。
+
+    示例：
+        >>> import mindspore
+        >>> import mindspore.nn as nn
+        >>> import mindspore.nn.probability.distribution as msd
+        >>> from mindspore import Tensor
+        >>> # 初始化probability为0.5的几何分布。
+        >>> g1 = msd.Geometric(0.5, dtype=mindspore.int32)
+        >>> # 几何分布可以在没有参数的情况下初始化。
+        >>> # 在这种情况下，`probs`必须在函数调用过程中通过参数传入。
+        >>> g2 = msd.Geometric(dtype=mindspore.int32)
+        >>>
+        >>> # 下面是用于测试的Tensor
+        >>> value = Tensor([1, 0, 1], dtype=mindspore.int32)
+        >>> probs_a = Tensor([0.6], dtype=mindspore.float32)
+        >>> probs_b = Tensor([0.2, 0.5, 0.4], dtype=mindspore.float32)
+        >>>
+        >>> # 公共接口对应的概率函数的私有接口，包括`prob`、`log_prob`、`cdf`、`log_cdf`、`survival_function`、`log_survival`，具有以下相同的参数。
+        >>> # 参数：
+        >>> #     value  (Tensor)：要评估的值。
+        >>> #     probs1 (Tensor)：伯努利试验成功的概率。默认值：self.probs.
+        >>> # `prob`示例。
+        >>> # 通过将`prob`替换为函数的名称，可以对其他概率函数进行类似的调用。
+        >>> ans = g1.prob(value)
+        >>> print(ans.shape)
+        (3,)
+        >>> # 根据分布b进行评估。
+        >>> ans = g1.prob(value, probs_b)
+        >>> print(ans.shape)
+        (3,)
+        >>> # `probs`必须在函数调用期间传入。
+        >>> ans = g2.prob(value, probs_a)
+        >>> print(ans.shape)
+        (3,)
+        >>> # 函数`mean`、`sd`、`var`和`entropy`具有相同的参数。
+        >>> # 参数：
+        >>> #     probs1 (Tensor)：伯努利试验成功的概率。默认值：self.probs.
+        >>> # `mean`示例。`sd`、`var`和`entropy`是相似的。
+        >>> ans = g1.mean() # return 1.0
+        >>> print(ans.shape)
+        ()
+        >>> ans = g1.mean(probs_b)
+        >>> print(ans.shape)
+        (3,)
+        >>> # 函数调用时必须传入probs。
+        >>> ans = g2.mean(probs_a)
+        >>> print(ans.shape)
+        (1,)
+        >>> # 'kl_loss'和'cross_entropy'的接口相同。
+        >>> # 参数：
+        >>> #     dist (str)：分布的名称。仅支持'Geometric'。
+        >>> #     probs1_b (Tensor)：伯努利分布b试验成功的概率。
+        >>> #     probs1_a (Tensor)：伯努利分布a试验成功的概率。
+        >>> # `kl_loss`示例。`cross_entropy`也类似。
+        >>> ans = g1.kl_loss('Geometric', probs_b)
+        >>> print(ans.shape)
+        (3,)
+        >>> ans = g1.kl_loss('Geometric', probs_b, probs_a)
+        >>> print(ans.shape)
+        (3,)
+        >>> # 必须传入额外的`probs`。
+        >>> ans = g2.kl_loss('Geometric', probs_b, probs_a)
+        >>> print(ans.shape)
+        (3,)
+        >>> # `sample`示例。
+        >>> # 参数：
+        >>> #     shape (tupler)：样本的shape。默认值：()
+        >>> #     probs1 (Tensor)：伯努利试验成功的概率。默认值：self.probs.
+        >>> ans = g1.sample()
+        >>> print(ans.shape)
+        ()
+        >>> ans = g1.sample((2,3))
+        >>> print(ans.shape)
+        (2, 3)
+        >>> ans = g1.sample((2,3), probs_b)
+        >>> print(ans.shape)
+        (2, 3, 3)
+        >>> ans = g2.sample((2,3), probs_a)
+        >>> print(ans.shape)
+        (2, 3, 1)
+    
+
+probs
+
+        返回伯努利试验成功的概率。
+        

docs/api/api_python/nn/probability/distribution/mindspore.nn.probability.distribution.Gumbel.txt

@@ -0,0 +1,45 @@
+Class mindspore.nn.probability.distribution.Gumbel(loc, scale, seed=0, dtype=mindspore.float32, name='Gumbel')
+
+    耿贝尔分布（Gumbel distribution）。
+
+    参数：
+        loc (float, list, numpy.ndarray, Tensor)：耿贝尔分布的位置。
+        scale (float, list, numpy.ndarray, Tensor)：耿贝尔分布的尺度。
+        seed (int)：采样时使用的种子。如果为None，则使用全局种子。默认值：None。
+        dtype (mindspore.dtype)：分布类型。默认值：mindspore.float32。
+        name (str)：分布的名称。默认值：'Gumbel'。
+
+    支持平台：
+        ``Ascend`` ``GPU``
+
+    注：
+        `scale`必须大于零。
+        `dtype`必须是浮点类型，因为耿贝尔分布是连续的。
+        GPU后端不支持`kl_loss`和`cross_entropy`。
+
+    示例：
+        >>> import mindspore
+        >>> import mindspore.nn as nn
+        >>> import mindspore.nn.probability.distribution as msd
+        >>> from mindspore import Tensor
+        >>> class Prob(nn.Cell):
+        ...     def __init__(self):
+        ...         super(Prob, self).__init__()
+        ...         self.gum = msd.Gumbel(np.array([0.0]), np.array([[1.0], [2.0]]), dtype=mindspore.float32)
+        ...
+        ...     def construct(self, x_):
+        ...         return self.gum.prob(x_)
+        >>> value = np.array([1.0, 2.0]).astype(np.float32)
+        >>> pdf = Prob()
+        >>> output = pdf(Tensor(value, dtype=mindspore.float32))
+    
+
+loc
+
+        返回分布位置。
+        
+
+scale
+
+        返回分布尺度。
+        

docs/api/api_python/nn/probability/distribution/mindspore.nn.probability.distribution.LogNormal.txt

@@ -0,0 +1,46 @@
+Class mindspore.nn.probability.distribution.LogNormal(loc=None, scale=None, seed=0, dtype=mindspore.float32, name='LogNormal')
+
+    对数正态分布（LogNormal distribution）。
+    对数正态分布是随机变量的连续概率分布，变量的对数为正态分布。它被构造为正态分布的指数变换。
+
+    参数：
+        loc (int, float, list, numpy.ndarray, Tensor)：基础正态分布的平均值。默认值：None。
+        scale (int, float, list, numpy.ndarray, Tensor)：基础正态分布的标准差。默认值：None。
+        seed (int)：采样时使用的种子。如果为None，则使用全局种子。默认值：None。
+        dtype (mindspore.dtype)：分布类型。默认值：mindspore.float32。
+        name (str)：分布的名称。默认值：'LogNormal'。
+
+    支持平台：
+        ``Ascend`` ``GPU``
+
+    注：
+        `scale`必须大于零。
+        `dtype`必须是float，因为对数正态分布是连续的。
+
+    示例：
+        >>> import numpy as np
+        >>> import mindspore
+        >>> import mindspore.nn as nn
+        >>> import mindspore.nn.probability.distribution as msd
+        >>> from mindspore import Tensor
+        >>> class Prob(nn.Cell):
+        ...     def __init__(self):
+        ...         super(Prob, self).__init__()
+        ...         self.ln = msd.LogNormal(np.array([0.3]), np.array([[0.2], [0.4]]), dtype=mindspore.float32)
+        ...     def construct(self, x_):
+        ...         return self.ln.prob(x_)
+        >>> pdf = Prob()
+        >>> output = pdf(Tensor([1.0, 2.0], dtype=mindspore.float32))
+        >>> print(output.shape)
+        (2, 2)
+    
+
+loc
+
+        返回分布的均值。
+        
+
+scale
+
+        返回分布的标准差。
+        

docs/api/api_python/nn/probability/distribution/mindspore.nn.probability.distribution.Logistic.txt

@@ -0,0 +1,97 @@
+Class mindspore.nn.probability.distribution.Logistic(loc=None, scale=None, seed=None, dtype=mindspore.float32, name='Logistic')
+
+    逻辑斯谛分布（Logistic distribution）。
+
+    参数：
+        loc (int, float, list, numpy.ndarray, Tensor)：逻辑斯谛分布的位置。默认值：None。
+        scale (int, float, list, numpy.ndarray, Tensor)：逻辑斯谛分布的尺度。默认值：None。
+        seed (int)：采样时使用的种子。如果为None，则使用全局种子。默认值：None。
+        dtype (mindspore.dtype)：事件样例的类型。默认值：mindspore.float32。
+        name (str)：分布的名称。默认值：'Logistic'。
+
+    支持平台：
+        ``Ascend`` ``GPU``
+
+    注：
+        `scale`必须大于零。
+        `dtype`必须是float，因为逻辑斯谛分布是连续的。
+
+    示例：
+        >>> import mindspore
+        >>> import mindspore.nn as nn
+        >>> import mindspore.nn.probability.distribution as msd
+        >>> from mindspore import Tensor
+        >>> # 初始化loc为3.0和scale为4.0的逻辑斯谛分布。
+        >>> l1 = msd.Logistic(3.0, 4.0, dtype=mindspore.float32)
+        >>> # 可以在没有参数的情况下初始化逻辑斯谛分布。
+        >>> # 在这种情况下，`loc`和`scale`必须通过参数传入。
+        >>> l2 = msd.Logistic(dtype=mindspore.float32)
+        >>>
+        >>> # 下面是用于测试的Tensor
+        >>> value = Tensor([1.0, 2.0, 3.0], dtype=mindspore.float32)
+        >>> loc_a = Tensor([2.0], dtype=mindspore.float32)
+        >>> scale_a = Tensor([2.0, 2.0, 2.0], dtype=mindspore.float32)
+        >>> loc_b = Tensor([1.0], dtype=mindspore.float32)
+        >>> scale_b = Tensor([1.0, 1.5, 2.0], dtype=mindspore.float32)
+        >>>
+        >>> # 公共接口对应的概率函数的私有接口，包括`prob`、`log_prob`、`cdf`、`log_cdf`、`survival_function`、`log_survival`，具有以下相同的参数。
+        >>> # 参数：
+        >>> #     value  (Tensor)：要评估的值。
+        >>> #     loc (Tensor)：分布的位置。默认值：self.loc.
+        >>> #     scale (Tensor)：分布的尺度。默认值：self.scale.
+        >>> # `prob`示例。
+        >>> # 通过将'prob'替换为函数的名称，可以对其他概率函数进行类似的调用
+        >>> ans = l1.prob(value)
+        >>> print(ans.shape)
+        (3,)
+        >>> # 根据分布b进行评估。
+        >>> ans = l1.prob(value, loc_b, scale_b)
+        >>> print(ans.shape)
+        (3,)
+        >>> # 在函数调用期间必须传入`loc`和`scale`
+        >>> ans = l1.prob(value, loc_a, scale_a)
+        >>> print(ans.shape)
+        (3,)
+        >>> # 函数`mean`、`mode`、`sd`、`var`和`entropy`具有相同的参数。
+        >>> # 参数：
+        >>> #     loc (Tensor)：分布的位置。默认值：self.loc.
+        >>> #     scale (Tensor)：分布的尺度。默认值：self.scale.
+        >>> # 'mean'示例。`mode`、`sd`、`var`和`entropy`也类似。
+        >>> ans = l1.mean()
+        >>> print(ans.shape)
+        ()
+        >>> ans = l1.mean(loc_b, scale_b)
+        >>> print(ans.shape)
+        (3,)
+        >>> # 在函数调用期间必须传入`loc`和`scale`。
+        >>> ans = l1.mean(loc_a, scale_a)
+        >>> print(ans.shape)
+        (3,)
+        >>> # `sample`示例。
+        >>> # 参数：
+        >>> #     shape (tuple)：样本的shape。默认值：()
+        >>> #     loc (Tensor)：分布的位置。默认值：self.loc.
+        >>> #     scale (Tensor)：分布的尺度。默认值：self.scale.
+        >>> ans = l1.sample()
+        >>> print(ans.shape)
+        ()
+        >>> ans = l1.sample((2,3))
+        >>> print(ans.shape)
+        (2, 3)
+        >>> ans = l1.sample((2,3), loc_b, scale_b)
+        >>> print(ans.shape)
+        (2, 3, 3)
+        >>> ans = l1.sample((2,3), loc_a, scale_a)
+        >>> print(ans.shape)
+        (2, 3, 3)
+    
+
+loc
+
+        返回分布的位置。
+        
+
+scale
+
+        返回分布的尺度。
+        

docs/api/api_python/nn/probability/distribution/mindspore.nn.probability.distribution.Normal.txt

@@ -0,0 +1,103 @@
+Class mindspore.nn.probability.distribution.Normal(mean=None, sd=None, seed=None, dtype=mindspore.float32, name='Normal')
+
+    正态分布（Normal distribution）。
+
+    参数：
+        mean (int, float, list, numpy.ndarray, Tensor)：正态分布的平均值。默认值：None。
+        sd (int, float, list, numpy.ndarray, Tensor)：正态分布的标准差。默认值：None。
+        seed (int)：采样时使用的种子。如果为None，则使用全局种子。默认值：None。
+        dtype (mindspore.dtype)：事件样例的类型。默认值：mindspore.float32。
+        name (str)：分布的名称。默认值：'Normal'。
+
+    支持平台：
+        ``Ascend`` ``GPU``
+
+    注：
+        `sd`必须大于零。
+        `dtype`必须是float，因为正态分布是连续的。
+
+    示例：
+        >>> import mindspore
+        >>> import mindspore.nn as nn
+        >>> import mindspore.nn.probability.distribution as msd
+        >>> from mindspore import Tensor
+        >>> # 初始化mean为3.0和standard deviation为4.0的正态分布。
+        >>> n1 = msd.Normal(3.0, 4.0, dtype=mindspore.float32)
+        >>> # 正态分布可以在没有参数的情况下初始化。
+        >>> # 在这种情况下，`mean`和`sd`必须通过参数传入。
+        >>> n2 = msd.Normal(dtype=mindspore.float32)
+        >>> # 下面是用于测试的Tensor
+        >>> value = Tensor([1.0, 2.0, 3.0], dtype=mindspore.float32)
+        >>> mean_a = Tensor([2.0], dtype=mindspore.float32)
+        >>> sd_a = Tensor([2.0, 2.0, 2.0], dtype=mindspore.float32)
+        >>> mean_b = Tensor([1.0], dtype=mindspore.float32)
+        >>> sd_b = Tensor([1.0, 1.5, 2.0], dtype=mindspore.float32)
+        >>> # 公共接口对应的概率函数的私有接口，包括`prob`、`log_prob`、`cdf`、`log_cdf`、`survival_function`、`log_survival`，具有以下相同的参数。
+        >>> # 参数：
+        >>> #     value (Tensor)：要评估的值。
+        >>> #     mean (Tensor)：分布的均值。默认值：self._mean_value。
+        >>> #     sd (Tensor)：分布的标准差。默认值：self._sd_value。
+        >>> # `prob`示例。
+        >>> # 通过将'prob'替换为其他概率函数的名称，可以对其他概率函数进行类似的调用
+        >>> ans = n1.prob(value)
+        >>> print(ans.shape)
+        (3,)
+        >>> # 根据分布b进行评估。
+        >>> ans = n1.prob(value, mean_b, sd_b)
+        >>> print(ans.shape)
+        (3,)
+        >>> # 在函数调用期间必须传入`mean`和`sd`
+        >>> ans = n2.prob(value, mean_a, sd_a)
+        >>> print(ans.shape)
+        (3,)
+        >>> # 函数`mean`、`sd`、`var`和`entropy`具有相同的参数。
+        >>> # 参数：
+        >>> #     mean (Tensor)：分布的均值。默认值：self._mean_value。
+        >>> #     sd (Tensor)：分布的标准差。默认值：self._sd_value。
+        >>> # 'mean'示例。`sd`、`var`和`entropy`是相似的。
+        >>> ans = n1.mean() # return 0.0
+        >>> print(ans.shape)
+        ()
+        >>> ans = n1.mean(mean_b, sd_b) # return mean_b
+        >>> print(ans.shape)
+        (3,)
+        >>> # `mean`和`sd`必须在函数调用期间传入。
+        >>> ans = n2.mean(mean_a, sd_a)
+        >>> print(ans.shape)
+        (3,)
+        >>> # 'kl_loss'和'cross_entropy'的接口相同：
+        >>> # 参数：
+        >>> #     dist (str)：分布的类型。仅支持"Normal"。
+        >>> #     mean_b (Tensor)：分布b的均值。
+        >>> #     sd_b（Tensor)：分布b的标准差。
+        >>> #     mean_a (Tensor)：分布a的均值。默认值：self._mean_value。
+        >>> #     sd_a（Tensor)：分布a的标准差。默认值：self._sd_value。
+        >>> # `kl_loss`示例。`cross_entropy`也类似。
+        >>> ans = n1.kl_loss('Normal', mean_b, sd_b)
+        >>> print(ans.shape)
+        (3,)
+        >>> ans = n1.kl_loss('Normal', mean_b, sd_b, mean_a, sd_a)
+        >>> print(ans.shape)
+        (3,)
+        >>> # 必须传入额外的`mean`和`sd`。
+        >>> ans = n2.kl_loss('Normal', mean_b, sd_b, mean_a, sd_a)
+        >>> print(ans.shape)
+        (3,)
+        >>> # `sample`示例。
+        >>> # 参数：
+        >>> #     shape (tuple)：样本的shape。默认值：()
+        >>> #     mean (Tensor)：分布的均值。默认值：self._mean_value。
+        >>> #     sd (Tensor)：分布的标准差。默认值：self._sd_value。
+        >>> ans = n1.sample()
+        >>> print(ans.shape)
+        ()
+        >>> ans = n1.sample((2,3))
+        >>> print(ans.shape)
+        (2, 3)
+        >>> ans = n1.sample((2,3), mean_b, sd_b)
+        >>> print(ans.shape)
+        (2, 3, 3)
+        >>> ans = n2.sample((2,3), mean_a, sd_a)
+        >>> print(ans.shape)
+        (2, 3, 3)
+

docs/api/api_python/nn/probability/distribution/mindspore.nn.probability.distribution.Poisson.txt

@@ -0,0 +1,85 @@
+Class mindspore.nn.probability.distribution.Poisson(rate=None, seed=None, dtype=mindspore.float32, name='Poisson')
+
+    泊松分布（Poisson Distribution）。
+
+    参数：
+        rate (list, numpy.ndarray, Tensor)：泊松分布的率参数。默认值：None。
+        seed (int)：采样时使用的种子。如果为None，则使用全局种子。默认值：None。
+        dtype (mindspore.dtype)：事件样例的类型。默认值：mindspore.float32。
+        name (str)：分布的名称。默认值：'Poisson'。
+
+    支持平台：
+        ``Ascend``
+
+    注：
+        `rate`必须大于0。
+
+    示例：
+        >>> import mindspore
+        >>> import mindspore.nn as nn
+        >>> import mindspore.nn.probability.distribution as msd
+        >>> from mindspore import Tensor
+        >>> # 初始化rate为0.5的泊松分布。
+        >>> p1 = msd.Poisson([0.5], dtype=mindspore.float32)
+        >>> # 泊松分布可以在没有参数的情况下初始化。
+        >>> # 在这种情况下，`rate`必须在函数调用期间通过`args`传入。
+        >>> p2 = msd.Poisson(dtype=mindspore.float32)
+        >>>
+        >>> # 下面是用于测试的Tensor
+        >>> value = Tensor([1, 2, 3], dtype=mindspore.int32)
+        >>> rate_a = Tensor([0.6], dtype=mindspore.float32)
+        >>> rate_b = Tensor([0.2, 0.5, 0.4], dtype=mindspore.float32)
+        >>>
+        >>> # 公共接口对应的概率函数的私有接口，包括`prob`、`log_prob`、`cdf`、`log_cdf`、`survival_function`、`log_survival`，如下所示。
+        >>> # 参数：
+        >>> #     value  (Tensor)：要评估的值。
+        >>> #     rate (Tensor)：分布的率参数。默认值：self.rate.
+        >>> # `prob`示例。
+        >>> # 通过将`prob`替换为其他概率函数的名称，可以对其他概率函数进行类似的调用。
+        >>> ans = p1.prob(value)
+        >>> print(ans.shape)
+        (3,)
+        >>> # 根据分布b进行评估。
+        >>> ans = p1.prob(value, rate_b)
+        >>> print(ans.shape)
+        (3,)
+        >>> # `rate`必须在函数调用期间传入。
+        >>> ans = p2.prob(value, rate_a)
+        >>> print(ans.shape)
+        (3,)
+        >>> # 函数`mean`、`mode`、`sd`和'var'具有相同的参数，如下所示。
+        >>> # 参数：
+        >>> #     rate (Tensor)：分布的率参数。默认值：self.rate.
+        >>> # `mean`、`sd`、`mode`和`var`的示例都类似。
+        >>> ans = p1.mean() # return 2
+        >>> print(ans.shape)
+        (1,)
+        >>> ans = p1.mean(rate_b) # return 1 / rate_b
+        >>> print(ans.shape)
+        (3,)
+        >>> # `rate`必须在函数调用期间传入。
+        >>> ans = p2.mean(rate_a)
+        >>> print(ans.shape)
+        (1,)
+        >>> # `sample`示例。
+        >>> # 参数：
+        >>> #     shape (tuple)：样本的shape。默认值：()
+        >>> #     probs1 (Tensor)：分布的率参数。默认值：self.rate.
+        >>> ans = p1.sample()
+        >>> print(ans.shape)
+        (1, )
+        >>> ans = p1.sample((2,3))
+        >>> print(ans.shape)
+        (2, 3, 1)
+        >>> ans = p1.sample((2,3), rate_b)
+        >>> print(ans.shape)
+        (2, 3, 3)
+        >>> ans = p2.sample((2,3), rate_a)
+        >>> print(ans.shape)
+        (2, 3, 1)
+    
+
+rate
+
+        返回分布的`rate`参数。
+        

docs/api/api_python/nn/probability/distribution/mindspore.nn.probability.distribution.TransformedDistribution.txt

@@ -0,0 +1,47 @@
+Class mindspore.nn.probability.distribution.TransformedDistribution(bijector, distribution, seed=None, name='transformed_distribution')
+
+    转换分布（Transformed Distribution）。
+    该类包含一个Bijector和一个分布，并通过Bijector定义的操作将原始分布转换为新分布。
+
+    参数：
+        bijector (Bijector)：要执行的转换。
+        distribution (Distribution)：原始分布。必须具有float数据类型。
+        seed (int)：采样时使用的种子。如果为None，则使用全局种子。默认值：None。
+          如果在初始化TransformedDistribution对象时给出了此种子，则对象的采样函数将使用此种子；否则，将使用基础分布的种子。
+        name (str)：转换分布的名称。默认值：'transformed_distribution'。
+
+    支持平台：
+        ``Ascend`` ``GPU``
+
+    注：
+        用于初始化原始分布的参数不能为None。
+        例如，由于未指定`mean`和`sd`，因此无法使用mynormal = msd.Normal(dtype=mindspore.float32)初始化TransformedDistribution。
+
+    示例：
+        >>> import numpy as np
+        >>> import mindspore
+        >>> import mindspore.nn as nn
+        >>> import mindspore.nn.probability.distribution as msd
+        >>> import mindspore.nn.probability.bijector as msb
+        >>> from mindspore import Tensor
+        >>> class Net(nn.Cell):
+        ...     def __init__(self, shape, dtype=mindspore.float32, seed=0, name='transformed_distribution'):
+        ...         super(Net, self).__init__()
+        ...         # 创建转换分布
+        ...         self.exp = msb.Exp()
+        ...         self.normal = msd.Normal(0.0, 1.0, dtype=dtype)
+        ...         self.lognormal = msd.TransformedDistribution(self.exp, self.normal, seed=seed, name=name)
+        ...         self.shape = shape
+        ...
+        ...     def construct(self, value):
+        ...         cdf = self.lognormal.cdf(value)
+        ...         sample = self.lognormal.sample(self.shape)
+        ...         return cdf, sample
+        >>> shape = (2, 3)
+        >>> net = Net(shape=shape, name="LogNormal")
+        >>> x = np.array([2.0, 3.0, 4.0, 5.0]).astype(np.float32)
+        >>> tx = Tensor(x, dtype=mindspore.float32)
+        >>> cdf, sample = net(tx)
+        >>> print(sample.shape)
+        (2, 3)
+    

docs/api/api_python/nn/probability/distribution/mindspore.nn.probability.distribution.Uniform.txt

@@ -0,0 +1,115 @@
+Class mindspore.nn.probability.distribution.Uniform(low=None, high=None, seed=None, dtype=mindspore.float32, name='Uniform')
+
+    示例类：均匀分布（Uniform Distribution）。
+
+    参数：
+        low (int, float, list, numpy.ndarray, Tensor)：分布的下限。默认值：None。
+        high (int, float, list, numpy.ndarray, Tensor)：分布的上限。默认值：None。
+        seed (int)：采样时使用的种子。如果为None，则使用全局种子。默认值：None。
+        dtype (mindspore.dtype)：事件样例的类型。默认值：mindspore.float32。
+        name (str)：分布的名称。默认值：'Uniform'。
+
+    支持平台：
+        ``Ascend`` ``GPU``
+
+    注：
+        `low`必须小于`high`。
+        `dtype`必须是float类型，因为均匀分布是连续的。
+
+    示例：
+        >>> import mindspore
+        >>> import mindspore.nn as nn
+        >>> import mindspore.nn.probability.distribution as msd
+        >>> from mindspore import Tensor
+        >>> # 初始化lower bound为0.0和higher bound为1.0的均匀分布。
+        >>> u1 = msd.Uniform(0.0, 1.0, dtype=mindspore.float32)
+        >>> # 平均分布可以在没有参数的情况下初始化。
+        >>> # 在这种情况下，`high`和`low`必须在函数调用过程中通过参数传入。
+        >>> u2 = msd.Uniform(dtype=mindspore.float32)
+        >>>
+        >>> # 下面是用于测试的Tensor
+        >>> value = Tensor([0.5, 0.8], dtype=mindspore.float32)
+        >>> low_a = Tensor([0., 0.], dtype=mindspore.float32)
+        >>> high_a = Tensor([2.0, 4.0], dtype=mindspore.float32)
+        >>> low_b = Tensor([-1.5], dtype=mindspore.float32)
+        >>> high_b = Tensor([2.5, 5.], dtype=mindspore.float32)
+        >>> # 公共接口对应的概率函数的私有接口，包括
+        >>> # `prob`、`log_prob`、`cdf`、`log_cdf`、`survival_function`、`log_survival`，具有相同的参数。
+        >>> # 参数：
+        >>> #     value (Tensor)：要评估的值。
+        >>> #     low (Tensor)：分布的下限。默认值：self.low.
+        >>> #     high (Tensor)：分布的上限。默认值：self.high。
+        >>> # `prob`示例。
+        >>> # 通过将'prob'替换为函数的名称，可以对其他概率函数进行类似的调用。        
+        >>> ans = u1.prob(value)
+        >>> print(ans.shape)
+        (2,)
+        >>> # 根据分布b进行评估。
+        >>> ans = u1.prob(value, low_b, high_b)
+        >>> print(ans.shape)
+        (2,)
+        >>> # `high`和`low`必须在函数调用期间传入。
+        >>> ans = u2.prob(value, low_a, high_a)
+        >>> print(ans.shape)
+        (2,)
+        >>> # 函数`mean`、`sd`、`var`和`entropy`具有相同的参数。
+        >>> # 参数：
+        >>> #     low (Tensor)：分布的下限。默认值：self.low.
+        >>> #     high (Tensor)：分布的上限。默认值：self.high。
+        >>> # `mean`示例。`sd`、`var`和`entropy`是相似的。
+        >>> ans = u1.mean() # return 0.5
+        >>> print(ans.shape)
+        ()
+        >>> ans = u1.mean(low_b, high_b) # return (low_b + high_b) / 2
+        >>> print(ans.shape)
+        (2,)
+        >>> # `high`和`low`必须在函数调用期间传入。
+        >>> ans = u2.mean(low_a, high_a)
+        >>> print(ans.shape)
+        (2,)
+        >>> # 'kl_loss'和'cross_entropy'的接口相同。
+        >>> # 参数：
+        >>> #     dist (str)：分布的类型。在这种情况下，应该是"Uniform"。
+        >>> #     low_b (Tensor)：分布b的下限。
+        >>> #     high_b (Tensor)：分布b的上限。
+        >>> #     low_a (Tensor)：分布a的下限。默认值：self.low.
+        >>> #     high_a (Tensor)：分布a的上限。默认值：self.high。
+        >>> # `kl_loss`示例。`cross_entropy`也类似。
+        >>> ans = u1.kl_loss('Uniform', low_b, high_b)
+        >>> print(ans.shape)
+        (2,)
+        >>> ans = u1.kl_loss('Uniform', low_b, high_b, low_a, high_a)
+        >>> print(ans.shape)
+        (2,)
+        >>> # 必须传入额外的`high`和`low`。
+        >>> ans = u2.kl_loss('Uniform', low_b, high_b, low_a, high_a)
+        >>> print(ans.shape)
+        (2,)
+        >>> # `sample`示例。
+        >>> # 参数：
+        >>> #     shape (tuple)：样本的shape。默认值：()
+        >>> #     low (Tensor)：分布的下限。默认值：self.low.
+        >>> #     high (Tensor)：分布的上限。默认值：self.high。
+        >>> ans = u1.sample()
+        >>> print(ans.shape)
+        ()
+        >>> ans = u1.sample((2,3))
+        >>> print(ans.shape)
+        (2, 3)
+        >>> ans = u1.sample((2,3), low_b, high_b)
+        >>> print(ans.shape)
+        (2, 3, 2)
+        >>> ans = u2.sample((2,3), low_a, high_a)
+        >>> print(ans.shape)
+        (2, 3, 2)
+    
+
+high
+
+        返回分布的上限。
+        
+
+low
+
+        返回分布的下限。
+        

docs/api/api_python/nn/probability/mindspore.nn.probability.txt

@@ -0,0 +1,3 @@
+mindspore.nn.probability
+
+用于构造概率网络的高级组件。