Transformer解析与tensorflow代码解读

本文是针对谷歌Transformer模型的解读，根据我自己的理解顺序记录的。

另外，针对Kyubyong实现的tensorflow代码进行解读，代码地址https://github.com/Kyubyong/transformer

这里不会详细描述Transformer的实现机理，如果有不了解Transformer的可以先阅读文章《Attention is all you need》，以及我列出的一些参考博客，都是不错的解读。

Layer Normalization

首先是Layer Normalization部分，和Batch Normalization有点不一样，BN能够让模型收敛的更快，但是BN的缺点也比较明显。

BN的缺点：

　　1，BN特别依赖Batch Size；当Batch size很小的适合，BN的效果就非常不理想了。在很多情况下，Batch size大不了，因为你GPU的显存不够。所以，通常会有其他比较麻烦的手段去解决这个问题，比如MegDet的CGBN等；

　　2，BN对处理序列化数据的网络比如RNN是不太适用的；So，BN的应用领域减少了一半。

　　3，BN只在训练的时候用，inference的时候不会用到，因为inference的输入不是批量输入。这也不一定是BN的缺点，但这是BN的特点。

BN是在batch的方向上计算均值方差，而LN是在每一条数据维度的方向上计算均值方差，换句话说，LN的操作类似于将BN做了一个“转置”，对同一层网络的输出做一个标准化。下图比较清晰：

 def ln(inputs, epsilon = 1e-8, scope="ln"):
     '''Applies layer normalization. See https://arxiv.org/abs/1607.06450.
     inputs: A tensor with 2 or more dimensions, where the first dimension has `batch_size`.
     epsilon: A floating number. A very small number for preventing ZeroDivision Error.
     scope: Optional scope for `variable_scope`.

     Returns:
       A tensor with the same shape and data dtype as `inputs`.
     '''

     '''
         使用层归一layer normalization
         tensorflow 在实现 Batch Normalization（各个网络层输出的归一化）时，主要用到nn.moments和batch_normalization
         其中moments作用是统计矩，mean 是一阶矩，variance 则是二阶中心矩
         tf.nn.moments 计算返回的 mean 和 variance 作为 tf.nn.batch_normalization 参数进一步调用
         :param inputs: 一个有2个或更多维度的张量，第一个维度是batch_size
         :param epsilon: 很小的数值，防止区域划分错误
         :param scope:
         :return: 返回一个与inputs相同shape和数据的dtype
         '''
     with tf.variable_scope(scope, reuse=tf.AUTO_REUSE):
         inputs_shape = inputs.get_shape()
         params_shape = inputs_shape[-1:]

         mean, variance = tf.nn.moments(inputs, [-1], keep_dims=True)
         beta= tf.get_variable("beta", params_shape, initializer=tf.zeros_initializer())
         gamma = tf.get_variable("gamma", params_shape, initializer=tf.ones_initializer())
         normalized = (inputs - mean) / ( (variance + epsilon) ** (.5) )
         outputs = gamma * normalized + beta

     return outputs

Mask

这部分比较重要，我们知道作者一开始在Mask方面的代码是写的有些问题的，后来作者做了一些更改，很多人看到这部分代码有点不知所云，单点调试之后会好一些。

mask表示掩码，它对某些值进行掩盖，使其在参数更新时不产生效果。Transformer 模型里面涉及两种 mask，分别是 padding mask 和 sequence mask。

其中，padding mask 在所有的 scaled dot-product attention 里面都需要用到，而 sequence mask 只有在 decoder 的 self-attention 里面用到。

Padding Mask

对于输入序列一般我们都要进行padding补齐，也就是说设定一个统一长度N，在较短的序列后面填充0到长度为N，如果输入的序列长度大于N，则截取左边长度为N的内容，把多余的直接舍弃。对于那些补零的数据来说，我们的attention机制不应该把注意力放在这些位置上，所以我们需要进行一些处理。具体的做法是，把这些位置的值加上一个非常大的负数(负无穷)，这样经过softmax后，这些位置的权重就会接近0。Transformer的padding mask实际上是一个张量，每个值都是一个Boolean，值为false的地方就是要进行处理的地方。

Sequence Mask

sequence mask是为了使decoder不能看见未来的信息。因为Transformer不是rnn结构的，因此我们要想办法在time_step 为 t 的时刻，把 t 时刻之后的信息隐藏起来。具体做法就是产生一个上三角矩阵，上三角的值全为0，把这个矩阵作用在每一个序列上。

　　对于 decoder 的 self-attention，里面使用到的 scaled dot-product attention，同时需要padding mask 和 sequence mask 作为 attn_mask，具体实现就是两个mask相加作为attn_mask。
　　其他情况，attn_mask 一律等于 padding mask。

