模型

模型架构

目前大部分的模型架构都是decode-only（casual LM），少量的有encode-decode，encode-only，为啥大部分LLM是decode-only的，原因可能是以下几点：从mask的角度看，decode-only的输入是一个对角矩阵，对角矩阵是满秩矩阵，表达能力更强。个人感觉decode-only训练的效率更高，更适合few shot learning， 或者zero shot learning。

encode-only架构（bert），需要加一个[cls]，然后下游任务需要继续finetune，这就决定了bert模型不能作为一个通用的大模型（LLM as a service）。encode-decode 架构大概是得益于多用了一倍的参数量。

模型参数量计算：4h*h + 4h*h*2=12h*h，忽略bias，所以整个参数是12lhh+VH。

一次Forward的计算量，attention的计算量，qkv的计算量为：2bshh * 3，qk计算量为2bssh，S的计算量也是2bssh，w0的计算量为2bshh。所以attention的计算量为8bshh + 4bssh。mlp的计算量为：16bshh，所以整个decode layer的计算量为24bshh + 4bssh。一次backward是一次forward的计算量的2倍。

在一次前向传递中，对于每个token，每个模型参数，需要进行2次浮点数运算，即一次乘法法运算和一次加法运算。一次训练迭代中，对于每个token，每个模型参数，需要进行 2∗3=6 次浮点数运算。

Forward过程

在训练的时候，模型的输入，一般是一个下三角矩阵，通过结合mask实现。过embedding层，后面要经过多个decode-layer层，一个decode layer层，一般包括attention和mlp。另外还有layer norm（rmsNorm），残差连接。

假设输入为x，如果采用pre-norm

Residual = x

x = layernorm(x)

Q = wq(x), k = wk(x), v = wv(x)，其中wx表示torch.linear()，bias可带可不带，最近的研究表明，带上bias有助于外推。

加上position embedding，一般采用ROPE（旋转位置编码），主要的思路是利用绝对位置编码的形式，来实现相对位置编码，思想是借鉴了欧拉公式，编码是针对embedding的每个元素，cos(m*sita)q1 + sin(msita)*q2，sita的取值是10000 （2i/2**d）。假如推理的时候，超过max_seq_length的时候，会采用NTK aware。

Q+= position embedding , K += position embedding.

attention_score = softmax(matmal(Q, K) + mask)/(sqrt(d))

attention_score = dropout(attention_score)

Attention = matmal(attention_score, v)

x = attention + residual

假如采用post norm 这里会对x进行layer_norm

下面是mlp部分:

residual = x

x = layernorm(x)

x = down_proj(active_func(up_proj(x)))

x = x + residual

如果采用了past_key_value, 那么input_ids只保留seq维度的最后一个输入，经过decode layer之后，也只会得到一个token的hidden state。在计算Q，K，V时，seq维度只有1个，k,v会和之前的拼接。

在计算loss时：

shift_logits = logits[…, :-1, :].contiguous() shift_labels = labels[…, 1:].contiguous() # Flatten the tokens loss_fct = CrossEntropyLoss() shift_logits = shift_logits.view(-1, self.config.vocab_size) ##需要展平 shift_labels = shift_labels.view(-1) # Enable model parallelism shift_labels = shift_labels.to(shift_logits.device) loss = loss_fct(shift_logits, shift_labels)

一般认为采用pre-LN会使得训练稳定，另外，采用RMSNORM 取代传统的layernorm(在embedding层面)，会加速计算，不用计算平均值，xi/sqrt(sigma xi*xi/n)

在activate func一般采用GLU，GeGLU，swishGLU等，具体细节容易记不清楚。

在预测结果时，需要在最后一个token的hidden states的加上一个lm_head，来做hidden state到vocab的映射，一般可以采用和embedding层相同的权重，有的模型是重新训练的， llama好像是重新开始训练的。

数据

数据对模型训练时至关重要的，数据质量感觉是重中之重，论文 textbook is all you need，少量的高质量的数据，比大规模数据训练出来的模型性能要好。

在预训练阶段：

一般的开源数据集包括：common crawl，c4，pile，github等网页数据，还有一些书籍，对话、书籍、代码、技术报告、论文考试，ArXiv等数据。

中文数据集：THUCNews，wiki百科中文，WuDaoCorpora（智源开源的数据集）

