掌握 PyTorch 張量乘法：八個關鍵函數與應用場景對比解析
PyTorch提供了幾種張量乘法的方法，每種方法都是不同的，并且有不同的應用。我們來詳細介紹每個方法，并且詳細解釋這些函數有什么區別：
一、torch.matmul
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
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
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
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
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 = 122torch.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
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
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 是一個用于計算兩個一維張量之間外積的高效工具。它在生成矩陣、處理雙線性形式、構建張量積等應用中非常有用。外積在很多場景中都有應用，包括但不限于：
- 矩陣構建：外積可用于生成特定類型的矩陣，例如克羅內克積。
- 雙線性形式：在雙線性形式的表示中，外積經常用于構建張量。
- 機器學習：在神經網絡的權重更新、特征交互等場景中，外積運算可以構造高階特征。
8、torch.einsum
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 則是處理復雜張量運算的多功能工具。
