经过前面一系列的铺垫，我们陆续介绍了 RMSNorm、SwiGLU、张量并行 ColumnParallel 和 RoPE 这些 LLaMA 1 模型当中所涉及到的基础模块，今天终于可以开始正式介绍 LLaMA 1 模型了[1]。

在这篇论文中，作者首先提出了两个动机，然后以此为方向构建了一系列不同尺寸的模型。最后，经过实验发现训练得到的 LLaMA 13B 在大多数评价指标上尽然都优于 GPT-3 (175B)，而前者只有后者约十分之一的参数量。

1. 动机#

1.1 如何避开大力出奇迹#

先前与 LLM 相关的研究都停留在这样一个印象，那就是参数规模越大，模型的效果就会越好（Scalling Law）。然而，最近有研究发现，对于固定算力的情况下，相比使用更大的模型来说，使用较小的模型但更多的数据往往能取得更好的收益。

These efforts are based on the assumption that more parameters will lead to better performance. However, recent work from Hoffmann et al. (2022) shows that, for a given compute budget, the best performances are not achieved by the largest models, but by smaller models trained on more data.

这样的固有印象其实一直都存在于深度学习的发展过程中，因此也出现了“大力出奇迹”这样的调侃，例如堆数据、堆算力等等。

那么我们能不能做到在既不用堆数据也不用堆算力的情况下，保持模型有一个较好的效果呢？

从图1中可以看出，尽管后来的模型效果上取得了显著的提升，但是参数量却迎来了剧烈的激增，并且研究显示随着参数量的增加模型的效果还能更好（当时作者这样的预言随着后来GPT-3和ChatGPT等的出现也得到了完美的验证）。这也就暗示着必须要通过某种办法来控制模型参数的大规模增长。

如果大家对于之前介绍的文章还有印象的话，上面这段话就是 DistilBERT 提出的核心动机：通过蒸馏来实现降低模型参数规模的同时，保持一个较好的效果。

因此，面对同样的问题，如何能在不太损失模型精度的情况下能够显著降低模型的规模就是 LLaMA 1 提出的动机之一。

1.2 长痛不如短痛#

同时，先前的研究都忽视了一点，那就是没有关注模型在推理时候的开销，例如对于需要频繁调用模型的应用来说（如 ChatGPT），推理开销显然比训练开销更加重要。换句话说，一个模型哪怕训练得更久一点，但是只要推理时的开销更小，那这也是更好的选择。

举个例子：假设我们想让模型在某个任务上达到 90 分的性能，然后训练一个大的模型（比如 10B）可能只需训练几周的时间就达到目标。虽然此时训练成本低，但它在推理时成本很高（因为参数多、显存大、延迟高）。相反，如果训练一个小点的模型（比如 7B），虽然需要训练更久（训练成本高），但它推理效率高、部署成本低，所以从长期服务的角度看它更划算。

例如，虽然 Hoffmann 等人的建议是10B 模型只需训练 200B tokens 就能达到最优性价比 [2]。但实际上，作者观察到的结果是 7B 的模型继续训练到 1T tokens（ 模型在训练过程中累计处理了 1 万亿个 token）时性能还在稳定提升（这一点从后面的图9可以看出），这说明它可以用更长的训练来弥补模型规模的不足，并且推理成本比 10B 更低。

For instance, although Hoffmann et al. (2022) recommends training a 10B model on 200B tokens, we find that the performance of a 7B model continues to improve even after 1T tokens.

因此，LLaMA 1 提出的核心动机之二就是：宁肯在模型训练时增加成本短痛，也不在模型上线后巨大推理开销上的长痛。

所以，作者希望在相同模型规模下，且仅使用公开数据集但通过训练更多 token （即让模型训练更多的 epochs ）的方式，来提升模型在受限推理资源条件下的性能表现。

The focus of this work is to train a series of language models that achieve the best possible performance at various inference budgets, by training on more tokens than what is typically used.

