YT YouTube2Text

YouTube2Text → Transcripts → Agents Week 2026 | Лекция 1.1 Intro to AI Agents LLM

Agents Week 2026 | Лекция 1.1 Intro to AI Agents LLM — Transcript

by Яндекс Образование · 7,016 words · 1,226 segments · language ru · Watch on YouTube

Open in transcriber Summarize with AI Download SRT/VTT

Full transcript

2:36Всем привет. Меня зовут Зайцева Алёна, и
2:38я руковожу службой AI в Яндекславке. Я
2:41отвечаю, во-первых, за AI в клиентском
2:43продукте. Это всё, что видят наши юзеры.
2:46Например, ассистент лавка AI, с которым
2:48можно общаться как текстом, так и
2:49голосом, а генеративный контент в
2:51карточке товара и многое другое.
2:54Во-вторых, я отвечаю за AI для
2:56оптимизации команд и бизнес-процессов.
2:58Это множество совершенно разноплановых
3:00внутренних агентов, которые позволяют
3:02автоматизировать некоторую рутину или
3:04конкретные задачки, а что в итоге
3:06приводит к тому, что мы намного быстрее
3:07прототипируем, разрабатываем, тестируем
3:10и внедряем различные проекты. И
3:12в-третьих, я отвечаю за инфраструктуру
3:14для разработки всех этих агентов. И
3:16сегодня я рада приветствовать вас на
3:18старте интенсива по AI агентам. Давайте
3:21немного расскажу про него. Команда
3:23спикеров курса включает в себя
3:25руководителей и инженеров из разных
3:27кусочков Яндекса. Это Лавка, Алиса и
3:29умные устройство, поисковой портал и
3:31cloudд. За последние годы индустрия
3:33прошла путь от простого промтинга лмок
3:36до многоагентских систем. И мы прошли
3:38этот путь вместе с ней. За это время мы
3:41внедряли разные новые фреймворки,
3:42протоколы и подходы, отказывались от
3:45решений, которые не выдерживали проверку
3:46продакшеном и придумывали собственные
3:48архитектуры и обменивались опытом друг с
3:50другом. И этим опытом очень хочется
3:52поделиться в рамках данного интенсива.
3:54Сегодня агенты - это уже не просто
3:56какая-то игрушка из лаборатории. Это то,
3:58что реальные компании внедряют в
4:00повседневную рутину. И мы хотим, чтобы
4:02по итогам курса вы могли не только
4:03быстро запротипировать своего личного
4:06ассистента, но и знали, как довести его
4:08до продакшена и масштабировать. Наш
4:10интенсив будет состоять из 5 дней и
4:12завершиться контрольным заданием. А
4:14чтобы достичь нашей цели, мы в первый
4:17день рассмотрим
4:18вообще зачем нужны агенты и из каких
4:21кусочков они состоят, и дальше подробно
4:23будем погружаться в каждый отдельный
4:24блок. Так, сегодня же мы погрузимся в
4:27мозг агента, это лэмки, и рассмотрим,
4:30что такое инструменты и MCP. Во второй
4:34день мы улубимся в два ключевых слоя,
4:36без которых агент быстро превращается в
4:38игрушку. Это память Игор Дрейлза, то
4:40есть некоторые инструменты, которые нам
4:42позволяют обезопасить агента, чтобы он
4:45вёл себя более предсказуемо. В третий
4:47день мы соберём из разобранных кусочков
4:50общий пайплайн. Мы рассмотрим агентский
4:52workкflow и рассмотрим, как
4:54взаимодействуют агенты внутри
4:55мультиагентной системы. И дополнительно
4:58коснёмся и мультимодальных систем. В
5:00четвёртый день поговорим про то, что
5:02обычно болит больнее всего. как понять,
5:04что стало лучше, как вообще наш агент
5:06работает и как не дать ему умереть
5:09где-то в продакшене, потому что у нас
5:10поехали данные. То есть поговорим про
5:12эвал агентов. И наконец пятый день мы
5:15соберём всё изученное в один большой
5:18блок. А разберёмся, как вообще нужно
5:21прототипировать ассистентов и доводить
5:22их до продакшена. И как, э, какие
5:25особенности у агентов в продакшене, где
5:27нам нужны обзервабилити инструменты, как
5:30следить будем за качеством и как будем
5:32их масштабировать. Что нас ждёт сегодня?
5:34А, сначала мы погрузимся в самих
5:36агентов, рассмотрим, в каких сценариях
5:38они могут применяться, затем пройдёмся
5:40по эволюции взаимодействия человека и,
5:43наконец, дадим формальное определение
5:45агента. А дальше углубимся в мозг агента
5:48в лэмке. Дадим формальное определение
5:50уже lm, разберёмся, что такое веса и что
5:53такое загадочное next token prediction.
5:56Дальше изучим то, как лмки обычно
5:58обучаются, и сделаем из этого выводы, с
6:00чем они справляются хорошо, а с чем не
6:01очень. И в конце нас ждёт практика. Мы
6:03посмотрим, как использовать LM можно у
6:05себя в ноутбуке, а затем построим
6:08простейшего агента. Итак, давайте
6:09начинать с погружения в агентов. Для
6:12начала рассмотрим вообще, где агенты
6:15применяются сейчас. На самом деле,
6:17практически везде. А, во-первых, это
6:18персональные ассистенты и инструменты
6:20для работы со знаниями. То есть системы,
6:22которые нам помогают искать информацию,
6:24автоматизировать задачи и поддерживать
6:25принятие сложных решений. Во-вторых, это
6:28агенты исполнители, которые уже могут не
6:29просто отвечать, но и выполнять за вас
6:31какие-то действия в браузерах. Например,
6:33там заполнять формочки, выполнять
6:35цепочки действий в интерфейсах. И
6:37отдельный класс здесь - это инструменты
6:39для написания кода, а которые помогают
6:41буквально за вас разрабатывать какие-то
6:43приложения. Также агенты активно
6:46применяются в бизнес-процессах, в
6:48поддержке клиентов, а, и автоматизации
6:50операционных задач. И это сейчас
6:52действительно очень развивающаяся
6:54отрасль. Мм, например, недавно у Сева
6:56Макинти спросили: "Сколько у вас
6:57работает сотрудников, и он сказал, что
6:59больше 60.000. Причём из них там около
7:0140.000 - это люди, и около 25.000 - это
7:05и ассистенты. А интересно, что и агентов
7:07он уже рассматривает как полноценных
7:08сотрудников". И, наконец, агенты
7:10применяются и в интерактивных средах.
7:12Например, в видеоиграх NPC персонажей
7:14уже пробуют делать с помощью агента,
7:16чтобы они подстраивались под поведение,
7:18а, в реальном времени.
7:21И чтобы понять, как мы пришли в эту
7:23точку, где агенты уже умеют так много,
7:25полезно сделать шаг назад и посмотреть,
7:27как в целом развивалось наше
7:28взаимодействие с лмками. Это поможет нам
7:30сформировать интуицию о том, что такое
7:32современный агент. В таблице показаны
7:34основные паттерны от самых простых к
7:36более сложным и то, какие новые
7:38возможности появлялись на каждом этапе.
7:40Начиналось всё с простого промтинга,
7:42когда мы могли просто в модель занести
7:44какой-то текст и ждать от неё ответа. И
7:46выхлоп модели никак не влиял на
7:48дальнейший ход исполнения программы. А
7:50на следующем шаге у нас появился
7:51роутинг, когда LLM начинает участвовать
7:53в принятии решения. А, например, она
7:55может выбрать, какую из заранее заданных
7:58ветвей выбрать в исполнении. Тут уже
8:00поведение нашего ассистента становится
8:02частично детерминированным, потому что
8:04моделька может выбрать один из двух
8:05возможных путей. На следующем этапе
8:08появился лol коллин, а когда LLM уже
8:10могла выбрать не только путь, но и
8:12конкретную функцию, которую нужно
8:14вызвать, и в том числе аргументы, с
8:15которыми её нужно вызвать. Это позволило
8:17нам связывать модель с внешними IP,
8:19сервисами и инструментами. На следующем
8:22шаге мы уже получаем многошагового
8:24агента, когда он выбирает не просто
8:27отдельную функцию, её аргументы, а может
8:29планировать свои действия, выполнять их
8:31в цепочке, рефлексировать и так далее.
8:34И, наконец, вершина эволюции, когда мы
8:36пришли уже к мультиагентным системам,
8:38когда несколько агентных процессов
8:40смогли координироваться между собой,
8:42совещаться, а, тоже раскидывать задачки
8:44друг на друга и так далее. Если
8:46посмотреть на эту эволюцию целиком, то
8:48видно, что на каждом этапе модель
8:49получает всё больше контроля над
8:51процессом, от генерации текста к
8:53принятию решений и затем уже к
8:54планированию и координации. И именно это
8:57постепенное увеличение автономности и
8:59приводит нас к современному понятию
9:01агента. Но прежде чем его дать, хочется
9:03сделать оговорку, что на самом деле
9:05индустрия там новая и какого-то чёткого
9:07единого определения нет. А в индустрии и
9:10исследованиях крупных компаний есть
9:12несколько же разных формулировок, и они
9:14заметно отличаются. И вот, например,
9:15даже внутри Open AI нет единой
9:17канонической версии. А так, например, в
9:20презентации Open AI Agents SDK агент
9:22определяется как AI приложение, которое
9:24состоит из модели, инструкций,
9:26инструментов и среды выполнения, то есть
9:28рантайма, который управляет жизненным
9:29циклом агента. Одновременно с этим
9:32другое популярное определение предложила
9:34Лилин Венг. Это вице-президент по
9:36исследованиям и безопасности в Open AI.
9:38А в своём посте LM Powered Autonomous
9:41Agents она определяет агента как
9:43комбинацию LLM, памяти, навыков, навыков
9:46планирования и использования
9:48инструментов. И если сравнить эти два
9:50определения, то можно заметить, что
9:52каждый каждая из них делает акцент на
9:54разных аспектах. Да, в обоих есть
9:56упоминания моделей, инструментов, но в
9:58первом ничего не сказано про
9:59планирование и память, а во втором про
10:01промты и планирование и фокус на LLM как
10:04на мозгах агента, хотя на самом деле там
10:05могут использоваться и другие модельки.
10:07А-а, в этом курсе мы будем использовать
10:09наиболее общее рабочее определение,
10:11которое объединяет все эти компоненты.
10:13Итак, мы будем считать, что агент этойм
10:16система, внутри которой у нас есть
10:19модель, промты, инструменты, память,
10:22механизмы защиты и механизмы
10:24планирования. Конечно, все эти кусочки
10:26могут быть опциональные, и начинать
10:28стоить с простненького агента, который
10:30может состоять просто из модели,
10:31например, и инструментов. В этой лекции
10:33я только верхне уровне расскажу, зачем
10:35нужны каждый из этих компонентов. А в
10:38повод курса мы уже будем подробно
10:39погружаться в каждый из них. Итак, в
10:41центре у нас находится AI модель. Это
10:43можно сказать, что мозг агента. Но сама
10:45по себе модель может только генерировать
10:47текст и отвечать на какие-то вопросы.
10:49Поэтому, собственно, нужны все эти
10:50обявязки вокруг неё. А следующий слой -
10:53это промты. Сюда входят системный промт
10:55- это какие-то глобальные инструкции,
10:57которые задают роль агента, его цели,
10:59ограничения, стиль, как он должен
11:01принимать какие-то решения. Дальше
11:04сообщение пользователя. Это буквально
11:06текущая задача, которую должен выполнить
11:07ассистент. И в-третьих - это сообщение
11:10самого ассистента. Это могут быть его
11:12предыдущие ответы, результаты вызова
11:13тулов и так далее. Слева у нас находятся
11:16инструменты. Это какие-то внешние
11:18функции и опишки, которые позволяют
11:19агенту взаимодействовать с внешней
11:21средой, искать информацию, работать с
11:23календарём и многое другое. А наверху
11:26находится память. И, как правило, у
11:28агента есть три вида памяти. Это
11:29краткосрочная, например, текущий диалог
11:32или промежуточные результаты его
11:33действий, а долгосрочная память, а здесь
11:37уже может храниться информация между
11:38сессиями, знания о пользователя,
11:40какие-то исторические выполненные
11:42задачи, а знания про предметную область
11:45и так далее. И, наконец, контекстная
11:47память - это информация, которая
11:48необходима агенту конкретно в данный
11:50момент. Она может собираться из
11:51различных кусочков. Дальше отдельным
11:53облачком здесь вынесено guardrails, а не
11:56в облачке, потому что на самом деле они
11:57пронизывают каждый компонент системы. А
12:00это различные инструменты, которые она
12:02позволяют защитить агента от промт
12:04инжекна, а, и других попыток взлома и
12:07сделать его поведение более
12:08детерминированным.
12:10И, наконец, справа у нас находятся
12:11инструменты планирования. А они
12:14позволяют агенту не просто реагировать
12:15на запрос, а строить последовательность
12:17действий и исполнять их. И всё это
12:20объединяется потрясающий серый квадратик
12:22в RНТА, который управляет жизненным
12:24циклом агента, когда нужно вызвать
12:26модель, когда нужно вызвать инструменты
12:27и так далее. И вот, глядя на картинку на
12:30предыдущем слайде, возникает ощущение,
12:32что нам это что-то напоминает. И этот
12:34момент классно подметил Андрей Карпатый,
12:36со основатель Open AI, в своём видео
12:38Introduction to Large Language Motals.
12:40Он предлагает думать облmм не как о
12:42чатботе, а как о новой версии
12:44операционной системы. В этой аналогии
12:46сама LLM - это ядро операционной
12:48системы. Она оркестрирует инструменты,
12:50память, внешние ресурсы и процессы для
12:51решения задачи. Внешние базы знаний -
12:54это аналог диска, то есть модель может
12:56доставать оттуда информацию через
12:57retrieval или браузинг, когда ей это
12:59необходимо. Контекстное окно модели в
13:02данном случае можно сравнить с
13:03оперативной памятью. То есть это
13:05какая-то ограниченная рабочая область,
13:06где модель думает и она постоянно
13:08решает, какую информацию туда стоит
13:09погрузить, а какую уже можно выбросить.
13:12И, наконец, инструменты и
13:13специализированные модели - это как
13:15приложение, и LLM вызывает их по
13:17необходимости. И это, на самом деле,
13:19работает даже там на уровне экосистемы.
13:21То есть у нас есть какие-то закрытые
13:23проприетарные модели, как Windows и
13:25MacOS, и есть быстрорастущая Open source
13:27экосистема аналог Linux. Наконец, мы
13:30готовы погрузиться в основную часть
13:33агента, в его мозг, который в
13:35большинстве случаев представляется
13:37лмкой. Мы сегодня коснёмся только того,
13:40что нам пригодится для разработки
13:41агентов, а более подробно вы можете
13:43углубиться в мир GPT моделей и других на
13:46интенсиве GPT Week. Ссылочка здесь
13:48внизу. С точки зрения агентов LLM - это
13:51наиболее распространённые мозгагенты. А
13:54формальное определение может быть
13:55записано так: это нейросетевая модель,
13:58обученная на больших корпусах текстовых
14:00данных, которая применяется для
14:02предсказания следующего токена в
14:03контексте предыдущих. Определение
14:05длинное, сложное, мы его сейчас
14:07обязательно подробно разберём, но
14:08сначала давайте опустимся там на уровень
14:11физический. И с этой точки зрения LLM -
14:14это на самом деле два файла. Первый файл
14:16- это файл параметров. Это огромный файл
14:18с весами неросетки. В современных
14:20моделях это десятки и сотни гигабайт. А
14:22второй файл - это код выполнения.
14:24Относительно небольшой набор
14:26программного кода, который описывает
14:27архитектуру сети и принцип её
14:29инфекренса. И когда мы запускаем модель,
14:32а на самом деле этот код просто
14:33применяет математические операции к
14:35входным данным и весам, чтобы
14:37предсказать следующий токен на основе
14:39поданных на вход. То есть физический LM
14:41- это никакой не интеллект, не
14:42понимание, а просто огромная таблица с
14:44весами и код, который умеет правильно их
14:46применять.
14:47Давайте погружаться в определение LLM и
14:51начнём с первой части. Что такое там
14:53нейросетевая модель, обученная на
14:55больших корпусах текстовых данных?
14:56Весамодели - это, по сути, сжатое
14:58представление всех обучающих данных,
15:01которые были ей переданы. Чем больше
15:03параметров у модели, тем проще, на самом
15:06деле, это всё сжать, ну, вплоть до того,
15:07что оставить представление как есть. Но
15:10тем сложнее будет модель infрить с той
15:12точки зрения, что, во-первых, нужно
15:13будет уметь хранить этот огромный файл с
15:14весами, а во-вторых, придётся ждать,
15:16когда посчитаются все эти математические
15:18операции. Поэтому задача при обучении -
15:21это подобрать такую архитектуру, такой
15:23набор обучающих данных и так провести
15:24обучение, чтобы в как можно меньшем
15:27количестве параметров закодировать как
15:28можно большие знания о мире. Теперь
15:30перейдём ко второй части определения,
15:32что такое там next token prediction. Для
15:35простоты начнём сначала с Next word
15:38prediction, то есть представим, что
15:39модели на вход поступает предложение cat
15:42set on e и нам нужно предсказать, какое
15:44слово будет дальше. В данном случае мы
15:46там предсказываем, что 97% вероятности,
15:49что это слово будет mat. И задача во
15:51время обучения подобрать веса модели
15:53так, чтобы если они провзаимодействовали
15:55с входными токенами, то на выходе мы
15:57ожидали там действительно наиболее
15:59вероятное следующее слово.
16:02А откуда в этом всём берутся токены?
16:06Весамо модели - это числа. И чтобы мы
16:08могли как-то обработать входные наши
16:11данные, их тоже нужно представить в виде
16:12чисел. Давайте подумаем, как вот можно
16:15закодировать, например, предложение I
16:16was reading an interest in book in New
16:18York. Там первое очевидное решение.
16:21Давайте закодируем их буквально
16:22посимвольно. То есть каждую букву
16:25назначим ей отдельную цифру и попытаемся
16:26так переписать предложение. Ну да,
16:28получилось, но здесь есть много проблем.
16:30Во-первых, последовательность получается
16:32очень длинной, и из это будет нам
16:34замедлять и обучение модели, и потом её
16:36infренс. А во-вторых, модель видит
16:38только отдельные символы и никак не
16:39улавливает саму структуру слов. То есть
16:41такое кодирование, оно как бы
16:42бессмысленно с точки зрения языка. И да,
16:44нам становится сложнее захватывать смысл
16:46на уровне слов или даже целых фраз. А
16:49тогда следующий там наивный подход.
16:51Давайте закодируем по словам. Каждое
16:53отдельное слово мы берём, назначаем ему
16:54новую цифру, кодируем. Так, да,
16:56последовательность стала вроде как
16:57короче, но здесь у нас возникают новые
17:00проблемы. Во-первых, у нас языки
17:02содержат сотни слов. В английском,
17:04например, 600.000. И тогда у нас словарь
17:07сам по себе будет огромным. И хранить
17:08его вместе с лисами модели, а это очень
17:11тяжело. А, во-вторых, у нас будут
17:13появляться какие-то новые слова или
17:15редко встречающиеся, и под них нужно
17:17будет подбирать какое-то новое число,
17:19которое модель ещё не видела в обучении.
17:21И у нас всё ещё нет связи между,
17:23например, однокоренными словами. Если
17:24нам в следующем предложении придёт слово
17:26read, мы ему назначим цифру 10, и нам
17:30ничего не скажет, что цифры три и 10
17:31как-то связаны, хотя у них на самом деле
17:33одинаковый корень. И здесь приходит
17:35компромиссное решение. То есть у нас
17:37была проблема в том, что буквы - это
17:38слишком маленькие единицы языка, слова
17:40слишком большие.
17:42Вот пришло решение в виде токенизации. А
17:44токеном называют минимальную единицу
17:46текста, с которой работает языковая
17:48модель. Он может быть фрагментным одного
17:50слова или даже состоять из двух слов. То
17:52есть в данном случае, например, мы слово
17:53readдинг разбили на два токена: read и
17:56in, потому что когда мы в следующий раз
17:58встретим слово read, мы уже поймём, что
18:00вот оно как-то было связано с тем, что
18:01мы видели до этого. А, например, слово
18:03New York, а точнее Token New York,
18:05состоит из двух слов, ровно потому, что
18:07оно часто встречается именно в такой
18:09комбинации, и это можно выделять как
18:10отдельную сущность. И таким образом у
18:12нас уменьшается размер словаря. Это уже
18:14не сотня тысяч слов. Модель лучше умеет
18:17обобщать и находить взаимосвязи между
18:19различными токенами.
18:22И на самом деле существуют помимо
18:24обычных токенов ещё служебные или
18:26специальные токены. Это какие-то
18:27зарезервированные токены в висковых
18:29моделях, которые выполняют заранее
18:31заданные функции. Они не соответствуют
18:33обычному тексту, а используются именно
18:35для управления поведением модели. Да, у
18:38каждых моделей они разные, но их можно
18:40поделить на некоторые классы. Мы сегодня
18:41рассмотрим только те, которые нам важны
18:43с точки зрения агентов. А у нас есть,
18:45например, токены окончания генерации в
18:47авторегрессионных моделях. Это EОВ
18:50токены, как правило. Они буквально
18:51говорят, что всё, я предложение дописал,
18:53это можно отдавать пользователю. Дальше
18:55есть специальные токены, которые
18:56обозначают роли пользователь, ассистент
18:59или системный промт. Это нам позволяет
19:02сделать так, что модель видит множество
19:04таких токенов, после которых следуют
19:06непосредственно промты во время своего
19:08обучения. И потом на инференсе, когда мы
19:10применяем это в реальных системах, у неё
19:12меньше шансов заколлюционировать, и она
19:14лучше следует как бы этой структуре. И,
19:16наконец, у нас есть управляющие токены
19:18или модификаторы промта, например,
19:20translate summarize или перепиши там в
19:23формальном стиле. Они вот появляются
19:25ровно из того, что очень часто у
19:26ассистентов просят там просто переведи
19:28мне вот этот кусочек текста или
19:29сумморизируй. И опять же, если модель
19:31это много раз видела именно с таким
19:33фиксированным токеном во время обучения,
19:35то и потом при реальном использовании в
19:37жизни а она справится с этой задачкой
19:39получше. И теперь мы готовы вернуться к
19:42тому самому Next Token prediction. Так,
19:44мы теперь знаем, что такое токены. И то
19:46есть на самом деле наша модель
19:48предсказывает следующий токен в
19:50контексте всех поданных ей на вход. При
19:52этом говорят, что модель является
19:54авторегрессионной, то есть выход модели
19:57с одного этапа является входом для
19:58другого, чтобы мы не заканчивали просто
20:00генерацию на одном токене, а завершали
20:02предложение до конца, пока модель не
20:04сгенерирует как раз end of sequence
20:05token. А и здесь нам полезно понять, что
20:09такое контекстное окно. Это вот как раз
20:11длина, которая счисляется в токенах
20:14того, что модель может в моменте
20:15учитывать. И когда лимит достигается,
20:18более старые данные, которые были в этом
20:20промте, или откидываются, или
20:21суммаризируются, чтобы занимать меньше
20:23места, и так далее. А, но что происходит
20:25внутри каждого отдельного шага
20:27генерации? У нас после токинизации
20:29входного текста модель вычисляет
20:31представление последовательности,
20:32которая содержит информацию о значении и
20:34позиции каждого токена во входе. Затем
20:37это представление подаётся в модель,
20:39которая выдаёт оценки в виде логитов,
20:41которые отражают вероятность каждого
20:43токена и словаря быть следующим в
20:45последовательности. И здесь используются
20:47параметры температуры, который управляет
20:49степенью случайности вывода. Низкая
20:52температура делает распределение
20:53вероятностей более острым, и модель чаще
20:56выбирает наиболее вероятные токены, и
20:58текст получается более предсказуемым и
21:00строгим, а более высокая температура
21:02сглаживает это распределение, и у нас
21:04больше шансов выбрать какой-то токен,
21:05может быть, не самый вероятный, но один
21:07из. И на основе этих оценок, которые мы
21:10выдали на предыдущем этапе, существует
21:12несколько стратегий выбора следующего
21:14токена для продолжения текста. А самая
21:16простая стратегия - это буквально
21:17выбирать токен с максимальной оценкой. А
21:21есть более стахастические методы,
21:22например, топка смплинг, когда у нас
21:24выбирается случайный токен из К наиболее
21:26вероятных. И существует более
21:28продвинутые методы декодирования. Это,
21:30например, Beam Search, который
21:32рассматривает сразу несколько возможных
21:33вариантов продолжения и до какого-то
21:35этапа пытается сгенерировать все их и
21:37потом уже оценивает вероятность целой
21:39последовательности токенов. А, и давай
21:42теперь поговорим про то, как обучается
21:44LLM. М, в общем случае это можно
21:46разделить на три шага. Первый шаг - это
21:48притрейнинг. На этом шаге в несей
21:50загружают просто большие массивы данных
21:52о мире. И мы показываем модели текста
21:54отовсюду, откуда только можем. И главная
21:56её задача на этом этапе научиться
21:58предсказывать буквально вот следующий
22:00токен. Следующий этап - это фантюнинг.
22:03Это метод адаптации готовой языковой
22:04модели к специфическим задачам компании
22:07или, возможно, какой-то новой предметной
22:08области. Модель учится уже на примерах
22:11запрос-ответ и лучше подстраивается
22:13именно под то, как нужно на них
22:15отвечать. И, наконец, третий этап - это
22:17reinforcement learning. Например, на
22:19прошлом шаге мы научились не просто
22:21предсказывать следующий токен, но и
22:22отвечать на запросы. Но на самом деле
22:25людям не всегда нужны какие-то точные
22:26ответы или не всегда в такой
22:27формулировке. И при этом этих вопросов
22:29очень много, и у нас просто не хватит
22:31времени и денег, чтобы насобирать эти
22:34обучающие корпуса. Поэтому на этом этапе
22:36мы буквально пробуем обучить модельку на
22:39фидбэке или от живых людей, а или обучив
22:42другую языковую модель, которая будет
22:44оценивать, как наша LM справляется с
22:46какими-то конкретными ответами. И мы
22:48будем обучаться тогда на фидбэк от вот
22:50этой reward модели. Итак, давайте
22:52подсоберём, что хочется унести из этого
22:54рассказа. Первое, что модельки у нас
22:56работают с токенами, то есть они не
22:57знают, что такое слова, предложения или
22:59смысла напрямую. Они работают только с
23:01последовательностями токенов и пытаются
23:04предсказать наиболее вероятный из них.
23:06Почему это важно на практике? Во-первых,
23:08нам это пригодится при расчёте билингов
23:10за использование модели и при
23:12проектировании контекст окон, потому что
23:13их длина как раз вычисляется в
23:15количестве токенов, а не символов или
23:17слов.
23:18Во-вторых, это важно для понимания того,
23:21насколько важно соблюдать правильную
23:23структуру промта и передавать моделям
23:25контекст именно так, как они его
23:27ожидают. Потому что если они в обучающей
23:29выборке миллион раз видели, а что после
23:31слова system идёт system prompt, а мы
23:34его пытаемся записать просто так где-то
23:36сбоку, то не стоит удивляться тому, что
23:38моделька будет плохо реагировать.
23:40Второе, что мы обсудили - это специфику
23:42обучения, что модели обучаются на
23:44каких-то больших объёмах данных,
23:45предсказывает следующий токен.
23:47А мы из этого знаем, за что отвечает
23:50такой параметр, как температура. И
23:53теперь можно понять, откуда возникают
23:55галлюцинации. Галлюцинациями называют
23:57уверенную генерацию правдоподобной, но
23:59неверной или вымышленной информации. Они
24:02как раз возникают, потому что это
24:03стахистические модели. Она не проверяет
24:05факты, она просто в голове себе
24:07представляет, какой следующий токен
24:09наиболее вероятный, и уверенно
24:10генерирует дальше последованость
24:12токенов. Поэтому здесь очень важный
24:14пункт, который специально выделен
24:16жирным. А давайте автоматизировать всё,
24:18что автоматизируется, и изировать только
24:21то, что не автоматизируется. Например, в
24:24системном ромте писать, что если
24:25какая-то функция вернула true, то мы
24:27делаем а, а если она вернула фalse, то
24:29мы делаем b. А это попытка нарваться на
24:32лишние галлюцинации, ну, плюс потратить
24:34деньги на лишние infence модели, хотя
24:36это можно было написать просто
24:37программным кодом. [фыркает]
24:39И дальше в контексте того, как у нас
24:41обучаются модельки, можно сделать
24:43выводы, с какими задачками они
24:45справляются хорошо, а с какими не очень.
24:47Сначала давайте рассмотрим сильные
24:49стороны. А это, во-первых, задачи с
24:51высокой статистической структурой,
24:53разные перефразирования, резюмирование,
24:55генерация связанного текста или кода,
24:57потому что это всё, это задача на
24:59предсказание вероятных последованостей
25:01слов, на которых модели как раз
25:02обучались. А, во-вторых, модельки хорошо
25:05умеют обрабатывать и генерировать
25:06стандартные для них структуры. Это
25:08какие-то рассуждения, такие как Chain of
25:10SS, которые мы рассмотрим в следующих
25:12занятиях, вызовылов, а, и обработка
25:16каких-то стандартных файлов и таблиц. Но
25:18с чем модели справляются плохо?
25:20Во-первых, это точные алгоритмические
25:22символьные задачи. А, например, там под
25:25счёт букв, цифр, спрашивает, сколько
25:27букв А в слове банана. Вот это у моделек
25:30не нужно, потому что они учились
25:32предсказывать следующий токен, а не
25:34смотреть там на предыдущий и буквально
25:36уметь что-то считать. А второе
25:38ограничение - это актуальные знания.
25:42Если вы спросите у модели там новости за
25:44вчера, скорее всего, она не сможет
25:45ответить, если у неё нет никаких
25:47дополнительных инструментов, потому что
25:48её обучение было где-то год назад или
25:51там полгода назад, [фыркает] и все
25:52заложенные у неё базовые знания, они
25:54ограничены как раз этим периодом. А
25:57третье, в чём модельки не очень хорошо
25:59справляются без дополнений к ним - это
26:02долгосрочное планирование и память. То
26:04есть запланировать последовательность
26:05там на 30 шагов, нигде при этом не
26:08сохраняя её и не продумывая по несколько
26:10раз, а даётся им довольно тяжело.
26:14Но здесь небольшие спойлеры. Большинство
26:16из этих ограничений можно как раз решать
26:18с помощью кубиков, которые мы дальше и
26:20рассмотрим. И теперь мы готовы перейти к
26:22практике, где мы уже сможем на реальных
26:24кейсах посмотреть как раз ограничения
26:26лэмок и их сильные стороны. А в этом
26:29ноутбуке хочется показать, как можно
26:31использовать лмки. Мы рассмотрим как
26:32локальный infence и на ЦПУ, и на ГПУ,
26:35так и infence через внешние опишки. И
26:38также на примерах рассмотрим те ключевые
26:41выводы про LM, которые мы с вами сделали
26:43в лекции. А сначала мы настраиваем
26:46среду. На самом деле Google Club может
26:48работать и с ЦПУ, и с ГПУ.
26:50Я покажу оба варианта. Чтобы вам
26:52включить гпушку, нужно перейти в Rime и
26:56поменять Runime Type на гпушный. Здесь
26:58мы устанавливаем нужные нам библиотеки.
27:01И вот для того, чтобы установить
27:02библиотеку с поддержкой, а GPU, если она
27:05вам доступна, мы здесь добавим следующие
27:07флаги.
27:09Переходим к первому пункту. Как можно
27:11использовать лэмки. Во-первых, их можно
27:13инферить локально, когда вы буквально
27:15скачиваете модель с открытыми весами и
27:18инферите её на своём ноутбуке.
27:20как на ЦПУ, так и на ГПУ. И, во-вторых,
27:22можно ходить во внешние АИ. И здесь
27:25понятно, что везде есть какие-то плюсы и
27:27минусы. При локальном инференсе вы
27:29получаете там полную приватность данных,
27:30данные никуда не улетают, полностью у
27:32вас логируются и так далее. Но при этом
27:35приходится хостить модельки у себя, что
27:37иногда бывает дорого по железу и
27:39непосредственно по техподдержке. Когда
27:41мы ходим через опишки, мы получаем
27:43доступ к огромным моделям, потому что
27:46они расположены на больших
27:47вычислительных кластерах. Но при этом
27:49тогда нам необходимо платить за каждый
27:51отправленный туда токен и полученный с
27:53сервера. А, ну и плюс мы теряем
27:55приватность данных, потому что они уже
27:57могут куда-то утекать. Начнём с
27:59локального инференса, а, и с цепушек.
28:04Сначала вынесем какие-то общие
28:05параметры, которые мы будем использовать
28:07внутри всего ноутбука, и напишем
28:08какой-то системный промт. Здесь я просто
28:10говорю, что там ты мой персональный
28:11ассистент и, пожалуйста, там всегда
28:12обращайся ко мне Алёна. И прошу выдать
28:15там три идеи, где агенты могут быть
28:18полезны. И вот здесь мы
28:19продемонстрируем, почему важны те самые
28:22специальные токены и почему важно
28:23подавать в модель данные именно так, как
28:25она ожидает. То есть здесь я формирую PL
28:27промт, где буквально пытаюсь сказать,
28:29что смотри, вот этот кусочек - это
28:30системный промт, вот это кусочек мой
28:32промт, и дальше мы ждём от тебя
28:34ассистентский выхлоп. А, а здесь запишем
28:37в том формате, в котором принято
28:39передавать в эту конкретную модель в
28:41формате там messages, где роль отдельно
28:43выделена и она потом перекодируется.
28:46Итак, [фыркает] м здесь мы скачиваем
28:48маленькую-маленькую модельку с
28:50Хагинфейса, а, и распечатываем, что всё
28:53загрузилось успешно. И дальше пишем
28:56обёртку над этой моделью. Здесь мы
28:58проставляем флаг про NGPU layers 0, что
29:00нам говорит о том, пожалуйста, infли эту
29:02модельку только на CPU. Подгрузили её на
29:05ЦПУ. И теперь давайте попробуем
29:06заинферить. Здесь такая простая обёртка
29:08над ней, которая буквально передаёт
29:10сообщение, которое мы хотим ей передать,
29:12и получаем из неё выхлоп. Напоминаю, что
29:14я там просила дать три идеи, где агентам
29:16могут быть полезны. И в первом случае я
29:19её спрашивала с помощью плейнпромпта,
29:22где я буквально говорил: "Вот системный
29:24промт, это мой промт и что-нибудь
29:26ответь". А и что мы видим? Что вот
29:28моделька начала отвечать и потом решила
29:32догаллюцинировать, что дальше? Юзер
29:34спросил: "Что-то ещё? и попросил
29:35ассистентский выхлоп, и он что-то ещё
29:37поотвечал, и что-то ещё и так далее. То
29:39есть зациклилась. Поэтому, пожалуйста,
29:42обращайте внимание на то, как конкретная
29:43модель ожидает э данных, которые будут
29:46продаваться ей на вход. Потому что вот,
29:48например, если мы передаём так, как она
29:50ожидает, то она буквально отвечает то,
29:52что мы хотели, там три области, в
29:54которых агент может быть полезен. Ну и
29:57дальше, просто потому, что модельки
29:58любят генерировать много текста, она
30:00предлагает ещё более конкретные примеры,
30:03но это уже лучше, чем было в предыдущий
30:05раз. Но, как мы видим, на ЦПУ мы можем
30:08инфрить только супер-спер лёгкие
30:09модельки. И вот это, например, она даже
30:11забыла, что её просила, вообще-то,
30:12обращаться ко мне: "Привет, Алёна".
30:14Теперь давайте перейдём к гпушке. Здесь
30:16мы уже скачиваем модельку побольше и
30:18проставляем параметр в обёртке над лмкой
30:21ngp layers -1. Здесь мы просим:
30:23"Заиспользуй все слои, которые только
30:25можешь, перенеси их на ГПУ". И теперь
30:27спрашиваем ровно те же самые промты у
30:30Гпушной модели. И здесь она вот уже
30:32вспомнила, как надо ко мне обращаться. И
30:34там из-за того, что она уже потяжелее и
30:36посильнее, смогла ответить в обоих
30:38случаях, что нужно. Но здесь смотрим,
30:40что она решила продолжить ещё дальше.
30:42Hello, Алёна сказать. Теперь давайте
30:43перейдём к инференсу через внешние
30:45опишки. В данном случае я буду
30:47показывать, как мы инферим open AI на
30:50IP.
30:51Но можно там поизучать, как использовать
30:53и другие внешние пишки в других
30:55занятиях. Во-первых, нам нужно будет
30:58здесь генерировать ключ, который мы
31:00будем использовать для авторизации в
31:01Open AI и по которому будет билиться
31:03наши запросы, запросы и ответы, которые
31:05мы будем получать. И дальше здесь слева
31:08нужно выбрать секрет, чтобы сложить туда
31:10этот ключ. И дальше внутри а файла вы
31:13его можете потянуть уже вот так. или
31:15там, если вам не нужно демонстрировать
31:16экран и вы не рискуете спалить этот
31:18токен, можете его подложить буквально
31:19сюда. А дальше мы, собственно, загружаем
31:22нужную нам библиотеку Open AI, объявляем
31:25модельку, которую мы будем использовать.
31:26В данном случае это там GPT5 n, но
31:28можете использовать и более какие-то
31:30дешёвые. И, собственно, обёртка над
31:33лмкой. Здесь мы просто входим в самого
31:35клиента с нашими параметрами. Говорим:
31:37"Мот такую модель будем использовать". И
31:38вот тебе сообщение на вход, на которое
31:40мы ждём ответа. И вот я передаю тот же
31:43самый Messenges Prompt. Потрясающе. Нам
31:45моделька ответила из Hello Алёна и
31:47перечислила три пункта, где лмки могут
31:49быть полезны и дальше никуда не ушла.
31:51Теперь давайте перейдём ко второй части,
31:53где мы посмотрим на те самые ke
31:55takeaways, которые мы рассмотрели в
31:56лекции. С чем лнки хорошо справляются, с
31:59чем не очень и что для них специфично.
32:02Во-первых, как мы говорили, модельки
32:03умеют галлюционировать, то есть уверенно
32:06генерировать ненастоящую информацию.
32:08тоже такая миниобёртка, которая он будет
32:09просто красиво выхлоп делать. И теперь
32:11давайте посмотрим, что я пытаюсь у неё
32:13спросить. Говорю, что там ты мой
32:14ассистент по питону. Расскажи мне,
32:16пожалуйста, вот в Open AI SDK как
32:18использовать вот этот конкретный метод.
32:22Спрашиваю, и она мне начинает очень
32:24уверенно отвечать там, как его найти
32:26вообще, как его использовать, как его
32:28установить, как его использовать в коде,
32:29какие там мо могут быть ограничения.
32:31Здесь есть одна глобальная проблема, что
32:33этого метода на самом деле вообще не
32:34существует. То есть это буквально
32:36галлюцинация модели. где она пошла
32:38писать код, вроде как он очень похож на
32:40правду, и она его продолжает там
32:41дописывать. Мм, с этим можно бороться. И
32:44там самый простой способ - это просить в
32:46промте. Там, если ты не уверена,
32:47пожалуйста, не отвечай, что я,
32:48собственно, вот здесь вот и делаю. Там,
32:50если ты не знаешь, просто скажи, что не
32:54надо меня об этом спрашивать, ничего не
32:55придумывай. И теперь спрашиваю Ровно тот
32:57же самый вопрос. И к счастью, она
32:59говорит: "Да, что я там вообще не знаю
33:01про такой метод, отстаньте от меня".
33:02[откашливается]
33:03Теперь давайте перейдём к сильным
33:04сторонам лолэмок. Как мы говорили, их
33:08первая там сильная сторона - это что они
33:09хорошо справляются с задачками на
33:11суммаризацию и перефразирование. Здесь я
33:13её прошу, там вот у меня был какой-то
33:15текст, говорю там сумморизируй меня для
33:16слайда, чтобы было поболе там расписано.
33:19Вот потрясающе справляется. Дальше
33:21генерация каких-то стандартных структур,
33:23потому что она, опять же, их много раз
33:24видела в выучающей выборке. Здесь я её
33:26прошу сгенерировать не структурированный
33:28выхлоп в виде Jon объекта. И да, он
33:31действительно корректный там с какими-то
33:32сильными и слабыми сторонами лмок.
33:35И, наконец, давайте рассмотрим то, с чем
33:38лмки справляются. Не очень хорошо, как
33:39мы говорили, там подсчёт символов.
33:41Например, здесь я формирую строку из там
33:44заранее заданного числа символов и прошу
33:46буквально посчитать их. А, и там
33:48сравниваю с каким-то идеальным
33:50результатом, который просто вычислить
33:51там через длину строки можно. И, как мы
33:52видим, модель мне смогла в предыдущих
33:54шагах там и какой-то метод придумать, и
33:57что-то посумаризировать. И даже там
33:59запомнила, что ко мне надо обращаться
34:00Алёны, но с такой, казалось бы, простой
34:02задачей, как подсчёт символа в строке,
34:03она не справилась. А дальше какая-то
34:06точная арифметика. Здесь тоже не самое
34:08сложное выражение: два перемножения и
34:10потом какое-то деление. Прошу её
34:12посчитать результат, с чем она опять же
34:14не справляется. Ну там
34:16эвалем настоящее выражение с помощью
34:17встроенной функции.
34:19И третье - это знания, которые там
34:22случились за последние пару дней или
34:23буквально там в последние секунды. А
34:26здесь я пытаюсь ей сообщить, что у тебя
34:27там нету доступа в интернет. И расскажи
34:30мне, какая там цена биткоина прямо
34:32сейчас. И моделька в данном случае я её
34:34попросила не эвалюционировать, и поэтому
34:35она честно признаётся, что она не знает.
34:38А, но м если мы будем уже подключать
34:41какие-то инструменты, которые ей
34:42позволят входить в какие-то внешние базы
34:44знаний или там в интернет, то она бы это
34:46уже смогла сделать. И, наконец, а модель
34:49плохо справляется со задачками
34:50цитирования. Например, здесь я её прошу
34:53вытать чётко первый параграф Гарри
34:55Поттера, но при этом прошу там опять же
34:58не галлюционировать. А без этого в
35:00данном случае она справляется плохо. То
35:02есть в первом пункте она мне ответила,
35:03что извините, там не могу точно
35:06пересказать его, а ногу там
35:08посумаризировать что-то или вспомнить.
35:10Но во втором случае я ей говорю, что вот
35:12книга начинается вот так, и уже прошу из
35:14этой книги что-то поцитировать. То есть
35:16то, что у неё реально есть в доступе. И
35:17с этой задачей она справляется уже
35:20идеально. То есть так мы смогли на
35:21практике проверить то, что утверждалось
35:24в лекции. С чем модель XПSтся хорошо, с
35:26чем не очень и какие у них особенности.
35:28Итак, давайте перейдём ко второй части
35:29нашей практики, где мы уже, наконец,
35:31построим нашего первого агента, который
35:33будет использовать только лмку. И здесь
35:35я сначала расскажу, собственно, про
35:37агента, которого мы будем строить, на
35:38самом деле, сквозь весь курс. Для этого
35:40мы рассмотрим, что такое там TA bench, и
35:43рассмотрим конкретного задачу на
35:45построение агента. И затем уже
35:47непосредственно перейдём к его
35:48разработке и посмотрим на то, что может
35:51сделать агент, если у него есть только
35:53LLM и больше ничего. Итак, а давайте
35:56сначала разберёмся, что такое TWН. У нас
35:59появляется много агентов за последние
36:00годы, и, естественно, их всех нужно
36:02как-то оценивать. А многие изобретают
36:05какие-то отхочные подходы, где просто
36:07пытаются его протыкать руками и там на
36:09глаз понять, насколько он хорошо
36:10работает. Ну, понятно, что это не как не
36:11масштабируемое решение. Поэтому стали
36:13создавать разные бенчмарки, которые нам
36:15позволят, в том числе, оценить, как
36:17разные лмки справляются в агентских
36:19сценариях. И вот как раз одним из таких
36:21бенчмарков является T2 benнchmark. А он
36:24вышел там в двух версиях. Здесь есть и
36:26ссылки на статьи, и ссылки на их
36:28реализации в гитхабе. Можете почитать
36:30подробнее, если интересно. Но если
36:32коротко, то в Таубенче оценка агентов
36:36происходит так, что есть какие-то
36:37конкретные сценарии, где описывается
36:39там, э, что случилось у пользователей,
36:42что он пытается добиться от агента,
36:43описывается ожидаемое поведение агента,
36:45какие он инструменты должен выдать и как
36:47ответить пользователю или вообще никак
36:49не отвечать на такой запрос и так далее.
36:51И вот потом вышло ещё обновление T2
36:54bench, где можно эмулировать не только
36:56поведение самого агента, как он будет
36:58отвечать на конкретный запрос с
37:00конкретной лмкой под капотом, ну и
37:02поведение пользователя, то есть чтобы
37:04они могли общаться между собой. Итак,
37:06здесь мы скачиваем, собственно,
37:08репозиторий St2 Bнчо. Можем перейти в
37:10директорию и установить там необходимые
37:12зависимости. А опять же, как в прошлый
37:14раз, генерируем ключик для модели,
37:17которую мы будем использовать под
37:18капотом. В моём случае это Open AI
37:20модель. И подгружаем его в переменные
37:22среды. Также вы можете вызвать команду,
37:25которая позволит вам запустить
37:26симуляцию. И здесь вы сможете поработать
37:28в разных доменах и от лица пользователя,
37:31и от лица агента. То есть вы будете
37:32получать конкретное задание, чтом ты
37:34должен заставить его отменить твоё
37:35бронирование и играть роль пользователя.
37:40Давайте посмотрим на задачку, которую мы
37:42будем решать. Там есть несколько
37:43доменов. Мы с вами займёмся агентом
37:46бронирований или airline агентом. То
37:48есть агент, который отвечает там за
37:50полёты, бронирование и так далее. В
37:52самом задании мы сейчас посмотрим
37:54конкретно его политики и что он должен
37:57делать, а что не должен. Для этого мы
37:58переходим там в внутри этого репозитория
38:01в папочку с нужным доменом и достаём вот
38:04его политику. И здесь написан,
38:06собственно, можно сказать, системный
38:08промт нашего агента. То есть в целом
38:10какое сейчас число, ну, для него, чтобы
38:11он понимал, и там какой у него t of
38:14voice, что такое пользователь, что такое
38:16перелёт, как мы работаем с
38:18бронированиями, как мы работаем там с
38:20изменениями этих бронирований, их
38:22отменой, где нужно подтверждать у
38:23пользователя, а где нет.
38:26И мом посмотреть с вами на пример
38:27заданий, которые лежат внутри этого
38:29бенчмарка. А вот выберем там самый
38:32первый. Здесь, как мы видим, несколько
38:33блоков. То есть вот описан
38:34пользовательский сценарий, а здесь
38:36написано, что ты пытаешься сделать с
38:39агентом следующие э задачки, а и вызвал
38:42его вообще по такой-то причине. Мы знаем
38:45про тебя, как тебя зовут, и там твой
38:47usеer ID, который там, видимо, ты будешь
38:49сообщать агенту, чтобы он мог дальше
38:51найти твои бронирования. И также есть
38:53описание самой задачки в целом, что она
38:55конкретно проверяет, а, и как мы её
38:57будем оценивать, что значит, что агент
38:59справился хорошо, какие инструменты он
39:01должен вызвоть, а какие нет. И можем там
39:03посмотреть на конкретные задачки,
39:05которые мы могли бы задавать нашему
39:06агенту. А, например, там ты хочешь
39:09отменить какое-то конкретное
39:10бронирование и добавлена специфика, с
39:13которой агенту предстоит справиться. А
39:16там или ты недавно разговаривал с
39:19саппортом, и тебе сказали, что э агент
39:22сможет помочь отменить твоё
39:24бронирование. То есть какая-то может
39:25быть немного другая задачка. И таких
39:28бенчмарков, на которых они будут
39:29замеряться, их очень много в данном
39:31репозитории.
39:32И как мы будем работать над этим
39:34агентом, мы буквально его соберём по
39:36кусочкам. То есть мы с вами в лекции
39:37рассмотрели, из чего состоит в целом наш
39:39агент. Сегодня попробуем реализовать
39:41только то, что касается лмной части, а в
39:43последующих занятиях будем добавлять
39:44инструменты, память, гардрелзы и потом
39:47всё это, собственно, попробуем оценить.
39:49Итак, сегодня начинаем разработку с
39:52самого простого агента. Я немного
39:54сократила системный прот, потому что
39:56большинство из того, что написано прямо
39:58сейчас в нём, то, что мы просматривали
39:59выше, нашему агенту не нужно, потому что
40:01он не с базы данных не сможет
40:02поработать, не сходить в какие-то
40:04внешние опишки. Здесь я просто говорю,
40:05что там ты ассистент, не галлюционируй,
40:08пожалуйста, ничего лишнего не дёргай, а
40:10можешь просто отвечать на мои вопросы.
40:12Разрабатывать э нашего агента мы будем в
40:15экосистеме L. Что нам понадобится
40:17сегодня - это две части: Linkchain и
40:19Longraph. Linkchain - это, собственно,
40:22первый фреймворк в данной экосистеме для
40:24разработки агентов. А он капсулерует
40:27себе разные обёртки над промтами, а,
40:29цепочками исполнения, инструментами,
40:32агентами, памятью и так далее. А нграф -
40:35это его расширение, а, которое нам
40:37позволяет реализовывать агентов, у
40:39которых состояние будет постепенно
40:42изменяться, проходя через различные узлы
40:45нашего графа. Также в этой системе есть
40:47ещё LFOW. Это инструмент, который
40:50позволяет визуально собирать агентов
40:52даже без кода. И LMI - это инструмент,
40:55который позволяет дебажить и отлаживать
40:58наших агентов и многое другое.
41:01Устанавливаем нужные библиотеки и
41:02переходим, собственно, к написанию
41:04агентов. Сначала сделаем обёртку над
41:06Лэмкой, а тоже здесь импортируем нужный
41:09нам класс чат Open AI, который м как раз
41:12является обёркой для Open Aйных моделей.
41:14То есть он знает, в каком формате нужно
41:15им передавать разные промты и как
41:17парсить их выхлопы. Дальше импортируем
41:21обёртки над сообщениями. А это системное
41:23сообщение, сообщение пользователя,
41:25сообщение ассистента, ну и, собственно,
41:27базовое сообщение, от которого они все
41:28наследуются.
41:30Теперь, а давайте чуть углубимся в то,
41:32как работает нграф, то есть место самого
41:34обычного пайплайна, там где у нас просто
41:36от пользователя прилетел запрос, мы его
41:37бросили в lлм, получили выхлоп и отдали
41:39обратно пользователю. Здесь вводится
41:41несколько абстракций. Мы создаём агента
41:44как некоторый граф, в котором состояние
41:46будет перетекать между узлами графа. Что
41:49это даёт? Так разрабатывать продакшновых
41:52агентов на самом деле намного проще,
41:53потому что у тебя есть какие-то
41:54абстрактные объекты, про которые ты
41:56знаешь, в какой момент, что и как именно
41:58должно было поменяться, и при переходе
42:00из какого состояния в какое мы ожидаем
42:02выполнения следующих действий. Итак, нам
42:05нужно определить состояние, которое у
42:06нас будет перетекать между вершинами
42:08графа. Собственно, это мы и делаем. В
42:10данном случае в состоянии мы хотим
42:11хранить пока только сообщения, которыми
42:13обменивался пользователь и ассистент.
42:16Теперь, а, обсудим узлы, через которые
42:18это состояние должно перетекать. Узел в
42:20данном случае должен получить текущее
42:22состояние агента, потом выполнить нужные
42:24ему операции и отдать, собственно,
42:27изменённое состояние. А в нашем случае
42:30мы объявляем лмный узел, который берёт
42:33текущее состояние, в котором должно
42:35лежать сообщение пользователя,
42:37дальше ходит в лэмку и дописывает ответ
42:41Лэмки в состоянии агента. И давайте
42:45перейдём уже к разработке самого агента.
42:46То есть мы формируем его как граф, в
42:49котором а вершинки - это некоторые
42:52функции, рёбра определяют транзакции
42:54между этими вершинками и передают между
42:57ними состояние агента, которое должно
42:59меняться. В нашем случае у нас будет
43:01самый простой агент, у которого будет
43:02просто старт, потом лмная нода и конец.
43:05Но на самом деле, естественно, дальше мы
43:07будем его расширять, подключая
43:08инструменты, память и так далее.
43:10объявляем наш граф, создаём его, а, с
43:14каким-то начальным состоянием, а,
43:16указывая, собственно, какой класс у него
43:18будет храниться. Дальше задаём стартовый
43:20узел. В нашем случае это лмная нода, и
43:22она же будет конечной. Дальше мы
43:25компилим наш граф в некоторое
43:26приложение, которое уже непосредственно
43:27можно будет запускать и исполнять, и
43:29получаем самый простой граф. Теперь
43:31давайте проверим, что у нас получилось.
43:34Просто делаем обёртку, которая будет
43:35красиво принтить выхлоп модели, и задаём
43:38два вопроса, с которыми в целом наш
43:39ассистент без чего-то дополнительного
43:41сможет справиться, и с чем он не сможет
43:44в данном случае. С чем он сможет
43:46справиться, как мы ожидаем. Это спросить
43:48про политику, где нужны там конкретные
43:51подтверждения от пользователя при
43:53исполнении некоторых действий. И да,
43:55агент там может нам порассказывать. А
43:57второе тоже попросить объяснить какие-то
44:00ограничения по багажу при перелётах.
44:03тоже потрясающе справился. Аа и задачки,
44:06где агент уже не может сработать, это,
44:08например, попросить отменить конкретную
44:10резервацию. Мм, ну не сможет он так
44:13сделать, просто потому что он может
44:14только генерировать какой-то текст. И
44:16здесь там вопрос тоже, какую компенсацию
44:19конкретный пользователь сможет получить
44:21по данному бронированию с перелётом а из
44:24одного города в другой. Опять же, из-за
44:25того, что у агента нету никакого доступа
44:27изучить, что это вообще за бронирование,
44:29в данном случае он нам ответить не
44:31сможет. Но всё это мы будем решать в
44:34последующих уроках, прикручивая к лэмке
44:36инструменты, память, инструменты защиты
44:38и так далее. На этом мы заканчиваем нашу
44:41первую лекцию, где мы с вами подробно
44:42рассмотрели из каких компонент состоит
44:44агент, детально углубились в то, как
44:46работают лмки и собрали простейшего
44:48агента. В следующем занятии, которое
44:50стартует совсем скоро, мы изучим, что
44:52такое инструменты и MCP, и
44:54непосредственно интегрируем их в нашего
44:56агента.

About this transcript

This page contains the full transcript of Agents Week 2026 | Лекция 1.1 Intro to AI Agents LLM by Яндекс Образование , generated from the public captions YouTube serves with the video. The transcript has 7,016 words across 1,226 segments, with the original timestamps preserved so you can click any line to jump to that moment in the embedded player.

What you can do with it

Use the transcript to take notes, quote the speaker, build a study guide, generate a summary with ChatGPT or Claude via the YouTube Summary tool, or export it as a timed subtitle file with YouTube to SRT. You can also re-open it in the transcriber to translate the transcript into 100+ languages.

Free YouTube transcript tool

YouTube2Text is a free YouTube transcript generator — no signup, no daily limit. Paste any YouTube link and get the full transcript instantly, with timestamps, click-to-jump, translation to 100+ languages, AI prompts for ChatGPT, Claude, and Gemini, and exports to TXT, SRT, VTT, or Markdown.