数学与算法基础

概述

数学是人工智能的底层语言。从神经网络的梯度下降到注意力机制的矩阵乘法，从概率生成模型到贝叶斯推断，AI 的每个核心组件都建立在坚实的数学基础之上。然而，对于工程实践者而言，我们不需要像数学家那样追求严格的证明体系，而是需要建立起"直觉理解"——能够看懂损失函数的数学表达、理解梯度下降的几何意义、读懂论文中的公式推导。

本模块聚焦四个核心数学领域（线性代数、微积分、概率统计、优化方法）以及基础数据结构与算法，按照"从概念到实践"的路径组织内容。每个知识点都配有直观的解释和在 AI 中的具体应用场景，确保你能够将抽象的数学符号与实际的代码实现对应起来。

线性代数是人工智能的数学基础，它为数据的表示、变换和分析提供了强大的工具。在机器学习领域，从数据预处理到模型训练，从神经网络的前向传播到反向传播，线性代数无处不在。本章将从实用角度出发，介绍理解AI算法所必需的线性代数知识，避免过度复杂的理论推导，注重几何直觉和代码实现。

3.1 向量与向量空间

3.1.1 向量的定义与表示

向量是线性代数中最基本的概念，它可以被理解为具有大小和方向的量。在AI中，向量是表示数据的基本方式：一张图片可以表示为像素值的向量，一段文本可以表示为词嵌入向量，一个用户的行为可以表示为特征向量。

从数学角度看，一个$n$维向量$\mathbf{v}$是一个有序的$n$元组：

在Python中，我们通常使用NumPy数组来表示向量：

import numpy as np

# 创建向量
v = np.array([3, 1, 4, 1, 5])
print(f"向量: {v}")
print(f"维度: {v.shape}")
print(f"L2范数: {np.linalg.norm(v):.4f}")

向量的范数（Norm）表示向量的"长度"。最常用的L2范数（欧几里得范数）定义为：

在机器学习中，范数有重要应用：L2正则化通过惩罚大权重的L2范数来防止过拟合；余弦相似度通过向量的内积和范数来衡量两个向量的相似程度。

3.1.2 向量运算与几何意义

向量的基本运算包括加法、数乘和点积，每种运算都有直观的几何解释。

向量加法遵循平行四边形法则。两个向量$\mathbf{u}$和$\mathbf{v}$的和$\mathbf{u} + \mathbf{v}$，几何上表示以这两个向量为邻边的平行四边形的对角线。

点积（内积）是机器学习中最重要的向量运算之一。两个向量的点积定义为：

点积的几何意义尤为深刻：

其中$\theta$是两个向量之间的夹角。这个公式揭示了点积的本质：它衡量了两个向量的"同向程度"。当两个向量方向相同时，点积最大；当方向垂直时，点积为零；当方向相反时，点积为负。

import numpy as np

# 向量运算示例
u = np.array([3, 1])
v = np.array([1, 3])

# 向量加法
w = u + v
print(f"u + v = {w}")

# 点积
dot_product = np.dot(u, v)
print(f"u · v = {dot_product}")

# 计算夹角
cos_theta = dot_product / (np.linalg.norm(u) * np.linalg.norm(v))
theta = np.arccos(cos_theta)
print(f"夹角: {np.degrees(theta):.2f}°")

# 投影
projection = dot_product / np.linalg.norm(v)
print(f"u在v上的投影长度: {projection:.4f}")

点积在AI中的应用：

1. 余弦相似度：衡量两个文档、用户或物品的相似程度，是推荐系统和信息检索的核心算法
2. 注意力机制：Transformer中的自注意力通过点积计算查询与键的相似度
3. 线性回归：预测值是特征向量与权重向量的点积

叉积（仅适用于三维向量）产生一个垂直于原向量所在平面的新向量，其模等于两向量张成的平行四边形的面积。叉积在计算机图形学和物理模拟中有广泛应用。

import numpy as np

# 叉积示例
u = np.array([1, 0, 0])
v = np.array([0, 1, 0])
cross_product = np.cross(u, v)
print(f"u × v = {cross_product}")  # 结果应该是[0, 0, 1]

# 叉积的模等于平行四边形面积
area = np.linalg.norm(cross_product)
print(f"平行四边形面积: {area}")

外积将两个向量相乘产生一个矩阵，在机器学习中用于构造秩1矩阵：

# 外积示例
u = np.array([1, 2, 3])
v = np.array([4, 5])
outer_product = np.outer(u, v)
print(f"外积结果:\n{outer_product}")

3.1.3 向量空间与子空间

向量空间（Vector Space）是一组向量的集合，满足特定的公理（加法封闭性、数乘封闭性等）。直观上，向量空间可以看作是一个"空间"，其中的向量可以通过加法和数乘进行"移动"和"伸缩"。

基（Basis）是向量空间中的一组特殊向量，它们线性无关且可以表示空间中的任何向量。$n$维空间的标准基是：

子空间是向量空间的子集，本身也构成向量空间。在机器学习中，降维的本质就是寻找数据所在的低维子空间。例如，主成分分析（PCA）找到的是数据方差最大的子空间。

线性无关与秩：一组向量线性无关意味着没有一个向量可以被其他向量的线性组合表示。向量组的秩（Rank）是其中线性无关向量的最大个数，它表示这组向量张成的子空间的维度。

import numpy as np

# 判断向量组的线性相关性
vectors = np.array([
    [1, 2, 3],
    [2, 4, 6],  # 这是第一个向量的2倍，线性相关
    [1, 0, 1]
])

# 计算秩
rank = np.linalg.matrix_rank(vectors)
print(f"向量组的秩: {rank}")  # 输出2，说明只有2个线性无关的向量

# 寻找一组基（通过SVD）
U, S, Vt = np.linalg.svd(vectors)
print(f"奇异值: {S}")  # 非零奇异值的个数等于秩

张成空间（Span）是一组向量所有线性组合的集合。如果一组向量张成的空间是整个$\mathbb{R}^n$，则称这组向量是完备的（Complete）。在机器学习中，特征空间的维度决定了模型的表达能力。

维数定理（Rank-Nullity Theorem）指出：对于矩阵$\mathbf{A} \in \mathbb{R}^{m \times n}$，

其中$\text{nullity}(\mathbf{A})$是$\mathbf{A}$的零空间维度。这个定理揭示了线性变换的"信息损失"：输入空间的维度等于像空间维度加上被"压缩"到零的维度。

# 零空间示例
A = np.array([[1, 2, 3], [2, 4, 6]])  # 秩为1
print(f"矩阵A的秩: {np.linalg.matrix_rank(A)}")

# 通过SVD找到零空间
U, S, Vt = np.linalg.svd(A)
# 零空间由Vt中对应于零奇异值的行向量张成
null_space = Vt[1:, :]  # 假设只有一个非零奇异值
print(f"零空间的基向量:\n{null_space}")

# 验证：A @ null_space.T 应该接近零
print(f"验证 A @ null_space.T:\n{A @ null_space.T}")

3.2 矩阵与矩阵运算

3.2.1 矩阵的基本概念

矩阵是线性代数的核心工具，它是一个由数字排列成的矩形阵列。一个$m \times n$的矩阵有$m$行$n$列：

在机器学习中，矩阵是表示数据的自然方式：

• 一个数据集通常表示为$n \times d$的矩阵，$n$是样本数，$d$是特征数
• 神经网络的权重是矩阵
• 图像可以看作像素值的矩阵

import numpy as np

# 创建矩阵
A = np.array([
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
])

print(f"矩阵A:\n{A}")
print(f"形状: {A.shape}")
print(f"转置:\n{A.T}")

# 访问元素
print(f"A[1,2] = {A[1, 2]}")  # 第2行第3列（从0开始计数）
print(f"第2行: {A[1, :]}")
print(f"第3列: {A[:, 2]}")

3.2.2 矩阵乘法与转置

