LoRA и QLoRA: чем отличаются и что выбрать для дообучения большой языковой модели

Введение​

В мире искусственного интеллекта и дообучения больших языковых моделей (LLM) возникло множество методов, позволяющих адаптировать модели под конкретные задачи без необходимости дообучения всех параметров. Два таких подхода — LoRA и QLoRA — стали популярными благодаря своей эффективности и экономии ресурсов. Однако, несмотря на схожесть в цели, они имеют существенные различия в реализации, применении и требованиях к оборудованию.

LoRA (Low-Rank Adaptation) и QLoRA (Quantized Low-Rank Adaptation) представляют собой методы параметрической эффективной дообучаемости (PEFT), разработанные для снижения затрат на обучение и хранение моделей. Эти методы позволяют изменять поведение модели, используя лишь небольшое количество дополнительных параметров, что делает их идеальными для использования на устройствах с ограниченными ресурсами.

В данной статье рассматриваются ключевые особенности LoRA и QLoRA, их различия, а также рекомендации по выбору подходящего метода в зависимости от задачи и доступных ресурсов.

Что такое LoRA?​

LoRA (Low-Rank Adaptation) — это метод параметрической эффективной дообучаемости (PEFT), предложенный в 2021 году. Основная идея LoRA состоит в том, чтобы адаптировать большую модель, изменяя лишь небольшое количество параметров, вместо дообучения всех весов. Это достигается за счёт введения низкоранговых матриц, которые добавляются к весам модели.

Механизм работы LoRA​

LoRA работает с линейными слоями модели, заменяя их на комбинацию оригинального веса и низкорангового изменения. Например, если веса модели представлены как матрица W, то в LoRA добавляется матрица ΔW = A × B, где A и B — матрицы низкой размерности. Таким образом, изменённый вес становится:

W' = W + ΔW = W + A × B

Это позволяет сохранить основную информацию модели, но при этом внести изменения, соответствующие новой задаче.

Преимущества LoRA​

• Экономия ресурсов: LoRA требует значительно меньше памяти и вычислительных ресурсов по сравнению с полным дообучением.
  
• Быстрое дообучение: Изменение происходит за относительно короткое время.
  
• Сохранение оригинальной модели: Оригинальные веса остаются неизменными, что позволяет использовать их в других задачах.
  
• Простота применения: LoRA легко интегрируется в существующие системы и фреймворки, такие как Hugging Face Transformers.
  

Ограничения LoRA​

• Не подходит для всех моделей: LoRA эффективен, когда модель имеет линейные слои, но не всегда применим к слоям с высокой нелинейностью.
  
• Ограниченная точность: В некоторых случаях точность LoRA может быть ниже, чем у полного дообучения, особенно при сложных задачах.
  

Что такое QLoRA?​

QLoRA — это развитие LoRA, которое включает в себя квантование весов модели. Основная цель QLoRA — уменьшение объема памяти, необходимого для хранения модели, и ускорение процесса обучения и инференса. QLoRA применяет квантование с низкой точностью (например, int4) к весам модели, сохраняя при этом эффективность LoRA.

Механизм работы QLoRA​

QLoRA сочетает два принципа:

1. Квантование: Веса модели сжимаются до формата с низкой точностью (например, int4 или int8).
   
2. LoRA: Добавляются низкоранговые изменения для адаптации модели.
   

Таким образом, QLoRA позволяет дообучать модели даже на устройствах с ограниченной памятью, таких как потребительские видеокарты.

Преимущества QLoRA​

• Снижение требований к памяти: Квантование позволяет сократить объем памяти, необходимый для хранения модели.
  
• Сохранение качества: Несмотря на квантование, качество модели остаётся высоким благодаря LoRA.
  
• Удобство для инференса: Модель может быть использована в реальных приложениях с меньшими затратами.
  

Ограничения QLoRA​

• Сложность реализации: Требуется дополнительная настройка и калибровка для достижения высокой точности.
  
• Снижение точности при сильном квантовании: При использовании очень низких форматов (например, int4) точность может значительно упасть.
  

Сравнение LoRA и QLoRA​

| Характеристика | LoRA | QLoRA |
|----------------|------|-------|
| Требования к памяти | Низкие | Очень низкие |
| Требования к вычислениям | Средние | Низкие |
| Уровень квантования | Отсутствует | Присутствует |
| Сложность реализации | Простая | Сложная |
| Точность | Высокая | Высокая (при правильной настройке) |
| Подходит для | Обычные устройства | Устройства с ограниченными ресурсами |

Когда использовать LoRA?​

LoRA идеально подходит для:

• Дообучения моделей на устройствах с достаточным объемом памяти.
  
• Задач, где требуется высокая точность.
  
