• 概览
• 演进方向
• 在注意力机制上搞事情：注意力效率与结构变体
• 早期探索（近似流派和稀疏流派）
• MHA、MQA、GQA、CLA（共享KV流派）
• MLA低秩压缩（进阶版共享KV流派）
• 可训练的稀疏注意力机制（现代稀疏流派）
• 线性注意力与状态空间模型（现代线性流派）
• 混合注意力机制
• 在FFN网络上搞事情：提高知识存储容量和深层网络训练稳定性
• FFN扩张比
• MoE（混合专家）稀疏大模型架构
• 激活函数的演进
• 在位置编码上搞事情：位置编码与长上下文扩展
• 从绝对位置编码到旋转位置编码
• 混合位置编码与NoPE
• 在嵌入层上搞事情：嵌入层优化也能无痛提升模型性能
• 大规模扩展词汇表
• N-gram嵌入技术
• 在整体架构上搞事情：后Transformer架构
• 多Token预测（MTP）
• 微观结构与训练稳定性
• 一个实际例子

在搞清楚Transformer的基本原理之后，我们再来讨论下，在Transformer之后，大模型领域有哪些变化和进展。本文作为一个初学者在学习过程中的记录，可能不一定能做到非常完整和系统。

Transformer之后大模型领域的变化和进展，总体来说可以分为下面这些方向：

• 架构演进
• 推理技术
• Scaling Law 与预训练数据工程
• 后训练与对齐
• Agent、工具使用与外部知识
• 多模态与统一生成
• 可解释性、安全与评测
• 系统、工程与成本

在这个系列中，我主要会整理、学习和总结架构演进、推理技术这两个方向的内容，并在过程中涉及一些关于系统、工程与成本的内容。

本文首先讨论架构演进这一方向。

概览

自2017年Transformer提出以来，主干结构的实质改动其实有限。真正的变化几乎全部发生在架构之外：训练配方、后训练目标、推理时策略与工程系统。

下面我们讨论下模型主干结构的一些关键演进，而关于推理的内容将会在推理技术篇中总结，不过本篇仍或多或少涉及到一些推理的内容，毕竟推理性能也影响着模型设计本身。

演进方向

在注意力机制上搞事情：注意力效率与结构变体

在注意力机制上做的改进，核心思想都是：在尽可能不牺牲注意力效果的前提下，降低显存与访存开销。

早期探索（近似流派和稀疏流派）

近似流派（利用近似改写公式以降低计算量），例如：

• Performer(2020)：【线性/核函数近似】利用随机特征映射将标准自注意力的Softmax核近似分解为两个低秩特征矩阵的乘积，将复杂度降低为线性
• Linformer(2020)：【低秩近似】用低秩投影把K/V压到固定维度，将复杂度降低为线性

但是由于投影无法支持自回归、无法动态处理变长的上下文，以及不适合工程实现和硬件并行化计算等原因，均已不再单独使用。

稀疏流派（剪枝以跳过影响较小的计算），例如：

• Sparse Transformer(2019)：【稀疏注意力】采用分块和步长的网格状稀疏，Token只看自己同一块或固定间隔的Token
• Longformer(2020)：【稀疏注意力】采用滑动窗口（局部只看邻居）+扩张滑动窗口+任务特定的全局Token 稀疏组合
• BigBird(2020)：【稀疏注意力】继承了Longformer的局部和全局，并额外加入了随机采样，通过“局部+全局+随机”的稀疏图结构，在数学上逼近全连接的效果

但是稀疏流派不利于硬件计算，显存带宽利用率极低，甚至可能还没有不做任何数学公式改动的纯工程优化方案FlashAttention速度快。

不过，早期的近似流派和稀疏流派的思想仍可能会可能会以混合的方式出现在现代模型中。

MHA、MQA、GQA、CLA（共享KV流派）

核心目的是通过降低隐状态数量来降低KVCache体积。

• MHA（Multi-Head Attention）：传统多头注意力机制，每个头都有独立的Q、K、V
• MQA（Multi-Query Attention）：让所有Q头共享唯一的一组K、V头
• GQA（Group-Query Attention）：一种折中方案，将Q头分为多个组，一个组内的多个Q头共享相同的K、V头。若组数等于1，GQA就退化为MQA；若组数等于Q头数，GQA就等同于MHA
• CLA（Cross-Layer Attention）：是一种在层之间共享KV的技术路线

传统MHA显存和带宽消耗大，MQA效果差，GQA在中小模型与稠密模型中最普遍，而CLA更适合端侧模型。

MLA低秩压缩（进阶版共享KV流派）

相比MQA/GQA，MLA（Multi-Head Latent Attention）不是粗暴地减少KV头数，而是对K和V进行联合低秩压缩。它在推理时缓存的不是完整的K和V，而是一个低维的隐向量，以及一个用于RoPE位置编码的共享向量（因为基于乘法的RoPE，会破坏矩阵结合律，导致矩阵吸收失效，因此需要解耦RoPE）

MLA本质上是把投影矩阵拆成了两个低秩矩阵的乘积，共用一个下投影矩阵：

于是，KV会被投影成相同的低维向量被KVCache，需要的时候再通过上投影矩阵恢复。这个低维的隐向量只有一份，它被该层所有的注意力头共同读取和共享，因此MLA可以理解为一个升级版的MQA。

但其实它甚至不需要做恢复动作，在实际推理的decoding阶段，MLA采用了一种名为矩阵吸收的优化，将用于隐向量还原的高维升维矩阵提前融合到投影矩阵中，使得模型不需要把K和V显式还原放大。

对比一下原始Transformer就很明显了：

MLA能奏效的核心原因是，不同头的隐状态中的信息密度其实没有那么高，所以才能压缩。

但是如开头所说，RoPE位置信息要单独携带，无法融入其中。因此除了一个低维的隐向量以外，还需要一个用于RoPE位置编码的共享向量。

最后是一个在工程实现上的点：矩阵吸收本质上是改变了升维矩阵的结合方式（是否要与Q结合）。如果Q少，就可以吸收（与Q结合），牺牲计算换取更小的显存带宽消耗；如果Q多，就不需要吸收。因此矩阵吸收通常只在推理decode阶段做，而在prefill或者训练阶段不做。

可训练的稀疏注意力机制（现代稀疏流派）

稀疏注意力这一方向核心要解决的问题有几个：

• 稀疏注意力gather操作与GQA等共享KV的访存模式冲突（最怕的就是每个头挑的token不一样导致KV没法共享），破坏内存合并访问，瓶颈从算力变成了不规则访存
• 往往只对prefill和decode的其中之一有加速，很难兼顾
• 稀疏注意力本质上要做离散选择，常见做法不可微，无法预训练

一种最简单的稀疏注意力机制，就是局部注意力，采用类似于滑动窗口的形式，简单粗暴。

随着研究深入，可训练的稀疏注意力机制被提出，典型方法如下：

• NSA（Native Sparse Attention，DeepSeek 2025-02）：引入三分支门控，三个分支的输出用一个学出来的门控加权求和，模型自己决定每层每头更依赖哪条路
  • 压缩分支：用可学习MLP聚合连续KV块，即把KV序列按连续块切开，每块用一个可学习的MLP压成一个代表性的K/V，Q对这些块摘要做全注意力
  • 选择分支：只看摘要毕竟有损，所以再从所有块里挑top n个最相关的，对这些块内的原始token做精确注意力（top n的选择复用压缩分支算出来的注意力分数），因为分数来自可学习的MLP，所以它可微分

    为了不与GQA产生冲突，NSA选择让同一个组内的多个Q头的打分做平均，从而合并为相同的决策。只有选择分支有这个问题，其他两个分支不会有冲突。
    如果不这么做，极端情况下访存开销退化到与没有用NSA一样的情况，这是因为：每个头的矩阵计算是独立的，如果Q头对应的KV切片一样，就可以复用；如果不一样，就还要把所有需要的KV切片拉出来

  • 滑窗分支：保留单独的近邻处理，防止局部模式吞掉长程学习
• MoBA（Mixture of Block Attention，Moonshot 2025-02）：把MoE搬到注意力上，采用无参数门控（Q与块内K均值池化的点积）取top n个块。它没有增加可训练的参数，但是稀疏pattern本身是被训练出来的
• DSA（DeepSeek Sparse Attention，DeepSeek 2025-09）：在注意力前加一个带参数的选路器（Lightning‑Indexer），先快速判断历史上哪些token值得关注，只把这部分送进真正的MLA注意力

  由于DSA直接把索引也做成per-token、全head共享的，所有head共享一份top n列表，因此它可以与MLA直接集成
  由于top n操作不可微，所以训练时会麻烦一些，需要分两步解决，先不开稀疏训练，再打开稀疏并通过计算图detach完成训练

但并不是每个方法都能与GQA/MLA同时使用的，所以在方案设计和选择上，与其他方法的冲突问题也是必须要考虑的。

从以上内容可以看出，各类方法其实已经在有机融合。

再额外提一下Attention‑Sink现象：模型会天然把大量注意力权重分配给序列开头少数几个token，和语义无关，是RoPE+softmax归一化带来的模型固有行为
针对Attention‑Sink现象，有一些不同的做法：有些模型会将这个现象显式化，也有一些模型会反向消除它
StreamingLLM就是利用Attention‑Sink现象，推理时强制永久保留前N个sink token并结合滑动窗口策略，是一种固定模式稀疏注意力机制

原生可训练稀疏已成为长上下文主流路径之一，且明显趋势是稀疏性向训练早期迁移（训练时就开启稀疏）。

线性注意力与状态空间模型（现代线性流派）

核心问题：能否用线性复杂度、固定大小状态的机制替代全注意力。

• 线性注意力：通过一个映射函数，把拆解为，然后利用结合律先计算，使得中间状态的大小只与维度有关而与序列长度无关，计算复杂度直接降为

  它与RNN的核心区别是，RNN是把全部历史压缩成一个向量，而线性注意力本质是快速权重，存储K到V的映射矩阵，用于与Q相乘得到结果
  线性注意力在训练阶段能够并行的核心原因是它的递归转移满足结合律，因此可以直接分块并行，而RNN不行

• 状态空间模型（SSM）：类似RNN，把文本序列压缩进一个能够随时间不断更新的隐状态中，但它不在隐状态的传递上引入非线性激活函数，而是在外部引入非线性，从而在支持并行计算的情况下提升表达能力（训练时并行，推理时像RNN一样串行），属于一种特殊的RNN

  SSM的隐状态迭代本质上就是线性层的叠加。
  对于静态SSM（每个线性层参数固定），该计算就是卷积，可以直接并行。
  对于动态SSM（每个线性层随着输入动态变化，称为选择性机制），可以通过并行扫描（前缀和）来并行。

线性注意力与状态空间模型在数学本质上是对等的关系。它们是从不同的视角（注意力视角、循环视角）去描述同一个计算逻辑，并在现代架构中走向了深度融合。

接下来分别介绍两个方向的典型模型，并不完全是最新的，后面还有一些衍生版本，但核心思想一致。

状态空间模型Mamba：属于动态选择性SSM，SSM参数由输入动态生成，自主控制历史信息的留存与丢弃；训练借助并行扫描实现序列并行，推理以固定大小隐状态迭代，无膨胀KVCache，为线性复杂度，再通过硬件定制kernel增强性能；整体是用状态更新机制替代Transformer自注意力

