目录

🍔 输入部分介绍

🍔 文本嵌入层的作用

🍔 位置编码器的作用

3.1 位置编码器的代码分析

3.2 绘制词汇向量中特征的分布曲线

🍔 输出部分介绍

🍔 线性层的作用

🍔 softmax层的作用

3.1 线性层和softmax层的代码分析

🍔 小结

学习目标

🍀 了解文本嵌入层和位置编码的作用.

🍀 掌握文本嵌入层和位置编码的实现过程.

🍀 了解线性层和softmax的作用.

🍀 掌握线性层和softmax的实现过程.

🍔 输入部分介绍

输入部分包含:

源文本嵌入层及其位置编码器目标文本嵌入层及其位置编码器

🍔 文本嵌入层的作用

无论是源文本嵌入还是目标文本嵌入，都是为了将文本中词汇的数字表示转变为向量表示, 希望在这样的高维空间捕捉词汇间的关系.

文本嵌入层的代码分析:

<code># 导入必备的工具包

import torch

# 预定义的网络层torch.nn, 工具开发者已经帮助我们开发好的一些常用层,

# 比如，卷积层, lstm层, embedding层等, 不需要我们再重新造轮子.

import torch.nn as nn

# 数学计算工具包

import math

# torch中变量封装函数Variable.

from torch.autograd import Variable

# 定义Embeddings类来实现文本嵌入层，这里s说明代表两个一模一样的嵌入层, 他们共享参数.

# 该类继承nn.Module, 这样就有标准层的一些功能, 这里我们也可以理解为一种模式, 我们自己实现的所有层都会这样去写.

class Embeddings(nn.Module):

def __init__(self, d_model, vocab):

"""类的初始化函数, 有两个参数, d_model: 指词嵌入的维度, vocab: 指词表的大小."""

# 接着就是使用super的方式指明继承nn.Module的初始化函数, 我们自己实现的所有层都会这样去写.

super(Embeddings, self).__init__()

# 之后就是调用nn中的预定义层Embedding, 获得一个词嵌入对象self.lut

self.lut = nn.Embedding(vocab, d_model)

# 最后就是将d_model传入类中

self.d_model = d_model

def forward(self, x):

"""可以将其理解为该层的前向传播逻辑，所有层中都会有此函数

当传给该类的实例化对象参数时, 自动调用该类函数

参数x: 因为Embedding层是首层, 所以代表输入给模型的文本通过词汇映射后的张量"""

# 将x传给self.lut并与根号下self.d_model相乘作为结果返回

# 让 embeddings vector 在增加 之后的 postion encoing 之前相对大一些的操作，

# 主要是为了让position encoding 相对的小，这样会让原来的 embedding vector 中的信息在和 position encoding 的信息相加时不至于丢失掉

# 让 embeddings vector 相对大一些

return self.lut(x) * math.sqrt(self.d_model)

nn.Embedding演示:

>>> embedding = nn.Embedding(10, 3)

>>> input = torch.LongTensor([[1,2,4,5],[4,3,2,9]])

>>> embedding(input)

tensor([[[-0.0251, -1.6902, 0.7172],

[-0.6431, 0.0748, 0.6969],

[ 1.4970, 1.3448, -0.9685],

[-0.3677, -2.7265, -0.1685]],

[[ 1.4970, 1.3448, -0.9685],

[ 0.4362, -0.4004, 0.9400],

[-0.6431, 0.0748, 0.6969],

[ 0.9124, -2.3616, 1.1151]]])

>>> embedding = nn.Embedding(10, 3, padding_idx=0)

>>> input = torch.LongTensor([[0,2,0,5]])

>>> embedding(input)

tensor([[[ 0.0000, 0.0000, 0.0000],

[ 0.1535, -2.0309, 0.9315],

[ 0.0000, 0.0000, 0.0000],

[-0.1655, 0.9897, 0.0635]]])

实例化参数:

# 词嵌入维度是512维

d_model = 512

# 词表大小是1000

vocab = 1000

输入参数:

# 输入x是一个使用Variable封装的长整型张量, 形状是2 x 4

x = Variable(torch.LongTensor([[100,2,421,508],[491,998,1,221]]))

调用:

emb = Embeddings(d_model, vocab)

embr = emb(x)

print("embr:", embr)

输出效果:

embr: Variable containing:

( 0 ,.,.) =

35.9321 3.2582 -17.7301 ... 3.4109 13.8832 39.0272

8.5410 -3.5790 -12.0460 ... 40.1880 36.6009 34.7141

-17.0650 -1.8705 -20.1807 ... -12.5556 -34.0739 35.6536

20.6105 4.4314 14.9912 ... -0.1342 -9.9270 28.6771

( 1 ,.,.) =

