【动手学深度学习】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×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$ ，数学定义： $\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} (或\langle \mathbf{x}, \mathbf{y} \rangle)$ ，计算如下：

$\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} = \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}$

$\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}$

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} = \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}$

$\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}$

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}) \leq f(\mathbf{x}) + f(\mathbf{y})$
非负性： $f(\mathbf{x}) \geq 0$
零向量性质：当且仅当 $\mathbf{x}$ 是零向量时， $f(\mathbf{x}) = 0$

（2）常见范数类型

L2范数（欧几里得范数）： $\|\mathbf{x}\|_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范数（曼哈顿范数）： $\|\mathbf{x}\|_1 = \sum_{i=1}^n |x_i|$ ，表示向量元素的绝对值之和。

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

范数L2和范数L1都是更一般的范数Lp的特例： $\|\mathbf{x}\|_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)。

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