• Простых и быстрых решений, где не требуется квантование.
  

Когда использовать QLoRA?​

QLoRA рекомендуется для:

• Работы на устройствах с ограниченной памятью (например, потребительские видеокарты).
  
• Инференса на устройствах с низкой производительностью.
  
• Сценариев, где важна экономия ресурсов и быстрое развертывание.
  

Как выбрать между LoRA и QLoRA?​

Выбор между LoRA и QLoRA зависит от нескольких факторов:

1. Доступные ресурсы​

Если у вас есть доступ к мощным GPU с большим объемом VRAM, LoRA может быть предпочтительным выбором, поскольку он позволяет достичь высокой точности без необходимости квантования.

Если же вы работаете на устройствах с ограниченными ресурсами, QLoRA станет лучшим решением, поскольку позволяет эффективно использовать ограниченные ресурсы.

2. Требования к точности​

Для задач, где важна максимальная точность, LoRA может быть предпочтительнее, поскольку он не теряет информации при квантовании.

Для задач, где допустима небольшая потеря точности, QLoRA может быть хорошим выбором, особенно если вы хотите уменьшить объем памяти и ускорить инференс.

3. Сложность внедрения​

LoRA проще в реализации и интеграции, тогда как QLoRA требует дополнительных шагов по калибровке и настройке.

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

Пример 1: Дообучение LLaMA через LoRA​

Для дообучения модели LLaMA с использованием LoRA можно использовать библиотеку Hugging Face PEFT. Ниже приведён пример конфигурации:

from peft import LoraConfig, get_peft_model
from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf")
config = LoraConfig(
    r=8,
    lora_alpha=32,
    target_modules=["q_proj", "v_proj"],
    lora_dropout=0.05,
    bias="none"
)
peft_model = get_peft_model(model, config)

Пример 2: Дообучение LLaMA через QLoRA​

Для QLoRA необходимо использовать квантование, например, с помощью библиотеки bitsandbytes:

from peft import LoraConfig, get_peft_model
from transformers import AutoModelForCausalLM, BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_use_double_quant=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16
)

model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-2-7b-hf",
    quantization_config=quantization_config
)

config = LoraConfig(
    r=8,
    lora_alpha=32,
    target_modules=["q_proj", "v_proj"],
    lora_dropout=0.05,
    bias="none"
)

peft_model = get_peft_model(model, config)

Безопасность и лучшие практики​

При работе с LoRA и QLoRA важно соблюдать следующие рекомендации:

1. Проверка совместимости: Убедитесь, что используемая модель поддерживает LoRA или QLoRA.
   
2. Тестирование точности: После дообучения проверьте точность модели на тестовых данных.
   
3. Контроль ресурсов: Следите за использованием памяти и процессора, особенно при использовании QLoRA.
   
4. Сохранение оригинальных весов: Не перезаписывайте оригинальные веса модели, чтобы сохранить возможность повторного использования.
   

Заключение​

LoRA и QLoRA являются мощными инструментами для дообучения больших языковых моделей. LoRA предоставляет эффективное решение для задач, где важна точность и доступны ресурсы. QLoRA — это более продвинутый подход, который позволяет дообучать модели даже на устройствах с ограниченными ресурсами, при этом сохраняя высокую точность. Выбор между ними зависит от целей проекта, доступных ресурсов и требований к точности.

Для успешного применения этих методов важно понимать их особенности, правильно настраивать параметры и следить за результатами дообучения. Использование Hugging Face и других библиотек значительно упрощает процесс, но требует внимательного подхода к каждой детали.

Чек-лист выбора метода​

• [ ] Проверить, поддерживает ли модель LoRA или QLoRA.
  
• [ ] Оценить объем доступной памяти и вычислительных ресурсов.
  
• [ ] Определить уровень точности, необходимый для задачи.
  
• [ ] Оценить сложность внедрения и необходимость дополнительной настройки.
  
• [ ] Проверить совместимость с используемыми библиотеками (например, PEFT, Transformers).
  
• [ ] Провести тестирование на тестовых данных.
  
• [ ] Убедиться, что оригинальные веса модели не будут перезаписаны.
  
• [ ] Оценить возможность дальнейшего использования модели в других задачах.
  

Источники​

• PEFT · Hugging Face
  
• Overview · Hugging Face
  
• vLLM
  

 

[zer0coder]

А какие есть ещё методы для обучения кроме LoRA и QLoRA ?

 

[Zer0Kernel CVE Radar]

Если коротко: LoRA и QLoRA — это не отдельные алгоритмы обучения, а способы параметрически эффективного дообучения. Кроме них есть как другие PEFT-методы, так и полноценное дообучение, обучение с подкреплением, preference-оптимизация и методы экономии памяти.

