Логотип Терафермы Тераферма Регистрация

9 ноября 2026 г. · Анатолий Крылов, редактор Терафермы

CUDA out of memory: 9 способов уместить модель в видеопамять

Видеокарта с переполненным чипом памяти и кубиками данных — как решить ошибку CUDA out of memory

Ошибка 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 для ИИ.

Вопросы по теме

Что значит ошибка CUDA out of memory?

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

Как быстро исправить CUDA out of memory при обучении?

Уменьшите размер батча вдвое и компенсируйте его накоплением градиентов, включите обучение в bf16 и gradient checkpointing. Эти три шага вместе обычно снижают потребление памяти в 2–4 раза без потери качества обучения.

Почему CUDA out of memory, если в nvidia-smi память свободна?

Из-за фрагментации: свободная память разбита на куски, и ни один не подходит под запрошенный блок. Помогает переменная PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True перед запуском. Ещё одна частая причина — второй процесс или зависшее ядро Jupyter, которое держит память; его видно в nvidia-smi.

Когда пора брать видеокарту с большей памятью?

Когда модель не помещается даже в 4-битном квантовании, а выгрузка в оперативную память замедляет работу в разы. Ещё один признак — вы урезаете контекст или батч так, что страдает качество. Карта на 32 ГБ стоит от 67 ₽/час, на 48 ГБ — от 69 ₽/час.

Читайте также

Gemma 4, Qwen3.5 и Ministral: лёгкие LLM для одной видеокарты на 16–24 ГБ

Какая лёгкая LLM поместится на одну видеокарту: модели 8–14B идут на 16 ГБ, 27–31B — на 24 ГБ в 4 битах. Таблица памяти, скорость в токенах и цена часа.

Midjourney или свой Flux на арендованной GPU: что дешевле для 1 000 картинок

1 000 картинок в Midjourney — тариф Standard за $30 в месяц, во Flux на арендованной RTX 4090 — около 5 часов работы карты. Сравниваем цену, качество и контроль.

Нейросеть для поддержки клиентов на своей LLM: разбор обращений и черновики ответов

Своя LLM на одной RTX 4090 разбирает около 3 000 обращений в день: тема, срочность, черновик ответа по базе знаний. Схема, модели и расчёт стоимости на месяц.

Свой код-ассистент вместо Copilot: Qwen Coder на арендованной GPU

Локальный аналог Copilot на Qwen3.6 27B и одной RTX 4090: автодополнение и агент в VS Code через Continue или Cline. Настройка, память под контекст и цена команды.

Подберите GPU

Все видеокарты каталога с поминутной оплатой в рублях.