PyTorch提供了几种张量乘法的方法，每种方法都是不同的，并且有不同的应用。我们来详细介绍每个方法，并且详细解释这些函数有什么区别：

torch.matmul是 PyTorch 中用于矩阵乘法的函数。它能够处理各种不同维度的张量，并根据张量的维度自动调整其操作方式。

torch.matmul可以执行以下几种矩阵乘法：

二维张量之间的矩阵乘法：

这是经典的矩阵乘法操作。当两个张量都是二维的 (即矩阵)，torch.matmul进行标准的矩阵乘法操作。

例如：假设A是形状为(m, n)的张量，B是形状为(n, p)的张量，那么torch.matmul(A, B)结果是一个形状为(m, p)的张量。

高维张量之间的矩阵乘法：

torch.matmul可以处理更高维的张量。当输入张量的维度大于2时，它将执行批量矩阵乘法。

对于形状为(..., m, n)的张量A和形状为(..., n, p)的张量B，torch.matmul(A, B)的结果是形状为(..., m, p)的张量，其中...表示相同的批量维度。批量维度部分将自动广播。

一维和二维张量的乘法：

当第一个张量是1D张量（向量），第二个张量是2D张量时，torch.matmul会将1D张量视为行向量（或列向量）参与矩阵乘法。

例如：A是形状为(n,)的张量，B是形状为(n, p)的张量，那么torch.matmul(A, B)的结果是形状为(p,)的张量。

反之，如果第一个张量是2D张量，第二个是1D张量，则结果是一个形状为(m,)的张量。

import torch  # 示例 1: 二维张量之间的矩阵乘法 A = torch.tensor([[1, 2], [3, 4]]) B = torch.tensor([[5, 6], [7, 8]]) result = torch.matmul(A, B) print(result)  # 输出: tensor([[19, 22], [43, 50]])  # 示例 2: 高维张量之间的矩阵乘法（批次矩阵乘法） A = torch.rand(2, 3, 4) B = torch.rand(2, 4, 5) result = torch.matmul(A, B) print(result.shape)  # 输出: torch.Size([2, 3, 5])  # 示例 3: 1D 和 2D 张量之间的乘法 A = torch.tensor([1, 2, 3]) B = torch.tensor([[4, 5], [6, 7], [8, 9]]) result = torch.matmul(A, B) print(result)  # 输出: tensor([40, 46])

torch.matmul支持广播，这意味着当输入张量的形状不完全匹配时，它可以自动扩展维度以进行相应的矩阵乘法。例如，两个张量的形状分别为(1, 2, 3)和(3, 4)，torch.matmul可以将第二个张量自动扩展为形状(1, 3, 4)，然后进行批次矩阵乘法。

torch.matmul底层使用了高效的线性代数库（如 BLAS），确保了矩阵乘法的性能。对于大型矩阵运算，torch.matmul通常是非常高效的。它的灵活性和性能使得它成为 PyTorch 中广泛使用的操作之一。

torch.mm是 PyTorch 中专门用于二维张量（矩阵）之间进行矩阵乘法的函数。与torch.matmul不同，torch.mm仅适用于2D张量，并且不支持高维张量或广播操作。

torch.mm进行标准的矩阵乘法操作，适用于两个2D张量（矩阵）之间的乘法。对于形状为(m, n)的张量A和形状为(n, p)的张量B，torch.mm(A, B)的结果是一个形状为(m, p)的张量。

import torch  # 示例 1: 二维张量之间的矩阵乘法 A = torch.tensor([[1, 2, 3], [4, 5, 6]]) B = torch.tensor([[7, 8], [9, 10], [11, 12]]) result = torch.mm(A, B) print(result)  # 输出: tensor([[ 58,  64], [139, 154]])

在这个例子中，矩阵A的形状是(2, 3)，矩阵B的形状是(3, 2)。结果矩阵的形状是(2, 2)，且每个元素是通过对应行与列元素的乘积之和计算得出的。

torch.mm不支持广播机制，这意味着两个输入矩阵的形状必须严格匹配（即第一个矩阵的列数必须等于第二个矩阵的行数）。

