秋招八股总结

transformer

损失函数

交叉熵的原理

公式

xi是true_label，yi是神经网络预测为正确的概率
在这里插入图片描述

对比学习loss

对比学习损失函数

InfoNEC Loss（bge中也用的这个）

在这里插入图片描述

SimCSE的主要思想：同一句话通过不同的drop out作为正例，其余的作为负例（损失函数还是用的InfoNEC Loss）；数据增强用的2次dropout

【【一起读论文】SimCSE: Simple Contrastive Learning of Sentence Embeddings】https://www.bilibili.com/video/BV12g411M7AB?vd_source=22a0d494d7d586e6e37e23570688a816
在这里插入图片描述

为什么除以根号dk

防止梯度消失
随着dk维度的值变大，点积的大小会增大，如果没有及时对点积的大小进行缩放，那么万一点积的数量级很大，softmax的梯度就会趋向于0，也就会出现梯度消失问题。
进行归一化
为什么选择，时因为可以使得 Q 和 K 点积趋向于期望为0，方差为1的标准正态分布，说白了就是归一化。

标准化

标准化作用

缓解梯度消失 / BN缓解内部协变量偏移 / 有一定正则化作用

内部协变量偏移

在训练深层神经网络时，各层的输入分布会随着参数更新而变化，这种现象被称为内部协变量偏移（Internal Covariate Shift）。具体来说，随着训练的进行，每层的激活值（即层的输出）的均值和方差可能会发生变化。由于每层的输入分布在训练过程中不断变化，优化过程中的梯度更新也会受到影响，这会导致训练过程变得不稳定。批归一化的目标是缓解这一问题，使得网络的每一层的输入分布更加稳定，从而加快训练速度。

为什么用 LayerNorm 不使用 BatchNorm？

数据的角度
CV 通常用 BatchNorm，NLP 通常用 LayerNorm。图像数据一个 Channel 内的关联性比较大，不同 Channel 的信息需要保持差异性。文本数据一个 Batch 内的不同样本关联性不大。
Pad的角度解释
不同句子的长度不同，在句子的末尾归一化会受到 pad 的影响，使得统计量不置信。
模型角度解释
Self Attention 中，内积的大小的上界和 q，k 的 L2Norm 有关。LayerNorm 对 L2Norm 限制更加直接。

(3) BN 在训练和推理时的差别

BN 在训练和推理时的差别
训练阶段：在训练过程中，BN 使用当前小批量的数据计算均值和方差。
推理阶段：在推理阶段，BN 使用在训练过程中累积的全局均值和方差进行标准化，以确保模型的稳定性。

BN 与dropout 能否一起用？为什么？

添加链接描述
本论文作者发现理解 Dropout 与 BN 之间冲突的关键是网络状态切换过程中存在神经方差的（neural variance）不一致行为。试想若有图一中的神经响应 X，当网络从训练转为测试时，Dropout 可以通过其随机失活保留率（即 p）来缩放响应，并在学习中改变神经元的方差，而 BN 仍然维持 X 的统计滑动方差。这种方差不匹配可能导致数值不稳定（见下图中的红色曲线）。而随着网络越来越深，最终预测的数值偏差可能会累计，从而降低系统的性能。简单起见，作者们将这一现象命名为「方差偏移」。事实上，如果没有 Dropout，那么实际前馈中的神经元方差将与 BN 所累计的滑动方差非常接近（见下图中的蓝色曲线），这也保证了其较高的测试准确率。
在这里插入图片描述

attention的时间复杂度

n2d : n为序列长度，d为隐层维度

如何减少时间复杂度：Sparse Self Attention

在这里插入图片描述

instruct_gpt

在这里插入图片描述

RM损失函数

在这里插入图片描述

RL目标函数

在这里插入图片描述

什么阶段达到了所谓 in-context learning（gpt-3）

GPT与transformer decoder的区别

少一层无mask自注意力层（交叉自注意力） / LN层前置 / 模型的输出部分添加一个LN层 / 采用可训练的 postion embedding

分词算法

WordPiece

