transformer库有没有java的

转载

mob64ca140d2323 2025-01-06 10:53:25

文章标签 transformer 深度学习自然语言处理 Self Google 文章分类 Java 后端开发

引言

$transformer库有没有java的_transformer$ 模型是 $transformer库有没有java的_transformer_02$ 团队在 $transformer库有没有java的_深度学习_03$ 年 $transformer库有没有java的_自然语言处理_04$ 月由 $transformer库有没有java的_自然语言处理_05$ 等人在论文《 $transformer库有没有java的_深度学习_06$ 》所提出，当前它已经成为 $transformer库有没有java的_transformer_07$ 领域中的首选模型。 $transformer库有没有java的_transformer$ 抛弃了 $transformer库有没有java的_深度学习_09$ 的顺序结构，采用了 $transformer库有没有java的_自然语言处理_10$ - $transformer库有没有java的_Google_11$ 机制，使得模型可以并行化训练，而且能够充分利用训练资料的全局信息，加入 $transformer库有没有java的_transformer$ 的 $transformer库有没有java的_transformer_13$ 模型在 $transformer库有没有java的_transformer_07$ 的各个任务上都有了显著的提升。本文做了大量的图示目的是能够更加清晰地讲解 $transformer库有没有java的_transformer$ 的运行原理，以及相关组件的操作细节，文末还有完整可运行的代码示例。

注意力机制

$transformer库有没有java的_transformer$ 中的核心机制就是 $transformer库有没有java的_自然语言处理_10$ - $transformer库有没有java的_Google_11$ 。 $transformer库有没有java的_自然语言处理_10$ - $transformer库有没有java的_Google_11$ 机制的本质来自于人类视觉注意力机制。当人视觉在感知东西时候往往会更加关注某个场景中显著性的物体，为了合理利用有限的视觉信息处理资源，人需要选择视觉区域中的特定部分，然后集中关注它。注意力机制主要目的就是对输入进行注意力权重的分配，即决定需要关注输入的哪部分，并对其分配有限的信息处理资源给重要的部分。

Self-Attention

transformer库有没有java的_transformer_21

$transformer库有没有java的_自然语言处理_10$ - $transformer库有没有java的_Google_11$ 工作原理如上图所示，给定输入 $transformer库有没有java的_深度学习_24$ 向量 $transformer库有没有java的_Self_25$ ，然后对于输入向量 $transformer库有没有java的_Google_26$ 通过矩阵 $transformer库有没有java的_transformer_27$ 进行线性变换得到 $transformer库有没有java的_transformer_28$ 向量 $transformer库有没有java的_Self_29$ ， $transformer库有没有java的_深度学习_30$ 向量 $transformer库有没有java的_自然语言处理_31$ ，以及 $transformer库有没有java的_Google_32$ 向量 $transformer库有没有java的_transformer_33$ ，即 $transformer库有没有java的_transformer_34$ 如果令矩阵 $transformer库有没有java的_transformer_35$ ， $transformer库有没有java的_Self_36$ ， $transformer库有没有java的_Google_37$ ， $transformer库有没有java的_自然语言处理_38$ ，则此时则有 $transformer库有没有java的_自然语言处理_39$ 接着再利用得到的 $transformer库有没有java的_transformer_28$ 向量和 $transformer库有没有java的_深度学习_30$ 向量计算注意力得分，论文中采用的注意力计算公式为点积缩放公式 $transformer库有没有java的_Google_42$ 论文中假定 $transformer库有没有java的_深度学习_30$ 向量 $transformer库有没有java的_transformer_44$ 的元素和 $transformer库有没有java的_transformer_28$ 向量 $transformer库有没有java的_Self_46$ 的元素独立同分布，且令均值为 $transformer库有没有java的_深度学习_47$ ，方差为 $transformer库有没有java的_Self_48$ ，则此时注意力向量 $transformer库有没有java的_transformer_49$ 的第 $transformer库有没有java的_深度学习_50$ 个分量 $transformer库有没有java的_深度学习_51$ 的均值为 $transformer库有没有java的_深度学习_47$ ，方差 $transformer库有没有java的_Self_48$ 具体的计算公式如下 $transformer库有没有java的_Google_54$ 令注意力分数矩阵 $transformer库有没有java的_深度学习_55$ ，则有 $transformer库有没有java的_自然语言处理_56$ 注意分数向量 $transformer库有没有java的_Self_57$ 经过 $transformer库有没有java的_自然语言处理_58$ 层得到归一化后的注意力分布 $transformer库有没有java的_Google_59$ ，即为 $transformer库有没有java的_transformer_60$ 最后利用得到的注意力分布向量 $transformer库有没有java的_Google_59$ 和 $transformer库有没有java的_Google_32$ 矩阵 $transformer库有没有java的_transformer_63$ 获得最后的输出 $transformer库有没有java的_Self_64$ ，则有 $transformer库有没有java的_Self_65$ 令输出矩阵 $transformer库有没有java的_transformer_66$ ，则有 $transformer库有没有java的_深度学习_67$

