8.循环神经网络（RNN）·

CNN：处理空间信息

RNN-recurrent neural network：处理序列信息

序列模型·

统计工具·

自回归模型·

输入数据的数量 $x_{t-1},…,x_1$ 随着 $t$ 而异，而不是不变的

策略1：满足某个长度为 $\tau$ 的时间跨度，即使用观测序列 $x_{t-1},…,x_{t-\tau}$，参数数量不变，可以训练一个网络

策略2：$h_t=g(h_{t-1},x_{t-1})\rightarrow x_t=P(x_t|h_t),$ 更新模型，由于$h_t$没有被观测到，因此称为隐变量自回归模型（latent autoregressive models）

如何生成训练数据？一般是利用历史观测来预测下一个未来观测。常见的一个假设是虽然$x_t$可能会变，序列本身动力学不改变，不变的动力学称为静止的，即整个序列估计值用以下方式获得：$P(x_1,…,x_t)=\prod {t=1}^T P(x_t|x{t-1},…,x_1)$

马尔可夫模型·

上文提到的 $x_{t-1},…,x_{t-\tau}$ 来估计 $x_t$ 时如果时近似精确的，则称满足马尔可夫条件，如果$\tau=1$，则可以得到一阶马尔可夫模型

$P(x_1,…,x_T)=\prod_{t=1}^T P(x_t|x_{t-1})$

此时可以得到$P(x_{t+1}|x_{t-1})=\frac {\sum_{x_t} P(x_{t+1},x_t,x_{t-1})} {P(x_{t-1})}=\frac {P(x_{t-1})\sum_{x_t} P(x_{t+1}|x_t)P(x_t|x_{t-1})} {P(x_{t-1})}=\sum_{x_t}P(x_{t+1}|x_t)P(x_t|x_{t-1})$

因果关系·

基于马尔可夫模型我们还可以得到一个反向条件概率分布，不过一般这不好解释

训练·

import torch
from torch import nn
from torch.utils import data
T=1000
time = torch.arange(1, T + 1, dtype=torch.float32)
x = torch.sin(0.01 * time) + torch.normal(0, 0.2, (T,))
t=5
train_data=torch.zeros(T-t,t)
for i in range(t):
    train_data[:,i]=x[i:T-t+i]
train_labels=x[t:].reshape(-1,1)
def init_weights(m):
    if type(m) == nn.Linear:
        nn.init.xavier_uniform_(m.weight)
batch_size, n_train,epoch,lr = 16, 600,100,0.1

net=nn.Sequential(
    nn.Linear(5,10),
    nn.ReLU(),
    nn.Linear(10,1)
)
net.apply(init_weights)
loss=nn.MSELoss(reduction='none')
optimizer=torch.optim.Adam(net.parameters(), lr)
def load_array(data_arrays, batch_size, is_train=True): 
    """构造一个PyTorch数据迭代器。"""
    dataset = data.TensorDataset(*data_arrays)
    return data.DataLoader(dataset, batch_size, shuffle=is_train)
train_iter=load_array((train_data[:n_train],train_labels[:n_train]),batch_size)
for i in range(epoch):
    for X,y in train_iter:
        l=loss(net(X),y)
        optimizer.zero_grad()
        l.sum().backward()
        optimizer.step()
    cnt=0
    loss_sum=0
    for X,y in train_iter:
        l=loss(net(X),y)
        loss_sum+=l.sum()
        cnt+=1
    print(f'epoch{i+1} loss: {float(loss_sum)/cnt}')

进行下一个时间的预测到下$t$个时间的预测都相对较精准，但$t+1$及之后的时间的预测就不精准了，因为需要不断用预测的数据去预测更之后的数据，会造成误差积累。

文本预处理·

最常见的序列数据就是文本，一篇文章可以看为是一串单词序列，甚至是一串字符序列。

常见预处理步骤：

文本作为字符串加载到内存中
字符串拆分为词元（单词和字符）
建立一个词表，将拆分的词元映射到数字索引
将文本转换为数字索引序列，方便模型操作

此部分在https://github.com/BUAADreamer/nnplayer/tree/master/nlputil处进行了一些实践

语言模型和数据集·

语言模型的目标：估计序列的联合概率 $P(x_1,x_2,…,x_T)$

