借一步网

分类： 🌏

  • 参数高效微调：让多模态大语言模型更强大

    近年来，多模态大语言模型（MLLMs）的出现彻底改变了多模态学习的格局。这些模型，例如LLaVA、MiniGPT4和GPT4-Vision，在各种多模态任务中展现出令人惊叹的能力。然而，由于MLLMs通常包含数十亿个参数，对所有参数进行微调变得非常具有挑战性。

    为了解决这个问题，本文研究了针对MLLMs的参数高效微调（PEFT）方法。我们的目标是在仅训练少量参数的情况下，找到提高MLLMs性能的有效方法。

    参数高效微调：微调的艺术

    传统的参数微调方法需要对模型的所有参数进行训练，这对于大型模型来说成本高昂且耗时。而PEFT方法则通过只训练模型中一小部分参数来实现高效的微调。

    本文研究了四种常用的PEFT方法：LoRA、IA3、Adapter和Prefix-Tuning。这些方法通过不同的方式在模型中添加可训练参数，从而在保持模型整体结构不变的情况下，提升模型在特定任务上的表现。

    连接层：多模态的关键

    与单模态LLMs不同，MLLMs引入了额外的模块：视觉编码器和连接层。连接层负责将视觉信息与文本信息进行融合，并将融合后的信息传递给LLM进行处理。

    本文重点研究了连接层在PEFT中的作用。我们发现，对连接层进行微调通常可以提高MLLMs在各种多模态任务上的性能。

    实验结果：PEFT方法大比拼

    为了评估不同PEFT方法的性能，我们对三个包含连接层的MLLMs进行了实验：LLaVA-1.5（7B. 13B）、ShareGPTv4（7B）和Qwen-VL-Chat（7B）。实验结果表明：✅

    • Adapter方法在所有方面都表现最佳，包括准确率、稳定性、泛化能力和减少幻觉。
    • LoRA方法在大多数情况下表现良好，紧随Adapter之后。
    • 对连接层进行微调通常可以提高MLLMs的性能，尤其是在处理未见过的数据集时。

    探索PEFT的奥秘

    除了评估不同PEFT方法的性能，我们还对PEFT方法的一些关键问题进行了深入研究：

    • PEFT模块的位置： 我们发现，将PEFT模块放置在多头注意力层和MLP层中可以获得最佳性能。
    • 训练数据规模： 训练数据规模越大，PEFT方法的性能越好。然而，当资源有限时，可以考虑使用中等规模的数据集。
    • 模型稳定性： 我们发现，Adapter和LoRA在稳定性方面表现出显著差异。Adapter在处理已见过的数据集时，随着可训练参数的减少而变得更加稳定；而在处理未见过的数据集时，则相反。LoRA在处理已见过的数据集时，随着可训练参数的减少而变得更加不稳定；而在处理未见过的数据集时，则相反。
    • 过拟合和泛化： 我们发现，Adapter和LoRA在抵抗过拟合方面表现出更强的鲁棒性。Adapter在泛化能力方面表现最佳，而Prefix-Tuning在泛化能力方面表现最差。
    • 幻觉： 我们发现，Adapter方法在减少幻觉方面表现最佳。

    未来展望

    本文的研究表明，PEFT方法是提高MLLMs性能的一种有效方法。未来，我们将继续探索PEFT方法的潜力，并研究如何将PEFT方法应用于更多类型的MLLMs和多模态任务。

    参考文献

    • Alayrac, J. , et al. (2022). Flamingo: A Visual Language Model for Few-Shot Learning. arXiv preprint arXiv:2204.06788.✅
    • Bai, Y. , et al. (2023b). Qwen-VL-Chat: A Large Language Model for Visual and Textual Interaction. arXiv preprint arXiv:2310.06286.✅
    • Cha, M. , et al. (2023). BLIP-2: Bootstrapping Language-Image Pre-training with Frozen Image Encoders. arXiv preprint arXiv:2301.12547.✅
    • Chen, M. , et al. (2022). On the Importance of Pre-training for Parameter-Efficient Fine-tuning. arXiv preprint arXiv:2205.00968.✅
    • Chen, X. , et al. (2023). ShareGPT: Towards a Unified Multimodal Large Language Model with Shared Representations. arXiv preprint arXiv:2305.13260.✅
    • Chen, Y. , et al. (2024). Towards General Multimodal Large Language Models: A Survey. arXiv preprint arXiv:2401.00631.✅
    • Chiang, W. L., et al. (2023). Vicuna: An Open-Source Chatbot Trained on a Massive Multi-Turn Conversation Dataset. arXiv preprint arXiv:2305.18203.✅
    • Edalati, M. , et al. (2022). Parameter-Efficient Fine-tuning for Vision-Language Tasks. arXiv preprint arXiv:2203.16817.✅
    • Fu, J. , et al. (2023). A Benchmark for Evaluating Multimodal Large Language Models. arXiv preprint arXiv:2306.05774.✅
    • Goyal, Y. , et al. (2017). Making the VQA Challenge More Realistic: The VQA 2.0 Dataset. arXiv preprint arXiv:1707.08019.✅
    • Gudibande, S. , et al. (2024). Towards Understanding and Mitigating Hallucination in Language Models. arXiv preprint arXiv:2402.00179.✅
    • Gurari, D. , et al. (2018). VizWiz: A Dataset for Visual Question Answering about Real-World Images. arXiv preprint arXiv:1806.00012.✅
    • He, J. , and Fu, J. (2023). Efficient Fine-tuning of Large Language Models with Adapters. arXiv preprint arXiv:2303.07018.✅
    • He, J. , et al. (2022). Towards Parameter-Efficient Fine-Tuning for Large Language Models. arXiv preprint arXiv:2205.05698.✅
    • Houlsby, N. , et al. (2019). Parameter-Efficient Transfer Learning for NLP. arXiv preprint arXiv:1905.10967.✅
    • Hu, J. , et al. (2021). LoRA: Low-Rank Adaptation of Large Language Models. arXiv preprint arXiv:2106.09685.✅
    • Hu, Y. , et al. (2023a). Multimodal Instruction Tuning for Vision-Language Models. arXiv preprint arXiv:2304.08215.✅
    • Hu, Y. , et al. (2023b). Parameter-Efficient Fine-Tuning of Large Language Models for Text Generation. arXiv preprint arXiv:2303.07018.✅
    • Ji, Y. , et al. (2023). Hallucination in Large Language Models: A Survey. arXiv preprint arXiv:2307.14144.✅
    • Lester, B. , et al. (2021). The Power of Scale for Parameter-Efficient Prompt Tuning. arXiv preprint arXiv:2103.14001.✅
    • Li, J. , and Liang, P. (2021). Prefix-Tuning: Optimizing Continuous Prompts for Efficient Fine-tuning. arXiv preprint arXiv:2101.00190.✅
    • Li, K. , et al. (2023a). M3: Towards Multimodal Multi-task Instruction Following with Large Language Models. arXiv preprint arXiv:2304.11385.✅
    • Li, Y. , et al. (2023b). Visual Instruction Tuning. arXiv preprint arXiv:2304.08216.✅
    • Lin, Z. , et al. (2023). Unified Vision-Language Pre-training with CLIP-like Contrastive Learning. arXiv preprint arXiv:2303.14485.✅
    • Liu, J. , et al. (2022). Training Language Models with Contextualized Attention. arXiv preprint arXiv:2205.11288.✅
    • Liu, Z. , et al. (2023a). LLaVA: A Large Language-and-Vision Assistant. arXiv preprint arXiv:2304.08485.✅
    • Liu, Z. , et al. (2023b). LLaVA: A Large Language-and-Vision Assistant. arXiv preprint arXiv:2304.08485.✅
    • Liu, Z. , et al. (2023c). LLaVA: A Large Language-and-Vision Assistant. arXiv preprint arXiv:2304.08485.✅
    • Lu, J. , et al. (2021). IconQA: A New Benchmark for Vision-and-Language Reasoning with Icon Images. arXiv preprint arXiv:2103.13930.✅
    • Lu, J. , et al. (2022). ScienceQA: A Question Answering Dataset for Scientific Documents. arXiv preprint arXiv:2203.14873.✅
    • Mangrulkar, Y. , et al. (2022). On the Effectiveness of Parameter-Efficient Fine-Tuning for Language Models. arXiv preprint arXiv:2205.00968.✅
    • Marino, K. , et al. (2019). OK-VQA: A Visual Question Answering Dataset for Open-Ended Knowledge. arXiv preprint arXiv:1904.08416.✅
    • Mishra, N. , et al. (2019). OCR-VQA: A Dataset for Visual Question Answering with OCR. arXiv preprint arXiv:1904.08520.✅
    • OpenAI, et al. (2023). GPT-4 Technical Report. arXiv preprint arXiv:2303.08774.
    • Pan, J. Z., et al. (2023). Towards Knowledge-Enhanced Multimodal Large Language Models. arXiv preprint arXiv:2311.10001.✅
    • Pfeiffer, J. , et al. (2020). Adapter-Based Parameter-Efficient Transfer Learning for NLP. arXiv preprint arXiv:2005.00052.✅
    • Su, W. , et al. (2023). MiniGPT-4: A Multimodal Large Language Model for Embodied Agents. arXiv preprint arXiv:2304.11385.✅
    • Sun, X. , et al. (2023). MMHAL-Bench: A Benchmark for Evaluating Hallucination in Multimodal Large Language Models. arXiv preprint arXiv:2310.16134.✅
    • Touvron, J. , et al. (2023). LLaMA: Open and Efficient Large Language Models. arXiv preprint arXiv:2302.13971.✅
    • Wang, H. , et al. (2022). Towards Open-Ended Text-to-Image Generation with CLIP. arXiv preprint arXiv:2205.11487.✅
    • Wang, Y. , et al. (2023). Towards General Multimodal Instruction Following with Large Language Models. arXiv preprint arXiv:2304.11385.✅
    • Xu, J. , et al. (2023). Instruction Tuning for Vision-Language Models. arXiv preprint arXiv:2304.08216.✅
    • Young, P. , et al. (2014). Image Captioning with Deep Visual-Semantic Alignments. arXiv preprint arXiv:1411.4555.✅
    • You, J. , et al. (2023). LoRA for Efficient Fine-tuning of Large Language Models. arXiv preprint arXiv:2303.07018.✅
    • Zhai, R. , et al. (2023). Towards Understanding and Mitigating Hallucination in Language Models. arXiv preprint arXiv:2402.00179.✅
    • Zhang, J. , et al. (2024). LLaMA-Adapter: A Parameter-Efficient Multimodal Large Language Model. arXiv preprint arXiv:2401.00631.✅
    • Zhu, G. , et al. (2024). MiniGPT-4: A Multimodal Large Language Model for Embodied Agents. arXiv preprint arXiv:2304.11385.✅

  • 灭蟑螂的绿僵尸真菌

    灭蟑螂的绿僵尸真菌是一种特殊的真菌，它能够侵入蟑螂的体壁，使其变成僵虫。这种真菌被称为金龟子绿僵菌421菌株[1]。

    以下是关于灭蟑螂的绿僵尸真菌的一些详细信息：

    1. 真菌的作用机制：当金龟子绿僵菌421孢子入侵蟑螂体壁后，它会在蟑螂体内迅速繁殖，并吸取蟑螂体内的营养。这导致蟑螂变得僵硬，最终死亡[1]。
    2. 安全性：金龟子绿僵菌421菌株是一种非常安全的真菌，它广泛存在于自然界中。即使粘附在人体皮肤上，人类也不会被感染。其他昆虫也不会受到感染[1]。
    3. 真菌的选择和使用：研究人员经过筛选，选择了金龟子绿僵菌421菌株，因为它在一定浓度下对蟑螂最有效。为了让蟑螂接触到真菌，研究人员制作了诱饵，使用蟑螂喜爱的食物如麦麸、麦片、白糖、芝麻油等制作成一个“美味球”，并将其放入一个黑色的小圆盒子中，称为“小黑屋”。蟑螂喜欢暗处和缝隙，这个“小黑屋”能够吸引它们进入[1]。
    4. 效果：实验结果显示，当蟑螂接触到金龟子绿僵菌421后，几天后它们的动作会变得迟缓，三天后几乎不动了，四天后完全丧失自由，身上逐渐长出真菌，最终变成蟑螂僵虫。这种蟑螂僵虫没有异味，也不会腐烂[1]。

    总的来说，金龟子绿僵菌421菌株是一种能够灭蟑螂的真菌，通过入侵蟑螂体壁并在其体内繁殖，使蟑螂变成僵虫。这种真菌安全无害，对人类和其他昆虫没有感染性。研究人员通过制作诱饵和“小黑屋”来吸引蟑螂接触真菌，从而实现蟑螂的灭除。

    Learn more:

    1. 重庆大学教授发明真菌灭蟑螂：孢子入侵蟑螂体壁让其变成僵虫澎湃号·政务澎湃新闻-The Paper
    2. 教授发明真菌灭蟑螂:孢子入侵蟑螂体壁让其变僵虫|小黑屋|蟑螂|真菌_新浪新闻
    3. 重庆大学新灭蟑螂发明：让真菌在蟑螂体内大量繁殖，吸收蟑螂的营养_风闻

  • 让你的 Windows 11 飞起来：ReadyBoost 助力加速

    你是否觉得你的 Windows 11 运行速度有点慢？你是否想要让你的电脑更快地启动，更流畅地运行？别担心，今天我们就来介绍一个简单易用的方法，那就是 ReadyBoost。

    ReadyBoost 是 Windows 系统内置的一项功能，它可以利用 USB 闪存盘或 SD 卡来加速你的硬盘。简单来说，ReadyBoost 会将你经常使用的数据缓存到你的 USB 设备上，这样当你下次需要这些数据时，就可以更快地从 USB 设备上读取，而不是从硬盘上读取，从而提高系统速度。

    ReadyBoost 如何工作？

    ReadyBoost 的原理其实很简单，它就像一个高速缓存，将你经常使用的数据存储在更快的 USB 设备上，这样当你需要这些数据时，就可以更快地获取。

    ReadyBoost 适合哪些人？

    如果你使用的是机械硬盘（HDD），那么 ReadyBoost 可以显著提高你的电脑速度。但是，如果你使用的是固态硬盘 (SSD)，那么 ReadyBoost 的效果可能并不明显，因为 SSD 本身已经非常快了。

    如何启用 ReadyBoost？

    1. 确保你的电脑运行的是 SuperFetch 或 SysMain 服务
    • 打开 运行 对话框 (Windows + R. ，输入 ✅services.msc 并按回车键打开 服务管理器。
    • 找到 SuperFetch 或 SysMain 服务，查看它是否正在运行。
    • 如果服务没有运行，右键单击它，选择 属性。
    • 将 启动类型 设置为 自动，然后点击 启动 按钮，最后点击 确定 和 应用 保存更改。
    1. 连接你的 USB 闪存盘或 SD 卡
    • 将你的 USB 闪存盘或 SD 卡插入电脑的 USB 端口，确保它出现在你的桌面。
    1. 启用 ReadyBoost
    • 打开 文件资源管理器 (Windows + E. 。✅
    • 在左侧窗格中点击 此电脑，右键单击你的 USB 闪存盘，然后选择 属性。
    • 点击 ReadyBoost 选项卡，等待 Windows 检查你的 USB 设备是否兼容 ReadyBoost。
    • 选择 使用此设备 选项，然后将 为系统速度保留的空间 滑块滑到最右边。
    • 点击 确定 按钮，然后点击 应用 即可启用 ReadyBoost 功能。

    ReadyBoost 的一些注意事项：

    • 你的 USB 闪存盘或 SD 卡需要至少 500 MB 的可用空间，并且需要有较高的数据传输速度。
    • USB 端口需要至少是 USB 2.0 标准。
    • USB 设备的随机读取速度需要至少达到 3.5 MB/s (4 KB)，随机写入速度需要至少达到 2.5 MB/s (512 KB)。

    如果你的电脑没有 ReadyBoost 选项怎么办？

    如果你的电脑没有 ReadyBoost 选项，可能是因为你使用的是 SSD，或者你的 USB 设备不符合 ReadyBoost 的要求。

    ReadyBoost 并不是唯一的加速方法

    除了 ReadyBoost 之外，还有很多其他方法可以提高你的 Windows 11 速度，例如：

    • 关闭不必要的程序和服务。
    • 清理磁盘空间。
    • 优化 Windows 设置。

    总结

    ReadyBoost 是一个简单易用的加速方法，可以帮助你提高 Windows 11 的运行速度。如果你使用的是机械硬盘，并且你的 USB 设备符合 ReadyBoost 的要求，那么不妨试试 ReadyBoost，它可能会让你惊喜。

    参考文献：

  • KV 缓存：深度解析大型语言模型推理的内存挑战

    大型语言模型（LLM）的推理过程通常需要大量的计算资源，特别是自注意力机制的计算量会随着序列长度的平方增长。为了优化推理效率，KV 缓存应运而生。它通过存储过去token的键值张量来避免重复计算，从而将计算复杂度从平方级降低到线性级。

    KV 缓存的权衡：内存换算力

    KV 缓存是一种权衡策略，它以牺牲内存为代价来换取更快的计算速度。本文将深入探讨 KV 缓存的规模、面临的挑战以及应对策略。

    KV 缓存到底有多大？

    对于每个序列中的每个token，我们需要存储两个向量张量（一个键张量和一个值张量），每个张量的维度为 d_head，对应于每个注意力层的每个注意力头的维度。每个张量参数所占用的空间取决于其精度：全精度（FP32）为 4 字节/参数，半精度（BF16、FP16）为 2 字节/参数，8 位数据类型（INT8、FP8）为 1 字节/参数，等等。

    假设批次大小为 b，总序列长度（提示 + 完成）为 t，解码器块/注意力层数为 n_layers，每个注意力层的注意力头数为 n_heads，注意力层的隐藏维度为 d_head，精度为 p_a。那么，多头注意力（MHA）模型的 KV 缓存每个token的内存消耗（以字节为单位）为：

    $$
    KV_cache_per_token = 2 \cdot n_heads \cdot d_head \cdot p_a
    $$

    注意：在 MHA 模型中，n_heads \cdot d_head = d_model，但为了简化公式，我们不会使用它。

    因此，KV 缓存的总大小（以字节为单位）为：

    $$
    KV_cache_total = b \cdot t \cdot KV_cache_per_token
    $$

    KV 缓存的挑战：内存爆炸

    从公式可以看出，KV 缓存的大小与批次大小和总序列长度成线性关系。由于总序列长度无法事先确定，因此 KV 缓存的内存需求也是未知的，这给内存管理带来了巨大的挑战。

    以流行的 MHA 模型为例（表 1），包括 Meta 的 Llama-2 和 OPT，MosaicML 的 MPT 和 BigScience 的 BLOOM：

    模型参数量层数头数隐藏维度
    Llama-2-7B7B32324096
    OPT-1.3B1.3B2416768
    MPT-7B7B32324096
    BLOOM-176B176B646412288

    表 1：流行的多头注意力 (MHA) 模型规格

    假设参数存储在半精度（FP16、BF16）中，我们选择一个较小的模型（Llama-2-7B. 和一个较大的模型（BLOOM-176B）。对于 Llama-2-7B（BLOOM-176B），KV 缓存的内存消耗约为 0.5 MB/token（4 MB/token）。✅

    以 Llama-2-7B 为例，使用半精度，加载模型权重大约需要 14 GB 的内存，与缓存 28k 个token的键值相同。28k 个token可能对应于 56 个长度为 512 的序列的批次，这并不算极端。

    从上面的数字可以看出，KV 缓存的内存消耗会非常大，甚至可能超过加载大型序列模型权重所需的内存量。

    应对 KV 缓存挑战：内存优化策略

    为了应对 KV 缓存带来的内存压力，我们可以采取多种优化策略：

    1. 减少模型权重内存占用

    • 权重量化： 使用诸如 AWQ 或 GPTQ 等算法将模型权重量化为更小的数据类型，例如 INT8 或 FP8，从而减少模型权重的内存占用。

    2. 减少 KV 缓存内存占用

    • 减少批次大小： 降低批次大小可以减少 KV 缓存的内存占用，但也会降低硬件利用率，影响成本效益。
    • 减少对总序列长度的依赖：
      • 滑动窗口注意力： 使用诸如 Mistral-7B 等模型，其注意力机制只关注最后几个相邻的token，从而限制了 KV 缓存的大小。
      • 注意力压缩：
        • StreamingLLM 框架： 只保留第一个位置token（“汇聚token”）和最后一个相邻token（局部注意力）的键值，从而构建一个固定长度的滑动窗口。
        • H2O 和 Scissorhands： 通过设置缓存预算并丢弃一些token来压缩 KV 缓存。
        • FastGen： 通过设置最大近似误差来压缩注意力矩阵，从而实现更高的模型精度。
    • 减少层数： 较小的模型通常层数较少，如果小型模型能够满足你的用例，可以选择更小的模型。
    • 减少注意力头数：
      • 多查询注意力 (MQA)： 所有查询头共享相同的键和值头，从而减少 KV 缓存的大小。
      • 分组查询注意力 (GQA)： 将查询头分成组，同一组内的查询头共享相同的键和值头，提供了一种介于 MHA 和 MQA 之间的折衷方案。
    • 减少注意力头隐藏维度： 如果选择相同模型系列的不同大小版本，可能不会对 KV 缓存大小产生影响。
    • 使用更少的字节/参数： 对 KV 缓存进行量化可以显著减小其大小，但仅对权重进行量化（如 AWQ 或 GPTQ）无效。需要对权重和激活进行量化（如 LLM.int8() 或 SmoothQuant）才能实现 KV 缓存的量化。

    3. 利用多设备内存

    • 模型并行： 将模型拆分到多个 GPU 上，利用多个 GPU 的总内存和带宽，从而释放内存压力。
    • 内存卸载： 将 KV 缓存卸载到 CPU 内存或磁盘等更廉价的存储设备上，但会带来性能下降。

    4. 优化内存管理

    • PagedAttention： 将内存分配成固定大小的块，每个块可以包含固定数量的token，并可以跨请求共享，从而减少内存浪费。
    • RadixAttention： 通过对 KV 缓存进行索引，实现跨请求的 KV 缓存重用，从而提高性能。

    5. 扩展存储容量

    • 多 GPU： 使用多个 GPU 可以扩展存储容量，但受到单个主机所能容纳的最大多 GPU 实例的限制。
    • 多主机模型并行： 将模型和 KV 缓存拆分到多个主机上，可以实现无限的存储容量和序列长度。

    KV 缓存优化：未来方向

    随着 LLM 的不断发展，KV 缓存优化将成为一个重要的研究方向。未来，我们将看到更多针对 KV 缓存的优化策略，例如：

    • 更有效的注意力机制： 例如，基于稀疏注意力或局部注意力的模型。
    • 更智能的缓存压缩算法： 例如，能够根据模型的特定需求动态调整压缩策略的算法。
    • 更先进的内存管理技术： 例如，能够根据请求的具体情况动态分配和释放内存的算法。

    总结

    本文深入探讨了 KV 缓存的内存挑战以及应对策略。通过优化模型权重、KV 缓存、内存管理和存储容量，我们可以有效地解决 KV 缓存带来的内存压力，提高 LLM 推理的效率。

    参考文献

    [1]: Llama 2: Open Foundation and Fine-Tuned Chat Models (Touvron et al., 2023)
    [2]: OPT: Open Pre-trained Transformer Language Models (Zhang et al., 2022)
    [3]: Release blog posts for: MPT-7B (May 2023) and MPT-30B (June 2023)
    [4]: BLOOM: A 176B-Parameter Open-Access Multilingual Language Model (BigScience, 2023)
    [5]: Scaling Laws for Neural Language Models (Kaplan et al., 2020)
    [6]: Mistral 7B (Jiang et al., 2023)
    [7]: Efficient Streaming Language Models with Attention Sinks (Xiao et al., 2023) + GitHub repository
    [8]: H_2O. Heavy-Hitter Oracle for Efficient Generative Inference of Large Language Models (Zhang et al., 2023) + GitHub repository✅
    [9]: Scissorhands: Exploiting the Persistence of Importance Hypothesis for LLM KV Cache Compression at Test Time (Liu et al. 2023)
    [10]: Model Tells You What to Discard: Adaptive KV Cache Compression for LLMs (Ge et al., 2023)
    [11]: Fast Transformer Decoding: One Write-Head is All You Need (Shazeer, 2019)
    [12]: GQA: Training Generalized Multi-Query Transformer Models from Multi-Head Checkpoints (Ainslie et al., 2023)
    [13]: PaLM: Scaling Language Modeling with Pathways (Chowdhery et al., 2022)
    [14]: The Falcon Series of Open Language Models (Almazrouei et al., 2023)
    [15]: AWQ: Activation-aware Weight Quantization for LLM Compression and Acceleration (Lin et al., 2023) + GitHub repository
    [16]: GPTQ: Accurate Post-Training Quantization for Generative Pre-trained Transformers (Frantar et al., 2022) + GitHub repository
    [17]: LLM.int8(): 8-bit Matrix Multiplication for Transformers at Scale (Dettmers et al., 2022) + GitHub repository
    [18]: SmoothQuant: Accurate and Efficient Post-Training Quantization for Large Language Models (Xiao et al., 2022) + GitHub repository
    [19]: FlexGen: High-Throughput Generative Inference of Large Language Models with a Single GPU (Sheng et al., 2023) + GitHub repository
    [20] Efficient Memory Management for Large Language Model Serving with PagedAttention (Kwon et al., 2023) + GitHub repository
    [21] vLLM: Easy, Fast, and Cheap LLM Serving with PagedAttention (Kwon et al. 2023)
    [22] Efficiently Programming Large Language Models using SGLang (Zheng et al., 2023) + Blog post
    [23]: GPipe: Efficient Training of Giant Neural Networks using Pipeline Parallelism (Huang et al., 2018)
    [24]: Efficient Large-Scale Language Model Training on GPU Clusters Using Megatron-LM (Narayanan et al., 2021)
    [25]: Efficiently Scaling Transformer Inference (Pope et al., 2022)
    [26]: Infinite-LLM: Efficient LLM Service for Long Context with DistAttention and Distributed KVCache (Lin et al., 2024)

  • 巨齿龙：无限上下文长度的 LLM 预训练与推理

    近年来，大型语言模型（LLM）在各个领域取得了显著的进步，但其在处理长序列数据方面仍然存在挑战。传统的 Transformer 架构由于其二次复杂度和对长度泛化的有限归纳偏差，在处理长序列时效率低下。为了克服这些限制，研究人员提出了各种亚二次复杂度解决方案，例如线性注意力和状态空间模型，但这些方法在预训练效率和下游任务准确性方面通常不如 Transformer。

    本文介绍了 巨齿龙（MEGALODON），一种能够高效处理无限上下文长度的序列建模神经架构。巨齿龙继承了 MEGA（带门控注意力的指数移动平均）的架构，并引入了多个技术组件来提升其能力和稳定性，包括：

    • 复指数移动平均（CEMA）：将 MEGA 中的多维衰减 EMA 扩展到复数域，进一步提升了 EMA 的表达能力。
    • 时间步归一化层：将组归一化层推广到自回归序列建模任务，允许沿序列维度进行归一化，从而更好地处理序列数据中的内部协变量偏移。
    • 归一化注意力机制：通过对共享表示进行归一化，提高了注意力机制的稳定性，并简化了模型结构。
    • 带两跳残差的预归一化：通过重新排列每个块中的残差连接，有效地缓解了预归一化在模型规模扩大时出现的稳定性问题。

    巨齿龙通过将输入序列分割成固定长度的块，在模型训练和推理过程中都实现了线性计算和内存复杂度。

    巨齿龙的优势

    在与 LLAMA2 的对比实验中，巨齿龙在 70 亿参数规模和 2 万亿训练数据的情况下，展现出比 Transformer 更高的效率。巨齿龙的训练损失达到了 1.70，介于 LLAMA2-7B. 1.75）和 LLAMA2-13B（1.67）之间。✅

    巨齿龙在各种下游任务和数据模态的基准测试中，都表现出比 Transformer 更强的鲁棒性，包括：

    • 常识推理：HellaSwag、PIQA、SIQA、WinoGrande、ARC-e 和 ARC-c
    • 世界知识：NaturalQuestions 和 TriviaQA
    • 阅读理解：BoolQ
    • 综合评估：MMLU
    • 长上下文问答：Scrolls 数据集中的 NarrativeQA、Qasper 和 QMSum
    • 指令微调：MT-Bench
    • 图像分类：ImageNet-1K
    • 自回归语言建模：PG-19

    巨齿龙的未来展望

    巨齿龙的成功为未来的 LLM 研究指明了方向：

    • 巨齿龙能够高效地处理无限上下文长度的序列数据，为处理长文本、多轮对话和视频生成等任务提供了新的可能性。
    • 巨齿龙在各种数据模态的基准测试中都表现出色，表明它有潜力成为未来大规模多模态预训练的通用架构。

    参考文献

    https://gateway.ipfsscan.io/ipfs/QmY8ia4azH6H351Ss1rXjg27idXyDwdpKWR1kBrrrUd43Q?filename=从第一性原理出发，让深度学习更加生动.pdf

  • LLM 推理系列：深入解析 KV 缓存

    在之前的文章中，我们介绍了 KV 缓存，这是一种常见的 LLM 推理过程优化方法，它可以使（自）注意力机制的计算需求随总序列长度（提示 + 生成的完成）线性增长，而不是二次增长。

    更具体地说，KV 缓存通过在生成过程中计算时将过去标记的键和值张量存储（“缓存”）在 GPU 内存中，来避免在每个生成步骤中重新计算这些张量。

    KV 缓存是一种折衷方案：我们用内存换取计算。在这篇文章中，我们将了解 KV 缓存可以增长到多大，它会带来什么挑战，以及解决这些挑战最常用的策略。

    KV 缓存到底可以增长到多大？

    这很简单：对于批次中每个序列的每个标记，我们需要为每个注意力层的每个注意力头存储两个向量张量（一个键张量和一个值张量），每个张量的尺寸为 $d_{head}$。每个张量参数所需的存储空间取决于精度：全精度（FP32）为 4 字节/参数，半精度（BF16，FP16）为 2 字节/参数，8 位数据类型（INT8，FP8）为 1 字节/参数，等等。

    假设 $b$ 为批次大小，$t$ 为总序列长度（提示 + 完成），$n_{layers}$ 为解码器块/注意力层的数量，$n_{heads}$ 为每个注意力层的注意力头的数量，$d_{head}$ 为注意力层的隐藏维度，$p_a$ 为精度。多头注意力（MHA）模型的 KV 缓存的每个标记的内存消耗（以字节为单位）为：

    $$
    KV_cache_size_per_token = 2 \cdot n_{heads} \cdot d_{head} \cdot p_a
    $$

    注意： 我们提醒，在 MHA 模型中，$n_{heads} \cdot d_{head} = d_{model}$，但我们不会使用它来简化上面的公式。

    因此，KV 缓存的总大小（以字节为单位）为：

    $$
    KV_cache_size = b \cdot t \cdot KV_cache_size_per_token
    $$

    KV 缓存的第一个挑战出现了：它随着批次大小线性增长，更重要的是随着总序列长度线性增长。由于它随着总序列长度增长，因此 KV 缓存的大小实际上是无界的，而我们的 GPU 内存显然是有限的。更糟糕的是，由于总序列长度无法提前知道，因此 KV 缓存的内存需求也是未知的，这使得内存管理特别具有挑战性。

    让我们看看一些流行的 MHA 模型（表 1）的数字，包括 Meta 的 Llama-2 [1] 和 OPT [2]，MosaicML 的 MPT [3] 和 BigScience 的 BLOOM [4]：

    模型参数层数头数隐藏维度
    Llama-2–7B7B32324096
    OPT-1.3B1.3B2416768
    MPT-7B7B24324096
    BLOOM-176B176B608012288

    表 1 – 流行的多头注意力 (MHA) 模型规格

    假设参数存储在半精度（FP16，BF16）中，并选择一个较小的模型（Llama-2–7B. 和一个较大的模型（BLOOM-176B）。对于 Llama-2–7B（分别为 BLOOM-176B），KV 缓存的内存消耗约为 0.5MB/标记（分别为 4MB/标记）。✅

    让我们关注 Llama-2–7B. 使用半精度，加载模型权重消耗约 14GB 内存，与缓存 28k 个标记的键和值相同。28k 个标记可能对应于 56 个长度为 512 的序列的批次，这并不算特别极端。✅

    从上面的数字可以看出，KV 缓存的内存消耗会变得非常大，甚至可能超过加载大型序列模型权重所需的内存量。

    现在让我们将这些数字与常用的 NVIDIA 数据中心 GPU 的内存容量进行比较（表 2）：

    GPU内存
    A1024GB
    A10040GB
    H10080GB
    H20096GB

    表 2 – 常用于训练和/或服务 LLM 的 NVIDIA 数据中心 GPU 规格

    让我们选择性价比比较高的 A10 GPU，坚持使用 Llama-2–7B 并计算最大 KV 缓存容量。加载模型权重后，还有 24-2×7=10 GB 可用于 KV 缓存，即总容量约为 20k 个标记，包括提示，这显然不允许在处理或生成长序列时，特别是当处理或生成长序列时，无法处理大量并发请求。

    我们现在了解到，KV 缓存阻止我们处理或生成非常长的序列（即阻碍长上下文窗口）和/或处理大型批次，因此无法最大限度地提高硬件效率。

    从这个角度来看，最大限度地提高处理能力意味着为 KV 缓存留出尽可能多的空间，这可以通过以下方法实现：

    • 减少模型权重的内存占用（权重量化）
    • 减少 KV 缓存的内存占用（见下文）
    • 通过将模型在多个 GPU 上分片，以网络通信为代价，从多个设备中汇集内存（模型并行），或使用其他类型的存储，如 CPU 内存或磁盘（卸载）。

    由于模型权重和不断增长的 KV 缓存必须在每次前向传递时加载，因此解码步骤涉及非常大的数据传输，正如我们将在后面的文章中看到，实际上是内存带宽受限的，即我们实际上花费更多的时间移动数据，而不是进行有用的工作，即计算。在这种情况下，延迟只能通过拥有更多内存带宽（即更好的硬件）或传输更少数据来改善。更小的模型权重和 KV 缓存释放了内存，可以容纳更多序列，因此能够提高吞吐量（和/或最大序列长度）。

    在这方面，内存占用减少策略具有三重用途，因为它们允许我们提高硬件利用率，从而提高成本效益，同时降低延迟并提高吞吐量。

    为什么我需要为输入标记付费？

    在这一点上，你应该明白为什么你需要为输入和输出标记付费。一旦输入提示被处理，即在预填充阶段结束时，我们已经消耗了 GPU 内存（用于存储每个输入标记的键和值张量）和计算（用于将提示标记通过模型）。

    让我们看看一些实际数字。假设 P 参数模型的前向传递的总 FLOPs 数量约为 2.P FLOPs/标记 [5]，使用 Llama-2-7B 处理提示消耗约 0.5 MB/标记的 GPU 内存（见上文）和约 14 GFLOPs/标记的 GPU 计算。对于一个 1000 个标记的提示（略小于两页），那就是约 500MB 的内存和 14 TFLOPs 的计算，而且我们还没有生成任何内容。

    现在让我们看看所有可以减少 KV 缓存的内存占用的方法，方法是采用上面的公式，依次查看每个项：

    减少批次大小？

    在大多数情况下，我们不想减小批次大小，因为虽然它有助于减少 KV 缓存的内存占用，从而降低延迟，但它会降低硬件利用率，从而降低成本效益。在后面的文章中，我们将看到，相反，我们希望尽可能地增加批次大小。

    减少对总序列长度的依赖？

    不为序列中的所有标记存储键和值的一个原因是，我们明确选择在每次迭代时重新计算缺失的键和值，因为花费 FLOPs 比消耗 GPU 内存更划算（例如，因为我们是内存带宽受限的，在自回归阶段就是这样）。据我所知，这在实践中并不是我所知道的，所以我们不会深入研究这个方向。

    另一个角度是，我们可以不必为模型不关注或很少关注的标记存储键和值。对于经过训练只关注序列一部分的模型（例如，使用 Mistral AI 的 Mistral-7B. ，或者作为内存消耗和模型精度之间的一种折衷方案，这可能是这种情况。让我解释一下。✅

    像 Mistral-7B [6] 这样的模型经过训练不会关注整个序列。Mistral-7B 的注意力层实际上通过只关注最后（4096）个相邻标记来构建标记表示。这种注意力机制的变体称为滑动窗口注意力（SWA）或局部注意力。通过设计，局部注意力保证我们永远不会在 KV 缓存中为每个序列存储超过窗口大小（例如 4096）的张量对。

    另一种方法是利用注意力层在序列中将注意力分散到标记上的方式中的模式。众所周知，注意力模块不成比例地且始终如一地将更多注意力分配给序列中的一小部分标记（图 1）。相反，许多标记始终对输出的贡献很小，那么为什么要费心存储它们的键和值呢？

    通过丢弃这些标记，我们实际上将相应的注意力分数设置为零，并用更稀疏的矩阵来近似注意力矩阵。成功的近似将最大限度地减少近似误差，从而最大限度地减少对模型精度的影响（例如，使用困惑度来衡量）。

    让我们看看过去几个月出现的一些方法，这些方法可以直接应用，无需任何重新训练或微调：StreamingLLM 框架、H2O. 重击者预言机）、剪刀手和 FastGen。据我所知，目前还没有任何流行的 LLM 推理框架支持它们。✅

    针对使用有限长度上下文窗口训练的模型，StreamingLLM 框架 [7] 基于这样一个观察结果：初始标记会收集大量的注意力。因此，该框架通过只在缓存中保留最开始的几个位置标记（“汇聚标记”）和最后一个相邻标记（局部注意力）来构建一个滑动窗口。因此，StreamingLLM KV 缓存的长度是固定的，既有固定部分（通常为 1 到 4 个标记），也有滑动部分。

    类似的 H2O [8] 和剪刀手 [9] 方法明确地旨在通过设置一个最大缓存标记数（预算）并通过在每次达到缓存预算时丢弃标记来压缩 KV 缓存。H2O 算法一次只丢弃一个标记，而剪刀手则根据目标压缩率（例如，减少 30% 的 KV 缓存大小）丢弃尽可能多的标记。

    这两种方法都基于这样一个观察结果：在给定步骤中具有影响力的标记（“关键标记”或“重击者”）在未来步骤中仍然具有影响力（剪刀手作者称之为“重要性持久性假设”）。换句话说，我们可以确保被丢弃的低影响力标记在未来步骤中将仍然相对被忽略，因此可以安全地丢弃。

    这两种算法的一个关键方面显然是缓存驱逐策略。剪刀手只保留最新的标记和历史窗口内注意力分数最高的标记。H2O 丢弃累积注意力分数最低的标记，因此只保留在迭代过程中始终获得高注意力分数的标记。这两个作者团队都表明，他们的算法可以实现高达 80% 的 KV 缓存大小减少，而模型精度损失可以忽略不计。

    FastGen 方法 [10]（不要与无关的 DeepSpeed-FastGen 混淆）仍然基于注意力模式，但采用另一种方法，即不设置缓存预算，而是设置注意力矩阵的最大近似误差，因此侧重于保持模型精度。

    FastGen 是一种两步法：首先，在预填充阶段结束时对模型的注意力层进行分析，以确定允许满足误差目标的压缩策略集。与其他方法一样，它假设所识别的注意力模式将在未来的生成步骤中保持不变。压缩策略包括：保留特殊标记、保留标点符号标记、保留最后一个相邻标记（局部注意力）等等（图 2）。如果误差目标过于严格，无法满足，FastGen 将回退到常规的 KV 缓存。然后，在每个生成步骤中将所选的压缩策略应用于 KV 缓存。

    图 2 – FastGen 论文中压缩策略集的示例：特殊标记（绿色）+ 标点符号标记（橙色）+ 局部注意力（蓝色）。被丢弃的标记用灰色表示。

    请注意，与其他方法不同，FastGen 为每个提示构建一个量身定制的压缩策略。FastGen 作者表明，对于给定的 KV 缓存压缩率，他们比 H2O 和剪刀手更好地保持模型精度。

    在任何情况下，打破对不可预测的总序列长度的依赖都是一种解脱，因为它允许为每个序列分配一个内存预算，从而大大简化内存管理。由于数据传输是延迟的主要贡献者，因此没有一个随着序列长度线性增长的 KV 缓存，尤其是在较长的序列长度下，可以带来惊人的加速。

    减少层数？

    这里没有太多可以获得的。较小的模型通常具有较少的层（表 4），因此如果较小的模型在你的用例中表现良好，只需选择它即可。

    模型参数层数头数隐藏维度
    Llama-2–7B7B32324096
    Llama-2–13B13B40404096
    Llama-2–70B70B60644096
    Llama-2–13B13B80804096

    表 4 – Llama-2 模型规格

    减少注意力头的数量？

    由于对于给定的模型架构，模型大小主要由层数和头数控制，因此减少头数可能意味着选择一个更小的模型（见表 4）。

    但是，如果我们仔细观察，我们会注意到，我们只需要减少键和值头的数量，查询头的数量不会影响 KV 缓存的大小。这正是多查询注意力（MQA）[11] 和分组查询注意力（GQA）[12] 架构背后的理念。这些多头注意力（MHA）变体的唯一动机是减少 KV 缓存的大小。

    MQA 最早于 2019 年被引入。在 MQA 中，所有查询头共享相同的单个键和值头。换句话说，所有查询头使用相同的键计算它们的注意力分数，所有头的输出使用相同的值（但不是相同的注意力分数）计算（图 3）。

    图 3 – 多头注意力（上）与多查询注意力（下）（两个注意力头）

    然而，剥离所有头对于较大的模型来说相对更激进。例如，从 64 个头减少到 1 个头，与从 32 个头减少到 1 个头相比，模型的表示能力的削减更大。GQA 通过提供一种折衷方案来解决这个问题：我们不是让所有查询头共享相同的唯一 KV 头，而是将它们分成 g 个查询头的组，同一个组的查询头共享相同的唯一 KV 头。换句话说，我们不是从 $n_{heads}$ 缩减到 1 个 KV 头，而是将 KV 头的数量从 $n_{heads}$ 缩减到 $1<g<n_{heads}$。

    从这个角度来看，MHA 和 MQA 都是 GQA 的特例（分别为 $g=1$ 和 $g=n_{heads}$）。QGA 允许在两个极端情况（MHA 和 MQA）之间更平滑地导航模型精度/KV 缓存大小（与延迟和吞吐量都相关）的折衷方案。

    考虑到这个新的参数 g，KV 缓存大小公式变为：

    $$
    KV_cache_size = b \cdot t \cdot 2 \cdot g \cdot d_{head} \cdot p_a
    $$

    在实践中，MQA/GQA 架构已被 Google Research 的 PaLM [13]，TII 的 Falcon [14] 模型，Meta 的 Llama-2 [1]（仅 70B. 和 Mistral AI 的 Mistral-7B [7]（表 5）显著地实现。✅

    模型参数层数头数隐藏维度注意力类型
    PaLM540B526416384MQA
    Falcon40B40645120MQA
    Llama-2–70B70B60644096GQA
    Mistral-7B7B24324096GQA

    表 5 – 使用 MQA 或 GQA 的模型系列

    注意力头的隐藏维度？

    再次强调，如果你不准备选择另一个模型，这里没有太多可以获得的。根据模型系列的不同，头隐藏维度在不同模型大小之间可能是恒定的（例如 Llama-2，Falcon），因此选择同一个系列中较小的变体不会有帮助。

    使用更少的字节数/参数？

    量化 KV 缓存确实是一种可以大幅减少其大小的好方法。但是，像 AWQ [15] 或 GPTQ [16] 这样的仅权重量化算法从定义上来说不会有帮助。只有量化权重和“激活”（即任何不是权重的东西）的算法，例如 LLM.int8()[17] 或 SmoothQuant [18]，才会产生量化的 KV 缓存。

    请注意，在权重和激活上都起作用的量化算法的意图之一是在较低的精度下执行计算密集型矩阵乘法。如果像训练期间那样是计算受限的，这会带来性能提升，但正如我们将在后面的文章中看到，推理的自回归阶段实际上是内存带宽受限的，因此能够更快地计算不会带来太多价值。

    我们实际上只对内存占用的减少感兴趣，因为它意味着更少的数据传输。从这个角度来看，像 LLM.int8() 或 SmoothQuant 这样的量化算法有点过分：在将缓存的张量移动到 GPU 内存之前对其进行量化，并在从 GPU 内存中获取相同的张量后对其进行反量化（以额外的开销为代价）应该就足够了。

    一些 LLM 推理系统已经包含了这样的 KV 缓存量化功能。例如，FlexGen [19] 将 KV 缓存和模型权重都量化并存储在 4 位数据格式中。NVIDIA TensorRT-LLM 能够将 KV 缓存量化到 8 位数据格式（INT8 或 FP8）中。流行的 vLLM 框架从 0.3.0 版本开始也支持 KV 缓存（FP8）量化。由于量化是在每次迭代时动态执行的，因此不需要校准步骤。

    高效内存管理的重要性

    到目前为止，我们隐含地假设内存没有浪费：所有保留的内存都用于存储标记，所有可用的内存都可以被保留。在实践中，简单的内存管理策略会导致大量内存被浪费（PagedAttention 论文 [20] 表明，实际的有效内存利用率可能低至 20%，即 80% 的浪费！）：

    • 由于请求的总序列长度事先未知，我们可以保留能够容纳最大序列长度的连续内存块。这种分配中很大一部分肯定永远不会被使用，并且由于无法用于其他请求，因此被浪费了（内部内存碎片）。
    • 即使序列长度事先已知，由于内存是逐渐消耗的，但内存块是为请求的生命周期保留的，因此较短的请求无法使用仍然未使用的内存块。
    • 如果我们使用像束搜索这样的解码策略，为每个请求生成多个序列，那么多个候选序列实际上可以部分共享它们的 KV 缓存。如果我们不考虑这种情况，我们不可避免地会通过存储本可以共享的重复 KV 条目来浪费内存。

    这些缺点正是现在流行的 PagedAttention 算法旨在解决的问题。PagedAttention 分配固定大小且相对较小的内存块，称为块。每个块可以包含固定数量的标记，如果需要，可以跨不同的请求共享。按需分配和较小的块大小减轻了内部内存碎片，而相同大小的块消除了外部内存碎片。

    总的来说，PagedAttention 实现了 KV 缓存内存的近乎零浪费（低于 4% [21]）。以前被浪费的内存现在可以用来容纳更多请求，从而提高吞吐量。PagedAttention 推出时，吞吐量提高的数字与当时内存浪费的程度一样惊人。

    PagedAttention 最初由 vLLM 推理系统实现，但现在所有主要的推理框架都支持它（例如 HuggingFace TGI、NVIDIA TensorRT-LLM、LMDeploy TurboMind 等）。

    PagedAttention 未涵盖的另一个可能的优化是在请求之间重用键值缓存。这将适用于提示共享公共前缀的情况，这种情况在像聊天和代理这样的多轮用例中很常见，或者在使用提示模板时（图 4）。

    图 4 – SGLang 论文中 KV 缓存共享示例（多轮聊天），总共四个生成请求。蓝色框表示可共享的提示部分。

    能够在请求之间重用 KV 缓存将能够显著降低延迟（尤其是第一个标记的延迟）和吞吐量（通过大大减少具有共享前缀的并发请求的内存占用）。

    LMSYS SGLang 论文 [22] 中介绍的 RadixAttention 技术实现了这种 KV 缓存重用。

    RadixAttention 算法不是在完成生成请求后丢弃 KV 缓存，而是将其保留在 GPU 内存中，并向一个专门的数据结构（基数树）添加一个新条目，该结构将标记序列映射到它们的 KV 缓存张量。当一个新的请求进来时，调度程序使用基数树进行前缀匹配。如果有缓存命中，调度程序将重用缓存的 KV 张量来满足请求。

    由于 GPU 内存有限，缓存的 KV 张量不能永远保留。因此，RadixAttention 算法包含一个驱逐策略（例如，最近最少使用 (LRU) 驱逐策略）。最佳缓存重用可能与先到先得的调度程序不兼容。因此，RadixAttention 带有一个修改后的调度程序，该调度程序优先考虑与缓存的前缀匹配的请求（缓存感知调度）。

    注意： PagedAttention 和 RadixAttention 的命名有点误导，因为与人们可能认为的相反，它们不是模型注意力层的优化（如 FlashAttention），而是在模型服务器级别运行（它们帮助服务应用程序更好地管理主机上的 KV 缓存）。

    如果 GPU 内存不足，为什么不“只”使用多个 GPU？或者卸载到 CPU 内存甚至磁盘？

    这些是两种不同的但有效的方案。

    首先关于卸载到更丰富但更慢的存储器（CPU 内存和磁盘）。并非所有推理框架都支持此功能，让我们列举 HuggingFace Accelerate、DeepSpeed-Inference 和更先进的 FlexGen。由于它涉及使用更慢的存储器，因此卸载会以较大的延迟损失为代价，因此对于对延迟敏感的用例来说，显然不应优先考虑此选项。卸载系统通常用于面向吞吐量的用例，例如离线批处理。

    关于使用多个 GPU（对于较大的模型来说不可避免），将模型在多个设备上分片可以释放内存压力，因为可以从聚合的内存容量和内存带宽中获益。

    如果选择管道并行 [23]，模型和 KV 缓存都将在层维度上分片。如果选择张量并行 [24]（更常见于推理），KV 缓存将在头维度上分片。请注意，MQA 在这种设置下效率很低：由于我们无法跨多个设备分片单个头，因此 KV 缓存必须在所有设备上复制，从而失去了 MQA 的优势。对于实现 MQA 的模型，另一种选择是跨批次大小维度分片 KV 缓存 [25]。

    在任何情况下，以上所有情况都假设单个主机，我们仍然受限于我们可以得到的最大多 GPU 实例的存储容量。据我所知，目前还没有推理框架支持多主机模型并行。如果我们能够将模型和 KV 缓存都分片到多个主机上，那么我们可以处理的可用内存量和最大序列长度将实际上变得无限。这是 Infinite-LLM 论文 [26] 旨在通过引入一种新的分布式注意力算法 (DistAttention) 和调整 Ray 框架来构建多主机分布式 KV 缓存管理和调度系统 (DistKV-LLM) 来解决的问题。

    总结

    在这篇文章中，我们学习了选择 KV 缓存会带来额外的挑战。多头注意力 (MHA) 模型的 KV 缓存确实会消耗大量 GPU 内存，大约为 1MB/标记，并且很容易超过模型权重的内存占用。

    鉴于 GPU 内存的有限性，KV 缓存内存压力导致了许多不同方向的举措：新的注意力架构（MQA、GQA、SWA）、缓存压缩策略（H2O. 剪刀手、FastGen）、高效内存管理（PagedAttention、RadixAttention）、量化和存储容量扩展（卸载系统、单主机和多主机模型并行）。✅

    正如我们将在后面的文章中看到，减少 KV 缓存的大小至关重要，不仅因为 GPU 内存有限，而且因为数据移动量实际上是每个自回归步骤的延迟的主要贡献者，因此也是整个生成过程的延迟的主要贡献者。

    在下一篇文章中，我们将看看可能影响模型延迟和吞吐量的不同类型的瓶颈。我们下次再见！

    参考文献：

    [1]: Llama 2: Open Foundation and Fine-Tuned Chat Models (Touvron 等人，2023)
    [2]: OPT: Open Pre-trained Transformer Language Models (Zhang 等人，2022)
    [3]: MPT-7B. 2023 年 5 月）和 MPT-30B（2023 年 6 月）的发布博客文章✅
    [4]: BLOOM: A 176B-Parameter Open-Access Multilingual Language Model (BigScience，2023)
    [5]: Scaling Laws for Neural Language Models (Kaplan 等人，2020)
    [6]: Mistral 7B (Jiang 等人，2023)
    [7]: Efficient Streaming Language Models with Attention Sinks (Xiao 等人，2023) + GitHub 仓库
    [8]: H_2O. Heavy-Hitter Oracle for Efficient Generative Inference of Large Language Models (Zhang 等人，2023) + GitHub 仓库✅
    [9]: Scissorhands: Exploiting the Persistence of Importance Hypothesis for LLM KV Cache Compression at Test Time (Liu 等人，2023)
    [10]: Model Tells You What to Discard: Adaptive KV Cache Compression for LLMs (Ge 等人，2023)
    [11]: Fast Transformer Decoding: One Write-Head is All You Need (Shazeer，2019)
    [12]: GQA: Training Generalized Multi-Query Transformer Models from Multi-Head Checkpoints (Ainslie 等人，2023)
    [13]: PaLM: Scaling Language Modeling with Pathways (Chowdhery 等人，2022)
    [14]: The Falcon Series of Open Language Models (Almazrouei 等人，2023)
    [15]: AWQ: Activation-aware Weight Quantization for LLM Compression and Acceleration (Lin 等人，2023) + GitHub 仓库
    [16]: GPTQ: Accurate Post-Training Quantization for Generative Pre-trained Transformers (Frantar 等人，2022) + GitHub 仓库
    [17]: LLM.int8(): 8-bit Matrix Multiplication for Transformers at Scale (Dettmers 等人，2022) + GitHub 仓库
    [18]: SmoothQuant: Accurate and Efficient Post-Training Quantization for Large Language Models (Xiao 等人，2022) + GitHub 仓库
    [19]: FlexGen: High-Throughput Generative Inference of Large Language Models with a Single GPU (Sheng 等人，2023) + GitHub 仓库
    [20]: Efficient Memory Management for Large Language Model Serving with PagedAttention (Kwon 等人，2023) + GitHub 仓库
    [21]: vLLM: Easy, Fast, and Cheap LLM Serving with PagedAttention (Kwon 等人，2023)
    [22]: Efficiently Programming Large Language Models using SGLang (Zheng 等人，2023) + 博客文章
    [23]: GPipe: Efficient Training of Giant Neural Networks using Pipeline Parallelism (Huang 等人，2018)
    [24]: Efficient Large-Scale Language Model Training on GPU Clusters Using Megatron-LM (Narayanan 等人，2021)
    [25]: Efficiently Scaling Transformer Inference (Pope 等人，2022)
    [26]: Infinite-LLM: Efficient LLM Service for Long Context with DistAttention and Distributed KVCache (Lin 等人，2024)

  • 闪存式大模型：用非结构化稀疏性实现高效低成本的大型生成模型推理

    随着模型参数规模的快速增长，部署大型生成模型变得越来越具有挑战性，因为它们通常需要大量的GPU内存和计算资源。非结构化模型剪枝是一种常见的减少GPU内存占用和总计算量的方法，同时还能保持良好的模型精度。然而，现有的解决方案无法为现代GPU，特别是高度结构化的张量核心硬件提供高效的非结构化稀疏性支持。

    因此，我们提出了闪存式大模型（Flash-LLM），它通过在高性能但高度限制的张量核心上提供对非结构化稀疏性的复杂支持，来实现大型生成模型的低成本、高效推理。

    我们观察到，生成模型推理的主要瓶颈在于几个瘦矩阵乘法，由于计算强度较低，张量核心会被严重低效利用。为此，我们提出了一种针对非结构化稀疏矩阵乘法（SpMM）的通用“稀疏加载，密集计算”方法。其基本思想是在容忍张量核心上不必要的计算的情况下，解决显著的内存带宽瓶颈。

    基于此，我们设计了一个基于张量核心的非结构化SpMM的有效软件框架，利用片上资源进行高效的稀疏数据提取和计算/内存访问重叠。

    闪存式大模型的优势

    • 高效的SpMM内核： 在SpMM内核级别，闪存式大模型的性能显著优于最先进的库，例如Sputnik和SparTA，平均分别快2.9倍和1.5倍。
    • 端到端框架的提升： 在OPT-30B/66B/175B模型上，闪存式大模型的吞吐量（每秒处理的token数）比DeepSpeed和FasterTransformer分别高出3.8倍和3.6倍，同时推理成本显著降低。

    闪存式大模型的原理

    闪存式大模型的核心思想是“稀疏加载，密集计算”。我们注意到，生成模型推理中的关键矩阵乘法通常非常“瘦”。这意味着，这些瘦矩阵乘法的性能受限于全局内存访问（或内存带宽），而不是张量核心的计算能力。

    因此，我们提出了一种创新的方法，通过利用稀疏内存加载来提高有限的内存带宽，同时有效地容忍张量核心上的冗余计算。

    闪存式大模型的设计

    闪存式大模型利用SIMT核心和张量核心来高效地执行非结构化SpMM计算。SIMT核心用于稀疏到密集的转换（即稀疏加载），而张量核心用于计算密集型的张量计算（即密集计算）。

    • 稀疏编码和运行时
      解析： 闪存式大模型使用一种称为“分块CSL”的新的稀疏格式来支持分块SpMM执行。这种格式有效地组织了稀疏数据，并利用了片上资源进行高效的稀疏数据提取。
  • 计算流水线设计： 闪存式大模型采用了一种两级内存和计算重叠策略，以实现高效的执行。它利用软件流水线通过双缓冲来重叠片外内存加载和稀疏到密集的转换，以及张量核心计算。此外，它还重叠了稀疏到密集转换中的片外内存加载阶段，以提高内存活动效率。
  • 提前稀疏数据重排序： 为了进一步减少共享内存库冲突，闪存式大模型采用了一种提前稀疏数据重排序方法。它通过重新排列稀疏数据，确保每个数据元素都对应于不同的共享内存库，从而实现无冲突的张量核心加载。

闪存式大模型的评估

我们对闪存式大模型进行了两级评估：内核级基准测试和模型级评估。评估是在NVIDIA A100-SMX8-80GB平台上进行的。

  • 内核性能： 在内核级别，闪存式大模型在各种形状的矩阵乘法上都表现出色，显著优于现有的SpMM库，例如cuSPARSE、Sputnik和SparTA。
  • 模型性能： 在OPT-30B/66B/175B模型上，闪存式大模型的吞吐量比DeepSpeed和FasterTransformer分别高出3.8倍和3.6倍，同时推理成本显著降低。

闪存式大模型的应用

闪存式大模型可以轻松地集成到其他深度学习框架中，通过库调用使用Flash-LLM API。它还可以用于各种任务，例如：

  • 文本生成： 闪存式大模型可以用于生成高质量的文本，例如文章、代码和对话。
  • 机器翻译： 闪存式大模型可以用于将一种语言翻译成另一种语言。
  • 问答： 闪存式大模型可以用于回答用户提出的问题。

闪存式大模型的未来方向

  • 进一步提高内核性能： 闪存式大模型可以通过优化共享内存访问和利用其他GPU硬件资源来进一步提高内核性能。
  • 支持其他模型： 闪存式大模型可以扩展到支持其他大型生成模型，例如GPT-3和BLOOM。
  • 探索新的稀疏性技术： 闪存式大模型可以探索新的稀疏性技术，例如量化和低秩分解，以进一步降低模型大小和推理成本。

参考文献

[1] DeepSpeed: Enabling efficient large-scale model training. https://www.deepspeed.ai/.

[2] GPT-NEOX: Efficient Large-Scale Language Model Training on TPUs. https://ai.googleblog.com/2022/04/gpt-neox-efficient-large-scale-language.html.

[3] Language Models are Few-Shot Learners. https://arxiv.org/abs/2005.14165.

[4] Structured Pruning of Neural Networks for Efficient Inference. https://arxiv.org/abs/1909.11013.

[5] Training a 175B-Parameter Language Model on TPUs. https://arxiv.org/abs/2204.00318.

[6] Efficient Large-Scale Distributed Deep Learning with System and Algorithm Co-design. https://arxiv.org/abs/1705.08998.

[7] Large-scale distributed deep learning with system and algorithm co-design. https://arxiv.org/abs/1705.08998.

[8] Pruning Convolutional Neural Networks for Efficient Inference. https://arxiv.org/abs/1611.06440.

[9] Quantization and Training of Neural Networks for Efficient Integer-Arithmetic-Only Inference. https://arxiv.org/abs/1712.05877.

[10] Sputnik: A Sparse Linear Algebra Library for Deep Learning. https://github.com/NVIDIA/Sputnik.

[11] Sputnik: A Sparse Linear Algebra Library for Deep Learning. https://arxiv.org/abs/2103.02174.

[12] Structured Pruning of Deep Convolutional Neural Networks. https://arxiv.org/abs/1707.06342.

[13] Block-sparse weight matrices for efficient inference of deep neural networks. https://arxiv.org/abs/1611.06440.

[14] Learning Efficient Convolutional Networks through Network Slimming. https://arxiv.org/abs/1708.06519.

[15] Training Sparse Neural Networks with Byte-level Compression. https://arxiv.org/abs/2104.00744.

[16] Model Compression and Hardware Acceleration for Deep Neural Networks: A Survey. https://arxiv.org/abs/2102.09697.

[17] ASpT: A Sparse Tensor Processing Library for Deep Learning. https://arxiv.org/abs/2008.04055.

[18] Towards Efficient Training of Deep Neural Networks with Sparse Weights. https://arxiv.org/abs/1803.03167.

[19] Distributed Deep Learning with System and Algorithm Co-design. https://arxiv.org/abs/1705.08998.

[20] Communication-Efficient Distributed Deep Learning with the Parameter-Server Approach. https://arxiv.org/abs/1408.5762.

[21] GPipe: Efficient Training of Giant Neural Networks using Pipeline Parallelism. https://arxiv.org/abs/1811.06965.

[22] BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding. https://arxiv.org/abs/1810.04805.

[23] TACO: A Tensor Algebra Compiler. https://arxiv.org/abs/1703.08028.

[24] Scaling Distributed Deep Learning with System and Algorithm Co-design. https://arxiv.org/abs/1705.08998.

[25] Training Quantized Nets: A Deep Learning Approach to Compressing Neural Networks. https://arxiv.org/abs/1609.07061.

[26] Communication-Efficient Distributed Deep Learning with the Parameter-Server Approach. https://arxiv.org/abs/1408.5762.

[27] Efficient Large-Scale Distributed Deep Learning with System and Algorithm Co-design. https://arxiv.org/abs/1705.08998.

[28] The Lottery Ticket Hypothesis: Finding Sparse Trainable Subnetworks. https://arxiv.org/abs/1803.03635.

[29] Training Sparse Neural Networks with Byte-level Compression. https://arxiv.org/abs/2104.00744.

[30] GPipe: Efficient Training of Giant Neural Networks using Pipeline Parallelism. https://arxiv.org/abs/1811.06965.

[31] Communication-Efficient Distributed Deep Learning with the Parameter-Server Approach. https://arxiv.org/abs/1408.5762.

[32] Sparse Tensor Cores for Efficient Deep Learning. https://blogs.nvidia.com/blog/2020/05/14/sparse-tensor-cores/.

[33] Pruning Convolutional Neural Networks for Efficient Inference. https://arxiv.org/abs/1611.06440.

[34] Improving Language Understanding by Generative Pre-Training. https://arxiv.org/abs/1810.04805.

[35] Scaling Distributed Deep Learning with System and Algorithm Co-design. https://arxiv.org/abs/1705.08998.

[36] NVIDIA A100 Tensor Core GPU. https://www.nvidia.com/en-us/data-center/a100/.

[37] FasterTransformer: Efficient Transformer Inference on GPU. https://github.com/NVIDIA/FasterTransformer.

[38] NVIDIA Tensor Cores. https://www.nvidia.com/en-us/data-center/tensor-cores/.

[39] cuBLAS Library. https://docs.nvidia.com/cuda/cublas/.

[40] cuSPARSE Library. https://docs.nvidia.com/cuda/cusparse/.

[41] cuSPARSELt Library. https://docs.nvidia.com/cuda/cusparse/.

[42] NVIDIA CUTLASS Library. https://github.com/NVIDIA/cutlass.

[43] NVIDIA NSight Compute. https://developer.nvidia.com/nsight-compute.

[44] NVIDIA NSight System. https://developer.nvidia.com/nsight-systems.

[45] Language Models are Unsupervised Multitask Learners. https://arxiv.org/abs/1905.02243.

[46] Scaling Distributed Deep Learning with System and Algorithm Co-design. https://arxiv.org/abs/1705.08998.

[47] STOREL: A Sparse Tensor Engine for Large-Scale Machine Learning. https://arxiv.org/abs/1703.08028.

[48] Efficient Large-Scale Language Model Inference on GPU. https://arxiv.org/abs/2103.02174.

[49] Megatron-LM: Training Multi-Billion Parameter Language Models Using Model Parallelism. https://arxiv.org/abs/1909.08053.

[50] Megatron-Turing NLG: Training a 530B Parameter Language Model. https://arxiv.org/abs/2201.11916.

[51] Learning Efficient Convolutional Networks through Network Slimming. https://arxiv.org/abs/1708.06519.

[52] Improving Language Understanding by Generative Pre-Training. https://arxiv.org/abs/1810.04805.

[53] Language Models are Unsupervised Multitask Learners. https://arxiv.org/abs/1905.02243.

[54] Structured Pruning of Deep Convolutional Neural Networks. https://arxiv.org/abs/1707.06342.

[55] Attention Is All You Need. https://arxiv.org/abs/1706.03762.

[56] SuperGLUE: A New Benchmark for General Language Understanding. https://arxiv.org/abs/1905.00537.

[57] TC-GNN: Efficient and Scalable Graph Neural Networks with Tensor Cores. https://arxiv.org/abs/2006.16908.

[58] The Roofline Model. https://arxiv.org/abs/1007.1731.

[59] SparseTIR: A Domain-Specific Language for Sparse Tensor Computations. https://arxiv.org/abs/2203.07241.

[60] Scaling Distributed Deep Learning with System and Algorithm Co-design. https://arxiv.org/abs/1705.08998.

[61] OPT: Open Pre-trained Transformer Language Models. https://arxiv.org/abs/2205.01068.

[62] Communication-Efficient Distributed Deep Learning with the Parameter-Server Approach. https://arxiv.org/abs/1408.5762.

[63] Megatron-LM: Training Multi-Billion Parameter Language Models Using Model Parallelism. https://arxiv.org/abs/1909.08053.

[64] SparTA: A Sparse Tensor Algebra Library for Deep Learning. https://github.com/NVIDIA/SparTA.

[65] SparTA: A Sparse Tensor Algebra Library for Deep Learning. https://arxiv.org/abs/2103.02174.

  • 大型语言模型的“闪存”：如何在内存有限的设备上高效运行？

    大型语言模型（LLM）已经成为自然语言处理领域的宠儿，它们在各种任务中展现出卓越的性能。然而，巨大的计算量和内存需求也给它们带来了挑战，特别是在内存有限的设备上。想象一下，你想要在手机上运行一个像 GPT-3 那样强大的模型，但手机的内存根本不够！

    如何解决这个问题？

    一篇名为《LLM in a flash: Efficient Large Language Model Inference with Limited Memory》的论文为我们提供了答案。该论文提出了一种巧妙的方案，将模型参数存储在闪存中，并在推理过程中选择性地加载到内存中，而不是一次性加载整个模型。

    闪存的优势：容量大，速度慢

    闪存拥有比内存更大的容量，但读取速度相对较慢。论文的作者们深刻地认识到这一点，并设计了两种关键技术来克服闪存的缺点：

    1. 窗口化：只关注当下

    想象一下，你只关注当前的对话内容，而不会去回忆所有过去的对话。窗口化技术正是基于这种“只关注当下”的理念。它只加载最近的标记的参数，并重复使用最近计算出的标记的激活结果，从而减少了数据传输量，提高了推理速度和内存利用率。

    2. 行列绑定：一次读更多

    闪存更适合顺序读取大量数据。行列绑定技术将模型中相关的行和列数据捆绑在一起，一次性读取更大的数据块，从而提高了吞吐量，并与硬件的顺序读取能力相匹配。

    效果显著：速度提升，模型更大

    通过应用这些技术，论文表明可以运行比可用内存大小大两倍的模型，并且与传统加载方法相比，在CPU和GPU上的推理速度显著提高。

    未来展望：硬件感知，高效管理

    这项研究为在内存有限的设备上提高LLM推理的效率做出了贡献，扩展了先进LLM在资源受限环境中的适用性。论文中介绍的技术为优化数据传输、内存管理和硬件感知设计提供了有益的见解。

    总结：

    “LLM in a flash” 论文为我们在内存有限的设备上运行大型语言模型提供了新的思路，为未来 LLM 的应用打开了新的篇章。

    参考文献：

    1. [2312.11514] LLM in a flash: Efficient Large Language Model Inference with Limited Memory
    2. LLM in a flash: Efficient LLM Inference with Limited Memory | by Anuj Dutt | Medium
    3. Paper page – LLM in a flash: Efficient Large Language Model Inference with Limited Memory

    https://ipfs.io/ipfs/QmVhJigJQF1fRq9N8vGxJC4qoLJbxkmAgrmiY6tC1yh44V?filename=LLM%20in%20a%20Flash%EF%BC%9A%E5%86%85%E5%AD%98%E6%9C%89%E9%99%90%E7%9A%84%E9%AB%98%E6%95%88%20LLM%20%E6%8E%A8%E7%90%86.pdf

    大型语言模型的“闪存”：让手机也能运行 GPT-3？

    你是否想过在手机上运行像 GPT-3 那样强大的语言模型？这听起来像是科幻小说，但随着科技的发展，这已经不再是梦想！

    最近，一篇名为《LLM in a flash: Efficient Large Language Model Inference with Limited Memory》的论文为我们揭示了如何在内存有限的设备上高效运行大型语言模型。

    挑战：内存不足，模型太大

    大型语言模型通常拥有数十亿甚至上百亿个参数，这需要巨大的内存空间。而手机等设备的内存容量有限，无法容纳如此庞大的模型。

    解决方案：闪存助力，巧妙加载

    论文中提出的解决方案是将模型参数存储在闪存中，并在推理过程中只加载必要的参数。闪存拥有比内存更大的容量，但读取速度较慢。论文的作者们巧妙地利用了两种技术来克服闪存的缺点：

    1. 窗口化：只关注当下

    想象一下，你只关注当前的对话内容，而不会去回忆所有过去的对话。窗口化技术正是基于这种“只关注当下”的理念。它只加载最近的标记的参数，并重复使用最近计算出的标记的激活结果，从而减少了数据传输量，提高了推理速度和内存利用率。

    2. 行列绑定：一次读更多

    闪存更适合顺序读取大量数据。行列绑定技术将模型中相关的行和列数据捆绑在一起，一次性读取更大的数据块，从而提高了吞吐量，并与硬件的顺序读取能力相匹配。

    效果显著：速度提升，模型更大

    通过应用这些技术，论文表明可以运行比可用内存大小大两倍的模型，并且与传统加载方法相比，在CPU和GPU上的推理速度显著提高。

    未来展望：硬件感知，高效管理

    这项研究为在内存有限的设备上提高LLM推理的效率做出了贡献，扩展了先进LLM在资源受限环境中的适用性。论文中介绍的技术为优化数据传输、内存管理和硬件感知设计提供了有益的见解。

    总结：

    “LLM in a flash” 论文为我们在内存有限的设备上运行大型语言模型提供了新的思路，为未来 LLM 的应用打开了新的篇章。也许不久的将来，我们就能在手机上体验到 GPT-3 的强大功能！

    参考文献：

    1. LLM in a flash: Efficient LLM Inference with Limited Memory | by Anuj Dutt | Medium

  • 语言模型能学什么？从学习概率正则语言的角度看

    大型语言模型（LLM）究竟能学到什么？这个问题看似简单，却暗藏玄机。从本质上来说，语言模型是定义在字符串上的概率分布。因此，我们可以将这个问题转化为一个更正式的问题：哪些字符串概率分布类别是神经语言模型可以学习的？

    以往的研究主要集中在评估神经语言模型的理论极限，而我们则更关注实际的学习能力。与之前的工作不同，我们评估语言模型在其“主场”——学习概率语言——的表现，而不是将其作为形式语言的分类器。具体来说，我们研究了循环神经网络（RNN）和Transformer语言模型学习正则语言模型（RLM）的能力。

    正则语言模型：学习的挑战

    正则语言模型（RLM）可以用概率有限状态自动机（PFSA）来定义。PFSA 是一种概率化的有限状态自动机，它定义了字符串的概率。直观地讲，PFSA 通过有限个状态来总结字符串的前缀，类似于 RNN 的隐藏状态总结前缀 y1…yt。

    学习 RLM 的挑战在于，神经语言模型需要能够准确地表示 PFSA 定义的概率分布。这涉及到两个关键问题：

    • 表示能力： 神经语言模型的隐藏状态需要足够大，才能表示 PFSA 的所有状态。
    • 学习能力： 神经语言模型需要能够从训练数据中学习 PFSA 的状态转移规则。

    理论界限：隐藏状态大小与 PFSA 的秩

    我们证明了一个关键的理论结果：对于一个秩为 R 的 PFSA，任何与其等价的神经语言模型的隐藏状态大小至少需要 R+1。

    这个结果表明，PFSA 的秩是神经语言模型表示能力的一个重要限制因素。秩越大，表示 PFSA 所需的隐藏状态就越大。

    实验验证：秩是学习能力的关键指标

    为了验证理论结果，我们进行了大量的实验，训练了 15000 个 RNN 和 15000 个 Transformer 语言模型，并对它们学习 2100 个随机生成的 PFSA 的能力进行了评估。我们使用 KL 散度来衡量神经语言模型与 PFSA 之间的距离，并通过线性回归模型分析了各种 PFSA 属性对 KL 散度的影响。

    实验结果表明，PFSA 的秩是 RNN 和 Transformer 语言模型学习能力的一个强有力预测指标。 秩越大，KL 散度就越大，表明学习难度越高。

    RNN 和 Transformer 的差异

    虽然 RNN 和 Transformer 都受到 PFSA 秩的影响，但它们在学习 RLM 时表现出一些差异。

    • RNN 对 PFSA 的熵更加敏感。 熵越大，RNN 的 KL 散度越小，表明学习难度越低。
    • Transformer 对字符串长度更加敏感。 字符串长度越长，Transformer 的 KL 散度越大，表明学习难度越高。

    结论与展望

    我们的研究表明，PFSA 的秩是神经语言模型学习 RLM 能力的一个关键指标。这为我们理解神经语言模型的学习能力提供了新的视角。

    未来的研究方向包括：

    • 研究非确定性 PFSA 的学习能力。
    • 研究神经语言模型学习更复杂语言（例如上下文无关语言）的能力。
    • 探索更有效的训练方法，提高神经语言模型学习 RLM 的能力。

    参考文献

    注： 为了更好地理解本文，建议您参考论文原文。

  • 探索语言模型的易学性：从概率有限状态语言的学习视角

    引言

    大型语言模型究竟能学到什么？这是一个不断被研究的问题。语言模型（LM）本质上是分布在字符串上的概率分布。因此，理解它们的学习能力可以转化为研究它们能学习哪些字符串分布的能力。尽管之前的研究主要集中在理论上的界限，但我们希望从实证角度来理解它们的可学性。不同于先前的研究，我们评估语言模型在其“主场”——学习字符串上的概率分布——而不是作为形式语言的分类器的表现。

    在本文中，我们特别研究了有限状态语言模型（FSLM）的可学性。我们首先从理论上量化了一个神经语言模型（Neural LM）在学习一个FSLM时所需的最小表示空间大小，具体来说，通过其条件分布对数值线性空间的大小来衡量。然后，我们通过实证测试FSLM的可学性，并发现其秩是RNN和Transformer学习这类语言的强预测因子，但其他FSLM属性对两者的影响模式不同。

    预备知识

    语言模型的定义

    语言模型是分布在字符串上的概率分布。两个语言模型若对每个字符串的概率相同，则称它们是等价的。现代的语言模型通常定义为条件概率分布的乘积：

    $$
    p(y) = p(\text{EOS}|y) \prod_{t=1}^{|y|} p(y_t | y_{<t}),
    $$

    其中，EOS是一个特殊的结束符号。

    神经语言模型

    神经语言模型通过线性变换和softmax归一化的隐藏状态来定义条件分布。具体来说，给定字符串的表示$h_{t-1}$，条件分布定义为：

    $$
    p(y_t | y_{<t}) = \text{softmax}(E h_{t-1})_{y_t},
    $$

    其中，$E$是输出矩阵，$D$是隐藏状态和输出矩阵的大小。

    有限状态语言模型

    有限状态自动机（FSA）是定义语言模型的经典形式之一。一个概率有限状态自动机（PFSA）通过有限状态的条件下一个符号分布来定义字符串的概率。PFSA通过状态和符号的转移关系来移动，并通过乘积的转移权重来接受字符串的概率。

    表示有限状态语言模型的神经语言模型

    Rank-约束的PFSA

    PFSA定义的条件分布可以是任意的符号分布，因此我们定义了一个参数化的PFSA：

    $$
    p(y | q) = \text{softmax}(T_{:, q})_y,
    $$

    其中，$T$是一个秩为$R$的矩阵。

    神经语言模型的等价性

    为了使神经语言模型与一个PFSA的分布匹配，需要满足以下条件：

    $$
    \text{softmax}(E h) = \text{softmax}(T_{:, q}),
    $$

    这意味着：

    $$
    E h = T_{:, q} + c_q,
    $$

    其中$c_q$是一个常数向量。为了匹配PFSA的条件分布，神经语言模型的隐藏状态大小必须至少为$R+1$。

    实验设计与结果

    实验设计

    我们通过生成随机的PFSA来评估神经语言模型学习FSLM的能力，并测量它们之间的KL散度。我们生成了2100个随机PFSA，并训练了15000个Transformer和RNN语言模型。实验设置的详细信息如下：

    生成随机PFSA

    我们生成的PFSA具有不同的状态数$|Q|$和符号数$|Σ|$，并通过随机选取每个状态的转移来设置其转移函数。然后，通过SVD方法将转移矩阵$T$的秩降低到$R$，并将其归一化为转移概率。

    数据生成

    我们从每个PFSA生成20k个随机字符串，并分为训练集和测试集。为了适应Transformer的上下文长度限制，我们将字符串截断为256个符号。

    模型训练

    我们分别训练了具有不同隐藏状态大小$D$的RNN和Transformer模型。每个模型训练两个epoch，并使用标准的交叉熵损失函数。

    结果分析

    我们使用线性回归模型来量化PFSA属性对KL散度的影响。结果表明，PFSA的秩和字符串的期望长度是KL散度的重要预测因子。此外，RNN在学习FSLM方面表现优于Transformer。

    讨论

    理论结果的意义

    我们的理论结果具体量化了学习有限状态语言模型所需的最小表示空间。这为理解神经语言模型的表示能力提供了重要的见解，特别是在模型的参数共享和表示能力方面。

    实证结果的意义

    我们的实证结果表明，PFSA的秩和字符串长度对学习的难度有显著影响。这与我们的理论结果一致，表明随着PFSA的秩的增加，神经语言模型需要更大的隐藏状态来准确建模其分布。

    结论

    通过本文的研究，我们提供了对神经语言模型学习有限状态语言模型能力的全面理解。我们的结果展示了使用形式语言理论来生成有意义的见解，并呼吁进一步的理论研究以更接近实际应用。

    这篇文章通过理论分析和实证研究，探讨了神经语言模型在学习有限状态语言模型时的表现。希望这篇文章能够为您提供有价值的见解和参考。

    • 人生梦想 - 关注前沿的计算机技术 acejoy.com