CrowsHaveEyes

Сразу стоит отметить важную деталь: речь идет не об обычной post-training квантизации, когда вы берете веса в FP16 и квантуете в GGUF или GPTQ. Хотя такие веса, безусловно, имеют практическое применение для множества задач, они страдают падением качества, это хорошо заметно на бенчмарках ниже.

Традиционный путь - QLoRA

Для квантизации применили два разных подхода, во-первых, QLoRA - знакомую методику, когда после квантизации матриц весов в 4bit к ним применяется low-rank-adaptation. Этот подход по-прежнему является очень эффективным и показал лучшие результаты на бенчмарках.

QLoRA достаточно легко выполнить самому, но для этого нужен подходящий графический процессор, базовая модель с весами в 16 битном разрешении и датасет. То есть веса модели сжимают в 4bit и файнтюнят на данных с применением LoRA, low-rank adaptation. Иными словами, обучаются только параметры LoRA-адаптеров - матриц более низкого порядка. Такой умный файнтюнинг дает то, что вы увидите ниже на приведенных бенчмарках - QLoRA-модель по качеству очень близка к весам в оригинальном разрешении.

Тем не менее, для этого метода все-таки необходима видеокарта - она должна иметь достаточно памяти, чтобы вместить веса в четырехбитном формате. Я арендую GPU в облаке для файнтюнинга с использованием QLoRA, и чаще всего я работаю с 8B моделями, так что мощности не такие уж огромные.

Усовершенствованная post-training квантизация: SpinQuant

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

Проблема квантизации - это значения-аутлаеры, которые сильно выбиваются из среднего диапазона датасета. Они могут быть причиной потери точности предсказания после квантизации. Для борьбы с ними применяют различные способы уменьшения разброса значений в матрице X - таких как нормализация или перемножение X на матрицу ротации. Подробнее об этом читайте в статье по SpinQuant.

Есть открытый репозиторий на Python и Pytorch, который предлагает реализацию SpinQuant, совместимую с ExecuTorch и Llama Stack. С его помощью удобно квантовать веса под разные платформы, включая мобильные.

Вот результаты подробного сравнения моделей с разными типами квантизации. Представлены метрики, полученные на несжатых весах в BF16, на весах после обычной post-training квантизации - здесь заметно падение качества - и на весах после SpinQuant и QLoRA. Последние, особенно QLoRA, на бенчмарках показывают результаты очень близко к оригинальной модели.

У SpinQuant и QLoRA примерно одинаковая скорость инференса, хотя QLoRA потребляет чуть больше памяти. Скорость более чем в два раза выше, чем у несжатых BF-16 весов.

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

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

Архитектура мультимодальных моделей Llama 3.2 - вопрос интересный, но в этой статье я хочу рассказать и о прикладной стороне, то есть о разработке AI приложений с использованием этих моделей.

Создатели Llama предложили Llama Stack - фреймворк для работы с их моделями, который позволяет деплоить многофункциональные API (для инференса, систем агентов, генерации собственных данных для обучения и других задач). У Llama Stack есть несколько клиентских SDK, в том числе на Python. С недавнего времени поддерживается мобильная платформа iOS - потому что модели Llama 3.2 1B и 3B могут работать на мобильном девайсе. Это обычные текстовые, только очень легковесные модели. По качеству сопоставимы с Gemma 2 и Phi-3.

Но если вас интересует именно мультимодальная Llama 3.2, то для ее деплоя на Llama Stack потребуется GPU -  особенно для версии 90B. Я развернул Llama Stack с мультимодальной 11B в облаке на видеокарте RTX 4090 и протестировал через Inference API и Python-клиент. По моим впечатлениям, и модель, и API вполне себе готовы к запуску в продакшен. Llama Stack поддерживает разнообразные API-бэкенды, как self-hosted (например, TGI) так и cloud-hosted (AWS Bedrock, Together и другие).

Если вам нужно развернуть Llama Stack на своей виртуальной машине - вот как я это сделал в GPU облаке. Кстати, видеокарты RTX 4090 более чем достаточно для работы мультимодальной 11B. Если хотите версию 90B, можете выбрать другой GPU или несколько. Llama Stack поддерживает мульти-GPU и квантизацию.

Я установил фреймворк, используя anaconda, но есть и вариант для тех, кто предпочитает докер. Мой тест модели и фреймворка можно посмотреть в этом видео:

Из минусов фреймворка - не помешала бы более подробная документация. В репозитории Llama Stack есть пример из демо - приложение-помощник дизайнера интерьера. Оно демонстрирует несколько концепций фреймворка, в том числе - создание и конфигурация агента, мультимодальный инференс, работа с памятью и RAG.

