【LLM开源项目】LLMs-微调框架-LLaMA-Factory入门指南v3.0

最新推荐文章于 2025-04-19 22:57:21 发布

AI大模型_学习君

最新推荐文章于 2025-04-19 22:57:21 发布

阅读量1.8k

点赞数 10

文章标签：开源 llama LLM 大模型微调 Factory LLMs 大模型入门

本文链接：https://blog.youkuaiyun.com/python12345678_/article/details/142521120

版权

【#】SFT 训练

项目地址：https://llamafactory.readthedocs.io/zh-cn/latest/getting_started/sft.html

可以使用以下命令进行微调：

llamafactory-cli train examples/train_lora/llama3_lora_sft.yaml

examples/train_lora/llama3_lora_sft.yaml 提供了微调时的配置示例。该配置指定了模型参数、微调方法参数、数据集参数以及评估参数等。您需要根据自身需求自行配置。



### examples/train\_lora/llama3\_lora\_sft.yaml  
model\_name\_or\_path: meta-llama/Meta-Llama-3-8B-Instruct  
  
stage: sft  
do\_train: true  
finetuning\_type: lora  
lora\_target: all  
  
dataset: identity,alpaca\_en\_demo  
template: llama3  
cutoff\_len: 1024  
max\_samples: 1000  
overwrite\_cache: true  
preprocessing\_num\_workers: 16  
  
output\_dir: saves/llama3-8b/lora/sft  
logging\_steps: 10  
save\_steps: 500  
plot\_loss: true  
overwrite\_output\_dir: true  
  
per\_device\_train\_batch\_size: 1  
gradient\_accumulation\_steps: 8  
learning\_rate: 1.0e-4  
num\_train\_epochs: 3.0  
lr\_scheduler\_type: cosine  
warmup\_ratio: 0.1  
bf16: true  
ddp\_timeout: 180000000  
  
val\_size: 0.1  
per\_device\_eval\_batch\_size: 1  
eval\_strategy: steps  
eval\_steps: 500

在这里插入图片描述

【#】LoRA 合并

教程地址：https://llamafactory.readthedocs.io/zh-cn/latest/getting_started/merge_lora.html

当我们基于预训练模型训练好 LoRA 适配器后，我们不希望在每次推理的时候分别加载预训练模型和 LoRA 适配器，因此我们需要将预训练模型和 LoRA 适配器合并导出成一个模型。根据是否量化以及量化算法的不同，导出的配置文件有所区别。

您可以通过 llamafactory-cli export merge_config.yaml 指令来合并模型。其中 merge_config.yaml 需要您根据不同情况进行配置。

量化（Quantization）通过数据精度压缩有效地减少了显存使用并加速推理。LLaMA-Factory 支持多种量化方法，包括:

AQLM
AWQ
GPTQ
QLoRA
…

GPTQ 等后训练量化方法(Post Training Quantization)是一种在训练后对预训练模型进行量化的方法。我们通过量化技术将高精度表示的预训练模型转换为低精度的模型，从而在避免过多损失模型性能的情况下减少显存占用并加速推理，我们希望低精度数据类型在有限的表示范围内尽可能地接近高精度数据类型的表示，因此我们需要指定量化位数 export_quantization_bit 以及校准数据集 export_quantization_dataset。

在进行模型合并时，请指定：

model_name_or_path: 预训练模型的名称或路径
template: 模型模板
export_dir: 导出路径
export_quantization_bit: 量化位数
export_quantization_dataset: 量化校准数据集
export_size: 最大导出模型文件大小
export_device: 导出设备
export_legacy_format: 是否使用旧格式导出

下面提供一个配置文件示例：

### examples/merge_lora/llama3_gptq.yaml  
### model  
model_name_or_path: meta-llama/Meta-Llama-3-8B-Instruct  
template: llama3  
  
### export  
export_dir: models/llama3_gptq  
export_quantization_bit: 4  
export_quantization_dataset: data/c4_demo.json  
export_size: 2  
export_device: cpu  
export_legacy_format: false

QLoRA 是一种在 4-bit 量化模型基础上使用 LoRA 方法进行训练的技术。它在极大地保持了模型性能的同时大幅减少了显存占用和推理时间。

### examples/merge_lora/llama3_q_lora.yaml  
### model  
model_name_or_path: meta-llama/Meta-Llama-3-8B-Instruct  
adapter_name_or_path: saves/llama3-8b/lora/sft  
template: llama3  
finetuning_type: lora  
  
### export  
export_dir: models/llama3_lora_sft  
export_size: 2  
export_device: cpu  
export_legacy_format: false

examples/merge_lora/llama3_lora_sft.yaml 提供了合并时的配置示例。

### examples/merge_lora/llama3_lora_sft.yaml  
### model  
model_name_or_path: meta-llama/Meta-Llama-3-8B-Instruct  
adapter_name_or_path: saves/llama3-8b/lora/sft  
template: llama3  
finetuning_type: lora  
  
### export  
export_dir: models/llama3_lora_sft  
export_size: 2  
export_device: cpu  
export_legacy_format: false

备注：模型 model_name_or_path 需要存在且与 template 相对应。 adapter_name_or_path 需要与微调中的适配器输出路径 output_dir 相对应。合并 LoRA 适配器时，不要使用量化模型或指定量化位数。您可以使用本地或下载的未量化的预训练模型进行合并。