这边代码中会用到一些tf的函数，一个比较有用的tf.where()的用法：https://blog.csdn.net/ustbbsy/article/details/79564828

注意这段代码里面type in ("f", "future", "right"): 部分是描述用一个下三角矩阵来做sequence mask的。

 def mask(inputs, queries=None, keys=None, type=None):
     '''
             对Keys或Queries进行遮盖
             :param inputs: (N, T_q, T_k)
             :param queries: (N, T_q, d)
             :param keys: (N, T_k, d)
             :return:
     '''
     """Masks paddings on keys or queries to inputs
     inputs: 3d tensor. (N, T_q, T_k)
     queries: 3d tensor. (N, T_q, d)
     keys: 3d tensor. (N, T_k, d)

     e.g.,
     >> queries = tf.constant([[[1.],
                         [2.],
                         [0.]]], tf.float32) # (1, 3, 1)
     >> keys = tf.constant([[[4.],
                      [0.]]], tf.float32)  # (1, 2, 1)
     >> inputs = tf.constant([[[4., 0.],
                                [8., 0.],
                                [0., 0.]]], tf.float32)
     >> mask(inputs, queries, keys, "key")
     array([[[ 4.0000000e+00, -4.2949673e+09],
         [ 8.0000000e+00, -4.2949673e+09],
         [ 0.0000000e+00, -4.2949673e+09]]], dtype=float32)
     >> inputs = tf.constant([[[1., 0.],
                              [1., 0.],
                               [1., 0.]]], tf.float32)
     >> mask(inputs, queries, keys, "query")
     array([[[1., 0.],
         [1., 0.],
         [0., 0.]]], dtype=float32)
     """

     padding_num = -2 ** 32 + 1
     if type in ("k", "key", "keys"):
         # Generate masks
         masks = tf.sign(tf.reduce_sum(tf.abs(keys), axis=-1))  # (N, T_k)
         masks = tf.expand_dims(masks, 1) # (N, 1, T_k)
         masks = tf.tile(masks, [1, tf.shape(queries)[1], 1])  # (N, T_q, T_k)

         # Apply masks to inputs
         paddings = tf.ones_like(inputs) * padding_num
         outputs = tf.where(tf.equal(masks, 0), paddings, inputs)  # (N, T_q, T_k)
     elif type in ("q", "query", "queries"):
         # Generate masks
         masks = tf.sign(tf.reduce_sum(tf.abs(queries), axis=-1))  # (N, T_q)
         masks = tf.expand_dims(masks, -1)  # (N, T_q, 1)
         masks = tf.tile(masks, [1, 1, tf.shape(keys)[1]])  # (N, T_q, T_k)

         # Apply masks to inputs
         outputs = inputs*masks
     elif type in ("f", "future", "right"):
         diag_vals = tf.ones_like(inputs[0, :, :])  # (T_q, T_k)
         tril = tf.linalg.LinearOperatorLowerTriangular(diag_vals).to_dense()  # (T_q, T_k)
         masks = tf.tile(tf.expand_dims(tril, 0), [tf.shape(inputs)[0], 1, 1])  # (N, T_q, T_k)

         paddings = tf.ones_like(masks) * padding_num
         outputs = tf.where(tf.equal(masks, 0), paddings, inputs)
     else:
         print("Check if you entered type correctly!")

     return outputs

这里对代码稍作解读，代码里 if type in ("k", "key", "keys"):  部分是padding mask，因为Q乘以V，V的序列后面有很长一部分是全零的向量（这就是我们自定义的padding的对应embedding，我们定义为全0），因此全零的部分我们让attention的权重为一个很小的值-4.2949673e+09。

elif type in ("q", "query", "queries"):  部分：类似的，query序列最后面也有可能是一堆padding，不过对queries做padding mask不需要把padding加上一个很小的值，只要将其置零就行，因为outputs是先key mask，再经过softmax，再进行query mask的。

而  elif type in ("f", "future", "right"):  部分则是我们在做decoder的self attention时要用到的sequence mask，也就是说在每一步，第i个token关注到的attention只有可能是在第i个单词之前的单词，因为它按理来说，看不到后面的单词。作者用一个下三角矩阵来完成这个操作，还是比较巧妙，我简单描述一下每个变量：

Context-Attention

也就是论文里提到的Encoder-Decoder Attention，是两个不同序列之间的attention，与来源于自身的 self-attention 相区别。context-attention有很多，这里使用的是scaled dot-product。通过 query 和 key 的相似性程度来确定 value 的权重分布。

