参考：淺談神經機器翻譯 & 用 Transformer 與 TensorFlow 2 英翻中 运行环境：Google Colab （也可以选择本地或服务器的 jupyter notebook，只是在线的 Colab 免费提供GPU） TensorFlow API：Modelu: tf | TensorFlow Core v2.5.0

1、环境设置

import os
import time
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt
from pprint import pprint
from IPython.display import clear_output

import tensorflow as tf
import tensorflow_datasets as tfds
print(tf.__version__)

输出 tensorflow 版本号：2.5.0

由于使用的是 Colab，将数据存储在 Google Drive，因此需要先挂载 Google Drive：

参考：Colab：在本地装载 Google 云端硬盘

from google.colab import drive
drive.mount('./mount')

定义一些之后存储各种数据时会用到的路径：

output_dir = "mount/My Drive/Colab Notebooks/DLHLP20"
en_vocab_file = os.path.join(output_dir, "en_vocab")
zh_vocab_file = os.path.join(output_dir, "zh_vocab")
checkpoint_path = os.path.join(output_dir, "checkpoints")
log_dir = os.path.join(output_dir, 'logs')
download_dir = "mount/My Drive/Colab Notebooks/DLHLP20/datasets"
if not os.path.exists(output_dir):
    os.makedirs(output_dir)
if not os.path.exists(download_dir):
    os.makedirs(download_dir)

2、数据处理 & 建立输入管道

通过 tf.data API 以及前面导入的 TensorFlow Datasets (import tensorflow_datasets as tfds) 来建立高效的输入管道，以在当前训练步骤完成之前就准备好下一个时间点 GPU 需要使用的数据，使得 GPU 并行计算能发挥最佳性能

2.1 下载并准备数据集

本实验最终让 Transformer 实现英翻中，使用的数据集是 机器翻译竞赛 WMT 2019 的中英数据集

先查看 tfds （tfds API）中 WMT 2019 的中英翻译有哪些数据来源：

tmp_builder = tfds.builder("wmt19_translate/zh-en")
pprint(tmp_builder.subsets)

输出如下，包含多个来源的数据集

{Split('train'): ['newscommentary_v14',    // 新闻评论数据集
                                'wikititles_v1',            // 维基百科标题数据集
                                'uncorpus_v1',                // 联合国数据集
                  'casia2015',
                  'casict2011',
                  'casict2015',
                  'datum2015',
                  'datum2017',
                  'neu2017'],
 Split('validation'): ['newstest2018']}

为了节省 Transformer 的训练时间，只选择其中的新闻评论数据集当作训练数据集，即 newscommentary_v14

config = tfds.translate.wmt.WmtConfig(
    version="0.0.3",  # 注意这一行与参考博文不一样，否则会报错
    language_pair=("zh", "en"),
    subsets={
        tfds.Split.TRAIN: ["newscommentary_v14"]
    }
)
builder = tfds.builder("wmt_translate", config=config)
builder.download_and_prepare(download_dir=download_dir)
clear_output()

2.2 切割数据集

然只下载了一个新闻评论的数据集，但里面还是有超过30万对中英语句，为了减少训练时间，将此数据集切割成多个部分的 split ，20% 当作训练集，1% 当作验证集，剩下的 79% 数据不使用

参考博文使用 tfds.Split.TRAIN.subsplit 切割，但这个函数已经被官方移除，是过时的写法，会报错 修改方法参考：How to split a tensorflow dataset into train, test and validation in a Python script?

train_perc = 20     # 训练集
val_prec = 1          # 验证集
drop_prec = 100 - train_perc - val_prec # 不用的数据
split = ["train[:20%]","train[20%:21%]","train[21%:]"]
split

examples = builder.as_dataset(split=split, as_supervised=True)
train_examples, val_examples, _ = examples
print(train_examples)    # 训练集
print(val_examples)        # 验证集

上面的 train_examples 跟 val_examples 都已經是 tf.data.Dataset
先拿几笔数据出来看看：

for en, zh in train_examples.take(3):
    print(en)
    print(zh)
    print('-' * 10)

输出如下，每一对 example （即每一次 take）都包含相同语义的中、英文两个句子，并且是以 unicode 呈现的 tf.Tensor ：

tf.Tensor(b'The fear is real and visceral, and politicians ignore it at their peril.', shape=(), dtype=string)
tf.Tensor(b'\xe8\xbf\x99\xe7\xa7\x8d\xe6\x81\x90\xe6\x83\xa7\xe6\x98\xaf\xe7\x9c\x9f\xe5\xae\x9e\xe8\x80\x8c\xe5\x86\x85\xe5\x9c\xa8\xe7\x9a\x84\xe3\x80\x82 \xe5\xbf\xbd\xe8\xa7\x86\xe5\xae\x83\xe7\x9a\x84\xe6\x94\xbf\xe6\xb2\xbb\xe5\xae\xb6\xe4\xbb\xac\xe5\x89\x8d\xe9\x80\x94\xe5\xa0\xaa\xe5\xbf\xa7\xe3\x80\x82', shape=(), dtype=string)
----------
tf.Tensor(b'In fact, the German political landscape needs nothing more than a truly liberal party, in the US sense of the word \xe2\x80\x9cliberal\xe2\x80\x9d \xe2\x80\x93 a champion of the cause of individual freedom.', shape=(), dtype=string)
tf.Tensor(b'\xe4\xba\x8b\xe5\xae\x9e\xe4\xb8\x8a\xef\xbc\x8c\xe5\xbe\xb7\xe5\x9b\xbd\xe6\x94\xbf\xe6\xb2\xbb\xe5\xb1\x80\xe5\x8a\xbf\xe9\x9c\x80\xe8\xa6\x81\xe7\x9a\x84\xe4\xb8\x8d\xe8\xbf\x87\xe6\x98\xaf\xe4\xb8\x80\xe4\xb8\xaa\xe7\xac\xa6\xe5\x90\x88\xe7\xbe\x8e\xe5\x9b\xbd\xe6\x89\x80\xe8\xb0\x93\xe2\x80\x9c\xe8\x87\xaa\xe7\x94\xb1\xe2\x80\x9d\xe5\xae\x9a\xe4\xb9\x89\xe7\x9a\x84\xe7\x9c\x9f\xe6\xad\xa3\xe7\x9a\x84\xe8\x87\xaa\xe7\x94\xb1\xe5\x85\x9a\xe6\xb4\xbe\xef\xbc\x8c\xe4\xb9\x9f\xe5\xb0\xb1\xe6\x98\xaf\xe4\xb8\xaa\xe4\xba\xba\xe8\x87\xaa\xe7\x94\xb1\xe4\xba\x8b\xe4\xb8\x9a\xe7\x9a\x84\xe5\x80\xa1\xe5\xaf\xbc\xe8\x80\x85\xe3\x80\x82', shape=(), dtype=string)
----------
tf.Tensor(b'Shifting to renewable-energy sources will require enormous effort and major infrastructure investment.', shape=(), dtype=string)
tf.Tensor(b'\xe5\xbf\x85\xe9\xa1\xbb\xe4\xbb\x98\xe5\x87\xba\xe5\xb7\xa8\xe5\xa4\xa7\xe7\x9a\x84\xe5\x8a\xaa\xe5\x8a\x9b\xe5\x92\x8c\xe5\x9f\xba\xe7\xa1\x80\xe8\xae\xbe\xe6\x96\xbd\xe6\x8a\x95\xe8\xb5\x84\xe6\x89\x8d\xe8\x83\xbd\xe5\xae\x8c\xe6\x88\x90\xe5\x90\x91\xe5\x8f\xaf\xe5\x86\x8d\xe7\x94\x9f\xe8\x83\xbd\xe6\xba\x90\xe7\x9a\x84\xe8\xbf\x87\xe6\xb8\xa1\xe3\x80\x82', shape=(), dtype=string)
----------

