2026-01-04 · Обновлено 2026-07-15

[!NOTE] Автоматический перевод Эта статья была автоматически переведена с оригинальной английской версии.

LLM Файн-тюнинг Руководство: LoRA, QLoRA, DoRA, Unsloth, Axolotl и Деплой

Большинство сбоев файн-тюнинг связаны с ошибками принятия решений. Команда сначала проводит тренировку, чтобы убедиться, что использование подсказок, retrieval, или constrained decoding не позволяет решить проблему; затем оценивает результаты на выборке данных, использованных в тренировке; либо обнаруживает после завершения тренировки, что готовый продукт труден в использовании.

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

Кратко: Начинайте тонкую настройку тогда, когда измеренный базовый результат показывает, что изменение поведения модель оправдывает проведение обновления вес. Для корректировки фактов используйте retrieval, а для изменения синтаксиса — constrained decoding. Начинайте с LoRA, если базовая модель модель работает стабильно; при ограничении в виде замороженной вес памяти применяйте QLoRA. Перед тренировкой сохраните набор для оценки, сравните его с ненастроенным базовым вариантом и выберите оптимальный результат деплой перед тем, как окончательно принять тот или иной метод.

Стоит ли вообще выполнять файн-тюнинг?

Прежде чем тратить GPU часов, определитесь с тем, является ли файн-тюнинг подходящим инструментом для решения поставленной перед вами задачи.

Файн-тюнинг против RAG

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

Файн-тюнинг против промпт-инжиниринг

Современные LLMs хорошо реагируют на чёткие промпты и примеры. Перед тем как вкладывать средства в файн-тюнинг, обязательно протестируйте эти варианты.

[!TIP] Сначала попробуйте сформулировать запрос Начните с промпт и типичных примеров. Если проблема касается только синтаксиса вывода, добавьте constrained decoding перед изменением веса.

Файн-тюнинг против constrained decoding

Библиотеки вроде xgrammar и outlines Ограничивают процесс генерации с помощью JSON schema, регулярных выражений или грамматики. В зависимости от выбранного ограничения и бэкенд создаётся автомат или грамматика, которые фильтруют недопустимые следующие токены. Обновление вес не требуется.

Это гарантирует использование поддерживаемого языка вывода, но не подтверждает, что значения являются истинными, полными или семантически корректными. Синтаксически корректный вызов функции всё равно может содержать неверный идентификатор клиента.

Практический порядок действий:

1. Начните с использования промптов и примеров в формате few-shot для базовой форматировки.
2. Добавьте constrained decoding (xgrammar или outlines) при несоответствии синтаксиса.
3. Выполняйте тонкую настройку только тогда, когда требуются изменения поведения, которые невозможно обеспечить с помощью схемы.

Краткий справочник: соответствие задач решениям

Сделайте экономическую обоснованность измеримой

Файн-тюнинг может снизить частоту возникновения промпт токены или позволить более небольшому объёму модель достичь поставленной цели, однако ни одна из этих экономий не происходит автоматически. Рассчитайте точку безубыточности, исходя из своего уровня трафика и ценообразования:

[ \text{Запросы на достижение точки безубыточности} = \frac{\text{стоимость обучения + оценки + деплой}} {\text{базовая стоимость/запрос} - \text{скорректированная стоимость/запрос}} ]

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

[!TIP] Гибридная конфигурация Распространённой архитектурой является более мелкий модель модель, адаптированный под конкретную задачу, в сочетании с retrieval для обновления фактов. Более крупный модель модель, запущенный с помощью специальных инструкций, следует рассматривать в качестве базового варианта; мелкий модель модель следует сохранять лишь в том случае, если он соответствует тем же критериям качества и безопасности, характерным для данной задачи.

Типы файн-тюнинг

Существуют три основные формы, которые может принимать файн-тюнинг. Они отличаются по типу данных, необходимых для работы, и по тому, что они обучают модель.

1. Продолжение предварительной обучаемости (без учителя)

Вы обучаете базовую модель модель на большем объёме необработанных текстов без меток. Она продолжает выполнять прогнозирование следующего токен, точно так же, как и во время первоначального этапа предобучения.

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

