长上下文大模型的LongLoRA与LongAlpaca

目录

1. 新闻
2. 亮点
3. 如何贡献
4. 使用要求
5. 安装与快速指南
6. LongAlpaca 数据
7. 模型
8. 训练
9. 评估
10. 演示
11. 流式推理
12. 通过Pdf2Text生成数据
13. 示例
14. 引用
15. 致谢
16. 许可证

新闻

• [2024.1.17] LongLoRA 已被 ICLR 2024 接受为 口头报告。
• [2023.11.19] 我们发布了新版本的 LongAlpaca 模型，包括 LongAlpaca-7B-16k、LongAlpaca-13B-16k 和 LongAlpaca-70B-16k。这些模型是在 LongLoRA 的 SFT 下，基于 LongAlpaca-12k 数据集的一个子集进行微调的，即 LongAlpaca-16k-length。我们对 LongAlpaca-7B-16k 模型进行了 LongBench 和 L-Eval 基准测试，结果可在此处查看：链接。
• [2023.11.2] 我们已将 LongAlpaca 模型的提示方式从 alpaca 提示更新为 llama2 提示，以与其预训练模型保持一致。请参考带有 llama2 提示的 推理代码。
• [2023.10.23] 我们支持在 监督微调 中将 QLoRA 与 LongLoRA 结合使用，以进一步降低 GPU 内存占用。我们已在 LongAlpaca-7B-qlora-weights 上发布了 7B 模型的 LoRA 权重。
• [2023.10.18] 我们支持在我们的 LongAlpaca 模型上使用 StreamingLLM 进行推理。这增加了 StreamingLLM 中多轮对话的上下文长度。
• [2023.10.8] 我们发布了长指令遵循数据集，即 LongAlpaca-12k，以及 相应的模型，包括 LongAlpaca-7B、LongAlpaca-13B 和 LongAlpaca-70B。
• (之前的 sft 模型，Llama-2-13b-chat-longlora-32k-sft 和 Llama-2-70b-chat-longlora-32k-sft，已被弃用。)
• [2023.10.3] 我们新增了对 GPTNeoX 模型的支持。请参阅此 PR 了解使用方法。感谢 @naubull2 的贡献。
• [2023.9.22] 我们发布了所有微调过的 模型，其中包括 70B-32k 模型，如 LLaMA2-LongLoRA-70B-32k 和 LLaMA2-LongLoRA-7B-100k。欢迎大家查看！
• [2023.9.22] 我们发布了 论文 和这个 GitHub 仓库，其中包含了训练和评估代码。

LongLoRA：高效微调长上下文大型语言模型 [论文]
Yukang Chen, Shengju Qian, Haotian Tang, Xin Lai, Zhijian Liu, Song Han, Jiaya Jia

亮点

1. 在 LongLoRA 方法中，提出的偏移短注意力机制易于实现，兼容 Flash-Attention，并且在推理过程中无需使用。
2. 我们发布了所有模型，涵盖 7B 至 70B 不等的参数规模，上下文长度从 8k 到 100k 不等，包括 LLaMA2-LongLoRA-7B-100k、LLaMA2-LongLoRA-13B-64k 和 LLaMA2-LongLoRA-70B-32k 等。
3. 我们构建了一个长上下文指令遵循数据集，即 LongAlpaca-12k。我们还发布了相应的 LongAlpaca-7B、LongAlpaca-13B 和 LongAlpaca-70B 模型。据我们所知，这是首个开源的长上下文 70B 模型。

如何贡献

• 请确保已安装 git。
• 创建您自己的项目 fork。
• 使用 git clone 并粘贴该项目的 URL，在您的本地机器上克隆该仓库。
• 仔细阅读下方的 使用要求 和 安装与快速指南 部分。
• 提交并推送您的更改。
• 完成项目修改后，请发起一个 pull request。

使用要求

要下载和使用 预训练权重，您需要：

1. 具有有效邮箱的 Hugging Face (HF) 账户。请注意，用于 HF 的邮箱也必须用于许可协议。
2. 接受 Meta 的 许可及可接受使用政策

安装与快速指南

要安装并运行该应用：

1. 在 GitHub 上 Fork 此仓库
2. 使用 git clone 命令，并粘贴该项目的 URL，将仓库克隆到本地。
3. 运行以下命令：

pip install -r requirements.txt
pip install flash-attn --no-build-isolation

4. 选择一个 已发布的模型 或者 进行微调，以满足您的需求。
5. 通过聊天测试您的模型。
6. 部署您自己的演示。

LongAlpaca 数据