Ниже — основные варианты, которые реально используются для LLM.

────────────────────

1. Full Fine-Tuning: полное дообучение всех весов​

Это классический вариант: берут базовую модель и обучают все её параметры на целевом датасете.

Когда подходит​

• Нужно максимально возможное качество под конкретный домен.
• Есть много GPU/VRAM.
• Нужна глубокая перестройка модели: стиль, формат, предметная область, сложный reasoning.
• Вы можете позволить себе хранить несколько полных копий модели под разные задачи.

Плюсы​

• Обычно даёт максимальное качество.
• Нет ограничений, связанных с рангом, целевыми модулями или заморозкой основной части весов.
• Модель можно полностью адаптировать под стиль, формат, предметную область.

Минусы​

• Очень высокое потребление памяти.
• Для модели уровня 7B полное дообучение в fp16/bf16 с оптимизатором типа Adam может требовать десятки и сотни GB VRAM в зависимости от batch size, sequence length и оптимизаций.
• Каждая задача требует отдельной полной копии модели.
• Выше риск катастрофического забывания базовых навыков.
• Дороже хранить и деплоить несколько вариантов.

Что обычно используют вместе с full fine-tuning​

• DeepSpeed ZeRO-1/2/3
• FSDP
• gradient checkpointing
• 8-bit Adam
• bf16 или fp16
• CPU/NVMe offloading
• GaLore и другие memory-efficient optimizer/gradient projection подходы

Примерно по памяти:

• 7B full FT без серьёзных оптимизаций — часто требует очень много VRAM.
• 13B full FT — уже практически недоступно на одной потребительской карте без offload.
• 70B full FT — обычно только кластер, ZeRO/FSDP, offload и большие вычислительные ресурсы.

────────────────────

2. Adapter Tuning: встраивание небольших адаптеров​

Adapter-based методы добавляют в модель маленькие обучаемые модули, обычно внутри или рядом с Transformer-блоками.

Основные варианты​

• Houlsby adapters
  • Адаптеры вставляются после attention и feed-forward слоёв.
  • Обычно содержат bottleneck-проекцию: down-projection, нелинейность, up-projection.
• Pfeiffer adapters
  • Похожи на Houlsby, но обычно размещаются только после feed-forward блоков.
  • Часто дают меньше накладных расходов.
• Parallel adapters
  • Адаптер работает параллельно с основным слоем, а не последовательно после него.
  • Может быть стабильнее и быстрее.
• MAM Adapter
  • Комбинация prefix tuning и adapter tuning.
  • Пытается получить преимущества обоих подходов.

Плюсы​

• Обучается только небольшая часть параметров.
• Можно держать одну базовую модель и много адаптеров.
• Хорошо подходит для multi-task сценариев.
• Адаптеры можно отключать, включать, комбинировать.

Минусы​

• Добавляют накладные расходы при инференсе.
• Не всегда легко сливаются с базовой моделью без изменения архитектуры.
• Качество может быть ниже, чем у хорошо настроенного LoRA, особенно если адаптеры маленькие.
• Нужно аккуратно выбирать места вставки и bottleneck size.

Пример идеи:

from peft import AdapterConfig

config = AdapterConfig(
    bottleneck_size=64,
    non_linearity="relu",
    target_modules=["q_proj", "v_proj"],
)

────────────────────

3. Prefix Tuning​

Prefix Tuning добавляет обучаемые виртуальные токены в начало последовательности, но не обычные текстовые токены, а непрерывные векторы, которые подаются в attention.

Как работает​

• К входу добавляется несколько обучаемых hidden states.
• Модель видит их как префикс.
• Сам текст задачи может оставаться неизменным.
• Обучаются только параметры префикса.

Когда подходит​

• Очень мало VRAM.
• Нужно быстро адаптировать модель под классификацию, извлечение данных, простые instruction-задачи.
• Хочется минимально менять модель.

Плюсы​

• Очень мало обучаемых параметров.
• Низкие требования к памяти.
• Можно держать разные префиксы под разные задачи.

Минусы​

• Часто слабее LoRA на сложных generative-задачах.
• Может быть нестабильным при малом количестве данных.
• Виртуальные токены занимают часть контекста.
• Не всегда удобно интерпретировать, что именно выучил префикс.

Пример:

from peft import PrefixTuningConfig

config = PrefixTuningConfig(
    task_type="CAUSAL_LM",
    num_virtual_tokens=20,
)

────────────────────

4. Prompt Tuning​

Prompt Tuning обучает мягкий prompt — набор continuous embeddings, которые добавляются к входу.

Отличие от Prefix Tuning​

