> 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/obuchenie/unsloth-finetune.md).

# Дообучение Unsloth в 2 раза быстрее

Unsloth переписывает критичные для производительности части HuggingFace Transformers с помощью вручную оптимизированных ядер Triton, обеспечивая **ускорение обучения в 2 раза** и **снижение потребления VRAM на 70%** без потери точности. Это полная замена — ваши существующие скрипты TRL/PEFT работают без изменений после замены импорта.

{% hint style="success" %}
Все примеры работают на GPU-серверах, арендованных через [маркетплейс CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

## Ключевые особенности

* **обучение в 2 раза быстрее** — пользовательские ядра Triton для attention, RoPE, cross-entropy и RMS norm
* **на 70% меньше VRAM** — интеллектуальный gradient checkpointing и веса с отображением в память
* **Полная замена HuggingFace без изменений** — одно изменение импорта, и ничего больше
* **QLoRA / LoRA / полное дообучение** — все режимы поддерживаются из коробки
* **Нативный экспорт** — сохранение напрямую в GGUF (все типы квантизации), адаптеры LoRA или объединённый 16-битный формат
* **Широкая поддержка моделей** — Llama 3.x, Mistral, Qwen 2.5, Gemma 2, DeepSeek-R1, Phi-4 и другие
* **Бесплатно и с открытым исходным кодом** (Apache 2.0)

## Требования

| Компонент | Минимум        | Рекомендуется  |
| --------- | -------------- | -------------- |
| GPU       | RTX 3060 12 ГБ | RTX 4090 24 GB |
| VRAM      | 10 ГБ          | 24 ГБ          |
| ОЗУ       | 16 ГБ          | 32 ГБ          |
| Диск      | 40 ГБ          | 80 ГБ          |
| CUDA      | 12.8+          | 12.8+          |
| Python    | 3.10           | 3.11           |

**Цены Clore.ai:** RTX 4090 ≈ $0.14–0.42/ч · RTX 3090 ≈ $0.07–0.21/ч · RTX 3060 ≈ $0.03–0.07/ч

Модель 7B с 4-битным QLoRA помещается в **\~10 ГБ VRAM**, что делает даже RTX 3060 вполне пригодной.

## Быстрый старт

### 1. Установите Unsloth

```bash
# Создайте venv (рекомендуется)
python -m venv /workspace/unsloth-env
source /workspace/unsloth-env/bin/activate

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

### 2. Загрузите модель с 4-битной квантизацией

```python
from unsloth import FastLanguageModel
import torch

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Meta-Llama-3.1-8B-Instruct-bnb-4bit",
    max_seq_length=2048,
    dtype=None,            # автоопределение (float16 на Ampere, bfloat16 на Ada)
    load_in_4bit=True,
)
```

### 3. Примените адаптеры LoRA

```python
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",   # снижение VRAM на 70%
    random_state=42,
    use_rslora=False,
    loftq_config=None,
)
```

### 4. Подготовьте данные и запустите обучение

```python
from datasets import load_dataset
from trl import SFTTrainer
from transformers import TrainingArguments

dataset = load_dataset("yahma/alpaca-cleaned", split="train")

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=2048,
    dataset_num_proc=2,
    packing=True,
    args=TrainingArguments(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        warmup_steps=10,
        num_train_epochs=1,
        learning_rate=2e-4,
        fp16=not torch.cuda.is_bf16_supported(),
        bf16=torch.cuda.is_bf16_supported(),
        logging_steps=10,
        optim="adamw_8bit",
        weight_decay=0.01,
        lr_scheduler_type="linear",
        seed=42,
        output_dir="/workspace/outputs",
    ),
)

stats = trainer.train()
print(f"Training loss: {stats.training_loss:.4f}")
```

## Экспорт модели

### Сохранить только адаптер LoRA

```python
model.save_pretrained("/workspace/lora-adapter")
tokenizer.save_pretrained("/workspace/lora-adapter")
```

### Объединить и сохранить полную модель (float16)

```python
model.save_pretrained_merged(
    "/workspace/merged-model",
    tokenizer,
    save_method="merged_16bit",
)
```

### Экспорт в GGUF для Ollama / llama.cpp

```python
# Квантование в Q4_K_M (хороший баланс размера и качества)
model.save_pretrained_gguf(
    "/workspace/gguf-output",
    tokenizer,
    quantization_method="q4_k_m",
)