LongAlpaca-12k 包含我们收集的 9,000 条长问答数据，以及从原始 Alpaca 数据 中采样的 3,000 条短问答数据。这样做是为了避免模型在处理短指令时性能下降的情况。我们收集的数据类型和数量如图所示。

数据	短问答	长问答	总计	下载
LongAlpaca-12k	3k	9k	12k	链接

遵循原始 Alpaca 的格式，我们的长问答数据使用以下提示进行微调：

• instruction: str，描述模型应执行的任务。例如，在阅读书籍章节或论文后回答问题。我们通过变化内容和问题来使指令更加多样化。
• output: str，即对指令的回答。

为了简化流程，我们未使用 Alpaca 格式中的 input 字段。

模型

经过监督微调的模型

模型	参数量	上下文长度	训练方式	链接
LongAlpaca-7B	70亿	32,768	全量微调	模型
LongAlpaca-13B	130亿	32,768	全量微调	模型
LongAlpaca-70B	700亿	32,768	LoRA+	模型 (LoRA权重)

通过全量微调扩展上下文长度的模型

模型	参数量	上下文长度	训练方式	链接
Llama-2-7b-longlora-8k-ft	70亿	8,192	全量微调	模型
Llama-2-7b-longlora-16k-ft	70亿	16,384	全量微调	模型
Llama-2-7b-longlora-32k-ft	70亿	32,768	全量微调	模型
Llama-2-7b-longlora-100k-ft	70亿	100,000	全量微调	模型
Llama-2-13b-longlora-8k-ft	130亿	8,192	全量微调	模型
Llama-2-13b-longlora-16k-ft	130亿	16,384	全量微调	模型
Llama-2-13b-longlora-32k-ft	130亿	32,768	全量微调	模型

通过改进的 LoRA 微调扩展上下文长度的模型

模型	参数量	上下文长度	训练方式	链接
Llama-2-7b-longlora-8k	70亿	8,192	LoRA+	LoRA 权重
Llama-2-7b-longlora-16k	70亿	16,384	LoRA+	LoRA 权重
Llama-2-7b-longlora-32k	70亿	32,768	LoRA+	LoRA 权重
Llama-2-13b-longlora-8k	130亿	8,192	LoRA+	LoRA 权重
Llama-2-13b-longlora-16k	130亿	16,384	LoRA+	LoRA 权重
Llama-2-13b-longlora-32k	130亿	32,768	LoRA+	LoRA 权重
Llama-2-13b-longlora-64k	130亿	65,536	LoRA+	LoRA 权重
Llama-2-70b-longlora-32k	700亿	32,768	LoRA+	LoRA 权重
Llama-2-70b-chat-longlora-32k	700亿	32,768	LoRA+	LoRA 权重

训练

预训练权重

我们使用 LLaMA2 模型作为预训练权重，并对其进行微调以支持更长的上下文窗口。请根据您的需求下载相应的权重。

预训练权重
Llama-2-7b-hf
Llama-2-13b-hf
Llama-2-70b-hf
Llama-2-7b-chat-hf
Llama-2-13b-chat-hf
Llama-2-70b-chat-hf

本项目也支持 GPTNeoX 模型作为基础架构。一些候选的预训练权重可能包括 GPT-NeoX-20B、Polyglot-ko-12.8B 等其他变体。

微调

torchrun --nproc_per_node=8 fine-tune.py  \
        --model_name_or_path path_to/Llama-2-7b-hf \
        --bf16 True \
        --output_dir path_to_saving_checkpoints       \
        --cache_dir path_to_cache \
        --model_max_length 8192 \
        --use_flash_attn True \
        --low_rank_training False \
        --num_train_epochs 1  \
        --per_device_train_batch_size 1     \
        --per_device_eval_batch_size 2     \
        --gradient_accumulation_steps 8     \
        --evaluation_strategy "no"     \
        --save_strategy "steps"     \
        --save_steps 1000     \
        --save_total_limit 2     \
        --learning_rate 2e-5     \
        --weight_decay 0.0     \
        --warmup_steps 20     \
        --lr_scheduler_type "constant_with_warmup"     \
        --logging_steps 1     \
        --deepspeed "ds_configs/stage2.json" \
        --tf32 True \
        --max_steps 1000

• 请记得将 path_to/Llama-2-7b-hf、path_to_saving_checkpoints 和 path_to_cache 替换为您的实际路径。
• 您可以调整 model_max_length 的值。
• 如果需要，您可以将 ds_configs/stage2.json 替换为 ds_configs/stage3.json。
• 如果您使用的是 V100 显卡或未安装 Flash Attention，请将 use_flash_attn 设置为 False。
• 如果您希望进行全参数微调，可以将 low_rank_training 设置为 False。虽然这会占用更多显存且训练速度较慢，但模型性能可能会更好。
• 训练完成后，要获取完整的模型权重：

