最强英文开源模型LLaMA架构探秘,从原理到源码

news2024/12/21 14:58:17

导读:
LLaMA 65B是由Meta AI(原Facebook AI)发布并宣布开源的真正意义上的千亿级别大语言模型,发布之初(2023年2月24日)曾引起不小的轰动。LLaMA的横空出世,更像是模型大战中一个搅局者。虽然它的效果(performance)和GPT-4仍存在差距,但GPT-4毕竟是闭源的商业模型,LLaMA系列的开源给了世界上其他团队研究和使用千亿大语言模型的机会。

读完本文,你可能觉得LLaMA会开源并不令人惊讶,因为它的架构可以说是站在巨人肩膀上摘苹果——基本上可以说使用其他模型的组件作为“积木”搭了一个新模型出来,并没有太多实质意义上的创新,但这种敢于开源的勇气和做法使得LLaMA足以在大语言模型上的开源发展历程上成为一个标志性的里程碑

在这里插入图片描述Introducing LLaMA: A foundational, 65-billion-parameter large language model
LLaMA开源地址:https://github.com/facebookresearch/llama(llama在llama_v1代码分支上)

正文

llama英文中指大羊驼,是一种分布在南美洲的骆驼科羊驼属动物

在这里插入图片描述

LLaMA是一个基于transformer架构的大语言模型,同Google的PaLM一样,针对原始的transformer架构进行了一些“小改进”。整体而言,初版LLaMA的架构和原始transformer有3个大的差异点:

  • 前置归一化(Pre-Normalization)[受GPT3启发]:为了提升训练时的稳定性,LLaMA归一化了transformer子层的输入而不是输出,具体使用的正则化方法是RMSNorm
  • SwiGLU激活函数 [受PaLM启发]:LLaMA使用了和PaLM一样的SwiGLU激活函数来替代原始的ReLU以提升模型效果。细节上,LLaMA使用dimension为 2 3 4 d \frac{2}{3}4d 324d而不是 4 d 4d 4d
  • 旋转位置编码(Rotary Embedding, Rotary Position Embedding)[受GPTNeo启发]:LLaMA没有使用绝对位置编码(BERT的位置 s i n sin sin c o s cos cos编码是一种绝对位置编码),而是使用了相对位置编码RoPE

除此之外,一些训练上的细节:

  • LLaMA使用adamW优化器,设置超参数 β 1 = 0.9 \beta_1=0.9 β1=0.9 β 2 = 0.95 \beta_2=0.95 β2=0.95
  • 使用cosine学习率调度,即最终的学习率是最大学习率的10%
  • 权重衰减设置为0.1
  • 梯度剪枝设置为1
  • 2000步热启动(warmup)。
  • 不同尺寸的模型使用不同的学习率batch size

下面我们来深入了解一下架构上3个差异点的技术细节。

RMSNorm

详细推到过程见原论文:Root Mean Square Layer Normalization

前置归一化(Pre-Normalization)可以使得训练过程更加稳定,这种设计将第一层的归一化设在多头注意力层之前,第二层的归一化移动到全连接层之前,同时将shortcut设置在multi-attention层与FNN层之间。如下如所示:
在这里插入图片描述
LLaMA在归一化过程中使用RMSNorm,针对输入向量 a a a,RMSNorm的计算公式如下:
R M S ( a ) = 1 n ∑ i = 1 n a i 2 RMS(a)=\sqrt{\frac{1}{n}\sum_{i=1}^{n}}a_i^2 RMS(a)=n1i=1n ai2
a i ˉ = a i R M S ( a ) \bar{a_i}=\frac{a_i}{RMS(a)} aiˉ=RMS(a)ai

相较于原始的RMSNorm,LLaMA加入了一个缩放因子 g i g_i gi和一个偏移参数 b i b_i bi(均为可学习参数),最终得到:
a i ˉ = a i R M S ( a ) g i + b i \bar{a_i}=\frac{a_i}{RMS(a)}g_i+b_i aiˉ=RMS(a)aigi+bi

HuggingFace Transformer 库中的LLaMA RMSNorm实现如下:

class LlamaRMSNorm(nn.Module):
	def __init__(self, hidden_size, eps=1e-6):
		"""
		LlamaRMSNorm is equivalent to T5LayerNorm
		"""
		super().__init__()
		self.weight = nn.Parameter(torch.ones(hidden_size))
		self.variance_epsilon = eps # eps 防止取倒数之后分母为 0

	def forward(self, hidden_states):
		input_dtype = hidden_states.dtype
		variance = hidden_states.to(torch.float32).pow(2).mean(-1, keepdim=True) hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon) # weight 是末尾乘的可训练参数, 即 g_i
		return (self.weight * hidden_states).to(input_dtype)