取 10 笔数据，将这些 Tensors 实际存储的字符串利用 numpy() 取出并解码查看：

sample_examples = []
num_samples = 10
for en_t, zh_t in train_examples.take(num_samples):
    en = en_t.numpy().decode("utf-8")
    zh = zh_t.numpy().decode("utf-8")
    print(en)
    print(zh)
    print('-' * 10)
    # 之後用來簡單評估模型的訓練情況
    sample_examples.append((en, zh))

输出如下：

The fear is real and visceral, and politicians ignore it at their peril.
这种恐惧是真实而内在的。 忽视它的政治家们前途堪忧。
----------
In fact, the German political landscape needs nothing more than a truly liberal party, in the US sense of the word “liberal” – a champion of the cause of individual freedom.
事实上，德国政治局势需要的不过是一个符合美国所谓“自由”定义的真正的自由党派，也就是个人自由事业的倡导者。
----------
Shifting to renewable-energy sources will require enormous effort and major infrastructure investment.
必须付出巨大的努力和基础设施投资才能完成向可再生能源的过渡。
----------
In this sense, it is critical to recognize the fundamental difference between “urban villages” and their rural counterparts.
在这方面，关键在于认识到“城市村落”和农村村落之间的根本区别。
----------
A strong European voice, such as Nicolas Sarkozy’s during the French presidency of the EU, may make a difference, but only for six months, and at the cost of reinforcing other European countries’ nationalist feelings in reaction to the expression of “Gallic pride.”
法国担任轮值主席国期间尼古拉·萨科奇统一的欧洲声音可能让人耳目一新，但这种声音却只持续了短短六个月，而且付出了让其他欧洲国家在面对“高卢人的骄傲”时民族主义情感进一步被激发的代价。
----------
Most of Japan’s bondholders are nationals (if not the central bank) and have an interest in political stability.
日本债券持有人大多为本国国民（甚至中央银行 ） ， 政治稳定符合他们的利益。
----------
Paul Romer, one of the originators of new growth theory, has accused some leading names, including the Nobel laureate Robert Lucas, of what he calls “mathiness” – using math to obfuscate rather than clarify.
新增长理论创始人之一的保罗·罗默（Paul Romer）也批评一些著名经济学家，包括诺贝尔奖获得者罗伯特·卢卡斯（Robert Lucas）在内，说他们“数学性 ” （ 罗默的用语）太重，结果是让问题变得更加模糊而不是更加清晰。
----------
It is, in fact, a capsule depiction of the United States Federal Reserve and the European Central Bank.
事实上，这就是对美联储和欧洲央行的简略描述。
----------
Given these variables, the degree to which migration is affected by asylum-seekers will not be easy to predict or control.
考虑到这些变量，移民受寻求庇护者的影响程度很难预测或控制。
----------
WASHINGTON, DC – In the 2016 American presidential election, Hillary Clinton and Donald Trump agreed that the US economy is suffering from dilapidated infrastructure, and both called for greater investment in renovating and upgrading the country’s public capital stock.
华盛顿—在2016年美国总统选举中，希拉里·克林顿和唐纳德·特朗普都认为美国经济饱受基础设施陈旧的拖累，两人都要求加大投资用于修缮和升级美国公共资本存量。
----------

2.3 建立中文 & 英文字典

和大多数 NLP 案例相同，有了原始的中英文语句后，分别为其建立字典，来将每个词会转换成索引（index）。
tfds.features.text 底下的 SubwordTextEncoder 提供了非常方便的 API 让我们扫过整个训练集并建立字典

2.3.1 建立英文字典

首先为英文语料建立字典（为节省时间，如果之前已经建好字典并保存，直接读取即可）：

注意：参考博文使用的是 tfds.features.text 底下的 SubwordTextEncoder 提供的 API，来扫过整个训练集并建立字典，但 tfds.features.text 已经被移除了，是过时的写法，会报错 修改方法：通过 tfds.deprecated.text 强制使用 参考：module ‘tensorflow_datasets.core.features’ has no attribute ‘text’

%%time
try:
    subword_encoder_en = tfds.deprecated.text.SubwordTextEncoder.load_from_file(en_vocab_file)
    print(f"載入已建立的字典： {en_vocab_file}")
except:
    print("沒有已建立的字典，從頭建立。")
    subword_encoder_en = tfds.deprecated.text.SubwordTextEncoder.build_from_corpus(
        (en.numpy() for en, _ in train_examples), 
        target_vocab_size=2**13)     # 有需要可以调整字典大小
    # 存储字典以方便下次 warmstart
    subword_encoder_en.save_to_file(en_vocab_file)
print(f"字典大小：{subword_encoder_en.vocab_size}")
print(f"前 10 個 subwords：{subword_encoder_en.subwords[:10]}")
print()

输出：

載入已建立的字典： mount/My Drive/Colab Notebooks/DLHLP20/en_vocab
字典大小：8113
前 10 個 subwords：[', ', 'the_', 'of_', 'to_', 'and_', 's_', 'in_', 'a_', 'is_', 'that_']
CPU times: user 40.7 ms, sys: 948 µs, total: 41.6 ms
Wall time: 387 ms

可以用上面建立的字典将一个英文句子转换成对应的索引序列：

sample_string = 'Taiwan is beautiful.'
indices = subword_encoder_en.encode(sample_string)
indices

输出句子 'Taiwan is beautiful.' 对应的索引序列如下：

[3461, 7889, 9, 3502, 4379, 1134, 7903]

再将上面输出的索引分别还原成对应的 tokens：

print("{0:10}{1:6}".format("Index", "Subword"))
print("-" * 15)
for idx in indices:
    subword = subword_encoder_en.decode([idx])
    print('{0:5}{1:6}'.format(idx, ' ' * 5 + subword))

输出如下，可以看到 beautiful 被拆分成了 bea uti ful，即，当 subword tokenizer 遇到字典里没有的词汇，就将该词拆成多个子词（subwords），因此这种断词方法（wordpieces）不用担心有字典里没出现过的词汇

Index     Subword
---------------
 3461     Taiwan
 7889      
    9     is 
 3502     bea
 4379     uti
 1134     ful
 7903     .

编码（词汇→索引）、解码（索引→词汇）是可逆的：

