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
Transformer解析与tensorflow代码解读的更多相关文章
- Jsoup代码解读之六-防御XSS攻击
Jsoup代码解读之八-防御XSS攻击 防御XSS攻击的一般原理 cleaner是Jsoup的重要功能之一,我们常用它来进行富文本输入中的XSS防御. 我们知道,XSS攻击的一般方式是,通过在页面输入 ...
- Jsoup代码解读之四-parser
Jsoup代码解读之四-parser 作为Java世界最好的HTML 解析库,Jsoup的parser实现非常具有代表性.这部分也是Jsoup最复杂的部分,需要一些数据结构.状态机乃至编译器的知识.好 ...
- Jsoup代码解读之一-概述
Jsoup代码解读之一-概述 今天看到一个用python写的抽取正文的东东,美滋滋的用Java实现了一番,放到了webmagic里,然后发现Jsoup里已经有了…觉得自己各种不靠谱啊!算了,静下心来学 ...
- Jsoup代码解读之二-DOM相关对象
Jsoup代码解读之二-DOM相关对象 之前在文章中说到,Jsoup使用了一套自己的DOM对象体系,和Java XML API互不兼容.这样做的好处是从XML的API里解脱出来,使得代码精炼了很多 ...
- tensorflow 代码阅读
具体实现: https://github.com/tensorflow/tensorflow/tree/master/tensorflow/core/framework 『深度长文』Tensorflo ...
- Android MVP模式 谷歌官方代码解读
Google官方MVP Sample代码解读 关于Android程序的构架, 当前(2016.10)最流行的模式即为MVP模式, Google官方提供了Sample代码来展示这种模式的用法. Repo ...
- 优秀开源代码解读之JS与iOS Native Code互调的优雅实现方案
简介 本篇为大家介绍一个优秀的开源小项目:WebViewJavascriptBridge. 它优雅地实现了在使用UIWebView时JS与ios 的ObjC nativecode之间的互调,支持消息发 ...
- SoftmaxLayer and SoftmaxwithLossLayer 代码解读
SoftmaxLayer and SoftmaxwithLossLayer 代码解读 Wang Xiao 先来看看 SoftmaxWithLoss 在prototext文件中的定义: layer { ...
- Hybrid----优秀开源代码解读之JS与iOS Native Code互调的优雅实现方案-备
本篇为大家介绍一个优秀的开源小项目:WebViewJavascriptBridge. 它优雅地实现了在使用UIWebView时JS与ios 的ObjC nativecode之间的互调,支持消息发送.接 ...
随机推荐
- web项目小总结
初步小结 1.之前的CSS有些遗忘,返回去重新看知识点,频繁会浪费项目时间. 比如说: position定位 1 position: absolute;//绝对定位 2 position:relat ...
- 【线性基 集合hash】uoj#138. 【UER #3】开学前的涂鸦
还需要加强分析题目特殊性质,设计对应特殊算法,少想多写大力dfs剪枝不要管MLETLE直接上的能力 红包是一个有艺术细胞的男孩子. 红包由于NOI惨挂心情不好,暑假作业又多,于是他开始在作业本上涂鸦. ...
- mysql优化之explain各参数详解：
explain简介 explain命令可以获取Mysql如何执行select语句的信息,包括在select语句执行过程中表如何连接和连接的顺序.当我们想知道这个表操作是索引查询还是全表扫描时,我们就可 ...
- ORA-04031: Unable To Allocate 32 Bytes Of Shared Memory
记录一次生产库遇到的4031错误,后来通过调整sga大小将问题解决了 报错信息: ORA-04031: 无法分配 32 字节的共享内存 ("shared pool","s ...
- 第四篇：python操作数据库时的传参问题
python在操作数据库执行sql的时候我们经常会遇到传参问题,以下是我总结的几种方法: 1.格式化字符串 city = 'beijing'cur.execute(“SELECT * FROM %s ...
- python变量声明及简单数据类型
一.python声明变量 变量的命名和使用 # 在Python中使用变量时,需要遵守一些规则和指南. # 违反这些规则将引发错误,而指南旨在让你编写的代码更容易阅读和理解.请务必牢记下述有关变量的规则 ...
- Laravel 命令行常用命令
一.简介 1.Artisan 是 Laravel 自带的命令行接口名称,它为我们在开发过程中提供了很多有用的命令.想要查看所有可用的Artisan命令,可使用list命令: php artisan l ...
- 科学计算库Numpy——文件读写
读文件 要读取的文件 有分隔符的文件 备注:delimiter分隔符. 有多余行的文件 备注:skiprows去掉几行. 指定列 备注:usecols指定使用哪几列. 写文件 保存后的文件 备注:fm ...
- 爬山算法 | Java版HA_TSP
嗯哼,今天记录下采用Java编写的爬山算法(Hill Algorithm)求解TSP问题. 爬山算法与其他智能算法类似,是一种用来求解多峰函数最值的算法,爬山算法的基本思想是新解不劣于当前解则转移,否 ...
- hibernate实体xml一对多关系映射
单向一对多关系映射: 一个房间对应多个使用者,也就是Room實例知道User實例的存在,而User實例則沒有意識到Room實例. 用户表: package onlyfun.caterpillar; p ...