深度学习符号速查表

深度学习符号速查表

涵盖：希腊字母 · 线性代数 · 微积分 · 概率统计 · 神经网络 · 损失函数 · 优化器 · 强化学习

每个符号附：读音（英文/中文谐音）、含义、典型公式、应用场景

每章末尾附「⚡ PyTorch 实战」小节：符号 → 代码的对应关系与可运行示例

---

一、希腊字母（最常用）

符号	读音	含义	典型公式 / 示例	应用场景
α (alpha)	/ˈælfə/ 阿尔法	学习率、平滑系数	θ ← θ − α·∇J(θ)	梯度下降步长；Adam 中的动量衰减
β (beta)	/ˈbeɪtə/ 贝塔	动量衰减系数	v = β₁v + (1−β₁)g	Adam: β₁=0.9, β₂=0.999
γ (gamma)	/ˈɡæmə/ 伽马	折扣因子、缩放参数	G = Σ γᵗ·rₜ	强化学习折扣回报；BatchNorm 的缩放 γ
δ (delta)	/ˈdeltə/ 德尔塔	误差项、微小变化	δ = (ŷ−y)·σ′(z)	反向传播中的层间误差 δ
ε (epsilon)	/ˈepsɪlɒn/ 艾普西隆	极小值（防除零）、探索率	x̂ = (x−μ)/√(σ²+ε)	Adam 数值稳定 ε=1e-8；ε-greedy 探索
ζ (zeta)	/ˈzeɪtə/ 泽塔	阻尼比（较少用）	---	控制系统、二阶优化
η (eta)	/ˈiːtə/ 伊塔	学习率（经典记号）	w ← w − η·∂L/∂w	与 α 同义，论文中常见
θ (theta)	/ˈθeɪtə/ 西塔	模型参数（权重+偏置）	f(x; θ)	"训练 θ" 即训练模型
λ (lambda)	/ˈlæmdə/ 兰姆达	正则化系数、特征值	L + λ‖w‖²	L2 正则（权重衰减）；TD(λ)
μ (mu)	/mjuː/ 缪	均值	μ = (1/n)Σxᵢ	BatchNorm 的批均值；动量法
ν (nu)	/njuː/ 纽	频率、粘度（易与 v 混）	---	物理类论文
ξ (xi)	/zaɪ/ 克西	随机变量（噪声）	---	变分推断中的噪声
π (pi)	/paɪ/ 派	圆周率；策略	`a ~ π(·	s)`
ρ (rho)	/roʊ/ 柔	相关系数、密度	---	统计、ρ-greedy 探索
σ (sigma)	/ˈsɪɡmə/ 西格马	标准差；Sigmoid 函数	σ(x)=1/(1+e⁻ˣ)	激活函数；VAE 的 σ
Σ (大写 sigma)	西格马	求和；协方差矩阵	Σ = E[(x−μ)(x−μ)ᵀ]	损失求和；多元高斯
τ (tau)	/taʊ/ 陶	温度、时间常数	softmax(zᵢ/τ)	知识蒸馏温度 T；采样温度
υ (upsilon)	宇普西隆	少用	---	---
φ (phi)	/faɪ/ 斐	特征函数、辅助网络参数	∇φ J(θ)	Actor-Critic 中 Critic 参数 φ
χ (chi)	/kaɪ/ 凯	卡方分布	χ² 检验	统计检验
ψ (psi)	/saɪ/ 普西	辅助函数/参数	---	生成器参数（部分论文）
ω (omega)	/oʊˈmeɡə/ 欧米伽	角频率、权重	---	信号处理、位置编码
Ω (大写 omega)	欧米伽	参数空间/域	θ ∈ Ω	约束优化可行域
∇ (nabla)	/ˈnæblə/ 纳布拉	梯度算子	∇f = (∂f/∂x₁,...,∂f/∂xₙ)	反向传播核心
∂ (partial)	偏德尔塔	偏导数	∂L/∂w	链式法则

⚡ PyTorch 实战：希腊字母 → 超参数与 API

import torch
import torch.nn.functional as F

model = torch.nn.Linear(10, 2)

# α/η 学习率 lr · β₁β₂ 动量 betas · ε 数值稳定 eps · λ 权重衰减 weight_decay
opt = torch.optim.Adam(model.parameters(),
                       lr=1e-3,              # α (或写作 η)
                       betas=(0.9, 0.999),   # β₁, β₂
                       eps=1e-8,             # ε
                       weight_decay=1e-4)    # λ → L2 正则

