@baimingtao/lbs-agent 1.0.0

package/extensions/skills/optional/mlops/training/axolotl/references/other.md

@@ -0,0 +1,2367 @@
+# Axolotl - 其他
+
+**页数：** 26
+
+---
+
+## 混合精度训练
+
+**URL:** https://docs.axolotl.ai/docs/mixed_precision.html
+
+**目录：**
+- 混合精度训练
+- 1 FP16 混合精度
+  - 1.1 概览
+  - 1.2 配置
+  - 1.3 FP16 注意事项
+- 2 BF16 混合精度
+  - 2.1 概览
+  - 2.2 配置
+- 3 FP8 混合精度
+  - 3.1 什么是 FP8？
+
+混合精度训练使用较低精度的数据类型来减少内存使用并提高训练速度，同时保持模型质量。Axolotl 支持多种混合精度格式：
+
+FP16 是传统的半精度格式，在较旧的 GPU 上受支持，但其数值稳定性不如 BF16。
+
+BF16（Brain Float 16）比 FP16 提供更好的数值稳定性，是现代 GPU 推荐的混合精度格式。它在使用一半内存的同时，提供了与 FP32 相同的动态范围。
+
+FP8 支持处于实验阶段，需要兼容的硬件（H100、H200）以及最新结合了 TorchAO 的 PyTorch 版本。
+
+FP8（8 位浮点数）与 FP16/BF16 相比，可以显著节省时间，同时保持训练稳定性。Axolotl 的实现使用了 PyTorch 的 TorchAO 库以及“张量级”缩放策略。
+
+添加到你的 YAML 配置中：
+
+torch.compile 对 FP8 的性能至关重要
+
+FP8 训练需要设置 torch_compile: true 才能看到明显的加速效果。如果不进行编译，FP8 实际上可能比 FP16/BF16 更慢，并且使用更多的内存。
+
+对于 FSDP（完全分片数据并行）训练：
+
+务必验证你的混合精度设置：
+
+有关优化的示例配置，请参见 examples/llama-3/3b-fp8-fsdp2.yaml。对于相对较小（3B 参数）的模型，启用 FP8 混合精度 + FP8 all-gather 训练可比 BF16 每秒迭代速度快约 10%。
+
+有关多 GPU 训练的更多信息，请参阅我们的多 GPU 指南。
+
+**示例:**
+
+示例 1 (yaml):
+```yaml
+# 自动 BF16 检测（推荐）
+bf16: auto
+
+# 或者显式启用
+bf16: true
+
+# 用于 BF16 评估
+bf16: full  # 相当于 HF trainer 中的 bf16_full_eval
+```
+
+示例 2 (yaml):
+```yaml
+# 启用 FP8 混合精度
+fp8: true
+
+# 可选：为 FSDP all-gather 操作启用 FP8
+fp8_enable_fsdp_float8_all_gather: true
+
+# 启用 torch.compile（对于 FP8 加速几乎总是必要的）
+torch_compile: true
+```
+
+示例 3 (yaml):
+```yaml
+fp8: true
+fp8_enable_fsdp_float8_all_gather: true
+
+torch_compile: true
+
+# FSDP 配置
+fsdp_version: 2
+fsdp_config:
+  offload_params: false
+  cpu_ram_efficient_loading: true
+  auto_wrap_policy: TRANSFORMER_BASED_WRAP
+  transformer_layer_cls_to_wrap: LlamaDecoderLayer
+  state_dict_type: FULL_STATE_DICT
+  reshard_after_forward: true
+```
+
+---
+
+## 常见问题解答
+
+**URL:** https://docs.axolotl.ai/docs/faq.html
+
+**目录：**
+- 常见问题解答
+  - 常规
+  - 聊天模板
+
+问：训练器停止了，并且几分钟没有进展。
+
+答：通常是 GPU 之间相互通信的问题。请参阅 NCCL 文档。
+
+答：这通常发生在系统内存（RAM）耗尽的时候。
+
+问：使用 deepspeed 时出现 exitcode: -7
+
+答：尝试通过 pip install -U deepspeed 升级 deepspeed。
+
+问：AttributeError: ‘DummyOptim’ object has no attribute ‘step’
+
+问：在单 GPU 中使用 deepspeed 时出现 ModuleNotFoundError: No module named ‘mpi4py’
+
+答：你可能正在单 GPU 中使用 deepspeed。请移除 yaml 文件中的 deepspeed: 部分或 --deepspeed CLI 标志。
+
+问：代码卡在保存预处理数据集上。
+
+答：这通常是 GPU 的问题。可以通过设置操作系统环境变量 CUDA_VISIBLE_DEVICES=0 来解决。如果你在 runpod 上，这通常是一个 pod 的问题。启动一个新 pod 就可以解决。
+
+问：在合并适配器/加载适配器时，接收到关于 checkpoint 和模型的 torch.Size 不匹配的错误。
+
+答：这可能是由于词表大小不匹配。默认情况下，如果分词器的词元数多于模型，Axolotl 会扩展模型的嵌入层。请使用 axolotl merge-lora 命令来合并适配器，而不是使用你自己的脚本。
+
+另一方面，如果模型的词元数多于分词器，除非在配置中设置 shrink_embeddings: true，否则 Axolotl 不会收缩模型的嵌入层。
+
+问：如何通过自定义 Python 脚本调用 Axolotl？
+
+答：由于 Axolotl 就是 Python 程序，请查看 src/axolotl/cli/main.py 以了解每个命令是如何被调用的。
+
+问：如何知道 fsdp_transformer_layer_cls_to_wrap 该使用什么值？
+
+答：这是要用 FSDP 包装的 Transformer 层的类名。例如，对于 LlamaForCausalLM，该值为 LlamaDecoderLayer。要查找特定模型的对应值，请检查该模型的 PreTrainedModel 定义，并在 transformers 库的 modeling_<model_name>.py 文件中查找 _no_split_modules 变量。
+
+问：ValueError: Asking to pad but the tokenizer does not have a padding token. Please select a token to use as pad_token
+
+答：这是因为分词器没有填充词元。请通过以下方式向分词器添加填充词元：
+
+问：使用 preprocess CLI 时出现 IterableDataset 错误或 KeyError: 'input_ids'
+
+答：这可能是你分别将 preprocess CLI 用于 pretraining_dataset: 或 skip_prepare_dataset: true 导致的。请直接使用 axolotl train CLI，因为这些数据集是按需准备好的。
+
+问：vLLM 在 Axolotl 中无法正常工作
+
+答：我们目前推荐使用 torch 2.6.0 配合 vllm。请确保你使用了正确的版本。对于 Docker，请使用 main-py3.11-cu124-2.6.0 标签。
+
+问：在 CUDA 12.4 上出现 FA2 2.8.0 undefined symbol 运行时错误
+
+答：FA2 2.8.0 在 CUDA 12.4 上似乎存在 wheel 包问题。尝试改用 CUDA 12.6 或降级到 FA2 2.7.4。请参阅上游问题：https://github.com/Dao-AILab/flash-attention/issues/1717。
+
+问：我们可以在 VLM 训练中混合纯文本和文本+图像数据集吗？
+
+答：是的，对于较新的 VLM 架构是可以的。那些无法工作的是 LLaVA / Pixtral 架构。如果你发现有不能正常工作的情况，请告诉我们！
+
+问：为什么 memory/max_* 与 nvidia-smi 显示的不同？
+
+答：我们使用 torch API 来获取此信息。你可以查看 https://docs.pytorch.org/docs/stable/notes/cuda.html#cuda-memory-management 了解更多信息。
+
+问：jinja2.exceptions.UndefinedError: 'dict object' has no attribute 'content' / 'role' / ____
+
+答：这意味着在构建 chat_template 提示词时，所指属性对应的映射不存在。例如，如果没有 'content' 属性，请检查你是否在 message_property_mappings 下为 content 添加了正确的映射。
+
+问：为第 ___ 轮生成了空模板
+
+答：该轮次的内容为空。
+
+问：找不到第 __ 轮内容的起始/结束边界
+
+答：无法检测到特定轮次的起始/结束位置。请确保你已按照你的 chat_template 设置了 eos_token。否则，这可能是因为某个 chat_template 没有为每一轮（如 system）使用正确的边界。在极少数情况下，请确保你的内容不是 [[dummy_message]]。请向我们反馈此问题。
+
+问：对于第 ___ 轮，内容结束边界在起始边界之前
+
+答：这是一个不应发生的边缘情况。如果发生这种情况，请创建一个 Issue。
+
+问：对于第 ___ 轮，内容结束边界与起始边界相同。这很可能是一个空轮次。
+
+答：这很可能是一个空轮次。
+
+问：EOS token 被错误地掩码或未被掩码 / 在聊天模板中找不到 EOS token __。
+
+答：可能有两个原因：
+
+问：“chat_template choice is tokenizer_default but tokenizer’s chat_template is null. Please add a chat_template in tokenizer config”
+
+答：这是因为分词器没有聊天模板。请在分词器配置中添加聊天模板。有关更多详细信息，请参阅 chat_template。
+
+问：EOT token 被错误地掩码或未被掩码 / 在聊天模板中找不到 EOT token __。
+
+答：可能有两个原因：
+
+问：EOT token 编码失败。请检查该 token 是否有效并且可以被编码。
+
+答：可能是分词器或 Unicode 编码存在某些问题。请携带导致问题的 EOT token 和分词器的示例提交一个 Issue。
+
+问：EOT token __ 被编码为多个 token。
+
+答：这是因为 EOT token 被编码为了多个 token，这可能会导致意外行为。请将其添加在 tokens: 下，或者（推荐）通过 added_tokens_overrides: 覆盖未使用的 added_tokens。
+
+问：train_on_eos 和 train_on_eot 之间存在冲突。eos_token 处于 eot_tokens 中，且 train_on_eos != train_on_eot
+
+答：这是因为 EOS token 在 eot_tokens: 中，同时 train_on_eos: 和 train_on_eot: 存在不一致。这将导致其中一个覆盖另一个。请确保 train_on_eos: 和 train_on_eot: 相同，或者从 eot_tokens: 中移除 EOS token。
+
+问：如果未提供 eot_tokens: 会发生什么？
+
+答：如果未提供 eot_tokens:，默认行为与以前相同。用于分隔轮次的 EOS token 会根据该轮次是否可训练来进行掩码/取消掩码。
+
+在内部，eot_tokens: 对应 tokenizer.eos_token，且 train_on_eot: 对应 train_on_eos（默认为 turn）。这种过渡有助于理清 EOT/EOS token 的命名和行为。
+
+问：数据处理错误：CAS 服务错误
+
+答：尝试通过 export HF_HUB_DISABLE_XET=1 禁用 XET。
+
+问：torch._inductor.exc.LoweringException: NoValidChoicesError: No choices to select, please consider adding ATEN into max_autotune_gemm_backends config (defined in torch/_inductor/config.py) to allow at least one choice.
+
+答：根据 torch 的版本，你可能需要在你的 YAML 中包含以下内容：
+
+**问: ValueError("Backward pass should have cleared tracker of all tensors")
+
+答：这可能是由于在 CUDA 流中使用现代 OffloadActivations 上下文管理器时出现的边缘情况导致的。如果你遇到此错误，通过在你的 YAML 中设置 offload_activations: legacy 来使用简单的实现可能会成功。
+
+**问：解析 tool_calls 参数为 JSON 时出错。
+
+答：将字符串参数解析为字典时出错。请检查你的数据集和错误消息以获取更多详细信息。
+
+**示例:**
+
+示例 1 (yaml):
+```yaml
+special_tokens:
+  # 字符串。如果你不确定，请将其设置为与 `eos_token` 相同。
+  pad_token: "..."
+```
+
+示例 2 (yaml):
+```yaml
+flex_attn_compile_kwargs:
+  dynamic: false
+  mode: max-autotune-no-cudagraphs
+```
+
+---
+
+## 安装
+
+**URL:** https://docs.axolotl.ai/docs/installation.html
+
+**目录：**
+- 安装
+- 1 要求
+- 2 安装方法
+  - 2.1 PyPI 安装（推荐）
+  - 2.2 uv 安装
+  - 2.3 Edge/开发版构建
+  - 2.4 Docker
+- 3 云环境
+  - 3.1 云 GPU 提供商
+  - 3.2 Google Colab
+
+本指南涵盖了为你的环境安装和设置 Axolotl 的所有方法。
+
+在本地环境中安装 Axolotl 之前，请确保已安装 PyTorch。
+
+请按照以下网址的说明进行操作：https://pytorch.org/get-started/locally/
+
+对于 Blackwell GPU，请使用 PyTorch 2.7.0 和 CUDA 12.8。
+
+我们使用 --no-build-isolation 来检测已安装的 PyTorch 版本（如果已安装），以免覆盖它，并确保我们设置了特定于该 PyTorch 版本或其他已安装协同依赖项的正确依赖版本。
+
+uv 是一个用 Rust 构建的快速、可靠的 Python 包安装和解析工具。它比 pip 提供了显著的性能提升，并具有更好的依赖解析能力，使其成为复杂环境下的绝佳选择。
+
+如果尚未安装，请先安装 uv
+
+选择要与 PyTorch 一起使用的 CUDA 版本；例如 cu124、cu126、cu128，然后创建虚拟环境并激活
+
+安装 PyTorch - 推荐使用 PyTorch 2.6.0
+
+从 PyPI 安装 axolotl
+
+获取版本发布之间的最新功能：
+
+用于使用 Docker 进行开发：
+
+对于 Blackwell GPU，请使用 axolotlai/axolotl:main-py3.11-cu128-2.7.0 或云变体 axolotlai/axolotl-cloud:main-py3.11-cu128-2.7.0。
+
+有关可用 Docker 镜像的更多信息，请参阅 Docker 文档。
+
+对于支持 Docker 的提供商：
+
+有关 Mac 特定的问题，请参见第 6 节。
+
+我们建议使用 WSL2（Windows Subsystem for Linux）或 Docker。
+
+安装 PyTorch：https://pytorch.org/get-started/locally/
+
+（可选）登录 Hugging Face：
+
+如果遇到安装问题，请参阅我们的常见问题解答和调试指南。
+
+**示例:**
+
+示例 1 (bash):
+```bash
+pip3 install -U packaging setuptools wheel ninja
+pip3 install --no-build-isolation axolotl[flash-attn,deepspeed]
+```
+
+示例 2 (bash):
+```bash
+curl -LsSf https://astral.sh/uv/install.sh | sh
+source $HOME/.local/bin/env
+```
+
+示例 3 (bash):
+```bash
+export UV_TORCH_BACKEND=cu126
+uv venv --no-project --relocatable
+source .venv/bin/activate
+```
+
+示例 4 (bash):
+```bash
+uv pip install packaging setuptools wheel
+uv pip install torch==2.6.0
+uv pip install awscli pydantic
+```
+
+---
+
+## 数据集预处理
+
+**URL:** https://docs.axolotl.ai/docs/dataset_preprocessing.html
+
+**目录：**
+- 数据集预处理
+- 概览
+  - 预处理的好处是什么？
+  - 边缘情况有哪些？
+
+数据集预处理是 Axolotl 根据你配置的每个数据集，结合数据集格式和提示词策略进行以下操作的步骤：
+
+数据集的处理可以通过以下两种方式之一进行：
+
+在交互式训练或进行参数扫描（例如，你经常重启训练器）时，处理数据集通常慢得令人沮丧。预处理会根据相关训练参数的哈希值缓存分词/格式化后的数据集，以便在可能的情况下智能地从其缓存中读取。
+
+缓存的路径由 dataset_prepared_path: 控制，在示例 YAML 中通常留空，因为这样可以形成更稳健的方案，防止意外重用过期的缓存数据。
+
+如果 dataset_prepared_path: 留空，在训练时，处理后的数据集将缓存在默认路径 ./last_run_prepared/ 中，但会忽略那里已经缓存的任何内容。通过显式设置 dataset_prepared_path: ./last_run_prepared，训练器将使用缓存中的任何预处理数据。
+
+假设你正在编写自定义提示词策略或使用用户定义的提示词模板。由于训练器无法轻易检测到这些更改，我们无法更改预处理数据集计算得出的哈希值。
+
+如果你设置了 dataset_prepared_path: ... 并更改了提示词模板逻辑，它可能不会应用你所做的更改，你将继续使用旧的提示词进行训练。
+
+---
+
+## 推理与合并
+
+**URL:** https://docs.axolotl.ai/docs/inference.html
+
+**目录：**
+- 推理与合并
+- 1 快速开始
+  - 1.1 基础推理
+- 2 高级用法
+  - 2.1 Gradio 界面
+  - 2.2 基于文件的提示词
+  - 2.3 内存优化
+- 3 合并 LoRA 权重
+  - 3.1 合并时的内存管理
+- 4 分词
+
+本指南涵盖了如何使用你训练好的模型进行推理，包括模型加载、交互式测试、合并适配器以及常见故障排除步骤。
+
+推理/合并时，请使用与训练时相同的配置。
+
+启动交互式 Web 界面：
+
+从文本文件中处理提示词：
+
+对于大模型或内存有限的情况：
+
+将 LoRA 适配器与基础模型合并：
+
+训练和推理之间的分词不匹配是产生问题的常见原因。
+
+在输入模型之前解码 token，验证推理分词
+
+比较训练和推理之间的 token ID
+
+在你的 YAML 中配置特殊 token：
+
+有关更多详细信息，请参阅我们的调试指南。
+
+**示例:**
+
+示例 1 (bash):
+```bash
+axolotl inference your_config.yml --lora-model-dir="./lora-output-dir"
+```
+
+示例 2 (bash):
+```bash
+axolotl inference your_config.yml --base-model="./completed-model"
+```
+
+示例 3 (bash):
+```bash
+axolotl inference your_config.yml --gradio
+```
+
+示例 4 (bash):
+```bash
+cat /tmp/prompt.txt | axolotl inference your_config.yml \
+  --base-model="./completed-model" --prompter=None
+```
+
+---
+
+## 多模态/视觉语言模型 (BETA)
+
+**URL:** https://docs.axolotl.ai/docs/multimodal.html
+
+**目录：**
+- 多模态/视觉语言模型 (BETA)
+- 支持的模型
+- 用法
+  - Mllama
+  - Llama4
+  - Pixtral
+  - Llava-1.5
+  - Mistral-Small-3.1
+  - Magistral-Small-2509
+  - Voxtral
+
+多模态支持有限，不具备完整的功能对等性。
+
+以下是你微调多模态模型所需要使用的超参数。
+
+完整的配置请查看 examples 文件夹。
+
+我们的一些 chat_templates 已经进行了扩展，以支持更广泛的数据集类型。这应该不会破坏任何现有的配置。
+
+目前，我们不会根据 sequence_len 截断或丢弃样本，因为每种架构处理非文本 token 的方式不同。我们正在寻求这方面的帮助。
+
+请确保通过 pip install 'mistral-common[opencv]==1.8.5' 安装视觉库。
+
+请确保通过 pip install 'mistral-common[opencv]==1.8.5' 安装视觉库。
+
+请确保通过 pip3 install librosa==0.11.0 'mistral_common[audio]==1.8.3' 安装音频库。
+
+Gemma3-1B 模型是纯文本模型，因此请将其作为常规的纯文本模型进行训练。
+
+对于多模态的 4B/12B/27B 模型，请使用以下配置：
+
+模型初始的损失和梯度范数会非常高。我们怀疑这是由于视觉层中的卷积导致的。
+
+请确保通过 pip3 install timm==1.0.17 安装 timm。
+
+请确保通过 pip3 install num2words==0.5.14 安装 num2words。
+
+请通过 pip3 uninstall -y causal-conv1d 卸载 causal-conv1d。
+
+对于多模态数据集，我们采用了类似于 OpenAI Message 格式的扩展 chat_template 格式。
+
+为了向后兼容：
+
+对于图像加载，你可以在 content 中与 "type": "image" 一起使用以下键：
+
+对于音频加载，你可以在 content 中与 "type": "audio" 一起使用以下键：
+
+你可能需要通过 pip3 install librosa==0.11.0 安装 librosa。
+
+目前该功能尚未经过充分测试。我们欢迎贡献者！
+
+对于视频加载，你可以在 content 中与 "type": "video" 一起使用以下键：
+
+以下是一个多模态数据集的示例：
+
+PIL 无法使用 requests 获取指定 URL 的文件。请检查是否有拼写错误。另一个可能的原因是请求被服务器阻止了。
+
+**示例:**
+
+示例 1 (yaml):
+```yaml
+processor_type: AutoProcessor
+
+skip_prepare_dataset: true
+remove_unused_columns: false  # 保留这些列，因为在训练期间处理图像嵌入时需要它们
+sample_packing: false  # 多模态暂不支持
+
+chat_template:  # 如果指定，请参见下一节
+
+# 数据集示例
+datasets:
+  - path: HuggingFaceH4/llava-instruct-mix-vsft
+    type: chat_template
+    split: train[:1%]
+
+# (可选) 如果使用 lora，只微调语言模型，
+# 保持视觉模型和视觉塔冻结
+# load_in_8bit: true
+adapter: lora
+lora_target_modules: 'model.language_model.layers.[\d]+.(mlp|cross_attn|self_attn).(up|down|gate|q|k|v|o)_proj'
+
+# (可选) 如果你想将图像调整为设定的大小
+image_size: 512
+image_resize_algorithm: bilinear
+```
+
+示例 2 (yaml):
+```yaml
+base_model: meta-llama/Llama-3.2-11B-Vision-Instruct
+
+chat_template: llama3_2_vision
+```
+
+示例 3 (yaml):
+```yaml
+base_model: meta-llama/Llama-4-Scout-17B-16E-Instruct
+
+chat_template: llama4
+```
+
+示例 4 (yaml):
+```yaml
+base_model: mistralai/Pixtral-12B-2409
+
+chat_template: pixtral
+```
+
+---
+
+## 奖励建模
+
+**URL:** https://docs.axolotl.ai/docs/reward_modelling.html
+
+**目录：**
+- 奖励建模
+  - 概览
+  - (结果) 奖励模型
+  - 过程奖励模型 (PRM)
+
+奖励建模是一种用于训练模型预测给定输入奖励或价值的技术。这在强化学习场景中特别有用，因为模型需要评估其行为或预测的质量。我们支持由 trl 提供支持的奖励建模技术。
+
+结果奖励模型是使用包含用户与模型之间整个交互过程的偏好标注数据（例如，而不是每一轮或每一个步骤）进行训练的。为了提高训练稳定性，你可以使用 center_rewards_coefficient 参数来鼓励产生均值为零的奖励输出（见 TRL 文档）。
+
+Bradley-Terry 聊天模板期望按以下格式提供单轮对话：
+
+请查看我们的 PRM 博客。
+
+过程奖励模型是使用包含一系列交互中每一步的偏好标注数据进行训练的。通常，PRM 被训练来为推理轨迹的每一个步骤提供奖励信号，并用于后续的强化学习。
+
+有关数据集格式的更多详细信息，请参见 stepwise_supervised。
+
+**示例:**
+
+示例 1 (yaml):
+```yaml
+base_model: google/gemma-2-2b
+model_type: AutoModelForSequenceClassification
+num_labels: 1
+tokenizer_type: AutoTokenizer
+
+reward_model: true
+chat_template: gemma
+datasets:
+  - path: argilla/distilabel-intel-orca-dpo-pairs
+    type: bradley_terry.chat_template
+
+val_set_size: 0.1
+eval_steps: 100
+```
+
+示例 2 (json):
+```json
+{
+    "system": "...", // 可选
+    "input": "...",
+    "chosen": "...",
+    "rejected": "..."
+}
+```
+
+示例 3 (yaml):
+```yaml
+base_model: Qwen/Qwen2.5-3B
+model_type: AutoModelForTokenClassification
+num_labels: 2
+
+process_reward_model: true
+datasets:
+  - path: trl-lib/math_shepherd
+    type: stepwise_supervised
+    split: train
+
+val_set_size: 0.1
+eval_steps: 100
+```
+
+---
+
+## RLHF (Beta)
+
+**URL:** https://docs.axolotl.ai/docs/rlhf.html
+
+**目录：**
+- RLHF (Beta)
+- 概览
+- 使用 Axolotl 进行 RLHF
+  - DPO
+    - chatml.argilla
+    - chatml.argilla_chat
+    - chatml.icr
+    - chatml.intel
+    - chatml.prompt_pairs
+    - chatml.ultra
+
+基于人类反馈的强化学习（RLHF）是一种利用人类反馈数据来优化语言模型的方法。各种方法包括但不限于：
+
+这是一个 BETA 功能，许多功能尚未完全实现。我们鼓励你提交新的 PR 来改善其集成和功能。
+
+我们依赖 TRL 库来实现各种 RL 训练方法，并对其进行封装以便在 Axolotl 中使用。每种方法都有其自身支持的数据集加载方式和提示词格式。
+
+你可以通过进入 src/axolotl/prompt_strategies/{method} 来了解每种方法支持的内容，其中 {method} 是我们支持的方法之一。type: 可以从 {method}.{function_name} 中获取。
+
+DPO 支持以下类型以及以下数据集格式：
+
+对于自定义行为，
+
+输入格式是一个简单的 JSON 输入，其字段基于上述配置可进行自定义。
+
+由于 IPO 只是具有不同损失函数的 DPO，因此 DPO 支持的所有数据集格式也适用于 IPO。
+
+论文：https://arxiv.org/abs/2403.07691
+
+ORPO 支持以下类型以及以下数据集格式：
+
+KTO 支持以下类型以及以下数据集格式：
+
+对于自定义行为，
+
+输入格式是一个简单的 JSON 输入，其字段基于上述配置可进行自定义。
+
+请查看我们的 GRPO 实践手册。
+
+在最新的 GRPO 实现中，使用 vLLM 显著加快了训练过程中的轨迹生成速度。在此示例中，我们使用了 4 个 GPU - 2 个用于训练，另外 2 个用于 vLLM：
+
+请确保在安装 axolotl 时将 vLLM 作为附加项安装以获取正确版本的 vLLM，例如 pip install axolotl[vllm]。
+
+你的 vLLM 实例现在将尝试启动，是时候利用我们剩下的两个 GPU 开始训练了。在另一个终端中，执行：
+
+由于 TRL 与 vLLM 的实现方式，vLLM 实例必须使用最后 N 个 GPU，而不是前 N 个 GPU。这就是为什么在上面的示例中，我们为 vLLM 实例使用 CUDA_VISIBLE_DEVICES=2,3 的原因。
+
+GRPO 使用自定义的奖励函数和转换。请确保在本地准备好它们。
+
+例如，要加载 OpenAI 的 GSM8K 并为补全内容使用随机奖励：
+
+要查看自定义奖励函数的其他示例，请参阅 TRL GRPO 文档。
+
+要查看所有配置，请参阅 TRLConfig。
+
+DAPO 论文以及随后的 Dr. GRPO 论文为 GRPO 提出了一种替代的损失函数，以弥补较长回复受到的惩罚。
+
+有关更多信息，请参阅 GRPO 文档。
+
+SimPO 使用 CPOTrainer，但采用替代的损失函数。
+
+此方法使用与 DPO 相同的数据集格式。
+
+TRL 支持为依赖参考模型的 RL 训练范式自动解包 PEFT 模型。这显著降低了内存压力，因为不需要加载额外的参考模型，并且可以通过禁用 PEFT 适配器来获取参考模型的对数概率。此功能默认开启。要将其关闭，请传递以下配置：
+
+**示例:**
+
+示例 1 (yaml):
+```yaml
+rl: dpo
+datasets:
+  - path: Intel/orca_dpo_pairs
+    split: train
+    type: chatml.intel
+  - path: argilla/ultrafeedback-binarized-preferences
+    split: train
+    type: chatml
+```
+
+示例 2 (json):
+```json
+{
+    "system": "...", // 可选
+    "instruction": "...",
+    "chosen_response": "...",
+    "rejected_response": "..."
+}
+```
+
+示例 3 (json):
+```json
+{
+    "chosen": [
+        {"role": "user", "content": "..."},
+        {"role": "assistant", "content": "..."}
+    ],
+    "rejected": [
+        {"role": "user", "content": "..."},
+        {"role": "assistant", "content": "..."}
+    ]
+}
+```
+
+示例 4 (json):
+```json
+{
+    "system": "...", // 可选
+    "input": "...",
+    "chosen": "...",
+    "rejected": "..."
+}
+```
+
+---
+
+## LoRA 优化
+
+**URL:** https://docs.axolotl.ai/docs/lora_optims.html
+
+**目录：**
+- LoRA 优化
+- 用法
+- 要求
+- 实现细节
+  - 自定义 autograd 函数
+  - Triton 内核
+  - 集成
+- 后续工作
+
+受 Unsloth 启发，我们为 LoRA 和 QLoRA 微调实现了两项优化，支持单 GPU 和多 GPU（包括 DDP、DeepSpeed 和 FSDP2 设置）训练。这些包括 (1) SwiGLU 和 GEGLU 激活函数的 Triton 内核，以及 (2) LoRA MLP 和注意力机制的自定义 autograd 函数。我们的目标是利用算子融合和张量重用，来提高这些计算的前向和反向传递过程中的速度并减少内存使用。
+
+我们目前支持几种常见的模型架构，包括（但不限于）：
+
+我们支持的模型集合目前受到注意力补丁策略的限制，该策略假定（并替换）了用于查询/键/值和输出投影的特定代码块：
+
+其中 apply_qkv 和 apply_o 定义在 axolotl.kernels.lora 模块中。
+
+我们欢迎对其他模型架构进行测试，和/或提交 PR 以扩展我们的补丁逻辑，使其兼容更多的模型。
+
+请查看我们的 LoRA 优化博客。
+
+这些优化可以在你的 Axolotl 配置 YAML 文件中启用。lora_mlp_kernel 选项用于启用优化的 MLP 路径，而 lora_qkv_kernel 和 lora_o_kernel 分别启用融合的查询-键-值投影和优化的输出投影。
+
+目前，LoRA 内核不支持 RLHF 训练，仅支持 SFT。
+
+带有现有 LoRA 适配器且使用了 Dropout 或具有偏置项的模型，可能需要在不使用这些特性的情况下重新微调才能发挥效用。
+
+LoRA MLP autograd 函数优化了整个 MLP 计算路径。它将 LoRA 和基础权重的计算融合在一起，并为整个 MLP 块提供了单一、高效的反向传递。
+
+对于注意力组件，通过一个处理查询、键和值投影的函数以及一个处理输出投影的函数提供了类似的优化。它们通过一些 monkey-patching 逻辑设计为与现有的 transformers 注意力实现一起工作。
+
+两种激活函数（SwiGLU 和 GeGLU）通过 Triton 内核实现，以提高速度和内存性能。这些内核同时处理前向和反向传递。
+
+自定义 autograd 函数和 Triton 内核被设计为协同工作。autograd 函数管理高层计算流和梯度跟踪，同时调用 Triton 内核进行激活函数计算。在反向传递期间，内核会计算激活输出和所需的梯度，随后 autograd 函数利用它们来计算整个计算路径的最终梯度。
+
+**示例:**
+
+示例 1 (python):
+```python
+ORIGINAL_QKV_CODE = """
+    query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+    key_states = self.k_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+    value_states = self.v_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+""".lstrip(
+    "\n"
+)
+
+ORIGINAL_O_CODE = """
+    attn_output = self.o_proj(attn_output)
+""".lstrip(
+    "\n"
+)
+```
+
+示例 2 (python):
+```python
+PATCHED_QKV_CODE = """
+    query_states, key_states, value_states = self.apply_qkv(hidden_states)
+    query_states = query_states.view(hidden_shape).transpose(1, 2)
+    key_states = key_states.view(hidden_shape).transpose(1, 2)
+    value_states = value_states.view(hidden_shape).transpose(1, 2)
+""".lstrip(
+    "\n"
+)
+
+PATCHED_O_CODE = """
+    attn_output = self.apply_o(attn_output)
+""".lstrip(
+    "\n"
+)
+```
+
+示例 3 (yaml):
+```yaml
+lora_mlp_kernel: true
+lora_qkv_kernel: true
+lora_o_kernel: true
+```
+
+---
+
+## 使用 torchao 进行量化
+
+**URL:** https://docs.axolotl.ai/docs/quantize.html
+
+**目录：**
+- 使用 torchao 进行量化
+- 在 Axolotl 中配置量化
+
+量化是一种降低模型内存占用技术，潜在的代价是牺牲精度或模型性能。我们支持使用 torchao 库对你的模型进行量化。支持训练后量化 (PTQ) 和量化感知训练 (QAT)。
+
+我们目前不支持诸如 GGUF/GPTQ、EXL2 等量化技术。
+
+在你的配置文件中使用 quantization 键来配置量化。
+
+量化完成后，你的量化模型将保存在 {output_dir}/quantized 目录中。
+
+你还可以使用 quantize 命令对使用 QAT 训练的模型进行量化——你可以通过使用你用来训练模型的现有 QAT 配置文件来做到这一点：
+
+这确保了在对模型进行量化时，使用了与训练时完全相同的量化配置。
+
+如果你配置了使用 hub_model_id 推送到 hub，你的模型 hub 名称将会附加量化方案后缀，例如 axolotl-ai-cloud/qat-nvfp4-llama3B 将变为 axolotl-ai-cloud/qat-nvfp4-llama3B-nvfp4w
+
+**示例:**
+
+示例 1 (yaml):
+```yaml
+base_model: # 需要量化的模型路径。
+quantization:
+  activation_dtype: # Optional[str] = "int8". 用于激活量化的伪量化布局。有效选项为 "int4"、"int8"、"float8"
+  weight_dtype: # Optional[str] = "int8". 用于权重权重的伪量化布局。有效选项为 "int4"、"fp8" 和 "nvfp4"。
+  group_size: # Optional[int] = 32. 每组伪量化中的元素数量
+  quantize_embedding: # Optional[bool] = False. 是否对嵌入层进行量化。
+
+output_dir:  # 输出目录的路径。
+```
+
+示例 2 (yaml):
+```yaml
+# qat.yml
+qat:
+  activation_dtype: int8
+  weight_dtype: int4
+  group_size: 256
+
+output_dir: # 训练期间使用的输出目录的路径，最终检查点已保存在此。
+```
+
+示例 3 (bash):
+```bash
+axolotl quantize qat.yml
+```
+
+---
+
+## NCCL
+
+**URL:** https://docs.axolotl.ai/docs/nccl.html
+
+**目录：**
+- NCCL
+
+NVIDIA NCCL 是一个促进和优化多 GPU 通信操作（如广播、全聚合、规减、全规减等）的库。总体而言，NCCL 配置高度依赖于环境，并通过多个环境变量进行配置。与 NCCL 相关的一个常见问题是，长时间运行的操作超时导致训练过程中止：
+
+通常，这种超时会在 30 分钟（默认设置）后发生，并在引发错误之前伴随着低于平均水平的功耗和接近 100% 的 GPU 利用率。如果此选项可用，NVIDIA 建议禁用 PCI 访问控制服务 (ACS) 作为可能的解决方案。
+
+在不增加超时的情况下，强制通过 NVLink 进行跨 GPU 通信可能会有所帮助。要验证你的配置是否正在利用 NVLink，请运行以下命令：
+
+要强制 NCCL 使用 NVLink，只需在环境中进行设置：
+
+如果你的环境中不可用 NVLink，下表提供了 NCCL_P2P_LEVEL 的其他选项：
+
+为了验证你的训练任务是否存在可接受的数据传输速度，运行 NCCL 测试有助于找出瓶颈，例如：
+
+在调试 NCCL 通信超时时，在 PyTorch 和 NCCL 中激活额外的日志记录可能会很有用：
+
+最后，如果你认为你的训练任务需要更多时间，你可以通过在 Axolotl 配置中设置 ddp_timeout 值来将超时增加到 30 分钟以上。有关此值的文档，请参阅 PyTorch init_process_group。
+
+**示例:**
+
+示例 1 (unknown):
+```unknown
+Watchdog caught collective operation timeout: WorkNCCL(SeqNum=42, OpType=ALLGATHER, Timeout(ms)=1800000) ran for 1806948 milliseconds before timing out.
+```
+
+示例 2 (bash):
+```bash
+nvidia-smi nvlink --status
+```
+
+示例 3 (bash):
+```bash
+export NCCL_P2P_LEVEL=NVL
+```
+
+示例 4 (bash):
+```bash
+./build/all_reduce_perf -b 8 -e 128M -f 2 -g 3
+```
+
+---
+
+## 多节点
+
+**URL:** https://docs.axolotl.ai/docs/multi-node
+
+## FSDP + QLoRA
+
+**URL:** https://docs.axolotl.ai/docs/fsdp_qlora.html
+
+**目录：**
+- FSDP + QLoRA
+- 背景
+- 用法
+- 为 FSDP2 启用 Swap
+- 示例配置
+- 参考
+- 脚注
+
+在消费级 GPU 上微调较大（70b+ 参数）的 LLM 时，将 FSDP 与 QLoRA 结合使用是必不可少的。例如，你可以使用 FSDP + QLoRA 在两张 24GB 的 GPU 上训练 70b 模型1。
+
+下面，我们将介绍如何在 Axolotl 中使用此功能。
+
+要启用结合 FSDP 的 QLoRA，你需要执行以下步骤：
+
+![提示] 除了阅读这些说明外，请参阅示例配置文件。
+
+如果在 FSDP 的 CPU 卸载（offload）之后可用内存仍然不足，你可以在 FSDP 配置中设置 `cpu_offload_pin_memory: false` 并配合 `offload_params: true` 来启用交换内存（swap）的使用。
+
+这会禁用内存锁定，允许 FSDP 将磁盘交换空间作为后备。禁用内存锁定本身会带来性能开销，而实际使用 swap 会增加更多开销，但这可能使得在资源受限的系统上训练更大的模型成为可能，从而避免原本会出现的 OOM（内存溢出）错误。
+
+`examples/llama-2/qlora-fsdp.yml` 中包含了如何在 axolotl 中启用 QLoRA + FSDP 的示例。
+
+此功能由 Answer.AI 团队的工作促成。↩︎
+
+---
+
+## 自定义集成
+
+**URL:** https://docs.axolotl.ai/docs/custom_integrations.html
+
+**目录：**
+- 自定义集成
+- Cut Cross Entropy
+  - 要求
+  - 安装
+  - 用法
+  - 支持的模型
+  - 引用
+- DenseMixer
+- Axolotl 的扩散模型训练插件
+  - 概览
+
+Axolotl 通过集成来添加自定义功能。它们位于 `src/axolotl/integrations` 目录中。
+
+要启用它们，请查看相应的文档。
+
+Cut Cross Entropy (CCE) 通过在损失计算过程中优化交叉熵操作来减少显存（VRAM）使用量。
+
+请参阅 https://github.com/apple/ml-cross-entropy
+
+如果你尚未安装，请运行以下命令安装 `cut_cross_entropy[transformers]`。
+
+请在此处查看参考
+
+只需将以下内容添加到你的 axolotl YAML 配置中：
+
+请在此处查看参考
+
+这个插件使得在 Axolotl 中能够使用受 LLaDA（大型语言扩散模型）启发的方法来进行扩散语言模型训练。
+
+LLaDA 是一种基于扩散的语言模型训练方法，它使用：
+- 在训练过程中进行随机 token 掩码，而不是下一 token 预测
+- 双向注意力，允许模型关注完整的上下文
+- 基于掩码概率的重要性加权，以确保训练稳定
+
+这种方法可以产生更稳健的语言模型，对双向上下文有更好的理解。
+
+该插件已包含在 Axolotl 中。请参阅我们的安装文档。
+
+使用示例配置（Llama‑3.2 1B）进行训练：
+- 预训练：`axolotl train examples/llama-3/diffusion-3.2-1b-pretrain.yaml`
+- SFT：`axolotl train examples/llama-3/diffusion-3.2-1b-sft.yaml`
+
+你也可以修改现有配置来启用/自定义扩散训练。
+
+将以下内容添加到你的 Axolotl 配置中：
+
+然后，配置嵌套的 diffusion 块（显示的是默认值）：
+
+任何支持 4D 注意力掩码的模型应该都可以开箱即用。如果不支持，请创建一个 issue 或提交一个 PR！
+
+在训练期间，token 会被随机掩码：
+- 从 [0, 1] 中均匀采样时间步 t
+- 计算掩码概率：p = (1 - eps) * t + eps
+- 以概率 p 随机掩码 token
+
+损失仅在带有（可选的）重要性权重的被掩码 token 上计算：
+
+当 `diffusion.generate_samples: true` 时，插件会在训练期间生成样本：
+
+样本会被记录到控制台以及 wandb（如果已启用）。
+
+扩散推理已集成到标准的 Axolotl CLI 中。使用你训练时用过的相同配置并运行：
+
+或者，传入 `--gradio` 来使用简单的 Web 界面。
+
+交互控制（在提示词前加上命令）：
+- `:complete N` → 追加 N 个新的被掩码 token 的补全模式（默认为 64）
+- `:mask R` → 目标掩码率 R 在 [0.0, 1.0] 之间的随机掩码模式
+
+该插件添加（或修改）了几个指标来跟踪扩散训练：
+
+请在此处查看参考
+
+请参阅 https://github.com/ironjr/grokfast
+
+请在此处查看参考
+
+可以在 `axolotl-ai-co/evolkit-logprobs-pipeline-75k-v2-sample` 找到示例数据集
+
+请在此处查看参考
+
+在 Axolotl 中使用 Neural Magic 的 LLMCompressor 微调稀疏化模型。
+
+此集成允许在 Axolotl 训练框架内微调使用 LLMCompressor 稀疏化的模型。通过将 LLMCompressor 的模型压缩能力与 Axolotl 的分布式训练管道相结合，用户可以大规模地高效微调稀疏模型。
+
+它使用 Axolotl 的插件系统挂钩到微调流程中，同时在训练过程中保持稀疏性。
+
+带有 llmcompressor 扩展依赖的 Axolotl：
+
+需要 llmcompressor >= 0.5.1
+
+这将安装使用该集成微调稀疏化模型所需的所有依赖项。
+
+要使用此集成启用稀疏微调，请将此插件包含在你的 Axolotl 配置中：
+
+这个插件本身并不执行剪枝或稀疏化——它是为微调已经稀疏化的模型而设计的。
+
+预稀疏化的检查点可以是：
+- 使用 LLMCompressor 生成
+- 从 Neural Magic 的 Hugging Face 页面下载
+- 你自己创建的具有兼容稀疏模式的任何自定义 LLM
+
+要了解有关编写和自定义 LLMCompressor 配方的更多信息，请参阅官方文档：https://github.com/vllm-project/llm-compressor/blob/main/README.md
+
+在你的配置中设置 `save_compressed: true` 将启用以压缩格式保存模型，这会：
+- 将磁盘空间使用量减少约 40%
+- 保持与 vLLM 的兼容性以实现加速推理
+- 保持与 llmcompressor 的兼容性以进行进一步优化（例如：量化）
+
+在处理稀疏模型时，强烈建议使用此选项，以最大化模型压缩的优势。
+
+有关完整示例，请参阅 `examples/llama-3/sparse-finetuning.yaml`。
+
+微调稀疏模型后，你可以利用 vLLM 进行高效推理。你也可以在推理之前使用 LLMCompressor 对微调后的稀疏模型应用额外的量化，以获得更大的性能提升。：
+
+有关 vLLM 的功能和高级配置选项的更多详细信息，请参阅官方的 vLLM 文档。
+
+有关可用的稀疏和量化方案、微调配方以及使用示例，请访问官方的 LLMCompressor 仓库：
+
+https://github.com/vllm-project/llm-compressor
+
+请在此处查看参考
+
+使用流行的 `lm-evaluation-harness` 库对模型进行评估。
+
+请参阅 https://github.com/EleutherAI/lm-evaluation-harness
+
+请在此处查看参考
+
+Liger Kernel 为 LLM 训练提供了高效的 Triton 内核，提供：
+
+请参阅 https://github.com/linkedin/Liger-Kernel
+
+请在此处查看参考
+
+作者：Eric Hartford, Lucas Atkins, Fernando Fernandes, David Golchinfar
+
+这个插件包含基于信噪比 (SNR) 冻结模型底层部分模块的代码。
+
+请参阅 https://github.com/cognitivecomputations/spectrum
+
+Spectrum 是一个用于扫描和评估大型语言模型各层信噪比 (SNR) 的工具。通过识别 SNR 最高的前 n% 的层，你可以优化训练效率。
+
+请在此处查看参考
+
+插件可用于通过挂钩（hooks）自定义训练管道的行为。有关可能的挂钩，请参阅 `axolotl.integrations.BasePlugin`。
+
+要添加新的集成，请按照以下步骤操作：
+
+有关最小集成的示例，请参阅 `src/axolotl/integrations/cut_cross_entropy`。
+
+如果你无法加载你的集成，请确保你正在以可编辑模式进行 pip 安装。
+
+并且在配置文件中拼写对了集成名称。
+
+你的集成不一定要放在 integrations 文件夹中。它可以位于任何位置，只要它作为一个包安装在你的 python 环境中即可。
+
+示例请参见此仓库：https://github.com/axolotl-ai-cloud/diff-transformer
+
+**示例:**
+
+示例 1 (bash):
+```bash
+python scripts/cutcrossentropy_install.py | sh
+```
+
+示例 2 (bash):
+```bash
+pip3 uninstall -y cut-cross-entropy && pip3 install "cut-cross-entropy[transformers] @ git+https://github.com/axolotl-ai-cloud/ml-cross-entropy.git@8a1a0ec"
+```
+
+示例 3 (yaml):
+```yaml
+plugins:
+  - axolotl.integrations.cut_cross_entropy.CutCrossEntropyPlugin
+```
+
+示例 4 (unknown):
+```unknown
+@article{wijmans2024cut,
+  author       = {Erik Wijmans and
+                  Brody Huval and
+                  Alexander Hertzberg and
+                  Vladlen Koltun and
+                  Philipp Kr\"ahenb\"uhl},
+  title        = {Cut Your Losses in Large-Vocabulary Language Models},
+  journal      = {arXiv},
+  year         = {2024},
+  url          = {https://arxiv.org/abs/2411.09009},
+}
+```
+
+## 配置参考
+
+**URL:** https://docs.axolotl.ai/docs/config-reference.html
+
+**目录:**
+- 配置参考
+
+**示例:**
+
+示例 1 (yaml):
+```yaml
+# 允许从命令行覆盖 yml 配置
+strict: bool | None = False
+# 从特定的检查点目录恢复
+resume_from_checkpoint: str | None
+# 如果未设置 resume_from_checkpoint，并且您只是希望它从上次中断的地方继续。
+# 在不同模型之间开启此选项时请务必小心。
+auto_resume_from_checkpoints: bool | None
+# 当新添加的 tokens 是 32 的倍数时，调整模型 embeddings 的大小。据报告这能提高某些模型的训练速度
+resize_token_embeddings_to_32x: bool | None
+mean_resizing_embeddings: bool | None = False
+
+# 是否将 embeddings 缩小到 len(tokenizer)。默认情况下，我们不会缩小。
+shrink_embeddings: bool | None
+# 使用 PEFT 时不要将 embeddings 向上转换为 float32。适用于低显存 GPU
+embeddings_skip_upcast: bool | None
+# 随机重新初始化模型权重，而不是加载预训练权重
+reinit_weights: bool | None
+
+# 用于训练的自定义训练器类模块
+trainer_cls: str | None
+
+# 使用 RL 训练：'dpo', 'ipo', 'kto', 'simpo', 'orpo', 'grpo'
+rl: RLType | None
+
+trl: TRLConfig | None
+  # 对于 TRLConfig:
+  # RL 训练的 Beta 参数。与 `rl_beta` 相同。使用
+  beta: float | None
+  # RL 训练的补全最大长度。
+  max_completion_length: int | None
+
+  # RL 训练是否使用 VLLM。
+  use_vllm: bool = False
+  # 要使用的 VLLM 模式，'server' 或 'colocate' 之一
+  vllm_mode: Literal['server', 'colocate'] | None
+  # 要连接的 vLLM 服务器主机。
+  vllm_server_host: str | None = 0.0.0.0
+  # 要连接的 vLLM 服务器端口。
+  vllm_server_port: int | None = 8000
+  # 等待 vLLM 服务器响应的总超时时间（以秒为单位）。
+  vllm_server_timeout: int | None
+  # 用于 vLLM 引导解码的正则表达式。
+  vllm_guided_decoding_regex: str | None
+
+  # 要加载的奖励函数列表。路径必须能从当前目录导入。
+  reward_funcs: list[str] | None
+  # 奖励函数的奖励权重列表。
+  reward_weights: list[float] | None
+  # 要采样的生成数量。
+  num_generations: int | None
+  # 是否记录补全。
+  log_completions: bool | None = False
+  # 当 log_completions 为 True 时要打印的补全数量。
+  num_completions_to_print: int | None
+  # 控制重要性采样比率是在 `'token'` 还是 `'sequence'` 级别计算。对于 GSPO，使用 `sequence`，默认为 None，对应于原始的 GRPO 论文。
+  importance_sampling_level: Literal['sequence', 'token'] | None
+
+  # 是否同步参考模型。
+  sync_ref_model: bool | None = False
+  # 参考模型的混合 alpha 值。
+  ref_model_mixup_alpha: float | None = 0.9
+  # 参考模型的同步步数。
+  ref_model_sync_steps: int | None = 64
+  # 是否按标准差缩放奖励。
+  scale_rewards: bool = True
+
+  # GRPO 策略的采样温度。
+  temperature: float | None
+  # 生成策略的 Top-p 采样概率。
+  top_p: float | None
+  # 生成策略的 Top-k 采样。
+  top_k: int | None
+  # 生成策略的最小概率。
+  min_p: float | None
+  # 对出现在提示词和生成文本中的 token 进行惩罚。
+  repetition_penalty: float | None
+  # GRPO 每批次的迭代次数 (μ)。
+  num_iterations: int | None
+  # GRPO 算法中用于裁剪的 Epsilon 值。
+  epsilon: float | None
+  # GRPO 算法中用于裁剪的上限 Epsilon 值。
+  epsilon_high: float | None
+  # GRPO 是否使用 Liger 损失。
+  use_liger_loss: bool | None
+  # 要使用的损失公式。支持的值：grpo, bnpo, dr_grpo。
+  loss_type: str | None
+  # 是否从损失计算中排除被截断的补全。
+  mask_truncated_completions: bool = False
+  # 为 vLLM 启用睡眠模式，以在空闲时卸载显存
+  vllm_enable_sleep_mode: bool | None
+
+vllm: VllmConfig | None
+  # 对于 VllmConfig:
+  # VLLM 使用的设备
+  device: str | None = auto
+  # VLLM 的张量并行大小
+  tensor_parallel_size: int | None
+  # VLLM 的数据并行大小
+  data_parallel_size: int | None
+  # VLLM 的 GPU 显存利用率
+  gpu_memory_utilization: float | None = 0.9
+  # VLLM 的数据类型
+  dtype: str | None = auto
+  # VLLM 的模型上下文最大长度
+  max_model_len: int | None
+  # 为 VLLM 启用前缀缓存
+  enable_prefix_caching: bool | None
+  # 启动 vLLM 服务器的主机
+  host: str | None = 0.0.0.0
+  # 启动 vLLM 服务器的端口
+  port: int | None = 8000
+
+  # 为 VLLM 启用推理
+  enable_reasoning: bool | None
+  # VLLM 的推理解析器
+  reasoning_parser: str | None
+
+qat: QATConfig | None
+  # 对于 QATConfig:
+  # 用于激活量化的伪量化布局。
+  activation_dtype: TorchAOQuantDType | None
+  # 用于权重张量的伪量化布局。
+  weight_dtype: TorchAOQuantDType = TorchAOQuantDType.int8
+  # 量化 embedding
+  quantize_embedding: bool | None = False
+  # 每组伪量化中每组的元素数量
+  group_size: int | None = 32
+  # 应用伪量化之前的步数
+  fake_quant_after_n_steps: int | None
+
+quantization: PTQConfig | None
+  # 对于 PTQConfig:
+  # 用于权重张量的伪量化布局。
+  weight_dtype: TorchAOQuantDType = TorchAOQuantDType.int8
+  # 用于激活量化的伪量化布局。
+  activation_dtype: TorchAOQuantDType | None
+  # 是否量化 embedding 层。
+  quantize_embedding: bool | None
+  # 每组伪量化中每组的元素数量
+  group_size: int | None = 32
+
+# 奖励建模：`True` 或 `False`
+reward_model: bool | None
+# 过程奖励建模：`True` 或 `False`
+process_reward_model: bool | None
+# 激励奖励模型输出均值为零的奖励的系数（由
+# https://huggingface.co/papers/2312.09244, Eq. 2 提出）。推荐值：`0.01`。
+center_rewards_coefficient: float | None
+num_labels: int | None
+
+# 是否在 DPO 训练器中执行加权
+dpo_use_weighting: bool | None
+dpo_use_logits_to_keep: bool | None
+dpo_label_smoothing: float | None
+dpo_norm_loss: bool | None
+dpo_padding_free: bool | None
+dpo_generate_during_eval: bool | None
+
+# 用于微调模型的一个或多个数据集列表
+datasets: Annotated[list[SFTDataset | DPODataset | KTODataset | StepwiseSupervisedDataset], MinLen(1)] | None
+  # 对于 SFTDataset:
+  # HuggingFace 数据集仓库 | s3:// | gs:// | 本地文件或目录的路径
+  path: str | None
+  # 要加载的数据集拆分的名称
+  split: str | None
+  # 训练要使用的提示词类型。[alpaca, gpteacher, oasst, reflection]
+  type: str | UserDefinedPrompterType | None
+    # 对于 UserDefinedPrompterType:
+    # 自定义用户指令提示词
+    system_prompt: str | None
+    # 使用 {system} 作为要替换的键
+    system_format: str | None
+    field_system: str | None
+    field_instruction: str | None
+    field_input: str | None
+    field_output: str | None
+
+    # 可自定义为单行或多行。使用 {instruction}/{input} 作为要替换的键。
+    # 'format' 可以包含 {input}
+    format: str | None
+    # 'no_input_format' 不能包含 {input}
+    no_input_format: str | None
+  input_transform: str | None
+  # 将数据集拆分为 N 份（与 shards_idx 配合使用）
+  shards: int | None
+  # 要使用的分片数据集的索引
+  shards_idx: int | None
+  # 为了内存效率，将数据集按 N 个连续块进行处理（与
+  # `shards` 互斥）
+  preprocess_shards: int | None
+  conversation: str | None
+
+  # 训练使用的聊天模板名称，支持以下值：
+  # tokenizer_default: 使用 tokenizer_config.json 中可用的聊天模板。
+  # 如果 tokenizer 中没有聊天模板，将引发错误。这是默认设置。
+  # alpaca/inst/chatml/gemma/cohere/llama3/phi_3/deepseek_v2/jamba: 这些聊天模板
+  # 可以在 axolotl 代码库的 src/axolotl/utils/chat_templates.py 中找到。
+  # tokenizer_default_fallback_*: 其中 * 是当 tokenizer 没有聊天模板时回退到的聊天模板名称，
+  # 否则默认使用 tokenizer。例如：tokenizer_default_fallback_chatml。
+  # jinja: 为聊天模板使用自定义的 jinja 模板。自定义 jinja 模板应该在 chat_template_jinja 字段中提供。
+  chat_template: ChatTemplate | str | None
+  # 自定义 jinja 聊天模板或 jinja 文件的路径。仅在 `chat_template:
+  # jinja` 或为空时使用。
+  chat_template_jinja: str | None
+  # 源数据文件的路径
+  data_files: str | list[str] | None
+  input_format: str | None
+  # 要加载的数据集配置名称
+  name: str | None
+  # 当 path 为文件时定义的数据类型
+  ds_type: str | None
+  # 仅适用于 `completion` 数据集，使用提供的字段而不是 `text` 列
+  field: str | None
+  field_human: str | None
+  field_model: str | None
+  # 包含消息的键（默认："messages"）
+  field_messages: str | None
+  # 包含工具的键（默认："tools"）。必须是 list[dict] 并且遵循 [JSON
+  # schema](https://json-schema.org/learn/getting-started-step-by-step)。
+  field_tools: str | None
+  # 包含推理轨迹的键（默认："reasoning_content"）。
+  field_thinking: str | None
+  # 聊天模板所期望的、指示推理轨迹的键。
+  template_thinking_key: str | None
+
+  message_field_role: str | None
+
+  message_field_content: str | None
+  # 将输入数据集的属性映射到聊天模板。（默认：
+  # message_property_mappings={'role':'role', 'content':'content'}）
+  # 如果模板中存在某属性但此映射中不存在，系统将尝试使用该属性名作为键直接从消息中加载。
+  # 示例：在下面的映射中，'from' 从输入数据集加载并用作 'role'，
+  # 而 'value' 加载并用作聊天模板中的 'content'。
+  message_property_mappings: dict[str, str] | None
+  # 消息轮次中的键，通过布尔值指示是否应考虑对该轮次进行训练。
+  # 除了 `roles_to_train` 之外，还可用于选择性地训练某些轮次。
+  message_field_training: str | None
+  # 消息轮次中包含训练细节的键。用于选择性地训练轮次中的某些 tokens。
+  # 该键的值是一个 List[Dict]，包含 `begin_offset`（内容中的起始字符索引）、
+  # `end_offset`（内容中的结束字符索引）和 `train`（指示是否训练的布尔值）。
+  message_field_training_detail: str | None
+  #（仅适用于 Qwen3 模板）是否根据包含在分隔标签内的推理轨迹来拆分助手内容
+  split_thinking: bool | None
+  logprobs_field: str | None
+  temperature: float | None
+  # 要训练的角色。来自这些角色的 tokens 将计入损失。
+  roles_to_train: list[str] | None
+  # 在对话中要训练哪些 EOS tokens。可能的值为：all：训练所有 EOS tokens，
+  # turn（默认）：训练每个可训练轮次结束时的 EOS token，
+  # last：训练对话中的最后一个 EOS token
+  train_on_eos: Literal['all', 'turn', 'last'] | None
+  # 消息中的角色映射。格式为 {target_role: [source_roles]}。所有
+  # 源角色将被映射到目标角色。默认为：user: ["human",
+  # "user"], assistant: ["gpt", "assistant"], system: ["system"], tool: ["tool"]
+  roles: dict[str, list[str]] | None
+  # 是否从数据集中丢弃系统轮次。仅适用于 chat_template。
+  # 如果存在，这不会从 chat_template 中丢弃默认系统消息。如果
+  # 您希望这样做，我们建议使用移除了默认系统消息的自定义 jinja 模板，
+  # 或者添加一个内容为空的系统轮次。
+  drop_system_message: bool | None
+  # 对不受信任的源信任远程代码
+  trust_remote_code: bool | None = False
+  # 从 Hugging Face Hub 加载时要使用的数据集特定版本。
+  # 这可以是提交哈希、标签或分支名称。如果未指定，将使用最新版本。
+  # 本地数据集将忽略此参数。
+  revision: str | None
+
+  # 对于 DPODataset:
+  path: str | None
+  split: str | None
+  type: UserDefinedDPOType | str | None
+    # 对于 UserDefinedDPOType:
+    field_system: str | None
+    field_prompt: str | None
+    field_chosen: str | None
+    field_rejected: str | None
+    prompt_format: str | None
+    chosen_format: str | None
+    rejected_format: str | None
+  data_files: list[str] | None
+  revision: str | None
+  field_messages: str | None
+
+  # 对于 KTODataset:
+  path: str | None
+  split: str | None
+  type: UserDefinedKTOType | str | None
+    # 对于 UserDefinedKTOType:
+    field_system: str | None
+    field_prompt: str | None
+    field_completion: str | None
+    field_label: bool | None
+    prompt_format: str | None
+    completion_format: str | None
+  data_files: list[str] | None
+  trust_remote_code: bool | None = False
+  revision: str | None
+
+  # 对于 StepwiseSupervisedDataset:
+  path: str | None
+  split: str | None
+  data_files: list[str] | None
+  revision: str | None
+  step_separator: str | None
+  max_completion_length: int | None
+  train_on_last_step_only: bool | None
+
+# 用于评估模型的一个或多个数据集列表。您可以使用
+# test_datasets 或 val_set_size，但不能同时使用两者。
+test_datasets: Annotated[list[SFTDataset | DPODataset | KTODataset | StepwiseSupervisedDataset], MinLen(1)] | None
+  # 对于 SFTDataset:
+  # HuggingFace 数据集仓库 | s3:// | gs:// | 本地文件或目录的路径
+  path: str | None
+  # 要加载的数据集拆分的名称
+  split: str | None
+  # 训练要使用的提示词类型。[alpaca, gpteacher, oasst, reflection]
+  type: str | UserDefinedPrompterType | None
+    # 对于 UserDefinedPrompterType:
+    # 自定义用户指令提示词
+    system_prompt: str | None
+    # 使用 {system} 作为要替换的键
+    system_format: str | None
+    field_system: str | None
+    field_instruction: str | None
+    field_input: str | None
+    field_output: str | None
+
+    # 可自定义为单行或多行。使用 {instruction}/{input} 作为要替换的键。
+    # 'format' 可以包含 {input}
+    format: str | None
+    # 'no_input_format' 不能包含 {input}
+    no_input_format: str | None
+  input_transform: str | None
+  # 将数据集拆分为 N 份（与 shards_idx 配合使用）
+  shards: int | None
+  # 要使用的分片数据集的索引
+  shards_idx: int | None
+  # 为了内存效率，将数据集按 N 个连续块进行处理（与
+  # `shards` 互斥）
+  preprocess_shards: int | None
+  conversation: str | None
+
+  # 训练使用的聊天模板名称，支持以下值：
+  # tokenizer_default: 使用 tokenizer_config.json 中可用的聊天模板。
+  # 如果 tokenizer 中没有聊天模板，将引发错误。这是默认设置。
+  # alpaca/inst/chatml/gemma/cohere/llama3/phi_3/deepseek_v2/jamba: 这些聊天模板
+  # 可以在 axolotl 代码库的 src/axolotl/utils/chat_templates.py 中找到。
+  # tokenizer_default_fallback_*: 其中 * 是当 tokenizer 没有聊天模板时回退到的聊天模板名称，
+  # 否则默认使用 tokenizer。例如：tokenizer_default_fallback_chatml。
+  # jinja: 为聊天模板使用自定义的 jinja 模板。自定义 jinja 模板应该在 chat_template_jinja 字段中提供。
+  chat_template: ChatTemplate | str | None
+  # 自定义 jinja 聊天模板或 jinja 文件的路径。仅在 `chat_template:
+  # jinja` 或为空时使用。
+  chat_template_jinja: str | None
+  # 源数据文件的路径
+  data_files: str | list[str] | None
+  input_format: str | None
+  # 要加载的数据集配置名称
+  name: str | None
+  # 当 path 为文件时定义的数据类型
+  ds_type: str | None
+  # 仅适用于 `completion` 数据集，使用提供的字段而不是 `text` 列
+  field: str | None
+  field_human: str | None
+  field_model: str | None
+  # 包含消息的键（默认："messages"）
+  field_messages: str | None
+  # 包含工具的键（默认："tools"）。必须是 list[dict] 并且遵循 [JSON
+  # schema](https://json-schema.org/learn/getting-started-step-by-step)。
+  field_tools: str | None
+  # 包含推理轨迹的键（默认："reasoning_content"）。
+  field_thinking: str | None
+  # 聊天模板所期望的、指示推理轨迹的键。
+  template_thinking_key: str | None
+
+  message_field_role: str | None
+
+  message_field_content: str | None
+  # 将输入数据集的属性映射到聊天模板。（默认：
+  # message_property_mappings={'role':'role', 'content':'content'}）
+  # 如果模板中存在某属性但此映射中不存在，系统将尝试使用该属性名作为键直接从消息中加载。
+  # 示例：在下面的映射中，'from' 从输入数据集加载并用作 'role'，
+  # 而 'value' 加载并用作聊天模板中的 'content'。
+  message_property_mappings: dict[str, str] | None
+  # 消息轮次中的键，通过布尔值指示是否应考虑对该轮次进行训练。
+  # 除了 `roles_to_train` 之外，还可用于选择性地训练某些轮次。
+  message_field_training: str | None
+  # 消息轮次中包含训练细节的键。用于选择性地训练轮次中的某些 tokens。
+  # 该键的值是一个 List[Dict]，包含 `begin_offset`（内容中的起始字符索引）、
+  # `end_offset`（内容中的结束字符索引）和 `train`（指示是否训练的布尔值）。
+  message_field_training_detail: str | None
+  #（仅适用于 Qwen3 模板）是否根据包含在分隔标签内的推理轨迹来拆分助手内容
+  split_thinking: bool | None
+  logprobs_field: str | None
+  temperature: float | None
+  # 要训练的角色。来自这些角色的 tokens 将计入损失。
+  roles_to_train: list[str] | None
+  # 在对话中要训练哪些 EOS tokens。可能的值为：all：训练所有 EOS tokens，
+  # turn（默认）：训练每个可训练轮次结束时的 EOS token，
+  # last：训练对话中的最后一个 EOS token
+  train_on_eos: Literal['all', 'turn', 'last'] | None
+  # 消息中的角色映射。格式为 {target_role: [source_roles]}。所有
+  # 源角色将被映射到目标角色。默认为：user: ["human",
+  # "user"], assistant: ["gpt", "assistant"], system: ["system"], tool: ["tool"]
+  roles: dict[str, list[str]] | None
+  # 是否从数据集中丢弃系统轮次。仅适用于 chat_template。
+  # 如果存在，这不会从 chat_template 中丢弃默认系统消息。如果
+  # 您希望这样做，我们建议使用移除了默认系统消息的自定义 jinja 模板，
+  # 或者添加一个内容为空的系统轮次。
+  drop_system_message: bool | None
+  # 对不受信任的源信任远程代码
+  trust_remote_code: bool | None = False
+  # 从 Hugging Face Hub 加载时要使用的数据集特定版本。
+  # 这可以是提交哈希、标签或分支名称。如果未指定，将使用最新版本。
+  # 本地数据集将忽略此参数。
+  revision: str | None
+
+  # 对于 DPODataset:
+  path: str | None
+  split: str | None
+  type: UserDefinedDPOType | str | None
+    # 对于 UserDefinedDPOType:
+    field_system: str | None
+    field_prompt: str | None
+    field_chosen: str | None
+    field_rejected: str | None
+    prompt_format: str | None
+    chosen_format: str | None
+    rejected_format: str | None
+  data_files: list[str] | None
+  revision: str | None
+  field_messages: str | None
+
+  # 对于 KTODataset:
+  path: str | None
+  split: str | None
+  type: UserDefinedKTOType | str | None
+    # 对于 UserDefinedKTOType:
+    field_system: str | None
+    field_prompt: str | None
+    field_completion: str | None
+    field_label: bool | None
+    prompt_format: str | None
+    completion_format: str | None
+  data_files: list[str] | None
+  trust_remote_code: bool | None = False
+  revision: str | None
+
+  # 对于 StepwiseSupervisedDataset:
+  path: str | None
+  split: str | None
+  data_files: list[str] | None
+  revision: str | None
+  step_separator: str | None
+  max_completion_length: int | None
+  train_on_last_step_only: bool | None
+
+# 如果为 false，数据集将不会被随机打乱，并将保持在
+# `datasets` 中的原始顺序。这同样适用于 `test_datasets` 选项和
+# `pretraining_dataset` 选项。默认为 true。
+shuffle_merged_datasets: bool | None = True
+# 如果为 true，`datasets` 中的每个数据集将在合并之前被打乱。这允许
+# 在数据集级别应用课程学习策略。默认为 false。
+shuffle_before_merging_datasets: bool | None = False
+# Axolotl 尝试在打包数据后将数据集保存为 arrow 格式，以便
+# 随后的训练尝试加载得更快，相对路径
+dataset_prepared_path: str | None
+# 整个数据集的分片数
+dataset_shard_num: int | None
+# 要使用的整个数据集分片的索引
+dataset_shard_idx: int | None
+skip_prepare_dataset: bool | None = False
+# 保存准备好数据集的分片数量
+num_dataset_shards_to_save: int | None
+
+# 设置为 type: 'completion' 的 HF 数据集，以流式传输而非预分词
+pretraining_dataset: Annotated[list[PretrainingDataset | SFTDataset], MinLen(1)] | None
+  # 对于 PretrainingDataset:
+  name: str | None
+  path: str | None
+  split: str | None = train
+  text_column: str | None = text
+  type: str | None = pretrain
+  trust_remote_code: bool | None = False
+  data_files: str | None
+  skip: int | None
+
+  # 对于 SFTDataset:
+  # HuggingFace 数据集仓库 | s3:// | gs:// | 本地文件或目录的路径
+  path: str | None
+  # 要加载的数据集拆分的名称
+  split: str | None
+  # 训练要使用的提示词类型。[alpaca, gpteacher, oasst, reflection]
+  type: str | UserDefinedPrompterType | None
+    # 对于 UserDefinedPrompterType:
+    # 自定义用户指令提示词
+    system_prompt: str | None
+    # 使用 {system} 作为要替换的键
+    system_format: str | None
+    field_system: str | None
+    field_instruction: str | None
+    field_input: str | None
+    field_output: str | None
+
+    # 可自定义为单行或多行。使用 {instruction}/{input} 作为要替换的键。
+    # 'format' 可以包含 {input}
+    format: str | None
+    # 'no_input_format' 不能包含 {input}
+    no_input_format: str | None
+  input_transform: str | None
+  # 将数据集拆分为 N 份（与 shards_idx 配合使用）
+  shards: int | None
+  # 要使用的分片数据集的索引
+  shards_idx: int | None
+  # 为了内存效率，将数据集按 N 个连续块进行处理（与
+  # `shards` 互斥）
+  preprocess_shards: int | None
+  conversation: str | None
+
+  # 训练使用的聊天模板名称，支持以下值：
+  # tokenizer_default: 使用 tokenizer_config.json 中可用的聊天模板。
+  # 如果 tokenizer 中没有聊天模板，将引发错误。这是默认设置。
+  # alpaca/inst/chatml/gemma/cohere/llama3/phi_3/deepseek_v2/jamba: 这些聊天模板
+  # 可以在 axolotl 代码库的 src/axolotl/utils/chat_templates.py 中找到。
+  # tokenizer_default_fallback_*: 其中 * 是当 tokenizer 没有聊天模板时回退到的聊天模板名称，
+  # 否则默认使用 tokenizer。例如：tokenizer_default_fallback_chatml。
+  # jinja: 为聊天模板使用自定义的 jinja 模板。自定义 jinja 模板应该在 chat_template_jinja 字段中提供。
+  chat_template: ChatTemplate | str | None
+  # 自定义 jinja 聊天模板或 jinja 文件的路径。仅在 `chat_template:
+  # jinja` 或为空时使用。
+  chat_template_jinja: str | None
+  # 源数据文件的路径
+  data_files: str | list[str] | None
+  input_format: str | None
+  # 要加载的数据集配置名称
+  name: str | None
+  # 当 path 为文件时定义的数据类型
+  ds_type: str | None
+  # 仅适用于 `completion` 数据集，使用提供的字段而不是 `text` 列
+  field: str | None
+  field_human: str | None
+  field_model: str | None
+  # 包含消息的键（默认："messages"）
+  field_messages: str | None
+  # 包含工具的键（默认："tools"）。必须是 list[dict] 并且遵循 [JSON
+  # schema](https://json-schema.org/learn/getting-started-step-by-step)。
+  field_tools: str | None
+  # 包含推理轨迹的键（默认："reasoning_content"）。
+  field_thinking: str | None
+  # 聊天模板所期望的、指示推理轨迹的键。
+  template_thinking_key: str | None
+
+  message_field_role: str | None
+
+  message_field_content: str | None
+  # 将输入数据集的属性映射到聊天模板。（默认：
+  # message_property_mappings={'role':'role', 'content':'content'}）
+  # 如果模板中存在某属性但此映射中不存在，系统将尝试使用该属性名作为键直接从消息中加载。
+  # 示例：在下面的映射中，'from' 从输入数据集加载并用作 'role'，
+  # 而 'value' 加载并用作聊天模板中的 'content'。
+  message_property_mappings: dict[str, str] | None
+  # 消息轮次中的键，通过布尔值指示是否应考虑对该轮次进行训练。
+  # 除了 `roles_to_train` 之外，还可用于选择性地训练某些轮次。
+  message_field_training: str | None
+  # 消息轮次中包含训练细节的键。用于选择性地训练轮次中的某些 tokens。
+  # 该键的值是一个 List[Dict]，包含 `begin_offset`（内容中的起始字符索引）、
+  # `end_offset`（内容中的结束字符索引）和 `train`（指示是否训练的布尔值）。
+  message_field_training_detail: str | None
+  #（仅适用于 Qwen3 模板）是否根据包含在分隔标签内的推理轨迹来拆分助手内容
+  split_thinking: bool | None
+  logprobs_field: str | None
+  temperature: float | None
+  # 要训练的角色。来自这些角色的 tokens 将计入损失。
+  roles_to_train: list[str] | None
+  # 在对话中要训练哪些 EOS tokens。可能的值为：all：训练所有 EOS tokens，
+  # turn（默认）：训练每个可训练轮次结束时的 EOS token，
+  # last：训练对话中的最后一个 EOS token
+  train_on_eos: Literal['all', 'turn', 'last'] | None
+  # 消息中的角色映射。格式为 {target_role: [source_roles]}。所有
+  # 源角色将被映射到目标角色。默认为：user: ["human",
+  # "user"], assistant: ["gpt", "assistant"], system: ["system"], tool: ["tool"]
+  roles: dict[str, list[str]] | None
+  # 是否从数据集中丢弃系统轮次。仅适用于 chat_template。
+  # 如果存在，这不会从 chat_template 中丢弃默认系统消息。如果
+  # 您希望这样做，我们建议使用移除了默认系统消息的自定义 jinja 模板，
+  # 或者添加一个内容为空的系统轮次。
+  drop_system_message: bool | None
+  # 对不受信任的源信任远程代码
+  trust_remote_code: bool | None = False
+  # 从 Hugging Face Hub 加载时要使用的数据集特定版本。
+  # 这可以是提交哈希、标签或分支名称。如果未指定，将使用最新版本。
+  # 本地数据集将忽略此参数。
+  revision: str | None
+
+# 预处理输入数据集时使用的最大进程数。如果未设置，
+# 默认为 `os.cpu_count()`。对于 Runpod 虚拟机，它将通过 RUNPOD_CPU_COUNT 默认为 vCPU 的数量。
+dataset_processes: int | None
+# 预处理输入数据集时使用的最大进程数。如果未设置，
+# 默认为 `os.cpu_count()`。对于 Runpod 虚拟机，它将通过 RUNPOD_CPU_COUNT 默认为 vCPU 的数量。
+dataset_num_proc: int | None
+
+# 对具有相同条目的 datasets 和 test_datasets 进行去重
+dataset_exact_deduplication: bool | None
+# 在预处理期间将数据集保留在内存中。仅当缓存的数据集占用
+# 过多存储空间时才需要
+dataset_keep_in_memory: bool | None
+dataloader_pin_memory: bool | None
+dataloader_num_workers: int | None
+dataloader_prefetch_factor: int | None
+dataloader_drop_last: bool | None
+
+accelerator_config: dict[str, Any] | None
+
+remove_unused_columns: bool | None
+
+# 将准备好的数据集推送到中心仓库 - repo_org/repo_name
+push_dataset_to_hub: str | None
+# 加载数据集时是否使用 hf `use_auth_token`。适用于获取私有
+# 数据集。与 `push_dataset_to_hub` 结合使用时必须设置为 true
+hf_use_auth_token: bool | None
+
+device: Any | None
+# 在没有启动 accelerate 加载模型时直接传递给 transformers。
+# 在使用模型并行训练时使用 `sequential` 以限制内存
+device_map: Any | None
+world_size: int | None
+# 不要乱动这个，这是为 accelerate 和 torchrun 准备的
+local_rank: int | None
+ddp: bool | None
+
+# 用于可复现性的随机种子
+seed: int | None
+# 高级 DDP 参数 - 超时
+ddp_timeout: int | None
+# 高级 DDP 参数 - 桶容量上限（以 MB 为单位）
+ddp_bucket_cap_mb: int | None
+# 高级 DDP 参数 - 广播缓冲区
+ddp_broadcast_buffers: bool | None
+ddp_find_unused_parameters: bool | None
+
+# 取决于批次大小，发送到 wandb 的预测的大致数量。大于
+# 0 时启用。默认为 0
+eval_table_size: int | None
+# 发送到 wandb 的预测生成的 tokens 总数。默认为 128
+eval_max_new_tokens: int | None
+# 是否在 `eval_causal_lm_metrics` 中对指标运行因果语言模型评估
+do_causal_lm_eval: bool | None
+# 评估期间使用的 HF evaluate 指标。默认为 ['sacrebleu', 'comet', 'ter',
+# 'chrf', 'perplexity']
+eval_causal_lm_metrics: list[str] | None
+do_bench_eval: bool | None
+bench_dataset: str | None
+bench_split: str | None
+metric_for_best_model: str | None
+greater_is_better: bool | None
+
+# 高损失值，表明学习已经崩溃（一个较好的估计值是训练开始时损失的 2 倍）
+loss_watchdog_threshold: float | None
+# 训练器中止之前连续出现高损失的步数（默认：3）
+loss_watchdog_patience: int | None
+
+# 每 `gc_steps` 步运行一次垃圾回收。-1 将在 epoch 结束和评估之前运行。
+# 默认为 0（禁用）。
+gc_steps: int | None
+
+# 使用 CUDA bf16。bool 或 'full' 用于 `bf16_full_eval`，或 'auto' 用于自动检测。
+# 需要 >=ampere
+bf16: Literal['auto'] | bool | None = auto
+# 使用 CUDA fp16
+fp16: bool | None
+# 使用 TorchAO 启用 FP8 混合精度训练。最好与
+# torch.compile 结合使用。
+fp8: bool | None
+# 为 FP8 训练启用 FSDP float8 全聚合优化。在启用
+# FSDP 时可将训练速度提高 10-15%。
+fp8_enable_fsdp_float8_all_gather: bool | None
+# 无 AMP（自动混合精度）- 需要 >=ampere
+bfloat16: bool | None
+# 无 AMP（自动混合精度）
+float16: bool | None
+# 使用 CUDA tf32 - 需要 >=ampere
+tf32: bool | None
+float32: bool | None
+
+# 是否使用梯度检查点。可用选项有：true, false, 'offload',
+# 'offload_disk'。
+# https://huggingface.co/docs/transformers/v4.18.0
+
+## 
+
+**URL:** https://docs.axolotl.ai
+
+**Contents:**
+- 🎉 最新更新
+- ✨ 概览
+- 🚀 快速开始 - 几分钟内微调 LLM
+  - Google Colab
+  - 安装
+    - 使用 pip
+    - 使用 Docker
+    - 云服务商
+  - 你的第一次微调
+- 📚 文档
+
+一个免费且开源的 LLM 微调框架
+
+Axolotl 是一个免费且开源的工具，旨在简化最新大型语言模型的后训练与微调。
+
+使用 Docker 安装通常比在你自己的环境中安装更不容易出错。
+
+其他安装方法请见此处。
+
+就这些啦！请查看我们的《快速开始指南》以获取更详细的操作步骤。
+
+欢迎参与贡献！详情请参阅我们的贡献指南。
+
+有兴趣赞助吗？请通过 [email protected] 联系我们
+
+如果你在研究或项目中使用了 Axolotl，请按以下格式引用：
+
+本项目采用 Apache 2.0 许可证授权 - 详情请参阅 LICENSE 文件。
+
+**示例:**
+
+示例 1 (bash):
+```bash
+pip3 install -U packaging==23.2 setuptools==75.8.0 wheel ninja
+pip3 install --no-build-isolation axolotl[flash-attn,deepspeed]
+
+# Download example axolotl configs, deepspeed configs
+axolotl fetch examples
+axolotl fetch deepspeed_configs  # OPTIONAL
+```
+
+示例 2 (bash):
+```bash
+docker run --gpus '"all"' --rm -it axolotlai/axolotl:main-latest
+```
+
+示例 3 (bash):
+```bash
+# Fetch axolotl examples
+axolotl fetch examples
+
+# Or, specify a custom path
+axolotl fetch examples --dest path/to/folder
+
+# Train a model using LoRA
+axolotl train examples/llama-3/lora-1b.yml
+```
+
+示例 4 (unknown):
+```unknown
+@software{axolotl,
+  title = {Axolotl: Open Source LLM Post-Training},
+  author = {{Axolotl maintainers and contributors}},
+  url = {https://github.com/axolotl-ai-cloud/axolotl},
+  license = {Apache-2.0},
+  year = {2023}
+}
+```
+
+---
+
+## 快速开始
+
+**URL:** https://docs.axolotl.ai/docs/getting-started.html
+
+**Contents:**
+- 快速开始
+- 1 快速示例
+- 2 理解流程
+  - 2.1 配置文件
+  - 2.2 训练
+- 3 你的第一次自定义训练
+- 4 常见任务
+  - 4.1 测试你的模型
+  - 4.2 使用 UI
+  - 4.3 预处理数据
+
+本指南将带你完成使用 Axolotl 的第一个模型微调项目。
+
+让我们先从使用 LoRA 微调一个小型语言模型开始。此示例使用一个 10 亿 (1B) 参数的模型，以确保它能在大多数 GPU 上运行。假设你已经安装了 axolotl（如果没有，请参阅我们的安装指南）
+
+就这些啦！让我们来了解一下刚才发生了什么。
+
+YAML 配置文件控制着关于你训练的一切。以下是我们示例配置（部分）的样子：
+
+load_in_8bit: true 和 adapter: lora 启用了 LoRA 适配器微调。
+
+请参阅我们的配置选项以获取更多详细信息。
+
+当你运行 axolotl train 时，Axolotl 会：
+
+让我们为你的数据修改一下示例：
+
+这个特定的配置用于使用 alpaca 数据集格式（格式如下）对带有指令微调数据的模型进行 LoRA 微调：
+
+请参阅我们的《数据集格式》以获取更多数据集格式及其格式化方法。
+
+训练、推理和合并均使用同一个 yaml 文件。
+
+训练完成后，测试你的模型：
+
+更多详细信息可在推理中找到。
+
+启动 Gradio 界面：
+
+对于大型数据集，请先进行预处理：
+
+请确保在配置中设置 dataset_prepared_path:，以指定准备好的数据集的保存路径。
+
+更多详细信息可在数据集预处理中找到。
+
+要将 LoRA 权重合并回基础模型，请运行：
+
+合并后的模型将保存在 {output_dir}/merged 目录中。
+
+更多详细信息可在合并 LoRA 权重中找到。
+
+现在你已经掌握了基础知识，你可能想要：
+
+请查看我们的其他指南以获取有关这些主题的详细信息：
+
+**示例:**
+
+示例 1 (bash):
+```bash
+axolotl fetch examples
+```
+
+示例 2 (bash):
+```bash
+axolotl train examples/llama-3/lora-1b.yml
+```
+
+示例 3 (yaml):
+```yaml
+base_model: NousResearch/Llama-3.2-1B
+
+load_in_8bit: true
+adapter: lora
+
+datasets:
+  - path: teknium/GPT4-LLM-Cleaned
+    type: alpaca
+dataset_prepared_path: last_run_prepared
+val_set_size: 0.1
+output_dir: ./outputs/lora-out
+```
+
+示例 4 (yaml):
+```yaml
+base_model: NousResearch/Nous-Hermes-llama-1b-v1
+
+load_in_8bit: true
+adapter: lora
+
+# Training settings
+micro_batch_size: 2
+num_epochs: 3
+learning_rate: 0.0003
+
+# Your dataset
+datasets:
+  - path: my_data.jsonl        # Your local data file
+    type: alpaca               # Or other format
+```
+
+---
+
+## Multipack (样本打包)
+
+**URL:** https://docs.axolotl.ai/docs/multipack.html
+
+**Contents:**
+- Multipack (样本打包)
+- 使用 Flash Attention 的 Multipack 可视化
+- 不使用 Flash Attention 的 Multipack
+
+因为 Flash Attention 直接丢弃了注意力掩码，所以我们不需要构建 4D 注意力掩码。我们只需要将序列拼接成单个批次，并让 Flash Attention 知道每个新序列从哪里开始。
+
+4k 上下文，bsz =4，每个字符代表 256 个 Token，X 代表填充 Token
+
+在每步中对最长输入进行填充之后
+
+使用打包（注意，每步有效的 Token 数量相同，但实际 bsz 为 1）
+
+cu_seqlens: [[ 0, 11, 17, 24, 28, 36, 41 44, 48, 51, 55, 60, 64]]
+
+在没有 Flash Attention 的情况下仍然可以实现 Multipack，但打包效率较低，因为如果没有 Flash Attention，由于上下文长度限制，我们无法将多个批次合并为一个批次。我们可以使用 Pytorch 的缩放点积注意力实现或原生 Pytorch 注意力实现，并结合 4D 注意力掩码将序列打包在一起，从而避免交叉注意力。
+
+**示例:**
+
+示例 1 (unknown):
+```unknown
+0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
+[[ A A A A A A A A A A A ]
+   B B B B B B ]
+   C C C C C C C ]
+   D D D D ]]
+
+[[ E E E E E E E E ]
+ [ F F F F ]
+ [ G G G ]
+ [ H H H H ]]
+
+[[ I I I ]
+ [ J J J ]
+ [ K K K K K]
+ [ L L L ]]
+```
+
+示例 2 (unknown):
+```unknown
+0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
+[[ A A A A A A A A A A A ]
+   B B B B B B X X X X X X ]
+   C C C C C C C X X X X ]
+   D D D D X X X X X X X ]]
+
+[[ E E E E E E E E ]
+ [ F F F F X X X X ]
+ [ G G G X X X X X ]
+ [ H H H H X X X X ]]
+
+[[ I I I X X ]
+ [ J J J X X ]
+ [ K K K K K ]
+ [ L L L X X ]]
+```
+
+示例 3 (unknown):
+```unknown
+0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
+[[ A A A A A A A A A A A B B B B B
+   B C C C C C C C D D D D E E E E
+   E E E E F F F F F G G G H H H H
+   I I I J J J J K K K K K L L L X ]]
+```
+
+---
+
+## 批次大小与梯度累积
+
+**URL:** https://docs.axolotl.ai/docs/batch_vs_grad.html
+
+**Contents:**
+- 批次大小与梯度累积
+
+梯度累积是指在多个小批次上累积梯度，然后再更新模型权重。当每个批次中的样本具有多样性时，这种技术不会对学习产生显著影响。
+
+这种方法允许使用更大的有效批次大小进行有效训练，而不需要按比例增加内存。原因如下：
+
+批次大小对内存消耗的影响：增加批次大小影响内存的主要原因是存储中间激活值的需求。当你通过网络对一个批次进行前向传播时，你必须为批次中的每个样本在每一层存储激活值，因为这些激活值会在反向传播期间用于计算梯度。因此，更大的批次意味着更多的激活值，从而导致更高的 GPU 内存消耗。
+
+梯度累积：通过梯度累积，你可以通过在多个较小的批次（或微批次）上累积梯度来有效地模拟更大的批次大小。但是，在任何特定时间，你只对一个微批次进行前向和反向传播。这意味着你只需存储微批次的激活值，而不是完整的累积批次的激活值。因此，你可以模拟更大批次大小的效果，而不需要承担存储大批次激活值的内存成本。
+
+示例 1: 微批次大小: 3 梯度累积步数: 2 GPU 数量: 3 总批次大小 = 3 * 2 * 3 = 18
+
+示例 2: 微批次大小: 2 梯度累积步数: 1 GPU 数量: 3 总批次大小 = 2 * 1 * 3 = 6
+
+**示例:**
+
+示例 1 (unknown):
+```unknown
+| GPU 1          | GPU 2          | GPU 3          |
+|----------------|----------------|----------------|
+| S1, S2, S3     | S4, S5, S6     | S7, S8, S9     |
+| e1, e2, e3     | e4, e5, e6     | e7, e8, e9     |
+|----------------|----------------|----------------|
+| → (accumulate) | → (accumulate) | → (accumulate) |
+|----------------|----------------|----------------|
+| S10, S11, S12  | S13, S14, S15  | S16, S17, S18  |
+| e10, e11, e12  | e13, e14, e15  | e16, e17, e18  |
+|----------------|----------------|----------------|
+| → (apply)      | → (apply)      | → (apply)      |
+
+Accumulated gradient for the weight w1 after the second iteration (considering all GPUs):
+Total gradient for w1 = e1 + e2 + e3 + e4 + e5 + e6 + e7 + e8 + e9 + e10 + e11 + e12 + e13 + e14 + e15 + e16 + e17 + e18
+
+Weight update for w1:
+w1_new = w1_old - learning rate x (Total gradient for w1 / 18)
+```
+
+示例 2 (unknown):
+```unknown
+| GPU 1     | GPU 2     | GPU 3     |
+|-----------|-----------|-----------|
+| S1, S2    | S3, S4    | S5, S6    |
+| e1, e2    | e3, e4    | e5, e6    |
+|-----------|-----------|-----------|
+| → (apply) | → (apply) | → (apply) |
+
+Accumulated gradient for the weight w1 (considering all GPUs):
+Total gradient for w1 = e1 + e2 + e3 + e4 + e5 + e6
+
+Weight update for w1:
+w1_new = w1_old - learning rate × (Total gradient for w1 / 6)
+```
+
+---
+
+## 调试
+
+**URL:** https://docs.axolotl.ai/docs/debugging.html
+
+**Contents:**
+- 调试
+- 目录
+- 常规提示
+- 使用 VSCode 调试
+  - 背景
+  - 配置
+    - 远程主机
+  - 配置
+  - 自定义你的调试器
+  - 视频教程
+
+本文档提供了一些调试 Axolotl 的提示和技巧。它还提供了一个使用 VSCode 调试的示例配置。良好的调试设置对于理解 Axolotl 代码的幕后工作原理至关重要。
+
+在调试时，尽可能简化你的测试场景会很有帮助。以下是一些执行此操作的提示：
+
+[!重要] 所有这些提示都已整合到下面使用 VSCode 调试的示例配置中。
+
+确保你使用的是最新版本的 axolotl：这个项目变动频繁，且错误修复得很快。检查你的 git 分支并确保你已拉取了 main 分支的最新更改。
+
+消除并发：将训练和数据预处理的进程数限制为 1：
+
+使用小型数据集：构建或从 HF Hub 使用一个小型数据集。当使用小型数据集时，你通常必须确保 sample_packing: False 和 eval_sample_packing: False 以避免错误。如果你时间紧迫，没有时间构建小型数据集，但想使用 HF Hub 上的数据，你可以对数据进行分片（这仍会对整个数据集进行 Tokenize，但只会使用其中一部分数据进行训练。例如，要将数据集分为 20 个分片，请将以下内容添加到你的 axolotl 配置中）：
+
+使用小型模型：TinyLlama/TinyLlama-1.1B-Chat-v1.0 是一个小型模型的好例子。
+
+最小化迭代时间：使用这些设置，确保训练循环尽可能快地完成。
+
+清除缓存：Axolotl 会缓存某些步骤，底层的 HuggingFace 训练器也是如此。在调试时，你可能希望清除其中一些缓存。
+
+下面的示例展示了如何配置 VSCode 以调试 chat_template 格式的数据预处理。这是当你在 axolotl 配置中包含以下内容时使用的格式：
+
+[!重要] 如果你已经熟悉高级的 VSCode 调试，你可以跳过下面的解释，直接查看文件 .vscode/launch.json 和 .vscode/tasks.json 中的示例配置。
+
+[!提示] 如果你更喜欢看视频而不是阅读，你可以直接跳到下面的视频教程（但建议两者都做）。
+
+确保你已进行了 Axolotl 的可编辑安装，这能确保你对代码所做的更改能在运行时反映出来。在此项目的根目录下运行以下命令：
+
+如果你在远程主机上进行开发，你可以轻松地使用 VSCode 进行远程调试。为此，你需要遵循这个 Remote - SSH 指南。你也可以观看下面关于 Docker 和远程 SSH 调试的视频。
+
+最简单的入门方法是修改此项目中的 .vscode/launch.json 文件。这只是一个示例配置，因此你可能需要对其进行修改或复制以满足你的需求。
+
+例如，要模拟命令 cd devtools && CUDA_VISIBLE_DEVICES=0 accelerate launch -m axolotl.cli.train dev_chat_template.yml，你可以使用下面的配置 1。请注意，我们添加了额外的标志来覆盖 axolotl 配置，并结合了上述提示（参见注释）。我们还将工作目录设置为 devtools，并将环境变量 HF_HOME 设置为一个稍后会被部分删除的临时文件夹。这是因为我们希望在每次运行之前删除 HF 数据集缓存，以确保数据预处理代码是从头开始运行的。
+
+关于此配置的附加说明：
+
+[!提示] 你可能不想删除这些文件夹。例如，如果你在调试模型训练而不是数据预处理，你可能不想删除缓存或输出文件夹。根据你的使用情况，你可能还需要向 tasks.json 文件添加额外的任务。
+
+下面是定义了 cleanup-for-dataprep 任务的 ./vscode/tasks.json 文件。当你使用上述配置时，此任务会在每次调试会话之前运行。请注意这里有两个任务分别删除了上面提到的两个文件夹。第三个任务 cleanup-for-dataprep 是一个组合了这两个任务的复合任务。使用复合任务是必要的，因为 VSCode 不允许你在 launch.json 文件的 preLaunchTask 参数中指定多个任务。
+
+你的调试用例可能与上面的示例不同。最简单的做法是将你自己的 axolotl 配置放在 devtools 文件夹中，并修改 launch.json 文件以使用你的配置。你可能还希望修改 preLaunchTask 以删除不同的文件夹或根本不删除任何内容。
+
+下面的视频教程详细讲解了上述配置，并演示了如何使用 VSCode 进行调试（点击下方图片观看）：
+
+使用官方的 Axolotl Docker 镜像是调试代码的好方法，这也是使用 Axolotl 非常受欢迎的方式。将 VSCode 附加到 Docker 需要多几个步骤。
+
+在运行 axolotl 的主机上（例如：如果你使用的是远程主机），克隆 axolotl 仓库并将当前目录更改为根目录：
+
+[!提示] 如果你的主机上已经克隆了 axolotl，请确保你拥有最新更改，并进入项目的根目录。
+
+接下来，运行所需的 docker 镜像并挂载当前目录。下面是一个你可以运行以执行此操作的 docker 命令：2
+
+[!提示] 要了解有哪些可用的容器，请参阅 README 的 Docker 部分和 DockerHub 仓库。有关 Docker 容器是如何构建的详细信息，请参阅 axolotl 的 Docker CI 构建。
+
+你现在将进入容器中。接下来，执行 Axolotl 的可编辑安装：
+
+接下来，如果你使用的是远程主机，请使用 VSCode 远程连接到此主机。如果你使用的是本地主机，则可以跳过此步骤。
+
+接下来，在 VSCode 中使用命令面板 (CMD + SHIFT + P) 选择 Dev Containers: Attach to 运行 Container...。系统会提示你选择要附加到的容器。选择你刚刚创建的容器。你现在将位于容器中，工作目录即为项目的根目录。你对代码所做的任何更改都将反映在容器和主机上。
+
+现在你已准备好如上所述进行调试（请参阅使用 VSCode 调试）。
+
+这是一个短视频，演示了如何附加到远程主机上的 Docker 容器：
+
+该配置实际上模拟了命令 CUDA_VISIBLE_DEVICES=0 python -m accelerate.commands.launch -m axolotl.cli.train devtools/chat_template.yml，但两者是一样的。↩︎
+
+以下许多标志是 Nvidia 在使用 nvidia-container-toolkit 时推荐的最佳实践。你可以在这里阅读有关这些标志的更多信息。↩︎
+
+**示例:**
+
+示例 1 (yaml):
+```yaml
+datasets:
+    ...
+    shards: 20
+```
+
+示例 2 (yaml):
+```yaml
+datasets:
+  - path: <path to your chat_template formatted dataset> # example on HF Hub: fozziethebeat/alpaca_messages_2k_test
+    type: chat_template
+```
+
+示例 3 (bash):
+```bash
+pip3 install packaging
+pip3 install --no-build-isolation -e '.[flash-attn,deepspeed]'
+```
+
+示例 4 (json):
+```json
+// .vscode/launch.json
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Debug axolotl prompt - chat_template",
+            "type": "python",
+            "module": "accelerate.commands.launch",
+            "request": "launch",
+            "args": [
+                "-m", "axolotl.cli.train", "dev_chat_template.yml",
+                // The flags below simplify debugging by overriding the axolotl config
+                // with the debugging tips above.  Modify as needed.
+                "--dataset_num_proc=1",      // limits data preprocessing to one process
+                "--max_steps=1",              // limits training to just one step
+                "--batch_size=1",             // minimizes batch size
+                "--micro_batch_size=1",       // minimizes batch size
+                "--val_set_size=0",           // disables validation
+                "--sample_packing=False",     // disables sample packing which is necessary for small datasets
+                "--eval_sample_packing=False",// disables sample packing on eval set
+                "--dataset_prepared_path=temp_debug/axolotl_outputs/data", // send data outputs to a temp folder
+                "--output_dir=temp_debug/axolotl_outputs/model" // send model outputs to a temp folder
+                ],
+            "console": "integratedTerminal",      // show output in the integrated terminal
+            "cwd": "${workspaceFolder}/devtools", // set working directory to devtools from the root of the project
+            "justMyCode": true,                   // step through only axolotl code
+            "env": {"CUDA_VISIBLE_DEVICES": "0",  // Since we aren't doing distributed training, we need to limit to one GPU
+                    "HF_HOME": "${workspaceFolder}/devtools/temp_debug/.hf-cache"}, // send HF cache to a temp folder
+            "preLaunchTask": "cleanup-for-dataprep", // delete temp folders (see below)
+        }
+    ]
+}
+```
+
+---
+
+## Docker
+
+**URL:** https://docs.axolotl.ai/docs/docker.html
+
+**Contents:**
+- Docker
+- Base
+    - Image
+    - Tags format
+- Main
+    - Image
+    - Tags format
+- Cloud
+    - Image
+    - Tags format
+
+本节介绍了 AxolotlAI 在 Docker Hub 上发布的不同 Docker 镜像。
+
+对于 Blackwell GPU，请使用带有 PyTorch 2.7.1 和 CUDA 12.8 的标签。
+
+基础镜像是可以安装 Axolotl 的最小化镜像。它基于 nvidia/cuda 镜像。它包含 python、torch、git、git-lfs、awscli、pydantic 等。
+
+主镜像是用于运行 Axolotl 的镜像。它基于 axolotlai/axolotl-base 镜像，包含 Axolotl 代码库、依赖项等。
+
+镜像后可能附加了一些额外的标签，例如 -vllm，用于安装这些软件包。
+
+云镜像是用于在云中运行 Axolotl 的镜像。它基于 axolotlai/axolotl 镜像，并为不同的云提供商设置了 ENV 变量，例如用于卷挂载的 HuggingFace 缓存目录、tmux 等。
+
+Jupyter lab 默认会运行。在环境变量中设置 JUPYTER_DISABLE=1 可禁用它。
+
+这里使用与主镜像相同的标签。
+
+我们建议将卷挂载到 /workspace/data 以实现数据持久化。/workspace/axolotl 包含源代码，并且是临时的。
+
+这与云镜像相同，但没有 tmux。
+
+命名可能有点令人困惑，因为它的末尾附加了 -term。
+
+这里使用与云镜像相同的标签。
+
+**示例:**
+
+示例 1 (unknown):
+```unknown
+axolotlai/axolotl-base
+```
+
+示例 2 (bash):
+```bash
+main-base-py{python_version}-cu{cuda_version}-{pytorch_version}
+```
+
+示例 3 (unknown):
+```unknown
+axolotlai/axolotl
+```
+
+示例 4 (bash):
+```bash
+# on push to main
+main-py{python_version}-cu{cuda_version}-{pytorch_version}
+
+# latest main (currently torch 2.6.0, python 3.11, cuda 12.4)
+main-latest
+
+# nightly build
+{branch}-{date_in_YYYYMMDD}-py{python_version}-cu{cuda_version}-{pytorch_version}
+
+# tagged release
+{version}
+```