最终，作者 仅通过公开的数据集 训练得到了 7B 、13B、33B、65B 这 4 种极具竞争力的网络模型，统称为 LLaMA （Large Language Model Meta AI），又是一个谐音梗的名字。并且，LLaMA 13B 在大多数评价指标上都优于 GPT-3 (175B)，而前者只有后者约十分之一的参数量；同时，与 Chinchilla-70B 和 PaLM-540B 相比， LLaMA 65B 也具有足够的竞争力。

We train our models on trillions of tokens, and show that it is possible to train state-of-the-art models using publicly available datasets exclusively, without resorting to proprietary and inaccessible datasets. In particular, LLaMA-13B outperforms GPT-3 (175B) on most benchmarks, and LLaMA- 65B is competitive with the best models, Chinchilla-70B and PaLM-540B.

2. LLaMA 模型原理#

从整体上来看， LLaMA 的网络结构依旧是以 Transformer 中的 Decoder 为原型，只是将其中的部分模块进行了等价替换，可谓是集大家之长，而这些我们在前面的一些列文章中也都分别进行了详细介绍。下面依次对整个模型各个部分进行一个简单的介绍。

We leverage various improvements that were subsequently proposed, and used in different models such as PaLM. Here are the main difference with the original architecture, and where we were found the inspiration for this change.

2.1 LLaMA 网络结构#

对于 LLaMA 1 来说，相较于原始的 Transformer 中的 Decoder，它替换了其中的位置编码、层归一化方式和线性变换这三个主要地方。如图3所示便是 LLaMA 1 的网络结构图。

在图3中，RMSNorm、RotaryEmb 和 SwiGLU（图中的 MLP）便是 LLaMA 1 中新替换的模块，当然还有用于并行计算的 ParallelLinear 部分。

如过大家看过我们之前写的对于 Baichuan2 大模型的介绍的话会发现，整体上它们俩的模型结构基本上类似。

如图4所示，左右两边分别是 Baichuan2 和 LLaMA 1 的结构对比图，整体上看并没有太大差异。不过还是老话说得好，“数无形时少直觉，形式数时难入微”，目前基于生成式的大模型在模型结构方面整体上都大同小异。虽然通过图示我们可以快速厘清它的核心之处，但是内部的细节还是得通过代码来进行刻画。

2.2 使用 RMSNorm 归一化#

首先，为了提高模型训练时的稳定性， LLaMA 1 借鉴了 GPT3 中所使用的 RMSNorm 归一化方法，并且在使用顺序上从对输出标准化变成了对每一层的输入进行表中。

To improve the training stability, we normalize the input of each transformer sub-layer, instead of normalizing the output. We use the RMSNorm normalizing function, introduced by Zhang and Sennrich (2019).

如图5所示，左右两侧便是 LLaMA 1 和 Transformer Decoder 中对于层归一化方法使用顺序上的差异。这一点其实就很类似于在卷积神经网络中 “conv + bn + relu” 和 “conv + relu + bn” 这两种方式一样，其实都是以实验结果为导向，我们相信 Transformer 中采用后归一化的方式一定也是经过实验对比的。

整体来看，RMSNorm 就是在 LayerNorm 的基础上，去掉了所有需要去均值的部分，因此计算均值这部分操作也就一并去掉了，而这也就大大减少了 LayerNorm 中对应部分的计算开销。

对于 RMSNorm 可以通过如下代码来进行实现，然后进行使用。

 1 class RMSNorm(torch.nn.Module):
 2     def __init__(self, dim: int, eps: float = 1e-6):
 3         super().__init__()
 4         self.eps = eps
 5         self.weight = nn.Parameter(torch.ones(dim))
 6 
 7     def _norm(self, x):
 8         a = x.pow(2).mean(-1, keepdim=True)
 9         b = x * torch.rsqrt(a + self.eps)
10         return b
11 
12     def forward(self, x):
13         output = self._norm(x.float()).type_as(x)
14         return output * self.weight

