---

---

2.3. 線性代數

本節將介紹線性代數中的基本數學對象、算術和運算，并用數學符號和相應的代碼實現來表示它們。

.

1）標量

定義：僅包含一個數值的量稱為標量（零維張量），例如溫度值。

表示：標量變量用普通小寫字母表示（如 x,y,z），屬于實數空間 R。

操作：標量支持加法、乘法、除法和指數運算。

import torch
x = torch.tensor(3.0, dtype=torch.float32)
y = torch.tensor(2.0, dtype=torch.float32)
x + y, x * y, x / y, x**y# 輸出：
(tensor(5.), tensor(6.), tensor(1.5000), tensor(9.))

.

2）向量

定義：向量是標量值組成的列表（一維張量）。

表示：向量用粗體、小寫字母表示，通常為列向量（如 $\mathbf{x}=[x_1,x_2,\dots ,x_n])$，維度為元素數量$(\mathbf{x}\in {\mathbb{R}}^n)$。

操作：通過索引訪問向量的元素。

x = torch.arange(4, dtype=torch.float32)  # 創建向量：生成 [0., 1., 2., 3.]print(x)
print(x[3])   # 訪問元素：獲取索引為3的元素（第4個元素）# 輸出：
tensor([0., 1., 2., 3.])
tensor(3.)

長度、維度和形狀

• 長度：向量的元素數量。

• 維度：同向量的長度，表示向量的元素數量。

• 形狀：張量的形狀表示每個軸的長度。

print(len(x))    # len()函數來訪問張量的長度
print(x.shape)   # .shape屬性訪問向量的長度# 輸出：
4
torch.Size([4])

注：維度在不同上下文中有不同含義。向量的維度指其長度，而張量的維度指其軸的數量。

.

3）矩陣

定義：矩陣是二維張量，形狀由 (行數, 列數) 定義。

表示：數學中表示為粗體大寫字母（如 $\mathbf{A}\in {\mathbb{R}}^{m\times n}$），形狀為 (m,n)；

訪問：通過索引 A[i][j] 或 A[i, j] 獲取第 i 行第 j 列的元素；

A = torch.arange(20).reshape(5, 4)
print(A)# 輸出：
tensor([[ 0,  1,  2,  3],[ 4,  5,  6,  7],[ 8,  9, 10, 11],[12, 13, 14, 15],[16, 17, 18, 19]])

矩陣的轉置（transpose）：是交換其行和列，表示為 ${\mathbf{A}}^T$。

print(A.T)# 輸出：
tensor([[ 0,  4,  8, 12, 16],[ 1,  5,  9, 13, 17],[ 2,  6, 10, 14, 18],[ 3,  7, 11, 15, 19]])

方陣（square matrix）：當矩陣具有相同數量的行和列時，被稱為方陣；

對稱矩陣（symmetric matrix）：如果矩陣等于其轉置，則稱為對稱矩陣。

B = torch.tensor([[1, 2, 3], [2, 0, 4], [3, 4, 5]])
print(B == B.T)# 輸出結果：
tensor([[True, True, True],[True, True, True],[True, True, True]])

.

4）張量

張量是多維數組的通用表示：

• 標量：0階張量（單個數值）

• 向量：1階張量（一維數組）

• 矩陣：2階張量（二維數組）

• 高階張量：如3階張量可表示圖像（高度×寬度×顏色通道）

示例：創建3階張量（2×3×4）

import torch
X = torch.arange(24).reshape(2, 3, 4)
# 輸出兩個 3×4 矩陣的堆疊
tensor([[[ 0,  1,  2,  3], [ 4,  5,  6,  7], [ 8,  9, 10, 11]],[[12, 13, 14, 15], [16, 17, 18, 19], [20, 21, 22, 23]]])

.

5）張量的基本性質

形狀不變性

• 一元運算（如取絕對值）不改變張量形狀；

