Сравнение инструментов дообучения

Выберите подходящий фреймворк для дообучения при обучении LLM на GPU-серверах Clore.ai.

Дообучение адаптирует предварительно обученную LLM под вашу конкретную задачу или предметную область. В этом руководстве сравниваются четыре ведущих open-source инструмента: Unsloth, Axolotl, LLaMA-Factory и TRL — с точки зрения скорости, эффективности использования памяти, поддерживаемых моделей и простоты использования.

---

Быстрая матрица выбора

	Unsloth	Axolotl	LLaMA-Factory	TRL
Лучше всего для	Скорость + память	Обучение на основе конфигурации	Подходит новичкам	Исследования + RLHF
Скорость по сравнению с базовым вариантом	в 2–5 раз быстрее	~1× (стандарт)	~1× (стандарт)	~1× (стандарт)
Снижение использования памяти	на 70–80% меньше	QLoRA — стандарт	QLoRA — стандарт	Стандартный
RLHF/DPO/PPO	Базовый	✅	✅	✅ (родная поддержка)
WebUI	❌	❌	✅	❌
Звёзды на GitHub	23K+	9K+	37K+	10K+
Лицензия	LGPL (бесплатно для некоммерческого использования)	Apache 2.0	Apache 2.0	Apache 2.0

---

Обзор

Unsloth

Unsloth сосредоточен на одной задаче: сделать дообучение максимально быстрым и экономным по памяти. Он переписывает ключевые операции на Triton и оптимизирует CUDA-ядра.

Философия: Максимальная скорость, минимум VRAM — никаких компромиссов.

from unsloth import FastLanguageModel
import torch

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Llama-3.2-8B-Instruct",
    max_seq_length=2048,
    load_in_4bit=True,  # 4-битная квантизация
)

model = FastLanguageModel.get_peft_model(
    model,
    r=16,              # ранг LoRA
    target_modules=["q_proj", "k_proj", "v_proj", "up_proj", "down_proj"],
    lora_alpha=16,
    lora_dropout=0,
    bias="none",
    use_gradient_checkpointing="unsloth",  # примерно на 30% больше размер батча
    random_state=42,
)

Axolotl

Axolotl оборачивает HuggingFace Transformers в систему конфигурации на основе YAML. Он берёт на себя сложность настройки обучения, чтобы вы могли сосредоточиться на данных и гиперпараметрах.

Философия: Всё в YAML, полная гибкость под капотом.

# config.yml
base_model: meta-llama/Meta-Llama-3-8B
model_type: LlamaForCausalLM
tokenizer_type: AutoTokenizer

datasets:
  - path: mhenrichsen/alpaca_data_cleaned
    type: alpaca

load_in_4bit: true
adapter: qlora

lora_r: 32
lora_alpha: 16
lora_target_modules:
  - q_proj
  - k_proj
  - v_proj
  - o_proj

num_epochs: 3
micro_batch_size: 2
gradient_accumulation_steps: 4
learning_rate: 2e-4

LLaMA-Factory

LLaMA-Factory поддерживает самый широкий спектр моделей (100+) и методов обучения, а также имеет WebUI для настройки. Это самый доступный вариант для не-исследователей.

Философия: Всё работает для всех.

# Обучение через командную строку
llamafactory-cli train \\
  --model_name_or_path meta-llama/Meta-Llama-3-8B \\
  --stage sft \\
  --do_train \\
  --dataset alpaca_gpt4_en \\
  --template llama3 \\
  --finetuning_type lora \\
  --lora_rank 8 \\
  --output_dir saves/llama3-8b-lora \\
  --num_train_epochs 3.0 \\
  --per_device_train_batch_size 2

# Или используйте WebUI
llamafactory-cli webui

TRL (Transformer Reinforcement Learning)

TRL — официальная библиотека HuggingFace для RLHF. Это стандарт для PPO, DPO, ORPO и других методов выравнивающего обучения.

Философия: В первую очередь для исследований, с родной поддержкой выравнивающего обучения.

from trl import SFTTrainer, SFTConfig
from transformers import AutoModelForCausalLM, AutoTokenizer
from datasets import load_dataset

model = AutoModelForCausalLM.from_pretrained("meta-llama/Meta-Llama-3-8B")
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Meta-Llama-3-8B")

training_args = SFTConfig(
    output_dir="./results",
    num_train_epochs=3,
    per_device_train_batch_size=2,
    gradient_accumulation_steps=4,
    learning_rate=2e-4,
    logging_steps=10,
)

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    args=training_args,
    train_dataset=load_dataset("tatsu-lab/alpaca", split="train"),
)