在上述代码中，第2行中 dim 用于指定归一化部分向量的维度，eps 是平滑项防止分母为0溢出。第5行是对应的可学习参数 $g$。第8行则是计算 $\text{RMS}$ 的过程。第9行是计算归一化缩放后的结果，其中 torch.rsqrt() 等价于 1/torch.sqrt()。第12~14行则是依次计算最终归一化的结果。

最后，使用方式如下：

1 if __name__ == '__main__':
2     rms_norm = RMSNorm(embedding_dim)
3     print(rms_norm(embedding))

更多关于 RMSNorm 思想动机和原理的介绍可以参见文章：「RMSNorm 归一化原理与 PyTorch 实现：详解与 LayerNorm 的区别及在 LLaMA/DeepSeek 中的应用」

2.3 使用 SwiGLU 激活函数#

在 LLaMA 1中，作者将 Transformer Decoder 中 Feed Forward 里的 Relu 激活函数替换成了 SwiGLU 激活函数，也就是图4左侧的 MLP 部分。

We replace the ReLU non-linearity by the SwiGLU activation function, introduced by Shazeer (2020) to improve the performance.

不过与其说 SwiGLU 是激活函数，倒不如说它是一个门控结构，其计算公式如下

根据式(1)的计算过程，其实现过程如下所示：

 1 class FFN(nn.Module):
 2     def __init__(self, dim, hidden_dim):
 3         super().__init__()
 4         self.linear1 = nn.Linear(dim, hidden_dim)
 5         self.linear2 = nn.Linear(dim, hidden_dim)
 6         self.linear3 = nn.Linear(hidden_dim, dim)
 7 
 8     def forward(self, x):
 9         x_gate = self.linear1(x)  # [batch_size, hidden_dim]
10         x_gate = x_gate * torch.sigmoid(x_gate)  # [batch_size, hidden_dim]
11         y = self.linear2(x)  # [batch_size, hidden_dim]
12         y = x_gate * y  # [batch_size, hidden_dim]
13         output1 = self.linear3(y)  # [batch_size, dim]
14         output2 = self.linear3(F.silu(self.linear1(x)) * self.linear2(x))
15         return output1, output2

在上述代码中，第4~5行是定义式(6)中对应的3个线性变换；第9~13行则是我们自己动手实现的整个计算过程，相关维度变换都进行了表示大家可以仔细阅读。同时，我们还可以通过第14行这样一行代码来完成整个计算过程。

更多关于 SwiGLU 思想动机和原理的介绍可以参见文章：「 SwiGLU 激活函数原理与 PyTorch 实现：详解为何 LLaMA/DeepSeek 用它取代 ReLU」

2.4 使用 Rotary Embeddings 位置编码#

在 LLaMA 1中，作者将传统 Transformer 中的绝对位置编码替换成了旋转位置编码，而这基本上现在也已经成为了各个大模型的标配，包括 LLaMA 系列、 Baichuan 系列和 DeepSeek 系列等。

We remove the absolute positional embeddings, and instead, add rotary positional embeddings (RoPE), introduced by Su et al. (2021), at each layer of the network.

一般来说，绝对位置编码具有实现简单、计算速度快等优点，而相对位置编码则直接地体现了相对位置的变化，这也跟我们的直观理解吻合。

在这样的背景和动机下，作者便开始假设，既然自注意力的核心就是内积，也就是注意力的计算过程，那么我们能不能假设向量 $q^Tk$ 计算完成以后的注意力权重结果自然就带有了相对位置的信息呢？

因此，作者就假设存在函数 $f(x,pos)$，它能够给向量 $q$ 和 $k$ 分别施加上在位置 $m$ 和 $n$ 处的绝对位置信息，即 $\tilde{q}_m=f(q,m)$ 和 $\tilde{k}_n=f(k,n)$；最后，通过 $\tilde{q}_m^T\tilde{k}_n$ 在完成注意力权重计算以后就自然包含有了 $m$ 与 $n$ 之间的相对位置信息 $m-n$。

