Hugging Face Transformers Trainer 深度指南：从零配置训练循环到优化器选型与分布式加速

本篇技术指南围绕 Transformers 仓库中 Trainer 文档 的核心脉络展开：如何用最少的代码跑通一个完整的训练与评估循环、如何通过继承与回调（Callbacks）定制训练行为、如何利用 NEFTune 与 Liger Kernel 等加速手段、如何从内置优化器列表中选择 GaLore / LOMO / GrokAdamW / Schedule-Free 等进阶优化器，以及如何借助 Accelerate 以 DDP、FSDP、DeepSpeed 策略启动分布式训练。读完后，你将能够直接复制文中的可运行配置与命令行，在当前仓库的示例脚本上完成单机与多机的训练实操。

前置依赖：安装 Accelerate

Trainer 由 Accelerate 驱动——这是官方用于在分布式环境中运行 PyTorch 训练的库，支持 DDP、FSDP、DeepSpeed 等集成。开始之前请先确认已安装：

pip install accelerate

# upgrade
pip install accelerate --upgrade

同时，除主类 Trainer 外，Transformers 还提供面向序列到序列任务（翻译、摘要等）的 Seq2SeqTrainer，以及来自 TRL 库、封装了 Trainer 的 SFTTrainer（支持序列打包、LoRA、量化、DeepSpeed，适合训练 Llama 系列、Mistral 等大语言模型）。三者分工是：Trainer 最通用、覆盖面最广；Seq2SeqTrainer 专为 seq2seq 任务设计；SFTTrainer 专为大语言模型微调设计。

基础用法：五步搭建训练循环

Trainer 内聚了所有你手工写训练循环时会写的代码：

1. 执行一步训练，计算损失；
2. 计算梯度（反向传播）；
3. 根据梯度更新权重；
4. 重复直到达到预定轮数（epochs）。

它把上述逻辑全部抽象掉，你只需提供训练所需的基本组件：模型、数据集、TrainingArguments 等。

TrainingArguments：集中管理超参数

所有训练选项与超参数都集中在 TrainingArguments 中。例如指定模型保存位置（output_dir）、训练完成后推送到 Hub（push_to_hub=True）：

from transformers import TrainingArguments

training_args = TrainingArguments(
    output_dir="your-model",
    learning_rate=2e-5,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=16,
    num_train_epochs=2,
    weight_decay=0.01,
    eval_strategy="epoch",
    save_strategy="epoch",
    load_best_model_at_end=True,
    push_to_hub=True,
)

实例化 Trainer 并启动训练

将 training_args 与模型、数据集、数据预处理组件（按数据类型分别是分词器、特征提取器或图像处理器）一起传入 Trainer，再加上数据拼接器（data_collator）和用于计算评估指标的 compute_metrics：

from transformers import Trainer

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=dataset["train"],
    eval_dataset=dataset["test"],
    tokenizer=tokenizer,
    data_collator=data_collator,
    compute_metrics=compute_metrics,
)

trainer.train()

从源码结构看，Trainer 的核心方法都定义在 trainer.py 中：train（trainer.py#L1350）、training_step（trainer.py#L1907）、compute_loss（trainer.py#L1980）、evaluate（trainer.py#L2569）、predict（trainer.py#L2875）、prediction_step（trainer.py#L2936），这些正是文档中列出的可覆写钩子。

检查点（Checkpoints）：保存与断点续训

Trainer 把检查点保存到 TrainingArguments 的 output_dir 中，存放在形如 checkpoint-000 的子文件夹里，末尾数字对应训练步数。保存检查点的核心价值在于可以稍后恢复训练：

# 从最新的检查点恢复
trainer.train(resume_from_checkpoint=True)

# 从输出目录中某个特定检查点恢复
trainer.train(resume_from_checkpoint="your-model/checkpoint-1000")

将检查点推送到 Hub

可以把检查点上传到 Hub（注意：优化器状态默认不保存），方式为在 TrainingArguments 中设置 push_to_hub=True。此外还可以用 hub_strategy 参数决定上传策略：

• hub_strategy="checkpoint"：把最新检查点推送到一个名为 "last-checkpoint" 的子文件夹中，你可以从该检查点恢复训练；
• hub_strategy="all_checkpoints"：把所有检查点推送到 output_dir 指定的目录（模型仓库中每个文件夹对应一个检查点）。