trainer.train()

---

Бенчмарки скорости

Сравнение скорости обучения (токенов/сек)

Тестовая конфигурация: LLaMA 3.1 8B, LoRA r=16, 4-битная квантизация, размер батча 4, A100 80GB

Инструмент	Токенов/сек	по сравнению с базовым вариантом	Память (VRAM)
Unsloth (4-бит)	~4,200	2.8×	~8 ГБ
Axolotl (QLoRA)	~1,500	1.0×	~16 ГБ
LLaMA-Factory (QLoRA)	~1,480	~1.0×	~16 ГБ
TRL (QLoRA)	~1,450	~0.97×	~18GB
Unsloth (полный 16-битный режим)	~2,800	1.9×	~22 ГБ

Преимущество Unsloth реально: Ускорение в 2–5 раз достигается за счёт кастомных Triton-ядр для attention, cross-entropy, RoPE и LoRA. Это не просто маркетинг.

Сравнение использования VRAM

Обучение LLaMA 3.1 8B, длина последовательности 2048:

Метод	Unsloth	Axolotl	LLaMA-Factory	TRL
Полное дообучение (bf16)	60 ГБ	70 ГБ	72 ГБ	74GB
LoRA (bf16)	18 ГБ	24 ГБ	25 ГБ	26 ГБ
QLoRA (4-bit)	8 ГБ	16GB	16GB	18 ГБ
QLoRA (4-бит, длинный контекст)	12GB	24 ГБ	24 ГБ	26 ГБ

Минимальная GPU для модели 8B:

• Unsloth: RTX 3080 (10GB) ✅

• Другие: требуется RTX 3090 (24GB)

---

Поддерживаемые модели

Матрица поддержки моделей

Семейство моделей	Unsloth	Axolotl	LLaMA-Factory	TRL
LLaMA 3.x	✅	✅	✅	✅
LLaMA 2	✅	✅	✅	✅
Mistral	✅	✅	✅	✅
Mixtral MoE	✅	✅	✅	✅
Gemma 2	✅	✅	✅	✅
Phi-3/3.5	✅	✅	✅	✅
Qwen 2.5	✅	✅	✅	✅
DeepSeek	✅	✅	✅	✅
Falcon	✅	✅	✅	✅
GPT-NeoX	Частично	✅	✅	✅
T5/FLAN	❌	✅	✅	✅
BERT/RoBERTa	❌	✅	✅	✅
Vision LLMs	Частично	Частично	✅	✅

Поддержка методов обучения

Метод	Unsloth	Axolotl	LLaMA-Factory	TRL
Полное дообучение	✅	✅	✅	✅
LoRA	✅	✅	✅	✅
QLoRA	✅	✅	✅	✅
DoRA	✅	✅	✅	❌
PEFT	✅	✅	✅	✅
SFT	✅	✅	✅	✅ (родная поддержка)
DPO	✅	✅	✅	✅ (родная поддержка)
PPO	❌	✅	✅	✅ (родная поддержка)
ORPO	✅	✅	✅	✅
KTO	❌	✅	✅	✅ (родная поддержка)
GRPO	✅	❌	✅	✅
CPT (продолженное предварительное обучение)	✅	✅	✅	✅

---

Unsloth: подробный разбор

Что делает его быстрым

1. Triton-ядра: Переписывает Flash Attention, cross-entropy loss и LoRA на Triton

2. Слитые операции: Объединяет несколько CUDA-операций в одно ядро

3. Умное checkpointing градиентов: Режим "unsloth" экономит примерно на 30% больше памяти

4. Эффективный backprop: Избегает материализации больших промежуточных тензоров

Установка на Clore.ai

# CUDA 12.8
pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
pip install --no-deps trl peft accelerate bitsandbytes

# Или через conda
conda create --name unsloth_env python=3.11
conda activate unsloth_env
conda install pytorch-cuda=12.1 pytorch cudatoolkit xformers -c pytorch -c nvidia -c xformers -y
pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
pip install --no-deps trl peft accelerate bitsandbytes

Полный скрипт обучения

from unsloth import FastLanguageModel
from trl import SFTTrainer
from transformers import TrainingArguments
from datasets import load_dataset
import torch

# 1. Загрузите модель с оптимизацией Unsloth
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Meta-Llama-3.1-8B-Instruct",
    max_seq_length=2048,
    dtype=None,        # автоопределение
    load_in_4bit=True,
)

