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

目录

• • 2.3. 线性代数
  • • 1）标量
    • 2）向量
    • 3）矩阵
    • 4）张量
    • 5）张量的基本性质
    • 6）降维
    • 7）点积
    • 8）矩阵-向量积
    • 9）矩阵-矩阵乘法
    • 10）范数
    • 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 = 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=1n​xi​yi​

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=

​0481216​1591317​26101418​37111519​

​, 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=

​0481216​1591317​26101418​37111519​

​

​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=

​0481216​1591317​26101418​37111519​

​,B=

​1111​1111​1111​

​

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=

​0481216​1591317​26101418​37111519​

​

​1111​1111​1111​

​=

​622385470​622385470​622385470​

​

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范数（欧几里得范数）：$\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) → √(3² + (-4)² = 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的特例：

  ∥

  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=1n​xij2​

  ​，是矩阵元素平方和的平方根

# 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, Petersen et al., 2008, Strang, 1993)。

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