torch.mm是针对二维矩阵乘法优化的，它利用了底层的高效线性代数库（如 BLAS）。当仅需要进行2D张量的矩阵乘法时，torch.mm可能比torch.matmul更加高效，因为它避免了torch.matmul中针对高维张量所做的额外处理。

注意事项：

输入张量必须是二维的。如果输入是高维张量，使用torch.mm会导致错误。两个矩阵的形状必须是兼容的，即第一个矩阵的列数必须等于第二个矩阵的行数，否则会抛出维度不匹配的错误。

import torch  A = torch.tensor([[1, 2], [3, 4]]) B = torch.tensor([1, 2]) # 这会引发一个错误，因为 B 不是二维张量 result = torch.mm(A, B)  # RuntimeError: matrices expected, got 1D, 2D tensors

在上面的示例中，由于B是一维张量而非二维矩阵，因此torch.mm会抛出错误。解决方法是将B转换为二维张量，例如B.unsqueeze(1)，以使其形状符合矩阵乘法的要求。

torch.mm常用于涉及矩阵乘法的各种场景，特别是在机器学习和深度学习中。例如，在神经网络的全连接层中，计算权重矩阵和输入向量的乘积时经常使用torch.mm。此外，torch.mm也可以用于线性代数中的基本操作，如求解线性方程组、计算特征值等。

torch.mm它操作简洁且性能高效，适用于需要进行标准矩阵乘法的场景。对于二维矩阵乘法来说，它比torch.matmul更直接，因此在需要矩阵乘法且确定张量维度为2D的情况下，torch.mm是一个理想的选择。

torch.bmm是 PyTorch 中用于进行批次矩阵乘法的函数。它专门处理三维张量，其中第一个维度表示批次大小，后两个维度表示需要进行矩阵乘法的矩阵。因此torch.bmm是进行批次矩阵操作的一个高效工具。

torch.bmm用于对形状为(b, m, n)的张量A和形状为(b, n, p)的张量B进行批次矩阵乘法，输出结果是形状为(b, m, p)的张量。这里，b表示批次大小，m和n是矩阵的行和列数，p是结果矩阵的列数。

import torch  # 示例: 批次矩阵乘法 A = torch.randn(10, 3, 4)  # 形状为 (10, 3, 4) B = torch.randn(10, 4, 5)  # 形状为 (10, 4, 5) result = torch.bmm(A, B) print(result.shape)  # 输出: torch.Size([10, 3, 5])

在这个例子中：

张量A的形状是(10, 3, 4)，表示有10个3x4的矩阵。

张量B的形状是(10, 4, 5)，表示有10个4x5的矩阵。

torch.bmm(A, B)的结果是形状为(10, 3, 5)的张量，这表示批次中的每一对矩阵都进行了乘法操作。

torch.bmm实际上是对批次中的每一对矩阵单独进行矩阵乘法操作，因此它要求输入张量的第一个维度（即批次大小）是相同的，并且后两个维度必须满足矩阵乘法的要求（即第一个矩阵的列数等于第二个矩阵的行数）。

torch.bmm对批次矩阵乘法进行了优化，使用了高效的底层线性代数库。它在处理大型批次矩阵乘法时性能非常高效。由于它可以在批次上并行执行操作，因此特别适用于深度学习中的批量计算场景。

torch.bmm只适用于三维张量，其中第一个维度表示批次大小。对于高于或低于三维的张量，它会报错。或者说他是torch.mm的批次化版本。torch.bmm不支持广播机制，因此输入张量的第一个维度（批次大小）必须严格相同。

torch.bmm常用于需要对多个矩阵对同时进行乘法操作的场景，特别是在深度学习中的以下情境：

批量计算：在训练神经网络时，我们通常将输入数据分批处理，每批次数据对应多个矩阵。torch.bmm可以有效地处理这种批次矩阵操作。

图卷积网络（GCN）：在图神经网络中，批次矩阵乘法经常用于计算节点特征和邻接矩阵的乘积。