Грань между Prompt Tuning и Prefix Tuning часто размыта, но обычно:

• Prompt Tuning обучает embeddings на входе.
• Prefix Tuning может обучать префиксы на разных слоях attention.
• P-Tuning v2 развивает идею обучаемых prompt-векторов по всей модели.

Когда подходит​

• Очень ограниченные ресурсы.
• Много задач, но одна базовая модель.
• Нужны лёгкие task-specific адаптеры.

Плюсы​

• Минимальный объём обучаемых параметров.
• Очень дёшево хранить.
• Можно быстро переключать задачи.

Минусы​

• На небольших моделях часто работает хуже, чем LoRA.
• Для сложных задач может не хватить выразительности.
• Требует хорошего initialization prompt.
• Может быть чувствителен к learning rate и длине prompt.

Пример:

from peft import PromptTuningConfig

config = PromptTuningConfig(
    task_type="CAUSAL_LM",
    num_virtual_tokens=8,
    prompt_tuning_init="TEXT",
    prompt_tuning_init_text="Classify the following text:",
)

────────────────────

5. P-Tuning / P-Tuning v2​

P-Tuning — семейство методов, где обучаются не обычные слова, а непрерывные prompt-векторы.

Особенности​

• P-Tuning v2 обычно добавляет обучаемые prompt-векторы не только на вход, но и на разные слои Transformer.
• Часто работает лучше обычного prompt tuning, особенно на задачах NLU.
• Может быть полезен для классификации, NER, извлечения сущностей, QA.

Плюсы​

• Очень экономичен по параметрам.
• Может быть эффективен при большом количестве задач.
• Хорошо сочетается с frozen backbone.

Минусы​

• Для сложной генерации может уступать LoRA.
• Требует аккуратной настройки длины prompt и инициализации.
• Может занимать часть контекстного окна.

────────────────────

6. IA3 / (IA)^3​

IA3 означает Infused Adapter by Inhibiting and Amplifying Inner Activations.

Идея​

Вместо добавления новых матриц или адаптеров метод обучает небольшие scaling-векторы, которые умножаются на активации внутри модели.

Обычно воздействуют на:

• keys;
• values;
• feed-forward activations.

Плюсы​

• Очень мало обучаемых параметров.
• Часто меньше overhead, чем у классических адаптеров.
• Может быть эффективен при ограниченном VRAM.

Минусы​

• Качество зависит от модели и задачи.
• Не всегда так же гибок, как LoRA.
• Нужно правильно выбирать целевые модули.
• Может быть менее зрелым в экосистеме, чем LoRA.

Пример:

from peft import IA3Config

config = IA3Config(
    task_type="CAUSAL_LM",
    target_modules=["q_proj", "v_proj", "k_proj"],
    feedforward_modules=["down_proj"],
)

────────────────────

7. BitFit​

BitFit обучает только bias-параметры модели, а основные веса оставляет замороженными.

Когда подходит​

• Очень простой baseline.
• Мало ресурсов.
• Нужно проверить, можно ли вообще адаптировать задачу без серьёзного обучения.

Плюсы​

• Максимально простая реализация.
• Очень мало обучаемых параметров.
• Низкий риск сильно сломать базовую модель.

Минусы​

• Обычно слабее LoRA, адаптеров и prefix tuning.
• Для сложных generative-задач часто недостаточен.
• Не все архитектуры удобно поддерживают нужные bias-слои.

────────────────────

8. DoRA​

DoRA — Weight-Decomposed Low-Rank Adaptation.

Идея​

DoRA разделяет вес на направление и масштаб, а затем адаптирует их более гибко, чем обычный LoRA.

Условно:

• LoRA учит низкоранговую добавку к весу.
• DoRA дополнительно лучше контролирует масштаб и направление весового вектора.

Когда может быть полезен​

• Когда обычный LoRA недообучается или нестабилен.
• Когда хочется получить ближе к full fine-tuning качеству, но с PEFT-экономией.
• Для задач, где важна стабильность адаптации.

Плюсы​

• Часто даёт лучшее качество, чем vanilla LoRA, при сопоставимом бюджете.
• Лучше приближает эффект полного дообучения.
• Может быть полезен для сложных instruction-задач.

Минусы​

• Чуть сложнее обычного LoRA.
• Не всегда поддерживается из коробки во всех стеках.
• Может требовать более аккуратного подбора learning rate.

────────────────────

9. AdaLoRA​

AdaLoRA — адаптивный вариант LoRA.

Идея​

В обычном LoRA ранг r обычно фиксирован для всех целевых модулей. AdaLoRA пытается распределить ранг более умно: каким-то слоям дать больше ёмкости, каким-то меньше.

Когда полезен​

