transformer

1. Transformer

1.1. 模型基本框架

1.2. 编码器

1. 通过嵌入层
2. 对位置进行编码
3. 经过编码器层
   1. 注意力层：
      1. 注意力机制
      2. 残差+ 规范化层
   2. 前馈网络
      1. 前馈网络
      2. 残差+ 规范化层

class TransformerEncoder(d2l.Encoder):
    def __init__(self, vocab_size, key_size, query_size, value_size,
                 num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens,
                 num_heads, num_layers, dropout, use_bias=False, **kwargs):
        super(TransformerEncoder, self).__init__(**kwargs)
        self.num_hiddens = num_hiddens
        
        self.embedding = nn.Embedding(vocab_size, num_hiddens)
        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)
        self.blks = nn.Sequential()
        for i in range(num_layers):
            self.blks.add_module("block"+str(i),
                EncoderBlock(key_size, query_size, value_size, num_hiddens,
                             norm_shape, ffn_num_input, ffn_num_hiddens,
                             num_heads, dropout, use_bias))
            
    def forward(self, X, valid_lens, *args):
        # 因为位置编码值在-1和1之间，
        # 因此嵌入值乘以嵌入维度的平方根进行缩放，
        # 然后再与位置编码相加。
        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))
        self.attention_weights = [None] * len(self.blks)
        for i, blk in enumerate(self.blks):
            X = blk(X, valid_lens)
            self.attention_weights[
                i] = blk.attention.attention.attention_weights
        return X

1.2.1. EncoderBlock层

1. 注意力层：
   1. 注意力机制
   2. 残差+ 规范化层
2. 前馈网络
   1. 前馈网络
   2. 残差+ 规范化层

class EncoderBlock(nn.Module):
    """Transformer编码器块"""
    def __init__(self, key_size, query_size, value_size, num_hiddens,
                     norm_shape, ffn_num_input, ffn_num_hiddens, num_heads,
                     dropout, use_bias=False, **kwargs):
        super(EncoderBlock, self).__init__(**kwargs)
        self.attention = d2l.MultiHeadAttention(
            key_size, query_size, value_size, num_hiddens, num_heads, dropout,
            use_bias)
        self.addnorm1 = AddNorm(norm_shape, dropout)
        self.ffn = PositionWiseFFN(
            ffn_num_input, ffn_num_hiddens, num_hiddens)
        self.addnorm2 = AddNorm(norm_shape, dropout)
    def forward(self, X, valid_lens):
        Y = self.addnorm1(X, self.attention(X, X, X, valid_lens))
        return self.addnorm2(Y, self.ffn(Y))

1.2.1.1. 多头注意力机制

将键值对分为多个子空间，每个注意力机制学习一个子空间的特征，得到H组的注意力权重，然后将注意力权重通过线性层汇聚

常规思路：

1. 将query, key, values映射到子空间，使用不同的Linear映射
2. 将不同头的注意力结果合并在一起，在feature维度上合并
3. 再通过一个Linear线性层，连接所有head

并行思路

1. 将query,key, values映射到完整空间，然后将完整空间查分成子空间，head与batch组成一个伪batch
2. 再将子空间的数据通过点积注意力
3. 将head从batch中分离出来，与feature合并，效果与非并行情况相同
4. 最后通过线性层

class MultiHeadAttention(nn.Module):
    def __init__(self, key_size, query_size, value_size, num_hiddens, num_head, dropout, bias = false, **kwargs):
           self.num_head = head
        self.attention = d2l.DotProductAttention(dropout)
        self.W_k = nn.Linear(key_size, num_hiddens)
        self.W_q = nn.Linear(query_size, num_hiddens)
        self.W_v = nn.Linear(value_size, num_hiddens)
        self.W_o = nn.Linear(num_hiddens, num_hiddens) # 全连接层
        
    def forward(self, query ,key ,values, valid_lens):
        
           # 转换为(batch_size* head, key/query , num_hidden/head)
        query = transpose(self.W_q(query),  self.head_num)
        keys = transpose_qkv(self.W_k(keys), self.num_heads)
        values = transpose_qkv(self.W_v(values), self.num_heads)
        
        # 将掩码扩展为batch*head
        if valid_len is not None:
            valid_lens = torch.repeat_interleave(
                valid_lens, repeats = self.num_heads , dim =0)
            
        output = self.attention(query, key ,value, valid_len)
        
        output_concat=transpose_output(output, self.num_heads)
        # 输出为（batch_size, query_size, hidden_size)
        return self.W_o(output_concat)