关于恢复训练时的随机数状态

恢复训练时，Trainer 会尝试保持 Python、NumPy、PyTorch 的 RNG 状态与保存检查点时一致。但由于 PyTorch 存在多种非确定性的默认设置，RNG 状态无法保证完全相同。若需要完全确定性，可参考 PyTorch 官方“控制随机性来源”文档了解可开启的选项——但需注意，开启确定性设置通常会降低训练速度。

定制 Trainer：覆写关键方法

Trainer 在设计上易上手，同时为进阶用户提供了大量定制点。你可以继承并覆写众多方法，而不必从头重写整个训练循环。文档中明确列出的可覆写方法包括：

• Trainer.get_train_dataloader：创建训练用 DataLoader（trainer.py#L881）
• Trainer.get_eval_dataloader：创建评估用 DataLoader（trainer.py#L901）
• Trainer.get_test_dataloader：创建测试用 DataLoader（trainer.py#L940）
• Trainer.log：记录各种监控训练的对象的信息（trainer.py#L3910）
• Trainer.create_optimizer_and_scheduler：若未在 __init__ 中传入优化器与学习率调度器则负责创建（trainer.py#L1160）；二者也可分别通过 Trainer.create_optimizer 与 Trainer.create_scheduler 独立定制
• Trainer.compute_loss：对一批训练输入计算损失函数
• Trainer.training_step：执行一步训练
• Trainer.prediction_step：执行预测/测试步骤
• Trainer.evaluate：评估模型并返回指标
• Trainer.predict：在测试集上执行预测（若标签可用则同时计算指标）

示例：覆写 compute_loss 使用加权交叉熵

例如，想用一个带类别权重的损失函数替代默认损失：

import torch
from torch import nn
from transformers import Trainer

class CustomTrainer(Trainer):
    def compute_loss(self, model, inputs, return_outputs=False):
        labels = inputs.pop("labels")
        # forward pass
        outputs = model(**inputs)
        logits = outputs.get("logits")
        # compute custom loss for 3 labels with different weights
        loss_fct = nn.CrossEntropyLoss(weight=torch.tensor([1.0, 2.0, 3.0], device=model.device))
        loss = loss_fct(logits.view(-1, self.model.config.num_labels), labels.view(-1))
        return (loss, outputs) if return_outputs else loss

回调函数（Callbacks）：观察而不改变

定制 Trainer 的另一条路径是使用回调。回调不会修改训练循环本身：它们检查训练循环的当前状态，然后根据状态执行某些动作（例如提前停止、记录结果等）。换句话说，回调不能用来实现自定义损失函数这类逻辑——那种情况必须覆写 Trainer.compute_loss。

例如，训练进行到 10 步后加入提前停止回调：

from transformers import TrainerCallback

class EarlyStoppingCallback(TrainerCallback):
    def __init__(self, num_steps=10):
        self.num_steps = num_steps

    def on_step_end(self, args, state, control, **kwargs):
        if state.global_step >= self.num_steps:
            return {"should_training_stop": True}
        else:
            return {}

然后将其传入 Trainer 的 callbacks 参数：

from transformers import Trainer

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=dataset["train"],
    eval_dataset=dataset["test"],
    tokenizer=tokenizer,
    data_collator=data_collator,
    compute_metrics=compute_metrics,
    callbacks=[EarlyStoppingCallback()],
)

从源码结构看，回调机制实现于 trainer_callback.py：回调返回的 {"should_training_stop": True} 对应 TrainerControl 的 should_training_stop 字段（trainer_callback.py#L234），训练循环每步检查该字段决定何时停止。仓库内置的 EarlyStoppingCallback（trainer_callback.py#L711）则是基于早停耐心值（patience）按评估指标触发停止的官方版本，可与其自带的基于步数的自定义版本配合理解。

日志记录（Logging）

Trainer 默认日志级别为 logging.INFO，会报告错误、警告与其他基础信息；在分布式环境中，Trainer 副本（非主进程）默认为 logging.WARNING，只报告错误与警告。可通过 TrainingArguments 的 log_level 与 log_level_replica 两个参数修改这两个级别；log_on_each_node 参数则决定日志级别是应用到每个节点还是仅主节点。

注意：`Trainer` 在 `Trainer.__init__` 中为每个节点单独设置日志级别，因此如果你在其他 Transformers 功能之后才创建 `Trainer` 对象，建议尽早设置该配置。

例如，让主代码与关键模块使用与各节点一致的日志级别：

import logging
import sys

logger = logging.getLogger(__name__)

logging.basicConfig(
    format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
    datefmt="%m/%d/%Y %H:%M:%S",
    handlers=[logging.StreamHandler(sys.stdout)],
)

log_level = training_args.get_process_log_level()
logger.setLevel(log_level)
datasets.utils.logging.set_verbosity(log_level)
transformers.utils.logging.set_verbosity(log_level)

trainer = Trainer(...)

通过命令行组合 log_level 与 log_level_replica 可以精确控制各节点记录什么：

单节点：

my_app.py ... --log_level warning --log_level_replica error

多节点：追加 log_on_each_node 0 参数，使仅主节点按其级别记录：

my_app.py ... --log_level warning --log_level_replica error --log_on_each_node 0

# 只报告错误
my_app.py ... --log_level error --log_level_replica error --log_on_each_node 0

NEFTune：向嵌入向量注入噪声

NEFTune 是一种通过训练期间向嵌入向量（embedding）添加噪声来提升模型表现的技术。在 Trainer 中启用它只需在 TrainingArguments 中设置 neftune_noise_alpha 控制噪声强度：

from transformers import TrainingArguments, Trainer

training_args = TrainingArguments(..., neftune_noise_alpha=0.1)
trainer = Trainer(..., args=training_args)

训练结束后 NEFTune 会自动关闭，以恢复原始嵌入层，避免任何意外行为。源码层面可以印证这一点：Trainer 在启动训练前通过 activate_neftune 挂接 hook（见 trainer.py#L1419-L1420），训练结束时调用 deactivate_neftune 解除（trainer.py#L1901-L1902），具体 hook 实现位于 integrations/neftune.py。

Liger Kernel：用 Triton 内核加速 LLM 训练

Liger Kernel 是 LinkedIn 开发的一组 Triton 内核，专为大语言模型（LLM）训练设计。Transformers 已与 Hugging Face 兼容地实现了其中 RMSNorm、RoPE、SwiGLU、CrossEntropy、FusedLinearCrossEntropy 等内核。官方给出的收益数据是：在多 GPU 训练上可将吞吐提高约 20%、内存占用降低约 60%（在 LLaMA 3-8B 训练上的实测结果），因此可以支撑更大的上下文长度与更大的批次；它也能与 flash attention、PyTorch FSDP、Microsoft DeepSpeed 自动配合工作。

先安装：

pip install liger-kernel

然后传入 use_liger_kernel=True 即可把 Liger 内核应用到模型上：

from transformers import TrainingArguments

training_args = TrainingArguments(
    output_dir="your-model",
    learning_rate=2e-5,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=16,
    num_train_epochs=2,
    weight_decay=0.01,
    eval_strategy="epoch",
    save_strategy="epoch",
    load_best_model_at_end=True,
    push_to_hub=True,
    use_liger_kernel=True
)

该内核支持 Llama、Gemma、Mistral、Mixtral 等模型架构，最新支持列表以 Liger-Kernel 上游仓库为准。从源码结构看，当 use_liger_kernel 为 True 时，Trainer 会通过 integrations/liger.py 中的 apply_liger_kernel（liger.py#L28）对模型实例原地打补丁——它要求安装 liger-kernel >= 0.3.0，并对 PEFT 包装的模型先 unwrap 再应用，所以除了设置参数外你无需做任何额外操作。

优化器：内置选项与进阶优化器

内置优化器列表

通过 TrainingArguments 的 optim 参数可以直接选择内置优化器：

from transformers import TrainingArguments
training_args = TrainingArguments(..., optim="adamw_torch")

完整的可选项定义在 training_args.py 的 OptimizerNames 枚举中（training_args.py#L113-L157），覆盖范围包括：adamw_torch、adamw_torch_fused、adamw_torch_xla、adafactor、sgd、adagrad、adamw_8bit（bitsandbytes 8 位）、lion_32bit、paged_adamw_32bit、paged_lion_8bit、rmsprop，以及下文详述的 galore_*、lomo、adalomo、grokadamw、schedule_free_*、apollo_adamw 等系列。

此外，也可以直接传入任意 PyTorch 优化器类及其参数：

import torch

optimizer_cls = torch.optim.AdamW
optimizer_kwargs = {
    "lr": 4e-3,
    "betas": (0.9, 0.999),
    "weight_decay": 0.05,
}

from transformers import Trainer
trainer = Trainer(..., optimizer_cls_and_kwargs=(optimizer_cls, optimizer_kwargs))

优化器的实际构造逻辑位于 trainer_optimizer.py，其中维护了一张 OptimizerNames 到工厂函数（如 _get_lomo_optimizer、_get_grokadamw、_get_schedule_free_optimizer）的映射表，并按需校验第三方包是否已安装。

GaLore：低秩梯度投影的全参训练

低秩梯度投影（GaLore）是一种内存高效的全参数训练策略：允许学习全部参数，同时比 LoRA 等常见低秩适配方法更省内存。

先安装官方实现：

pip install galore-torch

然后把 ["galore_adamw", "galore_adafactor", "galore_adamw_8bit"] 之一填入 optim，并配合 optim_target_modules 指定要适配的模块——它接受字符串列表、正则表达式或全名匹配，表示目标模块名称。完整示例如下（先 pip install trl datasets）：

import datasets
from trl import SFTConfig, SFTTrainer

train_dataset = datasets.load_dataset('imdb', split='train')
args = SFTConfig(
    output_dir="./test-galore",
    max_steps=100,
    optim="galore_adamw",
    optim_target_modules=[r".*.attn.*", r".*.mlp.*"],
    gradient_checkpointing=True,
)
trainer = SFTTrainer(
    model="google/gemma-2b",
    args=args,
    train_dataset=train_dataset,
)
trainer.train()

若要传递 GaLore 支持的额外参数，需正确传入 optim_args，例如：

args = SFTConfig(
    output_dir="./test-galore",
    max_steps=100,
    optim="galore_adamw",
    optim_target_modules=[r".*.attn.*", r".*.mlp.*"],
    optim_args="rank=64, update_proj_gap=100, scale=0.10",
    gradient_checkpointing=True,
)

当前限制与注意事项：

• 目前只有线性层（Linear）可以成为 GaLore 层，它们使用低秩分解进行训练；其余层仍按常规方式优化；
• 训练开始前需要一些初始化时间（文档给出的参考值：2B 模型在 NVIDIA A100 上约 3 分钟），之后训练会正常进行；
• 通过在优化器名中加 layerwise 后缀（如 optim="galore_adamw_layerwise"）可做逐层优化，但逐层优化仍偏实验性质、不支持 DDP，因此只能单 GPU 运行；梯度裁剪、DeepSpeed 等其他特性也可能开箱即不支持，遇到问题可到 Transformers 仓库提 Issue 反馈。

源码侧，GaLore 各变体的映射在 trainer_optimizer.py#L348-L353：GALORE_ADAMW → GaLoreAdamW、GALORE_ADAMW_8BIT → GaLoreAdamW8bit、GALORE_ADAFACTOR → GaLoreAdafactor，以及对应的 _layerwise 变体。

LOMO 优化器：合并梯度计算与参数更新

LOMO 优化器出自《Full-parameter training of large language models with limited resources》与《AdaLomo: memory-efficient optimization with adaptive learning rate》两篇论文。两者都是高效的全参微调方法，核心思想是把梯度计算与参数更新合并成一步，从而降低内存占用。Trainer 支持 lomo 与 adalomo 两个选项。安装方式：pip install lomo-optim，或从源码 pip install git+https://github.com/OpenLMLab/LOMO.git。

作者建议：使用 AdaLomo 时关闭 grad_norm 可获得更好的性能与速度。

在 IMDB 上全精度微调 google/gemma-2b 的完整示例：

import datasets
from trl import SFTConfig, SFTTrainer

train_dataset = datasets.load_dataset('imdb', split='train')
args = SFTConfig(
    output_dir="./test-lomo",
    max_steps=100,
    optim="adalomo",
    gradient_checkpointing=True,
)
trainer = SFTTrainer(
    model="google/gemma-2b",
    args=args,
    train_dataset=train_dataset,
)
trainer.train()

源码印证：trainer_optimizer.py#L400-L418 中的 _get_lomo_optimizer 会在未安装时抛出明确提示（pip install lomo-optim），安装后从 lomo_optim 导入 AdaLomo、Lomo 两个类。

GrokAdamW：面向 grokking 信号的训练稳定性

GrokAdamW 优化器专为提升训练性能与稳定性而设计，尤其适合受益于 grokking 信号的模型。先安装：pip install grokadamw。完整示例：在 IMDB 上用 GrokAdamW 全精度微调 google/gemma-2b：

import torch
import datasets
from transformers import TrainingArguments, AutoTokenizer, AutoModelForCausalLM, Trainer

# 加载 IMDB 数据集
train_dataset = datasets.load_dataset('imdb', split='train')

# 定义训练参数
args = TrainingArguments(
    output_dir="./test-grokadamw",
    max_steps=1000,
    per_device_train_batch_size=4,
    optim="grokadamw",
    logging_strategy="steps",
    logging_steps=1,
    learning_rate=2e-5,
    save_strategy="no",
    run_name="grokadamw-imdb",
)

# 加载模型与分词器
model_id = "google/gemma-2b"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id).to(0)

# 初始化 Trainer
trainer = Trainer(
    model=model,
    args=args,
    train_dataset=train_dataset,
)

# 开始训练
trainer.train()

Schedule-Free 优化器：摆脱学习率调度

Schedule-Free 优化器出自《The Road Less Scheduled》。其核心思想是：用平均与重叠（averaging and overlap）的混合来替代传统优化器的动量，从而完全省去靠传统调度器衰减学习率的必要性。Trainer 支持 schedule_free_adamw 与 schedule_free_sgd（枚举中另有 schedule_free_radam）。先安装：pip install schedulefree。

示例（IMDB 全精度微调 google/gemma-2b）：

import datasets
from trl import SFTConfig, SFTTrainer

train_dataset = datasets.load_dataset('imdb', split='train')
args = SFTConfig(
    output_dir="./test-galore",
    max_steps=100,
    optim="schedule_free_adamw",
    gradient_checkpointing=True,
)
trainer = SFTTrainer(
    model="google/gemma-2b",
    args=args,
    train_dataset=train_dataset,
)
trainer.train()

Accelerate 与 Trainer：分布式训练启动

Trainer 由 Accelerate 驱动，该库让 PyTorch 训练能便捷地运行在分布式环境中，并支持 FSDP（FullyShardedDataParallel）与 DeepSpeed 集成。若需深入了解 Trainer 下的 FSDP 分片策略、CPU offload 等，可继续阅读仓库内的 FSDP 文档（FSDP 指南，若阿拉伯语目录缺失可参考英文主目录 docs/source/en/fsdp.md）。

用 accelerate config 生成配置文件

将 Accelerate 与 Trainer 配合使用的第一步是运行 accelerate config，为训练环境做配置。该命令会生成一个 config_file.yaml，训练脚本运行时即使用它。以下分别给出 DDP、FSDP、DeepSpeed、DeepSpeed（Accelerate 插件）四种示例配置：

DDP（多机多卡）：

compute_environment: LOCAL_MACHINE
distributed_type: MULTI_GPU
downcast_bf16: 'no'
gpu_ids: all
machine_rank: 0 #change rank as per the node
main_process_ip: 192.168.20.1
main_process_port: 9898
main_training_function: main
mixed_precision: fp16
num_machines: 2
num_processes: 8
rdzv_backend: static
same_network: true
tpu_env: []
tpu_use_cluster: false
tpu_use_sudo: false
use_cpu: false

FSDP：

compute_environment: LOCAL_MACHINE
distributed_type: FSDP
downcast_bf16: 'no'
fsdp_config:
  fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP
  fsdp_backward_prefetch_policy: BACKWARD_PRE
  fsdp_forward_prefetch: true
  fsdp_offload_params: false
  fsdp_sharding_strategy: 1
  fsdp_state_dict_type: FULL_STATE_DICT
  fsdp_sync_module_states: true
  fsdp_transformer_layer_cls_to_wrap: BertLayer
  fsdp_use_orig_params: true
