Сравниваем скорость генерации LLM локально и по API

По ощущениям, на Хабре одна группа пользуется LLM локально, а другая — через внешние API.

А третья еще не определилась, и у неё периодически возникают следующие вопросы:

• Что будет, если запускать LLM на CPU вместо GPU? Сильно упадет скорость?

• А как это от размера модели зависит?

• А DeepSeek оригинальный очень большой — а можно его с диска подкачивать, если он в RAM не влезает?

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

TLDR: Я сделал небольшое HTML-приложение, которое наглядно дает ощущение скорости генерации в разных инсталляциях. Если непонятно, что там к чему — то лучше прочитать статью.

Локальный запуск LLM

Обычно локально всякие LLM-сети запускают с помощью программ типа Ollama или LM Studio — они как скачивают нужную сеть из интернета, так и запускают её у вас.

Обычно у них есть три варианта запуска:

• Модель полностью помещается в памяти GPU (обычно Nvidia) — и это самый быстрый вариант

• Модель полностью помещается в RAM — это приемлемый вариант

• Модель периодически загружается с SSD через swap (это работает адски медленно, можете потом в примерах посмотреть — имхо неюзабельно)

Модели бывают разных размеров — Llama 7B, 70B, Mistral Nemo 12B и пр. Нас интересует цифирка рядом с B — это, грубо говоря, число весов модели. Будем называть его SIZEB.

При этом надо понимать следующее: оригинальные веса модели хранятся в float32 (4 байта) — и, таким образом, если вы хотите запустить оригинальную модель, вам понадобится приблизительно SIZEB x 4 Гб памяти. Т.е. 28 Гб даже для не очень серьезной по качеству 7B-модели.

Понятное дело, это очень серьезные требования к железу, и люди придумали хак: они начали квантизировать веса — т.е. кодировать их меньшим количеством битов (меньше 32 оригинальных). Понятное дело, это приводит к понижению точности и качества генерации модели — но… это зависит от уровня квантизации.

Подобные квантизированные веса сейчас чаще всего распространяются в формате gguf (вы можете его увидеть, если будете качать с сайта). Условно считается, что:

• Квантизация q8 (8 бит на вес) почти не влияет на качество модели. Модель при этом занимает в памяти около SIZEB Гб

• Квантизация q4 (4 бита на вес) прилично влияет на качество модели, но в целом она по-прежнему используема. (Модель занимает в памяти SIZEB/2 Гб)

Есть и другие варианты (6 бит, 2 бита, 1 бит, разные квантизации для разных слоев) — но про них как-нибудь в другой раз.

В любом случае, при работе вам всегда имеет смысл качать максимальную модель по числу битов на вес (но не более q8, т.е. 8 бит на вес), которая помещается в памяти вашего устройства — VRAM или RAM.

Например:

• 13B в q4 это 13/2 = 6.5 Гб — помещается на видеокарту с 8Гб VRAM. Но в q8 она уже занимает 13 Гб — и на ту же видеокарту она уже не поместится, только в RAM.

• 70B в q4 это 35 Гб — она уже не помещается ни в одну бытовую видеокарту — но, возможно, поместится в RAM, если её у вас много.

Скорости генерации

Теперь, собственно, самое интересное — с какой скоростью будут работать сети в той или иной инсталляции?

Вот приблизительные цифры (полученные по результатам собственных экспериментов какое-то время назад):

• Локальные модели (помещаются на GPU / VRAM)

  • 7-13B: 20 токенов/секунду

  • 14-40B: 15 токенов/секунду

  • 70-700B: 10 токенов/секунду

• Локальные модели (на CPU / RAM)

  • 7B: 8 токенов/секунду

  • 14B: 5 токенов/секунду

  • 20-40B: 3 токена/секунду

  • 70-700B: 1.5 токена/секунду

• Удаленные модели по API

  • 7B-13B: 50 токенов/секунду

  • 14B-40B: 35 токенов/секунду

  • 70B: 25 токенов/секунду

  • 200-700B: 18 токенов/секунду

• Другие варианты

  • API FAST моделей: 200 токенов/секунду

  • Локальная от 32B, подгрузка с SSD: 0.2 токена/секунду

В реальности они могут раза в два отличаться — т.к. все зависит от процессора, видеокарты и пр., но приблизительное понимание они дают.

Интерактивный вариант

Чтобы не просто смотреть на цифры, а почувствовать, как это работает, я сделал небольшое HTML-приложение:

Пользовательские ощущения

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

• 50 токенов в секунду — ощущается как быстрое

• 10 токенов в секунду и выше — ощущается нормально

• 5 токенов в секунду — минимально приемлемый вариант с ожиданием, но еще не мучительным

Из этого следует, что, по моим ощущениям:

• Если модель помещается в VRAM — можно пользоваться, ощущения нормальные

• Если помещается в RAM, то нормальные ощущения от пользования моделями до 7B, условно можно пользоваться моделями до 13B; выше — ужасно медленно.

• Подгрузка с диска дает около 0.2 т/с — можете попробовать прям в приложении это ощущение, чтобы не пробовать вживую 🙂

По API, конечно, пользоваться можно с гораздо большим удовольствием:

• Большинство моделей выдают от 20 токенов в секунду

• Легкие модели — OpenAI gpt-4o-mini, Google Flash 2.0 — выдают 50-100 токенов в секунду, что ощущается как очень быстрый ответ.

• Изредка можно найти провайдеров, которые хостят модели с удивительной скоростью — например, я нашел DeepSeek 0324 со скоростью 200 токенов в секунду. Ощущение — как будто все летает, конечно. (Правда, за это приходится платить свою цену — при этом варианте контекст ограничен 8 000 токенами в противовес 128 000 в обыкновенном DeepSeek)

В общем, если:

• Нужная вам модель не предлагается никем

• Или у вас жесткие требования к приватности обработки данных

…используйте локальные модели. В противном случае, по моему мнению, гораздо лучше использовать удаленное API.

PS: Еще раз ссылка на приложение, в котором можно потыкать и ощутить разницу в скорости.