简单统计相对词频，执行某种形式的拉普拉斯平滑

马尔可夫模型与n元语法·

涉及⼀个、两个和三个变量的概率公式分别被称为“⼀元语法”（unigram）、“⼆元语法”（bigram）和“三元语法”（trigram）模型

自然语言统计·

词频最高的词都是类似 the/i/and 这样的词，被称为停用词，可以被过滤掉

词频衰减迅速，齐普夫定律：第 $i$ 个最常用的单词频率$n_i$为 $n_i\propto \frac 1 {i^\alpha}$

循环神经网络·

有隐状态的循环神经网络·

$H_t=\phi(X_tW_{xh}+H_{t-1}W_{hh}+b_h)$

困惑度（Perplexity）·

$exp(-\frac 1 n \sum_{t=1}^n log P(x_t|x_{t-1},…,x_{1}))$

梯度裁剪·

将梯度映射到$\theta$范围内，比如以下代码

def grad_clipping(net, theta): #@save
    """裁剪梯度"""
    if isinstance(net, nn.Module):
    	params = [p for p in net.parameters() if p.requires_grad]
    else:
    	params = net.params
    norm = torch.sqrt(sum(torch.sum((p.grad ** 2)) for p in params)) #梯度平方和开根号
    if norm > theta:
    	for param in params:
    		param.grad[:] *= theta / norm #映射到theta范围内

简洁实现·

参考实现的代码：https://github.com/BUAADreamer/nlpkiller/blob/master/main.py

class RNNModel(nn.Module):
    """循环神经网络模型
    Defined in :numref:`sec_rnn-concise`"""

    def __init__(self, rnn_layer, vocab_size, **kwargs):
        super().__init__()
        self.rnn = rnn_layer
        self.vocab_size = vocab_size
        self.num_hiddens = self.rnn.hidden_size
        # 如果RNN是双向的（之后将介绍），num_directions应该是2，否则应该是1
        if not self.rnn.bidirectional:
            self.num_directions = 1
            self.linear = nn.Linear(self.num_hiddens, self.vocab_size)
        else:
            self.num_directions = 2
            self.linear = nn.Linear(self.num_hiddens * 2, self.vocab_size)

    def forward(self, inputs, state):
        X = F.one_hot(inputs.T.long(), self.vocab_size)
        X = X.to(torch.float32)
        Y, state = self.rnn(X, state)
        # 全连接层首先将Y的形状改为(时间步数*批量大小,隐藏单元数)
        # 它的输出形状是(时间步数*批量大小,词表大小)。
        output = self.linear(Y.reshape((-1, Y.shape[-1])))
        return output, state

    def begin_state(self, device, batch_size=1):
        if not isinstance(self.rnn, nn.LSTM):
            # nn.GRU以张量作为隐状态
            return torch.zeros((self.num_directions * self.rnn.num_layers,
                                batch_size, self.num_hiddens),
                               device=device)
        else:
            # nn.LSTM以元组作为隐状态
            return (torch.zeros((
                self.num_directions * self.rnn.num_layers,
                batch_size, self.num_hiddens), device=device),
                    torch.zeros((
                        self.num_directions * self.rnn.num_layers,
                        batch_size, self.num_hiddens), device=device))

通过时间反向传播·

数学推导1·

链式求导法则应用于 $f(h(x),g(x))$

$\frac {d(f(h(x),g(x)))} {dx}=\frac {d(f(h(x),g(x)))} {d(h(x))}*h’(x)+\frac {d(f(h(x),g(x)))} {d(g(x))}*g’(x)$

数学推导2·

$a_3=b_3+c_3a_2=b_3+c_3(b_2+c_2a_1)=b_3+c_3(b_2+c_2b_1)$

数学归纳法证明$a_t=b_t+\sum_{i=1}^{{t-1}(\prod_{j=i+1}}tc_j)b_i $

随机截断，常规截断，完整计算（不可行）

9.现代循环神经网络·

门控循环单元（GRU）·

重置门和更新门·

R：重置门接近0时重置隐状态，接近1时是普通RNN

Z：更新门接近0时接近隐状态，接近1时倾向于保留旧状态，来自X的信息基本被忽略，跳过时间步t

计算重置门和更新门·

计算候选隐状态·

$\odot$ 是Hardmard积，按元素的乘积

计算隐状态·

重置门有助于捕捉序列的短期依赖关系

更新门有助于捕捉序列的长期依赖关系

简洁实现·

num_inputs = vocab_size
gru_layer = nn.GRU(num_inputs, num_hiddens)
model = RNNModel(gru_layer, len(vocab))
model = model.to(device)
train_rnn(model, train_iter, vocab, lr, num_epochs, device)

长短期记忆网络（LSTM）·

输入门，遗忘门，输出门·

值的范围都在[0,1]内

候选记忆元·

值的范围是[-1,1]

记忆元·

隐状态·

简洁实现·

num_inputs = vocab_size
lstm_layer = nn.LSTM(num_inputs, num_hiddens)
model = RNNModel(lstm_layer, len(vocab))
model = model.to(device)
train_rnn(model, train_iter, vocab, lr, num_epochs, device)

深度循环神经网络·

堆叠隐藏层来实现

简洁实现·

#和之前的区别在于指定了
vocab_size, num_hiddens, num_layers = len(vocab), 256, 2
num_inputs = vocab_size
device = d2l.try_gpu()
lstm_layer = nn.LSTM(num_inputs, num_hiddens, num_layers)
model = RNNModel(lstm_layer, len(vocab))
model = model.to(device)

双向循环神经网络·

增加一个从最后的词元开始从后向前运行的循环网络设计，添加反向传递信息的隐藏层。和隐马尔可夫模型中的动态规划前向后向递归没有太大区别

现代深度⽹络的设计原则：⾸先使⽤经典统计模型的函数依赖类型，然后将其参数化为通⽤形式。

机器翻译与数据集·

对语言数据集的source（比如英文）和target（比如中文）同时进行统计和建模

英法翻译数据集：有n条数据，每条数据是一句英文和一句对应法文

数据预处理：将不间断空格转换为空格，大写转小写

词元化：单词级词元化。返回两个词元列表：source和target。source[i]是源语言（此处为英语）第i个文本序列的词元列表，target[i]是目标语言（这里为法语）第i个文本序列的词元列表。

单词级词元化的词表大小远远大于字符级词元化大小，因此将低于2次的低频词元视为相同的未知词元<unk>。此外指定额外词元。小批量时将序列填充到相同长度的填充词元<pad>，序列的开始词元<bos>，结束词元<eos>

加载数据集：截断或填充让每个样本的长度保持一致，设置一个统一长度num_steps，小于则填充<pad>，大于则截断。在每个序列的末尾添加<eos>词元表明完成了序列输出工作

编码器-解码器架构·

将一个长度可变的序列作为输入，转换为有固定形状的编码状态。之后解码，将固定形状的编码状态映射到长度可变的序列。比如，先将某句话编码为一个状态，再将这个状态解码，一个词元一个词元的生成翻译后的序列

解码器新增一个init_state函数，将编码器输出转换为编码后的状态，这一过程可能需要额外的输出，比如输入序列的有效长度。为了生成长度可变的词元序列，解码器在每个时间步都将会将输入（比如在前一时间步生成的词元）和状态映射成当前时间步的输出词元

序列到序列学习（seq2seq）·

循环神经网络编码器将长度可变的序列作为输入，转换为固定形状的隐状态，独立的循环神经网络解码器基于输入序列的编码信息和输出序列已经看见的或者生成的词元来预测下一个词元。一旦输出序列生成了<eos>词元则停止预测

BLEU评估方法·

广泛用于测量许多应用的输出序列的质量

$\exp(min(0,1-\frac {len_{label}} {len_{pred}}))\prod_{n=1}^kp_n{\frac 1 {2^n}}$

$p_n$刻画n元语法的正确率，是预测序列中n元语法与标签序列中匹配的数量除以预测序列中n元语法的数量，k是用于匹配的最长n元语法

比如答案序列abcde，预测序列abcdde

则$p_1=3/5,p_2=2/4,p_3=1/3,p_4=0$

束搜索·

贪心搜索：逐个预测输出序列，每次选择概率最高概率的词元，一直到达最大长度输出完成

穷举搜索：列举所有的可能性

束搜索：改进贪心搜索。超参数为束宽(beam size)k，时间步1选择最高条件概率的k个词元，k个词元分别是k个候选输出序列的第一个词元。之后的每个时间步，基于上一时间步的k个候选输出序列，继续选出最高条件概率的k个候选输出序列。

