【动手学深度学习】2.3. 线性代数

---

目录

• • [2.3. 线性代数](#2.3. 线性代数)
  • • 1）标量
    • 2）向量
    • 3）矩阵
    • 4）张量
    • 5）张量的基本性质
    • 6）降维
    • 7）点积
    • 8）矩阵-向量积
    • 9）矩阵-矩阵乘法
    • 10）范数
    • [11） 小结](#11） 小结)

---

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）向量

定义：向量是标量值组成的列表（一维张量）。

表示 ：向量用粗体、小写字母表示，通常为列向量（如 x = [ x 1 , x 2 , ... , x n ] ) \mathbf{x} = [x_1, x_2, \dots, x_n] ) x=[x1,x2,...,xn])，维度为元素数量 ( x ∈ R n ) ( \mathbf{x} \in \mathbb{R}^n ) (x∈Rn)。

操作：通过索引访问向量的元素。

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）矩阵

定义 ：矩阵是二维张量，形状由 (行数, 列数) 定义。

表示 ：数学中表示为粗体大写字母（如 A ∈ R m × n \mathbf{A} \in \mathbb{R}^{m×n} A∈Rm×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）：是交换其行和列，表示为 A T \mathbf{A}^T AT。

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 ⊙ B ) i j = A i j × B i j (A \odot B){ij} = A{ij} \times B_{ij} (A⊙B)ij=Aij×Bij

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）： 是相同位置的按元素乘积的和。

表示 ：为 x ⊤ y ( 或 ⟨ x , y ⟩ ) \mathbf{x}^\top \mathbf{y} (或\langle \mathbf{x}, \mathbf{y} \rangle) x⊤y(或⟨x,y⟩)，计算如下：

x ⊤ y = ∑ i = 1 n x i y i \mathbf{x}^\top \mathbf{y} = \sum_{i=1}^n x_i y_i x⊤y=∑i=1nxiyi

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 的矩阵-向量积；
A = [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 ] , x = [ 0 1 2 3 ] \mathbf{A} = \begin{bmatrix} 0 & 1 & 2 & 3 \\ 4 & 5 & 6 & 7 \\ 8 & 9 & 10 & 11 \\ 12 & 13 & 14 & 15 \\ 16 & 17 & 18 & 19 \end{bmatrix} , \ \mathbf{x} = \begin{bmatrix} 0\\ 1\\ 2\\ 3 \end{bmatrix} A= 048121615913172610141837111519 , x= 0123

A x = [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 ] [ 0 1 2 3 ] = [ 14 38 62 86 110 ] \mathbf{Ax} = \begin{bmatrix} 0 & 1 & 2 & 3 \\ 4 & 5 & 6 & 7 \\ 8 & 9 & 10 & 11 \\ 12 & 13 & 14 & 15 \\ 16 & 17 & 18 & 19 \end{bmatrix} \begin{bmatrix} 0\\ 1\\ 2\\ 3 \end{bmatrix} =\begin{bmatrix} 14 \\ 38 \\ 62 \\ 86 \\ 110 \end{bmatrix} Ax= 048121615913172610141837111519 0123 = 14386286110

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的矩阵乘法；

A = [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 ] , B = [ 1 1 1 1 1 1 1 1 1 1 1 1 ] \mathbf{A} = \begin{bmatrix} 0 & 1 & 2 & 3 \\ 4 & 5 & 6 & 7 \\ 8 & 9 & 10 & 11 \\ 12 & 13 & 14 & 15 \\ 16 & 17 & 18 & 19 \\ \end{bmatrix}, \quad \mathbf{B} = \begin{bmatrix} 1 & 1 & 1 \\ 1 & 1 & 1 \\ 1 & 1 & 1 \\ 1 & 1 & 1 \\ \end{bmatrix} A= 048121615913172610141837111519 ,B= 111111111111

C = A B = [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 ] [ 1 1 1 1 1 1 1 1 1 1 1 1 ] = [ 6 6 6 22 22 22 38 38 38 54 54 54 70 70 70 ] \mathbf{C} = \mathbf{A} \mathbf{B} = \begin{bmatrix} 0 & 1 & 2 & 3 \\ 4 & 5 & 6 & 7 \\ 8 & 9 & 10 & 11 \\ 12 & 13 & 14 & 15 \\ 16 & 17 & 18 & 19 \end{bmatrix} \begin{bmatrix} 1 & 1 & 1 \\ 1 & 1 & 1 \\ 1 & 1 & 1 \\ 1 & 1 & 1 \end{bmatrix} = \begin{bmatrix} 6 & 6 & 6 \\ 22 & 22 & 22 \\ 38 & 38 & 38 \\ 54 & 54 & 54 \\ 70 & 70 & 70 \end{bmatrix} C=AB= 048121615913172610141837111519 111111111111 = 622385470622385470622385470

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 ( α x ) = ∣ α ∣ f ( x ) f(\alpha \mathbf{x}) = |\alpha| f(\mathbf{x}) f(αx)=∣α∣f(x)

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

• 非负性： f ( x ) ≥ 0 f(\mathbf{x}) \geq 0 f(x)≥0

• 零向量性质：当且仅当 x \mathbf{x} x 是零向量时， f ( x ) = 0 f(\mathbf{x}) = 0 f(x)=0

（2）常见范数类型

• L2范数（欧几里得范数） ： ∥ x ∥ 2 = ∑ i = 1 n x i 2 \|\mathbf{x}\|2 = \sqrt{\sum{i=1}^n x_i^2} ∥x∥2=∑i=1nxi2 ，表示向量元素平方和的平方根。

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

• L1范数（曼哈顿范数） ： ∥ x ∥ 1 = ∑ i = 1 n ∣ x i ∣ \|\mathbf{x}\|1 = \sum{i=1}^n |x_i| ∥x∥1=∑i=1n∣xi∣，表示向量元素的绝对值之和。

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

• 范数L2 和范数L1 都是更一般的范数Lp 的特例： ∥ x ∥ p = ( ∑ i = 1 n ∣ x i ∣ p ) 1 / p \|\mathbf{x}\|p = (\sum{i=1}^n |x_i|^p)^{1/p} ∥x∥p=(∑i=1n∣xi∣p)1/p，

• 矩阵X 的Frobenius范数 （Frobenius norm）： ∣ X ∣ F = ∑ i = 1 m ∑ j = 1 n x i j 2 |\mathbf{X}|F = \sqrt{\sum{i=1}^m \sum_{j=1}^n x_{ij}^2} ∣X∣F=∑i=1m∑j=1nxij2 ，是矩阵元素平方和的平方根

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

在深度学习中，范数常用于优化问题，例如最大化观测数据的概率、最小化预测与真实观测之间的距离等。它们帮助衡量和比较不同向量或矩阵的大小。

.

11） 小结

• 标量、向量、矩阵和张量是线性代数中的基本数学对象。

• 向量泛化自标量，矩阵泛化自向量。

• 标量、向量、矩阵和张量分别具有零、一、二和任意数量的轴。

• 一个张量可以通过sum和mean沿指定的轴降低维度。

• 两个矩阵的按元素乘法被称为他们的Hadamard积。它与矩阵乘法不同。

• 在深度学习中，我们经常使用范数，如范数、范数和Frobenius范数。

.

如果渴望了解有关线性代数的更多信息，可以参考线性代数运算的在线附录或其他优秀资源 (Kolter, 2008, Petersenet al. , 2008, Strang, 1993)。

---

声明：资源可能存在第三方来源，若有侵权请联系删除！