sample_string = 'Taiwan is beautiful.'
indices = subword_encoder_en.encode(sample_string)
decoded_string = subword_encoder_en.decode(indices)
assert decoded_string == sample_string
pprint((sample_string, decoded_string))

输出：

('Taiwan is beautiful.', 'Taiwan is beautiful.')

2.3.2 建立中文字典

然后为中文也建立一个字典，注意下面的代码中令 max_subword_length=1 ，这样每个汉字会被视为一个单位（对应一个索引）。BERT 等模型处理中文时实际上以字作为 token 更为合适。

%%time
try:
    subword_encoder_zh = tfds.deprecated.text.SubwordTextEncoder.load_from_file(zh_vocab_file)
    print(f"載入已建立的字典： {zh_vocab_file}")
except:
    print("沒有已建立的字典，從頭建立。")
    subword_encoder_zh = tfds.deprecated.text.SubwordTextEncoder.build_from_corpus(
        (zh.numpy() for _, zh in train_examples), 
        target_vocab_size=2**13, # 有需要可以調整字典大小
        max_subword_length=1) # 每一個中文字就是字典裡的一個單位
    # 將字典檔案存下以方便下次 warmstart 
    subword_encoder_zh.save_to_file(zh_vocab_file)
print(f"字典大小：{subword_encoder_zh.vocab_size}")
print(f"前 10 個 subwords：{subword_encoder_zh.subwords[:10]}")
print()

输出：

載入已建立的字典： mount/My Drive/Colab Notebooks/DLHLP20/zh_vocab
字典大小：4205
前 10 個 subwords：['的', '，', '。', '国', '在', '是', '一', '和', '不', '这']
CPU times: user 30.4 ms, sys: 5.13 ms, total: 35.5 ms
Wall time: 350 ms

取一个中文句子测试一下：

sample_string = sample_examples[0][1]
indices = subword_encoder_zh.encode(sample_string)
print(sample_string)
print(indices)

输出如下：

这种恐惧是真实而内在的。 忽视它的政治家们前途堪忧。
[10, 151, 574, 1298, 6, 374, 55, 29, 193, 5, 1, 3, 3981, 931, 431, 125, 1, 17, 124, 33, 20, 97, 1089, 1247, 861, 3]

用一个例子（example，指一组同语义的中英文语句）测试一下，分别将其转换成对应的索引序列

en = "The eurozone’s collapse forces a major realignment of European politics."
zh = "欧元区的瓦解强迫欧洲政治进行一次重大改组。"
# 將文字轉成為 subword indices
en_indices = subword_encoder_en.encode(en)
zh_indices = subword_encoder_zh.encode(zh)
print("[英中原文]（轉換前）")
print(en)
print(zh)
print()
print('-' * 20)
print()
print("[英中序列]（轉換後）")
print(en_indices)
print(zh_indices)

输出如下：

[英中原文]（轉換前）
The eurozone’s collapse forces a major realignment of European politics.
欧元区的瓦解强迫欧洲政治进行一次重大改组。
--------------------
[英中序列]（轉換後）
[16, 900, 11, 6, 1527, 874, 8, 230, 2259, 2728, 239, 3, 89, 1236, 7903]
[44, 202, 168, 1, 852, 201, 231, 592, 44, 87, 17, 124, 106, 38, 7, 279, 86, 18, 212, 265, 3]

2.4 前处理数据

2.4.1 BOS & EOS

为序列前后分别加上特殊的 token：BOS、EOS，分别代表序列的开始和结束。

定义一个 encode(en_t, zh_t) 函数，输入是一笔同语义的中英文语句，输出是加上了 BOS、EOS 后的字典序列

def encode(en_t, zh_t):
    """
    :param en_t: 英文语句
    :param zh_t: 同语义的中文语句
    :return en_indices: 英文语句加上 BOS、EOS 后转换成的字典序列
    :return zh_indices: 中文语句加上 BOS、EOS 后转换成的字典序列
    """
    # 因為字典的索引從 0 開始，
    # 我們可以使用 subword_encoder_en.vocab_size 這個值作為 BOS 的索引值
    # 用 subword_encoder_en.vocab_size + 1 作為 EOS 的索引值
    en_indices = [subword_encoder_en.vocab_size] + subword_encoder_en.encode(
        en_t.numpy()) + [subword_encoder_en.vocab_size + 1]
    # 同理，不過是使用中文字典的最後一個索引 + 1
    zh_indices = [subword_encoder_zh.vocab_size] + subword_encoder_zh.encode(
        zh_t.numpy()) + [subword_encoder_zh.vocab_size + 1]
    return en_indices, zh_indices

从训练集中取一笔中英文 Tensors 查看上面这个函数的实际输出

en_t, zh_t = next(iter(train_examples))
en_indices, zh_indices = encode(en_t, zh_t)
print('英文 BOS 的 index：', subword_encoder_en.vocab_size)
print('英文 EOS 的 index：', subword_encoder_en.vocab_size + 1)
print('中文 BOS 的 index：', subword_encoder_zh.vocab_size)
print('中文 EOS 的 index：', subword_encoder_zh.vocab_size + 1)
print('\n輸入為 2 個 Tensors：')
pprint((en_t, zh_t))
print('-' * 15)
print('輸出為 2 個索引序列：')
pprint((en_indices, zh_indices))

输出如下：

英文 BOS 的 index： 8113
英文 EOS 的 index： 8114
中文 BOS 的 index： 4205
中文 EOS 的 index： 4206
輸入為 2 個 Tensors：
(<tf.Tensor: shape=(), dtype=string, numpy=b'The fear is real and visceral, and politicians ignore it at their peril.'>,
 <tf.Tensor: shape=(), dtype=string, numpy=b'\xe8\xbf\x99\xe7\xa7\x8d\xe6\x81\x90\xe6\x83\xa7\xe6\x98\xaf\xe7\x9c\x9f\xe5\xae\x9e\xe8\x80\x8c\xe5\x86\x85\xe5\x9c\xa8\xe7\x9a\x84\xe3\x80\x82 \xe5\xbf\xbd\xe8\xa7\x86\xe5\xae\x83\xe7\x9a\x84\xe6\x94\xbf\xe6\xb2\xbb\xe5\xae\xb6\xe4\xbb\xac\xe5\x89\x8d\xe9\x80\x94\xe5\xa0\xaa\xe5\xbf\xa7\xe3\x80\x82'>)
---------------
輸出為 2 個索引序列：
([8113, 16, 1284, 9, 243, 5, 1275, 1756, 156, 1, 5, 1016, 5566, 21, 38, 33, 2982, 7965, 7903, 8114],
 [4205, 10, 151, 574, 1298, 6, 374, 55, 29, 193, 5, 1, 3, 3981, 931, 431, 125, 1, 17, 124, 33, 20, 97, 1089, 1247, 861, 3, 4206])

但还不能直接使用 train_dataset = train_examples.map(encode) 将 encode 函数直接套用到整个训练集，因为 tf.data.Dataset.map 里的计算是在计算图模式下执行的，因此里面的 Tensors 没有 Eager Execution 下才有的 numpy 属性，需要先用 tf.py_function 将上面定义的 encode 函数包成一个以 eager 模式执行的 TensorFlow 操作，然后再套用到整个训练集中