最后得到了6个候选输出序列 A C AB CE ABD CED

选择其中条件概率最高的序列作为输出序列：

L是最终候选序列的长度，$\alpha$为对长序列的惩罚项，一般为0.75

10.注意力机制·

10.1 注意力提示·

人类注意力是有限的，有价值，稀缺的

人通过非自主性和自主性提示有选择性地引导注意力，前者基于自然的突出性，比如一个红色杯子和4个灰色物体，很容易注意红色杯子。后者则需要人主观投入更多注意力，比如：我要认真写作业。

注意力机制与全连接层/汇聚层的区别在于增加了自主提示。全连接层/汇聚层可以认为是非自主性提示，注意力机制是自主性提示

注意力机制通过注意力汇聚使得选择偏向于值（value 感官输入），其中包含查询（query 自主性提示），键（key 非自主性提示），键和值是成对的，相当于感官输入的非自主提示。我们设计注意力汇聚，让给定的查询（自主性提示）可以和键（非自主性提示）进行匹配，引导得出最匹配的值（感官输入）

这里的注意力汇聚其实是通过调整不同参数的权重来实现的。

10.2 注意力汇聚：Nadaraya-Watson 核回归·

注意力汇聚公式：$f(x)=\sum_{i=1}^n\alpha(x,x_i)y_i$ 是$y_i$的加权平均

平均汇聚$\sum_{i=1}^ny_i$可以看成是特殊的注意力汇聚

查询x和键$x_i$之间的关系建模为注意力权重$\alpha(x,x_i)$，并分配给每一个对应值$y_i$，对于任何查询，模型在所有键值对注意力权重都是一个有效的概率分布：非负且总和为1

高斯核：$K(u)=\frac 1 {\sqrt{2\pi}}exp(-\frac {u^2} 2)$

一个键越接近所给的查询x，则分配给这个键对应值$y_i$的注意力权重越大，也就获得了更多注意力

unsqueeze函数：在指定位置插入一个维度，默认为1

非参数型注意力汇聚·

参数型非注意力汇聚（加入一个权重，可以被训练）·

$\omega$仅仅为一个参数，长度为1

10.3 注意力评分函数·

假设一个查询$q\in R^q$和m个键值对$(k_1,v_1),…,(k_m,v_m)$，其中$k_i\in R^k,v_i\in R^v$，注意力汇聚函数$f$被表示为值的加权和：

$f(q,(k_1,v_1),…,(k_m,v_m))=\sum_{i=1}^m\alpha (q,k_i)v_i \in R^v$

其中查询$q$和键$k_i$的注意力权重（标量）是通过注意力评分函数$a$将两个向量映射成标量，再经过softmax运算得到。

$\alpha (q,k_i)=softmax(a(q,k_i))=\frac {exp(a(q,k_i))} {\sum_{j=1}^mexp(a(q,k_j))}\in R$

遮掩softmax操作·

指定一个有效序列长度，即词元个数，从而过滤掉超出指定范围的位置

def masked_softmax(X, valid_lens):
    """通过在最后⼀个轴上掩蔽元素来执⾏softmax操作"""
    # X:3D张量，valid_lens:1D或2D张量
    if valid_lens is None:
    	return nn.functional.softmax(X, dim=-1)
    else:
    	shape = X.shape
    if valid_lens.dim() == 1:
    	valid_lens = torch.repeat_interleave(valid_lens, shape[1])
        #repeat_interleave([2,3],2)==>[2,2,3,3]
    else:
    	valid_lens = valid_lens.reshape(-1) 
        # 最后⼀轴上被掩蔽的元素使⽤⼀个⾮常⼤的负值替换，从⽽其softmax输出为0 
        X = d2l.sequence_mask(X.reshape(-1, shape[-1]), valid_lens,
    	value=-1e6)
    #对处理后的X做softmax运算
    return nn.functional.softmax(X.reshape(shape), dim=-1)
masked_softmax(torch.rand(2, 2, 4), torch.tensor([2, 3]))
'''
得到结果:
tensor([[[0.3412, 0.6588, 0.0000, 0.0000],
        [0.4643, 0.5357, 0.0000, 0.0000]],
        [[0.1967, 0.3512, 0.4522, 0.0000],
        [0.3580, 0.3092, 0.3328, 0.0000]]])
'''

