SciPy 1.12 中文文档（四十五）

原文：docs.scipy.org/doc/scipy-1.12.0/index.html

`scipy.special.logit`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.logit.html#scipy.special.logit

scipy.special.logit(x, out=None) = <ufunc 'logit'>

用于 ndarrays 的 logit ufunc。

logit 函数定义为 logit(p) = log(p/(1-p))。请注意，logit(0) = -inf，logit(1) = inf，而对于 p<0 或 p>1 的 logit(p) 结果为 nan。

参数：

x ndarray

ndarray，逐元素应用 logit。

out ndarray，可选

函数结果的可选输出数组请注意，以上是根据 Markdown 格式要求翻译后的文本。每一句译文都带有前缀（- ），符合指定格式。

返回值：

标量或者 ndarray

与 x 形状相同的 ndarray。其条目是对应 x 条目的 logit。

另请参见：

expit

注意：

作为 ufunc，logit 接受多个可选关键字参数。更多信息请参见 ufuncs

0.10.0 版本新增内容。

示例

>>> import numpy as np
>>> from scipy.special import logit, expit

>>> logit([0, 0.25, 0.5, 0.75, 1])
array([       -inf, -1.09861229,  0\.        ,  1.09861229,         inf])

expit 是 logit 的反函数：

>>> expit(logit([0.1, 0.75, 0.999]))
array([ 0.1  ,  0.75 ,  0.999])

绘制 logit(x) 在 x 属于 [0, 1] 的范围内：

>>> import matplotlib.pyplot as plt
>>> x = np.linspace(0, 1, 501)
>>> y = logit(x)
>>> plt.plot(x, y)
>>> plt.grid()
>>> plt.ylim(-6, 6)
>>> plt.xlabel('x')
>>> plt.title('logit(x)')
>>> plt.show()

../../_images/scipy-special-logit-1.png

`scipy.special.expit`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.expit.html#scipy.special.expit

scipy.special.expit(x, out=None) = <ufunc 'expit'>

Expit（又名逻辑 sigmoid）ndarrays 的 ufunc。

expit 函数，也称为逻辑 sigmoid 函数，定义为expit(x) = 1/(1+exp(-x))。它是 logit 函数的反函数。

参数：

xndarray

要对每个元素应用expit的 ndarray。

outndarray，可选

函数值的可选输出数组

标量或 ndarray

与 x 相同形状的 ndarray。其条目是相应 x 条目的expit。

另请参阅

logit

注意事项

作为一个 ufunc，expit接受多个可选的关键字参数。更多信息请参见ufuncs

版本 0.10.0 中的新功能。

示例

>>> import numpy as np
>>> from scipy.special import expit, logit

>>> expit([-np.inf, -1.5, 0, 1.5, np.inf])
array([ 0\.        ,  0.18242552,  0.5       ,  0.81757448,  1\.        ])

logit是expit的反函数：

>>> logit(expit([-2.5, 0, 3.1, 5.0]))
array([-2.5,  0\. ,  3.1,  5\. ])

绘制 expit(x)，其中 x 在[-6, 6]：

>>> import matplotlib.pyplot as plt
>>> x = np.linspace(-6, 6, 121)
>>> y = expit(x)
>>> plt.plot(x, y)
>>> plt.grid()
>>> plt.xlim(-6, 6)
>>> plt.xlabel('x')
>>> plt.title('expit(x)')
>>> plt.show()

../../_images/scipy-special-expit-1.png

`scipy.special.log_expit`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.log_expit.html#scipy.special.log_expit

scipy.special.log_expit(x, out=None) = <ufunc 'log_expit'>

逻辑 sigmoid 函数的对数。

SciPy 的逻辑 sigmoid 函数的实现是 scipy.special.expit，因此这个函数被称为 log_expit。

该函数在数学上等价于 log(expit(x))，但其表达式被设计为避免在输入具有大的（正或负）幅度时失去精度。

参数：

x 数组样式

要对每个元素应用 log_expit 的值。

out ndarray，可选

函数结果的可选输出数组

out 标量或 ndarray

计算出的值，一个与 x 形状相同的 ndarray。

另见

expit

注意事项

作为一个 ufunc，log_expit 接受多个可选的关键字参数。更多信息请参见 ufuncs

新版本 1.8.0 中引入。

示例

>>> import numpy as np
>>> from scipy.special import log_expit, expit

>>> log_expit([-3.0, 0.25, 2.5, 5.0])
array([-3.04858735, -0.57593942, -0.07888973, -0.00671535])

大的负值：

>>> log_expit([-100, -500, -1000])
array([ -100.,  -500., -1000.])

注意，expit(-1000) 返回 0，所以朴素实现 log(expit(-1000)) 返回 -inf。

大的正值：

>>> log_expit([29, 120, 400])
array([-2.54366565e-013, -7.66764807e-053, -1.91516960e-174])

将其与朴素实现进行比较：

>>> np.log(expit([29, 120, 400]))
array([-2.54463117e-13,  0.00000000e+00,  0.00000000e+00])

第一个值只准确到小数点后三位，更大的输入则失去所有精度并返回 0。

`scipy.special.tklmbda`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.tklmbda.html#scipy.special.tklmbda

scipy.special.tklmbda(x, lmbda, out=None) = <ufunc 'tklmbda'>

Tukey lambda 分布的累积分布函数。

参数：

x, lmbda array_like

参数

out ndarray，可选

函数结果的可选输出数组

cdf 标量或 ndarray

Tukey lambda CDF 的值

参见

scipy.stats.tukeylambda

Tukey lambda 分布

示例

>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.special import tklmbda, expit

计算lmbda为-1.5 时 Tukey lambda 分布的累积分布函数（CDF）在几个x值处的值。

>>> x = np.linspace(-2, 2, 9)
>>> x
array([-2\. , -1.5, -1\. , -0.5,  0\. ,  0.5,  1\. ,  1.5,  2\. ])
>>> tklmbda(x, -1.5)
array([0.34688734, 0.3786554 , 0.41528805, 0.45629737, 0.5       ,
 0.54370263, 0.58471195, 0.6213446 , 0.65311266])

