LLama-Factory高级选项

发表于 分类于 ，

基本信息

GitHub：LLaMA-Factory
Gitee：LLaMA-Factory【网络原因，个人迁移备份】
转载自：LLaMA-Factory
防止丢失、学习记录备忘。

加速

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

FlashAttention

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

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

1
flash_attn: fa2

Unsloth

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

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

1
use_unsloth: True

Liger Kernel

Liger Kernel 是一个大语言模型训练的性能优化框架, 可有效地提高吞吐量并减少内存占用。

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

1
enable_liger_kernel: True

调优算法

LLaMA-Factory 支持多种调优算法，包括：

Full Parameter Fine-tuning

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

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

1
2
3
4
5
6
### 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 等。

以下是一个例子：

1
2
3
4
5
6
7
8
...
### method
stage: sft
do_train: true
finetuning_type: freeze
freeze_trainable_layers: 8
freeze_trainable_modules: all
...
参数名称 类型 介绍
freeze_trainable_layers int 可训练层的数量。正数表示最后 n 层被设置为可训练的，负数表示前 n 层被设置为可训练的。默认值为 2
freeze_trainable_modules str 可训练层的名称。使用 all 来指定所有模块。默认值为 all
freeze_extra_modules[非必须] str 除了隐藏层外可以被训练的模块名称，被指定的模块将会被设置为可训练的。使用逗号分隔多个模块。默认值为 None

LoRA

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

1
2
3
4
5
6
7
8
9
10
...
### method
stage: sft
do_train: true
finetuning_type: lora
lora_target: all
lora_rank: 8
lora_alpha: 16
lora_dropout: 0.1
...
参数名称 类型 介绍
additional_target[非必须] [str,] 除 LoRA 层之外设置为可训练并保存在最终检查点中的模块名称。使用逗号分隔多个模块。默认值为 None
lora_alpha[非必须] int LoRA 缩放系数。一般情况下为 lora_rank * 2, 默认值为 None
lora_dropout float LoRA 微调中的 dropout 率。默认值为 0
lora_rank int LoRA 微调的本征维数 r， r 越大可训练的参数越多。默认值为 8
lora_target str 应用 LoRA 方法的模块名称。使用逗号分隔多个模块，使用 all 指定所有模块。默认值为 all
loraplus_lr_ratio[非必须] float LoRA+ 学习率比例(λ=ηB/ηA)。 ηA,ηB 分别是 adapter matrices A 与 B 的学习率。LoRA+ 的理想取值与所选择的模型和任务有关。默认值为 None
loraplus_lr_embedding[非必须] float LoRA+ 嵌入层的学习率, 默认值为 1e-6
use_rslora bool 是否使用秩稳定 LoRA(Rank-Stabilized LoRA)，默认值为 False。
use_dora bool 是否使用权重分解 LoRA（Weight-Decomposed LoRA），默认值为 False
pissa_init bool 是否初始化 PiSSA 适配器，默认值为 False
pissa_iter int PiSSA 中 FSVD 执行的迭代步数。使用 -1 将其禁用，默认值为 16
pissa_convert bool 是否将 PiSSA 适配器转换为正常的 LoRA 适配器，默认值为 False
create_new_adapter bool 是否创建一个具有随机初始化权重的新适配器，默认值为 False

LoRA+

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

rsLoRA

LoRA 通过添加低秩适配器进行微调，然而 lora_rank 的增大往往会导致梯度塌陷，使得训练变得不稳定。这使得在使用较大的 lora_rank 进行 LoRA 微调时较难取得令人满意的效果。rsLoRA(Rank-Stabilized LoRA) 通过修改缩放因子使得模型训练更加稳定。 使用 rsLoRA 时， 您只需要将 use_rslora 设置为 True 并设置所需的 lora_rank。

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 中的参数进行配置。

下面是一个例子：