cd path_to_saving_checkpoints && python zero_to_fp32.py . pytorch_model.bin

请注意，path_to_saving_checkpoints 可能是某个 global_step 目录，具体取决于 DeepSpeed 的版本。

有监督微调

torchrun --nproc_per_node=8 supervised-fine-tune.py  \
        --model_name_or_path path_to_Llama2_chat_models \
        --bf16 True \
        --output_dir path_to_saving_checkpoints       \
        --model_max_length 16384 \
        --use_flash_attn True \
        --data_path LongAlpaca-16k-length.json \
        --low_rank_training True \
        --num_train_epochs 5  \
        --per_device_train_batch_size 1     \
        --per_device_eval_batch_size 2     \
        --gradient_accumulation_steps 8     \
        --evaluation_strategy "no"     \
        --save_strategy "steps"     \
        --save_steps 98     \
        --save_total_limit 2     \
        --learning_rate 2e-5     \
        --weight_decay 0.0     \
        --warmup_steps 20     \
        --lr_scheduler_type "constant_with_warmup"     \
        --logging_steps 1     \
        --deepspeed "ds_configs/stage2.json" \
        --tf32 True

• 对于已扩展上下文的微调模型，无需再进行有监督微调。可以直接使用 Llama2-chat 模型作为基础模型，因为长指令遵循数据已经足够用于 SFT。
• 我们的长指令遵循数据可在 LongAlpaca-12k.json 中找到。
• 如果您想进一步减少显存占用，可以使用 supervised-fine-tune-qlora.py 来尝试 4 位量化微调。这基于 QLoRA。
• 如果在 QLoRA SFT 后保存 pytorch_model.bin 时遇到问题，请参考此 issue。

获取低秩训练中的可训练权重

在低秩训练中，我们设置嵌入层和归一化层为可训练。请使用以下命令从 pytorch_model.bin 中提取可训练权重 trainable_params.bin：

python3 get_trainable_weights.py --checkpoint_path path_to_saving_checkpoints --trainable_params "embed,norm"

合并 LoRA 权重

将 pytorch_model.bin 和可训练参数 trainable_params.bin 的 LoRA 权重合并，并将结果模型以 Hugging Face 格式保存到您指定的路径：

python3 merge_lora_weights_and_save_hf_model.py \
        --base_model path_to/Llama-2-7b-hf \
        --peft_model path_to_saving_checkpoints \
        --context_size 8192 \
        --save_path path_to_saving_merged_model

例如：

python3 merge_lora_weights_and_save_hf_model.py \
        --base_model /dataset/pretrained-models/Llama-2-7b-hf \
        --peft_model /dataset/yukangchen/hf_models/lora-models/Llama-2-7b-longlora-8k \
        --context_size 8192 \
        --save_path /dataset/yukangchen/models/Llama-2-7b-longlora-8k-merged

评估

悖论验证

要在低秩设置下评估模型，请同时设置 base_model 和 peft_model。base_model 是预训练权重，而 peft_model 是保存检查点的路径，其中应包含 trainable_params.bin、adapter_model.bin 和 adapter_config.json。例如：

python3 eval.py --seq_len 8192 --context_size 8192 --batch_size 1 --base_model path_to/Llama-2-7b-hf --peft_model path_to_saving_checkpoints --data_path pg19/test.bin

或者使用多 GPU 进行评估，如下所示：

torchrun --nproc_per_node=auto eval_distributed.py --seq_len 8192 --context_size 8192 --batch_size 1 --base_model path_to/Llama-2-7b-hf --peft_model path_to_saving_checkpoints --data_path pg19/test.bin

对于完全微调后的模型，只需将 base_model 设置为保存检查点的路径，该路径应包含 pytorch_model.bin 和 config.json。此时无需指定 peft_model。

python3 eval.py --seq_len 8192 --context_size 8192 --batch_size 1 --base_model path_to_saving_checkpoints --data_path pg19/test.bin

或者使用多 GPU 进行评估，如下所示：

torchrun --nproc_per_node=auto eval_distributed.py --seq_len 8192 --context_size 8192 --batch_size 1 --base_model path_to_saving_checkpoints --data_path pg19/test.bin

• 请注意，--seq_len 用于设置评估时的序列长度，而 --context_size 则用于设置微调期间模型的上下文长度。--seq_len 不应大于 --context_size。