def tf_encode(en_t, zh_t):
    # 在 `tf_encode` 函式裡頭的 `en_t` 與 `zh_t` 都不是 Eager Tensors
    # 要到 `tf.py_funtion` 裡頭才是
    # 另外因為索引都是整數，所以使用 `tf.int64`
    return tf.py_function(encode, [en_t, zh_t], [tf.int64, tf.int64])
# `tmp_dataset` 為說明用資料集，說明完所有重要的 func，
# 我們會從頭建立一個正式的 `train_dataset`
tmp_dataset = train_examples.map(tf_encode)
en_indices, zh_indices = next(iter(tmp_dataset))
print(en_indices)
print(zh_indices)

输出：

tf.Tensor(
[8113   16 1284    9  243    5 1275 1756  156    1    5 1016 5566   21
   38   33 2982 7965 7903 8114], shape=(20,), dtype=int64)
tf.Tensor(
[4205   10  151  574 1298    6  374   55   29  193    5    1    3 3981
  931  431  125    1   17  124   33   20   97 1089 1247  861    3 4206], shape=(28,), dtype=int64)

2.4.2 过滤长序列

为了加快 Transformer 的训练，在实验中将长度超过 40 个 tokens 的序列都去掉：

MAX_LENGTH = 40
def filter_max_length(en, zh, max_length=MAX_LENGTH):
    # en, zh 分別代表英文與中文的索引序列
    return tf.logical_and(tf.size(en) <= max_length,
                          tf.size(zh) <= max_length)
# tf.data.Dataset.filter(func) 只會回傳 func 為真的例子
tmp_dataset = tmp_dataset.filter(filter_max_length)

检查是否有序列超过设定的长度（40），顺便计算过滤掉长序列后剩余的训练集笔数：

# 因為我們數據量小可以這樣 count
num_examples = 0
for en_indices, zh_indices in tmp_dataset:
    cond1 = len(en_indices) <= MAX_LENGTH
    cond2 = len(zh_indices) <= MAX_LENGTH
    assert cond1 and cond2
    num_examples += 1
print(f"所有英文與中文序列長度都不超過 {MAX_LENGTH} 個 tokens")
print(f"訓練資料集裡總共有 {num_examples} 筆數據")

输出如下，过滤掉长句子后仍有近 3 万笔数据，数据量还是足够的

所有英文與中文序列長度都不超過 40 個 tokens
訓練資料集裡總共有 29784 筆數據

2.4.3 填充至等长

经过上述操作后，每个例子中的索引序列长度还是不同的，这在建立 batch 时可能会有问题，因此使用 padded_batch 函数将每个 batch 中所有序列填充至等长

# 使用 padded_batch 函式將 batch 裡的所有序列都 pad 到同樣長度
BATCH_SIZE = 64
tmp_dataset = tmp_dataset.padded_batch(BATCH_SIZE, padded_shapes=([-1], [-1]))
en_batch, zh_batch = next(iter(tmp_dataset))
print("英文索引序列的 batch")
print(en_batch)
print('-' * 20)
print("中文索引序列的 batch")
print(zh_batch)

输出如下，英文 batch 中最长序列长度为 39，就都填充到 39（未达到 39 的就补 0 填充到 39）；中文 batch 中最长序列长度为 40，就都填充到 40

英文索引序列的 batch
tf.Tensor(
[[8113   16 1284 ...    0    0    0]
 [8113 1894 1302 ...    0    0    0]
 [8113   44   40 ...    0    0    0]
 ...
 [8113  122  506 ...    0    0    0]
 [8113   16  215 ...    0    0    0]
 [8113 7443 7889 ...    0    0    0]], shape=(64, 39), dtype=int64)
--------------------
中文索引序列的 batch
tf.Tensor(
[[4205   10  151 ...    0    0    0]
 [4205  206  275 ...    0    0    0]
 [4205    5   10 ...    0    0    0]
 ...
 [4205   34    6 ...    0    0    0]
 [4205  317  256 ...    0    0    0]
 [4205  167  326 ...    0    0    0]], shape=(64, 40), dtype=int64)

2.4.4 建立训练集 & 验证集

上面介绍了一些建立训练集 & 验证集时要用到的前处理，现在开始从头建立训练集和验证集：

MAX_LENGTH = 40
BATCH_SIZE = 128
BUFFER_SIZE = 15000
# 訓練集
train_dataset = (train_examples  # 輸出：(英文句子, 中文句子)
                 .map(tf_encode) # 輸出：(英文索引序列, 中文索引序列)
                 .filter(filter_max_length) # 同上，且序列長度都不超過 40
                 .cache() # 加快讀取數據
                 .shuffle(BUFFER_SIZE) # 將例子洗牌確保隨機性
                 .padded_batch(BATCH_SIZE, # 將 batch 裡的序列都 pad 到一樣長度
                               padded_shapes=([-1], [-1]))
                 .prefetch(tf.data.experimental.AUTOTUNE)) # 加速
# 驗證集
val_dataset = (val_examples
               .map(tf_encode)
               .filter(filter_max_length)
               .padded_batch(BATCH_SIZE, 
                             padded_shapes=([-1], [-1])))

取一笔数据看看最终建立的数据集的样子：

en_batch, zh_batch = next(iter(train_dataset))
print("英文索引序列的 batch")
print(en_batch)
print('-' * 20)
print("中文索引序列的 batch")
print(zh_batch)

输出如下：

英文索引序列的 batch
tf.Tensor(
[[8113   41  233 ...    0    0    0]
 [8113   16  190 ...    0    0    0]
 [8113 3872   42 ...    0    0    0]
 ...
 [8113  435 7341 ...    0    0    0]
 [8113 3413 2088 ...    0    0    0]
 [8113 1560    1 ...    0    0    0]], shape=(128, 36), dtype=int64)
--------------------
中文索引序列的 batch
tf.Tensor(
[[4205   34   17 ...    0    0    0]
 [4205   16    4 ...    0    0    0]
 [4205  200   77 ...    0    0    0]
 ...
 [4205   10   66 ...    0    0    0]
 [4205  104   25 ...    0    0    0]
 [4205    9  803 ...    0    0    0]], shape=(128, 40), dtype=int64)

至此，我们已建立了一个可供训练的输入管道。
训练集/验证集中：

• 一次回传大小为 128 的 2 个 batch，分别包含 128 个英文索引序列和 128 个中文索引序列
• 序列开头皆为 BOS 对应的索引，英文为 8113，中文为 4205
• 中英文 batch 里的序列都被 padding 到等长，且不超过前面定义的最长序列长度 40

因此，之后每步训练拿出的数据 Tensors 的 shape 应为 (batch_size, seq_len)，且其中的每个索引数字都代表一个中/英文 token（包含 BOS/EOS）

3、Transformer 相关的处理

3.1 输入数据 & 词嵌入

为了直观理解 Transformer，我们建立两对同语义的中英文句子，用来在后面的步骤中将其丢入 Transformer，观察 Transformer 对它们做了些什么转换。