由此可见，作者想以一种表面上看似是绝对编码的计算过程，实则背后隐含着相对位置编码的本质，即通过绝对位置编码的计算过程，来实现相对位置编码的结果。

最后，之所以整个编码过程被取名为“旋转位置编码”是因为作者按照上述构想，求解得到的计算公式带有矩阵旋转的过程，所以取名为旋转位置编码。

对于 Rotary Embeddings 的实现，整个过程一共需要两步：① 计算每个位置在不同维度上的旋转角度；② 将其作用于 $q$ 或 $k$ 得到绝对位置信息编码后的输出。

首先，编码实现计算每个位置在不同维度上的旋转角度，示例代码如下：

1 def precompute_freqs_cos_sin(dim: int, seq_len: int, theta: float = 10000.0):
2     freqs = 1.0 / (theta ** (torch.arange(0, dim, 2).float() / dim)) #  [dim/2,]
3     position = torch.arange(seq_len).unsqueeze(1)  # [seq_len,1]
4     rot_theta = position * freqs  # (seq_len, dim/2)
5     cos = rot_theta.cos()  # [seq_len, dim/2]
6     sin = rot_theta.sin()  # [seq_len, dim/2]
7     return cos, sin

在上述代码中，第1行 dim 表示每个 token 对应的维度且必须要为偶数，因为整体是将维度分为两部分来进行计算。第2~4行便是实现 $m\theta$ 的计算过程，其中第2行是计算每个维度对应的旋转频率，维度越高频率越低旋转角度也就越小。第5~6行则是计算对应的正弦和余弦值。