线性注意力Gated DeltaNet：区别于普通线性注意力的简单累加KV信息，它引入动态门控+增量Delta更新机制，模型会先通过输入自适应门控衰减、遗忘冗余的历史记忆，再仅用新token的残差信息修正、更新固定尺寸的记忆状态，而非无脑叠加新信息

混合注意力机制

很显然，GQA和MLA这种由于作用对象不同（一个是降低KV隐状态大小，一个是降低参与注意力计算的历史KV数量），其实是可以融合使用的。

事实上，线性注意力与全注意力也是可以混合使用的。例如新发布的Qwen3.8-Flash-Next就同时使用了线性注意力GDN（Gated DeltaNet）层与稀疏注意力QSA（Qwen Sparse Attention）层按3:1的比例交替堆叠，且稀疏注意力使用了MQA索引器结构。

混合注意力已成为新常态。

混合架构核心需要考虑几个问题：线性注意力与全注意力的配比与排布、稀疏还是全局、位置编码归谁、是否叠加MoE等。

在FFN网络上搞事情：提高知识存储容量和深层网络训练稳定性

FFN扩张比

在Transformer架构中，每个注意力层后面都紧跟着一个FFN层。FFN扩张比代表了FFN隐藏层（中间层）的维度与模型主隐层（输入/输出）维度之间的比例关系。

intermediate_size与hidden_size之比就是FFN扩张比。

MoE（混合专家）稀疏大模型架构

其核心要解决的问题是：如何让模型容纳更多知识而不等比例增加推理成本。

具体做法是把每层FFN换成多个专家FFN，由router决策每个token激活其中的哪些，且只激活其中少数几个。

MoE的本质就是将FFN层的总扩张比做到了几十倍甚至上百倍（拥有海量的隐藏神经元作为参数容器），但通过稀疏路由机制，让每个token在前向传播时只激活其中的一小部分专家，这在隐式上完成了前所未有的超高维投影。

以DeepSeek-V3为例，671B总参数、每层256个专家、激活9个（1共享+8路由），激活参数仅37B，却比稠密的405BLlama 3更强且推理更省。其中共享专家是指始终保持激活状态、不参与动态路由选择、负责捕获和整合全局通用知识的固定专家模块。

一个现象是稀疏度在持续走高：

MoE也有几个固有难题：

• 路由与负载均衡（常见解法是辅助损失、无辅助损失均衡策略）
• 专家并行（Expert Parallelism, EP）带来的All-to-All通信开销
• 硬件资源的错配（显存要按总参数算但算力要按激活参数算）

激活函数的演进

早期我们想要在FFN上实现非线性使用的是ReLU。当前，SwiGLU已成为事实上的标准激活函数配置。

SwiGLU采用双支路并行设计（一路传输原始特征，另一路通过Swish/SiLU激活函数生成0-1之间的门控权重），两路逐元素相乘。这类似于一个可学习的注意力开关，让模型能够自适应地筛选重要语义并压制冗余噪声。彻底解决了ReLU的神经元永久死亡、梯度不稳定问题，以及GELU在深层网络中非线性拟合上限低、训练后期容易饱和的硬伤。

在位置编码上搞事情：位置编码与长上下文扩展

要解决的核心问题是：位置信息如何注入才能泛化到训练时未见过的长度；以及窗口做大之后，模型是否真的能用好其中的信息。

从绝对位置编码到旋转位置编码

Transformer原文使用的是三角函数绝对位置编码，当前旋转位置编码RoPE已逐渐成为事实标准。

RoPE有几个十分优雅且重要的特性：

• 完美结合绝对与相对位置：它通过将词元向量在二维子空间中进行旋转，使模型既能感知每个词的绝对位置，又能在计算注意力点积时自动暴露出两个词之间的相对距离
• 支持长文本外推：RoPE理论上支持无限长度，使得模型可以零开销或通过极少量的续训，将上下文直接暴力扩展
• 极致的计算效率：RoPE属于零参数机制，不增加训练负担；同时它的数学形式可以完美借助FlashAttention等现代GPU算子进行硬件级加速，几乎没有推理性能惩罚

再来详细分析一下RoPE为什么支持长文本外推：

RoPE的rope_theta在推理时可以根据需要修改。RoPE的数学推导证明了，Q和K乘以旋转矩阵后，进行点积运算时，绝对位置被消去了，只留下了相对位置差。不是像三角函数位置编码是一个绝对位置的概念。当调大rope_theta时相当于把整个特征空间里的相对距离等比例缩小或平滑拉伸了装置注意力机制来说，它看到的只是注意力权重矩阵的波形变得稍微平缓了一点，依然能识别出谁和谁应该产生注意力，模型已经学会了理解这种pattern。

不过这种操作也不是没有代价的：虽然调大后会减缓长距离注意力衰减，但是会牺牲短文本的局部精确度。

这种操作虽然可用，但如果是想要保障长文本的效果，通常必须配合一定量的长文本数据进行继续预训练或微调。

混合位置编码与NoPE

NoPE的核心洞察是：因果掩码本身就携带顺序信息（第t个token只能看到前t-1个token信息），这个可见计数就是位置，因此理论上NoPE可表达绝对与相对位置编码。

当然，理论是理论，实践是实践。NoPE与逐层差异化是近期的趋势。

实际落地的混合做法有四种形态：

• 不同层不同base（rope_theta）
• RoPE与NoPE按层交错
• 把位置职责整体外包，注意力放弃位置建模，交给注意力以外的模型结构处理
• 部分RoPE，让部分维度不旋转

  朴素的想法是：编码位置所需的维度远少于编码语义，留一批无位置信息的通道是有价值的 例如MLA中，由于RoPE无法压缩，因此拆出小维度做RoPE，剩下保持无位置便于应用MLA

在嵌入层上搞事情：嵌入层优化也能无痛提升模型性能

大规模扩展词汇表

N-gram嵌入技术

在整体架构上搞事情：后Transformer架构

多Token预测（MTP）

微观结构与训练稳定性

参数量配比

已成既定标准的内部改动包括：Pre-LN 取代 Post-LN（Xiong et al. 2020 证明其初始化时梯度更良性且无需精心设计的学习率 warmup）、RMSNorm 取代 LayerNorm、SwiGLU 类门控激活、QK-Norm（在 RoPE 之前对 q/k 做 RMSNorm，可追溯至 2023 年 Scaling Vision Transformers）。有意思的是 OLMo 2 反其道采用 Post-Norm 变体（norm 移到注意力/FFN 之后但仍在残差连接内部）以提升训练稳定性，OLMo 3 延续了该选择；Gemma 3 则在注意力模块前后都放 RMSNorm，兼取两者之长 [2]。

门控残差连接是一种在标准残差连接基础上引入门控机制的神经网络结构

一个实际例子

• 模型结构
• 实现
• tokenize逻辑
• 处理参数和超参数
• 工具函数
• 核心计算函数与Transformer层
• prefill与predict
• 构造输入
• 发起预测
• 性能
• 在过程中遇到的问题
• RoPE的细节

深度学习学完Transformer之后，决定古法手撕一个推理器出来，亲自做一遍可以验证自己的理解是否存在偏差，并且对各类细节有更深入和更系统的了解。

我选择Qwen3-0.6B模型实现推理器，并在我的3070Ti(8GB)上验证。

整体仅使用pytorch的张量计算，不使用任何其他高级封装函数。但在参数读取和tokenize方面，使用了Hugging Face的safetensors库读取模型权重，以及tokenizers库实现文本与token id之间的转换，省去了基于tokenizer.json处理BPE词表的merges的步骤，更关注于推理器的实现。总代码约200多行。

完整代码>>

完整输出结果（Jupyter Notebook）>>

模型结构

首先要看模型结构，图片来自LLM Architecture Gallery：

相比Transformer原始论文中的实现，主要有以下几点变化：

• 采用RMSNorm而非LayerNorm，不再减去均值
• 残差连接与RMSNorm的位置与原文有略微差异
• 采用旋转位置编码RoPE而非三角函数位置编码
• 额外引入对Q/K的RMSNorm
• Q与K/V的注意力头数不一样，需要对K/V做交错式repeat
• 前馈神经网络FFN采用SwiGLU门控前馈网络，引入了门控机制并采用SiLU作为激活函数

实现

整体拆解成下面这些步骤和模块：

tokenize逻辑

借助Hugging Face的tokenizers库快速实现文本与token id之间的转换。

DIR = "../models/HuggingFace/Qwen3-0.6B"

from tokenizers import Tokenizer

tokenizer = Tokenizer.from_file(DIR + "/tokenizer.json")
output = tokenizer.encode("测试一下tokenizer的效果")
print(output.ids)
tokenizer.decode(output.ids)

处理参数和超参数

从model.safetensors和config.json中读取参数和超参数。

from safetensors import safe_open
import json
import torch

# 常数和超参数
eos_token_id: int  # 用于判断模型输出完的token id
rms_norm_eps: float  # RMSNorm防止归一化分母为0的eps
rope_theta: int  # RoPE的theta的底数部分
num_hidden_layers: int  # transformer层数
num_attention_heads: int  # Q的注意力头数
num_key_value_heads: int  # KV的注意力头数
head_dim: int  # 单头注意力维数
max_position_embeddings: int  # 允许位置编码的最大序列长度

# 参数
E: torch.Tensor  # 嵌入层
Gamma_finalRMSNorm: torch.Tensor  # 最终RMSNorm的缩放系数
W_output: torch.Tensor  # 最终投影到词表大小的线性层
Gamma_inputRMSNorm: list[torch.Tensor] = []  # transformer层中对输入的RMSNorm的缩放系数
Gamma_postATTNRMSNorm: list[torch.Tensor] = []  # transformer层中对自注意力结果的RMSNorm的缩放系数
W_FFNGate: list[torch.Tensor] = []  # transformer层中FFN的门控层
W_FFNUp: list[torch.Tensor] = []  # transformer层中FFN的升维层
W_FFNDown: list[torch.Tensor] = []  # transformer层中FFN的降维层
Gamma_QRMSNorm: list[torch.Tensor] = []  # transformer层中Q投影后、RoPE前的每个头的RMSNorm的缩放系数
Gamma_KRMSNorm: list[torch.Tensor] = []  # transformer层中K投影后、RoPE前的每个头的RMSNorm的缩放系数
W_Q: list[torch.Tensor] = []  # transformer层中Q投影矩阵
W_K: list[torch.Tensor] = []  # transformer层中K投影矩阵
W_V: list[torch.Tensor] = []  # transformer层中V投影矩阵
W_O: list[torch.Tensor] = []  # transformer层中O投影矩阵

# 读取常数和超参数
with open(DIR + "/config.json", "r", encoding="utf-8") as f:
    data = json.load(f)

    def readParam(name, t):
        d = data.get(name)
        if not isinstance(d, t):
            raise ValueError(f"get {name} error")
        return d

    eos_token_id = readParam("eos_token_id", int)  # 151645
    rms_norm_eps = readParam("rms_norm_eps", float)  # 1e-06
    rope_theta = readParam("rope_theta", int)  # 1000000
    num_hidden_layers = readParam("num_hidden_layers", int)  # 28
    num_attention_heads = readParam("num_attention_heads", int)  # 16
    num_key_value_heads = readParam("num_key_value_heads", int)  # 8
    head_dim = readParam("head_dim", int)  # 128
    max_position_embeddings = readParam("max_position_embeddings", int)  # 40960