3.1.1 输入数据

建立两对同语义的中英文句子：

demo_examples = [
    ("It is important.", "这很重要。"),
    ("The numbers speak for themselves.", "数字证明了一切。"),
]
pprint(demo_examples)

然后，对这两对中英句子做前处理，并以 Tensor 的方式读出：

batch_size = 2
demo_examples = tf.data.Dataset.from_tensor_slices((
    [en for en, _ in demo_examples], [zh for _, zh in demo_examples]
))
# 將兩個句子透過之前定義的字典轉換成子詞的序列（sequence of subwords）
# 並添加 padding token: <pad> 來確保 batch 裡的句子有一樣長度
demo_dataset = demo_examples.map(tf_encode)\
  .padded_batch(batch_size, padded_shapes=([-1], [-1]))
# 取出這個 demo dataset 裡唯一一個 batch
inp, tar = next(iter(demo_dataset))
print('inp:', inp)  # shape=（2，8）,代表英文句子数目为2，句子长度为8
print('' * 10)
print('tar:', tar)  # shape=（2，10）,代表英文句子数目为2，句子长度为10

输出如下，inp 的 shape = (2, 8)，代表英文 batch 有 2 个句子，句子长度（tokens 数）为 8；tar 的 shape = (2, 10)，代表中文 batch 有 2 个句子，句子长度（tokens 数）为 10

inp: tf.Tensor(
[[8113  103    9 1066 7903 8114    0    0]
 [8113   16 4111 6735   12 2750 7903 8114]], shape=(2, 8), dtype=int64)
tar: tf.Tensor(
[[4205   10  241   86   27    3 4206    0    0    0]
 [4205  165  489  398  191   14    7  560    3 4206]], shape=(2, 10), dtype=int64)

3.1.2 词嵌入

上面得到的输入（句子的索引序列）是二维的，在将索引序列丢入神经网络之前，一般会先做词嵌入（word embedding），将词汇从维度为字典大小的高维离散空间嵌入到低维的连续空间中。

为英文与中文分别建立一个词嵌入层，并对 inp 和 tar 做转换，将输入从二维向量转换为三维向量：

# + 2 是因為我們額外加了 <start> 以及 <end> tokens
vocab_size_en = subword_encoder_en.vocab_size + 2
vocab_size_zh = subword_encoder_zh.vocab_size + 2
# 為了方便 demo, 將詞彙轉換到一個 4 維的詞嵌入空間
d_model = 4
embedding_layer_en = tf.keras.layers.Embedding(vocab_size_en, d_model)
embedding_layer_zh = tf.keras.layers.Embedding(vocab_size_zh, d_model)
emb_inp = embedding_layer_en(inp) # shape=(2, 8, 4)，代表英文句子数即batch_size=2，每个句子8个词，每个词向量维度为4
emb_tar = embedding_layer_zh(tar) # shape=(2, 10, 4)，代表中文句子数即batch_size=2，每个句子10个词，每个词向量维度为4
emb_inp, emb_tar

输出如下，做词嵌入转换后，emb_inp 的 shape = (2, 8, 4)，代表英文 batch 有 2 个句子，句子长度（tokens 数）为 8，每个 token （词嵌入向量）的维度为 4；emb_tar 的 shape = (2, 10, 4)，代表中文 batch 有 2 个句子，句子长度（tokens 数）为 10，每个 token （词嵌入向量）的维度为 4

(<tf.Tensor: shape=(2, 8, 4), dtype=float32, numpy=
 array([[[ 0.0290383 , -0.04547672, -0.02772095, -0.03357754],
         [-0.00695816, -0.04078375,  0.02525837, -0.02481749],
         [-0.04623505,  0.04233763, -0.01499236,  0.0204999 ],
         [ 0.01926272, -0.00047588, -0.04174998, -0.03272629],
         [-0.02661264, -0.01885304, -0.04105211,  0.04283339],
         [-0.03520732, -0.04360742,  0.02240748,  0.043366  ],
         [-0.00359789,  0.03168226, -0.04263718,  0.02017691],
         [-0.00359789,  0.03168226, -0.04263718,  0.02017691]],
        [[ 0.0290383 , -0.04547672, -0.02772095, -0.03357754],
         [ 0.0057646 ,  0.01873441,  0.04519582,  0.01169586],
         [-0.04670626, -0.0461443 , -0.03423715,  0.04910291],
         [-0.0080081 , -0.0066364 , -0.01258793, -0.0427192 ],
         [ 0.03887614, -0.03308231,  0.00964315,  0.04348907],
         [-0.04985246, -0.04806296,  0.03991742, -0.00247025],
         [-0.02661264, -0.01885304, -0.04105211,  0.04283339],
         [-0.03520732, -0.04360742,  0.02240748,  0.043366  ]]],
       dtype=float32)>, <tf.Tensor: shape=(2, 10, 4), dtype=float32, numpy=
 array([[[-9.4237924e-03, -1.8982053e-02, -3.8755499e-02,  1.6131904e-02],
         [ 1.3820972e-02, -3.2755092e-02,  1.0215558e-02,  2.3236815e-02],
         [ 5.3795800e-03,  2.7922321e-02,  4.9203541e-02,  5.4208413e-03],
         [ 3.0345544e-03, -3.4656405e-02, -2.3234559e-02,  3.9151311e-03],
         [ 4.8759926e-02,  4.2193059e-02, -2.9141665e-02,  4.5896284e-03],
         [-4.5878422e-02,  4.3194380e-02, -4.8125375e-02, -2.7835155e-02],
         [-1.0285042e-02,  5.3374879e-03,  4.0048312e-02,  1.6815785e-02],
         [-5.7560802e-03, -4.3076027e-02,  3.9412268e-03, -3.4347549e-03],
         [-5.7560802e-03, -4.3076027e-02,  3.9412268e-03, -3.4347549e-03],
         [-5.7560802e-03, -4.3076027e-02,  3.9412268e-03, -3.4347549e-03]],
        [[-9.4237924e-03, -1.8982053e-02, -3.8755499e-02,  1.6131904e-02],
         [ 4.1677501e-02,  6.7135915e-03,  3.7391197e-02, -3.8386367e-02],
         [-2.9780090e-02, -3.5157301e-02,  2.0691562e-02,  3.0919526e-02],
         [ 2.7362112e-02, -1.5102543e-02,  1.0358501e-02,  4.9035549e-03],
         [ 3.9686177e-02,  4.7571074e-02, -4.3680418e-02, -9.9581480e-04],
         [ 7.1074963e-03, -1.7719496e-02, -7.9342239e-03, -3.0051971e-02],
         [-1.1939298e-02, -3.7533417e-03,  2.2292137e-05,  4.3857586e-02],
         [-2.3507465e-02, -3.2441415e-02,  1.8460218e-02, -4.7260523e-02],
         [-4.5878422e-02,  4.3194380e-02, -4.8125375e-02, -2.7835155e-02],
         [-1.0285042e-02,  5.3374879e-03,  4.0048312e-02,  1.6815785e-02]]],
       dtype=float32)>)

理解了上面的 3 维张量后，就能明白 emb_tar 的第一个中文句子的倒数 3 行为什么长得是一样的，因为它们对应的 token 都是填充的 0

print("tar[0]:", tar[0][-3:])
print("-" * 20)
print("emb_tar[0]:", emb_tar[0][-3:])

输出如下：

tar[0]: tf.Tensor([0 0 0], shape=(3,), dtype=int64)
--------------------
emb_tar[0]: tf.Tensor(
[[-0.00575608 -0.04307603  0.00394123 -0.00343475]
 [-0.00575608 -0.04307603  0.00394123 -0.00343475]
 [-0.00575608 -0.04307603  0.00394123 -0.00343475]], shape=(3, 4), dtype=float32)

3.2 MASK 遮罩

Transformer 使用遮罩机制，使得在进行自注意力机制时不至于看到不该看的
Transformer 中有两种遮罩（mask）：

• padding mask：将序列中填充 0 （padding）的部分遮盖住，使得 Transformer 不会关注到这部分位置，而只关注实际的序列内容
• look ahead mask：确保 Decoder 在进行自注意力机制时，只关注当前 token 之前就已经产生的 tokens，而避免关注到 Decoder 未来才会生成的 tokens

对于两种遮罩，mask 矩阵都是将需要遮蔽的位置的值设为 1。

3.2.1 padding mask

创建 padding mask 矩阵：

# padding mask
def create_padding_mask(seq):
    # padding mask 的工作就是把索引序列中為 0 的位置設為 1
    mask = tf.cast(tf.equal(seq, 0), tf.float32)
    return mask[:, tf.newaxis, tf.newaxis, :] #　broadcasting
inp_mask = create_padding_mask(inp)    # 得到四维张量
inp_mask

输出如下，得到的是四维张量，因为在中间加了两个维度以便之后做 broadcasting。

具体可以看后面多头注意力的部分，在 padding mask 加入两个新维度分别是：

• 一个是用来遮住同个句子但不同头的注意力权重
• 一个是用来 broadcast 到 2 维注意力权重的

<tf.Tensor: shape=(2, 1, 1, 8), dtype=float32, numpy=
array([[[[0., 0., 0., 0., 0., 0., 1., 1.]]],
       [[[0., 0., 0., 0., 0., 0., 0., 0.]]]], dtype=float32)>

先将 inp_mask 遮罩的额外维度去掉，以方便和 inp 比较：

print("inp:", inp)
print("-" * 20)
print("tf.squeeze(inp_mask):", tf.squeeze(inp_mask))

输出如下，可以看到 inp_mask 就是将 inp 中为 0 的对应位置设为 1 凸显出来，这样后续的程序就知道应该把那些地方遮盖住

inp: tf.Tensor(
[[8113  103    9 1066 7903 8114    0    0]
 [8113   16 4111 6735   12 2750 7903 8114]], shape=(2, 8), dtype=int64)
--------------------
tf.squeeze(inp_mask): tf.Tensor(
[[0. 0. 0. 0. 0. 0. 1. 1.]
 [0. 0. 0. 0. 0. 0. 0. 0.]], shape=(2, 8), dtype=float32)

3.2.2 look ahead mask

创建 look ahead mask 矩阵，以遮住 Decoder 未来生成的 tokens 不让之前的 token 关注：

# 建立一個 2 維矩陣，維度為 (size, size)，
# 其遮罩為一個右上角的三角形
def create_look_ahead_mask(size):
    mask = 1 - tf.linalg.band_part(tf.ones((size, size)), -1, 0)
    return mask  # (seq_len, seq_len)
seq_len = emb_tar.shape[1] # 注意這次我們用中文的詞嵌入張量 `emb_tar`
look_ahead_mask = create_look_ahead_mask(seq_len)
print("emb_tar:", emb_tar)
print("-" * 20)
print("look_ahead_mask", look_ahead_mask)

输出如下，look ahead 遮罩就是产生一个 2 维矩阵，其两个维度都和中文的词嵌入张量 emb_tar 的倒数第 2 个维度（序列长度）一样，且矩阵中元素 1 呈右上三角

emb_tar: tf.Tensor(
[[[-9.4237924e-03 -1.8982053e-02 -3.8755499e-02  1.6131904e-02]
  [ 1.3820972e-02 -3.2755092e-02  1.0215558e-02  2.3236815e-02]
  [ 5.3795800e-03  2.7922321e-02  4.9203541e-02  5.4208413e-03]
  [ 3.0345544e-03 -3.4656405e-02 -2.3234559e-02  3.9151311e-03]
  [ 4.8759926e-02  4.2193059e-02 -2.9141665e-02  4.5896284e-03]
  [-4.5878422e-02  4.3194380e-02 -4.8125375e-02 -2.7835155e-02]
  [-1.0285042e-02  5.3374879e-03  4.0048312e-02  1.6815785e-02]
  [-5.7560802e-03 -4.3076027e-02  3.9412268e-03 -3.4347549e-03]
  [-5.7560802e-03 -4.3076027e-02  3.9412268e-03 -3.4347549e-03]
  [-5.7560802e-03 -4.3076027e-02  3.9412268e-03 -3.4347549e-03]]
 [[-9.4237924e-03 -1.8982053e-02 -3.8755499e-02  1.6131904e-02]
  [ 4.1677501e-02  6.7135915e-03  3.7391197e-02 -3.8386367e-02]
  [-2.9780090e-02 -3.5157301e-02  2.0691562e-02  3.0919526e-02]
  [ 2.7362112e-02 -1.5102543e-02  1.0358501e-02  4.9035549e-03]
  [ 3.9686177e-02  4.7571074e-02 -4.3680418e-02 -9.9581480e-04]
  [ 7.1074963e-03 -1.7719496e-02 -7.9342239e-03 -3.0051971e-02]
  [-1.1939298e-02 -3.7533417e-03  2.2292137e-05  4.3857586e-02]
  [-2.3507465e-02 -3.2441415e-02  1.8460218e-02 -4.7260523e-02]
  [-4.5878422e-02  4.3194380e-02 -4.8125375e-02 -2.7835155e-02]
  [-1.0285042e-02  5.3374879e-03  4.0048312e-02  1.6815785e-02]]], shape=(2, 10, 4), dtype=float32)