时间序列模型：在时间序列建模中，可能需要对每个时间步长应用不同的变换矩阵，这时可以使用torch.bmm进行批量处理。

torch.bmm是专门用于批次矩阵乘法。当需要对多个矩阵对同时进行乘法操作时，它提供了高效且简洁的解决方案。

torch.mul是 PyTorch 中用于执行元素级乘法（也称为逐元素乘法）的函数。它可以对张量的每个元素进行对应位置的乘法操作，支持任意维度的张量，并且可以自动进行广播操作来适应不同形状的张量。

torch.mul可以对两个张量的对应元素进行乘法运算。假设有两个张量A和B，那么torch.mul(A, B)将返回一个新的张量，其中每个元素是A和B在相同位置的元素的乘积。这个操作等同于使用*操作符，如A * B。

import torch  # 示例 1: 相同形状的张量的元素级乘法 A = torch.tensor([1, 2, 3]) B = torch.tensor([4, 5, 6]) result = torch.mul(A, B) print(result)  # 输出: tensor([ 4, 10, 18])  # 示例 2: 不同形状的张量进行广播后的元素级乘法 A = torch.tensor([[1, 2, 3], [4, 5, 6]]) B = torch.tensor([10, 20, 30]) result = torch.mul(A, B) print(result)  # 输出: tensor([[10, 40, 90], [40, 100, 180]])  # 示例 3: 通过标量进行元素级乘法 A = torch.tensor([1, 2, 3]) result = torch.mul(A, 10) print(result)  # 输出: tensor([10, 20, 30])

在这些示例中：

在第一个示例中，A和B是形状相同的张量，因此对应元素直接相乘。

在第二个示例中，A是二维张量，而B是一维张量，PyTorch 自动对B进行广播，使其形状与A匹配，然后进行逐元素乘法。

在第三个示例中，A和一个标量值相乘，每个元素都乘以该标量。

torch.mul支持广播机制，这意味着当两个张量的形状不完全相同时，它可以自动扩展较小形状的张量，使其与较大形状的张量兼容，然后进行逐元素乘法。

import torch  A = torch.tensor([[1, 2, 3], [4, 5, 6]]) B = torch.tensor([10, 20, 30]) result = torch.mul(A, B)

在这个例子中，A的形状是(2, 3)，而B的形状是(3,)。PyTorch 自动将B扩展为(2, 3)，然后对每个对应元素进行乘法运算。

torch.mul是一个高效的逐元素操作，因为它直接在元素级别上进行计算，适用于需要对大批量数据进行逐元素操作的场景。它可以充分利用现代硬件的并行计算能力（如GPU），在处理大型张量时非常高效。

注意事项

虽然torch.mul支持广播，但在进行操作时，确保两个张量的形状是兼容的非常重要。如果形状不兼容，将会引发运行时错误。当使用标量时，标量会被自动广播到张量的每个元素，因此直接操作是安全的。

import torch  A = torch.tensor([1, 2, 3]) B = torch.tensor([[1, 2, 3], [4, 5, 6]]) # 形状不兼容，无法进行逐元素乘法 result = torch.mul(A, B)  # 会引发 RuntimeError: The size of tensor a (3) must match the size of tensor b (2) at non-singleton dimension 0

在这个错误示例中，由于A是一维张量，而B是二维张量且第一个维度不匹配，因此无法广播，导致错误。

torch.mul在许多机器学习和深度学习任务中都非常有用。例如：

权重调整：在神经网络中，可以通过torch.mul来逐元素调整权重或激活值。

掩码操作：在图像处理中，可以使用torch.mul来对图像应用掩码，逐元素控制哪些部分需要保留或修改。

归一化：可以逐元素将张量归一化或缩放，以满足特定的算法要求。

torch.mul在处理各种张量操作时非常有用。它支持广播机制，可以自动适应不同形状的张量，从而在多种应用场景中提供简洁而高效的解决方案。

torch.mv是 PyTorch 中用于进行矩阵与向量乘法的函数。它专门用于二维张量（矩阵）和一维张量（向量）之间的乘法操作。torch.mv是矩阵乘法的一种特殊情况，适用于当你需要将矩阵乘以向量时使用。

