Kitobni o'qish: «AI для кофейников. От нейросети до агентов»

AI для кофейников

От нейросети до агентов

Роман Попов

Всё на пальцах, чтобы потом можно было объяснить своей бабушке. Наконец разобраться, как работает весь этот AI. С самого начала, по порядку и без объяснений одной непонятной штуки через три другие

Пролог. От автора

У меня нет технического образования, я не инженер и, честно говоря, довольно плохо знаю матчасть всего, что происходит внутри современного ИИ.

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

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

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

И каждый раз, когда я пытался разобраться, происходило одно и то же. Приходишь понять одну незнакомую вещь — её объясняют через две другие незнакомые вещи. Идёшь читать про них — там ещё четыре. Потом появляются сокращения, формулы, греческие буквы, и через двадцать минут у тебя открыто двенадцать вкладок и возникает ощущение, что, возможно, стоило лет двадцать назад всё-таки поступать куда-нибудь ещё.

Меня это бесит ещё со школы.

Потому что я довольно сильно верю в простую вещь: человек способен понять почти что угодно, если ему это нормально объяснить.

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

Особенно остро я в это упёрся, когда начал собирать open(space).

Я постоянно использую несколько нейросетей параллельно: одна лучше делает одно, другая — другое. Что-то отдаёшь Claude, результат несёшь Codex на ревью, замечания возвращаешь обратно. В какой-то момент понимаешь, что сам работаешь довольно дорогим маршрутизатором для копипаста.

Я подумал: а почему просто не посадить их всех в один чат?

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

Звучало прекрасно.

Работало отвратительно.

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

И вот тут стало действительно интересно.

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

А дальше произошло самое интересное. Вопрос «как заставить группу агентов хорошо думать вместе?» довольно быстро превратился в вопрос «а как вообще хорошо думает вместе группа?»

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

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

И чем дальше я туда лез, тем очевиднее становилась другая проблема: мне самому не хватает фундамента.

Я знаю отдельные карты, но у меня нет колоды.

Где-то слышал одно. Где-то использую другое. Какой-то термин знаю. Какой-то механизм примерно представляю. Но всё это лежит в голове кучей, а не системой.

А мне кажется, в таких вещах самое важное сначала — собрать скелет.

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

Вот такую структуру я и решил сначала собрать для себя.

Начать буквально с начала. Что значит «модель обучается». Что после обучения остаётся. Как из этого получилась штука, способная разговаривать. Почему ей понадобились знания извне, инструменты и память. В какой момент получается агент. Зачем агентов становится несколько. И уже потом добраться до всех страшных терминов и сокращений.

С одним правилом:

сначала понять штуку — потом узнать, как она называется.

Не объяснять незнакомое через незнакомое. Не доставать формулу там, где идея прекрасно объясняется без неё. На пальцах — настолько, чтобы, разобравшись самому, можно было объяснить своей бабушке.

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

Так появился AI для кофейников.

Параллельно я пишу о том, что делаю, собираю и пытаюсь понять, в телеграм-канале «Романтика Повседневности».

Я здесь такой же кофейник.

Давайте разбираться вместе.

Как устроен курс. Каждый урок собран одинаково: сначала сцена, в которой прежний способ ломается; потом механизм — за счёт чего работает новый и где перестаёт; потом один разобранный пример, список того, что легко перепутать, и небольшое задание в другом контексте. Название появляется в самом конце урока, когда механизм уже понятен и ему просто нужна метка.

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

Ядро курса — семь уроков, без которых остальное не соберётся. Седьмая глава «Глубже» — факультативы по свежим исследованиям, их можно пропустить целиком. Все факты в уроках опираются на исследовательскую базу с указанием границ: одна статья здесь нигде не превращается в закон.

Глава 1. Как система учится

правила, примеры, проверка, первый текст

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

В этой главе обычно ломается одно и то же: слово «учится» слышится как «учится, как человек», и дальше системе либо слепо доверяют, либо так же слепо не доверяют. Оба варианта мешают проектировать. Полезнее держать в голове механизм: примеры, настройка по ним, применение к новому. Тогда вопросы «а что она выучила на самом деле» и «а как это проверить» задаются сами.

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

