1. **自注意力机制**：Transformer通过自注意力机制能够高效地计算序列内所有元素之间的关系，这使得模型能够捕捉到长距离依赖，无论这些依赖的距离有多远。
2. **并行化处理**：与RNN不同，Transformer可以同时处理整个序列，这极大地提高了训练效率。
3. **无需递归结构**：Transformer完全摒弃了递归结构，这意味着不存在梯度消失或爆炸的问题，同时也使得模型能够更容易地学习长距离的依赖关系
tf 的三个关键 多头 掩码 位置编码
tf 的输入部分 位置编码和词嵌入
为什么要有位置编码 因为tf是并行运行的并不知道谁先谁后 rnn是必定有先后的
**位置编码**：由于Transformer本身不具备处理序列顺序的能力，通过添加位置编码到输入序列，模型能够利用序列中元素的位置信息。
位置编码 实际上就是一个向量 把它跟词向量结合 放在词向量中
##### 计算公式
位置编码可以有多种实现方式，Transformer原始论文中提出的位置编码是通过正弦和余弦函数来计算的，
**这样做的好处是能够让模型学习到相对位置信息**，因为这些函数对位置的偏移是可预测的。对于序列中的每个位置pos，和每个维度 i ，位置编码 ( pos , i ) 是这样计算的
根据三角函数的公式 知道1,2的位置即3 的位置也知道了
自注意的原理
本单词向其他单词发送 询问Q Q=权重矩阵q X 本词的词向量q 其他单词回应 K K=权重矩阵k X 其他词的词向量k 得到阿尔法a=q点乘k 点乘的原理是查看两个向量的相似度
自注意的代码实现
import torch
import torch.nn as nn
from torch.nn import functional as F
import numpy as np
def self_att():
x = torch.randn(3,2)
W_q=torch.eye(2)
W_k=torch.eye(2)
W_v=torch.eye(2)
Q=torch.matmul(x,W_q)
K=torch.matmul(x,W_k)
V=torch.matmul(x,W_v)
d_k=2
score=torch.matmul(Q,K.T)/np.sqrt(torch.tensor(d_k))
score.masked_fill(0,-1e10)
att_weight=F.softmax(score,dim=-1)
res=torch.matmul(att_weight,V)
return res
多头自注意力的概念
就是把 QKV 分别拆成多个q1 q2 k1 k2 v1 v2 然后 每个位置的对应走一遍 流程 最后的结果是散的 拼起来然后乘一个W 组合为一个结果
tf一般分8个头
为什么要分成多个
原来一个词的位置只能一个位置表示 现在分8个有8个位置了 更方便找到合适的位置
掩码的作用 把矩阵中的0变为一个特别小的值 然后经过softmax后成为真的0 不然原本为0 softmax后为一个小的数
class MutiSelfAtt(nn.Module):
def init(self,d_model,num_head, *args, **kwargs):
super().init(*args, **kwargs)
self.num_head=num_head
self.d_model=d_model
self.dim=d_model//num_head
定义三个线性层 wx
self.q_linear=nn.Linear(d_model,d_model)
self.k_linear=nn.Linear(d_model,d_model)
self.v_linear=nn.Linear(d_model,d_model)
self.linear=nn.Linear(d_model,d_model)
def forward(self,x): # x是batch_size,seq_len,emb_dim
Q=self.q_linear(x)
K=self.k_linear(x)
V=self.v_linear(x)
batch_size=x.shape[0]
print("------------",Q.shape)
Q=Q.view(batch_size,-1,self.num_head,self.dim) # 拆为 batch_size,seq_len,head,dim
K=K.view(batch_size,-1,self.num_head,self.dim)
V=V.view(batch_size,-1,self.num_head,self.dim)
变为batch_size,head,seq_len,dim 对应头的每个对应位置相乘
Q=Q.transpose(1,2)
K=K.transpose(1,2)
V=V.transpose(1,2)
res=self.self_att(Q,K,V)
res=res.transpose(1,2).contiguous().view(batch_size,-1,self.d_model)
res=self.linear(res)
return res
def self_att(self,Q,K,V,mask=None):
d_k=self.dim
score=torch.matmul(Q,K.transpose(-1, -2))/np.sqrt(torch.tensor(d_k))
if mask is not None:
score=score.masked_fill(mask==0,-1e10)
att_weight=F.softmax(score,dim=-1)
res=torch.matmul(att_weight,V)
return res
data=torch.randn(3,2,64)
msa=MutiSelfAtt(64,4)
res=msa(data)
print(res.shape)
残差连接（Add）
层归一化（Norm）跟批量归一化不同
前馈神经网络子层 Feed ForwardFeed Forward FFN
全连接层
class FFN(nn.Module):
def init(self,d_model,d_ff=256 ,*args, **kwargs):
super().init(*args, **kwargs)
self.d_model=d_model
self.ffn=nn.Sequential(
nn.Linear(d_model,d_ff),
nn.ReLU(),
nn.Linear(d_ff,d_model)
)
self.norm_res=nn.LayerNorm(self.d_model)
def forward(self,x):
res=x
output=self.ffn(x)
残差和层归一化
output=self.norm_res(output)
output=res+output
return output