Представьте: вы дообучаете модель всего 100 шагов — и её квадратичное внимание превращается в разреженное, почти линейное. При этом качество не падает, а в некоторых сценариях даже растет. Звучит как очередной хайп? Возможно. Но за этим стоит работа, которая реально может переписать правила игры для long-context LLM. И да, пока нет готового репозитория на GitHub — только препринт и обещание кода "скоро". Но сообщество LocalLLaMA уже лихорадочно переваривает результаты.
Главная головная боль: квадратичное внимание
Full-attention — это прекрасно, пока ваш контекст укладывается в 4K или 8K токенов. Но как только вы пытаетесь заставить модель прочитать целую книгу или часовой код-ревью, O(n²) начинает кусаться. Мы уже видели попытки решить это через Ulysses Sequence Parallelism, которая позволяет засунуть миллион токенов на одну видеокарту, но ценой дикой сложности инженерных танцев. А DroPE предлагает сломать механизм позиционных кодировок, чтобы модель "читала" в 10 раз больше. Но всё это — обходные пути.
Новая работа предлагает не обходить проблему, а радикально переделать архитектуру внимания — за 100 шагов fine-tuning. Никакого переобучения с нуля, никаких кастомных ядер CUDA. Просто 100 шагов, и ваша full-attention модель становится разреженной.
Как это работает? (спойлер: через учителя)
Исследователи предлагают метод, который можно назвать "full attention transfer". Берётся замороженная full-attention модель (учитель) и её разреженная копия (студент). У студента — sparse attention с эвристиками eviction (выброс токенов), которые обычно режут производительность. Но здесь к этой разреженной модели применяют знания от full-учителя через специальную loss-функцию, которая штрафует за отклонение распределения внимания.
Через 100 шагов студент учится воспроизводить поведение учителя, но с квадратичной стоимостью только на этапе обучения. На инференсе sparse attention работает за O(n log n) или даже O(n), если применяются агрессивные стратегии выброса. Причём качество не падает: на бенчмарках long-context (до 128K токенов) студент показывает те же или даже чуть лучшие результаты. Почему лучше? Потому что sparse внимание, отфильтровывая шум, может лучше фокусироваться на релевантных токенах. Звучит логично, но есть нюанс.
Нюанс: Учитель — это full-attention модель, которая сама по себе страдает от "Lost in the Middle". Если учитель плохо обрабатывает середину контекста, то и студент унаследует эту проблему. Авторы обещают, что их метод не усугубляет этот эффект, но прямая передача "слепых зон" всё ещё возможна.
Почему именно 100 шагов, а не 1000?
Ключевая фишка — дообучение идёт не на генерацию текста, а на дистилляцию карт внимания. Учитель генерирует для каждого токена распределение attention, и студент учится его имитировать. Это гораздо более простая задача, чем учиться генерировать текст с нуля. Плюс используется разогрев: первые 10 шагов — обычный fine-tune на тексте, чтобы модель "вспомнила" как разговаривать, а потом резкий переключатель на дистилляцию. После 100 шагов loss сходится, и дальше улучшения минимальны.
Кстати, технология перекликается с Tuneable Attention, где тоже пытались расширить внимание, а не сжать. Но там — обратный процесс: учили модель лучше понимать больше токенов. Здесь — учим отбрасывать лишнее, сохраняя суть. Интересно, можно ли комбинировать оба подхода?
Что это даёт на практике?
| Сценарий | Full attention (исходная) | Sparse после 100 шагов |
|---|---|---|
| Инференс с контекстом 32K | ~12 сек на токен (GPU A100) | ~1.5 сек на токен |
| Потребление памяти (KV cache) | ~16 ГБ | ~2 ГБ |
| Качество на RULER (128K) | 86% | 85% |
Цифры приблизительные, но тренд ясен: ускорение в 8 раз, снижение памяти в 8 раз, качество почти не страдает. При этом модель дообучается всего 100 шагов — это буквально 10-15 минут на одном GPU. Cerebellum даёт ускорение на 20% за счёт ранних выходов — здесь мы получаем порядок. Конечно, Cerebellum сохраняет полное внимание, а этот метод его режет, но когда скорость критична (чат-боты, real-time код-генерация), sparse внимание выглядит привлекательнее.
Но где подвох? (спойлер: он есть)
Пока нет открытого кода. Авторы обещают выложить веса и скрипты на GitHub, но дата релиза не названа. Это вызывает смешанные чувства: с одной стороны, идея гениальная и простая, с другой — до сих пор много подобных работ так и оставались препринтами без воспроизводимости. Вспомните историю со сложными RAG пайплайнами: RAG часто вытаскивает правильные данные, но даёт ерунду — из-за нестыковок в обучении. Здесь такой риск меньше, потому что fine-tuning на внимании, а не на тексте, но всё равно хочется потрогать руками.
Ещё один скользкий момент: метод тестировали на моделях до 7B параметров. Как он поведёт себя на 70B или 120B — большой вопрос. Возможно, на гигантах sparse внимание будет слишком агрессивно выбрасывать важные токены, и quality пострадает. Но для сообщества LocalLLaMA, где правят бал 7B и 13B модели, это реальный шанс получить long-context без даунгрейда GPU до медленной печати.
Что в итоге? (без заключения, только прогноз)
Если код появится (а я ставлю 70% на то, что появится в течение месяца), это станет одним из главных инструментов в арсенале любого, кто работает с длинными контекстами. Комбинация с управлением контекстом (например, иерархическим сжатием) может дать synergy, уводящую LLM за горизонт 1M токенов без квадратичных затрат. А пока — ждём код и готовим 100 шагов fine-tuning на своих любимых моделях. И да, советую заранее захостить свои датасеты длинных документов — Hugging Face Datasets уже видел наплыв long-context бенчмарков. А если хочется поэкспериментировать с архитектурой, Modular обещает поддержку кастомных attention в MAX Engine — может, там и sparse attention завезут.