实际上这部分代码就是self attention用到的QKV的公式的核心代码，不管是Encoder-Decoder Attention还是Self Attention都是用的这里的scaled dot-product方法。

 def scaled_dot_product_attention(Q, K, V,
                                  causality=False, dropout_rate=0.,
                                  training=True,
                                  scope="scaled_dot_product_attention"):
     '''See 3.2.1.
     Q: Packed queries. 3d tensor. [N, T_q, d_k].
     K: Packed keys. 3d tensor. [N, T_k, d_k].
     V: Packed values. 3d tensor. [N, T_k, d_v].
     causality: If True, applies masking for future blinding
     dropout_rate: A floating point number of [0, 1].
     training: boolean for controlling droput
     scope: Optional scope for `variable_scope`.
     '''
     '''
         查看原论文中3.2.1attention计算公式：Attention(Q,K,V)=softmax(Q K^T /√dk ) V
         :param Q: 查询，三维张量，[N, T_q, d_k].
         :param K: keys值，三维张量，[N, T_k, d_v].
         :param V: values值，三维张量，[N, T_k, d_v].
         :param causality: 布尔值，如果为True，就会对未来的数值进行遮盖
         :param dropout_rate: 0到1之间的一个数值
         :param training: 布尔值，用来控制dropout
         :param scope:
     '''
     with tf.variable_scope(scope, reuse=tf.AUTO_REUSE):
         d_k = Q.get_shape().as_list()[-1]

         # dot product
         outputs = tf.matmul(Q, tf.transpose(K, [0, 2, 1]))  # (N, T_q, T_k)

         # scale
         outputs /= d_k ** 0.5

         # key masking
         outputs = mask(outputs, Q, K, type="key")

         # causality or future blinding masking
         if causality:
             outputs = mask(outputs, type="future")

         # softmax
         outputs = tf.nn.softmax(outputs)
         attention = tf.transpose(outputs, [0, 2, 1])
         tf.summary.image("attention", tf.expand_dims(attention[:1], -1))

         # query masking
         outputs = mask(outputs, Q, K, type="query")

         # dropout
         outputs = tf.layers.dropout(outputs, rate=dropout_rate, training=training)

         # weighted sum (context vectors)
         outputs = tf.matmul(outputs, V)  # (N, T_q, d_v)

     return outputs

 这里有个问题：

outputs = tf.nn.softmax(outputs)
attention = tf.transpose(outputs, [0, 2, 1])

tf.summary.image("attention", tf.expand_dims(attention[:1], -1))

 用来干啥的？？为啥要transpose一下？？本来是(N,TQ,Tk)现在到(N,Tk,TQ)

Multi-head attention

多头self attention就是Transoformer的核心，就是用上面提到的QKV公式算出分布之后，用h份合在一起来表示，论文中的h为8。

这部分代码主要是先产生QKV向量，然后按照h头来进行划分，然后调用上面的scaled dot-product的方法来计算的。

另外这里可以看到代码里将8份self attention分别计算后后concat起来了，然后在self attention层后接了残差连接和layer normalization。

 def multihead_attention(queries, keys, values,
                         num_heads=8,
                         dropout_rate=0,
                         training=True,
                         causality=False,
                         scope="multihead_attention"):
     '''Applies multihead attention. See 3.2.2
     queries: A 3d tensor with shape of [N, T_q, d_model].
     keys: A 3d tensor with shape of [N, T_k, d_model].
     values: A 3d tensor with shape of [N, T_k, d_model].
     num_heads: An int. Number of heads.
     dropout_rate: A floating point number.
     training: Boolean. Controller of mechanism for dropout.
     causality: Boolean. If true, units that reference the future are masked.
     scope: Optional scope for `variable_scope`.

     Returns
       A 3d tensor with shape of (N, T_q, C)
     '''
     '''
         查看原论文中3.2.2中multihead_attention构建，
         这里是将不同的Queries、Keys和values方式线性地投影h次是有益的。
         线性投影分别为dk，dk和dv尺寸。在每个预计版本进行queries、keys、values，
         然后并行执行attention功能，产生dv维输出值。这些被连接并再次投影，产生最终值
         :param queries: 三维张量[N, T_q, d_model]
         :param keys: 三维张量[N, T_k, d_model]
         :param values: 三维张量[N, T_k, d_model]
         :param num_heads: heads数
         :param dropout_rate:
         :param training: 控制dropout机制
         :param causality: 控制是否遮盖
         :param scope:
         :return: 三维张量(N, T_q, C)
     '''
     d_model = queries.get_shape().as_list()[-1]
     with tf.variable_scope(scope, reuse=tf.AUTO_REUSE):
         # Linear projections
         Q = tf.layers.dense(queries, d_model, use_bias=False) # (N, T_q, d_model)
         K = tf.layers.dense(keys, d_model, use_bias=False) # (N, T_k, d_model)
         V = tf.layers.dense(values, d_model, use_bias=False) # (N, T_k, d_model)

         # Split and concat
         Q_ = tf.concat(tf.split(Q, num_heads, axis=2), axis=0) # (h*N, T_q, d_model/h)
         K_ = tf.concat(tf.split(K, num_heads, axis=2), axis=0) # (h*N, T_k, d_model/h)
         V_ = tf.concat(tf.split(V, num_heads, axis=2), axis=0) # (h*N, T_k, d_model/h)

         # Attention
         outputs = scaled_dot_product_attention(Q_, K_, V_, causality, dropout_rate, training)

         # Restore shape
         outputs = tf.concat(tf.split(outputs, num_heads, axis=0), axis=2 ) # (N, T_q, d_model)

         # Residual connection
         outputs += queries

         # Normalize
         outputs = ln(outputs)

     return outputs

这里提一句，所有的attention都是用scaled dot-product的方法来计算的，对于self attention来说，Q=K=V，而对于decoder-encoder attention来说，Q=decoder_input，K=V=memory。

Positional Embedding

就目前而言，Transformer 架构还没有提取序列顺序的信息，这个信息对于序列而言非常重要，如果缺失了这个信息，可能我们的结果就是：所有词语都对了，但是无法组成有意义的语句。因此模型对序列中的词语出现的位置进行编码。论文中使用的方法是在偶数位置使用正弦编码，在奇数位置使用余弦编码。

代码里有一点，

N, T = tf.shape(inputs)[0], tf.shape(inputs)[1]

position_ind = tf.tile(tf.expand_dims(tf.range(T), 0), [N, 1]) # (N, T)

outputs = tf.nn.embedding_lookup(position_enc, position_ind)

这里为什么直接用tf.range()之后，建立好了position_enbedding之后直接lookup呢，因为输入的句子顺序本来就是0，1，2，...，T，本来就是顺序输入的。

 def positional_encoding(inputs,
                         maxlen,
                         masking=True,
                         scope="positional_encoding"):
     '''Sinusoidal Positional_Encoding. See 3.5
     inputs: 3d tensor. (N, T, E)
     maxlen: scalar. Must be >= T
     masking: Boolean. If True, padding positions are set to zeros.
     scope: Optional scope for `variable_scope`.

     returns
     3d tensor that has the same shape as inputs.
     '''
     '''
         参看论文3.5，由于模型没有循环和卷积，为了让模型知道句子的编号，
         就必须加入某些绝对位置信息，来表示token之间的关系。
         positional encoding和embedding有相同的维度，这两个能够相加。
         :param inputs:
         :param maxlen:
         :param masking:
         :param scope:
         :return:
     '''

     E = inputs.get_shape().as_list()[-1] # static
     N, T = tf.shape(inputs)[0], tf.shape(inputs)[1] # dynamic
     with tf.variable_scope(scope, reuse=tf.AUTO_REUSE):
         # position indices
         position_ind = tf.tile(tf.expand_dims(tf.range(T), 0), [N, 1]) # (N, T)

         # First part of the PE function: sin and cos argument
         position_enc = np.array([
             [pos / np.power(10000, (i-i%2)/E) for i in range(E)]
             for pos in range(maxlen)])

         # Second part, apply the cosine to even columns and sin to odds.
         position_enc[:, 0::2] = np.sin(position_enc[:, 0::2])  # dim 2i
         position_enc[:, 1::2] = np.cos(position_enc[:, 1::2])  # dim 2i+1
         position_enc = tf.convert_to_tensor(position_enc, tf.float32) # (maxlen, E)

         # lookup
         outputs = tf.nn.embedding_lookup(position_enc, position_ind)

         # masks
         if masking:
             outputs = tf.where(tf.equal(inputs, 0), inputs, outputs)

         return tf.to_float(outputs)

其他一些小模块

还有一些小模块比较简单，比如前向网络，前向网络是两层全连接层接一个残差连接和layer normalization。　　

还用了一个Label Smoothing技术，简单来说就是本来ground truth标签是1的，他改到比如说0.9333，本来是0的，他改到0.0333，这是一个比较经典的平滑技术了。