В главе четыре урока: правила или примеры; что остаётся после обучения; проверка на новом; как появляется текст.

От автора

open(space) я собирал так. Идея, название, логика и дизайн-система были мои, а сам чат, лейауты и код делали модели. И первые версии выглядели как любой AI-чат из интернета: серый список сообщений, поле ввода, кнопка. Совсем не та вещь, которую я представлял.

Я пробовал описывать словами. Что должно быть плотнее, где воздух, какая иерархия, как ведёт себя список, когда участников больше трёх. Получал следующую версию, чуть ближе, и снова не то. Потом перестал описывать и стал показывать: скриншот с пометками, экран из Figma, чужой интерфейс со словами «вот так, только у нас три колонки». И дело пошло. Собрали, я пользуюсь, вижу, что не так, показываю, правим, снова пользуюсь.

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

Я дизайнер, для меня это старый способ работать, ИИ мне его не подарил. Но когда я начал разбираться, как система вообще чему-то учится, оказалось, что там с самого начала стоит тот же выбор: расписать правила или показать примеры. И у обоих вариантов есть цена.

С неё и начнём.

Написать правила или показать примеры

Можно самим прописать правило, а можно подготовить систему на примерах и посмотреть, что получится на новом обращении.

Правила ломаются быстрее, чем мы думали

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

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

Держится это недолго. Приходит «залог вернули, спасибо, а как теперь отменить бронь», и это вопрос про сервис со словом «залог». Приходит «сосед сверху говорит, что гараж его, а не тот, кто мне его сдал», и это спор, в котором нет ни залога, ни слова «спор». Можно дописывать исключения одно за другим, но новые формулировки появляются быстрее, чем мы успеваем их учитывать. И это не значит, что правила всегда плохи: если задача простая и условия устойчивые, нескольких правил вполне достаточно. Ломается именно расчёт на то, что мы заранее предугадаем все формулировки.

Систему готовят на примерах обращений

Есть другой способ. Берём много прежних обращений и для каждого заранее отмечаем, в какую папку оно должно было попасть. Дальше запускаем программу, которую тоже написал человек, только написал он в ней не правила про обращения, а способ подбирать поведение по примерам. Внутри у этой программы большой набор чисел, поначалу случайных. Обращение для неё тоже числа: сколько раз встречается каждое слово, какой длины текст, есть ли в нём фотографии. Программа прогоняет числа обращения через цепочку вычислений, в которой участвует её собственный набор, и получает на выходе одно число: насколько обращение похоже на спор.

Потом она сравнивает свой ответ с нашей пометкой. Если промахнулась, она вычисляет, какие из внутренних чисел и в какую сторону надо чуть сдвинуть, чтобы на этом обращении ошибка стала меньше, и сдвигает их. Затем следующее обращение, и так сотни раз. Сама программа при этом не меняется, строчки кода те же; меняются только значения чисел в наборе. Когда говорят «система нашла закономерность», буквально произошло вот это: числа сдвинулись так, что на большинстве примеров вычисление стало давать верный ответ.

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

Длинное обращение ставит систему в тупик

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

Как это называется?

Машинное обучение (Machine learning, ML). Вот вся история, которую мы только что разобрали: программу не пишут по пунктам про каждое обращение. Ей дают примеры с готовыми ответами, а она сдвигает свои внутренние числа, пока вычисление не начнёт совпадать с ответами. Такой способ получать поведение по примерам называют машинным обучением, по-английски machine learning, сокращённо ML.

Что важно не перепутать

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

• Слова «система учится» не означают, что она учится так же, как человек, и не означают, что ей можно доверять безоговорочно.

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

Попробуй сам

Возьми два случая из жизни того же «Тесно» и сравни их между собой, а потом перенеси сравнение в совсем другую задачу.

• Случай А. Мы явно указали: любое обращение от Галины Петровны отправлять в отдельную папку.

