Bitsandbytes

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

В основе библиотеки bitsandbytes лежат:

• Квантованные линейные слои: слои Linear8bitLt и Linear4bit, заменяющие стандартные линейные слои PyTorch на экономичные по памяти квантованные аналоги
• Оптимизированные оптимизаторы: 8-битные версии распространённых оптимизаторов через модуль optim, что позволяет обучать большие модели с уменьшенными требованиями к памяти
• Умножение матриц: оптимизированные операции умножения матриц, использующие квантованный формат

bitsandbytes предлагает две основные функции квантования:

1. LLM.int8() — метод 8-битной квантизации, который делает инференс более доступным без существенной потери производительности. В отличие от наивной квантизации, LLM.int8() динамически сохраняет более высокую точность для критических вычислений, предотвращая потерю информации в чувствительных частях модели.

2. QLoRA — техника 4-битной квантизации, которая сжимает модели ещё сильнее, сохраняя возможность обучения за счёт добавления небольшого набора обучаемых весов низко-ранговой адаптации (LoRA).

Примечание: Для удобного квантования вы можете использовать bitsandbytes пространство сообщества.

Выполните команду ниже, чтобы установить bitsandbytes.

pip install --upgrade transformers accelerate bitsandbytes

Чтобы собрать из исходного кода, следуйте инструкциям в руководстве по установке bitsandbytes.

Совместимость с оборудованием

bitsandbytes поддерживается на GPU NVIDIA для версий CUDA 11.8 - 13.0, Intel XPU, Intel Gaudi (HPU) и CPU. Ведётся работа по добавлению поддержки дополнительных платформ. Если вы хотите поделиться обратной связью или провести тестирование, ознакомьтесь с репозиторием bitsandbytes для получения дополнительной информации.

NVIDIA GPU (CUDA)

Этот бэкенд поддерживается на платформах Linux x86-64, Linux aarch64 и Windows.

Intel GPU (XPU)

Этот бэкенд поддерживается на платформах Linux x86-64 и Windows x86-64.

Intel Gaudi (HPU)

Этот бэкенд поддерживается на Linux x86-64 для Gaudi2 и Gaudi3.

CPU

Этот бэкенд поддерживается на платформах Linux x86-64, Linux aarch64 и Windows x86-64.

Примеры квантования

Квантуйте модель, передав BitsAndBytesConfig в from_pretrained(). Это работает для любой модели в любой модальности, если она поддерживает Accelerate и содержит слои torch.nn.Linear.

from transformers import AutoModelForCausalLM, BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(load_in_8bit=True)

model_8bit = AutoModelForCausalLM.from_pretrained(
    "bigscience/bloom-1b7", 
    device_map="auto",
    quantization_config=quantization_config
)

import torch
from transformers import AutoModelForCausalLM, BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(load_in_8bit=True)

model_8bit = AutoModelForCausalLM.from_pretrained(
    "facebook/opt-350m", 
    device_map="auto",
    quantization_config=quantization_config, 
    dtype="auto"
)
model_8bit.model.decoder.layers[-1].final_layer_norm.weight.dtype

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(load_in_8bit=True)

model = AutoModelForCausalLM.from_pretrained(
    "bigscience/bloom-560m", 
    device_map="auto",
    quantization_config=quantization_config
)

model.push_to_hub("bloom-560m-8bit")

from transformers import AutoModelForCausalLM, BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(load_in_4bit=True)

model_4bit = AutoModelForCausalLM.from_pretrained(
    "bigscience/bloom-1b7",
    device_map="auto",
    quantization_config=quantization_config
)

import torch
from transformers import AutoModelForCausalLM, BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(load_in_4bit=True)

model_4bit = AutoModelForCausalLM.from_pretrained(
    "facebook/opt-350m",
    device_map="auto",
    quantization_config=quantization_config, 
    dtype="auto"
)
model_4bit.model.decoder.layers[-1].final_layer_norm.weight.dtype

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(load_in_4bit=True)

model = AutoModelForCausalLM.from_pretrained(
    "bigscience/bloom-560m", 
    device_map="auto",
    quantization_config=quantization_config
)

model.push_to_hub("bloom-560m-4bit")

Обучение в 8- и 4-битном формате поддерживается только для обучения дополнительных параметров.

Проверьте объём занимаемой памяти с помощью get_memory_footprint.

print(model.get_memory_footprint())

Загружайте квантованные модели с помощью from_pretrained() без quantization_config.

from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("{your_username}/bloom-560m-8bit", device_map="auto")

LLM.int8

В этом разделе рассматриваются некоторые специфические возможности 8-битного квантования, такие как offloading, пороги выбросов, пропуск конвертации модулей и дообучение.

Выгрузка

8-битные модели могут выгружать веса между CPU и GPU, чтобы поместить в память очень большие модели. Веса, выгруженные на CPU, хранятся в формате float32 и не преобразуются в 8-битный. Например, чтобы включить выгрузку для bigscience/bloom-1b7, используйте BitsAndBytesConfig.

from transformers import AutoModelForCausalLM, BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(llm_int8_enable_fp32_cpu_offload=True)

Разработайте собственную карту устройств, чтобы разместить на GPU всё, кроме lm_head, который будет перемещён на CPU.