Multi-Head Attention

transformer库有没有java的_transformer_68

$transformer库有没有java的_Self_69$ - $transformer库有没有java的_transformer_70$ 的工作原理与 $transformer库有没有java的_自然语言处理_10$ - $transformer库有没有java的_Google_11$ 的工作原理非常类似。为了方便图解可视化将 $transformer库有没有java的_Self_69$ - $transformer库有没有java的_transformer_74$ 设置为 $transformer库有没有java的_Google_75$ - $transformer库有没有java的_transformer_74$ ，如果 $transformer库有没有java的_Self_69$ - $transformer库有没有java的_transformer_74$ 设置为 $transformer库有没有java的_自然语言处理_79$ - $transformer库有没有java的_transformer_74$ ，则上图的 $transformer库有没有java的_transformer_81$ 的下一步的分支数为 $transformer库有没有java的_自然语言处理_79$ 。给定输入 $transformer库有没有java的_深度学习_24$ 向量 $transformer库有没有java的_Self_25$ ，然后对于输入向量 $transformer库有没有java的_Google_26$ 通过矩阵 $transformer库有没有java的_transformer_27$ 进行第一次线性变换得到 $transformer库有没有java的_transformer_28$ 向量 $transformer库有没有java的_Self_29$ ， $transformer库有没有java的_深度学习_30$ 向量 $transformer库有没有java的_Google_90$ ，以及 $transformer库有没有java的_Google_32$ 向量 $transformer库有没有java的_自然语言处理_92$ 。然后再对 $transformer库有没有java的_transformer_28$ 向量 $transformer库有没有java的_自然语言处理_94$ 通过矩阵 $transformer库有没有java的_自然语言处理_95$ 和 $transformer库有没有java的_Self_96$ 进行第二次线性变换得到 $transformer库有没有java的_自然语言处理_97$ 和 $transformer库有没有java的_深度学习_98$ ，同理对 $transformer库有没有java的_深度学习_30$ 向量 $transformer库有没有java的_Google_100$ 通过矩阵 $transformer库有没有java的_transformer_101$ 和 $transformer库有没有java的_transformer_102$ 进行第二次线性变换得到 $transformer库有没有java的_Self_103$ 和 $transformer库有没有java的_Self_104$ ，对 $transformer库有没有java的_Google_32$ 向量 $transformer库有没有java的_transformer_106$ 通过矩阵 $transformer库有没有java的_深度学习_107$ 和 $transformer库有没有java的_深度学习_108$ 进行第二次线性变换得到 $transformer库有没有java的_Self_109$ 和 $transformer库有没有java的_transformer_110$ ,具体的计算公式如下所示： $transformer库有没有java的_自然语言处理_111$ 令矩阵 $transformer库有没有java的_Self_112$ 此时则有 $transformer库有没有java的_自然语言处理_113$ 对于每个 $transformer库有没有java的_transformer_74$ 利用得到对于 $transformer库有没有java的_transformer_28$ 向量和 $transformer库有没有java的_深度学习_30$ 向量计算对应的注意力得分，其中注意力向量 $transformer库有没有java的_transformer_117$ 的第 $transformer库有没有java的_深度学习_50$ 个分量的计算公式为 $transformer库有没有java的_Google_119$ 令注意力分数矩阵 $transformer库有没有java的_深度学习_120$ ， $transformer库有没有java的_Self_121$ ，则有 $transformer库有没有java的_深度学习_122$ 注意分数向量 $transformer库有没有java的_transformer_117$ 经过 $transformer库有没有java的_自然语言处理_58$ 层得到归一化后的注意力分布 $transformer库有没有java的_深度学习_125$ ，即为 $transformer库有没有java的_transformer_126$ 对于每一个 $transformer库有没有java的_transformer_74$ 利用得到的注意力分布向量 $transformer库有没有java的_深度学习_125$ 和 $transformer库有没有java的_Google_32$ 矩阵 $transformer库有没有java的_Self_130$ 获得最后的输出 $transformer库有没有java的_Google_131$ ，则有 $transformer库有没有java的_自然语言处理_132$ 两个 $transformer库有没有java的_transformer_74$ 的 $transformer库有没有java的_自然语言处理_134$ 的向量按照如下方式拼接在一起，则有 $transformer库有没有java的_自然语言处理_135$ 给定参数矩阵 $transformer库有没有java的_Google_136$ ，则输出矩阵为 $transformer库有没有java的_Google_137$ 综上所述则有 $transformer库有没有java的_深度学习_138$