# Другие варианты: q5_k_m, q8_0, f16
```

После экспорта запустите через Ollama:

```bash
# Создайте modelfile для Ollama
cat > Modelfile <<EOF
FROM /workspace/gguf-output/unsloth.Q4_K_M.gguf
TEMPLATE "{{ .System }}\n{{ .Prompt }}"
PARAMETER temperature 0.7
EOF

ollama create my-finetuned -f Modelfile
ollama run my-finetuned "Summarize the key points of transformers architecture"
```

## Примеры использования

### Дообучение на пользовательском чат-датасете

```python
from unsloth.chat_templates import get_chat_template

tokenizer = get_chat_template(tokenizer, chat_template="llama-3.1")

def format_chat(example):
    messages = [
        {"role": "system", "content": "Вы — полезный помощник."},
        {"role": "user", "content": example["instruction"]},
        {"role": "assistant", "content": example["output"]},
    ]
    return {"text": tokenizer.apply_chat_template(messages, tokenize=False)}

dataset = dataset.map(format_chat)
```

### Обучение согласованию DPO / ORPO

```python
from trl import DPOTrainer, DPOConfig

dpo_trainer = DPOTrainer(
    model=model,
    ref_model=None,          # Unsloth обрабатывает референсную модель внутри
    args=DPOConfig(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        learning_rate=5e-6,
        num_train_epochs=1,
        beta=0.1,
        output_dir="/workspace/dpo-output",
    ),
    train_dataset=dpo_dataset,
    tokenizer=tokenizer,
)
dpo_trainer.train()
```

## Справочник по использованию VRAM

| Модель         | Квант  | Метод | VRAM    | GPU         |
| -------------- | ------ | ----- | ------- | ----------- |
| Llama 3.1 8B   | 4-бит  | QLoRA | \~10 ГБ | RTX 3060    |
| Llama 3.1 8B   | 16-бит | LoRA  | \~18 ГБ | RTX 3090    |
| Qwen 2.5 14B   | 4-бит  | QLoRA | \~14 ГБ | RTX 3090    |
| Mistral 7B     | 4-бит  | QLoRA | \~9 ГБ  | RTX 3060    |
| DeepSeek-R1 7B | 4-бит  | QLoRA | \~10 ГБ | RTX 3060    |
| Llama 3.3 70B  | 4-бит  | QLoRA | \~44 ГБ | 2× RTX 3090 |

## Советы

* **Всегда используйте `use_gradient_checkpointing="unsloth"`** — это самый большой способ экономии VRAM, уникальный для Unsloth
* **Установите `lora_dropout=0`** — ядра Triton в Unsloth оптимизированы для нулевого dropout и работают быстрее
* **Используйте `packing=True`** в SFTTrainer, чтобы избежать перерасхода на padding для коротких примеров
* **Начните с `r=16`** для ранга LoRA — увеличивайте до 32 или 64 только если loss на валидации перестаёт снижаться
* **Следите с помощью wandb** — добавьте `report_to="wandb"` в TrainingArguments для отслеживания loss
* **Настройка размера пакета** — увеличьте `per_device_train_batch_size` пока не приблизитесь к лимиту VRAM, затем компенсируйте с помощью `gradient_accumulation_steps`

## Устранение неполадок

| Проблема                             | Решение                                                                                      |
| ------------------------------------ | -------------------------------------------------------------------------------------------- |
| `OutOfMemoryError` во время обучения | Уменьшите batch size до 1, сократите `max_seq_length`, или используйте 4-битную квантизацию  |
| Ошибки компиляции ядер Triton        | Запускайте `pip install triton --upgrade` и убедитесь, что CUDA Toolkit соответствует версии |
| Медленный первый шаг (компиляция)    | Нормально — Triton компилирует ядра при первом запуске, затем использует кэш                 |
| `bitsandbytes` Ошибка версии CUDA    | Установите подходящую версию: `pip install bitsandbytes --upgrade`                           |
| Всплески loss во время обучения      | Уменьшите learning rate до 1e-4, добавьте шаги warmup                                        |
| Сбой экспорта GGUF                   | Убедитесь, что хватает ОЗУ (2× размера модели) и места на диске для конвертации              |

## Ресурсы

* [GitHub Unsloth](https://github.com/unslothai/unsloth)
* [Вики Unsloth — все ноутбуки](https://github.com/unslothai/unsloth/wiki)
* [маркетплейс CLORE.AI](https://clore.ai/marketplace)


---

# 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/obuchenie/unsloth-finetune.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.