大模型数学基础1
系统地解释每个数学概念，提供清晰的数学公式，并用最小但完整的代码示例说明其在大模型中的应用。
1. 基本概念：从标量到张量
1.1 标量 (Scalar)
定义：单个数值，只有大小，没有方向。
数学表示：\(a \in \mathbb{R}\)
大模型意义：表示学习率、温度参数等超参数。
# 标量示例
learning_rate = 0.001 # 学习率
temperature = 0.7 # 采样温度
batch_size = 32 # 批量大小
print(f"标量示例: 学习率={learning_rate}, 温度={temperature}")
1.2 向量 (Vector)
定义：一维数组，有序排列的数值集合，有大小和方向。
数学表示：\(\mathbf{v} = [v_1, v_2, ..., v_n] \in \mathbb{R}^n\)
关键性质：
- 维度：向量中元素的数量 \(n\)
- 方向：向量在空间中的指向
- 大小：向量的模（范数）
大模型应用：词向量、位置编码、偏置项。
import numpy as np
# 创建向量
word_embedding = np.array([0.1, 0.5, -0.3, 0.8, 0.2]) # 5维词向量
position_encoding = np.array([0, 1, 0, 1, 0]) # 位置编码
bias = np.array([0.1, 0.2, 0.3]) # 偏置向量
print(f"词向量维度: {word_embedding.shape}")
print(f"词向量: {word_embedding}")
print(f"位置编码: {position_encoding}")
1.3 矩阵 (Matrix)
定义：二维数组，\(m \times n\) 个标量排列成的矩形阵列。
数学表示：
\[A = \begin{bmatrix}
a_{11} & a_{12} & \cdots & a_{1n} \\
a_{21} & a_{22} & \cdots & a_{2n} \\
\vdots & \vdots & \ddots & \vdots \\
a_{m1} & a_{m2} & \cdots & a_{mn}
\end{bmatrix} \in \mathbb{R}^{m \times n}
\]
关键概念：
- 形状：\(m \times n\)（行数 × 列数）
- 转置：\(A^T\)，行和列互换
- 迹：主对角线元素之和 \(\text{tr}(A) = \sum_i a_{ii}\)
大模型应用：权重矩阵、注意力分数矩阵、投影矩阵。
# 创建矩阵
W_q = np.array([ # Query权重矩阵 (3×4)
[0.1, 0.2, -0.1, 0.3],
[0.4, -0.2, 0.5, 0.1],
[-0.1, 0.3, 0.2, 0.4]
])
print(f"Query权重矩阵形状: {W_q.shape}")
print(f"矩阵转置: \n{W_q.T}")
print(f"矩阵的迹: {np.trace(W_q @ W_q.T)}")
1.4 张量 (Tensor)
定义：多维数组，向量和矩阵的推广。
数学表示：\(T \in \mathbb{R}^{d_1 \times d_2 \times \cdots \times d_k}\)
关键概念：
- 阶：张量的维度数
- 形状：每个维度的长度
- 轴：张量的维度
大模型应用：批处理数据、多头注意力、卷积特征图。
# 创建张量
batch_size = 2
seq_len = 3
hidden_dim = 4
num_heads = 2
# 4维张量: (batch_size, num_heads, seq_len, head_dim)
attention_scores = np.random.randn(batch_size, num_heads, seq_len, hidden_dim // num_heads)
print(f"注意力分数张量形状: {attention_scores.shape}")
print(f"张量阶数: {attention_scores.ndim}")
print(f"张量总元素数: {attention_scores.size}")
2. 关键运算
2.1 矩阵乘法
定义：两个矩阵相乘，结果矩阵的元素是第一个矩阵的行与第二个矩阵的列的点积。
数学公式：
\[C = AB \quad \text{其中} \quad c_{ij} = \sum_{k=1}^{n} a_{ik}b_{kj}
\]
条件：\(A \in \mathbb{R}^{m \times n}, B \in \mathbb{R}^{n \times p}, C \in \mathbb{R}^{m \times p}\)
大模型应用：线性变换、注意力计算、前向传播。
# 矩阵乘法示例
X = np.array([[1, 2], # 输入 (2×3)
[3, 4]])
W = np.array([[0.5, 0.2], # 权重 (3×2)
[0.3, 0.8]])
b = np.array([0.1, 0.2]) # 偏置 (2,)
# 线性变换: Y = XW + b
Y = X @ W + b # 或 np.dot(X, W) + b
print(f"输入X (2×2): \n{X}")
print(f"权重W (2×2): \n{W}")
print(f"偏置b: {b}")
print(f"输出Y (2×2): \n{Y}")
print(f"验证: X@W = \n{X@W}")
2.2 转置 (Transpose)
定义：将矩阵的行和列互换。
数学表示：\(A^T\)，其中 \((A^T)_{ij} = A_{ji}\)
性质：
- \((A^T)^T = A\)
- \((AB)^T = B^T A^T\)
- \((A + B)^T = A^T + B^T\)
# 转置示例
A = np.array([[1, 2, 3],
[4, 5, 6]])
print(f"原始矩阵A (2×3): \n{A}")
print(f"转置矩阵A^T (3×2): \n{A.T}")
print(f"验证 (A^T)^T = A: \n{(A.T).T}")
3. 特征值与特征向量
3.1 核心定义
特征向量：对于一个方阵 \(A\)，如果存在非零向量 \(\mathbf{v}\) 使得 \(A\mathbf{v} = \lambda\mathbf{v}\)，则 \(\mathbf{v}\) 是 \(A\) 的特征向量。
特征值：对应的标量 \(\lambda\) 称为特征值。
数学公式：
\[A\mathbf{v} = \lambda\mathbf{v}
\]
其中：
- \(A \in \mathbb{R}^{n \times n}\) 是方阵
- \(\mathbf{v} \in \mathbb{R}^n\) 是非零向量（特征向量）
- \(\lambda \in \mathbb{R}\) 是标量（特征值）
3.2 几何解释
特征向量表示矩阵变换中保持方向不变的向量，特征值表示该方向上的缩放因子。
可视化理解：
import matplotlib.pyplot as plt
def visualize_eigen():
# 定义变换矩阵
A = np.array([[3, 1],
[1, 2]])
# 计算特征值和特征向量
eigenvalues, eigenvectors = np.linalg.eig(A)
fig, ax = plt.subplots(figsize=(8, 8))
# 绘制原始向量
vectors = np.array([[1, 0], [0, 1], [1, 1], [-0.5, 1]])
colors = ['red', 'blue', 'green', 'purple']
for i, vec in enumerate(vectors):
# 原始向量
ax.quiver(0, 0, vec[0], vec[1], angles='xy', scale_units='xy', scale=1,
color=colors[i], alpha=0.3, width=0.01)
# 变换后向量
transformed = A @ vec
ax.quiver(0, 0, transformed[0], transformed[1], angles='xy', scale_units='xy', scale=1,
color=colors[i], alpha=0.8, width=0.01, label=f'v{i+1}')
# 绘制特征向量
for i, eigvec in enumerate(eigenvectors.T):
ax.quiver(0, 0, eigvec[0]*2, eigvec[1]*2, angles='xy', scale_units='xy', scale=1,
color='black', width=0.015, linewidth=2,
label=f'特征向量 {i+1} (λ={eigenvalues[i]:.2f})')
ax.set_xlim(-3, 5)
ax.set_ylim(-3, 5)
ax.grid(True, alpha=0.3)
ax.set_aspect('equal')
ax.set_title('矩阵变换与特征向量')
ax.legend()
plt.show()
print("矩阵A:")
print(A)
print(f"\n特征值: {eigenvalues}")
print("特征向量（每列是一个特征向量）:")
print(eigenvectors)
visualize_eigen()
3.3 特征值分解
定义：将方阵分解为特征向量矩阵和特征值对角矩阵的乘积。
数学公式：
\[A = Q\Lambda Q^{-1}
\]
其中：
- \(Q\) 是特征向量矩阵（每列是一个特征向量）
- \(\Lambda\) 是对角矩阵，对角线元素是特征值
- \(Q^{-1}\) 是 \(Q\) 的逆矩阵
特殊性质：如果 \(A\) 是实对称矩阵，则 \(Q\) 是正交矩阵（\(Q^{-1} = Q^T\)）：
\[A = Q\Lambda Q^T
\]
# 特征值分解示例
def eigendecomposition_demo():
# 对称矩阵（协方差矩阵）
A = np.array([[4, 2],
[2, 3]])
print("对称矩阵 A:")
print(A)
# 特征值分解
eigenvalues, eigenvectors = np.linalg.eig(A)
print(f"\n特征值: {eigenvalues}")
print("特征向量矩阵 Q:")
print(eigenvectors)
# 验证正交性（对于对称矩阵）
print(f"\nQ·Q^T ≈ I? {np.allclose(eigenvectors @ eigenvectors.T, np.eye(2))}")
# 重构矩阵
Q = eigenvectors
Λ = np.diag(eigenvalues)
A_reconstructed = Q @ Λ @ Q.T
print(f"\n重构误差: {np.max(np.abs(A - A_reconstructed))}")
# 大模型应用：主成分分析(PCA)
print("\n=== PCA应用示例 ===")
# 生成数据
np.random.seed(42)
X = np.random.randn(100, 3) # 100个样本，3个特征
X_centered = X - X.mean(axis=0)
# 协方差矩阵
cov_matrix = np.cov(X_centered.T)
print(f"协方差矩阵形状: {cov_matrix.shape}")
# 特征值分解
eigvals, eigvecs = np.linalg.eig(cov_matrix)
# 选择主成分
sorted_idx = np.argsort(eigvals)[::-1]
principal_components = eigvecs[:, sorted_idx[:2]] # 保留2个主成分
print(f"特征值: {eigvals[sorted_idx]}")
print(f"解释方差比例: {eigvals[sorted_idx]/eigvals.sum()}")
# 降维
X_pca = X_centered @ principal_components
print(f"降维后形状: {X_pca.shape}")
eigendecomposition_demo()
4. 范数 (Norms)
4.1 L0范数 (L0-Norm)
定义：非零元素的个数（严格来说不是范数，是伪范数）。
数学公式：
\[\| \mathbf{x} \|_0 = \#\{i : x_i \neq 0\}
\]
大模型应用：稀疏性约束、特征选择。
4.2 L1范数 (L1-Norm, 曼哈顿范数)
定义：向量元素绝对值之和。
数学公式：
\[\| \mathbf{x} \|_1 = \sum_{i=1}^{n} |x_i|
\]
几何意义：曼哈顿距离。
大模型应用：L1正则化（LASSO），促进稀疏解。
4.3 L2范数 (L2-Norm, 欧几里得范数)
定义：向量元素平方和的平方根。
数学公式：
\[\| \mathbf{x} \|_2 = \sqrt{\sum_{i=1}^{n} x_i^2}
\]
几何意义：欧几里得距离。
大模型应用：L2正则化（权重衰减）、梯度裁剪。
4.4 Lp范数 (Lp-Norm)
定义：向量元素绝对值的p次方和的p次方根。
数学公式：
\[\| \mathbf{x} \|_p = \left( \sum_{i=1}^{n} |x_i|^p \right)^{\frac{1}{p}}
\]
其中 \(p \geq 1\)。
4.5 L∞范数 (无穷范数)
定义：向量元素绝对值的最大值。
数学公式：
\[\| \mathbf{x} \|_\infty = \max_{i} |x_i|
\]
大模型应用：最大池化、梯度裁剪的另一种方式。
def norms_explained():
# 示例向量
v = np.array([3, -4, 1, 2])
print(f"示例向量: {v}")
# L0范数（非零元素个数）
l0 = np.count_nonzero(v)
print(f"L0范数: {l0}")
# L1范数（绝对值之和）
l1 = np.sum(np.abs(v))
print(f"L1范数: {l1} = |3| + |-4| + |1| + |2| = {np.abs(3)+np.abs(-4)+np.abs(1)+np.abs(2)}")
# L2范数（欧几里得范数）
l2 = np.linalg.norm(v) # 默认是L2范数
print(f"L2范数: {l2:.4f} = sqrt(3² + (-4)² + 1² + 2²) = sqrt({9+16+1+4})")
# Lp范数（通用形式）
def lp_norm(x, p):
return np.sum(np.abs(x) ** p) ** (1/p)
for p in [3, 5, 10]:
print(f"L{p}范数: {lp_norm(v, p):.4f}")
# L∞范数（最大绝对值）
linf = np.max(np.abs(v))
print(f"L∞范数: {linf} = max(|3|, |-4|, |1|, |2|)")
# 可视化不同范数的单位球
visualize_norm_unit_balls()
# 大模型应用示例
print("\n=== 大模型中的应用 ===")
# 1. L2正则化（权重衰减）
weights = np.random.randn(10, 20) * 0.1
l2_penalty = 0.01 * np.sum(weights ** 2)
print(f"权重矩阵的L2惩罚项: {l2_penalty:.6f}")
# 2. 梯度裁剪（防止梯度爆炸）
gradients = np.random.randn(5, 10) * 5
grad_norm = np.linalg.norm(gradients)
max_norm = 1.0
if grad_norm > max_norm:
clipped_gradients = gradients * (max_norm / grad_norm)
print(f"梯度裁剪: 原始范数={grad_norm:.2f}, 裁剪后范数={np.linalg.norm(clipped_gradients):.2f}")
return v, l2
def visualize_norm_unit_balls():
"""可视化不同范数的单位球"""
# 生成二维网格点
x = np.linspace(-1.5, 1.5, 400)
y = np.linspace(-1.5, 1.5, 400)
X, Y = np.meshgrid(x, y)
fig, axes = plt.subplots(2, 2, figsize=(10, 10))
# L1范数: |x| + |y| = 1
axes[0, 0].contour(X, Y, np.abs(X) + np.abs(Y), levels=[1], colors='blue')
axes[0, 0].set_title('L1范数: |x|+|y|=1')
axes[0, 0].set_aspect('equal')
axes[0, 0].grid(True, alpha=0.3)
# L2范数: x² + y² = 1
axes[0, 1].contour(X, Y, X**2 + Y**2, levels=[1], colors='red')
axes[0, 1].set_title('L2范数: x²+y²=1')
axes[0, 1].set_aspect('equal')
axes[0, 1].grid(True, alpha=0.3)
# L4范数: x⁴ + y⁴ = 1
axes[1, 0].contour(X, Y, X**4 + Y**4, levels=[1], colors='green')
axes[1, 0].set_title('L4范数: x⁴+y⁴=1')
axes[1, 0].set_aspect('equal')
axes[1, 0].grid(True, alpha=0.3)
# L∞范数: max(|x|, |y|) = 1
axes[1, 1].contour(X, Y, np.maximum(np.abs(X), np.abs(Y)), levels=[1], colors='purple')
axes[1, 1].set_title('L∞范数: max(|x|,|y|)=1')
axes[1, 1].set_aspect('equal')
axes[1, 1].grid(True, alpha=0.3)
plt.tight_layout()
plt.show()
v, l2 = norms_explained()
5. 大模型综合应用：注意力机制
5.1 缩放点积注意力公式
完整公式：
\[\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V
\]
分步解释：
-
点积：\(QK^T\)，计算查询和键的相似度
- \(Q \in \mathbb{R}^{n \times d_k}\)：查询矩阵
- \(K \in \mathbb{R}^{m \times d_k}\)：键矩阵
- 结果形状：\(n \times m\)
-
缩放：除以 \(\sqrt{d_k}\)，防止点积值过大导致softmax梯度消失
-
Softmax：将相似度转换为概率分布
\[\text{softmax}(z_i) = \frac{e^{z_i}}{\sum_{j} e^{z_j}} \] -
加权求和：用注意力权重对值矩阵 \(V\) 进行加权
5.2 代码实现
def scaled_dot_product_attention(Q, K, V, mask=None):
"""
缩放点积注意力实现
参数:
Q: 查询矩阵 (..., seq_len_q, d_k)
K: 键矩阵 (..., seq_len_k, d_k)
V: 值矩阵 (..., seq_len_v, d_v)
mask: 可选掩码
返回:
输出，注意力权重
"""
d_k = Q.shape[-1]
# 1. 计算点积
scores = np.matmul(Q, K.transpose(-2, -1)) # (..., 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（数值稳定版本）
def stable_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)
attention_weights = stable_softmax(scores) # (..., seq_len_q, seq_len_k)
# 5. 加权求和
output = np.matmul(attention_weights, V) # (..., seq_len_q, d_v)
return output, attention_weights
# 示例：多头注意力中的单头
def attention_example():
batch_size = 2
seq_len = 4
d_model = 8
d_k = d_v = d_model
# 随机初始化Q, K, V
np.random.seed(42)
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)
print(f"Q形状: {Q.shape}")
print(f"K形状: {K.shape}")
print(f"V形状: {V.shape}")
# 计算注意力
output, attention_weights = scaled_dot_product_attention(Q, K, V)
print(f"\n注意力输出形状: {output.shape}")
print(f"注意力权重形状: {attention_weights.shape}")
# 验证注意力权重的性质
print(f"\n注意力权重每行和为1: {np.allclose(np.sum(attention_weights, axis=-1), 1)}")
# 可视化注意力模式
plt.figure(figsize=(10, 4))
plt.subplot(1, 2, 1)
plt.imshow(attention_weights[0], cmap='viridis')
plt.colorbar()
plt.title('注意力权重（第一个样本）')
plt.xlabel('Key位置')
plt.ylabel('Query位置')
# 分析注意力矩阵的秩（低秩性质）
U, S, Vt = np.linalg.svd(attention_weights[0])
plt.subplot(1, 2, 2)
plt.plot(S, 'o-', linewidth=2)
plt.xlabel('奇异值索引')
plt.ylabel('奇异值大小')
plt.title('注意力矩阵的奇异值谱')
plt.grid(True, alpha=0.3)
print(f"\n注意力矩阵的秩近似（前2个奇异值能量占比）:")
print(f"{np.sum(S[:2]**2)/np.sum(S**2):.2%}")
plt.tight_layout()
plt.show()
attention_example()
本文来自博客园，作者：ffff5，转载请注明原文链接：https://www.cnblogs.com/ffff5/p/19585012
浙公网安备 33010602011771号