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

---

---

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}}^{\top }\mathbf{y}(或⟨\mathbf{x},\mathbf{y}⟩)$，计算如下：

${\mathbf{x}}^{\top }\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) → √(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的特例：$\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×1²) = 6

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

.

11） 小结

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

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

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

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

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

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

.

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

---

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