当lmbda为 0 时，函数为逻辑 sigmoid 函数，在scipy.special中实现为expit。

>>> tklmbda(x, 0)
array([0.11920292, 0.18242552, 0.26894142, 0.37754067, 0.5       ,
 0.62245933, 0.73105858, 0.81757448, 0.88079708])
>>> expit(x)
array([0.11920292, 0.18242552, 0.26894142, 0.37754067, 0.5       ,
 0.62245933, 0.73105858, 0.81757448, 0.88079708])

当lmbda为 1 时，Tukey lambda 分布在区间[-1, 1]上均匀分布，因此 CDF 线性增加。

>>> t = np.linspace(-1, 1, 9)
>>> tklmbda(t, 1)
array([0\.   , 0.125, 0.25 , 0.375, 0.5  , 0.625, 0.75 , 0.875, 1\.   ])

在下文中，我们生成了几个lmbda值的图表。

第一张图显示了当lmbda <= 0 时的图形。

>>> styles = ['-', '-.', '--', ':']
>>> fig, ax = plt.subplots()
>>> x = np.linspace(-12, 12, 500)
>>> for k, lmbda in enumerate([-1.0, -0.5, 0.0]):
...     y = tklmbda(x, lmbda)
...     ax.plot(x, y, styles[k], label=f'$\lambda$ = {lmbda:-4.1f}')

>>> ax.set_title('tklmbda(x, $\lambda$)')
>>> ax.set_label('x')
>>> ax.legend(framealpha=1, shadow=True)
>>> ax.grid(True)

第二张图显示了当lmbda > 0 时的图形。图中的点显示了分布支持的边界。

>>> fig, ax = plt.subplots()
>>> x = np.linspace(-4.2, 4.2, 500)
>>> lmbdas = [0.25, 0.5, 1.0, 1.5]
>>> for k, lmbda in enumerate(lmbdas):
...     y = tklmbda(x, lmbda)
...     ax.plot(x, y, styles[k], label=f'$\lambda$ = {lmbda}')

>>> ax.set_prop_cycle(None)
>>> for lmbda in lmbdas:
...     ax.plot([-1/lmbda, 1/lmbda], [0, 1], '.', ms=8)

>>> ax.set_title('tklmbda(x, $\lambda$)')
>>> ax.set_xlabel('x')
>>> ax.legend(framealpha=1, shadow=True)
>>> ax.grid(True)

>>> plt.tight_layout()
>>> plt.show()

../../_images/scipy-special-tklmbda-1_00_00.png

Tukey lambda 分布的累积分布函数也实现为scipy.stats.tukeylambda的cdf方法。在下文中，tukeylambda.cdf(x, -0.5)和tklmbda(x, -0.5)计算相同的值：

>>> from scipy.stats import tukeylambda
>>> x = np.linspace(-2, 2, 9)

>>> tukeylambda.cdf(x, -0.5)
array([0.21995157, 0.27093858, 0.33541677, 0.41328161, 0.5       ,
 0.58671839, 0.66458323, 0.72906142, 0.78004843])

>>> tklmbda(x, -0.5)
array([0.21995157, 0.27093858, 0.33541677, 0.41328161, 0.5       ,
 0.58671839, 0.66458323, 0.72906142, 0.78004843])

tukeylambda中的实现还提供了位置和比例参数，以及其他方法，如pdf()（概率密度函数）和ppf()（CDF 的反函数），因此对于处理 Tukey lambda 分布，tukeylambda更加通用。tklmbda的主要优势在于它比tukeylambda.cdf快得多。

`scipy.special.owens_t`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.owens_t.html#scipy.special.owens_t

scipy.special.owens_t(h, a, out=None) = <ufunc 'owens_t'>

Owen’s T Function。

函数 T(h, a) 给出事件的概率（X > h 并且 0 < Y < a * X），其中 X 和 Y 是独立的标准正态随机变量。

参数：

h: array_like

输入值。

a: array_like

输入值。

outndarray, optional

函数结果的可选输出数组

t: scalar or ndarray

事件的概率（X > h 并且 0 < Y < a * X），其中 X 和 Y 是独立的标准正态随机变量。

参考文献

[1]

M. Patefield 和 D. Tandy，“Owen’s T Function 的快速和准确计算”，Statistical Software 第 5 卷，第 1-25 页，2000 年。

示例

>>> from scipy import special
>>> a = 3.5
>>> h = 0.78
>>> special.owens_t(h, a)
0.10877216734852274

`scipy.special.entr`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.entr.html#scipy.special.entr

scipy.special.entr(x, out=None) = <ufunc 'entr'>

用于计算熵的逐元素函数。

[\begin{split}\text{entr}(x) = \begin{cases} - x \log(x) & x > 0 \ 0 & x = 0 \ -\infty & \text{否则} \end{cases}\end{split}]

参数：

x ndarray

输入数组。

out ndarray，可选

可选的输出数组，用于函数值

res 标量或 ndarray

给定点x处的逐元素熵函数值。

另请参阅

kl_div，rel_entr，scipy.stats.entropy

注意事项

自版本 0.15.0 起新增。

此函数为凹函数。

该函数的起源在于凸规划；参见[1]。给定概率分布 (p_1, \ldots, p_n)，在信息论的背景下，熵的定义为

[\sum_{i = 1}^n \mathrm{entr}(p_i).]

要计算后一种数量，请使用scipy.stats.entropy。

参考文献

[1]

Boyd, Stephen 和 Lieven Vandenberghe。凸优化。剑桥大学出版社，2004 年。DOI:https://doi.org/10.1017/CBO9780511804441

`scipy.special.rel_entr`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.rel_entr.html#scipy.special.rel_entr

scipy.special.rel_entr(x, y, out=None) = <ufunc 'rel_entr'>

用于计算相对熵的逐元素函数。

[\begin{split}\mathrm{rel_entr}(x, y) = \begin{cases} x \log(x / y) & x > 0, y > 0 \ 0 & x = 0, y \ge 0 \ \infty & \text{otherwise} \end{cases}\end{split}]