1.2.1.2. 残差+规范化层

class AddNorm(nn.Module):
    """残差连接后进行层规范化"""
    def __init__(self, normalized_shape, dropout, **kwargs):
        super(AddNorm, self).__init__(**kwargs)
        self.dropout = nn.Dropout(dropout)
        self.ln = nn.LayerNorm(normalized_shape)

    def forward(self, X, Y):
        # Y+X 残差网络
        # Ln 层归一化
        return self.ln(self.dropout(Y) + X)

1.2.1.2.1. 残差层

训练是模型训练出F(X) = f(x)- X

对应模型中 支线 为x ，前馈神经网络中预测是f(X), 相加后得到准确预测的F(X)

1.2.1.2.2. 批量归一化层BatchNorm

$$
\mathrm{BN}(\mathbf{x}) = \boldsymbol{\gamma} \odot \frac{\mathbf{x} - \hat{\boldsymbol{\mu}}_\mathcal{B}}{\hat{\boldsymbol{\sigma}}_\mathcal{B}} + \boldsymbol{\beta}.
$$

对特征维度进行归一化,$\gamma、\beta$ 是拉伸和偏移参数

1. 对特征维度进行归一化

   mean = X.mean(dim = 0, keepdim = True)
   

2. 卷积层

   1. 对通道维度进行归一化

3. 训练状态下使用小批次的样本均值与方差，测试状态使用的移动平均估算的均值与方差

1.2.2. 前馈网络层

这里的线性层可以使用1*1cnn网络代替，代替结果

class PositionWiseFFN(nn.Module):
    """基于位置的前馈网络"""
    def __init__(self, ffn_num_input, ffn_num_hiddens, ffn_num_outputs,
                 **kwargs):
        super(PositionWiseFFN, self).__init__(**kwargs)
        self.dense1 = nn.Linear(ffn_num_input, ffn_num_hiddens)
        self.relu = nn.ReLU()
        self.dense2 = nn.Linear(ffn_num_hiddens, ffn_num_outputs)

    def forward(self, X):
        return self.dense2(self.relu(self.dense1(X)))

1.3. 解码器

1. 通过嵌入层
2. 对位置进行编码
3. 经过解码器层
   1. 第一个注意力层 ， query ,key, value,都是解码器输入
   2. 第二个注意力层， query 来自解码器输入 ， key, values来自编码器输入
      1. 交叉注意力机制中，key,value来源使用一致，这里key,values来自编码器输入
   3. 前馈神经网络
4. 全连接层

class TransformerDecoder(d2l.AttentionDecoder):
    def __init__(self, vocab_size, key_size, query_size, value_size,
                 num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens,
                 num_heads, num_layers, dropout, **kwargs):
        super(TransformerDecoder, self).__init__(**kwargs)
        self.num_hiddens = num_hiddens
        self.num_layers = num_layers
        self.embedding = nn.Embedding(vocab_size, num_hiddens)
        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)
        self.blks = nn.Sequential()
        for i in range(num_layers):
            self.blks.add_module("block"+str(i),
                DecoderBlock(key_size, query_size, value_size, num_hiddens,
                             norm_shape, ffn_num_input, ffn_num_hiddens,
                             num_heads, dropout, i))
        self.dense = nn.Linear(num_hiddens, vocab_size)
        
    def init_state(self, enc_outputs, enc_valid_lens, *args):
        return [enc_outputs, enc_valid_lens, [None] * self.num_layers]
        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))
        self._attention_weights = [[None] * len(self.blks) for _ in range (2)]
        for i, blk in enumerate(self.blks):
            X, state = blk(X, state)
            # 解码器自注意力权重
            self._attention_weights[0][
                i] = blk.attention1.attention.attention_weights
            # “编码器－解码器”自注意力权重
            self._attention_weights[1][
                i] = blk.attention2.attention.attention_weights
        return self.dense(X), state
            

1.3.1. 解码器层

经过解码器层

1. 第一个注意力层 ， query ,key, value,都是解码器输入
2. 第二个注意力层， query 来自解码器输入 ， key, values来自编码器输入
3. 前馈神经网络

