Какие фреймворки для fine-tuning вы используете?

Краткий тезис

Выбор фреймворка для fine-tuning зависит от целей: для быстрых экспериментов и прототипирования я чаще всего использую Hugging Face TRL (SFTTrainer) в связке с Unsloth (ускорение в 2–5x). Для production-настроек с продвинутыми конфигурациями подходит Axolotl, а для non‑technical команд — LLaMA-Factory с GUI. Lamini удобен для enterprise с мониторингом. На практике комбинация TRL + Unsloth покрывает 80% задач, а остальные фреймворки подключаются под специфические требования.

1. Ключевая концепция: Fine-tuning и PEFT

Fine-tuning — это дообучение предобученной языковой модели на небольшом датасете для решения конкретной задачи. fine-tuning|Полный fine-tuning (update всех весов) дорог и не всегда нужен. PEFT (Fine-Tuning|Parameter-Efficient Fine-Tuning) — семейство методов (LoRA, QLoRA, Adapters), которые замораживают исходные веса и обучают только небольшие адаптеры. Это радикально снижает требования к памяти и времени. Все современные фреймворки поддерживают PEFT, а большинство — и fine-tuning|полный fine-tuning с использованием DeepSpeed или FSDP для распределённого обучения.

2. Hugging Face TRL (SFTTrainer)

TRL (Transformer Reinforcement Learning) от Hugging Face — это стандарт индустрии. Ключевой компонент — SFTTrainer (Supervised Fine-Tuning Trainer), который обёртывает стандартный Trainer и добавляет возможности:

• Обучение на текстовых датасетах с коллапсом в формат instruction‑response.
• Встроенная поддержка PEFT (через peft_config) — LoRA, QLoRA.
• Оптимизация памяти: gradient checkpointing, packed sequences (упаковка коротких примеров в один батч).
• Интеграция с bitsandbytes для 4‑битной квантизации (QLoRA).

from transformers import AutoModelForCausalLM, AutoTokenizer
from trl import SFTTrainer, DataCollatorForCompletionOnlyLM
from peft import LoraConfig

model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-v0.1",
                                             load_in_4bit=True,
                                             device_map="auto")
tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-v0.1")
peft_config = LoraConfig(r=8, lora_alpha=32, target_modules=["q_proj", "v_proj"], lora_dropout=0.05)

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,
    args=TrainingArguments(output_dir="./mistral-qlora", per_device_train_batch_size=4),
    peft_config=peft_config,
)
trainer.train()

Когда использовать:

• Стандартные задачи fine-tuning (instruction tuning, chat‑style).
• Быстрый старт с минимальными усилиями.
• Огромное сообщество и плагины (Wandb, MLflow).

3. Unsloth

Unsloth — это форк/надстройка над Hugging Face, которая ускоряет fine-tuning в 2–5 раз за счёт оптимизации операций и ручных ядер CUDA. Он совместим с TRL, поэтому можно комбинировать: использовать SFTTrainer с model, загруженной через Unsloth.

from unsloth import FastLanguageModel

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/mistral-7b-bnb-4bit",
    max_seq_length=4096,
    dtype=None,
    load_in_4bit=True,
)
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,
)

Ключевые возможности:

• Использование Flash Attention (автоматически, если поддерживается GPU).
• Оптимизация LoRA‑слоёв (ручные ядра вместо стандартной реализации).
• Экономия VRAM: можно обучать 7‑12B модели на GPU с 12–16 ГБ.
• Ускорение в 2–5x по сравнению с обычным TRL.

Когда использовать:

• Необходимость быстро прототипировать (много экспериментов за день).
• Ограниченные GPU‑ресурсы (одна карта потребительского уровня).
• Любой fine‑tuning, где важна скорость итераций.

4. Axolotl

Axolotl — это конфигурационный фреймворк, который абстрагирует код обучения в YAML‑файлы. Позволяет задать всё (модель, датасет, PEFT, распределённое обучение) в одном .yml.

base_model: mistralai/Mistral-7B-v0.1
load_in_8bit: false
load_in_4bit: true
datasets:
  - path: dataset.jsonl
    type: alpaca
    split: train
    ... 
lora_r: 8
lora_alpha: 16
lora_dropout: 0.05
lora_target_modules:
  - q_proj
  - v_proj
train_on_inputs: false
sequence_len: 4096
gradient_accumulation_steps: 4
micro_batch_size: 2
...