1
2
3
4
5
6
7
8
9
10
11
...
### 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 参数。
参数名称 类型 介绍
use_galore bool 是否使用 GaLore 算法，默认值为 False。
galore_target str 应用 GaLore 的模块名称。使用逗号分隔多个模块，使用 all 指定所有线性模块。默认值为 all。
galore_rank int GaLore 梯度的秩，默认值为 16。
galore_update_interval int 更新 GaLore 投影的步数间隔，默认值为 200。
galore_scale float GaLore 的缩放系数，默认值为 0.25。
galore_proj_type Literal GaLore 投影的类型，可选值有： std , reverse_std, right, left, full。默认值为 std。
galore_layerwise bool 是否启用逐层更新以进一步节省内存，默认值为 False。

BAdam

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

1
2
3
4
5
6
7
8
9
10
11
12
13
### 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 时仅支持 单卡 训练。
参数名称 类型 介绍
use_badam bool 是否使用 BAdam 优化器，默认值为 False。
badam_mode Literal BAdam 的使用模式，可选值为 layer 或 ratio，默认值为 layer。
badam_start_block Optional[int] layer-wise BAdam 的起始块索引，默认值为 None。
badam_switch_mode Optional[Literal] layer-wise BAdam 中块更新策略，可选值有： ascending, descending, random, fixed。默认值为 ascending。
badam_switch_interval Optional[int] layer-wise BAdam 中块更新步数间隔。使用 -1 禁用块更新，默认值为 50。
badam_update_ratio float ratio-wise BAdam 中的更新比例，默认值为 0.05。
badam_mask_mode Literal BAdam 优化器的掩码模式，可选值为 adjacent 或 scatter，默认值为 adjacent。
badam_verbose int BAdam 优化器的详细输出级别，0 表示无输出，1 表示输出块前缀，2 表示输出可训练参数。默认值为 0。

分布训练

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，从而进一步降低显存需求。

引擎 数据切分 模型切分 优化器切分 参数卸载
DDP 支持 不支持 不支持 不支持
DeepSpeed 支持 支持 支持 支持
FSDP 支持 支持 支持 支持

NativeDDP

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

单机多卡

llamafactory-cli

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

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

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

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

torchrun

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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 指令启动进行单机多卡训练。

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 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

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

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

多机多卡

llamafactory-cli

1
2
3
4
5
FORCE_TORCHRUN=1 NNODES=2 NODE_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 NODE_RANK=1 MASTER_ADDR=192.168.0.1 MASTER_PORT=29500 \
llamafactory-cli train examples/train_lora/llama3_lora_sft.yaml
变量名 介绍
FORCE_TORCHRUN 是否强制使用torchrun
NNODES 节点数量
NODE_RANK 各个节点的rank。
MASTER_ADDR 主节点的地址。
MASTER_PORT 主节点的端口。

torchrun

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

1
2
3
4
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 指令启动进行多机多卡训练。

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

1
accelerate config

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 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

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

1
2
3
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 配置文件的示例。包括：

备注

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

单机多卡

llamafactory-cli

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

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

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

1
2
3
...
deepspeed: examples/deepspeed/ds_z3_config.json
...

deepspeed

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

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

下面是一个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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。而需要：

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

--includelocalhost:1 表示只是用本节点的gpu1。

多机多卡

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

1
2
FORCE_TORCHRUN=1 NNODES=2 NODE_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 NODE_RANK=1 MASTER_ADDR=192.168.0.1 MASTER_PORT=29500 llamafactory-cli train examples/train_lora/llama3_lora_sft_ds3.yaml

deepspeed

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

1
2
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

备注

  • 关于hostfile:

hostfile的每一行指定一个节点，每行的格式为 <hostname>slots=<num_slots> ， 其中 <hostname> 是节点的主机名， <num_slots> 是该节点上的GPU数量。下面是一个例子： .. code-block:

1
2
worker-1 slots=4
worker-2 slots=4

请在 https://www.deepspeed.ai/getting-started/ 了解更多。

  • 如果没有指定 hostfile 变量, DeepSpeed 会搜索 /job/hostfile 文件。如果仍未找到，那么 DeepSpeed 会使用本机上所有可用的GPU。