矩阵乘法是线性代数中最重要的运算。对于矩阵$\mathbf{A} \in \mathbb{R}^{m \times n}$和$\mathbf{B} \in \mathbb{R}^{n \times p}$，它们的乘积$\mathbf{C} = \mathbf{A}\mathbf{B} \in \mathbb{R}^{m \times p}$的元素定义为：

矩阵乘法的几何意义是线性变换的组合。当我们用矩阵$\mathbf{A}$乘以向量$\mathbf{x}$时，实际上是对$\mathbf{x}$进行了一次线性变换。

import numpy as np

# 矩阵乘法示例
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])

# 矩阵乘法
C = np.dot(A, B)
# 或使用 @ 运算符（Python 3.5+）
C_alt = A @ B

print(f"A @ B =\n{C}")

# 验证: C[0,0] = 1*5 + 2*7 = 19
print(f"手动计算C[0,0]: {A[0,0]*B[0,0] + A[0,1]*B[1,0]}")

# 矩阵-向量乘法
v = np.array([1, 2])
result = A @ v
print(f"A @ v = {result}")

矩阵乘法的性质：

• 不满足交换律：一般情况下$\mathbf{A}\mathbf{B} \neq \mathbf{B}\mathbf{A}$
• 满足结合律：$(\mathbf{A}\mathbf{B})\mathbf{C} = \mathbf{A}(\mathbf{B}\mathbf{C})$
• 满足分配律：$\mathbf{A}(\mathbf{B} + \mathbf{C}) = \mathbf{A}\mathbf{B} + \mathbf{A}\mathbf{C}$

转置操作将矩阵的行和列互换。矩阵$\mathbf{A}$的转置记为$\mathbf{A}^T$：

转置的重要性质：

• $(\mathbf{A}^T)^T = \mathbf{A}$
• $(\mathbf{A}\mathbf{B})^T = \mathbf{B}^T\mathbf{A}^T$
• 对称矩阵满足$\mathbf{A} = \mathbf{A}^T$

广播机制是NumPy中处理不同形状数组运算的重要特性。当两个数组的形状不同时，NumPy会自动扩展较小的数组以匹配较大数组的形状。这在机器学习中非常常见，例如给每个样本加上相同的偏置向量：

import numpy as np

# 广播示例
X = np.array([[1, 2, 3], [4, 5, 6]])  # 2x3矩阵
b = np.array([10, 20, 30])           # 1x3向量

# 广播：b被扩展为[[10,20,30], [10,20,30]]
result = X + b
print(f"广播结果:\n{result}")

# 矩阵乘法中的广播
W = np.random.randn(3, 2)
b = np.array([1, 2])
X = np.random.randn(5, 3)
output = X @ W + b  # b被广播到(5, 2)
print(f"输出形状: {output.shape}")

批量矩阵乘法在深度学习中非常常见。当处理一个batch的数据时，输入是一个三维张量$(batch\_size, n, m)$，权重是$(m, p)$，输出是$(batch\_size, n, p)$：

# 批量矩阵乘法
batch_size = 32
seq_len = 10
d_model = 64
d_ff = 256

# 输入: (batch, seq, d_model)
X = np.random.randn(batch_size, seq_len, d_model)
# 权重: (d_model, d_ff)
W = np.random.randn(d_model, d_ff)

# 批量矩阵乘法
output = X @ W  # 结果: (batch, seq, d_ff)
print(f"输入形状: {X.shape}")
print(f"权重形状: {W.shape}")
print(f"输出形状: {output.shape}")

3.2.3 特殊矩阵类型

在AI中，有几种特殊类型的矩阵特别重要：

import numpy as np

# 单位矩阵
I = np.eye(3)
print(f"3x3单位矩阵:\n{I}")

# 对角矩阵
D = np.diag([2, 3, 5])
print(f"对角矩阵:\n{D}")

# 验证正交矩阵
Q = np.array([[0, -1], [1, 0]])  # 90度旋转矩阵
print(f"Q^T @ Q =\n{Q.T @ Q}")  # 应该接近单位矩阵

# 对称矩阵
S = np.array([[2, 1], [1, 3]])
print(f"S是否对称: {np.allclose(S, S.T)}")

# 验证正定性（通过特征值）
eigenvalues = np.linalg.eigvals(S)
print(f"特征值: {eigenvalues}")
print(f"是否正定: {np.all(eigenvalues > 0)}")

3.2.4 矩阵分解初步

矩阵分解是将矩阵表示为更简单矩阵乘积的技术，在AI中有广泛应用。

LU分解：将矩阵分解为下三角矩阵和上三角矩阵的乘积，用于高效求解线性方程组。

特征分解：对于方阵$\mathbf{A}$，如果存在非零向量$\mathbf{v}$和标量$\lambda$使得：

则$\lambda$称为特征值，$\mathbf{v}$称为特征向量。特征分解将矩阵表示为：

其中$\mathbf{\Lambda}$是对角矩阵，对角线元素是特征值；$\mathbf{V}$的列是对应的特征向量。

奇异值分解（SVD）：对于任意$m \times n$矩阵$\mathbf{A}$，都可以分解为：

其中$\mathbf{U}$和$\mathbf{V}$是正交矩阵，$\mathbf{\Sigma}$是对角矩阵（对角线元素称为奇异值，非负且按降序排列）。

SVD的应用：

1. 降维：通过保留前$k$个最大的奇异值，可以实现数据的有效压缩
2. 去噪：小奇异值通常对应噪声，去除它们可以净化信号
3. 推荐系统：矩阵分解是协同过滤的基础
4. 图像压缩：保留主要奇异值可以大幅减小图像存储空间

import numpy as np
import matplotlib.pyplot as plt

# SVD在图像压缩中的应用示例
# 创建一个模拟的"图像"矩阵
image = np.zeros((100, 100))
for i in range(100):
    for j in range(100):
        image[i, j] = np.sin(i/10) * np.cos(j/10) + 0.1 * np.random.randn()

# SVD分解
U, S, Vt = np.linalg.svd(image, full_matrices=False)

# 使用不同数量的奇异值进行重构
fig, axes = plt.subplots(2, 3, figsize=(15, 10))
axes = axes.flatten()

k_values = [5, 10, 20, 50, 100]
for idx, k in enumerate(k_values):
    # 低秩近似
    image_approx = U[:, :k] @ np.diag(S[:k]) @ Vt[:k, :]
    compression_ratio = (100*100) / (k * (100 + 100 + 1))
    
    ax = axes[idx]
    ax.imshow(image_approx, cmap='gray')
    ax.set_title(f'k={k}, Compression={compression_ratio:.1f}x')
    ax.axis('off')

# 原始图像
axes[-1].imshow(image, cmap='gray')
axes[-1].set_title('Original')
axes[-1].axis('off')

plt.tight_layout()
plt.savefig('/mnt/okcomputer/output/fig_svd_compression.png', dpi=100, bbox_inches='tight')
plt.show()

print(f"原始图像大小: {image.size} 个元素")
print(f"前10个奇异值: {S[:10].round(2)}")
print(f"奇异值总和: {S.sum():.2f}")
print(f"前10个奇异值占比: {S[:10].sum() / S.sum():.2%}")

import numpy as np

# 奇异值分解
A = np.array([[1, 2, 3], [4, 5, 6]])
U, S, Vt = np.linalg.svd(A, full_matrices=False)

print(f"U shape: {U.shape}")
print(f"奇异值: {S}")
print(f"Vt shape: {Vt.shape}")

# 重构矩阵
A_reconstructed = U @ np.diag(S) @ Vt
print(f"重构误差: {np.linalg.norm(A - A_reconstructed):.10f}")

# 低秩近似（保留前k个奇异值）
k = 1
A_approx = U[:, :k] @ np.diag(S[:k]) @ Vt[:k, :]
print(f"秩1近似误差: {np.linalg.norm(A - A_approx):.4f}")

3.3 线性变换与特征分析

3.3.1 线性变换的矩阵表示