一般需要对数据集进行去重，过滤等，保证数据质量，

去重一般采用minihash simhash等技术。过滤一般是指将有害的文本去除掉，一般采用关键词过滤，分类器过滤。

大模型标配是需要2T个token，一般需要对事实性更强的数据进行上采样，比如wikipadia数据。另外需要对特定网站的数据比如个人隐私性比较强的数据，进行过滤。

典型的模型训练细节（参考llama2）：adamW，B1=0.9, B2=0.95, cos leaning schedule (10% peak learning rate), warm up，weight decay 0.1， gradient clip 1.0，learning rate=10-5 采用Group query Attention， SwishGLU。

一般会对预训练的模型进行评估，针对不同的能力，会有不同的测试集，code能力：humaneval，MBPP，common sense reasoning：OpenQA，PIQA等，WorldKnowledge：NaturalQuestions，TriviaQA，Reading comprehension的能力：SQuAD, Math能力：GSM8K，MATH等，Popular Aggregated Benchmarks：MMLU，BBH等

训练

SFT阶段

SFT阶段一般也是instruction tuning，这个阶段数据质量是至关重要的，每条数据由指令和回答组成。指令的多样性，以及回答的质量是重要的因素。从已有的上百万的指令数据中，挑选出万级别（2-3万）的指令，并对此进行人工回答。llama2为了验证标注的质量，从sft训练数据中，选取出180条样本，不参与训练，然后用sft模型预测，并与人工标注的对比。

训练细节：learning rate 2*10-5，sequence length of 4096 tokens。在训练的时候，将所有的样本拼接起来，并用拼接。保证seq被充分利用。在训练中，也是和pretrain的训练方式一致，所不同的是，针对promt 不计算loss，还没找到相应的代码。另外训练的epoch 数量一般是2.

RLHF阶段

需要训练reward模型，和ppo两个阶段。

Reward阶段：需要收集人类偏好数据，针对同一个prompt，标注人员需要标注自己的喜好。其中prompt也是标注人员写的，产生的答案是从不同的模型，或者不同的temperature下采样的得到的。一般不止要标注哪个更好，还要标注好的程度（好的比较明显，一般明显，还是不怎么明显）。另外，要区分有用性和安全性。

因为偏好数据是不断收集的，另外，chat模型也是不断的更新的，如果reward模型只训练一次，不进行迭代，可能会degrade，it is important before a new Llama 2-Chat tuning iteration to gather new preference data using the latest Llama 2-Chat iterations. This step helps keep the reward model on-distribution and maintain an accurate reward for the latest model.

训练reward模型

一般是最大化两者的差值，llama2引入了一个margin，将偏好程度也引入进去了。这样可以让reward 模型分配一些reward score给那些更容易区分的generation上。

meta不仅自己标注了preference data（141万 pairs），还引入了开源的数据。其中anthropic的数据是一大来源（12万+4万）。

在训练helpful 模型时，是混合了helpful数据和safety数据一起训练的（50-50），训练safety数据也是混合的（10-90）

训练细节：1 epoch，max learning rate is 0.5*10-5 in 70b, 其他的是10-5。

模型训练结果，由于是分开训练helpful和safety模型，所以这两个模型分别在各自擅长的领域取得了最好的效果。但是后面怎么融合是一个问题。另外，在偏好程度越明显，reward的正确率越高。

另外，reward model也有scaling law，模型越大，数据越多，效果越好，这对于下面的ppo训练时有帮助的。

reward模型的训练一般是在base模型的基础上进行训练的。

在计算reward loss的细节上，在对比choosen和rejected时选取第一个不相同的token的seq 下标，计算loss的均值。

其实是计算choosen answer 和rejected answer的在seq的所有差异，不是只计算最后一个token的。但是在ppo里，是只用了最后一个token的reward score。

reward模型的能力对后续的finetune是至关重要的，指引了模型迭代的方向。

c_truncated_reward = chosen_reward[divergence_ind:end_ind] r_truncated_reward = rejected_reward[divergence_ind:end_ind] chosen_mean_scores.append( chosen_reward[c_ind - 1]) #use the end score for reference rejected_mean_scores.append(rejected_reward[r_ind - 1]) loss += -torch.nn.functional.logsigmoid(c_truncated_reward - r_truncated_reward).mean()