参数：

x, yarray_like

输入数组

outndarray，可选

函数结果的可选输出数组

标量或 ndarray

输入的相对熵

另请参阅

entr, kl_div, scipy.stats.entropy

注意事项

新版本 0.15.0 中引入。

此函数在 x 和 y 中是联合凸的。

此函数的起源在于凸优化；参见 [1]。给定两个离散概率分布 (p_1, \ldots, p_n) 和 (q_1, \ldots, q_n)，在信息理论背景下，相对熵的定义为

[\sum_{i = 1}^n \mathrm{rel_entr}(p_i, q_i).]

要计算后一数量，请使用 scipy.stats.entropy。

详细信息请参见 [2]。

参考资料

[1]

Boyd, Stephen 和 Lieven Vandenberghe。《凸优化》。剑桥大学出版社，2004 年。DOI:https://doi.org/10.1017/CBO9780511804441

[2]

Kullback-Leibler 散度，en.wikipedia.org/wiki/Kullback%E2%80%93Leibler_divergence

`scipy.special.kl_div`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.kl_div.html#scipy.special.kl_div

scipy.special.kl_div(x, y, out=None) = <ufunc 'kl_div'>

计算 Kullback-Leibler 散度的逐元素函数。

[\begin{split}\mathrm{kl_div}(x, y) = \begin{cases} x \log(x / y) - x + y & x > 0, y > 0 \ y & x = 0, y \ge 0 \ \infty & \text{otherwise} \end{cases}\end{split}]

参数：

x, y array_like

真实参数

out ndarray，可选

用于函数结果的可选输出数组

标量或 ndarray

Kullback-Liebler 散度的值。

另请参阅

entr, rel_entr, scipy.stats.entropy

注释

从版本 0.15.0 新增。

此函数非负，在 x 和 y 中是联合凸的。

此函数的起源在于凸优化；详细信息请参见 [1]。这也是为什么该函数包含与 Kullback-Leibler 散度不同的额外 (-x + y) 项。如需不带额外项的函数版本，请参见 rel_entr。

参考文献

[1]

Boyd, Stephen and Lieven Vandenberghe. Convex optimization. Cambridge University Press, 2004. DOI:https://doi.org/10.1017/CBO9780511804441

`scipy.special.huber`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.huber.html#scipy.special.huber

scipy.special.huber(delta, r, out=None) = <ufunc 'huber'>

Huber 损失函数。

[\begin{split}\text{huber}(\delta, r) = \begin{cases} \infty & \delta < 0 \ \frac{1}{2}r² & 0 \le \delta, | r | \le \delta \ \delta ( |r| - \frac{1}{2}\delta ) & \text{otherwise} \end{cases}\end{split}]

参数：

deltandarray

输入数组，指示二次与线性损失的变化点。

rndarray

输入数组，可能代表残差。

outndarray, optional

可选的输出数组，用于存放函数值。

标量或 ndarray

计算得到的 Huber 损失函数值。

另请参阅

pseudo_huber

该函数的平滑近似

注意事项

huber在稳健统计或机器学习中作为损失函数非常有用，以减少离群值的影响，与常见的平方误差损失相比，大于delta的残差不会被平方处理[1]。

通常，r代表残差，即模型预测与数据之间的差异。因此，对于( |r| \leq \delta )，huber类似于平方误差；而对于( |r| > \delta )，则类似于绝对误差。这种方式使得 Huber 损失函数在处理小残差（如平方误差损失函数）时能够快速收敛，并且在减小离群值的影响（( |r| > \delta )）时仍能发挥作用。由于(\delta)是平方误差和绝对误差之间的分界点，因此在每个问题中都需要进行仔细调整。huber还是凸函数，适合基于梯度的优化算法。

从版本 0.15.0 开始新增。

参考文献

[1]

Peter Huber. “Robust Estimation of a Location Parameter”, 1964. Annals of Statistics. 53 (1): 73 - 101.

示例

导入所有必要的模块。

>>> import numpy as np
>>> from scipy.special import huber
>>> import matplotlib.pyplot as plt

计算delta=1，r=2时的函数值。

>>> huber(1., 2.)
1.5

通过提供 NumPy 数组或列表来计算不同delta下的函数值。

>>> huber([1., 3., 5.], 4.)
array([3.5, 7.5, 8\. ])

通过提供 NumPy 数组或列表来计算不同点上的函数值r。

>>> huber(2., np.array([1., 1.5, 3.]))
array([0.5  , 1.125, 4\.   ])

可以通过提供形状兼容的delta和r数组来计算不同delta和r下的函数值。

>>> r = np.array([1., 2.5, 8., 10.])
>>> deltas = np.array([[1.], [5.], [9.]])
>>> print(r.shape, deltas.shape)
(4,) (3, 1)

>>> huber(deltas, r)
array([[ 0.5  ,  2\.   ,  7.5  ,  9.5  ],
 [ 0.5  ,  3.125, 27.5  , 37.5  ],
 [ 0.5  ,  3.125, 32\.   , 49.5  ]])

绘制不同delta下的函数图像。

>>> x = np.linspace(-4, 4, 500)
>>> deltas = [1, 2, 3]
>>> linestyles = ["dashed", "dotted", "dashdot"]
>>> fig, ax = plt.subplots()
>>> combined_plot_parameters = list(zip(deltas, linestyles))
>>> for delta, style in combined_plot_parameters:
...     ax.plot(x, huber(delta, x), label=f"$\delta={delta}$", ls=style)
>>> ax.legend(loc="upper center")
>>> ax.set_xlabel("$x$")
>>> ax.set_title("Huber loss function $h_{\delta}(x)$")
>>> ax.set_xlim(-4, 4)
>>> ax.set_ylim(0, 8)
>>> plt.show()

../../_images/scipy-special-huber-1.png

`scipy.special.pseudo_huber`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.pseudo_huber.html#scipy.special.pseudo_huber

scipy.special.pseudo_huber(delta, r, out=None) = <ufunc 'pseudo_huber'>

伪 Huber 损失函数。

