128k контекста: наконец-то можно показать модели чуть больше

•
Опубликовано
•
11 мин чтения

Текст написан с позиции ноября 2023 года: так, как тема выглядела тогда, без технологий и событий, появившихся позже.

Пару недель назад на OpenAI DevDay показали GPT-4 Turbo с окном контекста в 128k токенов, и для меня это первая за долгое время новость про языковые модели, которая касается работы напрямую, а не воображения. До этого с моделью разговор шел в режиме форточки: 8k токенов, в лучшем случае 32k, и любая попытка объяснить что-то про реальный проект упиралась в одно и то же. Ты выбираешь, какой огрызок кода показать, остальное пересказываешь словами, а модель достраивает недостающее наугад. 128k — это уже не форточка. Это первый раз, когда можно скормить не один файл, а заметный кусок кодовой базы и спросить что-то осмысленное.

Я честно обрадовался. И честно же провел пару вечеров, проверяя, что из этого выходит на моих задачах, а не на демках со сцены. Вывод, если коротко, такой: окно действительно выросло, а вот понимание — нет. И это важно разделить сразу, потому что соблазн перепутать одно с другим огромный. Когда в модель влезает в четыре раза больше текста, легко решить, что она и соображает в четыре раза лучше. Это не так. Влезает больше — да. Разбирается в этом больше — очень спорно.

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

Главным узким местом был вход, а не интеллект ответа

Начну с хорошего, потому что хорошее настоящее. Раньше главным узким местом во всех моих заходах к модели был не интеллект ответа, а вход. Я физически не мог объяснить контекст задачи. Есть модуль на полторы тысячи строк, он завязан на пару соседних файлов, есть тип из третьего места и конфиг из четвертого — и все это нужно держать в голове одновременно, чтобы понять, почему здесь баг. В окно на 8k это не влезало никогда. Приходилось вырезать кусок, и модель отвечала ровно на этот кусок, не видя остального.

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

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

Так что да, 128k — это не маркетинговая цифра ради цифры. Это реально другой режим работы. Только режим этот выгоднее всего там, где задача — найти и сопоставить, а не понять и рассудить. И вот на границе между «найти» и «понять» начинается вторая половина истории.

Все 128k весят неодинаково: середину модель проматывает

Первое, что я заметил, когда осмелел и начал заполнять окно по-настоящему плотно: качество ответов не растет линейно с количеством данных. Скорее наоборот. Пока я давал один-два хорошо подобранных файла, ответы были аккуратными. Когда я вывалил в окно десяток файлов, рассчитывая, что больше контекста — это всегда лучше, модель начала вести себя хуже, а не лучше.

Конкретно: она цеплялась за то, что лежит в начале и в конце, а середину как будто проматывала. Я специально проверил — закопал важную деталь, описание поведения функции, примерно в середину большого куска и задал вопрос, ответ на который прямо там. Модель ответила общими словами, опираясь на то, что было в начале, и про закопанную деталь вспомнила, только когда я ткнул её носом. Повторил с той же деталью в начале блока — ответила сразу и точно. Это не разовая случайность, это устойчивый рисунок: то, что лежит в середине длинного контекста, модель учитывает заметно хуже.

Я понимаю это так: окно в 128k не означает, что все 128k весят одинаково. У внимания есть свой профиль, и края этого профиля внимательнее, чем центр. Поэтому «просто залить весь репозиторий» — не стратегия. Чем больше мусора ты насыпал вокруг важного куска, тем выше шанс, что важный кусок окажется ровно в той зоне, которую модель проскользнет. Получается контринтуитивная вещь: иногда меньше контекста дает лучший ответ, чем больше, если этот меньший контекст подобран руками.

Из этого следует практический вывод, который мне самому не очень нравится, потому что он скучный. Большое окно не отменяет работу по подбору контекста — оно ее меняет. Раньше я подбирал, потому что иначе не влезало. Теперь влезает все, и появляется соблазн не думать вообще. А думать по-прежнему надо, просто теперь не «как впихнуть», а «как не утопить нужное в ненужном».

Контекст полный, а ответ все равно мимо — оправданий больше нет

Теперь к самому важному. Большой контекст сделал очень полезную вещь: он убрал оправдание. Раньше, когда модель отвечала мимо, всегда оставалась лазейка — «ну она же не видит всего проекта, конечно она ошиблась». Это была честная лазейка, ей правда не хватало входа. Теперь вход есть. И когда модель все равно отвечает мимо на вопросе, который требует не найти, а рассудить, оправдания больше нет. Видно голую механику.

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

Но как только вопрос требует именно рассуждения о конкретно этой системе — не «как обычно делают», а «почему именно здесь будет такой эффект» — она проваливается ровно так же, как и в окне на 8k. Я дал ей полный контекст одной хитрой гонки состояний: вся нужная информация на месте, файлы рядом, последовательность вызовов видна. И модель уверенно объяснила баг неправильно — складно, грамматически безупречно, по сути мимо. Потому что правильный ответ требовал проследить порядок исполнения в голове, а она вместо этого подобрала похожий по форме типичный объяснительный шаблон. Контекст у нее был полный. Понимания не было.

