torch.special

torch.special 模块，以 SciPy 的特殊模块为蓝本。

功能

torch.special 的airy_ai（input， *， out=None） → 张量

Airy 功能$\text{Ai}\left(\text{input}\right)$.

参数

input （Tensor） - 输入张量。

关键字参数

out （Tensor， optional） - 输出张量。

torch.special 的bessel_j0（input， *， out=None） → 张量

第一阶的 Bessel 函数$0$.

参数

input （Tensor） - 输入张量。

关键字参数

out （Tensor， optional） - 输出张量。

torch.special 的bessel_j1（input， *， out=None） → 张量

第一阶的 Bessel 函数$1$.

参数

input （Tensor） - 输入张量。

关键字参数

out （Tensor， optional） - 输出张量。

torch.special 的digamma（input， *， out=None） → 张量

计算 Gamma 函数在输入时的对数导数。

$$\digamma(x) = \frac{d}{dx} \ln\left(\Gamma\left(x\right)\right) = \frac{\Gamma'(x)}{\Gamma(x)}$$

参数

input （Tensor） – 要计算 digamma 函数的张量

关键字参数

out （Tensor， optional） - 输出张量。

注意

此函数类似于 SciPy 的 scipy.special.digamma。

注意

从 PyTorch 1.8 开始，digamma 函数返回 -Inf 表示 0。 以前，它返回 NaN 表示 0。

例：

>>> a = torch.tensor([1, 0.5])
>>> torch.special.digamma(a)
tensor([-0.5772, -1.9635])

torch.special 的entr（input， *， out=None） → 张量

按元素计算 （定义如下） 的熵。input

$$\begin{align} \text{entr(x)} = \begin{cases} -x * \ln(x) & x > 0 \\ 0 & x = 0.0 \\ -\infty & x < 0 \end{cases} \end{align}$$

参数

input （Tensor） - 输入张量。

关键字参数

out （Tensor， optional） - 输出张量。

例：：

>>> a = torch.arange(-0.5, 1, 0.5)
>>> a
tensor([-0.5000,  0.0000,  0.5000])
>>> torch.special.entr(a)
tensor([  -inf, 0.0000, 0.3466])

torch.special 的erf（input， *， out=None） → 张量

计算 的 误差函数 。error 函数定义如下：input

$$\mathrm{erf}(x) = \frac{2}{\sqrt{\pi}} \int_{0}^{x} e^{-t^2} dt$$

参数

input （Tensor） - 输入张量。

关键字参数

out （Tensor， optional） - 输出张量。

例：

>>> torch.special.erf(torch.tensor([0, -1., 10.]))
tensor([ 0.0000, -0.8427,  1.0000])

torch.special 的erfc（input， *， out=None） → 张量

计算 的互补误差函数 。 互补误差函数定义如下：input

$$\mathrm{erfc}(x) = 1 - \frac{2}{\sqrt{\pi}} \int_{0}^{x} e^{-t^2} dt$$

参数

input （Tensor） - 输入张量。

关键字参数

out （Tensor， optional） - 输出张量。

例：

>>> torch.special.erfc(torch.tensor([0, -1., 10.]))
tensor([ 1.0000, 1.8427,  0.0000])

torch.special 的erfcx（input， *， out=None） → 张量

计算 的每个元素的标度互补误差函数。 缩放的互补误差函数定义如下：input

$$\mathrm{erfcx}(x) = e^{x^2} \mathrm{erfc}(x)$$

参数

input （Tensor） - 输入张量。

关键字参数

out （Tensor， optional） - 输出张量。

例：

>>> torch.special.erfcx(torch.tensor([0, -1., 10.]))
tensor([ 1.0000, 5.0090, 0.0561])

torch.special 的erfinv（input， *， out=None） → 张量

计算 的反误差函数 。 逆误差函数在范围input$(-1, 1)$如：

$$\mathrm{erfinv}(\mathrm{erf}(x)) = x$$

参数

input （Tensor） - 输入张量。

关键字参数

out （Tensor， optional） - 输出张量。

例：

>>> torch.special.erfinv(torch.tensor([0, 0.5, -1.]))
tensor([ 0.0000,  0.4769,    -inf])

torch.special 的exp2（input， *， out=None） → 张量

计算 的 以 2 为底的指数函数。input

$$y_{i} = 2^{x_{i}}$$

参数

input （Tensor） - 输入张量。

关键字参数

out （Tensor， optional） - 输出张量。

例：

>>> torch.special.exp2(torch.tensor([0, math.log2(2.), 3, 4]))
tensor([ 1.,  2.,  8., 16.])

torch.special 的expit（input， *， out=None） → 张量

计算 的元素的 expit（也称为 Logistic sigmoid 函数）。input

$$\text{out}_{i} = \frac{1}{1 + e^{-\text{input}_{i}}}$$

参数

input （Tensor） - 输入张量。

关键字参数

out （Tensor， optional） - 输出张量。

例：

>>> t = torch.randn(4)
>>> t
tensor([ 0.9213,  1.0887, -0.8858, -1.7683])
>>> torch.special.expit(t)
tensor([ 0.7153,  0.7481,  0.2920,  0.1458])

torch.special 的expm1（input， *， out=None） → 张量

计算元素减 1 的指数 之。input

$$y_{i} = e^{x_{i}} - 1$$

注意

对于 x 的小值，此函数提供比 exp（x） - 1 更高的精度。

参数

input （Tensor） - 输入张量。

关键字参数

out （Tensor， optional） - 输出张量。

例：

>>> torch.special.expm1(torch.tensor([0, math.log(2.)]))
tensor([ 0.,  1.])

torch.special 的gammainc（input， other， *， out=None） → 张量

计算正则化的下不完全 gamma 函数：

$$\text{out}_{i} = \frac{1}{\Gamma(\text{input}_i)} \int_0^{\text{other}_i} t^{\text{input}_i-1} e^{-t} dt$$

其中两者$\text{input}_i$和$\text{other}_i$均为弱阳性 并且至少有一个是严格正的。 如果两者都为零或其中一个为负数，则$\text{out}_i=\text{nan}$.$\Gamma(\cdot)$在上面的方程中是 Gamma 函数，

$$\Gamma(\text{input}_i) = \int_0^\infty t^{(\text{input}_i-1)} e^{-t} dt.$$

请参阅 和 了解相关功能。

支持广播到通用形状和浮点输入。

注意

尚不支持 的向后传递。 请在 PyTorch 的 Github 上打开一个问题来请求它。input

参数

• input （Tensor） – 第一个非负输入张量

• other （Tensor） – 第二个非负输入张量

关键字参数

out （Tensor， optional） - 输出张量。

例：

>>> a1 = torch.tensor([4.0])
>>> a2 = torch.tensor([3.0, 4.0, 5.0])
>>> a = torch.special.gammaincc(a1, a2)
tensor([0.3528, 0.5665, 0.7350])
tensor([0.3528, 0.5665, 0.7350])
>>> b = torch.special.gammainc(a1, a2) + torch.special.gammaincc(a1, a2)
tensor([1., 1., 1.])

torch.special 的gammaincc（input， other， *， out=None） → 张量

计算正则化的上不完全 gamma 函数：

$$\text{out}_{i} = \frac{1}{\Gamma(\text{input}_i)} \int_{\text{other}_i}^{\infty} t^{\text{input}_i-1} e^{-t} dt$$

其中两者$\text{input}_i$和$\text{other}_i$均为弱阳性 并且至少有一个是严格正的。 如果两者都为零或其中一个为负数，则$\text{out}_i=\text{nan}$.$\Gamma(\cdot)$在上面的方程中是 Gamma 函数，

$$\Gamma(\text{input}_i) = \int_0^\infty t^{(\text{input}_i-1)} e^{-t} dt.$$

请参阅 和 了解相关功能。

支持广播到通用形状和浮点输入。

注意

尚不支持 的向后传递。 请在 PyTorch 的 Github 上打开一个问题来请求它。input

参数

• input （Tensor） – 第一个非负输入张量

• other （Tensor） – 第二个非负输入张量

关键字参数

out （Tensor， optional） - 输出张量。

例：

>>> a1 = torch.tensor([4.0])
>>> a2 = torch.tensor([3.0, 4.0, 5.0])
>>> a = torch.special.gammaincc(a1, a2)
tensor([0.6472, 0.4335, 0.2650])
>>> b = torch.special.gammainc(a1, a2) + torch.special.gammaincc(a1, a2)
tensor([1., 1., 1.])

torch.special 的gammaln（input， *， out=None） → 张量

计算 上 的 gamma 函数绝对值的自然对数。input

$$\text{out}_{i} = \ln \Gamma(|\text{input}_{i}|)$$

参数

input （Tensor） - 输入张量。

关键字参数

out （Tensor， optional） - 输出张量。

例：

>>> a = torch.arange(0.5, 2, 0.5)
>>> torch.special.gammaln(a)
tensor([ 0.5724,  0.0000, -0.1208])

torch.special 的i0（input， *， out=None） → 张量

计算 的每个元素的第一类零阶修正贝塞尔函数。input

$$\text{out}_{i} = I_0(\text{input}_{i}) = \sum_{k=0}^{\infty} \frac{(\text{input}_{i}^2/4)^k}{(k!)^2}$$

参数

input （Tensor） – 输入张量

关键字参数

out （Tensor， optional） - 输出张量。

例：

>>> torch.i0(torch.arange(5, dtype=torch.float32))
tensor([ 1.0000,  1.2661,  2.2796,  4.8808, 11.3019])

torch.special 的i0e（input， *， out=None） → 张量

计算第一类指数缩放的零阶修正贝塞尔函数（定义如下） 对于 的每个元素。input

$$\text{out}_{i} = \exp(-|x|) * i0(x) = \exp(-|x|) * \sum_{k=0}^{\infty} \frac{(\text{input}_{i}^2/4)^k}{(k!)^2}$$

参数

input （Tensor） - 输入张量。

关键字参数

out （Tensor， optional） - 输出张量。

例：：

>>> torch.special.i0e(torch.arange(5, dtype=torch.float32))
tensor([1.0000, 0.4658, 0.3085, 0.2430, 0.2070])

torch.special 的i1（input， *， out=None） → 张量

计算第一类的一阶修正贝塞尔函数（定义如下） 对于 的每个元素。input

$$\text{out}_{i} = \frac{(\text{input}_{i})}{2} * \sum_{k=0}^{\infty} \frac{(\text{input}_{i}^2/4)^k}{(k!) * (k+1)!}$$

参数

input （Tensor） - 输入张量。

关键字参数

out （Tensor， optional） - 输出张量。

例：：

>>> torch.special.i1(torch.arange(5, dtype=torch.float32))
tensor([0.0000, 0.5652, 1.5906, 3.9534, 9.7595])

torch.special 的i1e（input， *， out=None） → 张量

计算第一类指数缩放的一阶修正贝塞尔函数（定义如下） 对于 的每个元素。input

$$\text{out}_{i} = \exp(-|x|) * i1(x) = \exp(-|x|) * \frac{(\text{input}_{i})}{2} * \sum_{k=0}^{\infty} \frac{(\text{input}_{i}^2/4)^k}{(k!) * (k+1)!}$$

参数

input （Tensor） - 输入张量。

关键字参数

out （Tensor， optional） - 输出张量。

例：：

>>> torch.special.i1e(torch.arange(5, dtype=torch.float32))
tensor([0.0000, 0.2079, 0.2153, 0.1968, 0.1788])

torch.special 的log1p（input， *， out=None） → 张量

的别名 .

torch.special 的log_ndtr（input， *， out=None） → 张量

计算标准高斯概率密度函数下的面积对数， 从 minus infinity 到 ， Elementwise。input

$$\text{log\_ndtr}(x) = \log\left(\frac{1}{\sqrt{2 \pi}}\int_{-\infty}^{x} e^{-\frac{1}{2}t^2} dt \right)$$

参数

input （Tensor） - 输入张量。

关键字参数

out （Tensor， optional） - 输出张量。

例：：

>>> torch.special.log_ndtr(torch.tensor([-3., -2, -1, 0, 1, 2, 3]))
tensor([-6.6077 -3.7832 -1.841  -0.6931 -0.1728 -0.023  -0.0014])

torch.special 的log_softmax（input， dim， *， dtype=None） → 张量

计算 softmax，后跟对数。

虽然在数学上等同于 log（softmax（x）），但执行这两个 操作速度较慢且数值不稳定。此功能 计算公式为：

$$\text{log\_softmax}(x_{i}) = \log\left(\frac{\exp(x_i) }{ \sum_j \exp(x_j)} \right)$$

参数

• input （Tensor） – 输入

• dim （int） – 计算log_softmax的维度。

• dtype （， optional） – 返回的张量的所需数据类型。 如果指定，则输入张量将在操作之前强制转换为 执行。这对于防止数据类型溢出非常有用。默认值：None。dtype

例：：

>>> t = torch.ones(2, 2)
>>> torch.special.log_softmax(t, 0)
tensor([[-0.6931, -0.6931],
        [-0.6931, -0.6931]])

torch.special 的logit（input， eps=None， *， out=None） → 张量

返回一个新张量，其中包含 的元素的 logit 。 当 eps 不为 None 时，被限制为 [eps， 1 - eps]。 当 eps 为 None 且<为 0 或 > 1 时，该函数将产生 NaN。inputinputinputinput

$$\begin{align} y_{i} &= \ln(\frac{z_{i}}{1 - z_{i}}) \\ z_{i} &= \begin{cases} x_{i} & \text{if eps is None} \\ \text{eps} & \text{if } x_{i} < \text{eps} \\ x_{i} & \text{if } \text{eps} \leq x_{i} \leq 1 - \text{eps} \\ 1 - \text{eps} & \text{if } x_{i} > 1 - \text{eps} \end{cases} \end{align}$$

参数

• input （Tensor） - 输入张量。

• eps （float， optional） - input clamp bound的epsilon。违约：None

关键字参数

out （Tensor， optional） - 输出张量。

例：

>>> a = torch.rand(5)
>>> a
tensor([0.2796, 0.9331, 0.6486, 0.1523, 0.6516])
>>> torch.special.logit(a, eps=1e-6)
tensor([-0.9466,  2.6352,  0.6131, -1.7169,  0.6261])

torch.special 的logsumexp（input， dim， keepdim=False， *， out=None)

的别名 .

torch.special 的multigammaln（input， p， *， out=None） → 张量

计算维度为$p$元素方面，由下式给出

$$\log(\Gamma_{p}(a)) = C + \displaystyle \sum_{i=1}^{p} \log\left(\Gamma\left(a - \frac{i - 1}{2}\right)\right)$$

哪里$C = \log(\pi) \cdot \frac{p (p - 1)}{4}$和$\Gamma(-)$是 Gamma 函数。

所有元素都必须大于$\frac{p - 1}{2}$，否则行为为 undefiend。

参数

• input （Tensor） – 计算多元对数伽马函数的张量

• p （int） – 维度数

关键字参数

out （Tensor， optional） - 输出张量。

例：

>>> a = torch.empty(2, 3).uniform_(1, 2)
>>> a
tensor([[1.6835, 1.8474, 1.1929],
        [1.0475, 1.7162, 1.4180]])
>>> torch.special.multigammaln(a, 2)
tensor([[0.3928, 0.4007, 0.7586],
        [1.0311, 0.3901, 0.5049]])

torch.special 的ndtr（input， *， out=None） → 张量

计算标准高斯概率密度函数下的面积， 从 minus infinity 到 ， Elementwise。input

$$\text{ndtr}(x) = \frac{1}{\sqrt{2 \pi}}\int_{-\infty}^{x} e^{-\frac{1}{2}t^2} dt$$

参数

input （Tensor） - 输入张量。

关键字参数

out （Tensor， optional） - 输出张量。

例：：

>>> torch.special.ndtr(torch.tensor([-3., -2, -1, 0, 1, 2, 3]))
tensor([0.0013, 0.0228, 0.1587, 0.5000, 0.8413, 0.9772, 0.9987])

torch.special 的ndtri（input， *， out=None） → 张量

计算参数 x，其 Gaussian 概率密度函数下的面积 （从负无穷大到 x 的积分）等于 ，按元素。input

$$\text{ndtri}(p) = \sqrt{2}\text{erf}^{-1}(2p - 1)$$

注意

也称为正态分布的分位数函数。

参数

input （Tensor） - 输入张量。

关键字参数

out （Tensor， optional） - 输出张量。

例：：

>>> torch.special.ndtri(torch.tensor([0, 0.25, 0.5, 0.75, 1]))
tensor([   -inf, -0.6745,  0.0000,  0.6745,     inf])

torch.special 的polygamma（n， input， *， out=None） → 张量

计算$n^{th}$Digamma 函数的导数。input$n \geq 0$称为 Polygamma 函数的阶数。

$$\psi^{(n)}(x) = \frac{d^{(n)}}{dx^{(n)}} \psi(x)$$

注意

此函数仅对非负整数实现$n \geq 0$.

参数

• n （int） – Polygamma 函数的阶数

• input （Tensor） - 输入张量。

关键字参数

out （Tensor， optional） - 输出张量。

例：：

>>> a = torch.tensor([1, 0.5])
>>> torch.special.polygamma(1, a)
tensor([1.64493, 4.9348])
>>> torch.special.polygamma(2, a)
tensor([ -2.4041, -16.8288])
>>> torch.special.polygamma(3, a)
tensor([ 6.4939, 97.4091])
>>> torch.special.polygamma(4, a)
tensor([ -24.8863, -771.4742])

torch.special 的psi（input， *， out=None） → 张量

的别名 .

torch.special 的round（input， *， out=None） → 张量

的别名 .

torch.special 的scaled_modified_bessel_k0（input， *， out=None） → 张量

第二种阶的缩放修正贝塞尔函数$0$.

参数

input （Tensor） - 输入张量。

关键字参数

out （Tensor， optional） - 输出张量。

torch.special 的scaled_modified_bessel_k1（input， *， out=None） → 张量

第二种阶的缩放修正贝塞尔函数$1$.

参数

input （Tensor） - 输入张量。

关键字参数

out （Tensor， optional） - 输出张量。

torch.special 的sinc（input， *， out=None） → 张量

计算input.

$$\text{out}_{i} = \begin{cases} 1, & \text{if}\ \text{input}_{i}=0 \\ \sin(\pi \text{input}_{i}) / (\pi \text{input}_{i}), & \text{otherwise} \end{cases}$$

参数

input （Tensor） - 输入张量。

关键字参数

out （Tensor， optional） - 输出张量。

例：：

>>> t = torch.randn(4)
>>> t
tensor([ 0.2252, -0.2948,  1.0267, -1.1566])
>>> torch.special.sinc(t)
tensor([ 0.9186,  0.8631, -0.0259, -0.1300])

torch.special 的softmax（input， dim， *， dtype=None） → 张量

计算 softmax 函数。

Softmax 定义为：

$\text{Softmax}(x_{i}) = \frac{\exp(x_i)}{\sum_j \exp(x_j)}$

它应用于沿 dim 的所有切片，并将重新缩放它们，以便元素 位于 [0， 1] 范围内，总和为 1。

参数

• input （Tensor） – 输入

• dim （int） – 计算 softmax 所沿之的维度。

• dtype （， optional） – 返回的张量的所需数据类型。 如果指定，则输入张量将在操作之前强制转换为 执行。这对于防止数据类型溢出非常有用。默认值：None。dtype

例子：：

>>> t = torch.ones(2, 2)
>>> torch.special.softmax(t, 0)
tensor([[0.5000, 0.5000],
        [0.5000, 0.5000]])

torch.special 的spherical_bessel_j0（input， *， out=None） → 张量

第一阶球形贝塞尔函数$0$.

参数

input （Tensor） - 输入张量。

关键字参数

out （Tensor， optional） - 输出张量。

torch.special 的xlog1py（input， other， *， out=None） → 张量

在以下情况下进行计算。input * log1p(other)

$$\text{out}_{i} = \begin{cases} \text{NaN} & \text{if } \text{other}_{i} = \text{NaN} \\ 0 & \text{if } \text{input}_{i} = 0.0 \text{ and } \text{other}_{i} != \text{NaN} \\ \text{input}_{i} * \text{log1p}(\text{other}_{i})& \text{otherwise} \end{cases}$$

类似于 SciPy 的 scipy.special.xlog1py。

参数

• input （Number or Tensor） – 乘数

• other （Number 或 Tensor） – 参数

注意

至少有一个 或 必须是张量。inputother

关键字参数

out （Tensor， optional） - 输出张量。

例：

>>> x = torch.zeros(5,)
>>> y = torch.tensor([-1, 0, 1, float('inf'), float('nan')])
>>> torch.special.xlog1py(x, y)
tensor([0., 0., 0., 0., nan])
>>> x = torch.tensor([1, 2, 3])
>>> y = torch.tensor([3, 2, 1])
>>> torch.special.xlog1py(x, y)
tensor([1.3863, 2.1972, 2.0794])
>>> torch.special.xlog1py(x, 4)
tensor([1.6094, 3.2189, 4.8283])
>>> torch.special.xlog1py(2, y)
tensor([2.7726, 2.1972, 1.3863])

torch.special 的xlogy（input， other， *， out=None） → 张量

在以下情况下进行计算。input * log(other)

$$\text{out}_{i} = \begin{cases} \text{NaN} & \text{if } \text{other}_{i} = \text{NaN} \\ 0 & \text{if } \text{input}_{i} = 0.0 \\ \text{input}_{i} * \log{(\text{other}_{i})} & \text{otherwise} \end{cases}$$

类似于 SciPy 的 scipy.special.xlogy。

参数

• input （Number or Tensor） – 乘数

• other （Number 或 Tensor） – 参数

注意

至少有一个 或 必须是张量。inputother

关键字参数

out （Tensor， optional） - 输出张量。

例：

>>> x = torch.zeros(5,)
>>> y = torch.tensor([-1, 0, 1, float('inf'), float('nan')])
>>> torch.special.xlogy(x, y)
tensor([0., 0., 0., 0., nan])
>>> x = torch.tensor([1, 2, 3])
>>> y = torch.tensor([3, 2, 1])
>>> torch.special.xlogy(x, y)
tensor([1.0986, 1.3863, 0.0000])
>>> torch.special.xlogy(x, 4)
tensor([1.3863, 2.7726, 4.1589])
>>> torch.special.xlogy(2, y)
tensor([2.1972, 1.3863, 0.0000])

torch.special 的zeta（input， other， *， out=None） → 张量

按元素计算 Hurwitz zeta 函数。

$$\zeta(x, q) = \sum_{k=0}^{\infty} \frac{1}{(k + q)^x}$$

参数

• input （Tensor） – 对应于 x 的输入张量。

• other （Tensor） – 对应于 q 的输入张量。

注意

黎曼 zeta 函数对应于 q = 1 的情况

关键字参数

out （Tensor， optional） - 输出张量。

例：：

>>> x = torch.tensor([2., 4.])
>>> torch.special.zeta(x, 1)
tensor([1.6449, 1.0823])
>>> torch.special.zeta(x, torch.tensor([1., 2.]))
tensor([1.6449, 0.0823])
>>> torch.special.zeta(2, torch.tensor([1., 2.]))
tensor([1.6449, 0.6449])