[\mathrm{pseudo_huber}(\delta, r) = \delta² \left( \sqrt{ 1 + \left( \frac{r}{\delta} \right)² } - 1 \right)]

参数：

deltaarray_like

输入数组，指示软二次 vs 线性损失的变化点。

rarray_like

输入数组，可能表示残差。

outndarray，可选

可选的输出数组，用于函数结果

res标量或 ndarray

计算的伪 Huber 损失函数值。

另请参阅

huber

与该函数近似的类似函数

注意事项

像huber一样，pseudo_huber经常用作统计学或机器学习中的鲁棒损失函数，以减少异常值的影响。与huber不同，pseudo_huber是光滑的。

典型地，r代表残差，即模型预测与数据之间的差异。因此，对于( |r| \leq \delta )，pseudo_huber类似于平方误差，对于( |r| > \delta )，则是绝对误差。这样，伪 Huber 损失函数通常能够在小残差（如平方误差损失函数）的模型拟合中快速收敛，并且仍然减少了异常值（( |r| > \delta )）的影响。因为( \delta )是平方误差和绝对误差区域之间的分界点，对每个问题都需要进行精心调整。pseudo_huber也是凸的，适合基于梯度的优化方法。[1] [2]

新版本 0.15.0 中引入。

参考文献

[1]

Hartley，Zisserman，“计算机视觉中的多视图几何”。2003. 剑桥大学出版社。p. 619

[2]

Charbonnier 等人，“在计算成像中的确定性边缘保持正则化”。1997. IEEE 图像处理期刊。6（2）：298-311。

示例

导入所有必要的模块。

>>> import numpy as np
>>> from scipy.special import pseudo_huber, huber
>>> import matplotlib.pyplot as plt

计算delta=1时r=2的函数。

>>> pseudo_huber(1., 2.)
1.2360679774997898

通过为delta提供列表或 NumPy 数组，对r=2计算不同delta的函数。

>>> pseudo_huber([1., 2., 4.], 3.)
array([2.16227766, 3.21110255, 4\.        ])

通过为r提供列表或 NumPy 数组，对delta=1的多个点计算函数。

>>> pseudo_huber(2., np.array([1., 1.5, 3., 4.]))
array([0.47213595, 1\.        , 3.21110255, 4.94427191])

可以通过提供兼容形状以进行广播的两个数组，对不同的delta和r计算函数。

>>> r = np.array([1., 2.5, 8., 10.])
>>> deltas = np.array([[1.], [5.], [9.]])
>>> print(r.shape, deltas.shape)
(4,) (3, 1)

>>> pseudo_huber(deltas, r)
array([[ 0.41421356,  1.6925824 ,  7.06225775,  9.04987562],
 [ 0.49509757,  2.95084972, 22.16990566, 30.90169944],
 [ 0.49846624,  3.06693762, 27.37435121, 40.08261642]])

绘制不同delta的函数。

>>> x = np.linspace(-4, 4, 500)
>>> deltas = [1, 2, 3]
>>> linestyles = ["dashed", "dotted", "dashdot"]
>>> fig, ax = plt.subplots()
>>> combined_plot_parameters = list(zip(deltas, linestyles))
>>> for delta, style in combined_plot_parameters:
...     ax.plot(x, pseudo_huber(delta, x), label=f"$\delta={delta}$",
...             ls=style)
>>> ax.legend(loc="upper center")
>>> ax.set_xlabel("$x$")
>>> ax.set_title("Pseudo-Huber loss function $h_{\delta}(x)$")
>>> ax.set_xlim(-4, 4)
>>> ax.set_ylim(0, 8)
>>> plt.show()

../../_images/scipy-special-pseudo_huber-1_00_00.png

最后，通过绘制huber和pseudo_huber及其关于r的梯度，最终说明它们之间的差异。图表显示pseudo_huber在点(\pm\delta)处是连续可微的，而huber则不是。

>>> def huber_grad(delta, x):
...     grad = np.copy(x)
...     linear_area = np.argwhere(np.abs(x) > delta)
...     grad[linear_area]=delta*np.sign(x[linear_area])
...     return grad
>>> def pseudo_huber_grad(delta, x):
...     return x* (1+(x/delta)**2)**(-0.5)
>>> x=np.linspace(-3, 3, 500)
>>> delta = 1.
>>> fig, ax = plt.subplots(figsize=(7, 7))
>>> ax.plot(x, huber(delta, x), label="Huber", ls="dashed")
>>> ax.plot(x, huber_grad(delta, x), label="Huber Gradient", ls="dashdot")
>>> ax.plot(x, pseudo_huber(delta, x), label="Pseudo-Huber", ls="dotted")
>>> ax.plot(x, pseudo_huber_grad(delta, x), label="Pseudo-Huber Gradient",
...         ls="solid")
>>> ax.legend(loc="upper center")
>>> plt.show()

../../_images/scipy-special-pseudo_huber-1_01_00.png

`scipy.special.gamma`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.gamma.html#scipy.special.gamma

scipy.special.gamma(z, out=None) = <ufunc 'gamma'>

伽玛函数

伽玛函数定义为

[\Gamma(z) = \int_0^\infty t^{z-1} e^{-t} dt]

对于 (\Re(z) > 0)，并通过解析延拓到复平面的其余部分。更多详情请见[dlmf]。

参数：

z 数组型参数

实数或复数值参数

out 数组，可选

可选的输出数组，用于函数值

标量或者数组

伽玛函数的值

注意

伽玛函数通常被称为广义阶乘，因为对于自然数 (n)，(\Gamma(n + 1) = n!)。更一般地，对于复数 (z)，它满足递推关系 (\Gamma(z + 1) = z \cdot \Gamma(z))，结合事实 (\Gamma(1) = 1)，这意味着对于 (z = n) 的上述身份成立。

参考文献

[dlmf]

NIST 数字图书馆数学函数 dlmf.nist.gov/5.2#E1

示例

>>> import numpy as np
>>> from scipy.special import gamma, factorial

>>> gamma([0, 0.5, 1, 5])
array([         inf,   1.77245385,   1\.        ,  24\.        ])