Mask Self-Attention

如下图左半部分所示， $transformer库有没有java的_自然语言处理_10$ - $transformer库有没有java的_Google_11$ 的输出向量 $transformer库有没有java的_自然语言处理_141$ 综合了输入向量 $transformer库有没有java的_深度学习_142$ 的全部信息，由此可见， $transformer库有没有java的_自然语言处理_10$ - $transformer库有没有java的_Google_11$ 在实际编程中支持并行运算。如下图右半部分所示， $transformer库有没有java的_transformer_145$ - $transformer库有没有java的_Google_11$ 的输出向量 $transformer库有没有java的_Self_147$ 只利用了已知部分输入的向量 $transformer库有没有java的_transformer_148$ 的信息。例如， $transformer库有没有java的_Google_149$ 只是与 $transformer库有没有java的_transformer_150$ 有关； $transformer库有没有java的_自然语言处理_151$ 与 $transformer库有没有java的_transformer_150$ 和 $transformer库有没有java的_深度学习_153$ 有关； $transformer库有没有java的_transformer_154$ 与 $transformer库有没有java的_transformer_150$ ， $transformer库有没有java的_深度学习_153$ 和 $transformer库有没有java的_transformer_157$ 有关； $transformer库有没有java的_深度学习_158$ 与 $transformer库有没有java的_transformer_150$ ， $transformer库有没有java的_深度学习_153$ ， $transformer库有没有java的_transformer_157$ 和 $transformer库有没有java的_深度学习_162$ 有关。 $transformer库有没有java的_transformer_145$ - $transformer库有没有java的_Google_11$ 在 $transformer库有没有java的_transformer$ 中被用到过两次。

$transformer库有没有java的_Google_166$ 的 $transformer库有没有java的_Self_167$ 中如果输入一句话的 $transformer库有没有java的_transformer_168$ 长度小于指定的长度，为了能够让长度一致往往会用 $transformer库有没有java的_自然语言处理_169$ 进行填充，此时则需要用 $transformer库有没有java的_Google_170$ - $transformer库有没有java的_Self_171$ 来计算注意力分布。
$transformer库有没有java的_Google_166$ 的 $transformer库有没有java的_transformer_173$ 的输出是有时序关系的，当前的输出只与之前的输入有关，所以此时算注意力分布时需要用到 $transformer库有没有java的_Google_170$ - $transformer库有没有java的_Self_171$ 。

transformer库有没有java的_深度学习_176

Transformer模型

