Transformer原理及解析

x# Transformer

视频链接：https://www.youtube.com/watch?v=ugWDIIOHtPA&t=2055s

transformer是一个拥有self-attention的Sequence2Sequence模型,

Sequence

RNN是常用的Sequence模型，在双向的sequence模型中，b₁ ,b₂ 的输入为a¹到a⁴ ,适用于解决序列化的问题常用语音和NLP领域。但是序列化执行难以并行处理。希望采用CNN来替代RNN，实现并行化处理，然而CNN只有高层的filter的感受野比较大，能考虑长的序列。

self-attention

用self-attention来代替RNN，既能考虑长的序列，有能便于并行化。

如何做self-attention?

1. 输入的变量为xⁱ ,首先对xⁱ做编码 得到编码后的向量 aⁱ

class Embeddings(nn.Module):
    def __init__(self, d_model, vocab):
        super(Embeddings, self).__init__()
        self.lut = nn.Embedding(vocab, d_model)

    def forward(self, x):
        return self.lut(x) 

nn.Embedding是一个l固定字典lookup的表格,初始化的输入为单词数vocab和编码向量维度d_model。

3. 对向量aⁱ 分别得到 用于attention的三元组（q,k,v)

4. 拿每个query去对每个key做attention,用点乘计算：${\alpha }_{1,i}=q^1\cdot k^i/\sqrt{d}$ <img
   

   attention之后用softmax归一化:${\hat{\alpha }}_{1,i}=exp({\alpha }_{1,i})/{\sum }_{j}exp({\alpha }_{1,j})$

之后通过加权平均得到最后的输出：$b^1={\sum }_i{\hat{\alpha }}_{1,i}{v}^i$

def attention(query, key, value, mask=None, dropout=None):
	d_k = query.size(-1)
	scores = torch.matmul(query, key.transpose(-2, -1)) \
		/ math.sqrt(d_k)
	if mask is not None:
		scores = scores.masked_fill(mask == 0, -1e9)
	p_attn = F.softmax(scores, dim = -1)
	if dropout is not None:
		p_attn = dropout(p_attn)
	return torch.matmul(p_attn, value), p_attn

在实际实验中query,key,value维度为（batch, head个数，序列长度，特征数量）。通过矩阵乘法后scores的维度是（batch,head个数，序列长度，序列长度）。matmul会把query和key的最后两维进行矩阵乘法，这样效率更高。

为什么易于并行？

可以将每个时刻的输入做concat操作，这样直接通过一个矩阵乘法能够得到所有的值

所有的计算都是矩阵乘法，所以易于并行化。

Multi-head self-attention

每个head关注的东西可能不同

class MultiHeadedAttention(nn.Module):
	def __init__(self, h, d_model, dropout=0.1):
		super(MultiHeadedAttention, self).__init__()
		assert d_model % h == 0
		# We assume d_v always equals d_k
		self.d_k = d_model // h
		self.h = h
		self.linears = clones(nn.Linear(d_model, d_model), 4)
		self.attn = None
		self.dropout = nn.Dropout(p=dropout)
	
	def forward(self, query, key, value, mask=None): 
		if mask is not None:
			# 所有h个head的mask都是相同的 
			mask = mask.unsqueeze(1)
		nbatches = query.size(0)
		
		# 1) 首先使用线性变换，然后把d_model分配给h个Head，每个head为d_k=d_model/h 
		query, key, value = \
			[l(x).view(nbatches, -1, self.h, self.d_k).transpose(1, 2)	
				for l, x in zip(self.linears, (query, key, value))]
		
		# 2) 使用attention函数计算
		x, self.attn = attention(query, key, value, mask=mask, 
			dropout=self.dropout)
		
		# 3) 把8个head的64维向量拼接成一个512的向量。然后再使用一个线性变换(512,521)，shape不变。 
		x = x.transpose(1, 2).contiguous() \
			.view(nbatches, -1, self.h * self.d_k)
		return self.linears[-1](x)

先看构造函数，这里d_model(512)是Multi-Head的输出大小，因为有h(8)个head，因此每个head的d_k=512/8=64。接着我们构造4个(d_model x d_model)的矩阵，后面我们会看到它的用处。最后是构造一个Dropout层。

然后我们来看forward方法。输入的mask是(batch, 1, time)的，因为每个head的mask都是一样的，所以先用unsqueeze(1)变成(batch, 1, 1, time)，mask我们前面已经详细分析过了。

接下来是根据输入query，key和value计算变换后的Multi-Head的query，key和value。这是通过下面的语句来实现的：

query, key, value = \
		[l(x).view(nbatches, -1, self.h, self.d_k).transpose(1, 2)	
			for l, x in zip(self.linears, (query, key, value))]

zip(self.linears, (query, key, value))是把(self.linears[0],self.linears[1],self.linears[2])和(query, key, value)放到一起然后遍历。我们只看一个self.linears[0] (query)。根据构造函数的定义，self.linears[0]是一个(512, 512)的矩阵，而query是(batch, time, 512)，相乘之后得到的新query还是512(d_model)维的向量，然后用view把它变成(batch, time, 8, 64)。然后transponse成(batch, 8,time,64)，这是attention函数要求的shape。分别对应8个Head，每个Head的Query都是64维。

Key和Value的运算完全相同，因此我们也分别得到8个Head的64维的Key和64维的Value。接下来调用attention函数，得到x和self.attn。其中x的shape是(batch, 8, time, 64)，而attn是(batch, 8, time, time)。

x.transpose(1, 2)把x变成(batch, time, 8, 64)，然后把它view成(batch, time, 512)，其实就是把最后8个64维的向量拼接成512的向量。最后使用self.linears[-1]对x进行线性变换，self.linears[-1]是(512, 512)的，因此最终的输出还是(batch, time, 512)。我们最初构造了4个(512, 512)的矩阵，前3个用于对query，key和value进行变换，而最后一个对8个head拼接后的向量再做一次变换。
Positional Encoding