class DecoderBlock(nn.Module):
    """解码器中第i个块"""
    def __init__(self, key_size, query_size, value_size, num_hiddens,
                 norm_shape, ffn_num_input, ffn_num_hiddens, num_heads,
                 dropout, i, **kwargs):
        super(DecoderBlock, self).__init__(**kwargs)
        self.i = i
        self.attention1 = d2l.MultiHeadAttention(
            key_size, query_size, value_size, num_hiddens, num_heads, dropout)
        self.addnorm1 = AddNorm(norm_shape, dropout)
        self.attention2 = d2l.MultiHeadAttention(
            key_size, query_size, value_size, num_hiddens, num_heads, dropout)
        self.addnorm2 = AddNorm(norm_shape, dropout)
        self.ffn = PositionWiseFFN(ffn_num_input, ffn_num_hiddens,
                                   num_hiddens)
        self.addnorm3 = AddNorm(norm_shape, dropout)
    def forward(self, X, state):
        enc_outputs, enc_valid_lens = state[0], state[1]
        # 训练阶段，输出序列的所有词元都在同一时间处理，
        # 因此state[2][self.i]初始化为None。
        # 预测阶段，输出序列是通过词元一个接着一个解码的，
        # 因此state[2][self.i]包含着直到当前时间步第i个块解码的输出表示
        if state[2][self.i] is None:
            # 使用当前输入的数据进行预测
            key_values = X
        else:
            '''
            state[2] 中存放者上一个时间步，留下的已经每个块之前计算好的key_value
            # 加上y_t之前的数据一起预测
            '''
            key_values = torch.cat((state[2][self.i], X), axis=1)
        state[2][self.i] = key_values
        if self.training:
            batch_size, num_steps, _ = X.shape
            # dec_valid_lens的开头:(batch_size,num_steps),
            # 其中每一行是[1,2,...,num_steps]
            dec_valid_lens = torch.arange(
                1, num_steps + 1, device=X.device).repeat(batch_size, 1)
        else:
            dec_valid_lens = None

        # 自注意力
        X2 = self.attention1(X, key_values, key_values, dec_valid_lens)
        Y = self.addnorm1(X, X2)
        # 编码器－解码器注意力。
        # enc_outputs的开头:(batch_size,num_steps,num_hiddens)
        Y2 = self.attention2(Y, enc_outputs, enc_outputs, enc_valid_lens)
        Z = self.addnorm2(Y, Y2)
        return self.addnorm3(Z, self.ffn(Z)), state
        

在transformer结构中，query与key权重对values值进行查询，values值是编码器的输入，为什么就可以查询到解码器想要的结果呢？比如，编码器编码我是李华，解码器对I 查询 我，ji

1.4. 优化

Adam， 自动调整学习率

warm up 和逆平方根衰减

1.5. BERT

1.5.1. 预训练（无监督/自监督）

自监督

1. 完形填空
2. 预测下一句

1.5.2. 微调（有监督）

需要根据下游任务添加输出层，添加的层需要重新训练

1. 两个句子分类
2. 单个句子的分类
3. 问答任务
   1. 找到答案正确的文本位置
4. 命名实体位置标记
   1. 标记实体位置（begin ,inside ,O（非实体））

1.6. Decoder_only

优点：

1. Decoder-only的注意力矩阵始终是满秩，表达能力更强
2. 不会浪费Encoder的参数，输入可以直接作用与decoder

1.6.1. 预训练

test prediction 预测文本

1.6.2. 微调

test prediction + task classfication 的损失相加

1.7. GPT-2

无需微调，预训练的模型就可以解决下游任务

Zero-shot, One-shot, Few-shot

使用任务提示（prompt）和少量示例直接输入

1.7.1. lay N放在模块前

1. 尺度定律： 模型的大小与Loss线性拟合
2. 涌现能力： 大模型效果迅速提升

1.8. GPT

参数数量增多，需要减少计算量。

1.8.1. sparse attention

减少attention的计算量，只关注临近部分和前面的部分权重

1.8.2. chatgpt

增加人类反馈强化学习（RLHF) ,与人互动

1.9. LLAMA

1.9.1. swiGLU

使用swi激活函数，同时使用门控机制（GLU)，选择性激活函数

优点： swish激活函数更平滑，GLU实现选择性激活

1.9.2. GQA-grouped-query attention

减少k,v的head 数量，query共享重复的k,v，减少参数

1.9.3. layer norm 变体

RMSNorm:均方根归一化

取出平移，只保留缩放

优点：计算简单