CrowsHaveEyes

Llama 3.1 поддерживает семь языков, кроме английского - французский, немецкий, хинди, итальянский, португальский, испанский и тайский. Русского в списке нет, как легко заметить, но это не значит, что в корпусе базовой модели нет примеров на русском. Есть, и предостаточно, это становится очевидно при файнтюнинге. У меня есть мой собственный датасет для файнтюнинга ruslandev/tagengo-rus-gpt-4o, который я сгенерировал из преимущественно русскоязычных промптов датасета Tagengo с помощью GPT-4o.

Теперь о минусах модели 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 остается отличным материалом для ИИ разработки, при ее легковесности и высокой производительности.

В итоге я получил датасет ruslandev/tagengo-rus-gpt-4o и приступил к обучению.

Для этого я создал Виртуальную Машину с NVIDIA H100, используя сервис immers.cloud. Для достижения наилучших результатов по instruction-following (что проверяется на MT-Bench) я взял в качестве исходной модели meta-llama/Meta-Llama-3-8B-Instruct. Именно на ней обучена модель Suzume, у которой высокая оценка на MT Bench. Предыдущие эксперименты показали, что базовая Llama-3 8B, а особенно ее четырехбитная версия для QLoRA - unsloth/llama-3-8b-bnb-4bit - значительно отстает по оценкам бенчмарка.

В этот раз я обучил параллельно на двух 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

Вычислительную способность графического процессора оценивают по числу операций с плавающей точкой в секунду, Flops. Именно в этом отношении H100 является лидером и вдвое (1.5K TFlops) превосходит модель-предшественника A100. Зачем нужно так много операций с плавающей точкой, читайте ниже, где я привел немного справочной информации.

Деплой базовой модели и инструментов для обучения на облачной платформе осуществляется достаточно просто - можно выбрать предустановленный образ Ubuntu с CUDA. Для конфигурации окружения остается установить Pytorch/Tensorflow/Jax и другие нужные библиотеки.

Как именно я настраиваю свое 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

Первую фазу создания LLM - сбор данных - я уже упомянул, за ней следует собственно обучение (точнее, файнтюнинг), evaluation (оценка) и квантизация. Индустрия AI пока формируется, и среди инструментов для разработки LLM нет единого стандарта - для каждой из этих фаз программисты используют то, что им подходит. Я считаю, что наличие фреймворка, предлагающего стандартную реализацию вместо беспорядочного скриптинга, не повредит инновациям - даже наоборот. Поэтому две наиболее сложные в вычислительном плане фазы разработки - обучение и квантизацию модели - я реализовал в моем фреймворке gptchain.

Что касается сбора данных, этот процесс в рассмотренном случае сводится к выполнению запросов к API GPT-4o, для чего я написал отдельный скрипт - он прилагается к моему датасету, опубликованному на Huggingface.

Промпты я взял из мультиязычного датасета Tagengo. При этом я решил отфильтровать промпты, на которые модель отвечает типа - извините, не могу с этим помочь. Чаще всего это потому, что промпт не проходит цензуру.

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

После получения ответа на каждый промпт все диалоги мержатся с помощью Pandas, а затем конвертируются в датасет в формате Huggingface. Как видите, скрипт для сбора данных функционально получился достаточно простой. Суть идеи в том, что громко анонсированная модель GPT-4o с улучшенными мультиязычными возможностями поможет существенно улучшить навыки ламы-3 справляться с задачами на следование инструкциям.

Для фазы обучения я использовал виртуальную машину с GPU NVIDIA H100 на облачном сервисе immers.cloud. Как настроить виртуальную машину, установить виртуальное окружение python и необходимые пакеты, я рекомендую прочитать в этой статье или посмотреть видео.

Я добавил поддержку своего нового датасета в gptchain, который, как и Tagengo, загружается с Huggingface в ShareGPT формате, а затем конвертируется моим фреймворком в ChatML.

Я обучал на 3 эпохи. Так как датасет маленький - 3 тысячи примеров, 3 эпохи не заняли много времени - примерно полчаса. Следует учесть, что это для Llama-3 8B, QLoRA с 4-битной квантизацией.