Преимущества:

• Воспроизводимость — одна конфигурация вместо скриптов.
• Production‑среда: поддерживает DeepSpeed ZeRO-2/3, FSDP, мульти‑GPU, облачные очереди (SLURM, RunPod).
• Поддержка множества архитектур: Llama, Mistral, Gemma, Qwen и др.

Недостаток: меньше гибкости, чем чистый код TRL, но для типовых fine‑tuning'ов идеален.

Когда использовать:

• Командная работа: инженеры настраивают параметры, не трогая код.
• Требуется точное управление ресурсами (распределённое обучение).
• Воспроизводимые эксперименты с версионированием конфигов.

5. Lamini

Lamini — enterprise‑фреймворк, который предоставляет не только fine-tuning, но и дашборды для мониторинга, сравнения версий моделей, A/B‑тестирования. Он использует своё API, похожее на Hugging Face, но с дополнительными сервисами:

• Автоматическое создание датасетов из логов.
• Встроенный memory tuning (LLM запоминает факты из контекста).
• Дашборды с метриками потерь, faithfulness, accuracy.

Подходит для продакшн‑систем, где важна наблюдаемость (Observability). Однако он платный и менее гибкий, чем открытые решения.

6. LLaMA-Factory

LLaMA-Factory — это open‑source инструмент с веб‑интерфейсом (Gradio). Позволяет non‑technical пользователям (аналитикам, менеджерам) выполнять fine-tuning без написания кода.

• Поддержка множества PEFT методов: LoRA, QLoRA, AdaLoRA, IA3.
• Визуальный просмотр датасета, управление обучением.
• Экспорт модели в GGUF, Hugging Face Hub.

Когда использовать:

• Быстрые эксперименты без программирования.
• Демонстрация стейкхолдерам.
• Маленькие команды без MLOps‑инженера.

7. Сравнительная таблица фреймворков

8. Как я выбираю фреймворк

1. Для 80% задач: TRL + Unsloth. Unsloth даёт ускорение, а TRL — привычный API. Если нужно ещё быстрее — DeepSpeed ZeRO-3 с SFTTrainer.
2. Для сложных production: Axolotl. Одна конфигурация, поддержка кластера, легко версионировать.
3. Для неспециалистов: LLaMA-Factory — буквально за 5 минут через веб‑интерфейс.
4. Для enterprise с мониторингом: Lamini (если бюджет позволяет).
5. Когда хочется экспериментировать с новыми методами: чистый TRL с ручным написанием кастомного Trainer.

9. Узкие места и подводные камни

• Совместимость Unsloth с новыми моделями: не всегда сразу поддерживает только что вышедшие архитектуры.
• Axolotl: если нужен нестандартный collator или loss (например, для мультизадачности), придётся лезть в код фреймворка или писать хук.
• LLaMA-Factory: GUI не позволяет тонко регулировать параметры обучения (например, scheduler).
• QLoRA с bitsandbytes: могут быть проблемы с типом данных (нужна версия 0.42+).

Пет-проект для закрепления

Задача: Создать минимальный пайплайн fine-tuning маленькой LLM (GPT-2 или TinyLlama-1.1B) на датасете инструкций (Alpaca-формата) с использованием TRL + Unsloth и сравнить скорость с чистым TRL.

Инструменты: Python, PyTorch, Hugging Face Transformers, Unsloth, TRL, Weights & Biases (для логов).

Шаги:

1. Установить библиотеки: pip install transformers accelerate peft trl unsloth wandb bitsandbytes.
2. Загрузить модель через FastLanguageModel.from_pretrained (Unsloth) и отдельно через AutoModelForCausalLM.
3. Подготовить датасет (например, yahma/alpaca-cleaned).
4. Настроить SFTTrainer с одинаковыми параметрами (batch size, learning rate, кол-во шагов) для обоих вариантов.
5. Замерить время обучения (через Wandb или встроенные таймеры).
6. Оценить качество (генерация ответов на тестовых промптах).
7. Вывести таблицу сравнения скорости и использования VRAM.

Ожидаемый результат: Вы увидите ускорение в 2–3 раза на Unsloth при одинаковом качестве (loss, качество ответов). Это даст уверенность в выборе фреймворка и понимание, когда его стоит применять.

Связь с другими вопросами

Навигация

• Предыдущий: 32
• Следующий: 34
• Индекс: 00. Индекс разборов