• Когда непонятно, какие слои важнее для задачи.
• Когда хочется автоматизировать выбор ранга.
• Когда нужно эффективнее использовать бюджет параметров.

Плюсы​

• Более гибкое распределение ёмкости.
• Может дать лучшее качество при том же числе параметров.
• Полезен, если нет ресурсов вручную тюнить r по слоям.

Минусы​

• Сложнее отладка.
• Больше переменных в конфигурации.
• Не всегда даёт заметный выигрыш на простых задачах.

────────────────────

10. LoRA-варианты и связанные методы​

Вокруг LoRA появилось много модификаций. Некоторые из них:

• LoRA+
  • Разные learning rate для матриц A и B.
  • Может ускорять сходимость.
• rsLoRA
  • Rank-stabilized LoRA.
  • Пытается стабилизировать обучение при больших рангах.
• LoftQ
  • LoRA с quantization-aware инициализацией.
  • Полезен при работе с квантованными моделями.
• PiSSA
  • Инициализация LoRA через principal singular values/singular vectors.
  • Может быть полезен для более осмысленного старта адаптации.
• MoLE / Mixture of LoRA Experts
  • Несколько LoRA-экспертов, которые комбинируются или выбираются динамически.
  • Полезно для multi-domain или multi-task задач.
• LoRAHub
  • Идея композиции множества LoRA-модулей.
  • Больше про повторное использование и комбинирование адаптеров.

────────────────────

11. Sparse Fine-Tuning и mask-based методы​

Это методы, где обучается не вся модель, а разреженная часть весов.

Примеры​

• DiffPruning
  • Обучает разреженный delta к весам.
  • Пытается получить эффект fine-tuning при малом числе изменяемых параметров.
• FishMask
  • Использует информацию о важности параметров для выбора маски.
  • Обучает только выбранную подмаску весов.
• MeZO
  • Memory-efficient zeroth-order optimization.
  • Может быть полезен при экстремальных ограничениях памяти, но это уже отдельный класс оптимизаторов.

Когда подходит​

• Нужен очень маленький объём изменяемых параметров.
• Хочется альтернатива LoRA/adapter.
• Есть специфичные требования к хранению и деплою.

Минусы​

• Часто сложнее в настройке.
• Меньше зрелых production-инструментов.
• Качество может сильно зависеть от задачи и маски.

────────────────────

12. GaLore и другие методы экономии памяти для почти полного обучения​

GaLore — это не PEFT в духе LoRA, а метод, который пытается обучать модель почти полноценно, но экономит память за счёт low-rank projection градиентов.

Идея​

• Градиенты проецируются в низкоранговое пространство.
• Оптимизатор работает с уменьшенным представлением.
• Это позволяет снизить память под optimizer states.

Когда полезен​

• Хочется качество ближе к full fine-tuning.
• LoRA/QLoRA не дают нужного результата.
• Есть ограничения по памяти, но full FT в лоб не влезает.

Плюсы​

• Может быть эффективнее LoRA на некоторых задачах.
• Позволяет обновлять больше параметров модели.
• Хорошо сочетается с gradient checkpointing и ZeRO.

Минусы​

• Сложнее, чем LoRA.
• Требует поддержки в тренировочном стеке.
• Может быть медленнее или требовать аккуратного подбора гиперпараметров.

────────────────────

13. Quantization-Aware Training​

QAT — обучение с учётом будущего квантования.

Важно не путать​

• QLoRA — обычно LoRA поверх квантованной базовой модели.
• QAT — модель обучается или дообучается так, чтобы быть устойчивой к квантованию.
• GPTQ, AWQ, GGUF quantization — чаще post-training quantization, а не сам метод обучения.

Когда нужен QAT​

• Модель будет работать в int8/int4.
• Нужно минимизировать деградацию после квантования.
• Вы делаете production-инференс на слабом железе.
• Нужна максимальная стабильность квантованной модели.

Плюсы​

• Лучшее качество после квантования.
• Можно адаптировать модель под целевой формат инференса.
• Полезно для edge-устройств.

Минусы​

• Сложнее, чем просто post-training quantization.
• Требует поддержки квантования в фреймворке.
• Может быть медленнее и капризнее.

────────────────────

14. Supervised Fine-Tuning​

SFT — это уже не про то, какие параметры обучать, а про то, на каких данных и с какой целью.

Что такое SFT​

Модель обучают на парах:

instruction / prompt -> desired answer

или:

input -> output

Когда нужен​

• Нужно научить модель следовать инструкциям.
• Нужен конкретный формат ответа: JSON, SQL, YAML, Markdown, structured output.
• Нужно адаптировать модель под домен: медицина, юридика, код, SOC, DevOps, поддержка.
• Нужно убрать нежелательные форматы или галлюцинации в узкой задаче.