accelerate

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

1
accelerate config

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# 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

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

1
2
3
accelerate launch \
--config_file deepspeed_config.yaml \
train.py llm_config.yaml

DeepSpeed 配置文件

ZeRO-0

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
### 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 参数即可。

1
2
3
4
5
6
7
8
### ds_z2_config.json
{
    ...
    "zero_optimization": {
        "stage": 2,
    ...
    }
}

ZeRO-2+offload

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

1
2
3
4
5
6
7
8
9
10
11
12
### ds_z2_offload_config.json
{
    ...
    "zero_optimization": {
        "stage": 2,
        "offload_optimizer": {
        "device": "cpu",
        "pin_memory": true
        },
    ...
    }
}

ZeRO-3

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
### 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 参数即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
### 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。

llamafactory-cli

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

1
bash examples/extras/fsdp qlora/train.sh

accelerate

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

1
accelerate config

根据提示回答一系列问题后，我们就可以生成 FSDP 所需的配置文件。

当然您也可以根据需求自行配置 fsdp_config.yaml 。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
### /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数量一致

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

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

警告

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

量化

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

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

浮点数一般由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量化方法的配置示例：

1
2
3
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方法。具有较快的速度和简单易用的特性。

训练方法

Pre-training

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
### 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 。 下面提供监督微调的配置示例：

1
2
3
4
...
stage: sft
fintuning_type: lora
...

RLHF

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

Reward model

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

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

1
2
3
4
5
6
...
stage: rm
dataset: dpo_en_demo
...
output_dir: saves/llama3-8b/lora/reward
...

PPO

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

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

1
2
3
4
...
stage: ppo
reward_model: saves/llama3-8b/lora/reward
...

DPO

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

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

1
2
3
4
5
6
7
...
### 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 数据集。

以下是一个示例：

1
2
3
4
5
6
model_name_or_path: meta-llama/Meta-Llama-3-8B-Instruct
...
stage: kto
pref_beta: 0.1
...
dataset: kto_en_demo

实验监控

LLaMA-Factory 支持多种训练可视化工具，包括：

LlamaBoard

LlamaBoard 是指 WebUI 中自带的Loss曲线看板，可以方便的查看训练过程中的Loss变化情况。

如果你想使用 LlamaBoard，只需使用 WebUI 启动训练即可。

SwanLab

SwanLab 是一个开源的训练跟踪与可视化工具，云端和离线均可使用，支持超参数记录、指标记录、多实验对比、硬件监控、实验环境记录等功能，可以有效地帮助开发者管理实验。

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

1
2
3
use_swanlab: true
swanlab_project: llamafactory
swanlab_run_name: test_run

或者，在WebUI的 SwanLab 模块中开启 SwanLab 记录：

可视化样例：

TensorBoard

TensorBoard 是 TensorFlow 开源的离线训练跟踪工具，可以用于记录与可视化训练过程。

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

1
report_to: tensorboard

或者，在WebUI的 其他参数设置 模块中的 启用外部记录面板 中开启 TensorBoard 记录：

Wandb

Wandb（Weights and Biases）是一个云端的训练跟踪工具，可以用于记录与可视化训练过程。

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

1
2
report_to: wandb
run_name: test_run

或者，在WebUI的 其他参数设置 模块中的 启用外部记录面板 中开启 Wandb 记录：

MLflow

MLflow 是Databricks开源的离线训练跟踪工具，用于记录与可视化训练过程。

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

1
report_to: mlflow

或者，在WebUI的 其他参数设置 模块中的 启用外部记录面板 中开启 MLflow 记录：

参数介绍

微调参数

基本参数