线性变换是保持向量加法和数乘的映射。任何线性变换都可以用矩阵乘法来表示。对于变换$\mathbf{T}$和向量$\mathbf{x}$、$\mathbf{y}$，以及标量$c$：

上图展示了常见的线性变换及其矩阵表示：

1. 缩放变换：$\mathbf{S} = \begin{bmatrix} s_x & 0 \\ 0 & s_y \end{bmatrix}$
2. 旋转变换：$\mathbf{R} = \begin{bmatrix} \cos\theta & -\sin\theta \\ \sin\theta & \cos\theta \end{bmatrix}$
3. 剪切变换：$\mathbf{H} = \begin{bmatrix} 1 & h \\ 0 & 1 \end{bmatrix}$
4. 投影变换：将向量投影到某个子空间

import numpy as np
import matplotlib.pyplot as plt

# 线性变换示例：图像旋转
def rotate_image_points(points, angle_deg):
    """旋转点集"""
    angle_rad = np.radians(angle_deg)
    R = np.array([
        [np.cos(angle_rad), -np.sin(angle_rad)],
        [np.sin(angle_rad), np.cos(angle_rad)]
    ])
    return points @ R.T

# 创建一个简单的"图像"（正方形的点）
x = np.linspace(-1, 1, 20)
y = np.linspace(-1, 1, 20)
X, Y = np.meshgrid(x, y)
points = np.column_stack([X.ravel(), Y.ravel()])

# 应用旋转变换
rotated_points = rotate_image_points(points, 45)

print(f"原始点形状: {points.shape}")
print(f"变换后点形状: {rotated_points.shape}")
print(f"旋转矩阵:\n{np.array([[np.cos(np.pi/4), -np.sin(np.pi/4)], [np.sin(np.pi/4), np.cos(np.pi/4)]])}")

3.3.2 特征值与特征向量

特征值和特征向量是理解线性变换本质的关键。对于矩阵$\mathbf{A}$，如果：

则$\mathbf{v}$是$\mathbf{A}$的特征向量，$\lambda$是对应的特征值。

几何解释：特征向量是在变换后方向不变的向量（或反向），特征值表示该方向上伸缩的倍数。

import numpy as np

# 计算特征值和特征向量
A = np.array([[4, 2], [1, 3]])
eigenvalues, eigenvectors = np.linalg.eig(A)

print(f"特征值: {eigenvalues}")
print(f"特征向量:\n{eigenvectors}")

# 验证 Av = λv
for i in range(len(eigenvalues)):
    v = eigenvectors[:, i]
    lambda_v = eigenvalues[i]
    Av = A @ v
    lambda_v_v = lambda_v * v
    print(f"\n特征向量 {i+1}: {v}")
    print(f"A @ v = {Av}")
    print(f"λ * v = {lambda_v_v}")
    print(f"验证结果: {np.allclose(Av, lambda_v_v)}")

特征值的重要性质：

• 矩阵的迹（对角线元素之和）等于特征值之和
• 矩阵的行列式等于特征值之积
• 对称矩阵的特征值都是实数，特征向量两两正交

特征值分解与矩阵幂运算：对角化使得矩阵的幂运算变得简单。对于可对角化的矩阵$\mathbf{A} = \mathbf{V}\mathbf{\Lambda}\mathbf{V}^{-1}$：

这在计算状态转移、PageRank等迭代算法中非常有用。

import numpy as np

# 矩阵幂运算示例
A = np.array([[0.9, 0.1], [0.2, 0.8]])

# 方法1: 直接计算
A_power_10_direct = np.linalg.matrix_power(A, 10)

# 方法2: 通过特征值分解
eigenvalues, eigenvectors = np.linalg.eig(A)
V = eigenvectors
Lambda = np.diag(eigenvalues)
V_inv = np.linalg.inv(V)

A_power_10_eig = V @ np.diag(eigenvalues**10) @ V_inv

print("直接计算 A^10:")
print(A_power_10_direct.round(4))
print("\n特征值分解计算 A^10:")
print(A_power_10_eig.round(4))
print(f"\n两种方法结果一致: {np.allclose(A_power_10_direct, A_power_10_eig)}")

# 稳态分布（当n->无穷时）
# 稳态分布对应于特征值1的特征向量
steady_state = eigenvectors[:, np.isclose(eigenvalues, 1)]
steady_state = steady_state / steady_state.sum()  # 归一化
print(f"\n稳态分布: {steady_state.flatten().real.round(4)}")

协方差矩阵的特征分析：在统计学中，数据的协方差矩阵的特征值和特征向量揭示了数据的主要变异方向。最大的特征值对应的特征向量指向数据方差最大的方向，这正是PCA的基础。

# 协方差矩阵的特征分析
np.random.seed(42)

# 生成相关数据
n_samples = 500
x = np.random.randn(n_samples)
y = 0.8 * x + 0.6 * np.random.randn(n_samples)
data = np.column_stack([x, y])

# 计算协方差矩阵
cov_matrix = np.cov(data.T)
print(f"协方差矩阵:\n{cov_matrix.round(4)}")

# 特征值分解
eigenvalues, eigenvectors = np.linalg.eigh(cov_matrix)
print(f"\n特征值: {eigenvalues.round(4)}")
print(f"特征向量:\n{eigenvectors.round(4)}")

# 特征值表示各方向的方差
print(f"\n总方差: {eigenvalues.sum():.4f}")
print(f"第一主成分解释方差比例: {eigenvalues[1]/eigenvalues.sum():.2%}")

3.3.3 对角化与谱分解

对角化是将方阵$\mathbf{A}$表示为：

其中$\mathbf{\Lambda}$是对角矩阵。对角化的好处是简化矩阵运算：

谱分解是对称矩阵的特殊对角化形式：

这表示对称矩阵可以分解为秩1矩阵的加权和。

import numpy as np

# 对称矩阵的谱分解
A = np.array([[2, 1], [1, 2]])
eigenvalues, eigenvectors = np.linalg.eigh(A)  # eigh用于对称矩阵

print(f"特征值: {eigenvalues}")
print(f"特征向量:\n{eigenvectors}")

# 谱分解重构
A_reconstructed = np.zeros_like(A, dtype=float)
for i in range(len(eigenvalues)):
    lambda_i = eigenvalues[i]
    v_i = eigenvectors[:, i:i+1]  # 保持列向量形状
    A_reconstructed += lambda_i * (v_i @ v_i.T)

print(f"\n原始矩阵:\n{A}")
print(f"谱分解重构:\n{A_reconstructed}")
print(f"重构误差: {np.linalg.norm(A - A_reconstructed):.10f}")

# 验证特征向量正交性
print(f"\n特征向量正交性验证:")
print(f"v1·v2 = {np.dot(eigenvectors[:, 0], eigenvectors[:, 1]):.10f}")

3.4 线性代数在AI中的应用

3.4.1 数据表示与嵌入空间

在AI中，数据通常被表示为向量或矩阵，这种表示使得数学运算和机器学习算法可以高效地处理数据。

词嵌入是自然语言处理中的核心技术。每个词被表示为一个高维向量（如300维），语义相近的词在向量空间中距离较近。词嵌入的神奇之处在于向量运算可以捕捉语义关系：

import numpy as np

# 简化的词嵌入示例
# 假设我们有以下词向量（实际中通过Word2Vec或GloVe训练得到）
word_vectors = {
    'king': np.array([0.8, 0.6, 0.3]),
    'queen': np.array([0.7, 0.8, 0.4]),
    'man': np.array([0.5, 0.2, 0.1]),
    'woman': np.array([0.4, 0.7, 0.3]),
    'apple': np.array([0.1, 0.2, 0.9])
}

def cosine_similarity(v1, v2):
    """计算余弦相似度"""
    return np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2))