加性注意力·

当查询和键是不同长度的矢量时，可以使用加性注意力作为评分函数。给定查询$q\in R^q$和键$k\in R^k$，加性注意力评分函数为 $$ a(q,k)=w_v^Ttanh(W_qq+W_kk)\in R $$ 其中可学习的参数是$W_q\in R^{h\times q},W_k\in R^{h\times k}$和$w_v\in R^h$

缩放点积注意力·

查询和键是相同长度矢量时计算效率更高 $$ a(q,k)=q^Tk/\sqrt d $$

基于n个查询和m个键值对计算注意力，查询和键的长度为d，值的长度为v，查询$Q\in R^{n\times d}$，键$K\in R^{m\times d}$ 和值$V\in R^{m\times v}$的缩放点积注意力为 $$ softmax(\frac {QK^T} {\sqrt d})V\in R^{n\times v} $$

10.4 Bahdanau注意力·

在预测词元时，如果不是所有输⼊词元都相关，模型将仅对⻬（或参与）输⼊序列中与当前预测相关的部分。这是通过将上下⽂变量视为注意⼒集中的输出来实现的。

9.7中的上下文变量是注意力集中的输出：

$c_{t’}=\sum_{t=1}^T\alpha (s_{t’-1},h_t)h_t$

其中，时间步$t’-1$时的解码器隐状态$s_{t’-1}$是查询，编码器隐状态$h_t$既是键，也是值，注意⼒权重$\alpha$是使⽤加性注意⼒打分函数计算的。

10.5 多头注意力·

将多个注意力汇聚输出进行连结，每个注意力汇聚都被称为一个头

10.6 自注意力和位置编码·

同⼀组词元同时充当查询、键和值，每个查询都会关注所有的键－值对并⽣成⼀个注意⼒输出

查询、键和值来自同⼀组输入，因此被称为⾃注意⼒

自注意力同时具有最大路径长度短和可并行两个优势，CNN可并行，RNN不可并行

为了学习位置信息，引入位置编码：$p_{i,2j}=sin(\frac i {10000^{\frac {2j} d}})$ $p_{i,2j+1}=cos(\frac i {10000^{\frac {2j} d}})$

10.7 Transformer·

Transformer编码器和解码器是基于⾃注意⼒的模块叠加⽽成的，源（输⼊）序列和⽬标（输出）序列的嵌⼊（embedding）表⽰将加上位置编码（positional encoding），再分别输⼊到编码器和解码器中。

NLP中一般使用层规范化而不是批量规范化

11.优化算法·

12.计算性能·

13.计算机视觉·

14.自然语言处理：预训练·

14.1 词嵌入（Word2Vec）·

单词映射到实向量的技术称为词嵌⼊

独热编码不能刻画词语之间的相似度，需要能够刻画相似度的向量表示

自监督的word2vec·

跳元模型（Skip-Gram）·

假设一个词可以用来在文本序列中生成其周围的单词

每个词都有两个d维向量表示，用于计算条件概率。对于词典中索引为i的任何词，分别用$v_i\in R^d$和$u_i\in R^d$表示其用作中心词和上下文词时的两个向量。

给定中心词$w_c$（词典中的索引c），生成任何上下文词$w_o$（词典中索引o）的条件概率可以通过对向量点积的softmax操作来建模：

$P(w_o|w_c)=\frac {exp(u_o^Tv_c)} {\sum_{i\in V}exp(u_i^Tv_c)}$

词表索引集$V={0,1,…,|V|-1}$ 给定长度为T的文本序列，其中时间步t处的词表示为$w^{(t)}$。假设上下文词是在给定任何中心词的情况下独立生成的。对于上下文窗口m，跳元模型的似然函数是给定任何中心词的情况下生成所有上下文词的概率：

$\prod_{t=1}^T\prod_{-m\le j\le m,j\neq 0}P(w^{(t+j)}|w{(t)})$

训练·

用最大化似然函数（极大似然估计）来学习模型参数

最终使用中心词向量作为词表示

连续词袋模型（CBOW）·

基于在文本序列中的周围上下文词生成中心词

也就是P( “loves” | “I” , “you” )

