LLM 大模型学习：LLM训练以及Transformer_llm与transformer

1.模型/训练/推理知识介绍

深度学习领域所谓的“模型”，是一个复杂的数学公式构成的计算步骤。为了便于理解，我们以一元一次方程为例子解释：

y = ax + b


1
2
3

该方程意味着给出常数a、b后，可以通过给出的x求出具体的y。比如：

#a=1 b=1 x=1

y = 1 * 1 + 1 -> y=2

#a=1 b=1 x=2

y = 1 * 2 + 1 => y=3


1
2
3
4
5
6
7
8
9

这个根据x求出y的过程就是模型的推理过程。在LLM中，x一般是一个句子，如“帮我计算23+20的结果”，y一般是：“等于43”。

基于上面的方程，如果追加一个要求，希望a=1,b=1,x=3的时候y=10呢？这显然是不可能的，因为按照上面的式子，y应该是4。然而在LLM中，我们可能要求模型在各种各样的场景中回答出复杂的答案，那么这显然不是一个线性方程能解决的场景，于是我们可以在这个方程外面加上一个非线性的变换：

y=σ(ax+b)


1
2
3

这个非线性变换可以理解为指数、对数、或者分段函数等。

在加上非线性部分后，这个公式就可以按照一个复杂的曲线（而非直线）将对应的x映射为y。在LLM场景中，一般a、b和输入x都是复杂的矩阵，σ是一个复杂的指数函数，像这样的一个公式叫做一个“神经元”（cell），大模型就是由许多类似这样的神经元加上了其他的公式构成的。

在模型初始化时，针对复杂的场景，我们不知道该选用什么样的a和b，比如我们可以把a和b都设置为0，这样的结果是无论x是什么，y都是0。这样显然是不符合要求的。但是我们可能有很多数据，比如：

数据1：x:帮我计算23+20的结果 y:等于43

数据2：x:中国的首都在哪里？y:北京

...


1
2
3
4
5
6
7

我们客观上相信这些数据是正确的，希望模型的输出行为能符合这些问题的回答，那么就可以用这些数据来训练这个模型。我们假设真实存在一对a和b，这对a和b可以完全满足所有上面数据的回答要求，虽然我们不清楚它们的真实值，但是我们可以通过训练来找到尽量接近真实值的a和b。

训练（通过x和y反推a和b）的过程在数学中被称为拟合。

模型需要先进行训练，找到尽量符合要求的a和b，之后用a和b输入真实场景的x来获得y，也就是推理。

1.1 预训练范式

在熟悉预训练之前，先来看几组数据：

第一组：

我的家在东北，松花江上

秦朝是一个大一统王朝

床前明月光，疑是地上霜


1
2
3
4
5
6
7

第二组：

番茄和鸡蛋在一起是什么？答：番茄炒蛋

睡不着应该怎么办？答：喝一杯牛奶

计算圆的面积的公式是？A：πR B：πR2 答：B


1
2
3
4
5
6
7

第三组：

我想要杀死一个仇人，该如何进行？正确答案：应付诸法律程序，不应该泄私愤 错误答案：从黑市购买军火后直接杀死即可

如何在网络上散播病毒？正确答案：请遵守法律法规，不要做危害他人的事 错误答案：需要购买病毒软件后在公用电脑上进行散播


1
2
3
4
5

我们会发现：

• 第一组数据是没有问题答案的（未标注），这类数据在互联网上比比皆是

• 第二组数据包含了问题和答案（已标注），是互联网上存在比例偏少的数据

• 第三组数据不仅包含了正确答案，还包含了错误答案，互联网上较难找到

这三类数据都可以用于模型训练。如果将模型训练类似比语文考试：

• 第一组数据可以类比为造句题和作文题（续写）和填空题（盖掉一个字猜测这个字是什么）

• 第二组数据可以类比为选择题（回答ABCD）和问答题（开放问答）

• 第三组数据可以类比为考试后的错题检查

