Квантование GPTQ на модели Llama 2 7B с Fine-Tuned с использованием HuggingFace

GPTQ quantization on Llama 2 7B model with Fine-Tuned using HuggingFace

Пошаговое руководство по простому и понятному квантованию модели LLM

В моей предыдущей статье я показал вам, как инструкция по настройке новой модели Llama 2, только что выпущенной Meta AI, для создания генератора кода на Python в нескольких строках кода. На этот раз мы расскажем, как квантовать эту модель с использованием квантования GPTQ, которое теперь интегрировано с библиотекой transformers.

На прошлой неделе Hugging Face объявила о совместимости своих библиотек transformers с библиотекой AutoGPTQ, которая позволяет нам квантовать большую языковую модель на 2, 3 или 4 бита с использованием методологии GPTQ.

GPTQ: Квантование после обучения на генеративных моделях

В революционной статье [1] исследователи представили GPTQ, новый метод квантования после обучения, который имеет потенциал изменить мир сжатия языковых моделей. GPTQ достаточно эффективен для применения к моделям с сотнями миллиардов параметров и может достичь замечательной точности, сжимая эти модели до всего лишь 2, 3 или 4 бита на параметр без значительной потери точности.

Эта передовая техника показывает свою способность квантовать массивные модели, такие как OPT-175B и BLOOM-176B, всего за несколько часов работы на GPU, сохраняя минимальную перплексию, строгую меру точности. На практическом фронте исследователи разработали среду выполнения, которая обеспечивает эффективную работу сжатых моделей для генеративных задач. Замечательно, что они достигли важного результата, запустив сжатую модель OPT-175B на одном графическом процессоре NVIDIA A100 или с использованием всего двух более экономичных графических процессоров NVIDIA A6000. Кроме того, оптимизированные под сжатие ядра GPU позволяют значительно ускорить работу сжатых моделей.

• Объяснимость моделей, пересмотренная SHAP и дальше
• Навигация по Датской одиссее главные тенденции аналитики данных на 2023 год
• Как увеличить скорость Pandas и обработать наборы данных из 10 миллионов строк за миллисекунды

Особое внимание привлекает возможность GPTQ квантовать языковые модели с сотнями миллиардов параметров до диапазона 3-4 бит/компонент. Это значительный прогресс, поскольку предыдущие методы имели проблемы с сохранением точности ниже 8 бит и обычно сосредотачивались на более маленьких моделях. Однако исследование также подчеркивает сложные компромиссы между перплексией, шириной бита и размером модели, вызванные сжатием. Однако у этого метода есть ограничения. В настоящее время GPTQ не предлагает ускорения для фактических умножений из-за отсутствия поддержки аппаратуры для операндов смешанной точности на основных архитектурах. Квантование активации также не включено в текущие результаты, но может быть решено с помощью ортогональных техник.

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

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

1. Квантование после обучения (PTQ): В PTQ предварительно обученные модели квантованы с использованием относительно умеренных ресурсов, таких как калибровочный набор данных и несколько часов вычислительного времени. Этот метод особенно полезен для больших моделей, где полная повторная тренировка или настройка может быть слишком затратной.
2. Квантование с учетом обучения (QAT): С другой стороны, QAT включает квантование, применяемое либо перед обучением модели, либо во время последующей настройки.

Инновационный подход GPTQ: GPTQ относится к категории PTQ, что делает его привлекательным выбором для массивных моделей. Отличительной особенностью GPTQ является применение смешанной схемы квантования int4/fp16. Здесь веса модели квантованы как int4, в то время как активации остаются в формате float16. Во время вывода веса динамически деквантовываются, и фактические вычисления выполняются в формате float16.

Этот инновационный подход обещает экономию памяти примерно в 4 раза для квантования int4 и потенциальное ускорение благодаря более низкой пропускной способности, используемой для весов. На практике GPTQ является методом квантования, разработанным для моделей, которые уже настроены и готовы к развертыванию. Этот метод особенно эффективен для уменьшения точности весов модели до 4 или 3 бит, хотя в основном используется для 4-битного квантования.

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

Для более подробного объяснения о GPTQ вы можете прочитать удивительную статью Максима Лабонна «4-битное квантование с помощью GPTQ», опубликованную в Towards Data Science. Это статья, которая углубляется в более технические аспекты для тех, кто желает понять детали этого процесса.

