8 шагов: тонкая настройка LLM через Unsloth на своём ПК

Почему именно Unsloth

Представьте, что вы купили швейную машину, но она шьёт только в одну нитку. Fine-tuning языковой модели — это добавление второй нитки под ваши задачи. Unsloth делает этот процесс в 2 раза быстрее и потребляет вдвое меньше памяти, чем стандартные подходы.

Большинство LLM обучены на общих данных и не знают специфику вашего бизнеса. Тонкая настройка (fine-tuning) решает эту проблему: вы берёте готовую модель и «доучиваете» её на своих данных. Раньше для этого нужен был сервер с GPU на $10 000, но Unsloth меняет правила игры.

Если вы ещё не знакомы с основами работы с локальными моделями, начните с нашего гайда по установке Ollama — это база, без которой дальше будет сложнее.

Шаг 1: Проверка оборудования

Для запуска Unsloth достаточно видеокарты с 6 ГБ VRAM. GTX 1660, RTX 3060, RTX 4060 — всё подойдёт. Чем больше видеопамяти, тем крупнее модель можно настраивать.

Минимальные требования

GPU: NVIDIA с 6+ ГБ VRAM (Compute Capability 7.0+). AMD карты пока поддерживаются экспериментально через ROCm.

ОЗУ: 16 ГБ системной памяти. Это «склад» для хранения данных, пока GPU обрабатывает модель.

Диск: 50+ ГБ свободного места. Базовые модели весят 4–13 ГБ, плюс датасеты и чекпоинты.

Шаг 2: Установка Unsloth

Unsloth устанавливается одной командой. Но сначала убедитесь, что у вас установлены CUDA Toolkit и PyTorch с поддержкой GPU:

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"

После установки проверьте, что GPU виден:

python -c "import torch; print(torch.cuda.get_device_name(0))"

Если выводит название вашей карты — всё готово. Если нет — проверьте драйверы NVIDIA.

Шаг 3: Выбор базовой модели

Unsloth поддерживает семейства Llama, Mistral, Qwen, Gemma и Phi. Для начала рекомендуем Llama 3.1 8B — золотая середина между качеством и скоростью.

from unsloth import FastLanguageModel

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Meta-Llama-3.1-8B-bnb-4bit",
    max_seq_length=2048,
    load_in_4bit=True,
)

Параметр load_in_4bit=True сжимает модель до 4 бит на вес. Это как упаковать чемодан вакуумным пакетом — помещается в 4 раза больше, но содержимое не страдает. Подробнее о контекстных окнах моделей читайте в статье про контекстное окно LLM.

Шаг 4: Настройка LoRA-адаптеров

Вместо переобучения всей модели (это потребовало бы сотни гигабайт), Unsloth использует 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",
)

Параметр r=16 определяет «размер заплатки». Больше = точнее, но медленнее. Для большинства задач 16–32 достаточно.

Шаг 5: Подготовка датасета

Качество fine-tuning на 80% зависит от данных. Формат — JSONL с парами «вопрос-ответ» или «инструкция-результат»:

{"instruction": "Напиши заголовок для статьи про ИИ", "output": "Искусственный интеллект: практическое руководство для начинающих"}

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

Качество важнее количества. 500 идеальных примеров лучше 50 000 зашумлённых. Один плохой пример может отравить всю модель.

Разнообразие формулировок. Не повторяйте одну и ту же структуру. Модель должна учиться генерировать, а не копировать.

Фильтрация дубликатов. Дубли создают смещение — модель будет перегенерировать одни и те же ответы.

Шаг 6: Запуск обучения

Unsloth предоставляет обёртку над стандартным Trainer от Hugging Face с оптимизациями:

from trl import SFTTrainer
from transformers import TrainingArguments

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=2048,
    args=TrainingArguments(
        per_device_train_batch_size=4,
        gradient_accumulation_steps=4,
        warmup_steps=10,
        max_steps=100,
        learning_rate=2e-4,
        fp16=True,
        output_dir="./outputs",
    ),
)

trainer.train()

100 шагов на датасете из 500 примеров займёт около 15 минут на RTX 3060. Это как разогреть духовку — быстрее, чем кажется.

Шаг 7: Тестирование модели

После обучения протестируйте модель на примерах, которых не было в тренировочном наборе:

FastLanguageModel.for_inference(model)

inputs = tokenizer([
    "Напиши краткое описание MCP-сервера для чайника"
], return_tensors="pt").to("cuda")

outputs = model.generate(**inputs, max_new_tokens=256)
print(tokenizer.decode(outputs[0]))

Если ответы «поплыли» — возможно, learning rate слишком высокий. Уменьшите его вдвое и повторите обучение.

Шаг 8: Экспорт и использование

Unsloth поддерживает экспорт в GGUF (для llama.cpp/Ollama), а также merge с оригинальными весами:

# Сохранение LoRA-адаптера
model.save_pretrained("my-adapter")

# Экспорт в GGUF
model.save_pretrained_gguf("my-model-gguf", tokenizer, quantization_method="q4_k_m")

Квантование q4_k_m сжимает модель до ~5 ГБ без заметной потери качества. После экспорта загрузите модель в Ollama или llama.cpp и используйте как обычно.

Частые ошибки

Переобучение (overfitting). Если модель на тренировочных примерах выдаёт идеальные ответы, а на новых — бессмыслицу, уменьшите количество шагов или добавьте данные.

Неправильный формат датасета. Unsloth чувствителен к форматированию. Всегда проверяйте первые 10 строк датасета перед запуском.

Забыли включить fp16. Без half-precision обучение займёт вдвое больше памяти и времени.

Итог

Fine-tuning через Unsloth превращает通用модель в специалиста за часы, а не недели. 8 шагов — от проверки железа до экспорта готовой модели. Начните с маленькой модели и небольшого датасета, убедитесь что пайплайн работает, а затем масштабируйте. Каждая итерация учит чему-то новому — и это касается не только модели, но и вас.