Чем хорошо наличие еще одного фреймворка для Generative AI? На первый взгляд функционал Llama Stack напоминает то, что уже было до него - LangChain, LlamaIndex и другие подобные фреймворки. Хорошо то, что этот инструмент является частью экосистемы Llama и, вероятно, станет официальным открытым API последующих версий ламы. Прицел на кроссплатформенность и многозадачность говорит о том же. Ранние доморощенные решения, скорее всего, перестанут быть актуальными, что относится и к моему собственному фреймворку - gptchain. Однако это верный признак того, что прикладная отрасль Generative AI становится более зрелой.

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

Досадно то, что OpenAI не открыли доступ к своим цепочкам рассуждений, которыми оперирует o1. Официальная причина - рассуждения модели не цензурируются, чтобы они не потеряли эффективность. Так что пользователь видит только краткое саммари и финальный ответ. Но основная причина того, что цепочки мыслей скрыты, это защита от конкурентов, как легко догадаться. Используя тот же подход обучения с подкреплением и данные цепочек мыслей, можно было бы обучить открытую модель генерировать их так же, как это делает o1.

Впрочем, рано или поздно это все равно произойдет. Недавно компания SambaNova опубликовала демо на HuggingFace - Llama-3.1-Instruct-O1. Как становится понятным из названия, они использовали модель Llama-3.1-Instruct, а именно версию 405B. Модель работает со сложным системным промптом, который заставляет ее строить цепочки мыслей, что похоже на o1. Этот эксперимент показывает достаточно хорошие результаты. Осталось улучшить способность Llama или другой открытой модели генерировать собственные цепочки мыслей путем обучения или файнтюнинга.

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

Скорость генерации становится особенно важной для моделей рассуждений типа o1. Качество ответа повышается пропорционально времени, которое модель тратит на обдумывание проблемы. Но ждать ответа часами пользователь не может, поэтому например SambaNova для своего демо использовали собственный AI-чип SN40L, с помощью чего удалось достичь скорости генерации 129 токенов в секунду. Еще один известный стартап в области AI-чипов, который преодолевает лимит скорости генерации - Groq. Такие решения понадобятся для инференса "думающих" языковых моделей.

Docker

Первым шагом будет установка Docker на наш сервер. Я использовал Docker для запуска контейнера vLLM. Docker позволяет существенно упростить установку.

Запуск vLLM

Команда для запуска vLLM будет выглядеть следующим образом:

sudo docker run --ipc=host --log-opt max-size=10m --log-opt max-file=1 --rm -it --gpus '"device=0,1,2,3"' -p 8000:8000 --mount type=bind,source=/home/ubuntu/.cache,target=/root/.cache vllm/vllm-openai:v0.5.4 --model hugging-quants/Meta-Llama-3.1-405B-Instruct-AWQ-INT4 --tensor-parallel-size 4 --gpu-memory-utilization 0.94 --dtype half -q awq --disable-log-requests

После запуска к серверу можно слать запросы в OpenAI формате. На клиентской части используются библиотеки OpenAI. Многие программисты уже имеют такой опыт при обращении к ChatGPT по API.

Выводы

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

Стоимость аренды сервера составляет около 800 рублей в час. Если снимать сервер на длительное время, то стоимость может быть снижена до 50%. Стоимость внешних API для доступа к Llama 405b начинается от 3 долларов за миллион токенов. Если у вас нет требований к приватности данных или количество запросов относительно небольшое, то проще и выгоднее использовать внешние сервисы, которые предлагают доступ к нейросетям по API.

Теперь о минусах модели Llama 3.1 - файнтюнинг 405B версии обойдется дорого, так как даже при сжатии в 4bit необходимо выделить около 200 ГБ VRAM для такой задачи. Поэтому я файнтюнил версию 8b на вышеупомянутом датасете, арендуя две видеокарты A100 на облачном сервисе immers.cloud. Но я не заметил особого превосходства версии 3.1 над третьей версией. Даже наоборот, я столкнулся с несколькими проблемами - например, 3.1 после файнтюнинга на моем датасете показала тенденцию прерывать генерацию, не завершив ответ - до причины я так и не докопался, но у Llama 3 такой проблемы не было.

Кстати, если вам тоже кажется неподъемной версия 405B для запуска на своем железе, стоит обратить внимание на модель Mistral Large 2, которая вышла почти одновременно с Llama 3.1. У этой модели 123 миллиарда параметров - в три с лишним раза меньше, чем у Llama 3.1 405B. Но вот интересные результаты бенчмарков, по которым можно сравнить эти две модели.

Мистраль побеждает ламу на MT-Bench:

А также на задачах по генерации кода и математике:

При этом очевидно, что инференс Mistral Large 2 обходится дешевле.

Я еще не пробовал файнтюнинг Mistral - у Llama, на мой взгляд, больше инструментов для этого, включая официальные скрипты llama-recipes, которые поддерживают FSDP - Fully-Sharded Data Parallel, эффективный способ распределенного файнтюнинга, когда на нескольких видеокартах параллелятся не только данные (в отличие от DDP - Distributed Data Parallel), но и параметры и градиенты модели.