27.7016 16.7183 46.6900 ... 17.9840 17.2525 -3.9709

3.0645 -5.5105 10.8802 ... -13.0069 30.8834 -38.3209

33.1378 -32.1435 -3.9369 ... 15.6094 -29.7063 40.1361

-31.5056 3.3648 1.4726 ... 2.8047 -9.6514 -23.4909

[torch.FloatTensor of size 2x4x512]

🍔 位置编码器的作用

因为在Transformer的编码器结构中, 并没有针对词汇位置信息的处理，因此需要在Embedding层后加入位置编码器，将词汇位置不同可能会产生不同语义的信息加入到词嵌入张量中, 以弥补位置信息的缺失.

3.1 位置编码器的代码分析

# 定义位置编码器类, 我们同样把它看做一个层, 因此会继承nn.Module

class PositionalEncoding(nn.Module):

def __init__(self, d_model, dropout, max_len=5000):

"""位置编码器类的初始化函数, 共有三个参数, 分别是d_model: 词嵌入维度,

dropout: 置0比率, max_len: 每个句子的最大长度"""

super(PositionalEncoding, self).__init__()

# 实例化nn中预定义的Dropout层, 并将dropout传入其中, 获得对象self.dropout

self.dropout = nn.Dropout(p=dropout)

# 初始化一个位置编码矩阵, 它是一个0阵，矩阵的大小是max_len x d_model.

pe = torch.zeros(max_len, d_model)

# 初始化一个绝对位置矩阵, 在我们这里，词汇的绝对位置就是用它的索引去表示.

# 所以我们首先使用arange方法获得一个连续自然数向量，然后再使用unsqueeze方法拓展向量维度使其成为矩阵，

# 又因为参数传的是1，代表矩阵拓展的位置，会使向量变成一个max_len x 1 的矩阵，

position = torch.arange(0, max_len).unsqueeze(1)

# 绝对位置矩阵初始化之后，接下来就是考虑如何将这些位置信息加入到位置编码矩阵中，

# 最简单思路就是先将max_len x 1的绝对位置矩阵， 变换成max_len x d_model形状，然后覆盖原来的初始位置编码矩阵即可，

# 要做这种矩阵变换，就需要一个1xd_model形状的变换矩阵div_term，我们对这个变换矩阵的要求除了形状外，

# 还希望它能够将自然数的绝对位置编码缩放成足够小的数字，有助于在之后的梯度下降过程中更快的收敛. 这样我们就可以开始初始化这个变换矩阵了.

# 首先使用arange获得一个自然数矩阵， 但是细心的同学们会发现， 我们这里并没有按照预计的一样初始化一个1xd_model的矩阵，

# 而是有了一个跳跃，只初始化了一半即1xd_model/2 的矩阵。 为什么是一半呢，其实这里并不是真正意义上的初始化了一半的矩阵，

# 我们可以把它看作是初始化了两次，而每次初始化的变换矩阵会做不同的处理，第一次初始化的变换矩阵分布在正弦波上， 第二次初始化的变换矩阵分布在余弦波上，

# 并把这两个矩阵分别填充在位置编码矩阵的偶数和奇数位置上，组成最终的位置编码矩阵.

div_term = torch.exp(torch.arange(0, d_model, 2) *

-(math.log(10000.0) / d_model))

pe[:, 0::2] = torch.sin(position * div_term)

pe[:, 1::2] = torch.cos(position * div_term)

# 这样我们就得到了位置编码矩阵pe, pe现在还只是一个二维矩阵，要想和embedding的输出（一个三维张量）相加，

# 就必须拓展一个维度，所以这里使用unsqueeze拓展维度.

pe = pe.unsqueeze(0)

# 最后把pe位置编码矩阵注册成模型的buffer，什么是buffer呢，

# 我们把它认为是对模型效果有帮助的，但是却不是模型结构中超参数或者参数，不需要随着优化步骤进行更新的增益对象.

# 注册之后我们就可以在模型保存后重加载时和模型结构与参数一同被加载.

self.register_buffer('pe', pe)

def forward(self, x):

"""forward函数的参数是x, 表示文本序列的词嵌入表示"""

# 在相加之前我们对pe做一些适配工作， 将这个三维张量的第二维也就是句子最大长度的那一维将切片到与输入的x的第二维相同即x.size(1)，

# 因为我们默认max_len为5000一般来讲实在太大了，很难有一条句子包含5000个词汇，所以要进行与输入张量的适配.

# 最后使用Variable进行封装，使其与x的样式相同，但是它是不需要进行梯度求解的，因此把requires_grad设置成false.

x = x + Variable(self.pe[:, :x.size(1)],

requires_grad=False)

# 最后使用self.dropout对象进行'丢弃'操作, 并返回结果.

return self.dropout(x)

nn.Dropout演示:

>>> m = nn.Dropout(p=0.2)

>>> input = torch.randn(4, 5)

>>> output = m(input)

>>> output

Variable containing:

0.0000 -0.5856 -1.4094 0.0000 -1.0290

2.0591 -1.3400 -1.7247 -0.9885 0.1286

0.5099 1.3715 0.0000 2.2079 -0.5497

-0.0000 -0.7839 -1.2434 -0.1222 1.2815

[torch.FloatTensor of size 4x5]

torch.unsqueeze演示:

>>> x = torch.tensor([1, 2, 3, 4])

>>> torch.unsqueeze(x, 0)

tensor([[ 1, 2, 3, 4]])

>>> torch.unsqueeze(x, 1)

tensor([[ 1],

[ 2],

[ 3],

[ 4]])

实例化参数:

# 词嵌入维度是512维

d_model = 512

# 置0比率为0.1

dropout = 0.1

# 句子最大长度

max_len=60

输入参数:

# 输入x是Embedding层的输出的张量, 形状是2 x 4 x 512

x = embr

Variable containing:

( 0 ,.,.) =

35.9321 3.2582 -17.7301 ... 3.4109 13.8832 39.0272

8.5410 -3.5790 -12.0460 ... 40.1880 36.6009 34.7141

-17.0650 -1.8705 -20.1807 ... -12.5556 -34.0739 35.6536

20.6105 4.4314 14.9912 ... -0.1342 -9.9270 28.6771

( 1 ,.,.) =

27.7016 16.7183 46.6900 ... 17.9840 17.2525 -3.9709

3.0645 -5.5105 10.8802 ... -13.0069 30.8834 -38.3209

33.1378 -32.1435 -3.9369 ... 15.6094 -29.7063 40.1361

-31.5056 3.3648 1.4726 ... 2.8047 -9.6514 -23.4909

[torch.FloatTensor of size 2x4x512]

调用:

pe = PositionalEncoding(d_model, dropout, max_len)

pe_result = pe(x)

print("pe_result:", pe_result)

输出效果:

pe_result: Variable containing:

( 0 ,.,.) =

-19.7050 0.0000 0.0000 ... -11.7557 -0.0000 23.4553

-1.4668 -62.2510 -2.4012 ... 66.5860 -24.4578 -37.7469

9.8642 -41.6497 -11.4968 ... -21.1293 -42.0945 50.7943

0.0000 34.1785 -33.0712 ... 48.5520 3.2540 54.1348

( 1 ,.,.) =

7.7598 -21.0359 15.0595 ... -35.6061 -0.0000 4.1772

-38.7230 8.6578 34.2935 ... -43.3556 26.6052 4.3084

24.6962 37.3626 -26.9271 ... 49.8989 0.0000 44.9158

-28.8435 -48.5963 -0.9892 ... -52.5447 -4.1475 -3.0450

[torch.FloatTensor of size 2x4x512]

3.2 绘制词汇向量中特征的分布曲线

import matplotlib.pyplot as plt

import numpy as np

# 创建一张15 x 5大小的画布

plt.figure(figsize=(15, 5))

# 实例化PositionalEncoding类得到pe对象, 输入参数是20和0

pe = PositionalEncoding(20, 0)

# 然后向pe传入被Variable封装的tensor, 这样pe会直接执行forward函数,

# 且这个tensor里的数值都是0, 被处理后相当于位置编码张量

y = pe(Variable(torch.zeros(1, 100, 20)))

# 然后定义画布的横纵坐标, 横坐标到100的长度, 纵坐标是某一个词汇中的某维特征在不同长度下对应的值

# 因为总共有20维之多, 我们这里只查看4，5，6，7维的值.

plt.plot(np.arange(100), y[0, :, 4:8].data.numpy())

# 在画布上填写维度提示信息

plt.legend(["dim %d"%p for p in [4,5,6,7]])

输出效果:

效果分析:每条颜色的曲线代表某一个词汇中的特征在不同位置的含义.保证同一词汇随着所在位置不同它对应位置嵌入向量会发生变化.正弦波和余弦波的值域范围都是1到-1这又很好的控制了嵌入数值的大小, 有助于梯度的快速计算.

🍔 输出部分介绍

输出部分包含:

线性层softmax层

🍔 线性层的作用

通过对上一步的线性变化得到指定维度的输出, 也就是转换维度的作用.

🍔 softmax层的作用

使最后一维的向量中的数字缩放到0-1的概率值域内, 并满足他们的和为1.

3.1 线性层和softmax层的代码分析

<code># nn.functional工具包装载了网络层中那些只进行计算, 而没有参数的层

import torch.nn.functional as F

# 将线性层和softmax计算层一起实现, 因为二者的共同目标是生成最后的结构

# 因此把类的名字叫做Generator, 生成器类