另外值得注意的是这里用了一个Noam计划衰减学习率，我之前没怎么接触过这种，网上资料也不多，我自己写了个公式：

 def ff(inputs, num_units, scope="positionwise_feedforward"):
     '''position-wise feed forward net. See 3.3

     inputs: A 3d tensor with shape of [N, T, C].
     num_units: A list of two integers.
     scope: Optional scope for `variable_scope`.

     Returns:
       A 3d tensor with the same shape and dtype as inputs
     '''
     with tf.variable_scope(scope, reuse=tf.AUTO_REUSE):
         # Inner layer
         outputs = tf.layers.dense(inputs, num_units[0], activation=tf.nn.relu)

         # Outer layer
         outputs = tf.layers.dense(outputs, num_units[1])

         # Residual connection
         outputs += inputs

         # Normalize
         outputs = ln(outputs)

     return outputs

 def label_smoothing(inputs, epsilon=0.1):
     '''Applies label smoothing. See 5.4 and https://arxiv.org/abs/1512.00567.
     inputs: 3d tensor. [N, T, V], where V is the number of vocabulary.
     epsilon: Smoothing rate.

     For example,

     ```
     import tensorflow as tf
     inputs = tf.convert_to_tensor([[[0, 0, 1],
        [0, 1, 0],
        [1, 0, 0]],

       [[1, 0, 0],
        [1, 0, 0],
        [0, 1, 0]]], tf.float32)

     outputs = label_smoothing(inputs)

     with tf.Session() as sess:
         print(sess.run([outputs]))

     >>
     [array([[[ 0.03333334,  0.03333334,  0.93333334],
         [ 0.03333334,  0.93333334,  0.03333334],
         [ 0.93333334,  0.03333334,  0.03333334]],

        [[ 0.93333334,  0.03333334,  0.03333334],
         [ 0.93333334,  0.03333334,  0.03333334],
         [ 0.03333334,  0.93333334,  0.03333334]]], dtype=float32)]
     ```
     '''
     V = inputs.get_shape().as_list()[-1] # number of channels
     return ((1-epsilon) * inputs) + (epsilon / V)

 def noam_scheme(init_lr, global_step, warmup_steps=4000.):
     '''Noam scheme learning rate decay
     init_lr: initial learning rate. scalar.
     global_step: scalar.
     warmup_steps: scalar. During warmup_steps, learning rate increases
         until it reaches init_lr.
     '''
     step = tf.cast(global_step + 1, dtype=tf.float32)
     return init_lr * warmup_steps ** 0.5 * tf.minimum(step * warmup_steps ** -1.5, step ** -0.5)

---

作者写的模块内容到这里告一段落，下面分析一些utils代码，data_loader代码以及将这些模块整合的model代码。

uitls代码

1、计算num_batch，就是total_num除以batch_size取整，再加1

2、将int32转为字符串张量（string tensor）

这里需要描述的一点就是用了一个tf.py_func方法，具体作用是它是脱离Graph的，可以用feed_data的方式动态给它喂数据。

 def convert_idx_to_token_tensor(inputs, idx2token):
     '''Converts int32 tensor to string tensor.
     inputs: 1d int32 tensor. indices.
     idx2token: dictionary

     Returns
     1d string tensor.
     '''
     def my_func(inputs):
         return " ".join(idx2token[elem] for elem in inputs)

     return tf.py_func(my_func, [inputs], tf.string)

3、postprocess方法用来做翻译后的处理，输入一个是翻译的预测列表，还有一个是id2token的表，就是用查表的方式把数字序列转化成字符序列，从而形成一句可以理解的话。这里注意因为实现文章用的BPE算法来做双字节编码，压缩词表，所以在方法里有专门针对BPE解码的替代，如果做中文数据这个就要改一下了，中文不适用BPE等word piece算法。

4、保存超参数。

5、加载超参数并覆写parser对象。

6、save_variable_specs方法用来保存一些变量的信息，包括变量名，shape，总参数量等等。

7、get_hypotheses方法用来得到预测序列。这个方法就是结合前面的postprocess方法，来生成num_samples个数的有意义的自然语言输出。

8、calc_bleu计算BLEU值。

数据加载方面的代码

1、加载词汇表。param vocab_fpath: 字符串，词文件的地址 0: <pad>, 1: <unk>, 2: <s>, 3: </s>  :return: 两个字典，一个是id->token，一个是token->id

2、加载数据load_data。加载源语和目标语数据，筛除过长的数据，注意是筛除，也就是长度超过maxlen的数据直接丢掉了，没加载进去。

 :param fpath1: 源语地址 :param fpath2: 目标语地址 :param maxlen1: 源语句子中最长的长度 :param maxlen2: 目标语句子中最长的长度

