专注合肥网站推广,电力建设期刊网站,wordpress rewrite iis,计算机包含哪些专业系列文章目录
这个系列攒了很久。主要是前段之间面试大语言模型方面的实习#xff08;被拷打太多次了#xff09;#xff0c;然后每天根据面试官的问题进行扩展和补充的这个笔记。内容来源主要来自视频、个人理解以及官方文档中的记录。方便后面的回顾。 文章目录 系列文章…系列文章目录
这个系列攒了很久。主要是前段之间面试大语言模型方面的实习被拷打太多次了然后每天根据面试官的问题进行扩展和补充的这个笔记。内容来源主要来自视频、个人理解以及官方文档中的记录。方便后面的回顾。 文章目录 系列文章目录1 基本知识1. 1 归一化1层归一化LN2批量归一化BN3均方根归一化RMSNorm 4DeepNorm1.2 归一化的位置1Post-Normtransformer2Pre-Norm3Sandwish-Norm参考资料 1.3 激活函数1ReLUTransformerRectified Linear Unit2Swish/silu激活函数和GELU激活函数 (Gaussian Error Linear Unit)3GLU激活函数Gated Linear Units4swiGLU激活函数llama5tanh 激活函数 1.4 位置编码1.4.1 绝对位置编码Absolute Position Encoding1正余弦位置编码 Transformer2可学习的嵌入表示BERT 1.4.2 相对位置编码Relative Position Encoding1旋转位置编码Rotary Position Encoding 1.5 注意力机制代码1基本python函数2注意力机制代码3多头注意力机制 2 Transformer2.1 介绍2.2 模型结构(1) 输入部分(2) 输出部分 3 llama系列3.1 llama13.2 llama23.3 llama33.4 PPO的概念3.5 llama3.13.6 KV Cache3.7 Group query attention3.8 reward model 4 分布式基础知识4.1 进程线程和协程4.2 DP 和 DDP(1) DP的定义(2) DP 和 DDP 的区别(3) DDP 的代码 4.3 DeepSeed zero 5 微调5.1 Lora1 为什么叫低秩矩阵2 lora的优点3 方法4代码 1 基本知识
1. 1 归一化
1层归一化LN 计算均值 $\mu \frac{1}{d} \sum_{i1}^{d} x_i $ 计算方差 $\sigma^2 \frac{1}{d} \sum_{i1}^{d} (x_i - \mu)^2 $ 归一化 $ \mathbf{\hat{x}} \left[ \frac{x_1 - \mu}{\sqrt{\sigma^2 \epsilon}}, \frac{x_2 - \mu}{\sqrt{\sigma^2 \epsilon}}, \ldots, \frac{x_d - \mu}{\sqrt{\sigma^2 \epsilon}} \right] $ 其中 ϵ \epsilon ϵ 是一个很小的正数例如 1 0 − 5 10^{-5} 10−5用于防止除以零的情况发生。 缩放和平移 $\mathbf{y} \gamma \mathbf{\hat{x}} \beta $ 这里 γ \gamma γ 和 β \beta β 是可学习的参数通常初始化为 γ 1 \gamma 1 γ1 和 β 0 \beta 0 β0。
2批量归一化BN 批量归一化与层归一化不同批量归一化是在每个小批量上进行归一化 假设有一个小批量数据 X x 1 , x 2 , … , x m \mathbf{X} { \mathbf{x}_1, \mathbf{x}_2, \ldots, \mathbf{x}_m } Xx1,x2,…,xm其中 x i ∈ R d \mathbf{x}_i \in \mathbb{R}^d xi∈Rd 表示第 i i i 个样本的特征向量 m m m 是小批量的大小 d d d 是特征的维度。然后分别对每个批量的每个特征向量进行归一化。 计算均值 $\mu_b \frac{1}{m} \sum_{i1}^{m} \mathbf{x}_i $ 计算方差 $\sigma^2_b \frac{1}{m} \sum_{i1}^{m} (\mathbf{x}_i - \mu_b)^2 $ 归一化 $\mathbf{\hat{x}}_i \frac{\mathbf{x}_i - \mu_b}{\sqrt{\sigma^2_b \epsilon}} $ 缩放和平移 $\mathbf{y}_i \gamma_i \mathbf{\hat{x}}_i \beta_i $其中 γ i \gamma_i γi 和 β i \beta_i βi 是可学习的参数通常初始化为 γ i 1 \gamma_i 1 γi1 和 β i 0 \beta_i 0 βi0。
3均方根归一化RMSNorm
计算RMS: 1 d ∑ i 1 d x i 2 \sqrt{\frac{1}{d} \sum_{i1}^{d} x_i^2} d1∑i1dxi2 归一化 $\mathbf{\hat{x}} \frac{x}{RMS(x)} $优点 对数据进行归一化使得数据具有统一的分布便于模型训练。不需要计算均值和方差可以减少计算量。缺点对数据进行归一化可能会导致梯度消失或爆炸。
4DeepNorm
基于LN在残差块中将输入和输出进行归一化以保持梯度不消失或爆炸。公式 D e e p N o r m ( x ) L N ( γ ∗ x s u b l a y e r ( x ) ) DeepNorm(x)LN(\gamma*xsublayer(x)) DeepNorm(x)LN(γ∗xsublayer(x))其中 γ \gamma γ 是可学习参数sublayer() 是其注意力或前馈神经网络的子层。优点结合了Post-LN的良好性能和Pre-LN的训练稳定性。
1.2 归一化的位置
1Post-Normtransformer
作用
加快收敛速度降低对初始超参数的敏感性为什么通过层归一化可以消除不同层之间由于权重尺度变化带来的影响。这意味着即使某些超参数设置得不是最佳网络仍然能够更好地应对这些变化因为层归一化提供了一种机制来自动调整输入的尺度。具有不稳定性一般搭配其他策略例如DeepNorm
2Pre-Norm
作用
减少梯度消失和爆炸保持训练的稳定性例如 LLama收敛慢性能低于Post-Norm
3Sandwish-Norm
公式 $\mathbf{y} x Norm(Sublayer(Norm(x))) $理论上应该具有更加灵活的表达能力但是对于大语言模型来说甚至会引发训练崩溃的问题。
参考资料
论文《On Layer Normalization in the Transformer Architecture》对比了Pre—Nore和Post-Norm。https://zhuanlan.zhihu.com/p/480783670
1.3 激活函数
1ReLUTransformerRectified Linear Unit
公式ReLU(x)max(0,x)缺点被设置为0的学不到任何信息导致神经元失活
2Swish/silu激活函数和GELU激活函数 (Gaussian Error Linear Unit)
公式 S w i s h ( x ) x ∗ s i g m o i d ( x ) Swish(x)x*sigmoid(x) Swish(x)x∗sigmoid(x)GELU利用标准高斯积累分布函数作为激活函数 G E L U ( x ) 0.5 ∗ x ∗ ( 1 e r f ( x / ( 2 ) ) ) GELU(x)0.5*x*(1erf(x/\sqrt(2))) GELU(x)0.5∗x∗(1erf(x/( 2))), e r f ( x ) 2 π ∫ 0 x e − t 2 d t erf(x)\frac{2}{\sqrt{\pi}} \int_0^x e^{-t^2} dt erf(x)π 2∫0xe−t2dt这些激活函数可以带来更好的性能并且收敛性更好但是计算过程更为复杂。
3GLU激活函数Gated Linear Units
引入两个不同的线性层其中一个线性层的输入被输入到激活函数中然后将其结果和另一个线性层的输出进行元素相乘得到最终的输出。可以带来更高的提升。
4swiGLU激活函数llama
第一个线性层的输出被输入到swih激活函数中然后和第二个线性层的输出进行逐元素相乘 self.w1,self.w2和self.w3都是线性层。
5tanh 激活函数 函数公式$ tanh(x)\frac{ex-e{-x}}{exe{-x}} $ 缺点过大或过小导致梯度消失指数运算和指数函数的计算开销大输出范围在-1到1之间可能会限制神经网络的表达能力。 优点 零中心性质tanh函数的输出范围在-1到1之间具有零中心性质即均值为0这有助于减少梯度消失问题使得神经网络的训练更加稳定和快速。非线性特性tanh函数是一种非线性函数引入了非线性变换使得神经网络能够学习和表示更复杂的非线性函数关系。平滑性tanh函数是光滑且连续的在整个定义域上都具有可导性这对于基于梯度的优化方法如梯度下降非常重要。加速神经网络训练。
1.4 位置编码
1.4.1 绝对位置编码Absolute Position Encoding
绝对位置编码基于绝对位置信息每个位置都对应一个唯一的向量用于表示该位置在序列中的位置信息。只能局限于样本中见过的位置但是建模训练中未见过的位置。限制了长文本的能力。
1正余弦位置编码 Transformer
在Transformer模型中正余弦位置编码的计算公式如下 对于位置 ( pos ) 和维度 ( i )位置编码 ( PE(pos, i) ) 定义为 $PE(pos, 2k) sin\left(\frac{pos}{10000^{2k/d}}\right) $ $PE(pos, 2k1) cos\left(\frac{pos}{10000^{2k/d}}\right) $ pos表示位置索引k表示维度索引。 x i x P E ( p o s , i ) x_ixPE(pos, i) xixPE(pos,i)其中d和embedding的维度是一样的。那么模型最长只能为d超过长度的需要截断。这种编码方式能够为每个位置生成一个唯一的向量并且相邻位置之间的向量差异较小随着位置间隔增大向量差异也逐渐增大。
2可学习的嵌入表示BERT
1.4.2 相对位置编码Relative Position Encoding
相对位置编码是根据键和查询之间的偏移量计算得来的。旋转位置编码通过将位置编码旋转一定角度来模拟位置编码的相对位置信息。注意力机制公式 A t t e n t i o n ( Q , K , V ) s o f t m a x ( Q K T d ) V Attention(Q, K, V)softmax(\frac{QK^T}{\sqrt{d}})V Attention(Q,K,V)softmax(d QKT)V Q W Q ∗ X , K W K ∗ X , V W V ∗ X QW_Q*X, KW_K*X, VW_V*X QWQ∗X,KWK∗X,VWV∗X,如果没有W_Q,W_K,W_V那么就是绝对位置编码。但是如果字的顺序不一样的话字级别的embedding还是一样的。因此需要一个位置信息将其融合进去。
1旋转位置编码Rotary Position Encoding 推导公式 代码
def precompute_freqs_cis(dim: int, seq_len: int, theta: float 10000.0):# 计算词向量元素两两分组之后每组元素对应的旋转角度freqs 1.0 / (theta ** (torch.arange(0, dim, 2)[: (dim // 2)].float() / dim))# 生成 token 序列索引 t [0, 1,..., seq_len-1]t torch.arange(seq_len, devicefreqs.device)# freqs.shape [seq_len, dim // 2] freqs torch.outer(t, freqs).float()# torch.polar 的文档# https://pytorch.org/docs/stable/generated/torch.polar.html# 计算结果是个复数向量# 假设 freqs [x, y]# 则 freqs_cis [cos(x) sin(x)i, cos(y) sin(y)i]freqs_cis torch.polar(torch.ones_like(freqs), freqs)return freqs_cisdef apply_rotary_emb(xq: torch.Tensor,xk: torch.Tensor,freqs_cis: torch.Tensor,
) - Tuple[torch.Tensor, torch.Tensor]:# xq.shape [batch_size, seq_len, dim]# xq_.shape [batch_size, seq_len, dim // 2, 2]xq_ xq.float().reshape(*xq.shape[:-1], -1, 2)xk_ xk.float().reshape(*xk.shape[:-1], -1, 2)# 转为复数域xq_ torch.view_as_complex(xq_)xk_ torch.view_as_complex(xk_)# 应用旋转操作然后将结果转回实数域# xq_out.shape [batch_size, seq_len, dim]xq_out torch.view_as_real(xq_ * freqs_cis).flatten(2)xk_out torch.view_as_real(xk_ * freqs_cis).flatten(2)return xq_out.type_as(xq), xk_out.type_as(xk)class Attention(nn.Module):def __init__(self, args: ModelArgs):super().__init__()self.wq Linear(...)self.wk Linear(...)self.wv Linear(...)self.freqs_cis precompute_freqs_cis(dim, max_seq_len * 2)def forward(self, x: torch.Tensor):bsz, seqlen, _ x.shapexq, xk, xv self.wq(x), self.wk(x), self.wv(x)xq xq.view(batch_size, seq_len, dim)xk xk.view(batch_size, seq_len, dim)xv xv.view(batch_size, seq_len, dim)# attention 操作之前应用旋转位置编码xq, xk apply_rotary_emb(xq, xk, freqs_cisfreqs_cis)# scores.shape (bs, seqlen, seqlen)scores torch.matmul(xq, xk.transpose(1, 2)) / math.sqrt(dim)scores F.softmax(scores.float(), dim-1)output torch.matmul(scores, xv) # (batch_size, seq_len, dim)# ......1.5 注意力机制代码
1基本python函数
unsqueeze:在某个维度上添加张量
repeat/expend对某个维度的列进行复制
resheap对矩阵的维度进行重组2注意力机制代码
import torch
from torch import nn
import math
class self_attention1(nn.Module):def __init__(self,hidden_demision):super().__init__()self.hidden_demisionhidden_demisionself.qnn.Linear(hidden_demision,hidden_demision)self.knn.Linear(hidden_demision,hidden_demision)self.vnn.Linear(hidden_demision,hidden_demision)self.softmaxnn.Softmax(dim-1)def forward(self,X):# Xbatch*seq_len*hidden_demision# Q: batch*seq_len*hidden_demisionQself.q(X)Kself.k(X)Vself.v(X)# batch*seq_len*seq_lenattention_value(QK.transpose(-1,-2)) / math.sqrt(self.hidden_demision) #转置# batch*seq_len*hidden_demisionoutputself.softmax(attention_value) V return output输出结果
优化版本
import torch
from torch import nn
import math
class self_attention1(nn.Module):def __init__(self,hidden_demision):super().__init__()self.hidden_demisionhidden_demisionself.qkvnn.Linear(hidden_demision,hidden_demision*3)self.softmaxnn.Softmax(dim-1)def forward(self,X):# Xbatch*seq_len*hidden_demision# Q: batch*seq_len*hidden_demisionQ,K,Vtorch.split(self.qkv(X),self.hidden_demision,dim-1)# batch*seq_len*seq_lenattention_value(QK.transpose(-1,-2)) / math.sqrt(self.hidden_demision) #转置# batch*seq_len*hidden_demisionoutputself.softmax(attention_value) V return output# 完整版 mask_attention
import torch
from torch import nn
import math
class self_attention3(nn.Module):def __init__(self,hidden_demision):super().__init__()self.hidden_demisionhidden_demisionself.qnn.Linear(hidden_demision,hidden_demision)self.knn.Linear(hidden_demision,hidden_demision)self.vnn.Linear(hidden_demision,hidden_demision)self.attention_dropoutnn.Dropout(0.1)self.softmaxnn.Softmax(dim-1)def forward(self,X,mask_attentionNone):# Xbatch*seq_len*hidden_demision# Q: batch*seq_len*hidden_demisionQself.q(X)Kself.k(X)Vself.v(X)# batch*seq_len*seq_lenattention_value(QK.transpose(-1,-2)) / math.sqrt(self.hidden_demision) #转置if mask_attention is not None:attention_valueattention_value.masked_fill(mask_attention0,float(-1e20))print(attention_value:,attention_value)# batch*seq_len*hidden_demisionoutputself.softmax(attention_value) Vprint(not dopout_output:,self.softmax(attention_value))# 使得小于0的值的神经元可以被去除 outputself.attention_dropout(output)print(dopout_output:,output)return outputXtorch.rand([3,4,2])
mask_attentiontorch.tensor([[1,1,1,0],[1,1,0,0],[1,0,0,0]]
)mask_attention.size()3多头注意力机制
多头注意力机制是Transformer架构中的核心组件它允许模型同时关注多个位置的输入从而捕获更复杂的依赖关系。 import torch
from torch import nn
import math
class self_Multi_Head_Attention(nn.Module):def __init__(self,hidden_demision,head_num):super().__init__()self.hidden_demisionhidden_demisionself.head_dimhidden_demision//head_numself.head_numhead_numself.qnn.Linear(self.hidden_demision,self.hidden_demision)self.knn.Linear(self.hidden_demision,self.hidden_demision)self.vnn.Linear(self.hidden_demision,self.hidden_demision)self.attention_dropoutnn.Dropout(0.1)self.softmaxnn.Softmax(dim-1)def forward(self,X,mask_attentionNone):batch,seq_len,_X.size()# Xbatch*seq_len*hidden_demision# Q: batch*seq_len*hidden_demisionQself.q(X)Kself.k(X)Vself.v(X)# batch*head_num*seq_len*hidden_demisionq_stateQ.view(batch,seq_len,self.head_num,self.head_dim).transpose(1,2)k_stateK.view(batch,seq_len,self.head_num,self.head_dim).transpose(1,2)v_stateV.view(batch,seq_len,self.head_num,self.head_dim).transpose(1,2)# batch*head_num*seq_len*hidden_demisionattention_value(q_statek_state.transpose(-1,-2)) / math.sqrt(self.hidden_demision) #转置if mask_attention is not None:attention_valueattention_value.masked_fill(mask_attention0,float(-1e20))print(attention_value:,attention_value)# batch*head_num*seq_len*hidden_demisionoutputself.softmax(attention_value) v_stateprint(not dopout_output:,self.softmax(attention_value))# 使得小于0的值的神经元可以被去除 outputself.attention_dropout(output)print(dopout_output:,output)outputoutput.transpose(1,2).contiguous()outputoutput.view(batch,seq_len,self.hidden_demision)return outputXtorch.rand([3,4,128])
# mask_attentiontorch.tensor(
# [
# [1,1,1,0],
# [1,1,0,0],
# [1,0,0,0]
# ]
# )
X.size()
attentionself_Multi_Head_Attention(128,8)
outputattention.forward(X)2 Transformer
2.1 介绍
可以利用分布式GPU进行训练提升模型训练效率在分析预测更长文本时捕捉间隔较长的语义关联性更好
2.2 模型结构
(1) 输入部分
源文件和目标文件的词嵌入位置编码正余弦位置编码
(2) 输出部分
线性层softmax层
3 llama系列
3.1 llama1
关键词 ROPE旋转位置编码 pre-Norm RMS Norm wishGLU激活函数
3.2 llama2
llama 2中在较大的模型上使用了group 注意力机制。即将K和V进行分组同时对应一个Q进行计算。使用了更多的数据集微调阶段加入了100万人工标注的数据集llama chat出现使用模型输出不同的结果然后人工进行排序进行强化学习。上下文长度从2k扩充到了4kKV Cache在预测下一个token的时候kv中含有重复的计算。比如预测1-n个token的时候每预测一个tokenq中的每一个向量的所有数据都要和kv重新进行计算。因此可以将计算后的k和v进行存储。然后只选取第i个词的q然后将存储的k进行相加和q进行计算v也是一样。使用sentencePiece进行标记
3.3 llama3
使用三种并行化类型数据模型和流水线进行训练强化学习方法进行安全微调SFT拒绝采样PPODPO流程llama 3中所有的模型都用了分组注意力机制。上下文序列从4k到8ktoken数量从2t到15t使用Tikton及逆行标记
3.4 PPO的概念
一个是打分模型一个是奖励机制。此外还有一个基模型和经过基模型在进行强化后的模型打分模型即在模型的最后一层加一个全连接层size为hidden_dim*1流程首先对将数据输入到基模型中进行QA问答输出其答案然后将答案输入到评分模型中进行评分评分的结果通过人工进行纠正后输入到奖励机制中对比评分结果和评分模型的一致性从而对基模型进行纠正生成新的基模型。然后计算基模型和经过强化后基模型之间的KL 散度。
3.5 llama3.1 使用了更多的数据集 还是使用的dense transformer结果。区分MOE 支持更长的上下文序列其模型参数8b 70b和405b 语言方面支持八种多语言 148k上下文序列 增加了function call的功能。tool calling llama3.1 instruct 通过指令微调微调数据都是英文。因此对中文的效果并不是很好。
3.6 KV Cache
加速推理过程将之前的K和V存储起来作为KV chache。 将其作为一个矩阵开始初始化为0. 然后不断追加新的值。
初始化过程 计算过程 3.7 Group query attention
#n_local_heads (int): Number of local query heads.
#n_local_kv_heads (int): Number of local key and value heads.
#n_rep (int): Number of repetitions for local heads
self.n_rep self.n_local_heads // self.n_local_kv_heads
# repeat k/v heads if n_kv_heads n_heads
keys repeat_kv(keys, self.n_rep) # (bs, cache_len seqlen, n_local_heads, head_dim)
values repeat_kv(values, self.n_rep) # (bs, cache_len seqlen, n_local_heads, head_dim)def repeat_kv(x: torch.Tensor, n_rep: int) - torch.Tensor:torch.repeat_interleave(x, dim2, repeatsn_rep)bs, slen, n_kv_heads, head_dim x.shapeif n_rep 1:return xreturn (x[:, :, :, None, :].expand(bs, slen, n_kv_heads, n_rep, head_dim).reshape(bs, slen, n_kv_heads * n_rep, head_dim))n_kv_head8
3.8 reward model
训练一个打分或者回归模型。 损失函数源自instructGPT ρ表示sigmoid函数即希望 y c h o s e n y_{chosen} ychosen和 y r e j e c t e d y_{rejected} yrejected的差距越大越好。 通过casual lm输出多个数据进行人工评估然后形成偏序对相对答案输入到reward model中进行训练。
4 分布式基础知识
4.1 进程线程和协程
进程操作系统分配资源的基本单位 线程操作系统调度的基本单元 内存角度来说进程分配了独立的虚拟地址空间。 通信角度线程的通信比较方便可以直接在堆上面进行通信。进程之间的通信需要IPC进程间通信 相关技术。 安全性来说如果线程挂了则进程挂了如果进程挂了其他进程不会受到影响因为虚拟地址空间是独立的。
进程适合CPU密集型任务。线程适合IO密集型任务。多进程中每个进程可以包含多线程。每一个线程共享进程中所有的内存。比如qq微信就是一个进程里面可以包含多个线程。在python中由于GILGlobal interpreter的存在会导致伪多线程。多个线程无法同时执行python字节码。导致多线程在CPU密集型任务中无法提高性能一般是在执行IO操作如文件读写、网格请求时线程会释放GIL。因此多进程的中的线程也是串行。
IO密集型任务主要是受限于IO操作的速度任务执行的时间主要取决于外部设备如磁盘、网络的响应速度。
需要频繁的磁盘读写、网络请求或其他外部设备交互CPU大部分时间处于等待状态等待IO操作完成。性能瓶颈在于IO设备的速度而非CPU
CPU密集型任务
主要效果CPU的计算资源任务的执行时间主要取决于CPU的运算速度需要大量的数学计算或数据处理任务中很少或者没有IO的读写操作性能瓶颈在于CPU 的处理能力 4.2 DP 和 DDP
官方文档https://pytorch.org/tutorials/intermediate/ddp_tutorial.html
(1) DP的定义
DistributedDataParallel (DDP) implements data parallelism at the module level which can run across multiple machines. Applications using DDP should spawn multiple processes and create a single DDP instance per process. DDP uses collective communications in the torch.distributed package to synchronize gradients and buffers. More specifically, DDP registers an autograd hook for each parameter given by model.parameters() and the hook will fire when the corresponding gradient is computed in the backward pass. Then DDP uses that signal to trigger gradient synchronization across processes. Please refer to DDP design note for more details一个数据假如是128个batchsize为24一共有8组数据。那么DDP可以在多个GPU中运行不同的数据组即创建了多个进程。主要实现过程是在分布式数据并行时DDP会在每个GPU 上对模型参数或优化器进行拷贝。然后通过HPChigh performance calculate算法或ring all-reduce 算法保持每个GPU 上的数据是一致的 多进程多线程 Ring-ALLReduce多个GPT,每个GPU有多个参数然后里面的参数可以互相传递分发和累计然后同步到一个GPU。同时发送和接收可以最大限度利用每个显卡的上下行带宽。
(2) DP 和 DDP 的区别 First, DataParallel is single-process, multi-thread, and only works on a single machine, while DistributedDataParallel is multi-process and works for both single- and multi- machine training. DataParallel is usually slower than DistributedDataParallel even on a single machine due to GIL contention across threads, per-iteration replicated model, and additional overhead introduced by scattering inputs and gathering outputs. DP 单进程多线程由于GIL锁其实还是串行的。DDP是多进程 Recall from the prior tutorial that if your model is too large to fit on a single GPU, you must use model parallel to split it across multiple GPUs. DistributedDataParallel works with model parallel; DataParallel does not at this time. When DDP is combined with model parallel, each DDP process would use model parallel, and all processes collectively would use data parallel. DDP可以进行模型的并行即每个进程中都有一个模型然后就可以将数据分别输入到模型中进行数据的并行。DP不能实现不同模型的并行 If your model needs to span multiple machines or if your use case does not fit into data parallelism paradigm, please see the RPC API for more generic distributed training support.
如果你需要内联多个机器或者数据并不符合并行的要求可以使用RPC
(3) DDP 的代码 参数解释 rank某个device中GPU的编号 localrank所有device的GPU编号 world_size: GPU的总数量 例子假如2个device每个device中有3个GPU rank[0,1,2,3,4,5] localrank[0,1,2] [0,1,2] world_size:2*36 优化 比如进程中断可以通过torchrun运行DDP。防止中断后需要重新训练。 4.3 DeepSeed zero
每个GPU只存储一份优化器状态消除冗余。每个GPU只存储部分网络状态然后在更新的时候将所需的参数传递给所需的GPU。
5 微调
5.1 Lora
代码https://github.com/microsoft/LoRA.
论文https://arxiv.org/pdf/2106.09685 机制LoRA 是在预训练模型的每一层中插入额外的低秩矩阵。LoRA 在训练时不需要保存原始参数的梯度仅需对低秩子空间参数进行优化即可。
1 为什么叫低秩矩阵
参考: https://blog.csdn.net/weixin_43332715/article/details/131177583
秩可以度量矩阵自身相关性。如果各行各列都是线性无关的矩阵就是满秩。如果矩阵之间各行的相关性很强那么就表示这个矩阵实际可以投影到更低维的线性子空间也就是用几个向量就可以完全表达了它就是低秩的。
2 lora的优点
即插即用节省资源no inference latency正交性
3 方法 参数解释
训练过程中w0的参数不更新A和B是学习的参数。A和B进行随机高斯初始化使得BA的乘机在开始训练的时候为0.
4代码
初始化可以对应到上面的公式。 输入参数 in_features/out_features: 输入输出维度。
r秩用于构造lora_B 和lora_A 的矩阵。
lora_alpha越高意味着对模型行为的调整越大值越低则相反 if r 0:self.lora_A nn.Parameter(self.weight.new_zeros((r, in_features)))self.lora_B nn.Parameter(self.weight.new_zeros((out_features, r)))self.scaling self.lora_alpha / self.r# Freezing the pre-trained weight matrixself.weight.requires_grad Falselora_alpha的作用
# 定义了一个 self.scalingself.scaling self.lora_alpha / self.r# 这里的T(self.lora_B self.lora_A)的结果是一个矩阵矩阵的维度是[in_featuresout_features]。
self.weight.data T(self.lora_B self.lora_A) * self.scaling# 这里的构造了一个新的线性层。result F.linear(x, T(self.weight), biasself.bias)
LoRA 的权重更新。首先self.lora_dropout(x) 应用了一个 dropout 层到输入 x这有助于防止过拟合。然后这个经过 dropout 处理的输入与两个 LoRA 矩阵 self.lora_A 和 self.lora_B 进行矩阵乘法运算。self.lora_A.transpose(0, 1) 和 self.lora_B.transpose(0, 1) 分别表示 LoRA 矩阵的转置这是为了确保矩阵乘法的维度匹配。最后结果乘以一个缩放因子 self.scaling这个因子用于控制 LoRA 更新的强度避免对原模型权重造成过大影响。值得注意的是self.weight.data 被冻结了因此上面的result 里面的参数并不会被更新。下面附加的lora模块继续进行参数更新。 result (self.lora_dropout(x) self.lora_A.transpose(0, 1) self.lora_B.transpose(0, 1)) * self.scaling
使用示例
假如PyTorch 模型或具有两个线性层的模块
在使用 LoRA 时通常会将 LoRA 更新添加到这些线性层的输出中又得到代码如下
部分图片来自视频截图侵权删。未完待续~