def find_most_similar(query_vector, word_vectors, exclude=None):
    """找到最相似的词"""
    best_word = None
    best_sim = -1
    for word, vec in word_vectors.items():
        if exclude and word in exclude:
            continue
        sim = cosine_similarity(query_vector, vec)
        if sim > best_sim:
            best_sim = sim
            best_word = word
    return best_word, best_sim

# 词类比: king - man + woman ≈ ?
query = word_vectors['king'] - word_vectors['man'] + word_vectors['woman']
result, similarity = find_most_similar(query, word_vectors, exclude=['king', 'man', 'woman'])
print(f"king - man + woman ≈ {result} (相似度: {similarity:.4f})")

# 查看所有词对的相似度
print("\n词向量余弦相似度矩阵:")
words = list(word_vectors.keys())
sim_matrix = np.zeros((len(words), len(words)))
for i, w1 in enumerate(words):
    for j, w2 in enumerate(words):
        sim_matrix[i, j] = cosine_similarity(word_vectors[w1], word_vectors[w2])

for i, w in enumerate(words):
    print(f"{w}: {sim_matrix[i]}")

3.4.2 神经网络的前向传播

神经网络的核心运算是矩阵乘法和激活函数的组合。一个全连接层可以表示为：

其中$\mathbf{W}$是权重矩阵，$\mathbf{b}$是偏置向量，$f$是激活函数。

import numpy as np

def sigmoid(x):
    return 1 / (1 + np.exp(-np.clip(x, -500, 500)))

def relu(x):
    return np.maximum(0, x)

def softmax(x):
    exp_x = np.exp(x - np.max(x, axis=-1, keepdims=True))
    return exp_x / np.sum(exp_x, axis=-1, keepdims=True)

# 定义一个简单的神经网络
class SimpleNN:
    def __init__(self, input_size, hidden_size, output_size):
        # 初始化权重和偏置
        self.W1 = np.random.randn(input_size, hidden_size) * 0.1
        self.b1 = np.zeros(hidden_size)
        self.W2 = np.random.randn(hidden_size, output_size) * 0.1
        self.b2 = np.zeros(output_size)
    
    def forward(self, X):
        """前向传播"""
        # 第一层: 线性变换 + ReLU激活
        self.z1 = X @ self.W1 + self.b1  # 矩阵乘法
        self.a1 = relu(self.z1)          # 激活函数
        
        # 第二层: 线性变换 + Softmax
        self.z2 = self.a1 @ self.W2 + self.b2
        self.a2 = softmax(self.z2)
        
        return self.a2

# 创建网络并进行前向传播
np.random.seed(42)
model = SimpleNN(input_size=784, hidden_size=128, output_size=10)

# 模拟一个batch的输入（例如MNIST图像）
batch_size = 32
X_batch = np.random.randn(batch_size, 784)

# 前向传播
output = model.forward(X_batch)

print(f"输入形状: {X_batch.shape}")
print(f"第一层权重形状: {model.W1.shape}")
print(f"第二层权重形状: {model.W2.shape}")
print(f"输出形状: {output.shape}")
print(f"输出概率和: {output[0].sum():.4f}")  # 应该接近1

反向传播的矩阵视角：反向传播算法通过链式法则高效地计算梯度。对于线性层$\mathbf{z} = \mathbf{W}\mathbf{x} + \mathbf{b}$，损失函数$\mathcal{L}$对参数的梯度为：

# 简化的反向传播示例
class LinearLayer:
    """带反向传播的线性层"""
    def __init__(self, in_features, out_features):
        self.W = np.random.randn(in_features, out_features) * 0.01
        self.b = np.zeros(out_features)
        self.x = None  # 保存前向传播输入
        self.grad_W = None
        self.grad_b = None
    
    def forward(self, x):
        self.x = x
        return x @ self.W + self.b
    
    def backward(self, grad_output):
        """
        grad_output: dL/dz, shape (batch, out_features)
        """
        # dL/dW = x^T @ dL/dz
        self.grad_W = self.x.T @ grad_output / self.x.shape[0]
        # dL/db = mean(dL/dz, axis=0)
        self.grad_b = grad_output.mean(axis=0)
        # dL/dx = dL/dz @ W^T
        grad_input = grad_output @ self.W.T
        return grad_input

# 测试反向传播
np.random.seed(42)
layer = LinearLayer(10, 5)
x = np.random.randn(32, 10)

# 前向传播
output = layer.forward(x)
print(f"输入形状: {x.shape}")
print(f"输出形状: {output.shape}")

# 模拟梯度回传
grad_output = np.random.randn(32, 5)
grad_input = layer.backward(grad_output)
print(f"梯度输入形状: {grad_input.shape}")
print(f"权重梯度形状: {layer.grad_W.shape}")
print(f"偏置梯度形状: {layer.grad_b.shape}")

3.4.3 主成分分析与降维

**主成分分析（PCA）**是最常用的降维技术，它通过线性变换将高维数据投影到低维空间，同时保留数据的主要变异信息。

PCA的核心思想是找到数据方差最大的方向（主成分），这些方向彼此正交。

上图展示了PCA的工作流程：

1. 原始3D数据：数据分布在一个近似平面上
2. PCA投影到2D：数据被投影到前两个主成分张成的平面
3. 方差解释：第一个主成分解释了90%以上的方差

import numpy as np

class PCA:
    """PCA实现"""
    def __init__(self, n_components):
        self.n_components = n_components
        self.components_ = None
        self.explained_variance_ = None
        self.explained_variance_ratio_ = None
        self.mean_ = None
    
    def fit(self, X):
        """拟合PCA模型"""
        # 数据中心化
        self.mean_ = np.mean(X, axis=0)
        X_centered = X - self.mean_
        
        # 计算协方差矩阵
        cov_matrix = np.cov(X_centered.T)
        
        # 特征值分解
        eigenvalues, eigenvectors = np.linalg.eigh(cov_matrix)
        
        # 按特征值降序排序
        idx = eigenvalues.argsort()[::-1]
        eigenvalues = eigenvalues[idx]
        eigenvectors = eigenvectors[:, idx]
        
        # 保存结果
        self.components_ = eigenvectors[:, :self.n_components].T
        self.explained_variance_ = eigenvalues[:self.n_components]
        self.explained_variance_ratio_ = eigenvalues / np.sum(eigenvalues)
        
        return self
    
    def transform(self, X):
        """将数据投影到主成分空间"""
        X_centered = X - self.mean_
        return X_centered @ self.components_.T
    
    def fit_transform(self, X):
        """拟合并转换"""
        self.fit(X)
        return self.transform(X)
    
    def inverse_transform(self, X_transformed):
        """将降维后的数据重构回原始空间"""
        return X_transformed @ self.components_ + self.mean_

# 使用示例
np.random.seed(42)

# 生成高维数据（100个样本，50个特征）
n_samples, n_features = 100, 50
X = np.random.randn(n_samples, n_features)

# 添加一些结构（让数据具有低维内在结构）
true_dim = 5
basis = np.random.randn(n_features, true_dim)
X = X[:, :true_dim] @ basis.T + 0.1 * np.random.randn(n_samples, n_features)

# 应用PCA
pca = PCA(n_components=10)
X_pca = pca.fit_transform(X)

print(f"原始数据形状: {X.shape}")
print(f"降维后形状: {X_pca.shape}")
print(f"\n前10个主成分的方差解释比例:")
for i, ratio in enumerate(pca.explained_variance_ratio_[:10]):
    cumsum = np.sum(pca.explained_variance_ratio_[:i+1])
    print(f"  PC{i+1}: {ratio:.4f} (累计: {cumsum:.4f})")

# 数据重构
X_reconstructed = pca.inverse_transform(X_pca)
reconstruction_error = np.mean((X - X_reconstructed) ** 2)
print(f"\n重构误差 (MSE): {reconstruction_error:.6f}")

PCA的数学原理：PCA的目标是找到一组正交基，使得数据在这些基上的投影方差最大化。这等价于对协方差矩阵进行特征值分解，特征向量就是主成分方向，特征值表示该方向上的方差。

