《深入浅出LLM基础篇》（三）：大模型结构分类-CSDN博客

本文链接：https://blog.csdn.net/AIDAMOXING/article/details/142758312

导读：本篇为《深入浅出LLM基础篇》系列第三篇，《深入浅出LLM基础篇》（三）：大模型结构分类主要讨论大型语言模型是如何构建的，章节将着重讨论模型架构，主要讨论Transformer架构及编码、解码器组成结构及原理，这是真正实现大型语言模型的建模创新。

3.1 大模型概括

为了更好的了解整体的功能结构（而不从一开始就陷入局部的结构细节），我们一开始先将语言模型（model）的看作一个黑箱（black box）（在后续的内容中再逐步的拆解），从形象化的概念理解上来说当前大语言模型（大：体现中模型的规模上）的能力，其可以根据输入需求的语言描述（prompt）生成符合需求的结果（completion），形式可以表达为：

prompt⇝modelcompletion or model(prompt)=completionprom**pt⇝modelcompletion or model(prom**pt)=completio**n

接下来我们将从大语言模型的训练数据（traning data）分析开始接下来的内容，首先给出如下的形式化描述

training data⇒p(x1,…,xL).trainin**g dat**a⇒p(x1,…,x**L).

3.2 模型架构

到目前为止，我们已经将语言模型定义为对词元序列的概率分布 p(x1,…,xL)p(x1,…,x**L)，我们已经看到这种定义非常优雅且强大（通过提示，语言模型原则上可以完成任何任务，正如GPT-3所示）。然而，在实践中，对于专门的任务来说，避免生成整个序列的生成模型可能更高效。

上下文向量表征 (Contextual Embedding): 作为先决条件，主要的关键发展是将词元序列与相应的上下文的向量表征：

[the,mouse,ate,the,cheese]⇒ϕ[(10.1),(01),(11),(1−0.1),(0−1)].[the,mou**se,ate,the,cheese]⇒ϕ[(10.1),(01),(11),(1−0.1),(0−1)].

正如名称所示，词元的上下文向量表征取决于其上下文（周围的单词）；例如，考虑mouse的向量表示需要关注到周围某个窗口大小的其他单词。

符号表示：我们将 ϕ:VL→Rd×Lϕ:V**L→Rd×L 定义为嵌入函数（类似于序列的特征映射，映射为对应的向量表示）。
对于词元序列 x1:L=[x1,…,xL]x1:L=[x1,…,x**L]，ϕϕ 生成上下文向量表征 ϕ(x1:L)ϕ(x1:L)。

3.3 大模型分类

在这里插入图片描述

基于Transformer结构的模型又可以分为编码端（Encoder-Only），解码端（Decoder-Only）和编码-解码端（Encoder-Decoder）三类，具体如下图所示。

在这里插入图片描述

1.Encoder-Only架构：

定义与特点：这类模型仅包含编码器部分，主要用于从输入数据提取特征或表示。例如，在BERT (Bidirectional Encoder Representations from Transformers) 中，它是一个双向Transformer编码器，被训练来理解文本上下文信息，并输出一个固定长度的向量表示，该表示包含了原始输入序列的丰富语义信息。用途：主要用于预训练模型，如BERT、RoBERTa等，常用于各种下游任务的特征提取，比如分类、问答、命名实体识别等，但不直接用于生成新的序列。

仅编码器架构（Encoder-only）：自编码模型（破坏一个句子，然后让模型去预测或填补），更擅长理解类的任务，例如：文本分类、实体识别、关键信息抽取等。典型代表有：Bert、RoBERTa等。

2.Decoder-Only架构：

定义与特点：解码器仅架构专注于从某种内部状态或先前生成的内容生成新的序列，通常用于自回归式预测任务，其中每个时刻的输出都依赖于前面生成的所有内容。优点：强大的序列生成能力，能够按顺序逐个生成连续的元素（如单词、字符），适用于诸如文本生成、自动摘要、对话系统等生成性任务。典型的Decoder-Only模型包括GPT系列（如GPT-3）。