参数名称 类型 介绍 默认值
pure_bf16 bool 是否以纯 bf16 精度训练模型（不使用 AMP）。 False
stage Literal[“pt”, “sft”, “rm”, “ppo”, “dpo”, “kto”] 训练阶段 sft
finetuning_type Literal[“lora”, “freeze”, “full”] 微调方法 lora
use_llama_pro bool 是否仅训练扩展块中的参数（LLaMA Pro 模式）。 False
use_adam_mini bool 是否使用 Adam-mini 优化器。 False
freeze_vision_tower bool MLLM 训练时是否冻结视觉塔。 True
freeze_multi_modal_projector bool MLLM 训练时是否冻结多模态投影器。 True
train_mm_proj_only bool 是否仅训练多模态投影器。 False
compute_accuracy bool 是否在评估时计算 token 级别的准确率。 False
disable_shuffling bool 是否禁用训练集的随机打乱。 False
plot_loss bool 是否保存训练过程中的损失曲线。 False
include_effective_tokens_per_second bool 是否计算有效的每秒 token 数。 False

LoRA

参数名称 类型 介绍 默认值
additional_target Optional[str] 除 LoRA 层之外设置为可训练并保存在最终检查点中的模块名称。使用逗号分隔多个模块。 None
lora_alpha Optional[int] LoRA 缩放系数。一般情况下为 lora_rank * 2。 None
lora_dropout float LoRA 微调中的 dropout 率。 0
lora_rank int LoRA 微调的本征维数 r，r 越大可训练的参数越多。 8
lora_target str 应用 LoRA 方法的模块名称。使用逗号分隔多个模块，使用 all 指定所有模块。 all
loraplus_lr_ratio Optional[float] LoRA+ 学习率比例(λ=ηB/ηA)。 ηA,ηB 分别是 adapter matrices A 与 B 的学习率。 None
loraplus_lr_embedding Optional[float] LoRA+ 嵌入层的学习率。 1e-6
use_rslora bool 是否使用秩稳定 LoRA (Rank-Stabilized LoRA)。 False
use_dora bool 是否使用权重分解 LoRA（Weight-Decomposed LoRA）。 False
pissa_init bool 是否初始化 PiSSA 适配器。 False
pissa_iter Optional[int] PiSSA 中 FSVD 执行的迭代步数。使用 -1 将其禁用。 16
pissa_convert bool 是否将 PiSSA 适配器转换为正常的 LoRA 适配器。 False
create_new_adapter bool 是否创建一个具有随机初始化权重的新适配器。 False

RLHF

参数名称 类型 介绍 默认值
pref_beta float 偏好损失中的 beta 参数。 0.1
pref_ftx float DPO 训练中的 sft loss 系数。 0.0
pref_loss Literal[“sigmoid”, “hinge”, “ipo”, “kto_pair”, “orpo”, “simpo”] DPO 训练中使用的偏好损失类型。可选值为： sigmoid, hinge, ipo, kto_pair, orpo, simpo。 sigmoid
dpo_label_smoothing float 标签平滑系数，取值范围为 [0,0.5]。 0.0
kto_chosen_weight float KTO 训练中 chosen 标签 loss 的权重。 1.0
kto_rejected_weight float KTO 训练中 rejected 标签 loss 的权重。 1.0
simpo_gamma float SimPO 损失中的 reward margin。 0.5
ppo_buffer_size int PPO 训练中的 mini-batch 大小。 1
ppo_epochs int PPO 训练迭代次数。 4
ppo_score_norm bool 是否在 PPO 训练中使用归一化分数。 False
ppo_target float PPO 训练中自适应 KL 控制的目标 KL 值。 6.0
ppo_whiten_rewards bool PPO 训练中是否对奖励进行归一化。 False
ref_model Optional[str] PPO 或 DPO 训练中使用的参考模型路径。 None
ref_model_adapters Optional[str] 参考模型的适配器路径。 None
ref_model_quantization_bit Optional[int] 参考模型的量化位数，支持 4 位或 8 位量化。 None
reward_model Optional[str] PPO 训练中使用的奖励模型路径。 None
reward_model_adapters Optional[str] 奖励模型的适配器路径。 None
reward_model_quantization_bit Optional[int] 奖励模型的量化位数。 None
reward_model_type Literal[“lora”, “full”, “api”] PPO 训练中使用的奖励模型类型。可选值为： lora, full, api。 lora

