# Оптимизация LLM по скорости и памяти

Большые языковые модели (LLM), такие как GPT3/4, [Falcon](https://huggingface.co/tiiuae/falcon-40b) и [Llama](https://huggingface.co/meta-llama/Llama-2-70b-hf), стремительно развивают свои возможности в решении задач, ориентированных на человека, и становятся незаменимым инструментом в современных отраслях, основанных на знаниях. Однако развёртывание этих моделей в реальных задачах по-прежнему остаётся сложным:

- Чтобы демонстрировать возможности понимания и генерации текста, близкие к человеческим, LLMs в настоящее время должны состоять из миллиардов параметров (см. [Kaplan et al](https://huggingface.co/papers/2001.08361), [Wei et. al](https://huggingface.co/papers/2206.07682)). Это, в свою очередь, многократно увеличивает требования к памяти при выводе.
- Во многих практических задачах LLM необходимо предоставлять обширный контекст. Это требует, чтобы модель могла обрабатывать очень длинные входные последовательности на этапе инференса.

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

В этом руководстве мы рассмотрим эффективные методы для оптимизированного развертывания LLM:

1. **Низкая точность:** Исследования показали, что работа с пониженной числовой точностью, а именно [8-битной и 4-битной](./main_classes/quantization), позволяет получить вычислительные преимущества без существенного снижения качества модели.

2. **Flash Attention:** Flash Attention — это вариант алгоритма внимания, который не только обеспечивает более эффективное использование памяти, но и повышает общую производительность за счёт оптимизированного использования памяти GPU.

3. **Архитектурные инновации:** Поскольку LLMs всегда разворачиваются одинаковым образом на этапе инференса, а именно — авто-регрессивная генерация текста с длинным входным контекстом, были предложены специализированные архитектуры моделей, позволяющие осуществлять инференс более эффективно. Наиболее важными достижениями в области архитектур моделей являются [Alibi](https://huggingface.co/papers/2108.12409), [Rotary embeddings](https://huggingface.co/papers/2104.09864), [Multi-Query Attention (MQA)](https://huggingface.co/papers/1911.02150) и [Grouped-Query-Attention (GQA)](https://huggingface.co/papers/2305.13245).

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

## 1. Более низкая точность

Требования к памяти для LLM лучше всего понять, рассматривая LLM как набор матриц и векторов весов, а текстовые входные данные — как последовательность векторов. В дальнейшем термин *weights* будет использоваться для обозначения всех матриц и векторов весов модели.

На момент написания этого руководства LLM состоят как минимум из нескольких миллиардов параметров. Каждый параметр представляет собой десятичное число, например `4.5689`, которое обычно хранится в формате [float32](https://en.wikipedia.org/wiki/Single-precision_floating-point_format), [bfloat16](https://en.wikipedia.org/wiki/Bfloat16_floating-point_format) или [float16](https://en.wikipedia.org/wiki/Half-precision_floating-point_format). Это позволяет легко вычислить объём памяти, необходимый для загрузки LLM в оперативную память:

> *Загрузка весов модели с X миллиардами параметров требует примерно 4 \* X ГБ видеопамяти в точности float32*

Сегодня модели, однако, редко обучают в полной точности float32, как правило, в точности bfloat16 или, реже, в float16. Поэтому правило большого пальца становится следующим:

> *Загрузка весов модели с X миллиардами параметров требует примерно 2 \* X ГБ видеопамяти в точности bfloat16/float16*

Для коротких входных текстов (менее 1024 токенов) требования к памяти при инференсе в значительной степени определяются объёмом памяти, необходимым для загрузки весов. Поэтому пока будем считать, что требования к памяти при инференсе равны объёму памяти, необходимому для загрузки модели в VRAM GPU.

Вот несколько примеров того, сколько VRAM примерно требуется для загрузки модели в bfloat16:

- **GPT3** требует 2 \* 175 ГБ = **350 ГБ** VRAM
- [**Bloom**](https://huggingface.co/bigscience/bloom) требует 2 \* 176 ГБ = **352 ГБ** VRAM
- [**Llama-2-70b**](https://huggingface.co/meta-llama/Llama-2-70b-hf) требует 2 \* 70 ГБ = **140 ГБ** VRAM
- [**Falcon-40b**](https://huggingface.co/tiiuae/falcon-40b) требует 2 \* 40 ГБ = **80 ГБ** VRAM
- [**MPT-30b**](https://huggingface.co/mosaicml/mpt-30b) требует 2 \* 30 ГБ = **60 ГБ** VRAM
- [**bigcode/starcoder**](https://huggingface.co/bigcode/starcoder) требует 2 \* 15,5 = **31 ГБ** VRAM

На момент написания данного документа крупнейшим GPU-чипом на рынке является A100 & H100 с 80 ГБ видеопамяти. Большинство моделей, перечисленных выше, требуют более 80 ГБ только для загрузки и, следовательно, обязательно нуждаются в [тензорном параллелизме](./perf_train_gpu_many#tensor-parallelism) и/или [конвейерном параллелизме](./perf_train_gpu_many#pipeline-parallelism).

🤗 Transformers теперь поддерживает тензорный параллелизм для поддерживаемых моделей, у которых в соответствующих классах конфигурации есть `base_tp_plan`. Подробнее о тензорном параллелизме — [здесь](./perf_train_gpu_many#tensor-parallelism). Кроме того, если вы заинтересованы в написании моделей с учётом тензорного параллелизма, посмотрите [библиотеку text-generation-inference](https://github.com/huggingface/text-generation-inference/tree/main/server/text_generation_server/models/custom_modeling).

Наивный пайплайн-параллелизм поддерживается из коробки. Для этого достаточно загрузить модель с параметром `device="auto"`, который автоматически распределит различные слои по доступным GPU, как описано [здесь](https://huggingface.co/docs/accelerate/v0.22.0/en/concept_guides/big_model_inference). Однако, несмотря на высокую эффективность, наивный пайплайн-параллелизм не решает проблему простоя GPU. Для этого требуется более продвинутый пайплайн-параллелизм, описанный [здесь](./perf_train_gpu_many#pipeline-parallelism).

Если у вас есть доступ к узлу 8 x 80GB A100, вы можете загрузить BLOOM следующим образом

```bash
!pip install transformers accelerate bitsandbytes optimum
```

```python
from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained("bigscience/bloom", device_map="auto", pad_token_id=0)
```

При использовании `device_map="auto"` слои внимания распределяются равномерно по всем доступным GPU.

В этом руководстве мы будем использовать [bigcode/octocoder](https://huggingface.co/bigcode/octocoder), так как его можно запустить на одном чипе GPU A100 с 40 ГБ памяти. Обратите внимание, что все оптимизации памяти и скорости, которые мы будем применять далее, в равной степени применимы к моделям, требующим параллелизма на уровне модели или тензоров.

Поскольку модель загружена с точностью bfloat16, согласно приведённому выше правилу, ожидаемое потребление памяти для запуска инференса с `bigcode/octocoder` составляет около 31 ГБ VRAM. Давайте проверим.

Сначала мы загружаем модель и токенизатор, а затем передаём оба объекта в объект [pipeline](./main_classes/pipelines) из Transformers.

```python
from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
import torch

model = AutoModelForCausalLM.from_pretrained("bigcode/octocoder", dtype=torch.bfloat16, device_map="auto", pad_token_id=0)
tokenizer = AutoTokenizer.from_pretrained("bigcode/octocoder")

pipe = pipeline("text-generation", model=model, tokenizer=tokenizer)
```

```python
prompt = "Question: Please write a function in Python that transforms bytes to Giga bytes.\n\nAnswer:"

result = pipe(prompt, max_new_tokens=60)[0]["generated_text"][len(prompt):]
result
```

**Результат**:

```text
Here is a Python function that transforms bytes to Giga bytes:\n\n```python\ndef bytes_to_giga_bytes(bytes):\n    return bytes / 1024 / 1024 / 1024\n```\n\nThis function takes a single
```

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

```python
def bytes_to_giga_bytes(bytes):
  return bytes / 1024 / 1024 / 1024
```

Вызовем [`torch.accelerator.memory.max_memory_allocated`](https://docs.pytorch.org/docs/main/generated/torch.accelerator.memory.max_memory_allocated.html), чтобы измерить пиковое выделение памяти на ускорителе.

```python
bytes_to_giga_bytes(torch.accelerator.max_memory_allocated())
```

**Результат**:

```text
29.0260648727417
```

Достаточно близко к нашей приблизительной оценке! Мы видим, что число не совсем точное, так как при переходе от байтов к килобайтам требуется умножение на 1024, а не на 1000. Следовательно, формулу приблизительной оценки можно также понимать как вычисление «не более X ГБ». Обратите внимание, что если бы мы пытались запустить модель в полной точности float32, потребовалось бы целых 64 ГБ видеопамяти.

> Почти все модели сейчас обучаются в bfloat16, поэтому нет смысла запускать модель в полной точности float32, если [ваша GPU поддерживает bfloat16](https://discuss.pytorch.org/t/bfloat16-native-support/117155/5). Float32 не даст лучших результатов инференса, чем та точность, в которой обучалась модель.

Если вы не уверены, в каком формате на Hub хранятся веса модели, вы всегда можете посмотреть параметр `"dtype"` в конфигурации чекпоинта, *например* [здесь](https://huggingface.co/meta-llama/Llama-2-7b-hf/blob/6fdf2e60f86ff2481f2241aaee459f85b5b0bbb9/config.json#L21). При загрузке с помощью `from_pretrained(..., dtype=...)` рекомендуется устанавливать для модели тот же тип точности, что указан в конфигурации, за исключением случая, когда исходный тип — float32, тогда для инференса можно использовать как `float16`, так и `bfloat16`.

Определим функцию `flush(...)` для освобождения всей выделенной памяти, чтобы точно измерить пиковый объём выделенной памяти GPU.

```python
del pipe
del model

import gc
import torch

def flush():
  gc.collect()
  torch.accelerator.empty_cache()
  torch.accelerator.reset_peak_memory_stats()
```

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

```python
flush()
```

Из библиотеки Accelerate также можно использовать метод [release_memory](https://github.com/huggingface/accelerate/blob/29be4788629b772a3b722076e433b5b3b5c85da3/src/accelerate/utils/memory.py#L63), не зависящий от конкретного устройства, который учитывает различные аппаратные бэкенды, такие как XPU, MLU, NPU, MPS и другие.

```python
from accelerate.utils import release_memory
# ...

release_memory(model)
```

А что, если у вашей GPU нет 32 ГБ видеопамяти? Было установлено, что веса модели можно квантовать до 8 или 4 бит без существенной потери качества (см. [Dettmers et al.](https://huggingface.co/papers/2208.07339)). Как показано в недавней [статье GPTQ](https://huggingface.co/papers/2210.17323), модель можно квантовать даже до 3 или 2 бит с приемлемой потерей качества 🤯.

Не вдаваясь в излишние подробности, схемы квантования направлены на снижение точности весов при сохранении максимально возможной точности результатов инференса модели (*то есть* как можно ближе к bfloat16). Обратите внимание, что квантование особенно хорошо работает для генерации текста, поскольку нас интересует только выбор *набора наиболее вероятных следующих токенов*, а точные значения распределения *логитов* следующего токена нас не волнуют. Главное, чтобы распределение *логитов* следующего токена оставалось примерно таким же, чтобы операции `argmax` или `topk` давали те же результаты.

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

- 1. Квантовать все веса до целевой точности
- 2. Загрузите квантованные веса и передайте входную последовательность векторов в точности bfloat16
- 3. Динамически деквантовать веса в bfloat16, чтобы выполнить вычисления с их входными векторами в точности bfloat16

Короче говоря, это означает, что умножение *входной матрицы на матрицу весов* выполняется так, где $X$ — это *входы*, $W$ — матрица весов, а $Y$ — выход:

$$ Y = X * W $$

изменяются на

$$ Y = X * \text{dequantize}(W) $$

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

Поэтому при использовании квантованных весов время инференса часто **не** сокращается, а, наоборот, увеличивается. Достаточно теории, давайте попробуем! Чтобы квантовать веса с помощью Transformers, убедитесь, что установлена библиотека [`bitsandbytes`](https://github.com/bitsandbytes-foundation/bitsandbytes).

```bash
!pip install bitsandbytes
```

Затем мы можем загрузить модели в 8-битном квантовании, просто добавив флаг `load_in_8bit=True` к `from_pretrained`.

```python
model = AutoModelForCausalLM.from_pretrained("bigcode/octocoder", quantization_config=BitsAndBytesConfig(load_in_8bit=True), pad_token_id=0)
```

Теперь снова запустим наш пример и измерим потребление памяти.

```python
pipe = pipeline("text-generation", model=model, tokenizer=tokenizer)

result = pipe(prompt, max_new_tokens=60)[0]["generated_text"][len(prompt):]
result
```

**Результат**:

```text
Here is a Python function that transforms bytes to Giga bytes:\n\n```python\ndef bytes_to_giga_bytes(bytes):\n    return bytes / 1024 / 1024 / 1024\n```\n\nThis function takes a single
```

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

```python
bytes_to_giga_bytes(torch.accelerator.max_memory_allocated())
```

**Результат**:

```text
15.219234466552734
```

Значительно меньше! Мы снизили потребление до чуть более 15 ГБ, что позволяет запускать эту модель на потребительских GPU, таких как 4090. Мы наблюдаем значительный прирост эффективности использования памяти и практически отсутствие деградации качества вывода модели. Однако также можно заметить небольшое замедление во время инференса.

Мы удаляем модели и снова очищаем память.

```python
del model
del pipe
```

```python
flush()
```

Посмотрим, какое потребление видеопамяти GPU даёт 4-битное квантование. Квантование модели до 4 бит выполняется с тем же API, что и раньше, — на этот раз передаётся `load_in_4bit=True` вместо `load_in_8bit=True`.

```python
model = AutoModelForCausalLM.from_pretrained("bigcode/octocoder", quantization_config=BitsAndBytesConfig(load_in_4bit=True), pad_token_id=0)

pipe = pipeline("text-generation", model=model, tokenizer=tokenizer)

result = pipe(prompt, max_new_tokens=60)[0]["generated_text"][len(prompt):]
result
```

**Результат**:

```text
Here is a Python function that transforms bytes to Giga bytes:\n\n```\ndef bytes_to_gigabytes(bytes):\n    return bytes / 1024 / 1024 / 1024\n```\n\nThis function takes a single argument
```

Мы почти получаем тот же самый вывод, что и раньше — просто перед фрагментом кода отсутствует `python`. Посмотрим, сколько памяти потребовалось.

```python
bytes_to_giga_bytes(torch.accelerator.max_memory_allocated())
```

**Результат**:

```text
9.543574333190918
```

Всего 9,5 ГБ! Это действительно немного для модели с более чем 15 миллиардами параметров.

Хотя в нашем случае точность модели практически не снижается, 4-битное квантование на практике часто приводит к другим результатам по сравнению с 8-битным квантованием или полным выводом в `bfloat16`. Пользователю следует самостоятельно проверить это на практике.

Обратите также внимание, что инференс здесь снова был немного медленнее по сравнению с 8-битным квантованием, что обусловлено более агрессивным методом квантования, используемым для 4-битного квантования, из-за чего $\text{quantize}$ и $\text{dequantize}$ занимают больше времени во время инференса.

```python
del model
del pipe
```

```python
flush()
```

В целом мы увидели, что запуск OctoCoder с точностью 8 бит сокращает требуемый объём видеопамяти GPU с 32 ГБ до 15 ГБ, а запуск модели с точностью 4 бит дополнительно снижает требуемый объём видеопамяти GPU чуть выше 9 ГБ.

4-битная квантизация позволяет запускать модель на GPU, таких как RTX3090, V100 и T4, которые доступны большинству пользователей.

Для получения дополнительной информации о квантовании и о том, как можно квантовать модели так, чтобы они требовали ещё меньше видеопамяти GPU, чем в 4-битном представлении, рекомендуем ознакомиться с реализацией [`GPT-QModel`](./quantization/gptq).

> В заключение важно помнить, что квантование моделей повышает эффективность использования памяти за счёт точности, а в некоторых случаях — и времени инференса.

Если объём видеопамяти GPU не является ограничением для вашего сценария использования, то, как правило, нет необходимости изучать методы квантования. Однако многие GPU просто не способны запускать LLM без применения методов квантования, и в этом случае схемы 4-битного и 8-битного квантования становятся крайне полезными инструментами.

Для получения более подробной информации об использовании мы настоятельно рекомендуем обратиться к [документации Transformers по квантованию](./quantization/overview). Далее рассмотрим, как можно повысить вычислительную и энергетическую эффективность за счёт применения более совершенных алгоритмов и улучшенной архитектуры модели.

## 2. Flash Attention

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

Слои self-attention являются центральными для больших языковых моделей (LLM), поскольку они позволяют модели понимать контекстуальные связи между входными токенами. Однако пиковое потребление памяти GPU для слоёв self-attention растёт *квадратично* как по вычислительной, так и по памяти сложности с числом входных токенов (также называемым *длиной последовательности*), которое мы далее обозначаем как $N$ . Хотя для коротких входных последовательностей (до 1000 входных токенов) это не очень заметно, для длинных входных последовательностей (около 16000 входных токенов) это становится серьёзной проблемой.

Рассмотрим подробнее. Формула для вычисления выходного значения $\mathbf{O}$ слоя self-attention для входного значения $\mathbf{X}$ длины $N$ имеет вид:

$$ \textbf{O} = \text{Attn}(\mathbf{X}) = \mathbf{V} \times \text{Softmax}(\mathbf{QK}^T) \text{ where } \mathbf{Q} = \mathbf{W}_q \mathbf{X}, \mathbf{V} = \mathbf{W}_v \mathbf{X}, \mathbf{K} = \mathbf{W}_k \mathbf{X} $$

Таким образом, $\mathbf{X} = (\mathbf{x}_1, ... \mathbf{x}_{N})$ представляет собой входную последовательность для слоя внимания. Проекция $\mathbf{Q}$ и $\mathbf{K}$ будет состоять из $N$ векторов каждая, в результате чего $\mathbf{QK}^T$ будет иметь размер $N^2$ .

LLM обычно имеют несколько головок внимания, поэтому выполняют несколько вычислений само-внимания параллельно. Допустим, LLM имеет 40 головок внимания и работает в точности bfloat16; тогда объём памяти, необходимый для хранения матриц $\mathbf{QK^T}$, составляет $40 * 2 * N^2$ байт. Для $N=1000$ достаточно лишь около 50 МБ видеопамяти, однако для $N=16000$ потребуется 19 ГБ видеопамяти, а для $N=100,000$ — почти 1 ТБ, чтобы просто хранить матрицы $\mathbf{QK}^T$.

Коротко: алгоритм само-внимания по умолчанию быстро становится неприемлемо затратным по памяти для больших входных контекстов.

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

Как можно избавиться от чрезмерных требований к памяти при больших длинах входных последовательностей? Нам нужен новый способ вычисления механизма само-внимания, который позволяет отказаться от матрицы $\mathbf{QK}^T$. [Tri Dao и соавт.](https://huggingface.co/papers/2205.14135) разработали именно такой новый алгоритм и назвали его **Flash Attention**.

Короче говоря, Flash Attention разделяет вычисление $\mathbf{V} \times \text{Softmax}(\mathbf{QK}^T)$ и вместо этого вычисляет небольшие фрагменты результата, итерируя по нескольким шагам вычисления softmax:

$$ \textbf{O}_i \leftarrow s^a_{ij} * \textbf{O}_i + s^b_{ij} * \mathbf{V}_{j} \times \text{Softmax}(\mathbf{QK}^T_{i,j}) \text{ for multiple } i, j \text{ iterations} $$

где $s^a_{ij}$ и $s^b_{ij}$ — это некоторые статистики нормализации softmax, которые необходимо пересчитывать для каждого $i$ и $j$ .

Обратите внимание, что весь механизм Flash Attention несколько сложнее и здесь сильно упрощён, поскольку углублённое рассмотрение выходит за рамки данного руководства. Читателю предлагается ознакомиться с хорошо написанной [статьей о Flash Attention](https://huggingface.co/papers/2205.14135) для получения дополнительных деталей.

Главный вывод здесь:

> За счёт отслеживания статистики нормализации softmax и применения ряда математических приёмов Flash Attention обеспечивает **численно идентичные** результаты по сравнению со стандартным слоем self-attention при затратах памяти, которые растут лишь линейно с $N$.

Судя по формуле, можно интуитивно предположить, что Flash Attention должен работать значительно медленнее по сравнению с формулой стандартного self-attention, так как требуется выполнить больше вычислений. Действительно, Flash Attention требует больше FLOPs по сравнению с обычным attention, поскольку статистика нормализации softmax должна постоянно пересчитываться (см. [статью](https://huggingface.co/papers/2205.14135) для получения дополнительных деталей, если интересно)

> Однако Flash Attention значительно быстрее при инференсе по сравнению со стандартным attention, что обусловлено его способностью существенно снижать нагрузку на более медленную память GPU с высокой пропускной способностью (VRAM), переключая фокус на более быструю память на чипе (SRAM).

По сути, Flash Attention обеспечивает выполнение всех промежуточных операций записи и чтения с использованием быстрой *on-chip* памяти SRAM, а не с обращением к более медленной памяти VRAM для вычисления выходного вектора $\mathbf{O}$ .

На практике на данный момент нет абсолютно никаких причин **не** использовать Flash Attention, если он доступен. Алгоритм дает математически идентичные результаты, при этом он быстрее и эффективнее с точки зрения использования памяти.

## 3. Архитектурные инновации

До сих пор мы рассматривали способы повышения вычислительной и энергетической эффективности, а именно:

- Преобразование весов в формат с меньшей точностью
- Замена алгоритма само-внимания на более эффективную по памяти и вычислениям версию

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

- Вопросно-ответная система с расширением за счёт поиска,
- Суммаризация,
- Чат

Обратите внимание, что *chat* требует от LLM не только обработки длинных текстовых входных данных, но и эффективного ведения диалога между пользователем и ассистентом (например, как в ChatGPT).

После обучения базовую архитектуру LLM сложно изменить, поэтому важно заранее продумать задачи, которые должна решать LLM, и в соответствии с этим оптимизировать архитектуру модели. В архитектуре модели есть два важных компонента, которые при работе с длинными входными последовательностями быстро становятся узким местом по памяти и/или производительности.

- Позиционные эмбеддинги
- Кэш ключей и значений

Рассмотрим каждый компонент подробнее

### 3.1 Улучшение позиционных эмбеддингов LLM

Само-внимание устанавливает связь каждого токена с токенами остальных. В качестве примера, матрица $\text{Softmax}(\mathbf{QK}^T)$ для входной последовательности текста *"Hello", "I", "love", "you"* может выглядеть следующим образом:

![](/blog/assets/163_optimize_llm/self_attn_tokens.png)

Каждому токену слова присваивается вероятность, с которой он обращается ко всем остальным токенам слов, и, следовательно, устанавливает связь со всеми остальными токенами слов. Например, слово *"love"* обращается к слову *"Hello"* с вероятностью 5%, к *"I"* — с вероятностью 30%, а к самому себе — с вероятностью 65%.

LLM, основанная на self-attention, но без позиционных эмбеддингов, испытывала бы значительные трудности в понимании взаимного расположения входных текстовых токенов. Это связано с тем, что вероятностная оценка, вычисляемая по формуле $\mathbf{QK}^T$, связывает каждый токен слова с любым другим токеном слова за $O(1)$ вычислений, независимо от их относительного позиционного расстояния. Следовательно, для LLM без позиционных эмбеддингов каждый токен кажется находящимся на одинаковом расстоянии от всех остальных токенов, *например*, различение между *"Hello I love you"* и *"You love I hello"* было бы крайне затруднительным.

Чтобы LLM понимала порядок слов в предложении, требуется дополнительный *сигнал*, который обычно реализуется в виде *позиционных кодировок* (также называемых *позиционными эмбеддингами*). Позиционные кодировки преобразуют позицию каждого токена в числовое представление, которое LLM использует для более точного понимания порядка слов в предложении.

Авторы статьи [*Attention Is All You Need*](https://huggingface.co/papers/1706.03762) ввели синусоидальные позиционные эмбеддинги $\mathbf{P} = \mathbf{p}_1, \ldots, \mathbf{p}_N$ , где каждый вектор $\mathbf{p}_i$ вычисляется как синусоидальная функция его позиции $i$ . Затем позиционные кодировки просто прибавляются к векторам входной последовательности $\mathbf{\hat{X}} = \mathbf{\hat{x}}_1, \ldots, \mathbf{\hat{x}}_N$ = $\mathbf{x}_1 + \mathbf{p}_1, \ldots, \mathbf{x}_N + \mathbf{p}_N$ , что помогает модели лучше усваивать порядок слов в предложении.

Вместо использования фиксированных позиционных эмбеддингов другие (например, [Devlin et al.](https://huggingface.co/papers/1810.04805)) применяли обучаемые позиционные кодировки, для которых позиционные эмбеддинги $\mathbf{P}$ обучаются в процессе тренировки.

Синусоидальные и обучаемые позиционные эмбеддинги долгое время были основными методами кодирования порядка слов в LLM, однако было выявлено несколько проблем, связанных с этими позиционными кодировками:

  1. Синусоидальные и обучаемые позиционные эмбеддинги являются абсолютными позиционными эмбеддингами, *т. е.* кодируют уникальное эмбеддинг для каждого идентификатора позиции: $0, \ldots, N$ . Как показано в работах [Huang et al.](https://huggingface.co/papers/2009.13658) и [Su et al.](https://huggingface.co/papers/2104.09864), абсолютные позиционные эмбеддинги приводят к низкому качеству работы LLM на длинных текстовых входах. Для длинных текстовых входов предпочтительнее, чтобы модель обучалась на относительном позиционном расстоянии между входными токенами, а не на их абсолютном положении.
  2. При использовании обучаемых позиционных эмбеддингов LLM необходимо обучать на фиксированной длине входа $N$, что затрудняет экстраполяцию на длину входа, превышающую ту, на которой модель обучалась.

Недавно стали более популярными относительные позиционные эмбеддинги, способные решить вышеупомянутые проблемы, в частности:

- [Позиционное кодирование RoPE (Rotary Position Embedding)](https://huggingface.co/papers/2104.09864)
- [ALiBi](https://huggingface.co/papers/2108.12409)

Оба подхода — *RoPE* и *ALiBi* — утверждают, что лучше всего подавать LLM информацию о порядке предложений непосредственно в алгоритме self-attention, поскольку именно там токены слов ставятся в отношения друг с другом. Более конкретно, порядок предложений должен задаваться путём модификации вычисления $\mathbf{QK}^T$.

Не вдаваясь в излишние подробности, *RoPE* отмечает, что позиционная информация может быть закодирована в парах query-key, *например* $\mathbf{q}_i$ и $\mathbf{x}_j$, путём поворота каждого вектора на угол $\theta * i$ и $\theta * j$ соответственно, где $i, j$ описывают позицию каждого вектора в предложении:

$$ \mathbf{\hat{q}}_i^T \mathbf{\hat{x}}_j = \mathbf{{q}}_i^T \mathbf{R}_{\theta, i -j} \mathbf{{x}}_j. $$

$\mathbf{R}_{\theta, i - j}$ тем самым представляет собой матрицу поворота. $\theta$ *не* обучается в процессе обучения, а устанавливается в заранее заданное значение, зависящее от максимальной длины входной последовательности на этапе обучения.

> Таким образом, оценка вероятности между $\mathbf{q}_i$ и $\mathbf{q}_j$ изменяется только при $i \ne j$ и зависит исключительно от относительного расстояния $i - j$, независимо от конкретных позиций $i$ и $j$ каждого вектора.

*RoPE* используется в нескольких из самых важных LLM на сегодняшний день, таких как:

- [**Falcon**](https://huggingface.co/tiiuae/falcon-40b)
- [**Llama**](https://huggingface.co/papers/2302.13971)
- [**PaLM**](https://huggingface.co/papers/2204.02311)

В качестве альтернативы *ALiBi* предлагает гораздо более простую схему кодирования относительных позиций. Относительное расстояние между входными токенами добавляется в виде отрицательного целого числа, масштабированного заранее заданным значением `m`, к каждой записи матрицы $\mathbf{QK}^T$ непосредственно перед вычислением softmax.

![](/blog/assets/163_optimize_llm/alibi.png)

Как показано в статье [ALiBi](https://huggingface.co/papers/2108.12409), это простое относительное позиционное кодирование позволяет модели сохранять высокую производительность даже на очень длинных входных последовательностях текста.

*ALiBi* используется в нескольких из самых важных LLM на сегодняшний день, таких как:

- [**MPT**](https://huggingface.co/mosaicml/mpt-30b)
- [**BLOOM**](https://huggingface.co/bigscience/bloom)

Обе схемы позиционного кодирования *RoPE* и *ALiBi* способны экстраполировать на длины входных последовательностей, не встречавшиеся при обучении, при этом показано, что экстраполяция «из коробки» работает значительно лучше для *ALiBi*, чем для *RoPE*. В случае ALiBi достаточно просто увеличить значения в нижней треугольной матрице позиций, чтобы они соответствовали длине входной последовательности. Для *RoPE* сохранение того же значения $\theta$, которое использовалось при обучении, приводит к плохим результатам при обработке текстовых входов, значительно длиннее тех, что встречались в процессе обучения, *см.* [Press et al.](https://huggingface.co/papers/2108.12409). Однако сообщество нашло несколько эффективных приёмов, позволяющих адаптировать $\theta$, благодаря чему позиционные эмбеддинги *RoPE* хорошо работают для экстраполированных текстовых входных последовательностей (см. [здесь](https://github.com/huggingface/transformers/pull/24653)).

> RoPE и ALiBi — это относительные позиционные эмбеддинги, которые *не* обучаются в процессе обучения, а основаны на следующих интуициях:

- Позиционные сигналы о текстовых входных данных следует передавать непосредственно в матрицу $\mathbf{QK}^T$ слоя само-внимания.
- LLM должна поощряться к обучению константного *относительного* позиционного кодирования.
- Чем дальше друг от друга расположены токены входного текста, тем ниже вероятность их query-value. И RoPE, и ALiBi снижают вероятность query-key для токенов, находящихся далеко друг от друга. RoPE делает это, уменьшая их скалярное произведение за счёт увеличения угла между векторами query и key. ALiBi снижает вероятность, прибавляя к скалярному произведению большие отрицательные числа.

В заключение, LLM, предназначенные для развёртывания в задачах, требующих обработки больших текстовых входных данных, лучше обучать с использованием относительных позиционных эмбеддингов, таких как RoPE и ALiBi. Также обратите внимание, что даже если LLM с RoPE и ALiBi обучалась только на фиксированной длине, например $N_1 = 2048$, её всё равно можно использовать на практике с текстовыми входными данными, значительно превышающими $N_1$, например $N_2 = 8192 > N_1$, путём экстраполяции позиционных эмбеддингов.

### 3.2 Кэш ключей и значений

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

Ознакомьтесь с [руководством по генерации текста в Transformers](./llm_tutorial#default-generate), чтобы нагляднее понять, как работает авто-регрессивная генерация.

Запустим короткий фрагмент кода, чтобы показать, как на практике работает авто-регрессивное генерирование. Мы просто возьмём наиболее вероятный следующий токен с помощью `torch.argmax`.

```python
input_ids = tokenizer(prompt, return_tensors="pt")["input_ids"].to(model.device)

for _ in range(5):
  next_logits = model(input_ids)["logits"][:, -1:]
  next_token_id = torch.argmax(next_logits,dim=-1)

  input_ids = torch.cat([input_ids, next_token_id], dim=-1)
  print("shape of input_ids", input_ids.shape)

generated_text = tokenizer.batch_decode(input_ids[:, -5:])
generated_text
```

**Результат**:

```text
shape of input_ids torch.Size([1, 21])
shape of input_ids torch.Size([1, 22])
shape of input_ids torch.Size([1, 23])
shape of input_ids torch.Size([1, 24])
shape of input_ids torch.Size([1, 25])
[' Here is a Python function']
```

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

За редким исключением, LLM обучаются с использованием [цели каузального языкового моделирования](./tasks/language_modeling#causal-language-modeling) и поэтому маскируют верхний треугольник матрицы оценок внимания — именно поэтому на двух диаграммах выше оценки внимания оставлены пустыми (*то есть* имеют вероятность 0). Для краткого повторения каузального языкового моделирования можно обратиться к [*блогу Illustrated Self Attention*](https://jalammar.github.io/illustrated-gpt2/#part-2-illustrated-self-attention).

Вследствие этого токены *никогда* не зависят от последующих токенов: более конкретно, вектор $\mathbf{q}_i$ никогда не связывается с векторами ключей и значений $\mathbf{k}_j, \mathbf{v}_j$, если $j > i$. Вместо этого $\mathbf{q}_i обращается только к предыдущим векторам ключей и значений $\mathbf{k}_{m < i}, \mathbf{v}_{m < i} \text{ , для } m \in \{0, \ldots i - 1\}$. Чтобы сократить лишние вычисления, можно кэшировать векторы ключей и значений каждого слоя для всех предыдущих временных шагов.

Далее мы будем указывать LLM использовать кэш ключей и значений, извлекая его и передавая на каждом проходе. В Transformers кэш ключей и значений можно получить, передав флаг `use_cache` в вызов `forward`, а затем передать его вместе с текущим токеном.

```python
past_key_values = None # past_key_values is the key-value cache
generated_tokens = []
next_token_id = tokenizer(prompt, return_tensors="pt")["input_ids"].to(model.device)

for _ in range(5):
  next_logits, past_key_values = model(next_token_id, past_key_values=past_key_values, use_cache=True).to_tuple()
  next_logits = next_logits[:, -1:]
  next_token_id = torch.argmax(next_logits, dim=-1)

  print("shape of input_ids", next_token_id.shape)
  print("length of key-value cache", past_key_values.get_seq_length())  # past_key_values are of shape [num_layers, 0 for k, 1 for v, batch_size, length, hidden_dim]
  generated_tokens.append(next_token_id.item())

generated_text = tokenizer.batch_decode(generated_tokens)
generated_text
```

**Результат**:

```text
shape of input_ids torch.Size([1, 1])
length of key-value cache 20
shape of input_ids torch.Size([1, 1])
length of key-value cache 21
shape of input_ids torch.Size([1, 1])
length of key-value cache 22
shape of input_ids torch.Size([1, 1])
length of key-value cache 23
shape of input_ids torch.Size([1, 1])
length of key-value cache 24
[' Here', ' is', ' a', ' Python', ' function']
```

Как видно, при использовании кэша ключей и значений токены текстового входа *не* увеличиваются в длине, а остаются единым входным вектором. Длина кэша ключей и значений, в свою очередь, увеличивается на единицу на каждом шаге декодирования.

> Использование кэша ключей и значений означает, что $\mathbf{QK}^T$ фактически сводится к $\mathbf{q}_c\mathbf{K}^T$, где $\mathbf{q}_c$ — это проекция запроса для текущего входного токена, которая *всегда* представляет собой единственный вектор.

Использование кэша ключей и значений имеет два преимущества:

- Значительное повышение вычислительной эффективности, так как выполняется меньше вычислений по сравнению с полным вычислением матрицы $\mathbf{QK}^T$. Это приводит к увеличению скорости инференса
- Максимальный требуемый объём памяти не возрастает квадратично с числом сгенерированных токенов, а увеличивается только линейно.

> Всегда следует *использовать* кэш ключей и значений, так как это обеспечивает идентичные результаты и значительное ускорение для длинных входных последовательностей. В Transformers кэш ключей и значений включён по умолчанию при использовании текстового конвейера или метода [`generate`](./main_classes/text_generation). У нас есть отдельное руководство, посвящённое кэшированию, [здесь](./kv_cache).

Обратите внимание, что, несмотря на нашу рекомендацию использовать кэши ключей и значений, вывод вашей LLM может немного отличаться при их использовании. Это свойство самих ядер матричного умножения — подробнее об этом можно прочитать [здесь](https://github.com/huggingface/transformers/issues/25420#issuecomment-1775317535).

#### 3.2.1 Многократный диалог

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

```text
User: How many people live in France?
Assistant: Roughly 75 million people live in France
User: And how many are in Germany?
Assistant: Germany has ca. 81 million inhabitants
```

В этом чате LLM выполняет авто-регрессивное декодирование дважды:

  1. В первый раз кэш ключей и значений пуст, входной промпт — `"User: How many people live in France?"`, а модель авто-регрессивно генерирует текст `"Roughly 75 million people live in France"`, увеличивая кэш ключей и значений на каждом шаге декодирования.
  2. Во второй раз входной промпт — `"User: How many people live in France? \n Assistant: Roughly 75 million people live in France \n User: And how many in Germany?"`. Благодаря кэшу все ключевые и значения векторы для первых двух предложений уже вычислены. Поэтому входной промпт состоит только из `"User: And how many in Germany?"`. При обработке сокращенного входного промпта его вычисленные ключевые и значения векторы добавляются к кэшу ключевых и значений векторов первого декодирования. Затем второй ответ Assistant `"Germany has ca. 81 million inhabitants"` генерируется авто-регрессивно с использованием кэша ключевых и значений векторов, состоящего из закодированных ключевых и значений векторов `"User: How many people live in France? \n Assistant: Roughly 75 million people live in France \n User: And how many are in Germany?"`.

Здесь стоит отметить две вещи:

  1. Сохранение всего контекста имеет решающее значение для LLM, используемых в чатах, чтобы модель понимала весь предыдущий контекст разговора. Например, в приведённом выше примере LLM должна понимать, что пользователь имеет в виду население, когда задаёт вопрос `"And how many are in Germany"`.
  2. Кэш ключей и значений крайне полезен для чатов, поскольку позволяет непрерывно наращивать закодированную историю диалога, а не перекодировать её с нуля (как, например, в случае использования архитектуры «кодек-декодер»).

В `transformers` вызов `generate` возвращает `past_key_values`, если передан параметр `return_dict_in_generate=True` в дополнение к параметру `use_cache=True` по умолчанию. Обратите внимание, что эта функция пока недоступна через интерфейс `pipeline`.

```python
# Generation as usual
prompt = system_prompt + "Question: Please write a function in Python that transforms bytes to Giga bytes.\n\nAnswer: Here"
model_inputs = tokenizer(prompt, return_tensors='pt')
generation_output = model.generate(**model_inputs, max_new_tokens=60, return_dict_in_generate=True)
decoded_output = tokenizer.batch_decode(generation_output.sequences)[0]

# Piping the returned `past_key_values` to speed up the next conversation round
prompt = decoded_output + "\nQuestion: How can I modify the function above to return Mega bytes instead?\n\nAnswer: Here"
model_inputs = tokenizer(prompt, return_tensors='pt')
generation_output = model.generate(
  **model_inputs,
  past_key_values=generation_output.past_key_values,
  max_new_tokens=60,
  return_dict_in_generate=True
)
tokenizer.batch_decode(generation_output.sequences)[0][len(prompt):]
```

**Результат**:

```text
 is a modified version of the function that returns Mega bytes instead.

def bytes_to_megabytes(bytes):
   return bytes / 1024 / 1024

Answer: The function takes a number of bytes as input and returns the number of
```

Отлично, дополнительное время на пересчёт тех же ключей и значений для слоя внимания не тратится! Однако есть одна оговорка. Хотя требуемый пиковый объём памяти для матрицы $\mathbf{QK}^T$ значительно снижается, хранение кэша ключей-значений в памяти может стать очень затратным по памяти для длинных входных последовательностей или многоходового чата. Помните, что кэш ключей-значений должен хранить векторы ключей-значений для всех предыдущих входных векторов $\mathbf{x}_i \text{, for } i \in \{1, \ldots, c - 1\}$ для всех слоёв само-внимания и для всех головок внимания.

Вычислим количество значений типа float, которые необходимо сохранить в кэше ключей и значений для LLM `bigcode/octocoder`, которую мы использовали ранее. Количество значений типа float равно произведению двух, длины последовательности, количества головок внимания, размерности головки внимания и количества слоёв. Для нашей LLM при гипотетической длине входной последовательности 16000 это даёт:

```python
config = model.config
2 * 16_000 * config.n_layer * config.n_head * config.n_embd // config.n_head
```

**Результат**:

```text
7864320000
```

Почти 8 миллиардов значений типа float! Хранение 8 миллиардов значений float в точности `float16` требует около 15 ГБ ОЗУ, что примерно вдвое меньше, чем сами веса модели! Исследователи предложили два метода, позволяющих значительно снизить затраты памяти на хранение кэша ключей и значений; они рассматриваются в следующих подразделах.

#### 3.2.2 Multi-Query-Attention (MQA)

[Multi-Query-Attention](https://huggingface.co/papers/1911.02150) was proposed in Noam Shazeer's *Fast Transformer Decoding: One Write-Head is All You Need* paper. As the title says, Noam found out that instead of using `n_head` key-value projections weights, one can use a single head-value projection weight pair that is shared across all attention heads without that the model's performance significantly degrades.

> Использование одной пары весов проекции для ключей и значений означает, что векторы ключей и значений $\mathbf{k}_i, \mathbf{v}_i$ должны быть идентичными для всех головок внимания, что, в свою очередь, позволяет хранить в кэше лишь одну пару проекций ключей и значений вместо `n_head` пар.

Поскольку большинство LLM используют от 20 до 100 головок внимания, MQA значительно снижает потребление памяти кэш-памятью ключей и значений. Для LLM, используемой в этом ноутбуке, это позволяет сократить требуемое потребление памяти с 15 ГБ до менее чем 400 МБ при длине входной последовательности 16000.

Помимо экономии памяти, MQA также повышает вычислительную эффективность, что объясняется ниже. При авто-регрессивном декодировании большие векторы ключей и значений необходимо повторно загружать, конкатенировать с текущей парой векторов ключа и значения, а затем передавать в вычисление $\mathbf{q}_c\mathbf{K}^T$ на каждом шаге. Для авто-регрессивного декодирования требуемая пропускная способность памяти для постоянной перезагрузки может стать серьезным временным узким местом. За счет уменьшения размера векторов ключей и значений требуется обращение к меньшему объему памяти, что снижает узкое место пропускной способности памяти. Более подробную информацию можно найти в [статье Ноама](https://huggingface.co/papers/1911.02150).

Ключевой момент, который важно здесь понять: сокращение числа ключевых и value-голов внимания до 1 имеет смысл только при использовании кэша ключей и значений. Пиковое потребление памяти модели за один прямой проход без кэша ключей и значений остаётся неизменным, поскольку у каждой головы внимания по-прежнему есть собственный вектор запроса, и, следовательно, для каждой головы внимания матрица $\mathbf{QK}^T$ остаётся уникальной.

MQA получил широкое распространение в сообществе и сейчас используется во многих самых популярных LLM:

- [**Falcon**](https://huggingface.co/tiiuae/falcon-40b)
- [**PaLM**](https://huggingface.co/papers/2204.02311)
- [**MPT**](https://huggingface.co/mosaicml/mpt-30b)
- [**BLOOM**](https://huggingface.co/bigscience/bloom)

Также контрольная точка, используемая в этом ноутбуке — `bigcode/octocoder` — использует MQA.

#### 3.2.3 Grouped-Query-Attention (GQA)

[Grouped-Query-Attention](https://huggingface.co/papers/2305.13245), предложенная Айнсли и соавторами из Google, показала, что использование MQA часто приводит к ухудшению качества по сравнению с использованием стандартных проекций нескольких ключевых и value-голов. В статье утверждается, что сохранить производительность модели можно, менее радикально сокращая количество весов проекций query-голов. Вместо использования всего одного набора весов проекции key-value следует использовать `n < n_head` наборов весов проекции key-value. Выбрав `n` значительно меньшим, чем `n_head`, например 2, 4 или 8, можно сохранить почти все преимущества MQA в плане памяти и скорости, пожертвовав при этом меньшей ёмкостью модели и, следовательно, меньшей производительностью.

Более того, авторы GQA выяснили, что существующие контрольные точки моделей можно *дообучить* до архитектуры GQA, затратив всего 5% вычислительных ресурсов исходного предобучения. Хотя 5% исходных вычислительных ресурсов предобучения всё ещё могут составлять значительный объём, *дообучение* GQA позволяет использовать существующие контрольные точки для более длинных входных последовательностей.

GQA был предложен совсем недавно, поэтому на момент написания этого ноутбука его применение еще не получило широкого распространения. Наиболее заметным примером использования GQA является [Llama-v2](https://huggingface.co/meta-llama/Llama-2-70b-hf).

> В качестве вывода настоятельно рекомендуется использовать GQA или MQA, если LLM развернута с авто-регрессивным декодированием и должна обрабатывать длинные входные последовательности, как, например, в чат-приложениях.

## Заключение

Исследовательское сообщество постоянно предлагает новые, изящные способы ускорения времени вывода для всё более крупных LLM. В качестве примера, одним из перспективных направлений исследований является [speculative decoding](https://huggingface.co/papers/2211.17192), при котором «лёгкие токены» генерируются более мелкими и быстрыми языковыми моделями, а «сложные токены» — самой LLM. Более подробное описание выходит за рамки данного ноутбука, но с ним можно ознакомиться в этой [отличной статье](https://huggingface.co/blog/assisted-generation).

Причина, по которой крупные LLM, такие как GPT3/4, Llama-2-70b, Claude, PaLM, работают так быстро в чат-интерфейсах вроде [Hugging Face Chat](https://huggingface.co/chat/) или ChatGPT, во многом заключается в упомянутых выше улучшениях точности, алгоритмов и архитектуры. В будущем ускорители, такие как GPU, TPU и т. д., станут ещё быстрее и позволят использовать больше памяти, однако в любом случае всегда стоит использовать лучшие доступные алгоритмы и архитектуры, чтобы получить максимальную отдачу 🤗