PCA与SVD的关系：对数据中心化后的矩阵$\mathbf{X}$进行SVD分解：

其中$\mathbf{V}$的列向量就是主成分方向，$\mathbf{\Sigma}^2/(n-1)$的对角线元素就是特征值。实际应用中，SVD方法比直接计算协方差矩阵更数值稳定。

# PCA的SVD实现
class PCA_SVD:
    """基于SVD的PCA实现"""
    def __init__(self, n_components):
        self.n_components = n_components
        self.components_ = None
        self.singular_values_ = None
        self.mean_ = None
    
    def fit(self, X):
        self.mean_ = np.mean(X, axis=0)
        X_centered = X - self.mean_
        
        # SVD分解
        U, S, Vt = np.linalg.svd(X_centered, full_matrices=False)
        
        self.components_ = Vt[:self.n_components]
        self.singular_values_ = S
        
        return self
    
    def transform(self, X):
        X_centered = X - self.mean_
        return X_centered @ self.components_.T
    
    def explained_variance_ratio_(self):
        """计算方差解释比例"""
        return (self.singular_values_ ** 2) / np.sum(self.singular_values_ ** 2)

# 比较两种PCA实现
np.random.seed(42)
X = np.random.randn(200, 20)

pca_eig = PCA(n_components=5)
pca_svd = PCA_SVD(n_components=5)

X_eig = pca_eig.fit_transform(X)
X_svd = pca_svd.fit_transform(X)

print("特征值分解PCA的方差解释比例:")
print(pca_eig.explained_variance_ratio_[:5].round(4))
print("\nSVD PCA的方差解释比例:")
print(pca_svd.explained_variance_ratio_()[:5].round(4))

# 两种方法结果应该非常接近
print(f"\n两种方法结果差异: {np.linalg.norm(X_eig - X_svd):.6f}")

PCA的应用场景：

1. 数据可视化：将高维数据降至2D或3D以便可视化
2. 特征提取：去除冗余特征，保留主要信息
3. 噪声去除：小方差成分通常对应噪声
4. 数据压缩：减少存储和计算成本

# PCA用于数据可视化
from sklearn.datasets import load_iris

# 加载鸢尾花数据集
iris = load_iris()
X, y = iris.data, iris.target

# 应用PCA降至2D
pca_viz = PCA(n_components=2)
X_2d = pca_viz.fit_transform(X)

print(f"原始数据形状: {X.shape}")
print(f"降维后形状: {X_2d.shape}")
print(f"保留方差比例: {pca_viz.explained_variance_ratio_.sum():.2%}")

# 各主成分解释的方差
for i, ratio in enumerate(pca_viz.explained_variance_ratio_):
    print(f"  PC{i+1}: {ratio:.2%}")

3.4.4 注意力机制的矩阵视角

注意力机制是Transformer架构的核心，它通过计算查询（Query）、键（Key）和值（Value）之间的关系来动态地聚焦于输入的不同部分。

缩放点积注意力的公式为：

import numpy as np

def scaled_dot_product_attention(Q, K, V, mask=None):
    """
    缩放点积注意力
    
    参数:
        Q: Query矩阵, shape (batch_size, seq_len_q, d_k)
        K: Key矩阵, shape (batch_size, seq_len_k, d_k)
        V: Value矩阵, shape (batch_size, seq_len_v, d_v)
        mask: 可选的掩码矩阵
    
    返回:
        output: 注意力输出
        attention_weights: 注意力权重
    """
    d_k = Q.shape[-1]
    
    # 1. 计算Q和K的点积
    scores = Q @ K.transpose(-2, -1)  # (batch, seq_len_q, seq_len_k)
    
    # 2. 缩放
    scores = scores / np.sqrt(d_k)
    
    # 3. 应用掩码（可选）
    if mask is not None:
        scores = scores + (mask * -1e9)
    
    # 4. Softmax得到注意力权重
    attention_weights = softmax(scores)
    
    # 5. 与V相乘得到输出
    output = attention_weights @ V
    
    return output, attention_weights

def softmax(x):
    """数值稳定的softmax"""
    exp_x = np.exp(x - np.max(x, axis=-1, keepdims=True))
    return exp_x / np.sum(exp_x, axis=-1, keepdims=True)

# 注意力机制示例
np.random.seed(42)

# 模拟参数
batch_size = 2
seq_len = 4
d_k = 8
d_v = 8

# 创建Q, K, V矩阵
Q = np.random.randn(batch_size, seq_len, d_k)
K = np.random.randn(batch_size, seq_len, d_k)
V = np.random.randn(batch_size, seq_len, d_v)

# 计算注意力
output, attention_weights = scaled_dot_product_attention(Q, K, V)

print(f"Query形状: {Q.shape}")
print(f"Key形状: {K.shape}")
print(f"Value形状: {V.shape}")
print(f"注意力权重形状: {attention_weights.shape}")
print(f"输出形状: {output.shape}")

# 验证注意力权重的性质
print(f"\n注意力权重每行和: {attention_weights[0].sum(axis=-1)}")  # 应该接近1

# 可视化注意力权重
print(f"\n第一个batch的注意力权重矩阵:")
print(attention_weights[0].round(3))

# 多头注意力的概念
class MultiHeadAttention:
    """简化的多头注意力实现"""
    def __init__(self, d_model, num_heads):
        self.num_heads = num_heads
        self.d_model = d_model
        self.d_k = d_model // num_heads
        
        # 初始化投影矩阵
        self.W_q = np.random.randn(d_model, d_model) * 0.1
        self.W_k = np.random.randn(d_model, d_model) * 0.1
        self.W_v = np.random.randn(d_model, d_model) * 0.1
        self.W_o = np.random.randn(d_model, d_model) * 0.1
    
    def forward(self, Q, K, V):
        batch_size = Q.shape[0]
        
        # 线性投影
        Q_proj = Q @ self.W_q  # (batch, seq, d_model)
        K_proj = K @ self.W_k
        V_proj = V @ self.W_v
        
        # 分割成多个头
        Q_heads = Q_proj.reshape(batch_size, -1, self.num_heads, self.d_k).transpose(0, 2, 1, 3)
        K_heads = K_proj.reshape(batch_size, -1, self.num_heads, self.d_k).transpose(0, 2, 1, 3)
        V_heads = V_proj.reshape(batch_size, -1, self.num_heads, self.d_v).transpose(0, 2, 1, 3)
        
        # 对每个头计算注意力
        output, _ = scaled_dot_product_attention(
            Q_heads, K_heads, V_heads
        )
        
        # 合并头并输出投影
        output = output.transpose(0, 2, 1, 3).reshape(batch_size, -1, self.d_model)
        output = output @ self.W_o
        
        return output

# 测试多头注意力
mha = MultiHeadAttention(d_model=64, num_heads=8)
X = np.random.randn(2, 10, 64)  # (batch, seq_len, d_model)
output = mha.forward(X, X, X)
print(f"\n多头注意力输出形状: {output.shape}")

位置编码：由于注意力机制本身不具有位置感知能力，Transformer使用位置编码来注入序列位置信息。最常见的是正弦位置编码：

def positional_encoding(seq_len, d_model):
    """生成正弦位置编码"""
    position = np.arange(seq_len)[:, np.newaxis]  # (seq_len, 1)
    div_term = np.exp(np.arange(0, d_model, 2) * -(np.log(10000.0) / d_model))
    
    pe = np.zeros((seq_len, d_model))
    pe[:, 0::2] = np.sin(position * div_term)
    pe[:, 1::2] = np.cos(position * div_term)
    
    return pe

# 生成位置编码
seq_len, d_model = 50, 64
pe = positional_encoding(seq_len, d_model)

print(f"位置编码形状: {pe.shape}")
print(f"位置编码示例 (前5个位置, 前8个维度):\n{pe[:5, :8].round(4)}")