Freeze

参数名称 类型 介绍 默认值
freeze_trainable_layers int 可训练层的数量。正数表示最后 n 层被设置为可训练的，负数表示前 n 层被设置为可训练的。 2
freeze_trainable_modules str 可训练层的名称。使用 all 来指定所有模块。 all
freeze_extra_modules Optional[str] 除了隐藏层外可以被训练的模块名称，被指定的模块将会被设置为可训练的。使用逗号分隔多个模块。 None

Apollo

参数名称 类型 介绍 默认值
use_apollo bool 是否使用 APOLLO 优化器。 False
apollo_target str 适用 APOLLO 的模块名称。使用逗号分隔多个模块，使用 all 指定所有线性模块。 all
apollo_rank int APOLLO 梯度的秩。 16
apollo_update_interval int 更新 APOLLO 投影的步数间隔。 200
apollo_scale float APOLLO 缩放系数。 32.0
apollo_proj Literal[“svd”, “random”] APOLLO 低秩投影算法类型（svd 或 random）。 random
apollo_proj_type Literal[“std”, “right”, “left”] APOLLO 投影类型。 std
apollo_scale_type Literal[“channel”, “tensor”] APOLLO 缩放类型（channel 或 tensor）。 channel
apollo_layerwise bool 是否启用层级更新以进一步节省内存。 False
apollo_scale_front bool 是否在梯度缩放前使用范数增长限制器。 False

BAdam

参数名称 类型 介绍 默认值
use_badam bool 是否使用 BAdam 优化器。 False
badam_mode Literal BAdam 的使用模式，可选值为 layer 或 ratio。 layer
badam_start_block Optional[int] layer-wise BAdam 的起始块索引。 None
badam_switch_mode Optional[Literal] layer-wise BAdam 中块更新策略，可选值有： ascending, descending, random, fixed。 ascending
badam_switch_interval Optional[int] layer-wise BAdam 中块更新步数间隔。使用 -1 禁用块更新。 50
badam_update_ratio float ratio-wise BAdam 中的更新比例。 0.05
badam_mask_mode Literal BAdam 优化器的掩码模式，可选值为 adjacent 或 scatter。 adjacent
badam_verbose int BAdam 优化器的详细输出级别，0 表示无输出，1 表示输出块前缀，2 表示输出可训练参数。 0

GaLore

参数名称 类型 介绍 默认值
use_galore bool 是否使用 GaLore 算法。 False
galore_target str 应用 GaLore 的模块名称。使用逗号分隔多个模块，使用 all 指定所有线性模块。 all
galore_rank int GaLore 梯度的秩。 16
galore_update_interval int 更新 GaLore 投影的步数间隔。 200
galore_scale float GaLore 的缩放系数。 0.25
galore_proj_type Literal GaLore 投影的类型，可选值有： std, reverse_std, right, left, full。 std
galore_layerwise bool 是否启用逐层更新以进一步节省内存。 False

数据参数

