> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-ru/sravneniya/finetuning-comparison.md).

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

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

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

***

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

|                                               | 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 — никаких компромиссов.

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

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

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

| Инструмент                       | Токенов/сек | по сравнению с базовым вариантом | Память (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 ГБ       |

{% 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)        | 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

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

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

```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"### Инструкция:\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 особенно хорош, когда вам нужны воспроизводимые конфигурации обучения с версионированием:

```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. **Обучение** — настройка базовой модели, датасета, метода
2. **Оценка** — запуск бенчмарков MMLU, CMMLU
3. **Чат** — интерактивный инференс
4. **Экспорт** — объединение LoRA, квантизация в GGUF

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

```bash
# 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 — лучший выбор для выравнивающего обучения:

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

{% hint style="warning" %}
**Многопроцессорные конфигурации с GPU класса 80GB не представлены на маркетплейсе Clore.ai.** Самые крупные доступные сейчас машины — это 4× RTX PRO 6000 Blackwell (по 96GB, всего 380GB) и 8–11× RTX 5090 (по 32GB). Ёмкость A100 / H200 / B200 продаётся как [голое железо](https://clore.ai/bare-metal) по запросу. Проверьте [Цены и доступность GPU](/guides/guides_v2-ru/nachalo-raboty/pricing.md) перед выбором размера развёртывания.
{% endhint %}

| Задача            | Мин. 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](https://github.com/unslothai/unsloth) — 23K+ звёзд
* [GitHub Axolotl](https://github.com/axolotl-ai-cloud/axolotl) — 9K+ звёзд
* [GitHub LLaMA-Factory](https://github.com/hiyouga/LLaMA-Factory) — 37K+ звёзд
* [GitHub TRL](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
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.