以上对 $transformer库有没有java的_transformer$ 中的核心内容即自注意力机制进行了详细解剖，接下来会对 $transformer库有没有java的_transformer$ 模型架构进行介绍。 $transformer库有没有java的_transformer$ 模型是由 $transformer库有没有java的_Google_180$ 和 $transformer库有没有java的_深度学习_181$ 两个模块组成，具体的示意图如下所示，为了能够对 $transformer库有没有java的_transformer$ 内部的操作细节进行更清晰的展示，下图以矩阵运算的视角对 $transformer库有没有java的_transformer$ 的原理进行讲解。
$transformer库有没有java的_Self_167$ 模块操作的具体流程如下所示：

$transformer库有没有java的_Self_167$ 的输入由两部分组成分别是词编码矩阵 $transformer库有没有java的_深度学习_186$ 和位置编码矩阵 $transformer库有没有java的_深度学习_187$ ，其中 $transformer库有没有java的_transformer_188$ 表示句子数目， $transformer库有没有java的_Google_189$ 表示一句话单词的最大数目， $transformer库有没有java的_深度学习_190$ 表示的是词向量的维度。位置编码矩阵 $transformer库有没有java的_Google_191$ 表示的是每个单词在一句里的所有位置信息，因为 $transformer库有没有java的_Google_192$ - $transformer库有没有java的_Self_171$ 计算注意力分布的时候只能给出输出向量和输入向量之间的权重关系，但是不能给出词在一句话里的位置信息，所以需要在输入里引入位置编码矩阵 $transformer库有没有java的_Google_191$ 。位置编码向量生成方法有很多。一种比较简单粗暴的方式就是根据单词在句子中的位置生成一个 $transformer库有没有java的_Google_195$ - $transformer库有没有java的_Self_196$ 的位置编码；还有的方法是将位置编码当成参数进行训练学习；在该论文里是利用三角函数对位置进行编码，具体的公式如下所示 $transformer库有没有java的_深度学习_197$ 其中 $transformer库有没有java的_深度学习_198$ 表示的是位置编码向量， $transformer库有没有java的_Google_199$ 表示词在句子中的位置， $transformer库有没有java的_Self_200$ 表示编码向量的位置索引。
输入矩阵 $transformer库有没有java的_Google_201$ 通过线性变换生成矩阵 $transformer库有没有java的_Google_202$ ， $transformer库有没有java的_Google_203$ ， $transformer库有没有java的_深度学习_204$ 。在实际编程中是将输入 $transformer库有没有java的_Google_201$ 直接赋值给 $transformer库有没有java的_Google_202$ ， $transformer库有没有java的_Google_203$ ， $transformer库有没有java的_深度学习_204$ 。如果输入单词长度小于最大长度并 $transformer库有没有java的_自然语言处理_169$ 来填充的时候，还要相应引入 $transformer库有没有java的_Self_210$ 矩阵。
将矩阵 $transformer库有没有java的_Google_202$ ， $transformer库有没有java的_Google_203$ ， $transformer库有没有java的_深度学习_204$ 输入到 $transformer库有没有java的_深度学习_214$ - $transformer库有没有java的_自然语言处理_215$ 模块中进行注意分布的计算得到矩阵 $transformer库有没有java的_Self_216$ ，计算公式为 $transformer库有没有java的_transformer_217$ 具体的计算细节参考上文关于 $transformer库有没有java的_深度学习_214$ - $transformer库有没有java的_自然语言处理_215$ 原理的讲解不在这里赘述。然后将原始输入 $transformer库有没有java的_Google_201$ 与注意力分布 $transformer库有没有java的_transformer_221$ 进行残差计算得到输出矩阵 $transformer库有没有java的_Google_222$ 。
对矩阵 $transformer库有没有java的_Self_223$ 进行层归一化操作得到 $transformer库有没有java的_Google_224$ ，具体的计算公式为 $transformer库有没有java的_深度学习_225$
将 $transformer库有没有java的_transformer_226$ 输入到全连接神经网络中得到 $transformer库有没有java的_深度学习_227$ ，然后再让全连接神经网络的输入 $transformer库有没有java的_transformer_226$ 与输出 $transformer库有没有java的_Self_229$ 进行残差计算得到 $transformer库有没有java的_深度学习_230$ ，接着对 $transformer库有没有java的_深度学习_230$ 进行层归一化操作。
以上是一个 $transformer库有没有java的_Self_232$ 的操作原理，将 $transformer库有没有java的_transformer_233$ 个 $transformer库有没有java的_Self_232$ 进行堆叠就组成了 $transformer库有没有java的_Self_167$ 的模块，得到的最后输出为 $transformer库有没有java的_Google_236$ 。这里需要注意的是 $transformer库有没有java的_Self_167$ 模块中的各个组件的操作顺序并不是固定的，也可以先进行归一化操作，然后再计算注意力分布，再归一化，再预测等。