# σ: Sigmoid 激活 σ(z) = 1/(1+e⁻ᶻ)
a = torch.sigmoid(torch.randn(4))

# τ: softmax 温度（知识蒸馏 / LLM 采样，τ 越大分布越平）
tau = 0.7
p = F.softmax(torch.randn(4, 10) / tau, dim=-1)

# θ: 模型参数就是 named_parameters() 里的每一项
for name, theta in model.named_parameters():
    print(name, theta.shape)   # weight (2,10) / bias (2,)

# γ 折扣因子（RL）、ε-greedy 探索率 → 见第六章

---

二、线性代数符号

符号	含义	公式 / 说明	应用场景
x (粗体小写)	向量	x = (x₁, x₂, ..., xₙ)	输入特征、隐藏层表示
X (粗体大写)	矩阵	X ∈ ℝ^(m×n)	数据集、权重矩阵
W / W	权重矩阵	z = Wx + b	全连接层、注意力投影
b / b	偏置向量	z = Wx + b	每层的偏置项
xᵀ	转置	(AB)ᵀ = BᵀAᵀ	内积 xᵀy = Σxᵢyᵢ
‖x‖	范数	L2: ‖x‖₂ = √Σxᵢ²；L1: `‖x‖₁ = Σ	xᵢ
‖X‖_F	Frobenius 范数	√ΣΣxᵢⱼ²	权重衰减作用于矩阵
A ⊙ B	逐元素乘（Hadamard）	(A⊙B)ᵢⱼ = aᵢⱼ·bᵢⱼ	LSTM 门控、mask
A ⊗ B	张量积 / Kronecker 积	---	理论推导
A⁻¹	逆矩阵	AA⁻¹ = I	牛顿法 H⁻¹∇L
tr(A)	迹（对角线之和）	tr(AB)=tr(BA)	散度计算、log-det
det(A) | |A|	行列式	---	体积/可逆性判断
λᵢ, vᵢ	特征值/特征向量	Av = λv	PCA、谱分析
ℝⁿ	n 维实数空间	x ∈ ℝ³	声明向量维度
ℝ^(m×n)	m×n 实矩阵空间	W ∈ ℝ^(d_out×d_in)	声明矩阵形状
diag(·)	对角矩阵	---	协方差对角化
1(·)	指示函数	1(条件成立)=1 否则 0	掩码、one-hot

下标/上标惯例

记号	含义	示例
xᵢ	第 i 个元素/样本	x₁...xₘ 训练集
x⁽ⁱ⁾	第 i 个样本（上括号）	避免与幂混淆
xᵢⱼ	第 i 行第 j 列	矩阵元素
h⁽ˡ⁾	第 l 层的输出	h⁽ˡ⁾ = σ(W⁽ˡ⁾h⁽ˡ⁻¹⁾ + b⁽ˡ⁾)
Wᵗ	第 t 步 / t 次幂	依上下文
x̂	估计值 / 归一化值	BatchNorm 的 x̂
x̄	均值	---
x*	最优解	θ* = argmin L(θ)

⚡ PyTorch 实战：张量运算 ↔ 线性代数符号

import torch

B, T, d = 32, 10, 512              # 批大小 B · 序列长 T · 特征维 d
x = torch.randn(B, T, d)           # X ∈ ℝ^(B×T×d)

W = torch.randn(d, d)
y = x @ W                          # 矩阵乘法 XW
y = x.transpose(-2, -1)            # 转置 Xᵀ
y = x * W                          # Hadamard 逐元素乘 ⊙（广播）
y = torch.matmul(x, W)             # @ 的显式写法

n2 = torch.norm(x, p=2)            # ‖x‖₂  L2 范数
n1 = torch.norm(x, p=1)            # ‖x‖₁  L1 范数（稀疏）
nf = torch.linalg.matrix_norm(W)   # ‖W‖_F Frobenius 范数

# nn.Linear 一行实现 z = Wx + b（W、b 自动注册为 nn.Parameter）
fc = torch.nn.Linear(d, 256)
z = fc(x)                          # z ∈ ℝ^(B×T×256)
print(fc.weight.shape, fc.bias.shape)   # (256,512) (256,)

# 单位矩阵 I / 对角矩阵 diag / 迹 tr
I = torch.eye(d)
tr = torch.trace(I)                # = d

---

三、微积分与优化

符号	含义	公式	应用场景
∇f	f 的梯度	∇f = [∂f/∂x₁ ... ∂f/∂xₙ]ᵀ	反向传播计算 ∇L
∂L/∂w	偏导数	链式：∂L/∂w = ∂L/∂z · ∂z/∂w	参数更新方向
d/dx	导数	---	标量函数
H	Hessian 矩阵	Hᵢⱼ = ∂²L/∂xᵢ∂xⱼ	二阶优化、曲率分析
argmin / argmax	取最值的自变量	θ* = argmin_θ L(θ)	训练目标的严格写法
min / max	最值本身	min L(θ)	目标函数值
≈	约等于	---	近似推导
∝	正比于	p(x) ∝ f(x)	概率未归一化形式
≜ / :=	定义为	G ≜ Σγᵗrₜ	定义新符号
lim	极限	---	收敛性分析
E·	期望	E[x] = Σp(x)·x	损失是对数据的期望
⊥	独立	x ⊥ y	概率图模型

梯度下降家族公式

SGD:      θ ← θ − η·∇L(θ)
动量:     v ← μv − η∇L ;  θ ← θ + v
Adam:     m ← β₁m + (1−β₁)g          (一阶矩)
          v ← β₂v + (1−β₂)g²         (二阶矩)
          m̂ = m/(1−β₁ᵗ) ; v̂ = v/(1−β₂ᵗ)   (偏差修正)
          θ ← θ − α·m̂/(√v̂ + ε)
RMSprop:  E[g²] ← ρE[g²] + (1−ρ)g² ; θ ← θ − η·g/√(E[g²]+ε)

⚡ PyTorch 实战：autograd = 自动计算 ∇ 和 ∂

import torch

# ---- ∂L/∂w：requires_grad + backward() 就是链式法则 ----
w = torch.tensor(2.0, requires_grad=True)    # 声明 θ 需要梯度
L = (3 * w - 6) ** 2                         # L(w)
L.backward()                                 # 反向传播，自动算 ∇L
print(w.grad)                                # ∂L/∂w = 6(3w−6) = 0（w=2 恰是 argmin）

# ---- θ ← θ − η·∇L：手动梯度下降一步 ----
lr = 0.1
with torch.no_grad():                        # 更新时不追踪计算图
    w -= lr * w.grad                         # ← 对应伪代码的赋值箭头
    w.grad.zero_()                           # 梯度默认累加，用完必须清零

# ---- 优化器封装了整族更新公式 ----
model = torch.nn.Linear(4, 1)
opt = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9)   # 动量 μ
opt = torch.optim.RMSprop(model.parameters(), lr=1e-3, alpha=0.99) # ρ
opt = torch.optim.Adam(model.parameters(), lr=1e-3)                # m̂,v̂ 偏差修正内置

loss = model(torch.randn(8, 4)).pow(2).mean()
opt.zero_grad(); loss.backward(); opt.step()   # 三步曲

---

四、概率与统计

符号	含义	公式	应用场景
P(A)	概率	0 ≤ P(A) ≤ 1	分类输出（softmax 后）
p(x|y)	条件概率	`p(x	y)=p(x,y)/p(y)`
~	服从分布	x ~ N(0,1)	采样、权重初始化
Ex	期望/均值	E[x]=Σx·p(x)	损失期望形式
Var(x)	方差	Var(x)=E[(x−E[x])²]	方差缩减（RL baseline）
Cov(x,y)	协方差	E[(x−μₓ)(y−μ_y)]	多元高斯
N(μ,σ²)	正态分布	p(x)=1/(√(2π)σ)·e^(−(x−μ)²/2σ²)	VAE 潜变量、权重初始化
Bern(φ)	伯努利分布	---	二分类、Dropout
Cat / Mult	分类/多项分布	---	K 类输出、语言模型下一个词
KL(p‖q)	KL 散度	Σp·log(p/q)	VAE 正则、PPO-TRPO 约束、蒸馏
H§	熵	−Σp·log p	交叉熵损失、RL 熵正则
H(p,q)	交叉熵	−Σp·log q	分类损失（最常用）
I(x;y)	互信息	KL(p(x,y)‖p(x)p(y))	InfoNCE、表示学习
log	对数（默认 e 为底）	log softmax	log-likelihood everywhere
exp / eˣ	指数	softmax(zᵢ)=eᶻⁱ/Σeᶻʲ	激活、注意力权重

常见损失函数

MSE (回归):      L = (1/n)·Σ(ŷᵢ − yᵢ)²
交叉熵 (分类):   L = −(1/n)·Σ[y·log ŷ + (1−y)·log(1−ŷ)]
多类交叉熵:      L = −Σ_c y_c·log ŷ_c
Hinge (SVM):     L = max(0, 1 − y·ŷ)
L1 (MAE):        L = (1/n)·Σ|ŷᵢ − yᵢ|
NLL (VAE):       L = −E[log p(x|z)] + KL(q(z|x) ‖ p(z))

⚡ PyTorch 实战：分布、损失与 KL 散度

import torch
import torch.nn.functional as F
from torch.distributions import Normal, Categorical, kl_divergence

logits = torch.randn(32, 10)               # 32 样本 × 10 类的原始得分
p = F.softmax(logits, dim=-1)              # P(y|x)：softmax → 概率分布
logp = F.log_softmax(logits, dim=-1)       # log-softmax，数值更稳定

# 交叉熵 H(p,q) = −Σ y·log q（分类标配，内部已含 log_softmax，传 logits 即可！）
labels = torch.randint(0, 10, (32,))       # 真值 y
loss = F.cross_entropy(logits, labels)

# 回归用 MSE：L = (1/n)Σ(ŷ−y)²
loss = F.mse_loss(pred, target)

# KL 散度 KL(q‖p)：VAE 正则 / PPO 约束 / 知识蒸馏
q, p_ = Normal(0., 1.), Normal(0.5, 1.2)
kl = kl_divergence(q, p_)                  # 张量形式，逐元素

# E[x]、Var(x)、采样 x ~ 分布
x = torch.randn(1000)
mu, var = x.mean(), x.var()                # μ, σ²
dist = Categorical(probs=p[0])
action = dist.sample()                     # 从分类分布采样（RL 选动作）

---

五、神经网络专用符号

符号	含义	公式	应用场景
L	层数 / 损失函数	依上下文	h⁽ᴸ⁾ 输出层
l	层索引	第 l 层	---
d / d_model	特征维度	d_model=512	Transformer 宽度
N / m	样本数	---	批大小 batch size
B	batch 大小	X ∈ ℝ^(B×d)	训练循环
T	时间步/序列长度	X ∈ ℝ^(B×T×d)	RNN/Transformer 序列
f(x;θ)	参数化函数	神经网络本身	通用记号
ŷ (y-hat)	预测值	ŷ = f(x;θ)	与真值 y 对比算损失
y	真实标签	---	监督学习
z	预激活值	z = Wx+b，a = σ(z)	反向传播中区分 z 和 a
a	激活值	a⁽ˡ⁾ = σ(z⁽ˡ⁾)	层输出
h	隐藏状态/表示	h_t = tanh(W h_{t−1} + U x_t)	RNN、编码器输出
c	细胞状态	LSTM: c_t = f_t⊙c_{t−1} + i_t⊙c̃_t	LSTM
e	嵌入向量 / 自然常数	e = E[token]	Word Embedding
i, f, o	LSTM 输入/遗忘/输出门	i = σ(Wᵢ[h_{t−1},x_t])	LSTM 门控
ReLU	整流线性单元	max(0, x)	默认激活函数
softmax	归一化指数	eᶻⁱ/Σeᶻʲ	多分类输出层
Dropout	随机失活	训练时以 p 概率置零，输出×(1−p)⁻¹	正则化
BN	批归一化	y = γ·(x−μ_B)/√(σ²_B+ε) + β	加速收敛
LN	层归一化	同上但按特征维统计	Transformer 必备

Transformer 核心公式

自注意力:   Attention(Q,K,V) = softmax(QKᵀ/√d_k)·V
多头:       MultiHead = Concat(head₁...head_h)·Wᴼ
FFN:        FFN(x) = ReLU(xW₁+b₁)W₂+b₂
残差:       output = LayerNorm(x + Sublayer(x))

符号	含义
Q, K, V	查询 / 键 / 值矩阵
d_k	键向量维度，√d_k 缩放防 softmax 饱和
h	注意力头数
PE	位置编码

⚡ PyTorch 实战：z/a/h、归一化与注意力

import math
import torch
import torch.nn as nn

# ---- MLP：z = Wx+b → a = σ(z) 的逐层堆叠 ----
class MLP(nn.Module):
    def __init__(self, d_in=784, d_h=256, d_out=10, p=0.1):
        super().__init__()
        self.fc1, self.fc2 = nn.Linear(d_in, d_h), nn.Linear(d_h, d_out)
        self.act  = nn.ReLU()          # a⁽ˡ⁾ = ReLU(z⁽ˡ⁾)
        self.drop = nn.Dropout(p)      # 训练时以 p 置零
        self.ln   = nn.LayerNorm(d_h)  # Transformer 用 LN；CNN/MLP 常用 nn.BatchNorm1d

    def forward(self, x):              # f(x; θ)
        h = self.act(self.fc1(x))      # 隐藏表示 h
        h = self.ln(self.drop(h))
        return self.fc2(h)             # ŷ（logits）

# ---- 自注意力：Attention(Q,K,V) = softmax(QKᵀ/√d_k)·V ----
def attention(Q, K, V, mask=None):
    d_k = Q.size(-1)
    scores = Q @ K.transpose(-2, -1) / math.sqrt(d_k)   # √d_k 缩放防饱和
    if mask is not None:
        scores = scores.masked_fill(mask == 0, float('-inf'))
    return scores.softmax(dim=-1) @ V

# 官方多头实现（h 个头、残差、LN 都封装好）：
mha = nn.MultiheadAttention(embed_dim=512, num_heads=8, batch_first=True)
out, attn_weights = mha(query=x, key=x, value=x)        # x: (B, T, 512)

# ---- RNN 隐藏状态 h_t = tanh(W h_{t−1} + U x_t) ----
rnn = nn.RNN(input_size=128, hidden_size=256, batch_first=True)
h_all, h_T = rnn(torch.randn(32, 10, 128))              # h_all: 全部时刻, h_T: 最后状态

---

六、强化学习符号（结合本目录主题）

符号	含义	公式	应用场景
S / s	状态（空间/具体值）	s ∈ S	环境观测
A / a	动作	a ∈ A	智能体输出
π(a|s)	策略	给定 s 选 a 的概率	Actor 网络
r / rₜ	即时奖励	rₜ = R(sₜ,aₜ)	环境反馈
Gₜ	回报（折扣累积奖励）	Gₜ = Σ_{k≥0} γᵏ·rₜ₊ₖ₊₁	优化目标
γ	折扣因子	γ ∈ [0,1]，常用 0.99	权衡近期/远期奖励
V(s)	状态价值函数	`V^π(s)=E[Gₜ	sₜ=s]`
Q(s,a)	动作价值函数	`Q^π(s,a)=E[Gₜ	sₜ=s,aₜ=a]`
A(s,a)	优势函数	A = Q(s,a) − V(s)	A2C/PPO/GAE
δₜ	TD 误差	δₜ = rₜ + γV(sₜ₊₁) − V(sₜ)	TD 学习核心
E·|π	策略下的期望	---	强调依赖策略
ρ	重要性采样比	`ρ = π(a	s)/b(a
s′ / sₜ₊₁	下一状态	(s,a,r,s′) 转移元组	经验回放
τ	轨迹	τ = (s₀,a₀,r₀,...)	策略梯度
θ	策略网络参数	π_θ	Actor
w / φ	价值网络参数	V_w / Q_φ	Critic

核心算法公式

贝尔曼期望方程:  V(s) = Σ_a π(a|s)·Σ_{s'} P(s'|s,a)[r + γV(s')]
贝尔曼最优方程:  Q*(s,a) = E[r + γ·max_{a'} Q*(s',a')]
Q-learning:      Q(s,a) ← Q(s,a) + α[r + γ·max Q(s',a') − Q(s,a)]
策略梯度(REINFORCE): ∇J(θ) = E[∇log π_θ(a|s)·Gₜ]
Actor-Critic:    ∇J(θ) = E[∇log π_θ(a|s)·A(s,a)]
PPO-Clip:        L = E[min(ρₜAₜ, clip(ρₜ, 1−ε, 1+ε)Aₜ)]
GAE:             Âₜ = Σ_{l≥0} (γλ)ˡ·δₜ₊ₗ
DQN 目标:        y = r + γ·max_{a'} Q(s',a'; θ⁻)   (θ⁻ 为靶网络)

⚡ PyTorch 实战：Q-learning、REINFORCE、GAE、PPO

import torch
import torch.nn.functional as F

gamma, eps = 0.99, 0.2                   # 折扣因子 γ · PPO 裁剪 ε

# ---- 回报 Gₜ = Σ γᵏ rₜ₊ₖ（反向累积）----
def discounted_returns(rewards, gamma):
    G, out = 0.0, []
    for r in reversed(rewards):
        G = r + gamma * G                # 贝尔曼式递推
        out.insert(0, G)
    return torch.tensor(out)

# ---- Q-learning：目标 y = r + γ·max Q(s',a'; θ⁻) ----
q_pred   = q_net(s).gather(1, a)                        # Q(s,a)
q_target = r + gamma * q_net_target(s_next).max(1)[0].unsqueeze(1)
q_loss   = F.mse_loss(q_pred, q_target)                 # TD 误差 δ 的平方

# ---- REINFORCE：∇J = E[∇log π_θ(a|s)·Gₜ] → 损失 L = −E[log π·G] ----
logits = policy_net(s)                                  # Actor 输出 π_θ(·|s)
log_pi = F.log_softmax(logits, dim=-1).gather(-1, a)    # log π_θ(aₜ|sₜ)
pg_loss = -(log_pi * discounted_returns(rewards, gamma)).mean()

# ---- GAE：Âₜ = Σ (γλ)ˡ δₜ₊ₗ，δₜ = r + γV(s') − V(s) ----
def gae(rewards, values, gamma=0.99, lam=0.95):
    adv, last = [], 0.0
    for t in reversed(range(len(rewards) - 1)):
        delta = rewards[t] + gamma * values[t+1] - values[t]   # TD 误差 δₜ
        last  = delta + gamma * lam * last
        adv.insert(0, last)
    return torch.tensor(adv)

# ---- PPO-Clip：L = E[min(ρÂ, clip(ρ,1−ε,1+ε)Â)] ----
ratio = (new_logp - old_logp).exp()      # ρ = π_θ(a|s) / π_θ_old(a|s) 重要性采样比
surr1 = ratio * adv
surr2 = torch.clamp(ratio, 1 - eps, 1 + eps) * adv
ppo_loss = -torch.min(surr1, surr2).mean()

---

七、生成模型符号

符号	含义	公式	应用场景
z	潜变量	z ~ N(0,I)	VAE/GAN 输入
G(z;θ_g)	生成器	从噪声生成样本	GAN
D(x;θ_d)	判别器	输出真/假概率	GAN
q(z|x)	后验（编码器）	近似 p(z|x)	VAE
p(x|z)	似然（解码器）	---	VAE
ELBO	证据下界	`log p(x) ≥ E_q[log p(x	z)] − KL(q‖p)`
reparam	重参数化	z = μ + σ⊙ε, ε~N(0,I)	让采样可微
W₁	Wasserstein 距离	---	WGAN

GAN 目标函数

min_G max_D  E_x[log D(x)] + E_z[log(1 − D(G(z)))]

⚡ PyTorch 实战：VAE 重参数化与 GAN 损失

import torch
import torch.nn.functional as F

# ---- VAE：z ~ q(z|x) = N(μ, σ²)，重参数化 z = μ + σ⊙ε ----
mu, logvar = encoder(x)                     # 编码器输出 q(z|x) 的 μ 和 log σ²
std = (0.5 * logvar).exp()                  # σ = exp(logvar/2)
eps = torch.randn_like(std)                 # ε ~ N(0, I)
z   = mu + std * eps                        # 采样变得可微 → 能反向传播

# −ELBO = 重建项 + KL 正则
recon = F.binary_cross_entropy(decoder(z), x, reduction='sum')   # −E[log p(x|z)]
kl    = -0.5 * (1 + logvar - mu.pow(2) - logvar.exp()).sum()     # KL(q(z|x) ‖ N(0,I))
vae_loss = recon + kl

# ---- GAN：min_G max_D  E[log D(x)] + E[log(1 − D(G(z)))] ----
z_noise = torch.randn(64, 100)              # 潜变量 z ~ N(0,I)
one, zero = torch.ones(64, 1), torch.zeros(64, 1)

d_loss = F.binary_cross_entropy(D(real_x), one) \
       + F.binary_cross_entropy(D(G(z_noise).detach()), zero)    # detach: 训 D 不更新 G
g_loss = F.binary_cross_entropy(D(G(z_noise)), one)              # 非饱和实用变体

---

八、其他常见记号

符号	含义	场景
∀	任意 (for all)	数学陈述
∃	存在 (exists)	数学陈述
∈ / ∉	属于 / 不属于	θ ∈ ℝᵈ
⊂ / ⊆	子集	---
∪ / ∩	并集 / 交集	---
⇒ / ⇔	推出 / 等价	证明
□ / ∎	证毕	论文
O(·)	大 O 复杂度	O(n²) 注意力复杂度
Δ	增量	Δθ 参数变化量
‖	条件分隔 / 范数	P(A‖B) 有时写作条件概率
;	参数分隔	f(x; θ)：x 是输入，θ 是参数
|	给定（条件）	`p(y
←	赋值 / 更新	θ ← θ − ηg
← vs =	赋值 vs 相等	算法伪代码用 ←，数学等式用 =

⚡ PyTorch 实战：伪代码记号 → 代码习惯

import torch

w = torch.nn.Parameter(torch.randn(3))
g = torch.randn(3)

# ←（赋值/更新）：PyTorch 原地操作以 _ 结尾
w.data -= 0.1 * g          # w ← w − η·g
w.grad = None              # 清空梯度
opt = torch.optim.Adam([w]); opt.step()   # θ ← θ − α·m̂/(√v̂+ε)（优化器代劳）

# f(x; θ)：分号左边是输入、右边是参数 → 代码里就是 model(x)
model = torch.nn.Linear(3, 1)             # θ 藏在 model.parameters()
y_hat = model(torch.randn(8, 3))          # ŷ = f(x; θ)

# O(·)：自注意力 O(T²·d) → T=4096 时显存爆炸，
# 因此有 F.scaled_dot_product_attention（FlashAttention，省显存不换复杂度）
out = torch.nn.functional.scaled_dot_product_attention(q, k, v, is_causal=True)

---

九、快速记忆卡片

"一条训练循环"串起所有符号：

数据:   (x, y) ~ D,  x ∈ ℝᵈ
前向:   z = Wx + b  →  a = σ(z)  →  ŷ = softmax(a⁽ᴸ⁾)
损失:   L = −Σ y·log ŷ + λ‖W‖²
反向:   ∇W L = δ·xᵀ  (链式法则逐层传 δ)
更新:   m,v ← Adam矩估计 ;  W ← W − α·m̂/(√v̂+ε)

易混淆对照：

易混	区分
α vs η	都是学习率，不同作者习惯
σ vs Σ	小写=Sigmoid/标准差，大写=求和/协方差
π vs Π	小写=策略/圆周率，大写=连乘
θ vs ϑ	同一符号的手写体变体
‖x‖ vs |x|	范数 vs 绝对值
v vs ν	速度/动量 vs 希腊字母 nu
W vs w	矩阵 vs 向量（粗体惯例）
L (损失) vs L (层数) vs l (层索引)	看上下文
Q(s,a) vs Q,K,V	RL 的 Q 值 vs Transformer 的查询
E 期望 vs E 嵌入矩阵	花体/粗体区分

⚡ PyTorch 实战：完整训练循环（把所有符号串起来）

import torch
import torch.nn as nn

# θ = 全部可训练参数；L = 交叉熵 H(p,q)；α,β,ε = Adam 超参
model   = nn.Sequential(nn.Linear(784, 256), nn.ReLU(), nn.Linear(256, 10))
loss_fn = nn.CrossEntropyLoss()
opt     = torch.optim.Adam(model.parameters(), lr=1e-3,
                           weight_decay=1e-4)      # λ‖W‖² 正则

for x, y in train_loader:          # (x, y) ~ D
    opt.zero_grad()                # 清掉上一步的 ∇（否则累加）
    y_hat = model(x)               # 前向: z=Wx+b → a=ReLU(z) → ŷ
    loss  = loss_fn(y_hat, y)      # 损失: L = −Σ y·log ŷ
    loss.backward()                # 反向: autograd 逐层链式求 ∂L/∂θ
    opt.step()                     # 更新: θ ← θ − α·m̂/(√v̂+ε)

# 推理/评估时关闭 Dropout 与梯度：
model.eval()
with torch.no_grad():
    pred = model(x_test).argmax(dim=-1)     # ŷ* = argmax P(y|x)

---

生成日期：2026-09-17（含 PyTorch 实战） · 建议配合《Deep Learning》(花书) 第 2-4 章数学基础阅读