ppo和rejected sampling

这一步是利用上一步训练的reward model 继续训练sft模型。

大部分采用ppo算法，利用rl算法。lamma2 还采用一个rejected sampling的方法。

rejected sampling，就是让sft模型对同一个prompt多次采样，然后用reward model打分，选取得分最高的一个作为choosen answer，然后继续训练sft模型。可以想到采样的样本越多，最高得分越高。

lamma2利用rejected sampling 方法训练了70b的模型，其他的小模型，都是用的70b的模型产生的数据训练的。

当迭代进行了4轮（reward model也在进行迭代，sft也在进行迭代）。在迭代过程中，合并之前的最好的样本，是一个对抗遗忘的有效的方法。

PPO算法是一种offline的policy gradient 的算法。

训练的主要流程是，收集一轮样本，然后训练，然后在收集，训练。训练的主要思想是利用拒绝采样的方式，用上一轮的reward（或者整体advantage）乘上当前概率与之前的概率的比值。

优化的目的是最大化收益，收益的计算公式：

训练细节：adamW和前面的一样，采用固定的learning rate（10-6），For each PPO iteration we use a batch size of 512, a PPO clip threshold of 0.2, a mini-batch size of 64, and take one gradient step per mini-batch.

PPO算法细节：

ppo一般要有4个模型，reference model，actor model，critic model， reward model，其中，ref model 和 actor model都是从sft 模型中初始化来的，critic 和reward都是基于reward model。

第一步是收集样本，对一个prompt，actor model generate seq，得到logits，reference model 针对seq，得到ref_logit，reward model和critic model 得到reward_score，和value。 收集大概512个样本。

第二步：基于上述获得的样本进行训练

计算reward，将reward score 和 kl 结合在一起，这里是把reward score 加在了最后一个token的kl得分上了。计算advantage，是一个td error，在计算第i个token的advantage时，delta=reward[i] - v[i] + gama * v[i+1]，这里还要计算lastgaelam=delta + lamda * gama*lastgaelam。v[i]就是预测从i到最后的一个token的平均收益。advantage就是将lastgaelam append起来。另外为了计算critic model的loss，returns=advantage + value可以看做下一步critic model的迭代label。actor model重新计算seq的new_logit，然后和样本的logits的比值，乘以advange，然后再做一些clip，(new_logit-logits)*advantage，critic model重新计new_value，mse（returns - new_value）.为了缓解遗忘，可以在ppo算法迭代的过程中，加入unsupervised training。

SFT和RLHF的比较

SFT的训练很重要，这一点已经在LLaMA Eval中得到验证

Vicuna-33B没有进行Human Preference，但其表现却与SFT+RLHF的LLaMA-34B相差无几

SFT训练的瓶颈在于，高质量的Response难以生成；而preference的数据标注相对容易，因此实际应用中更多的注意力被放在了preference modeling上

RLHF优点是通过reward泛化能学到深层次的逻辑，而不只是浅层的alignment，避免shortcuts learning

SFT的训练必须循序渐进，如果刚开始就训练超出模型能力的数据，模型很可能就是走捷径，而不是学会推理。但如果SFT的训练数据多而且不复杂的情况下，模型也是能学会模型内在的逻辑，挑战在于数据质量和标注的成本，需要大量的人力来进行数据标注模型应该是在 pretrain 的过程中学习知识，finetune的目的则是教给模型 2 个事情，1. 不知道，2.不要编。在标注人员在标注数据的时候，应该根据模型的能力，标注数据哪些是模型知道的，哪些是模型不知道的，需要有这个边界，在sft的过程中强化这个边界。对每个模型找出这个边界是很难的，导致标注难度比较较大。

RLHF也更支持能力泛化，处理out of distribution cases

比如支持新api调用

但RLHF存在Reward Gaining & Back Assignment的问题

设计合理的reward机制很困难，RLHF需要在回答生成完毕后再back assign reward / credit，但如果context window扩展到2k, 4k, 8k，上千个step的 reward assignment的质量有待确认，（输入一整个句子，然后输出整个句子的hidden states，最后过v_head.）SFT优势是每个token都会有个reward，适合长context输入

有效的训练方式是先SFT再RLHF