• 我们已经使用 LLaMA 的分词器将 PG19 和 proof-pile 数据集的验证集和测试部分分别分词为 pg19/validation.bin、pg19/test.bin 和 proof-pile/test_sampled_data.bin。其中，proof-pile/test_sampled_data.bin 包含从 proof-pile 测试集中随机抽取的 128 篇文档，每篇文档至少有 32768 个标记。我们还发布了这些文档的索引文件 proof-pile/test_sampled_ids.bin，您可以通过以下链接下载：

数据集	划分	链接
PG19	验证集	pg19/validation.bin
PG19	测试集	pg19/test.bin
Proof-pile	测试集	proof-pile/test_sampled_data.bin

密钥检索

我们提供了一种测试密钥检索准确性的方法。例如：

python3 passkey_retrivial.py \
        --context_size 32768 \
        --base_model path_to/Llama-2-7b-longlora-32k \
        --max_tokens 32768 \
        --interval 1000

• 请注意，context_size 是微调期间的上下文长度。
• max_tokens 是密钥检索评估中文档的最大长度。
• interval 是文档长度递增的间隔，由于文档是以句子为单位增加的，因此这个数值只是一个大致的参考。

演示

本地推理

要与 LongAlpaca 模型对话，可以运行：

python3 inference.py  \
        --base_model path_to_model \
        --question $question \
        --context_size $context_length \
        --max_gen_len $max_gen_len \
        --flash_attn True \
        --material $material_content

例如，针对一本书提出问题：

python3 inference.py  \
        --base_model /data/models/LongAlpaca-13B \
        --question "为什么斯内普教授似乎不喜欢哈利？" \
        --context_size 32768 \
        --max_gen_len 512 \
        --flash_attn True \
        --material "materials/Harry Potter and the Philosophers Stone_section2.txt"

又如，针对一篇论文提出问题：

python3 inference.py  \
        --base_model /data/models/LongAlpaca-13B \
        --question "这项工作的主要贡献和创新点是什么？" \
        --context_size 32768 \
        --max_gen_len 512 \
        --flash_attn True \
        --material "materials/paper1.txt"

• 请注意，如果您希望进一步减少 GPU 内存占用并尝试 4 位量化微调，可以将 inference.py 替换为 inference-qlora.py。这遵循 QLoRA 的方法。

在线演示

要部署您自己的演示程序，可以运行：

python3 demo.py  \
	--base_model path_to_model \
	--context_size $context_size \
	--max_gen_len $max_gen_len \
	--flash_attn True

例如：

python3 demo.py  \
	--base_model /data/models/LongAlpaca-13B \
	--context_size 32768 \
	--max_gen_len 512 \
	--flash_attn True

• 请注意，将 flash_attn 设置为 True 会降低生成速度，但能显著节省 GPU 内存。

流式推理

我们支持使用 StreamingLLM 对 LongAlpaca 模型进行流式推理。这能够提升 StreamingLLM 中多轮对话的上下文长度。以下是一个示例：

python run_streaming_llama_longalpaca.py \
	----enable_streaming \
	--test_filepath outputs_stream.json \
	--use_flash_attn True \
	--recent_size 32768

• 如果遇到 OOM 问题，请适当减小 recent_size，例如设置为 8192。
• test_filepath 是包含推理提示的 JSON 文件。我们提供了一个示例文件 outputs_stream.json，它是 LongAlpaca-12k 的一个子集。您可以将其替换为您自己的问题。

通过 Pdf2text 生成数据

在收集数据的过程中，我们将论文和书籍从 PDF 转换为文本。转换质量对最终模型的质量有着重要影响。我们认为这一步骤并不简单。为此，我们发布了一个用于 PDF 到文本转换的工具，位于 pdf2txt 文件夹中。该工具基于 pdf2image、easyocr、ditod 和 detectron2 构建。更多详细信息请参阅 pdf2txt 文件夹中的 README.md。

示例

引用

如果您在研究中使用了本项目，请考虑引用以下内容：

@inproceedings{longlora,
  author       = {Yukang Chen and Shengju Qian and Haotian Tang and Xin Lai and Zhijian Liu and Song Han and Jiaya Jia},
  title        = {LongLoRA: 长上下文大语言模型的高效微调},
  booktitle    = {国际表征学习会议 (ICLR)},
  year         = {2024},
}