$transformer库有没有java的_深度学习_181$ 模块操作的具体流程如下所示：

$transformer库有没有java的_transformer_173$ 的输入也由两部分组成分别是词编码矩阵 $transformer库有没有java的_深度学习_240$ 和位置编码矩阵 $transformer库有没有java的_深度学习_241$ 。因为 $transformer库有没有java的_transformer_173$ 的输入是具有时顺序关系的（即上一步的输出为当前步输入）所以还需要输入 $transformer库有没有java的_Self_210$ 矩阵 $transformer库有没有java的_Self_244$ 以便计算注意力分布。
输入矩阵 $transformer库有没有java的_Google_245$ 通过线性变换生成矩阵 $transformer库有没有java的_Self_246$ ， $transformer库有没有java的_transformer_247$ ， $transformer库有没有java的_自然语言处理_248$ 。在实际编程中是将输入 $transformer库有没有java的_Google_245$ 直接赋值给 $transformer库有没有java的_Self_246$ ， $transformer库有没有java的_transformer_247$ ， $transformer库有没有java的_自然语言处理_248$ 。如果输入单词长度小于最大长度并 $transformer库有没有java的_自然语言处理_169$ 来填充的时候，还要相应引入 $transformer库有没有java的_Self_210$ 矩阵。
将矩阵 $transformer库有没有java的_Self_246$ ， $transformer库有没有java的_transformer_247$ ， $transformer库有没有java的_自然语言处理_248$ 以及 $transformer库有没有java的_Self_210$ 矩阵 $transformer库有没有java的_Self_244$ 输入到 $transformer库有没有java的_Self_260$ - $transformer库有没有java的_自然语言处理_215$ 模块中进行注意分布的计算得到矩阵 $transformer库有没有java的_Google_262$ ，计算公式为 $transformer库有没有java的_自然语言处理_263$ 具体的计算细节参考上文关于 $transformer库有没有java的_深度学习_264$ - $transformer库有没有java的_Self_171$ 的讲解不在这里赘述。然后将原始输入 $transformer库有没有java的_Google_245$ 与注意力分布 $transformer库有没有java的_transformer_267$ 进行残差计算得到输出矩阵 $transformer库有没有java的_transformer_268$ 。接着再对矩阵 $transformer库有没有java的_深度学习_269$ 进行层归一化操作得到 $transformer库有没有java的_自然语言处理_270$ 。
$transformer库有没有java的_Self_167$ 的输出 $transformer库有没有java的_深度学习_272$ 通过线性变换得到 $transformer库有没有java的_Google_273$ 和 $transformer库有没有java的_Google_274$ ， $transformer库有没有java的_transformer_267$ 进行线性变换得到 $transformer库有没有java的_Google_276$ ，利用矩阵 $transformer库有没有java的_Google_273$ 和 $transformer库有没有java的_Google_274$ 和 $transformer库有没有java的_Google_276$ 进行交叉注意力分布的计算得到 $transformer库有没有java的_Google_280$ ，计算公式为 $transformer库有没有java的_自然语言处理_281$ 这里的交叉注意力分布综合 $transformer库有没有java的_Self_167$ 输出结果和 $transformer库有没有java的_transformer_173$ 中间结果的信息。实际编程编程中将 $transformer库有没有java的_深度学习_272$ 直接赋值给 $transformer库有没有java的_Self_246$ 和 $transformer库有没有java的_transformer_247$ ， $transformer库有没有java的_transformer_267$ 直接赋值给 $transformer库有没有java的_Google_276$ 。然后将 $transformer库有没有java的_Self_289$ 与注意力分布 $transformer库有没有java的_Google_280$ 进行残差计算得到输出矩阵 $transformer库有没有java的_自然语言处理_291$ 。
接着对 $transformer库有没有java的_自然语言处理_291$ 进行层归一操作得到 $transformer库有没有java的_Google_293$ ，再将 $transformer库有没有java的_Google_293$ 输入到全连接神经网络中得到 $transformer库有没有java的_自然语言处理_295$ ，接着再做一步残差操作得到 $transformer库有没有java的_Google_296$ ，最后再进行一层归一化操作。
以上是一个 $transformer库有没有java的_Self_232$ 的操作原理，将 $transformer库有没有java的_transformer_233$ 个 $transformer库有没有java的_Self_232$ 进行堆叠就组成了 $transformer库有没有java的_transformer_173$ 的模块，得到的输出为 $transformer库有没有java的_Self_301$ 。然后在词汇字典中找到当前预测最大概率的单词，并将该单词词向量作为下一阶段的输入，重复以上步骤，直到输出“ $transformer库有没有java的_transformer_302$ ”字符为止。