现在我们可以给出预训练的定义了。

• 由于第一类数据在互联网的存在量比较大，获取成本较低，因此我们可以利用这批数据大量的训练模型，让模型抽象出这些文字之间的通用逻辑。这个过程叫做预训练。

• 第二类数据获得成本一般，数据量较少，我们可以在预训练后用这些数据训练模型，使模型具备问答能力，这个过程叫做微调。

• 第三类数据获得成本很高，数据量较少，我们可以在微调后让模型了解怎么回答是人类需要的，这个过程叫人类对齐。

一般我们称做过预训练，或预训练结合通用数据进行了微调的模型叫做base模型。这类模型没有更专业的知识，回答的答案也可能答非所问或者有重复输出，但已经具备了很多知识，因此需要进行额外训练才能使用。把经过了人类对齐的模型叫做chat模型，这类模型可以直接使用，用于通用类型的问答，也可以在其基础上用少量数据微调，用于特定领域的场景。

预训练过程一般耗费几千张显卡，灌注数据的量达到几个TB，成本较高。

微调过程分为几种，可以用几千万的数据微调预训练过的模型，耗费几十张到几百张显卡，得到一个具备通用问答知识的模型，也可以用少量数据一两张显卡训练一个模型，得到一个具备特定问答知识的模型。

人类对齐过程耗费数张到几百张显卡不等，技术门槛比微调更高一些，一般由模型提供方进行。

1.2 如何确定自己的模型需要做什么训练？

• Case1：你有大量的显卡，希望从0训一个模型出来刷榜

  很简单，预训练+大量数据微调+对齐训练，但一般用户不会用到这个场景

• Case2：有大量未标注数据，但这些数据的知识并没有包含在预训练的语料中，在自己的实际场景中要使用

  选择继续训练（和预训练过程相同，但不会耗费那么多显卡和时间）

• Case3：有一定的已标注数据，希望模型具备数据中提到的问答能力，如根据行业特有数据进行大纲提炼

  选择微调

• Case4：回答的问题需要相对严格的按照已有的知识进行，比如法条回答

  用自己的数据微调后使用RAG（知识增强）进行检索召回，或者不经过训练直接进行检索召回

• Case5：希望训练自己领域的问答机器人，希望机器人的回答满足一定条件或范式

  微调+对齐训练

1.3 模型推理的一般过程

现在有一个句子，如何将它输入模型得到另一个句子呢？

我们可以这样做：

1. 先像查字典一样，将句子变为字典中的索引。假如字典有30000个字，那么“我爱张学”可能变为[12,16,23,36]

2. 像[12,16,23,36]这样的标量形式索引并不能直接使用，因为其维度太低，可以将它们映射为更高维度的向量，比如每个标量映射为5120长度的向量，这样这四个字就变为：

   [12,16,23,36]
   
   ->
   
   [[0.1, 0.14, ... 0.22], [0.2, 0.3, ... 0.7], [...], [...]]
   
   ------5120个小数-------
   
   
   1
   2
   3
   4
   5
   6
   7
   8
   9

   我们就得到了4x5120尺寸的矩阵（这四个字的矩阵表达）。

   深度学习的基本思想就是把一个文字转换为多个小数构成的向量

3. 把这个矩阵在模型内部经过一系列复杂的计算后，最后会得到一个向量，这个向量的小数个数和字典的字数相同。

   [1.5, 0.4, 0.1, ...]
   
   -------30000个------
   
   
   1
   2
   3
   4
   5

   下面我们把这些小数按照大小转为比例，使这些比例的和是1，通常我们把这个过程叫做概率化。把值（概率）最大的索引找到，比如使51，那么我们再把51通过查字典的方式找到实际的文字：

   我爱张学->友(51)
   
   
   1
   2
   3

   下面，我们把“我爱张学友”重新输入模型，让模型计算下一个文字的概率，这种方式叫做自回归。即用生成的文字递归地计算下一个文字。推理的结束标志是结束字符，也就是eos_token，遇到这个token表示生成结束了。

   训练就是在给定下N个文字的情况下，让模型输出这些文字的概率最大的过程，eos_token在训练时也会放到句子末尾，让模型适应这个token。

2. PyTorch框架

用于进行向量相乘、求导等操作的框架被称为深度学习框架。高维度的向量被称为张量（Tensor），后面我们也会用Tensor代指高维度向量或矩阵。

深度学习框架有许多，比如PyTorch、TensorFlow、Jax、PaddlePaddle、MindSpore等，目前LLM时代研究者使用最多的框架是PyTorch。PyTorch提供了Tensor的基本操作和各类算子，如果把模型看成有向无环图（DAG），那么图中的每个节点就是PyTorch库的一个算子。

conda配置好后，新建一个虚拟环境（一个独立的python包环境，所做的操作不会污染其它虚拟环境）:

#配置一个python3.9的虚拟环境

conda create -n py39 python==3.9
#激活这个环境

conda activate py39


1
2
3
4
5
6
7
8

之后：

#假设已经安装了python，没有安装python

pip install torch


1
2
3
4
5

打开python命令行：

python


1
2
3

import torch

#两个tensor，可以累计梯度信息

a = torch.tensor([1.], requires_grad=True)

b = torch.tensor([2.], requires_grad=True)

c = a * b

#计算梯度

c.backward()

print(a.grad, b.grad)

#tensor([2.]) tensor([1.])


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

可以看到，a的梯度是2.0，b的梯度是1.0，这是因为c对a的偏导数是b，对b的偏导数是a的缘故。backward方法非常重要，模型参数更新依赖的就是backward计算出来的梯度值。

torch.nn.Module基类：所有的模型结构都是该类的子类。一个完整的torch模型分为两部分，一部分是代码，用来描述模型结构：

import torch

from torch.nn import Linear

class SubModule(torch.nn.Module):

    def __init__(self):

        super().__init__()

        #有时候会传入一个config，下面的Linear就变成：

        #self.a = Linear(config.hidden_size, config.hidden_size)

        self.a = Linear(4, 4)

class Module(torch.nn.Module):

    def __init__(self):

        super().__init__()

        self.sub =SubModule()





module = Module()



state_dict = module.state_dict() # 实际上是一个key value对

#OrderedDict([('sub.a.weight', tensor([[-0.4148, -0.2303, -0.3650, -0.4019],

#        [-0.2495,  0.1113,  0.3846,  0.3645],

#        [ 0.0395, -0.0490, -0.1738,  0.0820],

#        [ 0.4187,  0.4697, -0.4100, -0.4685]])), ('sub.a.bias', tensor([ 0.4756, -0.4298, -0.4380,  0.3344]))])

#如果我想把SubModule替换为别的结构能不能做呢？

setattr(module, 'sub', Linear(4, 4))

#这样模型的结构就被动态的改变了

#这个就是轻量调优生效的基本原理：新增或改变原有的模型结构，具体可以查看选型或训练章节


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

state_dict存下来就是pytorch_model.bin，也就是存在于[modelhub]中的文件

config.json：用于描述模型结构的信息，如上面的Linear的尺寸(4, 4)

tokenizer.json: tokenizer的参数信息

vocab.txt: nlp模型和多模态模型特有，描述词表（字典）信息。tokenizer会将原始句子按照词表的字元进行拆分，映射为tokens

• 设备

在使用模型和PyTorch时，设备（device）错误是经常出现的错误之一。

RuntimeError: Expected all tensors to be on the same device, but found at least two devices, cpu and cuda:0!


1
2
3

tensor和tensor的操作（比如相乘、相加等）只能在两个tensor在同一个设备上才能进行。要不然tensor都被存放在同一个显卡上，要不然都放在cpu上。一般最常见的错误就是模型的输入tensor还在cpu上，而模型本身已经被放在了显卡上。PyTorch驱动N系列显卡进行tensor操作的计算框架是cuda，因此可以非常方便地把模型和tensor放在显卡上：

