# Обзор

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

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

> [!NOTE]
> Память и скорость тесно связаны, но не тождественны. Сокращение объёма используемой памяти делает модель «быстрее», поскольку уменьшается количество данных, которые необходимо перемещать. Чистые оптимизации скорости не всегда снижают потребление памяти, а иногда даже увеличивают его. Выбирайте подходящую оптимизацию в зависимости от вашей задачи и аппаратного обеспечения.

Используйте таблицу ниже, чтобы выбрать метод оптимизации.

| Техника | Скорость | Память |
|---|:---:|:---:|
| [Компиляция](#compilation) | ✅ | |
| [Бэкенды внимания](#attention-backends) | ✅ | ✅ |
| [Ядра](#kernels) | ✅ | ✅ |
| [Квантование](#quantization) | ✅ | ✅ |
| [Кэширование](#caching) | ✅ | ✅ |
| [Параллелизм](#parallelism) | ✅ | |
| [Непрерывная пакетная обработка](#continuous-batching) | ✅ | |

В этом руководстве кратко описаны оптимизации Transformers.

## Компиляция

[torch.compile](./perf_torch_compile) снижает накладные расходы Python, объединяет операции и создаёт ядра, оптимизированные под ваши размеры тензоров и оборудование. Первый запуск выполняет прогрев, а последующие используют более быстрый скомпилированный путь.

Передайте [кэш фиксированного размера](./kv_cache#fixed-size-cache) в [generate()](/docs/transformers/main/ru/main_classes/text_generation#transformers.GenerationMixin.generate), чтобы автоматически запустить `torch.compile`.

```py
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-0.6B")
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen3-0.6B", dtype=torch.float16, device_map="auto")
input = tokenizer("The French Bread Law states", return_tensors="pt").to(model.device)

output = model.generate(**input, do_sample=False, max_new_tokens=20, cache_implementation="static")
tokenizer.batch_decode(output, skip_special_tokens=True)[0]
```

> [!WARNING]
> Избегайте вызова `torch.compile(model)` вне [generate()](/docs/transformers/main/ru/main_classes/text_generation#transformers.GenerationMixin.generate), чтобы модель не перекомпилировалась на каждом шаге.

## Бэкенды внимания

Альтернативные [бэкенды внимания](./attention_interface) снижают объём трафика памяти. Например, FlashAttention разбивает вычисления внимания на блоки и избегает создания крупных промежуточных тензоров, что уменьшает потребление памяти.

Укажите `attn_implementation` в [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained), чтобы загрузить оптимизированный бэкенд внимания.

```py
from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen3-0.6B", attn_implementation="flash_attention_2")
```

## Ядра

Kernels объединяют операции, чтобы повысить пропускную способность и снизить потребление памяти. Библиотека [Kernels](https://huggingface.co/docs/kernels/en/index) загружает оптимизированные вычислительные ядра из [Hub](https://huggingface.co/kernels-community) гибким и безопасным с точки зрения версий способом.

Приведённый ниже пример загружает оптимизированное ядро FlashAttention-2 без установки пакета.

```py
import torch
from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3-0.6B", attn_implementation="kernels-community/flash-attn2"
)
```

## Квантование

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

Передайте конфигурацию квантования в аргумент `quantization_config` в [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained). У каждого бэкенда квантования своя конфигурация с различными аргументами. В примере ниже модель квантуется до 4 бит, а тип данных для вычислений настраивается с помощью бэкенда [bitsandbytes](./quantization/bitsandbytes).

```py
import torch
from transformers import AutoModelForCausalLM, BitsAndBytesConfig

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

model = AutoModelForCausalLM.from_pretrained(
    "allenai/Olmo-3-7B-Think", quantization_config=bnb_config
)
```

## Кэширование

[Кэширование](./kv_cache) ускоряет генерацию, повторно используя прошлые ключи и значения вместо их пересчёта для каждого токена. Для компенсации и снижения затрат памяти на хранение прошлых ключей и значений Transformers поддерживает выгрузку кэша на CPU. На GPU остаётся только текущий слой.

Используйте аргумент `cache_implementation` в [generate()](/docs/transformers/main/ru/main_classes/text_generation#transformers.GenerationMixin.generate), чтобы задать стратегию кэширования.

```py
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-0.6B")
model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3-0.6B", attn_implementation="kernels-community/flash-attn2"
)
inputs = tokenizer("The Le Décret Pain states that a baguette must,", return_tensors="pt")
outputs = model.generate(**inputs, do_sample=False, max_new_tokens=50, cache_implementation="offloaded")
```

## Параллелизм

[Parallelism](./perf_infer_gpu_multi) распределяет модель по устройствам, чтобы модели, слишком большие для одного устройства, работали быстро. Этот подход потребляет больше памяти из-за накладных расходов на шардирование и коммуникацию для синхронизации результатов.

[Параллелизм тензоров](./perf_infer_gpu_multi) распределяет слой модели между устройствами. Укажите количество устройств с помощью `DistributedConfig(tp_size=N)` и передайте его в [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained), чтобы включить этот режим.

```py
from transformers import AutoModelForCausalLM, DistributedConfig

distributed_config = DistributedConfig(tp_size=4)
model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Meta-Llama-3-8B-Instruct",
    distributed_config=distributed_config,
)
print(model._tp_plan)
```

## Непрерывная пакетная обработка

[Continuous batching](./continuous_batching) максимизирует пропускную способность, поддерживая загрузку GPU за счёт динамического планирования и chunked prefill. Приложения для [Serving](./serve-cli/serving) используют его для одновременной обработки нескольких входящих запросов.

Используйте [generate_batch()](/docs/transformers/main/ru/main_classes/text_generation#transformers.ContinuousMixin.generate_batch) для включения непрерывного батчинга.

```py
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from transformers.generation import ContinuousBatchingConfig, GenerationConfig

model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3-0.6B",
    attn_implementation="sdpa",
    device_map="auto",
    torch_dtype=torch.bfloat16,
)
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-0.6B")

prompts = [
    "The Le Décret Pain states that a baguette must",
    "Explain gravity in one sentence.",
    "Name the capital of France.",
]
inputs = [tokenizer.encode(p) for p in prompts]

generation_config = GenerationConfig(
    max_new_tokens=32,
    eos_token_id=tokenizer.eos_token_id,
    pad_token_id=tokenizer.pad_token_id,
    do_sample=False,
)
continuous_batching_config = ContinuousBatchingConfig(max_batch_tokens=512)

outputs = model.generate_batch(
    inputs=inputs,
    generation_config=generation_config,
    continuous_batching_config=continuous_batching_config,
)

for request_id, output in outputs.items():
    text = tokenizer.decode(output.generated_tokens, skip_special_tokens=True)
    print(f"[{request_id}] {text}")
```