# 验证位置编码的性质
# 不同位置的编码点积应该反映位置差异
pos_0 = pe[0]
pos_10 = pe[10]
pos_20 = pe[20]

print(f"\n位置0与位置10的点积: {np.dot(pos_0, pos_10):.4f}")
print(f"位置0与位置20的点积: {np.dot(pos_0, pos_20):.4f}")

注意力机制的直观理解：

1. 查询（Query）：当前需要关注什么信息
2. 键（Key）：每个输入位置提供的信息标识
3. 值（Value）：每个输入位置实际包含的信息内容
4. 注意力权重：Query与Key的相似度，决定从每个Value中取多少信息

这种机制使得模型能够动态地关注输入的不同部分，是Transformer在NLP、视觉等领域取得成功的关键。

线性代数是理解现代AI算法的必备工具。本章介绍的向量、矩阵、线性变换、特征分析等概念，以及它们在数据表示、神经网络、降维和注意力机制中的应用，为后续学习深度学习奠定了数学基础。掌握这些概念的几何直觉和NumPy实现，将帮助你更好地理解和调试AI模型。

概率统计是人工智能的数学基石。从贝叶斯分类器到深度学习中的 dropout，从强化学习的探索策略到生成对抗网络，概率思维贯穿 AI 的各个分支。本章以"够用"为原则，聚焦于 AI 实践中最核心的概率统计知识，帮助读者建立概率化思考问题的能力。

4.1 概率论基础

4.1.1 随机事件与概率

随机事件是在一定条件下可能发生也可能不发生的事件。概率则是对随机事件发生可能性的度量，取值范围在 0 到 1 之间。

概率论建立在三条基本公理之上：

1. 非负性：对于任意事件 $A$，有 $P(A) \geq 0$
2. 规范性：必然事件的概率为 1，即 $P(\Omega) = 1$
3. 可列可加性：对于互斥事件 $A_1, A_2, \ldots$，有 $P(\bigcup_{i=1}^{\infty} A_i) = \sum_{i=1}^{\infty} P(A_i)$

基于这些公理，可以推导出概率的重要性质：

• 加法公式：$P(A \cup B) = P(A) + P(B) - P(A \cap B)$
• 对立事件：$P(\bar{A}) = 1 - P(A)$
• 单调性：若 $A \subseteq B$，则 $P(A) \leq P(B)$

在 AI 中，随机事件的概念无处不在。例如，垃圾邮件过滤器将"一封邮件是垃圾邮件"建模为随机事件，通过计算该事件的概率来决定是否拦截。

4.1.2 条件概率与贝叶斯定理

条件概率描述在已知某事件发生的条件下，另一事件发生的概率：

$P(A|B) = \frac{P(A \cap B)}{P(B)}, \quad P(B) > 0$

乘法公式是条件概率的直接推论：

$P(A \cap B) = P(A|B) \cdot P(B) = P(B|A) \cdot P(A)$

全概率公式提供了计算复杂事件概率的方法。若 $B_1, B_2, \ldots, B_n$ 构成样本空间的一个划分，则：

$P(A) = \sum_{i=1}^{n} P(A|B_i) \cdot P(B_i)$

贝叶斯定理是概率论中最具实践价值的工具之一，它建立了先验概率与后验概率之间的关系：

$P(H|E) = \frac{P(E|H) \cdot P(H)}{P(E)}$

其中：

• $P(H)$ 是先验概率（Prior）：在观察到证据前的假设概率
• $P(E|H)$ 是似然（Likelihood）：假设成立时观察到证据的概率
• $P(E)$ 是证据（Evidence）：观察到证据的总概率
• $P(H|E)$ 是后验概率（Posterior）：观察到证据后的假设概率

上图展示了一个经典的医学检测场景。假设某种疾病的患病率为 1%，检测的灵敏度（真阳性率）为 95%，特异度（真阴性率）为 95%。当一个人检测呈阳性时，实际患病的概率是多少？

通过贝叶斯定理计算：

$P(\text{患病}|+) = \frac{P(+|\text{患病}) \cdot P(\text{患病})}{P(+)} = \frac{0.95 \times 0.01}{0.95 \times 0.01 + 0.05 \times 0.99} \approx 0.161$

这个结果令人惊讶：即使检测准确率很高，由于疾病本身罕见，阳性结果中真正患病的比例只有约 16%。这一原理在 AI 的医疗诊断系统中至关重要。

4.1.3 随机变量与分布

随机变量是将随机事件映射到实数的函数，分为离散型和连续型两类。

离散型随机变量取有限或可数无限个值，其概率分布用概率质量函数（PMF）描述：

$P(X = x_i) = p_i, \quad \sum_i p_i = 1$

连续型随机变量取不可数无限个值，其概率分布用概率密度函数（PDF）描述：

$P(a \leq X \leq b) = \int_a^b f(x) dx, \quad \int_{-\infty}^{\infty} f(x) dx = 1$

累积分布函数（CDF）统一描述两类随机变量：

$F(x) = P(X \leq x)$

随机变量的数字特征是概率建模的核心：

期望（均值）表示随机变量的"中心位置"：

$E[X] = \begin{cases} \sum_i x_i p_i & \text{离散型} \\ \int_{-\infty}^{\infty} x f(x) dx & \text{连续型} \end{cases}$

方差度量随机变量偏离均值的程度：

$\text{Var}(X) = E[(X - E[X])^2] = E[X^2] - (E[X])^2$

标准差是方差的平方根，与原始数据同量纲。

4.2 常用概率分布

4.2.1 离散型分布

伯努利分布是最简单的离散分布，描述单次二元试验。在机器学习中，逻辑回归的输出可以看作伯努利分布的参数 $p$。

二项分布是 $n$ 次独立伯努利试验的成功次数。A/B 测试中，若每个用户的转化是伯努利试验，则总转化数服从二项分布。

泊松分布描述单位时间或空间内随机事件发生次数。网站访问量、客服中心接到的电话数、放射性衰变计数等都可以用泊松分布建模。泊松分布的一个重要性质是：当 $n$ 很大、$p$ 很小时，$Binomial(n,p) \approx Poisson(np)$。

4.2.2 连续型分布

正态分布（高斯分布）是概率论中最重要的分布，原因有三：

1. 中心极限定理：独立同分布随机变量之和趋于正态分布
2. 最大熵原理：给定均值和方差，正态分布是熵最大的分布
3. 数学便利性：正态分布具有良好的闭式性质，便于推导

在深度学习中，权重初始化常采用正态分布，批量归一化（Batch Normalization）利用正态分布稳定训练。

指数分布具有无记忆性：$P(X > s + t | X > s) = P(X > t)$。这意味着已等待的时间不影响剩余等待时间的分布。在强化学习中，指数分布用于建模动作选择的时间间隔。

4.2.3 多元分布与协方差

多元正态分布是单变量正态分布的高维推广：

$f(\mathbf{x}) = \frac{1}{(2\pi)^{d/2}|\Sigma|^{1/2}} \exp\left(-\frac{1}{2}(\mathbf{x}-\mu)^T\Sigma^{-1}(\mathbf{x}-\mu)\right)$

其中 $\mu \in \mathbb{R}^d$ 是均值向量，$\Sigma \in \mathbb{R}^{d \times d}$ 是协方差矩阵。

协方差度量两个随机变量的线性相关程度：

$\text{Cov}(X, Y) = E[(X - E[X])(Y - E[Y])] = E[XY] - E[X]E[Y]$

相关系数将协方差标准化到 $[-1, 1]$ 区间：

$\rho_{X,Y} = \frac{\text{Cov}(X, Y)}{\sigma_X \sigma_Y}$

协方差矩阵 $\Sigma$ 的结构决定了多元正态分布的形状：

• 对角元素 $\Sigma_{ii}$ 是各变量的方差
• 非对角元素 $\Sigma_{ij}$ 是变量 $i$ 和 $j$ 的协方差
• 当 $\Sigma$ 为对角矩阵时，各变量独立

在机器学习中，协方差矩阵用于：

