Каждый новый токен модель пишет, оглядываясь на весь уже написанный текст. Этот взгляд называется вниманием, а чтобы не повторять одну и ту же работу на каждом шаге, модель хранит кэш ключей и значений. От этих двух вещей зависят цена длинного контекста, задержка первого слова, память видеокарты и то, сколько людей может обслуживать один сервер. Разберём по шагам, от формулы до сервера. Весь код на странице мы запускали, и все выводы — из этих запусков; векторы в примерах маленькие и придуманы, а размеры моделей взяты из их настоящих файлов настроек.
Все дорожки — /put. Прошлая — как модель вызывает функции.
Зачем это в работе. Почти все новости про модели — «окно в миллион токенов», «ускорили ответ в два раза», «новый сервер для моделей» — упираются в один механизм внутри модели: внимание (attention). Это способ, которым каждый токен заглядывает в уже написанный текст и решает, что из него важно. Если понимать внимание на уровне «что на что умножается», становится ясно, почему длинный контекст дорогой, откуда берётся задержка и зачем серверам моделей столько видеопамяти. Без этого любые цифры в новостях о скорости и цене остаются заклинаниями.
Вспомни дорожку про токены: текст режется на кусочки, и каждый кусочек внутри модели превращается в вектор — список из нескольких тысяч чисел, который кодирует смысл. Беда в том, что вектор слова «она» сам по себе не знает, о ком речь. Чтобы понять, ему нужно посмотреть на соседей. Внимание и есть этот взгляд: для каждого токена модель вычисляет, какую долю «интереса» отдать каждому предыдущему токену, и смешивает их смыслы в этих долях.
Устроено это через три вектора, которые модель получает из каждого токена умножением на обученные таблицы чисел (матрицы весов). Запрос (query) — «что я ищу»: у слова «она» это примерно «ищу человека женского рода». Ключ (key) — «что я могу предложить»: у слова «Маша» это «я человек, женского рода». Значение (value) — «что я передам, если на меня посмотрят». Дальше по шагам: запрос текущего токена сравнивается с ключом каждого токена — это скалярное произведение, сумма попарных произведений чисел, чем оно больше, тем векторы ближе по направлению. Результат делится на корень из длины вектора, чтобы числа не разрастались. Потом функция softmax превращает оценки в доли, которые положительны и в сумме дают единицу. Наконец, значения всех токенов складываются с этими долями — получается новый вектор для «она», в котором уже есть кусочек смысла «Маши».
Ограничение заложено в самой схеме: чтобы посчитать внимание для одного токена, надо сравнить его запрос с ключами всех предыдущих. Для текста из n токенов это n×n сравнений, то есть стоимость растёт как квадрат длины: вдвое длиннее текст — вчетверо больше работы на этом шаге. Именно отсюда растут проблемы длинного контекста, про которые была дорожка об окне контекста.
Чем внимание отличается от поиска по смыслу из дорожки про эмбеддинги. Там тоже сравнивают векторы, но это делает твоя программа один раз, чтобы выбрать подходящие документы. Внимание происходит внутри модели, на каждом её слое и для каждого токена, и результат не «нашёл или не нашёл», а мягкая смесь всех предыдущих токенов. Схему с запросами, ключами и значениями описала статья «Attention Is All You Need» (Vaswani и соавторы, Google, 2017), с которой начались трансформеры — архитектура почти всех нынешних языковых моделей.
Подробный пример. Посчитаем внимание для слова «она» во фразе «Маша купила книгу, она …» руками на numpy (библиотека Python для работы с массивами чисел). Векторы маленькие и заданы вручную, чтобы был виден смысл; в настоящей модели в них тысячи чисел, и подбирает их обучение.
import numpy as np
# Четыре токена фразы «Маша купила книгу, она ...». Векторы заданы руками,
# чтобы было видно смысл; в настоящей модели их получают обучением.
words = ["Маша", "купила", "книгу", "она"]
# запрос (query): «что я ищу»; ключ (key): «что я предлагаю»; значение (value): «что я передам»
K = np.array([[1.0, 0.0, 0.2], # Маша: «я человек, женского рода»
[0.0, 1.0, 0.0], # купила: «я действие»
[0.2, 0.0, 1.0], # книгу: «я предмет»
[0.3, 0.0, 0.0]]) # она
V = np.array([[1.0, 0.0], # значение «Маши»
[0.0, 1.0],
[0.5, 0.5],
[0.1, 0.1]])
q = np.array([2.0, 0.0, 0.5]) # запрос слова «она»: ищу человека
d = K.shape[1]
scores = K @ q / np.sqrt(d) # похожесть запроса на каждый ключ
weights = np.exp(scores) / np.exp(scores).sum() # softmax: доли, в сумме 1
out = weights @ V # смесь значений по долям
for w, s, a in zip(words, scores, weights):
print(f"{w:7s} оценка {s:5.2f} доля внимания {a:.2f}")
print("сумма долей:", round(weights.sum(), 6))
print("выход для «она»:", np.round(out, 2))
У нас этот код напечатал:
Маша оценка 1.21 доля внимания 0.45
купила оценка 0.00 доля внимания 0.13
книгу оценка 0.52 доля внимания 0.23
она оценка 0.35 доля внимания 0.19
сумма долей: 1.0
выход для «она»: [0.58 0.27]
Почти половину внимания получила «Маша», потому что её ключ сильнее всего похож на запрос. Но и остальные получили свою долю: softmax никогда не даёт ровно ноль, поэтому выход — смесь, где «Маши» больше всего. Обрати внимание: токен «она» смотрит и сам на себя, это нормально. В настоящей модели такой расчёт идёт одновременно для всех токенов и повторяется на каждом слое, а их у современных моделей десятки.
Где обычно ошибаются.
Внимание (attention). механизм, которым каждый токен смешивает смыслы предыдущих токенов в долях, зависящих от их похожести.
Запрос (query). вектор токена, который описывает, что он ищет в остальном тексте.
Ключ (key). вектор токена, с которым сравнивают чужие запросы, чтобы решить, насколько он интересен.
Значение (value). вектор токена, который попадает в результат в доле, равной вниманию к нему.
Скалярное произведение. сумма попарных произведений чисел двух векторов; чем она больше, тем векторы ближе по направлению.
Softmax. функция, которая превращает любые оценки в положительные доли, в сумме дающие единицу.
Матрица весов. обученная таблица чисел, умножение на которую превращает вектор токена в запрос, ключ или значение.
Трансформер (transformer). архитектура нейросети, построенная на слоях внимания; на ней работают почти все современные языковые модели.
Зачем это в работе. Из устройства внимания следует несколько практических вещей: почему модель не может «вернуться и поправить» уже написанный токен, почему начало ответа можно показывать пользователю сразу, пока конец ещё пишется, и почему одинаковое начало запроса можно не пересчитывать. Всё это держится на одном правиле — маске, которая запрещает токену смотреть вперёд. Вторая деталь, несколько голов внимания, объясняет строчки вроде «28 голов, 4 из них для ключей» в описаниях моделей, которые понадобятся на четвёртой ступени.
Языковая модель учится угадывать следующий токен. Если бы при обучении токен видел текст справа от себя, задача была бы нечестной: ответ лежал бы прямо перед глазами. Поэтому оценки внимания к будущим токенам заменяют на минус бесконечность до softmax, и их доля становится ровно нулём. Это причинная маска (causal mask): в таблице внимания всё, что выше диагонали, закрыто. Получается треугольник: первый токен видит только себя, второй — себя и первого, и так далее.
Отсюда важное следствие: вычисления для токена номер пять не зависят от токенов шесть, семь и дальше. Значит, всё, что модель посчитала для начала текста, остаётся верным, сколько бы токенов ни добавилось потом. На этом держится кэш ключей и значений со следующей ступени и кэш одинакового начала запроса, про который была дорожка о цене и скорости. И это же объясняет, почему модель не исправляет уже выданный токен: его выбор окончателен, а «передумать» она может только следующими токенами, как в рассуждениях из дорожки про рассуждение.
Вторая деталь — головы (heads). Одного взгляда мало: слову нужно одновременно понять, кто действует, к чему относится прилагательное, где закрывается скобка. Поэтому внимание делают несколько раз параллельно, каждый раз со своими таблицами весов, и каждая такая копия называется головой. Каждая голова получает свой кусок вектора, считает свои доли, а результаты склеиваются обратно. Это многоголовое внимание (multi-head attention). Какая голова чему научилась, никто заранее не задаёт, это получается само при обучении.
Предел маски: модель видит только то, что слева, и видит его одинаково, сколько бы раз ты ни спросил. Если важное условие стоит в конце длинного запроса, токены начала его «не знали», когда считались. Это одна из причин, почему инструкцию часто советуют ставить и в начало, и рядом с вопросом. От обычного «прочитать текст целиком», как делает человек, это отличается принципиально: у модели нет второго прохода по уже прочитанному, если ты его не устроишь сам.
Подробный пример. Пять случайных токенов, случайные таблицы весов, внимание с маской и без неё. Потом меняем последний токен и проверяем, изменились ли выходы первых четырёх.
import numpy as np
rng = np.random.default_rng(0)
def attention(X, Wq, Wk, Wv, causal=True):
Q, K, V = X @ Wq, X @ Wk, X @ Wv
scores = Q @ K.T / np.sqrt(K.shape[1])
if causal: # маска: токен i не видит токены правее себя
n = len(X)
scores = np.where(np.tril(np.ones((n, n))) == 1, scores, -np.inf)
w = np.exp(scores - scores.max(axis=1, keepdims=True))
w = w / w.sum(axis=1, keepdims=True)
return w @ V, w
n, d = 5, 8
X = rng.normal(size=(n, d))
Wq, Wk, Wv = (rng.normal(size=(d, d)) for _ in range(3))
out, w = attention(X, Wq, Wk, Wv)
print("доли внимания с маской (строка = кто смотрит):")
print(np.round(w, 2))
# Меняем последний токен: выходы первых четырёх не должны измениться
X2 = X.copy(); X2[-1] = rng.normal(size=d)
out2, _ = attention(X2, Wq, Wk, Wv)
print("с маской, изменение выходов токенов 1-4:", np.abs(out2[:4] - out[:4]).max())
o_full, _ = attention(X, Wq, Wk, Wv, causal=False)
o_full2, _ = attention(X2, Wq, Wk, Wv, causal=False)
print("без маски, изменение выходов токенов 1-4:", round(float(np.abs(o_full2[:4] - o_full[:4]).max()), 3))
У нас этот код напечатал:
доли внимания с маской (строка = кто смотрит):
[[1. 0. 0. 0. 0. ]
[1. 0. 0. 0. 0. ]
[0.9 0.05 0.06 0. 0. ]
[0.4 0.1 0.49 0.02 0. ]
[0.83 0. 0.05 0. 0.12]]
с маской, изменение выходов токенов 1-4: 0.0
без маски, изменение выходов токенов 1-4: 1.885
Над диагональю везде нули — это и есть маска. Первый токен смотрит только на себя, поэтому его доля 1. Второй при случайных весах тоже почти целиком смотрит на первый (у нас вышло 0,9999999 — округлилось до 1). Главное в последних строках: с маской замена пятого токена не изменила выходы первых четырёх ни на одну единицу, разница ровно 0.0. Без маски те же выходы сдвинулись на 1.885 — каждый токен «подглядел» в изменённое будущее. Именно поэтому посчитанное для начала текста можно хранить и переиспользовать.
Где обычно ошибаются.
Причинная маска (causal mask). правило, которое обнуляет внимание токена ко всем токенам правее него.
Минус бесконечность. значение, которое ставят вместо оценки будущего токена, чтобы после softmax его доля стала ровно нулём.
Голова внимания (head). одна из нескольких параллельных копий внимания со своими таблицами весов.
Многоголовое внимание (multi-head attention). внимание, посчитанное несколькими головами сразу, с последующей склейкой результатов.
Слой (layer). один повтор блока «внимание плюс обработка каждого токена»; в модели таких слоёв десятки.
Авторегрессия. способ писать текст по одному токену, где каждый следующий выбирается с учётом всех предыдущих.
Зачем это в работе. Когда сервис показывает «время до первого токена» и «токенов в секунду», это две разные фазы работы модели, и устроены они по-разному именно из-за кэша ключей и значений (KV cache). От него зависит, почему длинный вопрос задерживает начало ответа, почему длинный ответ стоит дороже длинного вопроса у большинства сервисов и почему сервер упирается не в скорость вычислений, а в память. Это понятие постоянно встречается в новостях про серверы моделей и ускорители.
Вспомним, как модель пишет ответ: по одному токену, и для каждого нового токена нужны ключи и значения всех предыдущих, на каждом слое. Наивно на каждом шаге можно пересчитывать их заново для всего текста. Но со второй ступени мы знаем: из-за маски ключи и значения старых токенов не меняются, когда добавляются новые. Значит, их можно посчитать один раз и сложить в память. Это и есть кэш ключей и значений: на каждом шаге модель считает запрос, ключ и значение только для одного нового токена, добавляет ключ и значение в кэш и сравнивает запрос со всем, что там лежит.
Отсюда две фазы. Первая — разбор запроса (prefill): модель за один большой проход считает ключи и значения для всех токенов твоего вопроса сразу. Это много вычислений, но они хорошо распараллеливаются, видеокарта загружена полностью. От длины вопроса зависит время до первого токена (time to first token). Вторая — генерация (decode): по одному токену за шаг. Вычислений на шаге мало, но каждый раз надо прочитать из памяти все веса модели и весь накопленный кэш. Поэтому генерация упирается в скорость памяти, а не в скорость вычислений, и отсюда «токены в секунду».
Ограничение: кэш экономит вычисления, но не сравнения. Новый токен всё равно сравнивает свой запрос со всеми ключами в кэше, поэтому каждый следующий шаг чуть дороже предыдущего, а сам кэш растёт с каждым токеном. Кэш живёт только пока идёт этот разговор на этом сервере. Отличие от кэша одинакового начала запроса из дорожки о цене: тот кэш — это как раз сохранённый кэш ключей и значений для общего начала, который сервис держит между разными запросами и за который берёт меньше денег.
Подробный пример. Один слой внимания с векторами длиной 256 и случайными весами пишет 400 токенов двумя способами: без кэша (на каждом шаге пересчитываются ключи и значения всех токенов) и с кэшем (место под кэш выделено заранее, считается только новый токен). Потом проверяем, что ответы совпадают.
import numpy as np, time
rng = np.random.default_rng(1)
d, steps = 256, 400
Wq, Wk, Wv = (rng.normal(size=(d, d)) / np.sqrt(d) for _ in range(3))
xs = rng.normal(size=(steps, d)) # входы токенов по очереди (заглушка вместо модели)
def attend(q, K, V):
s = K @ q / np.sqrt(d)
w = np.exp(s - s.max()); w /= w.sum()
return w @ V
def no_cache():
outs, proj = [], 0
for t in range(1, steps + 1):
X = xs[:t]
K, V = X @ Wk, X @ Wv # пересчитываем ключи и значения ВСЕХ токенов
proj += 2 * t
outs.append(attend(xs[t-1] @ Wq, K, V))
return np.array(outs), proj
def with_cache():
outs, proj = [], 0
K, V = np.empty((steps, d)), np.empty((steps, d)) # место под кэш заранее
for t in range(steps):
K[t], V[t] = xs[t] @ Wk, xs[t] @ Wv # считаем только новый токен
proj += 2
outs.append(attend(xs[t] @ Wq, K[:t+1], V[:t+1]))
return np.array(outs), proj
for f in (no_cache, with_cache):
t0 = time.perf_counter(); out, proj = f(); dt = time.perf_counter() - t0
print(f"{f.__name__:10s} проекций ключ/значение: {proj:6d} время: {dt*1000:7.1f} мс")
if f is no_cache: ref = out
print("максимальная разница выходов:", np.abs(ref - out).max())
Один из запусков у нас напечатал:
no_cache проекций ключ/значение: 160400 время: 177.4 мс
with_cache проекций ключ/значение: 800 время: 29.9 мс
максимальная разница выходов: 3.885780586188048e-15
Число пересчётов ключей и значений упало с 160 400 до 800 — в двести раз, и разница растёт с длиной текста, потому что без кэша работа растёт как квадрат числа токенов. По времени в трёх запусках у нас вышло 125–177 мс без кэша и 25–30 мс с кэшем: выигрыш меньше, чем по числу пересчётов, потому что сравнения запроса со всеми ключами никуда не делись, а на таком маленьком примере заметна и цена самого Python. Выходы совпали с точностью до 4·10−15 — это погрешность округления дробных чисел, то есть кэш ничего не меняет в результате. Поучительная деталь: в первой версии мы на каждом шаге заново собирали кэш из списка в массив, и время с кэшем было 63–72 мс, примерно вдвое хуже. Копирование растущего кэша на каждом шаге съедает выигрыш, поэтому настоящие серверы выделяют под кэш память заранее.
Где обычно ошибаются.
Кэш ключей и значений (KV cache). сохранённые ключи и значения уже обработанных токенов, чтобы не пересчитывать их на каждом шаге.
Разбор запроса (prefill). первая фаза, когда модель одним проходом обрабатывает все токены вопроса и заполняет кэш.
Генерация (decode). вторая фаза, когда модель пишет ответ по одному токену, каждый раз дописывая кэш.
Время до первого токена (time to first token, TTFT). задержка от отправки запроса до появления первого слова ответа.
Проекция. умножение вектора токена на матрицу весов, которым получают его запрос, ключ или значение.
Пропускная способность памяти (memory bandwidth). сколько байт в секунду видеокарта успевает прочитать из памяти; именно в неё упирается генерация.
Зачем это в работе. Если ты запускаешь модель у себя или выбираешь сервер, памяти нужно не только под веса, про которые была дорожка о квантовании, но и под кэш ключей и значений. На длинных разговорах и при нескольких пользователях сразу кэш легко становится сравним с весами или больше них. Умение посчитать его по описанию модели отвечает на вопрос «влезет ли 32 тысячи токенов на мою видеокарту» до того, как ты что-то скачал.
Размер кэша на один токен считается по формуле: 2 (ключ и значение) × число слоёв × число голов для ключей × длина вектора одной головы × байт на число. Все эти числа лежат в файле настроек модели (config.json) на huggingface.co: num_hidden_layers — слои, num_key_value_heads — головы для ключей, а длина вектора головы — это hidden_size, делённый на num_attention_heads. Полный кэш — это размер на токен, умноженный на число токенов в разговоре и на число разговоров, которые сервер держит одновременно.
Главный приём экономии уже встроен в большинство новых моделей: общие ключи для нескольких голов (grouped-query attention, GQA). Запросов по-прежнему много, по одному на голову, а ключей и значений меньше: несколько голов делят одну пару. Это уменьшает кэш во столько раз, во сколько голов запросов больше, чем голов ключей. Крайний случай, когда пара всего одна на все головы, называется multi-query attention (Shazeer, 2019); промежуточный вариант описан в работе Ainslie и соавторов (Google, 2023). Качество при этом проседает мало, а память и скорость генерации выигрывают заметно, поэтому на практике это стало нормой.
Другие приёмы. Кэш можно хранить в меньшей разрядности, например в 8 битах вместо 16: так умеет, в частности, сервер vLLM (настройка kv_cache_dtype). Это то же квантование, только для кэша, и с тем же риском для точности. Можно ограничить, на сколько токенов назад смотрит внимание, — скользящее окно (sliding window): так сделано в Mistral 7B, где по описанию авторов окно равно 4096 токенам на слой. Тогда кэш перестаёт расти после окна, но дальний текст модель видит только косвенно, через слои. Наконец, можно просто не держать длинные разговоры: сжимать историю, как в дорожке об окне контекста.
Предел расчёта: формула даёт объём самого кэша, но серверы держат ещё служебную память и запас, поэтому реальная потребность всегда немного больше. И это отличается от размера весов: веса фиксированы для модели, а кэш растёт с каждым токеном и с каждым новым собеседником.
Подробный пример. Посчитаем кэш для двух открытых моделей по их настоящим файлам настроек: Qwen2.5-7B-Instruct (28 слоёв, 28 голов запросов, 4 головы ключей, длина вектора 3584) и Qwen2.5-0.5B-Instruct (24 слоя, 14 и 2 головы, длина 896). Числа хранятся в bfloat16, это 2 байта.
# Размер кэша ключей и значений по конфигурации модели.
# Числа из config.json на huggingface.co (Qwen/Qwen2.5-7B-Instruct и Qwen/Qwen2.5-0.5B-Instruct).
models = {
"Qwen2.5-7B": dict(layers=28, heads=28, kv_heads=4, hidden=3584),
"Qwen2.5-0.5B": dict(layers=24, heads=14, kv_heads=2, hidden=896),
}
BYTES = 2 # bfloat16: 2 байта на число
def kv_bytes_per_token(m, kv_heads=None):
head_dim = m["hidden"] // m["heads"]
kv = kv_heads or m["kv_heads"]
return 2 * m["layers"] * kv * head_dim * BYTES # 2 = ключ + значение
GiB = 1024**3
for name, m in models.items():
per = kv_bytes_per_token(m)
full = kv_bytes_per_token(m, kv_heads=m["heads"])
print(f"{name}: на токен {per/1024:.0f} КиБ (без общих голов было бы {full/1024:.0f} КиБ)")
for tokens in (4_096, 32_768):
print(f" {tokens:6d} токенов: {per*tokens/GiB:5.2f} ГиБ ×8 собеседников: {8*per*tokens/GiB:5.1f} ГиБ")
У нас этот код напечатал:
Qwen2.5-7B: на токен 56 КиБ (без общих голов было бы 392 КиБ)
4096 токенов: 0.22 ГиБ ×8 собеседников: 1.8 ГиБ
32768 токенов: 1.75 ГиБ ×8 собеседников: 14.0 ГиБ
Qwen2.5-0.5B: на токен 12 КиБ (без общих голов было бы 84 КиБ)
4096 токенов: 0.05 ГиБ ×8 собеседников: 0.4 ГиБ
32768 токенов: 0.38 ГиБ ×8 собеседников: 3.0 ГиБ
Как читать. У 7B-модели один токен разговора занимает в кэше 56 КиБ. Один разговор на 32 768 токенов — 1,75 ГиБ, а восемь таких разговоров одновременно — 14 ГиБ, и это сверх памяти под сами веса. Без общих голов ключей (если бы их было 28, как голов запросов) кэш был бы в 7 раз больше: 392 КиБ на токен, и те же восемь длинных разговоров потребовали бы около 98 ГиБ. Вот почему общие ключи стали стандартом: без них длинный контекст на одной видеокарте почти не помещается.
Где обычно ошибаются.
hidden_size на число голов ключей вместо числа голов запросов. Длина вектора головы считается по головам запросов, а головы ключей — отдельный множитель.Файл настроек модели (config.json). файл рядом с весами, где записаны число слоёв, голов, длина векторов и другие параметры архитектуры.
Общие ключи для групп голов (grouped-query attention, GQA). схема, где несколько голов запросов делят одну пару ключей и значений, чтобы уменьшить кэш.
Multi-query attention (MQA). крайний вариант той же идеи: одна пара ключей и значений на все головы.
bfloat16. формат дробных чисел в 2 байта, в котором обычно хранят веса и кэш современных моделей.
КиБ и ГиБ. единицы памяти: 1 КиБ — 1024 байта, 1 ГиБ — 1024 в кубе байт.
Скользящее окно (sliding window attention). ограничение, при котором токен смотрит только на фиксированное число предыдущих токенов, и кэш перестаёт расти.
Кэш в 8 битах (FP8 KV cache). хранение ключей и значений в меньшей разрядности, чтобы уместить больше токенов.
Зачем это в работе. В новостях регулярно мелькают vLLM, SGLang, «сервер вывода», «пропускная способность выросла в разы». Это всё про то, как одна видеокарта одновременно пишет ответы многим людям. Понимать это полезно, даже если ты пользуешься только чужим сервисом: отсюда растут цены на пакетную обработку, разница между «быстрым» и «дешёвым» тарифом и то, почему ответ иногда начинается с паузы в часы пик. А если поднимаешь модель у себя, эти настройки прямо решают, сколько пользователей выдержит сервер.
Исходная проблема видна из третьей ступени: при генерации видеокарта на каждом шаге читает из памяти все веса модели, а считает мало. Если писать ответ одному человеку, видеокарта почти простаивает. Выход — пакет (batch): на каждом шаге делать по токену сразу для многих разговоров. Веса читаются один раз на весь пакет, а работы становится больше, поэтому общий выход токенов в секунду растёт почти бесплатно, пока хватает памяти на кэши всех участников.
Простой пакет устроен плохо: набрали четыре запроса, генерируем, пока не закончит самый длинный, и только потом берём следующие. Короткий ответ на «спасибо» закончился на четвёртом шаге, а его место простаивает, пока соседний пишет эссе. Решение — непрерывная пакетная обработка (continuous batching): после каждого шага сервер смотрит, кто закончил, и сразу ставит на освободившееся место следующего из очереди. Идею планирования по отдельным шагам описала система Orca (Yu и соавторы, OSDI 2022), сейчас так работают все основные серверы моделей.
Вторая проблема — память под кэш. Заранее неизвестно, сколько токенов напишет ответ, и если резервировать под каждый разговор кусок на максимальную длину, большая часть памяти простаивает. Страничный кэш (PagedAttention) из работы авторов vLLM (Kwon и соавторы, 2023) делит кэш на маленькие блоки по нескольку токенов и выдаёт их по мере роста разговора, как операционная система выдаёт программам страницы памяти. Блоки не обязаны лежать подряд, а одинаковые блоки, например общее начало запроса с системной инструкцией, могут использоваться несколькими разговорами сразу. Это и есть техническая основа кэша одинакового начала запроса, за который сервисы берут меньше.
Предел: пакет увеличивает общий выход, но каждый отдельный пользователь получает свои токены чуть медленнее, потому что шаг стал тяжелее. Поэтому у серверов есть ручка между «быстро одному» и «много всем», и тарифы с пакетной обработкой без спешки дешевле именно поэтому. Отличие от распараллеливания на стороне клиента, про которое была пятая ступень дорожки о цене и скорости: там ты отправляешь много запросов сразу, а здесь сервер решает, как их уложить в видеокарту.
Подробный пример. Модель не нужна, чтобы увидеть разницу: достаточно посчитать шаги. Двенадцать запросов с разной длиной ответа, в пакет помещаются четыре. Один шаг — сервер выдал по токену каждому запросу в пакете.
# Сравнение двух способов обслуживать очередь: обычные пакеты и непрерывные.
# Один шаг = сервер выдал по одному токену каждому запросу в пакете.
lengths = [30, 4, 6, 28, 5, 7, 25, 3, 8, 6, 30, 4] # сколько токенов ответа нужно каждому
SLOTS = 4 # сколько запросов влезает в пакет
def static(lengths):
steps, busy, done_at = 0, 0, {}
for i in range(0, len(lengths), SLOTS):
batch = list(range(i, min(i + SLOTS, len(lengths))))
longest = max(lengths[j] for j in batch) # пакет ждёт самого длинного
for j in batch: done_at[j] = steps + lengths[j]
busy += sum(lengths[j] for j in batch)
steps += longest
return steps, busy, done_at
def continuous(lengths):
queue, active, left = list(range(len(lengths))), [], {}
steps, busy, done_at = 0, 0, {}
while queue or active:
while queue and len(active) < SLOTS: # освободилось место — сразу берём следующего
j = queue.pop(0); active.append(j); left[j] = lengths[j]
steps += 1; busy += len(active)
for j in active: left[j] -= 1
for j in [j for j in active if left[j] == 0]:
active.remove(j); done_at[j] = steps
return steps, busy, done_at
for f in (static, continuous):
steps, busy, done = f(lengths)
print(f"{f.__name__:10s} шагов всего: {steps:3d} загрузка мест: {busy/(steps*SLOTS):.0%} "
f"среднее ожидание ответа: {sum(done.values())/len(done):.1f} шага "
f"короткий запрос №2 готов на шаге {done[1]}, №8 — на шаге {done[7]}")
У нас этот код напечатал:
static шагов всего: 85 загрузка мест: 46% среднее ожидание ответа: 41.3 шага короткий запрос №2 готов на шаге 4, №8 — на шаге 33
continuous шагов всего: 58 загрузка мест: 67% среднее ожидание ответа: 23.8 шага короткий запрос №2 готов на шаге 4, №8 — на шаге 16
При простых пакетах все двенадцать ответов готовы за 85 шагов, и места в пакете заняты делом только 46% времени: остальное — ожидание самого длинного соседа. При непрерывных пакетах та же очередь закончена за 58 шагов, загрузка 67%, а среднее время до готового ответа почти вдвое меньше: 23,8 шага против 41,3. Особенно заметно на коротких запросах: трёхтокенный запрос №8 готов на 16-м шаге вместо 33-го, потому что ему не пришлось ждать, пока закончится чужой пакет. Загрузка всё равно не 100%: в конце очереди новых запросов нет, и места пустеют. Это упрощённая модель — настоящий сервер ещё вставляет разбор новых запросов между шагами генерации, — но главный эффект она показывает честно.
Где обычно ошибаются.
Пакет (batch). группа запросов, для которых сервер делает шаг генерации одновременно.
Непрерывная пакетная обработка (continuous batching). способ, при котором закончивший запрос сразу уступает место следующему из очереди, не дожидаясь соседей.
Страничный кэш (PagedAttention). хранение кэша ключей и значений маленькими блоками, которые выдаются по мере роста разговора и могут делиться между разговорами.
Сервер вывода (inference server). программа, которая держит модель на видеокарте и отвечает на запросы многих пользователей, например vLLM или SGLang.
Пропускная способность (throughput). сколько токенов в секунду сервер выдаёт всем пользователям вместе.
Задержка (latency). сколько ждёт один пользователь — до первого токена или до конца ответа.
Вытеснение (preemption). ситуация, когда серверу не хватает памяти и он временно выкидывает кэш одного разговора, чтобы потом пересчитать его заново.
Словарь целиком — /slovar, новости — /novosti. Все дорожки — /put.