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

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

{% hint style="info" %}
**Дообучение** адаптирует предварительно обученную LLM под вашу конкретную задачу или домен. Это руководство сравнивает четыре ведущих открытых инструмента: Unsloth, Axolotl, LLaMA-Factory и TRL — охватывая скорость, эффективность памяти, поддерживаемые модели и простоту использования.
{% endhint %}

***

## Краткая матрица принятия решений

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

***

## Обзор

### Unsloth

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

**Философия**: Максимальная скорость, минимальное использование VRAM — без компромиссов.

```python
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, при этом под капотом полная гибкость.

```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+) и методов обучения, с веб-интерфейсом для конфигурации. Это наиболее доступный вариант для не исследователей.

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

```bash
# Обучение через командную строку
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 и других методов выравнивания.

**Философия**: В первую очередь для исследований, выравнивание встроено нативно.

```python
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

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

{% hint style="success" %}
**Преимущество Unsloth реально**: Скорость 2-5× достигается за счёт кастомных Triton-ядр для attention, cross-entropy, RoPE и LoRA. Это не просто маркетинг.
{% endhint %}

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

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

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

**Минимальная видеокарта для модели 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 и LoRA на Triton
2. **Слитые операции**: Объединяет несколько CUDA-операций в одно ядро
3. **Умная проверка градиентов (gradient checkpointing)**: Режим "unsloth" сохраняет примерно на 30% больше памяти
4. **Эффективный обратный проход**: Избегает материализации больших промежуточных тензоров

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

```bash
# CUDA 12.1
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
```

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

```python
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"### Instruction:\n{example['instruction']}\n\n### Response:\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 проявляет силу, когда нужны воспроизводимые, версионируемые конфигурации обучения:

```yaml
# 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
```

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

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

***

## LLaMA-Factory: подробности

### Обзор WebUI

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

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

Вкладки WebUI:

1. **Train** — настройка базовой модели, датасета, метода
2. **Оценка** — запуск бенчмарков MMLU, CMMLU
3. **Чат** — интерактивный вывод
4. **Экспорт** — объединение LoRA, квантование в GGUF

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

```bash
# Супервизированное дообучение
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 — стандарт для обучения выравниванию:

```python
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 + выбранный + отклонённый)
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 ноутбуки                      |
| ML-инженер                   | Axolotl       | Управление через конфигурации, воспроизводимость |
| Продуктовая команда          | LLaMA-Factory | WebUI, широкая поддержка моделей                 |
| Команда по выравниванию      | TRL           | Нативные примитивы RLHF                          |
| Стартап                      | Unsloth + TRL | Скорость + выравнивание при необходимости        |

***

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

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

***

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

* [Unsloth на GitHub](https://github.com/unslothai/unsloth) — 23K+ звёзд
* [Axolotl на GitHub](https://github.com/axolotl-ai-cloud/axolotl) — 9K+ звёзд
* [LLaMA-Factory на GitHub](https://github.com/hiyouga/LLaMA-Factory) — 37K+ звёзд
* [TRL на GitHub](https://github.com/huggingface/trl) — 10K+ звёзд
* [Документация HuggingFace PEFT](https://huggingface.co/docs/peft)

***

## Резюме

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

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


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-ru/sravneniya/finetuning-comparison.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.