参数名称 类型 介绍 默认值
template Optional[str] 训练和推理时构造 prompt 的模板。 None
dataset Optional[str] 用于训练的数据集名称。使用逗号分隔多个数据集。 None
eval_dataset Optional[str] 用于评估的数据集名称。使用逗号分隔多个数据集。 None
dataset_dir str 存储数据集的文件夹路径。 “data”
media_dir Optional[str] 存储图像、视频或音频的文件夹路径。如果未指定，默认为 dataset_dir。 None
cutoff_len int 输入的最大 token 数，超过该长度会被截断。 2048
train_on_prompt bool 是否在输入 prompt 上进行训练。 False
mask_history bool 是否仅使用当前对话轮次进行训练。 False
streaming bool 是否启用数据流模式。 False
buffer_size int 启用 streaming 时用于随机选择样本的 buffer 大小。 16384
mix_strategy Literal[“concat”, “interleave_under”, “interleave_over”] 数据集混合策略，支持 concat、 interleave_under、 interleave_over。 concat
interleave_probs Optional[str] 使用 interleave 策略时，指定从多个数据集中采样的概率。多个数据集的概率用逗号分隔。 None
overwrite_cache bool 是否覆盖缓存的训练和评估数据集。 False
preprocessing_batch_size int 预处理时每批次的示例数量。 1000
preprocessing_num_workers Optional[int] 预处理时使用的进程数量。 None
max_samples Optional[int] 每个数据集的最大样本数：设置后，每个数据集的样本数将被截断至指定的 max_samples。 None
eval_num_beams Optional[int] 模型评估时的 num_beams 参数。 None
ignore_pad_token_for_loss bool 计算 loss 时是否忽略 pad token。 True
val_size float 验证集相对所使用的训练数据集的大小。取值在 [0,1) 之间。启用 streaming 时 val_size 应是整数。 0.0
packing Optional[bool] 是否启用 sequences packing。预训练时默认启用。 None
neat_packing bool 是否启用不使用 cross-attention 的 sequences packing。 False
tool_format Optional[str] 用于构造函数调用示例的格式。 None
tokenized_path Optional[str] Tokenized datasets的保存或加载路径。如果路径存在，会加载已有的 tokenized datasets；如果路径不存在，则会在分词后将 tokenized datasets 保存在此路径中。 None

模型参数

基本参数

参数名称 类型 介绍 默认值
model_name_or_path Optional[str] 模型路径（本地路径或 Huggingface/ModelScope 路径）。 None
adapter_name_or_path Optional[str] 适配器路径（本地路径或 Huggingface/ModelScope 路径）。使用逗号分隔多个适配器路径。 None
adapter_folder Optional[str] 包含适配器权重的文件夹路径。 None
cache_dir Optional[str] 保存从 Hugging Face 或 ModelScope 下载的模型的本地路径。 None
use_fast_tokenizer bool 是否使用 fast_tokenizer 。 True
resize_vocab bool 是否调整词表和嵌入层的大小。 False
split_special_tokens bool 是否在分词时将 special token 分割。 False
new_special_tokens Optional[str] 要添加到 tokenizer 中的 special token。多个 special token 用逗号分隔。 None
model_revision str 所使用的特定模型版本。 main
low_cpu_mem_usage bool 是否使用节省内存的模型加载方式。 True
rope_scaling Optional[Literal[“linear”, “dynamic”, “yarn”, “llama3”]] RoPE Embedding 的缩放策略，支持 linear、dynamic、yarn 或 llama3。 None
flash_attn Literal[“auto”, “disabled”, “sdpa”, “fa2”] 是否启用 FlashAttention 来加速训练和推理。可选值为 auto, disabled, sdpa, fa2。 auto
shift_attn bool 是否启用 Shift Short Attention (S^2-Attn)。 False
mixture_of_depths Optional[Literal[“convert”, “load”]] 需要将模型转换为 mixture_of_depths（MoD）模型时指定： convert 需要加载 mixture_of_depths（MoD）模型时指定： load。 None
use_unsloth bool 是否使用 unsloth 优化 LoRA 微调。 False
use_unsloth_gc bool 是否使用 unsloth 的梯度检查点。 False
enable_liger_kernel bool 是否启用 liger 内核以加速训练。 False
moe_aux_loss_coef Optional[float] MoE 架构中 aux_loss 系数。数值越大，各个专家负载越均衡。 None
disable_gradient_checkpointing bool 是否禁用梯度检查点。 False
use_reentrant_gc bool 是否启用可重入梯度检查点 True
upcast_layernorm bool 是否将 layernorm 层权重精度提高至 fp32。 False
upcast_lmhead_output bool 是否将 lm_head 输出精度提高至 fp32。 False
train_from_scratch bool 是否随机初始化模型权重。 False
infer_backend Literal[“huggingface”, “vllm”] 推理时使用的后端引擎，支持 huggingface 或 vllm。 huggingface
offload_folder str 卸载模型权重的路径。 offload
use_cache bool 是否在生成时使用 KV 缓存。 True
infer_dtype Literal[“auto”, “float16”, “bfloat16”, “float32”] 推理时使用的模型权重和激活值的数据类型。支持 auto, float16, bfloat16, float32。 auto
hf_hub_token Optional[str] 用于登录 HuggingFace 的验证 token。 None
ms_hub_token Optional[str] 用于登录 ModelScope Hub 的验证 token。 None
om_hub_token Optional[str] 用于登录 Modelers Hub 的验证 token。 None
print_param_status bool 是否打印模型参数的状态。 False
trust_remote_code bool 是否信任来自 Hub 上数据集/模型的代码执行。 False
compute_dtype Optional[torch.dtype] 用于计算模型输出的数据类型，无需手动指定。 None
device_map Optional[Union[str, Dict[str, Any]]] 模型分配的设备映射，无需手动指定。 None
model_max_length Optional[int] 模型的最大输入长度，无需手动指定。 None
block_diag_attn bool 是否使用块对角注意力，无需手动指定。 False