• У данной области есть словарный запас, с которым базовая модель никогда ранее не сталкивалась (медицинские термины, юридическая терминология, внутренние кодбазы).
• У вас имеется большое количество текста из этой области, но отсутствуют помеченные пары «входные данные — выходные данные».
• Базовая модель плохо справляется с терминологией, специфичной для данной области.

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

2. Надзорное обучение файн-тюнинг (SFT)

SFT обучается на пометленных парах (входные данные, выходные данные). Вы указываете модель точный выходной результат, который требуется для каждого входного значения.

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

• У вас есть конкретная задача с чётко определённым форматом входных/выходных данных.
• У вас имеются меткированные данные высокого качества, даже в небольших объёмах.
• Вам необходимо предсказуемое поведение модели при входных данных известной структуры.

Обучение на парах (описание SQL-запроса, код SQL) для задачи текст-на-SQL.

{
    "input": "Get all users who signed up last month",
    "output": "SELECT * FROM users WHERE signup_date >= DATE_SUB(NOW(), INTERVAL 1 MONTH)"
}

3. Настройка инструкций

Настройка по инструкциям представляет собой специальный случай SFT, направленный на то, чтобы заставить модели выполнять самые разнообразные запросы на естественном языке. Данные для обучения состоят из пар «инструкция, ответ», взятых из множества различных задач.

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

• Вам нужен универсальный ассистент (по аналогии с ChatGPT или Claude).
• модель должен обрабатывать разнообразные, открытые запросы.
• Вы разрабатываете интерфейс для чатов.

Пример: обучение на тысячах разнообразных заданий вроде «Подготовь краткое резюме этой статьи», «Напиши стихотворение на тему X», «Объясни концепцию Y простыми словами».

Сравнение

[!NOTE] Как на самом деле поступают разработчики SFT и настройка инструкций используют одну и ту же цель, связанную с выбором следующего токен; разница заключается в объёме и способе формирования датасет. Продолжительная предварительная обучающая фаза представляет собой отдельный эксперимент, после которого необходимо проводить тесты как для оценки улучшений в конкретной области, так и для выявления регрессии общих когнитивных способностей.

7-этапный процесс файн-тюнинг пайплайн

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

Каждый этап основан на предыдущем:

1. Подготовка данных — определение единицы оценки, разделение данных, а затем их очистка и форматирование
2. Модель selection — Выберите подходящую базу. модель и загружаем веса
3. Настройка обучения — настройка аппаратного обеспечения, гиперпараметров и стратегии оптимизации
4. Файн-тюнинг — Запустить SFT, DPO, или обучение ORPO
5. Оценка — Бенчмарк оптимизация производительности и проверка качестваДеплой** — Экспортируйте и предоставляйте свои модель
6. Мониторинг — отслеживание производительности, техническое обслуживание и постепенная оптимизация

[!WARNING] Данные — это основа

Этап 1: Подготовка данных

Большинство проектов файн-тюнинг проваливаются именно на этом этапе, а не во время обучения. Современная подготовка данных — это гораздо больше, чем простое применение регулярных выражений к файлам CSV.

5-этапная обработка данных пайплайн

Инструменты вроде DataTrove и Distilabel могут быть полезны при работе с крупными объёмами данных, однако выбор пайплайн должен определяться таксономией сбоев и контрактом данных, а не предпочтениями конкретного инструмента.

1. Прием данных и фильтрация

• Действие: исключение отказов вроде «Я не могу ответить на этот вопрос», данных с повреждённым форматом UTF-8 и сообщений на языках, не являющихся целевыми.
• Инструменты: Trafilatura для извлечения данных, FastText для определения идентификатора языка.

2. Политика обработки конфиденциальных данных

• Действие: определить, что именно модель допускается обучать, а затем в соответствии с требованиями удалить, токенизировать или исключить личные и конфиденциальные поля.
• Инструменты: Microsoft Presidio или scrubadub.
• Причина: детектор является лишь одним из средств контроля; по-прежнему применяются требования к происхождению данных, получению согласия, хранению, доступу и уничтожению информации.

3. Удаление дубликатов (MinHash LSH)

• Действие: удалять почти идентичные записи, чтобы модель не сохранял их в памяти.
• Инструменты: DataTrove эффективно справляется с обработкой объёмов данных в терабайтах.

4. Синтетическое усиление, при необходимости

• Действие: использовать более мощного учителя модель (GPT-4o, DeepSeek-V3) для преобразования сырых данных в структурированные пары «инструкция — ответ».
• Инструменты: Distilabel.
• Валидация: анализ примеров выводов учителя, сравнение их по той же шкале оценки, что и метки, созданные людьми, а также раздельная оценка синтетических и человекописанных фрагментов.

5. Форматирование

• Действие: преобразовать в стандартный формат (Alpaca или ShareGPT).

Примеры форматов данных

Формат Alpaca (соблюдение инструкций):

{
    "instruction": "Summarize the following text.",
    "input": "The text to be summarized...",
    "output": "This is the summary."
}

Формат ShareGPT/ChatML (диалоговый):

{
    "conversations": [
        { "from": "user", "value": "Hello, who are you?" },
        { "from": "assistant", "value": "I am a helpful AI assistant." }
    ]
}

Что действительно имеет значение

• Покрытие прежде чем объём. Приведите примеры, отражающие различные моди рассыпания, а не повторения простых случаев с высокой частотой возникновения.
• Чистота. Удалите нерелевантный текст, нормализуйте пробелы и сохраняйте единообразие форматирования.
• Баланс. Сохраняйте важные редкие случаи и отчитывайтесь о производительности для каждой группы данных.
• Разделение. Делите данные по источнику, пользователю, документу или времени, чтобы случайное разделение строк не приводило к появлению почти идентичных записей.
• Происхождение. Фиксируйте источник, лицензию или разрешение, историю преобразований и путь удаления для каждой версии датасет.

Этап 2: выбор Модель и аппаратная часть

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

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

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

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

Определяйте размер пайплайна, а не уровень маркетинговых услуг

Не существует стабильной таблицы «модель размер → GPU». Пиковое потребление памяти зависит от точности вес, алгоритма оптимизации, количества обучаемых параметров, длины последовательности, размера микропакетов, практики сохранения состояния в активация формате, способа аттеншн реализации и уровня накладных расходов фреймворк. Сначала следует оценить потребление памяти, а затем провести краткий тест на максимально возможную длину данных с использованием конкретной стековой структуры.

Исходная статья QLoRA показала, что в рамках своей специфической конфигурации 65-миллиардный вариант LLaMA модель умещается на одном устройстве с объёмом памяти 48 ГБ GPU. Этот результат представляет собой полезное ограничение, но не гарантию того, что любая современная архитектура с 70 миллиардами нейронов, любая длина контекста, любой ядро обработки или любой инструмент тренировки будут соответственно подходить для работы на таком же устройстве.

Математика памяти

Для модель с (P) параметрами один только веса требует примерно (2P) байт в формате BF16/FP16 или (0.5P) байт при использовании четырёхбитной представления, ещё до учёта метаданных квантизация и буферов рантайм. Полная обучающая процедура в стиле Adam включает градиенты, состояния оптимизатора, а также часто мастер-модели веса с более высокой точностью. Метод LoRA позволяет избежать хранения большинства состояний, подлежащих обучению; кроме того, QLoRA сокращает объём памяти, занимаемый замороженными компонентами типа вес. Тем не менее, при длине последовательностей, превышающих определённый порог, метод Активации может оставаться доминирующим.

Используйте следующий рабочий процесс:

1. Определите максимальную длину последовательности и размер микропакета, которые необходимо поддерживать.
2. Оцените объём веса и объём состояний, доступных для обучения, оставляя запас для активации и ядер.
3. Выполните один шаг вперёд/назад при максимальной длине последовательности.
4. Запишите пиковый объём выделенной и зарезервированной памяти.
5. Только после этого корректируйте размер пакета, количество процессоров, длину последовательности или количество GPU.

Этап 3: Методы обучения (PEFT и LoRA)

Полная реализация файн-тюнинг против PEFT

Полная обработка файн-тюнинг (FFT) выполняется каждые вес, в результате чего градиенты и состояние оптимизатора масштабируются вместе со всем модель. Максимальную нагрузку невозможно оценить исключительно по количеству параметров, однако она значительно превышает объём памяти, необходимый для загрузки веса в целях выполнения инференс.

Параметро-эффективный файн-тюнинг (PEFT) подразумевает обучение лишь небольшой группы параметров, при этом остальные фиксируются на текущих значениях. Благодаря этому математические вычисления становятся значительно проще.

LoRA: начальная точка

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

Для замороженной матрицы (W0 \in \mathbb{R}^{d{out} \times d_{in}}), LoRA обучается на основе:

• (A \in \mathbb{R}^{r \times d_{in}})
• (B \in \mathbb{R}^{d_{out} \times r})

Адаптированный слой представляет собой:

[W’ = W_0 + \frac{\alpha}{r}BA]

В данном адаптере имеется (r(d*{in}+d*{out})) обучаемых параметров вместо (d*{in}d*{out}), характерных для соответствующей матрицы. Для квадратной матрицы шириной 4 096 при ранге 16 это означает сокращение размерности на 128 раз, а не на 10 000 раз, как утверждалось в отношении произвольных модель. Утверждение из статьи LoRA о сокращении на 10 000 раз касалось конкретной конфигурации GPT-3 объёмом 175 млрд параметров, в которой использовалась адаптация отдельных матриц.

Сравнение методов PEFT

Когда выбирать тот или иной вариант

• LoRA: начинать следует именно здесь. Этот подход обеспечивает высокую скорость работы, эффективное использование памяти и широкую поддержку.
• QLoRA: когда тот же самый эксперимент с использованием LoRA невозможен из-за зафиксированной базовой конфигурации веса.
• DoRA: после проведения прямого сравнения LoRA становится очевидным наличие значимой выгоды.
• Полная файн-тюнинг оценка: только после выполнения PEFT получаем реальные результаты проверки боттлнек, а не просто предположения.

DoRA: вес-разложенные LoRA

DoRA (Вес — декомпозированная адаптация низкого ранга) позволяет разделить модуль каждого вектора вес и его направление. При этом к направленной составляющей применяется обновление с использованием LoRA, в то время как модуль определяется отдельно.

Как это работает:

Вместо того чтобы рассматривать веса как единое целое, DoRA разделяет заранее обученный веса на два компонента:

1. Амплитуда — это обучаемое значение для каждого вектора вес.
2. Направление — нормализованный вектор, обновляемый с помощью матриц низкого ранга.

В компактной колонковой нотации:

[W’ = m \frac{V + BA}{\lVert V + BA \rVert_c}]

где:

• m = величина (подлежащая обучению)
• (V) = замороженная матрица направлений
• (BA) = выученное обновление направлений низкого ранга
• (\lVert \cdot \rVert_c) = нормализация по столбцам

Что вы получаете за дополнительную структуру:

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

Объединение адаптеров в рамках многозадачного обучения

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

Распространённые методы слияния:

1. Соединение — объединение параметров адаптеров с целью увеличения эффективного ранга. Метод быстрый и простой.
2. Линейное соединение — взвешенная сумма адаптеров. Позволяет настраивать веса.
3. SVD — разложение матрицы для объединения компонентов. Более гибкий подход, но требует больше времени.

Пример: один адаптер предназначен для суммаризации, другой — для перевода; оба объединяются в единый мультизадачный модель.

Этап 4: Файн-тюнинг и согласование предпочтений

SFT обучается на примерах демонстраций. Метод оптимизации предпочтений, в отличие от него, работает на основе сравнений вроде «выбранный ответ A лучше отклонённого ответа B». Используйте его только тогда, когда парная оценка предпочтений является наиболее подходящей метрикой для описания ошибки; при этом фактическая точность и соблюдение правил часто требуют более строгого эвалуаторы, чем просто глобальных предпочтений.

Реализация на основе PPO-связанных RLHF

Изначальный алгоритм представлял собой трёхэтапный процесс пайплайн:

1. SFT — изучение задачи.
2. Награда модель — обучение на основе предпочтений людей (отобранных и отклонённых вариантов).
3. PPO (Proximal Policy Optimization) — метод усиленного обучения для оптимизации политики.

Рабочие затраты обусловлены наличием движущихся компонентов:

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

DPO

Метод DPO (оптимизация прямых предпочтений) исключает явное задание модель награды и цикл обучения с подкреплением. Он по‑прежнему оптимизирует цель RLHF (максимизацию награды при ограничении через дивергенцию KL), однако делает это в рамках перепараметризованной задачи обучения с учителем, а не с использованием методов машинного обучения с подкреплением.

{
    "prompt": "Explain quantum computing",
    "chosen": "Quantum computing uses qubits...",   # Preferred response
    "rejected": "Well, it's complicated..."        # Non-preferred response
}

Что меняется с операционной точки зрения:

• Проще структура кода (отсутствие отдельной награды модель и цикла обучения с использованием методов RL).
• Оффлайн-цель, основанная на парах предпочтений, вместо обучения с использованием методов reinforcement learning в режиме on-policy.
• Стандартная формулировка, включающая эталонную политику или эквивалентные вероятности журнала событий для сравнения.

Создание прототипа с использованием DPO проще, чем разработка полноценного PPO пайплайн, однако это не гарантирует автоматического улучшения качества. Результаты зависят от исходной политики обработки, качества пар данных, настроек потерь, эффектов длины последовательностей и протокола оценки. Следует сравнивать его с SFT чекпоинт на тех же наборах данных для тестирования и задачах.

ORPO

ORPO (Odds-Ratio Preference Optimization) объединяет функцию потерь вида отрицательный логарифм вероятности SFT с штрафом, основанным на коэффициенте шансов, применяемым к отклонённым ответам. Благодаря этому методу не требуется отдельная этапа формирования контрольных данных модель, что позволяет выполнять одновременно обучение на задачах и оптимизацию предпочтений.

Как это работает: ORPO использует комбинированную функцию потерь, которая одновременно выполняет две задачи:

1. Максимизирует вероятность выбранного ответа (обучение задаче).
2. Наказывает отклонённый ответ с помощью члена, основанного на соотношении шансов (обучение предпочтениям).

Гиперпараметры, которые стоит знать:

from trl import ORPOConfig

config = ORPOConfig(
    learning_rate=8e-6,  # Very low, as recommended by the ORPO paper
    beta=0.1,            # Controls strength of preference penalty
    # ... other params
)

• Скорость обучения: в своих экспериментах авторы статьи использовали низкие значения этого параметра; необходимо настраивать его с учётом особенностей вашего модель, размера пакетов данных и их структуры, а не просто копировать какое-либо фиксированное значение.
• Параметр Beta: определяет степень влияния соответствующего терма по сравнению с термом SFT.

Компромисс:

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

Выберите вариант из списка данных и схемы оценки:

• Используйте DPO в тех случаях, когда у вас уже имеется приемлемый SFT чекпоинт, но требуется более простой эксперимент с настройками в офлайн-режиме.
• Протестируйте метод ORPO, если для ваших данных и операционных ограничений подходит одноэтапная цель без использования внешних эталонов.
• Применяйте PPO-based RLHF, когда необходимо проводить онлайн-отбор примеров на основе явно выученной награды, и при этом возможен мониторинг процесса эксплуатации награды.

По умолчанию для всех задач значение равно «нет». Необходимо сохранять базовый уровень, рассчитанный исключительно с использованием SFT, и отчитываться как о метриках задач, так и о метриках предпочтений.

Файн-тюнинг фреймворки

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

Unsloth — высокая скорость и эффективность использования памяти

Unsloth интегрируется с Hugging Face trl и transformers и предоставляет оптимизированные ядра, механизмы сохранения состояния и квантированные пути файн-тюнинг для поддерживаемых модели.

• Специализированные ядра Triton GPU для аттеншн, RoPE и функции кросс-ентропии, которые исключают избыточные затраты, связанные с PyTorch.
• Эффективный по использованию памяти алгоритм обратного распространения ошибки, при котором активации пересчитывается во время обратного прохода вместо хранения в оперативной памяти.
• Объединённые операции, позволяющие объединить несколько этапов (нормализацию слоя + линейную преобразование и т. д.) в один вызов GPU.
• 4-битная кодировка квантизация, интегрированная непосредственно в путь обработки QLoRA с использованием оптимизированной процедуры деквантизации.

[!ВАЖНО] Порядок импорта имеет значение Следуйте порядку импорта из примера Unsloth для выбранной вами версии. Unsloth применяет патчи во время импорта, поэтому его необходимо импортировать раньше trl и transformers исключает пропуск оптимизаций или ошибки, связанные с конкретной версией.

# ✅ Correct order
from unsloth import FastLanguageModel  # Must be first!
from trl import SFTTrainer
from transformers import TrainingArguments