进一步，我们在完成 cos, sin 值的计算以后，便可以完成旋转编码过程，示例代码如下：

 1 def apply_rope_matrix(x, cos, sin):
 2     bsz, seq_len, dim = x.shape
 3     x = x.view(bsz, seq_len, dim // 2, 2)
 4     x1 = x[..., 0]  # [bsz, seq_len, dim // 2]
 5     x2 = x[..., 1]  # 
 6     cos = cos.unsqueeze(0)  # [1, seq_len, dim/2]
 7     sin = sin.unsqueeze(0)
 8     x_rotated_x = x1 * cos - x2 * sin
 9     x_rotated_y = x1 * sin + x2 * cos
10     x_rotated = torch.stack([x_rotated_x, x_rotated_y], dim=-1)
11     return x_rotated.view(bsz, seq_len, dim)

在上述代码中，第3~5行便是将输入在最后一个维度（也就是词向了维度）分成两部分，其中 x[..., 0] 里的 ... 表示前面的所有维度，此处等价于 x[:,:,:,0]。第6~7行是对cos, sin 进行维度扩充。第8~9行便是完成旋转计算过程。第10~11行则是完成拼接，并重塑成 [bsz, seq_len, dim] 的形状。

最后，我们可以通过如下方式来进行使用，示例代码如下：

 1 def rope_matrix(xq, xk):
 2     bsz, seq_len, dim = xq.shape
 3     cos, sin = precompute_freqs_cos_sin(dim, seq_len)
 4     q_rot = apply_rope_matrix(xq, cos, sin)
 5     k_rot = apply_rope_matrix(xk, cos, sin)
 6     print(q_rot)
 7 
 8 if __name__ == '__main__':
 9     dim = 8
10     seq_len = 5
11     xq = torch.randn(2, seq_len, dim)
12     xk = torch.randn(2, seq_len, dim)
13     rope_matrix(xq, xk)

更多关于 Rotary Embeddings 思想动机和原理的介绍可以参见文章：「 RoPE 旋转位置编码原理与从零实现：详解 LLaMA/ChatGLM/Mistral 大模型为何离不开它」

2.5 使用并行计算 ParallelLinear#

除了上述3个模块的改动以外，为了提高模型的计算效率 LLaMA 1 还引入了张量并行技术以实现在多个 GPU 上对模型进行并行计算，包括 ColumnParallelLinear、RowParallelLinear 和 ParallelEmbedding 这3个并行计算模块。

对于张量并行的详细原理，我们已经在前面几篇文章中陆续进行了介绍，这里就不再赘述，大家可以按序阅读如下3篇文章。

「① LLaMA 大模型并行计算原理图解：从数据并行到张量并行的演进与对比」

「② LLaMA 张量并行 PyTorch 实现：基于 FairScale 的 ColumnParallel/RowParallel 教程」

「③ 张量并行多头注意力从零实现：基于 Column/RowParallelLinear 拼装 LLaMA MHA 教程」

最后，至于 LLaMA 1 整体模型实现的代码讲解这里就不介绍了，原因是因为找了一大圈没有找到 LLaMA 1 的预训练模型，官方公开的模型都是从 LLaMA 2 开始。

下面，我们再来简单看一下训练 LLaMA 1 模型时所用到的数据集以及 LLaMA 1 对应的实验结果。

3. 训练数据及过程#

因为现在大模型所谓的开源，仅仅只是对模型权重和前向传播的代码进行了开源。甚至是为了开源，还重新修改了仅用于前向传播过程的代码，而对于模型训练过程的代码都没有进行开源。所以，我们也只能是根据论文中所提及的描述来简单看一下这部分内容。

3.1 数据集介绍#

在整个模型的预训练过程中，LLaMA 1一共使用了包含多个领域的 7 个数据，如图6所示。当然最重要也是作者在文中多次强调的一点就是使用到的都是公开可下载的数据集。

we reuse data sources that have been leveraged to train other LLMs, with the restriction of only using data that is publicly available, and compatible with open sourcing.

这里需要注意的是，图6中的 “Sampling proportion” 指的是在每个 batch 中各个数据源的占比，也就是说 Sampling proportion 直接决定了每个 mini-batch 里面来自各语料库的样本比例，而不是总的数据集大小的占比，这也是多语料训练最核心的概念之一。

例如，在 LLaMA 1 在训练过程中，每个 batch 的大小固定为 400万个 token，而根据图6中的比例，将会从 CommonCrawl 中取约 $400\times 0.67=268$ 万个token。

不过这里又有一个新的知识点，那就是在大模型的训练过程中为了避免因为各个序列长短差异过大使用 padding 带来的显存浪费，所以每个 batch 通常不会再以固定的样本数进行迭代（也就是 batch size 不再是固定的），而是以固定的 token 数训练。因此，一个常用的策略就是将长度差距不大的样本组合到一个 batch 中然后进行填充，然后形成固定 token 数量的样本输入到模型中，以最大化利用显存。

下面给大家依次简单介绍一下这7个数据集：

• English CommonCrawl：这是占比对多的一个数据集，达到了67%。CommonCrawl 是一个大规模的开放式网络抓取项目[4]，它致力于收集并提供互联网上的网页数据，总量超过了2550亿个网页。 LLaMA 1 将其中2017年至2020年的数据经过清洗、过滤非英文内容、去重、后留下约 3.3T 数据，作为训练数据的一部分。

• Colossal Clean Crawled Corpus（C4） ：由 Google 团队在 T5（Text-To-Text Transfer Transformer）[5] 论文中发布的大规模文本语料库，它是基于 CommonCrawl 利用不同启发式规则进行大规模清理和预处理后的版本，占比15%，约783GB。

• Github：LLaMA 1 使用了 Google BigQuery 上提供的公共 GitHub 数据集，且仅保留遵循 Apache、BSD 和 MIT 许可证的项目。此外，根据行长度或字母数字字符的比例，作者使用启发式算法过滤了低质量文件，并使用正则表达式删除了诸如文件头之类的样板文件。最后，还在文件级别对生成的数据集进行了去重，并进行精确匹配，占比4.5%，约328GB。

• Wikipedia：使用了 2022 年 6 月至 8 月期间的维基百科数据，涵盖 20 种使用拉丁字母或西里尔字母的语言，并且对数据进行了预处理，如删除超链接、评论等，占比4.5%，约83GB。

• Books：包括 Gutenberg 和 Books3 这两个数据集，都是可公开获取图书数据集，并且删除了两者内容重叠率超过 90% 的图书，占比4.5%，约85GB。

• ArXiv：这是一个大家都非常熟悉的论文预印本网站，加入它的目的是作为科学数据使用。这里需要注意的是，使用的是论文对应的 LaTex 文件，且删除了第一节以前、参考文献、LaTex 语法中的各种宏定义这些内容，占比2.5%，约92GB。

• Stack Exchange：这是一个提供高质量问答的网站，涵盖从计算机科学到化学等多个领域，类似于知乎。作者选择了其中28个数据量最大的领域，然后删除了文本中的 HTML 标签，并按得分（从高到低）对答案进行了排序。这部分数据占2%，约78GB。

可以看到，LLaMA 1 作为一个通用的大语言模型，CommonCrawl 预料占比最多也是合理的，同时再辅以不同场景下的数据集来增加模型对应的能力，包括代码能力、维基百科、图书和论文这些。

在经过使用 byte-pair encoding (BPE) 算法进行分词（tokenize）后，整个完整的训练数据集一共包含有 1.4T（万亿）个词元。同时，在分词时作者将所有的数字均按单子数字进行了划分，例如 57 将被切分成 ‘5’ 和 ‘7’ 这两个 token ，并且对于未知的 UTF-8 编码字符将其还原成了字节码。

如图6所示，在训练中对于大多数数据源来说每个 token 仅仅只出现过一次，换句话说仅迭代了一轮，只有 Wikipedia 和 Books 这两个数据源迭代了 2 轮训练。

3.2 训练过程#

在整个 LLaMA 1 系列模型的训练过程中，作者使用的是 AdamW 优化器，其中 $\beta_1 = 0.9, \beta_2=0.95$，衰减系数为 0.1，梯度裁剪范围 [-1,1]。 同时，它还使用了 cosine 学习率调度器，热身步数为 2000，且最小学习率为最大学习率的十分之一。

各个模型的超参数配置如图8所示。

从图8中可以看出，只有 LLaMA-33B 和 LLaMA-65B 这两个模型才使用了完整 1.4T 的数据集，另外两个小一点的模型仅使用了 1T 的数据量。对于所有模型来说，每个 batch 中的 token 数量均为 400 万。

LLaMA-33B and LLaMA-65B were trained on 1.4T tokens. The smaller models were trained on 1.0T tokens. All models are trained with a batch size of 4M tokens.

如图9所示，便是4个模型在训练过程中时的损失变化图。从图9中可以看出，LLaMA-7B 和 LLaMA-13B 继续训练模型的损失应该还能继续下降，而这也是同作者一开始提出的论点相呼应：如果训练一个小点的模型，虽然需要训练更久，但它推理效率高、部署成本低，所以从长期服务的角度看它更划算。

也就是说，当作者发现 LLaMA-13B 的训练 1T token 后所表现的能力居然在大多数评价指标上都优于 GPT-3 (175B) 时，也就停止了对于找个小模型的训练。

最终，作者通过使用 2048张 A100 显卡通过21天完成了 LLaMA-65B 的训练。

When training a 65B-parameter model, our code processes around 380 tokens/sec/GPU on 2048 A100 GPU with 80GB of RAM. This means that training over our dataset containing 1.4T tokens takes approximately 21 days.

4. 实验结果#

同先前的其它模型一样，LLaMA 同样也分别采用了 零样本学（zero-shot）和少样本学习（few-shot）在 20 个标准评测集上对 LLaMA 系列模型进行了评估。下面，我们来简单看一下 LLaMA 与 GPT-3 在各项数据集上的一个对比结果。

4.1 常识推理任务#

首先，LLaMA 在8个著名的常识推理数据集上对模型进行了评估，这些数据集包含填空、指代消解和多选问答。整个过程都采用了零样本学习来进行评估，也就是完全依赖模型已有的理解能力，评测结果如图10所示。

在图10中，这 8 个任务分别是 BoolQ（回答是/否问题的数据集）、PIQA（常识性物理推理，Physical Interaction QA）、SIQA（社会互动常识推理，Social IQA）、HellaSwag（给定上下文，选择最合理的续写）、WinoGrande（Winograd 风格的指代消解，即推断“他/她/它”指代谁）、ARC easy & challenge（机器做小学科学考试题，分简单和挑战版，AI2 Reasoning Challenge）和 OpenBookQA（结合开放式常识与给定课本知识回答问题）。

在这 8 个任务上，LLaMA 系列模型有 6 个都处于最高水平，其中 LLaMA-13B 在 4 个任务上的表现都优于 GPT-3模型。

4.2 Natural Questions 任务#

进一步，LLaMA 在标准闭卷问答数据集（Natural Questions，谷歌发布的一个问答数据集，问题多来自真实用户查询，例如“Who wrote the book War and Peace?” 《战争与和平》是谁写的？）上，分别使用零样本和少样本学习同现有大模型进行了对比，评测了模型在完全不能查阅文档情况下（即不能连接本地知识库或互联网）的精确匹配能力，评测结果如图11所示。

如图11所示，LLaMA 系列模型在 4 种学习方式下的评测结果全都好于其它模型，并且 LLaMA-13B 几乎也是在所有学习方式下的评测结果都好于 GPT-3，但更值得注意的是 LLaMA-13B 在推理过程中仅仅只是运行在一块 V100 GPU 上的，而这也是 LLaMA 提出来的重要动机。

More importantly, the LLaMA-13B is also competitive on these benchmarks with GPT-3 and Chinchilla, despite being 5-10× smaller. This model runs on a single V100 GPU during inference.

4.3 英文阅读理解#

同时，LLaMA 还用了 RACE 阅读理解任务（该数据集来自于我们初高中的英文阅读理解）来测试模型。结果表明，小体量的 LLaMA-13B 模型在阅读理解上也非常强大，LLaMA-65B跟PaLM-540B 差不多好，而 LLaMA-13B 甚至比 GPT-3 还好几个点，如图12所示。

从图12中的结果可以看出，LLaMA-13B 在两个子数据集上的准确率都要明显好于 GPT-3 模型。

4.4 MMLU 多项选择题任务#

最后，LLaMA 系列模型还在 MMLU 任务上进行了评测。大规模多任务语言理解基准（Massive Multitask Language Understanding benchmark, MMLU）是2020 年 Hendrycks 等人提出来的一个数据集，其形式为涉及人文、科学、技术、工程、数学和社会科学等领域的多项选择题，是目前最全面的多学科语言理解评测之一。

在 5-shot 少样本学习设定下，LLaMA-65B 只比 Chinchilla 和 PaLM 略差一些。作者认为一个可能原因是训练时书籍和论文数据较少（只有177GB），而其它模型用了几乎多达2TB的书籍内容，结果如图13所示。

从图13可以看出，LLaMA-13B 在其中的 3 项领域中的评估结果即平均值上都是优于 GPT-3模型的。因此，根据上面 LLaMA-13B 在多个任务上的评测结果，确实也能充分呼应作者提出 LLaMA 模型的动机。

引用#

[1] Touvron H, Lavril T, Izacard G, et al. Llama: Open and efficient foundation language models[J]. arXiv preprint arXiv:2302.13971, 2023.

[2] Jordan Hoffmann, et al. 2022. Training compute-optimal large language models.

[3] LLaMA-1: https://github.com/moon-hotel/llama/tree/llama_v1

[4] https://commoncrawl.org

[5] Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer