更新日志
2026.10.05:博客创建。
2026.10.06:完成第0、1、2章。
2026.10.07:完成4.1、4.2、4.3。
2026.10.08:完成4.4.1
2026.10.11:完成4.4.2
2026.10.12:修复了部分数学公式无法正常渲染的问题。
2026.10.18:完成4.4.3,优化了1.4的 Transformer 文本处理流程图
2026.10.19:完成4.4.
0. 怎么读这篇博客
阅读博客之前,请先阅读以下内容。
0.1 这套博客要回答什么问题
零基础入门人工智能要学什么基础知识?
Transformer 是什么?
它为什么能处理语言?
它是怎么学会预测下一个词的?
ChatGPT 这类模型怎么根据输入生成文字?
0.2 读者需要什么基础
本博客属于杂谈随笔,旨在记录本人如何从零基础入门人工智能领域,会从数学原理讲起,不过最基本的线性代数、微积分概念不予讲解,但涉及到的重要知识或者内容会进行补充,所以请在基本学完本科阶段线性代数、微积分之后并确保有基本的矩阵知识、微积分知识后进行阅读。
关于编程基础,懂得基本 Python 的语法即可。涉及到的 PyTorch 语句语法会给出对应的介绍以及讲解,所以可以不用担心没学过。
0.3 读前须知
阅读顺序可以直接从 Transformer 章节进行阅读。因为本人学的过程就是直接读 Transformer 的开山论文,然后采用深度优先学习法,遇到不会的、未接触的知识,再去学这个知识,直到学到底层后递归向上。所以阅读过程可以直接从 Transformer 章节进行阅读,涉及到的相关知识在前述章节会给出,可以点击进行查看。并不建议读完前面所有基础内容再学 Transformer,因为可能学完之后就忘记了。所以建议这种深度优先学习的方法。博客在编写过程中也会确保知识点出现过程中的相关介绍补充以及扫盲。
1. 计算机怎样处理文字
这一部分指的是将人类文字变成计算机可以看懂的输入,然后输入到计算机中,经过处理之后再输出成文字的过程。读完这部分后,我们应该可以区分字符编码、Token 切分和 Token ID 这些概念,知道信息在机器处理过程中的基本状态是什么。
1.1 字符、编码与数字
我们在屏幕上看到一个文字,例如“猫”时,作为一个客观存在的、有着自主思维的人类来讲,我们将“猫”这个文字作为载体存储到我们的大脑中,但计算机的存储以及信息的表示都基于一串又一串的二进制编码形成的数字,它在面对“猫”这个字的时候,通过已有的文本字符编号,将“猫”这个字映射到编号上,然后通过编码方式将编号映射成字节序列。
在这里要分清楚三个层次:
层次
例子
作用
人看到的文本
猫
人类阅读的文字
字符编号
Unicode 中对应的码点
在字符层面标识字符
编码后的字节
UTF-8 字节序列
供计算机存储和传输
比如我们得到一个字符“猫”,然后得到它的 Unicode 编号 U+732B,最后通过 UTF-8 编码方式得到对应的字节序列 E7 8C AB。这样我们就得到了一个字符如何转换为计算机可存储、表示的形式。
但这还不是 Transformer 所说的 Token 切分。字符编码解决的是将字符映射成计算机可理解的字节序列,使之可以表示和保存。Tokenizer 解决的是模型将输入的文本切分成多个处理单元。可以理解为一个重在将文本转化为可存储表示的字节,一个将字符切分为不同的 Token。具体可读下文。
1.2 Token
Token 是模型词表中的一个基本单位。它可能是一个完整的单词,或者一段单词,亦可是一个汉字、多个汉字,标点、空格等等。甚至某些字节片段中,Token 不一定是一个“词”,这由分词器 Tokenizer 决定。通常不同模型的 Tokenizer 处理同一段文本也可以得到不同的切分结果。
例如,把“我喜欢浙江工业大学”交给不同的 Tokenizer,可能得到这样的切分结果:
切分方式
Token 序列
一种可能
["我", "喜欢", "浙江工业", "大学"]
另一种可能
["我", "喜欢", "浙江", "工业", "大学"]
切分没有对错之分,也可能更细或更粗;实际结果由具体模型的 Tokenizer 决定。
为什么不直接一个字、一个单词就是一个 Token 呢?因为按字符切分会让 Token 序列变得很长,按完整词切分则会遇到词表过大、罕见词或新词难以处理的问题,子词切分让词表规模、序列长度之间做折中,也让模型通过熟悉的片段组合处理罕见的、未见得词性。
Token 数量会影响模型可处理的上下文长度以及计算量,同样长度的一段文字,切分的 Token 越多,占用的上下文通常越多。Token 是模型处理和理解世界的基本单位。
1.3 Token ID
Tokenizer 切分 Token 后,会查一张表,我们称之为词表,词表中把每个 Token 映射成一个整数,称之为 Token ID。假设现在存在一个词表如下:
示意词表(内容仅作说明,无具体含义)
Token
Token ID
Token
Token ID
我
0
喜欢
1
浙江
2
工业
3
大学
4
和
5
今天
6
明天
7
晴天
8
阴天
9
天气
10
下雨
11
机器
12
学习
13
很好
14
。
15
如果我们得到一个 Token 序列为 ["今天", "天气", "很好"],对应的词表中的 Token ID 为[6, 10, 14]。
当然这些数字只是示意,真实的编号由具体模型自身的词表决定。Token ID 的作用就是告诉程序该查哪一个 Token,并不表示一个 Token 多重要,编号距离相近也不影响 Token 之间的关系,同时不具有数值特征,不能说 "15" 就比 "4" 大或者好,仅仅表示一个离散的编号。
这里还要区分 Token ID 与模型实际计算的表示,ID只是离散的编号;进入神经网络后,模型会通过 Embedding 表把每个 ID 嵌入成一个向量,这个向量才是后续矩阵运算以及各种运算的输入。本文将在神经网络基础部分再细讲 Embedding。
Token ID 依赖 Tokenizer 的词表,因此同一个字符串交给不同的 Tokenizer 时可能会得到不同的切分结果以及不同的词表,因此使用一个预训练模型时必须配套的使用与之匹配的 Tokenizer。
1.4 特殊 Token 与词表
词表是 Token 与 Token ID 之间的映射表。模型输入时将 Token 转化为 ID,紧接着嵌入成向量,输出时也通常会词表里面的候选 Token 计算分数或概率。词表大小因此影响输出层的规模,可以理解为模型的 Token 候选集。
除了普通文本段外,词表或者输入协议中还包含特殊Token,例如:
特殊 Token
英文含义
作用
BOS
Beginning of Sequence
标记输入或生成序列的开始
EOS
End of Sequence
标记序列结束
PAD
Padding
补齐不同长度的序列,便于批量处理
UNK
Unknown
表示无法识别或表示的 Token;有些 Tokenizer 会尽量避免使用
当然不同模型不一定全部使用这些特殊标记,也不一定只含有这几个标记,这由具体的 Transformer 而定。
PAD Token 和后面要讲的 Attention Mask 也要区分开来。前者指的是一个填充位置可能使用的 Token,因为在把 Token 序列化为等长的时候,较短的序列可能采用 PAD 填补空缺;Mask 则是告诉模型应该的遮罩,即哪些位置信息应该被屏蔽。Mask 具体由后文的注意力机制章节展开讲解。
有了 Token 序列,就可以定义语言模型最常见的训练任务:给定前面的 Token,预测接下来那个 Token。注意,目标是下一个 Token,不一定是下一个完整单词,因为一个词可能被切成多个 Token。
比如一句话被切成["我", "喜欢", "浙江", "工业", "大学"],训练时过程如下:
已有上下文
要预测的下一个 Token
BOS
我
BOS, 我
喜欢
BOS, 我, 喜欢
浙江工业
BOS, 我, 喜欢, 浙江工业
大学
BOS, 我, 喜欢, 浙江工业, 大学
EOS
模型学习的就是,看到已有上下文之后,预测下一个 Token 中哪一个更可能出现。比如看到 "BOS, 我, 喜欢" 之后,开始对下一个可能的 Token 进行预测,每个候选 Token 用概率记号可以写成:
P ( t i + 1 ∣ t 1 , … , t i ) P(t_{i+1}\mid t_1,\ldots,t_i)
P ( t i + 1 ∣ t 1 , … , t i )
这里,t 1 , … , t i t_1,\ldots,t_i t 1 , … , t i 是已经出现的 Token,t i + 1 t_{i+1} t i + 1 是要预测的下一个 Token。公式的读法、下标和条件概率会在后面的符号与数学基础部分拆开讲。
举例说明,我们已有的 Token 上下文为 "BOS, 我, 喜欢",可能得到的候选集如下:
假设在上下文 BOS, 我, 喜欢 下,模型得到以下示意概率:
候选下一个 Token
条件概率
浙江工业
0.40
学习
0.20
你
0.15
运动
0.10
浙江大学
0.10
其他候选
0.05
当然这个表只是用于演示假设的概率表,仅用作说明。其中 浙江工业 出现的概率最高,所以它是最可能出现的下一个 Token,所以选择它。
这里补充一句,贪心解码中就是选概率最大的,但这不是唯一的方法。实际生成中可能按概率随机抽,也可能筛一部分再抽,具体由解码策略决定。所以并不一定就是说就选概率最大的,不过这里以它为例进行演示。
在实际训练过程中,模型通常能在一次计算中处理序列的多个位置,并同时预测多个 "下一个 Token",实现并行运算。工作原理就是通过因果 Mask,限制每个位置智能利用允许看到的上下文,而不会偷看后面的位置进行“作弊”。具体 Mask 矩阵将在后文细讲。
生成文字时,模型从已有上下文计算下一个 Token 的概率分布,选出一个 Token 并接到末尾,再用更新后的上下文预测下一步。重复这个过程,Token 序列逐渐变长完成整个序列的预测,之后 Tokenizer 再将 Token 序列还原成人能阅读的文本。
完整的数据流见下图:
本部分最重要的结论是:Transformer 接收的不是未经处理的句子,而是经过 Tokenizer 转换、再经 Embedding 映射得到的向量序列;语言模型训练时,则通过预测下一个 Token 来调整这些向量和网络参数。
2. 公式与符号说明
本部分旨在帮助读者认出公式里的记号、索引和形状写法。具体数学概念会在数学基础章节独立讲解。机器学习领域没有一份适用于所有教材和论文的固定符号表,同一字母可能在不同语境表示不同对象,本文仅对部分约定俗成的符号进行介绍以及讲解。可选择性阅读 。
2.1 标量、向量及矩阵
对象
写法
示例
标量
普通小写字母
x x x 、y y y 、η \eta η
向量
粗体小写字母
x \mathbf{x} x 、h \mathbf{h} h
矩阵
大写字母
X X X 、W W W 、Q Q Q
高维张量
花体大写字母
X ∈ R B × L × d \mathcal{X}\in\mathbb{R}^{B\times L\times d} X ∈ R B × L × d
随机变量
通常用大写字母;具体观测值用对应小写字母
随机变量 X X X ,观测值 x x x
向量的分量用普通字母和下标表示。例如,x \mathbf{x} x 是一个向量,x j x_j x j 是它的第 j j j 个分量。矩阵 X X X 的元素 X i j X_{ij} X ij 则表示第 i i i 行、第 j j j 列的数。
在本文中,单个 Token 的嵌入表示为一个行向量。若向量维度为 d model d_{\text{model}} d model ,则 e ( i ) ∈ R 1 × d model \mathbf{e}^{(i)} \in \mathbb{R}^{1 \times d_{\text{model}}} e ( i ) ∈ R 1 × d model 。一条包含 L L L 个 Token 的序列,把这些向量逐行堆叠成矩阵 X ∈ R L × d model X \in \mathbb{R}^{L \times d_{\text{model}}} X ∈ R L × d model 。因此,X i j X_{ij} X ij 表示第 i i i 个 Token 在第 j j j 个特征维度上的数值。
2.2 上标、下标与索引
上标和下标的含义由对象及上下文决定,不能把它们机械地理解成同一种编号。不过一般来说,下标常用来标记分量或位置;带括号的上标常用来标记样本或向量编号。因此本文约定:
数据集中的第 n n n 个样本写作 x ( n ) \mathbf{x}^{(n)} x ( n ) 、y ( n ) y^{(n)} y ( n ) 。圆括号里的上标表示样本编号,不是乘方。
向量第 n n n 个样本的第 j j j 个分量写作 x j ( n ) x_j^{(n)} x j ( n ) 。
矩阵的第 i i i 行、第 j j j 列元素写作 X i j X_{ij} X ij 。
序列中第 i i i 个 Token 写作 t i t_i t i ;它的 Token ID 写作 id ( t i ) \operatorname{id}(t_i) id ( t i ) 。
第 ℓ \ell ℓ 层、第 i i i 个序列位置的隐藏向量可写作 h ( ℓ , i ) \mathbf{h}^{(\ell,i)} h ( ℓ , i ) ;其中第 j j j 个分量是 h j ( ℓ , i ) h_j^{(\ell,i)} h j ( ℓ , i ) 。
x 2 x^2 x 2 中的上标表示平方;x T \mathbf{x}^{\mathrm{T}} x T 中的 T \mathrm{T} T 表示转置。
2.3 数据、标签、预测、参数
符号
含义
符号
含义
x ( n ) \mathbf{x}^{(n)} x ( n )
第 n n n 个输入样本或输入向量
y ( n ) y^{(n)} y ( n )
第 n n n 个样本对应的目标答案或标签
y ^ ( n ) \hat{y}^{(n)} y ^ ( n )
模型对第 n n n 个样本的预测;帽子表示预测值
D \mathcal{D} D
数据集
N N N
样本数量
f θ f_{\theta} f θ
参数为 θ \theta θ 的模型或函数
θ \theta θ
模型全部可学习参数的统称
W W W
权重矩阵;具体用途常用下标标明,如 W Q W_Q W Q
b b b
偏置参数
h \mathbf{h} h
隐藏表示或中间向量
一组带标签的数据可以写成:
D = { ( x ( n ) , y ( n ) ) } n = 1 N \mathcal{D}=\{(\mathbf{x}^{(n)},y^{(n)})\}_{n=1}^{N}
D = {( x ( n ) , y ( n ) ) } n = 1 N
模型根据输入产生预测,可以写成:
y ^ ( n ) = f θ ( x ( n ) ) \hat{y}^{(n)}=f_{\theta}(\mathbf{x}^{(n)})
y ^ ( n ) = f θ ( x ( n ) )
其中, D \mathcal{D} D 表示数据集;圆括号上标 ( n ) (n) ( n ) 表示第 n n n 个样本。
2.4 形状、维度、集合
记号
含义
x ∈ R d \mathbf{x}\in\mathbb{R}^{d} x ∈ R d
一个含 d d d 个实数分量的向量
X ∈ R m × n X\in\mathbb{R}^{m\times n} X ∈ R m × n
一个 m m m 行、n n n 列的矩阵
X ∈ R L × d model X\in\mathbb{R}^{L\times d_{\text{model}}} X ∈ R L × d model
一条长度为 L L L 的序列表示,每个 Token 有 d model d_{\text{model}} d model 个特征
X ∈ R B × L × d model \mathcal{X}\in\mathbb{R}^{B\times L\times d_{\text{model}}} X ∈ R B × L × d model
一批序列表示,三个轴依次为批次、序列位置和特征
本文主要使用以下维度符号:
符号
含义
B B B
批次大小,即一次处理的样本或序列数量
L L L
序列长度,即序列中 Token 的数量
d d d
一般的特征维度
d model d_{\text{model}} d model
Transformer 中每个 Token 的隐藏表示维度
H H H
注意力头数
d k , d v d_k,d_v d k , d v
每个注意力头中 Key/Query 与 Value 的维度
N vocab N_{\text{vocab}} N vocab
词表大小
2.5 常见运算符
记号
读法或作用
= = = 、: = := :=
等于、定义为
≈ \approx ≈ 、∝ \propto ∝
约等于、成正比
∈ \in ∈ 、∀ \forall ∀ 、∃ \exists ∃
属于、对所有、存在
∑ i = 1 N \sum_{i=1}^{N} ∑ i = 1 N 、∏ i = 1 N \prod_{i=1}^{N} ∏ i = 1 N
求和、求积
( ⋅ ) T (\cdot)^{\mathrm{T}} ( ⋅ ) T
转置
x T y \mathbf{x}^{\mathrm{T}}\mathbf{y} x T y
向量点积
⊙ \odot ⊙
逐元素相乘
∣ x ∣ 2 |\mathbf{x}|_2 ∣ x ∣ 2
向量的二范数
∂ \partial ∂ 、∇ θ \nabla_\theta ∇ θ
偏导数、对参数 θ \theta θ 求梯度
max \max max 、min \min min
最大值、最小值
argmax \operatorname{argmax} argmax 、argmin \operatorname{argmin} argmin
使目标值达到最大、最小的输入
1 [ A ] \mathbb{1}[A] 1 [ A ]
指示函数;条件成立时为 1 1 1 ,否则为 0 0 0
log \log log 、exp \exp exp 、softmax \operatorname{softmax} softmax
对数、指数函数、Softmax 函数
← \leftarrow ← 、→ \to →
赋值/更新、映射或趋向;具体含义看上下文
2.6 概率、条件、期望
记号
含义
P ( A ) P(A) P ( A )
事件 A A A 发生的概率
p ( x ) p(x) p ( x )
x x x 的概率分布;连续变量时也可表示概率密度
p ( y ∣ x ) p(y\mid x) p ( y ∣ x )
给定 x x x 时,y y y 的条件分布
x ∼ p ( x ) x\sim p(x) x ∼ p ( x )
从分布 p ( x ) p(x) p ( x ) 中抽取一个 x x x
E [ ⋅ ] \mathbb{E}[\cdot] E [ ⋅ ]
期望;对随机抽取的结果按其分布求平均
概率论教材常用大写 X X X 表示随机变量、小写 x x x 表示具体取值;机器学习文献中,期望下标也常直接用小写变量表示“从某分布抽取的样本”。本文在期望记号中使用后一种写法,并在下标中标出抽样来源。
单个变量的期望:
E x ∼ p data ( x ) [ g ( x ) ] \mathbb{E}_{x\sim p_{\text{data}}(x)}[g(x)]
E x ∼ p data ( x ) [ g ( x )]
表示从数据分布 p data ( x ) p_{\text{data}}(x) p data ( x ) 中抽取 x x x ,再对 g ( x ) g(x) g ( x ) 求平均。
多个变量可以一起出现在期望下标中。若一对变量从联合分布中抽取:
E ( x , y ) ∼ p ( x , y ) [ g ( x , y ) ] \mathbb{E}_{(x,y)\sim p(x,y)}[g(x,y)]
E ( x , y ) ∼ p ( x , y ) [ g ( x , y )]
这里 x x x 和 y y y 可以相关。如果它们分别从两个独立分布中抽取,可以写作:
E x ∼ p ( x ) , y ∼ q ( y ) [ g ( x , y ) ] \mathbb{E}_{x\sim p(x),\,y\sim q(y)}[g(x,y)]
E x ∼ p ( x ) , y ∼ q ( y ) [ g ( x , y )]
当然也可以简写为:
E x , y [ g ( x , y ) ] \mathbb{E}_{x,y}[g(x,y)]
E x , y [ g ( x , y )]
如果 y y y 的抽样分布取决于 x x x ,则应写明条件分布:
E x ∼ p ( x ) [ E y ∼ q ( y ∣ x ) [ g ( x , y ) ] ] \mathbb{E}_{x\sim p(x)}
\left[
\mathbb{E}_{y\sim q(y\mid x)}[g(x,y)]
\right]
E x ∼ p ( x ) [ E y ∼ q ( y ∣ x ) [ g ( x , y )] ]
因此,E x , y \mathbb{E}_{x,y} E x , y 只列出了参与取期望的变量;若分布关系还不明确,就需要补充联合分布、各自的抽样分布或条件分布。例如,ϵ ∼ N ( 0 , I ) \epsilon\sim\mathcal{N}(0,I) ϵ ∼ N ( 0 , I ) 表示噪声 ϵ \epsilon ϵ 从均值为 0 0 0 、协方差为单位矩阵 I I I 的正态分布中抽取。
机器学习中常用有限样本的平均估计总体期望:
E x ∼ p data ( x ) [ g ( x ) ] ≈ 1 N ∑ n = 1 N g ( x ( n ) ) \mathbb{E}_{x\sim p_{\text{data}}(x)}[g(x)]
\ \approx\
\frac{1}{N}\sum_{n=1}^{N}g(x^{(n)})
E x ∼ p data ( x ) [ g ( x )] ≈ N 1 n = 1 ∑ N g ( x ( n ) )
左边是对数据分布取期望,右边是用 N N N 个样本计算出的经验平均。
2.7 损失、梯度、参数更新
经验风险可以写为:
L ( θ ) = 1 N ∑ n = 1 N ℓ ( f θ ( x ( n ) ) , y ( n ) ) \mathcal{L}(\theta) = \frac{1}{N} \sum_{n=1}^{N} \ell \left( f_\theta(\mathbf{x}^{(n)}), y^{(n)} \right)
L ( θ ) = N 1 n = 1 ∑ N ℓ ( f θ ( x ( n ) ) , y ( n ) )
最基本的梯度下降更新记作:
θ ← θ − η ∇ θ L ( θ ) \theta \leftarrow \theta-\eta\nabla_{\theta}\mathcal{L}(\theta)
θ ← θ − η ∇ θ L ( θ )
这里 ℓ \ell ℓ 和 L \mathcal{L} L 不是同一个层级的量:前者可以表示单个样本的损失,后者通常把多个样本的损失汇总起来。实际用的是求和还是平均,要看公式如何定义。
###2.8 Transformer 中常见的符号
符号
含义
t i t_i t i
序列第 i i i 个 Token
id ( t i ) \operatorname{id}(t_i) id ( t i )
位置 i i i 上 Token 对应的整数 ID
E E E
Embedding 矩阵,形状通常为 N vocab × d model N_{\text{vocab}}\times d_{\text{model}} N vocab × d model
e ( k ) \mathbf{e}^{(k)} e ( k )
Token ID 为 k k k 时查到的嵌入向量
X X X
输入序列的表示矩阵;每一行对应一个 Token 位置
W Q , W K , W V W_Q,W_K,W_V W Q , W K , W V
将输入投影为 Query、Key、Value 的权重矩阵
Q , K , V Q,K,V Q , K , V
Query、Key、Value 矩阵
S S S
注意力分数矩阵
A A A
Softmax 后的注意力权重矩阵
M M M
注意力掩码
O O O
注意力计算得到的输出表示
z \mathbf{z} z
输出层产生的 Logits 向量,即 Softmax 前的分数
p \mathbf{p} p
候选 Token 的概率向量,常写作 p = softmax ( z ) \mathbf{p}=\operatorname{softmax}(\mathbf{z}) p = softmax ( z )
t ^ i + 1 \hat{t}_{i+1} t ^ i + 1
模型或解码策略选出的下一个 Token
τ \tau τ
生成时的 Temperature 参数
对于词表中第 j j j 个候选 Token,z j z_j z j 表示对应的 Logit,p j p_j p j 表示 Softmax 后的概率。语言模型给定前文时的条件分布可写作:
p θ ( t i + 1 ∣ t 1 , … , t i ) p_{\theta}(t_{i+1}\mid t_1,\ldots,t_i)
p θ ( t i + 1 ∣ t 1 , … , t i )
若序列长度为 L L L ,单头注意力的一种常见形状约定为:
X ∈ R L × d model , Q , K ∈ R L × d k , V ∈ R L × d v X\in\mathbb{R}^{L\times d_{\text{model}}},
\quad
Q,K\in\mathbb{R}^{L\times d_k},
\quad
V\in\mathbb{R}^{L\times d_v}
X ∈ R L × d model , Q , K ∈ R L × d k , V ∈ R L × d v
于是 Q K T QK^{\mathrm{T}} Q K T 的形状是 L × L L\times L L × L ,表示每个序列位置与其他位置之间的分数。批量输入增加批次轴 B B B ;多头注意力增加头数轴 H H H 。后文会推导这些形状如何产生。
3. 数学基础
本不放呢旨在补充部分 线性代数、微积分、概率论的数学基础知识以讲解后续机器学习、神经网络以及 Transformer 会实际用到的数学工具,可选择性阅读 。
4. 机器学习基础
本章旨在对机器学习基础进行补充,重在讲解 Transformer 中运用到的参数、预测、损失、梯度下降以及反向传播,对可能涉及到的机器学习入门基础进行扫盲式讲解。大家可根据自己的情况进行阅读。
4.1 从例子中寻找规律
首先,我们需要知道什么是人工智能。人工智能即让机器具备感知、学习、推理和决策的能力 。日常语境中,AI 既可以指的是实现机器智能的理论与方法,也可以是具有智能特征的具体产品,如ChatGPT、智能机器人等具体的应用载体。
AI的核心实现路径:机器学习(Machine Learning),简称 ML,其研究如何通过数据让机器自动学习已有数据的规律,进而对未来进行预测。其真正意义是由计算机来自动完成寻找规律的过程 。
那么就要引出模型 这个概念了。首先我们想知道,机器如何根据数据做决策?模型可以理解为通过海量数据训练出来的一套有自己判断及预测规则的算法,作为人类,我们判断今天会不会下雨,根据的是我们的经验,即如果今天阴天、天气潮湿,那么今天大概率是会下雨的;而作为机器,我们将大量数据输入给模型,比如我们的输入是很多天的天气、湿度以及是否降雨,模型根据海量的数据学习到这种经验,输出它认为的结果,这就是机器学习的一个流程。
4.2 参数、预测与误差
我们首先理解这几个概念:参数是模型可以调整的数字,它决定了模型的配置是怎么样的、以及模型如何处理输入的数据;预测是模型通过其参数处理输入后得到的结果;误差则是衡量模型预测的结果与正确答案之间差距的一个尺度。接下来我们以线性回归为例
线性回归(Linear Regression),基本上可以作为是机器学习最基础的模型,我们在中学学习阶段就接触过这个回归。其核心思想是假设输出 y y y 与输入特征 x x x 之间存在线性关系:
y = w x + b y = wx + b
y = w x + b
其中,w , b w, b w , b 便是模型的参数。假设我们训练后得到的参数值分别为 w = 2 , b = 3 w = 2, b = 3 w = 2 , b = 3 ,则我们的线性回归方程为 y = 2 x + 3 y = 2x + 3 y = 2 x + 3 。若目前我们有一组数据的 y , x y, x y , x 取值分别为 10 , 3 10, 3 10 , 3 。带入线性回归,我们得到 y ^ = 9 \hat{y} = 9 y ^ = 9 ,其中 y ^ \hat{y} y ^ 便是我们的预测,而我们的真实值是 y = 10 y = 10 y = 10 ,误差便是:
e = L ( y , y ^ ) e = L(y, \hat{y})
e = L ( y , y ^ )
其中,e e e 表示样本的误差;L L L 表示计算误差应用的函数。
因为误差有多种定义,比如绝对误差、百分比误差、相对误差,不同模型设定的误差不同,为方便演示,这里用 L L L 表示误差的计算方法。
4.3 损失函数
在前面我们已经知道了误差是什么,它本质是一个数,表示预测值与真实值的差距。我们将这种差距通过人为定义的规则转化为可优化的数值,便得到了损失函数(Loss Function)。
损失函数,用于衡量模型预测的有多差,损失越大代表模型预测越不符合训练目标,模型越差;反之损失越小说明模型预测越接近目标,模型越好。
损失函数是关于模型参数与真实答案的函数,提供了优化目标,通常是可导的、可最小化的。损失函数来源于不同的误差,也产生了不同的损失函数。损失函数的选取是决定模型能否高效地、正确地学习的关键。我们以常见的均方误差 MSE \text{MSE} MSE 结合线性回归进行讲解。
L MSE = 1 m ∑ i = 1 m ( y i − y ^ i ) 2 \mathcal{L_{\text{MSE}}} = \frac{1}{m} \sum_{i=1}^{m} (y_i - \hat{y}_i)^2
L MSE = m 1 i = 1 ∑ m ( y i − y ^ i ) 2
其中,L \mathcal{L} L 表示损失函数。
不过大多数文献会将 y ^ \hat{y} y ^ 写作 y ^ i = f θ ( x i ) \hat{y}_i = f_\theta(x_i) y ^ i = f θ ( x i ) ,以更清晰的表示“模型在参数 θ \theta θ 下对输入 x i x_i x i 的预测”这一概念,并将 L \mathcal{L} L 写作 L ( θ ) \mathcal{L}(\theta) L ( θ ) 以表示“模型在该参数下得到的损失函数”这一概念。然后我们得到更完整的公式如下:
L ( θ ) = 1 m ∑ i = 1 m ℓ ( f θ ( x i ) , y i ) \mathcal{L}(\theta) = \frac{1}{m} \sum_{i=1}^{m} \ell(f_\theta(x_i), y_i)
L ( θ ) = m 1 i = 1 ∑ m ℓ ( f θ ( x i ) , y i )
其中,ℓ \ell ℓ 表示单个样本产生的损失。
注意,这里我们不一定选择的就是均方误差 MSE \text{MSE} MSE ,不同的模型有不同的选择。
为了更好的理解前面的参数、预测、误差、损失函数等概念,我们列举一个简单的线性回归的场景进行演示。
预测成绩,输入是学习时间 x x x ,输出是分数 y y y 。假设模型是线性回归,采用均方误差作为损失的指标:
f θ ( x i ) = w x i + b f_\theta(x_i) = w x_i + b
f θ ( x i ) = w x i + b
其中,θ \theta θ 由 w w w 和 b b b 组成。
将损失函数化简得到:
L ( θ ) = 1 m ∑ i = 1 m ( ( w x i + b ) − y i ) 2 L(\theta) = \frac{1}{m} \sum_{i=1}^{m} ((w x_i + b) - y_i)^2
L ( θ ) = m 1 i = 1 ∑ m (( w x i + b ) − y i ) 2
假设给出的训练数据为:
样本
学习时间
真实分数
1
1
50
2
2
60
3
3
70
4
4
80
5
5
90
假设目前参数下模型预测函数如下:
f θ ( x i ) = 10 x i + 40 f_\theta(x_i) = 10x_i + 40
f θ ( x i ) = 10 x i + 40
则可以得到下表:
样本
y i y_i y i
f θ ( x i ) f_\theta(x_i) f θ ( x i )
ℓ i \ell_i ℓ i
1
50
53
9
2
60
61
1
3
70
69
1
4
80
77
9
5
90
85
25
带入损失函数得到损失为9。
4.4 梯度下降
我们首先给出梯度下降的定义:
梯度下降(Gradient Descent),是一种一阶迭代优化算法。给定可微的损失函数 L ( θ ) \mathcal{L}(\boldsymbol{\theta}) L ( θ ) ,从某个初始参数 θ 0 \boldsymbol{\theta}_0 θ 0 出发,在每一步都沿损失函数在当前参数处的负梯度方向 − ∇ θ L ( θ t ) -\nabla_{\boldsymbol{\theta}} \mathcal{L}(\boldsymbol{\theta}_t) − ∇ θ L ( θ t ) 更新参数,即:
θ t + 1 = θ t − η t ∇ θ L ( θ t ) \boldsymbol{\theta}_{t+1} = \boldsymbol{\theta}_t - \eta_t \nabla_{\boldsymbol{\theta}} \mathcal{L}(\boldsymbol{\theta}_t)
θ t + 1 = θ t − η t ∇ θ L ( θ t )
其中,η t \eta_t η t 为第 t t t 步的学习率,用于描述参数更新的幅度。其目标是使目标函数逐步下降,并最终收敛到极小点或者稳定点。
接下来我们详细介绍梯度下降涉及到的知识及其主要内容。
4.4.1 爬山算法
在正式介绍梯度下降之前,我们先介绍一个经典算法爬山算法(Hill Climbing):是一种基于局部搜索的迭代优化算法。它从某个初始解出发,在每一步检查当前解的邻域,选择能使目标函数值更优的邻居作为下一步的解;若邻域中不存在更优解,则算法停止,并返回当前解作为结果。
用更容易懂得话来讲,就是从一个初始位置 x 0 x_0 x 0 开始,假设当前位于位置 x x x ,每一步都查看邻域 f ( x ± Δ x ) f(x \pm \Delta x) f ( x ± Δ x ) 的函数大小,并沿着使得目标函数 f ( x ) f(x) f ( x ) 更优的方向移动,直到移动到某个点,在该邻域内不存在更优点为止,我们以某个二次函数为例,可见下图:
我们不难发现,因为我们的损失函数 L ( θ ) \mathcal{L}(\boldsymbol{\theta}) L ( θ ) 本质上也是一个关于参数 θ \boldsymbol{\theta} θ 函数,也可以通过爬山算法来优化我们的参数使得损失达到最小。但实际过程中,我们却没有使用这种方法,原因是什么呢?
假设模型有 10 6 10^6 1 0 6 个参数,那么爬山算法每个参数都需要尝试其正负邻域两个方向,那么每一步都需要尝试 2 × 10 6 2 \times 10^6 2 × 1 0 6 个候选点,每个候选点都要做一次前向传播计算到底直到算出损失,计算量巨大。
(关于前向传播,会在4.4.2给出介绍)
这里我们首先讲一下参数耦合,参数耦合是是数学建模、机器学习、控制理论以及物理学中常见的一个概念。简单来说,它指的是系统或模型中的多个参数之间存在相互依赖、相互影响的关系,而不是彼此完全独立的。如果一个参数发生变化,会导致另一个(或多个)参数也随之变化,或者一个参数的变化效果取决于另一个参数的值,我们就说这些参数是“耦合”的。
爬山算法通常只沿单个坐标轴或简单邻域试探。但深度学习参数高度耦合,真正下降的方向往往是多个参数联合变化的方向。所以爬山算法常常陷入局部最优解。
为了更好的讲解什么是参数耦合,我们举一个具体的例子:
f ( x , y ) = x 2 + y 2 + 10 x y Δ x = Δ y = ϵ x 0 = y 0 = 0 f(x, y) = x^2 + y^2 + 10xy \\\\
\Delta x = \Delta y = \epsilon \\\\
x_0 = y_0 = 0
f ( x , y ) = x 2 + y 2 + 10 x y Δ x = Δ y = ϵ x 0 = y 0 = 0
如果沿着 x x x 轴走,那么 f ( ϵ , 0 ) = ϵ 2 f(\epsilon, 0) = \epsilon^2 f ( ϵ , 0 ) = ϵ 2 ;沿着 y y y 轴走,那么 f ( 0 , ϵ ) = ϵ 2 f(0, \epsilon) = \epsilon^2 f ( 0 , ϵ ) = ϵ 2 。
会发现目标函数都上升,我们需要让函数值最小,所以算法认为这就是最优,停止并返回。
但实际上我们如果两个方向同时走,比如( ϵ , − ϵ ) (\epsilon, -\epsilon) ( ϵ , − ϵ ) ,那么 f ( ϵ , − ϵ ) = − 8 ϵ 2 < 0 f(\epsilon, -\epsilon) = -8\epsilon^2 < 0 f ( ϵ , − ϵ ) = − 8 ϵ 2 < 0 ,可以进一步降低。
造成这种问题的原因可以先简单这样理解,有的参数是相互之间耦合的,必须同时变化才会使得整体结果更优,但是只变化一个可能不会更优,甚至是更差。爬山算法只能离散的尝试每个参数的邻域,无法看到参数之间的联系。
爬山算法是贪心策略,只要邻域里没有更优点,它就停。它没有随机噪声、动量、重启等机制,很容易卡在局部最优或鞍点。
考虑一维函数 f ( x ) = x 2 + sin ( 5 x ) f(x) = x^2 + \sin(5x) f ( x ) = x 2 + sin ( 5 x ) ,它有很多局部极小值。爬山算法从某个点出发,会很快滑进最近的一个小坑,然后发现左右两边都比当前高,于是停住。但这个坑很可能不是全局最优。
总而言之,爬山算法因为其存在的问题,并没有成为主流的参数优化方式,但这种思想和机制是极为宝贵的,我们也在讲后面引出同一数学直觉的另一算法——梯度下降算法,这也是机器学习、人工智能领域的重要篇章。虽然爬山算法因为其弊端没有广泛应用到人工智能领域的参数更新中,但是其带来的数学直觉和机制提供了巨大的作用,在它的基础上也发展出来了一系列启发式算法,如模拟退火、随机重启、禁忌搜索、遗传算法、粒子群优化、蚁群算法和差分进化等等,感兴趣的可以自行研究。
4.4.2 梯度下降算法
经过了前面很多的铺垫,我们也是正式进入梯度下降算法了。前面的小节中我们已经知道,损失函数可以把模型预测结果“好不好”量化成一个具体的数作为评判指标,模型训练这一阶段的目的就是不断调整模型的参数,逐步降低这个损失。
假设目前模型的可学习参数 记作 θ \boldsymbol{\theta} θ ,记住一定是可学习的参数,而非固定参数。当参数改变时,模型预测就会跟着改变,损失也会随之改变,梯度下降就是根据损失对参数的变化趋势,反复更新参数的一种优化方式。
形象地,给定第 t t t 步参数为 θ t \boldsymbol{\theta}_t θ t ,则更新规则如下:
θ t + 1 = θ t − η t ∇ θ L ( θ t ) \boldsymbol{\theta}_{t+1}=\boldsymbol{\theta}_t-\eta_t\nabla_{\boldsymbol{\theta}}\mathcal{L}(\boldsymbol{\theta}_t)
θ t + 1 = θ t − η t ∇ θ L ( θ t )
不过这样理解可能不够明显,其实 ∇ θ L ( θ t ) \nabla_{\boldsymbol{\theta}}\mathcal{L}(\boldsymbol{\theta}_t) ∇ θ L ( θ t ) 就是损失函数关于所有可学习参数的偏导组成的。
如果只有一个参数,那么显然梯度就是该参数在 t t t 时的导数,当参数不只一个时,扩展为梯度,由所有参数的偏导数组成:
∇ θ L ( θ ) = ( ∂ L ∂ θ 1 , ∂ L ∂ θ 2 , … , ∂ L ∂ θ d ) T \nabla_{\boldsymbol{\theta}}\mathcal{L}(\boldsymbol{\theta})=
\left(
\frac{\partial\mathcal{L}}{\partial\theta_1},
\frac{\partial\mathcal{L}}{\partial\theta_2},
\ldots,
\frac{\partial\mathcal{L}}{\partial\theta_d}
\right)^{\mathrm{T}}
∇ θ L ( θ ) = ( ∂ θ 1 ∂ L , ∂ θ 2 ∂ L , … , ∂ θ d ∂ L ) T
梯度同时告诉我们每个参数对损失的影响方向和强弱,对于足够小的一步更新,沿着负梯度方向 移动通常会使得损失下降。我们在微积分中学到过微分近似(线性近似)公式,其关于一阶导数的展开形式如下:
f ( x + Δ x ) ≈ f ( x ) + f ′ ( x ) Δ x f(x + \Delta x) \approx f(x) + f'(x)\Delta x
f ( x + Δ x ) ≈ f ( x ) + f ′ ( x ) Δ x
扩展为用梯度表示,则可以得到下面式:
f ( x + Δ x ) ≈ f ( x ) + ∇ f ( x ) T Δ x f(\mathbf{x}+\Delta\mathbf{x})\approx f(\mathbf{x})+\nabla f(\mathbf{x})^{\mathrm{T}}\Delta\mathbf{x}
f ( x + Δ x ) ≈ f ( x ) + ∇ f ( x ) T Δ x
我们将梯度下降里的参数和变量带入进去,便可以得到:
L ( θ − η ∇ L ( θ ) ) ≈ L ( θ ) − η ∥ ∇ L ( θ ) ∥ 2 2 \mathcal{L}(\boldsymbol{\theta}-\eta\nabla\mathcal{L}(\boldsymbol{\theta}))
\approx
\mathcal{L}(\boldsymbol{\theta})-\eta\|\nabla\mathcal{L}(\boldsymbol{\theta})\|_2^2
L ( θ − η ∇ L ( θ )) ≈ L ( θ ) − η ∥∇ L ( θ ) ∥ 2 2
所以当 η \eta η 足够小的时候,可以认为是线性近似,即损失降低。沿着负梯度方向移动,并且学习率 η \eta η 为大于零的正数,所以是减去梯度而非加上,这里要做好区分。不过只有理论还是太难懂了,我们结合具体的例子进行讲解。
假设目前我们有五个点是这样的:(1, 2),(2, 5),(3, 6),(4, 8),(5, 9),我们用 y = w x y = wx y = w x 去拟合,通过不断改变 w w w 我们可以得到不同的损失值,大家可以拖动下面的滚动条直观的看一下拟合曲线关于参数的变化以及参数变化带来的损失变化。
插句题外话,这里我们用的损失是均方误差,为什么大多数情况我们不用绝对值误差呢,从这里也可以看出来,如果用的是绝对值误差,那么它的变化不是平滑的,就导致有点不可微,进而导致梯度无法定义,这也是很少使用绝对值误差的一个原因。
作为人类,我们当然可以肉眼的找出这个最优点在哪,但是机器不知道,它所能做的就是从一个点开始不断的尝试,梯度为我们确定了尝试的方向,而学习率就是在该方向上尝试的程度。不过学习率选取不当也可能造成一系列问题。比如学习率过大会导致可能跳过最优解,然后在最优解两侧不断震荡徘徊或者干脆彻底错过;过小则导致收敛慢、时间长。所以学习率的选取是模型能否成功训练的重要依据。为了解决学习率选取不当的问题,我们常见的方法是学习率衰减法和自适应学习率、学习率预热等,具体将在下一小章节介绍。
回到主线,我们继续讲解。大模型的参数肯定不止一个,它往往是很多的,我们也要对其进行升维。以二维为例,假设我们的预测方程变成了 y = w x + b y = wx + b y = w x + b ,增加一个 b b b 轴后,我们的示意图也变为如下图:
我们将两个参数组成参数向量:
θ t = [ w t b t ] \boldsymbol{\theta}_t=
\begin{bmatrix}
w_t\\
b_t
\end{bmatrix}
θ t = [ w t b t ]
在第 t t t 步,损失函数对参数的梯度为:
∇ θ L ( θ t ) = [ ∂ L ∂ w ∣ ( w t , b t ) ∂ L ∂ b ∣ ( w t , b t ) ] \nabla_{\boldsymbol{\theta}}\mathcal{L}(\boldsymbol{\theta}_t)=
\begin{bmatrix}
\left.\dfrac{\partial\mathcal{L}}{\partial w}\right|_{(w_t,b_t)}\\[6pt]
\left.\dfrac{\partial\mathcal{L}}{\partial b}\right|_{(w_t,b_t)}
\end{bmatrix}
∇ θ L ( θ t ) = ∂ w ∂ L ( w t , b t ) ∂ b ∂ L ( w t , b t )
这里的两个偏导数都在同一组当前参数 ( w t , b t ) (w_t,b_t) ( w t , b t ) 处计算。随后,两个参数同时更新:
θ t + 1 = θ t − η ∇ θ L ( θ t ) \boldsymbol{\theta}_{t+1}=
\boldsymbol{\theta}_t-\eta\nabla_{\boldsymbol{\theta}}\mathcal{L}(\boldsymbol{\theta}_t)
θ t + 1 = θ t − η ∇ θ L ( θ t )
展开即为:
[ w t + 1 b t + 1 ] = [ w t b t ] − η [ ∂ L ∂ w ∣ ( w t , b t ) ∂ L ∂ b ∣ ( w t , b t ) ] \begin{bmatrix}
w_{t+1}\\
b_{t+1}
\end{bmatrix}
=
\begin{bmatrix}
w_t\\
b_t
\end{bmatrix}
-\eta
\begin{bmatrix}
\left.\dfrac{\partial\mathcal{L}}{\partial w}\right|_{(w_t,b_t)}\\[6pt]
\left.\dfrac{\partial\mathcal{L}}{\partial b}\right|_{(w_t,b_t)}
\end{bmatrix}
[ w t + 1 b t + 1 ] = [ w t b t ] − η ∂ w ∂ L ( w t , b t ) ∂ b ∂ L ( w t , b t )
还是以给出的五个点为例,我们假设初始 θ = [ 0 0 ] T \boldsymbol{\theta}=\begin{bmatrix}0 & 0\end{bmatrix}^{\mathrm{T}} θ = [ 0 0 ] T ,学习率 η = 0.005 \eta = 0.005 η = 0.005 ,我们接下来展示更新过程:
t θ t = [ w t , b t ] T ∇ θ L ( θ t ) θ t + 1 L ( θ t ) 0 [ 0.000 , 0.000 ] T [ − 42.800 , − 12.000 ] T [ 0.214 , 0.060 ] T 42.000 1 [ 0.214 , 0.060 ] T [ − 37.732 , − 10.596 ] T [ 0.403 , 0.113 ] T 32.705 3 [ 0.569 , 0.160 ] T [ − 29.324 , − 8.267 ] T [ 0.716 , 0.201 ] T 19.863 10 [ 1.295 , 0.366 ] T [ − 12.125 , − 3.501 ] T [ 1.355 , 0.383 ] T 3.613 30 [ 1.764 , 0.510 ] T [ − 0.945 , − 0.400 ] T [ 1.768 , 0.512 ] T 0.268 100 [ 1.793 , 0.563 ] T [ 0.031 , − 0.114 ] T [ 1.793 , 0.564 ] T 0.241 500 [ 1.747 , 0.729 ] T [ 0.016 , − 0.058 ] T [ 1.747 , 0.729 ] T 0.225 1000 [ 1.720 , 0.827 ] T [ 0.007 , − 0.025 ] T [ 1.720 , 0.827 ] T 0.221 10000 [ 1.700 , 0.900 ] T [ 1.675 × 10 − 9 , − 6.048 × 10 − 9 ] T [ 1.700 , 0.900 ] T 0.220 \begin{array}{|c|c|c|c|c|}
\hline
\rule[-2.25ex]{0pt}{5.5ex}
\quad t\quad
& \quad\boldsymbol{\theta}_t=[w_t,b_t]^{\mathrm{T}}\quad
& \quad\nabla_{\boldsymbol{\theta}}\mathcal{L}(\boldsymbol{\theta}_t)\quad
& \quad\boldsymbol{\theta}_{t+1}\quad
& \quad\mathcal{L}(\boldsymbol{\theta}_t)\quad
\\ \hline
\rule[-1.75ex]{0pt}{4.5ex}
0
& [0.000,\ 0.000]^{\mathrm{T}}
& [-42.800,\ -12.000]^{\mathrm{T}}
& [0.214,\ 0.060]^{\mathrm{T}}
& 42.000
\\ \hline
\rule[-1.75ex]{0pt}{4.5ex}
1
& [0.214,\ 0.060]^{\mathrm{T}}
& [-37.732,\ -10.596]^{\mathrm{T}}
& [0.403,\ 0.113]^{\mathrm{T}}
& 32.705
\\ \hline
\rule[-1.75ex]{0pt}{4.5ex}
3
& [0.569,\ 0.160]^{\mathrm{T}}
& [-29.324,\ -8.267]^{\mathrm{T}}
& [0.716,\ 0.201]^{\mathrm{T}}
& 19.863
\\ \hline
\rule[-1.75ex]{0pt}{4.5ex}
10
& [1.295,\ 0.366]^{\mathrm{T}}
& [-12.125,\ -3.501]^{\mathrm{T}}
& [1.355,\ 0.383]^{\mathrm{T}}
& 3.613
\\ \hline
\rule[-1.75ex]{0pt}{4.5ex}
30
& [1.764,\ 0.510]^{\mathrm{T}}
& [-0.945,\ -0.400]^{\mathrm{T}}
& [1.768,\ 0.512]^{\mathrm{T}}
& 0.268
\\ \hline
\rule[-1.75ex]{0pt}{4.5ex}
100
& [1.793,\ 0.563]^{\mathrm{T}}
& [0.031,\ -0.114]^{\mathrm{T}}
& [1.793,\ 0.564]^{\mathrm{T}}
& 0.241
\\ \hline
\rule[-1.75ex]{0pt}{4.5ex}
500
& [1.747,\ 0.729]^{\mathrm{T}}
& [0.016,\ -0.058]^{\mathrm{T}}
& [1.747,\ 0.729]^{\mathrm{T}}
& 0.225
\\ \hline
\rule[-1.75ex]{0pt}{4.5ex}
1000
& [1.720,\ 0.827]^{\mathrm{T}}
& [0.007,\ -0.025]^{\mathrm{T}}
& [1.720,\ 0.827]^{\mathrm{T}}
& 0.221
\\ \hline
\rule[-1.75ex]{0pt}{4.5ex}
10000
& [1.700,\ 0.900]^{\mathrm{T}}
& [1.675\times10^{-9},\ -6.048\times10^{-9}]^{\mathrm{T}}
& [1.700,\ 0.900]^{\mathrm{T}}
& 0.220
\\ \hline
\end{array}
t 0 1 3 10 30 100 500 1000 10000 θ t = [ w t , b t ] T [ 0.000 , 0.000 ] T [ 0.214 , 0.060 ] T [ 0.569 , 0.160 ] T [ 1.295 , 0.366 ] T [ 1.764 , 0.510 ] T [ 1.793 , 0.563 ] T [ 1.747 , 0.729 ] T [ 1.720 , 0.827 ] T [ 1.700 , 0.900 ] T ∇ θ L ( θ t ) [ − 42.800 , − 12.000 ] T [ − 37.732 , − 10.596 ] T [ − 29.324 , − 8.267 ] T [ − 12.125 , − 3.501 ] T [ − 0.945 , − 0.400 ] T [ 0.031 , − 0.114 ] T [ 0.016 , − 0.058 ] T [ 0.007 , − 0.025 ] T [ 1.675 × 1 0 − 9 , − 6.048 × 1 0 − 9 ] T θ t + 1 [ 0.214 , 0.060 ] T [ 0.403 , 0.113 ] T [ 0.716 , 0.201 ] T [ 1.355 , 0.383 ] T [ 1.768 , 0.512 ] T [ 1.793 , 0.564 ] T [ 1.747 , 0.729 ] T [ 1.720 , 0.827 ] T [ 1.700 , 0.900 ] T L ( θ t ) 42.000 32.705 19.863 3.613 0.268 0.241 0.225 0.221 0.220
可视化交互训练过程大家可以操作下面这部分进行进一步理解:
因为训练集的样本可能有很多,每个样本都能产生对应的损失和梯度,所以计算梯度时我们也有以下不同的方式:
全量梯度下降(Batch Gradient Descent,BGD)
每次更新参数时,使用整个训练集计算梯度,求平均后更新一次参数。
例如,训练集有五个样本,就在同一组当前参数下计算这五个样本的梯度,取平均后更新。我们前面使用五个点的例子就是这种方法。
梯度能够准确反映整个训练集的当前损失变化方向,但当数据量很大时,每次更新的计算成本也比较高。
我们前文展示的更新过程采用的就是这种方法。
随机梯度下降(Stochastic Gradient Descent,SGD)
每次更新参数时,只使用一个样本计算梯度,然后立即更新参数。
例如,将五个样本随机打乱,使用第一个样本计算梯度并更新参数,再用更新后的参数处理第二个样本,依次进行。
每次更新的计算成本较低,但单个样本的梯度可能与整个训练集的梯度差别较大,因此下降过程通常会有波动,损失也不一定每一步都下降。
具体过程可见下图:
小批量梯度下降(Mini-batch Gradient Descent,MBGD)
每次更新参数时,使用一小批样本计算梯度,求平均后更新一次参数。
例如,将五个样本随机打乱,分成大小为 2、2、1 的三个小批次,每处理完一个小批次就更新一次参数。
它兼顾了计算效率和梯度的稳定性,也便于利用硬件进行并行计算,是深度学习训练中最常用的方式。实际讨论中,“SGD”有时也泛指采用小批量更新的方法,需要结合上下文区分。
4.4.3 学习率与优化器
这部分我们要讲一个机器学习中极为重要的参数——学习率,在前文中,我们一直用一个固定的学习率 η \eta η 作为参数来计算梯度,而对于其取值我们也事先设定了一个数字,但实际上,只要我们换一个学习率,我们的训练过程就会发生变化,所以为了使我们的模型训练效果更好,我们将讲解如何更好的选择学习率、以及如何让学习率参考更多的已有信息。
回到前文中的更新,我们发现代入不同的学习率,可以得到如下不同的结果:
学习率 η \eta η
当前梯度
更新后的 w 1 w_1 w 1
0.001 0.001 0.001
− 42.8 -42.8 − 42.8
0.0428 0.0428 0.0428
0.005 0.005 0.005
− 42.8 -42.8 − 42.8
0.214 0.214 0.214
0.010 0.010 0.010
− 42.8 -42.8 − 42.8
0.428 0.428 0.428
我们会发现,梯度相同时,学习率越大,该步参数的变化也越大。因此学习率可以理解为对当前参数梯度采用多大的更新幅度。这里要注意的是学习率本身不是参数实际变化的距离,参数真正的变化量是:
Δ w = − η ∂ L ∂ w \Delta w=-\eta\frac{\partial\mathcal{L}}{\partial w}
Δ w = − η ∂ w ∂ L
该变化量同时取决于梯度和学习率,学习率的大小直接影响训练过程:如果学习率很小,损失下降的速度很慢,浪费资源;反之则可能越过较优位置,在两侧来回震荡,甚至越走越远。下图展示了不同学习率下同一参数模型的移动轨迹和损失曲线:
实际训练过程中,学习率会收到数据、模型、损失函数以及更新方法的影响,该例子只是针对当前演示选择的一个数值,并不适用所有模型。
我们接下来讲解一下优化器(Optimizer),可以将其理解为模型负责更新参数的方法。
我们在每次更新时,最基本的更新方式如下:
θ t + 1 = θ t − η t g t \boldsymbol{\theta}_{t+1}
=
\boldsymbol{\theta}_t-\eta_t\mathbf{g}_t
θ t + 1 = θ t − η t g t
其中,g t \mathbf{g}_t g t 表示这一步使用的梯度。
这个方法是最基本的方法,仅需要当前参数、梯度以及学习率即可完成更新,但缺点也显而易见,它无法参考训练过程中的其他信息,只是极限的按照一个参数进行固定的更新方式。为了优化这种更新方式,我们可以增加一些信息进行参考,例如前几步的梯度、不同参数的梯度大小等,便由此得到了其他更新方式。考虑篇幅,我们仅介绍最重要的几个方法:Momentum、RMSProp、Adam等。
这里需要区分一下前面介绍的三种梯度下降(全量、随机和小批量梯度下降)与这里方式的区别。前者决定每次使用哪些样本计算梯度 ,后者决定得到梯度以后怎样去更新参数 ,这里读者要自行做好区分。
Momentum的思路是记录之前的方向。假设我们连续多步得到的梯度都指向一个相近的方向,这样持续出现的信息,可以帮助我们判断参数的变化趋势。
这里的方向不要理解为正负,而是参数向量所指向的方向。假设目前向量维度为2,连续几步梯度都是 ( + 2 , − 1 ) (+2, -1) ( + 2 , − 1 ) 附近,说明该阶段变化朝向 ( + 2 , − 1 ) (+2, -1) ( + 2 , − 1 ) 这个方向,而且第一个参数走的比第二个参数要快,因为数值更大。如果下一步变成 ( + 1.9 , − 0.9 ) (+1.9, -0.9) ( + 1.9 , − 0.9 ) ,那么也算方向接近。
这里正式介绍一下,Momentum 通常翻译为动量 ,它的基本思路就是:保留一部分之前的方向信息,再加入当前梯度,得到这一步使用的更新方向。结合动量这个名字,也可以知道它实际上可以理解为让惯性来参与更新。
为了更容易理解,我们先只考虑一个参数。
用 m t m_t m t 表示已经记录下来的信息,那么一种写法就是:
m t + 1 = β m t + ( 1 − β ) g t m_{t + 1} = \beta m_t + (1 - \beta)g_t
m t + 1 = β m t + ( 1 − β ) g t
其中, g t g_t g t 是当前梯度, β \beta β 是我们设置的系数,范围为 [ 0 , 1 ) [0, 1) [ 0 , 1 ) ,用于表示历史信息保留多少,当前信息取多少。
例如取 β = 0.5 \beta = 0.5 β = 0.5 ,就相当于历史信息和当前梯度各自保留一半。
然后使用这个记录进行参数的更新:
θ t + 1 = θ t − η t m t + 1 \theta_{t+1}=\theta_t-\eta_t m_{t+1}
θ t + 1 = θ t − η t m t + 1
为了便于理解,我们这里举一个例子:
取 β = 0.3 \beta = 0.3 β = 0.3 ,η = 0.1 \eta = 0.1 η = 0.1 ,初始参数和动量均为0:
θ 0 = [ 0 0 ] , m 0 = [ 0 0 ] \boldsymbol{\theta}_0=
\begin{bmatrix}0\\0\end{bmatrix},
\qquad
\mathbf{m}_0=
\begin{bmatrix}0\\0\end{bmatrix}
θ 0 = [ 0 0 ] , m 0 = [ 0 0 ]
假设已有的梯度如下:
g 0 = [ 4 2 ] , g 1 = [ 6 − 2 ] , g 2 = [ − 2 4 ] \mathbf{g}_0=
\begin{bmatrix}4\\2\end{bmatrix},
\qquad
\mathbf{g}_1=
\begin{bmatrix}6\\-2\end{bmatrix},
\qquad
\mathbf{g}_2=
\begin{bmatrix}-2\\4\end{bmatrix}
g 0 = [ 4 2 ] , g 1 = [ 6 − 2 ] , g 2 = [ − 2 4 ]
根据前文介绍,我们可以得到我们的更新公示如下:
m t + 1 = 0.3 m t + 0.7 g t \mathbf{m}_{t+1}=0.3\mathbf{m}_t+0.7\mathbf{g}_t
m t + 1 = 0.3 m t + 0.7 g t
θ t + 1 = θ t − 0.1 m t + 1 \boldsymbol{\theta}_{t+1}
=
\boldsymbol{\theta}_t-0.1\mathbf{m}_{t+1}
θ t + 1 = θ t − 0.1 m t + 1
我们开始进行梯度更新,第一步:
m 1 = 0.3 [ 0 0 ] + 0.7 [ 4 2 ] = [ 2.8 1.4 ] \mathbf{m}_1
=
0.3\begin{bmatrix}0\\0\end{bmatrix}
+
0.7\begin{bmatrix}4\\2\end{bmatrix}
=
\begin{bmatrix}2.8\\1.4\end{bmatrix}
m 1 = 0.3 [ 0 0 ] + 0.7 [ 4 2 ] = [ 2.8 1.4 ]
θ 1 = [ 0 0 ] − 0.1 [ 2.8 1.4 ] = [ − 0.28 − 0.14 ] \boldsymbol{\theta}_1
=
\begin{bmatrix}0\\0\end{bmatrix}
-
0.1\begin{bmatrix}2.8\\1.4\end{bmatrix}
=
\begin{bmatrix}-0.28\\-0.14\end{bmatrix}
θ 1 = [ 0 0 ] − 0.1 [ 2.8 1.4 ] = [ − 0.28 − 0.14 ]
第二步:
m 2 = 0.3 [ 2.8 1.4 ] + 0.7 [ 6 − 2 ] = [ 5.04 − 0.98 ] \mathbf{m}_2
=
0.3\begin{bmatrix}2.8\\1.4\end{bmatrix}
+
0.7\begin{bmatrix}6\\-2\end{bmatrix}
=
\begin{bmatrix}5.04\\-0.98\end{bmatrix}
m 2 = 0.3 [ 2.8 1.4 ] + 0.7 [ 6 − 2 ] = [ 5.04 − 0.98 ]
θ 2 = [ − 0.28 − 0.14 ] − 0.1 [ 5.04 − 0.98 ] = [ − 0.784 − 0.042 ] \boldsymbol{\theta}_2
=
\begin{bmatrix}-0.28\\-0.14\end{bmatrix}
-
0.1\begin{bmatrix}5.04\\-0.98\end{bmatrix}
=
\begin{bmatrix}-0.784\\-0.042\end{bmatrix}
θ 2 = [ − 0.28 − 0.14 ] − 0.1 [ 5.04 − 0.98 ] = [ − 0.784 − 0.042 ]
第三步:
m 3 = 0.3 [ 5.04 − 0.98 ] + 0.7 [ − 2 4 ] = [ 0.112 2.506 ] \mathbf{m}_3
=
0.3\begin{bmatrix}5.04\\-0.98\end{bmatrix}
+
0.7\begin{bmatrix}-2\\4\end{bmatrix}
=
\begin{bmatrix}0.112\\2.506\end{bmatrix}
m 3 = 0.3 [ 5.04 − 0.98 ] + 0.7 [ − 2 4 ] = [ 0.112 2.506 ]
θ 3 = [ − 0.784 − 0.042 ] − 0.1 [ 0.112 2.506 ] = [ − 0.7952 − 0.2926 ] \boldsymbol{\theta}_3
=
\begin{bmatrix}-0.784\\-0.042\end{bmatrix}
-
0.1\begin{bmatrix}0.112\\2.506\end{bmatrix}
=
\begin{bmatrix}-0.7952\\-0.2926\end{bmatrix}
θ 3 = [ − 0.784 − 0.042 ] − 0.1 [ 0.112 2.506 ] = [ − 0.7952 − 0.2926 ]
通过这种方法,我们的更新可以参考一部分过去的梯度方向信息,来回变化的信息便可以抵消掉了。
上面的记录方式为指数移动平均 ,这种方法不需要我们记录所有历史梯度,只要保存上一步的记录再加入当前梯度即可,较早的信息变回通过乘以系数过程中不断减弱。这种方式的意义主要体现在当移动到狭长的谷地中,普通梯度下降可能再两侧来回摆动,动量可以帮助积累沿谷底前进的方向信息,不过也可能因为该方向信息“过重”而越过合适的位置。
下面我们用一组数据(并非上面给出的数据)来演示一下这种更新方式的过程以及其与普通梯度下降在更新效果上的对比:
需要注意,不同资料中的动量公式可能略有不同。本文采用上述指数移动平均的写法,后面也会继续使用这一形式。
前面介绍的 Momentum,会把之前的梯度记录下来,帮助我们决定这一步使用的更新方向。不顾哦我们还可以考虑另一个问题,即不同参数对应的梯度,数值大小可能相差很多。
比如假设我们当前又两个参数,其对应的梯度为 ( 20 , 1 ) (20, 1) ( 20 , 1 ) ,学习率为 0.1 0.1 0.1 。如果我们直接使用普通梯度下降,那么这一步参数变化量就是 ( − 2 , − 0.1 ) (-2, -0.1) ( − 2 , − 0.1 ) 。可以看出第一个参数的变化幅度是第二个参数变化幅度的 20 20 20 倍。
如果这种差异连续出现,那么使用同一个学习率,就可能让一部分参数变得异常剧烈,亦或者是一部分参数变得极为缓慢。我们希望的是根据每个参数最近的梯度情况,分别调整它们的更新幅度。
RMSProp 的基本思路就是:记录每个参数近期梯度的大小,再用这个记录对当前梯度进行缩放。
这里的“大小”,一般用梯度的平方来记录,这样出现 3 3 3 与 − 3 -3 − 3 时,平方都是 9 9 9 ,即保留了大小,也取消了方向上带来的抵消,同时使得较大的数值表现更为敏感。
用 v t v_t v t 表示已经记录下来的梯度平方信息,那么一种写法就是:
v t + 1 = ρ v t + ( 1 − ρ ) g t 2 v_{t+1}=\rho v_t+(1-\rho)g_t^2
v t + 1 = ρ v t + ( 1 − ρ ) g t 2
其中,g t g_t g t 是当前梯度,ρ \rho ρ 是我们设置的系数,范围为 0 ≤ ρ < 1 0\leq\rho<1 0 ≤ ρ < 1 ,用来控制历史信息保留多少、当前信息加入多少。它与前文中的 β \beta β 起到类似的作用,这里使用不同字母,是为了方便区分。
这里我们可以发现,此处仍然使用了指数移动平均,只是记录的信息变为了梯度的平方以保留梯度的大小这一信息。
我们用于更新参数的公示是下面这个:
θ t + 1 = θ t − η t g t v t + 1 + ϵ \theta_{t+1}
=\theta_t-\eta_t\frac{g_t}{\sqrt{v_{t+1}}+\epsilon}
θ t + 1 = θ t − η t v t + 1 + ϵ g t
我们一步步分析这个公示,其中 v t + 1 v_{t + 1} v t + 1 记录的是平方后的数值,和梯度对应的数值尺度不在一个量纲,为了统一量纲我们需要对其进行开方。然后用梯度除以这个数值,调整它在这一步更新的大小。固定梯度,分母越大那么这一步更新的幅度就越小,反之则越大。也就是说,某个参数近期经常出现较大的梯度,那么其对应的分母通常也会交大,从而对它的更新起一个缩放作用。
这里的 ϵ \epsilon ϵ 是一个很小的正数,例如 10 − 8 10^{-8} 1 0 − 8 或者其他更小的数,用于避免分母为 0 0 0 导致运行错误的情况,并改善数值的稳定性。
这里是一个参数的例子,在实际训练过程中我们往往出现多个参数,那么每个参数都需要维护自己的记录。比如,对参数向量 θ = [ w , b ] T \boldsymbol{\theta}=[w,b]^{\mathrm{T}} θ = [ w , b ] T ,就需要分别记录 w w w 和 b b b 对应的梯度平方信息。
有些人在这里可能会有这样的误解,因为我们分母是一个长度大小,而分子作为梯度是一个向量,即有方向有大小的量,初学者可能会产生这样的疑问,如果是这样,那么:
d = g ∥ g ∥ 2 \mathbf{d} = \frac{\mathbf{g}}{\|\mathbf{g}\|_2}
d = ∥ g ∥ 2 g
根据这个公示,我们岂不是得到了一个单位方向向量?其实这是一个很大的误区,因为实际上分母并不是对梯度本身进行开方,即得到的不是当前梯度的大小。分母实际上是历史各参数大小均方根大小,借它对当前梯度进行的一种归一化处理。分母越大,则说明要抑制这种“大”,所以当前梯度相对缩放,分子除以一个较大的数来实现缩放;反之同理。
我们接着举例说明。
为了便于理解,我们重新假设连续三步的梯度如下:
g 0 = [ 8 2 ] , g 1 = [ 10 1 ] , g 2 = [ 6 3 ] \mathbf{g}_0=
\begin{bmatrix}8\\2\end{bmatrix},
\qquad
\mathbf{g}_1=
\begin{bmatrix}10\\1\end{bmatrix},
\qquad
\mathbf{g}_2=
\begin{bmatrix}6\\3\end{bmatrix}
g 0 = [ 8 2 ] , g 1 = [ 10 1 ] , g 2 = [ 6 3 ]
这里,第一个参数对应的梯度分量连续三步都大于第二个参数对应的梯度分量。我们通过这个例子,观察 RMSProp 如何根据各自的历史记录,调整两个参数的更新幅度。
取 ρ = 0.3 \rho=0.3 ρ = 0.3 ,η = 0.1 \eta=0.1 η = 0.1 ,ϵ = 10 − 8 \epsilon=10^{-8} ϵ = 1 0 − 8 ,初始参数和平方记录均为 0 0 0 :
θ 0 = [ 0 0 ] , v 0 = [ 0 0 ] \boldsymbol{\theta}_0=
\begin{bmatrix}0\\0\end{bmatrix},
\qquad
\mathbf{v}_0=
\begin{bmatrix}0\\0\end{bmatrix}
θ 0 = [ 0 0 ] , v 0 = [ 0 0 ]
下面显示的参数结果保留六位小数,后续计算仍使用未舍入的数值。
我们开始进行更新,第一步:
v 1 = 0.3 [ 0 0 ] + 0.7 [ 8 2 2 2 ] = [ 44.8 2.8 ] \mathbf{v}_1
=0.3\begin{bmatrix}0\\0\end{bmatrix}
+0.7\begin{bmatrix}8^2\\2^2\end{bmatrix}
=\begin{bmatrix}44.8\\2.8\end{bmatrix}
v 1 = 0.3 [ 0 0 ] + 0.7 [ 8 2 2 2 ] = [ 44.8 2.8 ]
θ 1 = [ 0 0 ] − 0.1 [ 8 44.8 + ϵ 2 2.8 + ϵ ] ≈ [ − 0.119523 − 0.119523 ] \boldsymbol{\theta}_1
=\begin{bmatrix}0\\0\end{bmatrix}
-0.1\begin{bmatrix}
\dfrac{8}{\sqrt{44.8}+\epsilon}\\[8pt]
\dfrac{2}{\sqrt{2.8}+\epsilon}
\end{bmatrix}
\approx\begin{bmatrix}-0.119523\\-0.119523\end{bmatrix}
θ 1 = [ 0 0 ] − 0.1 44.8 + ϵ 8 2.8 + ϵ 2 ≈ [ − 0.119523 − 0.119523 ]
这一步中,第一个梯度分量是第二个的 4 4 4 倍,但对应的分母也几乎是第二个的 4 4 4 倍,所以最后两个参数的更新幅度几乎相同。如果直接使用普通梯度下降,这一步的参数变化量则为 ( − 0.8 , − 0.2 ) (-0.8,-0.2) ( − 0.8 , − 0.2 ) 。
第二步:
v 2 = 0.3 [ 44.8 2.8 ] + 0.7 [ 10 2 1 2 ] = [ 83.44 1.54 ] \mathbf{v}_2
=0.3\begin{bmatrix}44.8\\2.8\end{bmatrix}
+0.7\begin{bmatrix}10^2\\1^2\end{bmatrix}
=\begin{bmatrix}83.44\\1.54\end{bmatrix}
v 2 = 0.3 [ 44.8 2.8 ] + 0.7 [ 1 0 2 1 2 ] = [ 83.44 1.54 ]
θ 2 = θ 1 − 0.1 [ 10 83.44 + ϵ 1 1.54 + ϵ ] ≈ [ − 0.228997 − 0.200105 ] \boldsymbol{\theta}_2
=\boldsymbol{\theta}_1
-0.1\begin{bmatrix}
\dfrac{10}{\sqrt{83.44}+\epsilon}\\[8pt]
\dfrac{1}{\sqrt{1.54}+\epsilon}
\end{bmatrix}
\approx\begin{bmatrix}-0.228997\\-0.200105\end{bmatrix}
θ 2 = θ 1 − 0.1 83.44 + ϵ 10 1.54 + ϵ 1 ≈ [ − 0.228997 − 0.200105 ]
这一步中,两个当前梯度分量的大小相差 10 10 10 倍,但经过各自的历史尺度缩放后,两个参数的变化量约为 ( − 0.109474 , − 0.080582 ) (-0.109474,-0.080582) ( − 0.109474 , − 0.080582 ) ,更新幅度之间的差距明显缩小。
第三步:
v 3 = 0.3 [ 83.44 1.54 ] + 0.7 [ 6 2 3 2 ] = [ 50.232 6.762 ] \mathbf{v}_3
=0.3\begin{bmatrix}83.44\\1.54\end{bmatrix}
+0.7\begin{bmatrix}6^2\\3^2\end{bmatrix}
=\begin{bmatrix}50.232\\6.762\end{bmatrix}
v 3 = 0.3 [ 83.44 1.54 ] + 0.7 [ 6 2 3 2 ] = [ 50.232 6.762 ]
θ 3 = θ 2 − 0.1 [ 6 50.232 + ϵ 3 6.762 + ϵ ] ≈ [ − 0.313654 − 0.315473 ] \boldsymbol{\theta}_3
=\boldsymbol{\theta}_2
-0.1\begin{bmatrix}
\dfrac{6}{\sqrt{50.232}+\epsilon}\\[8pt]
\dfrac{3}{\sqrt{6.762}+\epsilon}
\end{bmatrix}
\approx\begin{bmatrix}-0.313654\\-0.315473\end{bmatrix}
θ 3 = θ 2 − 0.1 50.232 + ϵ 6 6.762 + ϵ 3 ≈ [ − 0.313654 − 0.315473 ]
这一步中,虽然第一个参数的梯度仍然较大,但是因为它的历史尺度也比较大,所以缩放程度较大,在这种机制下,第二个参数的变量量反而更大一些。可以看到该方法并不是把两个参数的每一步的更新幅度都强行变为相同的数值,而是根据各自近期的梯度尺度进行调整。当前梯度和历史信息同时影响实际的更新幅度。
通过这种方法,每个参数都可以根据自己的近期的梯度情况,使用不同的缩放比例。对于第 j j j 个参数,我们也可以把它写成:
θ t + 1 , j = θ t , j − η t v t + 1 , j + ϵ ⏟ 该参数此时的有效学习率 g t , j \theta_{t+1,j}
=\theta_{t,j}
-\underbrace{\frac{\eta_t}{\sqrt{v_{t+1,j}}+\epsilon}}_{\text{该参数此时的有效学习率}}
g_{t,j}
θ t + 1 , j = θ t , j − 该参数此时的有效学习率 v t + 1 , j + ϵ η t g t , j
这其实也是“自适应”的一种体现,即基础学习率不变的情况下,不同参数、不同时间的有效学习率也会随着历史信息的改变而改变。
不过有效学习率仍然需要乘以梯度才能得到实际的参数变化量,该方法也仍然需要我们设置一个基础学东西率。在历史信息被不断记录的过程中,并不意味着所有更新都一定更小,或者一定能够收敛,具体情况都依靠历史信息而定。
为了更直观的看出 RMSProp 和普通梯度下降的方法,我们仍旧给出可视化过程,大家可以自行观看:
前面两种方法,一个记录了梯度的大小、一个记录的梯度的方向。我们已经学习了计算机领域的很多科目,都会发现一个很大的特色,即如果 A A A 可行,B B B 可行,那么一定存在一个适中的 A + B A + B A + B 也可行的折中套路。在这里我们也不禁要想,有没有一种方法,同时维护这两种信息呢?
Adam 的基本思路就是:同时记录梯度和梯度平方这两个信息,使用前者更新方向、后者调整各个参数的更新幅度,再对零初始化带来的影响进行修正。
这里仍然以一个参数为例,我们用 m t m_t m t 记录梯度信息,用 v t v_t v t 来记录梯度的平方信息以保留大小。
m t + 1 = β 1 m t + ( 1 − β 1 ) g t m_{t+1}=\beta_1m_t+(1-\beta_1)g_t
m t + 1 = β 1 m t + ( 1 − β 1 ) g t
v t + 1 = β 2 v t + ( 1 − β 2 ) g t 2 v_{t+1}=\beta_2v_t+(1-\beta_2)g_t^2
v t + 1 = β 2 v t + ( 1 − β 2 ) g t 2
其中,β 1 \beta_1 β 1 和 β 2 \beta_2 β 2 都位于 [ 0 , 1 ) [0,1) [ 0 , 1 ) ,分别控制这两份记录对历史信息的保留程度。它们可以取不同的值,因为记录方向和记录平方大小,不一定需要使用相同的保留比例。
在一些资料中,m t m_t m t 被称为梯度的一阶矩估计 ,v t v_t v t 被称为梯度的二阶原点矩估计 。这里可以先把它们理解为梯度的平均信息和梯度平方的平均信息。后者没有减去均值,所以不能直接把它当成方差。
不过,Adam 还多做了一步。前面我们把初始记录设置为 0 0 0 ,这会使训练刚开始时的记录受到这个初始值的影响。为了看得更清楚,我们把前两步的记录展开:
m 1 = ( 1 − β 1 ) g 0 m_1=(1-\beta_1)g_0
m 1 = ( 1 − β 1 ) g 0
m 2 = β 1 ( 1 − β 1 ) g 0 + ( 1 − β 1 ) g 1 m_2=\beta_1(1-\beta_1)g_0+(1-\beta_1)g_1
m 2 = β 1 ( 1 − β 1 ) g 0 + ( 1 − β 1 ) g 1
第一步中,已观察梯度的权重总和为 1 − β 1 1-\beta_1 1 − β 1 ;第二步中,权重总和为 1 − β 1 2 1-\beta_1^2 1 − β 1 2 。同样地,完成 t + 1 t+1 t + 1 次记录更新后,这个总和就是 1 − β 1 t + 1 1-\beta_1^{t+1} 1 − β 1 t + 1 。
因此,Adam 会用记录除以这个系数,进行偏差修正 :
m ^ t + 1 = m t + 1 1 − β 1 t + 1 \hat{m}_{t+1}=\frac{m_{t+1}}{1-\beta_1^{t+1}}
m ^ t + 1 = 1 − β 1 t + 1 m t + 1
v ^ t + 1 = v t + 1 1 − β 2 t + 1 \hat{v}_{t+1}=\frac{v_{t+1}}{1-\beta_2^{t+1}}
v ^ t + 1 = 1 − β 2 t + 1 v t + 1
这里的帽子表示修正后的记录。上标 t + 1 t+1 t + 1 表示乘方,因为本文从 g 0 \mathbf{g}_0 g 0 开始计数,所以第一步对应的指数是 1 1 1 。
然后,使用修正后的两份记录更新参数:
θ t + 1 = θ t − η t m ^ t + 1 v ^ t + 1 + ϵ \theta_{t+1}
=\theta_t-\eta_t\frac{\hat{m}_{t+1}}{\sqrt{\hat{v}_{t+1}}+\epsilon}
θ t + 1 = θ t − η t v ^ t + 1 + ϵ m ^ t + 1
为什么 Adam 相对其余两个方法需要进行修正?我们讲一下修正的原因。
如果不修正,我们这里举例说明,取 β 1 = 0.3 \beta_1=0.3 β 1 = 0.3 ,m 0 = 0 m_0=0 m 0 = 0 ,第一步梯度为 4 4 4 ,那么:
m 1 = 0.3 × 0 + 0.7 × 4 = 2.8 m_1=0.3\times0+0.7\times4=2.8
m 1 = 0.3 × 0 + 0.7 × 4 = 2.8
目前只观察到一个梯度 4 4 4 ,但记录得到的却是 2.8 2.8 2.8 。这与最开始加入了一个值为 0 0 0 的旧记录有关。但是修正后,刚才的 m 1 m_1 m 1 就变为了 4 4 4 。这一步修正的是零作为初始化时造成的偏小现象。
好了,我们回到主线,继续讲最重要的这条更新公示:
θ t + 1 = θ t − η t m ^ t + 1 v ^ t + 1 + ϵ \theta_{t+1}
=\theta_t-\eta_t\frac{\hat{m}_{t+1}}{\sqrt{\hat{v}_{t+1}}+\epsilon}
θ t + 1 = θ t − η t v ^ t + 1 + ϵ m ^ t + 1
可以看到,分子使用了带有历史信息的梯度记录,分母使用了梯度平方记录。分子带有了梯度的信息,分母则通过历史梯度大小这一信息进行缩放处理,通过这种方法,我们变使得训练参数可以自适应方向和大小。
我们依然举例进行说明,为了便于理解,我们继续使用前面 RMSProp 的三组假设梯度:
g 0 = [ 8 2 ] , g 1 = [ 10 1 ] , g 2 = [ 6 3 ] \mathbf{g}_0=
\begin{bmatrix}8\\2\end{bmatrix},
\qquad
\mathbf{g}_1=
\begin{bmatrix}10\\1\end{bmatrix},
\qquad
\mathbf{g}_2=
\begin{bmatrix}6\\3\end{bmatrix}
g 0 = [ 8 2 ] , g 1 = [ 10 1 ] , g 2 = [ 6 3 ]
取 β 1 = 0.3 \beta_1=0.3 β 1 = 0.3 ,β 2 = 0.9 \beta_2=0.9 β 2 = 0.9 ,η = 0.1 \eta=0.1 η = 0.1 ,ϵ = 10 − 8 \epsilon=10^{-8} ϵ = 1 0 − 8 ,初始参数和两份记录均为 0 0 0 :
θ 0 = [ 0 0 ] , m 0 = [ 0 0 ] , v 0 = [ 0 0 ] \boldsymbol{\theta}_0=
\begin{bmatrix}0\\0\end{bmatrix},
\qquad
\mathbf{m}_0=
\begin{bmatrix}0\\0\end{bmatrix},
\qquad
\mathbf{v}_0=
\begin{bmatrix}0\\0\end{bmatrix}
θ 0 = [ 0 0 ] , m 0 = [ 0 0 ] , v 0 = [ 0 0 ]
我们开始进行更新,第一步,先更新两份记录:
m 1 = 0.3 [ 0 0 ] + 0.7 [ 8 2 ] = [ 5.6 1.4 ] \mathbf{m}_1
=0.3\begin{bmatrix}0\\0\end{bmatrix}
+0.7\begin{bmatrix}8\\2\end{bmatrix}
=\begin{bmatrix}5.6\\1.4\end{bmatrix}
m 1 = 0.3 [ 0 0 ] + 0.7 [ 8 2 ] = [ 5.6 1.4 ]
v 1 = 0.9 [ 0 0 ] + 0.1 [ 8 2 2 2 ] = [ 6.4 0.4 ] \mathbf{v}_1
=0.9\begin{bmatrix}0\\0\end{bmatrix}
+0.1\begin{bmatrix}8^2\\2^2\end{bmatrix}
=\begin{bmatrix}6.4\\0.4\end{bmatrix}
v 1 = 0.9 [ 0 0 ] + 0.1 [ 8 2 2 2 ] = [ 6.4 0.4 ]
然后进行偏差修正:
m ^ 1 = m 1 1 − 0.3 1 = [ 8 2 ] , v ^ 1 = v 1 1 − 0.9 1 = [ 64 4 ] \hat{\mathbf{m}}_1
=\frac{\mathbf{m}_1}{1-0.3^1}
=\begin{bmatrix}8\\2\end{bmatrix},
\qquad
\hat{\mathbf{v}}_1
=\frac{\mathbf{v}_1}{1-0.9^1}
=\begin{bmatrix}64\\4\end{bmatrix}
m ^ 1 = 1 − 0. 3 1 m 1 = [ 8 2 ] , v ^ 1 = 1 − 0. 9 1 v 1 = [ 64 4 ]
最后更新参数:
θ 1 = [ 0 0 ] − 0.1 [ 8 64 + ϵ 2 4 + ϵ ] ≈ [ − 0.100000 − 0.100000 ] \boldsymbol{\theta}_1
=\begin{bmatrix}0\\0\end{bmatrix}
-0.1\begin{bmatrix}
\dfrac{8}{\sqrt{64}+\epsilon}\\[8pt]
\dfrac{2}{\sqrt{4}+\epsilon}
\end{bmatrix}
\approx\begin{bmatrix}-0.100000\\-0.100000\end{bmatrix}
θ 1 = [ 0 0 ] − 0.1 64 + ϵ 8 4 + ϵ 2 ≈ [ − 0.100000 − 0.100000 ]
这一步中,两个梯度分量分别为 8 8 8 和 2 2 2 ,但修正后的平方记录开方后也分别为 8 8 8 和 2 2 2 。因此,忽略很小的 ϵ \epsilon ϵ ,两个分量相除后的结果都是 1 1 1 ,两个参数的更新幅度几乎相同。
第二步,同样先更新两份记录:
m 2 = 0.3 [ 5.6 1.4 ] + 0.7 [ 10 1 ] = [ 8.68 1.12 ] \mathbf{m}_2
=0.3\begin{bmatrix}5.6\\1.4\end{bmatrix}
+0.7\begin{bmatrix}10\\1\end{bmatrix}
=\begin{bmatrix}8.68\\1.12\end{bmatrix}
m 2 = 0.3 [ 5.6 1.4 ] + 0.7 [ 10 1 ] = [ 8.68 1.12 ]
v 2 = 0.9 [ 6.4 0.4 ] + 0.1 [ 10 2 1 2 ] = [ 15.76 0.46 ] \mathbf{v}_2
=0.9\begin{bmatrix}6.4\\0.4\end{bmatrix}
+0.1\begin{bmatrix}10^2\\1^2\end{bmatrix}
=\begin{bmatrix}15.76\\0.46\end{bmatrix}
v 2 = 0.9 [ 6.4 0.4 ] + 0.1 [ 1 0 2 1 2 ] = [ 15.76 0.46 ]
进行偏差修正:
m ^ 2 = m 2 1 − 0.3 2 ≈ [ 9.538462 1.230769 ] \hat{\mathbf{m}}_2
=\frac{\mathbf{m}_2}{1-0.3^2}
\approx\begin{bmatrix}9.538462\\1.230769\end{bmatrix}
m ^ 2 = 1 − 0. 3 2 m 2 ≈ [ 9.538462 1.230769 ]
v ^ 2 = v 2 1 − 0.9 2 ≈ [ 82.947368 2.421053 ] \hat{\mathbf{v}}_2
=\frac{\mathbf{v}_2}{1-0.9^2}
\approx\begin{bmatrix}82.947368\\2.421053\end{bmatrix}
v ^ 2 = 1 − 0. 9 2 v 2 ≈ [ 82.947368 2.421053 ]
再将修正后的记录代入更新式。用 m ^ 2 , 1 \hat{m}_{2,1} m ^ 2 , 1 表示 m ^ 2 \hat{\mathbf{m}}_2 m ^ 2 的第一个分量,其他分量的记法相同:
θ 2 = θ 1 − 0.1 [ m ^ 2 , 1 v ^ 2 , 1 + ϵ m ^ 2 , 2 v ^ 2 , 2 + ϵ ] ≈ [ − 0.204731 − 0.179100 ] \boldsymbol{\theta}_2
=\boldsymbol{\theta}_1
-0.1\begin{bmatrix}
\dfrac{\hat{m}_{2,1}}{\sqrt{\hat{v}_{2,1}}+\epsilon}\\[8pt]
\dfrac{\hat{m}_{2,2}}{\sqrt{\hat{v}_{2,2}}+\epsilon}
\end{bmatrix}
\approx\begin{bmatrix}-0.204731\\-0.179100\end{bmatrix}
θ 2 = θ 1 − 0.1 v ^ 2 , 1 + ϵ m ^ 2 , 1 v ^ 2 , 2 + ϵ m ^ 2 , 2 ≈ [ − 0.204731 − 0.179100 ]
这里,当前的两个梯度分量分别为 10 10 10 和 1 1 1 ,而实际使用的梯度记录约为 9.538462 9.538462 9.538462 和 1.230769 1.230769 1.230769 。这两份数值都保留了第一步的信息,并没有完全跟随当前梯度变化。
第三步:
m 3 = 0.3 [ 8.68 1.12 ] + 0.7 [ 6 3 ] = [ 6.804 2.436 ] \mathbf{m}_3
=0.3\begin{bmatrix}8.68\\1.12\end{bmatrix}
+0.7\begin{bmatrix}6\\3\end{bmatrix}
=\begin{bmatrix}6.804\\2.436\end{bmatrix}
m 3 = 0.3 [ 8.68 1.12 ] + 0.7 [ 6 3 ] = [ 6.804 2.436 ]
v 3 = 0.9 [ 15.76 0.46 ] + 0.1 [ 6 2 3 2 ] = [ 17.784 1.314 ] \mathbf{v}_3
=0.9\begin{bmatrix}15.76\\0.46\end{bmatrix}
+0.1\begin{bmatrix}6^2\\3^2\end{bmatrix}
=\begin{bmatrix}17.784\\1.314\end{bmatrix}
v 3 = 0.9 [ 15.76 0.46 ] + 0.1 [ 6 2 3 2 ] = [ 17.784 1.314 ]
进行偏差修正:
m ^ 3 = m 3 1 − 0.3 3 ≈ [ 6.992806 2.503597 ] \hat{\mathbf{m}}_3
=\frac{\mathbf{m}_3}{1-0.3^3}
\approx\begin{bmatrix}6.992806\\2.503597\end{bmatrix}
m ^ 3 = 1 − 0. 3 3 m 3 ≈ [ 6.992806 2.503597 ]
v ^ 3 = v 3 1 − 0.9 3 ≈ [ 65.623616 4.848708 ] \hat{\mathbf{v}}_3
=\frac{\mathbf{v}_3}{1-0.9^3}
\approx\begin{bmatrix}65.623616\\4.848708\end{bmatrix}
v ^ 3 = 1 − 0. 9 3 v 3 ≈ [ 65.623616 4.848708 ]
最后更新参数:
θ 3 = θ 2 − 0.1 [ m ^ 3 , 1 v ^ 3 , 1 + ϵ m ^ 3 , 2 v ^ 3 , 2 + ϵ ] ≈ [ − 0.291053 − 0.292797 ] \boldsymbol{\theta}_3
=\boldsymbol{\theta}_2
-0.1\begin{bmatrix}
\dfrac{\hat{m}_{3,1}}{\sqrt{\hat{v}_{3,1}}+\epsilon}\\[8pt]
\dfrac{\hat{m}_{3,2}}{\sqrt{\hat{v}_{3,2}}+\epsilon}
\end{bmatrix}
\approx\begin{bmatrix}-0.291053\\-0.292797\end{bmatrix}
θ 3 = θ 2 − 0.1 v ^ 3 , 1 + ϵ m ^ 3 , 1 v ^ 3 , 2 + ϵ m ^ 3 , 2 ≈ [ − 0.291053 − 0.292797 ]
可以看到,第一个梯度分量从上一步的 10 10 10 降到 6 6 6 ,但修正后的梯度记录仍约为 6.992806 6.992806 6.992806 ;第二个梯度分量从 1 1 1 增到 3 3 3 ,修正后的记录则约为 2.503597 2.503597 2.503597 。这就体现了动量信息对变化的平滑作用。
与此同时,第一个参数对应的平方记录较大,开方后形成的分母也较大。虽然当前两个梯度分量分别为 6 6 6 和 3 3 3 ,这一更新中两个参数的变化量却约为 ( − 0.086322 , − 0.113698 ) (-0.086322,-0.113698) ( − 0.086322 , − 0.113698 ) ,在缩放后第二个参数的更新幅度反而更大一些。
通过这三步,我们就可以看到两份记录各自的作用:梯度记录保留过去的方向和数值信息,梯度平方记录提供各个分量的缩放尺度,两者共同决定最后的参数更新量。
下面是 Adam 和普通梯度下降的可视化过程,大家可以自行观看:
到这里,我们就可以大致串起来 Adam 的主要过程了:先计算梯度,然后更新两份记录,进行偏差修正,最后更新参数。下一步继续使用更新后的参数计算新的梯度,并保留新的记录。虽然 Adam 有更强的自适应能力,但不能保证每一步的损失都是下降的,也不能保证在所有任务上效果都强于其他优化器,同时他也需要设置基础学习率。
实际上,优化器并没有严格意义上的好坏之分,不是说 Adam 这些优化器一定就比最普通的梯度下降更好,亦或是说 Adam 考虑的更多就一定比前两种好,具体由真实情况而定。最后,我们也展示一下在正相关随机数据下,三种优化器以及普通梯度下降在随机数据上的表现:
以下是关于三种优化器的简单总结,大家可以简单复习一下。
优化器
参数
常用取值
作用
Momentum
学习率 η \eta η
0.01
控制更新步长
动量系数 β \beta β
0.9
控制历史梯度的影响
RMSProp
学习率 η \eta η
0.001
控制更新步长
衰减系数 ρ \rho ρ
0.9 或 0.99
控制历史平方梯度的影响
ϵ \epsilon ϵ
10 − 8 10^{-8} 1 0 − 8
防止除零
Adam
学习率 η \eta η
0.001
控制更新步长
一阶矩系数 β 1 \beta_1 β 1
0.9
控制历史梯度的影响
二阶矩系数 β 2 \beta_2 β 2
0.999
控制历史平方梯度的影响
ϵ \epsilon ϵ
10 − 8 10^{-8} 1 0 − 8
防止除零
注意:这些是常用经验起点,不是通用最优值。不同框架的默认值也有所区别。
接下来我们讲一下学习率调度(Learning Rate Scheduling),说白了就是动态的学习率。
前面的例子我们都使用的是固定的学习率,但实际上训练的前期和后期对更新幅度的需求是大概率不同的,比如前期举例较好的参数位置较远,则需要用较大的学习率推进,而后期可能已经逼近损失较低的区域,较大的学习率会使得参数反复越过合适的位置,因此可以尽量缩小学习率,让调整更细致。
这里需要注意,学习率控制更新的缩放比例,实际移动距离还取决于梯度以及优化器的历史信息。
这里我们介绍几种调整学习率的方法。
先介绍一种简单的,分段衰减。其实就是写一个关于 t t t 的分段函数,到达某个轮次之后改用不同的学习率,比如我们可以做出下面这种安排:
更新次数 t t t
学习率 η t \eta_t η t
这一阶段的安排
0 ≤ t < 1000 0\leq t<1000 0 ≤ t < 1000
0.01 0.01 0.01
使用较大的学习率进行更新
1000 ≤ t < 2000 1000\leq t<2000 1000 ≤ t < 2000
0.001 0.001 0.001
将学习率降低到原来的十分之一
t ≥ 2000 t\geq2000 t ≥ 2000
0.0001 0.0001 0.0001
再降低到前一阶段的十分之一
写成公式,就是:
η t = { 0.01 , 0 ≤ t < 1000 , 0.001 , 1000 ≤ t < 2000 , 0.0001 , t ≥ 2000. \eta_t=
\begin{cases}
0.01, & 0\leq t<1000,\\[4pt]
0.001, & 1000\leq t<2000,\\[4pt]
0.0001, & t\geq2000.
\end{cases}
η t = ⎩ ⎨ ⎧ 0.01 , 0.001 , 0.0001 , 0 ≤ t < 1000 , 1000 ≤ t < 2000 , t ≥ 2000.
如果画出来学习率与更新次数的函数,我们可以得到这是一条向下的阶梯。这里要注意,降低学习率不是重新初始化参数,我们要做的是在已经训练得到的参数下改用一个更小的学习率继续过呢更新。
在这种例子中,每次学习率的改变比例可以记作 γ \gamma γ ,表示到达指定阶段时,将学习率乘以该比例,可以理解为这个比例为衰减系数,然后得到新的学习率。这是分段衰减的一种典型形式。
分段衰减是在指定的位置进行改变,某种意义上整个变化不平滑、不连续,为此我们也可以用一种方法让学习率的变化相对平滑,从较大的数值主键过渡到较小的数值。余弦衰减就是这样的一种安排,利用一段余弦曲线计算训练进度所对应的学习率。
先只考虑一个衰减阶段。用 t = 0 t=0 t = 0 表示阶段开始,用 t = T t=T t = T 表示阶段结束,一种常见写法为:
η t = η min + η max − η min 2 ( 1 + cos ( π t T ) ) , 0 ≤ t ≤ T \eta_t
=\eta_{\min}
+\frac{\eta_{\max}-\eta_{\min}}{2}
\left(1+\cos\left(\frac{\pi t}{T}\right)\right),
\qquad 0\leq t\leq T
η t = η m i n + 2 η m a x − η m i n ( 1 + cos ( T π t ) ) , 0 ≤ t ≤ T
这里,η max \eta_{\max} η m a x 是这个阶段开始时的最大学习率,η min \eta_{\min} η m i n 是结束时的最小学习率,T T T 是这一衰减阶段的长度。这里介绍的是一段不包含重启的余弦衰减。
我们看一下它的起点和终点。
开始时,t = 0 t=0 t = 0 ,有 cos ( 0 ) = 1 \cos(0)=1 cos ( 0 ) = 1 ,代入后得到:
η 0 = η min + η max − η min 2 × 2 = η max \eta_0
=\eta_{\min}
+\frac{\eta_{\max}-\eta_{\min}}{2}\times2
=\eta_{\max}
η 0 = η m i n + 2 η m a x − η m i n × 2 = η m a x
结束时,t = T t=T t = T ,有 cos ( π ) = − 1 \cos(\pi)=-1 cos ( π ) = − 1 ,代入后得到:
η T = η min + η max − η min 2 × 0 = η min \eta_T
=\eta_{\min}
+\frac{\eta_{\max}-\eta_{\min}}{2}\times0
=\eta_{\min}
η T = η m i n + 2 η m a x − η m i n × 0 = η m i n
也就是说,公式把学习率从 η max \eta_{\max} η m a x 平滑地带到了 η min \eta_{\min} η m i n 。在这个过程中,开始和结束附近变化较缓,中间阶段下降较快。
例如,取 η max = 0.01 \eta_{\max}=0.01 η m a x = 0.01 ,η min = 0.0001 \eta_{\min}=0.0001 η m i n = 0.0001 ,衰减阶段为 10000 10000 10000 步,可以得到:
阶段内的更新次数 t t t
学习率 η t \eta_t η t ,约取六位小数
0 0 0
0.010000 0.010000 0.010000
2500 2500 2500
0.008550 0.008550 0.008550
5000 5000 5000
0.005050 0.005050 0.005050
7500 7500 7500
0.001550 0.001550 0.001550
10000 10000 10000
0.000100 0.000100 0.000100
要注意的是,这里的余弦函数只负责安排学习率怎样变化。它并不要求损失函数本身具有余弦形状,学习率曲线与损失曲线也是两张不同的图。
前文说到,训练前期用较大的学习率推进,但有些训练却从较小的学习率开始?思考下原因。
因为,训练刚开始的时候,模型参数刚初始化,梯度和中间表示可能还会出现明显的变化,对于优化器,也刚开始累积历史记录,直接采用较大的学习率则可能会导致初始几次参数更新过于剧烈。
因此,我们可以先使用较小的学习率,在逐渐提高到目标值,这种安排称之为学习率预热(Warmup) 。
在预测阶段,模型仍然正常计算梯度、更新参数,仅仅只是学习率从小到大变化,也不是先等待一段时间再开始训练。
最容易理解的预热方法是线性预热 ,也就是每一步都提高相同的数值,直到达到目标值,写法如下:
η t = η s t a r t + ( η p e a k − η s t a r t ) t T w a r m u p , 0 ≤ t ≤ T w a r m u p \eta_t
=\eta_{\mathrm{start}}
+\left(\eta_{\mathrm{peak}}-\eta_{\mathrm{start}}\right)
\frac{t}{T_{\mathrm{warmup}}},
\qquad 0\leq t\leq T_{\mathrm{warmup}}
η t = η start + ( η peak − η start ) T warmup t , 0 ≤ t ≤ T warmup
其中,η s t a r t \eta_{\mathrm{start}} η start 是预热开始时的学习率,η p e a k \eta_{\mathrm{peak}} η peak 是预热结束时达到的目标学习率,T w a r m u p T_{\mathrm{warmup}} T warmup 是预热阶段的长度。
比如,取 η s t a r t = 0.0001 \eta_{\mathrm{start}}=0.0001 η start = 0.0001 ,η p e a k = 0.001 \eta_{\mathrm{peak}}=0.001 η peak = 0.001 ,预热 1000 1000 1000 步,那么:
预热进度 t t t
学习率 η t \eta_t η t
0 0 0
0.000100 0.000100 0.000100
250 250 250
0.000325 0.000325 0.000325
500 500 500
0.000550 0.000550 0.000550
750 750 750
0.000775 0.000775 0.000775
1000 1000 1000
0.001000 0.001000 0.001000
可以看到,这一阶段的学习率在逐渐增大。
它也可以和前面的方法结合起来,即预热结束后,我们再接前文的衰减方法,这样整个过程就变成了:先从较小学习率主键提高到目标值,再从目标值逐渐降低。
例如,总训练进度安排为 10000 10000 10000 步,前 1000 1000 1000 步线性预热,剩余 9000 9000 9000 步使用余弦衰减。开始时为 0.0001 0.0001 0.0001 ,预热峰值为 0.001 0.001 0.001 ,结束时降到 0.00001 0.00001 0.00001 ,几个代表位置的学习率为:
总训练进度
当前阶段
学习率
0 0 0
预热开始
0.000100 0.000100 0.000100
500 500 500
预热进行到一半
0.000550 0.000550 0.000550
1000 1000 1000
预热结束,达到峰值
0.001000 0.001000 0.001000
5500 5500 5500
衰减阶段进行到一半
0.000505 0.000505 0.000505
10000 10000 10000
衰减阶段结束
0.000010 0.000010 0.000010
这里,余弦衰减的计时需要从预热结束时重新开始,衰减时长也应该取剩余的 9000 9000 9000 步。这样才能把两段曲线正确地接起来。
当然,Warmup 的时长和目标学习率也可以设置,预热也不是越长越好,因为如果大部分训练都在较小的学习率下度过会显著影响训练进度。
其实除了这些方法之外,还有很多其他的方法,比如衰减方法还有指数衰减等,这里不做详细介绍,根据不同的模型会有不同的方法,这里仅介绍常见的几种以及其对应概念。
最后,我们来讲一下优化器和学习率的关系。很多人有这样的误解,为什么前面的优化器已经有的有部分自适应了,还需要进行学习率的动态调度呢?
我们以 Adam 为例,先把其参数更新公示写出来:
θ t + 1 = θ t − η t m ^ t + 1 v ^ t + 1 + ϵ \boldsymbol{\theta}_{t+1}
=\boldsymbol{\theta}_t
-\eta_t
\frac{\hat{\mathbf{m}}_{t+1}}
{\sqrt{\hat{\mathbf{v}}_{t+1}}+\epsilon}
θ t + 1 = θ t − η t v ^ t + 1 + ϵ m ^ t + 1
可以看到, Adam 前面仍然乘以一个基础学习率,得到实际更新的变量,因此学习率这一部分可以同时变化,对于第 j j j 个参数,可以进一步写成:
Δ θ t , j = − η t v ^ t + 1 , j + ϵ ⏟ 该参数此时的有效学习率 m ^ t + 1 , j \Delta\theta_{t,j}
=-
\underbrace{\frac{\eta_t}{\sqrt{\hat{v}_{t+1,j}}+\epsilon}}_{\text{该参数此时的有效学习率}}
\hat{m}_{t+1,j}
Δ θ t , j = − 该参数此时的有效学习率 v ^ t + 1 , j + ϵ η t m ^ t + 1 , j
Adam 根据历史梯度,让不同参数使用不同的缩放比例;学习率调度则根据训练进度等规则,改变基础学习率 η t \eta_t η t 。因此,我们完全可以一边使用 Adam,一边进行预热和学习率衰减。
这里也区分一下前面的偏差修正,Adam 的偏差修正用于记录从 0 0 0 开始训练带来的统计偏差;Warmup 则直接控制基础学习率的变化,让训练初期的更新更温和,它们做的事情不同。
到这里,一次梯度下降产生的更新过程就可以串起来了:首先根据进度,确定学习率,然后取出全部样本或者一部分样本,计算模型输出、损失和梯度。优化器根据梯度以及已有的记录计算更新量,并使用这一步的学习率进行参数的更新。完成后进入下一个循环。
我们要区分下面三个问题:
问题
对应的安排
例子
样本如何选择
梯度的计算方式
全量、随机、小批量
如何更新参数
优化器
普通梯度下降、Momentum、RMSProp、Adam
学习率如何变化
学习率调度
分段衰减、余弦衰减、Warmup
例如,“小批量训练,使用 Adam,前 1000 1000 1000 步预热,之后使用余弦衰减”,这几种安排可以共同出现在同一次训练中,你可以将不同问题的答案进行排列组合。要记住学习率可以根据训练进度进行动态调整,这种调整时可以和优化器同时使用而不冲突的。
我们也要区分学习率曲线和损失曲线并非一样,前者展示学习率的变化,后者表示模型的损失如何变化。实际上,模型的损失一般会收敛到某个值,不一定是一直变小的,也不代表每一步都一定降低。
如果模型效果不好,只是简单地减小学习率也不一定能解决问题,具体情况需视情况而定。
4.4.4 算法的优势与局限
梯度下降通过借助梯度信息,使得它相比起爬山算法效率更高。因为梯度下降只需算到底一次便可以得到所有的梯度,进而求出变量;爬山算法则是每个参数的改变都需要算到底一次才能得到变化,计算量极大。而且梯度下降可以实现多个参数的同时变化,不过参数之间的耦合仍会一定程度下影响路径更新,比如狭长谷地中的来回摆动就是一个例子,不过梯度下降可以使用优化器缓解这种负面影响。
同时梯度下降可以借助梯度来实现对历史信息的保存,这是一个优点,各类优化器以及学习率的动态调整为梯度下降提供了更多的更新手段。
爬山算法中的一个大问题就是局部最优和鞍点问题,这些问题在梯度下降中仍然存在,比如面对函数:
f ( x , y ) = x 2 + y 2 + 10 x y f(x,y)=x^2+y^2+10xy
f ( x , y ) = x 2 + y 2 + 10 x y
在原点处,它的梯度为:
∇ f ( 0 , 0 ) = [ 2 x + 10 y 2 y + 10 x ] ∣ ( 0 , 0 ) = [ 0 0 ] \nabla f(0, 0) = \left. \begin{bmatrix} 2x + 10y \\ 2y + 10x \end{bmatrix} \right|_{(0,0)} = \begin{bmatrix} 0 \\ 0 \end{bmatrix}
∇ f ( 0 , 0 ) = [ 2 x + 10 y 2 y + 10 x ] ( 0 , 0 ) = [ 0 0 ]
但梯度下降通过优化器维持历史信息,可以一定程度上解决这部分问题。例如面对上面这个例子时,优化器可以借助历史信息调整梯度的变量,使之不再是 ( 0 , 0 ) (0, 0) ( 0 , 0 ) ,进而逃逸出鞍点或局部最优点,移向其他位置。
总的来说,梯度下降及其相关方法的主要优势时可以借助损失函数的可微结构,高效的获取参数的变化信息,并以此为据进行更新,改善了爬山算法中逐个邻域试探的效率和更新方式,但当面对复杂损失曲面的时候,其带来的困难仍需面对。
关于梯度下降的“算到底”,实际上指的是前向传播,而信息的返回则是反向传播,这部分将在下一章节中详细讲解。
4.5 反向传播