BLAS和LAPACK操作

译者：ApacheCN

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

执行存储在batch1和batch2中的矩阵的批量矩阵 - 矩阵乘积，减少加法步骤(所有矩阵乘法沿第一维积累）。 mat被添加到最终结果中。

batch1和batch2必须是3-D张量，每个张量包含相同数量的矩阵。

如果batch1是 张量，batch2是 张量，mat必须是可广播和 张量和out将是 张量。

对于FloatTensor或DoubleTensor类型的输入，参数beta和alpha必须是实数，否则它们应该是整数。

参数：

• beta (编号 ， 任选） - mat ()的乘数
• mat (Tensor） - 要添加的基质
• alpha (数 ， 任选） - batch1 @ batch2 ()的乘数
• batch1 (Tensor） - 第一批要乘的矩阵
• batch2 (Tensor） - 第二批矩阵被乘以
• out (Tensor， 任选） - 输出张量

例：

>>> M = torch.randn(3, 5)
>>> batch1 = torch.randn(10, 3, 4)
>>> batch2 = torch.randn(10, 4, 5)
>>> torch.addbmm(M, batch1, batch2)
tensor([[  6.6311,   0.0503,   6.9768, -12.0362,  -2.1653],
 [ -4.8185,  -1.4255,  -6.6760,   8.9453,   2.5743],
 [ -3.8202,   4.3691,   1.0943,  -1.1109,   5.4730]])

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

执行矩阵mat1和mat2的矩阵乘法。矩阵mat被添加到最终结果中。

如果mat1是 张量，mat2是 张量，那么mat必须是可广播和 [] 张量和out将是 张量。

alpha和beta分别是mat1和：attr mat2与添加的基质mat之间的基质 - 载体产物的比例因子。

For inputs of type FloatTensor or DoubleTensor, arguments beta and alpha must be real numbers, otherwise they should be integers.

Parameters:

• beta (编号 ， 任选） - mat ()的乘数
• mat (Tensor） - 要添加的基质
• alpha (编号 ， 任选） - ()的乘数
• mat1 (Tensor） - 第一个被乘法的矩阵
• mat2 (Tensor） - 要倍增的第二个矩阵
• out (Tensor， 任选） - 输出张量

Example:

>>> M = torch.randn(2, 3)
>>> mat1 = torch.randn(2, 3)
>>> mat2 = torch.randn(3, 3)
>>> torch.addmm(M, mat1, mat2)
tensor([[-4.8716,  1.4671, -1.3746],
 [ 0.7573, -3.9555, -2.8681]])

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

执行矩阵mat和向量vec的矩阵向量乘积。将载体 tensor 添加到最终结果中。

如果mat是 张量，vec是大小为m的1-D张量，则 tensor 必须是可广播具有1-D张量的n和out将是1-D张量的大小n。

alpha和beta分别是mat和vec之间的基质 - 载体产物和加入的张量 tensor 的比例因子。

对于FloatTensor或DoubleTensor类型的输入，参数beta和alpha必须是实数，否则它们应该是整数

Parameters:

• beta (， 任选） - tensor ()的乘数
• 张量 (Tensor） - 要添加的载体
• alpha (编号 ， 任选） - ()的乘数
• mat (Tensor） - 矩阵成倍增加
• vec (Tensor） - 载体倍增
• out (Tensor， 任选） - 输出张量

Example:

>>> M = torch.randn(2)
>>> mat = torch.randn(2, 3)
>>> vec = torch.randn(3)
>>> torch.addmv(M, mat, vec)
tensor([-0.3768, -5.5565])

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

执行向量vec1和vec2的外积并将其添加到矩阵mat。

可选值beta和alpha分别是vec1和vec2之间的外积和添加的矩阵mat的缩放因子。

如果vec1是大小为n的矢量而vec2是大小为m的矢量，那么mat必须是可广播的，其大小为矩阵 和out将是大小 的基质。

For inputs of type FloatTensor or DoubleTensor, arguments beta and alpha must be real numbers, otherwise they should be integers

Parameters:

• beta (编号 ， 任选） - mat ()的乘数
• mat (Tensor） - 要添加的基质
• alpha (编号 ， 任选） - ()的乘数
• vec1 (Tensor） - 外部产品的第一个载体
• vec2 (Tensor） - 外产品的第二个载体
• out (Tensor， 任选） - 输出张量

Example:

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

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

在batch1和batch2中执行矩阵的批量矩阵 - 矩阵乘积。 mat被添加到最终结果中。

batch1 and batch2 must be 3-D tensors each containing the same number of matrices.

如果batch1是 张量，batch2是 张量，那么mat必须是可广播和 [] 张量和out将是 张量。 alpha和beta均与 torch.addbmm() 中使用的比例因子相同。

For inputs of type FloatTensor or DoubleTensor, arguments beta and alpha must be real numbers, otherwise they should be integers.

Parameters:

• beta (编号 ， 任选） - mat ()的乘数
• 垫 (Tensor） - 要加的张量
• alpha (编号 ， 任选） - ()的乘数
• batch1 (Tensor） - 第一批要乘的矩阵
• batch2 (Tensor） - 第二批矩阵被乘以
• out (Tensor， 任选） - 输出张量

Example:

>>> 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(batch1, batch2, out=None) → Tensor

执行存储在batch1和batch2中的矩阵的批量矩阵 - 矩阵乘积。

batch1 and batch2 must be 3-D tensors each containing the same number of matrices.

如果batch1是 张量，batch2是 张量，out将是 张量。

注意

此功能不广播。有关广播矩阵产品，请参阅 torch.matmul() 。

Parameters:

• batch1 (Tensor） - 第一批要乘的矩阵
• batch2 (Tensor） - 第二批矩阵被乘以
• out (Tensor， 任选） - 输出张量

Example:

>>> 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(A, info=None, pivot=True)

批量LU分解。

返回包含LU分解和枢轴的元组。如果设置了pivot，则完成旋转。

如果每个minibatch示例的分解成功，则可选参数info存储信息。 info作为IntTensor提供，其值将从dgetrf填充，非零值表示发生错误。具体来说，如果使用cuda，则值来自cublas，否则为LAPACK。

警告

info参数不推荐使用 torch.btrifact_with_info() 。

Parameters:

• A (tensor) - 因子的张量
• info (IntTensor ， 可选） - (弃用）IntTensor存储指示分解是否成功的值
• pivot (bool， 可选） - 控制是否完成旋转

Example:

>>> A = torch.randn(2, 3, 3)
>>> A_LU, pivots = torch.btrifact(A)
>>> A_LU
tensor([[[ 1.3506,  2.5558, -0.0816],
 [ 0.1684,  1.1551,  0.1940],
 [ 0.1193,  0.6189, -0.5497]],
 [[ 0.4526,  1.2526, -0.3285],
 [-0.7988,  0.7175, -0.9701],
 [ 0.2634, -0.9255, -0.3459]]])
>>> pivots
tensor([[ 3,  3,  3],
 [ 3,  3,  3]], dtype=torch.int32)

torch.btrifact_with_info(A, pivot=True) -> (Tensor, IntTensor, IntTensor)

批量LU分解和其他错误信息。

这是 torch.btrifact() 的一个版本，它始终创建一个info IntTensor，并将其作为第三个返回值返回。

Parameters:

• A (tensor) - 因子的张量
• pivot (bool， 可选） - 控制是否完成旋转

Example:

>>> A = torch.randn(2, 3, 3)
>>> A_LU, pivots, info = A.btrifact_with_info()
>>> if info.nonzero().size(0) == 0:
>>>   print('LU factorization succeeded for all samples!')
LU factorization succeeded for all samples!

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

批量LU解决。

返回线性系统 的LU求解。

Parameters:

• b (tensor) - RHS张量
• LU_data (Tensor） - 来自 btrifact() 的A的旋转LU分解。
• LU_pivots (IntTensor ) - LU分解的关键点

Example:

>>> A = torch.randn(2, 3, 3)
>>> b = torch.randn(2, 3)
>>> A_LU = torch.btrifact(A)
>>> x = torch.btrisolve(b, *A_LU)
>>> torch.norm(torch.bmm(A, x.unsqueeze(2)) - b.unsqueeze(2))
tensor(1.00000e-07 *
 2.8312)

torch.btriunpack(LU_data, LU_pivots, unpack_data=True, unpack_pivots=True)

从张量的分段LU分解(btrifact）解包数据和枢轴。

返回张量的元组作为(the pivots, the L tensor, the U tensor)。

Parameters:

• LU_data (Tensor） - 打包的LU分解数据
• LU_pivots (Tensor） - 打包的LU分解枢轴
• unpack_data (bool） - 指示数据是否应解包的标志
• unpack_pivots (bool） - 指示枢轴是否应解包的标志

Example:

>>> A = torch.randn(2, 3, 3)
>>> A_LU, pivots = A.btrifact()
>>> P, A_L, A_U = torch.btriunpack(A_LU, pivots)
>>>
>>> # can recover A from factorization
>>> A_ = torch.bmm(P, torch.bmm(A_L, A_U))

torch.chain_matmul(*matrices)

返回 2-D张量的矩阵乘积。使用矩阵链序算法有效地计算该乘积，该算法选择在算术运算方面产生最低成本的顺序 ([CLRS])。请注意，由于这是计算产品的函数， 需要大于或等于2;如果等于2，则返回一个平凡的矩阵 - 矩阵乘积。如果 为1，那么这是一个无操作 - 原始矩阵按原样返回。

参数：	矩阵(张量… ) - 2个或更多个2-D张量的序列，其产物将被确定。
返回：	如果 张量具有 的维度，则产物的尺寸为 。
返回类型：	Tensor

Example:

>>> a = torch.randn(3, 4)
>>> b = torch.randn(4, 5)
>>> c = torch.randn(5, 6)
>>> d = torch.randn(6, 7)
>>> torch.chain_matmul(a, b, c, d)
tensor([[ -2.3375,  -3.9790,  -4.1119,  -6.6577,   9.5609, -11.5095,  -3.2614],
 [ 21.4038,   3.3378,  -8.4982,  -5.2457, -10.2561,  -2.4684,   2.7163],
 [ -0.9647,  -5.8917,  -2.3213,  -5.2284,  12.8615, -12.2816,  -2.5095]])

torch.cholesky(A, upper=False, out=None) → Tensor

计算对称正定矩阵 的Cholesky分解或对称批正对称正定矩阵。

如果upper为True，则返回的矩阵U为上三角形，分解的形式为：

如果upper为False，则返回的矩阵L为低三角形，分解的形式为：

如果upper是True，并且A是一批对称正定矩阵，则返回的张量将由每个单独矩阵的上三角形Cholesky因子组成。类似地，当upper是False时，返回的张量将由每个单个矩阵的下三角形Cholesky因子组成。

Parameters:

• a (tensor) - 输入张量大小 (* ，n，n）其中*为零或更多批由对称正定矩阵组成的维数。
• 上 (bool， 可选） - 表示是否返回上下三角矩阵的标志。默认值：False
• out (Tensor， 可选） - 输出矩阵

Example:

>>> a = torch.randn(3, 3)
>>> a = torch.mm(a, a.t()) # make symmetric positive-definite
>>> l = torch.cholesky(a)
>>> a
tensor([[ 2.4112, -0.7486,  1.4551],
 [-0.7486,  1.3544,  0.1294],
 [ 1.4551,  0.1294,  1.6724]])
>>> l
tensor([[ 1.5528,  0.0000,  0.0000],
 [-0.4821,  1.0592,  0.0000],
 [ 0.9371,  0.5487,  0.7023]])
>>> torch.mm(l, l.t())
tensor([[ 2.4112, -0.7486,  1.4551],
 [-0.7486,  1.3544,  0.1294],
 [ 1.4551,  0.1294,  1.6724]])
>>> a = torch.randn(3, 2, 2)
>>> a = torch.matmul(a, a.transpose(-1, -2)) + 1e-03 # make symmetric positive-definite
>>> l = torch.cholesky(a)
>>> z = torch.matmul(l, l.transpose(-1, -2))
>>> torch.max(torch.abs(z - a)) # Max non-zero
tensor(2.3842e-07)

torch.dot(tensor1, tensor2) → Tensor

计算两个张量的点积(内积）。

Note

此功能不广播。

Example:

>>> torch.dot(torch.tensor([2, 3]), torch.tensor([2, 1]))
tensor(7)

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

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

Parameters:

• a (Tensor） - 形状 的方阵，其特征值和特征向量将被计算
• 特征向量 (bool） - True计算特征值和特征向量;否则，只计算特征值
• out (元组 ， 任选） - 输出张量

|返回：|包含元组的元组

＆GT; e (tensor）：形状 。每行是a的特征值，其中第一个元素是实部，第二个元素是虚部。特征值不一定是有序的。 ＆GT; v (Tensor )：如果eigenvectors=False，它是一个空张量。否则，该张量形状 可用于计算相应特征值e的归一化(单位长度）特征向量，如下所述。如果对应的e [j]是实数，则列v [：，j]是对应于特征值e [j]的特征向量。如果相应的e [j]和e [j + 1]特征值形成复共轭对，那么真实的特征向量可以被计算为 ， 。

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

计算大小 的全秩矩阵 和大小的矩阵 的最小二乘和最小范数问题的解决方案 。

如果 ， gels() 解决了最小二乘问题：

如果 ， gels() 解决了最小范数问题：

返回张量 具有 的形状。 的第一 行包含该溶液。如果 ，则每列中溶液的残余平方和由该列的剩余 行中的元素的平方和给出。

Parameters:

• B (tensor) - 基质
• (tensor) -
• out (元组 ， 可选） - 可选目的地张量

|返回：|包含以下内容的元组：

＆GT; X (tensor）：最小二乘解＆gt; qr (Tensor )：QR分解的细节

Note

无论输入矩阵的步幅如何，返回的矩阵将始终被转置。也就是说，他们将有(1, m)而不是(m, 1)。

Example:

>>> 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)
>>> X
tensor([[  2.0000,   1.0000],
 [  1.0000,   1.0000],
 [  1.0000,   2.0000],
 [ 10.9635,   4.8501],
 [  8.9332,   5.2418]])

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

这是一个直接调用LAPACK的低级函数。

您通常希望使用 torch.qr() 。

计算input的QR分解，但不构造 和 作为显式单独的矩阵。

相反，这直接调用底层LAPACK函数?geqrf，它产生一系列“基本反射器”。

有关详细信息，请参阅geqrf 的 LAPACK文档。

Parameters:

• 输入 (Tensor） - 输入矩阵
• out (元组 ， 可选） - 输出元组(Tensor，Tensor）

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

vec1和vec2的外产物。如果vec1是大小 的载体，vec2是大小 的载体，那么out必须是大小的矩阵 。

Note

This function does not broadcast.

Parameters:

• vec1 (tensor) - 1-D输入向量
• vec2 (tensor) - 1-D输入向量
• out (Tensor， 可选） - 可选输出矩阵

Example:

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

torch.gesv(B, A) -> (Tensor, Tensor)

该函数将解决方案返回到由 表示的线性方程组和A的LU分解，按顺序作为元组X, LU。

LU包含A的LU分解的L和U因子。

torch.gesv(B, A)可以接收2D输入B, A或两批2D矩阵的输入。如果输入是批次，则返回批量输出X, LU。

Note

out关键字仅支持2D矩阵输入，即B, A必须是2D矩阵。

Note

不管原始步幅如何，返回的矩阵X和LU将被转置，即分别具有诸如B.contiguous().transpose(-1, -2).strides()和A.contiguous().transpose(-1, -2).strides()的步幅。

Parameters:

• B (Tensor） - 大小 的输入矩阵，其中 为零或批量维度更多。
• A (tensor) - 输入方形矩阵 ，其中 为零或更多批量维度。
• 出(( tensor ， tensor ]）__， 可选） - 可选输出元组。

Example:

>>> 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))
tensor(1.00000e-06 *
 7.0977)
>>> # Batched solver example
>>> A = torch.randn(2, 3, 1, 4, 4)
>>> B = torch.randn(2, 3, 1, 4, 6)
>>> X, LU = torch.gesv(B, A)
>>> torch.dist(B, A.matmul(X))
tensor(1.00000e-06 *
 3.6386)

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

采用方阵input的倒数。 input可以是2D方形张量的批次，在这种情况下，该函数将返回由单个反转组成的张量。

Note

无论原始步幅如何，返回的张量都将被转置，即像input.contiguous().transpose(-2, -1).strides()这样的步幅

Parameters:

• 输入 (Tensor） - 输入张量大小 (* ，n，n）其中*为零或更多批尺寸
• out (Tensor， 可选） - 可选输出张量

Example:

>>> x = torch.rand(4, 4)
>>> y = torch.inverse(x)
>>> z = torch.mm(x, y)
>>> z
tensor([[ 1.0000, -0.0000, -0.0000,  0.0000],
 [ 0.0000,  1.0000,  0.0000,  0.0000],
 [ 0.0000,  0.0000,  1.0000,  0.0000],
 [ 0.0000, -0.0000, -0.0000,  1.0000]])
>>> torch.max(torch.abs(z - torch.eye(4))) # Max non-zero
tensor(1.1921e-07)
>>> # Batched inverse example
>>> x = torch.randn(2, 3, 4, 4)
>>> y = torch.inverse(x)
>>> z = torch.matmul(x, y)
>>> torch.max(torch.abs(z - torch.eye(4).expand_as(x))) # Max non-zero
tensor(1.9073e-06)

torch.det(A) → Tensor

计算2D平方张量的行列式。

Note

当A不可逆时，向后通过 det() 在内部使用SVD结果。在这种情况下，当A没有明显的奇异值时，通过 det() 的双向后将是不稳定的。有关详细信息，请参阅 svd() 。

Example:

>>> A = torch.randn(3, 3)
>>> torch.det(A)
tensor(3.7641)

torch.logdet(A) → Tensor

计算2D平方张量的对数行列式。

Note

如果A具有零对数行列式，则结果为-inf，如果A具有负的行列式，则结果为nan。

Note

当A不可逆时，向后通过 logdet() 在内部使用SVD结果。在这种情况下，当A没有明显的奇异值时，通过 logdet() 的双向后将是不稳定的。有关详细信息，请参阅 svd() 。

Example:

>>> A = torch.randn(3, 3)
>>> torch.det(A)
tensor(0.2611)
>>> torch.logdet(A)
tensor(-1.3430)

torch.slogdet(A) -> (Tensor, Tensor)

计算2D平方张量的行列式的符号和对数值。

Note

如果A的行列式为零，则返回(0, -inf)。

Note

当A不可逆时，向后通过 slogdet() 在内部使用SVD结果。在这种情况下，当A没有明显的奇异值时，通过 slogdet() 的双向后将是不稳定的。有关详细信息，请参阅 svd() 。

Example:

>>> A = torch.randn(3, 3)
>>> torch.det(A)
tensor(-4.8215)
>>> torch.logdet(A)
tensor(nan)
>>> torch.slogdet(A)
(tensor(-1.), tensor(1.5731))

torch.matmul(tensor1, tensor2, out=None) → Tensor

两个张量的矩阵乘积。

行为取决于张量的维度如下：

• 如果两个张量都是1维的，则返回点积(标量）。
• 如果两个参数都是二维的，则返回矩阵 - 矩阵乘积。
• 如果第一个参数是1维且第二个参数是2维，则为了矩阵乘法的目的，在其维度之前加1。在矩阵乘法之后，移除前置维度。
• 如果第一个参数是2维且第二个参数是1维，则返回矩阵向量乘积。
• 如果两个参数都是至少一维的并且至少一个参数是N维的(其中N> 2），则返回批量矩阵乘法。如果第一个参数是1维的，则为了批量矩阵的目的，将1加在其维度之前，然后将其删除。如果第二个参数是1维的，则为了批处理矩阵的多个目的，将1附加到其维度，并在之后删除。非矩阵(即批量）维度是广播(因此必须是可广播的）。例如，如果tensor1是 张量而tensor2是 张量，out将是 张量。

Note

此功能的1维点积版本不支持out参数。

Parameters:

• tensor1 (Tensor） - 第一个要乘的张量
• tensor2 (Tensor） - 要增加的第二个张量
• out (Tensor， 任选） - 输出张量

Example:

>>> # vector x vector
>>> tensor1 = torch.randn(3)
>>> tensor2 = torch.randn(3)
>>> torch.matmul(tensor1, tensor2).size()
torch.Size([])
>>> # matrix x vector
>>> tensor1 = torch.randn(3, 4)
>>> tensor2 = torch.randn(4)
>>> torch.matmul(tensor1, tensor2).size()
torch.Size([3])
>>> # batched matrix x broadcasted vector
>>> tensor1 = torch.randn(10, 3, 4)
>>> tensor2 = torch.randn(4)
>>> torch.matmul(tensor1, tensor2).size()
torch.Size([10, 3])
>>> # batched matrix x batched matrix
>>> tensor1 = torch.randn(10, 3, 4)
>>> tensor2 = torch.randn(10, 4, 5)
>>> torch.matmul(tensor1, tensor2).size()
torch.Size([10, 3, 5])
>>> # batched matrix x broadcasted matrix
>>> tensor1 = torch.randn(10, 3, 4)
>>> tensor2 = torch.randn(4, 5)
>>> torch.matmul(tensor1, tensor2).size()
torch.Size([10, 3, 5])

torch.matrix_power(input, n) → Tensor

返回为矩形矩阵提升到幂n的矩阵。对于一批矩阵，每个单独的矩阵被提升到功率n。

如果n为负，则矩阵的反转(如果可逆）将升至功率n。对于一批矩阵，批量反转(如果可逆）则上升到功率n。如果n为0，则返回单位矩阵。

Parameters:

• 输入 (Tensor） - 输入张量
• n (int） - 将矩阵提升到

Example:

>>> a = torch.randn(2, 2, 2)
>>> a
tensor([[[-1.9975, -1.9610],
 [ 0.9592, -2.3364]],
 [[-1.2534, -1.3429],
 [ 0.4153, -1.4664]]])
>>> torch.matrix_power(a, 3)
tensor([[[  3.9392, -23.9916],
 [ 11.7357,  -0.2070]],
 [[  0.2468,  -6.7168],
 [  2.0774,  -0.8187]]])

torch.matrix_rank(input, tol=None, bool symmetric=False) → Tensor

返回二维张量的数值等级。默认情况下，使用SVD完成计算矩阵秩的方法。如果symmetric是True，则假设input是对称的，并且通过获得特征值来完成秩的计算。

tol是一个阈值，低于该阈值时，奇异值(或symmetric为True时的特征值）被认为是0.如果未指定tol，则tol设置为S.max() * max(S.size()) * eps，其中S ]是奇异值(或symmetric为True时的特征值），eps是input数据类型的epsilon值。

Parameters:

• 输入 (Tensor） - 输入2-D张量
• tol (float， 任选） - 耐受值。默认值：None
• 对称 (bool， 任选） - 表示input是否对称。默认值：False

Example:

>>> a = torch.eye(10)
>>> torch.matrix_rank(a)
tensor(10)
>>> b = torch.eye(10)
>>> b[0, 0] = 0
>>> torch.matrix_rank(b)
tensor(9)

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

执行矩阵mat1和mat2的矩阵乘法。

如果mat1是 张量，mat2是 张量，out将是 张量。

Note

This function does not broadcast. For broadcasting matrix products, see torch.matmul().

Parameters:

• mat1 (Tensor） - 第一个被乘法的矩阵
• mat2 (Tensor） - 要倍增的第二个矩阵
• out (Tensor， 任选） - 输出张量

Example:

>>> mat1 = torch.randn(2, 3)
>>> mat2 = torch.randn(3, 3)
>>> torch.mm(mat1, mat2)
tensor([[ 0.4851,  0.5037, -0.3633],
 [-0.0760, -3.6705,  2.4784]])

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

执行矩阵mat和向量vec的矩阵向量乘积。

如果mat是 张量，vec是1-D张量大小 ，out将是1-D大小 [] 。

Note

This function does not broadcast.

Parameters:

• mat (Tensor） - 矩阵成倍增加
• vec (Tensor） - 载体倍增
• out (Tensor， 任选） - 输出张量

Example:

>>> mat = torch.randn(2, 3)
>>> vec = torch.randn(3)
>>> torch.mv(mat, vec)
tensor([ 1.0404, -0.6361])

torch.orgqr(a, tau) → Tensor

从 torch.geqrf() 返回的(a, tau)元组计算QR分解的正交矩阵Q。

这直接调用底层LAPACK函数?orgqr。有关详细信息，请参阅orgqr 的 LAPACK文档。

Parameters:

• a (tensor) - 来自 torch.geqrf() 的a。
• tau (tensor) - 来自 torch.geqrf() 的tau。

torch.ormqr(a, tau, mat, left=True, transpose=False) -> (Tensor, Tensor)

将mat乘以由(a, tau)表示的 torch.geqrf() 形成的QR分解的正交Q矩阵。

这直接调用底层LAPACK函数?ormqr。有关详细信息，请参阅ormqr 的 LAPACK文档。

Parameters:

• a (tensor) - 来自 torch.geqrf() 的a。
• tau (tensor) - 来自 torch.geqrf() 的tau。
• mat (Tensor） - 要倍增的矩阵。

torch.pinverse(input, rcond=1e-15) → Tensor

计算2D张量的伪逆(也称为Moore-Penrose逆）。有关详细信息，请查看 Moore-Penrose逆

Note

该方法使用奇异值分解来实现。

Note

伪逆不一定是矩阵 [1] 的元素中的连续函数。因此，衍生物并不总是存在，只存在于恒定等级 [2] 。但是，由于使用SVD结果实现，此方法可以反向使用，并且可能不稳定。由于在内部使用SVD，双向后也将不稳定。有关详细信息，请参阅 svd() 。

Parameters:

• 输入 (Tensor） - 维度 的输入2D张量
• rcond (float） - 一个浮点值，用于确定小奇异值的截止值。默认值：1e-15

Returns:	维度 的input的伪逆

Example:

>>> input = torch.randn(3, 5)
>>> input
tensor([[ 0.5495,  0.0979, -1.4092, -0.1128,  0.4132],
 [-1.1143, -0.3662,  0.3042,  1.6374, -0.9294],
 [-0.3269, -0.5745, -0.0382, -0.5922, -0.6759]])
>>> torch.pinverse(input)
tensor([[ 0.0600, -0.1933, -0.2090],
 [-0.0903, -0.0817, -0.4752],
 [-0.7124, -0.1631, -0.2272],
 [ 0.1356,  0.3933, -0.5023],
 [-0.0308, -0.1725, -0.5216]])

torch.potrf(a, upper=True, out=None)

计算对称正定矩阵 的Cholesky分解。

有关 torch.potrf() 的更多信息，请查看 torch.cholesky() 。

Warning

torch.potrf不赞成使用torch.cholesky，将在下一个版本中删除。请改用torch.cholesky并注意torch.cholesky中的upper参数默认为False。

torch.potri(u, upper=True, out=None) → Tensor

计算正半定矩阵的倒数，给出其Cholesky因子u：返回矩阵inv

如果upper为True或未提供，则u为上三角形，使得返回的张量为

如果upper为False，则u为下三角形，使得返回的张量为

Parameters:

• u (Tensor） - 输入2-D张量，上下三角Cholesky因子
• 上 (bool， 可选） - 是否返回上限(默认）或下三角矩阵
• out (Tensor， 任选） - inv的输出张量

Example:

>>> a = torch.randn(3, 3)
>>> a = torch.mm(a, a.t()) # make symmetric positive definite
>>> u = torch.cholesky(a)
>>> a
tensor([[  0.9935,  -0.6353,   1.5806],
 [ -0.6353,   0.8769,  -1.7183],
 [  1.5806,  -1.7183,  10.6618]])
>>> torch.potri(u)
tensor([[ 1.9314,  1.2251, -0.0889],
 [ 1.2251,  2.4439,  0.2122],
 [-0.0889,  0.2122,  0.1412]])
>>> a.inverse()
tensor([[ 1.9314,  1.2251, -0.0889],
 [ 1.2251,  2.4439,  0.2122],
 [-0.0889,  0.2122,  0.1412]])

torch.potrs(b, u, upper=True, out=None) → Tensor

求解具有正半定矩阵的线性方程组，给定其Cholesky因子矩阵u。

如果upper为True或未提供，则u为上三角形并返回c，以便：

如果upper为False，则u为下三角形并返回c，以便：

torch.potrs(b, u)可以接收2D输入b, u或两批2D矩阵的输入。如果输入是批次，则返回批量输出c

Note

out关键字仅支持2D矩阵输入，即b, u必须是2D矩阵。

Parameters:

• b (tensor) - 大小 的输入矩阵，其中 为零或批量维度更多
• u (Tensor） - 大小为 的输入矩阵，其中 为零更多批量尺寸由上部或下部三角形Cholesky因子组成
• 上 (bool， 可选） - 是否返回上限(默认）或下三角矩阵
• out (Tensor， 任选） - c的输出张量

Example:

>>> a = torch.randn(3, 3)
>>> a = torch.mm(a, a.t()) # make symmetric positive definite
>>> u = torch.cholesky(a)
>>> a
tensor([[ 0.7747, -1.9549,  1.3086],
 [-1.9549,  6.7546, -5.4114],
 [ 1.3086, -5.4114,  4.8733]])
>>> b = torch.randn(3, 2)
>>> b
tensor([[-0.6355,  0.9891],
 [ 0.1974,  1.4706],
 [-0.4115, -0.6225]])
>>> torch.potrs(b,u)
tensor([[ -8.1625,  19.6097],
 [ -5.8398,  14.2387],
 [ -4.3771,  10.4173]])
>>> torch.mm(a.inverse(),b)
tensor([[ -8.1626,  19.6097],
 [ -5.8398,  14.2387],
 [ -4.3771,  10.4173]])

torch.pstrf(a, upper=True, out=None) -> (Tensor, Tensor)

计算正半定矩阵a的旋转Cholesky分解。返回矩阵u和piv。

如果upper为True或未提供，则u为上三角形，使得 ，p为piv给出的置换。

如果upper为False，则u为三角形，使得 。

Parameters:

• a (tensor) - 输入二维张量
• 上 (bool， 可选） - 是否返回上限(默认）或下三角矩阵
• out (元组 ， 任选） - u和piv张量的元组

Example:

>>> a = torch.randn(3, 3)
>>> a = torch.mm(a, a.t()) # make symmetric positive definite
>>> a
tensor([[ 3.5405, -0.4577,  0.8342],
 [-0.4577,  1.8244, -0.1996],
 [ 0.8342, -0.1996,  3.7493]])
>>> u,piv = torch.pstrf(a)
>>> u
tensor([[ 1.9363,  0.4308, -0.1031],
 [ 0.0000,  1.8316, -0.2256],
 [ 0.0000,  0.0000,  1.3277]])
>>> piv
tensor([ 2,  0,  1], dtype=torch.int32)
>>> p = torch.eye(3).index_select(0,piv.long()).index_select(0,piv.long()).t() # make pivot permutation
>>> torch.mm(torch.mm(p.t(),torch.mm(u.t(),u)),p) # reconstruct
tensor([[ 3.5405, -0.4577,  0.8342],
 [-0.4577,  1.8244, -0.1996],
 [ 0.8342, -0.1996,  3.7493]])

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

计算矩阵input的QR分解，并返回矩阵Q和R，使 ， 为正交矩阵和 [] 是一个上三角矩阵。

这将返回瘦(减少）QR分解。

Note

如果input的元素的大小很大，则精度可能会丢失

Note

虽然它应该总是给你一个有效的分解，它可能不会跨平台给你相同的 - 它将取决于你的LAPACK实现。

Note

不管原始步幅如何，返回的基质 将被转置，即步幅为(1, m)而不是(m, 1)。

Parameters:

• 输入 (Tensor） - 输入2-D张量
• out (元组 ， 任选） - Q和R张量的元组

Example:

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

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

U, S, V = torch.svd(A)返回大小为(n x m)的实矩阵A的奇异值分解，使得 。

U具有 的形状。

S是形状 的对角矩阵，表示为包含非负对角线条目的大小 的向量。

V具有 的形状。

如果some为True(默认值），则返回的U和V矩阵将仅包含 正交列。

如果compute_uv是False，则返回的U和V矩阵将分别为形状 和 的零矩阵。这里将忽略some。

Note

在CPU上实现SVD使用LAPACK例程?gesdd(分而治之算法）而不是?gesvd来提高速度。类似地，GPU上的SVD也使用MAGMA例程gesdd。

Note

不管原始步幅如何，返回的矩阵U将被转置，即用步幅(1, n)代替(n, 1)。

Note

向后通过U和V输出时需要特别小心。当input具有所有不同的奇异值的满秩时，这种操作实际上是稳定的。否则，NaN可能会出现，因为未正确定义渐变。此外，请注意，即使原始后向仅在S上，双向后通常会通过U和V向后进行。

Note

当some = False时，U[:, min(n, m):]和V[:, min(n, m):]上的梯度将被反向忽略，因为这些矢量可以是子空间的任意基数。

Note

当compute_uv = False时，由于后向操作需要前向通道的U和V，因此无法执行后退操作。

Parameters:

• 输入 (Tensor） - 输入2-D张量
• 一些 (bool， 任选） - 控制返回U和V的形状
• out (元组 ， 任选） - 张量的输出元组

Example:

>>> 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()
>>> u, s, v = torch.svd(a)
>>> u
tensor([[-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]])
>>> s
tensor([ 27.4687,  22.6432,   8.5584,   5.9857,   2.0149])
>>> v
tensor([[-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.4933, -0.6227, -0.4396]])
>>> torch.dist(a, torch.mm(torch.mm(u, torch.diag(s)), v.t()))
tensor(1.00000e-06 *
 9.3738)

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

该函数返回实对称矩阵input的特征值和特征向量，由元组 表示。

input和 是 基质， 是 维向量。

该函数计算input的所有特征值(和向量），使得 。

布尔参数eigenvectors仅定义特征向量或特征值的计算。

如果是False，则仅计算特征值。如果是True，则计算特征值和特征向量。

由于输入矩阵input应该是对称的，因此默认情况下仅使用上三角形部分。

如果upper是False，则使用下三角形部分。

注意：无论原始步幅如何，返回的矩阵V都将被转置，即使用步幅(1, m)而不是(m, 1)。

Parameters:

• 输入 (Tensor） - 输入对称矩阵
• 特征向量(布尔 ， 可选） - 控制是否必须计算特征向量
• 上(布尔 ， 可选） - 控制是否考虑上三角或下三角区域
• out (元组 ， 可选） - 输出元组(Tensor，Tensor）

| Returns: | A tuple containing

＆GT; e (tensor）：形状 。每个元素是input的特征值，特征值按升序排列。 ＆GT; V (tensor）：形状 。如果eigenvectors=False，它是一个充满零的张量。否则，该张量包含input的标准正交特征向量。

例子：

>>> 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
tensor([-11.0656,  -6.2287,   0.8640,   8.8655,  16.0948])
>>> v
tensor([[-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.trtrs(b, A, upper=True, transpose=False, unitriangular=False) -> (Tensor, Tensor)

求解具有三角系数矩阵 和多个右侧b的方程组。

特别是，解决 并假设 是默认关键字参数的上三角形。

Parameters:

• A (Tensor） - 输入三角系数矩阵
• b (Tensor） - 多个右侧。 的每一列是方程组的右侧。
• 上 (bool， 可选） - 是否解决上三角方程组(默认）或者下三角方程组。默认值：True。
• 转座 (bool， 任选） - 是否应转置在被送到解算器之前。默认值：False。
• 三角 (bool， 任选） - 是单位三角形。如果为True，则假定 的对角元素为1，并且未参考 。默认值：False。

Returns:	元组 其中 是 和 的克隆是[的解决方案] (或等式系统的任何变体，取决于关键字参数。）

Shape:

• 答：
• b：
• 输出[0]：
• 输出[1]：

Examples:

>>> A = torch.randn(2, 2).triu()
>>> A
tensor([[ 1.1527, -1.0753],
 [ 0.0000,  0.7986]])
>>> b = torch.randn(2, 3)
>>> b
tensor([[-0.0210,  2.3513, -1.5492],
 [ 1.5429,  0.7403, -1.0243]])
>>> torch.trtrs(b, A)
(tensor([[ 1.7840,  2.9045, -2.5405],
 [ 1.9319,  0.9269, -1.2826]]), tensor([[ 1.1527, -1.0753],
 [ 0.0000,  0.7986]]))