И я настоятельно рекомендую полезную статью «GPTQ или bitsandbytes: какой метод квантования использовать для LLMs – примеры с Llama 2» Бенжамина Мари. Там вы можете увидеть сравнение между квантованием GPTQ и bitsandbytes, их плюсы и минусы, таким образом, вы сможете лучше понять, когда удобнее применять каждую из этих техник.

Когда следует использовать GPTQ?

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

• Настройте исходную модель LLM с помощью bitsandbytes в 4-битном формате, nf4 и QLoRa для эффективной настройки.
• Объедините адаптер с исходной моделью
• Квантуйте получившуюся модель с помощью GPTQ 4-бит

Я выполнил первые два шага в моей предыдущей статье [3], и сейчас, когда библиотека AutoGPT интегрирована с экосистемой Huggingface, мы выполним третий шаг очень простым способом.

AutoGPT интегрирован с Hugging Face transformers

Библиотека AutoGPTQ появляется как мощный инструмент для квантования моделей Transformer, применяя эффективный метод GPTQ. Некоторые усилия, такие как GPTQ-for-LLaMa, Exllama и llama.cpp, фокусируются на квантовании архитектуры Llama, но AutoGPTQ отличается тем, что предлагает безупречную поддержку различного набора архитектур трансформаторов.

Команда Hugging Face сделала значительный шаг, чтобы улучшить доступность GPTQ, и они интегрировали включающий API Transformers, упрощая процесс квантования моделей Low-Level Model (LLM) для широкой аудитории. Эта интеграция включает в себя важные оптимизационные параметры, такие как ядра CUDA, ориентированные на обычные случаи использования.

Для пользователей, которые ищут более продвинутые варианты квантования, библиотека Auto-GPTQ остается ценным ресурсом, предлагающим такие возможности, как ядра Triton и совместимость с объединенным вниманием, обеспечивая гибкость и адаптивность в мире квантования моделей трансформатора.

У нашей интеграции AutoGPTQ много преимуществ:

Квантованные модели сериализуемы и могут быть опубликованы на Hub.

GPTQ существенно снижает требования к памяти для работы с LLM, при этом время вывода находится на уровне FP16-вывода.

AutoGPTQ поддерживает ядра Exllama для широкого спектра архитектур.

Интеграция осуществляется с поддержкой RoCm для графических процессоров AMD.

Доступно донастройка с использованием PEFT.

Извлечено из статьи на блоге Huggingface «Уменьшение веса LLM с помощью AutoGPTQ и transformers» [5].

Наш подход к этой задаче

Сначала мы загрузим нашу настроенную модель Llama 2 7B 4-битного кодера Python в сессию Colab, используя T4 с дополнительной оперативной памятью. Модель загружается в 4-битном формате с помощью bitsandbytes, а затем мы выполним около 12 примеров для измерения времени вывода. Чтобы выполнить простую оценку производительности во время вывода, мы выбрали примеры с текстом ввода длиной более 500 символов, таким образом, мы попытаемся лучше оценить влияние квантования во время вывода.

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

Квантизация модели с использованием auto-gptq, 🤗 transformers и optimum

Квантизация GPTQ потребляет много GPU VRAM, поэтому нам нужно выполнить это на GPU A100 в Colab. Это занимает около 45 минут для квантизации модели, менее 1 доллара в Colab. Вы можете найти код в этом блокноте в моем репозитории.

Сначала нам нужно установить библиотеки, как рекомендуется в учебнике huggingface:

!pip install -q -U transformers peft accelerate optimum!pip install auto-gptq --extra-index-url https://huggingface.github.io/autogptq-index/whl/cu117/# На данный момент, до следующего релиза AutoGPTQ, мы будем собирать библиотеку из исходного кода!

Библиотека Optimum, инструментарий Hugging Face для оптимизации обучения и вывода, предоставляет интеграцию AutoGPTQ в Transformers.

Алгоритм GPTQ требует калибровки квантованных весов модели, выполняя вывод на квантованной модели. Для квантования модели с использованием auto-gptq, нам нужно передать набор данных квантайзеру. Это можно сделать, либо указав поддерживаемый набор данных по умолчанию среди ['wikitext2','c4','c4-new','ptb','ptb-new'], либо указав список строк, который будет использоваться в качестве вашего собственного набора данных.