>>> z = 2.5 + 1j
>>> gamma(z)
(0.77476210455108352+0.70763120437959293j)
>>> gamma(z+1), z*gamma(z)  # Recurrence property
((1.2292740569981171+2.5438401155000685j),
 (1.2292740569981158+2.5438401155000658j))

>>> gamma(0.5)**2  # gamma(0.5) = sqrt(pi)
3.1415926535897927

为实数 (x) 绘制伽玛函数 ( \Gamma(x) )

>>> x = np.linspace(-3.5, 5.5, 2251)
>>> y = gamma(x)

>>> import matplotlib.pyplot as plt
>>> plt.plot(x, y, 'b', alpha=0.6, label='gamma(x)')
>>> k = np.arange(1, 7)
>>> plt.plot(k, factorial(k-1), 'k*', alpha=0.6,
...          label='(x-1)!, x = 1, 2, ...')
>>> plt.xlim(-3.5, 5.5)
>>> plt.ylim(-10, 25)
>>> plt.grid()
>>> plt.xlabel('x')
>>> plt.legend(loc='lower right')
>>> plt.show()

../../_images/scipy-special-gamma-1.png

`scipy.special.gammaln`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.gammaln.html#scipy.special.gammaln

scipy.special.gammaln(x, out=None) = <ufunc 'gammaln'>

Gamma 函数绝对值的对数。

定义为

[\ln(\lvert\Gamma(x)\rvert)]

其中(\Gamma)是 Gamma 函数。有关 Gamma 函数的更多详细信息，请参见[dlmf]。

参数：

x：array_like

实数参数

out：ndarray，可选

用于函数结果的可选输出数组

返回值：

标量或 ndarray

绝对值的对数的值

另请参阅

gammasgn

Gamma 函数的符号

loggamma

Gamma 函数对数的主分支

注意事项

它与 Python 标准库函数math.lgamma相同。

当与gammasgn结合使用时，此函数对于在实轴上的对数空间中工作而无需处理复数非常有用，关系为exp(gammaln(x)) = gammasgn(x) * gamma(x)。

对于复值对数 Gamma 函数，请使用loggamma而不是gammaln。

参考文献

[dlmf]

NIST 数学函数数字图书馆dlmf.nist.gov/5

示例

>>> import numpy as np
>>> import scipy.special as sc

它有两个正零点。

>>> sc.gammaln([1, 2])
array([0., 0.])

它在非正整数处有极点。

>>> sc.gammaln([0, -1, -2, -3, -4])
array([inf, inf, inf, inf, inf])

它渐近地趋近于x * log(x)（Stirling 公式）。

>>> x = np.array([1e10, 1e20, 1e40, 1e80])
>>> sc.gammaln(x)
array([2.20258509e+11, 4.50517019e+21, 9.11034037e+41, 1.83206807e+82])
>>> x * np.log(x)
array([2.30258509e+11, 4.60517019e+21, 9.21034037e+41, 1.84206807e+82])

`scipy.special.loggamma`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.loggamma.html#scipy.special.loggamma

scipy.special.loggamma(z, out=None) = <ufunc 'loggamma'>

伽玛函数的主分支的对数。

定义为对于(x > 0)的情况为(\log(\Gamma(x)))，并通过解析延续扩展到复平面。该函数在负实轴上有一个单一的分支切割。

新功能在版本 0.18.0 中引入。

参数：

zarray_like

在复平面上计算loggamma的值。

outndarray, 可选

计算所得的loggamma值的输出数组。

loggamma标量或 ndarray

loggamma在 z 处的值。

另见

gammaln

伽玛函数绝对值的对数。

gammasgn

伽玛函数的符号

注意

一般而言，并非总是成立(\log\Gamma(z) = \log(\Gamma(z)))，尽管函数的实部是一致的。不将loggamma定义为(\log(\Gamma(z)))的好处在于，后者具有复杂的分支切割结构，而loggamma在负实轴上除外是解析的。

标识

[\begin{split}\exp(\log\Gamma(z)) &= \Gamma(z) \ \log\Gamma(z + 1) &= \log(z) + \log\Gamma(z)\end{split}]

使loggamma在复对数空间中的工作变得有用。

在实轴上，通过exp(loggamma(x + 0j)) = gammasgn(x)*exp(gammaln(x))，loggamma与gammaln相关，误差可忽略不计。

此处的实现基于[hare1997]。

参考资料

[hare1997]

作者 D.E.G. Hare，《计算对数伽玛的主分支》，《算法期刊》，1997 年 11 月，第 25 卷，第 2 期，页码 221-236。

`scipy.special.gammasgn`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.gammasgn.html#scipy.special.gammasgn

scipy.special.gammasgn(x, out=None) = <ufunc 'gammasgn'>

gamma 函数的符号。

定义如下

[\begin{split}\text{gammasgn}(x) = \begin{cases} +1 & \Gamma(x) > 0 \ -1 & \Gamma(x) < 0 \end{cases}\end{split}]

其中 (\Gamma) 是 gamma 函数；参见 gamma。该定义是完备的，因为 gamma 函数从不为零；参见 [dlmf] 后的讨论。

参数：

xarray_like

实数参数

outndarray，可选

函数值的可选输出数组

标量或 ndarray

gamma 函数的符号

另请参阅

gamma

gamma 函数

gammaln

gamma 函数绝对值的对数

loggamma

gamma 函数对数的解析延拓

注释

gamma 函数可以计算为 gammasgn(x) * np.exp(gammaln(x))。

参考文献

[dlmf]

NIST 数字数学函数图书馆 dlmf.nist.gov/5.2#E1

示例

>>> import numpy as np
>>> import scipy.special as sc

当 x > 0 时为 1。

>>> sc.gammasgn([1, 2, 3, 4])
array([1., 1., 1., 1.])

对于负整数，它在 -1 和 1 之间交替。

>>> sc.gammasgn([-0.5, -1.5, -2.5, -3.5])
array([-1.,  1., -1.,  1.])

它可用于计算 gamma 函数。

>>> x = [1.5, 0.5, -0.5, -1.5]
>>> sc.gammasgn(x) * np.exp(sc.gammaln(x))
array([ 0.88622693,  1.77245385, -3.5449077 ,  2.3632718 ])
>>> sc.gamma(x)
array([ 0.88622693,  1.77245385, -3.5449077 ,  2.3632718 ])

`scipy.special.gammainc`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.gammainc.html#scipy.special.gammainc

scipy.special.gammainc(a, x, out=None) = <ufunc 'gammainc'>

正则化的下不完全伽玛函数。

定义为

[P(a, x) = \frac{1}{\Gamma(a)} \int_0^x t^{a - 1}e^{-t} dt]

对于(a > 0) 和 (x \geq 0)。详细信息请参见[dlmf]。

参数：

aarray_like

正参数

xarray_like

非负参数

outndarray, optional

函数值的可选输出数组

标量或 ndarray

下不完全伽玛函数的值

另请参见

gammaincc

正则化的上不完全伽玛函数

gammaincinv

正则化的下不完全伽玛函数的逆

gammainccinv

正则化的上不完全伽玛函数的逆

注释

函数满足关系 gammainc(a, x) + gammaincc(a, x) = 1，其中gammaincc 是正则化的上不完全伽玛函数。

实现主要遵循[boost]的那个。

参考文献

[dlmf]

NIST 数字数学函数库dlmf.nist.gov/8.2#E4

[boost]

Maddock 等人，“不完全伽玛函数”，www.boost.org/doc/libs/1_61_0/libs/math/doc/html/math_toolkit/sf_gamma/igamma.html

示例

>>> import scipy.special as sc

它是伽玛分布的累积分布函数，因此从 0 开始单调增加到 1。

>>> sc.gammainc(0.5, [0, 1, 10, 100])
array([0\.        , 0.84270079, 0.99999226, 1\.        ])

它等于一减去上不完全伽玛函数。

>>> a, x = 0.5, 0.4
>>> sc.gammainc(a, x)
0.6289066304773024
>>> 1 - sc.gammaincc(a, x)
0.6289066304773024

`scipy.special.gammaincinv`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.gammaincinv.html#scipy.special.gammaincinv

scipy.special.gammaincinv(a, y, out=None) = <ufunc 'gammaincinv'>

正则化的下不完全伽马函数的反函数。

给定介于 0 和 1 之间的输入( y )，返回( x )，使得( y = P(a, x) )。这里的( P )是正则化的下不完全伽马函数；参见gammainc。这是明确定义的，因为下不完全伽马函数如其在[dlmf]中的定义所示是单调的。

参数：

a，类似数组

正参数

y，类似数组

参数在 0 到 1 之间，包括边界

out，可选的 ndarray

函数值的可选输出数组

标量或 ndarray

下不完全伽马函数的反函数的值

另见

gammainc

正则化的下不完全伽马函数

gammaincc

正则化的上不完全伽马函数

gammainccinv

正则化的上不完全伽马函数的反函数

参考

[dlmf]

NIST 数字数学函数库dlmf.nist.gov/8.2#E4

示例

>>> import scipy.special as sc

它从 0 开始单调增加到无穷大。

>>> sc.gammaincinv(0.5, [0, 0.1 ,0.5, 1])
array([0\.        , 0.00789539, 0.22746821,        inf])

它反转了下不完全伽马函数。

>>> a, x = 0.5, [0, 0.1, 0.5, 1]
>>> sc.gammainc(a, sc.gammaincinv(a, x))
array([0\. , 0.1, 0.5, 1\. ])

>>> a, x = 0.5, [0, 10, 25]
>>> sc.gammaincinv(a, sc.gammainc(a, x))
array([ 0\.        , 10\.        , 25.00001465])

`scipy.special.gammaincc`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.gammaincc.html#scipy.special.gammaincc

scipy.special.gammaincc(a, x, out=None) = <ufunc 'gammaincc'>

规则化的上不完全伽玛函数。

定义为

[Q(a, x) = \frac{1}{\Gamma(a)} \int_x^\infty t^{a - 1}e^{-t} dt]

当 (a > 0) 和 (x \geq 0) 时。详见 [dlmf]。

参数：

aarray_like

正参数

xarray_like

非负参数

outndarray，可选

函数值的可选输出数组

标量或者 ndarray

上不完全伽玛函数的值

另请参阅

gammainc

规则化的下不完全伽玛函数

gammaincinv

规则化的下不完全伽玛函数的反函数

gammainccinv

规则化的上不完全伽玛函数的反函数

注意事项

函数满足关系 gammainc(a, x) + gammaincc(a, x) = 1，其中 gammainc 是规则化的下不完全伽玛函数。

实现大部分遵循 [boost]。

参考资料

[dlmf]

NIST 数字数学函数库 dlmf.nist.gov/8.2#E4

[boost]

Maddock 等人，“不完全伽玛函数”，www.boost.org/doc/libs/1_61_0/libs/math/doc/html/math_toolkit/sf_gamma/igamma.html

示例

>>> import scipy.special as sc

它是伽玛分布的生存函数，因此从 1 开始单调递减到 0。

>>> sc.gammaincc(0.5, [0, 1, 10, 100, 1000])
array([1.00000000e+00, 1.57299207e-01, 7.74421643e-06, 2.08848758e-45,
 0.00000000e+00])

它等于 1 减去下不完全伽玛函数。

>>> a, x = 0.5, 0.4
>>> sc.gammaincc(a, x)
0.37109336952269756
>>> 1 - sc.gammainc(a, x)
0.37109336952269756

`scipy.special.gammainccinv`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.gammainccinv.html#scipy.special.gammainccinv

scipy.special.gammainccinv(a, y, out=None) = <ufunc 'gammainccinv'>

正则化的上不完全伽马函数的反函数。

给定介于 0 和 1 之间的输入 (y)，返回 (x)，使得 (y = Q(a, x))。这里 (Q) 是正则化的上不完全伽马函数；参见 gammaincc。这是合理的，因为上不完全伽马函数从其在[dlmf]中的定义中可以看出是单调的。

参数：

a 数组类似