【#】模型推理

教程地址：https://llamafactory.readthedocs.io/zh-cn/latest/getting_started/inference.html

LLaMA-Factory 支持多种推理方式。

可以使用 llamafactory-cli chat inference_config.yaml 或 llamafactory-cli webchat inference_config.yaml 进行推理与模型对话。对话时配置文件只需指定原始模型 model_name_or_path 和 template ，并根据是否是微调模型指定 adapter_name_or_path 和 finetuning_type。

如果希望向模型输入大量数据集并记录推理输出，您可以使用 llamafactory-cli train inference_config.yaml 使用数据集或 llamafactory-cli api 使用 api 进行批量推理。

使用任何方式推理时，模型 model_name_or_path 需要存在且与 template 相对应。

原始模型推理配置

对于原始模型推理，inference_config.yaml`中只需指定原始模型 ``model_name_or_path和 template 即可。

### examples/inference/llama3.yaml  
model_name_or_path: meta-llama/Meta-Llama-3-8B-Instruct  
template: llama

微调模型推理配置

对于微调模型推理，除原始模型和模板外，还需要指定适配器路径 adapter_name_or_path 和微调类型 finetuning_type。

### examples/inference/llama3_lora_sft.yaml  
model_name_or_path: meta-llama/Meta-Llama-3-8B-Instruct  
adapter_name_or_path: saves/llama3-8b/lora/sft  
template: llama3  
finetuning_type: lora

多模态模型

对于多模态模型，您可以运行以下指令进行推理。

llamafactory-cli webchat examples/inferece/llava1_5.yaml

examples/inference/llava1_5.yaml 的配置示例如下：

model_name_or_path: llava-hf/llava-1.5-7b-hf  
template: vicuna  
visual_inputs: true

vllm推理框架

若使用vllm推理框架，请在配置中指定： infer_backend 与 vllm_enforce_eager。



### examples/inference/llama3\_vllm.yaml  
model\_name\_or\_path: meta-llama/Meta-Llama-3-8B-Instruct  
template: llama3  
infer\_backend: vllm  
vllm\_enforce\_eager: true

使用数据集批量推理

使用数据集批量推理时，需要指定模型、适配器（可选）、评估数据集、输出路径等信息并且指定 do_predict 为 true。下面提供一个示例,可以通过使用数据集进行批量推理。

llamafactory-cli train examples/train_lora/llama3_lora_predict.yaml

如果您需要多卡推理，则需要在配置文件中指定 deepspeed 参数。

# examples/train_lora/llama3_lora_predict.yaml  
### model  
model_name_or_path: meta-llama/Meta-Llama-3-8B-Instruct  
adapter_name_or_path: saves/llama3-8b/lora/sft  
  
deepspeed: examples/deepspeed/ds_z3_config.yaml # deepspeed配置文件  
  
### method  
stage: sft  
do_predict: true  
finetuning_type: lora  
  
### dataset  
eval_dataset: identity,alpaca_en_demo  
template: llama3  
cutoff_len: 1024  
max_samples: 50  
overwrite_cache: true  
preprocessing_num_workers: 16  
  
### output  
output_dir: saves/llama3-8b/lora/predict  
overwrite_output_dir: true  
  
### eval  
per_device_eval_batch_size: 1  
predict_with_generate: true  
ddp_timeout: 180000000

只有 stage 为 sft 的时候才可设置 predict_with_generate 为 true。

使用api批量推理

如果需要使用 api 进行批量推理，您只需指定模型、适配器（可选）、模板、微调方式等信息。

下面是一个配置文件的示例：

# examples/inference/llama3_lora_sft.yaml  
model_name_or_path: meta-llama/Meta-Llama-3-8B-Instruct  
adapter_name_or_path: saves/llama3-8b/lora/sft  
template: llama3  
finetuning_type: lora

下面是一个启动并调用 api 服务的示例：

可以使用如下启动 api 服务：

API_PORT=8000 CUDA_VISIBLE_DEVICES=0 llamafactory-cli api examples/inference/llama3_lora_sft.yaml

并运行以下示例程序进行调用：

# api_call_example.py  
from openai import OpenAI  
client = OpenAI(api_key="0",base_url="http://0.0.0.0:8000/v1")  
messages = [{"role": "user", "content": "Who are you?"}]  
result = client.chat.completions.create(messages=messages, model="meta-llama/Meta-Llama-3-8B-Instruct")  
print(result.choices[0].message)

【#】模型评估

教程地址：https://llamafactory.readthedocs.io/zh-cn/latest/getting_started/eval.html

在完成模型训练后，可以通过 llamafactory-cli eval examples/train_lora/llama3_lora_eval.yaml 来评估模型效果。

配置示例文件 examples/train_lora/llama3_lora_eval.yaml 具体如下：

### examples/train_lora/llama3_lora_eval.yaml  
### model  
model_name_or_path: meta-llama/Meta-Llama-3-8B-Instruct  
adapter_name_or_path: saves/llama3-8b/lora/sft # 可选项  
  
### method  
finetuning_type: lora  
  
### dataset  
task: mmlu_test  
template: fewshot  
lang: en  
n_shot: 5  
  
### output  
save_dir: saves/llama3-8b/lora/eval  
  
### eval  
batch_size: 4

在批量推理的过程中，模型的 BLEU 和 ROUGE 分数会被自动计算并保存，您也可以通过此方法评估模型。

下面是相关参数的介绍:

在这里插入图片描述

【#】加速技术

LLaMA-Factory 支持多种加速技术，包括：FlashAttention 、 Unsloth 。

FlashAttention

FlashAttention 能够加快注意力机制的运算速度，同时减少对内存的使用。

如果您想使用 FlashAttention,请在启动训练时在训练配置文件中添加以下参数：

flash_attn: fa2

Unsloth

Unsloth 框架支持 Llama, Mistral, Phi-3, Gemma, Yi, DeepSeek, Qwen等大语言模型并且支持 4-bit 和 16-bit 的 QLoRA/LoRA 微调，该框架在提高运算速度的同时还减少了显存占用。

如果您想使用 Unsloth,请在启动训练时在训练配置文件中添加以下参数：



use\_unsloth: True

【#】调优算法

LLaMA-Factory 支持多种调优算法，包括：Full Parameter Fine-tuning 、 Freeze 、 LoRA 、 Galore 、 BAdam 。

Full Parameter Fine-tuning

全参微调指的是在训练过程中对于预训练模型的所有权重都进行更新，但其对显存的要求是巨大的。

如果您需要进行全参微调，请将 finetuning_type 设置为 full 。下面是一个例子：

### examples/train_full/llama3_full_sft_ds3..yaml  
# ...  
finetuning_type: full  
# ...  
# 如果需要使用deepspeed:  
deepspeed: examples/deepspeed/ds_z3_config.json

Freeze

Freeze(冻结微调)指的是在训练过程中只对模型的小部分权重进行更新，这样可以降低对显存的要求。

如果您需要进行冻结微调，请将 finetuning_type 设置为 freeze 并且设置相关参数, 例如冻结的层数 freeze_trainable_layers 、可训练的模块名称 freeze_trainable_modules 等。

以下是一个例子：

...  
### method  
stage: sft  
do_train: true  
finetuning_type: freeze  
freeze_trainable_layers: 8  
freeze_trainable_modules: all  
...

LoRA

如果您需要进行 LoRA 微调，请将 finetuning_type 设置为 lora 并且设置相关参数。下面是一个例子：

...  
### method  
stage: sft  
do_train: true  
finetuning_type: lora  
lora_target: all  
lora_rank: 8  
lora_alpha: 16  
lora_dropout: 0.1  
...

LoRA+

在LoRA中，适配器矩阵 A 和 B 的学习率相同。您可以通过设置 loraplus_lr_ratio 来调整学习率比例。在 LoRA+ 中，适配器矩阵 A 的学习率 ηA 即为优化器学习率。适配器矩阵 B 的学习率 ηB 为 λ * ηA。其中 λ 为 loraplus_lr_ratio 的值，一般取16。

rsLoRA

LoRA 通过添加低秩适配器进行微调，然而当增大 lora_rank 时，其训练速度会减慢。rsLoRA(Rank-Stabilized LoRA) 通过修改缩放因子使得模型训练更加稳定。使用 rsLoRA 时， lora_rank 的大小对训练速度没有影响。注意，使用rsLoRA时，您只需要将 use_rslora 设置为 True ，而无需修改 lora_rank, lora_alpha 等参数。

DoRA

DoRA （Weight-Decomposed Low-Rank Adaptation）提出尽管 LoRA 大幅降低了推理成本，但这种方式取得的性能与全量微调之间仍有差距。

DoRA 将权重矩阵分解为大小与单位方向矩阵的乘积，并进一步微调二者（对方向矩阵则进一步使用 LoRA 分解），从而实现 LoRA 与 Full Fine-tuning 之间的平衡。

如果您需要使用 DoRA，请将 use_dora 设置为 True 。

PiSSA

在 LoRA 中，适配器矩阵 A 由 kaiming_uniform 初始化，而适配器矩阵 B 则全初始化为0。这导致一开始的输入并不会改变模型输出并且使得梯度较小，收敛较慢。PiSSA 通过奇异值分解直接分解原权重矩阵进行初始化，其优势在于它可以更快更好地收敛。

如果您需要使用 PiSSA，请将 pissa_init 设置为 True 。

Galore

当需要在训练中使用 GaLore（Gradient Low-Rank Projection）算法时，可以通过设置 GaloreArguments 中的参数进行配置。

下面是一个例子：

...  
### method  
stage: sft  
do_train: true  
finetuning_type: full  
use_galore: true  
galore_layerwise: true  
galore_target: mlp,self_attn  
galore_rank: 128  
galore_scale: 2.0  
...

不要将 LoRA 和 GaLore/BAdam 一起使用。
``galore_layerwise``为 ``true``时请不要设置 ``gradient_accumulation``参数。

BAdam

BAdam 是一种内存高效的全参优化方法，您通过配置 BAdamArgument 中的参数可以对其进行详细设置。下面是一个例子：

### model  
...  
### method  
stage: sft  
do_train: true  
finetuning_type: full  
use_badam: true  
badam_mode: layer  
badam_switch_mode: ascending  
badam_switch_interval: 50  
badam_verbose: 2  
pure_bf16: true  
...

不要将 LoRA 和 GaLore/BAdam 一起使用。

使用 BAdam 时请设置 finetuning_type 为 full 且 pure_bf16 为 True 。

badam_mode = layer 时仅支持使用 DeepSpeed ZeRO3 进行单卡或多卡训练。

badam_mode = ratio 时仅支持单卡训练。

【#】分布训练-NativeDDP

LLaMA-Factory 支持单机多卡和多机多卡分布式训练。同时也支持 DDP , DeepSpeed 和 FSDP 三种分布式引擎。

DDP (DistributedDataParallel) 通过实现模型并行和数据并行实现训练加速。使用 DDP 的程序需要生成多个进程并且为每个进程创建一个 DDP 实例，他们之间通过 torch.distributed 库同步。

DeepSpeed 是微软开发的分布式训练引擎，并提供ZeRO（Zero Redundancy Optimizer）、offload、Sparse Attention、1 bit Adam、流水线并行等优化技术。您可以根据任务需求与设备选择使用。

FSDP 通过全切片数据并行技术（Fully Sharded Data Parallel）来处理更多更大的模型。在 DDP 中，每张 GPU 都各自保留了一份完整的模型参数和优化器参数。而 FSDP 切分了模型参数、梯度与优化器参数，使得每张 GPU 只保留这些参数的一部分。除了并行技术之外，FSDP 还支持将模型参数卸载至CPU，从而进一步降低显存需求。

NativeDDP 是 PyTorch 提供的一种分布式训练方式，您可以通过以下命令启动训练：

单机多卡- llamafactory-cli

可以使用 llamafactory-cli 启动 NativeDDP 引擎。

FORCE_TORCHRUN=1 llamafactory-cli train examples/train_full/llama3_full_sft_ds3.yaml

如果 CUDA_VISIBLE_DEVICES 没有指定，则默认使用所有GPU。如果需要指定GPU，例如第0、1个GPU，可以使用：

FORCE_TORCHRUN=1 CUDA_VISIBLE_DEVICES=0,1 llamafactory-cli train config/config1.yaml

单机多卡- torchrun

可以使用 torchrun 指令启动 NativeDDP 引擎进行单机多卡训练。下面提供一个示例：

torchrun  --standalone --nnodes=1 --nproc-per-node=8  src/train.py \  
--stage sft \  
--model_name_or_path meta-llama/Meta-Llama-3-8B-Instruct  \  
--do_train \  
--dataset alpaca_en_demo \  
--template llama3 \  
--finetuning_type lora \  
--output_dir  saves/llama3-8b/lora/ \  
--overwrite_cache \  
--per_device_train_batch_size 1 \  
--gradient_accumulation_steps 8 \  
--lr_scheduler_type cosine \  
--logging_steps 100 \  
--save_steps 500 \  
--learning_rate 1e-4 \  
--num_train_epochs 2.0 \  
--plot_loss \  
--bf16

单机多卡- accelerate

可以使用 accelerate 指令启动进行单机多卡训练。

首先运行以下命令，根据需求回答一系列问题后生成配置文件：

accelerate config

下面提供一个示例配置文件：

# accelerate_singleNode_config.yaml  
compute_environment: LOCAL_MACHINE  
debug: true  
distributed_type: MULTI_GPU  
downcast_bf16: 'no'  
enable_cpu_affinity: false  
gpu_ids: all  
machine_rank: 0  
main_training_function: main  
mixed_precision: fp16  
num_machines: 1  
num_processes: 8  
rdzv_backend: static  
same_network: true  
tpu_env: []  
tpu_use_cluster: false  
tpu_use_sudo: false  
use_cpu: false

可以通过运行以下指令开始训练:

accelerate launch \  
--config_file accelerate_singleNode_config.yaml \  
src/train.py training_config.yaml

多机多卡-lla mafactory-cli

FORCE_TORCHRUN=1 NNODES=2 RANK=0 MASTER_ADDR=192.168.0.1 MASTER_PORT=29500 \  
llamafactory-cli train examples/train_lora/llama3_lora_sft.yaml  
  
FORCE_TORCHRUN=1 NNODES=2 RANK=1 MASTER_ADDR=192.168.0.1 MASTER_PORT=29500 \  
llamafactory-cli train examples/train_lora/llama3_lora_sft.yam

在这里插入图片描述

多机多卡-torchrun

可以使用 torchrun 指令启动 NativeDDP 引擎进行多机多卡训练。

torchrun --master_port 29500 --nproc_per_node=8 --nnodes=2 --node_rank=0  \  
--master_addr=192.168.0.1  train.py  
torchrun --master_port 29500 --nproc_per_node=8 --nnodes=2 --node_rank=1  \  
--master_addr=192.168.0.1  train.py

多机多卡-accelerate

可以使用 accelerate 指令启动进行多机多卡训练。

首先运行以下命令，根据需求回答一系列问题后生成配置文件：

accelerate config

下面提供一个示例配置文件：

# accelerate_multiNode_config.yaml  
compute_environment: LOCAL_MACHINE  
debug: true  
distributed_type: MULTI_GPU  
downcast_bf16: 'no'  
enable_cpu_affinity: false  
gpu_ids: all  
machine_rank: 0  
main_process_ip: '192.168.0.1'  
main_process_port: 29500  
main_training_function: main  
mixed_precision: fp16  
num_machines: 2  
num_processes: 16  
rdzv_backend: static  
same_network: true  
tpu_env: []  
tpu_use_cluster: false  
tpu_use_sudo: false  
use_cpu: false

可以通过运行以下指令开始训练:

accelerate launch \  
--config_file accelerate_multiNode_config.yaml \  
train.py llm_config.yaml

【#】分布训练-DeepSpeed

DeepSpeed 是由微软开发的一个开源深度学习优化库，旨在提高大模型训练的效率和速度。在使用 DeepSpeed 之前，您需要先估计训练任务的显存大小，再根据任务需求与资源情况选择合适的 ZeRO 阶段。

ZeRO-1: 仅划分优化器参数，每个GPU各有一份完整的模型参数与梯度。
ZeRO-2: 划分优化器参数与梯度，每个GPU各有一份完整的模型参数。
ZeRO-3: 划分优化器参数、梯度与模型参数。

简单来说：从 ZeRO-1 到 ZeRO-3，阶段数越高，显存需求越小，但是训练速度也依次变慢。此外，设置 offload_param=cpu 参数会大幅减小显存需求，但会极大地使训练速度减慢。因此，如果您有足够的显存，应当使用 ZeRO-1，并且确保 offload_param=none。

LLaMA-Factory提供了使用不同阶段的 DeepSpeed 配置文件的示例。包括：

ZeRO-0 (不开启)
ZeRO-2
ZeRO-2+offload
ZeRO-3
ZeRO-3+offload

https://huggingface.co/docs/transformers/deepspeed 提供了更为详细的介绍。

单机多卡-llamafactory-cli

可以使用 llamafactory-cli 启动 DeepSpeed 引擎进行单机多卡训练。

FORCE_TORCHRUN=1 llamafactory-cli train examples/train_full/llama3_full_sft_ds3.yaml

为了启动 DeepSpeed 引擎，配置文件中 deepspeed 参数指定了 DeepSpeed 配置文件的路径:

...  
deepspeed: examples/deepspeed/ds_z3_config.json  
...

单机多卡-deepspeed

可以使用 deepspeed 指令启动 DeepSpeed 引擎进行单机多卡训练。

deepspeed --include localhost:1 your_program.py <normal cl args> --deepspeed ds_config.json

下面是一个例子：

deepspeed --num_gpus 8 src/train.py \  
--deepspeed examples/deepspeed/ds_z3_config.json \  
--stage sft \  
--model_name_or_path meta-llama/Meta-Llama-3-8B-Instruct  \  
--do_train \  
--dataset alpaca_en \  
--template llama3 \  
--finetuning_type full \  
--output_dir  saves/llama3-8b/lora/full \  
--overwrite_cache \  
--per_device_train_batch_size 1 \  
--gradient_accumulation_steps 8 \  
--lr_scheduler_type cosine \  
--logging_steps 10 \  
--save_steps 500 \  
--learning_rate 1e-4 \  
--num_train_epochs 2.0 \  
--plot_loss \  
--bf16

使用 deepspeed 指令启动 DeepSpeed 引擎时您无法使用 CUDA_VISIBLE_DEVICES 指定GPU。而需要：

deepspeed --include localhost:1 your_program.py <normal cl args> --deepspeed ds_config.json

`--include localhost:1` 表示只是用本节点的gpu1。

多机多卡-deepspeed

LLaMA-Factory 支持使用 DeepSpeed 的多机多卡训练，您可以通过以下命令启动：

FORCE_TORCHRUN=1 NNODES=2 RANK=0 MASTER_ADDR=192.168.0.1 MASTER_PORT=29500 llamafactory-cli train examples/train_lora/llama3_lora_sft_ds3.yaml  
FORCE_TORCHRUN=1 NNODES=2 RANK=1 MASTER_ADDR=192.168.0.1 MASTER_PORT=29500 llamafactory-cli train examples/train_lora/llama3_lora_sft_ds3.yaml

可以使用 deepspeed 指令来启动多机多卡训练。

deepspeed --num_gpus 8 --num_nodes 2 --hostfile hostfile --master_addr hostname1 --master_port=9901 your_program.py <normal cl args> --deepspeed ds_config.json

多机多卡-accelerate

可以使用 accelerate 指令启动 DeepSpeed 引擎。首先通过以下命令生成 DeepSpeed 配置文件：

accelerate config

下面提供一个配置文件示例：

# deepspeed_config.yaml  
compute_environment: LOCAL_MACHINE  
debug: false  
deepspeed_config:  
    deepspeed_multinode_launcher: standard  
    gradient_accumulation_steps: 8  
    offload_optimizer_device: none  
    offload_param_device: none  
    zero3_init_flag: false  
    zero_stage: 3  
distributed_type: DEEPSPEED  
downcast_bf16: 'no'  
enable_cpu_affinity: false  
machine_rank: 0  
main_process_ip: '192.168.0.1'  
main_process_port: 29500  
main_training_function: main  
mixed_precision: fp16  
num_machines: 2  
num_processes: 16  
rdzv_backend: static  
same_network: true  
tpu_env: []  
tpu_use_cluster: false  
tpu_use_sudo: false  
use_cpu: false

随后，可以使用以下命令启动训练：

accelerate launch \  
--config_file deepspeed_config.yaml \  
train.py llm_config.yaml

【#】DeepSpeed 配置文件

ZeRO-0

### ds_z0_config.json  
{  
    "train_batch_size": "auto",  
    "train_micro_batch_size_per_gpu": "auto",  
    "gradient_accumulation_steps": "auto",  
    "gradient_clipping": "auto",  
    "zero_allow_untested_optimizer": true,  
    "fp16": {  
        "enabled": "auto",  
        "loss_scale": 0,  
        "loss_scale_window": 1000,  
        "initial_scale_power": 16,  
        "hysteresis": 2,  
        "min_loss_scale": 1  
    },  
    "bf16": {  
        "enabled": "auto"  
    },  
    "zero_optimization": {  
        "stage": 0,  
        "allgather_partitions": true,  
        "allgather_bucket_size": 5e8,  
        "overlap_comm": true,  
        "reduce_scatter": true,  
        "reduce_bucket_size": 5e8,  
        "contiguous_gradients": true,  
        "round_robin_gradients": true  
    }  
}

ZeRO-2

只需在 ZeRO-0 的基础上修改 zero_optimization 中的 stage 参数即可。

### ds_z2_config.json  
{  
    ...  
    "zero_optimization": {  
        "stage": 2,  
    ...  
    }  
}

ZeRO-2+offload

只需在 ZeRO-0 的基础上在 zero_optimization 中添加 offload_optimizer 参数即可。

### ds_z2_offload_config.json  
{  
    ...  
    "zero_optimization": {  
        "stage": 2,  
        "offload_optimizer": {  
        "device": "cpu",  
        "pin_memory": true  
        },  
    ...  
    }  
}

ZeRO-3

只需在 ZeRO-0 的基础上修改 zero_optimization 中的参数。

### ds_z3_config.json  
{  
    ...  
    "zero_optimization": {  
        "stage": 3,  
        "overlap_comm": true,  
        "contiguous_gradients": true,  
        "sub_group_size": 1e9,  
        "reduce_bucket_size": "auto",  
        "stage3_prefetch_bucket_size": "auto",  
        "stage3_param_persistence_threshold": "auto",  
        "stage3_max_live_parameters": 1e9,  
        "stage3_max_reuse_distance": 1e9,  
        "stage3_gather_16bit_weights_on_model_save": true  
    }  
}

ZeRO-3+offload

只需在 ZeRO-3 的基础上添加 zero_optimization 中的 offload_optimizer 和 offload_param 参数即可。

### ds_z3_offload_config.json  
{  
    ...  
    "zero_optimization": {  
        "stage": 3,  
        "offload_optimizer": {  
        "device": "cpu",  
        "pin_memory": true  
        },  
        "offload_param": {  
        "device": "cpu",  
        "pin_memory": true  
        },  
    ...  
    }  
}

https://www.deepspeed.ai/docs/config-json/ 提供了关于deepspeed配置文件的更详细的介绍。

【#】分布训练-FSDP

PyTorch 的全切片数据并行技术 FSDP （Fully Sharded Data Parallel）能让我们处理更多更大的模型。LLaMA-Factory支持使用 FSDP 引擎进行分布式训练。

FSDP 的参数 ShardingStrategy 的不同取值决定了模型的划分方式：

FULL_SHARD: 将模型参数、梯度和优化器状态都切分到不同的GPU上，类似ZeRO-3。
SHARD_GRAD_OP: 将梯度、优化器状态切分到不同的GPU上，每个GPU仍各自保留一份完整的模型参数。类似ZeRO-2。
NO_SHARD: 不切分任何参数。类似ZeRO-0。

FSDP-llamafactory-cli

只需根据需要修改examples/accelerate/fsdp_config.yaml以及examples/extras/fsdp_qlora/llama3_lora_sft.yaml ，文件然后运行以下命令即可启动 FSDP+QLoRA 微调：

bash examples/extras/fsdp qlora/train.sh

FSDP-accelerate

可以使用 accelerate 启动 FSDP 引擎，节点数与 GPU 数可以通过 num_machines 和 num_processes 指定。对此，Huggingface 提供了便捷的配置功能。只需运行：

accelerate config

根据提示回答一系列问题后，我们就可以生成 FSDP 所需的配置文件。当然您也可以根据需求自行配置 fsdp_config.yaml 。

### /examples/accelerate/fsdp_config.yaml  
compute_environment: LOCAL_MACHINE  
debug: false  
distributed_type: FSDP  
downcast_bf16: 'no'  
fsdp_config:  
    fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP  
    fsdp_backward_prefetch: BACKWARD_PRE  
    fsdp_forward_prefetch: false  
    fsdp_cpu_ram_efficient_loading: true  
    fsdp_offload_params: true # offload may affect training speed  
    fsdp_sharding_strategy: FULL_SHARD  
    fsdp_state_dict_type: FULL_STATE_DICT  
    fsdp_sync_module_states: true  
    fsdp_use_orig_params: true  
machine_rank: 0  
main_training_function: main  
mixed_precision: fp16 # or bf16  
num_machines: 1 # the number of nodes  
num_processes: 2 # the number of GPUs in all nodes  
rdzv_backend: static  
same_network: true  
tpu_env: []  
tpu_use_cluster: false  
tpu_use_sudo: false  
use_cpu: false

请确保 num_processes 和实际使用的总GPU数量一致

随后，您可以使用以下命令启动训练：

accelerate launch \  
--config_file fsdp_config.yaml \  
src/train.py llm_config.yaml

不要在 FSDP+QLoRA 中使用 GPTQ/AWQ 模型

【#】模型量化

https://llamafactory.readthedocs.io/zh-cn/latest/advanced/quantization.html

随着语言模型规模的不断增大，其训练的难度和成本已成为共识。而随着用户数量的增加，模型推理的成本也在不断攀升，甚至可能成为限制模型部署的首要因素。因此，我们需要对模型进行压缩以加速推理过程，而模型量化是其中一种有效的方法。

大语言模型的参数通常以高精度浮点数存储，这导致模型推理需要大量计算资源。量化技术通过将高精度数据类型存储的参数转换为低精度数据类型存储，可以在不改变模型参数量和架构的前提下加速推理过程。这种方法使得模型的部署更加经济高效，也更具可行性。

在这里插入图片描述

浮点数一般由3部分组成：符号位、指数位和尾数位。指数位越大，可表示的数字范围越大。尾数位越大、数字的精度越高。

量化可以根据何时量化分为：后训练量化和训练感知量化，也可以根据量化参数的确定方式分为：静态量化和动态量化。

PTQ

后训练量化（PTQ, Post-Training Quantization）一般是指在模型预训练完成后，基于校准数据集（calibration dataset）确定量化参数进而对模型进行量化。

GPTQ

GPTQ(Group-wise Precision Tuning Quantization)是一种静态的后训练量化技术。”静态”指的是预训练模型一旦确定,经过量化后量化参数不再更改。GPTQ 量化技术将 fp16 精度的模型量化为 4-bit ,在节省了约 75% 的显存的同时大幅提高了推理速度。为了使用GPTQ量化模型，您需要指定量化模型名称或路径，例如 model_name_or_path: TechxGenus/Meta-Llama-3-8B-Instruct-GPTQ

QAT

在训练感知量化（QAT, Quantization-Aware Training）中，模型一般在预训练过程中被量化，然后又在训练数据上再次微调，得到最后的量化模型。

AWQ

AWQ（Activation-Aware Layer Quantization）是一种静态的后训练量化技术。其思想基于：有很小一部分的权重十分重要，为了保持性能这些权重不会被量化。AWQ 的优势在于其需要的校准数据集更小，且在指令微调和多模态模型上表现良好。为了使用 AWQ 量化模型,您需要指定量化模型名称或路径，例如 model_name_or_path: TechxGenus/Meta-Llama-3-8B-Instruct-AWQ

AQLM

AQLM（Additive Quantization of Language Models）作为一种只对模型权重进行量化的PTQ方法，在 2-bit 量化下达到了当时的最佳表现，并且在 3-bit 和 4-bit 量化下也展示了性能的提升。尽管 AQLM 在模型推理速度方面的提升并不是最显著的，但其在 2-bit 量化下的优异表现意味着您可以以极低的显存占用来部署大模型。

OFTQ

OFTQ(On-the-fly Quantization)指的是模型无需校准数据集，直接在推理阶段进行量化。OFTQ是一种动态的后训练量化技术. OFTQ在保持性能的同时。因此，在使用OFTQ量化方法时，您需要指定预训练模型、指定量化方法 quantization_method 和指定量化位数 quantization_bit 下面提供了一个使用bitsandbytes量化方法的配置示例：

model_name_or_path:meta-llama/Meta-Llama-3-8B-Instruct  
quantization_bit:4  
quantization_method:bitsandbytes# choices: [bitsandbytes (4/8), hqq (2/3/4/5/6/8), eetq (8)]

bitsandbytes

区别于 GPTQ, bitsandbytes 是一种动态的后训练量化技术。bitsandbytes 使得大于 1B 的语言模型也能在 8-bit 量化后不过多地损失性能。经过bitsandbytes 8-bit 量化的模型能够在保持性能的情况下节省约50%的显存。

HQQ

依赖校准数据集的方法往往准确度较高，不依赖校准数据集的方法往往速度较快。HQQ（Half-Quadratic Quantization）希望能在准确度和速度之间取得较好的平衡。作为一种动态的后训练量化方法，HQQ无需校准阶段，但能够取得与需要校准数据集的方法相当的准确度，并且有着极快的推理速度。

EETQ

EETQ(Easy and Efficient Quantization for Transformers)是一种只对模型权重进行量化的PTQ方法。具有较快的速度和简单易用的特性。

【#】训练方法

https://llamafactory.readthedocs.io/zh-cn/latest/advanced/trainers.html

Pre-training

大语言模型通过在一个大型的通用数据集上通过无监督学习的方式进行预训练，来学习语言的表征/初始化模型权重/学习概率分布。期望在预训练后模型能够处理大量、多种类的数据集，进而可以通过监督学习的方式来微调模型使其适应特定的任务。

预训练时，请将 stage 设置为 pt ，并确保使用的数据集符合预训练数据集格式。

（https://llamafactory.readthedocs.io/zh-cn/latest/getting_started/data_preparation.html#id7）

下面提供预训练的配置示例：

### model  
model_name_or_path: meta-llama/Meta-Llama-3-8B-Instruct  
  
### method  
stage: pt  
do_train: true  
finetuning_type: lora  
lora_target: all  
  
### dataset  
dataset: c4_demo  
cutoff_len: 1024  
max_samples: 1000  
overwrite_cache: true  
preprocessing_num_workers: 16  
  
### output  
output_dir: saves/llama3-8b/lora/sft  
logging_steps: 10  
save_steps: 500  
plot_loss: true  
overwrite_output_dir: true  
  
### train  
per_device_train_batch_size: 1  
gradient_accumulation_steps: 8  
learning_rate: 1.0e-4  
num_train_epochs: 3.0  
lr_scheduler_type: cosine  
warmup_ratio: 0.1  
bf16: true  
ddp_timeout: 180000000

Post-training

在预训练结束后，模型的参数得到初始化，模型能够理解语义、语法以及识别上下文关系，在处理一般性任务时有着不错的表现。尽管模型涌现出的零样本学习，少样本学习的特性使其能在一定程度上完成特定任务，但仅通过提示（prompt）并不一定能使其表现令人满意。因此，我们需要后训练(post-training)来使得模型在特定任务上也有足够好的表现。

Supervised Fine-Tuning

Supervised Fine-Tuning(监督微调)是一种在预训练模型上使用小规模有标签数据集进行训练的方法。相比于预训练一个全新的模型，对已有的预训练模型进行监督微调是更快速更节省成本的途径。

监督微调时，请将 stage 设置为 sft 。下面提供监督微调的配置示例：

...  
stage: sft  
fintuning_type: lora  
...

RLHF

由于在监督微调中语言模型学习的数据来自互联网，所以模型可能无法很好地遵循用户指令，甚至可能输出非法、暴力的内容，因此我们需要将模型行为与用户需求对齐(alignment)。通过 RLHF(Reinforcement Learning from Human Feedback) 方法，我们可以通过人类反馈来进一步微调模型，使得模型能够更好更安全地遵循用户指令。

Reward model

但是，获取真实的人类数据是十分耗时且昂贵的。一个自然的想法是我们可以训练一个奖励模型（reward model）来代替人类对语言模型的输出进行评价。为了训练这个奖励模型，我们需要让奖励模型获知人类偏好，而这通常通过输入经过人类标注的偏好数据集来实现。在偏好数据集中，数据由三部分组成：输入、好的回答、坏的回答。奖励模型在偏好数据集上训练，从而可以更符合人类偏好地评价语言模型的输出。

在训练奖励模型时，请将 stage 设置为 rm ，确保使用的数据集符合偏好数据集格式并且指定奖励模型的保存路径。以下提供一个示例：

...  
stage: rm  
dataset: dpo_en_demo  
...  
output_dir: saves/llama3-8b/lora/reward  
...

PPO

在训练奖励完模型之后，我们可以开始进行模型的强化学习部分。与监督学习不同，在强化学习中我们没有标注好的数据。语言模型接受prompt作为输入，其输出作为奖励模型的输入。奖励模型评价语言模型的输出，并将评价返回给语言模型。确保两个模型都能良好运行是一个具有挑战性的任务。一种实现方式是使用近端策略优化（PPO，Proximal Policy Optimization）。其主要思想是：我们既希望语言模型的输出能够尽可能地获得奖励模型的高评价，又不希望语言模型的变化过于“激进”。通过这种方法，我们可以使得模型在学习趋近人类偏好的同时不过多地丢失其原有的解决问题的能力。

在使用 PPO 进行强化学习时，请将 stage 设置为 ppo，并且指定所使用奖励模型的路径。下面是一个示例：

...  
stage: ppo  
reward_model: saves/llama3-8b/lora/reward  
...

DPO

既然同时保证两个语言模型与奖励模型的良好运行是有挑战性的，一种想法是我们可以丢弃奖励模型，进而直接基于人类偏好训练我们的语言模型，这大大简化了训练过程。

在使用 DPO 时，请将 stage 设置为 dpo，确保使用的数据集符合偏好数据集格式并且设置偏好优化相关参数。以下是一个示例：

...  
### method  
stage: dpo  
pref_beta: 0.1  
pref_loss: sigmoid  # choices: [sigmoid (dpo), orpo, simpo]  
dataset: dpo_en_demo  
...

KTO

KTO(Kahneman-Taversky Optimization) 的出现是为了解决成对的偏好数据难以获得的问题。KTO使用了一种新的损失函数，使其只需二元的标记数据，即只需标注回答的好坏即可训练，并取得与 DPO 相似甚至更好的效果。

在使用 KTO 时，请将 stage 设置为 kto ，设置偏好优化相关参数并使用 KTO 数据集。

以下是一个示例：

model_name_or_path: meta-llama/Meta-Llama-3-8B-Instruct  
...  
stage: kto  
pref_beta: 0.1  
...  
dataset: kto_en_dem

如何学习大模型 AI ？

由于新岗位的生产效率，要优于被取代岗位的生产效率，所以实际上整个社会的生产效率是提升的。

但是具体到个人，只能说是：

“最先掌握AI的人，将会比较晚掌握AI的人有竞争优势”。

这句话，放在计算机、互联网、移动互联网的开局时期，都是一样的道理。

我在一线互联网企业工作十余年里，指导过不少同行后辈。帮助很多人得到了学习和成长。

我意识到有很多经验和知识值得分享给大家，也可以通过我们的能力和经验解答大家在人工智能学习中的很多困惑，所以在工作繁忙的情况下还是坚持各种整理和分享。但苦于知识传播途径有限，很多互联网行业朋友无法获得正确的资料得到学习提升，故此将并将重要的AI大模型资料包括AI大模型入门学习思维导图、精品AI大模型学习书籍手册、视频教程、实战学习等录播视频免费分享出来。

在这里插入图片描述