# 2. Добавьте адаптер LoRA
model = FastLanguageModel.get_peft_model(
    model,
    r=16,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                    "gate_proj", "up_proj", "down_proj"],
    lora_alpha=16,
    lora_dropout=0,
    bias="none",
    use_gradient_checkpointing="unsloth",
    random_state=3407,
)

# 3. Загрузите и отформатируйте датасет
dataset = load_dataset("tatsu-lab/alpaca", split="train")

def format_prompt(example):
    return {"text": f"### Инструкция:\n{example['instruction']}\n\n### Ответ:\n{example['output']}"}

dataset = dataset.map(format_prompt)

# 4. Обучение
trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=2048,
    args=TrainingArguments(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        warmup_steps=5,
        num_train_epochs=1,
        learning_rate=2e-4,
        fp16=not torch.cuda.is_bf16_supported(),
        bf16=torch.cuda.is_bf16_supported(),
        logging_steps=1,
        optim="adamw_8bit",
        weight_decay=0.01,
        lr_scheduler_type="linear",
        seed=3407,
        output_dir="outputs",
    ),
)
trainer.train()

# 5. Сохранение
model.save_pretrained("lora_model")
model.save_pretrained_gguf("model_gguf", tokenizer, quantization_method="q4_k_m")

Недостатки: Нет PPO, ограничено списком поддерживаемых моделей, лицензия LGPL (проверьте возможность коммерческого использования)

---

Axolotl: подробный разбор

Подход, основанный на конфигурации

Axolotl особенно хорош, когда вам нужны воспроизводимые конфигурации обучения с версионированием:

# axolotl_config.yml — полный пример
base_model: meta-llama/Meta-Llama-3-8B-Instruct
model_type: LlamaForCausalLM
tokenizer_type: AutoTokenizer

# Данные
datasets:
  - path: tatsu-lab/alpaca
    type: alpaca
  - path: ./my_custom_data.jsonl
    type: sharegpt
dataset_prepared_path: ./prepared_data
val_set_size: 0.01

# Квантизация
load_in_4bit: true
adapter: qlora
bf16: true
tf32: true

# LoRA
lora_r: 32
lora_alpha: 16
lora_dropout: 0.05
lora_target_modules:
  - q_proj
  - v_proj
  - k_proj
  - o_proj
  - gate_proj
  - up_proj
  - down_proj

# Обучение
sequence_len: 4096
sample_packing: true  # упаковывает короткие последовательности для повышения эффективности
pad_to_sequence_len: true
micro_batch_size: 2
gradient_accumulation_steps: 4
num_epochs: 3
learning_rate: 0.0002
optimizer: adamw_bnb_8bit
lr_scheduler: cosine

# Логирование
logging_steps: 10
eval_steps: 100
save_steps: 100
output_dir: ./outputs/my-model

# wandb
wandb_project: my-fine-tune
wandb_run_id: run-001

# Установка и запуск
pip install axolotl[flash-attn,deepspeed]
axolotl train axolotl_config.yml

Лучше всего для: Команды, которым нужны воспроизводимые запуски обучения с версионированием конфигураций

---

LLaMA-Factory: подробный разбор

Пошаговый разбор WebUI

# Установка
pip install llamafactory

# Запустите WebUI
llamafactory-cli webui
# Откройте http://localhost:7860

Вкладки WebUI:

1. Обучение — настройка базовой модели, датасета, метода

2. Оценка — запуск бенчмарков MMLU, CMMLU

3. Чат — интерактивный инференс

4. Экспорт — объединение LoRA, квантизация в GGUF

Пример обучения через CLI

# Supervised Fine-Tuning
llamafactory-cli train \\
  --stage sft \\
  --model_name_or_path meta-llama/Meta-Llama-3-8B \\
  --dataset alpaca_gpt4_en,glaive_toolcall_en \\
  --template llama3 \\
  --finetuning_type lora \\
  --lora_rank 8 \\
  --lora_alpha 16 \\
  --lora_target all \\
  --output_dir saves/llama3-lora \\
  --num_train_epochs 3 \\
  --per_device_train_batch_size 2 \\
  --gradient_accumulation_steps 4 \\
  --learning_rate 2e-4 \\
  --quantization_bit 4 \\
  --flash_attn fa2

# Обучение DPO
llamafactory-cli train \\
  --stage dpo \\
  --model_name_or_path meta-llama/Meta-Llama-3-8B \\
  --dataset dpo_mix_en \\
  --template llama3 \\
  --finetuning_type lora \\
  --output_dir saves/llama3-dpo

