PyTorch学习笔记之基础函数篇（八）

6 线性代数运算

6.1 torch.mm()函数

torch.mm() 是 PyTorch 中的一个函数，用于执行矩阵乘法操作。这个函数会接受两个张量作为输入，并返回它们的矩阵乘积。

函数的基本语法如下：

torch.mm(mat1, mat2) → Tensor
1

参数说明：

• mat1 (Tensor)：第一个要进行矩阵乘法的张量。通常是一个二维张量（矩阵）。
• mat2 (Tensor)：第二个要进行矩阵乘法的张量。也通常是一个二维张量（矩阵）。

torch.mm() 函数返回一个新的张量，它是 mat1 和 mat2 的矩阵乘积。注意，mat1 的列数必须等于 mat2 的行数，以满足矩阵乘法的规则。

下面是一个使用 torch.mm() 的例子：

import torch

# 创建两个矩阵
mat1 = torch.tensor([[1, 2], [3, 4]])
mat2 = torch.tensor([[5, 6], [7, 8]])

# 计算矩阵乘积
result = torch.mm(mat1, mat2)

print(result)
# 输出:
# tensor([[19, 22],
#         [43, 50]])
1
2
3
4
5
6
7
8
9
10
11
12
13

在这个例子中，mat1 和 mat2 都是 2x2 的矩阵。使用 torch.mm() 函数计算了它们的矩阵乘积，并打印了结果。

需要注意的是，虽然 torch.mm() 通常用于二维矩阵的乘法，但 PyTorch 还提供了其他函数如 torch.matmul() 来执行更一般的张量乘法，它可以处理更高维度的张量，并提供了更灵活的广播能力。如果你需要处理更复杂的张量乘法，可能需要使用 torch.matmul() 而不是 torch.mm()。

6.2 torch.bmm()函数

torch.bmm 是 PyTorch 中的一个函数，用于执行批量矩阵乘法。这个函数在深度学习中特别有用，特别是在处理一批样本时，每个样本都是一个矩阵，你想要对这批样本执行矩阵乘法。

函数的基本语法如下：
参数说明：

• batch1 (Tensor): 第一个批量矩阵，通常是一个三维张量，其中第一个维度是批量大小（batch size），第二和第三个维度分别是矩阵的行和列。
• batch2 (Tensor): 第二个批量矩阵，也是一个三维张量，其形状与 batch1 兼容，即第一个维度是批量大小，第二维度的大小应与 batch1 的第三维度相同（用于矩阵乘法），第三维度的大小定义了结果矩阵的列数。

torch.bmm() 函数返回一个新的三维张量，其第一个维度是批量大小，第二维度是 batch1 的第二维度大小，第三维度是 batch2 的第三维度大小。

下面是一个使用 torch.bmm() 的例子：

import torch

# 创建两个批量矩阵
batch1 = torch.randn(10, 3, 4)  # 批量大小为 10，每个矩阵 3x4
batch2 = torch.randn(10, 4, 5)  # 批量大小为 10，每个矩阵 4x5

# 执行批量矩阵乘法
result = torch.bmm(batch1, batch2)

print(result.size())  # 输出: torch.Size([10, 3, 5])
1
2
3
4
5
6
7
8
9
10

在这个例子中，batch1 和 batch2 都是包含 10 个矩阵的批量，每个矩阵分别具有不同的维度。torch.bmm() 函数对这两个批量中的每个矩阵执行矩阵乘法，并返回一个包含 10 个矩阵的新批量，每个矩阵是 3x5 的。

需要注意的是，torch.bmm() 只支持批量矩阵乘法，并且输入的张量必须是三维的。如果你想要执行普通的矩阵乘法，可以使用 torch.mm() 或 torch.matmul()。

6.3 torch.matmul()函数

torch.matmul 是 PyTorch 中的一个函数，用于执行矩阵乘法或更高维度的张量乘法。这个函数能够处理从向量到矩阵以及更高维度的张量，提供了比 torch.mm 和 torch.bmm 更广泛的功能。

函数的基本语法如下：

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

参数说明：

• tensor1 (Tensor)：第一个张量。
• tensor2 (Tensor)：第二个张量。
• *：其他命名参数。
• out (Tensor, optional)：输出张量。