多模态模型

参数名称 类型 介绍 默认值
image_max_pixels int 图像输入的最大像素数。 768 x 768
image_min_pixels int 图像输入的最小像素数。 32 x 32
video_max_pixels int 视频输入的最大像素数。 256 x 256
video_min_pixels int 视频输入的最小像素数。 16 x 16
video_fps float 视频输入的采样帧率（每秒采样帧数）。 2.0
video_maxlen int 视频输入的最大采样帧数。 128

vllm 推理

参数名称 类型 介绍 默认值
vllm_maxlen int 最大序列长度（包括输入文本和生成文本）。 4096
vllm_gpu_util float GPU使用比例，范围在(0, 1)之间。 0.9
vllm_enforce_eager bool 是否禁用 vLLM 中的 CUDA graph。 False
vllm_max_lora_rank int 推理所允许的最大的 LoRA Rank。 32
vllm_config Optional[Union[dict, str]] vLLM引擎初始化配置。以字典或JSON字符串输入。 None

模型量化

参数名称 类型 介绍 默认值
quantization_method Literal[“bitsandbytes”, “hqq”, “eetq”] 指定用于量化的算法，支持 “bitsandbytes”, “hqq” 和 “eetq”。 bitsandbytes
quantization_bit Optional[int] 指定在量化过程中使用的位数，通常是4位、8位等。 None
quantization_type Literal[“fp4”, “nf4”] 量化时使用的数据类型，支持 “fp4” 和 “nf4”。 nf4
double_quantization bool 是否在量化过程中使用 double quantization，通常用于 “bitsandbytes” int4 量化训练。 True
quantization_device_map Optional[Literal[“auto”]] 用于推理 4-bit 量化模型的设备映射。需要 “bitsandbytes >= 0.43.0”。 None

模型导出

参数名称 类型 介绍 默认值
export_dir Optional[str] 导出模型保存目录的路径。 None
export_size int 导出模型的文件分片大小（以GB为单位）。 5
export_device Literal[“cpu”, “auto”] 导出模型时使用的设备，auto 可自动加速导出。 cpu
export_quantization_bit Optional[int] 量化导出模型时使用的位数。 None
export_quantization_dataset Optional[str] 用于量化导出模型的数据集路径或数据集名称。 None
export_quantization_nsamples int 量化时使用的样本数量。 128
export_quantization_maxlen int 用于量化的模型输入的最大长度。 1024
export_legacy_format bool True： .bin 格式保存。 False： .safetensors 格式保存。 False
export_hub_model_id Optional[str] 模型上传至 Huggingface 的仓库名称。 None

评估参数