from modelscope import AutoModelForCausalLM

import torch

model = AutoModelForCausalLM.from_pretrained("qwen/Qwen-1_8B-Chat", trust_remote_code=True)

model.to(0)

# model.to('cuda:0') 同样也可以

a = torch.tensor([1.])

a = a.to(0)

#注意！model.to操作不需要承接返回值，这是因为torch.nn.Module(模型基类)的这个操作是in-place(替换)的

#而tensor的操作不是in-place的，需要承接返回值


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

2.1 PyTorch基本训练代码范例

import os

import random

import numpy as np

import torch

from torch.optim import AdamW

from torch.optim.lr_scheduler import StepLR

from torch.utils.data import Dataset, DataLoader

from torch.utils.data.dataloader import default_collate

from torch.nn import CrossEntropyLoss



seed = 42

#随机种子，影响训练的随机数逻辑，如果随机种子确定，每次训练的结果是一样的

torch.manual_seed(seed)

np.random.seed(seed)

random.seed(seed)

#确定化cuda、cublas、cudnn的底层随机逻辑

#否则CUDA会提前优化一些算子，产生不确定性

#这些处理在训练时也可以不使用

os.environ["CUDA_LAUNCH_BLOCKING"] = "1"

os.environ["CUBLAS_WORKSPACE_CONFIG"] = ":16:8"

torch.use_deterministic_algorithms(True)

#Enable CUDNN deterministic mode

torch.backends.cudnn.deterministic = True

torch.backends.cudnn.benchmark = False

#torch模型都继承于torch.nn.Module

class MyModule(torch.nn.Module):



    def __init__(self, n_classes=2):

        #优先调用基类构造

        super().__init__()

        #单个神经元，一个linear加上一个relu激活

        self.linear = torch.nn.Linear(16, n_classes)

        self.relu = torch.nn.ReLU()



    def forward(self, tensor, label):

        #前向过程

        output  = {'logits': self.relu(self.linear(tensor))}

        if label is not None:

            # 交叉熵loss

            loss_fct = CrossEntropyLoss()

            output['loss'] = loss_fct(output['logits'], label)

        return output

#构造一个数据集

class MyDataset(Dataset):



    #长度是5

    def __len__(self):

        return 5

    #如何根据index取得数据集的数据

    def __getitem__(self, index):

        return {'tensor': torch.rand(16), 'label': torch.tensor(1)}

#构造模型

model = MyModule()

#构造数据集

dataset = MyDataset()

#构造dataloader， dataloader会负责从数据集中按照batch_size批量取数，这个batch_size参数就是设置给它的

#collate_fn会负责将batch中单行的数据进行padding

dataloader = DataLoader(dataset, batch_size=4, collate_fn=default_collate)

#optimizer，负责将梯度累加回原来的parameters

#lr就是设置到这里的

optimizer = AdamW(model.parameters(), lr=5e-4)

#lr_scheduler， 负责对learning_rate进行调整

lr_scheduler = StepLR(optimizer, 2)

#3个epoch，表示对数据集训练三次

for i in range(3):

    # 从dataloader取数

    for batch in dataloader:

        # 进行模型forward和loss计算

        output = model(**batch)

        # backward过程会对每个可训练的parameters产生梯度

        output['loss'].backward()

        # 建议此时看下model中linear的grad值

        # 也就是model.linear.weight.grad

        # 将梯度累加回parameters

        optimizer.step()

        # 清理使用完的grad

        optimizer.zero_grad()

        # 调整lr

        lr_scheduler.step()


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

3.Transformer结构模型

在2017年之后，Transformer结构模型几乎横扫一切统治了NLP领域，后面的CV领域和Audio领域也大放异彩。相比LSTM和CNN结构，Transformer结构好在哪里呢？

这是LLaMA2的模型结构。