class Generator(nn.Module):

def __init__(self, d_model, vocab_size):

"""初始化函数的输入参数有两个, d_model代表词嵌入维度, vocab_size代表词表大小."""

super(Generator, self).__init__()

# 首先就是使用nn中的预定义线性层进行实例化, 得到一个对象self.project等待使用,

# 这个线性层的参数有两个, 就是初始化函数传进来的两个参数: d_model, vocab_size

self.project = nn.Linear(d_model, vocab_size)

def forward(self, x):

"""前向逻辑函数中输入是上一层的输出张量x"""

# 在函数中, 首先使用上一步得到的self.project对x进行线性变化,

# 然后使用F中已经实现的log_softmax进行的softmax处理.

# 在这里之所以使用log_softmax是因为和我们这个pytorch版本的损失函数实现有关, 在其他版本中将修复.

# log_softmax就是对softmax的结果又取了对数, 因为对数函数是单调递增函数,

# 因此对最终我们取最大的概率值没有影响. 最后返回结果即可.

return F.log_softmax(self.project(x), dim=-1)

nn.Linear演示:

>>> m = nn.Linear(20, 30)

>>> input = torch.randn(128, 20)

>>> output = m(input)

>>> print(output.size())

torch.Size([128, 30])

实例化参数:

# 词嵌入维度是512维

d_model = 512

# 词表大小是1000

vocab_size = 1000

输入参数:

# 输入x是上一层网络的输出, 我们使用来自解码器层的输出

x = de_result

调用:

gen = Generator(d_model, vocab_size)

gen_result = gen(x)

print(gen_result)

print(gen_result.shape)

输出效果:

tensor([[[-7.8098, -7.5260, -6.9244, ..., -7.6340, -6.9026, -7.5232],

[-6.9093, -7.3295, -7.2972, ..., -6.6221, -7.2268, -7.0772],

[-7.0263, -7.2229, -7.8533, ..., -6.7307, -6.9294, -7.3042],

[-6.5045, -6.0504, -6.6241, ..., -5.9063, -6.5361, -7.1484]],

[[-7.1651, -6.0224, -7.4931, ..., -7.9565, -8.0460, -6.6490],

[-6.3779, -7.6133, -8.3572, ..., -6.6565, -7.1867, -6.5112],

[-6.4914, -6.9289, -6.2634, ..., -6.2471, -7.5348, -6.8541],

[-6.8651, -7.0460, -7.6239, ..., -7.1411, -6.5496, -7.3749]]],

grad_fn=<LogSoftmaxBackward>)

torch.Size([2, 4, 1000])

🍔 小结

学习了文本嵌入层的作用:

无论是源文本嵌入还是目标文本嵌入，都是为了将文本中词汇的数字表示转变为向量表示, 希望在这样的高维空间捕捉词汇间的关系.

学习并实现了文本嵌入层的类: Embeddings

初始化函数以d_model, 词嵌入维度, 和vocab, 词汇总数为参数, 内部主要使用了nn中的预定层Embedding进行词嵌入.在forward函数中, 将输入x传入到Embedding的实例化对象中, 然后乘以一个根号下d_model进行缩放, 控制数值大小.它的输出是文本嵌入后的结果.

学习了位置编码器的作用:

因为在Transformer的编码器结构中, 并没有针对词汇位置信息的处理，因此需要在Embedding层后加入位置编码器，将词汇位置不同可能会产生不同语义的信息加入到词嵌入张量中, 以弥补位置信息的缺失.

学习并实现了位置编码器的类: PositionalEncoding

初始化函数以d_model, dropout, max_len为参数, 分别代表d_model: 词嵌入维度, dropout: 置0比率, max_len: 每个句子的最大长度.forward函数中的输入参数为x, 是Embedding层的输出.最终输出一个加入了位置编码信息的词嵌入张量.

实现了绘制词汇向量中特征的分布曲线:

保证同一词汇随着所在位置不同它对应位置嵌入向量会发生变化.正弦波和余弦波的值域范围都是1到-1, 这又很好的控制了嵌入数值的大小, 有助于梯度的快速计算.

学习了输出部分包含:

线性层softmax层

线性层的作用:

通过对上一步的线性变化得到指定维度的输出, 也就是转换维度的作用.

softmax层的作用:

使最后一维的向量中的数字缩放到0-1的概率值域内, 并满足他们的和为1.

学习并实现了线性层和softmax层的类: Generator

初始化函数的输入参数有两个, d_model代表词嵌入维度, vocab_size代表词表大小.forward函数接受上一层的输出.最终获得经过线性层和softmax层处理的结果.

💘若能为您的学习之旅添一丝光亮，不胜荣幸💘

🐼期待您的宝贵意见，让我们共同进步共同成长🐼