仅解码器架构（Decoder-only）：自回归模型（将解码器自己当前步的输出加入下一步的输入，解码器融合所有已经输入的向量来输出下一个向量，所以越往后的输出考虑了更多输入），更擅长生成类的任务，例如：文本生成。典型代表有：GPT系列、LLaMA、OPT、Bloom等。

3.Encoder-Decoder架构：

定义与特点：这种架构由两个主要部分组成：编码器和解码器。编码器负责将输入序列转换为压缩的中间表示，解码器则基于这个中间表示生成目标输出序列。这种结构非常适合翻译、摘要生成、图像描述等任务，需要理解和重构输入信息后生成新序列的任务。工作原理：编码器对源序列进行处理并生成上下文向量，解码器根据此上下文向量逐步生成目标序列。例如，经典的Seq2Seq（Sequence-to-Sequence）模型和Transformer中的机器翻译模型就采用了这样的结构。

编码器-解码器架构（Encoder-Decoder）：序列到序列模型（编码器的输出作为解码器的输入），主要用于基于条件的生成任务，例如：翻译，概要等。典型代表有：T5、BART、GLM等。

3.3.1 结构详细介绍

编码端（Encoder-Only）架构

编码端架构的著名的模型如BERT、RoBERTa等。这些语言模型生成上下文向量表征，但不能直接用于生成文本。可以表示为， x1:L⇒ϕ(x1:L)x1:L⇒ϕ(x1:L) 。这些上下文向量表征通常用于分类任务（也呗称为自然语言理解任务）。任务形式比较简单，下面以情感分类/自然语言推理任务举例：

情感分析输入与输出形式：[[CLS],他们,移动,而,强大]⇒正面情绪情感分析输入与输出形式：[[CLS],他们,移动,而,强大]⇒正面情绪

自然语言处理输入与输出形式：[[CLS],所有,动物,都,喜欢,吃,饼干,哦]⇒蕴涵自然语言处理输入与输出形式：[[CLS],所有,动物,都,喜欢,吃,饼干,哦]⇒蕴涵

该架构的优势是对于文本的上下文信息有更好的理解，因此该模型架构才会多用于理解任务。该架构的有点是对于每个 xix**i ，上下文向量表征可以双向地依赖于左侧上下文 (x1:i−1)(x1:i−1) 和右侧上下文 (xi+1:L)(x**i+1:L) 。但是缺点在于不能自然地生成完成文本，且需要更多的特定训练目标（如掩码语言建模）。

解码器（Decoder-Only）架构

解码器架构的著名模型就是大名鼎鼎的GPT系列模型。这些是我们常见的自回归语言模型，给定一个提示 x1:ix1:i ，它们可以生成上下文向量表征，并对下一个词元 xi+1x**i+1 （以及递归地，整个完成 xi+1:Lx**i+1:L）生成一个概率分布。 x1:i⇒ϕ(x1:i),p(xi+1∣x1:i)x1:i⇒ϕ(x1:i),p(x**i+1∣x1:i) 。我们以自动补全任务来说，输入与输出的形式为， [[CLS],他们,移动,而]⇒强大[[CLS],他们,移动,而]⇒强大。与编码端架构比，其优点为能够自然地生成完成文本，有简单的训练目标（最大似然）。缺点也很明显，对于每个 xix**i ，上下文向量表征只能单向地依赖于左侧上下文 (x1:i−1x1:i−1) 。

编码-解码端（Encoder-Decoder）架构

编码-解码端架构就是最初的Transformer模型，其他的还有如BART、T5等模型。这些模型在某种程度上结合了两者的优点：它们可以使用双向上下文向量表征来处理输入 x1:Lx1:L ，并且可以生成输出 y1:Ly1:L 。可以公式化为：

x1:L⇒ϕ(x1:L),p(y1:L∣ϕ(x1:L))。x1:L⇒ϕ(x1:L),p(y1:L∣ϕ(x1:L))。

以表格到文本生成任务为例，其输入和输出的可以表示为：

[名称:,植物,∣,类型:,花卉,商店]⇒[花卉,是,一,个,商店]。[名称:,植物,∣,类型:,花卉,商店]⇒[花卉,是,一,个,商店]。

该模型的具有编码端，解码端两个架构的共同的优点，对于每个 xix**i ，上下文向量表征可以双向地依赖于左侧上下文 x1:i−1x1:i−1 ) 和右侧上下文 ( xi+1:Lx**i+1:L )，可以自由的生成文本数据。缺点就说需要更多的特定训练目标。

总结：

Encoder-Only用于理解输入并生成其抽象表示，不涉及序列生成。 Decoder-Only专门用于根据之前的信息自动生成新序列，不接收外部输入。 Encoder-Decoder结合了两者的功能，首先对输入进行编码，然后基于编码结果解码生成新序列。

3.3.2 语言模型理论

下一步，我们会介绍语言模型的模型架构，重点介绍Transformer架构机器延伸的内容。另外我们对于架构还会对于之前RNN网络的核心知识进行阐述，其目的是对于代表性的模型架构进行学习，为未来的内容增加知识储备。

深度学习的美妙之处在于能够创建构建模块，就像我们用函数构建整个程序一样。因此，在下面的模型架构的讲述中，我们能够像下面的函数一样封装，以函数的的方法进行理解:

TransformerBlock(x1:L)TransformerBlock(x1:L)

为了简单起见，我们将在函数主体中包含参数，接下来，我们将定义一个构建模块库，直到构建完整的Transformer模型。

3.3.2.1 基础架构

首先，我们需要将词元序列转换为序列的向量形式。 EmbedTokenEmbedToken 函数通过在嵌入矩阵 E∈R∣v∣×dE∈R∣v∣×d 中查找每个词元所对应的向量，该向量的具体值这是从数据中学习的参数：

def EmbedToken(x1:L:VL)→Rd×LEmbedToken(x1:L:V**L)→Rd×L ：

将序列 x1:Lx1:L 中的每个词元 xix**i 转换为向量。
返回[Ex1,…,ExL]。

以上的词嵌入是传统的词嵌入，向量内容与上下文无关。这里我们定义一个抽象的 SequenceModelSequenceMode**l 函数，它接受这些上下文无关的嵌入，并将它们映射为上下文相关的嵌入。

defSequenceModel(x1:L:Rd×L)→Rd×LdefSequenceModel(x1:L:Rd×L)→Rd×L ：

针对序列 x1:Lx1:L 中的每个元素xi进行处理，考虑其他元素。
[抽象实现（例如， FeedForwardSequenceModelFeedForwardSequenceModel ， SequenceRNNSequence**RNN ， TransformerBlockTransformerBlock ）]

最简单类型的序列模型基于前馈网络（Bengio等人，2003），应用于固定长度的上下文，就像n-gram模型一样，函数的实现如下：

def FeedForwardSequenceModel(x1:L:Rd×L)→Rd×LFeedForwardSequenceModel(x1:L:Rd×L)→Rd×L ：

通过查看最后 nn 个元素处理序列 x1:Lx1:L 中的每个元素 xix**i 。
对于每个

i=1,…,Li=1,…,L

：
- 计算 hih**i=FeedForward(xi−n+1,…,xi)FeedForward(x**i−n+1,…,x**i) 。
返回[ h1,…,hLh1,…,h**L ]。

3.3.2.2 递归神经网络

第一个真正的序列模型是递归神经网络（RNN），它是一类模型，包括简单的RNN、LSTM和GRU。基本形式的RNN通过递归地计算一系列隐藏状态来进行计算。

def SequenceRNN(x:Rd×L)→Rd×LSequence**RNN(x:Rd×L)→Rd×L ：

从左到右处理序列 x1,…,xLx1,…,x**L ，并递归计算向量 h1,…,hLh1,…,h**L 。
对于

i=1,…,Li=1,…,L

：
- 计算 hi=RNN(hi−1,xi)h**i=RNN(h**i−1,x**i) 。
- 返回 [h1,…,hL][h1,…,h**L] 。

实际完成工作的模块是RNN，类似于有限状态机，它接收当前状态h、新观测值x，并返回更新后的状态：

def RNN(h:Rd,x:Rd)→RdRNN(h:Rd,x:Rd)→Rd ：

根据新的观测值x更新隐藏状态h。
[抽象实现（例如，SimpleRNN，LSTM，GRU）]

有三种方法可以实现RNN。最早的RNN是简单RNN（Elman，1990），它将hh和xx的线性组合通过逐元素非线性函数 σσ （例如，逻辑函数 σ(z)=(1+e−z)−1σ(z)=(1+e−z)−1 或更现代的 ReLUReLU 函数 σ(z)=max(0,z)σ(z)=ma**x(0,z) ）进行处理。

def SimpleRNN(h:Rd,x:Rd)→RdSimpleRNN(h:Rd,x:Rd)→Rd ：

通过简单的线性变换和非线性函数根据新的观测值 xx 更新隐藏状态 hh 。
返回 σ(Uh+Vx+b)σ(U**h+V**x+b) 。

正如定义的RNN只依赖于过去，但我们可以通过向后运行另一个RNN来使其依赖于未来两个。这些模型被ELMo和ULMFiT使用。

def BidirectionalSequenceRNN(x1:L:Rd×L)→R2d×LBidirectionalSequenceRNN(x1:L:Rd×L)→R2d×L ：

同时从左到右和从右到左处理序列。
计算从左到右： [h→1,…,h→L]←SequenceRNN(x1,…,xL)[h→1,…,h→L]←Sequence**RNN(x1,…,x**L) 。
计算从右到左： [h←L,…,h←1]←SequenceRNN(xL,…,x1)[h←L,…,h←1]←Sequence**RNN(x**L,…,x1) 。
返回 [h→1h←1,…,h→Lh←L][h→1h←1,…,h→L**h←L] 。

注：

简单RNN由于梯度消失的问题很难训练。
为了解决这个问题，发展了长短期记忆（LSTM）和门控循环单元（GRU）（都属于RNN）。
然而，即使嵌入h200可以依赖于任意远的过去（例如，x1），它不太可能以“精确”的方式依赖于它（更多讨论，请参见Khandelwal等人，2018）。
从某种意义上说，LSTM真正地将深度学习引入了NLP领域。

3.4 Transformer组成

Transformer是一种由谷歌在2017年提出的深度学习模型，主要用于自然语言处理（NLP）任务，特别是序列到序列（Sequence-to-Sequence）的学习问题，如机器翻译、文本生成等。Transformer彻底改变了之前基于循环神经网络（RNNs）和长短期记忆网络（LSTMs）的序列建模范式，并且在性能上取得了显著提升。Transformer模型将其分解为Decoder-Only（GPT-2，GPT-3）、Encoder-Only（BERT，RoBERTa）和Encoder-Decoder（BART，T5）模型的构建模块。Transformer结构如下图所示：

在这里插入图片描述

Transformer的核心创新点包括：

自注意力机制（Self-Attention Mechanism）：Transformer模型摒弃了传统RNN结构的时间依赖性，通过自注意力机制实现了对输入序列中任意两个位置之间的直接关联建模。每个词的位置可以同时关注整个句子中的其他所有词，计算它们之间的相关性得分，然后根据这些得分加权求和得到该位置的上下文向量表示。这种全局信息的捕获能力极大地提高了模型的表达力。

多头注意力（Multi-Head Attention）：Transformer进一步将自注意力机制分解为多个并行的“头部”，每个头部负责从不同角度对输入序列进行关注，从而增强了模型捕捉多种复杂依赖关系的能力。最后，各个头部的结果会拼接并经过线性变换后得到最终的注意力输出。

位置编码（Positional Encoding）：由于Transformer不再使用RNN那样的顺序处理方式，为了引入序列中词的位置信息，它采用了一种特殊的位置编码方法。这种方法对序列中的每个位置赋予一个特定的向量，这个向量的值与位置有关，确保模型在处理时能够区分不同的词语顺序。

编码器-解码器架构（Encoder-Decoder Architecture）：Transformer采用了标准的编码器-解码器结构，其中编码器负责理解输入序列，将其转换成高级语义表示；而解码器则依据编码器的输出并结合自身产生的隐状态逐步生成目标序列。在解码过程中，解码器还应用了自注意力机制以及一种称为“掩码”（Masking）的技术来防止提前看到未来要预测的部分。

残差连接（Residual Connections）：Transformer沿用了ResNet中的残差连接设计，以解决随着网络层数加深带来的梯度消失或爆炸问题，有助于训练更深更复杂的模型。

层归一化（Layer Normalization）：Transformer使用了层归一化而非批量归一化，这使得模型在小批量训练时也能获得良好的表现，并且有利于模型收敛。

总结：

Transformer架构的核心组成：

自注意力机制（Self-Attention）和前馈神经网络（Feedforward Neural Networks），自注意力机制允许模型在处理每个单词时同时考虑到句子中的其他单词，从而捕捉更复杂的语言关系
Layer Normalization和残差连接ADD，防止在深层网络中出现的梯度消失问题
位置编码：由于Transformer模型本身不处理序列中的位置信息，位置编码可以添加位置信息，对于理解文本顺序和语言结构至关重要。

关于Transformer的学习资源有很多：

Illustrated Transformer和Illustrated GPT-2：对Transformer的视觉描述非常好。
Annotated Transformer：Transformer的Pytorch实现。

强烈建议您阅读这些参考资料。该课程主要依据代码函数和接口进行讲解。

注意力机制

Transformer的关键是注意机制，这个机制早在机器翻译中就被开发出来了（Bahdananu等人，2017）。可以将注意力视为一个“软”查找表，其中有一个查询 yy，我们希望将其与序列 x1:L=[x1,…,xL]x1:L=[x1,…,x**L] 的每个元素进行匹配。我们可以通过线性变换将每个 xix**i 视为表示键值对：

(Wkeyxi)：(Wvaluexi)(Wkeyxi)：(Wvaluex**i)

并通过另一个线性变换形成查询：

WqueryyWqueryy

可以将键和查询进行比较，得到一个分数：

scorei=xi⊤Wkey⊤Wqueryyscorei=x**i⊤Wkey⊤Wqueryy

这些分数可以进行指数化和归一化，形成关于词元位置1,…,L1,…,L的概率分布：

[α1,…,αL]=softmax([score1,…,scoreL])[α1,…,α**L]=softmax([scor**e1,…,scoreL])

然后最终的输出是基于值的加权组合：

∑i=1Lαi(Wvaluexi)i=1∑Lαi(Wvaluex**i)

我们可以用矩阵形式简洁地表示所有这些内容：

def Attention(x1:L:Rd×L,y:Rd)→RdAttentio**n(x1:L:Rd×L,y:Rd)→Rd ：

通过将其与每个xix**i进行比较来处理yy。
返回 Wvaluex1:Lsoftmax⁡(x1:L⊤Wkey⊤Wqueryy/d)Wvaluex1:Lsoftmax(x1:L⊤Wkey⊤Wqueryy/d)

我们可以将注意力看作是具有多个方面（例如，句法、语义）的匹配。为了适应这一点，我们可以同时使用多个注意力头，并简单地组合它们的输出。

def MultiHeadedAttention(x1:L:Rd×L,y:Rd)→RdMultiHeadedAttention(x1:L:Rd×L,y:Rd)→Rd :

通过将其与每个xi与nheads个方面进行比较，处理y。
返回 Woutput[[Attention⁡(x1:L,y),…,Attention⁡(x1:L,y)]⏟nheadstimesWoutpu**t[nheadstimes[Attention(x1:L,y),…,Attention(x1:L,y)]

对于自注意层，我们将用xix**i替换yy作为查询参数来产生，其本质上就是将自身的xix**i对句子的其他上下文内容进行 AttentionAttentio**n 的运算：

def SelfAttention(x1:L:Rd×L)→Rd×L)SelfAttentio**n(x1:L:Rd×L)→Rd×L) ：

