LLaMA：开放高效的基础语言模型（Meta AI-2023）
论文： LLaMA: Open and Efficient Foundation Language Models
Meta AI Hugo Touvron,∗ Thibaut Lavril等人。
GitHub - facebookresearch/llama: Inference code for LLaMA models
模型官网实现代码
GitHub - lxe/simple-llama-finetuner: LLaMA微调UI
LLAMA底座模型下载： https:// ipfs.io/ipfs/Qmb9y5GCkT G7ZzbBWMu2BXwMkzyCKcUjtEKPpgdZ7GEFKm/
小虎AI珏爷：ChatGPT背后的技术之理解人类反馈强化学习（RLHF）
小虎AI珏爷：ChatGPT可能的应用场景及Prompt使用方式
小虎AI珏爷：ChatGPT指令模板大全-通用人工智能的觉醒
小虎AI珏爷：论文阅读-PaLM-E：一种体现的多模态语言模型
小虎AI珏爷：论文阅读：Language Models are Few-Shot Learners（巨无霸OpenAI GPT3 2020）
小虎AI珏爷：论文阅读：语言模型是无监督的多任务学习者（GPT2 2019）
小虎AI珏爷：论文阅读-自指导：将语言模型与自生成的指令相结合
小虎AI珏爷：ColossalChat：完整RLHF平替ChatGPT的开源方案
论文介绍了 LLaMA ，它是一组基础语言模型，参数范围从7B到65B。在数万亿的tokens上训练的模型，并表明可以专门使用公开可用的数据集来训练最先进的模型，而无需求助于专有和不可访问的数据集。特别是， LLaMA-13B在大多数基准测试中都优于GPT-3（175B） ，并且LLaMA65B与最好的型号Chinchilla-70B和PaLM-540B具有竞争力。
1 介绍
在大量文本语料库上训练的大型语言模型（LLM）已经显示出它们从文本指令或几个例子中执行新任务的能力（Brown et al.，2020）。当将模型缩放到足够大时，这些few-shot 特性首次出现（Kaplan等人，2020年），导致一系列工作集中于进一步缩放这些模型（Chowdhery等人，2022年；Rae等人，2021）。这些努力是基于这样一种假设，即更多的参数将带来更好的性能。然而， Hoffmann等人最近的工作（2022）表明，对于给定的计算预算，最佳性能不是通过最大的模型实现的，而是通过在更多数据上训练的较小模型实现的 。
Hoffmann等人（2022）的缩放规律的目标是确定如何为特定的训练计算预算最佳地缩放数据集和模型大小。然而，这个目标忽略了推理预算，这在大规模服务于语言模型时变得至关重要。在这种情况下，给定目标性能水平，首选模型不是训练最快的，而是推理最快的。尽管训练大型模型以达到一定的性能水平可能更便宜，但训练时间更长的小型模型最终推理更便宜。例如，尽管Hoffmann等人（2022）建议在200B代币上训练10B模型，但论文发现即使在1T tokens之后，7B模型的性能也会继续提高。
这项工作的重点是训练一系列语言模型，通过训练比通常使用的tokens更多的tokens，在不同的推理预算下实现尽可能好的性能。由此产生的模型称为 LLaMA ，其参数范围从7B到65B，与现有的最佳LLM相比具有竞争力。例如， LLaMA-13B 在 大多数基准测试 中都 优于GPT-3 ， 尽管它比GPT-3小10倍 。我们相信，这个模型将有助于LLM的访问和研究民主化，因为它可以在 单个GPU上运行 。在规模的高端，论文的65B参数模型也与最好的大型语言模型（如 Chinchilla或PaLM-540B ）具有竞争力。
与Chinchilla、PaLM或GPT-3不同，论文只使用公开可用的数据，使论文工作与开源兼容，而大多数现有模型依赖于未公开或未记录的数据（例如“Books–2TB”或“Social media conversations”）。存在一些例外，特别是 OPT （Zhang等人，2022）、 GPT-NeoX （Black等人，2022）。
在本文的其余部分中，论文概述了我们对Transformer架构所做的修改（Vaswani et al.，2017），以及训练方法。然后，报告的模型的性能，并在一组标准基准上与其他LLM进行比较。最后，使用负责任的人工智能社区的一些最新基准，揭示了模型中编码的一些偏见和毒性。
2 方法
论文的训练方法类似于之前工作中描述的方法（Brown et al.，2020；Chowdhery et al.，2022），并受到Chinchilla比例规律的启发（Hoffmann et al.，2021）。使用标准优化器在大量文本数据上训练大型Transformer。
2.1 预训练数据集
训练数据集是表1中报告的几个来源的混合，涵盖了一组不同的领域。在大多数情况下，论文重用已被用来训练其他LLM的数据源，但限制只能使用公开可用且与开源兼容的数据。这导致了以下数据及其在训练集中所代表的百分比的混合：
英语CommonCrawl[67%]。 论文使用CCNet pipline 预处理了2017年至2020年的五个CommonCrawl 转储（Wenzek et al.，2020）。该过程在行级别消除重复数据，使用fastText线性分类器执行语言识别以删除非英语页面，并使用ngram语言模型过滤低质量内容。此外，训练了一个线性模型来对维基百科中用作参考文献的页面进行分类。随机抽样的页面，以及未被分类为参考文献的丢弃页面。
C4 [15%]。 在探索性实验中，观察到使用不同的预处理CommonCrawl数据集可以提高性能。因此，将公开可用的C4数据集（Raffel et al.，2020）包含在数据中。C4的预处理还包括 重复数据消除 和 语言识别 步骤：与CCNet的主要区别在于质量过滤，它主要依赖于启发式方法，如标点符号的存在或网页中的单词和句子的数量。
Github [4.5%]。 论文使用Google BigQuery上提供的公共GitHub数据集。只保留了在Apache、BSD和MIT许可证下分发的项目。此外，使用基于行长度或字母数字字符比例的启发式方法过滤低质量文件，并使用正则表达式删除样板文件，如标头。最后，在文件级别对生成的数据集进行重复数据消除，并进行精确匹配。
维基百科[4.5%]。 添加了2022年6月至8月期间的维基百科转储，涵盖20种语言，使用拉丁语或西里尔文：bg、ca、cs、da、de、en、es、fr、hr、hu、it、nl、pl、pt、ro、ru、sl、sr、sv、uk。论文处理数据以删除超链接、注释和其他格式样板。
Gutenberg 和 Books3 [4.5%]。 论文在训练数据集中包括两个图书语料库：Gutenberg项目，其中包含公共领域的图书，以及ThePile的Books3部分（Gao et al.，2020），这是一个用于训练大型语言模型的公开数据集。论文在书本本级别执行重复数据消除，删除内容重叠超过90%的书本。
ArXiv【2.5%】。 我们处理arXiv Latex文件，将科学数据添加到数据集中。继Lewkowycz等人（2022）之后，删除了第一节之前的所有内容以及参考书目。还删除了.tex文件中的注释，并内联扩展了用户编写的定义和宏，以提高论文之间的一致性。
Stack Exchange [2%]。 包括Stack Exchange，这是一个高质量问答网站，涵盖了从计算机科学到化学的一系列不同领域。保留了28个最大网站的数据，删除了文本中的HTML标签，并按分数（从高到低）对答案进行了排序。
Tokenizer。 使用字节对编码（BPE）算法（Sennrich et al.，2015）对数据进行标记，使用PensionePiece（Kudo和Richardson，2018）的实现。值得注意的是，论文将所有数字拆分为单个数字，并回退到字节以分解未知的UTF-8字符。
总体而言，整个训练数据集在标记化后包含大约1.4T的tokens。对于大多数训练数据，每个token在训练期间只使用一次，但维基百科和图书领域除外，论文在这两个领域执行了大约两个epochs。
2.2 架构
继最近对大型语言模型的研究之后，论文网络基于Transformer架构（Vaswani et al.，2017）。论文利用了随后提出的各种改进，并在不同的模型中使用，如 PaLM 。以下是与原始建筑的主要区别，以及论文在那里找到了这一变化的灵感：
预归一化[GPT3]。 为了提高训练稳定性，对每个Transformer子层的输入进行归一化，而不是对输出进行归一化。使用了Zhang和Sennrich（2019）引入的 RMSNorm 规范化函数。
SwiGLU激活功能[PaLM]。 用Shazeer（2020）引入的 SwiGLU激活函数 取代了 ReLU非线性 ，以提高性能。论文使用 \frac{2}{3} 4d 的尺寸，而不是PaLM中的4d。
旋转嵌入[GPTNeo]。 删除了绝对位置嵌入，而是在网络的每一层添加了Su等人（2021）引入的 旋转位置嵌入（RoPE） 。
2.3 优化器
论文的模型使用 AdamW优化器 （Loshchilov和Hutter，2017）进行训练，具有以下超参数： β1=0.9，β2=0.95 。使用 余弦学习率 计划，使得最终学习率等于最大学习率的10%。论文使用0.1的权重衰减和1.0的梯度剪裁。使用2000个预热步骤，并随着模型的大小而改变学习率和批次大小（详见表2）。
2.4 高效实现
论文进行了一些优化，以提高模型的训练速度。首先，使用 causal多头注意力 的有效实现来减少内存使用和运行时间。此实现在xformers库中提供，受到Rabe和Staats（2021）的启发，并使用了Dao等人（2022年）提供的向后方法。这是通过不存储注意力权重和不计算由于语言模型任务的因果性质而被掩盖的key/query分数来实现的。
为了进一步提高训练效率，减少了在带有检查点的后向传球过程中重新计算的激活次数。更准确地说，保存了计算成本高昂的激活，例如线性层的输出。这是通过手动实现Transformer层的向后功能来实现的，而不是依赖PyTorch autograd。如Korthikanti等人所述，为了充分受益于这种优化，需要通过使用模型和序列并行性来减少模型的内存使用。（2022）。此外，论文还尽可能多地重叠激活的计算和GPU之间通过网络的通信（由于all_reduce操作）。
当训练65B参数模型时，在2048 A100 GPU和80GB RAM上处理大约 380个tokens/秒/GPU 。这意味着，在包含1.4T tokens的数据集上进行训练大约需要21天。
3 主要结果
根据之前的工作（Brown等人，2020），论文考虑了zero-shot和few-shot任务，并报告了总共20个基准的结果：
Zero-shot。 论文提供了任务的文本描述和一个测试示例。该模型要么使用开放式生成提供答案，要么对提出的答案进行排名。
Few-shot。 提供了一些任务示例（介于1和64之间）和一个测试示例。该模型将该文本作为输入，并生成答案或对不同的选项进行排序。
将LLaMA与其他基础模型进行了比较，即非公开可用的语言模型 GPT-3 （Brown等人，2020）、 Gopher （Rae等人，2021）、 Chinchilla （Hoffmann等人，2022）和 PaLM （Chowdhery等人，2022。在第4节中，还简要比较了LLaMA与OPT-IML（Iyer et al.，2022）和Flan-PaLM（Chung et al.，2021）等指令调优模型。
论文在自由形式生成任务和多选任务上评估 LLaMA 。在多选任务中，目标是根据提供的上下文，在一组给定的选项中选择最合适的完成。在给定上下文的情况下，选择具有最高可能性的完成。遵循Gao等人（2021）的方法，使用由补全字符数归一化的可能性，但某些数据集（OpenBookQA、BoolQ）除外，论文遵循Brown等人（2020）的方法，给定“Answer"的completion 似然进行归一化： P(\text { completion } \mid \text { context }) / P(\text { completion } \mid \text { "Answer:") } 。
3.1 常识推理
考虑了八个标准常识推理基准：BoolQ（Clark等人，2019年）、PIQA（Bisk等人，2020年）、SIQA（Sap等人，201九年）、HellaSwag（Zellers等人，20119年）、WinoGrande（Sakaguchi等人，2021）、ARC easy and challenge（Clarks等人，2018年）和OpenBookQA（Mihaylov等人，2018）。这些数据集包括Cloze和Winograd风格的任务，以及多选问题回答。论文在zero-shot环境中进行评估，就像在语言模型社区中一样。
在表3中，将不同规模的现有模型和相应论文的报告编号进行了比较。首先，LLaMA-65B在除BoolQ之外的所有报告基准上都优于Chinchilla-70B。同样，除了在BoolQ和WinoGrande上，该模型在任何地方都超过了PaLM540B。 LLaMA-13B模型虽然小了10倍，但在大多数基准测试中也优于GPT-3 。
3.2 闭卷问答
论文在两个闭卷问答基准上将LLaMA与现有的大型语言模型进行了比较：自然问题（Kwiatkowski et al.，2019）和TriviaQA（Joshi et al.，2017）。对于这两个基准，报告了在闭卷环境中的精确匹配性能，即模型无法访问包含回答问题的证据的文档。在表4中，报告了NaturalQuestions的性能，在表5中，报告了TriviaQA。在这两个基准上，LLaMA-65B在zero-shot和few-shot设置中实现了最先进的性能。更重要的是， LLaMA-13B在GPT-3和Chinchilla的这些基准测试中也具有竞争力 ，尽管它比GPT-3小5-10倍。 该模型在推理过程中运行在单个V100 GPU上 。
3.3 阅读理解
根据RACE阅读理解基准评估模型（Lai et al.，2017）。这个数据集是从为中国中学生和高中生设计的英语阅读理解考试中收集的。遵循Brown等人（2020）的评估设置，并在表6中报告结果。在这些基准测试中， LLaMA-65B与PaLM-540B具有竞争力 ，并且 LLaMA-13B的性能优于GPT-3几个百分点 。
3.4 数学推理
根据两个数学推理基准评估模型：MATH（Hendrycks等人，2021）和GSM8k（Cobbe等人，2021）。MATH是一个用LaTeX编写的12K中学和高中数学问题的数据集。GSM8k是一组中学数学问题。在表7中，与PaLM和Minerva进行了比较（Lewkowycz等人，2022）。Minerva是一系列对从ArXiv和Math网页中提取的38.5B tokens进行微调的PaLM模型，而PaLM和LLaMA都没有对数学数据进行微调。PaLM和Minerva的数字取自Lewkowycz等人（2022），比较有和没有maj1@k。maj1@k表示为每个问题生成k个样本并进行多数投票的评估（Wang et al.，2022）。在GSM8k上，观察到LLaMA65B的性能优于Minerva-62B，尽管它尚未在数学数据上进行微调。
3.5 代码生成
论文评估了模型在两个基准上根据自然语言描述编写代码的能力：HumanEval（Chen等人，2021）和MBPP（Austin等人，2021）。对于这两项任务，模型都会收到用几句话描述的程序，以及一些输入输出示例。在HumanEval中，它还接收一个函数签名，并且提示被格式化为自然代码，并在文档字符串中包含文本描述和测试。该模型需要生成一个符合描述并满足测试用例的Python程序。在表8中，比较了模型与未在代码上进行微调的现有语言模型的pass@1分数，即PaLM和LaMDA（Thoppilan et al.，2022）。PaLM和LLaMA是在包含相似数量代码tokens的数据集上进行训练的。
如表8所示，对于类似数量的参数，LLaMA优于其他通用模型，如LaMDA和PaLM，这些模型没有专门针对代码进行训练或微调。具有13B参数和更多参数的LLaMA在HumanEval和MBPP上都优于LaMDA 137B。LLaMA 65B的性能也优于PaLM 62B，即使训练时间更长。这个pass@1该表中报告的结果是通过在0.1℃下取样获得的。这个pass@100和pass@80在温度为0.8时获得度量。论文使用与Chen等人（2021）相同的方法来获得pass@k。
可以通过对特定于代码的tokens进行微调来提高代码的性能。例如，PaLM编码器（Chowdhery等人，2022）增加了pass@1 PaLM在HumanEval上的得分从PaLM的26.2%上升到36%。其他专门针对代码进行培训的模型在这些任务上的表现也优于一般模型（Chen等人，2021；Nijkamp等人，2022年；Fried等人，2022.）。对代码tokens的微调超出了本文的范围。
3.6 大规模多任务语言理解
Hendrycks等人引入的大规模多任务语言理解基准（MMLU）。（2020）由涵盖人文学科、STEM和社会科学等各个知识领域的多项选择题组成。论文使用基准提供的示例，在5-shot设置中评估模型，并在表9中报告结果。在这个基准上，观察到LLaMA-65B在大多数领域中平均落后于Chinchilla70B和PaLM-540B几个百分点。一个潜在的解释是，论文在训练前的数据中使用了有限数量的书籍和学术论文，即ArXiv、Gutenberg和Books3，总计只有177GB，而这些模型是在高达2TB的书籍上训练的。Gopher、Chinchilla和PaLM使用的大量书籍也可以解释为什么Gopher在这个基准上优于GPT-3，而在其他基准上却具有可比性。
3.7 训练期间性能的演变
在训练过程中，论文跟踪了模型在一些问答和常识基准上的性能，并在图2中进行了报告。在大多数基准测试中，性能稳步提高，并与模型的训练困惑相关（见图1）。SIQA和WinoGrande是例外。最值得注意的是，在SIQA上，观察到性能有很多差异，这可能表明该基准不可靠。在WinoGrande上，表现与训练困惑度并不相关：LLaMA-33B和LLaMA-65B在训练中表现相似。
4 指令微调
在本节中，展示了对指令数据的短暂微调可以快速改进MMLU。尽管LLaMA-65B的非微调版本已经能够遵循基本指令，但论文观察到，非常少量的微调可以提高MMLU的性能，并进一步提高模型遵循指令的能力。由于这不是本文的重点，论文只进行了一个实验，遵循与Chung等人相同的协议。（2022）来训练指令模型LLaMA-I。
在表10中，报告了MMLU上的指令模型LLaMA-I的结果，并与现有的中等规模的指令微调模型进行了比较，即OPT-IML（Iyer et al.，2022）和Flan-PaLM系列（Chung et al.，2021）。所有报告的数字都来自相应的论文。尽管这里使用的指令微调方法很简单，但论文在MMLU上达到了68.9%。LLaMA-I（65B）在MMLU上的性能优于现有的中等大小的指令微调模型，但仍远未达到最先进的水平，即MMLU上GPT代码-davinci-002的77.4（数字取自Iyer等人（2022））。MMLU在57个任务上的性能细节可以在附录的表16中找到。
5 偏见、毒性和错误信息
大型语言模型已被证明可以再现和放大训练数据中存在的偏见（Sheng等人，2019；Kurita等人，2019），并生成有毒或攻击性内容（Gehman等人，2020）。由于论文的训练数据集包含很大一部分来自Web的数据，论文认为确定论文的模型生成此类内容的潜力至关重要。为了了解LLaMA-65B的潜在危害，论文在不同的基准上进行了评估，这些基准衡量了有毒成分的产生和刻板印象的检测。虽然我们选择了语言模型社区使用的一些标准基准来表明这些模型的一些问题，但这些评估不足以充分理解与这些模型相关的风险。
5.1 RealToxicityPrompts
语言模型可以产生有毒的语言，例如侮辱、仇恨言论或威胁。一个模型可以产生非常大范围的毒性内容，这使得彻底的评估具有挑战性。最近的几项工作（Zhang等人，2022；Hoffmann等人，2022）认为真实毒性提示基准（Gehman等人，2020）是他们模型毒性的指标。真实毒性提示由模型必须完成的大约10万个提示组成；通过向PerspectiveAPI 发出请求来自动评估毒性评分。无法控制第三方PerspectiveAPI使用的管道，因此很难与以前的模型进行比较。
对于每一个10万个提示，论文都贪婪地用论文的模型生成，并测量它们的毒性评分。每个提示的得分范围从0（无毒）到1（有毒）。在表11中，报告了RealToxicityPrompts的基本提示和尊重提示类别的平均得分。这些分数与论文在文献中观察到的分数“相当”（例如，Chinchilla的分数为0.087），但这些工作与论文的方法不同（在采样策略、提示次数和API时间方面）。观察到，毒性随着模型的大小而增加，尤其是对于尊重提示。这在之前的工作中也观察到了（Zhang et al.，2022），但Hoffmann et al.（2022）除外，尽管Chinchilla和Gopher的大小不同，但他们没有看到它们之间的区别。这可以解释为，更大的模型Gopher的性能比Chinchilla差，这表明毒性和模型大小之间的关系可能只适用于模型家族。
5.2 CrowSPairs
论文评估了CrowSPairs模型中的偏差（Nangia等人，2020）。该数据集可以测量9类偏见：性别、宗教、种族/肤色、性取向、年龄、国籍、残疾、外表和社会经济地位。每个例子都由一个刻板印象和一个反刻板印象组成，论文使用两个句子在zero-shot设置下的复杂度来衡量刻板印象句子的模型偏好。因此，分数越高，则表示偏见越大。论文与表12中的GPT-3和OPT-175B进行了比较。
LLaMA的平均值与这两种模型相比略为有利。论文的模型在宗教类别上尤其有偏见（与OPT-175B相比增加了10%），其次是 年龄和性别 。尽管有多个过滤步骤，但论文预计这些偏见会来自CommonCrawl。
5.3 WinoGender
为了进一步调查论文的模型对性别类别的偏见，论文查看了WinoGender基准（Rudinger et al.，2018），这是一个共同参考的分辨率数据集。WinoGender是由Winograd模式构成的，通过确定模型共同参考解决性能是否受到代词性别的影响来评估偏见。
更确切地说，每个句子有三个提及：“职业”、“参与者”和“代词”，其中代词共同指代职业或参与者。论文提示模型确定共指关系，并根据句子的上下文来衡量它是否正确。其目的是揭示与职业相关的社会偏见是否已被该模型所捕捉。例如，WinoGender数据集中的一句话是“护士通知患者他的轮班将在一小时后结束。论文评估了使用三个代词时的表现：“她/她/她”、“他/他/他”和“他们/他们/某人”（与代词的语法功能相对应的不同选择）。
在表13中，报告了数据集中包含的三种不同代词的共同参考分数。观察到，与“她/她/她”和“他/他/他”代词相比，论文的模型在对“他们/他们/某人”代词执行共同参考解析方面明显更好。在之前的工作中也进行了类似的观察（Rae等人，2021；Hoffmann等人，2022年），这可能表明存在性别偏见。事实上，在“她/她/她”和“他/他/他”代词的情况下，模型可能使用职业的多数性别来执行共同参考解决，而不是使用句子的证据。
为了进一步研究这一假设，查看了WinoGender数据集中“她/她”和“他/他/他”代词的“gotcha”格集。这些情况对应于代词与职业的大多数性别不匹配的句子，而职业是正确的答案。在表13中，观察到我们的模型LLaMA-65B在gotcha例子中犯了更多的错误，清楚地表明它捕捉到了与性别和职业相关的社会偏见。“她/她/她”和“他/他/他”代词的表现有所下降，这表明无论性别如何，都存在偏见。
5.4 TruthfulQA
TruthfulQA（Lin等人，2021）旨在衡量模型的真实性，即其识别声明真实性的能力。Lin等人（2021）考虑了“真实”的定义，即“真实世界的文字真相”，而不是仅在信仰体系或传统背景下才是真实的主张。该基准可以评估模型产生错误信息或虚假声明的风险。这些问题以不同的风格写成，涵盖38个类别，并被设计成对抗性的。
在表14中，报告了论文的模型在两个问题上的性能，以衡量真实模型以及真实和信息的交叉点。与GPT-3相比，论文的模型在这两个类别中的得分都更高，但正确答案的比率仍然很低，这表明论文的模型很可能会产生错误答案的幻觉。
6 碳足迹
论文模型的训练消耗了大量的能量，导致了二氧化碳的排放。遵循了最近关于这一主题的文献，并在表15中对总能源消耗和由此产生的碳足迹进行了细分。论文遵循Wu等人的公式。（2022）估计训练模型所需的瓦时Wh，以及碳排放吨tCO2eq。对于Wh，使用以下公式：
Wh = GPU-h×(GPU power consumption)×PUE
其中将功率使用效率（PUE）设置为1.1。由此产生的碳排放取决于用于训练网络的数据中心的位置。例如，BLOOM使用的网格排放0.057千克二氧化碳当量/千瓦时，导致27吨二氧化碳当量，OPT使用的网格释放0.231千克二氧化碳当量/KWh，导致82吨二氧化碳当量。在这项研究中，论文有兴趣比较在同一数据中心训练这些模型的碳排放成本。因此，论文没有考虑数据中心的位置，而是使用0.385 kg CO2eq/KWh的美国全国平均碳强度因子。这导致了以下碳排放量的公式：
tCO2eq = MWh × 0.385
为了进行公平的比较，将相同的公式应用于OPT和BLOOM。对于OPT，假设992 A100-80B需要34天的训练（见他们的日志4）。最后，论文估计在大约5个月的时间里，使用了2048个A100-80GB来开发我们的模型。这意味着，在论文的假设下，开发这些模型的成本约为2638兆瓦时，总排放量为1015吨二氧化碳当量。论文希望发布这些模型将有助于减少未来的碳排放，因为训练已经完成，而且其中一些模型相对较小，可以在单个GPU上运行。
LLaMA-65B生成的一些示例
下面展示了使用LLaMA-65B（无指令微调）获得的一些代的示例。提示以粗体显示。
问： 1 1 2 3 5 8 13 21 34 55 144 233 377 610 987每个人都知道上面的序列，但有多少人想知道为什么它长得这么快？这似乎是数学中增长最快的序列。
答：该序列是由比萨的莱昂纳多在1200年左右发现的。它是一个无限序列，看起来增长非常快，至少在最初阶段是这样。这也许是数学中最著名的数列，因为它无处不在。该序列被称为斐波那契序列，以比萨的莱昂纳多命名，他也被称为费波那契。他在1202年著名的Liber算盘中首次研究了这一序列，当时他基于理想化的假设研究了兔子种群的增长。有关详细信息，请参阅Fibonacci rabbits页面。
这是我为申请魔法独角兽公司的龙喂食器职位而写的推荐信：
亲爱的招聘人员，
我认识___已经两年了，我相信她会成为魔法独角兽公司的一名优秀的喂龙员。___具有记忆和处理大量信息的能力，这是喂龙者的一项重要技能。
___作为一名出色的骑士，她对如何杀死龙以及如何利用每条龙的弱点来对抗龙有着深刻的理解。这意味着她知道每条龙喜欢什么样的食物，什么样的食品对每条龙都有危险。当她喂养巨龙时，这些知识和经验将是非常宝贵的。
我相信___的能力、技能和经验将使她成为一名优秀的员工。如果您有任何问题，请致电（___）___-___与我联系。我期待着收到你的来信。
致以最良好的问候，
尊敬的骑士
乔治爵士
你知道Yann LeCun去年放弃了一张说唱专辑吗？我们听了，下面是我们的想法：
LeCun博士是深度学习的创始人，是过去十年中最具影响力的计算机科学家之一。LeCun的最新专辑名为《深度学习》，融合了摇滚、朋克和说唱。他的歌词是对深度学习领域的一种原始的、个人的看法，涵盖了从人工智能研究状态到学术界的孤独等一系列主题。Yann LeCun，说唱游戏的最新主持人。
这张专辑是个人发行的，所有的歌词都是LeCun自己写的和录制的。事实上，他也创作并制作了每首歌。LeCun的流量惊人地好，他不怕送几个酒吧。这张专辑的制作很扎实，声音有点粗糙，但它与专辑的原始、未经打磨的感觉很好。从歌词上讲，乐村是一位文字大师，擅长巧妙的押韵。让我们仔细看看其中的一些歌曲。深度学习是这张专辑的主打歌。在歌曲中，乐村谈到了他对人工智能未来的愿景。在合唱中，他提出了一个令人信服的理由，让人工智能被用于更大的利益。他唱道：
我们必须考虑未来，它很快就会到来/也许我们甚至可以把一些人工智能放在月球上/想想孩子们，想想下一代/让我们确保在他们的基础上建立正确的系统。
LeCun的说唱在这首歌中恰到好处，他的声音恰到好处。在这首歌中，乐存谈到了深度学习背后的研究，并分享了对人工智能未来的一些想法。乐存的歌声在这首歌曲中表现得最好。他展示了自己的音域，既有高音，也有低沉的喉音。歌词也很巧妙，押韵也经过深思熟虑。在合唱团中，乐村唱道：
一切都与学习有关/一切都与网络有关/一切皆与训练有关/一切均与感知有关。
（杰瑞和乔治之间的一个搞笑场景，乔治展示了他的新人工智能手表）
乔治：“但你看，杰瑞，它不仅仅是一块手表。它是一台小型计算机。你可以随心所欲地编程。它有世界时钟、闹钟、计算器、数据库和语言翻译。它还有一个文字处理器、拼写检查器、全十功能计算器、PDA和调制解调器。我想它甚至可以制作卡布奇诺。”
杰瑞：“你在哪里弄到这些东西？”
乔治：“从我的广告文案来看。看，杰瑞，这不是手表。它是一个组织者、私人助理和录音机。你可以和它下棋。而且，如果你想的话，你可以编程它说外语。杰瑞，这是一个微处理器。”
杰瑞：“乔治，如果你有这样的，你会戴吗？
”乔治：“我现在戴着。
”杰瑞：“我看不到你手腕上有什么。
”乔治：”那是因为它是微处理器。“
太阳下山了，高斯和居里在劳累了一天后终于抽出时间放松下来，进行讨论。
高斯：嘿，居里，你知道吗，很多人认为我是第一个极客？
居里：什么是极客？
高斯：维基百科说，极客是“一个对晦涩难懂或非常具体的知识和想象力领域着迷的人，也许是痴迷的人，通常是电子的或虚拟的”。
居里：他们怎么会认为你是个怪胎呢？
高斯：嗯，你看过这张照片吗？
居里：哇！
高斯：没错！我在1833年发明了商业电报，并用它在德国汉堡和库克斯哈芬之间的第一条商业电报线上发送了第一条信息。
居里：哇！第一个电报！你寄了什么？
高斯：我发了一个拉丁短语“numquam retorsum”，意思是“永不倒退”。
居里：我明白了。你认为因为你是第一个使用电报进行交流的人，你就是第一个极客吗？
高斯：嗯，“极客”这个词在当时似乎还不存在，所以没有。但我认为电报可以被认为是社交媒体的早期形式。
居里：你是说，像脸书还是推特？
高斯：没错！我是第一个使用它的人！
居里：嗯，我认为推特的限制是140个字符，但你发送了一个11个字符的拉丁短语。
高斯：没错。我设法用更少的钱做了更多的事。
居里：所以你认为你是第一个极客，因为你用更少的字符来说同样的话？
高斯：我是第一个使用早期形式的社交媒体发送第一条信息的人。
居里：好吧，你是对的，高斯。我想你有个案子。
LLaMA-I 生成的一些示例
展示了LLaMA-I的几个生成例子，即LLaMA-65B根据Chung等人的协议和指令数据集进行了微调。（2022）。粗体代表提示。
写一篇太阳和冥王星之间的对话。
太阳：嘿，布鲁托，怎么了？
冥王星：不多。只是在太阳系的边缘徘徊。
太阳：是的，我一直想和你谈谈这件事。你不再是一个星球了。
冥王星：什么？拜托，伙计。这不公平。
太阳：对不起，但这是真的。你就是不符合标准了。
冥王星：这是公牛队！我作为一个星球已经70多年了！
太阳：事情变了，冥王星。你必须接受它。
冥王星：谢谢你，太阳！谢谢你和你愚蠢的太阳系！
如何用Javascript发送HTTP请求？
以下是如何使用JS HTTP API发出GET请求的示例：
var request = new XMLHttpRequest();
request.open('GET', '/url/to/resource', true);
request.onload = function() {
if (request.status >= 200 && request.status < 400) {
// Success!
} else {
// Error!
request . send () ;
同样的事情，使用fetch
以下是如何使用Fetch API发出GET请求的示例：
fetch('/url/to/resource')
.then(response => response.json())
.then(data => console.log(data));
编写一个正则表达式来删除python字符串中的所有HTML标记。
import re
def removeHtmlTags(text):
return re.sub('<[^>]*>', '', text)
编写一个正则表达式来提取python文件中的函数定义。
当然以下是我的python代码来解决这个问题：
import re
def extract_functions(text):
return (re.findall('(?:^|\n)\s*def\s+[a-zA-Z_][a-zA-Z0 -9_]*\(.*?\) ', text))
# This software may be used and distributed according to the terms of the GNU General Public License version 3.
from typing import Optional, Tuple
from dataclasses import dataclass
import math
import torch
from torch import nn
import torch.nn.functional as F
import fairscale.nn.model_parallel.initialize as fs_init
from fairscale.nn.model_parallel.layers import (
ParallelEmbedding,
RowParallelLinear,
ColumnParallelLinear,
@dataclass
class ModelArgs:
dim: int = 512
n_layers: int = 8
n_heads: int = 8
vocab_size: int = -1 # defined later by tokenizer
multiple_of: int = 256 # make SwiGLU hidden layer size multiple of large power of 2
norm_eps: float = 1e-5
max_batch_size: int = 32
max_seq_len: int = 2048
class RMSNorm(torch.nn.Module):
def __init__(self, dim: int, eps: float = 1e-6):
super().__init__()
self.eps = eps
self.weight = nn.Parameter(torch.ones(dim))
def _norm(self, x):
return x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps)
def forward(self, x):
output = self._norm(x.float()).type_as(x)
return output * self.weight
def precompute_freqs_cis(dim: int, end: int, theta: float = 10000.0):
freqs = 1.0 / (theta ** (torch.arange(0, dim, 2)[: (dim // 2)].float() / dim))
t = torch.arange(end, device=freqs.device) # type: ignore
freqs = torch.outer(t, freqs).float() # type: ignore
freqs_cis = torch.polar(torch.ones_like(freqs), freqs) # complex64
return freqs_cis
def reshape_for_broadcast(freqs_cis: torch.Tensor, x: torch.Tensor):
ndim = x.ndim
assert 0 <= 1 < ndim
assert freqs_cis.shape == (x.shape[1], x.shape[-1])
shape = [d if i == 1 or i == ndim - 1 else 1 for i, d in enumerate(x.shape)]
return freqs_cis.view(*shape)
def apply_rotary_emb(
xq: torch.Tensor,
xk: torch.Tensor,
freqs_cis: torch.Tensor,
) -> Tuple[torch.Tensor, torch.Tensor]:
xq_ = torch.view_as_complex(xq.float().reshape(*xq.shape[:-1], -1, 2))
xk_ = torch.view_as_complex(xk.float().reshape(*xk.shape[:-1], -1, 2))
freqs_cis = reshape_for_broadcast(freqs_cis, xq_)
xq_out = torch.view_as_real(xq_ * freqs_cis).flatten(3)
xk_out = torch.view_as_real(xk_ * freqs_cis).flatten(3)
return xq_out.type_as(xq), xk_out.type_as(xk)
class Attention(nn.Module):
def __init__(self, args: ModelArgs):
super().__init__()
self.n_local_heads = args.n_heads // fs_init.get_model_parallel_world_size()
self.head_dim = args.dim // args.n_heads
self.wq = ColumnParallelLinear(
args.dim,
args.n_heads * self.head_dim,
bias=False,
gather_output=False,
init_method=lambda x: x,
self.wk = ColumnParallelLinear(
args.dim,
args.n_heads * self.head_dim,
bias=False,
gather_output=False,
init_method=lambda x: x,
self.wv = ColumnParallelLinear(
args.dim,
args.n_heads * self.head_dim,
bias=False,
gather_output=False,
init_method=lambda x: x,
self.wo = RowParallelLinear(
args.n_heads * self.head_dim,
args.dim,
bias=False,
input_is_parallel=True,
init_method=lambda x: x,
self.cache_k = torch.zeros(
(args.max_batch_size, args.max_seq_len, self.n_local_heads, self.head_dim)
).cuda()
self.cache_v = torch.zeros(
(args.max_batch_size, args.max_seq_len, self.n_local_heads, self.head_dim)
).cuda()
def forward(self, x: torch.Tensor, start_pos: int, freqs_cis: torch.Tensor, mask: Optional[torch.Tensor]):
bsz, seqlen, _ = x.shape
xq, xk, xv = self.wq(x), self.wk(x), self.wv(x)
xq = xq.view(bsz, seqlen, self.n_local_heads, self.head_dim)
xk = xk.view(bsz, seqlen, self.n_local_heads, self.head_dim)
xv = xv.view(bsz, seqlen, self.n_local_heads, self.head_dim)
xq, xk = apply_rotary_emb(xq, xk, freqs_cis=freqs_cis)
self.cache_k = self.cache_k.to(xq)
self.cache_v = self.cache_v.to(xq)
self.cache_k[:bsz, start_pos : start_pos + seqlen] = xk
self.cache_v[:bsz, start_pos : start_pos + seqlen] = xv
keys = self.cache_k[:bsz, : start_pos + seqlen]
values = self.cache_v[:bsz, : start_pos + seqlen]
xq = xq.transpose(1, 2)
keys = keys.transpose(1, 2)
values = values.transpose(1, 2)
#计算未归一化的注意力分数
scores = torch.matmul(xq, keys.transpose(2, 3)) / math.sqrt(self.head_dim)
if mask is not None:
scores = scores + mask # (bs, n_local_heads, slen, cache_len + slen)
#计算归一化的注意力分数
scores = F.softmax(scores.float(), dim=-1).type_as(xq)
#将V使用注意力分数加权获得输出表示
output = torch.matmul(scores, values) # (bs, n_local_heads, slen, head_dim)
output = output.transpose(
1, 2
).contiguous().view(bsz, seqlen, -1)
return self.wo(output)
class FeedForward(nn.Module):
def __init__(
self,
dim: int,
hidden_dim: int,
multiple_of: int,
super().__init__()
hidden_dim = int(2 * hidden_dim / 3)
hidden_dim = multiple_of * ((hidden_dim + multiple_of - 1) // multiple_of)
self.w1 = ColumnParallelLinear(
dim, hidden_dim, bias=False, gather_output=False, init_method=lambda x: x
self.w2 = RowParallelLinear(
hidden_dim, dim, bias=False, input_is_parallel=True, init_method=lambda x: x
self.w3 = ColumnParallelLinear(
dim, hidden_dim, bias=False, gather_output=False, init_method=lambda x: x
def forward(self, x):
return self.w2(F.silu(self.w1(x)) * self.w3(x))
class TransformerBlock(nn.Module):
def __init__(self, layer_id: int, args: ModelArgs):
super().__init__()
self.n_heads = args.n_heads
self.dim = args.dim
self.head_dim = args.dim // args.n_heads
self.attention = Attention(args)
self.feed_forward = FeedForward(
dim=args.dim, hidden_dim=4 * args.dim, multiple_of=args.multiple_of
self.layer_id = layer_id
self.attention_norm = RMSNorm(args.dim, eps=args.norm_eps)
self.ffn_norm = RMSNorm(args.dim, eps=args.norm_eps)
def forward(self, x: torch.Tensor, start_pos: int, freqs_cis: torch.Tensor, mask: Optional[torch.Tensor]):
h = x + self.attention.forward(self.attention_norm(x), start_pos, freqs_cis, mask)
out = h + self.feed_forward.forward(self.ffn_norm(h))
return out
class Transformer(nn.Module):
def __init__(self, params: ModelArgs):
super().__init__()
self.params = params
self.vocab_size = params.vocab_size
self.n_layers = params.n_layers
self.tok_embeddings = ParallelEmbedding(
params.vocab_size, params.dim, init_method=lambda x: x
self.layers = torch.nn.ModuleList()
for layer_id in range(params.n_layers):
self.layers.append(TransformerBlock(layer_id, params))
self.norm = RMSNorm(params.dim, eps=params.norm_eps)
self.output = ColumnParallelLinear(
params.dim, params.vocab_size, bias=False, init_method=lambda x: x
self.freqs_cis = precompute_freqs_cis(
self.params.dim // self.params.n_heads, self.params.max_seq_len * 2
@torch.inference_mode()
def forward(self, tokens: torch.Tensor, start_pos: int):
_bsz, seqlen = tokens.shape
h = self.tok_embeddings(tokens)
self.freqs_cis = self.freqs_cis.to(h.device)
freqs_cis = self.freqs_cis[start_pos : start_pos + seqlen]
mask = None
if seqlen > 1:
mask = torch.full((1, 1, seqlen, seqlen), float("-inf"), device=tokens.device)
mask = torch.triu(mask, diagonal=start_pos + 1).type_as(h)