# Avoid this order with Unsloth's patched path
from trl import SFTTrainer
from unsloth import FastLanguageModel

Идеально подходит для: одиночной GPU обучающей сессии, разработки прототипов, ноутбуков Colab и всех, кто следит за счетами за использование GPU.

Значения скорости обработки и объёма памяти, указанные в документации, могут сильно отличаться в зависимости от модель, длины последовательности, режима обработки пакетами данных, уровня точности и характеристик аппаратного обеспечения. Вместо того чтобы рассматривать приведённые в заголовках коэффициенты как неизменную фреймворк характеристику модели, необходимо измерять фактическую скорость выполнения операций в Бенчмарк токены в секунду и максимальный объём используемой памяти при конкретном запуске.

Axolotl — обучение на основе конфигурации

# config.yaml - no code required
base_model: meta-llama/Meta-Llama-3-8B
adapter: qlora
lora_r: 32
lora_alpha: 16
datasets:
    - path: data/my_data.jsonl
      type: alpaca
sample_packing: true

Запустить с: accelerate launch -m axolotl.cli.train config.yaml

Идеально подходит: для декларативных, воспроизводимых запусков, а также благодаря встроенным опциям запуска для распределённого обучения.

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

Сравнение Фреймворк

Практическая демонстрация: файн-тюнинг с Unsloth

Вот полный пример из моего unsloth-finetune-demo хранилище данных. В демонстрации происходит финтюнинг модели Nemotron-Nano под function calling.

Быстрое начало

# Clone and setup
git clone https://github.com/slavadubrov/unsloth-finetune-demo.git
cd unsloth-finetune-demo

# Install with uv (recommended)
uv sync

# Run fine-tuning (quick test)
uv run finetune --max-samples 1000

Конфигурация

Интересные аспекты находятся в config.py:

# Model & Dataset
MODEL_NAME = "nvidia/Llama-3.1-Nemotron-Nano-4B-v1.1"  # 4B params, 128K context
DATASET_NAME = "glaiveai/glaive-function-calling-v2"   # 113K examples

# LoRA Configuration
LORA_R = 16        # Adapter capacity; tune against held-out results
LORA_ALPHA = 32    # Update scaling; alpha/r is the classic LoRA scale
MAX_SEQ_LENGTH = 4096

# Candidate modules for this Llama-family model
LORA_TARGET_MODULES = [
    "q_proj", "k_proj", "v_proj", "o_proj",
    "gate_proj", "up_proj", "down_proj",
]

[!NOTE] Соотношение альфа к рангу alpha/r масштабирует традиционную процедуру обновления LoRA. alpha = 2r Это распространённая исходная гиперпараметризация, часто упоминаемая в документации некоторых инструментов, однако она не является гарантией стабильности работы. Изменять параметры порядка сканирования, значения альфы, скорости обучения и целевые модули следует только после того, как данные и базовая конфигурация будут определены.

Основной код обучения

from unsloth import FastLanguageModel
from trl import SFTConfig, SFTTrainer

# Load model with 4-bit quantization
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="nvidia/Llama-3.1-Nemotron-Nano-4B-v1.1",
    max_seq_length=4096,
    load_in_4bit=True,
)

# Add LoRA adapters
model = FastLanguageModel.get_peft_model(
    model,
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                    "gate_proj", "up_proj", "down_proj"],
    use_gradient_checkpointing="unsloth",  # Lower activation memory; extra compute
)

# The data step creates versioned train_dataset and eval_dataset objects.
# Each row has the chat messages and tool schemas expected by current TRL.

# Train with the current TRL configuration surface.
trainer = SFTTrainer(
    model=model,
    processing_class=tokenizer,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset,
    args=SFTConfig(
        output_dir="outputs/nemotron-function-calling",
        max_length=4096,
        packing=True,
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        learning_rate=2e-4,
        num_train_epochs=3,
        bf16=True,
    ),
)
trainer.train()

Файн-тюнинг с Axolotl

[!NOTE] Вскоре появится демо Я работаю над практическим демонстрационным примером на Axolotl. До его готовности… Руководство по ускорению n-мерного параллелизма Документ Hugging Face является хорошим источником информации по стратегиям обучения с использованием нескольких GPU.