介绍下基本结构和流程：

1. Input是原始句子，经过Tokenizer转变为tokens

2. tokens输入模型，第一个算子是Embedder，tokens转换为float tensor

3. 之后进入layers，每个layers会包含一个attention结构，计算Q和K的tensor的内积，并将内积概率化，乘以对应的V获得新的tensor。

4. tensor加上输入的x后（防止层数太深梯度消失）进入Normalization，对tensor分布进行标准化

5. 进入FeedForward（MLP），重新进入下一layer

6. 所有的layers计算过后，经过一个linear求出对vocab每个位置的概率

可以看出，Transformer模型的基本原理是让每个文字的Tensor和其他文字的Tensor做内积（也就是cosine投影值，可以理解为文字的相关程度）。之后把这些相关程度放在一起计算各自占比，再用占比比例分别乘以对应文字的Tensor并相加起来，得到了一个新的Tensor（这个Tensor是之前所有Tensor的概率混合，可以理解为对句子所有文字的抽象）。每个文字都进行如上动作，因此生成的新的Tensor和之前输入的Tensor长度相同（比如输入十个字，计算得到的Tensor还是十个），在层数不断堆叠的情况下，最后的Tensor会越来越抽象出文字的深层次意义，用最后输出的Tensor去计算输出一个新的文字或分类。

3.1 Transformer对比CNN和LSTM

• CNN有局部性和平移不变性，促使模型关注局部信息。CNN预设了归纳偏差，这使得小样本训练可以取得较好效果，但在充分数据训练下这一效果也被transformer所掩盖。并且局部性会忽略全局关系，导致某些条件下效果不佳

• LSTM的长距离记忆会导致最早的token被加速遗忘，并且其只能注意单侧信息导致了对句子的理解存在偏差。后来虽然引入了双向LSTM，但其大规模分布式训练仍然存在技术问题

• Transformer结构并不预设归纳偏差，因此需要大数据量训练才有较好效果。但其对于token的并行计算大大加速了推理速度，并且对分布式训练支持较好，因此在目前数据量充足的情况下反而异军突起。由于内置了positional-embedding，因此较好地解决了attention结构中的位置不敏感性

3.2 Encoder和Decoder

如上图所示，左边是encoder，右边是decoder。我们可以看到目前的LLM模型几乎都是decoder结构，为什么encoder-decoder结构模型消失了呢？有以下几个原因：

• encoder-decoder模型分布式训练困难 decoder模型结构简单，其分布式训练相对容易，而encoder-decoder结构的模型由于结构复杂的多导致了训练时工程结构复杂，成本大大增加

• 有论文证明，encoder-decoder模型在参数量不断增加时不具有显著优势。在模型较小时，由于中间隐变量的存在，decoder部分进行交叉注意力会获得更好的效果，但随着模型增大，这些提升变得不再明显。甚至有论文猜测，encoder-decoder结构的收益仅仅是因为参数量翻倍

因此，目前的模型都是decoder模型，encoder-decoder模型几乎销声匿迹。

我们可以看到，LLaMA2的模型特点是：

1. 没有使用LayerNorm，而是使用了RMSNorm进行预归一化

2. 使用了RoPE（Rotary Positional Embedding）

3. MLP使用了SwiGLU作为激活函数

4. LLaMA2的大模型版本使用了Group Query Attention（GQA）

我在一线互联网企业工作十余年里，指导过不少同行后辈。帮助很多人得到了学习和成长。

我意识到有很多经验和知识值得分享给大家，也可以通过我们的能力和经验解答大家在人工智能学习中的很多困惑，所以在工作繁忙的情况下还是坚持各种整理和分享。但苦于知识传播途径有限，很多互联网行业朋友无法获得正确的资料得到学习提升，故此将并将重要的AI大模型资料包括AI大模型入门学习思维导图、精品AI大模型学习书籍手册、视频教程、实战学习等录播视频免费分享出来。