BLAS and LAPACK Operations

torch.addbmm

torch.addbmm(beta=1, mat, alpha=1, batch1, batch2, out=None) → Tensor

对两个批batch1和batch2内存储的矩阵进行批矩阵乘操作，附带reduced add 步骤( 所有矩阵乘结果沿着第一维相加)。矩阵mat加到最终结果。 batch1和 batch2都为包含相同数量矩阵的3维张量。如果batch1是形为(b\times n \times m )的张量，batch1是形为(b\times m \times p )的张量，则out和mat的形状都是(n \times p )，即 ( res=(beta∗M)+(alpha∗sum(batch1_i@batch2_i,i=0,b)) )

对类型为 FloatTensor 或 DoubleTensor 的输入，alphaand beta必须为实数，否则两个参数须为整数。

参数：

beta (Number, optional) – 用于mat的乘子
mat (Tensor) – 相加矩阵
alpha (Number, optional) – 用于(batch1 @ batch2 )的乘子
batch1 (Tensor) – 第一批相乘矩阵
batch2 (Tensor) – 第二批相乘矩阵
out (Tensor, optional) – 输出张量

例子:

>>> M = torch.randn(3, 5)>>> batch1 = torch.randn(10, 3, 4)>>> batch2 = torch.randn(10, 4, 5)>>> torch.addbmm(M, batch1, batch2) -3.1162 11.0071 7.3102 0.1824 -7.6892 1.8265 6.0739 0.4589 -0.5641 -5.4283 -9.3387 -0.1794 -1.2318 -6.8841 -4.7239[torch.FloatTensor of size 3x5]

torch.addmm

torch.addmm(beta=1, mat, alpha=1, mat1, mat2, out=None) → Tensor

对矩阵mat1和mat2进行矩阵乘操作。矩阵mat加到最终结果。如果mat1 是一个 (n \times m )张量，mat2 是一个 (m \times p )张量，那么out和mat的形状为(n \times p )。 alpha 和 beta 分别是两个矩阵 (mat1 @ mat2 )和(mat )的比例因子，即， (out=(beta∗M)+(alpha∗mat1@mat2) )

对类型为 FloatTensor 或 DoubleTensor 的输入，betaand alpha必须为实数，否则两个参数须为整数。

参数：

beta (Number, optional) – 用于mat的乘子
mat (Tensor) – 相加矩阵
alpha (Number, optional) – 用于(mat1 @ mat2 )的乘子
mat1 (Tensor) – 第一个相乘矩阵
mat2 (Tensor) – 第二个相乘矩阵
out (Tensor, optional) – 输出张量

>>> M = torch.randn(2, 3)>>> mat1 = torch.randn(2, 3)>>> mat2 = torch.randn(3, 3)>>> torch.addmm(M, mat1, mat2)-0.4095 -1.9703 1.3561 5.7674 -4.9760 2.7378[torch.FloatTensor of size 2x3]

torch.addmv

torch.addmv(beta=1, tensor, alpha=1, mat, vec, out=None) → Tensor

对矩阵mat和向量vec对进行相乘操作。向量tensor加到最终结果。如果mat 是一个 (n \times m )维矩阵，vec 是一个 (m )维向量，那么out和mat的为(n )元向量。可选参数alpha 和 beta 分别是 (mat * vec )和(mat )的比例因子，即， ( out=(beta∗tensor)+(alpha∗(mat@vec)) )

对类型为FloatTensor或DoubleTensor的输入，alphaand beta必须为实数，否则两个参数须为整数。

参数：

beta (Number, optional) – 用于mat的乘子
mat (Tensor) – 相加矩阵
alpha (Number, optional) – 用于(mat1 @ vec )的乘子
mat (Tensor) – 相乘矩阵
vec (Tensor) – 相乘向量
out (Tensor, optional) – 输出张量

>>> M = torch.randn(2)>>> mat = torch.randn(2, 3)>>> vec = torch.randn(3)>>> torch.addmv(M, mat, vec)-2.0939-2.2950[torch.FloatTensor of size 2]

torch.addr

torch.addr(beta=1, mat, alpha=1, vec1, vec2, out=None) → Tensor