torch.matmul 的工作方式是，它会根据输入张量的维度和形状来确定执行什么样的乘法操作。如果输入的是两个向量，则执行点积；如果输入的是两个矩阵，则执行矩阵乘法；如果输入的是更高维度的张量，则执行逐元素的广播乘法。

这里有一些使用 torch.matmul 的例子：

例子 1：向量点积

import torch

v1 = torch.tensor([2, 3])
v2 = torch.tensor([6, 7])

# 执行点积
result = torch.matmul(v1, v2)

print(result)  # 输出: tensor(20)
1
2
3
4
5
6
7
8
9

例子 2：矩阵乘法

import torch

mat1 = torch.tensor([[1, 2], [3, 4]])
mat2 = torch.tensor([[5, 6], [7, 8]])

# 执行矩阵乘法
result = torch.matmul(mat1, mat2)

print(result)
# 输出:
# tensor([[19, 22],
#         [43, 50]])
1
2
3
4
5
6
7
8
9
10
11
12

例子 3：张量乘法（广播）

import torch

tensor1 = torch.tensor([[1, 2], [3, 4]])
tensor2 = torch.tensor([5, 6])

# 执行逐元素的张量乘法（广播）
result = torch.matmul(tensor1, tensor2)

print(result)
# 输出:
# tensor([[ 5, 12],
#         [15, 24]])
1
2
3
4
5
6
7
8
9
10
11
12

在最后一个例子中，tensor1 是一个 2x2 的矩阵，而 tensor2 是一个 1x2 的矩阵。由于 tensor2 的形状可以广播到与 tensor1 兼容的形状（即 2x2），因此 torch.matmul 执行了逐元素的乘法。

torch.matmul 提供了比 torch.mm 和 torch.bmm 更强大的功能，因为它能够处理不同维度的张量，并且具有广播能力。在处理深度学习模型时，通常推荐使用 torch.matmul 而不是 torch.mm，因为它更加灵活和通用。

6.4 torch.eig()函数

torch.eig 是 PyTorch 中的一个函数，用于计算一个方阵的特征值和特征向量。这个函数返回一个元组，其中第一个元素是特征值组成的张量，第二个元素是对应的特征向量组成的张量。

函数的基本语法如下：

torch.eig(input, eigenvectors=False, *, out=None) → (Tensor, Tensor)
1

参数说明：

• input (Tensor): 要计算特征值和特征向量的方阵。
• eigenvectors (bool, optional): 如果为 True，则计算特征向量；如果为 False，则只计算特征值。默认为 False。
• *: 其他命名参数。
• out (tuple[Tensor, Tensor], optional): 可选的输出张量元组，用于存储特征值和特征向量。

返回值是一个包含两个张量的元组：

• 第一个张量包含输入矩阵的特征值。
• 第二个张量（如果 eigenvectors=True）包含与特征值对应的特征向量。

以下是一个使用 torch.eig 的例子：

import torch

# 创建一个方阵
A = torch.tensor([[4, 1], [2, 3]], dtype=torch.float32)

# 计算特征值和特征向量
eigenvalues, eigenvectors = torch.eig(A, eigenvectors=True)

print("Eigenvalues:")
print(eigenvalues)

print("Eigenvectors:")
print(eigenvectors)
1
2
3
4
5
6
7
8
9
10
11
12
13

输出将类似于以下内容：

Eigenvalues:
tensor([-0.5437,  5.5437])
Eigenvectors:
tensor([[-0.8165, -0.5774],
        [ 0.5774, -0.8165]])
1
2
3
4
5

在这个例子中，A 是一个 2x2 的方阵，torch.eig 计算了它的特征值和特征向量。特征值是两个标量（在这个例子中为 -0.5437 和 5.5437），而特征向量是两个正交向量（在这个例子中由两列组成的矩阵表示）。

6.5 torch.inverse()函数

torch.inverse 是 PyTorch 中的一个函数，用于计算矩阵的逆。这个函数返回输入矩阵的逆矩阵。如果输入矩阵是奇异的（即不可逆），则该函数会抛出错误。