Для конфигурационно-ориентированных и распределённых архитектур Axolotl обеспечивает воспроизводимость рабочего процесса:

# axolotl_config.yaml
base_model: meta-llama/Meta-Llama-3-8B
model_type: LlamaForCausalLM

# QLoRA configuration
load_in_4bit: true
adapter: qlora
lora_r: 32
lora_alpha: 16
lora_dropout: 0.05
lora_target_modules:
    - q_proj
    - k_proj
    - v_proj
    - o_proj
    - gate_proj
    - up_proj
    - down_proj

# Dataset
datasets:
    - path: data/training_data.jsonl
      type: alpaca

# Training settings
sequence_len: 4096
sample_packing: true # Benchmark with your length distribution
micro_batch_size: 2
gradient_accumulation_steps: 4
learning_rate: 0.0002
num_epochs: 3

# Precision and attention path; verify support on the pinned stack
bf16: true
flash_attention: true

Запустить обучение:

axolotl train axolotl_config.yaml

Этап 5: Оценка

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

Отслеживайте четыре группы:

1. Целевая задача: точное совпадение, успешная эксплуатация, оценка по шкале человека или любой другой результат, связанный с конкретным случаем применения.
2. Регрессия: общие способности системы и ранее поддерживаемые типы задач, которые могут пострадать в результате адаптации.
3. Безопасность и политика: отказы в выполнении запросов, утечки данных, промпт-инъекция или ограничения, характерные для конкретной области применения.
4. Эксплуатация: латентность, throughput, объём памяти, размер генерируемых результатов и затраты при заданной конфигурации сервинг.

Автоматизированный бенчмарки

Использовать lm-evaluation-harness для соответствующих стандартизированных задач, а не в качестве замены оценке продукта:

lm_eval --model hf \
    --model_args pretrained=./outputs/merged-model \
    --tasks hellaswag,arc_easy,mmlu \
    --batch_size 8

LLM в качестве джадж

Для оценки субъективного качества более крупный модель может помочь в формировании баллов, однако его необходимо калибровать на примерах, проверенных людьми, при этом идентичность кандидата должна оставаться скрытой:

judge_prompt = """
Rate this response from 1-5 on:
- Relevance
- Accuracy
- Formatting

Response: {model_output}
Expected: {ground_truth}
"""

Оценка в узкоспециализированной области

Обеспечьте наличие реальных примеров по источнику, пользователю, документу или временной шкале в таком близком расположении друг к другу, чтобы почти идентичные данные не могли попасть в разные группы после разделения. Что касается function calling, необходимо проверить всю цепочку операций: выбор инструмента, аргументы, результат выполнения, процедуру восстановления и окончательный ответ. При небольшом объёме выборки следует указывать диапазоны уверенности или количество успешных/неудачных случаев, а также тщательно анализировать каждую тенденцию изменения в критически важном сегменте данных.

Этап 6: Деплой и форматы вывода

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

1. Адаптер LoRA

uv run finetune  # Saves ~100-500MB adapter

• Размер: пропорционален целевым модулям, рангу, слоям и типу данных; зачастую значительно меньше базовой версии.
• Идеально подходит для: разработки, версионируемых адаптеров задач, а также движков, которые напрямую поддерживают LoRA.
• Дополнительное преимущество: можно заменять адаптеры без необходимости повторного загрузки базового модель.

2. Объединённый модель

uv run finetune --merge  # Creates a standalone full model

• Размер: примерно полная база чекпоинт при выбранной точности вывода.
• Идеально подходит для: движков или путей распространения, которые не поддерживают отдельный адаптер.
• Компромисс: более крупный результат и медленнее внедрение; проще однократное загрузчик модель.

3. Формат GGUF

uv run finetune --gguf q4_k_m  # Creates ~2-4GB quantized model

• Размер: зависит от модель; примерно четыре бита веса плюс метаданные для вариантов Q4.
• Идеально подходит для: CPU инференс, Ollama, llama.cpp, edge деплой.
• Опции: q4_k_m (меньший размер), q5_k_m (более высокая вес точность воспроизведения). q8_0 (более крупный масштаб и высокая фидельность). Оцените влияние данной операции на качество результата после её выполнения.

Этап 7: Сервинг и мониторинг

С vLLM