对向量vec1和vec2对进行张量积操作。矩阵mat加到最终结果。如果vec1 是一个 (n )维向量，vec2 是一个 (m )维向量，那么矩阵mat的形状须为(n \times m )。可选参数beta 和 alpha 分别是两个矩阵 (mat )和 (vec1 @ vec2 )的比例因子，即，( resi=(beta∗Mi)+(alpha∗batch1i×batch2i))

对类型为FloatTensor或DoubleTensor的输入，alphaand beta必须为实数，否则两个参数须为整数。

参数：

beta (Number, optional) – 用于mat的乘子
mat (Tensor) – 相加矩阵
alpha (Number, optional) – 用于两向量(vec1， vec2 )外积的乘子
vec1 (Tensor) – 第一个相乘向量
vec2 (Tensor) – 第二个相乘向量
out (Tensor, optional) – 输出张量

>>> vec1 = torch.arange(1, 4)>>> vec2 = torch.arange(1, 3)>>> M = torch.zeros(3, 2)>>> torch.addr(M, vec1, vec2) 1 2 2 4 3 6[torch.FloatTensor of size 3x2]

torch.baddbmm

torch.baddbmm(beta=1, mat, alpha=1, batch1, batch2, out=None) → Tensor

对两个批batch1和batch2内存储的矩阵进行批矩阵乘操作，矩阵mat加到最终结果。 batch1和 batch2都为包含相同数量矩阵的3维张量。如果batch1是形为(b\times n \times m )的张量，batch1是形为(b\times m \times p )的张量，则out和mat的形状都是(n \times p )，即 ( resi=(beta∗M_i)+(alpha∗batch1_i×batch2_i) )

对类型为FloatTensor或DoubleTensor的输入，alphaand beta必须为实数，否则两个参数须为整数。

参数：

beta (Number, optional) – 用于mat的乘子
mat (Tensor) – 相加矩阵
alpha (Number, optional) – 用于(batch1 @ batch2 )的乘子
batch1 (Tensor) – 第一批相乘矩阵
batch2 (Tensor) – 第二批相乘矩阵
out (Tensor, optional) – 输出张量

>>> M = torch.randn(10, 3, 5)>>> batch1 = torch.randn(10, 3, 4)>>> batch2 = torch.randn(10, 4, 5)>>> torch.baddbmm(M, batch1, batch2).size()torch.Size([10, 3, 5])

torch.bmm

torch.bmm(batch1, batch2, out=None) → Tensor

对存储在两个批batch1和batch2内的矩阵进行批矩阵乘操作。batch1和 batch2都为包含相同数量矩阵的3维张量。如果batch1是形为(b\times n \times m )的张量，batch1是形为(b\times m \times p )的张量，则out和mat的形状都是(n \times p )，即 ( res=(beta∗M)+(alpha∗sum(batch1_i@batch2_i,i=0,b)) )

对类型为 FloatTensor 或 DoubleTensor 的输入，alphaand beta必须为实数，否则两个参数须为整数。

参数：

batch1 (Tensor) – 第一批相乘矩阵
batch2 (Tensor) – 第二批相乘矩阵
out (Tensor, optional) – 输出张量

>>> batch1 = torch.randn(10, 3, 4)>>> batch2 = torch.randn(10, 4, 5)>>> res = torch.bmm(batch1, batch2)>>> res.size()torch.Size([10, 3, 5])

torch.btrifact

torch.btrifact(A, info=None) → Tensor, IntTensor

返回一个元组，包含LU 分解和pivots 。可选参数info决定是否对每个minibatch样本进行分解。info are from dgetrf and a non-zero value indicates an error occurred. 如果用CUDA的话，这个值来自于CUBLAS，否则来自LAPACK。

参数： A (Tensor) – 待分解张量

>>> A = torch.randn(2, 3, 3)>>> A_LU = A.btrifact()

torch.btrisolve

torch.btrisolve(b, LU_data, LU_pivots) → Tensor

返回线性方程组( Ax = b )的LU解。

参数：

b (Tensor) – RHS 张量.
LU_data (Tensor) – Pivoted LU factorization of A from btrifact.
LU_pivots (IntTensor) – LU 分解的Pivots.