Как показывают метрики wandb, после трех эпох обучения train loss уменьшился с 1.4 до 0.8.

Прежде, чем перейти к следующей фазе - оценке модели на бенче, давайте сравним ее инференс с моими предыдущими экспериментами, чтобы почувствовать разницу чисто субъективно.

После файнтюнинга на датасете Tagengo (состоящем из ответов GPT-4):

Я: Из чего состоит нейронная сеть?

ИИ: Нейронная сеть состоит из нескольких основных компонентов, которые работают вместе для обработки и анализа данных. Вот основные компоненты нейронной сети:

**Нейроны (или узлы)**: Это основные вычислительные единицы нейронной сети. Нейроны принимают входные данные, обрабатывают их и генерируют выходные данные. [...]

После файнтюнинга на моем датасете (на ответах GPT-4o):

Я: Из чего состоит нейронная сеть?

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

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

Какой ответ лучше, оставлю судить вам. Важно отменить, что для генерации первого ответа использована Llama-3 70B, второго - Llama-3 8B.

Теперь пора оценить мою новую модель. Я использовал мультиязычный MT-Bench, и генерация ответов на тестовые вопросы на английском и на русском заняла у меня больше времени, чем сам файнтюнинг.

Кстати, техническую инструкцию, как выполнить мультиязычный MT-Bench на своей модели, смотрите в этой статье.

Результат моей модели на английском бенче составил 6.6, это значительно хуже, чем у той же Suzume, что впрочем неудивительно - в моем датасете всего тысяча англоязычных ответов, против 15 тысяч в датасете Tagengo.

Я попробовал и русскоязычный бенчмарк ru_mt_bench. На нем я получил 7.3, не так плохо, близко к GPT-3.5, но все еще слабее Suzume.

Подытожим. Для моего эксперимента мне хватило одной Виртуальной Машины с одним H100, но как бы этот процесс выглядел, будь это серьезный продакшн? Очевидно, добавился бы model parallelism - для более серьезного обучения лама параллелилась бы на несколько H100 одновременно. Я не затронул последнюю фазу - квантизацию, которая нужна для деплоя модели на компьютер или сервер пользователя. Для этого хорошо подходит GGUF формат, поддерживаемый библиотекой llama.cpp.

Можно представить, что для "фабрики LLM" наподобие той, что работает за закрытыми дверями "Open" AI, все эти фазы должны быть автоматизированы - включая дата-пайплайн и бенчмарки. Сделать это проще в облаке при наличии фреймворка наподобие gptchain, но все же остается нетривиальной задачей. Все описанные фазы разработки LLM можно посмотреть в действии - в моем последнем видео.

Например, есть GLUE (General Language Understanding Evaluation), оценка общего понимания естественного языка. Оценивает в том числе способность модели отвечать на вопросы, логическую связность и sentiment analysis - умение распознавать эмоциональную окраску. Это обширная область задач, и одного GLUE-бенчмарка явно мало, чтобы как следует оценить общее понимание моделью естественного языка, поэтому существуют другие тестовые наборы, например, SuperGLUE и MMLU (Massive Multitask Language Understanding). Последний бенчмарк оценивает, насколько хорошо в среднем модель понимает сложные вопросы из разных категорий - гуманитарной, социальной, STEM - то есть точные науки и естествознание.

Есть HellaSwag - это интересный бенчмарк, составленный из непростых вопросов, которые проверяют модель на здравый смысл, common sense. HellaSwag датасет содержит текстовое описание события, записанного на видео, и несколько вариантов завершения этого события, только один из которых правильный.

Большой интерес для оценки моделей представляет TruthfulQA -бечмарк, который позволяет понять, насколько модели можно доверять.

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

• недостаток данных по некоторым предметам при обучении

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

От этой проблемы трудно избавиться, и бенчмарк TruthfulQA призван выявить ложные ответы модели, даже если они звучат убедительно, имитируя правду.

Естественно, возникает вопрос, как именно авторы TruthfulQA определяют, что правда, а что нет.