SFT后模型达到不错水平，能够继续根据RL强化如果一开始的Policy非常糟糕，那么提高到较高水平可能需要很长时间，甚至可能永远无法达到自从PPO以后收敛性已经达到了不错水平，但是和SFT相比平稳性、收敛等还是存在一定差距

其他训练细节

sft阶段怎样避免遗忘

一般在sft阶段，也要进行unsupervised训练。

怎样缓解幻觉问题

对事实性比较强的文本进行上采样，比如Wikipedia数据。另外，可以教模型如果不太清楚某个问题，可以拒绝回答。假如我们有一个knowledge base，我们可以从中抽取一些三元组（spo），然后基于s和p拼写一些问题，输入到模型，检查模型生成的答案里是不是包含o，如果没有包含，则模型很有可能出现了幻觉，这时候我们就找到了一个模型出现的幻觉的问题，这个时候，我们可以改写答案比如，这个问题，我不太清楚，不能回答等等。

另外，在推理的时候，我们可以写一些prompt，要求模型先给出分析过程，然后再给回答，这样也能缓解一些幻觉。

怎么解决loss spike问题，记录历史的checkpoint，以及step，如果训练crash了，找出crash时正在进行训练的数据，再往前推个200个step，把这些数据删掉。从最近的数据中训练，learning rate 还是lr schedule 也要成checkpoint所在的状态。数据课程表，也对训练过程有利，一般是先训练简单的数据，逐渐训练较难的数据，模型能比较容易训练。比如要训练模型写代码的能力，先用通用数据训练，然后用代码数据，训练效果比混合训练更好。另外，在预训练中不只采用ppl，而是采用顿悟时长，可能也是一个可以参考的指标

分布式训练、加速

模型训练时的显存占用：

假设模型参数量是sita，adamw：8sita，gradient: 2sita，原始的参数，4sita，另外，还要存一分bf16的参数。总的是16sita

推理时的内存占用：只需要一个fp16的param，2*sita

Deep speed（Zero）：

Zero是一种数据并行的方法，采用的ring all reduce方式。

传统的parameter server是server和client的方式，client通过计算分配给自己的数据，产生梯度，传给server，server做聚合，然后把聚合后的参数再传给client，这个方式的弊端是server容易成为瓶颈，server通信量太大。另外可能一个client失败，会导致其他client等待。

Ring allreduce是一种分布式的方式，各个节点分配通信量。总的通信量和ps没啥变化，但是通信的压力平摊到各个GPU上了，GPU之间的通信可以并行进行。