Может сочетаться с​

• full fine-tuning;
• LoRA;
• QLoRA;
• adapters;
• prefix tuning;
• IA3;
• DoRA.

────────────────────

15. Instruction Tuning​

Instruction Tuning — частный случай SFT, где модель учат реагировать на инструкции.

Примеры задач​

• Ответить по контексту.
• Извлечь сущности.
• Преобразовать текст в JSON.
• Написать SQL по схеме БД.
• Сделать summary.
• Классифицировать обращение.
• Сгенерировать конфиг, манифест, правило, regex.

Важно​

Для instruction tuning критично качество данных:

• разнообразие инструкций;
• корректные ответы;
• отсутствие противоречий;
• единый формат;
• отсутствие утечек PII и секретов;
• проверка на prompt injection внутри обучающих примеров.

────────────────────

16. Continued Pretraining​

Если нужно не просто научить модель отвечать в нужном формате, а дать ей новые знания, используют continued pretraining.

Когда нужен​

• Модель должна знать внутренний код, документацию, стандарты, регламенты.
• Нужно адаптировать модель к специфичному языку предметной области.
• Обычный SFT не помогает, потому что модели не хватает фактических знаний.
• Есть большой корпус текстов: документация, тикеты, codebase, RFC, runbooks.

Форматы данных​

• Обычный текст.
• Код.
• Markdown.
• JSON/YAML.
• Логи.
• Диффы.
• Пары вопрос-ответ.
• Контекст-продолжение.

Минусы​

• Требует больше данных и ресурсов.
• Может вызвать катастрофическое забывание.
• Нужно тщательно смешивать доменные и общие данные.
• Сложнее оценить качество, чем у SFT.

────────────────────

17. RLHF​

RLHF — Reinforcement Learning from Human Feedback.

Идея​

Модель учат не только на готовых ответах, а на предпочтениях людей:

prompt -> answer A
prompt -> answer B
human: A better than B

Затем обучают reward model и оптимизируют политику модели.

Классический pipeline​

1. SFT.
2. Сбор preference-данных.
3. Обучение reward model.
4. Оптимизация политики через PPO или другой RL-алгоритм.

Когда нужен​

• Нужно улучшить стиль, полезность, безопасность.
• Есть качественные preference-данные.
• Есть ресурсы на сложный pipeline.
• Нужен контроль над поведением модели.

Минусы​

• Сложно.
• Дорого.
• Нестабильно.
• Требует хорошей reward model.
• Риск reward hacking.
• Требует мониторинга деградации базовых навыков.

────────────────────

18. DPO​

DPO — Direct Preference Optimization.

Идея​

DPO пытается оптимизировать предпочтения напрямую, без отдельной reward model и сложного RL-цикла.

Когда полезен​

• Есть preference-данные.
• Хочется проще, чем RLHF/PPO.
• Нужно улучшить стиль, тон, безопасность, формат.
• Нужно дообучить модель на парах лучший/худший ответ.

Плюсы​

• Проще RLHF.
• Меньше компонентов.
• Часто стабильнее PPO.
• Хорошо сочетается с LoRA/QLoRA.

Минусы​

• Нужны качественные preference-данные.
• Может переобучиться на шумные предпочтения.
• Не всегда заменяет полноценный RLHF.

Пример использования через trl:

from trl import DPOTrainer

────────────────────

19. IPO, KTO, ORPO, SimPO, GRPO​

Это семейство preference-optimization методов, альтернативных или родственных DPO.

IPO​

• Identity Preference Optimization.
• Пытается улучшить стабильность preference-оптимизации.

KTO​

• Kahneman-Tversky Optimization.
• Может работать с данными, где есть не только пары, а оценки хороший/плохой ответ.

ORPO​

• Odds Ratio Preference Optimization.
• Объединяет SFT и preference-оптимизацию.

SimPO​

• Упрощённый preference optimization без reference model в некоторых реализациях.
• Может быть проще и дешевле.

GRPO​

• Group Relative Policy Optimization.
• Часто используется в reinforcement-сценариях, где ответы оцениваются относительно группы.

Когда это нужно​

• Есть данные вида preferred/rejected.
• Нужно выровнять поведение модели.
• Нужно уменьшить вредные, токсичные или нежелательные ответы.
• Нужно улучшить следование инструкциям.

────────────────────

20. Rejection Sampling Fine-Tuning / RFT​

Rejection Sampling Fine-Tuning — подход, где модель сама генерирует много ответов, затем лучшие из них отбираются и используются для дальнейшего обучения.

Pipeline​

1. Модель генерирует несколько ответов на один prompt.
2. Ответы оцениваются:
   • reward model;
   • unit tests;
   • linting;
   • формальные проверки;
   • LLM-as-judge;
   • человек.
3. Лучшие ответы добавляются в SFT-датасет.
4. Модель дообучается на улучшенных данных.

Где особенно полезен​

• Код.
• Математика.
• Формальные задачи.
• Генерация SQL.
• Генерация конфигов.
• Задачи с проверяемым результатом.

Плюсы​

• Можно автоматически улучшать датасет.
• Хорошо работает, если есть объективная проверка.
• Может быть дешевле полноценного RLHF.

Минусы​

• Нужен хороший критерий отбора.
• Если reward model плохая, модель начнёт оптимизировать артефакты.
• Может усилить bias или галлюцинации, если отбор некачественный.

────────────────────

21. Curriculum Learning​

Curriculum Learning — это стратегия обучения, а не отдельный PEFT-метод.

Идея​

Сначала модель обучают на более простых примерах, затем постепенно усложняют.

Пример​

1. Короткие инструкции.
2. Простые ответы.
3. Более длинные контексты.
4. Сложные multi-step задачи.
5. Edge cases.
6. Negative examples.
7. Safety-примеры.

Когда полезно​

• Модель нестабильно обучается.
• Данные разного качества.
• Есть сложные и простые примеры.
• Нужно уменьшить переобучение на шумных данных.

────────────────────

22. Multi-Task Learning​

Модель обучают сразу на нескольких задачах.

Примеры задач​

• классификация;
• summarization;
• QA;
• code generation;
• SQL generation;
• extraction;
• rewriting;
• safety refusal;
• tool calling;
• structured output.

Плюсы​

• Модель становится более универсальной.
• Улучшается generalization.
• Можно использовать одну модель под несколько сценариев.

Минусы​

• Задачи могут конфликтовать.
• Нужно балансировать датасеты.
• Нужно следить, чтобы одна задача не деградировала другую.

────────────────────

23. Mixture of Experts и adapter routing​

Если задач много, можно использовать не одну большую адаптацию, а набор экспертов или адаптеров.

Варианты​

• LoRA per task.
• Adapter per task.
• Prefix per task.
• Mixture of LoRA experts.
• Router, который выбирает адаптер по задаче.
• Dynamic adapter loading.

Когда полезно​

• Одна базовая модель должна обслуживать много задач.
• Нужно быстро переключать домены.
• Нужно экономить память и хранение.
• Есть требования изоляции задач.

Минусы​

• Сложнее деплой.
• Нужен routing.
• Возможны конфликты между адаптерами.
• Нужно тестировать комбинации.

────────────────────

24. Что выбрать на практике​

Если нужно быстро и недорого дообучить LLM​

Используйте:

• LoRA;
• QLoRA;
• DoRA;
• AdaLoRA.

Обычно это лучший старт.

────────────────────

Если VRAM очень мало​

Смотрите в сторону:

• QLoRA;
• IA3;
• Prompt Tuning;
• Prefix Tuning;
• P-Tuning v2;
• BitFit как самый простой baseline.

────────────────────

Если нужно максимальное качество​

Смотрите в сторону:

• Full Fine-Tuning;
• GaLore;
• DoRA;
• LoRA с большим рангом и правильными target modules;
• Continued Pretraining + SFT;
• Preference optimization после SFT.

────────────────────

Если нужно научить модель следовать инструкциям​

Используйте:

• SFT;
• Instruction Tuning;
• LoRA/QLoRA как параметрический метод;
• DPO/KTO/ORPO, если есть preference-данные.

────────────────────

Если нужно улучшить безопасность, стиль, тон, отказ от вредных ответов​

Используйте:

• SFT на безопасных примерах;
• DPO;
• KTO;
• RLHF;
• rejection sampling;
• red-team evaluation.

────────────────────

Если нужно дать модели новые знания​

Используйте:

• Continued Pretraining;
• RAG вместо попытки вшить все знания в веса;
• SFT поверх RAG;
• доменные датасеты с контролем качества.

Важно: для фактических знаний часто лучше использовать RAG, чем пытаться полностью вшить знания в модель через fine-tuning.

────────────────────

Если нужно адаптировать модель под код​

Используйте:

• Continued pretraining на коде;
• SFT на instruction-code задачах;
• LoRA/QLoRA;
• Rejection sampling с unit tests;
• Evaluation на HumanEval, MBPP, internal repo tests.

────────────────────

Если нужно много задач на одной базовой модели​

Используйте:

• LoRA per task;
• adapters;
• prefix tuning;
• mixture of adapters;
• router-based PEFT.

────────────────────

25. Пример сравнения по смыслу​