正参数

y 数组类似

介于 0 和 1 之间的参数

out 数组，可选的

函数值的可选输出数组

标量或数组

上不完全伽马函数的反函数值

另请参阅

gammaincc

正则化的上不完全伽马函数

gammainc

正则化的下不完全伽马函数

gammaincinv

正则化的下不完全伽马函数的反函数

参考

[dlmf]

NIST 数学函数数字图书馆 dlmf.nist.gov/8.2#E4

示例

>>> import scipy.special as sc

它从无穷大开始单调减少到 0。

>>> sc.gammainccinv(0.5, [0, 0.1, 0.5, 1])
array([       inf, 1.35277173, 0.22746821, 0\.        ])

它反转了上不完全伽马函数。

>>> a, x = 0.5, [0, 0.1, 0.5, 1]
>>> sc.gammaincc(a, sc.gammainccinv(a, x))
array([0\. , 0.1, 0.5, 1\. ])

>>> a, x = 0.5, [0, 10, 50]
>>> sc.gammainccinv(a, sc.gammaincc(a, x))
array([ 0., 10., 50.])

`scipy.special.beta`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.beta.html#scipy.special.beta

scipy.special.beta(a, b, out=None) = <ufunc 'beta'>

Beta 函数。

此函数在[1]中定义为

[B(a, b) = \int_0¹ t^{a-1}(1-t)^{b-1}dt = \frac{\Gamma(a)\Gamma(b)}{\Gamma(a+b)},]

其中 (\Gamma) 是 Gamma 函数。

参数:

a, barray_like

实数参数

outndarray, 可选的

函数结果的可选输出数组

标量或者 ndarray

Beta 函数的值

另请参阅

gamma

Gamma 函数

betainc

正则不完全 Beta 函数

betaln

Beta 函数的绝对值的自然对数

参考文献

[1]

NIST 数字数学函数库，Eq. 5.12.1. dlmf.nist.gov/5.12

例子

>>> import scipy.special as sc

Beta 函数通过上述定义与 Gamma 函数相关联：

>>> sc.beta(2, 3)
0.08333333333333333
>>> sc.gamma(2)*sc.gamma(3)/sc.gamma(2 + 3)
0.08333333333333333

正如这个关系所示，Beta 函数是对称的：

>>> sc.beta(1.7, 2.4)
0.16567527689031739
>>> sc.beta(2.4, 1.7)
0.16567527689031739

此函数满足 (B(1, b) = 1/b):

>>> sc.beta(1, 4)
0.25

`scipy.special.betaln`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.betaln.html#scipy.special.betaln

scipy.special.betaln(a, b, out=None) = <ufunc 'betaln'>

beta 函数绝对值的自然对数。

计算 ln(abs(beta(a, b)))。

参数：

a, barray_like

正实数参数

outndarray，可选

函数值的可选输出数组

标量或 ndarray

betaln 函数的值

另请参阅

gamma

伽马函数

betainc

正则化不完全贝塔函数

beta

beta 函数

示例

>>> import numpy as np
>>> from scipy.special import betaln, beta

验证，在中等值的情况下 a 和 b，betaln(a, b) 等同于 log(beta(a, b))：

>>> betaln(3, 4)
-4.0943445622221

>>> np.log(beta(3, 4))
-4.0943445622221

在下面的情况下 beta(a, b) 衰减为 0，所以我们不能计算实际值的对数。

>>> a = 400
>>> b = 900
>>> beta(a, b)
0.0

我们可以通过使用 betaln 来计算 beta(a, b) 的对数：

>>> betaln(a, b)
-804.3069951764146

`scipy.special.betainc`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.betainc.html#scipy.special.betainc

scipy.special.betainc(a, b, x, out=None) = <ufunc 'betainc'>

正则化不完全贝塔函数。

计算定义为 [1] 的正则化不完全贝塔函数:

[I_x(a, b) = \frac{\Gamma(a+b)}{\Gamma(a)\Gamma(b)} \int_0^x t^{a-1}(1-t)^{b-1}dt]

对于 (0 \leq x \leq 1)。

该函数是贝塔分布的累积分布函数；其范围为 [0, 1]。

参数：

a, b 数组形式

正数实数值参数

x 数组形式

实数值，使得 (0 \leq x \leq 1)，积分的上限

out 数组，可选

函数值的可选输出数组

标量或者数组

正则化不完全贝塔函数的值

参见

beta

贝塔函数

betaincinv

正则化不完全贝塔函数的反函数

betaincc

正则化不完全贝塔函数的补函数

scipy.stats.beta

贝塔分布

注释

函数名称中的 regularized 指的是通过公式中显示的 gamma 函数项对函数进行缩放。当未标明为 regularized 时，函数名称 incomplete beta function 通常仅指积分表达式，不包括 gamma 项。可以使用 scipy.special 中的函数 beta，通过将 betainc(a, b, x) 的结果乘以 beta(a, b) 来获取这种“非正则化”的不完全贝塔函数。

参考文献

[1]

NIST 数学函数数字图书馆 dlmf.nist.gov/8.17

示例

设 (B(a, b)) 为 beta 函数。

>>> import scipy.special as sc

通过 gamma 的系数等于 (1/B(a, b))。此外，当 (x=1) 时，积分等于 (B(a, b))。因此，对于任意的 (a, b)，(I_{x=1}(a, b) = 1)。

>>> sc.betainc(0.2, 3.5, 1.0)
1.0

满足 (I_x(a, b) = x^a F(a, 1-b, a+1, x)/ (aB(a, b)))，其中 (F) 是超几何函数 hyp2f1:

>>> a, b, x = 1.4, 3.1, 0.5
>>> x**a * sc.hyp2f1(a, 1 - b, a + 1, x)/(a * sc.beta(a, b))
0.8148904036225295
>>> sc.betainc(a, b, x)
0.8148904036225296

此函数满足关系式 (I_x(a, b) = 1 - I_{1-x}(b, a))：

>>> sc.betainc(2.2, 3.1, 0.4)
0.49339638807619446
>>> 1 - sc.betainc(3.1, 2.2, 1 - 0.4)
0.49339638807619446