计算条件概率时对上下文词向量进行平均

给定上下文词$w_{o_1},…,w_{o_m}$生成中心词$w_c$的条件概率由以下公式建模：

$P(w_c|w_{o_1},…,w_{o_m})=\frac {exp(\frac 1 {2m}u_c^T(v_{o_1}+…+v_{o_{2m}}))} {\sum_{i\in V}exp(\frac 1 {2m}u_i^T(v_{o_1}+…+v_{o_{2m}}))}$

通常使用上下文词向量作为词表示

14.2 近似训练·

负采样。修改目标函数，增加负采样。训练的计算量与每⼀步的噪声词数成线性关系。
层序Softmax。使⽤⼆叉树中从根节点到叶节点的路径构造损失函数。训练的计算成本取决于词表⼤⼩的对数。

14.5 全局向量的词嵌入（GloVe）·

带全局语料统计的跳元模型·

用$q_{ij}$表示词$w_j$的条件概率$P(w_j|w_i)$，在跳元模型中给定词$w_i$，可以得到：

$q_{ij}=\frac {exp(u_j^Tv_i)} {\sum_{k\in V}exp(u_k^Tv_i)}$

在整个语料库中，词$w_i$可能出现多次，则所有以它为中心词的上下文词形成了一个词索引的多重集$C_i$，允许同一元素的多个实例。实例数称为重数。比如以$w_i$为中心词的上下文词索引为a,b,c,d和a,c,e 那么多重集$C_i={a,a,b,c,c,d,e}$ a,b,c,d,e的重数为2，1，2，1，1

将多重集$C_i$中$j$元素的重数表示为$x_{ij}$，这是词$w_j$作为上下文词和词$w_i$作为中心词在整个语料库中的同一上下文窗口中的全局共现计数，则此时的跳元模型损失函数为：$-\sum_{i\in V}\sum_{j\in V}x_{ij}\log q_{ij}$

用$x_i$表示上下文窗口中所有上下文词的数量，其中$w_i$作为中心词出现，相当于$|C_i|$，设$p_{ij}$为用于生成上下文词$w_{j}$的条件概率$x_{ij}/x_i$，给定中心词，将损失函数重写为：$-\sum_{i\in V}x_i\sum_{j\in V}p_{ij}\log q_{ij}$

计算全局语料统计的条件分布$p_{ij}$和模型预测的条件分布$q_{ij}$的交叉熵，这⼀损失也按$x_i$加权

这个损失函数计算昂贵且给太多罕见事件赋值，需要替换

GloVe模型·

基于平方损失，修改了跳元模型

使用变量$p’{ij}=x{ij}$ 和$q’{ij}=exp(u_j^Tv_i)$ 而非概率分布，并取二者的对数。平方损失项是$(\log(p’{ij})-\log(q’{ij}))^2=(u_jTv_i-\log x{ij})^2$
为每个词$w_i$添加两个标量参数模型：中心词偏置$b_i$和上下文偏置$c_i$
用权重函数$h(x_{ij})$替换每个损失项的权重，其中$h(x)$在[0,1]区间单调增

整合以下，训练GloVe就是降低以下损失函数

$\sum_{i\in V}\sum_{j\in V}h(x_{ij})(u_j^Tv_i+b_i+c_j-\log x_{ij})^2$

对于权重函数，建议是：当x<c时，$h(x)=(x/c)^\alpha$，否则$h(x)=1$

这样可以省略掉任何$x_{ij}=0$的平方损失项

每次随机抽样一批非零的$x_{ij}$（预先计算的全局语料库统计数据，所以GloVe被叫做全局向量）来计算梯度并更新模型参数

由于$x_{ij}=x_{ji}$，所以任意词的中心词向量和上下文词向量是等价的，实际应用中，同一个词经过训练后，在两个向量中可能得到不同值，因此最后将其相加作为输出向量。

14.6 子词嵌入·

fastText模型·

子词级跳元模型

对于where单词，先在开头和末尾添加特殊字符"<“和”>"，从而将前缀和后缀与其他子词分开。之后提取出n-gram。比如n=3时，获得长度为3的所有子词：<wh,whe,her,ere,re>和特殊子词<where>