Здесь и проходит настоящая граница. Я думал, что упирался в размер окна. Оказалось, размер окна был верхним слоем проблемы. Под ним лежал слой потолще: модель не понимает код, она его узнаёт. Пока окно было маленьким, эти две вещи было легко спутать, потому что обе давали один симптом — неверный ответ. Теперь, когда данных полно, симптомы разошлись. Ошибки от нехватки контекста почти ушли. Ошибки от отсутствия рассуждения остались на месте, и теперь их видно во весь рост.

У каждого лишнего токена есть ценник и есть пауза

Есть еще приземленная сторона, про которую на сцене говорят меньше. Контекст не бесплатный. Каждый токен, который ты залил в окно, ты оплачиваешь, и input-токенов на 128k набегает прилично. Привычка «на всякий случай покажу побольше» из инженерной аккуратности превращается в строчку в счете. На разовом запросе это копейки, на потоке — уже нет.

Второе — латентность. Большой контекст модель не проглатывает мгновенно. Чем плотнее набито окно, тем дольше ждешь первого токена ответа. На маленьком запросе разница незаметна, на по-настоящему большом — это уже ощутимая пауза, которая ломает темп работы. Когда отвечает почти сразу, держишь модель в петле рассуждения вместе с собой. Когда каждый заход — это ожидание, проще самому открыть файлы и подумать руками.

Складывается простая экономика. За каждое расширение контекста ты платишь дважды: деньгами за токены и временем за ожидание. И платить это имеет смысл только тогда, когда дополнительный контекст реально поднимает качество ответа. А мы выше выяснили, что после определенного объема качество не растет, а иногда падает. То есть существует точка, после которой ты платишь больше, а получаешь хуже. Этой точкой и надо управлять, а не гнаться за тем, чтобы забить окно до краев просто потому, что теперь оно большое.

Четыре привычки, которые вытаскивают из 128k максимум

За эти пару недель у меня сложился набор привычек, которые, кажется, вытаскивают из 128k максимум и не дают обмануться. Делюсь не как наставлением, а как тем, к чему сам пришел методом тыка:

  • Класть важное по краям. Если есть кусок кода или формулировка, вокруг которой крутится вопрос, я ставлю ее в начало или ближе к самому вопросу в конце, а не закапываю в середину. Середина — зона, куда модель смотрит хуже всего.
  • Подбирать контекст руками, а не вываливать репозиторий. Большое окно — это разрешение не вырезать нужное, а не приглашение залить ненужное. Десять релевантных файлов работают лучше тридцати, среди которых десять релевантных.
  • Доверять модели поиск и сопоставление, проверять за ней рассуждение. «Где используется», «что сломается при переименовании», «собери похожие места» — принимаю почти не глядя. «Почему здесь баг», «безопасно ли это изменение по сути» — перепроверяю всегда, потому что складный ответ тут не равен верному.
  • Помнить про счет и про паузу. Прежде чем добить окно еще одним файлом, спрашиваю себя, поднимет ли он качество ответа или просто увеличит цену и ожидание. Чаще, чем хотелось бы, ответ — второе.

Это не звучит как прорыв, и это нормально. Хороший инструмент редко требует пафоса. 128k встроились в работу буднично: где раньше я мучительно резал контекст, теперь не режу, и это просто стало удобнее. А там, где модель и раньше не понимала систему, она не понимает ее и сейчас — только теперь без отговорок.

Если завтра пообещают миллион токенов, что я спрошу первым делом?

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

А отношение у меня после этих двух недель спокойное. Рост окна — это рост вместимости, и только. Он снимает ограничение на вход и убирает целый класс глупых галлюцинаций от нехватки данных. Это ценно, я этим пользуюсь каждый день. Но он не добавляет модели рассуждения. Когда я увижу заголовок про миллион токенов контекста — а я почти уверен, что увижу, и довольно скоро, — первый вопрос будет не «как много влезет», а «насколько ровно она держит внимание по всему этому объему и научилась ли она наконец рассуждать о том, что видит, а не просто узнавать похожее».

Самая вредная реакция на новость про 128k — услышать «в четыре раза больше контекста» и решить, что помощник стал в четыре раза умнее. Он не стал. Он стал в четыре раза вместительнее, и это другое. Полезное, рабочее, но другое. Я рад этому сдвигу куда больше, чем хотел бы признаться весной, когда ворчал на форточку в 8k. И при этом трезво вижу, где он заканчивается.

Окно выросло, дистанция до понимания осталась прежней

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

Поэтому относиться к этому надо как ко взрослому инструменту, а не как к чуду. Большое окно — это не «теперь модель понимает мой проект». Это «теперь я могу дать ей весь нужный материал, а думать над выводами по-прежнему мне». Разница между этими двумя формулировками — это вся дистанция между хайпом и рабочей пользой.

Если совсем коротко: контекст вырос, понимание — нет; пользуйся вместимостью там, где нужно сопоставить, и не доверяй ей там, где нужно рассудить, — и тогда 128k станут честным шагом вперед, а не поводом переоценить того, с кем работаешь.

Автор

Senior Principal JavaScript Developer, Tech Lead. Пишет о React, TypeScript, React Native, архитектуре фронтенда и бэкенда и о том, как AI меняет работу разработчика.

Обновлено

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