9 ноября 2026 г. · Анатолий Крылов, редактор Терафермы
CUDA out of memory: 9 способов уместить модель в видеопамять
Ошибка CUDA out of memory означает, что модели, батчу или контексту не хватило видеопамяти. В девяти случаях из десяти её можно исправить без новой карты: уменьшить батч и включить накопление градиентов, перейти на bf16, включить gradient checkpointing, квантовать модель или ограничить контекст. Эти приёмы экономят от 30% до 75% памяти. Если не помогло, карта на 32 ГБ стоит 67 ₽/час, переезжать сразу на H100 обычно не нужно.
Как прочитать сообщение об ошибке
Типичный текст выглядит так:
torch.OutOfMemoryError: CUDA out of memory. Tried to allocate 2.00 GiB.
GPU 0 has a total capacity of 23.55 GiB of which 1.12 GiB is free.
Of the allocated memory 20.31 GiB is allocated by PyTorch,
and 1.65 GiB is reserved by PyTorch but unallocated.
Из него видно три вещи:
- Сколько запрошено (2 ГБ) и сколько свободно (1,1 ГБ). Если не хватает немного, помогут мелкие настройки. Если в разы, нужно квантование или другая карта.
- Сколько занял PyTorch (20,3 ГБ). Если это число намного меньше общего объёма, а свободной памяти всё равно нет, память держит другой процесс.
- Reserved but unallocated (1,65 ГБ). Большое значение говорит о фрагментации, она лечится отдельно, способом № 9.
Ещё полезно понять, в какой момент падает. Если сразу при загрузке модели, значит не помещаются веса. Если на первом шаге обучения, виноваты градиенты и состояния оптимизатора. Если через несколько минут работы, растёт контекст или течёт память.
Способ 1. Проверить, кто занимает память
Прежде чем что-то настраивать, посмотрите:
nvidia-smi
В нижней части выводится список процессов с объёмом памяти. Частые находки: второе ядро Jupyter с загруженной моделью, оставшийся после падения процесс Python, параллельно запущенный сервер ComfyUI или Ollama. Завершите лишнее командой kill <PID>.
В ноутбуке Jupyter память не освобождается, пока жива переменная. Удалите объекты и очистите кэш:
import gc, torch
del model, optimizer
gc.collect()
torch.cuda.empty_cache()
Надёжнее всего перезапустить ядро.
Способ 2. Уменьшить батч и накапливать градиенты
Активации растут пропорционально размеру батча. Уменьшите батч вдвое, а чтобы обучение шло так же, накапливайте градиенты за два шага:
# Hugging Face Trainer
TrainingArguments(per_device_train_batch_size=4, gradient_accumulation_steps=4, ...)
Эффективный батч остаётся 16, а память под активации падает в четыре раза по сравнению с батчем 16 за один проход. Скорость немного снижается: карта делает больше мелких шагов.
Способ 3. Перейти на bf16
Обучение и инференс в FP32 тратят 4 байта на каждый параметр и активацию. bf16 тратит 2 байта, то есть вдвое меньше. На картах с архитектурой Ampere и новее (RTX 30, 40, 50, A100, H100) bf16 работает быстрее FP32 и почти не влияет на качество.
model = AutoModelForCausalLM.from_pretrained(name, torch_dtype=torch.bfloat16)
# или в TrainingArguments: bf16=True
Если модель загружается без указания типа, многие библиотеки по умолчанию берут FP32, и это частая и незаметная причина ошибки.
Способ 4. Включить gradient checkpointing
При обучении фреймворк хранит активации всех слоёв для обратного прохода. Чекпойнтинг хранит лишь часть, а остальное пересчитывает. Память под активации падает в несколько раз, время шага растёт примерно на 20–30%.
model.gradient_checkpointing_enable()
# или TrainingArguments(gradient_checkpointing=True)
Для дообучения LLM на одной карте это почти обязательный пункт.
Способ 5. Квантовать модель
Самый сильный способ для инференса и дообучения через LoRA. Веса в 4 битах занимают примерно 0,6 ГБ на миллиард параметров вместо 2 ГБ в FP16, экономия около 70%.
from transformers import BitsAndBytesConfig
q = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_compute_dtype=torch.bfloat16, bnb_4bit_quant_type="nf4")
model = AutoModelForCausalLM.from_pretrained(name, quantization_config=q)
Для инференса удобнее готовые квантованные файлы: GGUF для llama.cpp и Ollama, AWQ или GPTQ для vLLM. Чем форматы отличаются и сколько качества теряется, разобрано в статье квантование LLM: GGUF, AWQ и FP8. Качество в 4 битах для моделей от 7B обычно почти не отличается от FP16 в повседневных задачах, но в точных (код, математика, извлечение данных) 8 бит надёжнее. Обучение полных весов в 4 битах невозможно, но LoRA поверх 4-битной модели (QLoRA) остаётся стандартным способом дообучить 70B на одной карте.
Способ 6. Ограничить контекст и KV-кэш
При генерации текста модель хранит кэш ключей и значений для каждого токена контекста. На длинных диалогах он может занимать больше, чем сами веса. Формула:
KV-кэш, байт = 2 × слои × KV-головы × размер головы × длина контекста × байт на число × число запросов
Пример для модели класса 8B с 32 слоями, 8 KV-головами и размером головы 128 в bf16: 2 × 32 × 8 × 128 × 2 = 131 072 байта, то есть 128 КБ на токен. Контекст 32 тыс. токенов займёт 4 ГБ. Восемь одновременных запросов с таким контекстом займут 32 ГБ, больше, чем вся RTX 4090.
Что делать:
- в vLLM задайте
--max-model-lenпод реальную длину запросов, а не максимум модели; - там же уменьшите
--max-num-seqs, если запросов одновременно меньше; - включите квантованный кэш:
--kv-cache-dtype fp8в vLLM или-ctk q8_0 -ctv q8_0в llama.cpp, это минус половина памяти кэша; --gpu-memory-utilization 0.9оставляет запас для других процессов.
Подробнее о том, сколько памяти нужно моделям разного размера, читайте в статье сколько видеопамяти нужно для LLM.
Способ 7. Экономные режимы для генерации изображений
Stable Diffusion, SDXL и Flux падают с CUDA out of memory на больших разрешениях и при пакетной генерации. В diffusers есть несколько переключателей:
pipe.enable_attention_slicing() # внимание по частям
pipe.vae.enable_tiling() # VAE по плиткам — для больших разрешений
pipe.enable_model_cpu_offload() # держать в GPU только текущий блок
В ComfyUI ту же роль играют флаги --lowvram и --novram при запуске, а также модели в FP8 вместо FP16. Flux.1 dev в FP8 помещается в 16 ГБ, в полной точности ему нужно около 24 ГБ и больше.
Способ 8. Выгрузить часть модели в оперативную память
Если модель не помещается даже квантованной, часть слоёв можно держать в ОЗУ:
model = AutoModelForCausalLM.from_pretrained(name, device_map="auto", max_memory={0: "22GiB", "cpu": "64GiB"})
В llama.cpp то же делает параметр -ngl: сколько слоёв загрузить в видеокарту. Для MoE-моделей есть отдельный приём: выгрузить в ОЗУ только экспертов (--n-cpu-moe), оставив внимание на карте.
Это работает, но медленно: для плотных моделей скорость падает в 3–10 раз. Подходит для разовой проверки, а не для работы. Если выгрузка стала постоянной, дешевле арендовать карту побольше.
Способ 9. Убрать фрагментацию
Если в ошибке большое значение «reserved but unallocated», свободная память есть, но разбита на куски. Задайте перед запуском:
export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True
Аллокатор PyTorch начнёт расширять существующие сегменты вместо выделения новых, и фрагментация обычно исчезает. Это особенно помогает при обучении с последовательностями разной длины.
Какой способ выбрать
| Способ | Экономия памяти | Цена в скорости | Когда применять |
|---|---|---|---|
| 1. Освободить память | до 100% лишнего | нет | всегда в первую очередь |
| 2. Батч + накопление градиентов | 30–70% активаций | 5–15% | обучение |
| 3. bf16 вместо FP32 | ≈ 50% | ускорение | обучение и инференс |
| 4. Gradient checkpointing | 60–80% активаций | 20–30% | обучение |
| 5. Квантование 4/8 бит | 50–75% весов | от 0 до 20% | инференс, QLoRA |
| 6. Контекст и KV-кэш | до 50% кэша и больше | нет | инференс LLM |
| 7. Режимы diffusers и ComfyUI | 20–60% | 10–50% | генерация картинок |
| 8. Выгрузка в ОЗУ | сколько угодно | в 3–10 раз | разовые проверки |
| 9. expandable_segments | 5–20% | нет | при фрагментации |
Когда пора взять карту больше
Посчитайте, поместится ли задача в принципе:
Нужно памяти ≈ веса + KV-кэш или активации + 15–20% запаса
Веса считаются как параметры в миллиардах × 2 ГБ для FP16 или × 0,6 ГБ для 4 бит. Для обучения LoRA добавьте 20–40% к весам, для полного дообучения закладывайте около 16 байт на параметр. Проще всего прикинуть всё сразу в VRAM-калькуляторе.
Если результат больше памяти карты даже после квантования, настройки не помогут. Ориентиры по объёму:
| Объём | Что помещается | Тариф, ₽/час |
|---|---|---|
| 24 ГБ (RTX 4090) | LLM до 32B в 4 битах, Flux в полной точности, LoRA для 8B | 54 |
| 32 ГБ (RTX 5090) | то же с длинным контекстом, LoRA для 14B | 67 |
| 48 ГБ (RTX A6000) | 70B в 4 битах, QLoRA для 70B | 69 |
| 80 ГБ (A100) | 70B в 8 битах, LoRA для 32B в bf16 | 154 |
Переход на карту побольше стоит денег, но и время на борьбу с ошибкой стоит денег: час отладки на RTX 4090 обходится в 54 ₽, и иногда проще сразу запустить задачу на 32 ГБ. Список карт от этого объёма есть на странице аренда GPU с 32 ГБ видеопамяти.
Когда память «течёт»
Отдельный случай: ошибка появляется не сразу, а через десятки или сотни шагов. Модель помещается, но потребление памяти растёт, пока не упрётся в потолок. Почти всегда это ошибка в коде, а не нехватка памяти.
Накопление тензоров с графом вычислений. Классика: total_loss += loss в цикле обучения. Вместе с числом сохраняется весь граф для обратного прохода, и память растёт с каждым шагом. Правильно так: total_loss += loss.item().
Оценка без torch.no_grad(). На валидации PyTorch по умолчанию строит граф для градиентов, которые никому не нужны. Оборачивайте оценку в with torch.no_grad(): или torch.inference_mode(): это экономит память и ускоряет проверку.
Списки выходов модели. Если вы сохраняете логиты или эмбеддинги каждого батча в список на GPU, он растёт до конца эпохи. Переносите их на CPU (.cpu()) или сохраняйте только нужное.
Растущий контекст в чате. В сервисах с LLM память может расти от того, что история диалога передаётся целиком и становится всё длиннее. Обрезайте историю или сжимайте её до краткого резюме.
Утечки в ноутбуке. Каждый перезапуск ячейки с загрузкой модели в Jupyter может оставлять в памяти предыдущую копию, если на неё осталась ссылка. Проще перезапустить ядро, чем искать, где она живёт.
Проверить, течёт ли память, легко: печатайте torch.cuda.memory_allocated() каждые несколько шагов. Если число стабильно, всё в порядке. Если растёт от шага к шагу, ищите одну из причин выше.
CUDA out of memory — не приговор карте. Сначала проверьте, не держит ли память другой процесс, затем включите bf16, уменьшите батч с накоплением градиентов и включите чекпойнтинг — это решает большинство ошибок при обучении. Для инференса главные рычаги это квантование и ограничение контекста. Если модель не помещается и после этого, считайте память по формуле и берите карту, в которую задача влезает с запасом.
Прикиньте объём в VRAM-калькуляторе и запустите задачу на подходящей карте в разделе аренда GPU для ИИ.