对于任意词w，用$g_w$表示其长度在3和6之间的所有子词与其特殊子词的并集。词表是所有子词的集合。假设$z_g$是词典中的子词g的向量，则跳元模型中作为中心词的词w的向量$v_w$是其子词向量的和：

$v_w=\sum_{g\in g_w}z_g$

其余部分和跳元模型相同。因此fastText词量更大，模型参数也更多。同时计算一个词表示必须对所有子词向量求和，计算复杂度增高。但是对于具有相似结构的词之间共享来自子词的参数，罕见词甚至词表外的词在fastText中可能获得更好的向量表示

字节对编码（Byte Pair Encoding）·

在fastText中所有子词长度必须指定，词表大小不能预定义

为了在固定大小的词表中允许可变长度的子词，应用一种字节对编码压缩算法来提取子词

字节对编码执⾏训练数据集的统计分析，以发现单词内的公共符号，诸如任意⻓度的连续字符。从⻓度为1的符号开始，字节对编码迭代地合并最频繁的连续符号对以产⽣新的更⻓的符号。请注意，为提⾼效率，不考虑跨越单词边界的对。最后，我们可以使⽤像⼦词这样的符号来切分单词。字节对编码及其变体已经⽤于诸如GPT-2和RoBERTa等⾃然语⾔处理预训练模型中的输⼊表⽰。

14.7 词的相似性和类比任务·

在实践中，在⼤型语料库上预先练的词向量可以应⽤于下游的⾃然语⾔处理任务。
预训练的词向量可以应⽤于词的相似性和类⽐任务。

14.8 来⾃Transformers的双向编码器表⽰（BERT）·

从上下⽂⽆关到上下⽂敏感·

之前的编码方式都采用上下文无关表示，但是很多词语在不同句子中有不同表示，因此需要上下文敏感表示方法。常见的有：TagLM（language-model-augmented sequence tagger，语⾔模型增强的序列标记器），CoVe（Context Vectors，上下⽂向量），ELMo（Embeddings from Language Models，来⾃语⾔模型的嵌⼊）

例如，通过将整个序列作为输⼊，ELMo是为输⼊序列中的每个单词分配⼀个表⽰的函数。具体来说，ELMo将来⾃预训练的双向⻓短期记忆⽹络的所有中间层表⽰组合为输出表⽰。然后，ELMo的表⽰将作为附加特征添加到下游任务的现有监督模型中，例如通过将ELMo的表⽰和现有模型中词元的原始表⽰（例如GloVe）连结起来。⼀⽅⾯，在加⼊ELMo表⽰后，冻结了预训练的双向LSTM模型中的所有权重。另⼀⽅⾯，现有的监督模型是专⻔为给定的任务定制的。利⽤当时不同任务的不同最佳模型，添加ELMo改进了六种⾃然语⾔处理任务的技术⽔平：情感分析、⾃然语⾔推断、语义⻆⾊标注、共指消解、命名实体识别和问答。

从特定于任务到不可知任务·

尽管ELMo显著改进了各种⾃然语⾔处理任务的解决⽅案，但每个解决⽅案仍然依赖于⼀个特定于任务的架构。然⽽，为每⼀个⾃然语⾔处理任务设计⼀个特定的架构实际上并不是⼀件容易的事。GPT（Generative Pre Training，⽣成式预训练）模型为上下⽂的敏感表⽰设计了通⽤的任务⽆关模型 。GPT建⽴在Transformer解码器的基础上，预训练了⼀个⽤于表⽰⽂本序列的语⾔模型。当将GPT应⽤于下游任务时，语⾔模型的输出将被送到⼀个附加的线性输出层，以预测任务的标签。与ELMo冻结预训练模型的参数不同，GPT在下游任务的监督学习过程中对预训练Transformer解码器中的所有参数进⾏微调。GPT在⾃然语⾔推断、问答、句⼦相似性和分类等12项任务上进⾏了评估，并在对模型架构进⾏最⼩更改的情况下改善了其中9项任务的最新⽔平。然⽽，由于语⾔模型的⾃回归特性，GPT只能向前看（从左到右）。在“i went to the bank to deposit cash”（我去银⾏存现⾦）和“i went to the bank to sit down”（我去河岸边坐下）的上下⽂中，由于“bank”对其左边的上下⽂敏感，GPT将返回“bank”的相同表⽰，尽管它有不同的含义。

BERT：把两个最好的结合起来·