函数的基本语法如下：

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

参数说明：

• input (Tensor)：要计算逆的矩阵。
• *：其他命名参数。
• out (Tensor, optional)：输出张量。

返回值是一个张量，表示输入矩阵的逆矩阵。

以下是一个使用 torch.inverse 的例子：

import torch

# 创建一个可逆矩阵
A = torch.tensor([[4, 1], [2, 3]], dtype=torch.float32)

# 计算逆矩阵
A_inv = torch.inverse(A)

print("Original matrix A:")
print(A)

print("Inverse of matrix A:")
print(A_inv)

# 验证逆矩阵的正确性
I = torch.matmul(A, A_inv)
print("Identity matrix (should be close to I):")
print(I)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

输出将类似于以下内容

Original matrix A:
tensor([[4., 1.],
        [2., 3.]])
Inverse of matrix A:
tensor([[-0.75,  0.25],
        [ 0.5 , -0.25]])
Identity matrix (should be close to I):
tensor([[1.0000, 0.0000],
        [0.0000, 1.0000]])
1
2
3
4
5
6
7
8
9

在这个例子中，A 是一个 2x2 的可逆矩阵，torch.inverse 计算了它的逆矩阵 A_inv。最后，通过矩阵乘法验证了 A 和 A_inv 的乘积接近单位矩阵 I，这验证了逆矩阵的正确性。

请注意，如果输入矩阵不是方阵（即行数和列数不相等），或者矩阵是奇异的（即没有逆矩阵），torch.inverse 会抛出错误。在这种情况下，你可能需要使用其他方法（如求解线性方程组或计算伪逆矩阵）来处理矩阵。

6.6torch.cholesky()函数

torch.cholesky 是 PyTorch 中的一个函数，用于计算一个正定矩阵（positive-definite matrix）的 Cholesky 分解。Cholesky 分解是一种将一个正定矩阵分解为一个下三角矩阵（以主对角线为轴进行镜像对称）和其转置的乘积的方法。

函数的基本语法如下：

torch.cholesky(input, upper=False, *, out=None) → Tensor
1

参数说明：

• input (Tensor): 要进行 Cholesky 分解的正定矩阵。
• upper (bool, optional): 如果为 True，则输入矩阵被假定为上三角矩阵，且函数返回上三角 Cholesky 因子。默认为 False，表示输入矩阵是下三角的。
• *: 其他命名参数。
• out (Tensor, optional): 可选的输出张量。

返回值是一个张量，表示输入矩阵的 Cholesky 分解的下三角因子（如果 upper=False）或上三角因子（如果 upper=True）。

以下是一个使用 torch.cholesky 的例子：

import torch

# 创建一个正定矩阵
A = torch.tensor([[4., 12., -16.],
                  [12., 37., -43.],
                  [-16., -43., 98.]], dtype=torch.float32)

# 计算 Cholesky 分解
L = torch.cholesky(A)

print("Original matrix A:")
print(A)

print("Cholesky factor L:")
print(L)

# 验证分解的正确性：A = L * L.T
A_reconstructed = torch.matmul(L, L.t())
print("Reconstructed matrix A_reconstructed:")
print(A_reconstructed)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

输出将类似于以下内容：

Original matrix A:
tensor([[ 4., 12., -16.],
        [12., 37., -43.],
        [-16., -43.,  98.]], dtype=torch.float32)
Cholesky factor L:
tensor([[ 2.0000,  0.0000,  0.0000],
        [ 6.0000,  1.0000,  0.0000],
        [-8.0000, -5.0000,  3.2016]], dtype=torch.float32)
Reconstructed matrix A_reconstructed:
tensor([[ 4.0000, 12.0000, -16.0000],
        [12.0000, 37.0000, -43.0000],
        [-16.0000, -43.0000,  98.0001]], dtype=torch.float32)
1
2
3
4
5
6
7
8
9
10
11
12

在这个例子中，A 是一个正定矩阵，torch.cholesky 计算了它的 Cholesky 分解因子 L。最后，通过计算 L 和其转置的乘积，验证了重构的矩阵 A_reconstructed 与原始矩阵 A 相等（由于数值误差，可能会有轻微的不同）。