• 主成分分析（PCA）：通过特征分解协方差矩阵实现降维
• 高斯过程：协方差函数（核函数）定义函数空间的相似性
• 投资组合优化：协方差矩阵描述资产收益的关联性

4.2.4 分布之间的关系

概率分布之间存在深刻的理论联系：

中心极限定理（Central Limit Theorem）是概率论最重要的定理之一：设 $X_1, X_2, \ldots, X_n$ 是独立同分布随机变量，$E[X_i] = \mu$，$\text{Var}(X_i) = \sigma^2$，则：

$\frac{\sum_{i=1}^n X_i - n\mu}{\sigma\sqrt{n}} \xrightarrow{d} N(0, 1), \quad n \to \infty$

上图展示了中心极限定理的威力：无论原始分布是均匀、指数还是伯努利，样本均值的分布都趋于正态分布。

共轭先验是贝叶斯推断中的重要概念。当先验分布与似然函数共轭时，后验分布与先验属于同一族，大大简化了计算：

Dirichlet 分布是 Beta 分布在高维的推广，是主题模型（LDA）的核心组件。

4.3 统计推断基础

4.3.1 点估计与区间估计

点估计是用样本统计量估计总体参数。常用估计方法包括：

矩估计：用样本矩估计总体矩。例如，用样本均值估计总体均值，用样本方差估计总体方差。

最大似然估计（MLE）：选择使观测数据出现概率最大的参数值。

估计量的评价标准：

• 无偏性：$E[\hat{\theta}] = \theta$
• 有效性：方差最小的无偏估计
• 一致性：$\hat{\theta} \xrightarrow{p} \theta$，当 $n \to \infty$

区间估计给出参数的可能范围。置信区间表示：若重复抽样多次，有 $(1-\alpha)$ 比例的区间包含真实参数。

对于正态总体均值，$95\%$ 置信区间为：

$\bar{x} \pm 1.96 \cdot \frac{\sigma}{\sqrt{n}}$

4.3.2 假设检验原理

假设检验是统计推断的核心工具，用于判断样本数据是否支持某个统计假设。

基本步骤：

1. 建立原假设 $H_0$ 和备择假设 $H_1$
2. 选择检验统计量
3. 确定显著性水平 $\alpha$（通常为 0.05）
4. 计算 p 值或临界值
5. 做出决策

p 值是在原假设成立时，观察到当前或更极端结果的概率。若 $p < \alpha$，拒绝原假设。

常见检验方法：

• Z 检验：大样本均值检验
• t 检验：小样本均值检验
• 卡方检验：分类变量独立性检验
• F 检验：方差比较检验

在机器学习中，假设检验用于：

• 比较两个模型的性能差异（配对 t 检验）
• 特征选择的显著性检验
• A/B 测试中的效果验证

4.3.3 最大似然估计

最大似然估计（Maximum Likelihood Estimation, MLE）是参数估计的最重要方法。其核心思想是：选择使观测数据出现概率最大的参数值。

给定独立同分布样本 $x_1, x_2, \ldots, x_n$，似然函数为：

$L(\theta) = \prod_{i=1}^n p(x_i | \theta)$

通常对似然函数取对数，得到对数似然函数：

$\ell(\theta) = \log L(\theta) = \sum_{i=1}^n \log p(x_i | \theta)$

MLE 通过求解优化问题获得：

$\hat{\theta}_{MLE} = \arg\max_\theta \ell(\theta)$

正态分布的 MLE：

设 $x_1, \ldots, x_n \sim N(\mu, \sigma^2)$，则：

$\ell(\mu, \sigma^2) = -\frac{n}{2}\log(2\pi) - \frac{n}{2}\log(\sigma^2) - \frac{1}{2\sigma^2}\sum_{i=1}^n (x_i - \mu)^2$

对 $\mu$ 求导并令其为零：

$\frac{\partial \ell}{\partial \mu} = \frac{1}{\sigma^2}\sum_{i=1}^n (x_i - \mu) = 0 \Rightarrow \hat{\mu} = \frac{1}{n}\sum_{i=1}^n x_i = \bar{x}$

对 $\sigma^2$ 求导并令其为零：

$\frac{\partial \ell}{\partial \sigma^2} = -\frac{n}{2\sigma^2} + \frac{1}{2(\sigma^2)^2}\sum_{i=1}^n (x_i - \mu)^2 = 0 \Rightarrow \hat{\sigma}^2 = \frac{1}{n}\sum_{i=1}^n (x_i - \bar{x})^2$

上图展示了 MLE 的工作过程：左图显示数据直方图和拟合的正态分布曲线，右图展示对数似然函数随均值参数的变化，最大值点即为 MLE 估计。

Python 实现：

import numpy as np
from scipy import stats

def mle_normal(data):
    """
    正态分布的最大似然估计
    
    参数:
        data: 观测数据数组
    
    返回:
        mu_mle: 均值的 MLE 估计
        sigma_mle: 标准差的 MLE 估计
    """
    n = len(data)
    
    # 均值估计
    mu_mle = np.mean(data)
    
    # 方差估计（注意：MLE 使用 n 而非 n-1）
    sigma_mle = np.sqrt(np.mean((data - mu_mle)**2))
    
    return mu_mle, sigma_mle

# 示例使用
np.random.seed(42)
true_mu, true_sigma = 5, 2
sample_data = np.random.normal(true_mu, true_sigma, 100)

mu_est, sigma_est = mle_normal(sample_data)
print(f"真实参数: μ={true_mu}, σ={true_sigma}")
print(f"MLE 估计: μ={mu_est:.4f}, σ={sigma_est:.4f}")

# 计算对数似然
log_likelihood = np.sum(stats.norm.logpdf(sample_data, mu_est, sigma_est))
print(f"对数似然值: {log_likelihood:.2f}")

逻辑回归的 MLE：

逻辑回归通过 MLE 估计参数。设 $y_i \in \{0, 1\}$，则：

$P(y_i | \mathbf{x}_i) = p_i^{y_i}(1-p_i)^{1-y_i}, \quad p_i = \sigma(\mathbf{w}^T\mathbf{x}_i)$

对数似然函数为：

$\ell(\mathbf{w}) = \sum_{i=1}^n [y_i \log p_i + (1-y_i)\log(1-p_i)]$

最大化对数似然等价于最小化交叉熵损失，这是逻辑回归的理论基础。

4.4 概率统计在 AI 中的应用

4.4.1 损失函数的概率解释

机器学习中的损失函数往往有深刻的概率解释。理解这种联系有助于选择合适的损失函数和设计新的优化目标。

MSE 损失与正态分布：

假设观测值 $y$ 与预测值 $\hat{y}$ 的关系为：

$y = \hat{y} + \epsilon, \quad \epsilon \sim N(0, \sigma^2)$

则似然函数为：

$L = \prod_{i=1}^n \frac{1}{\sqrt{2\pi}\sigma}\exp\left(-\frac{(y_i - \hat{y}_i)^2}{2\sigma^2}\right)$

对数似然为：

$\log L = -\frac{n}{2}\log(2\pi\sigma^2) - \frac{1}{2\sigma^2}\sum_{i=1}^n (y_i - \hat{y}_i)^2$

最大化对数似然等价于最小化 MSE：

$\text{MSE} = \frac{1}{n}\sum_{i=1}^n (y_i - \hat{y}_i)^2$

MAE 损失与拉普拉斯分布：

若噪声服从拉普拉斯分布：

$\epsilon \sim Laplace(0, b)$

则最大化似然等价于最小化 MAE：

$\text{MAE} = \frac{1}{n}\sum_{i=1}^n |y_i - \hat{y}_i|$

上图对比了 MSE 和 MAE 的拟合效果。MSE 对异常值敏感（平方惩罚），而 MAE 更鲁棒。右图显示高斯分布（MSE）比拉普拉斯分布（MAE）有更轻的尾部。

交叉熵损失与伯努利分布：