# Serve the base and expose a PEFT adapter as a model name.
vllm serve nvidia/Llama-3.1-Nemotron-Nano-4B-v1.1 \
    --enable-lora \
    --lora-modules function-calling=./outputs/adapter \
    --host 0.0.0.0 \
    --port 8000 \
    --max-model-len 4096

Запрос через совместимый с OpenAI интерфейс API:

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="dummy")
response = client.chat.completions.create(
    model="function-calling",
    messages=[{"role": "user", "content": "Book a flight to Tokyo"}]
)

С Ollama (локально)

# Create Modelfile
echo 'FROM ./outputs/unsloth-nemotron-function-calling-gguf/model-q4_k_m.gguf' > Modelfile

# Import to Ollama
ollama create my-function-model -f Modelfile

# Run
ollama run my-function-model

С llama.cpp (CPU)

./llama-cli -m ./outputs/model-q4_k_m.gguf \
    -p "What's the weather in Tokyo?" \
    --ctx-size 4096

Осуществляйте мониторинг выпущенного модель

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

Основные выводы

1. Доработку следует проводить только после того, как ненастроенная базовая модель вместе с таксономией сбоев покажут, что адаптация вес действительно решает поставленную проблему.
2. Retrieval отвечает за обработку меняющихся данных; constrained decoding — за синтаксис; ни один из этих механизмов не заменяется на SFT.
3. LoRA сокращает объём параметров, подлежащих обучению. Кроме того, QLoRA компрессирует замороженную базовую часть веса. Не стоит приписывать показатели памяти, связанные с QLoRA, модели LoRA.
4. Покрытие данных, целостность разделений, происхождение информации и маскировка потерь имеют гораздо большее значение, чем простое копирование конфигурации какого-либо модного оптимизатора.
5. DPO, ORPO и методы RLHF, основанные на PPO, представляют собой разные экспериментальные подходы, а не иерархию качества с универсальным стандартом.
6. Оценка целевого поведения, возможных регрессий, уровня безопасности и работоспособности должна проводиться на основе одной и той же базовой модели модель.
7. Перед началом обучения необходимо выбрать адаптер, объединённую версию или результат GGUF в соответствии с требованиями к сервинг и механизмам отката.

Список литературы

Статьи и исследования

• LoRA: Адаптация крупных языковых моделей с низким рангом Модели
• QLoRA: Эффективная настройка параметров для квантизированных LLMs
• DoRA: Вес — адаптация с низким рангом с использованием декомпозиции
• DPO: Оптимизация прямых предпочтений
• ORPO: Оптимизация предпочтений по коэффициенту шансов
• PPO: алгоритмы оптимизации политики с проксимальными функциями — OpenAI, 2017

Инструменты обработки данных

• DataTrove — Hugging Face обработка данных в крупном масштабе Distilabel — Генерация синтетических данных (Argilla)
• Обработка профиля — Извлечение текста из веб-страниц и краулинг FastText — Идентификация языка в Facebook AI (поддерживает 217 языков) Microsoft Presidio — Обнаружение и анонимизация PII
• scrubadub — Библиотека на Python для удаления PII

Constrained decoding

• xgrammar — Constrained decoding с автоматами состояний контурная структура — Структурированное генерирование для LLMs

Обучение фреймворки

• Unsloth — Оптимизированные файн-тюнинг фреймворк
• аксолотл — Обучение на основе конфигураций и распределённые запускающие механизмы
• TRL — Hugging Face SFT и библиотека для обучения на основе предпочтений Торчтюн — PyTorch-нативная библиотека файн-тюнинг

Инференс и деплой

• адаптеры vLLM LoRA — Обслуживать один или несколько адаптеров с базовым модель Ollama — Локальный запускающий процессор LLM для Mac/Windows/Linux
• llama.cpp — CPU/GPU инференс в формате GGUF

Оценка

• оценка LM-моделей-харнесс — EleutherAI унифицировал процедуры тестирования на соответствие стандарту LLM.

Руководства и ресурсы

• Репозиторий демонстрации — Практический пример файн-тюнинг LLM Файн-тюнинг. Теоретическая интуиция и практическая реализация — Исследовательский ноутбук NotebookLM
• Руководство по ускорению n-мерной параллельности — Hugging Face стратегии многократной GPU обучающей сессии