transformer库有没有java的_深度学习_303

代码示例

$transformer库有没有java的_transformer$ 具体的代码示例如下所示为一个国外博主视频里的代码，并根据上文对代码的一些细节进行了探讨。根据上文中 $transformer库有没有java的_Self_69$ - $transformer库有没有java的_transformer_70$ 原理示例图可知，严格来看 $transformer库有没有java的_Self_69$ - $transformer库有没有java的_transformer_70$ 在求注意分布的时候中间其实是有两步线性变换。给定输入向量 $transformer库有没有java的_深度学习_309$ 第一步线性变换直接让向量 $transformer库有没有java的_深度学习_310$ 赋值给 $transformer库有没有java的_transformer_311$ ， $transformer库有没有java的_自然语言处理_312$ ， $transformer库有没有java的_深度学习_313$ ，这一过程以下程序中有所体现，在这里并不会产生歧义。第二步线性变换产生多 $transformer库有没有java的_transformer_74$ ，假设 $transformer库有没有java的_Self_315$ 的时候，按理说 $transformer库有没有java的_transformer_311$ 要与 $transformer库有没有java的_自然语言处理_79$ 个矩阵 $transformer库有没有java的_自然语言处理_318$ 进行线性变换得到 $transformer库有没有java的_自然语言处理_79$ 个 $transformer库有没有java的_Google_320$ ，同理 $transformer库有没有java的_自然语言处理_312$ 要与 $transformer库有没有java的_自然语言处理_79$ 个矩阵 $transformer库有没有java的_Google_323$ 进行线性变换得到 $transformer库有没有java的_自然语言处理_79$ 个 $transformer库有没有java的_transformer_325$ ， $transformer库有没有java的_深度学习_313$ 要与 $transformer库有没有java的_自然语言处理_79$ 个矩阵 $transformer库有没有java的_自然语言处理_328$ 进行线性变换得到 $transformer库有没有java的_自然语言处理_79$ 个 $transformer库有没有java的_深度学习_330$ ，如果按照这个方式在程序实现则需要定义24个权重矩阵，非常的麻烦。以下程序中有一个简单的权重定义方法，通过该方法也可以实现以上多 $transformer库有没有java的_transformer_74$ 的线性变换，以向量 $transformer库有没有java的_Self_332$ 为例：

首先将向量 $transformer库有没有java的_Self_333$ 进行截断分成 $transformer库有没有java的_深度学习_334$ 个向量，即为 $transformer库有没有java的_深度学习_335$ 其中 $transformer库有没有java的_深度学习_336$ 是 $transformer库有没有java的_Self_333$ 的第 $transformer库有没有java的_Self_200$ 个截断向量， $transformer库有没有java的_Google_339$ 是单位矩阵， $transformer库有没有java的_transformer_340$ 是零矩阵。
然后对 $transformer库有没有java的_Self_341$ 用相同的权重矩阵 $transformer库有没有java的_深度学习_342$ 进行线性变换，此时可以发现，训练过程的时候只需要更新权重矩阵 $transformer库有没有java的_自然语言处理_343$ 即可，而且可以进行多 $transformer库有没有java的_深度学习_344$ 线性变换， $transformer库有没有java的_transformer_345$ 个权重矩阵可以表示为： $transformer库有没有java的_Self_346$ 其中权重矩阵 $transformer库有没有java的_Google_347$ 。