--------------------
look_ahead_mask tf.Tensor(
[[0. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
 [0. 0. 1. 1. 1. 1. 1. 1. 1. 1.]
 [0. 0. 0. 1. 1. 1. 1. 1. 1. 1.]
 [0. 0. 0. 0. 1. 1. 1. 1. 1. 1.]
 [0. 0. 0. 0. 0. 1. 1. 1. 1. 1.]
 [0. 0. 0. 0. 0. 0. 1. 1. 1. 1.]
 [0. 0. 0. 0. 0. 0. 0. 1. 1. 1.]
 [0. 0. 0. 0. 0. 0. 0. 0. 1. 1.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]], shape=(10, 10), dtype=float32)

3.3 Scaled dot product attention

在之前的文章中讲过，Transformer 中使用的自注意力机制和注意力机制实际上是一回事，因此在编码中也是用同一个注意力函数实现。
此外，Transformer 中，注意力机制计算注意力打分函数时，用的是缩放点积模型（Scaled dot product）。

上图是缩放点积注意力机制的计算图和示意图，公式为 .

• MatMul：先将维度相同的 Q 和 K 做点积
• Scale：然后除以一个缩放因子 。这是为了避免 Q、K 点积的值由于 Q、K 的维度 太大而跟着太大，而太大的点积值丢入 softmax 后可能是其梯度变得很小，导致训练结果不理想
  • 生成的 scaled_attention_logits 的 shape=(batch_size, seq_len_q, seq_len_k) ，每一行代表序列 q 的某个 token 对序列 k 中每个 token 的注意力权重
• Mask 遮罩（可选）：避免将注意力放在没有实际语义（填充 0）的地方
• Softmax：再丢入 softmax 函数中得到相加和为 1 的注意力权重
• MatMul：最后将注意力权重对 V 做加权平均

缩放点积注意力的实现：

def scaled_dot_product_attention(q, k, v, mask):
    """Calculate the attention weights.
      q, k, v must have matching leading dimensions.
      k, v must have matching penultimate dimension, i.e.: seq_len_k = seq_len_v.
      The mask has different shapes depending on its type(padding or look ahead) 
      but it must be broadcastable for addition.
      Args:
        q: query shape == (..., seq_len_q, depth)
        k: key shape == (..., seq_len_k, depth)
        v: value shape == (..., seq_len_v, depth_v)
        mask: Float tensor with shape broadcastable 
              to (..., seq_len_q, seq_len_k). Defaults to None.
      Returns:
        output: 注意力机制的结果，是每个 token 的新的 representation
        attention_weights: 注意力权重矩阵
      """
    # 將 `q`、 `k` 做點積再 scale
    matmul_qk = tf.matmul(q, k, transpose_b=True)  # (..., seq_len_q, seq_len_k)
    dk = tf.cast(tf.shape(k)[-1], tf.float32)  # 取得 seq_k 的序列長度
    scaled_attention_logits = matmul_qk / tf.math.sqrt(dk)  # scale by sqrt(dk)
    # scaled_attention_logits 的 shape=(batch_size, seq_len_q, seq_len_k)
    # 最后一个维度代表序列 q 里的某个 token 与序列 k 中每个 token 的匹配程度，但加和还不为1（后面做 softmax 后和为 1）
    # 將遮罩「加」到被丟入 softmax 前的 logits
    # 將遮罩乘上一個接近負無窮大的 -1e9, 這樣可以讓這些被加上極大負值的位置變得無關緊要，在經過 softmax 以後的值趨近於 0
    if mask is not None:
        scaled_attention_logits += (mask * -1e9)
    # 对最后一个维度做 softmax 是為了得到總和為 1 的比例之後對 `v` 做加權平均
    attention_weights = tf.nn.softmax(scaled_attention_logits, axis=-1)  # (..., seq_len_q, seq_len_k)
    # 以注意權重對 v 做加權平均（weighted average）
    output = tf.matmul(attention_weights, v)  # (..., seq_len_q, depth_v)
    return output, attention_weights

示例 1：这里拿已经被转换成词嵌入空间得英文张量 emb_inp 同时充当 Q 和 K，自己与自己做匹配（self-attention）；随机生成一个二元张量作为 V

# 設定一個 seed 確保我們每次都拿到一樣的隨機結果
tf.random.set_seed(9527)
# 自注意力機制：查詢 `q` 跟鍵值 `k` 都是 `emb_inp`
q = emb_inp
k = emb_inp
# 随机產生一個跟 `emb_inp` 同樣 shape 的 binary vector
v = tf.cast(tf.math.greater(tf.random.uniform(shape=emb_inp.shape), 0.5), tf.float32)
v

输出如下：

<tf.Tensor: shape=(2, 8, 4), dtype=float32, numpy=
array([[[1., 0., 0., 0.],
        [0., 1., 0., 1.],
        [0., 0., 0., 1.],
        [1., 0., 1., 0.],
        [1., 0., 1., 0.],
        [0., 1., 0., 1.],
        [0., 0., 1., 0.],
        [0., 1., 0., 1.]],
       [[1., 0., 1., 1.],
        [1., 0., 1., 0.],
        [1., 0., 0., 0.],
        [1., 0., 1., 0.],
        [0., 1., 0., 1.],
        [1., 1., 1., 1.],
        [0., 0., 0., 0.],
        [0., 0., 1., 0.]]], dtype=float32)>

假设没有遮罩，将上面的 Q，K，V 输入到注意力函数，查看输出结果

mask = None
output, attention_weights = scaled_dot_product_attention(q, k, v, mask)
print("output:", output)  # 注意力机制的结果
print("-" * 20)
print("attention_weights:", attention_weights)  # 句子 q 里每个 token 对句子 k 里每个 token 的注意权重

输出如下

output: tf.Tensor(
[[[0.3754064  0.37491858 0.37504062 0.49967808]
  [0.375093   0.3751777  0.37480363 0.5000596 ]
  [0.37471822 0.37491643 0.37509933 0.5001621 ]
  [0.37528062 0.37477034 0.37516797 0.49968264]
  [0.3749827  0.3749506  0.3751282  0.4999781 ]
  [0.37483385 0.3752799  0.3748202  0.5002752 ]
  [0.3749682  0.37477815 0.37523592 0.4998837 ]
  [0.3749682  0.37477815 0.37523592 0.4998837 ]]
 [[0.62511265 0.24998146 0.62504023 0.37525356]
  [0.62497264 0.2501231  0.6251355  0.37500358]
  [0.62471056 0.24997216 0.6245305  0.37481806]
  [0.6252279  0.24993078 0.6251918  0.3750667 ]
  [0.6247138  0.2501474  0.6247551  0.37513638]
  [0.62503874 0.25015905 0.62513757 0.37502298]
  [0.62474614 0.24991831 0.6245631  0.37481573]
  [0.6247693  0.2501465  0.6248009  0.37493715]]], shape=(2, 8, 4), dtype=float32)
--------------------
attention_weights: tf.Tensor(
[[[0.12528133 0.12509221 0.1247595  0.12515798 0.12496709 0.12491082
   0.12491555 0.12491555]
  [0.12513678 0.12521061 0.12488186 0.12500277 0.12495347 0.12511972
   0.12484738 0.12484738]
  [0.12473849 0.12481638 0.1252457  0.12489983 0.1250799  0.12498043
   0.12511961 0.12511961]
  [0.12514941 0.12494969 0.12491229 0.1251712  0.12496004 0.12478393
   0.12503672 0.12503672]
  [0.12489372 0.12483564 0.12502751 0.12489522 0.12519377 0.12507571
   0.12503922 0.12503922]
  [0.1249046  0.12506895 0.12499527 0.12478628 0.12514298 0.12532
   0.12489095 0.12489095]
  [0.12488046 0.12476789 0.12510554 0.12501018 0.12507756 0.12486209
   0.12514816 0.12514816]
  [0.12488046 0.12476789 0.12510554 0.12501018 0.12507756 0.12486209
   0.12514816 0.12514816]]
 [[0.1252721  0.12482584 0.12497401 0.12508717 0.12502795 0.12495351
   0.12495787 0.12490161]
  [0.12488046 0.1251864  0.1248944  0.1249486  0.12506035 0.12506276
   0.12490975 0.1250573 ]
  [0.12484588 0.12471178 0.12533696 0.12478167 0.1249379  0.12503427
   0.12519464 0.12515691]
  [0.12513591 0.12494262 0.1249584  0.12515086 0.12489066 0.12504013
   0.12495913 0.12492236]
  [0.12498897 0.12496667 0.12502712 0.12480308 0.12521943 0.12492798
   0.12499836 0.12506838]
  [0.12486393 0.12491844 0.12507285 0.12490181 0.12487736 0.12528169
   0.12491225 0.1251717 ]
  [0.12489744 0.12479473 0.12526251 0.12485005 0.12497689 0.12494142
   0.12519751 0.12507945]
  [0.12479065 0.12489156 0.12517406 0.12476277 0.12499625 0.12515025
   0.1250288  0.12520567]]], shape=(2, 8, 8), dtype=float32)

示例 2：再为英文语句产生对应的 padding mask：

def create_padding_mask(seq):
    # padding mask 的工作就是把索引序列中為 0 的位置設為 1
    mask = tf.cast(tf.equal(seq, 0), tf.float32)
    return mask[:, tf.newaxis, tf.newaxis, :] #　broadcasting
print("inp:", inp)
inp_mask = create_padding_mask(inp)
print("-" * 20)
print("inp_mask:", inp_mask)

输出如下：

inp: tf.Tensor(
[[8113  103    9 1066 7903 8114    0    0]
 [8113   16 4111 6735   12 2750 7903 8114]], shape=(2, 8), dtype=int64)
--------------------
inp_mask: tf.Tensor(
[[[[0. 0. 0. 0. 0. 0. 1. 1.]]]
 [[[0. 0. 0. 0. 0. 0. 0. 0.]]]], shape=(2, 1, 1, 8), dtype=float32)

将 inp_mask 降到 3 维，并和示例 1 的 q、k、v 一起丢入注意力函数中，查看注意力权重变化：

mask = tf.squeeze(inp_mask, axis=1) # (batch_size, 1, seq_len_q), 這次把 inp_mask 降到 3 維
_, attention_weights = scaled_dot_product_attention(q, k, v, mask)
print("attention_weights:", attention_weights)

输出如下，可以看到由于第一个英文句子的倒数两个位置为 0（填充），因此每个 token 针对倒数两个 token 的注意力权重的值都为 0

attention_weights: tf.Tensor(
[[[0.16700415 0.16675204 0.16630854 0.16683973 0.16658527 0.16651024
   0.         0.        ]
  [0.16678117 0.16687958 0.16644143 0.16660257 0.16653687 0.16675843
   0.         0.        ]
  [0.16637106 0.16647494 0.16704756 0.16658624 0.16682641 0.16669376
   0.         0.        ]
  [0.16688222 0.1666159  0.16656603 0.16691127 0.1666297  0.16639486
   0.         0.        ]
  [0.16654237 0.16646492 0.16672078 0.16654438 0.16694249 0.16678506
   0.         0.        ]
  [0.16649106 0.16671014 0.16661192 0.16633335 0.16680881 0.16704477
   0.         0.        ]
  [0.16657309 0.16642293 0.16687332 0.16674611 0.16683598 0.16654858
   0.         0.        ]
  [0.16657309 0.16642293 0.16687332 0.16674611 0.16683598 0.16654858
   0.         0.        ]]
 [[0.1252721  0.12482584 0.12497401 0.12508717 0.12502795 0.12495351
   0.12495787 0.12490161]
  [0.12488046 0.1251864  0.1248944  0.1249486  0.12506035 0.12506276
   0.12490975 0.1250573 ]
  [0.12484588 0.12471178 0.12533696 0.12478167 0.1249379  0.12503427
   0.12519464 0.12515691]
  [0.12513591 0.12494262 0.1249584  0.12515086 0.12489066 0.12504013
   0.12495913 0.12492236]
  [0.12498897 0.12496667 0.12502712 0.12480308 0.12521943 0.12492798
   0.12499836 0.12506838]
  [0.12486393 0.12491844 0.12507285 0.12490181 0.12487736 0.12528169
   0.12491225 0.1251717 ]
  [0.12489744 0.12479473 0.12526251 0.12485005 0.12497689 0.12494142
   0.12519751 0.12507945]
  [0.12479065 0.12489156 0.12517406 0.12476277 0.12499625 0.12515025
   0.1250288  0.12520567]]], shape=(2, 8, 8), dtype=float32)

可以把针对最后两个位置的注意力权重拿出来，方便比较：

attention_weights[:, :, -2:]

输出如下：

<tf.Tensor: shape=(2, 8, 2), dtype=float32, numpy=
array([[[0.        , 0.        ],
        [0.        , 0.        ],
        [0.        , 0.        ],
        [0.        , 0.        ],
        [0.        , 0.        ],
        [0.        , 0.        ],
        [0.        , 0.        ],
        [0.        , 0.        ]],
       [[0.12495787, 0.12490161],
        [0.12490975, 0.1250573 ],
        [0.12519464, 0.12515691],
        [0.12495913, 0.12492236],
        [0.12499836, 0.12506838],
        [0.12491225, 0.1251717 ],
        [0.12519751, 0.12507945],
        [0.1250288 , 0.12520567]]], dtype=float32)>

示例 3：用中文张量 emb_tar 同时充当 Q 和 K，来模拟 Decoder 自注意力机制的的处理情况，再随机生成 V，和 look ahead mask 一起输入注意力函数：

• 建立 look ahead mask： ```python

  建立一個 2 維矩陣，維度為 (size, size)，

  其遮罩為一個右上角的三角形

  def create_look_ahead_mask(size): mask = 1 - tf.linalg.band_part(tf.ones((size, size)), -1, 0) return mask # (seq_len, seq_len)

seq_len = emb_tar.shape[1] # 注意這次我們用中文的詞嵌入張量 emb_tar look_ahead_mask = create_look_ahead_mask(seq_len) print(“emb_tar:”, emb_tar) print(“-“ * 20) print(“look_ahead_mask”, look_ahead_mask)

- 将 Q、K、V 和 mask 一起输入到注意力函数：
```python
# 讓我們用目標語言（中文）的 batch
# 來模擬 Decoder 處理的情況
temp_q = temp_k = emb_tar
temp_v = tf.cast(tf.math.greater(
    tf.random.uniform(shape=emb_tar.shape), 0.5), tf.float32)
# 將 look_ahead_mask 放入注意函式
_, attention_weights = scaled_dot_product_attention(
    temp_q, temp_k, temp_v, look_ahead_mask)
print("attention_weights:", attention_weights)