Так что по крайней мере 8B версия llama 3 и 3.1 остается отличным материалом для ИИ разработки, при ее легковесности и высокой производительности.

В этот раз я обучил параллельно на двух GPU, для этого я задал новую конфигурацию моей Виртуальной Машины - две NVIDIA A100.

Я воспользовался инструментом axolotl, который позволяет быстро сконфигурировать и запустить сессию обучения.

Мой конфиг axolotl здесь.

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

accelerate launch -m axolotl.cli.train config.yaml

Accelerate - это Huggingface библиотека для распределенного обучения.

axolotl запустил два параллельных процесса с шардами модели для каждого из двух GPU. Обучение на одну эпоху длилось около часа, итоговый train loss - 0.8.

Результат превзошел мои ожидания - третье место в mt_bench:

Моя модель превзошла llama-3-8b-instruct и большинство версий Suzume, кроме самой сильной из них. Это на англоязычном бенчмарке.

Теперь - результат ru_mt_bench:

Моя модель получила оценку 8.12, немного не дотянув до Suzume и превосходя gpt-3.5-turbo, у которой 7.94.

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

Я не увеличивал англоязычную выборку в своем датасете, там всего тысяча примеров на английском, а англоязычный MT Bench неожиданно показал среднюю оценку 8 баллов. Это значит, что добавление большего количества качественных мультиязычных данных повышает общее качество модели, а не только ее показатели для этого конкретного языка. Эта эффект уже был показан в статье Петера Девина - Tagengo: A Multilingual Chat Dataset

Я очень рад, что мне удалось наблюдать реализацию этой идеи на практике. Мой датасет, веса модели, а также файлы в формате GGUF опубликованы в моем Huggingface аккаунте.

Модель: https://huggingface.co/ruslandev/llama-3-8b-gpt-4o-ru1.0

GGUF: https://huggingface.co/ruslandev/llama-3-8b-gpt-4o-ru1.0-gguf

Датасет: https://huggingface.co/datasets/ruslandev/tagengo-rus-gpt-4o

Как именно я настраиваю свое ML окружение, я описал в этом гайде.

Если вы знакомы с терминалом Linux, развертывание виртуальной машины с H100 на облаке, установка пакетов и конфигурация процесса обучения - например, в виде Unix-демона, как это сделал я - не составит для вас труда.

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

Наглядный пример преимущества скорости, которое H100 дает при обучении большой модели Llama 3 70B по сравнению с A100, был показан в моем видео:

Файнтюнинг и квантизация Llama-3 70B

По результатам этого примера, обучение Llama 3-70B на GPU H100 потребовало 7 часов, чтобы выполнить 2400 итераций:

График обучения

По сравнению с другими моделями H100 показала явное превосходство в скорости.

Но Flops - это не единственный параметр, который мне приходится учитывать при обучении нейросетей. Объем видеопамяти и пропускная способность видеокарты - два очень важных показателя. Первый определяет, сможете ли вы вместить веса своей модели в память GPU. А второй - с какой скоростью батч, или "кусок" данных, за одну итерацию обучения передается из видеопамяти в кэши и регистры ядер GPU, где происходит перемножение матриц, о котором речь ниже.

У H100 размер видеопамяти - 80 гигабайт - и пропускная способность - 2 терабайта в секунду - не отличаются от соответствующих параметров модели A100. Этих значений достаточно, чтобы обучать такие большие модели, как Llama 3 70B. Но с увеличением размера батча данных увеличивается размерность матрицы, которую перемножает GPU, а для этого нужно больше Flops, и здесь H100 проявляет себя, устраняя барьер скорости.

А дальше немного общей справочной информации.

При обучении трансформер выполняет операцию перемножения матриц - matmul, в очень тяжеловесных масштабах. Даже "небольшие" AI-модели имеют по 7-8 миллиардов параметров, которые перемножаются с вектором переданного на вход батча при каждой итерации обучения, а число итераций зависит от числа этих батчей, т. е. от объема данных. Этот объем при обучении современных базовых, или foundational моделей может достигать размеров Интернета - скажем, текстовый корпус Llama 3 содержит 15 триллионов текстовых токенов.

Конечно, не все задачи, связанные с AI, имеют такие эпические масштабы. LoRA предлагает эффективный способ уменьшения числа обучаемых параметров путем конвертации весов в матрицы низшего порядка. А при наличии уже обученной foundational модели чаще всего моя задача сводится к файнтюнингу на совсем небольшом наборе данных, условно от 10 до 100K примеров.

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

Благодарю за внимание, надеюсь, мой опыт поможет вам при выборе видеокарт для ML-приложения.

Ruslan Dev