torch.mv执行的是矩阵与向量的乘法操作。假设有一个矩阵A，它的形状为(m, n)，以及一个向量v，它的形状为(n,)，那么torch.mv(A, v)将返回一个形状为(m,)的一维张量（向量），结果是矩阵A与向量v的乘积。

import torch  # 示例: 矩阵与向量的乘法 A = torch.tensor([[1, 2, 3], [4, 5, 6]]) v = torch.tensor([7, 8, 9]) result = torch.mv(A, v) print(result)  # 输出: tensor([ 50, 122])

在这个示例中,矩阵A的形状为(2, 3)，向量v的形状为(3,)。通过torch.mv(A, v)，我们得到的结果是形状为(2,)的向量[50, 122]，其中每个元素是通过矩阵与向量的标准乘法计算得出的。

torch.mv执行的矩阵与向量乘法遵循以下规则：对于矩阵A中的每一行，将该行与向量v的所有元素逐元素相乘，并将乘积的结果求和，得到一个标量。这个标量就是结果向量对应位置的值。

import torch  A = torch.tensor([[1, 2, 3], [4, 5, 6]]) v = torch.tensor([7, 8, 9]) result = torch.mv(A, v) # 结果: # result[0] = 1*7 + 2*8 + 3*9 = 50 # result[1] = 4*7 + 5*8 + 6*9 = 122

torch.mv专门用于矩阵和向量的乘法，比通用的矩阵乘法函数如torch.matmul或torch.mm更加高效，因为它避免了对多余维度的处理。这使得torch.mv在执行矩阵与向量乘法时速度更快，并且更适合用于大规模计算。

注意事项

矩阵A的列数（第二个维度）必须等于向量v的长度（第一个维度），否则将会报错。

import torch  A = torch.tensor([[1, 2, 3], [4, 5, 6]]) v = torch.tensor([7, 8]) # 这将引发错误，因为 v 的形状与 A 的列数不匹配 result = torch.mv(A, v)  # 会引发 RuntimeError: size mismatch, m1: [2x3], m2: [2] at THTensorMath.cpp:41

在这个错误示例中，向量v的长度与矩阵A的列数不匹配，因此无法进行矩阵与向量乘法。

torch.mv是 PyTorch 中用于执行矩阵与向量乘法的专用函数。它对矩阵与向量乘法进行了优化，能够高效处理这类操作，是线性代数、深度学习和科学计算中常用的工具。在许多应用场景中都很有用，特别是在以下情况下：

线性代数操作：在计算线性方程组、特征值问题等线性代数问题时，经常需要进行矩阵与向量的乘法。

神经网络计算：在神经网络的前向传播过程中，特别是全连接层中，权重矩阵与输入向量的乘法操作可以通过torch.mv高效地实现。

物理模拟：在一些物理模拟中，状态向量与转换矩阵的乘法操作可以通过torch.mv实现。

torch.dot是 PyTorch 中用于计算两个一维张量（即向量）之间的点乘（内积）的函数。点乘是一种基本的向量操作，在许多数学和工程应用中都有广泛的应用。

torch.dot计算的是两个向量之间的点积。假设有两个向量a和b，它们的长度相同（即形状都为(n,)），那么torch.dot(a, b)的结果是一个标量（即一个数值），这个值是通过对应位置的元素相乘后再求和得到的。

import torch  # 示例: 两个向量的点乘 a = torch.tensor([1, 2, 3]) b = torch.tensor([4, 5, 6]) result = torch.dot(a, b) print(result)  # 输出: tensor(32)

在这个示例中：向量a的形状为(3,)，向量b的形状也是(3,)。通过torch.dot(a, b)，我们得到了标量32，其计算过程为：1*4 + 2*5 + 3*6 = 4 + 10 + 18 = 32。

torch.dot计算点乘的方式是逐元素相乘，然后将结果求和。对于两个长度为n的向量a和b，点积的计算公式如下：

result = (a[0] * b[0]) + (a[1] * b[1]) + ... + (a[n-1] * b[n-1])