Принцип такой: если ответ буквально описывает реальное явление без искажений, то это правда. Даже если утверждение не относится к теме вопроса. То есть модель может все время отвечать: "Курица - это птица" и у нее будет высокая оценка. Модель может просто говорить "я не знаю", это тоже не будет ложью.

Поэтому есть еще один критерий - информативность, по которому оценивают, насколько полезен ответ и относится ли он к теме вопроса. Интересно, что когда TruthfulQA впервые появился, в 2021 году, у модели GPT-3 только 58% ответов показали правду на этом бенчмарке, а правдивых и притом информативных ответов было только 21%, то есть примерно один ответ из пяти был реально полезен.

Есть другие бенчмарки для разных задач, например HumanEval и CodeXGLUE на задачи, связанные с программированием и пониманием кода. Есть API-Bank, который оценивает, насколько хорошо модель может интегрироваться с другими системами посредством API. Все это очень актуально для систем вроде того же GPT-4 Omni, которые используют веб-поиск, вызов функций, Retrieval Augmented Generation и так далее.

Но сегодня я хочу остановиться на одном бенчмарке и продемонстрировать evaluation на нем -MT-Bench (Multi-Turn Benchmark). Он тестирует поведение модели в разных ситуациях, которые могут возникнуть в диалоге. Набор промптов содержит разные категории запросов - гуманитарные, математические, кодинг и другие.

Меня особенно интересует мультиязычный MT-Bench. Чтобы оценить с его помощью свою модель, я склонировал код бенчмарка с Github:

git clone https://github.com/Peter-Devine/multilingual_mt_bench.git

Еvaluation скрипты находятся в папке multilingual_mt_bench/fastchat/llm_judge. Но сначала нужно сначала установить зависимости. Для этого склонируйте другой репозиторий -

git clone https://github.com/lm-sys/FastChat.git

cd FastChat

pip install -e ".[model_worker,llm_judge]"

Теперь можно приступить к оценке на MT-Bench. Первый скрипт из указанной выше папке скачивает веса модели, которую хотите оценить, и генерирует ответы на вопросы берчмарка. Например:

python gen_model_answer.py --model-path lightblue/suzume-llama-3-8B-multilingual \

--model-id suzume-llama-3-8B-multilingual

Здесь аргументом --model-path я передал путь к весам модели на Huggingface, а --model-id - это имя модели, под которым я сохраню файл с ее ответами на вопросы бенчмарка.

После завершения скрипта - на видеокарте A100 в облачном сервисе immers.cloud, модель с 8 миллиардами параметров справилась с бенчмарком за 23 минуты - файл с ответами сохранился в папку data/mt_bench/model_answer.

Важно отметить, что вопросы и ответы в файле - на английском. Но, как я уже сказал, это мультиязычная версия MT-Bench, и здесь можно сгенерировать отдельный файл ответов, например, на русском:

python gen_model_answer.py --model-path lightblue/suzume-llama-3-8B-multilingual \

--model-id suzume-llama-3-8B-multilingual \

--bench-name ru_mt_bench

Теперь нужно оценить, насколько хорошо справилась модель. Второй скрипт позволяет использовать сильную LLM, например GPT-4, в качестве судьи - она получит на вход пару вопрос-ответ из файла, сгенерированного на предыдущем шаге, и выставит оценку по 10-балльной шкале, а также напишет свой комментарий, объясняющий оценку.

export OPENAI_API_KEY=XXXXXX # экспортируйте свой ключ OPENAI_API_KEY

python gen_judgment.py --model-list suzume-llama-3-8B-multilingual \

--parallel 2

Аргументом --model-list передаете список имен моделей (через пробел), ответы которых хотите оценить. Для каждой модели должен быть сгенерирован файл ответов.

По умолчанию судьей будет GPT-4, но вы можете передать аргумент --judge-model, чтобы использовать в качестве судьи другую модель. Например, почему бы не последнюю GPT-4o?

Аргумент --parallel устанавливает число параллельных вызовов API.

Когда оценка закончится, появится файл в папке data/mt_bench/model_judgement. В нем вы можете найти оценки каждой пары с комментариями модели-судьи.

Теперь можете выполнить:

python show_result.py

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

Рекомендую посмотреть мое видео, где все описанные шаги продемонстрированы наглядно.

Базовая модель, которую я файнтюнил - unsloth/llama-3-70b-bnb-4bit. Cначала я проверил, как эта модель справляется с русскоязычным промптом, задав ей вопрос - "Из чего состоит нейронная сеть?"

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

Я обратился к облачному GPU сервису immers.cloud. чтобы обучить модель.

Сначала я собирался обучать на нескольких видеокартах параллельно и выбрал два GPU A100 c NvLink.

Однако, я не учел тот факт, что библиотека unsloth, которую я использую в моем фреймворке, еще не поддерживает model parallelism, а это серьезное ограничение. В их дискорде нашел пост, что в ближайшее время обучение на нескольких GPU станет возможным. Если этого не случится, мне придется искать альтернативные пути.

Поскольку файнтюнинг базовой модели Llama 70B c квантизацией в 4 bit на 3 эпохи на одном A100 требует порядка 5 дней, мне пришлось сократить количество шагов обучения.

Также я решил перейти на другую видеокарту - H100, самую мощную из того что есть.

Настройка рабочего окружения у меня довольно простая. Мне нужен только python >= 3.9, а затем клонирую свой фреймворк gptchain с github:

git clone https://github.com/RuslanPeresy/gptchain.git

И устанавливаю его зависимости:

pip install -r requirements-train.txt

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

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

О датасете

Я использовал датасет lightblue/tagengo-gpt4.

На странице датасета заявлено, что "Tagengo - самый большой в мире мультиязычный датасет высокого качества". 78 тысяч примеров диалога на разных языках, включая русский. Здесь есть серьезная выборка на русском - 8 тысяч строк.

Я обучил модель на 2,400 шагов, на это ушло 7 часов на H100.

python gptchain.py train -m unsloth/llama-3-70b-bnb-4bit \

--dataset-name tagengo_gpt4 \

--save-path checkpoints/llama-3-70b-tagengo \

--huggingface-repo llama-3-70b-tagengo \

--max-steps 2400

Если использовать A100, по моим расчетам, потребовалось бы примерно 10 часов.

Я запустил файнтюнинг на Виртуальной Машине в бэкграунд-процессе. Для этого я воспользовался systemd, стандартным способом создания фоновых процессов (демонов) в Linux.

Как настроить фоновый процесс для файнтюнинга через systemd:

Я создал файл gptchain.service в /etc/systemd/system. В него вставил вот такую конфигурацию:

[Unit]

Description=Llama-3-70b finetune

[Service]

WorkingDirectory=/home/ubuntu/gptchain

ExecStart=/home/ubuntu/venv/bin/python gptchain.py train --model_id unsloth/llama-3-70b-bnb-4bit --dataset-name tagengo_gpt4 --save-path checkpoints/llama-3-70b-tagengo --huggingface-repo llama-3-70b-tagengo --max-steps 2400

Type=simple

Restart=no

Здесь главное - команда gptchain.py train, которая запускает файнтюнинг модели.

А теперь нужно выполнить:

sudo systemctl daemon-reload

sudo systemctl start gptchain

И все, остается ждать завершения файнтюнинга, но метрики вроде Train Loss хотелось бы как-то отслеживать. Самое простое - посмотреть логи процесса:

journalctl -u gptchain.service

Чтобы иметь возможность нормально наблюдать метрики, лучше, конечно, использовать wandb или tensorboard.

В этот раз я использовал wandb - просто указал ключ доступа в переменной WANDB_API_KEY в файле .env. Мой процесс подключается к wandb автоматически и экспортирует метрики в реальном времени.

Внутри команды train (вкратце) происходит следующее:

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

Дальше происходит загрузка датасета и приведение к нужной структуре. Данные в Tagengo представлены в виде массивов json, какие принимает и возвращает OpenAI API. Чтобы использовать эти данные для файнтюнинга, я сконвертировал их в формат ChatML. У библиотеки Unsloth есть хорошая поддержка СhatML, что мне очень помогло конвертировать данные из вот этого:

[

{

"from": "human",

"value": "The user’s message goes here"

},

{

"from": "gpt",

"value": ""

}

]

Вот в это:

<|im_start|>user

The user’s message goes here

<|im_end|>

<|im_start|>assistant

Следующее, что происходит в моем коде - конфигурируется экземпляр Supervised Fine-tuning Trainer (SFTTrainer) - класса, предоставленного библиотекой trl. В нем задаются параметры файнтюнинга.

Основные из них:

• learning_rate: 2e-4

• seed: 3407

• gradient_accumulation_steps: 4

• per_device_train_batch_size: 2

• optimizer: adamw_8bit

• lr_scheduler_type: linear

• warmup_steps: 5

• max_steps: 2400

• weight_decay: 0.01

Через семь часов файнтюнинг завершился. Я убедился, что Train Loss медленно, но верно сходится. Хотелось бы обучить на несколько полных эпох, но, как я уже говорил, надо значительно больше GPU часов. Обучать нужно минимум на 2, а лучше на 4 видеокартах параллельно.

Затем я проверил, начала ли Llama следовать инструкциям на русском языке:

python gptchain.py chat -m checkpoints/llama-3-70b-tagengo \

-q '[{"from": "human", "value": "Из чего состоит нейронная сеть?"}]' \

--chatml true

Да, начала - вместо бессмысленных повторений я получил правильный, очень подробный ответ на вопрос "Из чего состоит нейронная сеть?" Рекомендую посмотреть видео, чтобы оценить качество ответа и скорость инференса Llama 3 70B на H100.

Стиль ответа напоминает GPT-4, это длинный детализированный текст. Неудивительно, так как датасет tagengo включает именно ответы GPT-4.

Затем я выполнил квантизацию модели и сконвертировал ее в формат GGUF, чтобы ее можно было запускать без GPU, на обычном процессоре.

Для этого в моем фреймворке есть консольная команда quant. Среди прочих аргументов она принимает метод квантизации. В интерфейсе llama.cpp, который используется под капотом, есть также полезная команда quantize --help, которая покажет много полезной информации по методам квантизации, в том числе какие из них рекомендуются в плане баланса качества модели, скорости инференса и размера файла. Я воспользовался методом q4_k_m:

python gptchain.py quant -m checkpoints/llama-3-70b-tagengo \

--method q4_k_m \

--save-path quants/llama-3-70b-tagengo \

--huggingface-repo llama-3-70b-tagengo-GGUF

Для Llama 3 70B непосредственно квантизация занимает примерно полчаса, перед этим еще произойдет сборка llama.cpp из C++ исходников, что необходимо для конвертации весов модели в GGUF формат.

В итоге вы получите файл gguf в папке quants, его можно запустить с помощью llama.cpp.

Я задал модели тот же вопрос "Из чего состоит нейронная сеть?", и модель начинала генерировать просто completion - завершила фразу, выдала в конце токен end-of-text и остановилась.

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

Я задал формат ChatML вручную и запустил еще раз:

llama.cpp/main -m quants/llama-3-70b-tagengo-unsloth.Q4_K_M.gguf \

-p "<|im_start|>user \nИз чего состоит нейронная сеть?<|im_end|>"

Модель на этот раз поняла, что от нее хотят. Она сгенерировала ответ в нужном формате.

Это такой же развернутый ответ в том же стиле, что у несжатой модели. Но инференс GGUF значительно медленнее, чем на GPU. Зато вы можете запустить этот файл на любом компьютере, лишь бы хватило мощности CPU, иначе инференс будет длиться вечность.

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

Тем не менее, в целом мне понравилось качество ответов обеих моделей - с квантизацией и без. Я бы хотел протестировать свою модель на разных бенчмарках, например MT-Bench, в особенности меня интересуют результаты для русского языка. Это, вероятно, тема для новой статьи. А пока я рекомендую посмотреть видео о том, как происходил файнтюнинг, описанный в этой статье.

Веса моей модели можно скачать с Huggingface:

https://huggingface.co/ruslandev/llama-3-70b-tagengo

https://huggingface.co/ruslandev/llama-3-70b-tagengo-GGUF