• Случай Б. Мы показали множество прежних обращений и настроили систему различать похожие случаи.

• Вопрос. В каком случае поведение задано написанным правилом, а в каком получено через обучение? Объясни без специальных слов, а потом попробуй то же самое на фотографии: программа определяет, есть ли на снимке велосипед, и мы не расписывали признаки велосипеда вручную, а показали много фотографий с уже известными ответами. К какому из двух подходов это ближе?

Основная мысль

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

Дальше: Что именно меняется внутри системы во время обучения и что в ней остаётся после того, как обучение закончилось?

Почитать

•

Introduction to Machine Learning (Google, документация)

Что изменилось после обучения

Систему один раз подготовили на примерах, а потом она отвечает на новые обращения за секунды — разберёмся, что происходит между этими двумя моментами.

Ответ приходит за секунды

Систему из прошлого урока готовили один раз, показав ей много примеров обращений с уже расставленными папками. Возникает практический вопрос: значит ли это, что при каждом новом обращении она заново пересматривает все прежние примеры и сравнивает с ними?

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

Готовят долго, применяют быстро

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

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

Сколько таких чисел? В системе, которая делит обращения на две папки, их могут быть сотни. В системах, которые пишут текст, счёт идёт на миллиарды, но устроено всё так же: набор чисел плюс цепочка вычислений над ними. Удобно представлять прибор с миллиардами ручек, каждую из которых подготовка чуть подкрутила. Только помни, что ручки — картинка. В компьютере это файл с числами и программа, которая умеет их применять.

Прежнее обращение она не открывает

Представь два обращения от одного и того же арендатора с разницей в неделю: «Хозяин гаража не отвечает третий день, а мне нужно забрать велосипед» и «Он так и не ответил, что мне делать?» Система не открывает первое обращение, когда обрабатывает второе: в момент применения она не обращается ни к прежним обращениям, ни к примерам из подготовки. Оба обращения проходят через одни и те же подстроенные настройки, и у системы, которая только выбирает папку, итог совпадает — «спор между людьми», — потому что оба обращения похожи на закономерности, которые в настройках уже закрепились. Оговорка «только выбирает папку» важна: у системы, которая пишет текст, одинаковый вход не обязан давать одинаковый ответ, и почему так — увидим через два урока.

Как это называется?

Модель. Вот то, что остаётся после подготовки: набор подобранных чисел вместе с цепочкой вычислений, а не сами примеры. Этот набор и называют моделью, а числа внутри — её параметрами или весами. Файл с весами можно скопировать на другой компьютер и использовать там ту же модель.

Что важно не перепутать

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

• Веса — не список готовых ответов на конкретные обращения. В модели не «лежат» прежние примеры, из которых она подбирает подходящий; результат вычисляется заново, когда новый текст пропускают через подобранные числа.

• Устройство вычислений может быть разным, но принцип один: сначала долгая подготовка, потом быстрое применение. Внутри не стоит представлять таблицу ответов: там числа, сдвинутые примерами.

Попробуй сам

Перенеси то же различие в другую задачу.

• Помощник путешественника подсказывает, какой город подходит по описанному бюджету и интересам. Настройку на множестве прошлых поездок он проходил заранее, один раз. Где здесь подготовка, а где применение?

• Он получает совсем новый запрос, которого раньше не видел. Значит ли это, что он заново пересматривает все прошлые поездки, на которых его готовили, — или он просто пропускает новый запрос через то, что уже подобралось?

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

Основная мысль

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

Дальше: Как проверить, что модель научилась чему-то полезному?

Почитать

•

Introduction to Machine Learning (Google, документация)

•

Курс Hugging Face о работе современных моделей обработки текста (глава 1)

•

Vaswani et al. (2017) — статья, заложившая основу современных моделей обработки текста

Проверка на том, чего раньше не было

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

Отличный результат, который ничего не объясняет

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

Возникает вопрос: если система так хорошо справилась с тем, на чём её готовили, откуда взялись новые ошибки? И можно ли было заметить эту разницу заранее, ещё до того, как система начала работать с настоящими обращениями?