import torch
import torch.nn as nn
import os

class SelfAttention(nn.Module):
	def __init__(self, embed_size, heads):
		super(SelfAttention, self).__init__()
		self.embed_size = embed_size
		self.heads = heads
		self.head_dim = embed_size // heads

		assert (self.head_dim * heads == embed_size), "Embed size needs to be div by heads"

		self.values = nn.Linear(self.head_dim, self.head_dim, bias=False)
		self.keys = nn.Linear(self.head_dim, self.head_dim, bias=False)
		self.queries = nn.Linear(self.head_dim, self.head_dim, bias=False)
		self.fc_out = nn.Linear(heads * self.head_dim, embed_size)

	def forward(self, values, keys, query, mask):
		N =query.shape[0]
		value_len , key_len , query_len = values.shape[1], keys.shape[1], query.shape[1]

		# split embedding into self.heads pieces
		values = values.reshape(N, value_len, self.heads, self.head_dim)
		keys = keys.reshape(N, key_len, self.heads, self.head_dim)
		queries = query.reshape(N, query_len, self.heads, self.head_dim)
		
		values = self.values(values)
		keys = self.keys(keys)
		queries = self.queries(queries)

		energy = torch.einsum("nqhd,nkhd->nhqk", queries, keys)
		# queries shape: (N, query_len, heads, heads_dim)
		# keys shape : (N, key_len, heads, heads_dim)
		# energy shape: (N, heads, query_len, key_len)

		if mask is not None:
			energy = energy.masked_fill(mask == 0, float("-1e20"))

		attention = torch.softmax(energy/ (self.embed_size ** (1/2)), dim=3)

		out = torch.einsum("nhql, nlhd->nqhd", [attention, values]).reshape(N, query_len, self.heads*self.head_dim)
		# attention shape: (N, heads, query_len, key_len)
		# values shape: (N, value_len, heads, heads_dim)
		# (N, query_len, heads, head_dim)

		out = self.fc_out(out)
		return out


class TransformerBlock(nn.Module):
	def __init__(self, embed_size, heads, dropout, forward_expansion):
		super(TransformerBlock, self).__init__()
		self.attention = SelfAttention(embed_size, heads)
		self.norm1 = nn.LayerNorm(embed_size)
		self.norm2 = nn.LayerNorm(embed_size)

		self.feed_forward = nn.Sequential(
			nn.Linear(embed_size, forward_expansion*embed_size),
			nn.ReLU(),
			nn.Linear(forward_expansion*embed_size, embed_size)
		)
		self.dropout = nn.Dropout(dropout)

	def forward(self, value, key, query, mask):
		attention = self.attention(value, key, query, mask)

		x = self.dropout(self.norm1(attention + query))
		forward = self.feed_forward(x)
		out = self.dropout(self.norm2(forward + x))
		return out


class Encoder(nn.Module):
	def __init__(
			self,
			src_vocab_size,
			embed_size,
			num_layers,
			heads,
			device,
			forward_expansion,
			dropout,
			max_length,
		):
		super(Encoder, self).__init__()
		self.embed_size = embed_size
		self.device = device
		self.word_embedding = nn.Embedding(src_vocab_size, embed_size)
		self.position_embedding = nn.Embedding(max_length, embed_size)

		self.layers = nn.ModuleList(
			[
				TransformerBlock(
					embed_size,
					heads,
					dropout=dropout,
					forward_expansion=forward_expansion,
					)
				for _ in range(num_layers)]
		)
		self.dropout = nn.Dropout(dropout)


	def forward(self, x, mask):
		N, seq_length = x.shape
		positions = torch.arange(0, seq_length).expand(N, seq_length).to(self.device)
		out = self.dropout(self.word_embedding(x) + self.position_embedding(positions))
		for layer in self.layers:
			out = layer(out, out, out, mask)

		return out