• 二元運算（如加法）要求輸入形狀相同，輸出形狀不變；

例如，將兩個相同形狀的矩陣相加，會在這兩個矩陣上執行元素加法。

A = torch.arange(20, dtype=torch.float32).reshape(5, 4)
B = A.clone()  # 通過分配新內存，將A的一個副本分配給B
A, A + B# 輸出：
(tensor([[ 0.,  1.,  2.,  3.],[ 4.,  5.,  6.,  7.],[ 8.,  9., 10., 11.],[12., 13., 14., 15.],[16., 17., 18., 19.]]),tensor([[ 0.,  2.,  4.,  6.],[ 8., 10., 12., 14.],[16., 18., 20., 22.],[24., 26., 28., 30.],[32., 34., 36., 38.]]))

Hadamard積（元素乘法）

• 對應位置元素相乘，符號為 $\odot$，數學定義：$(A\odot B{)}_{ij}=A_{ij}\times B_{ij}$

A = torch.arange(20, dtype=torch.float32).reshape(5,4)
B = A.clone()  # 復制A到B
A * B  # 輸出Hadamard積結果# 輸出：
tensor([[  0.,   1.,   4.,   9.],[ 16.,  25.,  36.,  49.],[ 64.,  81., 100., 121.],[144., 169., 196., 225.],[256., 289., 324., 361.]])

張量與標量的運算

• 張量乘以或加上一個標量不會改變張量的形狀，其中張量的每個元素都將與標量相加或相乘。

a = 2
X = torch.arange(24).reshape(2, 3, 4)
a + X, (a * X).shape# 輸出：
(tensor([[[ 2,  3,  4,  5],[ 6,  7,  8,  9],[10, 11, 12, 13]],[[14, 15, 16, 17],[18, 19, 20, 21],[22, 23, 24, 25]]]),torch.Size([2, 3, 4]))

.

6）降維

張量降維操作可以減少張量的維度，常用的降維方法包括求和和求平均值。

（1）求和操作

• 全局求和：對張量中所有元素求和，結果是一個標量。

# 向量求和
x = torch.arange(4, dtype=torch.float32)
print(x.sum())  # 輸出：tensor(6.)# 矩陣求和
A = torch.arange(20, dtype=torch.float32).reshape(5,4)
print(A.sum())  # 輸出：tensor(190.)

• 指定軸求和：沿指定軸求和，降低張量的維度。

# axis=0：對矩陣的行求和
A_sum_axis0 = A.sum(axis=0)
print(A_sum_axis0, A_sum_axis0.shape)  # 輸出：tensor([40., 45., 50., 55.]) torch.Size([4])# axis=1：對矩陣的列求和
A_sum_axis1 = A.sum(axis=1)
print(A_sum_axis1, A_sum_axis1.shape)  # 輸出：tensor([ 6., 22., 38., 54., 70.]) torch.Size([5])# 多軸求和：同時沿多個軸求和，等價于對所有元素求和。
print(A.sum(axis=[0,1]))  # 輸出：tensor(190.)

（2）求平均值操作

