SciPy-1-12-中文文档-二十四-
SciPy 1.12 中文文档（二十四）
scipy.stats.vonmises
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.vonmises.html#scipy.stats.vonmises
scipy.stats.vonmises = <scipy.stats._continuous_distns.vonmises_gen object>
一个 Von Mises 连续随机变量。
作为 rv_continuous 类的一个实例，vonmises 对象继承了一系列通用方法（详见下文），并为这一特定分布补充了特定的细节。
另请参阅
scipy.stats.vonmises_fisher
Von-Mises Fisher 分布在超球面上
注释
对于 vonmises 和 vonmises_line 的概率密度函数为：
[f(x, \kappa) = \frac{ \exp(\kappa \cos(x)) }{ 2 \pi I_0(\kappa) }]
对于 (-\pi \le x \le \pi)，(\kappa > 0)。(I_0) 是零阶修正贝塞尔函数（scipy.special.i0）。
vonmises 是一个环形分布，不限制分布到固定区间。目前，SciPy 中没有环形分布框架。cdf 的实现使得 cdf(x + 2*np.pi) == cdf(x) + 1。
vonmises_line 是相同的分布，定义在实轴上的 ([-\pi, \pi]) 区间。这是一个常规（非环形）分布。
关于分布参数的说明：vonmises 和 vonmises_line 将 kappa 作为形状参数（集中度）和 loc 作为位置参数（环形均值）进行接受。接受 scale 参数但不产生任何效果。
示例
导入必要的模块。
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.stats import vonmises
定义分布参数。
>>> loc = 0.5 * np.pi # circular mean
>>> kappa = 1 # concentration
计算使用 pdf 方法在 x=0 处的概率密度。
>>> vonmises.pdf(loc, kappa, 0)
0.12570826359722018
验证百分位函数 ppf 反转累积分布函数 cdf，精确到浮点数精度。
>>> x = 1
>>> cdf_value = vonmises.cdf(loc=loc, kappa=kappa, x=x)
>>> ppf_value = vonmises.ppf(cdf_value, loc=loc, kappa=kappa)
>>> x, cdf_value, ppf_value
(1, 0.31489339900904967, 1.0000000000000004)
调用 rvs 方法绘制 1000 个随机变量。
>>> number_of_samples = 1000
>>> samples = vonmises(loc=loc, kappa=kappa).rvs(number_of_samples)
在笛卡尔和极坐标网格上绘制 von Mises 密度以突出显示其为环形分布。
>>> fig = plt.figure(figsize=(12, 6))
>>> left = plt.subplot(121)
>>> right = plt.subplot(122, projection='polar')
>>> x = np.linspace(-np.pi, np.pi, 500)
>>> vonmises_pdf = vonmises.pdf(loc, kappa, x)
>>> ticks = [0, 0.15, 0.3]
左侧图像包含笛卡尔图。
>>> left.plot(x, vonmises_pdf)
>>> left.set_yticks(ticks)
>>> number_of_bins = int(np.sqrt(number_of_samples))
>>> left.hist(samples, density=True, bins=number_of_bins)
>>> left.set_title("Cartesian plot")
>>> left.set_xlim(-np.pi, np.pi)
>>> left.grid(True)
右侧图像包含极坐标图。
>>> right.plot(x, vonmises_pdf, label="PDF")
>>> right.set_yticks(ticks)
>>> right.hist(samples, density=True, bins=number_of_bins,
... label="Histogram")
>>> right.set_title("Polar plot")
>>> right.legend(bbox_to_anchor=(0.15, 1.06))
方法
| rvs(kappa, loc=0, scale=1, size=1, random_state=None) | 随机变量。 |
|---|---|
| pdf(x, kappa, loc=0, scale=1) | 概率密度函数。 |
| logpdf(x, kappa, loc=0, scale=1) | 概率密度函数的自然对数。 |
| cdf(x, kappa, loc=0, scale=1) | 累积分布函数。 |
| logcdf(x, kappa, loc=0, scale=1) | 累积分布函数的对数。 |
| sf(x, kappa, loc=0, scale=1) | 生存函数（也定义为 1 - cdf，但 sf 有时更精确）。 |
| logsf(x, kappa, loc=0, scale=1) | 生存函数的对数。 |
| ppf(q, kappa, loc=0, scale=1) | 百分点函数（cdf 的逆函数 — 百分位数）。 |
| isf(q, kappa, loc=0, scale=1) | 逆生存函数（sf 的逆函数）。 |
| moment(order, kappa, loc=0, scale=1) | 指定阶数的非中心矩。 |
| stats(kappa, loc=0, scale=1, moments=’mv’) | 均值（‘m’）、方差（‘v’）、偏度（‘s’）和/或峰度（‘k’）。 |
| entropy(kappa, loc=0, scale=1) | 随机变量的（微分）熵。 |
| fit(data) | 通用数据的参数估计。详细文档请参见 scipy.stats.rv_continuous.fit。 |
| **expect(func, args=(kappa,), loc=0, scale=1, lb=None, ub=None, conditional=False, kwds) | 对于分布的一个参数，函数（一个参数的函数）的期望值。 |
| median(kappa, loc=0, scale=1) | 分布的中位数。 |
| mean(kappa, loc=0, scale=1) | 分布的均值。 |
| var(kappa, loc=0, scale=1) | 分布的方差。 |
| std(kappa, loc=0, scale=1) | 分布的标准差。 |
| interval(confidence, kappa, loc=0, scale=1) | 置信区间，围绕中位数具有相等面积的区间。 |
scipy.stats.vonmises_line
scipy.stats.vonmises_line = <scipy.stats._continuous_distns.vonmises_gen object>
一个 Von Mises 连续随机变量。
作为 rv_continuous 类的实例，vonmises_line 对象从中继承了一系列通用方法（请参阅下面的完整列表），并使用特定于此特定分布的详细信息补充它们。
另请参见
Von-Mises Fisher 分布在超球面上
注释
vonmises 和 vonmises_line 的概率密度函数为：
[f(x, \kappa) = \frac{ \exp(\kappa \cos(x)) }{ 2 \pi I_0(\kappa) }]
对于 (-\pi \le x \le \pi), (\kappa > 0)。 (I_0) 是零阶修改贝塞尔函数（scipy.special.i0）。
vonmises 是一个不限制分布到固定区间的圆形分布。目前 SciPy 中没有圆形分布框架。 cdf 实现使得 cdf(x + 2*np.pi) == cdf(x) + 1。
vonmises_line 是相同的分布，在实轴上定义在 ([-\pi, \pi])。这是一个常规（非圆形）分布。
关于分布参数的注意：vonmises 和 vonmises_line 以 kappa 作为形状参数（集中度）和 loc 作为位置（圆形均值）。接受 scale 参数但不产生任何效果。
示例
导入必要的模块。
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.stats import vonmises
定义分布参数。
>>> loc = 0.5 * np.pi # circular mean
>>> kappa = 1 # concentration
通过 pdf 方法计算 x=0 处的概率密度。
>>> vonmises.pdf(loc, kappa, 0)
0.12570826359722018
验证百分位函数ppf在浮点精度下反转累积分布函数cdf。
>>> x = 1
>>> cdf_value = vonmises.cdf(loc=loc, kappa=kappa, x=x)
>>> ppf_value = vonmises.ppf(cdf_value, loc=loc, kappa=kappa)
>>> x, cdf_value, ppf_value
(1, 0.31489339900904967, 1.0000000000000004)
通过调用 rvs 方法绘制 1000 个随机变量。
>>> number_of_samples = 1000
>>> samples = vonmises(loc=loc, kappa=kappa).rvs(number_of_samples)
在笛卡尔和极坐标网格上绘制冯·米塞斯密度图，以突显其为圆形分布。
>>> fig = plt.figure(figsize=(12, 6))
>>> left = plt.subplot(121)
>>> right = plt.subplot(122, projection='polar')
>>> x = np.linspace(-np.pi, np.pi, 500)
>>> vonmises_pdf = vonmises.pdf(loc, kappa, x)
>>> ticks = [0, 0.15, 0.3]
左图包含笛卡尔图。
>>> left.plot(x, vonmises_pdf)
>>> left.set_yticks(ticks)
>>> number_of_bins = int(np.sqrt(number_of_samples))
>>> left.hist(samples, density=True, bins=number_of_bins)
>>> left.set_title("Cartesian plot")
>>> left.set_xlim(-np.pi, np.pi)
>>> left.grid(True)
右图包含极坐标图。
>>> right.plot(x, vonmises_pdf, label="PDF")
>>> right.set_yticks(ticks)
>>> right.hist(samples, density=True, bins=number_of_bins,
... label="Histogram")
>>> right.set_title("Polar plot")
>>> right.legend(bbox_to_anchor=(0.15, 1.06))
方法
| rvs(kappa, loc=0, scale=1, size=1, random_state=None) | 随机变量。 |
|---|---|
| pdf(x, kappa, loc=0, scale=1) | 概率密度函数。 |
| logpdf(x, kappa, loc=0, scale=1) | 概率密度函数的对数。 |
| cdf(x, kappa, loc=0, scale=1) | 累积分布函数。 |
| logcdf(x, kappa, loc=0, scale=1) | 累积分布函数的对数。 |
| sf(x, kappa, loc=0, scale=1) | 生存函数（也定义为 1 - cdf，但sf有时更精确）。 |
| logsf(x, kappa, loc=0, scale=1) | 生存函数的对数。 |
| ppf(q, kappa, loc=0, scale=1) | 百分位点函数（cdf 的反函数 — 百分位数）。 |
| isf(q, kappa, loc=0, scale=1) | 逆生存函数（sf的反函数）。 |
| moment(order, kappa, loc=0, scale=1) | 指定阶数的非中心矩。 |
| stats(kappa, loc=0, scale=1, moments=’mv’) | 平均值（‘m’）、方差（‘v’）、偏度（‘s’）和/或峰度（‘k’）。 |
| entropy(kappa, loc=0, scale=1) | 随机变量的（微分）熵。 |
| fit(data) | 通用数据的参数估计。详细文档请参见 scipy.stats.rv_continuous.fit。 |
| **expect(func, args=(kappa,), loc=0, scale=1, lb=None, ub=None, conditional=False, kwds) | 期望值函数（一个参数的函数）关于分布的期望值。 |
| median(kappa, loc=0, scale=1) | 分布的中位数。 |
| mean(kappa, loc=0, scale=1) | 分布的均值。 |
| var(kappa, loc=0, scale=1) | 分布的方差。 |
| std(kappa, loc=0, scale=1) | 分布的标准差。 |
| interval(confidence, kappa, loc=0, scale=1) | 等面积置信区间，围绕中位数。 |
scipy.stats.wald
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.wald.html#scipy.stats.wald
scipy.stats.wald = <scipy.stats._continuous_distns.wald_gen object>
一个 Wald 连续随机变量。
作为rv_continuous类的一个实例，wald对象继承了一组通用方法（下面是完整列表），并且用于该特定分布的详细信息完成了它们。
注意
wald的概率密度函数为：
[f(x) = \frac{1}{\sqrt{2\pi x³}} \exp(- \frac{ (x-1)² }{ 2x })]
为 (x >= 0)。
wald是invgauss的mu=1的特殊情况。
上面的概率密度在“标准化”形式中定义。使用loc和scale参数来进行分布的位移和/或缩放。具体地说，wald.pdf(x, loc, scale)等同于wald.pdf(y) / scale，其中y = (x - loc) / scale。注意，平移分布的位置并不会使其成为“非中心”分布；某些分布的非中心推广可以在单独的类中找到。
例子
>>> import numpy as np
>>> from scipy.stats import wald
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)
计算前四个矩：
>>> mean, var, skew, kurt = wald.stats(moments='mvsk')
显示概率密度函数(pdf)：
>>> x = np.linspace(wald.ppf(0.01),
... wald.ppf(0.99), 100)
>>> ax.plot(x, wald.pdf(x),
... 'r-', lw=5, alpha=0.6, label='wald pdf')
或者，可以像函数一样调用分布对象来固定形状、位置和比例参数。这将返回一个持有给定参数固定的“冻结”RV 对象。
冻结分布并显示冻结的pdf：
>>> rv = wald()
>>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')
检查 cdf 和 ppf 的准确性：
>>> vals = wald.ppf([0.001, 0.5, 0.999])
>>> np.allclose([0.001, 0.5, 0.999], wald.cdf(vals))
True
生成随机数：
>>> r = wald.rvs(size=1000)
并且比较直方图：
>>> ax.hist(r, density=True, bins='auto', histtype='stepfilled', alpha=0.2)
>>> ax.set_xlim([x[0], x[-1]])
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()
方法
| rvs(loc=0, scale=1, size=1, random_state=None) | 随机变量。 |
|---|---|
| pdf(x, loc=0, scale=1) | 概率密度函数。 |
| logpdf(x, loc=0, scale=1) | 概率密度函数的对数。 |
| cdf(x, loc=0, scale=1) | 累积分布函数。 |
| logcdf(x, loc=0, scale=1) | 累积分布函数的对数。 |
| sf(x, loc=0, scale=1) | 生存函数（也被定义为 1 - cdf，但 sf 有时更准确）。 |
| logsf(x, loc=0, scale=1) | 生存函数的对数。 |
| ppf(q, loc=0, scale=1) | 百分点函数（cdf的反函数——百分位数）。 |
| isf(q, loc=0, scale=1) | 逆生存函数（sf的反函数）。 |
| moment(order, loc=0, scale=1) | 指定顺序的非中心矩。 |
| stats(loc=0, scale=1, moments=’mv’) | 平均值（‘m’），方差（‘v’），偏度（‘s’）和/或峰度（‘k’）。 |
| entropy(loc=0, scale=1) | RV 的（微分）熵。 |
| fit(data) | 通用数据的参数估计。参见scipy.stats.rv_continuous.fit以获取关键字参数的详细文档。 |
| **expect(func, args=(), loc=0, scale=1, lb=None, ub=None, conditional=False, kwds) | 对分布的一个函数（一个参数的函数）的期望值。 |
| median(loc=0, scale=1) | 分布的中位数。 |
| mean(loc=0, scale=1) | 分布的均值。 |
| var(loc=0, scale=1) | 分布的方差。 |
| std(loc=0, scale=1) | 分布的标准差。 |
| interval(confidence, loc=0, scale=1) | 置信区间，围绕中位数具有相等的面积。 |
scipy.stats.weibull_min
scipy.stats.weibull_min = <scipy.stats._continuous_distns.weibull_min_gen object>
Weibull 最小连续随机变量.
Weibull 最小极值分布，来自极值理论（费舍尔-格涅登科定理），通常也简称为 Weibull 分布. 它是 iid 随机变量最小值的重新缩放极限分布.
作为 rv_continuous 类的一个实例，weibull_min 对象继承了一组通用方法（下文详列），并针对这个特定分布补充了具体细节。
另请参阅
weibull_max, numpy.random.Generator.weibull, exponweib
注释
weibull_min 的概率密度函数为：
[f(x, c) = c x^{c-1} \exp(-x^c)]
对于 (x > 0), (c > 0).
weibull_min 以 c 作为形状参数，用于 (c).（在维基百科文章中称为 (k)，在 numpy.random.weibull 中称为 (a). 特殊形状值为 (c=1) 和 (c=2), 其中 Weibull 分布分别简化为 expon 和 rayleigh 分布.
假设 X 是具有比例 s 的指数分布随机变量. 那么 Y = X**k 就是具有形状 c = 1/k 和比例 s**k 的 weibull_min 分布.
上述概率密度在 “标准化” 形式下定义. 若要移动和/或缩放分布，请使用 loc 和 scale 参数. 具体而言, weibull_min.pdf(x, c, loc, scale) 等价于 weibull_min.pdf(y, c) / scale, 其中 y = (x - loc) / scale. 请注意, 移动分布的位置并不使其成为 “非中心” 分布; 一些分布的非中心推广可在单独的类中找到.
参考文献
zh.wikipedia.org/wiki/费舍尔-提普特-格涅登科定理
示例
>>> import numpy as np
>>> from scipy.stats import weibull_min
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)
计算前四个时刻：
>>> c = 1.79
>>> mean, var, skew, kurt = weibull_min.stats(c, moments='mvsk')
显示概率密度函数 (pdf)：
>>> x = np.linspace(weibull_min.ppf(0.01, c),
... weibull_min.ppf(0.99, c), 100)
>>> ax.plot(x, weibull_min.pdf(x, c),
... 'r-', lw=5, alpha=0.6, label='weibull_min pdf')
或者，可以调用分布对象（作为函数），以固定形状、位置和尺度参数。这会返回一个“冻结的”RV 对象，保持给定的参数不变。
冻结分布并显示冻结的 pdf：
>>> rv = weibull_min(c)
>>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')
检查 cdf 和 ppf 的准确性：
>>> vals = weibull_min.ppf([0.001, 0.5, 0.999], c)
>>> np.allclose([0.001, 0.5, 0.999], weibull_min.cdf(vals, c))
True
生成随机数：
>>> r = weibull_min.rvs(c, size=1000)
并比较直方图：
>>> ax.hist(r, density=True, bins='auto', histtype='stepfilled', alpha=0.2)
>>> ax.set_xlim([x[0], x[-1]])
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()
方法
| rvs(c, loc=0, scale=1, size=1, random_state=None) | 随机变量。 |
|---|---|
| pdf(x, c, loc=0, scale=1) | 概率密度函数。 |
| logpdf(x, c, loc=0, scale=1) | 概率密度函数的对数。 |
| cdf(x, c, loc=0, scale=1) | 累积分布函数。 |
| logcdf(x, c, loc=0, scale=1) | 累积分布函数的对数。 |
| sf(x, c, loc=0, scale=1) | 生存函数（也定义为 1 - cdf，但 sf 有时更精确）。 |
| logsf(x, c, loc=0, scale=1) | 生存函数的对数。 |
| ppf(q, c, loc=0, scale=1) | 百分位点函数（cdf 的反函数 — 百分位数）。 |
| isf(q, c, loc=0, scale=1) | 逆生存函数（sf 的反函数）。 |
| moment(order, c, loc=0, scale=1) | 指定阶数的非中心矩。 |
| stats(c, loc=0, scale=1, moments=’mv’) | 均值（‘m’）、方差（‘v’）、偏度（‘s’）和/或峰度（‘k’）等参数估计。 |
| entropy(c, loc=0, scale=1) | RV 的（微分）熵。 |
| fit(data) | 用于一般数据的参数估计。详细文档请参阅 scipy.stats.rv_continuous.fit。 |
| **expect(func, args=(c,), loc=0, scale=1, lb=None, ub=None, conditional=False, kwds) | 函数期望值（一参数函数）相对于分布的期望值。 |
| median(c, loc=0, scale=1) | 分布的中位数。 |
| mean(c, loc=0, scale=1) | 分布的均值。 |
| var(c, loc=0, scale=1) | 分布的方差。 |
| std(c, loc=0, scale=1) | 分布的标准差。 |
| interval(confidence, c, loc=0, scale=1) | 中位数周围具有相等面积的置信区间。 |
scipy.stats.weibull_max
scipy.stats.weibull_max = <scipy.stats._continuous_distns.weibull_max_gen object>
威布尔最大值连续随机变量。
威布尔最大值极值分布，源于极值理论（费舍尔-格涅登科定理），是独立同分布随机变量的重新缩放最大值的极限分布。如果 X 是 weibull_min 函数的结果，则此分布是 -X 的分布。
作为 rv_continuous 类的一个实例，weibull_max 对象继承了一组通用方法（请参阅下面的完整列表），并以此特定分布的细节补充完善了它们。
另请参阅
注意事项
威布尔最大值的概率密度函数为：
[f(x, c) = c (-x)^{c-1} \exp(-(-x)^c)]
对于 (x < 0), (c > 0)。
weibull_max 以 (c) 作为形状参数。
上述概率密度在“标准化”形式中定义。使用 loc 和 scale 参数进行移动和/或缩放分布。特别地，weibull_max.pdf(x, c, loc, scale) 等同于 weibull_max.pdf(y, c) / scale，其中 y = (x - loc) / scale。请注意，移动分布的位置并不会使其成为“非中心”分布；某些分布的非中心推广可在单独的类中找到。
参考文献
en.wikipedia.org/wiki/Weibull_distribution
en.wikipedia.org/wiki/Fisher-Tippett-Gnedenko_theorem
示例
>>> import numpy as np
>>> from scipy.stats import weibull_max
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)
计算前四个矩：
>>> c = 2.87
>>> mean, var, skew, kurt = weibull_max.stats(c, moments='mvsk')
显示概率密度函数 (pdf)：
>>> x = np.linspace(weibull_max.ppf(0.01, c),
... weibull_max.ppf(0.99, c), 100)
>>> ax.plot(x, weibull_max.pdf(x, c),
... 'r-', lw=5, alpha=0.6, label='weibull_max pdf')
或者，可以调用分布对象（作为函数）来固定形状、位置和尺度参数。这将返回一个“冻结”的随机变量对象，保存给定的参数不变。
冻结分布并显示冻结的 pdf：
>>> rv = weibull_max(c)
>>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')
检查 cdf 和 ppf 的准确性：
>>> vals = weibull_max.ppf([0.001, 0.5, 0.999], c)
>>> np.allclose([0.001, 0.5, 0.999], weibull_max.cdf(vals, c))
True
生成随机数：
>>> r = weibull_max.rvs(c, size=1000)
并比较直方图：
>>> ax.hist(r, density=True, bins='auto', histtype='stepfilled', alpha=0.2)
>>> ax.set_xlim([x[0], x[-1]])
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()
方法
| rvs(c, loc=0, scale=1, size=1, random_state=None) | 随机变量。 |
|---|---|
| pdf(x, c, loc=0, scale=1) | 概率密度函数。 |
| logpdf(x, c, loc=0, scale=1) | 概率密度函数的对数。 |
| cdf(x, c, loc=0, scale=1) | 累积分布函数。 |
| logcdf(x, c, loc=0, scale=1) | 累积分布函数的对数。 |
| sf(x, c, loc=0, scale=1) | 生存函数（也定义为1 - cdf，但sf有时更精确）。 |
| logsf(x, c, loc=0, scale=1) | 生存函数的对数。 |
| ppf(q, c, loc=0, scale=1) | 百分点函数（cdf的反函数 — 百分位数）。 |
| isf(q, c, loc=0, scale=1) | 逆生存函数（sf的反函数）。 |
| moment(order, c, loc=0, scale=1) | 指定阶数的非中心矩。 |
| stats(c, loc=0, scale=1, moments=’mv’) | 均值（‘m’）、方差（‘v’）、偏度（‘s’）和/或峰度（‘k’）。 |
| entropy(c, loc=0, scale=1) | 随机变量的（微分）熵。 |
| fit(data) | 一般数据的参数估计。详细文档请参见scipy.stats.rv_continuous.fit。 |
| **expect(func, args=(c,), loc=0, scale=1, lb=None, ub=None, conditional=False, kwds) | 相对于分布的函数（单参数）的期望值。 |
| median(c, loc=0, scale=1) | 分布的中位数。 |
| mean(c, loc=0, scale=1) | 分布的均值。 |
| var(c, loc=0, scale=1) | 分布的方差。 |
| std(c, loc=0, scale=1) | 分布的标准差。 |
| interval(confidence, c, loc=0, scale=1) | 中位数周围面积相等的置信区间。 |
scipy.stats.wrapcauchy
scipy.stats.wrapcauchy = <scipy.stats._continuous_distns.wrapcauchy_gen object>
一个封装的柯西连续随机变量。
作为rv_continuous类的一个实例，wrapcauchy对象继承了它的一系列通用方法（下文有完整列表），并且用于完成这些方法的细节，适用于这个特定分布。
注释
wrapcauchy的概率密度函数为：
[f(x, c) = \frac{1-c²}{2\pi (1+c² - 2c \cos(x))}]
对于 (0 \le x \le 2\pi)，(0 < c < 1)。
wrapcauchy将 c 作为参数形状。
上述概率密度函数以“标准化”形式定义。要移动和/或缩放分布，请使用loc和scale参数。具体地说，wrapcauchy.pdf(x, c, loc, scale)与wrapcauchy.pdf(y, c) / scale完全等效，其中y = (x - loc) / scale。请注意，移动分布的位置不会使其成为“非中心”分布；某些分布的非中心推广可在单独的类中使用。
示例
>>> import numpy as np
>>> from scipy.stats import wrapcauchy
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)
计算前四阶矩：
>>> c = 0.0311
>>> mean, var, skew, kurt = wrapcauchy.stats(c, moments='mvsk')
显示概率密度函数（pdf）：
>>> x = np.linspace(wrapcauchy.ppf(0.01, c),
... wrapcauchy.ppf(0.99, c), 100)
>>> ax.plot(x, wrapcauchy.pdf(x, c),
... 'r-', lw=5, alpha=0.6, label='wrapcauchy pdf')
或者，可以调用分布对象（作为函数），以固定形状、位置和尺度参数。这将返回一个“冻结”的 RV 对象，持有给定的参数固定。
冻结分布并显示冻结的pdf：
>>> rv = wrapcauchy(c)
>>> ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf')
检查cdf和ppf的准确性：
>>> vals = wrapcauchy.ppf([0.001, 0.5, 0.999], c)
>>> np.allclose([0.001, 0.5, 0.999], wrapcauchy.cdf(vals, c))
True
生成随机数：
>>> r = wrapcauchy.rvs(c, size=1000)
比较直方图：
>>> ax.hist(r, density=True, bins='auto', histtype='stepfilled', alpha=0.2)
>>> ax.set_xlim([x[0], x[-1]])
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()
方法
| rvs(c, loc=0, scale=1, size=1, random_state=None) | 随机变量。 |
|---|---|
| pdf(x, c, loc=0, scale=1) | 概率密度函数。 |
| logpdf(x, c, loc=0, scale=1) | 概率密度函数的对数。 |
| cdf(x, c, loc=0, scale=1) | 累积分布函数。 |
| logcdf(x, c, loc=0, scale=1) | 累积分布函数的对数。 |
| sf(x, c, loc=0, scale=1) | 生存函数（也定义为 1 - cdf，但是sf有时更精确）。 |
| logsf(x, c, loc=0, scale=1) | 生存函数的对数。 |
| ppf(q, c, loc=0, scale=1) | 百分点函数（cdf的反函数 —— 百分位数）。 |
| isf(q, c, loc=0, scale=1) | 生存函数的反函数（sf的反函数）。 |
| moment(order, c, loc=0, scale=1) | 指定阶数的非中心矩。 |
| stats(c, loc=0, scale=1, moments=’mv’) | 均值（‘m’）、方差（‘v’）、偏度（‘s’）和/或峰度（‘k’）。 |
| entropy(c, loc=0, scale=1) | 随机变量的（微分）熵。 |
| fit(data) | 一般数据的参数估计。详见scipy.stats.rv_continuous.fit以获取关键字参数的详细文档。 |
| **expect(func, args=(c,), loc=0, scale=1, lb=None, ub=None, conditional=False, kwds) | 对于分布的函数（一个参数）的期望值。 |
| median(c, loc=0, scale=1) | 分布的中位数。 |
| mean(c, loc=0, scale=1) | 分布的均值。 |
| var(c, loc=0, scale=1) | 分布的方差。 |
| std(c, loc=0, scale=1) | 分布的标准偏差。 |
| interval(confidence, c, loc=0, scale=1) | 等面积围绕中位数的置信区间。 |
scipy.stats.CensoredData
class scipy.stats.CensoredData(uncensored=None, *, left=None, right=None, interval=None)
此类的实例表示截尾数据。
可以将实例传递给 SciPy 连续单变量分布的最大似然估计的fit方法。唯一理解CensoredData的单变量连续分布的方法是fit方法。CensoredData的实例不能传递给pdf和cdf等方法。
当观测值的确切值未知但具有已知的上限和/或下限时，称观测值为censored。传统的术语是：
-
左截尾：观测值低于某个值，但具体低多少未知。
-
右截尾：观测值高于某个值，但具体高多少未知。
-
区间截尾：观测值位于两个值之间的区间内。
左截尾、右截尾和区间截尾数据可以由CensoredData表示。
为了方便起见，提供了类方法left_censored和right_censored，用于从单个一维测量数组和相应的布尔数组（指示哪些测量被截尾）创建CensoredData实例。类方法interval_censored接受两个一维数组，包含间隔的下限和上限。
参数：
uncensored：array_like，1 维
未截尾观测。
left：array_like，1 维
左截尾观测。
right：array_like，1 维
右截尾观测。
interval：array_like，2 维，形状为(m, 2)
区间截尾观测。每行interval[k, :]表示第 k 个区间截尾观测的区间。
注意
在输入数组interval中，区间的下限可能为-inf，上限可能为inf，但至少一个必须是有限的。当下限为-inf时，该行表示左截尾观测；当上限为inf时，该行表示右截尾观测。如果一个区间的长度为 0（即interval[k, 0] == interval[k, 1]），则将观测视为未截尾。因此，可以用uncensored、left和right分别表示未截尾、左截尾和右截尾的观测，但通常更方便使用uncensored、left和right表示所有类型的截尾和未截尾数据。
示例
在最一般的情况下，一个被审查的数据集可能包含左审查、右审查、区间审查和未审查的值。例如，这里我们创建了一个包含五个观测值的数据集。其中两个是未审查的（值为 1 和 1.5），一个是左审查的观测值为 0，一个是右审查的观测值为 10，还有一个在区间[2, 3]内的区间审查观测值。
>>> import numpy as np
>>> from scipy.stats import CensoredData
>>> data = CensoredData(uncensored=[1, 1.5], left=[0], right=[10],
... interval=[[2, 3]])
>>> print(data)
CensoredData(5 values: 2 not censored, 1 left-censored,
1 right-censored, 1 interval-censored)
等价地，
>>> data = CensoredData(interval=[[1, 1],
... [1.5, 1.5],
... [-np.inf, 0],
... [10, np.inf],
... [2, 3]])
>>> print(data)
CensoredData(5 values: 2 not censored, 1 left-censored,
1 right-censored, 1 interval-censored)
一个常见的情况是同时具有未审查观测和全为右审查（或全为左审查）的审查观测。例如，考虑一个实验，其中六个设备在不同时间启动并继续运行直到失效。假设时间以小时计算，并且即使所有设备在此时间之前未全部失效，实验也会在 30 小时后停止。我们可能会得到类似以下的数据：
Device Start-time Fail-time Time-to-failure
1 0 13 13
2 2 24 22
3 5 22 17
4 8 23 15
5 10 *** >20
6 12 *** >18
当实验停止时，有两个设备尚未失效；这两个设备的失效时间观测结果为右审查。我们可以用以下方式表示这些数据：
>>> data = CensoredData(uncensored=[13, 22, 17, 15], right=[20, 18])
>>> print(data)
CensoredData(6 values: 4 not censored, 2 right-censored)
或者，我们可以使用方法CensoredData.right_censored来创建此数据的表示。失效时间观测结果放在列表ttf中。censored列表指示ttf中哪些值被审查。
>>> ttf = [13, 22, 17, 15, 20, 18]
>>> censored = [False, False, False, False, True, True]
将这些列表传递给CensoredData.right_censored以创建CensoredData的实例。
>>> data = CensoredData.right_censored(ttf, censored)
>>> print(data)
CensoredData(6 values: 4 not censored, 2 right-censored)
如果输入数据为区间审查，并且已经存储在两个数组中，一个数组保存区间的下限，另一个数组保存区间的上限，则可以使用类方法interval_censored来创建CensoredData实例。
此示例创建了一个包含四个区间审查值的实例。这些区间为[10, 11]、[0.5, 1]、[2, 3]和[12.5, 13.5]。
>>> a = [10, 0.5, 2, 12.5] # Low ends of the intervals
>>> b = [11, 1.0, 3, 13.5] # High ends of the intervals
>>> data = CensoredData.interval_censored(low=a, high=b)
>>> print(data)
CensoredData(4 values: 0 not censored, 4 interval-censored)
最后，我们从weibull_min分布中创建和审查一些数据，然后将weibull_min拟合到这些数据中。我们假设位置参数已知为 0。
>>> from scipy.stats import weibull_min
>>> rng = np.random.default_rng()
创建随机数据集。
>>> x = weibull_min.rvs(2.5, loc=0, scale=30, size=250, random_state=rng)
>>> x[x > 40] = 40 # Right-censor values greater or equal to 40.
使用right_censored方法创建CensoredData实例。被审查的值是值为 40 的值。
>>> data = CensoredData.right_censored(x, x == 40)
>>> print(data)
CensoredData(250 values: 215 not censored, 35 right-censored)
35 个值已被右审查。
将weibull_min拟合到审查数据中。我们预计形状和比例分别为大约 2.5 和 30。
>>> weibull_min.fit(data, floc=0)
(2.3575922823897315, 0, 30.40650074451254)
方法
__len__() |
值的数量（包括被审查和未被审查）。 |
|---|---|
interval_censored(low, high) |
创建一个区间被审查数据的 CensoredData 实例。 |
left_censored(x, censored) |
创建一个左截尾数据的 CensoredData 实例。 |
num_censored() |
被审查值的数量。 |
right_censored(x, censored) |
创建一个右截尾数据的 CensoredData 实例。 |
scipy.stats.multivariate_normal
scipy.stats.multivariate_normal = <scipy.stats._multivariate.multivariate_normal_gen object>
多变量正态随机变量。
mean 关键字指定均值。cov 关键字指定协方差矩阵。
参数：
meanarray_like，默认：[0]
分布的均值。
covarray_like 或者 协方差，默认：[1]
分布的对称正（半）定协方差矩阵。
allow_singularbool，默认：False
如果 cov 是一个 协方差 对象，则是否允许奇异协方差矩阵将被忽略。
seed，可选
用于生成随机变量。如果 seed 是 None，则使用 RandomState 单例。如果 seed 是一个整数，则使用一个新的 RandomState 实例，并用 seed 初始化。如果 seed 已经是一个 RandomState 或 Generator 实例，则直接使用该对象。默认值是 None。
注意事项
将参数 mean 设置为 None 相当于将 mean 设置为零向量。参数 cov 可以是标量，此时协方差矩阵为单位矩阵乘以该值，也可以是对角线元素的向量，二维数组，或者是一个 协方差 对象。
协方差矩阵 cov 可能是 Covariance 的子类的实例，例如 scipy.stats.CovViaPrecision。如果是这样，则 allow_singular 将被忽略。
否则，当 allow_singular 为 True 时，cov 必须是对称正半定矩阵；当 allow_singular 为 False 时，cov 必须是（严格）正定矩阵。不会检查对称性；仅使用下三角部分。协方差矩阵的行列式和逆矩阵分别计算为伪行列式和伪逆，因此 cov 不需要具有满秩。
multivariate_normal 的概率密度函数为
[f(x) = \frac{1}{\sqrt{(2 \pi)^k \det \Sigma}} \exp\left( -\frac{1}{2} (x - \mu)^T \Sigma^{-1} (x - \mu) \right),]
其中 (\mu) 是均值，(\Sigma) 是协方差矩阵，(k) 是 (\Sigma) 的秩。如果 (\Sigma) 是奇异的，则 SciPy 根据 [1] 扩展此定义。
从版本 0.14.0 开始。
参考资料
[1]
多元正态分布 - 退化情况，维基百科，en.wikipedia.org/wiki/Multivariate_normal_distribution#Degenerate_case
示例
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.stats import multivariate_normal
>>> x = np.linspace(0, 5, 10, endpoint=False)
>>> y = multivariate_normal.pdf(x, mean=2.5, cov=0.5); y
array([ 0.00108914, 0.01033349, 0.05946514, 0.20755375, 0.43939129,
0.56418958, 0.43939129, 0.20755375, 0.05946514, 0.01033349])
>>> fig1 = plt.figure()
>>> ax = fig1.add_subplot(111)
>>> ax.plot(x, y)
>>> plt.show()
或者，可以将对象（作为函数）调用以固定均值和协方差参数，返回一个“冻结”的多元正态随机变量：
>>> rv = multivariate_normal(mean=None, cov=1, allow_singular=False)
>>> # Frozen object with the same methods but holding the given
>>> # mean and covariance fixed.
输入分位数可以是任何形状的数组，只要最后一个轴标记组件。这使我们可以例如以 2D 中非各向同性随机变量显示冻结 pdf 如下：
>>> x, y = np.mgrid[-1:1:.01, -1:1:.01]
>>> pos = np.dstack((x, y))
>>> rv = multivariate_normal([0.5, -0.2], [[2.0, 0.3], [0.3, 0.5]])
>>> fig2 = plt.figure()
>>> ax2 = fig2.add_subplot(111)
>>> ax2.contourf(x, y, rv.pdf(pos))
方法
| pdf(x, mean=None, cov=1, allow_singular=False) | 概率密度函数。 |
|---|---|
| logpdf(x, mean=None, cov=1, allow_singular=False) | 概率密度函数的对数。 |
| cdf(x, mean=None, cov=1, allow_singular=False, maxpts=1000000*dim, abseps=1e-5, releps=1e-5, lower_limit=None) | 累积分布函数。 |
| logcdf(x, mean=None, cov=1, allow_singular=False, maxpts=1000000*dim, abseps=1e-5, releps=1e-5) | 累积分布函数的对数。 |
| rvs(mean=None, cov=1, size=1, random_state=None) | 从多元正态分布中抽取随机样本。 |
| entropy(mean=None, cov=1) | 计算多元正态分布的微分熵。 |
| fit(x, fix_mean=None, fix_cov=None) | 将多元正态分布拟合到数据。 |
scipy.stats.matrix_normal
scipy.stats.matrix_normal = <scipy.stats._multivariate.matrix_normal_gen object>
矩阵正态分布随机变量。
mean关键字指定均值。rowcov关键字指定行内协方差矩阵。'colcov'关键字指定列内协方差矩阵。
参数：
meanarray_like，可选
分布的均值（默认为None）
rowcovarray_like，可选
分布的行内协方差矩阵（默认为1）
colcovarray_like，可选
分布的列内协方差矩阵（默认为1）
seed，可选
用于生成随机变量。如果seed为None，则使用RandomState单例。如果seed是一个整数，则使用一个新的RandomState实例，并使用 seed 进行种子初始化。如果seed已经是RandomState或Generator实例，则直接使用该对象。默认为None。
注意
如果mean设置为None，则使用零矩阵作为均值。此矩阵的维度从rowcov和colcov的形状推断得出，如果这些参数已提供，则设置为1以避免歧义。
rowcov和colcov可以是直接指定协方差矩阵的二维数组，或者作为对角矩阵的条目的一维数组。或者，标量或零维数组将被解释为该值乘以单位矩阵。
由rowcov和colcov指定的协方差矩阵必须是（对称的）正定的。如果X中的样本是 (m \times n)，则rowcov必须是 (m \times m)，colcov必须是 (n \times n)。mean必须与X的形状相同。
matrix_normal 的概率密度函数为
[f(X) = (2 \pi){-\frac{mn}{2}}|U|{2}} |V|^{-\frac{m}{2}} \exp\left( -\frac{1}{2} \mathrm{Tr}\left[ U^{-1} (X-M) V^{-1} (X-M)^T \right] \right),]
其中 (M) 是均值，(U) 是行内协方差矩阵，(V) 是列内协方差矩阵。
multivariate_normal 分布的allow_singular行为目前不受支持。协方差矩阵必须是满秩的。
matrix_normal 分布与 multivariate_normal 分布密切相关。具体来说，(\mathrm{Vec}(X))（由 (X) 的列连接形成的向量）具有以 (\mathrm{Vec}(M)) 为均值、(V \otimes U) 为协方差的多元正态分布（其中 (\otimes) 表示 Kronecker 乘积）。对于矩阵正态分布的采样和概率密度函数评估为 (\mathcal{O}(m³ + n³ + m² n + m n²))，而等效的多元正态分布为 (\mathcal{O}(m³ n³))，使得这种等效形式在算法上效率低下。
新版本中添加于 0.17.0。
示例
>>> import numpy as np
>>> from scipy.stats import matrix_normal
>>> M = np.arange(6).reshape(3,2); M
array([[0, 1],
[2, 3],
[4, 5]])
>>> U = np.diag([1,2,3]); U
array([[1, 0, 0],
[0, 2, 0],
[0, 0, 3]])
>>> V = 0.3*np.identity(2); V
array([[ 0.3, 0\. ],
[ 0\. , 0.3]])
>>> X = M + 0.1; X
array([[ 0.1, 1.1],
[ 2.1, 3.1],
[ 4.1, 5.1]])
>>> matrix_normal.pdf(X, mean=M, rowcov=U, colcov=V)
0.023410202050005054
>>> # Equivalent multivariate normal
>>> from scipy.stats import multivariate_normal
>>> vectorised_X = X.T.flatten()
>>> equiv_mean = M.T.flatten()
>>> equiv_cov = np.kron(V,U)
>>> multivariate_normal.pdf(vectorised_X, mean=equiv_mean, cov=equiv_cov)
0.023410202050005054
或者，该对象也可以（作为函数）用于固定均值和协方差参数，返回一个“冻结”的矩阵正态随机变量：
>>> rv = matrix_normal(mean=None, rowcov=1, colcov=1)
>>> # Frozen object with the same methods but holding the given
>>> # mean and covariance fixed.
方法
| pdf(X, mean=None, rowcov=1, colcov=1) | 概率密度函数。 |
|---|---|
| logpdf(X, mean=None, rowcov=1, colcov=1) | 概率密度函数的对数。 |
| rvs(mean=None, rowcov=1, colcov=1, size=1, random_state=None) | 生成随机样本。 |
| entropy(rowcol=1, colcov=1) | 差分熵。 |
scipy.stats.dirichlet
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.dirichlet.html#scipy.stats.dirichlet
scipy.stats.dirichlet = <scipy.stats._multivariate.dirichlet_gen object>
一个 Dirichlet 随机变量。
alpha关键字指定了分布的集中参数。
0.15.0 版本中新增。
参数:
alphaarray_like
集中参数。条目数决定了分布的维度。
seed，可选
用于抽取随机变量。如果seed为None，则使用RandomState单例。如果seed为整数，则使用新的RandomState实例，种子为 seed。如果seed已经是RandomState或Generator实例，则使用该对象。默认为None。
注释
每个 (\alpha) 条目必须是正的。该分布仅在由以下定义的单纯形上有支持
[\sum_{i=1}^{K} x_i = 1]
其中 (0 < x_i < 1)。
如果分位数不在单纯形内，则引发 ValueError。
dirichlet的概率密度函数是
[f(x) = \frac{1}{\mathrm{B}(\boldsymbol\alpha)} \prod_{i=1}^K x_i^{\alpha_i - 1}]
其中
[\mathrm{B}(\boldsymbol\alpha) = \frac{\prod_{i=1}^K \Gamma(\alpha_i)} {\Gamma\bigl(\sum_{i=1}^K \alpha_i\bigr)}]
和 (\boldsymbol\alpha=(\alpha_1,\ldots,\alpha_K))，集中参数和 (x) 取值空间的维度 (K)。
注意，dirichlet接口有些不一致。rvs 函数返回的数组与 pdf 和 logpdf 期望的格式相对置。
示例
>>> import numpy as np
>>> from scipy.stats import dirichlet
生成一个 Dirichlet 随机变量
>>> quantiles = np.array([0.2, 0.2, 0.6]) # specify quantiles
>>> alpha = np.array([0.4, 5, 15]) # specify concentration parameters
>>> dirichlet.pdf(quantiles, alpha)
0.2843831684937255
相同的 PDF，但遵循对数尺度
>>> dirichlet.logpdf(quantiles, alpha)
-1.2574327653159187
一旦我们指定了 Dirichlet 分布，就可以计算感兴趣的量
>>> dirichlet.mean(alpha) # get the mean of the distribution
array([0.01960784, 0.24509804, 0.73529412])
>>> dirichlet.var(alpha) # get variance
array([0.00089829, 0.00864603, 0.00909517])
>>> dirichlet.entropy(alpha) # calculate the differential entropy
-4.3280162474082715
我们还可以从分布中返回随机样本
>>> dirichlet.rvs(alpha, size=1, random_state=1)
array([[0.00766178, 0.24670518, 0.74563305]])
>>> dirichlet.rvs(alpha, size=2, random_state=2)
array([[0.01639427, 0.1292273 , 0.85437844],
[0.00156917, 0.19033695, 0.80809388]])
或者，可以将对象（作为函数）调用以固定集中参数，返回“冻结”的 Dirichlet 随机变量：
>>> rv = dirichlet(alpha)
>>> # Frozen object with the same methods but holding the given
>>> # concentration parameters fixed.
方法
| pdf(x, alpha) | 概率密度函数。 |
|---|---|
| logpdf(x, alpha) | 概率密度函数的对数。 |
| rvs(alpha, size=1, random_state=None) | 从 Dirichlet 分布中抽取随机样本。 |
| mean(alpha) | Dirichlet 分布的均值 |
| var(alpha) | Dirichlet 分布的方差 |
| cov(alpha) | Dirichlet 分布的协方差 |
| entropy(alpha) | 计算 Dirichlet 分布的微分熵。 |
scipy.stats.dirichlet_multinomial
scipy.stats.dirichlet_multinomial = <scipy.stats._multivariate.dirichlet_multinomial_gen object>
一个 Dirichlet 多项式随机变量。
Dirichlet 多项式分布是一个复合概率分布：它是具有n试验次数和从具有浓度参数alpha随机抽样的类概率p的多项式分布。
参数：
alpha数组类型
浓度参数。沿着最后一个轴的条目数决定分布的维度。每个条目必须严格为正。
n整数或数组类型
试验次数。每个元素必须是严格正整数。
seed, 可选
用于生成随机变量。如果seed为None，则使用RandomState单例。如果seed为整数，则使用新的RandomState实例，并以 seed 为种子。如果seed已经是RandomState或Generator实例，则使用该对象。默认为None。
参见
scipy.stats.dirichlet
狄利克雷分布。
scipy.stats.multinomial
多项式分布。
参考资料
[1]
狄利克雷-多项式分布，维基百科，www.wikipedia.org/wiki/Dirichlet-multinomial_distribution
示例
>>> from scipy.stats import dirichlet_multinomial
获取概率质量函数
>>> n = 6 # number of trials
>>> alpha = [3, 4, 5] # concentration parameters
>>> x = [1, 2, 3] # counts
>>> dirichlet_multinomial.pmf(x, alpha, n)
0.08484162895927604
如果类别计数的总和不等于试验次数，则概率质量为零。
>>> dirichlet_multinomial.pmf(x, alpha, n=7)
0.0
获取概率质量函数的对数
>>> dirichlet_multinomial.logpmf(x, alpha, n)
-2.4669689491013327
获取均值
>>> dirichlet_multinomial.mean(alpha, n)
array([1.5, 2\. , 2.5])
获取方差
>>> dirichlet_multinomial.var(alpha, n)
array([1.55769231, 1.84615385, 2.01923077])
获取协方差
>>> dirichlet_multinomial.cov(alpha, n)
array([[ 1.55769231, -0.69230769, -0.86538462],
[-0.69230769, 1.84615385, -1.15384615],
[-0.86538462, -1.15384615, 2.01923077]])
或者，可以将对象（作为函数）调用以固定alpha和n参数，返回“冻结”的 Dirichlet 多项式随机变量。
>>> dm = dirichlet_multinomial(alpha, n)
>>> dm.pmf(x)
0.08484162895927579
所有方法都是完全向量化的。x和alpha的每个元素是一个向量（沿着最后一个轴），n的每个元素是一个整数（标量），并且结果是逐元素计算的。
>>> x = [[1, 2, 3], [4, 5, 6]]
>>> alpha = [[1, 2, 3], [4, 5, 6]]
>>> n = [6, 15]
>>> dirichlet_multinomial.pmf(x, alpha, n)
array([0.06493506, 0.02626937])
>>> dirichlet_multinomial.cov(alpha, n).shape # both covariance matrices
(2, 3, 3)
支持按照标准 NumPy 约定进行广播。在这里，我们有每个三个试验次数（每个标量）的四组浓度参数（每个两个元素向量）。
>>> alpha = [[3, 4], [4, 5], [5, 6], [6, 7]]
>>> n = [[6], [7], [8]]
>>> dirichlet_multinomial.mean(alpha, n).shape
(3, 4, 2)
方法
| logpmf(x, alpha, n): | 概率质量函数的对数。 |
|---|---|
| pmf(x, alpha, n): | 概率质量函数。 |
| mean(alpha, n): | Dirichlet 多项式分布的均值。 |
| var(alpha, n): | Dirichlet 多项式分布的方差。 |
| cov(alpha, n): | Dirichlet 多项式分布的协方差。 |
scipy.stats.wishart
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.wishart.html#scipy.stats.wishart
scipy.stats.wishart = <scipy.stats._multivariate.wishart_gen object>
一个 Wishart 随机变量。
df 关键字指定自由度。scale 关键字指定尺度矩阵，必须是对称的且正定的。在这个上下文中，尺度矩阵通常解释为多元正态精度矩阵（协方差矩阵的逆）。这些参数必须满足关系 df > scale.ndim - 1，但请参阅有关使用 rvs 方法时 df < scale.ndim 的注释。
参数：
df int
自由度，必须大于或等于尺度矩阵的维数
scale array_like
分布的对称正定尺度矩阵
seed {None, int, np.random.RandomState, np.random.Generator}，可选
用于生成随机变量。如果 seed 是 None，则使用 RandomState 单例。如果 seed 是一个整数，则使用一个新的 RandomState 实例，并使用 seed 进行初始化。如果 seed 已经是 RandomState 或 Generator 实例，则直接使用该对象。默认值为 None。
引发异常：
scipy.linalg.LinAlgError
如果尺度矩阵 scale 不是正定的。
另请参阅
invwishart，chi2
注释
尺度矩阵 scale 必须是对称正定矩阵。不支持奇异矩阵，包括对称正半定情况。不会检查对称性；只使用下三角部分。
Wishart 分布通常用以下符号表示
[W_p(\nu, \Sigma)]
其中 (\nu) 是自由度，(\Sigma) 是 (p \times p) 尺度矩阵。
wishart 的概率密度函数支持正定矩阵 (S)；如果 (S \sim W_p(\nu, \Sigma))，则其 PDF 为：
[f(S) = \frac{|S|^{\frac{\nu - p - 1}{2}}}{2^{ \frac{\nu p}{2} } |\Sigma|^\frac{\nu}{2} \Gamma_p \left ( \frac{\nu}{2} \right )} \exp\left( -tr(\Sigma^{-1} S) / 2 \right)]
如果 (S \sim W_p(\nu, \Sigma))（Wishart 分布），则 (S^{-1} \sim W_p^{-1}(\nu, \Sigma^{-1}))（逆 Wishart 分布）。
如果尺度矩阵是一维且等于一，则 Wishart 分布 (W_1(\nu, 1)) 会坍缩成 (\chi²(\nu)) 分布。
由 rvs 方法实现的算法[2]可能会产生数值上奇异的矩阵，其中 (p - 1 < \nu < p)；用户可能需要检查此条件并根据需要生成替代样本。
从版本 0.16.0 开始。
参考文献
[1]
M.L. Eaton, “Multivariate Statistics: A Vector Space Approach”, Wiley, 1983.
[2]
W.B. Smith and R.R. Hocking, “Algorithm AS 53: Wishart Variate Generator”, Applied Statistics, vol. 21, pp. 341-345, 1972.
示例
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.stats import wishart, chi2
>>> x = np.linspace(1e-5, 8, 100)
>>> w = wishart.pdf(x, df=3, scale=1); w[:5]
array([ 0.00126156, 0.10892176, 0.14793434, 0.17400548, 0.1929669 ])
>>> c = chi2.pdf(x, 3); c[:5]
array([ 0.00126156, 0.10892176, 0.14793434, 0.17400548, 0.1929669 ])
>>> plt.plot(x, w)
>>> plt.show()
输入的分位数可以是任何形状的数组，只要最后一个轴标记组件即可。
或者，可以将对象作为函数调用，以固定自由度和比例参数，返回一个“冻结”的 Wishart 随机变量：
>>> rv = wishart(df=1, scale=1)
>>> # Frozen object with the same methods but holding the given
>>> # degrees of freedom and scale fixed.
方法
| pdf(x, df, scale) | 概率密度函数。 |
|---|---|
| logpdf(x, df, scale) | 概率密度函数的对数。 |
| rvs(df, scale, size=1, random_state=None) | 从 Wishart 分布中抽取随机样本。 |
| entropy() | 计算 Wishart 分布的差分熵。 |
scipy.stats.invwishart
scipy.stats.invwishart = <scipy.stats._multivariate.invwishart_gen object>
一个逆 Wishart 随机变量。
df 关键字指定自由度。scale 关键字指定比例矩阵，它必须是对称的正定矩阵。在这种情况下，比例矩阵通常解释为多元正态协方差矩阵。
参数：
dfint
自由度，必须大于或等于比例矩阵的维数
scalearray_like
分布的对称正定比例矩阵
seed, 可选
用于生成随机变量。如果 seed 是 None，则使用 RandomState 单例。如果 seed 是一个整数，则使用一个新的 RandomState 实例，并使用 seed 进行种子。如果 seed 已经是 RandomState 或 Generator 实例，则使用该对象。默认值为 None。
Raises:
scipy.linalg.LinAlgError
如果比例矩阵 scale 不是正定的。
参见
wishart
注意
scale 比例矩阵必须是对称正定矩阵。不支持奇异矩阵，包括对称正半定的情况。只检查对称性；只使用下三角部分。
逆 Wishart 分布通常表示为
[W_p^{-1}(\nu, \Psi)]
其中 (\nu) 是自由度，(\Psi) 是 (p \times p) 的比例矩阵。
对 invwishart 的概率密度函数在正定矩阵 (S) 上有支持；如果 (S \sim W^{-1}_p(\nu, \Sigma))，则其 PDF 给出为：
[f(S) = \frac{|\Sigma|\frac{\nu}{2}}{2 } |S|^{\frac{\nu + p + 1}{2}} \Gamma_p \left(\frac{\nu}{2} \right)} \exp\left( -tr(\Sigma S^{-1}) / 2 \right)]
如果 (S \sim W_p^{-1}(\nu, \Psi))（逆 Wishart），则 (S^{-1} \sim W_p(\nu, \Psi^{-1}))（Wishart）。
如果比例矩阵是一维的且等于一，则逆 Wishart 分布 (W_1(\nu, 1)) 将折叠为具有参数形状 = (\frac{\nu}{2}) 和尺度 = (\frac{1}{2}) 的逆 Gamma 分布。
与描述的随机生成 Wishart 矩阵的反向操作不同，在这里使用的算法在 [4] 中直接生成随机逆 Wishart 矩阵而无需反向操作。
版本 0.16.0 中的新内容。
参考文献
[1]
M.L. Eaton，《多元统计学：向量空间方法》，Wiley，1983 年。
[2]
M.C. Jones，《生成逆 Wishart 矩阵》，《统计 - 模拟与计算》通信，第 14.2 卷，第 511-514 页，1985 年。
[3]
Gupta, M. 和 Srivastava, S.，“参数贝叶斯估计的差分熵和相对熵”。Entropy 12, 818 - 843. 2010.
[4]
S.D. Axen，“高效生成逆 Wishart 矩阵及其 Cholesky 因子”，arXiv:2310.15884v1。2023 年。
示例
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.stats import invwishart, invgamma
>>> x = np.linspace(0.01, 1, 100)
>>> iw = invwishart.pdf(x, df=6, scale=1)
>>> iw[:3]
array([ 1.20546865e-15, 5.42497807e-06, 4.45813929e-03])
>>> ig = invgamma.pdf(x, 6/2., scale=1./2)
>>> ig[:3]
array([ 1.20546865e-15, 5.42497807e-06, 4.45813929e-03])
>>> plt.plot(x, iw)
>>> plt.show()
输入分位数可以是任何形状的数组，只要最后一个轴标记组件。
或者，可以将对象（作为函数）调用以固定自由度和比例参数，返回一个“冻结”的逆 Wishart 随机变量：
>>> rv = invwishart(df=1, scale=1)
>>> # Frozen object with the same methods but holding the given
>>> # degrees of freedom and scale fixed.
方法
| pdf(x, df, scale) | 概率密度函数。 |
|---|---|
| logpdf(x, df, scale) | 概率密度函数的对数。 |
| rvs(df, scale, size=1, random_state=None) | 从逆 Wishart 分布中抽取随机样本。 |
| entropy(df, scale) | 分布的微分熵。 |
scipy.stats.multinomial
scipy.stats.multinomial = <scipy.stats._multivariate.multinomial_gen object>
一个多项式随机变量。
参数：
nint
试验次数
parray_like
每个类别落入的概率；应该总和为 1
seed, optional
用于生成随机变量。如果seed为None，则使用RandomState单例。如果seed是一个整数，则使用一个新的RandomState实例，并使用该种子进行初始化。如果seed已经是RandomState或Generator实例，则直接使用该对象。默认为None。
参见
scipy.stats.binom
二项式分布。
numpy.random.Generator.multinomial
从多项式分布中抽样。
scipy.stats.multivariate_hypergeom
多元超几何分布。
注意事项
n应为非负整数。p的每个元素应在区间([0,1])内，并且元素应总和为 1。如果它们的总和不为 1，则不使用p数组的最后一个元素，并用前面元素剩余的概率代替。
multinomial的概率质量函数是
[f(x) = \frac{n!}{x_1! \cdots x_k!} p_1^{x_1} \cdots p_k^{x_k},]
在(x=(x_1, \ldots, x_k))且每个(x_i)为非负整数且它们的和为(n)的情况下受支持。
版本 0.19.0 中的新功能。
示例
>>> from scipy.stats import multinomial
>>> rv = multinomial(8, [0.3, 0.2, 0.5])
>>> rv.pmf([1, 3, 4])
0.042000000000000072
对于(k=2)的多项式分布与相应的二项式分布完全相同（尽管存在微小的数值差异）：
>>> from scipy.stats import binom
>>> multinomial.pmf([3, 4], n=7, p=[0.4, 0.6])
0.29030399999999973
>>> binom.pmf(3, 7, 0.4)
0.29030400000000012
函数pmf，logpmf，entropy和cov支持广播，遵循的约定是向量参数（x和p）被解释为沿着最后一个轴的每一行都是单个对象。例如：
>>> multinomial.pmf([[3, 4], [3, 5]], n=[7, 8], p=[.3, .7])
array([0.2268945, 0.25412184])
在这里，x.shape == (2, 2)，n.shape == (2,)，p.shape == (2,)，但根据上述规则，它们表现得好像行[3, 4]和[3, 5]在x中以及[.3, .7]在p中是单个对象，并且好像我们有x.shape = (2,)，n.shape = (2,)，p.shape = ()。要获取不进行广播的各个元素，我们可以这样做：
>>> multinomial.pmf([3, 4], n=7, p=[.3, .7])
0.2268945
>>> multinomial.pmf([3, 5], 8, p=[.3, .7])
0.25412184
这种广播在cov中也适用，其中输出对象是大小为p.shape[-1]的方阵。例如：
>>> multinomial.cov([4, 5], [[.3, .7], [.4, .6]])
array([[[ 0.84, -0.84],
[-0.84, 0.84]],
[[ 1.2 , -1.2 ],
[-1.2 , 1.2 ]]])
在这个例子中，n.shape == (2,)，p.shape == (2, 2)，并且根据以上规则，这些会像p.shape == (2,)一样进行广播。因此结果应该也是形状为(2,)，但由于每个输出是一个(2 \times 2)的矩阵，实际上结果的形状是(2, 2, 2)，其中result[0]等于multinomial.cov(n=4, p=[.3, .7])，而result[1]等于multinomial.cov(n=5, p=[.4, .6])。
另外，该对象可以被调用（作为一个函数）来固定n和p参数，返回一个“冻结”的多项随机变量：
>>> rv = multinomial(n=7, p=[.3, .7])
>>> # Frozen object with the same methods but holding the given
>>> # degrees of freedom and scale fixed.
方法
| pmf(x, n, p) | 概率质量函数。 |
|---|---|
| logpmf(x, n, p) | 概率质量函数的对数。 |
| rvs(n, p, size=1, random_state=None) | 从多项分布中抽取随机样本。 |
| entropy(n, p) | 计算多项分布的熵。 |
| cov(n, p) | 计算多项分布的协方差矩阵。 |
scipy.stats.special_ortho_group
scipy.stats.special_ortho_group = <scipy.stats._multivariate.special_ortho_group_gen object>
特殊正交矩阵（SO(N)）随机变量。
从 Haar 分布中返回一个随机旋转矩阵（SO(N)上唯一的均匀分布），其行列式为+1。
关键词dim指定维度 N。
参数：
dim标量
矩阵的维度
seed，可选
用于绘制随机变量。如果seed为None，则使用RandomState单例。如果seed为 int，则使用带有 seed 种子的新的RandomState实例。如果seed已经是RandomState或Generator实例，则使用该对象。默认值为None。
参见
ortho_group，scipy.spatial.transform.Rotation.random
注意事项
该类封装了 MDP Toolkit 中的 random_rot 代码，github.com/mdp-toolkit/mdp-toolkit
从 Haar 分布中返回一个随机旋转矩阵（SO(N)上唯一的均匀分布）。该算法在文章 Stewart, G.W.，“The efficient generation of random orthogonal matrices with an application to condition estimators”，SIAM Journal on Numerical Analysis, 17(3), pp. 403-409, 1980 中有描述。更多信息请参见en.wikipedia.org/wiki/Orthogonal_matrix#Randomization
另请参见类似的ortho_group。关于三维空间中的随机旋转，请参见scipy.spatial.transform.Rotation.random。
示例
>>> import numpy as np
>>> from scipy.stats import special_ortho_group
>>> x = special_ortho_group.rvs(3)
>>> np.dot(x, x.T)
array([[ 1.00000000e+00, 1.13231364e-17, -2.86852790e-16],
[ 1.13231364e-17, 1.00000000e+00, -1.46845020e-16],
[ -2.86852790e-16, -1.46845020e-16, 1.00000000e+00]])
>>> import scipy.linalg
>>> scipy.linalg.det(x)
1.0
这会生成一个来自 SO(3)的随机矩阵。它是正交的，并且行列式为 1。
或者，该对象可以作为函数调用以固定dim参数，返回一个“冻结”的 special_ortho_group 随机变量：
>>> rv = special_ortho_group(5)
>>> # Frozen object with the same methods but holding the
>>> # dimension parameter fixed.
方法
| rvs(dim=None, size=1, random_state=None) | 从 SO(N)中抽取随机样本。 |
|---|
scipy.stats.ortho_group
scipy.stats.ortho_group = <scipy.stats._multivariate.ortho_group_gen object>
正交矩阵（O(N)）随机变量。
返回一个从 O(N) Haar 分布（O(N) 上唯一的均匀分布）中抽取的随机正交矩阵。
dim 关键字指定维度 N。
参数:
dim 标量
矩阵的维度
seed, optional
用于绘制随机变量。如果 seed 为 None，则使用 RandomState 单例。如果 seed 是一个整数，则使用一个新的 RandomState 实例，种子为 seed。如果 seed 已经是 RandomState 或 Generator 实例，则使用该对象。默认为 None。
另见
special_ortho_group
注意事项
该类与 special_ortho_group 密切相关。
一些小心措施用于避免数值误差，如 Mezzadri 所述的论文。
参考文献
[1]
F. Mezzadri，《如何从经典紧致群中生成随机矩阵》，arXiv:math-ph/0609050v2。
示例
>>> import numpy as np
>>> from scipy.stats import ortho_group
>>> x = ortho_group.rvs(3)
>>> np.dot(x, x.T)
array([[ 1.00000000e+00, 1.13231364e-17, -2.86852790e-16],
[ 1.13231364e-17, 1.00000000e+00, -1.46845020e-16],
[ -2.86852790e-16, -1.46845020e-16, 1.00000000e+00]])
>>> import scipy.linalg
>>> np.fabs(scipy.linalg.det(x))
1.0
这会生成一个来自 O(3) 的随机矩阵。它是正交的，并且行列式为 +1 或 -1。
或者，对象可以被称为（作为一个函数）来固定 dim 参数，返回一个“冻结的” ortho_group 随机变量：
>>> rv = ortho_group(5)
>>> # Frozen object with the same methods but holding the
>>> # dimension parameter fixed.
方法
| rvs(dim=None, size=1, random_state=None) | 从 O(N) 中抽取随机样本。 |
|---|
scipy.stats.unitary_group
scipy.stats.unitary_group = <scipy.stats._multivariate.unitary_group_gen object>
一个矩阵值 U(N) 随机变量。
返回一个随机酉矩阵。
dim 关键字指定维度 N。
参数：
dim 标量
矩阵的维度
seed，可选
用于绘制随机变量。如果 seed 为 None，则使用 RandomState 单例。如果 seed 是整数，则使用带有 seed 的新 RandomState 实例。如果 seed 已经是 RandomState 或 Generator 实例，则使用该对象。默认为 None。
另见
注释
此类与 ortho_group 类似。
参考文献
[1]
F. Mezzadri，《如何从经典紧致群生成随机矩阵》，arXiv:math-ph/0609050v2。
示例
>>> import numpy as np
>>> from scipy.stats import unitary_group
>>> x = unitary_group.rvs(3)
>>> np.dot(x, x.conj().T)
array([[ 1.00000000e+00, 1.13231364e-17, -2.86852790e-16],
[ 1.13231364e-17, 1.00000000e+00, -1.46845020e-16],
[ -2.86852790e-16, -1.46845020e-16, 1.00000000e+00]])
这会生成一个来自 U(3) 的随机矩阵。点积确认其在机器精度下是酉的。
或者，可以调用对象（作为函数）来固定 dim 参数，返回一个“冻结”的 unitary_group 随机变量：
>>> rv = unitary_group(5)
方法
| rvs(dim=None, size=1, random_state=None) | 从 U(N) 中抽取随机样本。 |
|---|
scipy.stats.random_correlation
scipy.stats.random_correlation = <scipy.stats._multivariate.random_correlation_gen object>
一个随机相关矩阵。
给定特征值向量，返回一个随机相关矩阵。
eigs 关键字指定相关矩阵的特征值，并暗示其维度。
参数：
eigs1d ndarray
相关矩阵的特征值
seed{None, int, numpy.random.Generator, numpy.random.RandomState}, 可选
如果 seed 是 None（或 np.random），则使用 numpy.random.RandomState 单例。如果 seed 是一个整数，则使用一个新的 RandomState 实例，并以 seed 为种子。如果 seed 已经是 Generator 或 RandomState 实例，则使用该实例。
tolfloat, optional
输入参数检查的容差
diag_tolfloat, optional
用于结果矩阵对角线偏差的容差。默认值：1e-7
返回：
rvsndarray or scalar
随机大小 N 维矩阵，维度（大小，dim，dim），每个具有特征值 eigs。
引发：
运行时错误
浮点误差阻止生成有效的相关矩阵。
注意
生成一个随机相关矩阵，遵循由戴维斯和海姆详细阐述的数值稳定算法。该算法使用单个 O(N)相似变换构造对称正半定矩阵，并应用一系列 Givens 旋转来缩放，使其对角线上为 1。
参考文献
[1]
戴维斯，Philip I; Higham，Nicholas J; “数值稳定的相关矩阵及其因子的生成”，BIT 2000 年，第 40 卷，第 4 期，第 640-651 页
示例
>>> import numpy as np
>>> from scipy.stats import random_correlation
>>> rng = np.random.default_rng()
>>> x = random_correlation.rvs((.5, .8, 1.2, 1.5), random_state=rng)
>>> x
array([[ 1\. , -0.02423399, 0.03130519, 0.4946965 ],
[-0.02423399, 1\. , 0.20334736, 0.04039817],
[ 0.03130519, 0.20334736, 1\. , 0.02694275],
[ 0.4946965 , 0.04039817, 0.02694275, 1\. ]])
>>> import scipy.linalg
>>> e, v = scipy.linalg.eigh(x)
>>> e
array([ 0.5, 0.8, 1.2, 1.5])
方法
| rvs(eigs=None, random_state=None) | 绘制具有特征值 eigs 的随机相关矩阵。 |
|---|
scipy.stats.multivariate_t
scipy.stats.multivariate_t = <scipy.stats._multivariate.multivariate_t_gen object>
多元 t 分布随机变量。
loc 参数指定位置。shape 参数指定正半定形状矩阵。df 参数指定自由度。
除了调用下面的方法，对象本身也可以作为一个函数调用，以固定位置、形状矩阵和自由度参数，返回一个“冻结”的多元 t 分布随机对象。
参数：
locarray_like，可选
分布的位置。（默认0）
shapearray_like，可选
分布的正半定矩阵。（默认1）
dffloat，可选
分布的自由度；必须大于零。如果 np.inf，则结果为多元正态分布。默认为 1。
allow_singularbool，可选
是否允许奇异矩阵。（默认False）
seed，可选
用于生成随机变量。如果 seed 为 None，则使用 RandomState 单例。如果 seed 是整数，则使用一个新的 RandomState 实例，并用 seed 进行初始化。如果 seed 已经是 RandomState 或 Generator 实例，则使用该对象。默认为 None。
注意事项
将 loc 参数设为 None 相当于将 loc 设为零向量。shape 参数可以是标量，此时形状矩阵为单位矩阵乘以该值，也可以是形状矩阵的对角线条目的向量，或者是二维数组。矩阵 shape 必须是（对称的）正半定矩阵。其伪行列式和伪逆分别计算为矩阵 shape 的行列式和逆，因此 shape 不需要具有完全秩。
multivariate_t 的概率密度函数为
[f(x) = \frac{\Gamma((\nu + p)/2)}{\Gamma(\nu/2)\nu{p/2}\pi|\Sigma|^{1/2}} \left[1 + \frac{1}{\nu} (\mathbf{x} - \boldsymbol{\mu})^{\top} \boldsymbol{\Sigma}^{-1} (\mathbf{x} - \boldsymbol{\mu}) \right]^{-(\nu + p)/2},]
其中 (p) 是 (\mathbf{x}) 的维度，(\boldsymbol{\mu}) 是 (p) 维位置，(\boldsymbol{\Sigma}) 是 (p \times p) 维形状矩阵，(\nu) 是自由度。
版本 1.6.0 中的新增内容。
参考文献
[1]
Arellano-Valle 等人的“多元斜椭圆分布的香农熵和互信息”。《斯堪的纳维亚统计学杂志》。第 40 卷，第 1 期。
示例
该对象可以被调用（作为函数），以固定 loc、shape、df 和 allow_singular 参数，返回一个“冻结”的多元 t 随机变量：
>>> import numpy as np
>>> from scipy.stats import multivariate_t
>>> rv = multivariate_t([1.0, -0.5], [[2.1, 0.3], [0.3, 1.5]], df=2)
>>> # Frozen object with the same methods but holding the given location,
>>> # scale, and degrees of freedom fixed.
创建概率密度函数的等高线图。
>>> import matplotlib.pyplot as plt
>>> x, y = np.mgrid[-1:3:.01, -2:1.5:.01]
>>> pos = np.dstack((x, y))
>>> fig, ax = plt.subplots(1, 1)
>>> ax.set_aspect('equal')
>>> plt.contourf(x, y, rv.pdf(pos))
方法
| pdf(x, loc=None, shape=1, df=1, allow_singular=False) | 概率密度函数。 |
|---|---|
| logpdf(x, loc=None, shape=1, df=1, allow_singular=False) | 概率密度函数的对数。 |
| *cdf(x, loc=None, shape=1, df=1, allow_singular=False, , | maxpts=None, lower_limit=None, random_state=None) 累积分布函数。 |
| rvs(loc=None, shape=1, df=1, size=1, random_state=None) | 从多元 t 分布中抽取随机样本。 |
| entropy(loc=None, shape=1, df=1) | 多元 t 分布的微分熵。 |
scipy.stats.multivariate_hypergeom
scipy.stats.multivariate_hypergeom = <scipy.stats._multivariate.multivariate_hypergeom_gen object>
多元超几何随机变量。
参数：
marray_like
人口中每种对象的数量。即，(m[i]) 是类型 (i) 的对象数量。
narray_like
从人口中取样的样本数量。
seed, 可选
用于绘制随机变量。如果 seed 为 None，则使用 RandomState 单例。如果 seed 是整数，则使用一个新的 RandomState 实例，并用 seed 初始化。如果 seed 已经是 RandomState 或 Generator 实例，则使用该对象。默认为 None。
另见
scipy.stats.hypergeom
超几何分布。
scipy.stats.multinomial
多项分布。
注意事项
m 必须是正整数数组。如果分位数 (i) 包含超出范围 ([0, m_i]) 的值，其中 (m_i) 是人群中类型 (i) 的对象数量，或者如果参数不一致（例如 x.sum() != n），则方法返回适当的值（例如 0 对于 pmf）。如果 m 或 n 包含负值，则结果将包含 nan。
用于 multivariate_hypergeom 的概率质量函数为
[\begin{split}P(X_1 = x_1, X_2 = x_2, \ldots, X_k = x_k) = \frac{\binom{m_1}{x_1} \binom{m_2}{x_2} \cdots \binom{m_k}{x_k}}{\binom{M}{n}}, \ \quad (x_1, x_2, \ldots, x_k) \in \mathbb{N}^k \text{ with } \sum_{i=1}^k x_i = n\end{split}]
其中 (m_i) 是种类 (i) 的对象数量，(M) 是总人口中的对象总数（所有 (m_i) 的总和），(n) 是从人口中取样的样本大小。
自 1.6.0 版本新增。
参考文献
[1]
多元超几何分布，www.randomservices.org/random/urn/MultiHypergeometric.html
[2]
Thomas J. Sargent 和 John Stachurski，2020，多元超几何分布 python.quantecon.org/_downloads/pdf/multi_hyper.pdf
示例
要评估多元超几何分布的概率质量函数，在大小为 (10) 和 (20) 的二元人口中，取样大小为 (12)，第一类对象有 (8) 个，第二类对象有 (4) 个，请使用：
>>> from scipy.stats import multivariate_hypergeom
>>> multivariate_hypergeom.pmf(x=[8, 4], m=[10, 20], n=12)
0.0025207176631464523
多变量超几何分布（multivariate_hypergeom）在人口中仅有两种类型（好的和坏的）物体（如上例）时与相应的hypergeom分布完全相同（尽管存在微小的数值差异）。考虑另一个例子，用于与超几何分布进行比较：
>>> from scipy.stats import hypergeom
>>> multivariate_hypergeom.pmf(x=[3, 1], m=[10, 5], n=4)
0.4395604395604395
>>> hypergeom.pmf(k=3, M=15, n=4, N=10)
0.43956043956044005
函数 pmf, logpmf, mean, var, cov, 和 rvs 支持广播，遵循向量参数（x, m, 和 n）被解释为最后轴上的每行作为单个对象的约定。例如，我们可以结合前两次调用multivariate_hypergeom：
>>> multivariate_hypergeom.pmf(x=[[8, 4], [3, 1]], m=[[10, 20], [10, 5]],
... n=[12, 4])
array([0.00252072, 0.43956044])
这种广播也适用于 cov，其中输出对象是大小为 m.shape[-1] 的方阵。例如：
>>> multivariate_hypergeom.cov(m=[[7, 9], [10, 15]], n=[8, 12])
array([[[ 1.05, -1.05],
[-1.05, 1.05]],
[[ 1.56, -1.56],
[-1.56, 1.56]]])
即，result[0] 等于 multivariate_hypergeom.cov(m=[7, 9], n=8)，而 result[1] 等于 multivariate_hypergeom.cov(m=[10, 15], n=12)。
或者，可以调用该对象（作为函数）来固定参数 m 和 n，返回一个“冻结”的多变量超几何随机变量。
>>> rv = multivariate_hypergeom(m=[10, 20], n=12)
>>> rv.pmf(x=[8, 4])
0.0025207176631464523
方法
| pmf(x, m, n) | 概率质量函数。 |
|---|---|
| logpmf(x, m, n) | 概率质量函数的对数。 |
| rvs(m, n, size=1, random_state=None) | 从多变量超几何分布中抽取随机样本。 |
| mean(m, n) | 多变量超几何分布的均值。 |
| var(m, n) | 多变量超几何分布的方差。 |
| cov(m, n) | 计算多变量超几何分布的协方差矩阵。 |
scipy.stats.random_table
scipy.stats.random_table = <scipy.stats._multivariate.random_table_gen object>
来自固定边际和的独立样本的列联表。
这是具有给定行和列向量总和的随机表的分布。该分布表示在假设行和列是独立的零假设下的随机表集合。它用于独立性假设检验。
由于假设独立性，可以从行和列总和计算出每个表元素的期望频率，因此该分布完全由这两个向量确定。
参数：
行array_like
每行中表条目的总和。
列array_like
每列中表条目的总和。
种子，可选
用于绘制随机变量。如果seed为None，则使用RandomState单例。如果seed为 int，则使用一个新的RandomState实例，并用 seed 种子。如果seed已经是RandomState或Generator实例，则使用该对象。默认值为None。
注释
行和列向量必须是一维的，不能是空的，并且每个都加起来到相同的值。它们不能包含负数或非整数条目。
从分布中生成的随机元素可以使用 Boyett 的[1]或 Patefield 的算法[2]。 Boyett 算法具有 O(N)的时间和空间复杂度，其中 N 是表中条目的总和。 Patefield 的算法具有 O(K x log(N))的时间复杂度，其中 K 是表中的单元格数，并且仅需要一个小的常数工作空间。默认情况下，rvs方法根据输入选择最快的算法，但您可以使用关键字method指定算法。允许的值为“boyett”和“patefield”。
新版本 1.10.0 中。
参考文献
[1]
- Boyett, AS 144 Appl. Statist. 28 (1979) 329-332
[2]
W.M. Patefield, AS 159 Appl. Statist. 30 (1981) 91-97
示例
>>> from scipy.stats import random_table
>>> row = [1, 5]
>>> col = [2, 3, 1]
>>> random_table.mean(row, col)
array([[0.33333333, 0.5 , 0.16666667],
[1.66666667, 2.5 , 0.83333333]])
或者，对象可以被称为（作为一个函数），以修正行和列向量的总和，返回一个“冻结”的分布。
>>> dist = random_table(row, col)
>>> dist.rvs(random_state=123)
array([[1., 0., 0.],
[1., 3., 1.]])
方法
| logpmf(x) | 表x在分布中发生的对数概率。 |
|---|---|
| pmf(x) | 表x在分布中发生的概率。 |
| mean(row, col) | 平均表。 |
| rvs(row, col, size=None, method=None, random_state=None) | 用给定的行和列向量总和绘制随机表。 |
scipy.stats.uniform_direction
scipy.stats.uniform_direction = <scipy.stats._multivariate.uniform_direction_gen object>
一个向量值均匀方向。
返回一个随机方向（单位向量）。dim关键字指定空间的维数。
参数：
dim标量
方向的维度。
seed{None, int, numpy.random.Generator,
numpy.random.RandomState}, 可选项
用于绘制随机变量。如果seed为None，则使用RandomState单例。如果seed为整数，则使用带有该种子的新RandomState实例。如果seed已经是RandomState或Generator实例，则使用该对象。默认为None。
笔记
此分布生成在超球面表面均匀分布的单位向量。这些可以解释为随机方向。例如，如果dim为 3，则会从(S²)的表面采样 3D 向量。
参考文献
[1]
Marsaglia, G. (1972). “Choosing a Point from the Surface of a Sphere”. Annals of Mathematical Statistics. 43 (2): 645-646.
示例
>>> import numpy as np
>>> from scipy.stats import uniform_direction
>>> x = uniform_direction.rvs(3)
>>> np.linalg.norm(x)
1.
这生成一个随机方向，一个位于(S²)表面的向量。
或者，对象可以被称为（作为函数）以返回一个具有固定dim参数的冻结分布。在这里，我们创建一个uniform_direction，其中dim=3并绘制 5 个观测值。然后，样本被安排在形状为 5x3 的数组中。
>>> rng = np.random.default_rng()
>>> uniform_sphere_dist = uniform_direction(3)
>>> unit_vectors = uniform_sphere_dist.rvs(5, random_state=rng)
>>> unit_vectors
array([[ 0.56688642, -0.1332634 , -0.81294566],
[-0.427126 , -0.74779278, 0.50830044],
[ 0.3793989 , 0.92346629, 0.05715323],
[ 0.36428383, -0.92449076, -0.11231259],
[-0.27733285, 0.94410968, -0.17816678]])
方法
| rvs(dim=None, size=1, random_state=None) | 绘制随机方向。 |
|---|
scipy.stats.vonmises_fisher
scipy.stats.vonmises_fisher = <scipy.stats._multivariate.vonmises_fisher_gen object>
冯·米塞斯-费舍尔变量。
关键词mu指定均值方向向量。关键词kappa指定集中参数。
参数：
mu类似数组
分布的均值方向。必须是一个单位范数的一维向量。
kappa浮点数
集中参数。必须为正。
种子，可选
用于绘制随机变量。如果seed为None，则使用RandomState单例。如果seed为整数，则使用一个新的RandomState实例，种子为 seed。如果seed已经是RandomState或Generator实例，则使用该对象。默认为None。
另请参见
在 2D 上的冯·米塞斯-费舍尔分布，圆上
在超球面上的均匀分布
注意事项
冯·米塞斯-费舍尔分布是单位超球面上的方向分布。单位向量(\mathbf{x})的概率密度函数为
[f(\mathbf{x}) = \frac{\kappa{d/2-1}}{(2\pi)I_{d/2-1}(\kappa)} \exp\left(\kappa \mathbf{\mu}^T\mathbf{x}\right),]
其中(\mathbf{\mu})是均值方向，(\kappa)是集中参数，(d)是维数，(I)是第一类修正贝塞尔函数。由于(\mu)表示一个方向，它必须是一个单位向量，或者换句话说，是超球面上的一个点：(\mathbf{\mu}\in S^{d-1})。(\kappa)是一个集中参数，这意味着它必须是正的（(\kappa>0)），且随着(\kappa)的增加，分布变得更加狭窄。在这种意义上，倒数(1/\kappa)类似于正态分布的方差参数。
冯·米塞斯-费舍尔分布通常作为球面上正态分布的类比。直观地，对于单位向量，一个有用的距离度量由它们之间的角度(\alpha)给出。这正是冯·米塞斯-费舍尔概率密度函数中标量积(\mathbf{\mu}^T\mathbf{x}=\cos(\alpha))描述的：均值方向(\mathbf{\mu})与向量(\mathbf{x})之间的角度。它们之间的角度越大，观察到特定均值方向(\mathbf{\mu})的向量(\mathbf{x})的概率就越小。
在 2 维和 3 维中，使用了专门的算法进行快速抽样 [2]，[3]。对于 4 维或更高维度，使用了[4]中描述的拒绝抽样算法。此实现部分基于 geomstats 软件包 [5]，[6]。
1.11 版本更新内容。
参考文献
[1]
Von Mises-Fisher 分布，维基百科，en.wikipedia.org/wiki/Von_Mises%E2%80%93Fisher_distribution
[2]
Mardia，K.，和 Jupp，P. 方向统计。Wiley，2000 年。
[3]
J. Wenzel。在 S2 上对 von Mises Fisher 分布进行数值稳定抽样。www.mitsuba-renderer.org/~wenzel/files/vmf.pdf
[4]
Wood，A. von Mises Fisher 分布的模拟。统计学沟通 - 模拟与计算 23，1（1994 年），157-164。doi.org/10.1080/03610919408813161
[5]
geomstats，Github。MIT 许可证。访问日期：2023 年 06 月 01 日。github.com/geomstats/geomstats
[6]
Miolane，N. 等。Geomstats：机器学习中的黎曼几何 Python 包。机器学习研究杂志 21（2020 年）。jmlr.org/papers/v21/19-027.html
示例
概率密度的可视化
绘制三维中随着浓度参数增加的概率密度。密度由pdf方法计算得出。
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.stats import vonmises_fisher
>>> from matplotlib.colors import Normalize
>>> n_grid = 100
>>> u = np.linspace(0, np.pi, n_grid)
>>> v = np.linspace(0, 2 * np.pi, n_grid)
>>> u_grid, v_grid = np.meshgrid(u, v)
>>> vertices = np.stack([np.cos(v_grid) * np.sin(u_grid),
... np.sin(v_grid) * np.sin(u_grid),
... np.cos(u_grid)],
... axis=2)
>>> x = np.outer(np.cos(v), np.sin(u))
>>> y = np.outer(np.sin(v), np.sin(u))
>>> z = np.outer(np.ones_like(u), np.cos(u))
>>> def plot_vmf_density(ax, x, y, z, vertices, mu, kappa):
... vmf = vonmises_fisher(mu, kappa)
... pdf_values = vmf.pdf(vertices)
... pdfnorm = Normalize(vmin=pdf_values.min(), vmax=pdf_values.max())
... ax.plot_surface(x, y, z, rstride=1, cstride=1,
... facecolors=plt.cm.viridis(pdfnorm(pdf_values)),
... linewidth=0)
... ax.set_aspect('equal')
... ax.view_init(azim=-130, elev=0)
... ax.axis('off')
... ax.set_title(rf"$\kappa={kappa}$")
>>> fig, axes = plt.subplots(nrows=1, ncols=3, figsize=(9, 4),
... subplot_kw={"projection": "3d"})
>>> left, middle, right = axes
>>> mu = np.array([-np.sqrt(0.5), -np.sqrt(0.5), 0])
>>> plot_vmf_density(left, x, y, z, vertices, mu, 5)
>>> plot_vmf_density(middle, x, y, z, vertices, mu, 20)
>>> plot_vmf_density(right, x, y, z, vertices, mu, 100)
>>> plt.subplots_adjust(top=1, bottom=0.0, left=0.0, right=1.0, wspace=0.)
>>> plt.show()
随着浓度参数的增加，点围绕平均方向越来越聚集。
抽样
使用rvs方法从分布中抽取 5 个样本，生成一个 5x3 的数组。
>>> rng = np.random.default_rng()
>>> mu = np.array([0, 0, 1])
>>> samples = vonmises_fisher(mu, 20).rvs(5, random_state=rng)
>>> samples
array([[ 0.3884594 , -0.32482588, 0.86231516],
[ 0.00611366, -0.09878289, 0.99509023],
[-0.04154772, -0.01637135, 0.99900239],
[-0.14613735, 0.12553507, 0.98126695],
[-0.04429884, -0.23474054, 0.97104814]])
这些样本是单位球面上的单位向量 (S²)。为了验证，让我们计算它们的欧几里德范数：
>>> np.linalg.norm(samples, axis=1)
array([1., 1., 1., 1., 1.])
绘制从 von Mises-Fisher 分布中抽取的 20 个观测值，随着浓度参数 (\kappa) 的增加。红点突出显示平均方向 (\mu)。
>>> def plot_vmf_samples(ax, x, y, z, mu, kappa):
... vmf = vonmises_fisher(mu, kappa)
... samples = vmf.rvs(20)
... ax.plot_surface(x, y, z, rstride=1, cstride=1, linewidth=0,
... alpha=0.2)
... ax.scatter(samples[:, 0], samples[:, 1], samples[:, 2], c='k', s=5)
... ax.scatter(mu[0], mu[1], mu[2], c='r', s=30)
... ax.set_aspect('equal')
... ax.view_init(azim=-130, elev=0)
... ax.axis('off')
... ax.set_title(rf"$\kappa={kappa}$")
>>> mu = np.array([-np.sqrt(0.5), -np.sqrt(0.5), 0])
>>> fig, axes = plt.subplots(nrows=1, ncols=3,
... subplot_kw={"projection": "3d"},
... figsize=(9, 4))
>>> left, middle, right = axes
>>> plot_vmf_samples(left, x, y, z, mu, 5)
>>> plot_vmf_samples(middle, x, y, z, mu, 20)
>>> plot_vmf_samples(right, x, y, z, mu, 100)
>>> plt.subplots_adjust(top=1, bottom=0.0, left=0.0,
... right=1.0, wspace=0.)
>>> plt.show()
图表显示，随着浓度参数 (\kappa) 的增加，结果样本更集中地围绕平均方向。
拟合分布参数
可以使用fit方法将分布拟合到数据中，返回估计的参数。作为一个示例，让我们将分布拟合到从已知 von Mises-Fisher 分布中抽取的样本。
>>> mu, kappa = np.array([0, 0, 1]), 20
>>> samples = vonmises_fisher(mu, kappa).rvs(1000, random_state=rng)
>>> mu_fit, kappa_fit = vonmises_fisher.fit(samples)
>>> mu_fit, kappa_fit
(array([0.01126519, 0.01044501, 0.99988199]), 19.306398751730995)
我们看到估计的参数 mu_fit 和 kappa_fit 与真实参数非常接近。
方法
| pdf(x, mu=None, kappa=1) | 概率密度函数。 |
|---|---|
| logpdf(x, mu=None, kappa=1) | 概率密度函数的对数。 |
| rvs(mu=None, kappa=1, size=1, random_state=None) | 从 von Mises-Fisher 分布中抽取随机样本。 |
| entropy(mu=None, kappa=1) | 计算 von Mises-Fisher 分布的差分熵。 |
| fit(data) | 拟合数据到 von Mises-Fisher 分布。 |
scipy.stats.Covariance
class scipy.stats.Covariance
协方差矩阵的表示
对涉及协方差矩阵的计算（例如数据白化、多元正态函数评估），通常使用协方差矩阵的分解而不是协方差矩阵本身效率更高。此类允许用户使用多种分解构建代表协方差矩阵的对象，并使用通用接口进行计算。
注意
不能直接实例化Covariance类。而是使用其中的一个工厂方法（例如Covariance.from_diagonal）。
示例
通过调用其工厂方法之一来创建Covariance对象，然后将该表示传递给多元分布的形状参数，从而使用Covariance矩阵的表示来计算概率密度函数。
例如，多元正态分布可以接受表示协方差矩阵的数组：
>>> from scipy import stats
>>> import numpy as np
>>> d = [1, 2, 3]
>>> A = np.diag(d) # a diagonal covariance matrix
>>> x = [4, -2, 5] # a point of interest
>>> dist = stats.multivariate_normal(mean=[0, 0, 0], cov=A)
>>> dist.pdf(x)
4.9595685102808205e-08
但是计算是以一种通用方式进行的，不利用协方差矩阵的任何特殊属性。因为我们的协方差矩阵是对角的，我们可以使用Covariance.from_diagonal创建代表协方差矩阵的对象，并且multivariate_normal可以利用这一点更有效地计算概率密度函数。
>>> cov = stats.Covariance.from_diagonal(d)
>>> dist = stats.multivariate_normal(mean=[0, 0, 0], cov=cov)
>>> dist.pdf(x)
4.9595685102808205e-08
属性：
covariance
协方差矩阵的显式表示
log_pdet
协方差矩阵伪行列式的对数
rank
协方差矩阵的秩
shape
协方差数组的形状
方法
colorize(x) |
对数据执行颜色变换。 |
|---|---|
from_cholesky(cholesky) |
通过（下三角）Cholesky 因子提供的协方差的表示。 |
from_diagonal(diagonal) |
从其对角线返回协方差矩阵的表示。 |
from_eigendecomposition(eigendecomposition) |
通过特征分解提供的协方差的表示。 |
from_precision(precision[, covariance]) |
从其精度矩阵返回协方差的表示。 |
whiten(x) |
对数据执行白化变换。 |
scipy.stats.bernoulli
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.bernoulli.html#scipy.stats.bernoulli
scipy.stats.bernoulli = <scipy.stats._discrete_distns.bernoulli_gen object>
一个伯努利离散随机变量。
作为rv_discrete类的实例，伯努利分布对象继承了一组通用方法（下面列出完整列表），并用特定于该特定分布的细节完成了它们。
注意事项
伯努利分布的概率质量函数为：
[\begin{split}f(k) = \begin{cases}1-p &\text{如果 } k = 0\ p &\text{如果 } k = 1\end{cases}\end{split}]
对于(k)在({0, 1})中，(0 \leq p \leq 1)
伯努利分布以(p)作为形状参数，其中(p)是单次成功的概率，(1-p)是单次失败的概率。
上述概率质量函数以“标准化”形式定义。使用loc参数来移动分布。具体来说，bernoulli.pmf(k, p, loc)与bernoulli.pmf(k - loc, p)完全等价。
示例
>>> import numpy as np
>>> from scipy.stats import bernoulli
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)
计算前四个矩：
>>> p = 0.3
>>> mean, var, skew, kurt = bernoulli.stats(p, moments='mvsk')
显示概率质量函数（pmf）：
>>> x = np.arange(bernoulli.ppf(0.01, p),
... bernoulli.ppf(0.99, p))
>>> ax.plot(x, bernoulli.pmf(x, p), 'bo', ms=8, label='bernoulli pmf')
>>> ax.vlines(x, 0, bernoulli.pmf(x, p), colors='b', lw=5, alpha=0.5)
或者，可以调用分布对象（作为函数）来固定形状和位置。这将返回一个“冻结”的随机变量对象，保持给定的参数不变。
冻结分布并显示冻结的pmf：
>>> rv = bernoulli(p)
>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1,
... label='frozen pmf')
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()
检查cdf和ppf的准确性：
>>> prob = bernoulli.cdf(x, p)
>>> np.allclose(x, bernoulli.ppf(prob, p))
True
生成随机数：
>>> r = bernoulli.rvs(p, size=1000)
方法
| rvs(p, loc=0, size=1, random_state=None) | 随机变量。 |
|---|---|
| pmf(k, p, loc=0) | 概率质量函数。 |
| logpmf(k, p, loc=0) | 概率质量函数的对数。 |
| cdf(k, p, loc=0) | 累积分布函数。 |
| logcdf(k, p, loc=0) | 累积分布函数的对数。 |
| sf(k, p, loc=0) | 生存函数（也定义为1 - cdf，但sf有时更准确）。 |
| logsf(k, p, loc=0) | 生存函数的对数。 |
| ppf(q, p, loc=0) | 百分点函数（cdf的逆 - 百分位数）。 |
| isf(q, p, loc=0) | 逆生存函数（sf的逆）。 |
| stats(p, loc=0, moments=’mv’) | 均值（‘m’）、方差（‘v’）、偏度（‘s’）、峰度（‘k’）。 |
| entropy(p, loc=0) | 随机变量的（微分）熵。 |
| expect(func, args=(p,), loc=0, lb=None, ub=None, conditional=False) | 期望值函数（一元函数）关于分布的期望值。 |
| median(p, loc=0) | 分布的中位数。 |
| mean(p, loc=0) | 分布的均值。 |
| var(p, loc=0) | 分布的方差。 |
| std(p, loc=0) | 分布的标准差。 |
| interval(confidence, p, loc=0) | 置信区间，围绕中位数具有相等面积。 |
scipy.stats.betabinom
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.betabinom.html#scipy.stats.betabinom
scipy.stats.betabinom = <scipy.stats._discrete_distns.betabinom_gen object>
贝塔二项离散随机变量。
作为 rv_discrete 类的一个实例，betabinom 对象从中继承了一系列通用方法（详见下面的完整列表），并为此特定分布补充了特定的细节。
另见
beta, binom
注释
贝塔二项分布是一个具有成功概率 p 的二项分布，其符合贝塔分布。
betabinom 的概率质量函数为：
[f(k) = \binom{n}{k} \frac{B(k + a, n - k + b)}{B(a, b)}]
对于 (k \in {0, 1, \dots, n})，(n \geq 0)，(a > 0)，(b > 0)，其中 (B(a, b)) 是贝塔函数。
betabinom 以 (n)、(a) 和 (b) 作为形状参数。
参考资料
[1]
上述概率质量函数定义为“标准化”形式。要移动分布，请使用 loc 参数。具体而言，betabinom.pmf(k, n, a, b, loc) 等同于 betabinom.pmf(k - loc, n, a, b)。
新版本 1.4.0 中引入。
示例
>>> import numpy as np
>>> from scipy.stats import betabinom
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)
计算前四个矩：
>>> n, a, b = 5, 2.3, 0.63
>>> mean, var, skew, kurt = betabinom.stats(n, a, b, moments='mvsk')
显示概率质量函数（pmf）：
>>> x = np.arange(betabinom.ppf(0.01, n, a, b),
... betabinom.ppf(0.99, n, a, b))
>>> ax.plot(x, betabinom.pmf(x, n, a, b), 'bo', ms=8, label='betabinom pmf')
>>> ax.vlines(x, 0, betabinom.pmf(x, n, a, b), colors='b', lw=5, alpha=0.5)
或者，可以调用分布对象（作为函数）来固定形状和位置。这将返回一个保持给定参数固定的“冻结”随机变量对象。
冻结分布并显示冻结的 pmf：
>>> rv = betabinom(n, a, b)
>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1,
... label='frozen pmf')
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()
检查 cdf 和 ppf 的准确性：
>>> prob = betabinom.cdf(x, n, a, b)
>>> np.allclose(x, betabinom.ppf(prob, n, a, b))
True
生成随机数：
>>> r = betabinom.rvs(n, a, b, size=1000)
方法
| rvs(n, a, b, loc=0, size=1, random_state=None) | 随机变量。 |
|---|---|
| pmf(k, n, a, b, loc=0) | 概率质量函数。 |
| logpmf(k, n, a, b, loc=0) | 概率质量函数的对数。 |
| cdf(k, n, a, b, loc=0) | 累积分布函数。 |
| logcdf(k, n, a, b, loc=0) | 累积分布函数的对数。 |
| sf(k, n, a, b, loc=0) | 生存函数（也被定义为 1 - cdf，但sf有时更准确）。 |
| logsf(k, n, a, b, loc=0) | 生存函数的对数。 |
| ppf(q, n, a, b, loc=0) | 百分位点函数（cdf的反函数 — 百分位数）。 |
| isf(q, n, a, b, loc=0) | 生存函数的反函数（sf的反函数）。 |
| stats(n, a, b, loc=0, moments=’mv’) | 均值（‘m’）、方差（‘v’）、偏度（‘s’）、峰度（‘k’）。 |
| entropy(n, a, b, loc=0) | (微分) 随机变量的熵。 |
| expect(func, args=(n, a, b), loc=0, lb=None, ub=None, conditional=False) | 对分布的一个函数（一个参数）的期望值。 |
| median(n, a, b, loc=0) | 分布的中位数。 |
| mean(n, a, b, loc=0) | 分布的均值。 |
| var(n, a, b, loc=0) | 分布的方差。 |
| std(n, a, b, loc=0) | 分布的标准偏差。 |
| interval(confidence, n, a, b, loc=0) | 中位数周围面积相等的置信区间。 |
scipy.stats.betanbinom
scipy.stats.betanbinom = <scipy.stats._discrete_distns.betanbinom_gen object>
贝塔负二项离散随机变量。
作为 rv_discrete 类的一个实例，betanbinom 对象继承了一组通用方法（请参阅下文的完整列表），并用此特定分布的详细信息补充了它们。
另请参见
Beta 负二项分布
注意
贝塔负二项分布是具有成功概率 p 的贝塔分布的负二项分布。
betanbinom 的概率质量函数为：
[f(k) = \binom{n + k - 1}{k} \frac{B(a + n, b + k)}{B(a, b)}]
对于 (k \ge 0), (n \geq 0), (a > 0), (b > 0)，其中 (B(a, b)) 是贝塔函数。
betanbinom 接受 (n)、(a) 和 (b) 作为形状参数。
参考资料
[1]
en.wikipedia.org/wiki/Beta_negative_binomial_distribution
上述概率质量函数定义为“标准化”形式。要转移分布，请使用 loc 参数。具体来说，betanbinom.pmf(k, n, a, b, loc) 等同于 betanbinom.pmf(k - loc, n, a, b)。
自版本 1.12.0 起新增。
示例
>>> import numpy as np
>>> from scipy.stats import betanbinom
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)
计算前四个时刻：
>>> n, a, b = 5, 9.3, 1
>>> mean, var, skew, kurt = betanbinom.stats(n, a, b, moments='mvsk')
显示概率质量函数 (pmf)：
>>> x = np.arange(betanbinom.ppf(0.01, n, a, b),
... betanbinom.ppf(0.99, n, a, b))
>>> ax.plot(x, betanbinom.pmf(x, n, a, b), 'bo', ms=8, label='betanbinom pmf')
>>> ax.vlines(x, 0, betanbinom.pmf(x, n, a, b), colors='b', lw=5, alpha=0.5)
或者，可以调用分布对象（作为函数）以固定形状和位置。这会返回一个固定给定参数的“冻结”RV 对象。
冻结分布并显示冻结的 pmf：
>>> rv = betanbinom(n, a, b)
>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1,
... label='frozen pmf')
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()
检查 cdf 和 ppf 的准确性：
>>> prob = betanbinom.cdf(x, n, a, b)
>>> np.allclose(x, betanbinom.ppf(prob, n, a, b))
True
生成随机数：
>>> r = betanbinom.rvs(n, a, b, size=1000)
方法
| rvs(n, a, b, loc=0, size=1, random_state=None) | 随机变量。 |
|---|---|
| pmf(k, n, a, b, loc=0) | 概率质量函数。 |
| logpmf(k, n, a, b, loc=0) | 概率质量函数的对数。 |
| cdf(k, n, a, b, loc=0) | 累积分布函数。 |
| logcdf(k, n, a, b, loc=0) | 累积分布函数的对数。 |
| sf(k, n, a, b, loc=0) | 生存函数（也定义为 1 - cdf，但 sf 有时更精确）。 |
| logsf(k, n, a, b, loc=0) | 生存函数的对数。 |
| ppf(q, n, a, b, loc=0) | 百分位点函数（cdf 的反函数，即百分位数）。 |
| isf(q, n, a, b, loc=0) | 生存函数的反函数（sf 的反函数）。 |
| stats(n, a, b, loc=0, moments=’mv’) | 均值（‘m’）、方差（‘v’）、偏度（‘s’）和/或峰度（‘k’）。 |
| entropy(n, a, b, loc=0) | 随机变量的（微分）熵。 |
| expect(func, args=(n, a, b), loc=0, lb=None, ub=None, conditional=False) | 期望值，针对分布的一个参数的函数（的一个参数）。 |
| median(n, a, b, loc=0) | 分布的中位数。 |
| mean(n, a, b, loc=0) | 分布的均值。 |
| var(n, a, b, loc=0) | 分布的方差。 |
| std(n, a, b, loc=0) | 分布的标准差。 |
| interval(confidence, n, a, b, loc=0) | 置信区间，围绕中位数有相等的面积。 |
scipy.stats.binom
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.binom.html#scipy.stats.binom
scipy.stats.binom = <scipy.stats._discrete_distns.binom_gen object>
一个二项离散随机变量。
作为rv_discrete类的一个实例，binom 对象从中继承了一组通用方法（完整列表见下文），并通过特定于该特定分布的详细信息来完成它们。
另请参阅
hypergeom, nbinom, nhypergeom
注意事项
binom 的概率质量函数为：
[f(k) = \binom{n}{k} p^k (1-p)^{n-k}]
对于 (k \in {0, 1, \dots, n}), (0 \leq p \leq 1)
binom 接受n和p作为形状参数，其中p是单次成功的概率，1-p是单次失败的概率。
上述概率质量函数以“标准化”形式定义。要移动分布，请使用loc参数。具体地说，binom.pmf(k, n, p, loc)与binom.pmf(k - loc, n, p)等价。
示例
>>> import numpy as np
>>> from scipy.stats import binom
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)
计算前四个矩：
>>> n, p = 5, 0.4
>>> mean, var, skew, kurt = binom.stats(n, p, moments='mvsk')
显示概率质量函数（pmf）：
>>> x = np.arange(binom.ppf(0.01, n, p),
... binom.ppf(0.99, n, p))
>>> ax.plot(x, binom.pmf(x, n, p), 'bo', ms=8, label='binom pmf')
>>> ax.vlines(x, 0, binom.pmf(x, n, p), colors='b', lw=5, alpha=0.5)
或者，可以调用分布对象（作为函数）来固定形状和位置。这会返回一个保持给定参数固定的“冻结”随机变量对象。
冻结分布并显示冻结的pmf：
>>> rv = binom(n, p)
>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1,
... label='frozen pmf')
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()
检查cdf和ppf的准确性：
>>> prob = binom.cdf(x, n, p)
>>> np.allclose(x, binom.ppf(prob, n, p))
True
生成随机数：
>>> r = binom.rvs(n, p, size=1000)
方法
| rvs(n, p, loc=0, size=1, random_state=None) | 随机变量。 |
|---|---|
| pmf(k, n, p, loc=0) | 概率质量函数。 |
| logpmf(k, n, p, loc=0) | 概率质量函数的对数。 |
| cdf(k, n, p, loc=0) | 累积分布函数。 |
| logcdf(k, n, p, loc=0) | 累积分布函数的对数。 |
| sf(k, n, p, loc=0) | 生存函数（也定义为1 - cdf，但sf有时更精确）。 |
| logsf(k, n, p, loc=0) | 生存函数的对数。 |
| ppf(q, n, p, loc=0) | 百分位点函数（cdf的逆 — 百分位数）。 |
| isf(q, n, p, loc=0) | 逆生存函数（sf的逆）。 |
| stats(n, p, loc=0, moments=’mv’) | 均值（‘m’）、方差（‘v’）、偏度（‘s’）和/或峰度（‘k’）。 |
| entropy(n, p, loc=0) | 随机变量的（微分）熵。 |
| expect(func, args=(n, p), loc=0, lb=None, ub=None, conditional=False) | 期望值函数（一个参数）相对于分布的期望值。 |
| median(n, p, loc=0) | 分布的中位数。 |
| mean(n, p, loc=0) | 分布的平均值。 |
| var(n, p, loc=0) | 分布的方差。 |
| std(n, p, loc=0) | 分布的标准差。 |
| interval(confidence, n, p, loc=0) | 置信区间，围绕中位数具有相等的区域。 |
scipy.stats.boltzmann
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.boltzmann.html#scipy.stats.boltzmann
scipy.stats.boltzmann = <scipy.stats._discrete_distns.boltzmann_gen object>
一种 Boltzmann（截断离散指数）随机变量。
作为rv_discrete类的一个实例，boltzmann 对象继承了一组通用方法（下面详细列出），并补充了特定于此特定分布的细节。
注意事项
boltzmann 的概率质量函数为：
[f(k) = (1-\exp(-\lambda)) \exp(-\lambda k) / (1-\exp(-\lambda N))]
对于 (k = 0,..., N-1)。
boltzmann 接受 (\lambda > 0) 和 (N > 0) 作为形状参数。
上述概率质量函数以“标准化”形式定义。要移动分布，请使用loc参数。具体而言，boltzmann.pmf(k, lambda_, N, loc) 与 boltzmann.pmf(k - loc, lambda_, N) 完全等效。
示例
>>> import numpy as np
>>> from scipy.stats import boltzmann
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)
计算前四个时刻：
>>> lambda_, N = 1.4, 19
>>> mean, var, skew, kurt = boltzmann.stats(lambda_, N, moments='mvsk')
显示概率质量函数（pmf）：
>>> x = np.arange(boltzmann.ppf(0.01, lambda_, N),
... boltzmann.ppf(0.99, lambda_, N))
>>> ax.plot(x, boltzmann.pmf(x, lambda_, N), 'bo', ms=8, label='boltzmann pmf')
>>> ax.vlines(x, 0, boltzmann.pmf(x, lambda_, N), colors='b', lw=5, alpha=0.5)
或者，可以调用分布对象（作为函数）以固定形状和位置。这将返回一个“冻结的”RV 对象，其中包含给定的固定参数。
冻结分布并显示冻结的pmf：
>>> rv = boltzmann(lambda_, N)
>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1,
... label='frozen pmf')
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()
检查cdf和ppf的准确性：
>>> prob = boltzmann.cdf(x, lambda_, N)
>>> np.allclose(x, boltzmann.ppf(prob, lambda_, N))
True
生成随机数：
>>> r = boltzmann.rvs(lambda_, N, size=1000)
方法
| rvs(lambda_, N, loc=0, size=1, random_state=None) | 随机变量。 |
|---|---|
| pmf(k, lambda_, N, loc=0) | 概率质量函数。 |
| logpmf(k, lambda_, N, loc=0) | 概率质量函数的对数。 |
| cdf(k, lambda_, N, loc=0) | 累积分布函数。 |
| logcdf(k, lambda_, N, loc=0) | 累积分布函数的对数。 |
| sf(k, lambda_, N, loc=0) | 生存函数（也被定义为1 - cdf，但sf有时更精确）。 |
| logsf(k, lambda_, N, loc=0) | 生存函数的对数。 |
| ppf(q, lambda_, N, loc=0) | 百分点函数（cdf的逆 — 百分位数）。 |
| isf(q, lambda_, N, loc=0) | 逆生存函数（sf的逆）。 |
| stats(lambda_, N, loc=0, moments=’mv’) | 平均值（‘m’）、方差（‘v’）、偏度（‘s’）和/或峰度（‘k’）。 |
| entropy(lambda_, N, loc=0) | RV 的（微分）熵。 |
| expect(func, args=(lambda_, N), loc=0, lb=None, ub=None, conditional=False) | 函数期望值（一个参数的函数）。 |
| median(lambda_, N, loc=0) | 分布的中位数。 |
| mean(lambda_, N, loc=0) | 分布的均值。 |
| var(lambda_, N, loc=0) | 分布的方差。 |
| std(lambda_, N, loc=0) | 分布的标准差（lambda，N，位置=0）。 |
| interval(confidence, lambda_, N, loc=0) | 区间（置信度，lambda，N，位置=0），中位数周围具有相等面积的置信区间。 |
scipy.stats.dlaplace
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.dlaplace.html#scipy.stats.dlaplace
scipy.stats.dlaplace = <scipy.stats._discrete_distns.dlaplace_gen object>
一个拉普拉斯离散随机变量。
作为 rv_discrete 类的一个实例，dlaplace 对象继承了一组通用方法（下面详细列出），并用特定于此特定分布的细节完善了它们。
注意事项
dlaplace 的概率质量函数为：
[f(k) = \tanh(a/2) \exp(-a |k|)]
对于整数 (k) 和 (a > 0)。
dlaplace 以参数 (a) 作为形状参数。
上述概率质量函数以“标准化”形式定义。使用 loc 参数来移动分布。具体地，dlaplace.pmf(k, a, loc) 与 dlaplace.pmf(k - loc, a) 完全等价。
示例
>>> import numpy as np
>>> from scipy.stats import dlaplace
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)
计算前四个矩：
>>> a = 0.8
>>> mean, var, skew, kurt = dlaplace.stats(a, moments='mvsk')
显示概率质量函数（pmf）：
>>> x = np.arange(dlaplace.ppf(0.01, a),
... dlaplace.ppf(0.99, a))
>>> ax.plot(x, dlaplace.pmf(x, a), 'bo', ms=8, label='dlaplace pmf')
>>> ax.vlines(x, 0, dlaplace.pmf(x, a), colors='b', lw=5, alpha=0.5)
或者，可以调用分布对象（作为函数）以固定形状和位置。这将返回一个固定给定参数的“冻结”随机变量对象。
冻结分布并显示冻结的 pmf：
>>> rv = dlaplace(a)
>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1,
... label='frozen pmf')
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()
检查 cdf 和 ppf 的准确性：
>>> prob = dlaplace.cdf(x, a)
>>> np.allclose(x, dlaplace.ppf(prob, a))
True
生成随机数：
>>> r = dlaplace.rvs(a, size=1000)
方法
| rvs(a, loc=0, size=1, random_state=None) | 随机变量。 |
|---|---|
| pmf(k, a, loc=0) | 概率质量函数。 |
| logpmf(k, a, loc=0) | 概率质量函数的对数。 |
| cdf(k, a, loc=0) | 累积分布函数。 |
| logcdf(k, a, loc=0) | 累积分布函数的对数。 |
| sf(k, a, loc=0) | 生存函数（也定义为 1 - cdf，但 sf 有时更准确）。 |
| logsf(k, a, loc=0) | 生存函数的对数。 |
| ppf(q, a, loc=0) | 百分点函数（cdf 的反函数 — 百分位数）。 |
| isf(q, a, loc=0) | 生存函数的逆函数（sf 的逆函数）。 |
| stats(a, loc=0, moments=’mv’) | 均值（‘m’），方差（‘v’），偏度（‘s’），及/或峰度（‘k’）。 |
| entropy(a, loc=0) | 随机变量的（微分）熵。 |
| expect(func, args=(a,), loc=0, lb=None, ub=None, conditional=False) | 对分布的函数（一个参数的函数）的期望值。 |
| median(a, loc=0) | 分布的中位数。 |
| mean(a, loc=0) | 分布的均值。 |
| var(a, loc=0) | 分布的方差。 |
| std(a, loc=0) | 分布的标准偏差。 |
| interval(confidence, a, loc=0) | 中位数周围具有相等面积的置信区间。 |
scipy.stats.geom
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.geom.html#scipy.stats.geom
scipy.stats.geom = <scipy.stats._discrete_distns.geom_gen object>
几何离散随机变量。
作为rv_discrete类的一个实例，geom对象从中继承了一系列通用方法（详见下文的完整列表），并补充了针对该特定分布的详细信息。
另请参阅
注意事项
geom的概率质量函数为：
[f(k) = (1-p)^{k-1} p]
对于(k \ge 1), (0 < p \leq 1)
geom以(p)作为形状参数，其中(p)是单次成功的概率，(1-p)是单次失败的概率。
上述概率质量函数以“标准化”形式定义。使用loc参数来移动分布。具体而言，geom.pmf(k, p, loc)与geom.pmf(k - loc, p)完全等价。
示例
>>> import numpy as np
>>> from scipy.stats import geom
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)
计算前四个时刻：
>>> p = 0.5
>>> mean, var, skew, kurt = geom.stats(p, moments='mvsk')
显示概率质量函数（pmf）：
>>> x = np.arange(geom.ppf(0.01, p),
... geom.ppf(0.99, p))
>>> ax.plot(x, geom.pmf(x, p), 'bo', ms=8, label='geom pmf')
>>> ax.vlines(x, 0, geom.pmf(x, p), colors='b', lw=5, alpha=0.5)
或者，可以调用分布对象（作为函数）以固定形状和位置。这将返回一个“冻结”的 RV 对象，其中包含给定的参数。
冻结分布并显示冻结的pmf：
>>> rv = geom(p)
>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1,
... label='frozen pmf')
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()
检查cdf和ppf的准确性：
>>> prob = geom.cdf(x, p)
>>> np.allclose(x, geom.ppf(prob, p))
True
生成随机数：
>>> r = geom.rvs(p, size=1000)
方法
| rvs(p, loc=0, size=1, random_state=None) | 随机变量。 |
|---|---|
| pmf(k, p, loc=0) | 概率质量函数。 |
| logpmf(k, p, loc=0) | 概率质量函数的对数。 |
| cdf(k, p, loc=0) | 累积分布函数。 |
| logcdf(k, p, loc=0) | 累积分布函数的对数。 |
| sf(k, p, loc=0) | 生存函数（也定义为1 - cdf，但sf有时更精确）。 |
| logsf(k, p, loc=0) | 生存函数的对数。 |
| ppf(q, p, loc=0) | 百分位点函数（cdf的反函数——百分位数）。 |
| isf(q, p, loc=0) | 生存函数的反函数（sf的反函数）。 |
| stats(p, loc=0, moments=’mv’) | 均值（‘m’）、方差（‘v’）、偏度（‘s’）和/或峰度（‘k’）。 |
| entropy(p, loc=0) | RV 的（微分）熵。 |
| expect(func, args=(p,), loc=0, lb=None, ub=None, conditional=False) | 对于分布的函数（一个参数）的期望值。 |
| median(p, loc=0) | 分布的中位数。 |
| mean(p, loc=0) | 分布的均值。 |
| var(p, loc=0) | 分布的方差。 |
| std(p, loc=0) | 分布的标准差。 |
| interval(confidence, p, loc=0) | 等面积置信区间围绕中位数。 |
scipy.stats.hypergeom
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.hypergeom.html#scipy.stats.hypergeom
scipy.stats.hypergeom = <scipy.stats._discrete_distns.hypergeom_gen object>
一个超几何离散随机变量。
超几何分布模型是从一个箱子中抽取物体的一种模型。M 是总物体数，n 是类型 I 物体的总数。随机变量表示从总体中不放回地抽取 N 个物体时的类型 I 物体数量。
作为 rv_discrete 类的一个实例，hypergeom 对象从中继承了一组通用方法（下文列出），并用特定于这种分布的细节来补充它们。
另见
注意
用来表示形状参数（M、n 和 N）的符号并非被普遍接受。查看示例以澄清此处使用的定义。
概率质量函数定义如下，
[p(k, M, n, N) = \frac{\binom{n}{k} \binom{M - n}{N - k}} {\binom{M}{N}}]
对于 (k \in [\max(0, N - M + n), \min(n, N)])，其中二项式系数定义为，
[\binom{n}{k} \equiv \frac{n!}{k! (n - k)!}.]
上述概率质量函数以“标准化”形式定义。要移动分布，请使用 loc 参数。具体而言，hypergeom.pmf(k, M, n, N, loc) 等同于 hypergeom.pmf(k - loc, M, n, N)。
示例
>>> import numpy as np
>>> from scipy.stats import hypergeom
>>> import matplotlib.pyplot as plt
假设我们有一组包含 20 只动物，其中有 7 只狗。如果我们想知道在我们随机选择这 20 只动物中的 12 只时找到指定数量的狗的概率，我们可以初始化一个冻结的分布并绘制概率质量函数：
>>> [M, n, N] = [20, 7, 12]
>>> rv = hypergeom(M, n, N)
>>> x = np.arange(0, n+1)
>>> pmf_dogs = rv.pmf(x)
>>> fig = plt.figure()
>>> ax = fig.add_subplot(111)
>>> ax.plot(x, pmf_dogs, 'bo')
>>> ax.vlines(x, 0, pmf_dogs, lw=2)
>>> ax.set_xlabel('# of dogs in our group of chosen animals')
>>> ax.set_ylabel('hypergeom PMF')
>>> plt.show()
不使用冻结分布，我们也可以直接使用 hypergeom 方法。例如，要获得累积分布函数，使用：
>>> prb = hypergeom.cdf(x, M, n, N)
并生成随机数：
>>> R = hypergeom.rvs(M, n, N, size=10)
方法
| rvs(M, n, N, loc=0, size=1, random_state=None) | 随机变量。 |
|---|---|
| pmf(k, M, n, N, loc=0) | 概率质量函数。 |
| logpmf(k, M, n, N, loc=0) | 概率质量函数的对数。 |
| cdf(k, M, n, N, loc=0) | 累积分布函数。 |
| logcdf(k, M, n, N, loc=0) | 累积分布函数的对数。 |
| sf(k, M, n, N, loc=0) | 生存函数（也定义为 1 - cdf，但 sf 有时更精确）。 |
| logsf(k, M, n, N, loc=0) | 生存函数的对数。 |
| ppf(q, M, n, N, loc=0) | 百分位点函数（cdf的逆函数——百分位数）。 |
| isf(q, M, n, N, loc=0) | 逆生存函数（sf的逆函数）。 |
| stats(M, n, N, loc=0, moments=’mv’) | 均值（‘m’）、方差（‘v’）、偏度（‘s’）和/或峰度（‘k’）。 |
| entropy(M, n, N, loc=0) | (微分)随机变量的熵。 |
| expect(func, args=(M, n, N), loc=0, lb=None, ub=None, conditional=False) | 对于分布的一个参数的函数的期望值。 |
| median(M, n, N, loc=0) | 分布的中位数。 |
| mean(M, n, N, loc=0) | 分布的均值。 |
| var(M, n, N, loc=0) | 分布的方差。 |
| std(M, n, N, loc=0) | 分布的标准差。 |
| interval(confidence, M, n, N, loc=0) | 围绕中位数的等面积置信区间。 |
scipy.stats.logser
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.logser.html#scipy.stats.logser
scipy.stats.logser = <scipy.stats._discrete_distns.logser_gen object>
一个对数（Log-Series, Series）离散随机变量。
作为rv_discrete类的一个实例，logser对象继承了一组通用方法（下面详细列出），并添加了特定于这个特定分布的细节。
注意
logser的概率质量函数为：
[f(k) = - \frac{p^k}{k \log(1-p)}]
对于 (k \ge 1), (0 < p < 1)
logser以参数 (p) 为形状参数，其中 (p) 是单次成功的概率，(1-p) 是单次失败的概率。
上述概率质量函数在“标准化”形式中定义。要移动分布，请使用 loc 参数。具体地说，logser.pmf(k, p, loc) 与 logser.pmf(k - loc, p) 完全相同。
示例
>>> import numpy as np
>>> from scipy.stats import logser
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)
计算前四个矩：
>>> p = 0.6
>>> mean, var, skew, kurt = logser.stats(p, moments='mvsk')
显示概率质量函数（pmf）：
>>> x = np.arange(logser.ppf(0.01, p),
... logser.ppf(0.99, p))
>>> ax.plot(x, logser.pmf(x, p), 'bo', ms=8, label='logser pmf')
>>> ax.vlines(x, 0, logser.pmf(x, p), colors='b', lw=5, alpha=0.5)
或者，可以调用分布对象（作为函数），以固定形状和位置。这返回一个保持给定参数固定的“冻结”RV 对象。
冻结分布并显示冻结的 pmf：
>>> rv = logser(p)
>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1,
... label='frozen pmf')
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()
检查 cdf 和 ppf 的准确性：
>>> prob = logser.cdf(x, p)
>>> np.allclose(x, logser.ppf(prob, p))
True
生成随机数：
>>> r = logser.rvs(p, size=1000)
方法
| rvs(p, loc=0, size=1, random_state=None) | 随机变量。 |
|---|---|
| pmf(k, p, loc=0) | 概率质量函数。 |
| logpmf(k, p, loc=0) | 概率质量函数的对数。 |
| cdf(k, p, loc=0) | 累积分布函数。 |
| logcdf(k, p, loc=0) | 累积分布函数的对数。 |
| sf(k, p, loc=0) | 生存函数（也定义为 1 - cdf，但有时 sf 更精确）。 |
| logsf(k, p, loc=0) | 生存函数的对数。 |
| ppf(q, p, loc=0) | 百分位点函数（cdf 的逆函数 — 百分位数）。 |
| isf(q, p, loc=0) | 逆生存函数（sf 的逆函数）。 |
| stats(p, loc=0, moments=’mv’) | 均值（‘m’），方差（‘v’），偏度（‘s’），以及/或峰度（‘k’）。 |
| entropy(p, loc=0) | RV 的（微分）熵。 |
| expect(func, args=(p,), loc=0, lb=None, ub=None, conditional=False) | 期望值（对于一个参数的函数）关于分布。 |
| median(p, loc=0) | 分布的中位数。 |
| mean(p, loc=0) | 分布的均值。 |
| var(p, loc=0) | 分布的方差。 |
| std(p, loc=0) | 分布的标准偏差。 |
| interval(confidence, p, loc=0) | 置信区间，围绕中位数等面积。 |
scipy.stats.nbinom
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.nbinom.html#scipy.stats.nbinom
scipy.stats.nbinom = <scipy.stats._discrete_distns.nbinom_gen object>
负二项离散随机变量。
作为 rv_discrete 类的一个实例，nbinom 对象继承了一组通用方法（下面完整列表），并根据这个特定分布补充了细节。
另请参阅
hypergeom, binom, nhypergeom
注意事项
负二项分布描述了一系列独立同分布的伯努利试验，重复进行直到达到预定的非随机成功次数。
nbinom 的失败次数的概率质量函数是：
[f(k) = \binom{k+n-1}{n-1} p^n (1-p)^k]
对于 (k \ge 0), (0 < p \leq 1)
nbinom 接受 (n) 和 (p) 作为形状参数，其中 (n) 是成功次数，(p) 是单次成功的概率，(1-p) 是单次失败的概率。
负二项分布的另一种常见参数化是通过平均失败次数 (\mu) 来实现 (n) 次成功。平均值 (\mu) 与成功概率的关系如下
[p = \frac{n}{n + \mu}]
成功次数 (n) 也可以用“分散度”、“异质性”或“聚合度”参数 (\alpha) 来指定，它将平均值 (\mu) 与方差 (\sigma²) 关联起来，例如 (\sigma² = \mu + \alpha \mu²)。无论使用 (\alpha) 的哪种约定，
[\begin{split}p &= \frac{\mu}{\sigma²} \ n &= \frac{\mu²}{\sigma² - \mu}\end{split}]
上面的概率质量函数是以“标准化”形式定义的。要移动分布，请使用 loc 参数。具体而言，nbinom.pmf(k, n, p, loc) 等同于 nbinom.pmf(k - loc, n, p)。
示例
>>> import numpy as np
>>> from scipy.stats import nbinom
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)
计算前四个矩：
>>> n, p = 5, 0.5
>>> mean, var, skew, kurt = nbinom.stats(n, p, moments='mvsk')
显示概率质量函数 (pmf)：
>>> x = np.arange(nbinom.ppf(0.01, n, p),
... nbinom.ppf(0.99, n, p))
>>> ax.plot(x, nbinom.pmf(x, n, p), 'bo', ms=8, label='nbinom pmf')
>>> ax.vlines(x, 0, nbinom.pmf(x, n, p), colors='b', lw=5, alpha=0.5)
或者，可以调用分布对象（作为函数）来固定形状和位置。这将返回一个“冻结”的随机变量对象，保持给定的参数不变。
冻结分布并显示冻结的 pmf：
>>> rv = nbinom(n, p)
>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1,
... label='frozen pmf')
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()
检查 cdf 和 ppf 的准确性：
>>> prob = nbinom.cdf(x, n, p)
>>> np.allclose(x, nbinom.ppf(prob, n, p))
True
生成随机数：
>>> r = nbinom.rvs(n, p, size=1000)
方法
| rvs(n, p, loc=0, size=1, random_state=None) | 随机变量。 |
|---|---|
| pmf(k, n, p, loc=0) | 概率质量函数。 |
| logpmf(k, n, p, loc=0) | 概率质量函数的对数。 |
| cdf(k, n, p, loc=0) | 累积分布函数。 |
| logcdf(k, n, p, loc=0) | 累积分布函数的对数。 |
| sf(k, n, p, loc=0) | 生存函数（也定义为 1 - cdf，但sf有时更精确）。 |
| logsf(k, n, p, loc=0) | 生存函数的对数。 |
| ppf(q, n, p, loc=0) | 百分位点函数（cdf的逆函数，即百分位数）。 |
| isf(q, n, p, loc=0) | 逆生存函数（sf的逆函数）。 |
| stats(n, p, loc=0, moments=’mv’) | 均值（‘m’）、方差（‘v’）、偏度（‘s’）和/或峰度（‘k’）。 |
| entropy(n, p, loc=0) | 随机变量的（微分）熵。 |
| expect(func, args=(n, p), loc=0, lb=None, ub=None, conditional=False) | 期望值（对于分布的一个参数的函数）。 |
| median(n, p, loc=0) | 分布的中位数。 |
| mean(n, p, loc=0) | 分布的均值。 |
| var(n, p, loc=0) | 分布的方差。 |
| std(n, p, loc=0) | 分布的标准差。 |
| interval(confidence, n, p, loc=0) | 置信区间，围绕中位数有相等的区域。 |
scipy.stats.nchypergeom_fisher
scipy.stats.nchypergeom_fisher = <scipy.stats._discrete_distns.nchypergeom_fisher_gen object>
Fisher 的非中心超几何离散随机变量。
Fisher 的非中心超几何分布模型从箱中抽取两种类型的物体。 M 是总物体数， n 是类型 I 物体的数量， odds 是赔率比：当每种类型只有一个物体时选择类型 I 物体而不是类型 II 物体的赔率。随机变量表示从箱子中一把抓取物体后抽取的类型 I 物体数量，事后发现我们抓取了 N 个物体。
作为 rv_discrete 类的一个实例，nchypergeom_fisher 对象继承了该类的一系列通用方法（下面列出了完整列表），并完成了这些方法与该特定分布的详细信息。
参见
nchypergeom_wallenius, hypergeom, nhypergeom
注释
让数学符号 (N), (n), 和 (M) 分别对应上述定义的参数 N, n, 和 M。
概率质量函数定义为
[p(x; M, n, N, \omega) = \frac{\binom{n}{x}\binom{M - n}{N-x}\omega^x}{P_0},]
对于 (x \in [x_l, x_u]), (M \in {\mathbb N}), (n \in [0, M]), (N \in [0, M]), (\omega > 0), 其中 (x_l = \max(0, N - (M - n))), (x_u = \min(N, n)),
[P_0 = \sum_{y=x_l}^{x_u} \binom{n}{y}\binom{M - n}{N-y}\omega^y,]
并且二项式系数定义为
[\binom{n}{k} \equiv \frac{n!}{k! (n - k)!}.]
nchypergeom_fisher 使用 Agner Fog 的 BiasedUrn 包，并在 SciPy 许可下分发。
用于表示形状参数 (N, n, 和 M) 的符号并非普遍接受；选择这些符号是为了与 hypergeom 保持一致。
请注意，Fisher 的非中心超几何分布与 Wallenius 的非中心超几何分布不同，Wallenius 模型从箱子中逐个抽取预定数量的 N 物体。然而，当赔率比为单位时，两个分布都归结为普通超几何分布。
上述概率质量函数以“标准化”形式定义。要移动分布，请使用 loc 参数。具体来说，nchypergeom_fisher.pmf(k, M, n, N, odds, loc) 与 nchypergeom_fisher.pmf(k - loc, M, n, N, odds) 是完全等价的。
参考文献
[1]
阿格内尔·福格，《有偏抽奖理论》。cran.r-project.org/web/packages/BiasedUrn/vignettes/UrnTheory.pdf
[2]
“费舍尔的非中心超几何分布”，维基百科，en.wikipedia.org/wiki/Fisher’s_noncentral_hypergeometric_distribution
示例
>>> import numpy as np
>>> from scipy.stats import nchypergeom_fisher
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)
计算前四个时刻：
>>> M, n, N, odds = 140, 80, 60, 0.5
>>> mean, var, skew, kurt = nchypergeom_fisher.stats(M, n, N, odds, moments='mvsk')
显示概率质量函数（pmf）：
>>> x = np.arange(nchypergeom_fisher.ppf(0.01, M, n, N, odds),
... nchypergeom_fisher.ppf(0.99, M, n, N, odds))
>>> ax.plot(x, nchypergeom_fisher.pmf(x, M, n, N, odds), 'bo', ms=8, label='nchypergeom_fisher pmf')
>>> ax.vlines(x, 0, nchypergeom_fisher.pmf(x, M, n, N, odds), colors='b', lw=5, alpha=0.5)
或者，可以调用分布对象（作为函数）以固定形状和位置。这将返回一个“冻结”的随机变量对象，保持给定的参数不变。
冻结分布并显示冻结的 pmf：
>>> rv = nchypergeom_fisher(M, n, N, odds)
>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1,
... label='frozen pmf')
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()
检查 cdf 和 ppf 的准确性：
>>> prob = nchypergeom_fisher.cdf(x, M, n, N, odds)
>>> np.allclose(x, nchypergeom_fisher.ppf(prob, M, n, N, odds))
True
生成随机数：
>>> r = nchypergeom_fisher.rvs(M, n, N, odds, size=1000)
方法
| rvs(M, n, N, odds, loc=0, size=1, random_state=None) | 随机变量。 |
|---|---|
| pmf(k, M, n, N, odds, loc=0) | 概率质量函数。 |
| logpmf(k, M, n, N, odds, loc=0) | 概率质量函数的对数。 |
| cdf(k, M, n, N, odds, loc=0) | 累积分布函数。 |
| logcdf(k, M, n, N, odds, loc=0) | 累积分布函数的对数。 |
| sf(k, M, n, N, odds, loc=0) | 生存函数（也被定义为 1 - cdf，但 sf 有时更精确）。 |
| logsf(k, M, n, N, odds, loc=0) | 生存函数的对数。 |
| ppf(q, M, n, N, odds, loc=0) | 百分点函数（cdf 的反函数 — 百分位数）。 |
| isf(q, M, n, N, odds, loc=0) | 生存函数的反函数（sf的反函数）。 |
| stats(M, n, N, odds, loc=0, moments=’mv’) | 均值（‘m’）、方差（‘v’）、偏度（‘s’）和/或峰度（‘k’）。 |
| entropy(M, n, N, odds, loc=0) | 随机变量的（微分）熵。 |
| expect(func, args=(M, n, N, odds), loc=0, lb=None, ub=None, conditional=False) | 对于分布的函数（一个参数）的期望值。 |
| median(M, n, N, odds, loc=0) | 分布的中位数。 |
| mean(M, n, N, odds, loc=0) | 分布的均值。 |
| var(M, n, N, odds, loc=0) | 分布的方差。 |
| std(M, n, N, odds, loc=0) | 分布的标准差。 |
| interval(confidence, M, n, N, odds, loc=0) | 周围面积相等的置信区间，围绕中位数。 |
scipy.stats.nchypergeom_wallenius
scipy.stats.nchypergeom_wallenius = <scipy.stats._discrete_distns.nchypergeom_wallenius_gen object>
Wallenius'非中心超几何离散随机变量。
Wallenius'非中心超几何分布模型从一个箱子中抽取两种类型的对象。M是对象的总数，n是第一类型对象的数量，odds是赔率比：当每种类型只有一个对象时，选择第一类型对象而不是第二类型对象的比率。随机变量表示如果我们从一个箱子中逐个抽取预定的N个对象，则抽取的第一类型对象的数量。
作为rv_discrete类的一个实例，nchypergeom_wallenius对象从中继承了一系列通用方法（下面详细列出），并根据这一特定分布完善了它们的细节。
参见
nchypergeom_fisher，hypergeom，nhypergeom
注意事项
让数学符号(N)，(n)和(M)分别对应于上述定义的参数N，n和M。
概率质量函数定义为
[p(x; N, n, M) = \binom{n}{x} \binom{M - n}{N-x} \int_0¹ \left(1-t{\omega/D}\right)x\left(1-t{1/D}\right) dt]
对于(x \in [x_l, x_u])，(M \in {\mathbb N})，(n \in [0, M])，(N \in [0, M])，(\omega > 0)，其中(x_l = \max(0, N - (M - n)))，(x_u = \min(N, n))，
[D = \omega(n - x) + ((M - n)-(N-x)),]
和二项式系数定义为
[\binom{n}{k} \equiv \frac{n!}{k! (n - k)!}.]
nchypergeom_wallenius使用 Agner Fog 的 BiasedUrn 包，根据 SciPy 的许可分发。
用于表示形状参数（N，n和M）的符号并不是普遍接受的；它们被选择是为了与hypergeom保持一致。
请注意，Wallenius'非中心超几何分布与 Fisher's 非中心超几何分布不同，后者模拟一次从箱子中抽取少量对象，后来发现抽取了N个对象。然而，当赔率比为 1 时，这两个分布都会减少到普通超几何分布。
上述概率质量函数以“标准化”形式定义。要移动分布，请使用 loc 参数。具体来说，nchypergeom_wallenius.pmf(k, M, n, N, odds, loc) 与 nchypergeom_wallenius.pmf(k - loc, M, n, N, odds) 是完全等价的。
参考文献
[1]
Agner Fog，“偏倚球理论”。cran.r-project.org/web/packages/BiasedUrn/vignettes/UrnTheory.pdf
[2]
“瓦列尼乌斯非中心超几何分布”，维基百科，en.wikipedia.org/wiki/Wallenius’_noncentral_hypergeometric_distribution
示例
>>> import numpy as np
>>> from scipy.stats import nchypergeom_wallenius
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)
计算前四个时刻：
>>> M, n, N, odds = 140, 80, 60, 0.5
>>> mean, var, skew, kurt = nchypergeom_wallenius.stats(M, n, N, odds, moments='mvsk')
显示概率质量函数（pmf）：
>>> x = np.arange(nchypergeom_wallenius.ppf(0.01, M, n, N, odds),
... nchypergeom_wallenius.ppf(0.99, M, n, N, odds))
>>> ax.plot(x, nchypergeom_wallenius.pmf(x, M, n, N, odds), 'bo', ms=8, label='nchypergeom_wallenius pmf')
>>> ax.vlines(x, 0, nchypergeom_wallenius.pmf(x, M, n, N, odds), colors='b', lw=5, alpha=0.5)
或者，可以调用分布对象（作为函数）以固定形状和位置。这将返回一个保持给定参数固定的“冻结”RV 对象。
冻结分布并显示冻结的 pmf：
>>> rv = nchypergeom_wallenius(M, n, N, odds)
>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1,
... label='frozen pmf')
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()
检查cdf和ppf的准确性：
>>> prob = nchypergeom_wallenius.cdf(x, M, n, N, odds)
>>> np.allclose(x, nchypergeom_wallenius.ppf(prob, M, n, N, odds))
True
生成随机数：
>>> r = nchypergeom_wallenius.rvs(M, n, N, odds, size=1000)
方法
| rvs(M, n, N, odds, loc=0, size=1, random_state=None) | 随机变量。 |
|---|---|
| pmf(k, M, n, N, odds, loc=0) | 概率质量函数。 |
| logpmf(k, M, n, N, odds, loc=0) | 概率质量函数的对数。 |
| cdf(k, M, n, N, odds, loc=0) | 累积分布函数。 |
| logcdf(k, M, n, N, odds, loc=0) | 累积分布函数的对数。 |
| sf(k, M, n, N, odds, loc=0) | 生存函数（也定义为 1 - cdf，但 sf 有时更精确）。 |
| logsf(k, M, n, N, odds, loc=0) | 生存函数的对数。 |
| ppf(q, M, n, N, odds, loc=0) | 百分点函数（cdf的逆函数 — 百分位数）。 |
| isf(q, M, n, N, odds, loc=0) | 逆生存函数（sf的逆函数）。 |
| stats(M, n, N, odds, loc=0, moments=’mv’) | 均值（‘m’）、方差（‘v’）、偏度（‘s’）和/或峰度（‘k’）。 |
| entropy(M, n, N, odds, loc=0) | RV 的（微分）熵。 |
| expect(func, args=(M, n, N, odds), loc=0, lb=None, ub=None, conditional=False) | 关于分布的函数（单参数）的期望值。 |
| median(M, n, N, odds, loc=0) | 分布的中位数。 |
| mean(M, n, N, odds, loc=0) | 分布的均值。 |
| var(M, n, N, odds, loc=0) | 分布的方差。 |
| std(M, n, N, odds, loc=0) | 分布的标准差。 |
| interval(confidence, M, n, N, odds, loc=0) | 以中位数为中心的等面积置信区间。 |
scipy.stats.nhypergeom
scipy.stats.nhypergeom = <scipy.stats._discrete_distns.nhypergeom_gen object>
负超几何离散随机变量。
考虑一个包含(M)个球的盒子：(n)个红球和(M-n)个蓝球。我们从盒子中随机抽取球，一次一个，且不放回，直到我们选出(r)个蓝球。nhypergeom是我们选出的红球数(k)的分布。
作为rv_discrete类的一个实例，nhypergeom对象从中继承了一组通用方法（请参阅下文完整列表），并针对此特定分布提供了详细信息。
另请参阅
hypergeom，binom，nbinom
笔记
用于表示形状参数（M、n和r）的符号在各地并非普遍接受。请参阅示例以了解此处使用的定义。
概率质量函数定义如下，
[f(k; M, n, r) = \frac{{{k+r-1}\choose{k}}{{M-r-k}\choose{n-k}}} {{M \choose n}}]
对于(k \in [0, n])，(n \in [0, M])，(r \in [0, M-n])，二项式系数为：
[\binom{n}{k} \equiv \frac{n!}{k! (n - k)!}.]
它等同于观察(k)个成功在(k+r-1)个样本中，其中第(k+r)个样本是失败。前者可以建模为超几何分布。后者的概率只是剩余失败数(M-n-(r-1))除以剩余总体大小(M-(k+r-1))。这种关系可以表示为：
[NHG(k;M,n,r) = HG(k;M,n,k+r-1)\frac{(M-n-(r-1))}{(M-(k+r-1))}]
其中(NHG)是负超几何分布的概率质量函数（PMF），而(HG)是超几何分布的 PMF。
上述概率质量函数以“标准化”形式定义。要移动分布，请使用loc参数。具体而言，nhypergeom.pmf(k, M, n, r, loc)等效于nhypergeom.pmf(k - loc, M, n, r)。
参考资料
[1]
负超几何分布在维基百科上的介绍：en.wikipedia.org/wiki/Negative_hypergeometric_distribution
[2]
来自Negative Hypergeometric Distribution（负超几何分布）
示例
>>> import numpy as np
>>> from scipy.stats import nhypergeom
>>> import matplotlib.pyplot as plt
假设我们有一组 20 只动物，其中 7 只是狗。那么如果我们想知道在一个样本中找到给定数量的狗（成功）在恰好 12 只非狗（失败）的样本中的概率，我们可以初始化一个冻结的分布并绘制概率质量函数：
>>> M, n, r = [20, 7, 12]
>>> rv = nhypergeom(M, n, r)
>>> x = np.arange(0, n+2)
>>> pmf_dogs = rv.pmf(x)
>>> fig = plt.figure()
>>> ax = fig.add_subplot(111)
>>> ax.plot(x, pmf_dogs, 'bo')
>>> ax.vlines(x, 0, pmf_dogs, lw=2)
>>> ax.set_xlabel('# of dogs in our group with given 12 failures')
>>> ax.set_ylabel('nhypergeom PMF')
>>> plt.show()
除了使用冻结分布外，我们也可以直接使用nhypergeom的方法。例如，要获取概率质量函数，使用：
>>> prb = nhypergeom.pmf(x, M, n, r)
要生成随机数：
>>> R = nhypergeom.rvs(M, n, r, size=10)
要验证hypergeom和nhypergeom之间的关系，请使用：
>>> from scipy.stats import hypergeom, nhypergeom
>>> M, n, r = 45, 13, 8
>>> k = 6
>>> nhypergeom.pmf(k, M, n, r)
0.06180776620271643
>>> hypergeom.pmf(k, M, n, k+r-1) * (M - n - (r-1)) / (M - (k+r-1))
0.06180776620271644
方法
| rvs(M, n, r, loc=0, size=1, random_state=None) | 随机变量。 |
|---|---|
| pmf(k, M, n, r, loc=0) | 概率质量函数。 |
| logpmf(k, M, n, r, loc=0) | 概率质量函数的对数。 |
| cdf(k, M, n, r, loc=0) | 累积分布函数。 |
| logcdf(k, M, n, r, loc=0) | 累积分布函数的对数。 |
| sf(k, M, n, r, loc=0) | 生存函数（也定义为1 - cdf，但sf有时更精确）。 |
| logsf(k, M, n, r, loc=0) | 生存函数的对数。 |
| ppf(q, M, n, r, loc=0) | 百分点函数（cdf的逆函数 — 百分位数）。 |
| isf(q, M, n, r, loc=0) | 逆生存函数（sf的逆函数）。 |
| stats(M, n, r, loc=0, moments=’mv’) | 均值（‘m’）、方差（‘v’）、偏度（‘s’）、峰度（‘k’）。 |
| entropy(M, n, r, loc=0) | 随机变量的（微分）熵。 |
| expect(func, args=(M, n, r), loc=0, lb=None, ub=None, conditional=False) | 对于分布的函数（一个参数的）的期望值。 |
| median(M, n, r, loc=0) | 分布的中位数。 |
| mean(M, n, r, loc=0) | 分布的均值。 |
| var(M, n, r, loc=0) | 分布的方差。 |
| std(M, n, r, loc=0) | 分布的标准偏差。 |
| interval(confidence, M, n, r, loc=0) | 中位数周围面积相等的置信区间。 |
scipy.stats.planck
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.planck.html#scipy.stats.planck
scipy.stats.planck = <scipy.stats._discrete_distns.planck_gen object>
Planck 离散指数随机变量。
作为 rv_discrete 类的一个实例，planck 对象继承了一组通用方法（下面详细列出），并根据此特定分布进行了补充。
另请参阅
geom
注释
planck 的概率质量函数如下：
[f(k) = (1-\exp(-\lambda)) \exp(-\lambda k)]
对于 (k \ge 0) 和 (\lambda > 0)。
planck 将 (\lambda) 视为形状参数。Planck 分布可以写成以 p = 1 - \exp(-\lambda) 为参数的几何分布（geom），并且以 loc = -1 进行了平移。
上述概率质量函数定义为“标准化”形式。使用 loc 参数进行分布偏移。具体而言，planck.pmf(k, lambda_, loc) 与 planck.pmf(k - loc, lambda_) 完全等价。
示例
>>> import numpy as np
>>> from scipy.stats import planck
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)
计算前四个矩：
>>> lambda_ = 0.51
>>> mean, var, skew, kurt = planck.stats(lambda_, moments='mvsk')
显示概率质量函数（pmf）：
>>> x = np.arange(planck.ppf(0.01, lambda_),
... planck.ppf(0.99, lambda_))
>>> ax.plot(x, planck.pmf(x, lambda_), 'bo', ms=8, label='planck pmf')
>>> ax.vlines(x, 0, planck.pmf(x, lambda_), colors='b', lw=5, alpha=0.5)
或者，可以调用分布对象（作为函数）以固定形状和位置。这将返回一个“冻结”的 RV 对象，保存给定的参数。
冻结分布并显示冻结的 pmf：
>>> rv = planck(lambda_)
>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1,
... label='frozen pmf')
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()
检查 cdf 和 ppf 的准确性：
>>> prob = planck.cdf(x, lambda_)
>>> np.allclose(x, planck.ppf(prob, lambda_))
True
生成随机数：
>>> r = planck.rvs(lambda_, size=1000)
方法
| rvs(lambda_, loc=0, size=1, random_state=None) | 随机变量。 |
|---|---|
| pmf(k, lambda_, loc=0) | 概率质量函数。 |
| logpmf(k, lambda_, loc=0) | 概率质量函数的对数。 |
| cdf(k, lambda_, loc=0) | 累积分布函数。 |
| logcdf(k, lambda_, loc=0) | 累积分布函数的对数。 |
| sf(k, lambda_, loc=0) | 生存函数（也定义为 1 - cdf，但 sf 有时更精确）。 |
| logsf(k, lambda_, loc=0) | 生存函数的对数。 |
| ppf(q, lambda_, loc=0) | 百分点函数（cdf 的反函数 — 百分位数）。 |
| isf(q, lambda_, loc=0) | 生存函数的反函数（sf 的反函数）。 |
| stats(lambda_, loc=0, moments=’mv’) | 均值（‘m’）、方差（‘v’）、偏度（‘s’）和/或峰度（‘k’）。 |
| entropy(lambda_, loc=0) | 随机变量的（微分）熵。 |
| expect(func, args=(lambda_,), loc=0, lb=None, ub=None, conditional=False) | 期望值，关于分布的一个函数（一个参数）。 |
| median(lambda_, loc=0) | 分布的中位数。 |
| mean(lambda_, loc=0) | 分布的均值。 |
| var(lambda_, loc=0) | 分布的方差。 |
| std(lambda_, loc=0) | 分布的标准差。 |
| interval(confidence, lambda_, loc=0) | 置信区间，围绕中位数具有相等面积。 |
scipy.stats.poisson
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.poisson.html#scipy.stats.poisson
scipy.stats.poisson = <scipy.stats._discrete_distns.poisson_gen object>
一个泊松离散随机变量。
作为 rv_discrete 类的一个实例，poisson 对象继承了一系列通用方法（请参见下面的完整列表），并用这个特定分布的细节补充完整。
注意事项
poisson 的概率质量函数为：
[f(k) = \exp(-\mu) \frac{\mu^k}{k!}]
对于 (k \ge 0)。
poisson 以 (\mu \geq 0) 作为形状参数。当 (\mu = 0) 时，pmf 方法在分位点 (k = 0) 处返回 1.0。
上述概率质量函数以“标准化”形式定义。使用 loc 参数来进行分布的移动。具体来说，poisson.pmf(k, mu, loc) 等同于 poisson.pmf(k - loc, mu)。
示例
>>> import numpy as np
>>> from scipy.stats import poisson
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)
计算前四个矩：
>>> mu = 0.6
>>> mean, var, skew, kurt = poisson.stats(mu, moments='mvsk')
展示概率质量函数 (pmf):
>>> x = np.arange(poisson.ppf(0.01, mu),
... poisson.ppf(0.99, mu))
>>> ax.plot(x, poisson.pmf(x, mu), 'bo', ms=8, label='poisson pmf')
>>> ax.vlines(x, 0, poisson.pmf(x, mu), colors='b', lw=5, alpha=0.5)
或者，可以像调用函数一样使用分布对象来固定形状和位置。这将返回一个固定了给定参数的“冻结”随机变量对象。
冻结分布并展示冻结的 pmf：
>>> rv = poisson(mu)
>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1,
... label='frozen pmf')
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()
检查 cdf 和 ppf 的准确性：
>>> prob = poisson.cdf(x, mu)
>>> np.allclose(x, poisson.ppf(prob, mu))
True
生成随机数：
>>> r = poisson.rvs(mu, size=1000)
方法
| rvs(mu, loc=0, size=1, random_state=None) | 随机变量。 |
|---|---|
| pmf(k, mu, loc=0) | 概率质量函数。 |
| logpmf(k, mu, loc=0) | 概率质量函数的对数。 |
| cdf(k, mu, loc=0) | 累积分布函数。 |
| logcdf(k, mu, loc=0) | 累积分布函数的对数。 |
| sf(k, mu, loc=0) | 生存函数（也定义为 1 - cdf，但 sf 有时更准确）。 |
| logsf(k, mu, loc=0) | 生存函数的对数。 |
| ppf(q, mu, loc=0) | 百分位点函数（cdf 的逆 — 百分位数）。 |
| isf(q, mu, loc=0) | 逆生存函数（sf 的逆）。 |
| stats(mu, loc=0, moments=’mv’) | 均值（‘m’）、方差（‘v’）、偏度（‘s’）、及/或峰度（‘k’）。 |
| entropy(mu, loc=0) | 随机变量的（微分）熵。 |
| expect(func, args=(mu,), loc=0, lb=None, ub=None, conditional=False) | 期望值函数（具有一个参数的函数）相对于分布。 |
| median(mu, loc=0) | 分布的中位数。 |
| mean(mu, loc=0) | 分布的均值。 |
| var(mu, loc=0) | 分布的方差。 |
| std(mu, loc=0) | 分布的标准差。 |
| interval(confidence, mu, loc=0) | 中位数周围具有相等面积的置信区间。 |
scipy.stats.randint
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.randint.html#scipy.stats.randint
scipy.stats.randint = <scipy.stats._discrete_distns.randint_gen object>
一个均匀离散随机变量。
作为 rv_discrete 类的一个实例，randint 对象继承了一些通用方法（见下面的完整列表），并且根据具体分布补充了特定细节。
注意
randint 的概率质量函数为：
[f(k) = \frac{1}{\texttt{high} - \texttt{low}}]
对于 (k \in {\texttt{low}, \dots, \texttt{high} - 1})。
randint 接受 low 和 high 作为形状参数。
上述概率质量函数定义为“标准化”形式。要转换分布，请使用 loc 参数。具体而言，randint.pmf(k, low, high, loc) 与 randint.pmf(k - loc, low, high) 完全等价。
示例
>>> import numpy as np
>>> from scipy.stats import randint
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)
计算前四个时刻：
>>> low, high = 7, 31
>>> mean, var, skew, kurt = randint.stats(low, high, moments='mvsk')
显示概率质量函数 (pmf)：
>>> x = np.arange(low - 5, high + 5)
>>> ax.plot(x, randint.pmf(x, low, high), 'bo', ms=8, label='randint pmf')
>>> ax.vlines(x, 0, randint.pmf(x, low, high), colors='b', lw=5, alpha=0.5)
或者，可以调用分布对象（作为函数）来固定形状和位置。这将返回一个“冻结”的随机变量对象，保持给定参数不变。
冻结分布并显示冻结的 pmf：
>>> rv = randint(low, high)
>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-',
... lw=1, label='frozen pmf')
>>> ax.legend(loc='lower center')
>>> plt.show()
检查累积分布函数（cdf）与其逆函数百分点函数（ppf）之间的关系：
>>> q = np.arange(low, high)
>>> p = randint.cdf(q, low, high)
>>> np.allclose(q, randint.ppf(p, low, high))
True
生成随机数：
>>> r = randint.rvs(low, high, size=1000)
方法
| rvs(low, high, loc=0, size=1, random_state=None) | 随机变量。 |
|---|---|
| pmf(k, low, high, loc=0) | 概率质量函数。 |
| logpmf(k, low, high, loc=0) | 概率质量函数的对数。 |
| cdf(k, low, high, loc=0) | 累积分布函数。 |
| logcdf(k, low, high, loc=0) | 累积分布函数的对数。 |
| sf(k, low, high, loc=0) | 生存函数（也定义为 1 - cdf，但 sf 有时更精确）。 |
| logsf(k, low, high, loc=0) | 生存函数的对数。 |
| ppf(q, low, high, loc=0) | 百分点函数（cdf 的逆函数，即百分位数）。 |
| isf(q, low, high, loc=0) | 逆生存函数（sf 的逆函数）。 |
| stats(low, high, loc=0, moments=’mv’) | 均值（‘m’）、方差（‘v’）、偏度（‘s’）、峰度（‘k’）。 |
| entropy(low, high, loc=0) | 随机变量的（微分）熵。 |
| expect(func, args=(low, high), loc=0, lb=None, ub=None, conditional=False) | 计算函数（一个参数）相对于分布的期望值。 |
| median(low, high, loc=0) | 分布的中位数。 |
| mean(low, high, loc=0) | 分布的均值。 |
| var(low, high, loc=0) | 分布的方差。 |
| std(low, high, loc=0) | 分布的标准差。 |
| interval(confidence, low, high, loc=0) | 置信区间，中位数周围面积相等。 |
scipy.stats.skellam
原文链接：scipy.stats.skellam
scipy.stats.skellam = <scipy.stats._discrete_distns.skellam_gen object>
一个斯凯拉姆离散随机变量。
作为 rv_discrete 类的一个实例，skellam 对象继承了一系列通用方法（请参阅下面的完整列表），并针对这个特定分布补充了特定细节。
注释
两个相关或不相关泊松随机变量差的概率分布。
设 (k_1) 和 (k_2) 是两个期望值分别为 (\lambda_1) 和 (\lambda_2) 的泊松分布随机变量。那么，(k_1 - k_2) 符合参数为 (\mu_1 = \lambda_1 - \rho \sqrt{\lambda_1 \lambda_2}) 和 (\mu_2 = \lambda_2 - \rho \sqrt{\lambda_1 \lambda_2}) 的斯凯拉姆分布，其中 (\rho) 是 (k_1) 和 (k_2) 之间的相关系数。如果两个泊松分布随机变量是独立的，则 (\rho = 0)。
参数 (\mu_1) 和 (\mu_2) 必须严格为正数。
详细信息请参见：斯凯拉姆分布
skellam 以 (\mu_1) 和 (\mu_2) 作为形状参数。
上述概率质量函数以“标准化”形式定义。使用 loc 参数来改变分布位置。具体而言，skellam.pmf(k, mu1, mu2, loc) 与 skellam.pmf(k - loc, mu1, mu2) 完全等价。
示例
>>> import numpy as np
>>> from scipy.stats import skellam
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)
计算前四个矩：
>>> mu1, mu2 = 15, 8
>>> mean, var, skew, kurt = skellam.stats(mu1, mu2, moments='mvsk')
显示概率质量函数（pmf）：
>>> x = np.arange(skellam.ppf(0.01, mu1, mu2),
... skellam.ppf(0.99, mu1, mu2))
>>> ax.plot(x, skellam.pmf(x, mu1, mu2), 'bo', ms=8, label='skellam pmf')
>>> ax.vlines(x, 0, skellam.pmf(x, mu1, mu2), colors='b', lw=5, alpha=0.5)
或者，可以调用分布对象（作为函数）以固定形状和位置。这将返回一个持有给定参数固定的“冻结”随机变量对象。
冻结分布并显示冻结的 pmf：
>>> rv = skellam(mu1, mu2)
>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1,
... label='frozen pmf')
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()
检查 cdf 和 ppf 的准确性：
>>> prob = skellam.cdf(x, mu1, mu2)
>>> np.allclose(x, skellam.ppf(prob, mu1, mu2))
True
生成随机数：
>>> r = skellam.rvs(mu1, mu2, size=1000)
方法
| rvs(mu1, mu2, loc=0, size=1, random_state=None) | 随机变量。 |
|---|---|
| pmf(k, mu1, mu2, loc=0) | 概率质量函数。 |
| logpmf(k, mu1, mu2, loc=0) | 概率质量函数的对数。 |
| cdf(k, mu1, mu2, loc=0) | 累积分布函数。 |
| logcdf(k, mu1, mu2, loc=0) | 累积分布函数的对数。 |
| sf(k, mu1, mu2, loc=0) | 生存函数（也定义为 1 - cdf，但 sf 有时更精确）。 |
| logsf(k, mu1, mu2, loc=0) | 生存函数的对数。 |
| ppf(q, mu1, mu2, loc=0) | 百分点函数（cdf 的反函数 — 百分位数）。 |
| isf(q, mu1, mu2, loc=0) | 逆生存函数（sf 的反函数）。 |
| stats(mu1, mu2, loc=0, moments=’mv’) | 均值（‘m’）、方差（‘v’）、偏度（‘s’）和/或峰度（‘k’）。 |
| entropy(mu1, mu2, loc=0) | 随机变量的（微分）熵。 |
| expect(func, args=(mu1, mu2), loc=0, lb=None, ub=None, conditional=False) | 对分布的一个参数函数（一个参数）的期望值。 |
| median(mu1, mu2, loc=0) | 分布的中位数。 |
| mean(mu1, mu2, loc=0) | 分布的均值。 |
| var(mu1, mu2, loc=0) | 分布的方差。 |
| std(mu1, mu2, loc=0) | 分布的标准差。 |
| interval(confidence, mu1, mu2, loc=0) | 中位数周围等面积置信区间。 |
scipy.stats.yulesimon
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.yulesimon.html#scipy.stats.yulesimon
scipy.stats.yulesimon = <scipy.stats._discrete_distns.yulesimon_gen object>
Yule-Simon 离散随机变量。
作为 rv_discrete 类的一个实例，yulesimon 对象继承了一系列通用方法（下面列出完整列表），并通过特定于此特定分布的细节完善它们。
注释
yulesimon 的概率质量函数如下：
[f(k) = \alpha B(k, \alpha+1)]
对于 (k=1,2,3,...)，其中 (\alpha>0)。这里 (B) 是 scipy.special.beta 函数。
随机变量的采样基于[1]第 553 页第 6.3 节。我们的符号映射到通过 (\alpha=a-1) 引用的逻辑。
详细信息请参见维基百科条目[2]。
参考文献
[1]
Devroye, Luc. “非均匀随机变量生成”，（1986 年）斯普林格出版社，纽约。
[2]
en.wikipedia.org/wiki/Yule-Simon_distribution
上述概率质量函数定义为“标准化”形式。要移动分布，请使用 loc 参数。具体地说，yulesimon.pmf(k, alpha, loc) 与 yulesimon.pmf(k - loc, alpha) 完全等效。
示例
>>> import numpy as np
>>> from scipy.stats import yulesimon
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)
计算前四个时刻：
>>> alpha = 11
>>> mean, var, skew, kurt = yulesimon.stats(alpha, moments='mvsk')
显示概率质量函数 (pmf)：
>>> x = np.arange(yulesimon.ppf(0.01, alpha),
... yulesimon.ppf(0.99, alpha))
>>> ax.plot(x, yulesimon.pmf(x, alpha), 'bo', ms=8, label='yulesimon pmf')
>>> ax.vlines(x, 0, yulesimon.pmf(x, alpha), colors='b', lw=5, alpha=0.5)
或者，可以调用分布对象（作为函数）以固定形状和位置。这将返回一个“冻结”的 RV 对象，保持给定参数不变。
冻结分布并显示冻结的 pmf：
>>> rv = yulesimon(alpha)
>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1,
... label='frozen pmf')
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()
检查 cdf 和 ppf 的准确性：
>>> prob = yulesimon.cdf(x, alpha)
>>> np.allclose(x, yulesimon.ppf(prob, alpha))
True
生成随机数：
>>> r = yulesimon.rvs(alpha, size=1000)
方法
| rvs(alpha, loc=0, size=1, random_state=None) | 随机变量。 |
|---|---|
| pmf(k, alpha, loc=0) | 概率质量函数。 |
| logpmf(k, alpha, loc=0) | 概率质量函数的对数。 |
| cdf(k, alpha, loc=0) | 累积分布函数。 |
| logcdf(k, alpha, loc=0) | 累积分布函数的对数。 |
| sf(k, alpha, loc=0) | 生存函数（也定义为 1 - cdf，但 sf 有时更精确）。 |
| logsf(k, alpha, loc=0) | 生存函数的对数。 |
| ppf(q, alpha, loc=0) | 百分位点函数（cdf 的反函数 — 百分位数）。 |
| isf(q, alpha, loc=0) | 逆生存函数（sf 的逆）。 |
| stats(alpha, loc=0, moments=’mv’) | 均值（‘m’）、方差（‘v’）、偏度（‘s’）、峰度（‘k’）。 |
| entropy(alpha, loc=0) | RV 的（微分）熵。 |
| expect(func, args=(alpha,), loc=0, lb=None, ub=None, conditional=False) | 对分布中一个（一元）函数的期望值。 |
| median(alpha, loc=0) | 分布的中位数。 |
| mean(alpha, loc=0) | 分布的均值。 |
| var(alpha, loc=0) | 分布的方差。 |
| std(alpha, loc=0) | 分布的标准差。 |
| interval(confidence, alpha, loc=0) | 置信区间，围绕中位数具有相等面积。 |
scipy.stats.zipf
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.zipf.html#scipy.stats.zipf
scipy.stats.zipf = <scipy.stats._discrete_distns.zipf_gen object>
一个 Zipf（Zeta）离散随机变量。
作为 rv_discrete 类的一个实例，zipf 对象继承了一组通用方法（下面详细列出），并补充了特定于此特定分布的细节。
另见
zipfian
注意
zipf 的概率质量函数是：
[f(k, a) = \frac{1}{\zeta(a) k^a}]
对于 (k \ge 1), (a > 1)。
zipf 将 (a > 1) 作为形状参数。(\zeta) 是黎曼 zeta 函数（scipy.special.zeta)
Zipf 分布也被称为 zeta 分布，是 Zipfian 分布的一个特例（zipfian）。
上述概率质量函数以“标准化”形式定义。要移动分布，请使用 loc 参数。具体来说，zipf.pmf(k, a, loc) 与 zipf.pmf(k - loc, a) 是完全等价的。
参考文献
[1]
“Zeta Distribution”，维基百科，en.wikipedia.org/wiki/Zeta_distribution
示例
>>> import numpy as np
>>> from scipy.stats import zipf
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)
计算前四个时刻：
>>> a = 6.5
>>> mean, var, skew, kurt = zipf.stats(a, moments='mvsk')
显示概率质量函数（pmf）：
>>> x = np.arange(zipf.ppf(0.01, a),
... zipf.ppf(0.99, a))
>>> ax.plot(x, zipf.pmf(x, a), 'bo', ms=8, label='zipf pmf')
>>> ax.vlines(x, 0, zipf.pmf(x, a), colors='b', lw=5, alpha=0.5)
或者，可以调用分布对象（作为函数）来固定形状和位置。这将返回一个“冻结”的 RV 对象，其中包含给定的参数。
冻结分布并显示冻结的 pmf：
>>> rv = zipf(a)
>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1,
... label='frozen pmf')
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()
检查 cdf 和 ppf 的准确性：
>>> prob = zipf.cdf(x, a)
>>> np.allclose(x, zipf.ppf(prob, a))
True
生成随机数：
>>> r = zipf.rvs(a, size=1000)
确认 zipf 是 zipfian 的大 n 极限。
>>> import numpy as np
>>> from scipy.stats import zipf, zipfian
>>> k = np.arange(11)
>>> np.allclose(zipf.pmf(k, a), zipfian.pmf(k, a, n=10000000))
True
方法
| rvs(a, loc=0, size=1, random_state=None) | 随机变量。 |
|---|---|
| pmf(k, a, loc=0) | 概率质量函数。 |
| logpmf(k, a, loc=0) | 概率质量函数的对数。 |
| cdf(k, a, loc=0) | 累积分布函数。 |
| logcdf(k, a, loc=0) | 累积分布函数的对数。 |
| sf(k, a, loc=0) | 生存函数（也定义为 1 - cdf，但有时 sf 更准确）。 |
| logsf(k, a, loc=0) | 生存函数的对数。 |
| ppf(q, a, loc=0) | 百分位点函数（cdf 的逆函数 —— 百分位数）。 |
| isf(q, a, loc=0) | 生存函数的逆函数（sf 的逆）。 |
| stats(a, loc=0, moments=’mv’) | 均值（‘m’）、方差（‘v’）、偏度（‘s’）、峰度（‘k’）。 |
| entropy(a, loc=0) | 随机变量的（微分）熵。 |
| expect(func, args=(a,), loc=0, lb=None, ub=None, conditional=False) | 对于给定分布的函数（一个参数）的期望值。 |
| median(a, loc=0) | 分布的中位数。 |
| mean(a, loc=0) | 分布的均值。 |
| var(a, loc=0) | 分布的方差。 |
| std(a, loc=0) | 分布的标准差。 |
| interval(confidence, a, loc=0) | 中位数周围等面积的置信区间。 |
scipy.stats.zipfian
Original text：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.zipfian.html#scipy.stats.zipfian
scipy.stats.zipfian = <scipy.stats._discrete_distns.zipfian_gen object>
A Zipfian discrete random variable.
As an instance of the rv_discrete class, zipfian object inherits from it a collection of generic methods (see below for the full list), and completes them with details specific for this particular distribution.
See also
zipf
Notes
The probability mass function for zipfian is:
[f(k, a, n) = \frac{1}{H_{n,a} k^a}]
for (k \in {1, 2, \dots, n-1, n}), (a \ge 0), (n \in {1, 2, 3, \dots}).
zipfian takes (a) and (n) as shape parameters. (H_{n,a}) is the (n)^(th) generalized harmonic number of order (a).
The Zipfian distribution reduces to the Zipf (zeta) distribution as (n \rightarrow \infty).
The probability mass function above is defined in the “standardized” form. To shift distribution use the loc parameter. Specifically, zipfian.pmf(k, a, n, loc) is identically equivalent to zipfian.pmf(k - loc, a, n).
References
[1]
“Zipf’s Law”, Wikipedia, en.wikipedia.org/wiki/Zipf’s_law
[2]
Larry Leemis, “Zipf Distribution”, Univariate Distribution Relationships. www.math.wm.edu/~leemis/chart/UDR/PDFs/Zipf.pdf
Examples
>>> import numpy as np
>>> from scipy.stats import zipfian
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots(1, 1)
Calculate the first four moments:
>>> a, n = 1.25, 10
>>> mean, var, skew, kurt = zipfian.stats(a, n, moments='mvsk')
Display the probability mass function (pmf):
>>> x = np.arange(zipfian.ppf(0.01, a, n),
... zipfian.ppf(0.99, a, n))
>>> ax.plot(x, zipfian.pmf(x, a, n), 'bo', ms=8, label='zipfian pmf')
>>> ax.vlines(x, 0, zipfian.pmf(x, a, n), colors='b', lw=5, alpha=0.5)
Alternatively, the distribution object can be called (as a function) to fix the shape and location. This returns a “frozen” RV object holding the given parameters fixed.
Freeze the distribution and display the frozen pmf:
>>> rv = zipfian(a, n)
>>> ax.vlines(x, 0, rv.pmf(x), colors='k', linestyles='-', lw=1,
... label='frozen pmf')
>>> ax.legend(loc='best', frameon=False)
>>> plt.show()
Check accuracy of cdf and ppf:
>>> prob = zipfian.cdf(x, a, n)
>>> np.allclose(x, zipfian.ppf(prob, a, n))
True
Generate random numbers:
>>> r = zipfian.rvs(a, n, size=1000)
Confirm that zipfian reduces to zipf for large n, a > 1.
>>> import numpy as np
>>> from scipy.stats import zipf, zipfian
>>> k = np.arange(11)
>>> np.allclose(zipfian.pmf(k, a=3.5, n=10000000), zipf.pmf(k, a=3.5))
True
Methods
| rvs(a, n, loc=0, size=1, random_state=None) | 随机变量。 |
|---|---|
| pmf(k, a, n, loc=0) | 概率质量函数。 |
| logpmf(k, a, n, loc=0) | 概率质量函数的对数。 |
| cdf(k, a, n, loc=0) | 累积分布函数。 |
| logcdf(k, a, n, loc=0) | 累积分布函数的对数。 |
| sf(k, a, n, loc=0) | 生存函数（也定义为 1 - cdf，但 sf 有时更精确）。 |
| logsf(k, a, n, loc=0) | 生存函数的对数。 |
| ppf(q, a, n, loc=0) | 百分位点函数（cdf 的反函数 — 百分位数）。 |
| isf(q, a, n, loc=0) | 逆生存函数（sf 的反函数）。 |
| stats(a, n, loc=0, moments=’mv’) | 均值（‘m’），方差（‘v’），偏度（‘s’），以及/或峰度（‘k’）。 |
| entropy(a, n, loc=0) | 随机变量的（微分）熵。 |
| expect(func, args=(a, n), loc=0, lb=None, ub=None, conditional=False) | 函数（一个参数）关于分布的期望值。 |
| median(a, n, loc=0) | 分布的中位数。 |
| mean(a, n, loc=0) | 分布的均值。 |
| var(a, n, loc=0) | 分布的方差。 |
| std(a, n, loc=0) | 分布的标准差。 |
| interval(confidence, a, n, loc=0) | 置信区间，围绕中位数具有相等的区域。 |
scipy.stats.describe
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.describe.html#scipy.stats.describe
scipy.stats.describe(a, axis=0, ddof=1, bias=True, nan_policy='propagate')
计算传递数组的几个描述性统计。
参数：
a：类似于数组
输入数据。
轴：整数或 None，可选
计算统计量的轴。默认为 0。如果为 None，则在整个数组a上计算。
ddof：整数，可选
自由度增量（仅适用于方差）。默认为 1。
偏差：布尔值，可选
如果为 False，则对偏度和峰度的计算进行了统计偏差校正。
nan_policy：{‘propagate’，‘raise’，‘omit’}，可选
定义输入数据包含 NaN 时的处理方式。可用选项如下（默认为‘propagate’）：
-
‘propagate’：返回 nan
-
‘raise’：抛出一个错误
-
‘omit’：执行忽略 nan 值的计算
返回：
观测数：整数或整数 ndarray
观察次数（沿着axis的数据长度）。当选择 nan_policy 为‘omit’时，每个轴切片的长度会分别计算。
minmax：ndarray 或浮点数的元组
沿给定轴的a的最小值和最大值。
均值：ndarray 或浮点数
沿给定轴的算术平均值。
方差：ndarray 或浮点数
沿给定轴的无偏方差；分母为观测次数减去 1。
偏度：ndarray 或浮点数
a沿给定轴的偏度，基于具有与观察数相等的分母的矩计算，即没有自由度校正。
峰度：ndarray 或浮点数
a沿给定轴的峰度（费舍尔）。峰度被标准化为正态分布为零。未使用任何自由度。
另请参阅
示例
>>> import numpy as np
>>> from scipy import stats
>>> a = np.arange(10)
>>> stats.describe(a)
DescribeResult(nobs=10, minmax=(0, 9), mean=4.5,
variance=9.166666666666666, skewness=0.0,
kurtosis=-1.2242424242424244)
>>> b = [[1, 2], [3, 4]]
>>> stats.describe(b)
DescribeResult(nobs=2, minmax=(array([1, 2]), array([3, 4])),
mean=array([2., 3.]), variance=array([2., 2.]),
skewness=array([0., 0.]), kurtosis=array([-2., -2.]))
scipy.stats.gmean
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.gmean.html#scipy.stats.gmean
scipy.stats.gmean(a, axis=0, dtype=None, weights=None, *, nan_policy='propagate', keepdims=False)
沿指定轴计算加权几何平均值。
与权重数组相关联的数组(a_i)的加权几何平均值是：
[\exp \left( \frac{ \sum_{i=1}^n w_i \ln a_i }{ \sum_{i=1}^n w_i } \right) , ,]
并且，在权重相等的情况下，它给出：
[\sqrt[n]{ \prod_{i=1}^n a_i } , .]
参数：
aarray_like
可转换为数组的输入数组或对象。
axisint 或 None，默认值：0
如果是 int，则是计算统计量的输入轴。输入的每个轴切片（例如行）的统计量将显示在输出的相应元素中。如果为None，则在计算统计量之前将会拉平输入。
dtypedtype，可选
在执行计算之前将输入数组强制转换为的类型。
weightsarray_like，可选
weights数组必须与a的形状广播兼容。默认为 None，即每个值的权重为 1.0。
nan_policy
定义如何处理输入的 NaN。
-
propagate: 如果在计算统计量的轴切片（例如行）中存在 NaN，则输出的相应条目将是 NaN。 -
omit: 在执行计算时将省略 NaN。如果在计算统计量的轴切片中剩余的数据不足，则输出的相应条目将为 NaN。 -
raise: 如果存在 NaN，则会引发ValueError。
keepdimsbool，默认值：False
如果设置为 True，则会将被缩减的轴保留在结果中作为具有大小为一的维度。通过此选项，结果将正确地广播到输入数组。
返回：
gmeanndarray
请参见上面的dtype参数。
另请参见
算术平均值
加权平均值
hmean
调和平均
注意
从 SciPy 1.9 开始，将np.matrix输入（不建议新代码使用）转换为np.ndarray后再执行计算。在这种情况下，输出将是适当形状的标量或np.ndarray，而不是 2D 的np.matrix。同样地，忽略掩码数组的屏蔽元素，输出将是标量或np.ndarray，而不是具有mask=False的掩码数组。
参考文献
[1]
“加权几何平均值”，维基百科，en.wikipedia.org/wiki/Weighted_geometric_mean。
[2]
Grossman, J., Grossman, M., Katz, R., “Averages: A New Approach”, Archimedes Foundation, 1983
示例
>>> from scipy.stats import gmean
>>> gmean([1, 4])
2.0
>>> gmean([1, 2, 3, 4, 5, 6, 7])
3.3800151591412964
>>> gmean([1, 4, 7], weights=[3, 1, 3])
2.80668351922014
scipy.stats.hmean
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.stats.hmean.html#scipy.stats.hmean
scipy.stats.hmean(a, axis=0, dtype=None, *, weights=None, nan_policy='propagate', keepdims=False)
计算沿指定轴的加权调和平均值。
与权重 w_i 关联的数组 a_i 的加权调和平均值为：
[\frac{ \sum_{i=1}^n w_i }{ \sum_{i=1}^n \frac{w_i}{a_i} } , ,]
并且，使用相同的权重，它给出：
[\frac{ n }{ \sum_{i=1}^n \frac{1}{a_i} } , .]
参数：
aarray_like
输入数组、掩码数组或可转换为数组的对象。
axisint 或 None，默认：0
如果是整数，则为计算统计量的输入轴。输入的每个轴切片（例如行）的统计量将显示在输出的相应元素中。如果为None，则在计算统计量之前将展平输入。
dtypedtype，可选
返回数组的类型，以及元素被求和的累加器的类型。如果未指定 dtype，则默认为 a 的 dtype，除非 a 具有小于默认平台整数的精度的整数 dtype。在这种情况下，将使用默认平台整数。
weightsarray_like，可选
权重数组可以是 1-D（在这种情况下，其长度必须与给定 axis 上的 a 的大小相同），也可以与 a 的形状相同。默认值为 None，这会使每个值的权重为 1.0。
自版本 1.9 开始。
nan_policy
定义如何处理输入的 NaN。
-
propagate：如果在计算统计量的轴切片（例如行）中存在 NaN，则输出的相应条目将为 NaN。 -
omit：在执行计算时，将省略 NaN。如果在计算统计量的轴切片中剩余的数据不足，则输出的相应条目将为 NaN。 -
raise：如果存在 NaN，则会引发ValueError。
keepdimsbool，默认：False
如果设置为 True，则减少的轴将作为尺寸为一的维度保留在结果中。使用此选项，结果将正确地广播到输入数组。
返回：
hmeanndarray
参见上面的 dtype 参数。
另请参阅
算术平均值
加权平均值
gmean
几何平均值
注意
默认情况下，调和平均值在输入数组的单个维度上计算，axis=0，或者如果 axis=None，则在数组的所有值上计算。对于整数输入，使用 float64 的中间和返回值。
从 SciPy 1.9 开始，np.matrix 输入（不建议在新代码中使用）在执行计算之前会转换为np.ndarray。在这种情况下，输出将是一个标量或适当形状的np.ndarray，而不是 2D 的np.matrix。类似地，虽然屏蔽数组的屏蔽元素被忽略，输出将是一个标量或np.ndarray，而不是带有mask=False的屏蔽数组。
参考资料
[1]
“加权调和平均数”，维基百科，en.wikipedia.org/wiki/Harmonic_mean#Weighted_harmonic_mean
[2]
Ferger, F., “调和平均数的性质和使用”，美国统计协会杂志，第 26 卷，第 36-40 页，1931 年
示例
>>> from scipy.stats import hmean
>>> hmean([1, 4])
1.6000000000000001
>>> hmean([1, 2, 3, 4, 5, 6, 7])
2.6997245179063363
>>> hmean([1, 4, 7], weights=[3, 1, 3])
1.9029126213592233