例子：

>>> A = torch.randn(2, 3, 3)>>> b = torch.randn(2, 3)>>> A_LU = torch.btrifact(A)>>> x = b.btrisolve(*A_LU)>>> torch.norm(A.bmm(x.unsqueeze(2)) - b)6.664001874625056e-08

torch.dot

torch.dot(tensor1, tensor2) → float

计算两个张量的点乘(内乘),两个张量都为1-D 向量.

例子：

>>> torch.dot(torch.Tensor([2, 3]), torch.Tensor([2, 1]))7.0

torch.eig

torch.eig(a, eigenvectors=False, out=None) -> (Tensor, Tensor)

计算实方阵a 的特征值和特征向量

参数：

a (Tensor) – 方阵，待计算其特征值和特征向量
eigenvectors (bool) – 布尔值，如果True，则同时计算特征值和特征向量，否则只计算特征值。
out (tuple, optional) – 输出元组

返回值：元组，包括：

e (Tensor): a 的右特征向量
v (Tensor): 如果eigenvectors为True，则为包含特征向量的张量; 否则为空张量

返回值类型： (Tensor, Tensor)

torch.gels

torch.gels(B, A, out=None) → Tensor

对形如( m \times n )的满秩矩阵a计算其最小二乘和最小范数问题的解。如果( m >= n ),gels对最小二乘问题进行求解，即：

$$minimize \qquad ‖AX - B‖_F $$

如果( m < n ),gels求解最小范数问题，即：

$$minimize \qquad ‖ X ‖_F \qquad subject \ to \quad a \quad b AX=B $$

返回矩阵(X )的前(n ) 行包含解。余下的行包含以下残差信息: 相应列从第n 行开始计算的每列的欧式距离。

注意：返回矩阵总是被转置，无论输入矩阵的原始布局如何，总会被转置；即，总是有 stride (1, m) 而不是 (m, 1).

参数：

B (Tensor) – 矩阵B
A (Tensor) – ( m \times n )矩阵
out (tuple, optional) – 输出元组

返回值：元组，包括：

X (Tensor): 最小二乘解
qr (Tensor): QR 分解的细节

返回值类型： (Tensor, Tensor)

例子：

>>> A = torch.Tensor([[1, 1, 1],... [2, 3, 4],... [3, 5, 2],... [4, 2, 5],... [5, 4, 3]])>>> B = torch.Tensor([[-10, -3], [ 12, 14], [ 14, 12], [ 16, 16], [ 18, 16]])>>> X, _ = torch.gels(B, A)>>> X2.0000 1.00001.0000 1.00001.0000 2.0000[torch.FloatTensor of size 3x2]

torch.geqrf

torch.geqrf(input, out=None) -> (Tensor, Tensor)

这是一个直接调用LAPACK的底层函数。一般使用torch.qr()

计算输入的QR 分解，但是并不会分别创建Q,R两个矩阵，而是直接调用LAPACK 函数 Rather, this directly calls the underlying LAPACK function ?geqrf which produces a sequence of ‘elementary reflectors’.

参考 LAPACK文档获取更详细信息。

参数:

input (Tensor) – 输入矩阵
out (tuple, optional) – 元组，包含输出张量 (Tensor, Tensor)

torch.ger

torch.ger(vec1, vec2, out=None) → Tensor

计算两向量vec1,vec2的张量积。如果vec1的长度为n,vec2长度为m，则输出out应为形如n x m的矩阵。

参数:

vec1 (Tensor) – 1D 输入向量
vec2 (Tensor) – 1D 输入向量
out (tuple, optional) – 输出张量

例子：

>>> v1 = torch.arange(1, 5)>>> v2 = torch.arange(1, 4)>>> torch.ger(v1, v2) 1 2 3 2 4 6 3 6 9 4 8 12[torch.FloatTensor of size 4x3]

torch.gesv

torch.gesv(B, A, out=None) -> (Tensor, Tensor)

( X, LU = torch.gesv(B, A) )，返回线性方程组(AX=B )的解。