• 全局平均值：對張量中所有元素求平均值(mean或average）。

print(A.mean())  # 輸出：tensor(9.5000)
print(A.sum() / A.numel())  # 輸出：tensor(9.5000)

• 指定軸平均值：沿指定軸求平均值，降低張量的維度。

print(A.mean(axis=0))  # 輸出：tensor([ 8.,  9., 10., 11.])
print(A.sum(axis=0) / A.shape[0])  # 輸出：tensor([ 8.,  9., 10., 11.])

（3）非降維求和

• 保持維度的操作： 計算總和或均值時保持軸數不變；

sum_A = A.sum(axis=1, keepdims=True)
# 輸出形狀變為5×1（保留二維結構）
tensor([[ 6.],[22.],[38.],[54.],[70.]])# 利用廣播實現逐行歸一化
A / sum_A  # 每行元素除以對應行和
tensor([[0.0000, 0.1667, 0.3333, 0.5000],[0.1818, 0.2273, 0.2727, 0.3182],[0.2105, 0.2368, 0.2632, 0.2895],[0.2222, 0.2407, 0.2593, 0.2778],[0.2286, 0.2429, 0.2571, 0.2714]])

• 累積求和：沿某個軸計算A元素的累積總和；

A.cumsum(axis=0)
# 結果矩陣顯示逐步行累加過程：
tensor([[ 0,  1,  2,  3],[ 4,  6,  8, 10],  # 0行+1行[12, 15, 18, 21],  # 前兩行+2行[24, 28, 32, 36],  # 前三行+3行[40, 45, 50, 55]]) # 全部行累加

.

7）點積

點積（dot product）： 是相同位置的按元素乘積的和。

表示：為${\mathbf{x}}^{?}\mathbf{y}(或?\mathbf{x},\mathbf{y}?)$，計算如下：

${\mathbf{x}}^{?}\mathbf{y}={\sum }_{i=1}^n{x}_i{y}_i$

x = torch.arange(4, dtype=torch.float32)
y = torch.ones(4, dtype=torch.float32)# 方法1：直接點積函數
x, y, torch.dot(x, y)
# 輸出
(tensor([0., 1., 2., 3.]), tensor([1., 1., 1., 1.]), tensor(6.))# 方法2：元素乘法+求和（等價實現）
torch.sum(x * y)
# 輸出：
tensor(6.)

加權平均（weighted average）：若權重非負且和為1，則點積表示加權平均（如 x 的值與 y 的權重結合）；

余弦相似度 ：向量規范化后，點積等于夾角余弦（cosθ）；

.

8）矩陣-向量積

矩陣-向量積（matrix-vector product）：矩陣的每一行與向量的點積，結果是一個向量。

例如：矩陣A與向量x的矩陣-向量積；
$$\mathbf{A}=\left[\begin{array}{cccc}0& 1& 2& 3\\ 4& 5& 6& 7\\ 8& 9& 10& 11\\ 12& 13& 14& 15\\ 16& 17& 18& 19\end{array}\right],\mathbf{x}=\left[\begin{array}{c}0\\ 1\\ 2\\ 3\end{array}\right]$$

$$\mathbf{Ax}=\left[\begin{array}{cccc}0& 1& 2& 3\\ 4& 5& 6& 7\\ 8& 9& 10& 11\\ 12& 13& 14& 15\\ 16& 17& 18& 19\end{array}\right]\left[\begin{array}{c}0\\ 1\\ 2\\ 3\end{array}\right]=\left[\begin{array}{c}14\\ 38\\ 62\\ 86\\ 110\end{array}\right]$$

A = torch.arange(20).reshape(5, 4)
x = torch.arange(4)
result = torch.mv(A, x)
print(result)  
# 輸出：tensor([14, 38, 62, 86, 110])

.

9）矩陣-矩陣乘法

矩陣-矩陣乘法（matrix-matrix multiplication）：矩陣A的每一行與矩陣B的每一列的點積，結果是一個矩陣。

矩陣-矩陣乘法可以簡單地稱為矩陣乘法，不應與“Hadamard積”混淆。

例如：矩陣A與矩陣B的矩陣乘法；

$\mathbf{A}=\left[\begin{array}{cccc}0& 1& 2& 3\\ 4& 5& 6& 7\\ 8& 9& 10& 11\\ 12& 13& 14& 15\\ 16& 17& 18& 19\end{array}\right],\mathbf{B}=\left[\begin{array}{ccc}1& 1& 1\\ 1& 1& 1\\ 1& 1& 1\\ 1& 1& 1\end{array}\right]$

$\mathbf{C}=\mathbf{AB}=\left[\begin{array}{cccc}0& 1& 2& 3\\ 4& 5& 6& 7\\ 8& 9& 10& 11\\ 12& 13& 14& 15\\ 16& 17& 18& 19\end{array}\right]\left[\begin{array}{ccc}1& 1& 1\\ 1& 1& 1\\ 1& 1& 1\\ 1& 1& 1\end{array}\right]=\left[\begin{array}{ccc}6& 6& 6\\ 22& 22& 22\\ 38& 38& 38\\ 54& 54& 54\\ 70& 70& 70\end{array}\right]$

A = torch.arange(20).reshape(5, 4)  # 形狀 (5,4)  
B = torch.ones(4, 3)                # 形狀 (4,3)  
# 使用 torch.mm(A, B) 來執行矩陣乘法
C = torch.mm(A, B)                  # 輸出形狀 (5,3)  print(C)  
# 輸出:  
# tensor([[  6.,   6.,   6.],  
#         [ 22.,  22.,  22.],  
#         [ 38.,  38.,  38.],  
#         [ 54.,  54.,  54.],  
#         [ 70.,  70.,  70.]])  

.

10）范數

（1）范數（Norm）： 是衡量向量/矩陣“大小”的函數，滿足以下性質：

• 縮放性質：$f(\alpha \mathbf{x})=|\alpha |f(\mathbf{x})$

• 三角不等式：$f(\mathbf{x}+\mathbf{y})\le f(\mathbf{x})+f(\mathbf{y})$

• 非負性：$f(\mathbf{x})\ge 0$

• 零向量性質：當且僅當 $\mathbf{x}$ 是零向量時，$f(\mathbf{x})=0$

（2）常見范數類型

• L2范數（歐幾里得范數）：$\Vert \mathbf{x}{\Vert }_2=\sqrt{{\sum }_{i=1}^n{x}_i^2}$，表示向量元素平方和的平方根。

# L2范數（向量）
u = torch.tensor([3.0, -4.0])
l2_norm = torch.norm(u)           # tensor(5.0) → √(32 + (-4)2 = 5

• L1范數（曼哈頓范數）：$\Vert \mathbf{x}{\Vert }_1={\sum }_{i=1}^n|x_i|$，表示向量元素的絕對值之和。

# L1范數（向量）
l1_norm = torch.abs(u).sum()      # tensor(7.0) → |3| + |-4| = 7

• 范數L2和范數L1都是更一般的范數Lp的特例：$\Vert \mathbf{x}{\Vert }_p=({\sum }_{i=1}^n|x_i{|}^p{)}^{1/p}$，

• 矩陣X的Frobenius范數（Frobenius norm）：$|\mathbf{X}{|}_F=\sqrt{{\sum }_{i=1}^m{\sum }_{j=1}^n{x}_{ij}^2}$，是矩陣元素平方和的平方根

# Frobenius范數（矩陣）
matrix = torch.ones((4, 9))       # 4行9列全1矩陣
frobenius_norm = torch.norm(matrix)  # tensor(6.0) → √(4×9×12) = 6

在深度學習中，范數常用于優化問題，例如最大化觀測數據的概率、最小化預測與真實觀測之間的距離等。它們幫助衡量和比較不同向量或矩陣的大小。

.

11） 小結

• 標量、向量、矩陣和張量是線性代數中的基本數學對象。

• 向量泛化自標量，矩陣泛化自向量。

• 標量、向量、矩陣和張量分別具有零、一、二和任意數量的軸。

• 一個張量可以通過sum和mean沿指定的軸降低維度。

• 兩個矩陣的按元素乘法被稱為他們的Hadamard積。它與矩陣乘法不同。

• 在深度學習中，我們經常使用范數，如范數、范數和Frobenius范數。

.

如果渴望了解有關線性代數的更多信息，可以參考線性代數運算的在線附錄或其他優秀資源 (Kolter, 2008, Petersen et al., 2008, Strang, 1993)。

---

聲明：資源可能存在第三方來源，若有侵權請聯系刪除！