# 读取参数
with safe_open(DIR + "/model.safetensors", framework="pt", device=0) as f:
    E = f.get_tensor("model.embed_tokens.weight")  # torch.Size([151936, 1024])
    Gamma_finalRMSNorm = f.get_tensor("model.norm.weight")  # torch.Size([1024])
    W_output = f.get_tensor("lm_head.weight")  # torch.Size([151936, 1024])
    for i in range(num_hidden_layers):
        Gamma_inputRMSNorm.append(f.get_tensor(f"model.layers.{i}.input_layernorm.weight"))  # torch.Size([1024])
        Gamma_postATTNRMSNorm.append(f.get_tensor(f"model.layers.{i}.post_attention_layernorm.weight"))  # torch.Size([1024])
        W_FFNGate.append(f.get_tensor(f"model.layers.{i}.mlp.gate_proj.weight"))  # torch.Size([3072, 1024])
        W_FFNUp.append(f.get_tensor(f"model.layers.{i}.mlp.up_proj.weight"))  # torch.Size([3072, 1024])
        W_FFNDown.append(f.get_tensor(f"model.layers.{i}.mlp.down_proj.weight"))  # torch.Size([1024, 3072])
        Gamma_QRMSNorm.append(f.get_tensor(f"model.layers.{i}.self_attn.q_norm.weight"))  # torch.Size([128])
        Gamma_KRMSNorm.append(f.get_tensor(f"model.layers.{i}.self_attn.k_norm.weight"))  # torch.Size([128])
        W_Q.append(f.get_tensor(f"model.layers.{i}.self_attn.q_proj.weight"))  # torch.Size([2048, 1024])
        W_K.append(f.get_tensor(f"model.layers.{i}.self_attn.k_proj.weight"))  # torch.Size([1024, 1024])
        W_V.append(f.get_tensor(f"model.layers.{i}.self_attn.v_proj.weight"))  # torch.Size([1024, 1024])
        W_O.append(f.get_tensor(f"model.layers.{i}.self_attn.o_proj.weight"))  # torch.Size([1024, 2048])

model_dtype = E.dtype

工具函数

主要是RMSNorm、RoPE、SiLU、softmax、masked_softmax等工具函数的实现。

def RMSNorm(X, gamma):
    return X / torch.sqrt(torch.mean(X[..., :] ** 2, -1, keepdim=True) + rms_norm_eps) * gamma