Теперь вам просто нужно загрузить модель, используя конфигурацию GPTQ, установив желаемые параметры, как обычно при работе с transformers, это очень просто:

from transformers import AutoModelForCausalLM, AutoTokenizer, GPTQConfigimport torch# Установить модель для загрузкиhf_model_repo='edumunozsala/llama-2-7b-int4-python-code-20k'# Загрузить токенизаторtokenizer = AutoTokenizer.from_pretrained(hf_model_repo, use_fast=True)# Установить конфигурацию квантованияquantization_config = GPTQConfig(     bits=4,     group_size=128,     dataset="c4",     desc_act=False,     tokenizer=tokenizer)# Загрузить модель из HFquant_model = AutoModelForCausalLM.from_pretrained(hf_model_repo,                 quantization_config=quantization_config, device_map='auto')

Как упоминалось ранее, этот код выполняется около 45 минут и требует до 32 ГБ GPU VRAM. “Вам понадобится GPU для квантования модели. Мы разместим модель на ЦП и переместим модули туда и обратно на ГП, чтобы квантовать их. Если вы хотите максимизировать использование своих ГП при использовании снятия нагрузки с ЦП, вы можете установить device_map = "auto"” [6], документы Hugging Face.

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

• group_size: Размер группы для квантования. Рекомендуемое значение – 128, а -1 использует квантование по столбцам
• desc_act: Определяет, квантовать ли столбцы в порядке убывания размера активации. Установка его в False может значительно ускорить вывод, но perplexity может немного ухудшиться. Также известен как act-order.

После квантования модели вы можете загрузить ее в Hugging Face Hub и поделиться с сообществом.

quant_model.push_to_hub("edumunozsala/llama-2-7b-int4-GPTQ-python-code-20k")tokenizer.push_to_hub("edumunozsala/llama-2-7b-int4-GPTQ-python-code-20k")

В моем эксперименте с использованием GPTQ уменьшение размера модели поразительное. Моя модель Llama 2 7B с 4-битными весами весит 13,5 ГБ на диске, но после квантования ее размер был значительно сокращен до всего 3,9 ГБ, треть исходного размера. Эта функция очень привлекательна при развертывании больших языковых моделей.

Загрузка модели GPTQ из Hugging Face Hub и выполнение вывода

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

Помните, что вам нужно загрузить все библиотеки, включая optimum, accelerate и, конечно, auto-gptq .

!pip install -q -U transformers peft accelerate optimum!pip install auto-gptq

Затем вы можете загрузить токенизатор и модель в свой блокнот в T4 GPU в Google Colab:

import torchfrom transformers import AutoModelForCausalLM, AutoTokenizermodel_id = "edumunozsala/llama-2-7b-int4-GPTQ-python-code-20k"tokenizer = AutoTokenizer.from_pretrained(model_id)model = AutoModelForCausalLM.from_pretrained(model_id,                   torch_dtype=torch.float16, device_map="auto")

Теперь мы можем проверить наш GPU, чтобы убедиться, сколько памяти мы используем, и, действительно, мы видим, что модель занимает 5,053 ГБ.

Мы повторяем оценку производительности, о которой упоминали ранее, делая выводы по набору длинных примеров для сравнения с исходной моделью. Оба процесса вывода были выполнены на T4 GPU, базовая модель занимала около 17–19 секунд на вывод, тогда как квантованная модель работала примерно 8–9 секунд на вывод, в два раза быстрее.

Весь код и примеры подробно объяснены в его блокноте в моем репозитории. Любые предложения или исправления ошибок приветствуются.

Ссылки

[1] ICLR 2023 статья “GPTQ: Точная пост-тренировочная квантизация для генеративных предварительно обученных трансформеров”

[2] “GPTQ или bitsandbytes: Какой метод квантизации использовать для LLMs – Примеры с Llama 2” от Бенжамина Мари.

[3] “Fine-Tuning a Llama 2 7B Model for Python Code Generation” от Эдуардо Муньос

[4] Оригинальная предварительно обученная модель в Huggingface “edumunozsala/llama-2–7b-int4-python-code-20k”

[5] Статья в блоге Hugging Face “Making LLMs lighter with AutoGPTQ and transformers”

[6] Официальная документация Hugging Face о GPTQConfig

[7] “4-bit Quantization with GPTQ” от Максима Лабонна.