Тонкая настройка merged модели за 45 минут на T4 с Unsloth: пошаговый workflow

Fine-tuning как роскошь? Больше нет

Год назад тонкая настройка модели на 7 миллиардов параметров означала аренду A100 на несколько дней и счет в сотни долларов. Сегодня это 45 минут работы на Google Colab с картой T4, которая стоит копейки. Прогресс не в новых алгоритмах, а в инструментах, которые выжимают из железа последние соки. Если вы все еще думаете, что кастомная LLM — удел больших корпораций, этот гайд перевернет ваше представление.

Почему Unsloth — не опция, а необходимость

Библиотек для ускорения обучения полно. Но Unsloth — другая история. Разработчики не стали оптимизировать существующие ядра PyTorch. Они выкинули их и написали свои с нуля на CUDA. Результат? Потребление памяти падает в 3-4 раза, скорость обучения вырастает до 5 раз. На T4 с ее 16 ГБ GDDR6 это разница между "не помещается" и "обучается за 45 минут".

Секрет в двух вещах: эффективный оффлоадинг и пересчет градиентов на лету. Unsloth не хранит в VRAM кучу промежуточных значений, а вычисляет их заново, когда нужно. Это trade-off между вычислениями и памятью, и на современных GPU он работает идеально. Особенно для merged-моделей, где слои из разных архитектур создают пиковую нагрузку на память.

1Выбор модели: не все merged-архитектуры одинаково полезны

Merged-модель — это франкенштейн, собранный из лучших частей разных LLM. Хорошая новость: они часто показывают лучшие результаты, чем оригиналы. Плохая: их кошмарно обучать на обычном железе. Для нашего эксперимента возьмем SOLARized-GraniStral-14B — гибрид SOLAR и Mixtral, который отлично справляется с кодом и инструкциями.

Почему именно она? 14 миллиардов параметров — золотая середина между качеством и требовательностью. И что важнее, архитектура Mixtral (sparse MoE) дружит с Unsloth. Библиотека умеет эффективно работать с экспертами, не загружая в память все сразу.

2Подготовка среды: режем все лишнее

Откройте VS Code и новый терминал. Забудьте про Anaconda и виртуальные окружения с мистическими зависимостями. Нам нужен чистый Python 3.11+ и pip. Первая команда установит Unsloth и все необходимое.

pip install unsloth[cu121] torch==2.4.0 --index-url https://download.pytorch.org/whl/cu121

Установите утилиты для работы с данными. Нам понадобится Datasets от Hugging Face.

pip install datasets trl peft accelerate

3Подготовка датасета: качество против количества

Вам не нужны миллионы примеров. Для эффективного fine-tuning достаточно 1000-5000 качественных samples. Формат — инструкция и ответ. Загрузим тестовый датасет и сразу приведем его к нужному виду.

from datasets import load_dataset

dataset = load_dataset("json", data_files="your_data.json")
# Ваш датасет должен иметь поля 'instruction' и 'output'
def format_instruction(sample):
    return {
        "instruction": sample["instruction"],
        "output": sample["output"]
    }

dataset = dataset.map(format_instruction)

Разделите данные на обучение и валидацию. 90/10 — хорошее правило. Если данных мало, используйте кросс-валидацию, но помните — у нас всего 45 минут.

4Загрузка модели: трюк с 4-битной квантованием

Unsloth умеет загружать модели в 4-битном формате (NF4) без потери качества для обучения. Это главный ключ к экономии памяти. Загружаем нашу merged-модель.

from unsloth import FastLanguageModel
import torch

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "model/SOLARized-GraniStral-14B",
    max_seq_length = 2048, # Увеличивайте осторожно! Каждый +512 — это +1 ГБ памяти.
    dtype = torch.float16,
    load_in_4bit = True, # Магия здесь
    token = "your_hf_token", # Если модель приватная
)

Не увеличивайте max_seq_length без необходимости. На T4 с 16 ГБ потолок — около 2048 токенов. Хотите больше? Придется уменьшать batch size или использовать оффлоадинг в RAM, но это замедлит обучение.

5Настройка LoRA: атакуем только слабые места

Обучать все 14 миллиардов параметров — безумие. Используем LoRA (Low-Rank Adaptation), чтобы дообучить только 0.1% весов. Unsloth делает это автоматически, но параметры нужно подобрать.