假如，GPU数量是N，把模型参数分成N份，每个GPU要存放整个参数。每个GPU也要分配训练数据。当一次迭代，N个GPU之间要经过一个scatter和gather操作，reduce-scatter是将不同gpu上对应的参数的gradient相加，一共需要通讯（N-1）次。 All-gather 是将合并完整的参数，传到其他gpu上，需要通讯(n-1）次。一次allreduce，单卡通信量为2*sita

Zero包括3种方案，逐步递进：

zero1：将adam的参数分割成N份，这样一个GPU上只能保存一份adam参数：这对于forward没啥影响，gradient需要进行一次all-reduce，但是只能更新一部分参数，所以W需要进行一次all-gather，通信量为3Nsita，存储为 12sita/N + 4sita

zero2: 将adamw，gradient都分割成N份，梯度就不需要all-gather了，只需要scatter了，w需要all-gather，通讯量为2Nsita

zero3: 将参数，adam 和gradient都分割，forward的时候，需要将w all-gather，backfoward时，还需要把w all-gather回来，计算梯度，丢掉不属于自己的w，然后对梯度做reduce scatter，更新w，通讯量为3N*sita

最后采用采用stage3：用1.5倍的通讯开销，换回近120倍的显存

另外，还有ZeRO-Offload是基于Zero2，将adam和gradient放到内存中，在cpu内起了N个线程计算。

其中的一条主线是gradient总是需要scatter的，感觉这个数据并行标志。这里需要注意一点 不管是forward 还是backward，都是需要有完整的w的。另外有了gradient，以及adamW的参数，才能更新W。

速度方面（左边比右边快）

阶段 0 (DDP) > 阶段 1 > 阶段 2 > 阶段 2 + 卸载 > 阶段 3 > 阶段 3 + 卸载

GPU 内存使用情况（右侧的 GPU 内存效率高于左侧）

阶段 0 (DDP) < 阶段 1 < 阶段 2 < 阶段 2 + 卸载 < 阶段 3 < 阶段 3 + 卸载

因此，当您想要在适应最少数量的 GPU 的同时获得最快的执行速度时，您可以遵循以下流程。我们从最快的方法开始，如果遇到 GPU OOM，我们就会转向下一个较慢的方法，但会使用更少的 GPU 内存。

首先将批量大小设置为 1（您始终可以使用梯度累积来获得任何所需的有效批量大小）。

启用--gradient_checkpointing 1（HF Trainer）或直接model.gradient_checkpointing_enable()如果 OOM 那么

首先尝试 ZeRO 第 2 阶段。如果 OOM 那么

尝试 ZeRO 阶段 2 + offload_optimizer如果 OOM 那么

切换到 ZeRO 阶段 3 - 如果 OOM 那么

启用offload_param-cpu如果 OOM 那么

启用offload_optimizer-cpu

\2. 除了数据并行，另外还有pipeline并行，和tensor 并行。

pipeline并行一般是将模型按层分割放在不同的GPU上，感觉这里pipeline并行和stage3有冲突，需要查证一下两个是否可以共存。pipeline一般包括两个要点：1. Mirco batch，用于减少时间bubble，和cpu的流水线类似。2. activation checkpoint，在计算gradient的时候，需要几点需要激活值，之前的做法是从头开始计算，是时间换空间，现在的主流做法是在中间的某些层，保留activation，后续的计算可以基于这个值进行计算。

Tensor 并行：

主要专注于矩阵乘法，将矩阵按行分割按列分割，不同的分割方式，后续的聚合方式也不相同。后续的backward也不同。transformer主要关注attention，multihead attention以及mlp

对于mlp层，B(act(A(x))) 一般是A是按列分割，B按行分割。

attention，对三个参数矩阵Q，K，V，按照“列切割”，每个头放到一块GPU上，做并行计算。对线性层B，按照“行切割”。

\2. Lora

虽然模型的参数众多，但其实模型主要依赖低秩维度，类比一下，似乎adaption好使的本质也依赖于此，所以提出了Low-Rank Adaptation (LoRA)。在训练时，由于矩阵的内在低秩性，可以将一个大矩阵MN，分为Mk K*N两个矩阵相乘的形式，可以极大的减少计算训练量，在计算时，作为一个旁路，只训练这个矩阵，在forward的时候两者都过，但是在backward的时候，只训练lora部分。

LoRA的思想也很简单，在原始PLM旁边增加一个旁路，做一个降维再升维的操作，来模拟所谓的 intrinsic rank 。训练的时候固定PLM的参数，只训练降维矩阵A与升维矩阵B。而模型的输入输出维度不变，输出时将BA与PLM的参数叠加。用随机高斯分布初始化A，用0矩阵初始化B，保证训练的开始此旁路矩阵依然是0矩阵。

用随机高斯分布初始化A，B设为0，先降维再升维，输入一样，输出相加。只针对linear层进行适配。

return F.linear( input, self.weight, self.bias) + (self.lora_dropout(input) @ self.lora_right_weight @ self.lora_left_weight) * self.lora_scaling

训练完成后lora部分可以和PLM单独存放，在推理的时候，将两者融合，推理结束还可以分离。

\3. Flash Attention

Flash attention是用来减少访问HBM，提升训练推理的速度，且对外是无感知的。

标准Attention的中间结果S，P通常需要通过高带宽内存（HBM）进行存取，两者所需内存空间复杂度为NN。

GPU中存储单元主要有HBM和SRAM：HBM容量大但是访问速度慢，SRAM容量小却有着较高的访问速度。例如：A100 GPU有40-80GB的HBM，带宽为1.5-2.0TB/s；每108个流式多核处理器各有192KB的片上SRAM，带宽估计约为19TB/s。可以看出，片上的SRAM比HBM快一个数量级，但尺寸要小许多数量级。

另外也能一定程度上缓解显存OOM，核心的思想是分块载入RAM，分别进行计算。难点在于解决softmax，由于softmax是要依赖整个一个行sum，需要聚合分块。在计算softmax时，假如x=[1,3,2,4],分成2块，第一块[1,3]，取最大值3，[-2, 0],第二块[2,4]，最大值为4，[-2, 0]，聚合最大值[3,4]，为4，[-3，-1，-2， 0]。

伪代码如下：

包括内外两层循环，外层循环是K，V分块，j，内层循环是Q分块。

外推

之所以要做外推，由于在训练的复杂度是seq_len的平方关系，所以在训练的时候，seq_len一般不会太大。而推理的时候，往往有长推理寻求，由于一些位置编码在训练时没见过，会导致推理的性能下降。常见的外推方式有rope，alibi等。

出发点就是“通过绝对位置编码的方式实现相对位置编码”，这样做既有理论上的优雅之处，也有实践上的实用之处，比如它可以拓展到线性Attention中就是主要因为这一点。

alibi：在QK之后加上一个矩阵，该矩阵是由qk的相对位置和一个归一化的数字得到。

对于n个head的话，m的取值就是2^-8/n

另外，为了解决外推问题：还有一些方法，比如window attention，取一个固定的窗口，只计算窗口内的注意力。这个可以作为一个base line，由于自然语言的局部性，这种性能还可以。

还有一种叫做streaming llm，通过观测发现，在attention score的分布中，在开头的几个attention score比较大，起到了attention sink的作用，而且intial tokens与被预测token的距离如何，语义信息如何都不重要，重要的只是它的绝对位置。也就是说前几个位置上的token不管是啥，对维持LLMs推理的稳定性都很关键。如果在推理的时候，用开头的几个attention score 再加上local window的attention，应该能很好的表示。

至于为啥会出现attention sink，SoftMax函数的性质使得所有经过attention结构的激活张量不能全部为零，虽然有些位置其实不需要给啥注意力。因此，模型倾向于将不必要的注意力值转嫁给特定的token，作者发现就是initial tokens。

KV Cache

Kv cache是为了节省计算时间，空间换时间，在一个seq的推理时，在推理第i个token时，其实i-1个k，v都缓存起来了，在计算本token时，将本次计算的k,v与缓存的拼接起来。计算attention，并缓存拼接之后的kv。

所以kv cache，input ids只能输入最后一个。

应用

一般包括prompt技术，思维链是其代表，还有一些更上层的应用，比如agent。

思维链

prompt技术，怎么更好的发挥LLM的作用，思维链，思维树等技术。所谓思维链：思维链提示，就是把一个多步骤推理问题，分解成很多个中间步骤，分配给更多的计算量，把一个多步的推理，分解成多个中间步骤，分配更多的计算量。包括few shot cot和零样本思维链（Let’s think step by step 或者take a deep breath）。

自洽性 self-consistent：对同一个问题，多次generate，采用topk的方式，temperature和k的个数影响最后的结果。

Least to most prompt：与思维链提示过程类似，需要解决的问题被分解成一组建立在彼此之上的子问题。在第二步中，这些子问题被逐个解决。与思维链不同的是，先前子问题的解决方案被输入到提示中，以尝试解决下一个问题。

思维链一般是在模型规模比较大的时候才有效，

小型模型没有足够的参数来记忆这些世界知识，所以也不太可能产生正确的推理步骤。

思维链在推理任务上有作用，在机器翻译的提升还有待评估。

思维树，可以认为是思维链的扩展，假设问题解决可以划分为多个步骤，每个步骤都可以产生多个解法，这种形式，自然而然就是个树的形式，在一个节点生成子节点时，往往会加上其兄弟地点的内容，然后提示说之前的都不太有效，请生成一个新的，这样就能尽量保证每个节点的差异性。

RAG（retrieve augument Generation）

检索增强的生成策略，感觉这种策略是比较好的额解决幻觉问题的（还能解决知识过时的问题，数据隐私的问题），是一种知识和能力（推理能力，文本摘要生成等）分离比较好的方式。

一般是通过检索系统，搜出和query比较相关的文档，然后将文档以prompt的形式输入大模型，让大模型基于prompt + query生成答案。一般要提示模型要按照所给的材料，不要随意发挥。

检索能力以及文章的分块方式是很关键的因素，一般采用向量检索+文本检索混合的方式，BGE+es，或者传统的entity linking方式。融合方式可以采用排名的倒数相加的方式。

文档的分块，为了便于大模型的信息整合，原则是尽可能把文档分成语义独立的块，这块研究的比较少，一般会按长度切分，和前一个文档会保留一部分重合。也有用符号分割的（\n\n，.等）

LangChain里的multivector retrieval，将这个rag玩出了花，大致的步骤如下：

将文档分块，（large chunks），存在数据库中，格式为(uuid, chunk content)将每个大块文档分成多个小块文档，（small chunk），分别计算embedding，存在向量数据库中（embedding， uuid）uuid就是大块文档的id对每个大块文档做summary，然后对summary做embedding，（embedding， uuid）用每个大块文档生成一些问题（query_hypothetical），分别做embedding，（embedding， uuid）对原始的query，做改写，生成多个意思相似的query。分别检索上述的向量数据库，然后做聚合，排序 sigam（1/(k+r(d))）。反查large doc，输入到大模型。生成回答。

Agent

智能体，能够完成一个特定任务的机器人。有代表性的agent是small valley，里面有25个虚拟人，虚拟人每个人有自己的profile，系统会根据每个人的profile以及history，利用大模型+思维链的方式生成虚拟人每天的活动。里面也集成了rag技术，比如遇到某个人（会拿到某个人的name）首先检索关于这个人的信息，然后基于这些信息才产生要说话的话。

memory是核心组件，按行记录事件，一个时间戳，一段自然语言描述。在检索的时候，一般要考虑时间的重要性，相关性，以及最近性，时效性：每小时衰减指数为0.995。重要性是通过LLM给出的打分。相关性通过计算embedding的相似度（感觉是embedding自己的近况）。

另外还需要反思，反思是通过规则触发的，每存储100条记忆，或者记忆时间的重要性大于某个阈值的时候就会触发反思，问大模型“Given only the information above, what are 3 most salient highlevel questions we can answer about the subjects in the statements?”，得到三个问题，然后针对每个问题，检索相关的记忆。然后再将这些记忆加相关的prompt输入LLM，让大模型总结出几个insight（insight+证据编号）。

对话是建立在彼此的记忆上进行的，每次对话，都会成为记忆，和其他记忆（或者summary）一起triger下一次的对话。

那么，如何系统的去学习大模型LLM？

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

作为一名热心肠的互联网老兵，我意识到有很多经验和知识值得分享给大家，也可以通过我们的能力和经验解答大家在人工智能学习中的很多困惑，所以在工作繁忙的情况下还是坚持各种整理和分享。

但苦于知识传播途径有限，很多互联网行业朋友无法获得正确的资料得到学习提升，故此将并将重要的AI大模型资料包括AI大模型入门学习思维导图、精品AI大模型学习书籍手册、视频教程、实战学习等录播视频免费分享出来。

所有资料 ⚡️ ，朋友们如果有需要全套 《LLM大模型入门+进阶学习资源包》，扫码获取~

篇幅有限，部分资料如下：

👉LLM大模型学习指南+路线汇总👈

💥大模型入门要点，扫盲必看！

💥既然要系统的学习大模型，那么学习路线是必不可少的，这份路线能帮助你快速梳理知识，形成自己的体系。

路线图很大就不一一展示了 （文末领取）

👉大模型入门实战训练👈

💥光学理论是没用的，要学会跟着一起做，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。

👉国内企业大模型落地应用案例👈

💥两本《中国大模型落地应用案例集》 收录了近两年151个优秀的大模型落地应用案例，这些案例覆盖了金融、医疗、教育、交通、制造等众多领域，无论是对于大模型技术的研究者，还是对于希望了解大模型技术在实际业务中如何应用的业内人士，都具有很高的参考价值。 （文末领取）

👉GitHub海量高星开源项目👈

💥收集整理了海量的开源项目，地址、代码、文档等等全都下载共享给大家一起学习！

👉LLM大模型学习视频👈

💥观看零基础学习书籍和视频，看书籍和视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。 （文末领取）

👉640份大模型行业报告（持续更新）👈

💥包含640份报告的合集，涵盖了AI大模型的理论研究、技术实现、行业应用等多个方面。无论您是科研人员、工程师，还是对AI大模型感兴趣的爱好者，这套报告合集都将为您提供宝贵的信息和启示。

👉获取方式：

这份完整版的大模型 LLM 学习资料已经上传CSDN，朋友们如果需要可以微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】

😝有需要的小伙伴，可以Vx扫描下方二维码免费领取🆓