参数名称 类型 介绍 默认值
task str 评估任务的名称，可选项有 mmlu_test, ceval_validation, cmmlu_test None
task_dir str 包含评估数据集的文件夹路径。 evaluation
batch_size int 每个GPU使用的批量大小。 4
seed int 用于数据加载器的随机种子。 42
lang str 评估使用的语言，可选值为 en、zh。 en
n_shot int few-shot 的示例数量。 5
save_dir str 保存评估结果的路径。 如果该路径已经存在则会抛出错误。 None
download_mode str 评估数据集的下载模式，如果数据集已经存在则重复使用，否则则下载。 DownloadMode.REUSE_DATASET_IF_EXISTS

生成参数

参数名称 类型 介绍 默认值
do_sample bool 是否使用采样策略生成文本。如果设置为 False，将使用 greedy decoding。 True
temperature float 用于调整生成文本的随机性。temperature 越高，生成的文本越随机；temperature 越低，生成的文本越确定。 0.95
top_p float 用于控制生成时候选 token 集合大小的参数。例如：top_p = 0.7 意味着模型会先选择概率最高的若干个 token 直到其累积概率之和大于 0.7，然后在这些 token 组成的集合中进行采样。 0.7
top_k int 用于控制生成时候选 token 集合大小的参数。例如：top_k = 50 意味着模型会在概率最高的50个 token 组成的集合中进行采样。 50
num_beams int 用于 beam_search 的束宽度。值为 1 表示不使用 beam_search。 1
max_length int 文本最大长度（包括输入文本和生成文本的长度）。 1024
max_new_tokens int 生成文本的最大长度。设置 max_new_tokens 会覆盖 max_length。 1024
repetition_penalty float 对生成重复 token 的惩罚系数。对于已经生成过的 token 生成概率乘以 1/repetition_penalty。值小于 1.0 会提高重复 token 的生成概率，大于 1.0 则会降低重复 token 的生成概率。 1.0
length_penalty float 在使用 beam_search 时对生成文本长度的惩罚系数。length_penalty > 0 鼓励模型生成更长的序列，length_penalty < 0 会鼓励模型生成更短的序列。 1.0
default_system str 默认的 system_message，例如: “You are a helpful assistant.” None
skip_special_tokens bool 解码时是否忽略特殊 token。 True

SwanLab 参数

参数名称 类型 介绍 默认值
use_swanlab bool 是否使用 SwanLab。 False
swanlab_project str SwanLab 中的项目名称。 “llamafactory”
swanlab_workspace str SwanLab 中的工作区名称。 None
swanlab_run_name str SwanLab 中的实验名称。 None
swanlab_mode Literal[“cloud”, “local”] SwanLab 的运行模式。 cloud
swanlab_api_key str SwanLab 的 API 密钥。 None

训练参数

RAY

参数名称 类型 介绍 默认值
ray_run_name Optional[str] 训练结果将保存在 /ray_run_name 路径下。 None
ray_storage_path str 保存训练结果的存储路径。 ./saves
ray_num_workers int Ray 训练所使用的工作进程数量。 1
resources_per_worker Union[dict, str] 每个工作进程分配的资源。默认使用 1 GPU。 {“GPU”: 1}
placement_strategy Literal[“SPREAD”, “PACK”, “STRICT_SPREAD”, “STRICT_PACK”] Ray 训练的资源调度策略。可选值包括 SPREAD、PACK、STRICT_SPREAD 和 STRICT_PACK。 PACK

额外选项

LLaMA Pro

为了解决大语言模型的遗忘问题， LLaMA Pro 通过在原有模型上增加新模块以适应新的任务，使其在多个新任务上的表现均优于原始模型。 LLaMA-Factory 支持 LLaMA Pro 的使用。 您可以使用运行 expand.sh 将 Meta-Llama-3-8B-Instruct 扩展为 llama3-8b-instruct-pro。

对于 LLaMA Pro 模型进行训练时，您需要指定 use_llama_pro 为 true。