3、encode函数用于将字符串转化为数字，这里具体方法是输入的是一个字符序列，然后根据空格切分，然后如果是源语言，则每一句话后面加上“</s>”，如果是目标语言，则在每一句话前面加上“<S>”，后面加上“</s>”，然后再转化成数字序列。如果是中文，这里很显然要改，具体看是字符级别输入还是词语级别输入。

 def encode(inp, type, dict):
     '''Converts string to number. Used for `generator_fn`.
     inp: 1d byte array.
     type: "x" (source side) or "y" (target side)
     dict: token2idx dictionary

     Returns
     list of numbers
     '''
     inp_str = inp.decode("utf-8")
     if type=="x": tokens = inp_str.split() + ["</s>"]
     else: tokens = ["<s>"] + inp_str.split() + ["</s>"]

     x = [dict.get(t, dict["<unk>"]) for t in tokens]
     return x

4、generator_fn方法生成训练和评估集数据。这段代码简单讲一下，对于每一个sent1，sent2（源句子，目标句子），sent1经过前面的encode函数转化成x，sent2经过前面的encode函数转化成y之后，decoder的输入decoder_input是y[:-1]，预期输出y是y[1:]，啥意思呢，就是其实是RNN一样的，用来解码输入的前N-1个，期望的输出是从第2个到第N个，也是N-1个。

 def generator_fn(sents1, sents2, vocab_fpath):
     '''Generates training / evaluation data
     sents1: list of source sents
     sents2: list of target sents
     vocab_fpath: string. vocabulary file path.

     yields
     xs: tuple of
         x: list of source token ids in a sent
         x_seqlen: int. sequence length of x
         sent1: str. raw source (=input) sentence
     labels: tuple of
         decoder_input: decoder_input: list of encoded decoder inputs
         y: list of target token ids in a sent
         y_seqlen: int. sequence length of y
         sent2: str. target sentence
     '''
     token2idx, _ = load_vocab(vocab_fpath)
     for sent1, sent2 in zip(sents1, sents2):
         x = encode(sent1, "x", token2idx)
         y = encode(sent2, "y", token2idx)
         decoder_input, y = y[:-1], y[1:]

         x_seqlen, y_seqlen = len(x), len(y)
         yield (x, x_seqlen, sent1), (decoder_input, y, y_seqlen, sent2)

5、input_fn方法用来生成Batch数据。这段代码其实也比较值得学习，用tf.data.Dataset.from_generator的方式读入数据，不受计算图的影响，比较好。Dataset作为新的API，比以前的feed_dict效率要高一些。关于dataset的简单使用，和一些它代码里用到的API的简单解释，这里有几篇相关博客：

https://blog.csdn.net/googler_offer/article/details/89929657

https://blog.csdn.net/qq_16234613/article/details/81703228

https://blog.csdn.net/Eartha1995/article/details/84930492

这里要非常注意一点！！！！就是这个方法里产生batch，是先repeat()之后，再产生batch数据的，这样会造成最后一个batch如果长度小于batch_size，那么最后几条数据是之前batch里会出现过的，这样做可能会影响到loss的评估！但是作者是怎么做的呢，看他的loss计算公式：

loss = tf.reduce_sum(ce * nonpadding) / (tf.reduce_sum(nonpadding) + 1e-7)

他的loss是把所有非padding的部分的交叉熵保留了下来，加起来，除以非padding序列的长度，但是并没有除以batch_size，也就是算的是一个batch里面的总loss，也就对应了他先repeat()再产生batch数据，也就是每个batch中数据的条目数是相等的，这样就会造成:

训练集和验证集的loss是有问题的！！（稍微有一点点问题），但是测试集并不是用loss来衡量的，而是用bleu值。可以想象，如果按照这样的方法产生batch数据，测试集合比如说有900条数据，batch size=128，那么测试集会生成1024条数据，但是代码中他取了前900条数据，先写入生成结果，然后计算bleu值，这样是没有问题的。

但是！如果想要把repeat()放到产生batch之前，那么在loss部分最好要除以batch_size，因为这样最后一个batch的loss是天然更小的，会有问题。

 def input_fn(sents1, sents2, vocab_fpath, batch_size, shuffle=False):
     '''Batchify data
     sents1: list of source sents
     sents2: list of target sents
     vocab_fpath: string. vocabulary file path.
     batch_size: scalar
     shuffle: boolean

     Returns
     xs: tuple of
         x: int32 tensor. (N, T1)
         x_seqlens: int32 tensor. (N,)
         sents1: str tensor. (N,)
     ys: tuple of
         decoder_input: int32 tensor. (N, T2)
         y: int32 tensor. (N, T2)
         y_seqlen: int32 tensor. (N, )
         sents2: str tensor. (N,)
     '''
     shapes = (([None], (), ()),
               ([None], [None], (), ()))
     types = ((tf.int32, tf.int32, tf.string),
              (tf.int32, tf.int32, tf.int32, tf.string))
     paddings = ((0, 0, ''),
                 (0, 0, 0, ''))

     dataset = tf.data.Dataset.from_generator(
         generator_fn,
         output_shapes=shapes,
         output_types=types,
         args=(sents1, sents2, vocab_fpath))  # <- arguments for generator_fn. converted to np string arrays

     if shuffle: # for training
         dataset = dataset.shuffle(128*batch_size)

     dataset = dataset.repeat()  # iterate forever
     dataset = dataset.padded_batch(batch_size, shapes, paddings).prefetch(1)

     return dataset

