6 线性代数运算
6.1 torch.mm()函数
torch.mm() 是 PyTorch 中的一个函数,用于执行矩阵乘法操作。这个函数会接受两个张量作为输入,并返回它们的矩阵乘积。
函数的基本语法如下:
torch.mm(mat1, mat2) → Tensor
参数说明:
- 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]])
在这个例子中,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])
在这个例子中,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
参数说明:
- tensor1 (Tensor):第一个张量。
- tensor2 (Tensor):第二个张量。
- *:其他命名参数。
- out (Tensor, optional):输出张量。
torch.matmul 的工作方式是,它会根据输入张量的维度和形状来确定执行什么样的乘法操作。如果输入的是两个向量,则执行点积;如果输入的是两个矩阵,则执行矩阵乘法;如果输入的是更高维度的张量,则执行逐元素的广播乘法。
这里有一些使用 torch.matmul 的例子:
例子 1:向量点积
import torchv1 = torch.tensor([2, 3])
v2 = torch.tensor([6, 7])# 执行点积
result = torch.matmul(v1, v2)print(result) # 输出: tensor(20)
例子 2:矩阵乘法
import torchmat1 = 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]])
例子 3:张量乘法(广播)
import torchtensor1 = torch.tensor([[1, 2], [3, 4]])
tensor2 = torch.tensor([5, 6])# 执行逐元素的张量乘法(广播)
result = torch.matmul(tensor1, tensor2)print(result)
# 输出:
# tensor([[ 5, 12],
# [15, 24]])
在最后一个例子中,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)
参数说明:
- 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)
输出将类似于以下内容:
Eigenvalues:
tensor([-0.5437, 5.5437])
Eigenvectors:
tensor([[-0.8165, -0.5774],[ 0.5774, -0.8165]])
在这个例子中,A 是一个 2x2 的方阵,torch.eig 计算了它的特征值和特征向量。特征值是两个标量(在这个例子中为 -0.5437 和 5.5437),而特征向量是两个正交向量(在这个例子中由两列组成的矩阵表示)。
6.5 torch.inverse()函数
torch.inverse 是 PyTorch 中的一个函数,用于计算矩阵的逆。这个函数返回输入矩阵的逆矩阵。如果输入矩阵是奇异的(即不可逆),则该函数会抛出错误。
函数的基本语法如下:
torch.inverse(input, *, out=None) → Tensor
参数说明:
- 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)
输出将类似于以下内容
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]])
在这个例子中,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
参数说明:
- 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)
输出将类似于以下内容:
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)
在这个例子中,A 是一个正定矩阵,torch.cholesky 计算了它的 Cholesky 分解因子 L。最后,通过计算 L 和其转置的乘积,验证了重构的矩阵 A_reconstructed 与原始矩阵 A 相等(由于数值误差,可能会有轻微的不同)。