LU 包含两个矩阵L，U。A须为非奇异方阵，如果A是一个( m \times m )矩阵，B 是( m \times k )矩阵，则LU 是( m \times m )矩阵， X为( m \times k )矩阵

参数：

B (Tensor) – ( m \times k )矩阵
A (Tensor) – ( m \times m )矩阵
out (Tensor, optional) – 可选地输出矩阵( X )

例子:

>>> A = torch.Tensor([[6.80, -2.11, 5.66, 5.97, 8.23],... [-6.05, -3.30, 5.36, -4.44, 1.08],... [-0.45, 2.58, -2.70, 0.27, 9.04],... [8.32, 2.71, 4.35, -7.17, 2.14],... [-9.67, -5.14, -7.26, 6.08, -6.87]]).t()>>> B = torch.Tensor([[4.02, 6.19, -8.22, -7.57, -3.03],... [-1.56, 4.00, -8.67, 1.75, 2.86],... [9.81, -4.09, -4.57, -8.61, 8.99]]).t()>>> X, LU = torch.gesv(B, A)>>> torch.dist(B, torch.mm(A, X))9.250057093890353e-06

torch.inverse

torch.inverse(input, out=None) → Tensor

对方阵输入input 取逆。

注意： Irrespective of the original strides, the returned matrix will be transposed, i.e. with strides (1, m) instead of (m, 1)

参数：

input (Tensor) – 输入2维张量
out (Tensor, optional) – 输出张量

例子:

>>> x = torch.rand(10, 10)>>> x 0.7800 0.2267 0.7855 0.9479 0.5914 0.7119 0.4437 0.9131 0.1289 0.1982 0.0045 0.0425 0.2229 0.4626 0.6210 0.0207 0.6338 0.7067 0.6381 0.8196 0.8350 0.7810 0.8526 0.9364 0.7504 0.2737 0.0694 0.5899 0.8516 0.3883 0.6280 0.6016 0.5357 0.2936 0.7827 0.2772 0.0744 0.2627 0.6326 0.9153 0.7897 0.0226 0.3102 0.0198 0.9415 0.9896 0.3528 0.9397 0.2074 0.6980 0.5235 0.6119 0.6522 0.3399 0.3205 0.5555 0.8454 0.3792 0.4927 0.6086 0.1048 0.0328 0.5734 0.6318 0.9802 0.4458 0.0979 0.3320 0.3701 0.0909 0.2616 0.3485 0.4370 0.5620 0.5291 0.8295 0.7693 0.1807 0.0650 0.8497 0.1655 0.2192 0.6913 0.0093 0.0178 0.3064 0.6715 0.5101 0.2561 0.3396 0.4370 0.4695 0.8333 0.1180 0.4266 0.4161 0.0699 0.4263 0.8865 0.2578[torch.FloatTensor of size 10x10]>>> x = torch.rand(10, 10)>>> y = torch.inverse(x)>>> z = torch.mm(x, y)>>> z 1.0000 0.0000 0.0000 -0.0000 0.0000 0.0000 0.0000 0.0000 -0.0000 -0.0000 0.0000 1.0000 -0.0000 0.0000 0.0000 0.0000 -0.0000 -0.0000 -0.0000 -0.0000 0.0000 0.0000 1.0000 -0.0000 -0.0000 0.0000 0.0000 0.0000 -0.0000 -0.0000 0.0000 0.0000 0.0000 1.0000 0.0000 0.0000 0.0000 -0.0000 -0.0000 0.0000 0.0000 0.0000 -0.0000 -0.0000 1.0000 0.0000 0.0000 -0.0000 -0.0000 -0.0000 0.0000 0.0000 0.0000 -0.0000 0.0000 1.0000 -0.0000 -0.0000 -0.0000 -0.0000 0.0000 0.0000 0.0000 -0.0000 0.0000 0.0000 1.0000 0.0000 -0.0000 0.0000 0.0000 0.0000 -0.0000 -0.0000 0.0000 0.0000 -0.0000 1.0000 -0.0000 0.0000-0.0000 0.0000 -0.0000 -0.0000 0.0000 0.0000 -0.0000 -0.0000 1.0000 -0.0000-0.0000 0.0000 -0.0000 -0.0000 -0.0000 0.0000 -0.0000 -0.0000 0.0000 1.0000[torch.FloatTensor of size 10x10]>>> torch.max(torch.abs(z - torch.eye(10))) # Max nonzero5.096662789583206e-07