model = FastLanguageModel.get_peft_model(
    model,
    r = 16, # Ранг LoRA. 16 — безопасно, 32 — если данных много.
    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", # Используем фирменный метод Unsloth
    random_state = 42,
)

Параметр use_gradient_checkpointing критически важен. Он еще сильнее уменьшает потребление памяти, ценой небольшого замедления. На T4 включайте всегда.

6Тренировка: 45 минут на все про все

Теперь настройте тренировочные аргументы. Здесь нельзя ошибиться, иначе либо модель не обучится, либо выйдете за пределы памяти.

from trl import SFTTrainer
from transformers import TrainingArguments

trainer = SFTTrainer(
    model = model,
    tokenizer = tokenizer,
    train_dataset = dataset["train"],
    eval_dataset = dataset["test"],
    dataset_text_field = "instruction", # Поле с текстом для обучения
    max_seq_length = 2048,
    dataset_num_proc = 2,
    args = TrainingArguments(
        per_device_train_batch_size = 2, # На T4 больше 2 — риск OOM.
        gradient_accumulation_steps = 4, # Эффективный batch size = 2 * 4 = 8
        warmup_steps = 10,
        max_steps = 60, # Да, всего 60 шагов! При batch size 8 это 480 примеров.
        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 = 42,
        output_dir = "outputs",
        report_to = "none", # Отключаем интеграции, чтобы не тратить время
    ),
)

Самая частая ошибка — слишком большой per_device_train_batch_size. На T4 начинайте с 1 или 2. max_steps = 60 звучит смешно, но для адаптации к новой задаче этого часто достаточно. Unsloth настолько эффективен, что модель учится за десятки шагов.

7Запуск и мониторинг: жмем на газ

Запустите обучение. Сидите и смотрите. Первые 5 шагов — самые важные. Если loss не падает, что-то не так с данными или learning rate.

trainer.train()

Используйте nvidia-smi в отдельном терминале, чтобы следить за использованием VRAM. Пиковое значение не должно превышать 15 ГБ. Если приближается — немедленно останавливайтесь и уменьшайте batch size.

8Сохранение и конвертация: готовим к бою

После обучения сохраните модель. Но не как обычный PyTorch .pth, а сразу в формате, готовом к инференсу.

model.save_pretrained("lora_adapter") # Сохраняем только LoRA веса
# Или сохраняем полную модель для последующего использования
model.save_pretrained_merged("fine_tuned_model", tokenizer, save_method = "merged_16bit")

Для запуска на слабом железе конвертируйте модель в GGUF. Это можно сделать тем же Unsloth или использовать специальные скрипты. GGUF с квантованием Q4_K_M уменьшит размер модели в 4 раза без заметной потери качества.

Нюансы, которые съедят ваши 45 минут, если не знать

• Неправильный формат токенизации. Merged-модели часто используют нестандартные токенизаторы. Всегда проверяйте, как ваш текст разбивается на токены: print(tokenizer.tokenize("ваш текст")).
• Слишком длинные последовательности. Если max_seq_length больше, чем реальная длина ваших примеров, вы тратите память впустую. Урезайте.
• Эвристика "зоны убийства". В некоторых merged-моделях есть слои, которые при fine-tuning дают катастрофическую потерю качества. О том, как это обнаружить и избежать, я писал в статье про лоботомические слои в Llama 3.1.
• Переобучение на маленьком датасете. 60 шагов — это мало. Но если у вас всего 100 примеров, модель запомнит их наизусть. Всегда оставляйте hold-out набор для проверки.

Частые вопросы (FAQ)

Что дальше? Запускаем цикл экспериментов

45 минут — это не предел. С таким циклом вы можете запускать 10 экспериментов в день. Меняйте learning rate, пробуйте разные LoRA target_modules, тестируйте на новых данных. Fine-tuning превращается из сакрального ритуала в инженерную практику. Следующий шаг — автоматизация пайплайна с помощью GitHub Actions и мониторинг результатов в Weights & Biases. Но это уже тема для другой статьи.

Главное, что нужно вынести: проблема стоимости fine-tuning решена. Технологии догнали мечту. Осталось взять и сделать.

Подписаться на канал