DeepSeek V4.1 Flash Часть #1. Можно ли сэкономить на фазе чтения промпта моделью?

Помните, мы вчера смотрели на GPT-OSS 20B и видели, как примерно в середине сети уже хорошо разделяются внутренние представления плохих и нейтральных промптов?

В DeepSeek V4.1 Flash середину модели использовали уже архитектурно: 40 слоёв разделили на две половины по 20.

Первые 20 слоёв читают весь промпт и строят внутреннее представление контекста. А когда начинается генерация, подключается вторая половина — и каждый новый токен проходит уже через все 40 слоёв.

Отсюда и странные на первый взгляд цифры: при обработке входа задействовано около 8 млрд параметров на токен, а при генерации — около 16 млрд. При длинном входе такая схема почти вдвое сокращает объём вычислений.

Но вычисления — только половина проблемы. Вторая половина называется K/V-кэш.

На пальцах: когда слой впервые читает токен, механизм внимания сохраняет для него подготовленную служебную информацию — условно «как потом к этому месту обратиться» и «что из него можно забрать». Благодаря этому при генерации следующего токена модель не обязана заново перерабатывать весь предыдущий текст.

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

В DeepSeek решили разделить память на локальную и глобальную.

Локальный K/V-кэш — это ближайшие токены, в V4.1 окно составляет всего 128 позиций. Такой кэш есть у каждого слоя отдельно. По сути это тот же принцип K/V-кэша, что и в обычном Transformer, только модель хранит не всю историю, а короткое скользящее окно: последние токены ушли слишком далеко — из локальной памяти они выпали.

А всё далёкое прошлое обслуживает уже глобальная память.
И здесь DeepSeek начинает экономить особенно нагло.
Первые два слоя вообще работают только с локальным окном. Оставшиеся 18 слоёв первой половины разбили на три группы по шесть.

В каждой группе:
- первый слой строит глобальный K/V-кэш
- следующие пять используют тот же самый глобальный кэш

То есть вместо условных:

18 слоёв → 18 отдельных глобальных K/V-кэшей

получаем:

18 слоёв → всего 3 групповых глобальных K/V-кэша

При этом локальный кэш последних 128 токенов у каждого слоя остаётся своим.

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

А для далёкой истории можно позволить нескольким слоям пользоваться одной подготовленной глобальной памятью вместо того, чтобы каждый раз хранить ещё одну почти такую же огромную копию.

DeepSeek поэтому экономит сразу в двух местах:
- длинный промпт полностью считает только первая половина сети
и
- глобальную память внутри этой половины делят группы слоёв вместо отдельной копии на каждый слой.

Третье важное решение - последние 20 слоёв получают глобальный контекст уже из итогового представления первой половины и по-настоящему включаются в работу при генерации ответа.

Локальную память последних токенов они всё равно считают самостоятельно.
И что особенно приятно — по результатам DeepSeek это не привело к заметной потере качества.

Почему модель вообще позволяет настолько нагло делить память между слоями и не разваливается — отдельная интересная тема.
Но на этом разработчики не остановились.

Они посмотрели на эти групповые глобальные кэши и задали следующий логичный вопрос:
- а обязательно ли каждому слою даже самостоятельно решать, какие куски огромного контекста из этой памяти сейчас читать?

Вот отсюда начинается еще одна инновация CSA2. Об этом — в следующем посте.