torch.mm

torch.mm(mat1, mat2, out=None) → Tensor

对矩阵mat1和mat2进行相乘。如果mat1 是一个( n \times m ) 张量，mat2 是一个 ( m \times p ) 张量，将会输出一个 ( n \times p ) 张量out。

参数：

mat1 (Tensor) – 第一个相乘矩阵
mat2 (Tensor) – 第二个相乘矩阵
out (Tensor, optional) – 输出张量

例子:

>>> mat1 = torch.randn(2, 3)>>> mat2 = torch.randn(3, 3)>>> torch.mm(mat1, mat2) 0.0519 -0.3304 1.2232 4.3910 -5.1498 2.7571[torch.FloatTensor of size 2x3]

torch.mv

torch.mv(mat, vec, out=None) → Tensor

对矩阵mat和向量vec进行相乘。如果mat 是一个( n \times m )张量，vec 是一个( m )元 1维张量，将会输出一个( n ) 元 1维张量。

参数：

mat (Tensor) – 相乘矩阵
vec (Tensor) – 相乘向量
out (Tensor, optional) – 输出张量

例子:

>>> mat = torch.randn(2, 3)>>> vec = torch.randn(3)>>> torch.mv(mat, vec)-2.0939-2.2950[torch.FloatTensor of size 2]

torch.orgqr

torch.orgqr()

torch.ormqr

torch.ormqr()

torch.potrf

torch.potrf()

torch.potri

torch.potri()

torch.potrs

torch.potrs()

torch.pstrf

torch.pstrf()

torch.qr

torch.qr(input, out=None) -> (Tensor, Tensor)

计算输入矩阵的QR分解：返回两个矩阵( q ) ,( r )，使得 ( x=q∗r ) ，这里( q ) 是一个半正交矩阵与 ( r ) 是一个上三角矩阵

本函数返回一个thin(reduced)QR分解。

注意如果输入很大，可能可能会丢失精度。

注意本函数依赖于你的LAPACK实现，虽然总能返回一个合法的分解，但不同平台可能得到不同的结果。

Irrespective of the original strides, the returned matrix q will be transposed, i.e. with strides (1, m) instead of (m, 1).

参数：

input (Tensor) – 输入的2维张量
out (tuple, optional) – 输出元组tuple，包含Q和R

例子:

>>> a = torch.Tensor([[12, -51, 4], [6, 167, -68], [-4, 24, -41]])>>> q, r = torch.qr(a)>>> q-0.8571 0.3943 0.3314-0.4286 -0.9029 -0.0343 0.2857 -0.1714 0.9429[torch.FloatTensor of size 3x3]>>> r -14.0000 -21.0000 14.0000 0.0000 -175.0000 70.0000 0.0000 0.0000 -35.0000[torch.FloatTensor of size 3x3]>>> torch.mm(q, r).round() 12 -51 4 6 167 -68 -4 24 -41[torch.FloatTensor of size 3x3]>>> torch.mm(q.t(), q).round() 1 -0 0-0 1 0 0 0 1[torch.FloatTensor of size 3x3]

torch.svd

torch.svd(input, some=True, out=None) -> (Tensor, Tensor, Tensor)

(U, S, V = torch.svd(A) )。返回对形如 (n \times m )的实矩阵 A 进行奇异值分解的结果，使得 (A=USV′∗ )。 (U ) 形状为 (n \times n )，(S ) 形状为 (n \times m ) ，(V ) 形状为 (m \times m )

some 代表了需要计算的奇异值数目。如果 some=True, it computes some and some=False computes all.

Irrespective of the original strides, the returned matrix U will be transposed, i.e. with strides (1, n) instead of (n, 1).

参数：

input (Tensor) – 输入的2维张量
some (bool, optional) – 布尔值，控制需计算的奇异值数目
out (tuple, optional) – 结果tuple

例子：