# interleaved: 交错配对theta[0,0,1,1,2,2,3,3]
# rope_theta_repeat2 = torch.pow(rope_theta, -torch.arange(head_dim // 2) * 2 / head_dim).repeat_interleave(2)
# rotate_half: 前后两半配对theta_0,1,2,3,0,1,2,3
rope_theta_repeat2 = torch.pow(rope_theta, -torch.arange(head_dim // 2) * 2 / head_dim).repeat(2)
rope_m_theta = torch.arange(max_position_embeddings).reshape(-1, 1) * rope_theta_repeat2.reshape(1, -1)
rope_sin_m_theta = torch.sin(rope_m_theta).cuda()  # torch.Size([40960, 128])
rope_cos_m_theta = torch.cos(rope_m_theta).cuda()  # torch.Size([40960, 128])
def RoPE(X, offset=0):
    Ls = X.shape[-2]
    d = X.shape[-1]
    cos, sin = rope_cos_m_theta[offset : offset + Ls], rope_sin_m_theta[offset : offset + Ls]
    # interleaved: 交错配对x[-1,0,-3,2]
    # X_rot = torch.stack((-X[..., 1::2], X[..., 0::2]), dim=-1).flatten(-2)
    # rotate_half: 前后两半配对x[-0,-1,-2,-3,0,1,2,3]
    X_rot = torch.cat((-X[..., d // 2 :], X[..., : d // 2]), dim=-1)
    return (X * cos + X_rot * sin).to(model_dtype)

def SiLU(X):
    return X / (1 + torch.exp(-X))

def softmax(X, temperature=1):
    X_shifted = X - torch.max(X / temperature, dim=-1, keepdims=True).values
    exp_X = torch.exp(X_shifted)
    return exp_X / torch.sum(exp_X, dim=-1, keepdims=True)

# 右上方三角被mask
def masked_softmax(X):
    # X: (batch_size, num_heads, num_steps, num_steps)
    maxlen = X.size(-1)
    mask = (torch.arange(maxlen).reshape(-1, 1) >= torch.arange(maxlen)).to(X.device)
    mask_not = ~mask
    return softmax(X * mask + (mask_not * -1e6).to(X.dtype))

核心计算函数与Transformer层

主要是FFN、缩放点积注意力、KVCache、单个Transformer层的计算逻辑。

由于投影矩阵是所有注意力头合在一起存放的，transpose_qkv/transpose_output主要用于在计算时的注意力头拆分与恢复。

KVCache主要存储经过投影、RMSNorm、RoPE的K，以及经过投影的V（V不需要RMSNorm、RoPE）。在prefill阶段一次性存储，在predict阶段每个token预测过程中一个个附加存储上去。

def FFN(X, gate, up, down):
    return (SiLU(X @ gate.T) * (X @ up.T)) @ down.T

# 通过转置实现Q/K/V张量按注意力头的拆分与恢复，便于一次性计算所有注意力头
def transpose_qkv(X, num_heads):
    # X_h: (batch_size, num_steps, num_heads, num_hiddens/num_heads)
    X_h = X.reshape(*X.shape[:-1], num_heads, -1)
    return X_h.transpose(-2, -3)
def transpose_output(X):
    # X_t: (batch_size, num_steps, num_heads, num_hiddens/num_heads)
    X_t = X.transpose(-2, -3)
    return X_t.reshape(*X_t.shape[:-2], -1)

def DotProductAttention(Q, K, V, offset=0):
    KVScale = num_attention_heads // num_key_value_heads
    # Q/K/V: (batch_size, num_heads, num_steps, num_hiddens/num_heads)
    # scores/A: (batch_size, num_heads, num_steps, num_steps)
    scores = Q @ torch.repeat_interleave(K.transpose(-1, -2), KVScale, -3) / torch.sqrt(torch.tensor(Q.shape[-1]))
    A = softmax(scores) if offset else masked_softmax(scores)
    return A @ torch.repeat_interleave(V, KVScale, -3)

KVCache: list[list[torch.Tensor]]

def ClearKVCache():
    global KVCache
    KVCache = [None] * num_hidden_layers

# KVCache中已经prefill或predict了多少个字符
def GetOffset():
    global KVCache
    return KVCache[0][0].size(-2)

# offset为0代表prefill阶段
def TransfomerLayer(layer, X, Gamma_inputRMSNorm, Gamma_postATTNRMSNorm, W_FFNGate, W_FFNUp, W_FFNDown, Gamma_QRMSNorm, Gamma_KRMSNorm, W_Q, W_K, W_V, W_O, offset=0):
    # X: (batch_size, num_steps, num_hiddens)
    X_inputRMSNorm = RMSNorm(X, Gamma_inputRMSNorm)
    # 投影 -> QK RMSNorm -> RoPE -> attention
    # Q/K/V: (batch_size, num_steps, num_heads, num_hiddens) -> (batch_size, num_heads, num_steps, num_hiddens/num_heads)
    Q = transpose_qkv(X_inputRMSNorm @ W_Q.T, num_attention_heads)
    K = transpose_qkv(X_inputRMSNorm @ W_K.T, num_key_value_heads)
    V = transpose_qkv(X_inputRMSNorm @ W_V.T, num_key_value_heads)
    Q_RMSNorm = RMSNorm(Q, Gamma_QRMSNorm)
    K_RMSNorm = RMSNorm(K, Gamma_KRMSNorm)
    Q_RoPE = RoPE(Q_RMSNorm, offset)
    K_RoPE = RoPE(K_RMSNorm, offset)
    # prefill阶段初始化KVCache
    global KVCache
    if offset == 0:
        KVCache[layer] = [K_RoPE, V]
    else:
        KVCache[layer][0] = torch.cat((KVCache[layer][0], K_RoPE), dim=-2)
        KVCache[layer][1] = torch.cat((KVCache[layer][1], V), dim=-2)
    # V_attn: (batch_size, num_heads, num_steps, num_hiddens/num_heads)
    V_attn = DotProductAttention(Q_RoPE, KVCache[layer][0], KVCache[layer][1], offset)
    X2 = X + transpose_output(V_attn) @ W_O.T
    # FFN前的RMSNorm -> FFN
    # O: (batch_size, num_steps, num_hiddens)
    O = X2 + FFN(RMSNorm(X2, Gamma_postATTNRMSNorm), W_FFNGate, W_FFNUp, W_FFNDown)
    return O

prefill与predict

由于prefill阶段不需要output，所以这里把Transformer层后面的输出逻辑单独摘出来为lastOutputToken函数，prefill不需要调用，predict需要调用。

def prefill(X):
    ClearKVCache()
    # X: (batch_size, num_steps)
    # O: (batch_size, num_steps, num_hiddens)
    O = E[X]
    for i in range(num_hidden_layers):
        O = TransfomerLayer(
            i, O, Gamma_inputRMSNorm[i], Gamma_postATTNRMSNorm[i], W_FFNGate[i], W_FFNUp[i], W_FFNDown[i], Gamma_QRMSNorm[i], Gamma_KRMSNorm[i], W_Q[i], W_K[i], W_V[i], W_O[i]
        )
    return O

# 多层Transformer得到的结果经过最终的RMSNorm、线性层和softmax得到概率
def lastOutputToken(O, temperature=1):
    O = RMSNorm(O, Gamma_finalRMSNorm)
    Y = O @ W_output.T
    P = softmax(Y, temperature)
    return torch.argmax(P, dim=-1)[..., -1:].to(torch.long)

def predict(X, temperature=1):
    offset = GetOffset()
    # O: (batch_size, 1)
    res = X.clone().cpu()
    while offset < max_position_embeddings:
        token_id = res[0][-1].numpy()
        print(tokenizer.decode([token_id], skip_special_tokens=False), end="")
        if token_id == eos_token_id:
            break
        O = E[X]
        for i in range(num_hidden_layers):
            O = TransfomerLayer(
                i, O, Gamma_inputRMSNorm[i], Gamma_postATTNRMSNorm[i], W_FFNGate[i], W_FFNUp[i], W_FFNDown[i], Gamma_QRMSNorm[i], Gamma_KRMSNorm[i], W_Q[i], W_K[i], W_V[i], W_O[i], offset
            )
        X = lastOutputToken(O, temperature)
        res = torch.cat((res, X.cpu()), dim=-1)
        offset += 1
    print()
    return res.numpy()

构造输入

解析tokenizer_config.json文件中的template（jinja2格式），将给定测试messages转为用于模型输入的文本，并通过tokenizer.encode得到token id序列。

import jinja2

with open(DIR + "/tokenizer_config.json", "r", encoding="utf-8") as f:
    data = json.load(f)
    chat_template = data["chat_template"]

tpl = jinja2.Environment().from_string(chat_template)

messages = [{"role": "system", "content": "You are a helpful assistant."}, {"role": "user", "content": "steam现在最火的游戏是什么"}]

rendered = tpl.render(
    messages=messages,
    add_generation_prompt=True,
    enable_thinking=True,
)
tokens = tokenizer.encode(rendered).ids

发起预测

先完成prefill，将最后一个时间步的Transformer结果，计算最后的token输出逻辑，将其作为predict的第一个输入，循环预测。

同时在整个过程中监测prefill阶段耗时以及predict阶段每秒输出的token数。

由于整个实现是支持多样本的，因此可以同时跑多条prefill和predict。

import time

batch_size = 50

start = time.perf_counter()
O = prefill(torch.tensor(tokens, dtype=torch.long).reshape(1, -1).repeat(batch_size, 1))
end = time.perf_counter()
print(f"prefill耗时: {end - start:.2f} 秒")

start = time.perf_counter()
X = lastOutputToken(O)
res = predict(X)
end = time.perf_counter()
print(f"predict: {len(res[0])*batch_size/(end - start):.2f} tokens/s")
print(res)

性能

由于整体的实现在优化上做得很少，在我3070Ti(8GB)上，能够实现约22 tokens/s的推理速度，在并行50个batch的情况下，能够实现925 tokens/s的推理速度。

这个性能与vLLM/SGLang应该没有数量级上的差距，但是在显存占用上差距比较大。在并行50个batch的情况下，8G显存已经快要打满。核心原因是各类中间张量过多，可以通过算子简化或者inplace运算来降低显存占用。

在过程中遇到的问题

在debug的过程中主要有这么几类问题：

• device的处理：权重和计算过程中的数据一开始就是默认在GPU上的，但是一些arange的数据默认在CPU上，需要手动指定
• dtype数据类型的问题：模型权重是bfloat16，而pytorch默认是float32，新创建的（不是与已有张量计算产生的）张量需要指定dtype
• RoPE计算问题：这个下面单独讲

整体来讲最大的bug在RoPE这里，因为我之前看的Transformer原始实现用的是三角函数位置编码，RoPE不太熟悉，找的资料与模型真实实现其实有差异。反倒是Transformer的实现由于理论方面了解得特别清楚，写完就bug free了。

RoPE的细节

第一个要注意的是RoPE的theta的底（ ），要从config.json拿，并不都是10000。

第二个要注意的点是：RoPE有interleaved和rotate_half两种效果等价的变换方式，但是推理时必须采用与训练时一样的变换方式。

interleaved的计算公式：

rotate_half的计算公式：

整体来讲，工业界更常用rotate_half的方式，因为它可以通过复数来简化计算。Qwen3-0.6B使用的就是该方式。

• 安装
• 通过pip安装
• 通过Nvidia私有源安装
• 测试

主要讲在Linux中怎么配。

以Debian为例，虽然源里也有nvidia-cuda-toolkit，但是其版本太低，Debian 13的nvcc居然是24年的，还不支持Debian 13源里的默认的gcc 14。所以安装nvcc主要有如下两种方式。

安装

通过pip安装

直接uv pip install nvidia-cuda-nvcc即可，头文件什么都是齐全的，是最简单的方式。

在VSCode中，应当这样配置c_cpp_properties.json（主要是compilerPath），相关的语法和标识符才不会飘红：

{
    "configurations": [
        {
            "name": "Linux",
            "includePath": [
                "${workspaceFolder}/**"
            ],
            "compilerPath": "/mnt/d/work/python-work/cuda-learn/.venv/lib/python3.14/site-packages/nvidia/cu13/bin/nvcc"
        }
    ],
    "version": 4
}

然后将nvcc的bin路径加到PATH即可。

通过Nvidia私有源安装

参考官方文档的说明，步骤如下：

# wget https://developer.download.nvidia.com/compute/cuda/repos/<distro>/<arch>/cuda-keyring_1.1-1_all.deb
# Debian 13 x86_64
wget https://developer.download.nvidia.cn/compute/cuda/repos/debian13/x86_64/cuda-keyring_1.1-1_all.deb
sudo dpkg -i cuda-keyring_1.1-1_all.deb
sudo apt install cuda-toolkit

然后把/usr/local/cuda/bin加到PATH里即可。

在VSCode的c_cpp_properties.json中，compilerPath要配置成/usr/local/cuda/bin/nvcc。

测试

可以跑一下向量加的cuda-samples。

编译并运行：

nvcc add.cu -arch=sm_86 -o add && ./add

加-arch=sm_86是因为我装的nvcc V13.3.73默认是sm_75的（CUDA 13.X最低支持硬件就是sm_75），而我的3070Ti是sm_86。

CUDA Tile C++ API Reference, Release 13.3文档上有写：
Note: NVCC targets sm_75 as the default architecture if no architecture is provided. In this configuration, no tile code will be generated and a tile kernel launch will fail at runtime.

• 前言、安装与符号
• 引言
• 预备知识
• 数据操作
• 数据预处理
• 线性代数
• 微积分
• 自动微分
• 概率
• 线性神经网络
• 线性回归
• softmax回归
• 多层感知机
• 多层感知机原理
• 模型选择、欠拟合和过拟合
• 权重衰减
• 暂退法（Dropout）
• 前向传播、反向传播和计算图
• 数值稳定性和模型初始化
• 环境和分布偏移
• 实战Kaggle比赛：预测房价
• 深度学习计算
• 层和块
• 参数管理
• 延后初始化
• 自定义层
• 读写文件
• GPU
• 卷积神经网络
• 从全连接层到卷积 & 图像卷积
• 填充和步幅
• 多输入多输出通道
• 汇聚层
• 卷积神经网络（LeNet）
• 现代卷积神经网络
• 深度卷积神经网络（AlexNet）
• 使用块的网络（VGG）
• 网络中的网络（NiN）
• 含并行连结的网络（GoogLeNet）
• 批量规范化
• 残差网络（ResNet）
• 稠密连接网络（DenseNet）
• 循环神经网络
• 序列模型
• 文本预处理
• 语言模型和数据集
• 循环神经网络实现
• 通过时间反向传播
• 现代循环神经网络
• 门控循环单元（GRU）
• 长短期记忆网络（LSTM）
• 深度循环神经网络
• 双向循环神经网络
• 机器翻译与数据集
• 编码器-解码器架构
• 序列到序列学习（seq2seq）
• 束搜索
• 注意力机制
• 注意力提示（Queries, Keys, and Values）
• 注意力汇聚：Nadaraya-Watson核回归（Attention Pooling by Similarity）
• 注意力评分函数（Attention Scoring Functions）
• Bahdanau注意力（The Bahdanau Attention Mechanism）
• 多头注意力（Multi-Head Attention）
• 自注意力和位置编码（Self-Attention and Positional Encoding）
• Transformer（The Transformer Architecture）
• 【TODO】Transformers for Vision（视觉Transformer）
• 【TODO】Large-Scale Pretraining with Transformers（Transformer的大规模预训练）
• 【TODO】优化算法
• 【TODO】计算性能

李沐的《动手学深度学习》是一个非常不错的深度学习入门教材。在学习一段时间后，我觉得有必要以笔记的形式记录下我对每个章节的概括以及一些关键问题的认识和理解（在学习过程中产生的但教材没有解答的一些疑问和经过研究与思考后我的理解），也能强化自己对深度学习的理解。

本文的章节组织形式将与D2L中文版教材基本相同。

前言、安装与符号

前言：主要介绍了教材的内容与结构，并使用Jupyter Notebook的形式来组织。

安装：主要介绍如何配置运行Python、Jupyter Notebook、相关库以及运行本书所需的代码等所需的环境。由于教材及其配套代码的最终更新日期已是23年，所以相关库依赖与当前最新版本存在一些冲突。另外如果是在Windows平台上使用，还涉及到我之前在关于python与pytorch的各种配置问题与迷思中提到的一些问题。因此在安装pytorch和d2l库时，建议通过以下方法安装：

conda create -n d2l python=3.14
conda activate d2l

conda install pytorch torchvision
pip install d2l --no-deps # 不直接安装d2l包声明的依赖，而是手动安装依赖
pip install matplotlib pandas requests scipy numpy

符号：介绍了教材中所使用的各类数学符号的含义，包括数值对象、集合论、函数和运算符、微积分、概率统计与信息论等领域。

引言

引入机器学习（深度学习），表达它与“业务逻辑”的关键区别在于：机器学习是一类强大的可以从经验中学习的技术，而业务逻辑执行的一直是相同的任务，无论积累多少经验，都不会自动提高，除非开发人员认识到问题并更新软件。

机器学习的关键组件其实只有4个：数据、模型、目标函数、优化算法。

机器学习问题大致可以按如下方式分类：

• 监督学习
  • 回归
  • 分类
  • 标记问题（多标签分类，学习预测不相互排斥的类别的问题）
  • 搜索
  • 推荐系统
  • 序列学习
• 无监督学习
  • 聚类
  • 主成分分析
  • 因果关系和概率图模型
  • 生成对抗性网络
• 强化学习（会与环境互动）

近些年深度学习的发展主要归功于数据、算力的增长以及日益强大的开源infra工具链。

深度学习方法中最显著的共同点是使用端到端训练，通过力大砖飞的思想，取代了传统机器学习管道末端的浅层模型以及劳动密集型的特征工程，实现了一种相对简单、通用、大一统的方法来解决各类机器学习问题。正如《苦涩的教训》所表达的观点：利用人类知识构建AI的方法最终都会失效，基于大规模算力和通用搜索/学习算法的方法才是最有效的。

预备知识

对于数学知识来说，我认为重要性和难度排序是（仅针对入门）：概率统计 > 微积分 > 线性代数。

数据操作

其他内容基本中规中矩，理解广播机制比较重要。python的list相加，其实是拼接操作；而Tensor的相加其实是两个Tensor按元素相加的操作。

当两个Tensor维度不匹配的时候，会从最后一个维度来依次往前匹配，若有一个维度的大小不匹配，就无法相加，除非其中一个维度的大小是1，此时会应用广播机制，将该维度的元素按另一个维度的大小复制相同的份数，再进行计算。例如下面的代码会得到一个全为2的、shape为[4, 6, 3, 3, 6, 7]的Tensor。

t1=torch.ones((    3,1,6,7))
t2=torch.ones((4,6,1,3,1,1))
print((t1+t2).shape)

数据预处理

介绍了怎么借助pandas来做数据清洗。

线性代数

主要介绍如何在pytorch中对标量、向量、矩阵和张量执行各种操作。

除了最基本的操作之外，本节介绍了一个比较重要的操作即通过形如A.sum(axis=1, keepdims=True)的方式进行按某维度求和与非降维求和（便于借助广播机制做下一步计算）。

微积分

介绍微积分中的几个关键概念：导数、偏导数、梯度和链式法则。

单变量函数可以求导数，多变量可以求偏导数。连结一个多元函数对其所有变量的偏导数，可以得到该函数的梯度向量：

所以梯度是一个向量，每个分量是函数对某个变量的偏导数。多元函数的全微分可以看作是梯度向量与自变量位移向量的点积。

链式法则为我们做导数（梯度）计算提供了一种循序渐进的方式，通过将一个复杂函数拆解为一系列简单函数的复合函数，实现将复杂函数的梯度计算拆解为一系列简单函数的梯度计算结果的乘积。

自动微分

主要介绍如何利用pytorch做“自动的”梯度计算。这里的“自动”，指的是在完成计算函数值 的过程（称为前向传播）后，可以通过执行y.backward()反过来把计算过程中涉及到的变量的梯度计算出来（称为反向传播）。通过x.grad可以取到执行反向传播的那个变量对x的梯度，在这个例子中就是对的梯度，也就是。

本节只讲用法，不讲原理。具体的实现过程会在后面的章节中详细介绍。

概率

介绍概率论中的一些基本概念，包括：

• 随机变量的定义
• 联合概率：
• 条件概率：
• 贝叶斯定理：
• 边际化：从包含多个变量的联合概率分布中，通过累加或积分不需要的变量，来计算出单个或部分变量的边缘概率分布的过程
• 独立性： ，两个随机变量是独立的，当且仅当两个随机变量的联合分布是其各自分布的乘积
• 期望与方差

本节介绍的概率论的概念比较基础，想要完全理解后续章节的各类方法的理论推导还远远不够，不过下面我还会对其他的需要的概率知识做补充，虽然不一定能做到非常严密的推导，但至少可以从思维逻辑上讲清楚。

另外还有两个基础概念是本节没有介绍的，这里做个补充：

• 概率质量/密度函数：
  • 概率质量函数(PMF)：专门用于离散型随机变量。它直接表示随机变量取到某个具体数值的真实概率。例如，掷一枚硬币正面朝上的概率。
  • 概率密度函数(PDF)：专门用于连续型随机变量。因为连续变量取某一个精确值的概率为零，PDF描述的是变量落在某个区间内的“概率密集程度”（需要对区间求积分才能得到概率）。
• 累积分布函数(CDF)：表示随机变量的取值小于或等于某一特定数值的概率，等于PMF累加或PDF积分

线性神经网络

线性神经网络是深度学习的基础，真正搞懂它是非常重要的。

机器学习领域中的大多数任务通常都与预测有关。本章介绍了两类线性神经网络：线性回归和softmax回归，分别解决数值预测和分类预测问题。核心目的是：通过最简单的神经网络，讲清楚深度学习的基本概念和流程。

这里的神经网络，指的就是机器学习的4个关键组件之一——模型，而线性神经网络指的就是我们使用的模型是线性的。

如果我们能够得到输出（标签） 关于输入（特征） 的函数，我们就可以说我们能够实现预测。从本质上讲，深度学习就是设计这个函数所使用的模型，并用大量的输入输出数据去拟合函数，得到函数模型的参数的过程。

线性回归

基本假设：线性回归解决数值预测问题，它采用线性的函数模型来进行预测，它的关键假设是：自变量和因变量之间的关系是线性的， 即可以表示为中元素的加权和。

模型：当我们的输入包含个特征时，我们将预测结果表示为 ，或者更简洁的点积形式 。当我们用矩阵 表示整个数据集的个样本时（每一行是一个样本，每一列是一种特征），个样本的预测值向量 。

损失函数：我们的目的是希望通过样本数据，得到最符合样本数据的和。为了衡量“符合”的程度，我们需要定义一个关于和的函数，即损失函数，其中特征、标签、预测值均为参数，我们的目标是寻找一组参数，能最小化在所有训练样本上的总损失：

这里，我们的损失函数是平方损失，即标签与预测值之差的平方。但为什么是平方损失？这是因为我们假设了观测中包含噪声，其中噪声服从正态分布，通过极大似然估计法，参数和的最优值是使整个数据集的似然（通过给定观测到特定）最大的值。最终可以推导出：在高斯噪声的假设下，最小化均方误差等价于对线性模型的极大似然估计。

需要注意的是，我们要优化的问题是损失函数的值，损失函数相当于在模型函数（输出关于输入的函数）基础上用样本数据做了复合，并把函数的自变量从输入变成了模型参数。

优化算法：其实线性回归问题是有解析解的，想象一下：先假设没有观测误差的情况，每一个样本数据就可以列出一个关于和的方程，只要线性无关的样本数量与参数（也就是方程的未知数）相同，就可以得到方程组的唯一解；再假设有观测误差的情况，也就是最小化平方损失，我们合并和到中，只需要设其对的导数为0，就可以得到解析解。但并不是所有的问题都存在解析解，所以我们采用数值方法得到数值解，这种方法叫做随机梯度下降。

梯度的定义是“函数增长最快的方向”，于是我们可以在求出损失函数关于参数和的梯度后，通过每次沿着梯度的反方向修改和的值，就可以不断降低损失函数的值。

为什么沿着梯度的反方向就可以不断降低损失函数的值？我们先设想一维场景：关于的导数表达了随的变化方向和变化率，为正则表示随的增加而增加，为负则表示随的增加而减少，所以随着导数的反方向调整的值意味着朝着减少的方向调整。这个导数扩展到多维场景就是梯度。

softmax回归

softmax回归核心要解决的问题就是：如何将线性模型应用到分类问题中？

假设我们有4个特征和3个可能的输出类别，我们可以用这样的一个线性模型（12个标量来表示权重、3个标量来表示偏置）来表示：

用向量形式可以表达为 。在多样本的情况下（特征个、样本个、类别个）表达为： （特征为 ，权重为 ，偏置为 ）。

但至此我们还存在一个问题：输出怎么对应到预测的分类上？一个简单的想法是：选择一个最大的作为我们预测的那个分类。这个想法是合理的，但现在面临一个新的问题：我们该如何定义损失函数以优化这个模型？

类似于我们在线性回归中的方法，我们自然想到利用极大似然估计推导出损失函数，但首先我们需要将输出转化为概率。

教材中给出的方法是利用softmax运算，将输出转化为预测概率向量（每个分类的预测概率）： ，但并没有解释为什么要用softmax运算而不是其他运算，并且在损失函数推导中没有像线性回归一样基于噪声模型做推导，而是直接使用softmax运算得到的概率进行极大似然估计。

想要解释这个问题，关键还是在于为什么要选softmax运算。由于分类问题要解决的就是给定输入预测其属于各个类别的条件概率，在特征与标签之间存在线性关联的假设下，我们可以从两方面来解释：

• 从噪声角度：如果假设噪声是逻辑分布，条件概率分布就是对输出结果取softmax
• 从信息论中的最大熵原理角度：熵最大的条件概率分布就是对输出结果取softmax

所以并不是在softmax回归问题中没有噪声，而是对输出的数值结果进行softmax运算转化为概率的过程就已经蕴含了对噪声的假设，是将“连续误差”的假设转换为了“类别概率（离散选择）”的假设。

我们再换个角度来理解。我们依然采用与线性回归一样的极大似然估计的方式：让在给定的特征观测到特定标签的似然最大化，这在分类问题上等于是最大化整个数据集上的预测正确的概率乘积。给定的特征观测到特定标签的概率是什么？取决于噪声是怎样的。如果没有噪声，就是在求线性模型的解析解（或是其他模型的插值问题）而非回归问题。在噪声是逻辑分布的假设下，这个概率就是。极大似然估计的过程就是在该噪声假设下寻找最优参数的过程。

因此，基于softmax后的概率进行极大似然估计，我们很容易得到极大似然估计等价于最小化损失函数：

该损失函数也被称为交叉熵损失。从信息论的角度理解交叉熵的含义：只要预测概率分布与真实概率不一样，就一定比真实概率的熵大，所以我们希望最小化交叉熵。交叉熵不是“预测分布自身蕴含的信息量”，而是“用预测分布去适配真实数据时，产生的额外代价/浪费”。

另外注意一个工程上的点，在简洁实现中，使用了nn.CrossEntropyLoss作为损失函数，它内部做了softmax运算，所以我们无需针对网络的输出层单独手动做softmax运算。

多层感知机

多层感知机原理

线性意味着单调假设： 任何特征的增大都会导致模型输出的增大（如果对应的权重为正）， 或者导致模型输出的减小（如果对应的权重为负）。因此，线性模型是一个很强的假设。

由于线性模型无论叠加多少次线性运算永远都是线性模型，为了让模型能够进行非线性的预测，我们可以通过在线性模型中引入非线性层来克服线性模型的限制，使其能处理更普遍的函数关系类型。

在输入层和输出层中间的层叫做隐藏层，我们只要添加非线性的隐藏层即可，最简单的方式是，针对线性层的输出结果应用一个非线性的激活函数，就可以将该层转变为非线性层。最常见的激活函数是ReLU函数。

模型选择、欠拟合和过拟合

• 欠拟合：训练误差和验证误差都很严重，模型不能降低训练误差。这可能意味着模型过于简单（即表达能力不足）。
• 过拟合：训练误差明显低于验证误差。模型倾向于记住样本的数据规律，泛化性可能会变差。但过拟合并不总是一件坏事，关键还是看验证误差的情况。

是否过拟合或欠拟合可能取决于模型复杂性和可用训练数据集的大小。

接下来教材使用了一个多项式回归的例子来说明模型复杂性与欠拟合和过拟合的影响：对于一个三阶多项式下得到的样本数据，使用线性函数拟合会欠拟合，使用高阶多项式函数拟合会过拟合。

权重衰减

为了解决过拟合的问题，我们引入权重衰减这一正则化模型的技术。这是一种可以在不去收集更多的训练数据，也不用调整模型复杂性来缓解过拟合的一种有效手段。

经典泛化理论认为，为了缩小训练和测试性能之间的差距，应该以简单的模型为目标。权重衰减是最广泛使用的正则化的技术之一，通常被称为正则化，这项技术通过函数与零的距离来衡量函数的复杂度，希望通过一种手段让训练后的模型尽可能简单，即比较小。

想要实现这一点，最常用方法是将其范数作为惩罚项加到最小化损失的问题中，将原来的训练目标最小化训练标签上的预测损失，调整为最小化预测损失和惩罚项之和： 。

接下来教材使用了高维线性回归的例子（200维的线性模型、20个样本的小训练集）演示了过拟合如何产生以及如何通过权重衰减来缓解。

但是，我们还没有讨论一个问题：为什么我们要选择正则化而不是正则化？教材中的解释是：正则化对权重向量的大分量施加了巨大的惩罚，使得我们的学习算法偏向于在大量特征上均匀分布权重的模型，在实践中，这可能使它们对单个变量中的观测误差更为稳定；惩罚会导致模型将权重集中在一小部分特征上，而将其他权重清除为零，这称为特征选择。相比特征选择会离散地决定某些特征要还是不要，权重衰减为我们提供了一种连续的机制来调整函数的复杂度。

但是为什么惩罚会有这样的效果？这是因为：无论权重本身是大是小，惩罚都会施加一个大小恒定、方向始终指向0的梯度；而惩罚的拉力随权重成正比衰减。

此外，我们还可以从概率的角度来解释正则化的科学性。教材中最后一题提到了基于贝叶斯公式的后验计算：后验 = 似然 * 先验 / 边缘似然（证据）。详细解释如下：

之前我们在推导损失函数时，用的都是极大似然估计。如果我们从后验的角度去考虑，根据贝叶斯公式，的后验概率为：

极大后验估计（最小化负对数后验估计）相比极大似然估计，损失函数会多出来一项（其中 与无关，所以我们使用正比而忽略它）。因此我们可以说：正则化等价于给权重设定特定的先验分布。也就是说：

• 不带正则的训练（只最小化损失） = 极大似然估计（MLE）：最大化 ，完全相信观测数据，对参数没有任何预设，容易被训练数据里的噪声带偏，也就是过拟合。
• 带正则的训练（损失 + 惩罚项） = 极大后验估计（MAP）：最大化 ，既参考观测数据，也保留我们对参数的先验常识。

因此，正则化不是强行惩罚大权重，而是在数据之外，引入我们对模型参数的合理信念。我们对权重设定的特定的先验分布，决定了我们将采用什么样的正则化：

• 权重衰减的平方惩罚，本质对应给权重加零均值高斯先验：我们默认“所有权重都不该太大”，用高斯分布把这个信念量化，就得到了权重衰减
• 正则的绝对值惩罚，本质对应给权重加拉普拉斯先验：我们默认“只有少数特征重要、大多数权重应该是0”，用拉普拉斯分布把这个信念量化，就得到了稀疏正则。

对于网络有多层的情况，我们只需要让惩罚项是所有之和即可。这是因为我们假设网络中每一层的权重是相互独立的，由于多个独立事件同时发生的联合概率等于各自概率的乘积，因此在极大后验估计中就会变成的乘积，在取对数后就会变成求和项。

暂退法（Dropout）

本节进一步讨论过拟合的问题。

线性模型的泛化性很好，但线性模型没有考虑到特征之间的交互作用，只能表示一小类函数，所以必须引入非线性的激活函数，但这样一来，即使我们有比特征多得多的样本，深度神经网络也有可能过拟合。

上一节已经讨论了，经典泛化理论认为我们应该以简单的模型为目标，并引入了权重衰减，它能够起作用，是因为参数的范数代表了一种有用的简单性度量（基于奥卡姆剃刀，简单模型先验概率大）。简单性的另一个角度是平滑性，即函数不应该对其输入的微小变化敏感，为输入添加随机噪声应该对结果基本无影响。

那么关键的挑战就是如何注入这种噪声，但无论怎么注入噪声，预期都是 ：

• Bishop是将高斯噪声添加到线性模型的输入中，恰好会推导出与权重衰减相同的形式
• 标准暂退法正则化中，每个隐藏层以暂退概率随机丢弃一些参数不参与本次训练，剩余参数等比例放大，保持总期望不变：

暂退法的这一策略基于这样的朴素想法：暂退法会破坏共适应性，强迫特征具备更强的健壮性。

由此，我们可以对比一下两种防止过拟合的策略，并将损失函数的推导过程也加入对比：

此外，通过研究习题中的问题，我们还可以得出以下结论：

• 越靠近输出的深层抽象特征层，越适合设置更高的dropout概率，浅层底层特征层适合更低的丢弃率，避免有效基础特征大量丢失
• 权重dropout相对于标准激活dropout，有明显短板：无法打破神经元协同适应，还会让优化的稳定性变差（梯度方差变大）
• 标准dropout是在激活函数后dropout而非先dropout再应用激活函数，因为dropout的目的是对隐藏层特征进行随机失活，尽管在ReLU激活下两者数学等价

前向传播、反向传播和计算图

本节详细介绍了梯度是怎么计算的。其关键在于：

• 前向传播：在计算目标函数的过程中构建出计算图
• 反向传播：再通过反向遍历计算图把目标函数对图中涉及到的变量的梯度依次通过链式法则计算出来。

---
config:
  look: handDrawn
---
graph LR
    x["$$\mathbf{x}$$"] --> mul1(("$$\times$$"))
    W1["$$\mathbf{W}^{(1)}$$"] --> mul1
    mul1 --> z["$$\mathbf{z}$$"]
    z --> phi(("$$\phi$$"))
    phi --> h["$$\mathbf{h}$$"]
    h --> mul2(("$$\times$$"))
    W2["$$\mathbf{W}^{(2)}$$"] --> mul2
    mul2 --> o["$$\mathbf{o}$$"]
    o --> loss(("$$l$$"))
    y["$$y$$"] --> loss
    loss --> L["$$L$$"]
    L --> add(("$$+$$"))
    add --> J["$$J$$"]
    
    W1 --> l2(("$$\mathcal{l}_2$$"))
    W2 --> l2
    l2 --> s["$$s$$"]
    s --> add
    
    %% 普通节点：纯白背景
    classDef white fill:#ffffff,stroke:#333,stroke-width:1.5px,color:#000,font-size:20px
    class x,z,h,o,y,s,L,J white
    
    %% 权重方块：蓝色填充
    classDef weight fill:#66bfff,stroke:#333,stroke-width:1.5px,color:#000,font-size:20px
    class W1,W2 weight
    
    %% 运算圆圈：浅蓝色填充
    classDef op fill:#b2d9ff,stroke:#333,stroke-width:1.5px,color:#000,font-size:20px
    class mul1,phi,mul2,l2,loss,add op

用计算机的语言一句话讲反向传播的计算过程：先把图中所有边反向，然后找目标函数能够抵达某个参数的所有路径，每个路径用链式法则一步步求中间变量的梯度并相乘得到对参数的梯度，最后把所有路径计算出来的梯度求和就是总梯度。

用纯数学简单理解这个思路：

1. 我们希望对自变量求全导数
2. 含有自变量的函数可能有很多，只要有路径能够到达自变量，就要把这条路径计算出的导数加进来
3. 每个路径上做的都是一次复合函数求导

值得一提的是，反向传播的这种计算方式，天然是计算量更小的一种方式，其通过计算量较小的向量-雅可比乘积（VJP）完成梯度计算，而无需构造完整雅可比矩阵，也无需计算雅可比矩阵的乘法，下面解释一下：

我们考虑多层感知机中的某一层，即一个从维向量映射到向量的函数 ，其导数是一个雅可比矩阵（分母布局）：

由复合函数的链式求导法则可知，多层神经网络中间层的输出对输入的导数就是多个上述雅可比矩阵的乘积。但是，一个完整的神经网络的总输出和输入并不是都是向量，而是标量（目标函数）和向量（特征），这意味着最终求出来的梯度会是个向量。换句话说，我们想求的是（其中 ），是向量-雅可比乘积，而不是一个个雅可比矩阵和雅可比矩阵的乘积，这无需矩阵乘法，也并不需要完整构建矩阵（因为可以在实际运算时拆分成多个向量与向量乘积）。

当然，我们的目的是求梯度后做参数更新，所以要在链式求导计算到需要更新参数的那一层时，将这一层输出对输入的求导转为输出对参数的求导。典型地，当这一层参数 时，该导数就是一个雅可比张量，最终的梯度就是，但整个过程仍然无需完整构造矩阵（张量）或是执行矩阵（张量）乘法，只需向量-雅可比矩阵（张量）乘积。

让我们再来看看pytorch中真实的生产环境的计算图是什么样的：

import torch
import torchviz
from torch import nn

def l2_penalty(W1, W2):
    return torch.sum(W1.pow(2)) + torch.sum(W2.pow(2)) # 为了计算图展示的简洁性，省略常数计算
# 为了计算图展示的简洁性，不使用手动实现的损失函数
# def cross_entropy(O, y):
#     def softmax(X):
#         X_exp = torch.exp(X)
#         partition = X_exp.sum(1, keepdim=True)
#         return X_exp / partition
#     y_hat=softmax(O)
#     return - torch.log(y_hat[range(len(y_hat)), y])
cross_entropy = nn.CrossEntropyLoss(reduction='none')
def relu(X):
    a = torch.zeros_like(X)
    return torch.max(X, a)
def net(X):
    X = X.reshape((-1, num_inputs))
    H = relu(X @ W1)
    return H @ W2

batch_num, num_inputs, num_outputs, num_hiddens = 20, 784, 10, 256

W1 = nn.Parameter(torch.randn(num_inputs, num_hiddens, requires_grad=True) * 0.01)
W2 = nn.Parameter(torch.randn(num_hiddens, num_outputs, requires_grad=True) * 0.01)

X = torch.randn(batch_num, num_inputs)
y = torch.randint(num_outputs, (batch_num,))

O = net(X)
L = cross_entropy(O, y)
s = l2_penalty(W1, W2)
J = L + s

# 因为反向传播完了计算图就会销毁，所以需要retain_graph
# 不过这里不进行反向传播也完全可以，因为计算图是前向传播时构建的
J.sum().backward(retain_graph=True)

graph = torchviz.make_dot(
    J,
    params={"W1": W1, "W2": W2},
    show_attrs=True,
    show_saved=False,
)
graph.graph_attr['rankdir'] = 'LR'
graph.render("compute_graph", format="svg")

在pytorch的计算图中，只有参数、目标值和算子。中间张量值（包括输入张量）会被存放在算子中，这是因为只有在进行算子运算时才需要这些张量。在pytorch中前向传播与反向传播的具体操作如下：

• 按照提供的计算过程一步步计算出目标值，在过程中只要有参与计算的张量的requires_grad=True（例如参数），就会像传染一样，其后的计算就会纳入计算图构建，计算出的中间张量（或目标张量）会写入grad_fn属性，表示计算该张量所需的算子，例如图中的Mm、Pow、Maximum（用于激活函数）、LogSoftmax等算子
• grad_fn有两个重要属性：grad_fn.saved_tensors表示反向传播计算导数时所需要的张量，grad_fn.next_functions表示要把当前节点计算好的梯度往哪里传，它指向下一个算子
• grad_fn作为入口函数，在当前算子计算完梯度后，通过grad_fn.next_functions找下一个算子并将梯度传入，下一个算子用上游梯度结合算子自身的导数计算逻辑计算VJP，得到新的梯度，重复以上过程
• 直到传播到AccumulateGrad算子，这是一个特殊的算子，表示计算图至此已经抵达叶子节点，该算子会将最终梯度写到叶子张量的.grad属性中

pytorch为我们把几乎所有常见的运算做好了算子封装，如果想要自己实现，可以通过继承torch.autograd.Function并实现forward和backward两个函数即可，例如下面这个矩阵乘法算子：

class MyMatmul(torch.autograd.Function):
    @staticmethod
    def forward(ctx, W, X):
        # 把反向需要用到的输入存起来
        ctx.save_for_backward(W, X)
        Z = W @ X
        # 返回顺序必须和backward的输入顺序一致：Z对应grad_output
        return Z

    @staticmethod
    def backward(ctx, grad_output):
        # 取出前向时存的值
        W, X = ctx.saved_tensors
        # 链式法则分别求对w和x的梯度
        grad_W = grad_output @ X.T
        grad_X = W.T @ grad_output
        # 返回顺序必须和forward的输入顺序一致：W对应grad_W，X对应grad_X
        return grad_W, grad_X

使用apply函数即可执行算子计算，例如MyMatmul.apply(X, W1)。

数值稳定性和模型初始化

本节介绍数值稳定性的两个重要问题：梯度消失和梯度爆炸。为了解决这两个问题，除了模型的设计（例如非线性激活函数的选择），模型初始化是非常重要的一环。

随机初始化本身是保证在进行优化前打破对称性的关键，以防止模型表达能力受限。

在模型初始化的具体策略方面，教材介绍了一种叫做Xavier初始化的方式：

对于一个线性全连接层输出，假设权重具有零均值和方差，输入具有零均值和方差，可计算出输出的均值是0，方差是。为了数值稳定性，我们希望输出与输入具备同样的均值和方差，因此我们希望 。我们再考虑反向传播，我们也希望梯度方差在反向传播中保持稳定，即上游梯度方差与本层计算出的梯度方差保持一致，经计算可以得出只有 才满足。这样一来就产生了矛盾，前向传播和反向传播数值稳定性所要求的条件不同，不存在一个权重的初始化方法能让它的同时满足前向与反向的方差条件。

因此Xavier初始化采取了一种折中的方案，让 ，这在实践中被证明是有效的。它实现了尽可能地让输出的方差不受输入数量的影响，梯度的方差不受输出数量的影响。

环境和分布偏移

本节核心讨论训练数据的问题。如果数据本身有偏（与真实环境分布不符，训练集和测试集并不来自同一个分布），对模型的影响很可能是致命的。此外，通过将基于模型的决策引入环境，可能会影响环境，进而破坏模型。

首先是讨论了三种训练数据中的分布偏移问题：

• 协变量偏移：特征的分布与真实不符（例如图片猫狗分类问题现实中新出现的大量二次元猫狗图片），但给定特征依然正确对应标签
• 标签偏移：标签的分布与真实不符（例如症状->疾病诊断中不同疾病的流行率），但给定的标签依然正确对应特征（症状还是对应疾病，但如果训练集中某罕见病的样本很多，稍模糊一些的症状会倾向于预测为样本多的罕见病）
• 概念偏移：标签的定义发生变化（例如精神疾病的诊断标准、时尚与复古的定义等）

接下来是怎么进行分布偏移纠正：

• 协变量偏移纠正：训练模型用的数据分布，和实际测试时遇到的数据分布不一样，那我们就针对每个样本加权，权重是真实分布与训练数据分布之比 ，让真实分布里常见的样本权重变大、训练集里泛滥但真实场景少见的样本权重变小（将权重应用到该样本计算出的loss上）。权重的获取方法是：
  • 抽取训练集和测试集的相同数量的样本数据训练一个二分类器（逻辑回归）来区分一张图是来自训练集还是测试集。注意：这里我们可以使用测试集中的数据的原因是，我们只使用了测试集的特征，并没有使用它的标签，这个二分类器所使用的标签是我们人为构造的（来自训练集还是测试集）。
  • 针对训练集的所有数据用分类器判断样本来自测试集的概率，而来自训练集的概率就是 ，从而反推出权重。
  • 这个方法成立的前提是测试集中出现的每个样本，在训练集中都有出现。
• 标签偏移纠正：同样采用样本加权的方法，某个标签在真实场景中越常见，权重就越大。权重 的获取方法是：
  • 可以直接通过训练集标签分布统计得到，而标签的真实分布无法直接得到。
  • 基于已训练好的在训练集上表现良好的模型，使用验证集（也来自训练分布）计算混淆矩阵，表示真实标签为而模型预测为的样本数量所占的比例。由于标签相比特征的量级小了很多，这个矩阵规模不大。
  • 如果标签偏移假设成立（给定类别，特征的分布在训练集和测试集是一样的），那么在相同模型下用验证集（也来自训练分布）和测试集计算出的就是相同的，于是有 ，表示：分类器的犯错模式*测试集的真实标签分布=观测到的模型的平均预测分布。
  • 用测试集跑出平均预测分布，解出 。
  • 基本逻辑可以理解为：用验证集计算出的分类器的犯错模式，再在测试集上反推出测试集的真实标签分布。
• 概念偏移纠正：只能从零开始收集新标签和训练，但在实践中极端的偏移是罕见的，通常概念的变化总是缓慢的，因此我们可以使用新数据更新现有的网络权重，而不是从头开始训练。

以上为分布变化的理论知识，接下来教材介绍了几种机器学习问题形式化的一些实际问题类型：经典的批量学习、基于预测决策的应用结果来优化模型的在线学习、有限行动下的老虎机问题（在线学习的特例）、环境会记住之前动作的控制类问题、强调如何基于环境而行动的强化学习、会随着时间的推移而发生变化的问题等。

最后还提到了机器学习中的公平、责任和透明度，表达出精度不一定是评估模型好坏的标准，这是因为将预测转化为行动时，我们通常会考虑到各种方式犯错的潜在成本敏感性。另外还提到了“失控反馈循环”现象，我们要避免发生这种预测-决策-环境的这种坏的正向反馈循环。

实战Kaggle比赛：预测房价

本节通过一个实际的例子来应用之前学过的知识。本节在实战中应用到了K折交叉验证的技术。

• 通常的训练过程：将数据集拆分成训练集和验证集，用训练集训练、用验证集计算误差，以观察模拟是否会过拟合，选择模型和调整超参数。但是这类粗暴的拆分方法，在数据量小的情况下，受数据划分的运气影响较大。
• K折交叉验证：通过多次划分，分别训练模型，对误差结果取平均，避免了评估结果的偶然性与波动。本质上是一种“多次测量取平均”的方法。

深度学习计算

本章深入讨论深度学习计算的关键组件：模型构建、参数访问与初始化、设计自定义层和块、将模型读写到磁盘，以及利用GPU实现显著的加速。基本上都是在讲pytorch怎么使用这些深度学习的基本元素。

层和块

层就是神经网络中的一层，例如线性层nn.Linear；而块是神经网络中一个或多个层的组合，是一个抽象概念，主要目的是便于组合成一个逻辑结构，以通过简洁的代码实现复杂的神经网络，例如nn.Sequential。

本节主要介绍如何自定义块。自定义块只需要继承nn.Module，实现__init__和forward即可。由于计算图是前向传播过程中动态生成的，所以forward中是可以执行代码实现控制流的。

class MLP(nn.Module):
    def __init__(self):
        super().__init__()
        # 层实例直接保存在类实例（self）中，框架会自动注册进self._modules，使得框架可以拿到层的参数
        self.hidden = nn.Linear(20, 256)
        self.out = nn.Linear(256, 10)

    def forward(self, X):
        return self.out(nn.functional.relu(self.hidden(X)))

参数管理

本节介绍怎么访问参数、初始化参数，以及参数绑定（在多个层间共享参数）。

访问参数很简单，先直接下标访问到对应层，然后取层的相关参数即可，例如线性层的.weight、.bias。但此时获取的是parameter，可以通过.weight.data获取到普通张量（做运算不会记录计算图，不累积梯度），.weight.grad获取梯度。

通过.named_parameters()可以遍历所有的参数，例如net[0].named_parameters()，返回值是一个由(name, param)组成的Iterator。

可以通过.state_dict()直接获取所有参数组成的dict，其中key的命名方式与.named_parameters()返回的元组中的name是一致的。这让我们可以以一种字符串表达的形式获取参数，例如net.state_dict()['2.bias'].data。

初始化参数，我们可以定义一个my_init函数，然后net.apply(my_init)即可。

至于参数绑定，我们只需要在定义net时，针对需要共享参数的块，使用相同的nn.Module实例即可。

延后初始化

所谓延后初始化，就是在没有指定输入维度的情况下先搭建起网络结构，在首次前向传播时初始化，其核心目的是简化开发。

中文版教材中没有介绍pytorch的方法，但实际上是支持的。具体使用如下：

import torch
from torch import nn

net = nn.Sequential(nn.LazyLinear(256), nn.ReLU(), nn.LazyLinear(10))
print(net)
X = torch.rand(100, 20)
net(X)
print(net)

# 会得到以下输出
# Sequential(
#   (0): LazyLinear(in_features=0, out_features=256, bias=True)
#   (1): ReLU()
#   (2): LazyLinear(in_features=0, out_features=10, bias=True)
# )
# Sequential(
#   (0): Linear(in_features=20, out_features=256, bias=True)
#   (1): ReLU()
#   (2): Linear(in_features=256, out_features=10, bias=True)
# )

在使用nn.LazyLinear的情况下，只需要定义输出大小即可，输入可以省略。事实上我们需要省略的其实只有第一层（因为通常只有第一层的输入不知道），但只要把层定义成lazy的，尽管可以通过前面层的输出大小推断出输入大小，也依然会在第一次前向传播时才初始化。

自定义层

本节主要介绍如何自定义层。下面的代码自定义了一个带ReLU的全连接线性层。

import torch
import torch.nn.functional as F
from torch import nn

class MyLinear(nn.Module):
    def __init__(self, in_units, units):
        super().__init__()
        self.weight = nn.Parameter(torch.randn(in_units, units))
        self.bias = nn.Parameter(torch.randn(units,))
    def forward(self, X):
        linear = torch.matmul(X, self.weight) + self.bias
        return F.relu(linear)

另外，pytorch的线性层实现中，参数采用输出通道在前的存储方式，这样性能更好。

读写文件

张量读写：

• 写：torch.save(x, 'x-file')
• 读：x2 = torch.load('x-file')

但其实它们也能读写内置类型与张量的组合，甚至模型也可以。但是load归load，想要加载后能正常使用，前提是load的变量所需要的各种定义在代码中都有。张量和pytorch的预定义层都是引入了pytorch就自动有定义了，所以能直接load，但自定义的块和层就不一定了。

所以，对于保存模型的场景，建议是保存参数权重（state_dict），而不保存整个模型。我们可以通过如下代码保存和恢复参数：

# 保存
net = MLP()
params = net.state_dict()
torch.save(params, 'mlp.params')

# 恢复
params2 = torch.load('mlp.params')
net2 = MLP()
net2.load_state_dict(params2)

简单来说，就是通过前面介绍的方式，调用模型获取所有参数的方法，然后保存变量；恢复时加载变量，定义好网络，再调用模型的恢复参数的方法。

GPU

利用GPU加速计算，其核心是将张量的计算放到显存并利用GPU完成计算操作。但两个张量计算的前提是它们必须在同一个设备上。下面以代码形式整理一下所有常见的操作：

import torch
from torch import nn

# 基本操作：查看GPU的数量
torch.cuda.device_count()
# 基本操作：获取device，用于下面的传参；cuda等价于cuda:0
torch.device("cpu"), torch.device("cuda"), torch.device("cuda:1")
# 基本操作：查看张量所在device
X.device

# 张量操作：定义张量时指定device
X = torch.ones(2, 3, device=torch.device("cpu"))
# 张量操作：转移数据到其他device（不会修改原变量，所以必须赋值）
X = X.to(torch.device("cuda"))
X = X.cuda(0)

net = nn.Sequential(nn.Linear(3, 1))
# 模型操作：将模型参数转移到其他device，原地生效
net.to(torch.device("cuda"))
net.cuda()

卷积神经网络

从本章开始，将介绍一些全连接层以外的模型结构。

从全连接层到卷积 & 图像卷积

卷积层的发明，主要来源于图像领域的机器学习问题。

核心问题：图像数据过于庞大，不可能用全连接层来实现，过多的参数会导致无法训练

关键思路：基于图像数据特性和要解决的问题的特性来做简化，减少参数及其计算

具体的特性是：

• 平移不变性：通常我们针对图像想做的事情是识别，而图像中某一块区域的像素所代表的基本含义在别的位置不会产生变化（例如狗还是狗），即使有变化也是更高级的含义而非基本含义产生变化（高级含义可以后续用其他类型的层来表达）
• 局部性：神经网络的前面几层应该只探索输入图像中的局部区域，而不过度在意图像中相隔较远区域的关系，不需要每个像素之间都有参数表达关系

依据一些假设来确定模型/目标函数等机器学习组件设计的过程，我们称之为归纳偏置。

基于这两个朴素的想法，我们想到利用信号处理领域常见的卷积运算来表达。其实我们完全没必要理解数学定义上的卷积，在机器学习领域使用的卷积运算只是采用了类似的思想。严格来讲深度学习所使用的卷积运算实际上叫互相关运算。

卷积层核心做的事情是，针对每个输入像素，使用该像素周围一圈的像素进行加权求和，作为该位置的输出。其中加权的权重叫做卷积核，它同时也决定了周围一圈的像素取多大范围。这个操作本质上类似于滑动加权求和运算。

用数学表达就是：每个输出的值，等于在输入周围按卷积核大小取元素出来，然后与按元素相乘求和。即：

但图像每个像素的值并不是一个标量而是一个向量（例如颜色），卷积运算得到的隐藏层输出往往也不是只有一个特征（每个像素周围一圈的像素所组成的图像往往不能用单一的特征来描述，对于每一个空间位置，我们想要采用一组而不是一个隐藏表示）。因此，我们需要在输入中增加一个维度表达不同颜色通道，输出中也增加一个维度表达多个隐藏表示（我们对这两个新增加的维度用通道来称呼）。相应地，卷积核就需要加两个维度。于是，卷积计算将会变成下式：

填充和步幅

如果我们按上述定义，输入的大小是大于的（先不考虑通道），因为只要卷积核不是 ，那么在图像边缘部分就涉及到需要对不存在图像的部分做卷积运算的问题，如果忽略这些位置，输出的尺寸就会小于输入。如果我们对输入的边缘做填充（例如填充0），此时输入和输出就应该具有相同大小。因此，填充可以增加输出的高度和宽度。

除了填充我们还可以调整步幅。简单来讲步幅就是卷积核所应用到输入上的间距，也就是应用一次卷积核计算出结果后，计算下一个结果时要在输入上横向和纵向移动的距离。前面我们所介绍的都是步幅为1的情况，在应用值为stride的步幅的情况下，我们可以让输出以stride为比例缩减。因此，步幅可以减小输出的高和宽。

总的来说，填充和步幅可用于有效地调整数据的维度，对于输入尺寸为 、卷积核尺寸为 、填充大小为 （指上下共填充、左右共填充）、步幅大小为 的情况，输出形状为： 。

注意：pytorch中nn.Conv2d传入的padding值是上下或左右各填充的大小，而不是共填充的大小（是上面和的一半）。

多输入多输出通道

本节重新讨论通道的问题，在有个输入通道和个输出通道的情况下，卷积核形状是 。

多输入多输出通道下互相关的实际运算逻辑为：针对每个输出通道，获取所有输入通道以对应的卷积核计算出结果并求和。简单讲就是for(每个输出通道)计算sum(每个输入通道对应的卷积结果矩阵）。操作后会将输入通道维度消掉，输出通道维度保留。

特别地，如果是卷积层是 的，相当于我们在每个像素位置应用全连接层（每个像素位置的输入通道数据线性变换成输出通道数据）。

汇聚层

汇聚层与卷积层类似，做的仍然是互相关运算，但是汇聚层没有参数，所做的事情从卷积层的输入与参数进行按元素相乘并求和，改为了对输入参数求最大值和求平均，分别称为最大汇聚层和平均汇聚层。汇聚层的主要优点之一是减轻卷积层对位置的过度敏感。

• 平均汇聚：对窗口内所有像素做算术平均，平滑局部特征，弱化高频噪声，能够保留区域的整体信息，对全局均值偏移更不敏感，但会模糊边缘细节
• 最大汇聚：取窗口内像素最大值，只保留局部最显著的激活特征，能更好保留纹理、边缘这类关键特征，对特征轻微平移更不敏感，但容易放大噪声、出现过拟合

两者优化目标不同：平均汇聚侧重区域整体信息平滑，最大汇聚侧重局部最强特征筛选。

此外，汇聚层的输出通道数与输入通道数相同，也就是说会保留原有的通道，不会像卷积层一样在通道上对输入进行汇总。

卷积神经网络（LeNet）

本节介绍最早发布的卷积神经网络之一LeNet，它发明于上世纪90年代。其网络结构如下：

net = nn.Sequential(
    nn.Conv2d(1, 6, kernel_size=5, padding=2), nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2),
    nn.Conv2d(6, 16, kernel_size=5), nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2),
    nn.Flatten(),
    nn.Linear(16 * 5 * 5, 120), nn.Sigmoid(),
    nn.Linear(120, 84), nn.Sigmoid(),
    nn.Linear(84, 10)
)

现代卷积神经网络

本章按时间顺序介绍现代的卷积神经网络架构，这些神经网络是将人类直觉和相关数学见解结合后，经过大量研究试错后的结晶。

深度卷积神经网络（AlexNet）

相比之前盛极一时的特征提取方法，另一组研究人员认为特征本身应该被学习。在合理地复杂性前提下，特征应该由多个共同学习的神经网络层组成，每个层都有可学习的参数。

尽管一直有一群执着的研究者不断钻研，试图学习视觉数据的逐级表征，然而很长一段时间里这些尝试都未有突破。深度卷积神经网络的突破出现在2012年，突破可归因于数据和硬件这两个关键因素。

使用块的网络（VGG）

网络中的网络（NiN）

LeNet、AlexNet和VGG都有一个共同的设计模式：通过一系列的卷积层与汇聚层来提取空间结构特征，然后通过全连接层对特征的表征进行处理。

含并行连结的网络（GoogLeNet）

批量规范化

训练深层神经网络是十分困难的。批量规范化（Batch Normalization）是一种流行且有效的技术，可持续加速深层网络的收敛速度。再结合后面的残差块，批量规范化使得研究人员能够训练100层以上的网络。

BN层在训练时做如下计算：

其中，

简单来说就是针对一个batch的输入数据中的每一个特征做归一化。

• 线性层：用batch中所有样本计算每个特征的均值和方差然后做归一化
• 卷积层：类似线性层，但是只把通道作为特征，对所有样本和样本中所有像素位置一起算均值和方差（因为同一通道全部空间像素是同类空间特征，H/W只是位置，不算独立特征）

而对于推理过程来说，会使用在训练过程中通过批次间指数加权平均得到的近似的全局均值和方差，对输入做归一化，进行下一步计算：

BN层通常加在激活函数前。实践表明：加BN后损失下降更平稳、梯度不会剧烈震荡、能开更大学习率。2018年后续研究证明BN真正价值是平滑优化损失曲面，而非稳定层内分布。

残差网络（ResNet）

批量规范化解决了深层神经网络收敛速度的问题，但它只能缓解，最根本的还是模型本身的设计。ResNet通过残差块的设计在该问题上取得了质的突破，对如何建立深层神经网络产生了深远的影响。

ResNet的核心思想源于这样的思考：当我们要添加一层新网络，如果新增层可以被训练成恒等映射 ，那么新网络的输出完全等于旧网络，效果不会变差，至少和原模型一样强。

简单来说就是：给网络加深时，只要新增层能学习 “什么都不做”，加深网络就不会带来性能退化，深层网络理论上一定不差于浅层。

然而，深层网络堆叠几十上百层后，优化器很难找到一组权重，让多层叠加后抵消所有变换。ResNet采用残差结构，将学习目标改为 ，强制让恒等映射成为简单解。此时模型只需要让残差分支 就能满足 。无论叠加多少残差块，每个残差块都可以选择输出0，整体网络等价于浅层模型，所以只会更好不会更差。

残差块示意图：

稠密连接网络（DenseNet）

DenseNet在某种程度上是ResNet的逻辑扩展。在跨层连接上，不同于ResNet中将输入与输出相加，DenseNet在通道维上连结输入与输出。稠密块中每一层都连接在它前面的所有层的输出。

以泰勒展开式做类比，ResNet中通过 将分解为两部分：一个简单的线性项和一个复杂的非线性项。DenseNet则是把这个分解做得更彻底，将块中所有的输出都作为输入传递给后面的层，具体的方法是直接使用torch.cat。

相比ResNet，DenseNet这样做的好处是拓宽了特征存储与复用的上限（而不是只能用上一层的输入），并且能使用到块中前面每个层的原始输出（而不是上一层输出与输入混合后的结果）。

此外，DenseNet没有改变ResNet让恒等映射成为简单解的性质。DenseNet新增层只需要把自身卷积权重、偏置全部训练为0，输出一组全零特征通道拼接在原有特征后方，即可使得函数性质不变。这是因为全零通道不携带任何有效信息，下游所有运算结果和完全没有这一层时完全一致，因此拥有和ResNet一样的“新增网络层不会导致性能退化”的保底能力。通道数量只是存储空间维度，携带全零的额外通道不会改变网络任何输出结果。

循环神经网络

本章介绍的循环神经网络（recurrent neural network，RNN），主要服务于序列信息处理。循环神经网络通过引入状态变量存储过去的信息和当前的输入来预测当前的输出。

序列模型

前面学习了数值预测、分类预测、图像分类预测等问题的建模方法，现在讨论序列模型。时间序列、文本序列都属于序列，序列模型解决的就是这些序列的预测问题。

序列模型的数学本质是对序列的联合概率分布建模，标准数学定义是：输入任意长度序列，输出这个序列的联合概率分布，也就是。

如果我们有了这样的一个模型，能够知道任意序列的联合概率分布，我们就可以通过该模型做预测：给定，寻找使得最大的那个即可。

但在实际的训练和推理中，我们不会直接预测，而是预测条件概率 。这是因为，根据概率链式法则，联合概率可以拆解成条件概率乘积：

于是问题被转化为条件概率：

• 对于训练来说：对每个位置最大化条件概率，等价于最大化整条序列的联合概率
• 对于推理来说：我们真正需要的是用条件概率逐步构造出完整序列，而不是求整条序列的联合概率

为了训练这样的模型，我们还需要一些统计工具，这是因为，随着数据的积累，输入序列长度会不断增加，我们需要一个近似方法来使这个计算变得容易处理。常见的策略有：

• 自回归模型：假设我们不需要完整序列，只需要最近长度为的时间跨度的序列数据。特别地，如果这种假设是近似精确的，我们就称序列满足马尔可夫条件，如果 ，我们称之为一阶马尔可夫模型。
• 隐变量自回归模型：保留并持续更新对历史序列的总结，并以此来估计。

需要说明的是，以上策略都建立在一个假设之上：尽管随时间推移具体的观测值会不断发生变化，但支配整个序列生成和演化规律的底层物理或统计学规律（即系统动力学）保持不变。否则我们得到的模型也只能描述过去已知序列，不能预测未来。

随着我们对预测时间的增加，会造成误差的快速累积和预测质量的极速下降，这是序列预测的一个重大挑战。

文本预处理

文本是序列数据的一种最常见的形式之一。本节基于一些语料库，展示如何针对文本数据做预处理，以将其组织成文本序列。

简单来讲就是将文本拆分为词元，构建词表将词元字符串映射为数字索引，并将文本数据转换为词元索引以供模型操作。

语言模型和数据集

本节主要介绍语言序列这种特殊的序列在建模时需要注意的问题，以及数据集的处理方式。

语言模型预测的关键目标依然是 ，即给定前面几个单词后出现某个单词的条件概率。

那这个模型应该怎么设计呢？一个朴素的建模方式是：根据单词或单词元组在语料库中出现的频率计算联合概率，再根据公式计算出条件概率，例如 。这样的一种简单的建模方式有几个问题：