`scipy.special.betaincc`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.betaincc.html#scipy.special.betaincc

scipy.special.betaincc(a, b, x, out=None) = <ufunc 'betaincc'>

正则化不完全贝塔函数的补数

计算定义为[1]的正则化不完全贝塔函数的补数：

[\bar{I}_x(a, b) = 1 - I_x(a, b) = 1 - \frac{\Gamma(a+b)}{\Gamma(a)\Gamma(b)} \int_0^x t^{a-1}(1-t)^{b-1}dt,]

对于 (0 \leq x \leq 1)。

参数：

a, b array_like

正数实数参数

x array_like

实数，使得 (0 \leq x \leq 1)，积分的上限

out ndarray，可选

函数值的可选输出数组

标量或 ndarray

正则化不完全贝塔函数的值

另请参见

正则化不完全贝塔函数

正则化不完全贝塔函数的逆

正则化不完全贝塔函数的补数的逆

贝塔函数

贝塔分布

注意事项

版本 1.11.0 中的新功能。

参考文献

[1]

NIST 数字数学函数库 dlmf.nist.gov/8.17

示例

>>> from scipy.special import betaincc, betainc

当 betainc(a, b, x) 的值接近 1 时，朴素计算 1 - betainc(a, b, x) 会失去精度：

>>> 1 - betainc(0.5, 8, [0.9, 0.99, 0.999])
array([2.0574632e-09, 0.0000000e+00, 0.0000000e+00])

通过使用 betaincc，我们得到正确的值：

>>> betaincc(0.5, 8, [0.9, 0.99, 0.999])
array([2.05746321e-09, 1.97259354e-17, 1.96467954e-25])

`scipy.special.betaincinv`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.betaincinv.html#scipy.special.betaincinv

scipy.special.betaincinv(a, b, y, out=None) = <ufunc 'betaincinv'>

正则化不完全贝塔函数的反函数。

计算 (x) 使得：

[y = I_x(a, b) = \frac{\Gamma(a+b)}{\Gamma(a)\Gamma(b)} \int_0^x t^{a-1}(1-t)^{b-1}dt,]

其中，(I_x)是标准化的不完全贝塔函数betainc，(\Gamma)是gamma函数[1]。

参数：

a, barray_like

正实数值参数

yarray_like

实值输入

outndarray, 可选

函数值的可选输出数组

返回值：

标量或者 ndarray

正则化不完全贝塔函数的倒数值

另请参阅

betainc

正则化不完全贝塔函数

gamma

gamma 函数

参考文献

[1]

NIST 数学函数数字库 dlmf.nist.gov/8.17

示例

>>> import scipy.special as sc

对于固定的 (a) 和 (b) 值，该函数是 betainc 的反函数。

>>> a, b = 1.2, 3.1
>>> y = sc.betainc(a, b, 0.2)
>>> sc.betaincinv(a, b, y)
0.2
>>>
>>> a, b = 7.5, 0.4
>>> x = sc.betaincinv(a, b, 0.5)
>>> sc.betainc(a, b, x)
0.5

`scipy.special.betainccinv`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.betainccinv.html#scipy.special.betainccinv

scipy.special.betainccinv(a, b, y, out=None) = <ufunc 'betainccinv'>

正则化不完全贝塔函数的互补

计算 (x) 使得：

[y = 1 - I_x(a, b) = 1 - \frac{\Gamma(a+b)}{\Gamma(a)\Gamma(b)} \int_0^x t^{a-1}(1-t)^{b-1}dt,]

其中 (I_x) 是归一化不完全贝塔函数 betainc，(\Gamma) 是 gamma 函数 [1]。

参数：

a, b array_like

正实数参数

y array_like

实值输入

out ndarray, 可选

可选的输出数组用于函数值

标量或者 ndarray

正则化不完全贝塔函数的反函数的值

另请参阅

betainc

正则化不完全贝塔函数

betaincc

正则化不完全贝塔函数的互补

注意

版本 1.11.0 中的新功能。

参考文献

[1]

美国国家标准与技术研究院数学函数数字图书馆 dlmf.nist.gov/8.17

示例

>>> from scipy.special import betainccinv, betaincc

对于固定的 (a) 和 (b) 值，此函数是 betaincc 的反函数。

>>> a, b = 1.2, 3.1
>>> y = betaincc(a, b, 0.2)
>>> betainccinv(a, b, y)
0.2

>>> a, b = 7, 2.5
>>> x = betainccinv(a, b, 0.875)
>>> betaincc(a, b, x)
0.875

SciPy-1-12-中文文档-四十五-

SciPy 1.12 中文文档（四十五）

scipy.special.logit

scipy.special.expit

scipy.special.log_expit

scipy.special.tklmbda

scipy.special.owens_t

scipy.special.entr

scipy.special.rel_entr

scipy.special.kl_div

scipy.special.huber

scipy.special.pseudo_huber

scipy.special.gamma

scipy.special.gammaln

scipy.special.loggamma

scipy.special.gammasgn

scipy.special.gammainc

scipy.special.gammaincinv

scipy.special.gammaincc

scipy.special.gammainccinv

scipy.special.beta

scipy.special.betaln

scipy.special.betainc

scipy.special.betaincc

scipy.special.betaincinv

scipy.special.betainccinv

`scipy.special.logit`

`scipy.special.expit`

`scipy.special.log_expit`

`scipy.special.tklmbda`

`scipy.special.owens_t`

`scipy.special.entr`

`scipy.special.rel_entr`

`scipy.special.kl_div`

`scipy.special.huber`

`scipy.special.pseudo_huber`

`scipy.special.gamma`

`scipy.special.gammaln`

`scipy.special.loggamma`

`scipy.special.gammasgn`

`scipy.special.gammainc`

`scipy.special.gammaincinv`

`scipy.special.gammaincc`

`scipy.special.gammainccinv`

`scipy.special.beta`

`scipy.special.betaln`

`scipy.special.betainc`

`scipy.special.betaincc`

`scipy.special.betaincinv`

`scipy.special.betainccinv`