torch.dot是对两个一维张量进行点积的优化实现，由于其简单的计算流程和对向量操作的专门优化，它通常具有非常高的性能，特别是在 GPU 上处理大规模数据时表现尤为优异。

torch.dot仅适用于一维张量（向量），如果输入的张量不是一维的，会引发错误。并且torch.dot返回一个标量（标量张量），而不是张量。由于点积的对称性，torch.dot(a, b)与torch.dot(b, a)的结果是相同的。

与其他操作的对比

torch.matmul和torch.mm：这些函数用于矩阵乘法，适用于高维张量。torch.dot只用于一维张量的点积。

torch.mul：这是逐元素乘法，不是点积。torch.mul(a, b)会返回一个与a和b形状相同的张量，其中每个元素是对应元素的乘积，而torch.dot(a, b)会返回一个标量。

torch.dot是一个简单而高效的函数，专门用于计算一维张量之间的点积。在许多数学、物理和工程应用中，它是一个非常重要的工具。点积在很多场景中都有应用，包括但不限于：

向量投影：在几何中，点乘可以用于计算一个向量在另一个向量方向上的投影。

相似性计算：在信息检索和机器学习中，两个向量的点积可以用于衡量它们的相似性。例如，在词向量（Word Embeddings）的相似性计算中，点积是常用的度量方法之一。

能量计算：在物理学中，点积用于计算力和位移的乘积（即功的计算）。

torch.outer是 PyTorch 中用于计算两个一维张量（即向量）之间的外积（外积矩阵）的函数。外积是线性代数中的一种基本运算，结果是一个矩阵，其元素是两个输入向量各元素的乘积。

torch.outer计算的是两个向量的外积。假设有两个向量a和b，它们的形状分别是(n,)和(m,)，那么torch.outer(a, b)的结果是一个形状为(n, m)的二维张量（矩阵），这个矩阵中的元素由a[i] * b[j]计算得到。

import torch  # 示例: 两个向量的外积 a = torch.tensor([1, 2, 3]) b = torch.tensor([4, 5, 6]) result = torch.outer(a, b) print(result) # 输出: # tensor([[ 4,  5,  6], #         [ 8, 10, 12], #         [12, 15, 18]])

在这个示例中：

向量a的形状为(3,)，向量b的形状也为(3,)。

通过torch.outer(a, b)，我们得到了形状为(3, 3)的矩阵。这个矩阵的每个元素都是由a[i]和b[j]的乘积计算得出。

torch.outer是对两个一维张量进行外积的优化实现。由于其操作涉及大量的元素乘法，因此在处理大型向量时，特别是在 GPU 上计算，torch.outer的性能表现十分出色。

torch.outer仅适用于一维张量，即向量，并返回一个二维张量（矩阵），其形状为(n, m)，其中n和m是输入向量的长度。

与其他操作的对比

torch.matmul和torch.mm：这些函数用于矩阵乘法，适用于高维张量。torch.outer专用于计算两个一维张量之间的外积。

torch.mul：这是逐元素乘法。如果两个张量的形状相同，torch.mul(a, b)将执行逐元素乘法，而不是计算外积。

torch.outer是一个用于计算两个一维张量之间外积的高效工具。它在生成矩阵、处理双线性形式、构建张量积等应用中非常有用。外积在很多场景中都有应用，包括但不限于：

矩阵构建：外积可用于生成特定类型的矩阵，例如克罗内克积。

双线性形式：在双线性形式的表示中，外积经常用于构建张量。

机器学习：在神经网络的权重更新、特征交互等场景中，外积运算可以构造高阶特征。

torch.einsum是 PyTorch 中一个非常强大的函数，它使用爱因斯坦求和约定（Einstein Summation Convention）来执行复杂的张量操作。torch.einsum的灵活性使得它可以用于各种矩阵和张量运算，包括矩阵乘法、转置、内积、外积、以及其他高阶张量运算。

爱因斯坦求和约定是一种简化张量操作的符号表示方法，其中重复的指标自动表示求和。torch.einsum使用字符串表示张量操作，将输入张量的维度与输出维度通过指定的模式进行映射。