如我们所⻅，ELMo对上下⽂进⾏双向编码，但使⽤特定于任务的架构；⽽GPT是任务⽆关的，但是从左到右编码上下⽂。BERT（来⾃Transformers的双向编码器表⽰）结合了这两个⽅⾯的优点。它对上下⽂进⾏双向编码，并且对于⼤多数的⾃然语⾔处理任务只需要最少的架构改变。通过使⽤预训练的Transformer编码器，BERT能够基于其双向上下⽂表⽰任何词元。在下游任务的监督学习过程中，BERT在两个⽅⾯与GPT相似。⾸先，BERT表⽰将被输⼊到⼀个添加的输出层中，根据任务的性质对模型架构进⾏最⼩的更改，例如预测每个词元与预测整个序列。其次，对预训练Transformer编码器的所有参数进⾏微调，⽽额外的输出层将从头开始训练。

输入表示·

有些任务以单文本作为输入（情感分析），有些任务以一对文本序列作为输入（自然语言推断）。BERT输入序列明确表示单个文本和文本对。

输入为单文本的BERT输入序列：特殊类别词元<cls>、文本序列的标记、特殊分割词元<sep>的连结

输入为文本对时的BERT输入序列：<cls>、第一个文本序列的标记、<sep>、第二个文本序列的标记、<sep>的终结

BERT输⼊序列的嵌⼊是词元嵌⼊、⽚段嵌⼊和位置嵌⼊的和。

预训练任务·

掩蔽语言模型（Masked Language Modeling）·

为了双向编码上下⽂以表⽰每个词元，BERT随机掩蔽词元并使⽤来⾃双向上下⽂的词元以⾃监督的⽅式**预测掩蔽词元。**此任务称为掩蔽语⾔模型。

下一句预测（Next Sentence Prediction）·

为了帮助理解两个⽂本序列之间的关系，BERT在预训练中考虑了⼀个⼆元分类任务——下⼀句预测

8.循环神经网络（RNN）·

序列模型·

统计工具·

自回归模型·

马尔可夫模型·

因果关系·

训练·

文本预处理·

语言模型和数据集·

马尔可夫模型与n元语法·

自然语言统计·

循环神经网络·

有隐状态的循环神经网络·

困惑度（Perplexity）·

梯度裁剪·

简洁实现·

通过时间反向传播·

数学推导1·

数学推导2·

9.现代循环神经网络·

门控循环单元（GRU）·

重置门和更新门·

计算重置门和更新门·

计算候选隐状态·

计算隐状态·

简洁实现·

长短期记忆网络（LSTM）·

输入门，遗忘门，输出门·

候选记忆元·

记忆元·

隐状态·

简洁实现·

深度循环神经网络·

简洁实现·

双向循环神经网络·

机器翻译与数据集·

编码器-解码器架构·

序列到序列学习（seq2seq）·

BLEU评估方法·

束搜索·

10.注意力机制·

10.1 注意力提示·

10.2 注意力汇聚：Nadaraya-Watson 核回归·

非参数型注意力汇聚·

参数型非注意力汇聚（加入一个权重，可以被训练）·

10.3 注意力评分函数·

遮掩softmax操作·

加性注意力·

缩放点积注意力·

10.4 Bahdanau注意力·

10.5 多头注意力·

10.6 自注意力和位置编码·

10.7 Transformer·

11.优化算法·

12.计算性能·

13.计算机视觉·

14.自然语言处理：预训练·

14.1 词嵌入（Word2Vec）·

自监督的word2vec·

跳元模型（Skip-Gram）·

训练·

连续词袋模型（CBOW）·

14.2 近似训练·

14.5 全局向量的词嵌入（GloVe）·

带全局语料统计的跳元模型·

GloVe模型·

14.6 子词嵌入·

fastText模型·

字节对编码（Byte Pair Encoding）·

14.7 词的相似性和类比任务·

14.8 来⾃Transformers的双向编码器表⽰（BERT）·

从上下⽂⽆关到上下⽂敏感·

从特定于任务到不可知任务·

BERT：把两个最好的结合起来·

输入表示·

预训练任务·

掩蔽语言模型（Masked Language Modeling）·

下一句预测（Next Sentence Prediction）·

15.自然语言处理：应用·

FEATURED TAGS