device_map = {
    "transformer.word_embeddings": 0,
    "transformer.word_embeddings_layernorm": 0,
    "lm_head": "cpu",
    "transformer.h": 0,
    "transformer.ln_f": 0,
}

Теперь загрузите модель с настраиваемыми параметрами device_map и quantization_config.

model_8bit = AutoModelForCausalLM.from_pretrained(
    "bigscience/bloom-1b7",
    dtype="auto",
    device_map=device_map,
    quantization_config=quantization_config,
)

Порог выбросов

«Аутлайер» — это значение скрытого состояния, превышающее определённый порог, и такие значения вычисляются в fp16. Как правило, значения распределены нормально ([-3.5, 3.5]), однако для больших моделей это распределение может сильно отличаться ([-60, 6] или [6, 60]). 8-битное квантование хорошо работает для значений ~5, но при превышении этого диапазона возникает значительное снижение производительности. Хорошим значением порога по умолчанию является 6, однако для более нестабильных моделей (маленькие модели или дообучение) может потребоваться более низкий порог.

Чтобы подобрать оптимальный порог для вашей модели, экспериментируйте с параметром llm_int8_threshold в BitsAndBytesConfig. Например, если установить порог в 0.0, инференс значительно ускорится, но это может привести к некоторой потере точности.

from transformers import AutoModelForCausalLM, BitsAndBytesConfig

model_id = "bigscience/bloom-1b7"

quantization_config = BitsAndBytesConfig(
    llm_int8_threshold=0.0,
    llm_int8_enable_fp32_cpu_offload=True
)

model_8bit = AutoModelForCausalLM.from_pretrained(
    model_id,
    dtype="auto",
    device_map=device_map,
    quantization_config=quantization_config,
)

Пропустить конвертацию модуля

Для некоторых моделей, таких как Jukebox, не обязательно квантовать каждый модуль до 8 бит, так как это может привести к нестабильности. В случае с Jukebox есть несколько модулей lm_head, которые следует пропустить с помощью параметра llm_int8_skip_modules в BitsAndBytesConfig.

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig

model_id = "bigscience/bloom-1b7"

quantization_config = BitsAndBytesConfig(
    llm_int8_skip_modules=["lm_head"],
)

model_8bit = AutoModelForCausalLM.from_pretrained(
    model_id,
    dtype="auto",
    device_map="auto",
    quantization_config=quantization_config,
)

Довобучение

Библиотека PEFT поддерживает дообучение крупных моделей, таких как flan-t5-large и facebook/opt-6.7b, с 8-битным квантованием. Для обучения не нужно передавать параметр device_map, так как модель автоматически загружается на GPU. Тем не менее, вы можете настроить карту устройств с помощью параметра device_map (device_map="auto" следует использовать только для инференса).

QLoRA

В этом разделе рассматриваются некоторые особенности 4-битного квантования, такие как изменение типа данных для вычислений, тип данных Normal Float 4 (NF4) и вложенное квантование.

Тип данных для вычислений

Измените тип данных с float32 (значение по умолчанию) на bf16 в BitsAndBytesConfig, чтобы ускорить вычисления.

import torch
from transformers import BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_compute_dtype=torch.bfloat16)

Обычный Float 4 (NF4)

NF4 — это 4-битный тип данных из статьи QLoRA, адаптированный для весов, инициализированных из нормального распределения. Используйте NF4 для обучения базовых моделей с 4-битным представлением.

from transformers import BitsAndBytesConfig

nf4_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
)

model_nf4 = AutoModelForCausalLM.from_pretrained(model_id, dtype="auto", quantization_config=nf4_config)

Для инференса параметр bnb_4bit_quant_type не оказывает значительного влияния на производительность. Однако, чтобы сохранить согласованность с весами модели, следует использовать значения bnb_4bit_compute_dtype и dtype.

Вложенная квантизация

Вложенная квантизация позволяет сэкономить дополнительную память без потери производительности. Эта функция выполняет вторую квантизацию уже квантованных весов, что позволяет сэкономить дополнительные 0,4 бита на параметр. Например, с использованием вложенной квантизации можно выполнить дообучение модели Llama-13b на GPU NVIDIA T4 с 16 ГБ памяти при длине последовательности 1024, размере батча 1 и включённом накоплении градиентов с шагом 4.

from transformers import BitsAndBytesConfig

double_quant_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_use_double_quant=True,
)

model_double_quant = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-13b-chat-hf", dtype="auto", quantization_config=double_quant_config)

Декуантизация моделей bitsandbytes

После квантования вы можете dequantize() модель до исходной точности, однако это может привести к некоторой потере качества. Убедитесь, что у вас достаточно памяти GPU для размещения деквантованной модели.

from transformers import AutoModelForCausalLM, BitsAndBytesConfig, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("facebook/opt-125m", BitsAndBytesConfig(load_in_4bit=True))
model.dequantize()

Ресурсы

Подробнее о деталях 8-битного квантования можно узнать в статье Нежное введение в 8-битное матричное умножение для трансформеров большого масштаба с использованием Hugging Face Transformers, Accelerate и bitsandbytes.

Попробуйте 4-битное квантование в этом ноутбуке и узнайте больше о деталях в статье Делаем LLM ещё более доступными с помощью bitsandbytes, 4-битного квантования и QLoRA.