将每个元素xi与其他元素进行比较。
返回 [Attention(x1:L,x1),…,Attention(x1:L,xL)][Attentio**n(x1:L,x1),…,Attentio**n(x1:L,x**L)] 。

自注意力使得所有的词元都可以“相互通信”，而前馈层提供进一步的连接：

def FeedForward(x1:L:Rd×L)→Rd×LFeedForward(x1:L:Rd×L)→Rd×L ：

独立处理每个词元。
对于

i=1,…,Li=1,…,L

：
- 计算 yi=W2max(W1xi+b1,0)+b2y**i=W2ma**x(W1x**i+b1,0)+b2 。
返回 [y1,…,yL][y1,…,y**L] 。

对于Transformer的主要的组件，我们差不多进行介绍。原则上，我们可以只需将 FeedForward∘SelfAttentionFeedForward∘SelfAttentio**n 序列模型迭代96次以构建GPT-3，但是那样的网络很难优化（同样受到沿深度方向的梯度消失问题的困扰）。因此，我们必须进行两个手段，以确保网络可训练。

残差连接和归一化

残差连接：计算机视觉中的一个技巧是残差连接（ResNet）。我们不仅应用某个函数f：

f(x1:L)，f(x1:L)，

而是添加一个残差（跳跃）连接，以便如果ff的梯度消失，梯度仍然可以通过 x1:Lx1:L 进行计算：

x1:L+f(x1:L)。x1:L+f(x1:L)。

层归一化:另一个技巧是层归一化，它接收一个向量并确保其元素不会太大：

def LayerNorm(x1:L:Rd×L)→Rd×LLayerNor**m(x1:L:Rd×L)→Rd×L ：

使得每个 xix**i 既不太大也不太小。

我们首先定义一个适配器函数，该函数接受一个序列模型ff并使其“鲁棒”：

def AddNorm(f:(Rd×L→Rd×L),x1:L:Rd×L)→Rd×LAddNorm(f:(Rd×L→Rd×L),x1:L:Rd×L)→Rd×L ：

安全地将f应用于 x1:Lx1:L 。
返回 LayerNorm(x1:L+f(x1:L))LayerNor**m(x1:L+f(x1:L)) 。

最后，我们可以简洁地定义Transformer块如下：

def TransformerBlock(x1:L:Rd×L)→Rd×LTransformerBlock(x1:L:Rd×L)→Rd×L ：

处理上下文中的每个元素 xix**i 。
返回 AddNorm(FeedForward,AddNorm(SelfAttention,x1:L))AddNorm(FeedForward,AddNorm(SelfAttentio**n,x1:L)) 。

位置嵌入

最后我们对目前语言模型的位置嵌入进行讨论。您可能已经注意到，根据定义，词元的嵌入不依赖于其在序列中的位置，因此两个句子中的𝗆𝗈𝗎𝗌𝖾将具有相同的嵌入，从而在句子位置的角度忽略了上下文的信息，这是不合理的。

css代码解读复制代码[𝗍𝗁𝖾,𝗆𝗈𝗎𝗌𝖾,𝖺𝗍𝖾,𝗍𝗁𝖾,𝖼𝗁𝖾𝖾𝗌𝖾]
[𝗍𝗁𝖾,𝖼𝗁𝖾𝖾𝗌𝖾,𝖺𝗍𝖾,𝗍𝗁𝖾,𝗆𝗈𝗎𝗌𝖾]

为了解决这个问题，我们将位置信息添加到嵌入中：

def EmbedTokenWithPosition(x1:L:Rd×L)EmbedTokenWithPositio**n(x1:L:Rd×L) ：

添加位置信息。
定义位置嵌入：
- 偶数维度：Pi,2j=sin(i/100002j/dmodel)P**i,2j=s**in(i/100002j/dmode**l)
- 奇数维度：Pi,2j+1=cos(i/100002j/dmodel)P**i,2j+1=cos(i/100002j/dmode**l)
返回 [x1+P1,…,xL+PL][x1+P1,…,x**L+P**L] 。