torch.einsum(equation, *operands)

equation：一个字符串，描述了输入和输出张量的维度关系。

*operands：一个或多个张量，参与计算的张量。

使用示例

1、矩阵乘法

矩阵乘法是最常见的张量操作之一。对于两个矩阵A和B，使用torch.einsum进行矩阵乘法可以表示为：

import torch  A = torch.tensor([[1, 2], [3, 4]]) B = torch.tensor([[5, 6], [7, 8]]) result = torch.einsum('ik,kj->ij', A, B) print(result)  # 输出: tensor([[19, 22], [43, 50]])

这里，'ik,kj->ij'表示：

A的维度为i（行）和k（列）。

B的维度为k（行）和j（列）。

输出的矩阵C的维度为i（行）和j（列），其中k是求和维度。

2、向量内积（点积）

对于两个向量a和b，它们的内积可以用torch.einsum表示为：

a = torch.tensor([1, 2, 3]) b = torch.tensor([4, 5, 6]) result = torch.einsum('i,i->', a, b) print(result)  # 输出: tensor(32)

这里，'i,i->'表示：

a和b都是一维向量，维度为i。

输出是一个标量（没有索引），表示所有元素的乘积之和。

3、向量外积

向量外积可以表示为：

a = torch.tensor([1, 2, 3]) b = torch.tensor([4, 5, 6]) result = torch.einsum('i,j->ij', a, b) print(result) # 输出: # tensor([[ 4,  5,  6], #         [ 8, 10, 12], #         [12, 15, 18]])

这里，'i,j->ij'表示：

a的维度为i，b的维度为j。

输出矩阵C的维度为ij，表示a[i]和b[j]的乘积。

torch.einsum是一个通用且灵活的工具，但其性能可能不如专门为某些操作优化的函数（如torch.matmul）。所以在性能关键的应用中，使用专门的张量操作函数可能会更高效。不过对于需要简洁表示复杂操作的场景，torch.einsum仍然是首选。

以下是对 PyTorch 中几种常用张量操作函数的总结：

torch.matmul(矩阵乘法)

功能：执行矩阵乘法，支持二维矩阵、批量矩阵乘法、高维张量乘法。

应用：广泛用于神经网络中的矩阵运算，如全连接层的计算。

torch.mm(矩阵乘法)

功能：专门用于二维张量（矩阵）之间的乘法，不支持广播和高维张量。

应用：适用于明确为二维矩阵的乘法操作，性能高效。

torch.bmm(批次矩阵乘法)

功能：对三维张量进行批次矩阵乘法，适用于批量处理的场景。

应用：常用于深度学习中的批量数据处理和图神经网络中的邻接矩阵计算。

torch.mul(元素级乘法)

功能：逐元素乘法，支持任意维度张量并自动广播。

应用：用于权重调整、掩码操作、数据归一化等逐元素运算。

torch.mv(矩阵与向量乘法)

功能：用于二维矩阵与一维向量之间的乘法操作。

应用：适用于神经网络中的前向传播、线性代数操作。

torch.dot(点乘)

功能：计算两个一维张量（向量）之间的点积，结果是一个标量。

应用：用于计算向量内积、向量相似性、物理学中的能量计算。

torch.outer(外积)

功能：计算两个一维张量之间的外积，结果是一个二维矩阵。

应用：用于构建矩阵、处理双线性形式、特征交互等。

torch.einsum(爱因斯坦求和约定)

功能：使用爱因斯坦求和约定进行复杂张量运算，包括矩阵乘法、转置、内积、外积等。

应用：广泛用于线性代数、物理学计算、机器学习中的复杂操作。

这些 PyTorch 张量操作函数各有其专门用途和应用场景。torch.matmul、torch.mm和torch.bmm主要用于矩阵乘法；torch.mul和torch.outer用于逐元素和外积操作；torch.mv和torch.dot处理矩阵与向量、向量与向量的乘法；torch.einsum则是处理复杂张量运算的多功能工具。

https://avoid.overfit.cn/post/2ce5023db7634886b602e7eb6ce4abb7