@misc{long-alpaca,
  author = {Yukang Chen and Shaozuo Yu and Shengju Qian and Haotian Tang and Xin Lai and Zhijian Liu and Song Han and Jiaya Jia},
  title = {Long Alpaca: 长上下文指令遵循模型},
  year = {2023},
  publisher = {GitHub},
  journal = {GitHub 仓库},
  howpublished = {\url{https://github.com/dvlab-research/LongLoRA}},
}

致谢

• 本工作以 LLaMA2 作为预训练模型。
• 本工作也可基于 GPTNeoX-HF，其架构源自 EleutherAI/GPTNeoX 的预训练模型。
• 本工作利用 DeepSpeed、peft 和 Flash-Attention2 进行加速。
• 部分评估代码参考并修改自 Landmark Attention。
• 我们使用 LongChat 进行检索评估。
• 流式推理部分参考了 StreamingLLM。
• 在监督微调中，我们将 QLoRA 与 LongLoRA 结合使用。

许可证

• LongLoRA 采用 Apache License 2.0 许可证。这意味着必须保留版权和许可证声明。
• 数据和权重采用 CC-BY-NC 4.0 许可证。它们仅允许用于研究目的，且仅限非商业用途。使用该数据集训练的模型不得用于研究以外的其他用途。

LongLoRA 快速上手指南

LongLoRA 是一种用于长上下文大型语言模型（LLM）的高效微调方法，支持将 LLaMA2 等模型的上下文窗口扩展至 100k token，同时保持推理速度。本指南帮助中国开发者快速完成环境搭建与基础使用。

环境准备

在开始之前，请确保满足以下系统和依赖要求：

• 操作系统: Linux (推荐 Ubuntu 20.04+)
• Python: 3.8 或更高版本
• GPU: 支持 CUDA 的 NVIDIA 显卡（显存需求视模型大小而定，7B 模型建议至少 16GB，70B 需多卡或量化方案）
• 账号准备:
  • 注册 Hugging Face 账号。
  • 接受 Meta 的 LLaMA 模型许可协议（如需使用 LLaMA2 基座）。
• 网络环境: 由于模型和数据托管在 Hugging Face，国内用户建议配置代理或使用镜像源加速下载。

安装步骤

1. 克隆项目代码

   git clone https://github.com/dvlab-research/LongLoRA.git
   cd LongLoRA
   

2. 安装 Python 依赖 建议先配置国内 pip 镜像源以加速安装：

   pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
   

3. 安装 Flash-Attention LongLoRA 依赖 Flash-Attention 以获得最佳性能。请使用以下命令安装（跳过构建隔离以加快编译）：

   pip install flash-attn --no-build-isolation
   

   注：如果编译失败，请确保已安装正确的 CUDA Toolkit 和 C++ 编译环境。

基本使用

1. 加载预训练模型

你可以直接从 Hugging Face 加载已微调好的 LongAlpaca 模型（例如 7B 版本）。以下是最简单的推理示例：

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

# 模型路径 (可替换为其他版本，如 Yukang/LongAlpaca-13B)
model_name = "Yukang/LongAlpaca-7B"

# 加载分词器和模型
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto"
)

# 准备输入 (遵循 LLaMA2 对话格式)
prompt = """[INST] <<SYS>>
You are a helpful assistant.
<</SYS>>

Summarize the following long text briefly:
(此处放入你的长文本内容...)
[/INST]"""

# 生成回复
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
outputs = model.generate(
    **inputs,
    max_new_tokens=512,
    do_sample=True,
    temperature=0.7,
    top_p=0.9
)

print(tokenizer.decode(outputs[0], skip_special_tokens=True))

2. 使用 LoRA 权重进行推理

如果你使用的是仅包含 LoRA 权重的模型（如 Llama-2-7b-longlora-32k），需要结合基座模型加载：

from peft import PeftModel
from transformers import AutoTokenizer, AutoModelForCausalLM

base_model_name = "meta-llama/Llama-2-7b-hf" # 需接受协议并登录
lora_weights_path = "Yukang/Llama-2-7b-longlora-32k"

tokenizer = AutoTokenizer.from_pretrained(base_model_name)
base_model = AutoModelForCausalLM.from_pretrained(base_model_name, torch_dtype=torch.float16, device_map="auto")

# 加载 LoRA 适配器
model = PeftModel.from_pretrained(base_model, lora_weights_path)

# 后续推理步骤同上...

3. 流式推理 (Streaming)

LongLoRA 支持 StreamingLLM 以处理超长多轮对话，减少显存占用。参考项目中的 inference.py 脚本启用该功能：

python inference.py --model_name_or_path Yukang/LongAlpaca-7B --streaming

提示: 对于长文本任务，请确保输入数据符合 LongAlpaca 的数据格式（Instruction-Output 对），并利用其支持的 32k+ 上下文窗口优势。