>>> a = torch.Tensor([[8.79, 6.11, -9.15, 9.57, -3.49, 9.84],... [9.93, 6.91, -7.93, 1.64, 4.02, 0.15],... [9.83, 5.04, 4.86, 8.83, 9.80, -8.99],... [5.45, -0.27, 4.85, 0.74, 10.00, -6.02],... [3.16, 7.98, 3.01, 5.80, 4.27, -5.31]]).t()>>> a 8.7900 9.9300 9.8300 5.4500 3.1600 6.1100 6.9100 5.0400 -0.2700 7.9800 -9.1500 -7.9300 4.8600 4.8500 3.0100 9.5700 1.6400 8.8300 0.7400 5.8000 -3.4900 4.0200 9.8000 10.0000 4.2700 9.8400 0.1500 -8.9900 -6.0200 -5.3100[torch.FloatTensor of size 6x5]>>> u, s, v = torch.svd(a)>>> u-0.5911 0.2632 0.3554 0.3143 0.2299-0.3976 0.2438 -0.2224 -0.7535 -0.3636-0.0335 -0.6003 -0.4508 0.2334 -0.3055-0.4297 0.2362 -0.6859 0.3319 0.1649-0.4697 -0.3509 0.3874 0.1587 -0.5183 0.2934 0.5763 -0.0209 0.3791 -0.6526[torch.FloatTensor of size 6x5]>>> s 27.4687 22.6432 8.5584 5.9857 2.0149[torch.FloatTensor of size 5]>>> v-0.2514 0.8148 -0.2606 0.3967 -0.2180-0.3968 0.3587 0.7008 -0.4507 0.1402-0.6922 -0.2489 -0.2208 0.2513 0.5891-0.3662 -0.3686 0.3859 0.4342 -0.6265-0.4076 -0.0980 -0.4932 -0.6227 -0.4396[torch.FloatTensor of size 5x5]>>> torch.dist(a, torch.mm(torch.mm(u, torch.diag(s)), v.t()))8.934150226306685e-06

torch.symeig

torch.symeig(input, eigenvectors=False, upper=True, out=None) -> (Tensor, Tensor)

(e, V = torch.symeig(input)) 返回实对称矩阵input的特征值和特征向量。

(input) 和 (V) 为 (m \times m) 矩阵，(e ) 是一个(m) 维向量。此函数计算intput的所有特征值(和特征向量)，使得 (input = V diag(e) V’)布尔值参数eigenvectors 规定是否只计算特征向量。如果为False，则只计算特征值；若设为True，则两者都会计算。因为输入矩阵 ( input) 是对称的，所以默认只需要上三角矩阵。如果参数upper为 False，下三角矩阵部分也被利用。

注意: 不管原来Irrespective of the original strides, the returned matrix V will be transposed, i.e. with strides (1, m) instead of (m, 1)

参数：

input (Tensor) – 输入对称矩阵
eigenvectors (boolean, optional) – 布尔值（可选），控制是否计算特征向量
upper (boolean, optional) – 布尔值（可选），控制是否考虑上三角或下三角区域
out (tuple, optional) – 输出元组(Tensor, Tensor)

例子：

>>> a = torch.Tensor([[ 1.96, 0.00, 0.00, 0.00, 0.00],... [-6.49, 3.80, 0.00, 0.00, 0.00],... [-0.47, -6.39, 4.17, 0.00, 0.00],... [-7.20, 1.50, -1.51, 5.70, 0.00],... [-0.65, -6.34, 2.67, 1.80, -7.10]]).t()>>> e, v = torch.symeig(a, eigenvectors=True)>>> e-11.0656 -6.2287 0.8640 8.8655 16.0948[torch.FloatTensor of size 5]>>> v-0.2981 -0.6075 0.4026 -0.3745 0.4896-0.5078 -0.2880 -0.4066 -0.3572 -0.6053-0.0816 -0.3843 -0.6600 0.5008 0.3991-0.0036 -0.4467 0.4553 0.6204 -0.4564-0.8041 0.4480 0.1725 0.3108 0.1622[torch.FloatTensor of size 5x5]

torch.trtrs

torch.trtrs()

BLAS and LAPACK Operations