6、get_batch方法获取batch数据。

---

整合模型

model.py是模型代码，代码比较短，因为要用到的模块已经在modules.py里面都定义好了。

注意tf.nn.dropout和tf.layers.dropout的区别：https://blog.csdn.net/Bruce_Wang02/article/details/81036796

另外还有一点就是他把所有的输入向量按照一个比例进行了缩放，具体看

dec *= self.hp.d_model ** 0.5

可以看到是将向量的所有维度都扩了根号d_model倍，我目前不知道这样做的意义，先占个位置。

还有一点，logits = tf.einsum('ntd,dk->ntk', dec, weights)，对于tf.einsum的用法，这里有个简单的描述：https://blog.csdn.net/qq_35203425/article/details/81560118

这里有个详细的：https://www.jqr.com/article/000481

损失函数：loss = tf.reduce_sum(ce * nonpadding) / (tf.reduce_sum(nonpadding) + 1e-7)

 class Transformer:
     '''
     xs: tuple of
         x: int32 tensor. (N, T1)
         x_seqlens: int32 tensor. (N,)
         sents1: str tensor. (N,)
     ys: tuple of
         decoder_input: int32 tensor. (N, T2)
         y: int32 tensor. (N, T2)
         y_seqlen: int32 tensor. (N, )
         sents2: str tensor. (N,)
     training: boolean.
     '''
     def __init__(self, hp):
         self.hp = hp
         self.token2idx, self.idx2token = load_vocab(hp.vocab)
         self.embeddings = get_token_embeddings(self.hp.vocab_size, self.hp.d_model, zero_pad=True)

     def encode(self, xs, training=True):
         '''
         Returns
         memory: encoder outputs. (N, T1, d_model)
         '''
         with tf.variable_scope("encoder", reuse=tf.AUTO_REUSE):
             x, seqlens, sents1 = xs

             # embedding
             enc = tf.nn.embedding_lookup(self.embeddings, x) # (N, T1, d_model)
             enc *= self.hp.d_model**0.5 # scale

             enc += positional_encoding(enc, self.hp.maxlen1)
             enc = tf.layers.dropout(enc, self.hp.dropout_rate, training=training)

             ## Blocks
             for i in range(self.hp.num_blocks):
                 with tf.variable_scope("num_blocks_{}".format(i), reuse=tf.AUTO_REUSE):
                     # self-attention
                     enc = multihead_attention(queries=enc,
                                               keys=enc,
                                               values=enc,
                                               num_heads=self.hp.num_heads,
                                               dropout_rate=self.hp.dropout_rate,
                                               training=training,
                                               causality=False)
                     # feed forward
                     enc = ff(enc, num_units=[self.hp.d_ff, self.hp.d_model])
         memory = enc
         return memory, sents1

     def decode(self, ys, memory, training=True):
         '''
         memory: encoder outputs. (N, T1, d_model)

         Returns
         logits: (N, T2, V). float32.
         y_hat: (N, T2). int32
         y: (N, T2). int32
         sents2: (N,). string.
         '''
         with tf.variable_scope("decoder", reuse=tf.AUTO_REUSE):
             decoder_inputs, y, seqlens, sents2 = ys

             # embedding
             dec = tf.nn.embedding_lookup(self.embeddings, decoder_inputs)  # (N, T2, d_model)
             dec *= self.hp.d_model ** 0.5  # scale

             dec += positional_encoding(dec, self.hp.maxlen2)
             dec = tf.layers.dropout(dec, self.hp.dropout_rate, training=training)

             # Blocks
             for i in range(self.hp.num_blocks):
                 with tf.variable_scope("num_blocks_{}".format(i), reuse=tf.AUTO_REUSE):
                     # Masked self-attention (Note that causality is True at this time)
                     dec = multihead_attention(queries=dec,
                                               keys=dec,
                                               values=dec,
                                               num_heads=self.hp.num_heads,
                                               dropout_rate=self.hp.dropout_rate,
                                               training=training,
                                               causality=True,
                                               scope="self_attention")

                     # Vanilla attention
                     dec = multihead_attention(queries=dec,
                                               keys=memory,
                                               values=memory,
                                               num_heads=self.hp.num_heads,
                                               dropout_rate=self.hp.dropout_rate,
                                               training=training,
                                               causality=False,
                                               scope="vanilla_attention")
                     ### Feed Forward
                     dec = ff(dec, num_units=[self.hp.d_ff, self.hp.d_model])

         # Final linear projection (embedding weights are shared)
         weights = tf.transpose(self.embeddings) # (d_model, vocab_size)
         logits = tf.einsum('ntd,dk->ntk', dec, weights) # (N, T2, vocab_size)
         y_hat = tf.to_int32(tf.argmax(logits, axis=-1))

         return logits, y_hat, y, sents2

     def train(self, xs, ys):
         '''
         Returns
         loss: scalar.
         train_op: training operation
         global_step: scalar.
         summaries: training summary node
         '''
         # forward
         memory, sents1 = self.encode(xs)
         logits, preds, y, sents2 = self.decode(ys, memory)

         # train scheme
         y_ = label_smoothing(tf.one_hot(y, depth=self.hp.vocab_size))
         ce = tf.nn.softmax_cross_entropy_with_logits_v2(logits=logits, labels=y_)
         nonpadding = tf.to_float(tf.not_equal(y, self.token2idx["<pad>"]))  # 0: <pad>
         # 测试一下********************************************
         print(tf.reduce_sum(nonpadding))
         # ********************************************************
         loss = tf.reduce_sum(ce * nonpadding) / (tf.reduce_sum(nonpadding) + 1e-7)

         global_step = tf.train.get_or_create_global_step()
         lr = noam_scheme(self.hp.lr, global_step, self.hp.warmup_steps)
         optimizer = tf.train.AdamOptimizer(lr)
         train_op = optimizer.minimize(loss, global_step=global_step)

         tf.summary.scalar('lr', lr)
         tf.summary.scalar("loss", loss)
         tf.summary.scalar("global_step", global_step)

         summaries = tf.summary.merge_all()

         return loss, train_op, global_step, summaries

     def eval(self, xs, ys):
         '''Predicts autoregressively
         At inference, input ys is ignored.
         Returns
         y_hat: (N, T2)
         '''
         decoder_inputs, y, y_seqlen, sents2 = ys

         decoder_inputs = tf.ones((tf.shape(xs[0])[0], 1), tf.int32) * self.token2idx["<s>"]
         ys = (decoder_inputs, y, y_seqlen, sents2)

         memory, sents1 = self.encode(xs, False)

         logging.info("Inference graph is being built. Please be patient.")
         for _ in tqdm(range(self.hp.maxlen2)):
             logits, y_hat, y, sents2 = self.decode(ys, memory, False)
             if tf.reduce_sum(y_hat, 1) == self.token2idx["<pad>"]: break

             _decoder_inputs = tf.concat((decoder_inputs, y_hat), 1)
             ys = (_decoder_inputs, y, y_seqlen, sents2)

         # monitor a random sample
         n = tf.random_uniform((), 0, tf.shape(y_hat)[0]-1, tf.int32)
         sent1 = sents1[n]
         pred = convert_idx_to_token_tensor(y_hat[n], self.idx2token)
         sent2 = sents2[n]

         tf.summary.text("sent1", sent1)
         tf.summary.text("pred", pred)
         tf.summary.text("sent2", sent2)
         summaries = tf.summary.merge_all()

         return y_hat, summaries

还有一些值得说明的地方：我们会发现作者在train()方法里的代码，解码器的输入只用了一次输入，然后利用下三角的方法完成每一次的sequence mask，但是在eval()方法里却按照序列长度分次输入，如果序列长度是100，则跑了100次decoder，一开始decoder_inputs的输入只有开始符<S>，后来每一次多一个token。这样做是为了方便在做inference的时候也能调用这个eval()方法。

一些疑问（暂时未解决）：

1、为什么生成Q、K、V的dense层选择不用偏置use_bias=False

参考博客

https://blog.csdn.net/u012526436/article/details/86295971

https://www.jianshu.com/p/6670f775625f

https://blog.csdn.net/ustbbsy/article/details/79564828

https://blog.csdn.net/googler_offer/article/details/89929657

https://blog.csdn.net/qq_16234613/article/details/81703228

https://blog.csdn.net/Eartha1995/article/details/84930492

https://blog.csdn.net/Bruce_Wang02/article/details/81036796

https://blog.csdn.net/qq_35203425/article/details/81560118

https://www.jqr.com/article/000481