Лучше всего для: Новички, команды, которым нужен WebUI, DPO/RLHF без глубоких исследовательских знаний

---

TRL: подробный разбор

Пример конвейера RLHF

TRL — лучший выбор для выравнивающего обучения:

from trl import PPOTrainer, PPOConfig, AutoModelForCausalLMWithValueHead
from trl import DPOTrainer, DPOConfig
from datasets import load_dataset

# DPO (Direct Preference Optimization) — самый распространённый метод выравнивания
model_name = "meta-llama/Meta-Llama-3-8B-Instruct"

dpo_config = DPOConfig(
    model_name_or_path=model_name,
    output_dir="dpo_outputs",
    num_train_epochs=1,
    per_device_train_batch_size=2,
    beta=0.1,             # коэффициент штрафа KL
    loss_type="sigmoid",  # или "hinge", "ipo", "kto_pair"
    learning_rate=5e-7,
)

# Загрузите датасет предпочтений (prompt + chosen + rejected)
dataset = load_dataset("Anthropic/hh-rlhf", split="train")

trainer = DPOTrainer(
    model=model_name,
    args=dpo_config,
    train_dataset=dataset,
)
trainer.train()

Лучше всего для: Исследования по выравниванию, RLHF, DPO, PPO, реализации ORPO

---

Выбор подходящего инструмента

Схема принятия решения

Нужны максимальная скорость и минимум VRAM?
  → ДА → Unsloth (в 2–5 раз быстрее, работает на более маленьких GPU)

Нужно обучение выравниванию (DPO/PPO/RLHF)?
  → ДА → TRL или LLaMA-Factory
  → Для исследований/кастомизации → TRL
  → Для продакшена/простоты → LLaMA-Factory

Нужна воспроизводимость на основе конфигурации?
  → ДА → Axolotl

Нетехническая команда или нужен WebUI?
  → ДА → LLaMA-Factory

Просто хотите быстро начать?
  → LLaMA-Factory или Unsloth

По типу команды

Команда	Рекомендация	Причина
Индивидуальный исследователь	Unsloth	Скорость + Jupyter notebooks
ML-инженер	Axolotl	На основе конфигурации, воспроизводимо
Продуктовая команда	LLaMA-Factory	WebUI, широкая поддержка моделей
Команда по выравниванию	TRL	Нативные примитивы RLHF
Стартап	Unsloth + TRL	Скорость + выравнивание при необходимости

---

Рекомендации по GPU для Clore.ai

Многопроцессорные конфигурации с GPU класса 80GB не представлены на маркетплейсе Clore.ai. Самые крупные доступные сейчас машины — это 4× RTX PRO 6000 Blackwell (по 96GB, всего 380GB) и 8–11× RTX 5090 (по 32GB). Ёмкость A100 / H200 / B200 продаётся как голое железо по запросу. Проверьте Цены и доступность GPU перед выбором размера развёртывания.

Задача	Мин. GPU	Рекомендуется	Инструмент
7-8B LoRA (QLoRA)	RTX 3080 (10GB)	RTX 3090	Unsloth
13B LoRA	RTX 3090 (24 ГБ)	A6000 (48 ГБ)	Unsloth/Axolotl
70B LoRA	A100 (80 ГБ)	2×A100	Axolotl/TRL
8B Full FT	A100 (40GB)	A100 (80 ГБ)	Любой
DPO/PPO 7B	RTX 4090 (24 ГБ)	A6000 (48 ГБ)	TRL

---

Полезные ссылки

• GitHub Unsloth — 23K+ звёзд

• GitHub Axolotl — 9K+ звёзд

• GitHub LLaMA-Factory — 37K+ звёзд

• GitHub TRL — 10K+ звёзд

• Документация HuggingFace PEFT

---

Итог

Инструмент	Лучше всего для	Ключевое преимущество
Unsloth	Обучение, критичное к скорости, маленькие GPU	в 2–5 раз быстрее, на 70% меньше VRAM
Axolotl	Запуски на основе конфигурации, воспроизводимость	Сначала YAML, много форматов данных
LLaMA-Factory	100+ моделей, WebUI, для новичков	Максимальная поддержка моделей, GUI
TRL	RLHF, DPO, исследования по выравниванию	Нативное обучение выравниванию

Для большинства сценариев использования Clore.ai: начните с Unsloth (скорость + эффективность памяти), добавьте TRL если вам нужно обучение выравниванию DPO или PPO.