SwiGLU激活函数

详细推导过程见原论文:GLU Variants Improve Transformer

LLaMA使用的SwiGLU激活函数同时也在PaLM等多个LLM应用,相较于ReLU能在很多评测数据集上提升明显。

LLaMA全连接层使用SwiGLU激活函数的计算公式如下:
F F N S w i G L U ( x , W , V , W 2 ) = S w i G L U ( x , W , V ) W 2 FFN_{SwiGLU}(x,W,V,W_2)=SwiGLU(x,W,V)W_2 FFNSwiGLU(x,W,V,W2)=SwiGLU(x,W,V)W2
S w i G L U ( x , W , V ) = S w i s h β ( x W ) ⊗ x V SwiGLU(x,W,V)=Swish_\beta(xW) \otimes xV SwiGLU(x,W,V)=Swishβ(xW)xV
S w i s h β = x σ ( β x ) Swish_\beta=x\sigma(\beta x) Swishβ=xσ(βx)

其中 σ \sigma σ即sigmoid函数。

S w i s h β Swish_\beta Swishβ函数在参数 β \beta β取值不同时形状不同,如下图:
在这里插入图片描述

  • β → 0 \beta \rightarrow 0 β0时, S w i s h β → 直线 y = x Swish_\beta \rightarrow 直线 y=x Swishβ直线y=x
  • β → ∞ \beta \rightarrow \infin β时, S w i s h β → R e L U Swish_\beta \rightarrow ReLU SwishβReLU

LLaMA中 β = 1 \beta=1 β=1,维度缩放为 2 3 4 d \frac{2}{3}4d 324d
在这里插入图片描述

SwishGLU一定程度上引入了Gating机制,原论文实验结果证明了基于Gating的方法普遍优于单纯的激活函数(ReLU
/GELU/Swish)

旋转位置编码 RoPE (Rotary Position Embeddings)

详细推导过程见原论文:ROFORMER: ENHANCED TRANSFORMER WITH ROTARY POSITION EMBEDDING

LLaMA使用RoPE代替原有的绝对位置编码(指BERT的 s i n sin sin c o s cos cos位置编码是按固定值计算的,逻辑上表示的位置也是固定的),以取得更好效果。RoPE的数学推导借助了复数的思想,原作者期望通过数学方法基于绝对位置编码的方式实现相对位置编码,进一步讲,存在向量 q q q k k k,通过如下运算可以给它们添加绝对位置信息:
q ~ m = f ( q , m ) , k ~ n \tilde{\mathbf{q}}_m=f(\mathbf{q},m),\tilde{\mathbf{k}}_n q~m=f(q,m),k~n
q ~ m \tilde{\mathbf{q}}_m q~m k ~ n \tilde{\mathbf{k}}_n k~n具备了 m m m n n n的绝对位置信息。

f ( q , m ) ) f(\mathbf{q},m)) f(q,m))经推导如下:
f ( q , m ) ) = R f ( q , m ) e i Θ f ( q , m ) = ∣ ∣ q ∣ ∣ e i ( Θ ( q ) + m θ ) = q e i m θ f(\mathbf{q},m))=R_f(\mathbf{q},m)e^{i\varTheta_f(\mathbf{q},m)}=||\mathbf{q}||e^{i(\varTheta(q)+m\theta)}=\mathbf{q}e^{im\theta} f(q,m))=Rf(q,m)eiΘf(q,m)=∣∣q∣∣ei(Θ(q)+mθ)=qeimθ
(详细推导过程参见源论文)

根据复数乘法的几何意义,上述变换实际上对应向量旋转操作,因而得名“旋转位置编码”,矩阵形式可能能提供不一样的理解:
f ( q , m ) ) = ( c o s   m θ − s i n   c o s   m θ s i n   m θ c o s   m θ ) ( q 0 q 1 ) f(\mathbf{q},m))=\begin{pmatrix} cos \ m\theta & -sin \ cos \ m\theta \\ sin \ m\theta & cos \ m\theta \end{pmatrix} \begin{pmatrix} \mathbf{q_0} \\ \mathbf{q_1} \end{pmatrix} f(q,m))=(cos mθsin mθsin cos mθcos mθ)(q0q1)

根据内积满足线性叠加的性质,任意偶数维上的RoPE,都可以表示为二维情形的拼接,进一步将公式转化为:
在这里插入图片描述
上述稀疏矩阵可以使用逐位相乘 ⊗ \otimes 加快计算速度,因而RoPE在HuggingFace Transformer 库中代码实现如下所示:

class LlamaRotaryEmbedding(torch.nn.Module):
    def __init__(self, dim, max_position_embeddings=2048, base=10000, device=None):
        super().__init__()
        inv_freq = 1.0 / (base ** (torch.arange(0, dim, 2).float().to(device) / dim))
        self.register_buffer("inv_freq", inv_freq)
        # Build here to make `torch.jit.trace` work.
        self.max_seq_len_cached = max_position_embeddings
        t = torch.arange(self.max_seq_len_cached, device=self.inv_freq.device,
                         dtype=self.inv_freq.dtype)
        freqs = torch.einsum("i,j->ij", t, self.inv_freq)
        # Different from paper, but it uses a different permutation
        # in order to obtain the same calculation
        emb = torch.cat((freqs, freqs), dim=-1)
        dtype = torch.get_default_dtype()
        self.register_buffer("cos_cached", emb.cos()[None, None, :, :].to(dtype), persistent=False)
        self.register_buffer("sin_cached", emb.sin()[None, None, :, :].to(dtype), persistent=False)
    def forward(self, x, seq_len=None):
        # x: [bs, num_attention_heads, seq_len, head_size]
        # This `if` block is unlikely to be run after we build sin/cos in `__init__`. # Keep the logic here just in case.
        if seq_len > self.max_seq_len_cached:
            self.max_seq_len_cached = seq_len
            t = torch.arange(self.max_seq_len_cached, device=x.device, dtype=self.inv_freq.dtype) freqs = torch.einsum("i,j->ij", t, self.inv_freq)
            # Different from paper, but it uses a different permutation
            # in order to obtain the same calculation
            emb = torch.cat((freqs, freqs), dim=-1).to(x.device) self.register_buffer("cos_cached", emb.cos()[None, None, :, :].to(x.dtype),
            persistent=False)
            self.register_buffer("sin_cached", emb.sin()[None, None, :, :].to(x.dtype),
            persistent=False)
        return (
            self.cos_cached[:, :, :seq_len, ...].to(dtype=x.dtype), self.sin_cached[:, :, :seq_len, ...].to(dtype=x.dtype),
        )

    def rotate_half(x):
        """Rotates half the hidden dims of the input."""
        x1 = x[..., : x.shape[-1] // 2]
        x2 = x[..., x.shape[-1] // 2 :]
        return torch.cat((-x2, x1), dim=-1)

    def apply_rotary_pos_emb(q, k, cos, sin, position_ids):
        # The first two dimensions of cos and sin are always 1, so we can `squeeze` them. cos = cos.squeeze(1).squeeze(0) # [seq_len, dim]
        sin = sin.squeeze(1).squeeze(0) # [seq_len, dim]
        cos = cos[position_ids].unsqueeze(1) # [bs, 1, seq_len, dim]
        sin = sin[position_ids].unsqueeze(1) # [bs, 1, seq_len, dim]
        q_embed = (q * cos) + (rotate_half(q) * sin)
        k_embed = (k * cos) + (rotate_half(k) * sin)
        return q_embed, k_embed

不同参数规模的LLaMA模型

基于我们前面讲解的内容,可以实现一个完整的LLaMA Decoder,HuggingFace Transformer库中的实现代码实现如下所示:

class LlamaDecoderLayer(nn.Module):
    def __init__(self, config: LlamaConfig):
        super().__init__()
        self.hidden_size = config.hidden_size
        self.self_attn = LlamaAttention(config=config)
        self.mlp = LlamaMLP( 
            hidden_size=self.hidden_size,
            intermediate_size=config.intermediate_size,
            hidden_act=config.hidden_act,
        )
        self.input_layernorm = LlamaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
        self.post_attention_layernorm = LlamaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)

def forward(self, 
            hidden_states: torch.Tensor,
            attention_mask: Optional[torch.Tensor] = None, 
            position_ids: Optional[torch.LongTensor] = None, 
            past_key_value: Optional[Tuple[torch.Tensor]] = None, 
            output_attentions: Optional[bool] = False, 
            use_cache: Optional[bool] = False,
) -> Tuple[torch.FloatTensor, Optional[Tuple[torch.FloatTensor, torch.FloatTensor]]]:
    
    residual = hidden_states
    hidden_states = self.input_layernorm(hidden_states)
    # Self Attention
    hidden_states, self_attn_weights, present_key_value = self.self_attn(
        hidden_states=hidden_states,
        attention_mask=attention_mask,
        position_ids=position_ids,
        past_key_value=past_key_value,
        output_attentions=output_attentions,
        use_cache=use_cache,
    )
    hidden_states = residual + hidden_states
    # Fully Connected
    residual = hidden_states
    hidden_states = self.post_attention_layernorm(hidden_states)
    hidden_states = self.mlp(hidden_states)
    hidden_states = residual + hidden_states
    outputs = (hidden_states,)

    if output_attentions:
        outputs += (self_attn_weights,) 
    if use_cache:
        outputs += (present_key_value,) 
    
    return outputs

再按架构即可可以实现整个LLaMA模型。

Meta一共发布了4种尺寸的LLaMA,不同尺寸模型的的细节区别如下:
在这里插入图片描述

预训练 Pre-Training

预训练数据集对模型效果有深刻影响,LLaMA使用的混合数据集配比以及大小如下:
在这里插入图片描述
预训练数据集经token化之后总计1.4T个token,对于大多数预训练token仅使用一次,但Wikipedia和Books数据集训练了2轮。

指令精调 Instruction Finetuning

在LLaMA论文里,原作者尝试对LLaMA做了一个简单的指令精调,结果在MMLU数据集上有5.4%提升:
在这里插入图片描述
指令精调的细节参见:Scaling Instruction-Finetuned Language Models,作者为了针对模型效果作对比采用了同样的流程。

结语

LLaMA的架构探秘止步于此。

随着大模型的参数逐步增大,模型的整体架构已不足以对最终效果决定性影响,反而数据集和架构上的一些小细节决定了模型的最终效果。LLaMA虽然没有特别亮眼的创新,但是它的一些实验性的结论,也对后面的模型设计和训练提供了良好的借鉴意义。作为第一个开源的由业界顶尖公司发布的大模型,LLaMA实际上起到了大模型开源进程的奠基作用。

希望未来能看到越来越多的大模型开源,也希望自然语言处理能真正为人类的生产力带来更多可实地落地的突破。

参考文献

  1. LLaMA: Open and Efficient Foundation Language Models
  2. Introducing LLaMA: A foundational, 65-billion-parameter large language model
  3. 大规模语言模型:从原理到实践(复旦NLP教材)
  4. 大规模预训练语言模型方法与实践 (崔一鸣 北京·BAAI 2023年8月26日)
  5. Root Mean Square Layer Normalization
  6. GLU Variants Improve Transformer
  7. ROFORMER: ENHANCED TRANSFORMER WITH ROTARY POSITION EMBEDDING
  8. Scaling Instruction-Finetuned Language Models

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/1121360.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

支付风控规则

支付宝使用基本风控规则 一、 6个规则 1、规则一:30分钟内,不要连续刷3笔(包括失败交易),两笔交易时间间隔大于5分钟,交易金额不要一样,不要贴近限额; 2、规则二:非正…

Python数据结构(链表)

Python数据结构(链表) 单向链表 单向链表也叫单链表,是链表中最简单的一种形式,它的每个节点包含两个域,一个信息域(元素域)和一个链接域。这个链接指向链表中的下一个节点,而最后一个节点的链接域则指向…

postgresql14-表的管理(四)

表table 创建表 CREATE TABLE table_name --表名 (column_name data_type column_constraint, --字段名、字段类型、约束字段(可选)column_name data_type, --表级别约束字段...,table_constraint );CREATE TABLE emp1 --创建表 AS SELECT * FROM empl…

『干货』WebStorm代码模板配置大全

『干货』WebStorm代码模板配置大全 文章目录 『干货』WebStorm代码模板配置大全一、代码模板二、前端 vue 框架2.1 选项式API2.2 组合式API2.3 组合式API TS 三、 前端 UniApp 框架3.1 选项式API3.2 组合式API3.3 组合式API TS 四、前端 React 框架4.1 类声明式4.2 函数声明式…

史上最全 2023全国大学生软件测试大赛——赛后有感

这个比赛什么成分我不好多说,首先说一下我的背景,我们学校是这个比赛的我们省赛的主办方,老师要求我们参加web应用测试和开发者测试,我都参加了,自认为还算是个学习成绩比较好的student,计算机专业前5%&…

【BP-Adaboost预测】基于BP神经网络的Adaboost的单维时间序列预测研究(Matlab代码实现)

💥💥💞💞欢迎来到本博客❤️❤️💥💥 🏆博主优势:🌞🌞🌞博客内容尽量做到思维缜密,逻辑清晰,为了方便读者。 ⛳️座右铭&a…

详解 Diffusion (扩散) 模型

扩散模型是跨不同深度学习领域使用的生成模型。目前,它们主要用于图像和音频生成。最值得注意的是,这些模型是令人印象深刻的图像生成模型(例如 Dalle2 和稳定扩散)背后的驱动力。我相信您已经看过这些模型生成的闪烁图像。令人惊…

Java基础-IO流

目录 1 File 类的使用 1.1 File类的概念 1.2 构造方法 1.3 常用方法 1.4 课后练习 2 IO流原理及流的分类 2.1 IO原理 2.2 流的分类 2.3 IO流体系 2.4 接口方法 2.4.1 InputStream & Reader相同点 2.4.2 InputStream方法详解 2.4.3 Reader方法详解 2.4.4 Outp…

【数据结构】顺序表实现通讯录

前言 在上一节中我们实现了顺序表,现在我们将使用顺序表完成通讯录的实现。(注:本人水平有限,“小屎山”有些许bug,代码冗余且语无伦次,望谅解!😅) 文章目录 一、数据结构…

postgresql14-安装(一)

安装 以管理员权限运行windows版安装包,否则会导致安装不全。过程中记录密码。 在服务管理,启动postgresql服务。 管理工具pgadmin

使用Dockerfile生成docker镜像和容器的方法记录

一、相关介绍 Docker 是一个开源的容器化平台,其中的主要概念是容器和镜像。 容器是 Docker 的运行实例。 它是一个独立并可执行的软件包,包含了应用程序及其依赖的所有组件(如代码、运行时环境、系统工具、库文件等)。容器可以在…

用户及授权设置API

用户及授权设置API 一、登录API——wx.login(object)二、用户信息API——wx.getUserInfor(object)三、授权API——wx.authorize(object object)四、设置API——wx.openSetting(object object)&wx.getSetting(object object)1、wx.openSetting(object object)2、wx.getSetti…

汽车屏类产品(五):中控IVI车载信息娱乐系统

前言: 车载信息娱乐系统(IVI)的起源可以追溯到20世纪,按钮调幅收音机被认为是第一个功能。从那以后,IVI系统在创造壮观的车内体验方面变得不可或缺,以至于汽车被称为“车轮上的智能手机”。但随着包括自动驾驶汽车在内的汽车技术的进步,以及对个性化体验的需求不断增长…

从裸机启动开始运行一个C++程序(十二)

前序文章请看: 从裸机启动开始运行一个C程序(十一) 从裸机启动开始运行一个C程序(十) 从裸机启动开始运行一个C程序(九) 从裸机启动开始运行一个C程序(八) 从裸机启动开始…

SpringBoot连接MySQL密码错误,报错:Access denied for user

记:一次连接MySQL报密码错误,Access denied for user 检查步骤: 核对用户和密码是否正确,用工具登陆试下。如果配置文件是yml格式,配置密码是123456这种纯数字,记得加上单/双引号。检查云上数据库配置&am…

使用rna-seq定量软件salmon运行index步骤遇到的一个问题(计算集群slurm)

salmon 帮助文档 https://salmon.readthedocs.io/en/latest/building.html#installation github主页 https://github.com/COMBINE-lab/salmon 我最开始是直接使用conda安装的 v1.4 首先第一步是对参考转录组进行索引,命令 salmon index -t pome.fa -i transcr…

postgresql14-用户与角色(二)

介绍 查看 SELECT rolname FROM pg_roles;postgres是系统初始化时默认创建的角色,为超级管理员。 \duList of rolesRole name | Attributes | Member of ------------------------------------------------------…

python 之计算矩阵乘法

文章目录 总的介绍例子 总的介绍 np.matmul 是NumPy库中的矩阵乘法函数,用于执行矩阵乘法操作。矩阵乘法是线性代数中的一种常见操作,用于将两个矩阵相乘以生成新的矩阵。在神经网络、机器学习和科学计算中,矩阵乘法经常用于变换和组合数据。…

简单宿舍管理系统(springboot+vue)

简单宿舍管理系统(springbootvue) 1.创建项目1.前端2.数据库3.后端 2.登陆1.前端1.准备工作2.登陆组件3.配置 2.后端1.链接数据库2.创建用户实体类3.数据操作持久层1.配置2.内容3.测试 4.中间业务层1.异常2.业务实现3.测试 5.响应前端控制层 3.前后对接4…

散列表:Word文档中的单词拼写检查功能是如何实现的?

文章来源于极客时间前google工程师−王争专栏。 一旦我们在Word里输入一个错误的英文单词,它就会用标红的方式提示“编写错误”。Word的这个单词拼写检查功能,虽然很小但却非常实用。这个功能是如何实现的? 散列别(Hash Table&am…