WordPiece核心思想是将单词拆分成多个前缀符号（比如BERT中的##）最小单元，再通过子词合并规则将最小单元进行合并为子词级别。例如对于单词"word"，拆分如下：
w ##o ##r ##d
然后通过合并规则进行合并，从而循环迭代构建出一个词表，以下是核心步骤：

计算初始词表：通过训练语料获得或者最初的英文中26个字母加上各种符号以及常见中文字符，这些作为初始词表。
计算合并分数：对训练语料拆分的多个子词单元通过合拼规则计算合并分数。
合并分数最高的子词对：选择分数最高的子词对，将它们合并成一个新的子词单元，并更新词表。
重复合并步骤：不断重复步骤 2 和步骤 3，直到达到预定的词表大小、合并次数，或者直到不再有有意义的合并（即，进一步合并不会显著提高词表的效益）。
分词：使用最终得到的词汇表对文本进行分词。

Byte-Pair Encoding (BPE)

核心思想是逐步合并出现频率最高的子词对而不是像Wordpiece计算合并分数，从而构建出一个词汇表。
6. 计算初始词表：通过训练语料获得或者最初的英文中26个字母加上各种符号以及常见中文字符，这些作为初始词表。
7. 构建频率统计：统计所有子词单元对（两个连续的子词）在文本中的出现频率。
合并频率最高的子词对：选择出现频率最高的子词对，将它们合并成一个新的子词单元，并更新词汇表。
8. 重复合并步骤：不断重复步骤 2 和步骤 3，直到达到预定的词汇表大小、合并次数，或者直到不再有有意义的合并（即，进一步合并不会显著提高词汇表的效益）。
9. 分词：使用最终得到的词汇表对文本进行分词。

Byte-level BPE(BBPE)

手撕代码

多头自注意力代码

在这里插入图片描述

from math import sqrt
import torch
import torch.nn as nn
 
class MultiHeadSelfAttention(nn.Module):
    def __init__(self, dim_in, dim_k, dim_v, num_heads=8):
        super(MultiHeadSelfAttention, self).__init__()
        assert dim_k % num_heads == 0 and dim_v % num_heads == 0, "dim_k and dim_v must be multiple of num_heads"
        self.dim_in = dim_in
        self.dim_k = dim_k
        self.dim_v = dim_v
        self.num_heads = num_heads
        
        # 定义线性变换矩阵
        self.linear_q = nn.Linear(dim_in, dim_k, bias=False)
        self.linear_k = nn.Linear(dim_in, dim_k, bias=False)
        self.linear_v = nn.Linear(dim_in, dim_v, bias=False)
        
        # 最后通过线性层将输出映射回原来的维度
        self.fc_out = nn.Linear(dim_v, dim_in)
        
        self._norm_fact = 1 / sqrt(dim_k // num_heads)

    def forward(self, x):
        batch, n, dim_in = x.shape
        assert dim_in == self.dim_in
 
        nh = self.num_heads
        dk = self.dim_k // nh  # dim_k of each head
        dv = self.dim_v // nh  # dim_v of each head
 
        # 线性变换并切分头
        q = self.linear_q(x).reshape(batch, n, nh, dk).transpose(1, 2)  # (batch, nh, n, dk)
        k = self.linear_k(x).reshape(batch, n, nh, dk).transpose(1, 2)  # (batch, nh, n, dk)
        v = self.linear_v(x).reshape(batch, n, nh, dv).transpose(1, 2)  # (batch, nh, n, dv)
 
        # 计算注意力
        dist = torch.matmul(q, k.transpose(2, 3)) * self._norm_fact  # batch, nh, n, n
        dist = torch.softmax(dist, dim=-1)  # batch, nh, n, n
 
        # 根据注意力分数加权值矩阵
        att = torch.matmul(dist, v)  # batch, nh, n, dv
        att = att.transpose(1, 2).reshape(batch, n, self.dim_v)  # batch, n, dim_v
        
        # 最后通过线性层融合不同头的输出，并映射回原始维度
        out = self.fc_out(att)  # (batch, n, dim_in)
        
        return out

# test
x = torch.randn(2, 10, 128)
attn = MultiHeadSelfAttention(128, 64, 64, 8)
y = attn(x)
print(y.shape)  # torch.Size([2, 10, 64])