class DecoderBlock(nn.Module):
	def __init__(self, embed_size, heads, forward_expansion, dropout, device):
		super(DecoderBlock, self).__init__()
		self.attention = SelfAttention(embed_size, heads)
		self.norm = nn.LayerNorm(embed_size)
		self.transformer_block = TransformerBlock(
			embed_size, heads, dropout, forward_expansion
		)

		self.dropout = nn.Dropout(dropout)

	def forward(self, x, value, key, src_mask, trg_mask):
		attention = self.attention(x, x, x, trg_mask)
		query = self.dropout(self.norm(attention + x))
		out = self.transformer_block(value, key, query, src_mask)
		return out

class Decoder(nn.Module):
	def __init__(
			self,
			trg_vocab_size,
			embed_size,
			num_layers,
			heads,
			forward_expansion,
			dropout,
			device,
			max_length,
	):
		super(Decoder, self).__init__()
		self.device = device
		self.word_embedding = nn.Embedding(trg_vocab_size, embed_size)
		self.position_embedding = nn.Embedding(max_length, embed_size)
		self.layers = nn.ModuleList(
			[DecoderBlock(embed_size, heads, forward_expansion, dropout, device)
			for _ in range(num_layers)]
			)
		self.fc_out = nn.Linear(embed_size, trg_vocab_size)
		self.dropout = nn.Dropout(dropout)

	def forward(self, x ,enc_out , src_mask, trg_mask):
		N, seq_length = x.shape
		positions = torch.arange(0, seq_length).expand(N, seq_length).to(self.device)
		x = self.dropout((self.word_embedding(x) + self.position_embedding(positions)))

		for layer in self.layers:
			x = layer(x, enc_out, enc_out, src_mask, trg_mask)

		out =self.fc_out(x)
		return out


class Transformer(nn.Module):
	def __init__(
			self,
			src_vocab_size,
			trg_vocab_size,
			src_pad_idx,
			trg_pad_idx,
			embed_size = 256,
			num_layers = 6,
			forward_expansion = 4,
			heads = 8,
			dropout = 0,
			device="cuda",
			max_length=100
		):
		super(Transformer, self).__init__()
		self.encoder = Encoder(
			src_vocab_size,
			embed_size,
			num_layers,
			heads,
			device,
			forward_expansion,
			dropout,
			max_length
			)
		self.decoder = Decoder(
			trg_vocab_size,
			embed_size,
			num_layers,
			heads,
			forward_expansion,
			dropout,
			device,
			max_length
			)


		self.src_pad_idx = src_pad_idx
		self.trg_pad_idx = trg_pad_idx
		self.device = device


	def make_src_mask(self, src):
		src_mask = (src != self.src_pad_idx).unsqueeze(1).unsqueeze(2)
		# (N, 1, 1, src_len)
		return src_mask.to(self.device)

	def make_trg_mask(self, trg):
		N, trg_len = trg.shape
		trg_mask = torch.tril(torch.ones((trg_len, trg_len))).expand(
			N, 1, trg_len, trg_len
		)
		return trg_mask.to(self.device)

	def forward(self, src, trg):
		src_mask = self.make_src_mask(src)
		trg_mask = self.make_trg_mask(trg)
		enc_src = self.encoder(src, src_mask)
		out = self.decoder(trg, enc_src, src_mask, trg_mask)
		return out


if __name__ == '__main__':
	device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
	print(device)
	x = torch.tensor([[1,5,6,4,3,9,5,2,0],[1,8,7,3,4,5,6,7,2]]).to(device)
	trg = torch.tensor([[1,7,4,3,5,9,2,0],[1,5,6,2,4,7,6,2]]).to(device)

	src_pad_idx = 0
	trg_pad_idx = 0
	src_vocab_size = 10
	trg_vocab_size = 10
	model = Transformer(src_vocab_size, trg_vocab_size, src_pad_idx, trg_pad_idx, device=device).to(device)
	out = model(x, trg[:, : -1])
	print(out.shape)

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。