machine_rank: 0
main_training_function: main
mixed_precision: bf16
num_machines: 1
num_processes: 2
rdzv_backend: static
same_network: true
tpu_env: []
tpu_use_cluster: false
tpu_use_sudo: false
use_cpu: false

DeepSpeed（指定外部 ZeRO-3 配置文件）：

compute_environment: LOCAL_MACHINE
deepspeed_config:
  deepspeed_config_file: /home/user/configs/ds_zero3_config.json
  zero3_init_flag: true
distributed_type: DEEPSPEED
downcast_bf16: 'no'
machine_rank: 0
main_training_function: main
num_machines: 1
num_processes: 4
rdzv_backend: static
same_network: true
tpu_env: []
tpu_use_cluster: false
tpu_use_sudo: false
use_cpu: false

DeepSpeed（内联 Accelerate 插件参数）：

compute_environment: LOCAL_MACHINE
deepspeed_config:
  gradient_accumulation_steps: 1
  gradient_clipping: 0.7
  offload_optimizer_device: cpu
  offload_param_device: cpu
  zero3_init_flag: true
  zero_stage: 2
distributed_type: DEEPSPEED
downcast_bf16: 'no'
machine_rank: 0
main_training_function: main
mixed_precision: bf16
num_machines: 1
num_processes: 4
rdzv_backend: static
same_network: true
tpu_env: []
tpu_use_cluster: false
tpu_use_sudo: false
use_cpu: false

用 accelerate launch 启动训练

accelerate launch 是结合 Accelerate 与 Trainer 在分布式系统上运行训练脚本的推荐方式，它会加载 Accelerate 缓存目录中的 config_file.yaml（自动生成时会自动加载）。

例如，以 FSDP 配置运行仓库自带的 GLUE 文本分类脚本 run_glue.py：

accelerate launch \
    ./examples/pytorch/text-classification/run_glue.py \
    --model_name_or_path google-bert/bert-base-cased \
    --task_name $TASK_NAME \
    --do_train \
    --do_eval \
    --max_seq_length 128 \
    --per_device_train_batch_size 16 \
    --learning_rate 5e-5 \
    --num_train_epochs 3 \
    --output_dir /tmp/$TASK_NAME/ \

也可以把 config_file.yaml 中的参数直接写在命令行上：

accelerate launch --num_processes=2 \
    --use_fsdp \
    --mixed_precision=bf16 \
    --fsdp_auto_wrap_policy=TRANSFORMER_BASED_WRAP  \
    --fsdp_transformer_layer_cls_to_wrap="BertLayer" \
    --fsdp_sharding_strategy=1 \
    --fsdp_state_dict_type=FULL_STATE_DICT \
    ./examples/pytorch/text-classification/run_glue.py \
    --model_name_or_path google-bert/bert-base-cased \
    --task_name $TASK_NAME \
    --do_train \
    --do_eval \
    --max_seq_length 128 \
    --per_device_train_batch_size 16 \
    --learning_rate 5e-5 \
    --num_train_epochs 3 \
    --output_dir /tmp/$TASK_NAME/ \

同目录下还有 run_classification.py、run_glue_no_trainer.py、run_xnli.py 等可参考脚本，其中 run_glue_no_trainer.py 展示了不使用 Trainer 的手写训练循环，可与本文的基础用法对照阅读。

小结

回到 Trainer 的设计哲学：它以最小的样板代码覆盖“计算损失—反向传播—更新权重—评估”的完整闭环，同时通过可覆写方法（compute_loss、training_step 等）、回调（TrainerCallback）、TrainingArguments 中的加速与优化器选项（NEFTune、Liger Kernel、GaLore/LOMO/GrokAdamW/Schedule-Free）以及 Accelerate 驱动的 DDP/FSDP/DeepSpeed 启动方式，为不同规模与场景的训练提供逐级加深的定制空间。文中所有命令行与参数均以当前仓库 trainer.py、training_args.py、trainer_optimizer.py 的实际实现为准；涉及第三方包（accelerate、liger-kernel、galore-torch、lomo-optim、grokadamw、schedulefree）的特性以其官方仓库的最新说明为准。