对于二分类问题，设真实标签 $y \in \{0, 1\}$，预测概率为 $\hat{y}$。则似然为：

$L = \prod_{i=1}^n \hat{y}_i^{y_i}(1-\hat{y}_i)^{1-y_i}$

负对数似然即为交叉熵损失：

$\text{CrossEntropy} = -\frac{1}{n}\sum_{i=1}^n [y_i \log \hat{y}_i + (1-y_i)\log(1-\hat{y}_i)]$

KL 散度与信息论：

KL 散度（Kullback-Leibler divergence）度量两个概率分布的差异：

$D_{KL}(P || Q) = \sum_x P(x) \log \frac{P(x)}{Q(x)}$

在变分自编码器（VAE）中，ELBO（Evidence Lower Bound）包含重构误差和 KL 散度项，后者约束隐变量分布接近先验。

4.4.2 正则化的贝叶斯视角

正则化技术是防止过拟合的关键手段，从贝叶斯角度看，正则化等价于引入参数的先验分布。

L2 正则化与高斯先验：

假设参数 $w_j$ 服从独立同分布的高斯先验：

$w_j \sim N(0, \sigma_w^2)$

则后验概率为：

$P(\mathbf{w} | \mathbf{X}, \mathbf{y}) \propto P(\mathbf{y} | \mathbf{X}, \mathbf{w}) \cdot P(\mathbf{w})$

取负对数：

$-\log P(\mathbf{w} | \mathbf{X}, \mathbf{y}) = -\log P(\mathbf{y} | \mathbf{X}, \mathbf{w}) - \log P(\mathbf{w}) + \text{const}$

$= \text{Loss}(\mathbf{w}) + \frac{1}{2\sigma_w^2}\sum_j w_j^2 + \text{const}$

这与 L2 正则化等价，其中 $\lambda = \frac{1}{2\sigma_w^2}$。先验方差越小（对参数约束越强），正则化强度越大。

L1 正则化与拉普拉斯先验：

若参数服从拉普拉斯先验：

$P(w_j) = \frac{1}{2b}\exp\left(-\frac{|w_j|}{b}\right)$

则 MAP 估计等价于 L1 正则化：

$\min_\mathbf{w} \text{Loss}(\mathbf{w}) + \lambda \sum_j |w_j|$

其中 $\lambda = \frac{1}{b}$。

上图展示了不同正则化强度对应的先验分布。L2 的高斯先验倾向于产生小而分散的权重，L1 的拉普拉斯先验（尖峰分布）倾向于产生稀疏解（部分权重恰好为零）。

Dropout 的贝叶斯解释：

Dropout 可以解释为对网络权重的近似贝叶斯推断。训练时随机丢弃神经元等价于对权重进行变分近似，预测时的权重缩放等价于对多个网络进行模型平均。

4.4.3 生成模型与概率建模

生成模型学习数据的概率分布 $p(x)$，从而能够生成新的样本。这是概率统计在 AI 中最激动人心的应用之一。

朴素贝叶斯分类器：

基于贝叶斯定理和特征条件独立假设：

$P(y | \mathbf{x}) = \frac{P(y) \prod_{i=1}^d P(x_i | y)}{P(\mathbf{x})}$

尽管"朴素"的独立性假设很少成立，朴素贝叶斯在文本分类等任务上表现优异。

高斯混合模型（GMM）：

假设数据来自 $K$ 个高斯分布的混合：

$p(\mathbf{x}) = \sum_{k=1}^K \pi_k \mathcal{N}(\mathbf{x} | \mu_k, \Sigma_k)$

EM 算法用于估计 GMM 参数，是聚类分析的经典方法。

变分自编码器（VAE）：

VAE 学习隐变量模型 $p_\theta(\mathbf{x}) = \int p_\theta(\mathbf{x}|\mathbf{z})p(\mathbf{z})d\mathbf{z}$。通过变分推断，引入编码器 $q_\phi(\mathbf{z}|\mathbf{x})$ 近似后验，优化 ELBO：

$\mathcal{L}(\theta, \phi) = E_{q_\phi(\mathbf{z}|\mathbf{x})}[\log p_\theta(\mathbf{x}|\mathbf{z})] - D_{KL}(q_\phi(\mathbf{z}|\mathbf{x}) || p(\mathbf{z}))$

生成对抗网络（GAN）：

GAN 通过对抗训练学习生成分布。生成器 $G$ 试图欺骗判别器 $D$，判别器试图区分真实样本和生成样本。理论上，当判别器最优时，生成器最小化生成分布与真实分布的 JS 散度。

扩散模型：

扩散模型通过逐步去噪学习数据分布。前向过程逐步添加高斯噪声，反向过程学习去噪。扩散模型在图像生成领域取得了最先进的成果。

4.4.4 不确定性量化

深度学习模型不仅要给出预测，还要知道"自己不知道什么"。不确定性量化在安全关键应用中至关重要。

认知不确定性（Epistemic Uncertainty）：源于模型参数的不确定性，可以通过更多数据减少。贝叶斯神经网络通过后验分布 $p(\mathbf{w} | \mathcal{D})$ 建模认知不确定性。

偶然不确定性（Aleatoric Uncertainty）：源于数据的固有噪声，无法通过更多数据消除。可以通过让网络同时输出预测均值和方差来建模。

上图展示了高斯过程中的不确定性量化。左图显示预测均值和置信区间，右图显示预测标准差随输入位置的变化。远离训练数据的区域不确定性更大，这是认知不确定性的典型表现。

蒙特卡洛 Dropout：

在测试时保持 Dropout 开启，进行多次前向传播，预测结果的方差即为不确定性估计。这是一种计算高效的近似贝叶斯推断方法。

集成方法：

训练多个模型，预测结果的方差反映认知不确定性。深度集成（Deep Ensemble）在实践中表现优异，但计算成本较高。

贝叶斯神经网络：

对网络权重引入先验，通过变分推断或 MCMC 方法近似后验分布。尽管计算复杂，BNN 提供了最严谨的不确定性量化框架。

概率统计为人工智能提供了坚实的数学基础。从贝叶斯定理到最大似然估计，从损失函数的概率解释到正则化的贝叶斯视角，概率思维贯穿 AI 的方方面面。掌握这些核心概念，将帮助读者更深入地理解机器学习算法的工作原理，并在实践中做出更明智的建模决策。

优化与泛化是机器学习的两大核心问题。优化关注如何高效地找到模型参数使得损失函数最小化，而泛化则关注模型在未见过的数据上的表现能力。本章将深入探讨这两大问题，从理论基础到实践技巧，为读者构建完整的知识体系。

5.1 优化基础

5.1.1 优化问题建模：目标函数、约束条件

机器学习的训练过程本质上是一个优化问题。给定训练数据集 $\mathcal{D} = \{(\mathbf{x}_i, y_i)\}_{i=1}^n$，我们需要找到一组模型参数 $\boldsymbol{\theta}$，使得损失函数 $L(\boldsymbol{\theta})$ 最小化：

$\boldsymbol{\theta}^* = \arg\min_{\boldsymbol{\theta}} L(\boldsymbol{\theta}; \mathcal{D})$

目标函数（也称为损失函数或代价函数）衡量模型预测与真实值之间的差距。常见的目标函数包括：

• 均方误差（MSE）：用于回归问题 $L_{\text{MSE}} = \frac{1}{n} \sum_{i=1}^n (y_i - f(\mathbf{x}_i; \boldsymbol{\theta}))^2$

• 交叉熵损失：用于分类问题 $L_{\text{CE}} = -\frac{1}{n} \sum_{i=1}^n \sum_{c=1}^C y_{i,c} \log(p_{i,c})$

• 正则化损失：在原始损失基础上添加正则化项 $L_{\text{reg}} = L(\boldsymbol{\theta}) + \lambda R(\boldsymbol{\theta})$

约束条件在某些优化问题中起着关键作用。约束优化问题的一般形式为：