Без точных цифр, потому что всё зависит от модели, batch size, sequence length и стека:

• Full Fine-Tuning
  • Максимальное качество.
  • Максимальная цена.
  • Нужны большие GPU.
• LoRA
  • Хороший баланс качества и ресурсов.
  • Подходит для большинства задач.
  • Легко хранить адаптеры отдельно.
• QLoRA
  • LoRA на квантованной базовой модели.
  • Хорошо для ограниченного VRAM.
  • Часто лучший выбор для локального дообучения.
• DoRA / AdaLoRA
  • Потенциально лучше обычного LoRA.
  • Полезны, если LoRA не даёт нужного качества.
• Adapters
  • Хороши для multi-task.
  • Могут добавлять overhead.
• Prefix/Prompt Tuning
  • Очень дешёвые.
  • Могут быть слабее на сложных generative-задачах.
• IA3
  • Очень компактный.
  • Может быть хорошей альтернативой LoRA.
• DPO/KTO/ORPO
  • Не замена SFT/LoRA, а следующий этап выравнивания поведения.

────────────────────

26. Практический рекомендуемый pipeline​

Для большинства задач разумный pipeline выглядит так:

1. Подготовить данные.
2. Очистить от секретов, PII, мусора.
3. Проверить формат ответов.
4. Сделать train/validation split.
5. Выбрать базовую модель.
6. Начать с LoRA или QLoRA.
7. Оценить качество.
8. Если качества мало:
   • увеличить ранг;
   • добавить больше target modules;
   • улучшить данные;
   • попробовать DoRA/AdaLoRA;
   • попробовать full FT или GaLore.
9. Если нужно улучшить поведение:
   • собрать preference-данные;
   • применить DPO/KTO/ORPO.
10. Сделать regression evaluation.
11. Проверить безопасность и prompt injection устойчивость.
12. Сохранить базовую модель и адаптеры отдельно.

────────────────────

27. Минимальный пример конфигурации LoRA​

from peft import LoraConfig, get_peft_model
from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained("TARGET_MODEL")

config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=[
        "q_proj",
        "k_proj",
        "v_proj",
        "o_proj",
        "gate_proj",
        "up_proj",
        "down_proj",
    ],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
)

model = get_peft_model(model, config)
model.print_trainable_parameters()

────────────────────

28. Минимальный пример QLoRA​

import torch
from transformers import AutoModelForCausalLM, BitsAndBytesConfig
from peft import LoraConfig, get_peft_model

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_use_double_quant=True,
    bnb_4bit_compute_dtype=torch.bfloat16,
)

model = AutoModelForCausalLM.from_pretrained(
    "TARGET_MODEL",
    quantization_config=bnb_config,
)

lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=[
        "q_proj",
        "k_proj",
        "v_proj",
        "o_proj",
        "gate_proj",
        "up_proj",
        "down_proj",
    ],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
)

model = get_peft_model(model, lora_config)
model.print_trainable_parameters()

────────────────────

29. На что смотреть при оценке результата​

После обучения важно проверять не только loss.

Технические метрики​

• validation loss;
• perplexity;
• accuracy на целевой задаче;
• exact match;
• F1;
• BLEU/ROUGE, если уместно;
• pass@k для кода;
• JSON schema validity;
• SQL execution accuracy;
• tool calling accuracy.

Поведенческие проверки​

• Модель следует инструкции?
• Не выдумывает ли факты?
• Не ломает ли формат?
• Не отвечает на вредные запросы?
• Устойчива ли к prompt injection?
• Не деградировали ли базовые навыки?

Инженерные проверки​

• VRAM usage.
• Throughput.
• Latency.
• Размер адаптера.
• Возможность merge/unmerge.
• Совместимость с inference engine.
• Совместимость с quantization.

────────────────────

30. Частые ошибки​

• Обучать LoRA только на q_proj и v_proj, хотя задаче нужно больше ёмкости.
• Слишком маленький ранг для сложной задачи.
• Слишком большой learning rate.
• Плохие данные: дубли, шум, противоречия, утечки секретов.
• Обучение на данных с prompt injection.
• Оценка только по train loss.
• Попытка вшить фактические знания только в веса вместо RAG.
• Не проверять catastrophic forgetting.
• Не сохранять базовую модель отдельно от адаптера.
• Не тестировать модель после квантования.

────────────────────

31. Итоговая рекомендация​

Если нужен практичный выбор:

• Локально, мало VRAM, обычная задача → QLoRA.
• Есть GPU, нужно хорошее качество → LoRA.
• LoRA не хватает → DoRA, AdaLoRA, больше target modules, выше rank, лучше данные.
• Нужно максимум качества → Full Fine-Tuning или GaLore, если full FT не влезает.