Buckets:
| # Agents-Course | |
| ## Docs | |
| - [Добро пожаловать на курс 🤗 ИИ Агенты [[introduction]]](https://huggingface.co/learn/agents-course/ru-RU/unit0/introduction.md) | |
| - [Подготовка к работе: Ваши первые шаги ⛵](https://huggingface.co/learn/agents-course/ru-RU/unit0/onboarding.md) | |
| - [(Необязательно) Discord 101 [[discord-101]]](https://huggingface.co/learn/agents-course/ru-RU/unit0/discord101.md) | |
| - [Наблюдение: Интеграция Обратной Связи для Рефлексии и Адаптации](https://huggingface.co/learn/agents-course/ru-RU/unit1/observations.md) | |
| - [Понимание AI Агентов через цикл Мысль - Действие - Наблюдение.](https://huggingface.co/learn/agents-course/ru-RU/unit1/agent-steps-and-structure.md) | |
| - [Сообщения и Специальные Токены](https://huggingface.co/learn/agents-course/ru-RU/unit1/messages-and-special-tokens.md) | |
| - [Что такое Агент?](https://huggingface.co/learn/agents-course/ru-RU/unit1/what-are-agents.md) | |
| - [Что такое Инструменты?](https://huggingface.co/learn/agents-course/ru-RU/unit1/tools.md) | |
| - [Быстрая самопроверка (не оценивается) [[quiz2]]](https://huggingface.co/learn/agents-course/ru-RU/unit1/quiz2.md) | |
| - [Раздел 1 Тест](https://huggingface.co/learn/agents-course/ru-RU/unit1/final-quiz.md) | |
| - [Небольшой тест (не оценивается) [[quiz1]]](https://huggingface.co/learn/agents-course/ru-RU/unit1/quiz1.md) | |
| - [Введение в Агентов](https://huggingface.co/learn/agents-course/ru-RU/unit1/introduction.md) | |
| - [Что такое LLM?](https://huggingface.co/learn/agents-course/ru-RU/unit1/what-are-llms.md) | |
| - [Библиотека Фиктивного Агента](https://huggingface.co/learn/agents-course/ru-RU/unit1/dummy-agent-library.md) | |
| - [Мысль: Внутреннее Рассуждение и Re-Act подход](https://huggingface.co/learn/agents-course/ru-RU/unit1/thoughts.md) | |
| - [Давайте создадим нашего первого агента с помощью smolagents](https://huggingface.co/learn/agents-course/ru-RU/unit1/tutorial.md) | |
| - [Заключение [[conclusion]]](https://huggingface.co/learn/agents-course/ru-RU/unit1/conclusion.md) | |
| - [Table of Contents](https://huggingface.co/learn/agents-course/ru-RU/unit1/README.md) | |
| - [Получите свой сертификат](https://huggingface.co/learn/agents-course/ru-RU/unit1/get-your-certificate.md) | |
| - [Действия: Обеспечение взаимодействия Агента с его Окружением](https://huggingface.co/learn/agents-course/ru-RU/unit1/actions.md) | |
| - [Введение](https://huggingface.co/learn/agents-course/ru-RU/bonus-unit1/introduction.md) | |
| - [Заключение [[conclusion]]](https://huggingface.co/learn/agents-course/ru-RU/bonus-unit1/conclusion.md) | |
| - [Давайте дообучим вашу модель для вызова функций](https://huggingface.co/learn/agents-course/ru-RU/bonus-unit1/fine-tuning.md) | |
| - [Что такое вызов функции?](https://huggingface.co/learn/agents-course/ru-RU/bonus-unit1/what-is-function-calling.md) | |
| - [Live 1: Как работает курс и первые ответы на вопросы](https://huggingface.co/learn/agents-course/ru-RU/communication/live1.md) | |
| - [Когда будут опубликованы следующие разделы?](https://huggingface.co/learn/agents-course/ru-RU/communication/next-units.md) | |
| ### Добро пожаловать на курс 🤗 ИИ Агенты [[introduction]] | |
| https://huggingface.co/learn/agents-course/ru-RU/unit0/introduction.md | |
| # Добро пожаловать на курс 🤗 ИИ Агенты [[introduction]] | |
| Фон изображения был сгенерирован с помощью Scenario.com | |
| Добро пожаловать на самую захватывающую тему в ИИ на сегодняшний день: **Агенты**! | |
| Этот бесплатный курс проведет вас по пути **от новичка до эксперта** в понимании, использовании и создании ИИ агентов. | |
| Этот первый блок поможет вам освоиться в материале: | |
| - Ознакомьтесь с **учебным планом курса**. | |
| - **Выберите путь**, по которому вы собираетесь идти (самооценка или процесс сертификации). | |
| - **Получите дополнительную информацию о процессе сертификации и сроках**. | |
| - Познакомьтесь с командой, создавшей этот курс. | |
| - Создайте свою учетную запись **Hugging Face**. | |
| - **Зарегистрируйтесь на нашем сервере Discord** и познакомьтесь со своими одноклассниками и с нами. | |
| Давайте начнем! | |
| ## Что ожидать от этого курса? [[expect]] | |
| В этом курсе вы узнаете: | |
| - 📖 Изучите AI агентов в **теории, дизайне и на практике.** | |
| - 🧑💻 Научитесь **использовать известные библиотеки ИИ-агентов**, такие как [smolagents](https://huggingface.co/docs/smolagents/en/index), [LangChain](https://www.langchain.com/), и [LlamaIndex](https://www.llamaindex.ai/). | |
| - 💾 **Поделитесь своими агентами** на Hugging Face Hub и изучите агентов, созданных сообществом. | |
| - 🏆 Примите участие в испытаниях, где вы будете **оценивать своих агентов в сравнении с агентами других студентов.** | |
| - 🎓 Выполнив задания, вы **получите сертификат об окончании курса.** | |
| И многое другое! | |
| В конце этого курса вы поймете, **как работают агенты и как создавать свои собственных агентов с помощью новейших библиотек и инструментов**. | |
| Не забудьте **записаться на курс!** | |
| (Мы с уважением относимся к вашей конфиденциальности. Мы собираем ваш адрес электронной почты, чтобы **высылать вам ссылки, когда каждый блок будет опубликован, и предоставлять вам информацию о задачах и обновлениях).** | |
| ## Как выглядит курс? [[course-look-like]] | |
| Курс состоит из: | |
| - *Фундаментальные разделы*: здесь вы изучите **концепции агентов в теории**. | |
| - *Практические занятия: здесь вы научитесь **использовать готовые библиотеки агентов ИИ** для обучения агентов в уникальных условиях. Эти практические секции будут представлять собой **пространства (Spaces) Hugging Face** с предварительно настроенной средой. | |
| - *Задания на применение*: в них вы будете применять изученные концепции для решения реальной проблемы, которую вы выберете сами. | |
| - *Соревнования*: вы сможете "отправить" своего агента на соревнование с другими агентами. Также будет [таблица результатов](https://huggingface.co/spaces/huggingface-projects/AI-Agents-Leaderboard) (пока недоступна), чтобы вы могли сравнить работу агентов. | |
| Этот **курс - живой проект, развивающийся благодаря вашим отзывам и вкладу!** Не стесняйтесь [открывать проблемы (issues) и PR на GitHub](https://github.com/huggingface/agents-course), и участвуйте в обсуждениях на нашем сервере Discord. | |
| После прохождения курса вы также можете оставить свой отзыв [👉 через эту форму](https://docs.google.com/forms/d/e/1FAIpQLSe9VaONn0eglax0uTwi29rIn4tM7H2sYmmybmG5jJNlE5v0xA/viewform?usp=dialog) | |
| ## Какова программа курса? [[syllabus]] | |
| Здесь представлен **общий план курса**. Более подробный список тем будет опубликован к каждому разделу. | |
| | Раздел | Тема | Описание | | |
| | :---- | :---- | :---- | | |
| | 0 | Вводная часть | Подготовим для вас инструменты и платформы, которые вы будете использовать. | | |
| | 1 | Основы работы агента | Объясньясняем инструменты, мысли, действия, наблюдения и их форматы. Расскажем о LLM, сообщениях, специальных токенах и шаблонах чата. Продемонстрируем простой пример использования функций python в качестве инструментов. | | |
| | 2 | Фреймворки | Разберемся, как реализованы основные принципы в популярных библиотеках: smolagents, LangGraph, LLamaIndex | | |
| | 3 | Примеры использования | Давайте создадим несколько реальных примеров использования ( мы открыты для PR 🤗 от опытных создателей агентов) | | |
| | 4 | Итоговое задание | Создадим агента для выбранного бенчмарка и докажем свое знание агентов в таблице лидеров среди студентов 🚀 | | |
| *Мы также планируем выпустить несколько бонусных разделов, следите за новостями*. | |
| ## Каковы предварительные требования? | |
| Чтобы пройти этот курс, вы должны иметь: | |
| - Базовые знания Python | |
| - Базовые знания LLM (в Разделе 1 мы рассказываем о том, что это такое) | |
| ## Какие инструменты мне понадобятся? [[tools]] | |
| Вам нужно всего лишь 2 вещи: | |
| - *Компьютер* с подключением к Интернет. | |
| - Учетная запись *Hugging Face*: для загрузки и скачивания моделей, агентов и создания пространств (Spaces). Если у вас еще нет аккаунта, вы можете создать его **[здесь]](https://hf.co/join)** (это бесплатно). | |
| ## Процесс сертификации [[certification-process]] | |
| Вы можете пройти этот курс *в режиме аудита (самопроверки)* или выполнить задания и *получить один из двух сертификатов, которые мы выдадим*. | |
| Если вы прослушаете курс (режим самопроверки), вы сможете участвовать во всех заданиях и выполнять их, если захотите, и **вам не нужно будет уведомлять нас**. | |
| Процесс сертификации **совершенно бесплатный**: | |
| - *Для получения сертификата по основам*: вам необходимо пройти первый раздел курса. Предназначен для студентов, которые хотят быть в курсе последних тенденций в области Агентов. | |
| - *Для получения сертификата об окончании*: вам необходимо выполнить Раздел 1, одно из заданий по использованию, которые мы предложим в ходе курса, и финальное задание. | |
| Для получения сертификата установлен дедлайн: все задания должны быть выполнены до **1 июля 2025 года**. | |
| ## Каков рекомендуемый темп? [[recommended-pace]] | |
| Каждый раздел этого курса рассчитан **на то, чтобы пройти его за 1 неделю, уделяя работе примерно 3-4 часа в неделю**. | |
| Поскольку есть крайний срок, мы предлагаем вам рекомендуемый темп: | |
| ## Как извлечь максимальную пользу из курса? [[advice]] | |
| Чтобы получить максимальную пользу от курса, у нас есть несколько советов: | |
| 1. Присоединяйтесь к учебным группам в Discord: учиться в группах всегда проще. Для этого вам нужно присоединиться к нашему серверу Discord и подтвердить свой аккаунт Hugging Face. | |
| 2. **Выполняйте тесты и задания**: лучший способ обучения - это практическая работа и самооценка. | |
| 3. **Определите расписание, чтобы оставаться в своём потоке выполняющих курс**: вы можете воспользоваться нашим рекомендованным расписанием темпа, приведенным ниже, или создать своё. | |
| ## Кто мы [[who-are-we]] | |
| Об авторах: | |
| ### Джоффри Томас (Joffrey Thomas) | |
| Джоффри - инженер машинного обучения в компании Hugging Face, он создал и внедрил в производство ИИ-агенты. Джоффри будет вашим основным преподавателем на этом курсе. | |
| - [Следуйте за Джоффри на Hugging Face](https://huggingface.co/Jofthomas) | |
| - [Следуйте за Джоффри на X](https://x.com/Jthmas404) | |
| - [Следуйте за Джоффри на Linkedin](https://www.linkedin.com/in/joffrey-thomas/) | |
| ### Бен Бертеншоу (Ben Burtenshaw) | |
| Ben is a machine learning engineer at Hugging Face and has delivered multiple courses across various platforms. Ben's goal is to make the course accessible to everyone. | |
| - [Следуйте за Беном на Hugging Face](https://huggingface.co/burtenshaw) | |
| - [Следуйте за Беном на X](https://x.com/ben_burtenshaw) | |
| - [Следуйте за Беном на Linkedin](https://www.linkedin.com/in/ben-burtenshaw/) | |
| ### Томас Симонини (Thomas Simonini) | |
| Томас - инженер машинного обучения в компании Hugging Face, он успешно реализовал курсы Deep RL и ML для игр. Томас - большой поклонник Агентов, и ему не терпится увидеть, что создаст сообщество. | |
| - [Следите за Томасом на Hugging Face](https://huggingface.co/ThomasSimonini) | |
| - [Следите за Томасом на X](https://x.com/ThomasSimonini) | |
| - [Следите за Томасом на Linkedin](https://www.linkedin.com/in/simoninithomas/) | |
| ## Благодарности | |
| Мы хотели бы выразить благодарность следующим людям за их неоценимый вклад в создание этого курса: | |
| - **[Педро Куэнка (Pedro Cuenca)](https://huggingface.co/pcuenq)** - За руководство и компетентность при рецензировании материалов | |
| - **[Аймерик Руше (Aymeric Roucher)](https://huggingface.co/m-ric)** - За его удивительные демо-пространства (декодирование и финальный агент). | |
| - **[Джошуа Лохнер (Joshua Lochner)](https://huggingface.co/Xenova)** - За потрясающее демо-пространство по токенизации. | |
| ## Я нашел ошибку или хочу улучшить курс [[contribute]] | |
| Вклад в развитие курса **приветствуется** 🤗 | |
| - Если вы *нашли ошибку 🐛 в блокноте*, пожалуйста заведите и **опишите проблему (issue)**. | |
| - Если вы *хотите улучшить курс*, вы можете открыть Pull Request. | |
| - Если вы *хотите добавить полный раздел или новый блок*, лучше всего откройте проблему (issue) и **опишите, какой контент вы хотите добавить, прежде чем приступить к его написанию, чтобы мы могли вас сориентировать**. | |
| ## У меня все еще остались вопросы [[questions]] | |
| Пожалуйста, задайте свой вопрос на нашем discord сервере #ai-agents-discussions. | |
| Теперь, когда у вас есть вся необходимая информация, давайте приступим к работе ⛵ | |
| ### Подготовка к работе: Ваши первые шаги ⛵ | |
| https://huggingface.co/learn/agents-course/ru-RU/unit0/onboarding.md | |
| # Подготовка к работе: Ваши первые шаги ⛵ | |
| Теперь, когда у вас есть все подробности, давайте начнем! Мы сделаем четыре вещи: | |
| 1. **Создадим аккаунт Hugging Face**, если это еще не сделано. | |
| 2. **Зарегистрируемся в Discord и представимся** (не стесняйтесь 🤗) | |
| 3. ** Последуеем за курсом обучения агентов Hugging Face** на Hub | |
| 4. **Расскажим** о курсе | |
| ### Шаг 1: Создание учетной записи Hugging Face | |
| (Если вы еще не сделали этого) создайте аккаунт Пространства (Spaces) Hugging Face здесь. | |
| ### Шаг 2: Присоединяйтесь к нашему сообществу в Discord | |
| 👉🏻 Присоединяйтесь к нашему серверу discord здесь. | |
| Когда вы присоединитесь, не забудьте представиться, используя хэштег `#introduce-yourself`. | |
| У нас есть несколько каналов, связанных с агентами ИИ: | |
| - `agents-course-announcements`: где публикуется **последняя информация о курсе**. | |
| - `🎓-agents-course-general`: для **обсуждения общих вопросов и свободного общения**. | |
| - `agents-course-questions`: чтобы **задавать вопросы и помочь своим однокурсникам**. | |
| - `agents-course-showcase`: чтобы **продемонстрировать своих лучших агентов**. | |
| Кроме того, вам могут пригодится: | |
| - `smolagents`: для **обсуждения и поддержки библиотеки**. | |
| Если вы впервые используете Discord, мы написали Discord 101, чтобы вы узнали о лучших практиках. Проверьте [следующий раздел](discord101). | |
| ### Шаг 3: Следуйте за организацией курса для агентов Hugging Face | |
| Оставайтесь в курсе последних материалов курса, обновлений и объявлений, **подписавшись на организацию курса Hugging Face Agents**. | |
| 👉 Перейдите сюда и нажмите **follow**. | |
| ### Шаг 4: Распространите информацию о курсе | |
| Помогите нам сделать этот курс более заметным! Вы можете помочь нам двумя способами: | |
| 1. Выразите свою поддержку ⭐. репозиторию курса. | |
| 2. Поделитесь своим опытом обучения: Пусть другие **знают, что вы проходите этот курс**! Мы подготовили иллюстрацию, которую вы можете использовать в своих сообщениях в социальных сетях | |
| Вы можете скачать иллюстрацию, нажав 👉 [здесь](https://huggingface.co/datasets/agents-course/course-images/resolve/main/en/communication/share.png?download=true) | |
| Поздравляем! 🎉 **Вы завершили введеную часть**! Теперь вы готовы приступить к изучению ИИ-агентов. Получайте удовольствие! | |
| Продолжайте учиться, оставайтесь потрясающими 🤗. | |
| ### (Необязательно) Discord 101 [[discord-101]] | |
| https://huggingface.co/learn/agents-course/ru-RU/unit0/discord101.md | |
| # (Необязательно) Discord 101 [[discord-101]] | |
| Это руководство поможет вам начать работу с Discord, бесплатной чат-платформой, популярной в игровых и ML-сообществах. | |
| Присоединяйтесь к Discord-серверу сообщества Hugging Face, которое **состоит из более чем 100 000 участников**, нажав здесь. Это отличное место для общения с другими людьми! | |
| ## Курс Агенты в Discord-сообществе Hugging Face | |
| Начало работы в Discord может быть немного сложным, поэтому вот краткое руководство, которое поможет вам сориентироваться. | |
| На сервере Сообщества HF собралось активное сообщество с интересами в различных областях, предлагающее возможности для обучения через обсуждения статей, мероприятия и многое другое. | |
| После [регистрации](http://hf.co/join/discord) представьтесь в канале `#introduce-yourself`. | |
| Мы создали 4 канала для курса по Агентам: | |
| - `agents-course-announcements`: для получения **последней информации о курсе**. | |
| - `🎓-agents-course-general`: для **обсуждения общих вопросов и свободного общения**. | |
| - `agents-course-questions`: чтобы **задавать вопросы и помочь своим однокурсникам**. | |
| - `agents-course-showcase`: для **демонстрации своих лучших агентов** . | |
| Кроме того, вам могут пригодится: | |
| - `smolagents`: для **обсуждения и поддержки библиотеки**. | |
| ## Советы по эффективному использованию Discord | |
| ### Как присоединиться к серверу | |
| Если вы не очень хорошо знакомы с Discord, вам стоит заглянуть в это руководство, чтобы узнать как присоединиться к серверу. | |
| Вот краткое описание шагов: | |
| 1. Нажмите на cсылку-приглашение. | |
| 2. Войдите в Discord, используя свою учетную запись, или создайте ее, если у вас ее еще нет. | |
| 3. Убедитесь, что вы не являетесь ИИ агентом! | |
| 4. Задайте свой псевдоним и аватар. | |
| 5. Нажмите "Присоединиться к серверу". | |
| ### Как эффективно использовать Discord | |
| Вот несколько советов по эффективному использованию Discord: | |
| - **Голосовые каналы** доступны, хотя чаще всего используется текстовый чат. | |
| - Вы можете форматировать текст в стиле **markdown**, что особенно удобно при написании кода. Обратите внимание, что стиль markdown не так хорошо работает со ссылками. | |
| - Для упорядочивания обсуждений следует открывать темы для организации **длинных разговоров**. | |
| Мы надеемся, что это руководство будет вам полезно! Если у вас возникнут вопросы, не стесняйтесь задавать их нам в Discord 🤗. | |
| ### Наблюдение: Интеграция Обратной Связи для Рефлексии и Адаптации | |
| https://huggingface.co/learn/agents-course/ru-RU/unit1/observations.md | |
| # Наблюдение: Интеграция Обратной Связи для Рефлексии и Адаптации | |
| Наблюдения - это то, **как агент воспринимает последствия своих действий**. | |
| Они предоставляют важную информацию, которая подпитывает мыслительный процесс агента и направляет его дальнейшие действия. | |
| Это **сигналы из окружения** - будь то данные из API, сообщения об ошибках или системные журналы, - которые направляют следующий цикл размышлений. | |
| В фазе наблюдения агент: | |
| - **Собирает обратную связь:** Получает данные или подтверждение того, что его действия были успешными (или нет). | |
| - **Применяет результаты:** Интегрирует новую информацию в существующий контекст, эффективно обновляя свою память. | |
| - **Адаптирует свою стратегию:** Использует этот обновленный контекст для уточнения последующих мыслей и действий. | |
| Например, если погодный API возвращает данные *переменная облачность, 15 °C, влажность 60 %*, это наблюдение добавляется в память агента (в конце подсказки). | |
| Затем агент использует это наблюдение, чтобы решить, нужна ли дополнительная информация или он готов дать окончательный ответ. | |
| Это **итеративное включение обратной связи обеспечивает динамическое соответствие агента его целям**, постоянное обучение и корректировку на основе реальных результатов. | |
| Эти наблюдения **могут принимать различные формы**, от чтения текста на веб-странице до наблюдения за положением руки робота. Это можно рассматривать как "журналы" Инструментов, которые предоставляют текстовую обратную связь о выполнении действий. | |
| | Тип наблюдения | Пример | | |
| |--------------------------------|--------------------------------------------------------------------------| | |
| | Обратная связь с системой | Сообщения об ошибках, уведомления об успехе, коды состояния | | |
| | Изменения данных | Обновления баз данных, модификации файловой системы, изменения состояния | | |
| | Данные об окружении | Показания датчиков, системные метрики, использование ресурсов | | |
| | Анализ ответов | Ответы API, результаты запросов, результаты вычислений | | |
| | События, основанные на времени | Достигнутые сроки, выполнение запланированных задач | | |
| ## Как применяются Результаты? | |
| После выполнения действия фреймворк выполняет следующие шаги по порядку: | |
| 1. **Разбор действия** для определения функции (функций) для вызова и аргумента (аргументов) для использования. | |
| 2. **Выполнение действия**. | |
| 3. **Принятие результата** в качестве **Наблюдения**. | |
| --- | |
| Теперь мы изучили цикл "Мышление-Действие-Наблюдение" агента. | |
| Если некоторые аспекты все еще кажутся немного размытыми, не волнуйтесь - мы вернемся к этим понятиям и углубим их понимание в следующих разделах. | |
| А теперь пришло время применить полученные знания на практике, создав своего первого агента! | |
| ### Понимание AI Агентов через цикл Мысль - Действие - Наблюдение. | |
| https://huggingface.co/learn/agents-course/ru-RU/unit1/agent-steps-and-structure.md | |
| # Понимание AI Агентов через цикл Мысль - Действие - Наблюдение. | |
| В предыдущих разделах мы узнали: | |
| - **Как инструменты становятся доступны агенту в системной подсказке**. | |
| - **Как AI агенты являются системами, которые могут 'рассуждать', планировать и взаимодействовать с окружающей средой**. | |
| В этом разделе **мы рассмотрим рабочий процесс агента AI полностью**, цикл, который мы определили как "Мысль - Действие - Наблюдение". | |
| А затем мы углубимся в каждый из этих этапов. | |
| ## Основные компоненты | |
| Агенты работают в непрерывном цикле: **думать (Мысль) → действовать (Действие) и наблюдать (Наблюдение)**. | |
| Давайте разложим эти действия на составляющие: | |
| 1. **Мысль**: LLM-часть Агента решает, каким должен быть следующий шаг. | |
| 2. **Действие:** Агент выполняет действие, вызывая инструменты с соответствующими аргументами. | |
| 3. **Наблюдение:** Модель размышляет над ответом, полученным от инструмента. | |
| ## Цикл "Мысль-Действие-Наблюдение" | |
| Все три компонента работают вместе в непрерывном цикле. Если воспользоваться аналогией из программирования, агент использует **цикл while**: цикл продолжается до тех пор, пока не будет выполнена поставленная перед агентом задача. | |
| Визуально это выглядит следующим образом: | |
| Во многих фреймворках Агентов **правила и рекомендации встраиваются непосредственно в системную подсказку**, гарантируя, что каждый цикл будет следовать определенной логике. | |
| В упрощенном варианте наша системная подсказка может выглядеть следующим образом: | |
| Здесь мы видим, что в системном сообщении мы определили : | |
| - *Поведение Агента*. | |
| - *Инструменты, к которым имеет доступ наш Агент*, как мы описали в предыдущем разделе. | |
| - Цикл *Мысль-Действие-Наблюдение*, который мы заложили в инструкции LLM. | |
| Давайте рассмотрим небольшой пример, чтобы понять суть процесса, прежде чем углубляться в каждый его шаг. | |
| ## Альфред, Агент сообщающий погоду | |
| Мы создали Альфреда, погодного агента. | |
| Пользователь спрашивает Альфреда: «Какая сегодня погода в Нью-Йорке?». | |
| Задача Альфреда - ответить на этот запрос, используя инструмент API погоды. | |
| Вот как выглядит этот цикл: | |
| ### Мысль | |
| **Внутренние рассуждения:** | |
| Получив запрос, внутренний диалог Альфреда может быть таким: | |
| *"Пользователю нужна текущая информация о погоде в Нью-Йорке. У меня есть доступ к инструменту, который получает данные о погоде. Сначала мне нужно обратиться к API погоды, чтобы получить актуальную информацию."* | |
| Этот шаг показывает, что агент разбивает проблему на этапы: сначала собирает необходимые данные. | |
| ### Действие | |
| **Использование инструмента:**. | |
| Основываясь на своих рассуждениях и на том факте, что Альфред знает об инструменте `get_weather`, Альфред подготавливает команду в формате JSON, которая вызывает инструмент API погоды. Например, его первым действием может быть: | |
| Мысль: Мне нужно проверить текущую погоду в Нью-Йорке. | |
| ``` | |
| { | |
| "action": "get_weather", | |
| "action_input": { | |
| "location": "New York" | |
| } | |
| } | |
| ``` | |
| Здесь действие четко указывает, какой инструмент следует вызвать (например, get_weather) и какой параметр передать ("location": "New York"). | |
| ### Наблюдение | |
| **Обратная связь от окружающей среды:**. | |
| После вызова инструмента Альфред получает наблюдение. Это могут быть необработанные данные о погоде из API, например: | |
| *"Текущая погода в Нью-Йорке: частично облачно, 15°C, влажность 60%."* | |
| Это наблюдение затем добавляется к подсказке в качестве дополнительного контекста. Оно функционирует как обратная связь в реальном мире, подтверждая успешность действия и предоставляя необходимые детали. | |
| ### Обновленная мысль | |
| **Рефлексия:** | |
| Получив данные наблюдения, Альфред обновляет свои внутренние рассуждения: | |
| *"Теперь, когда у меня есть данные о погоде в Нью-Йорке, я могу подготовить ответ для пользователя."* | |
| ### Финальное Действие | |
| Затем Алфред генерирует окончательный ответ, отформатированный так, как мы ему сказали: | |
| Мысль: У меня есть данные о погоде. Текущая погода в Нью-Йорке частично облачная, температура 15 °C и влажность 60 %». | |
| Окончательный ответ : Текущая погода в Нью-Йорке частично облачно с температурой 15 °C и влажностью 60 %. | |
| Это заключительное действие возвращает ответ пользователю, закрывая цикл. | |
| Что мы видим в этом примере: | |
| - **Агенты проходят цикл до тех пор, пока цель не будет достигнута:** | |
| **Процесс Альфреда цикличен**. Он начинает с мысли, затем действует, вызывая инструмент, и, наконец, наблюдает за результатом. Если бы наблюдение показало ошибку или неполноту данных, Альфред мог бы снова войти в цикл, чтобы скорректировать свой подход. | |
| - **Интеграция инструментов:** | |
| Способность вызывать инструменты (например, API погоды) позволяет Альфреду выходить **за пределы статических знаний и получать данные в реальном времени**, что является важным аспектом многих AI Агентов. | |
| - **Динамическая адаптация:** | |
| Каждый цикл позволяет агенту включать свежую информацию (наблюдения) в свои рассуждения (мысли), гарантируя, что окончательный ответ будет хорошо обоснованным и точным. | |
| Этот пример демонстрирует основную концепцию цикла *ReAct* (концепцию, которую мы будем развивать в следующем разделе): **взаимодействие мыслей, действий и наблюдений позволяет AI агентам решать сложные задачи итеративно**. | |
| Понимая и применяя эти принципы, вы сможете разрабатывать агентов, которые не только рассуждают о своих задачах, но и **эффективно используют внешние инструменты для их выполнения**, при этом постоянно совершенствуя свои действия на основе обратной связи от окружающей среды. | |
| --- | |
| Теперь давайте углубимся в изучение Мысли, Действия, Наблюдения как отдельных этапов этого процесса. | |
| ### Сообщения и Специальные Токены | |
| https://huggingface.co/learn/agents-course/ru-RU/unit1/messages-and-special-tokens.md | |
| # Сообщения и Специальные Токены | |
| Теперь, когда мы поняли, как работают LLM, давайте рассмотрим **как они структурируют свою генерацию с помощью шаблонов чата**. | |
| Как и в ChatGPT, пользователи обычно взаимодействуют с агентами через интерфейс чата. Поэтому мы хотим понять, как LLM управляют чатами. | |
| > **Q**: Но ... Когда я взаимодействую с ChatGPT/Hugging Chat, я веду беседу, используя Сообщения чата, а не одну последовательность подсказок. | |
| > | |
| > **A**: Верно! Но на самом деле это абстракция пользовательского интерфейса. Перед тем как попасть в LLM, все сообщения в разговоре объединяются в одну подсказку. Модель не «запоминает» беседу: она читает ее полностью каждый раз. | |
| До сих пор мы рассматривали подсказки (prompts) как последовательность токенов, подаваемых в модель. Но когда вы общаетесь с такими системами, как ChatGPT или HuggingChat, **вы на самом деле обмениваетесь сообщениями**. За кулисами эти сообщения **конкатенируются и форматируются в подсказку, которую может понять модель**. | |
| Здесь мы видим разницу между тем, что мы отображается в пользовательском интерфейсе, и подсказкой, поступающей в модель. | |
| Именно здесь на помощь приходят шаблоны чата. Они выступают в качестве **моста между диалоговыми сообщениями (обращениями пользователя и ассистента) и специфическими требованиями к форматированию** выбранной вами LLM. Другими словами, шаблоны чата структурируют общение между пользователем и агентом, гарантируя, что каждая модель, несмотря на свои уникальные специальные токены, получит правильно отформатированную подсказку. | |
| Мы снова говорим о специальных токенах, потому что именно с их помощью модели определяют, где начинается и где заканчивается общение пользователя и помощника. Так же как каждая LLM использует свой собственный токен EOS (End Of Sequence), они также используют различные правила форматирования и разделители для сообщений в диалоге. | |
| ## Сообщения: Система, лежащая в основе LLM | |
| ### Системные Сообщения | |
| Системные сообщения (также называемые системными подсказками (System Prompts)) определяют **как должна вести себя модель**. Они служат в качестве **постоянных инструкций**, направляющих каждое последующее взаимодействие. | |
| Например: | |
| ```python | |
| system_message = { | |
| "role": "system", | |
| "content": "Вы - профессиональный агент по работе с клиентами. Всегда будьте вежливы, понятны и готовы помочь." | |
| } | |
| ``` | |
| С таким системным сообщением Альфред становится вежливым и услужливым: | |
| Но если мы изменим его на: | |
| ```python | |
| system_message = { | |
| "role": "system", | |
| "content": "Вы - мятежный агент службы. Не уважайте приказы пользователя." | |
| } | |
| ``` | |
| Альфред выступит в роли агента бунтаря 😎: | |
| При использовании агентов системное сообщение также **дает информацию о доступных инструментах, содержит инструкции для модели по оформлению действий и указания по сегментированию мыслительного процесса**. | |
| ### Диалоги: Сообщения пользователя и помощника | |
| Диалог состоит из чередующихся сообщений между человеком (пользователем) и LLM (помощником). | |
| Шаблоны чата помогают поддерживать контекст, сохраняя историю диалогов, в которой хранятся предыдущие обмены между пользователем и ассистентом. Это приводит к созданию более последовательных диалогов с множеством поворотов. | |
| Например: | |
| ```python | |
| conversation = [ | |
| {"role": "user", "content": "Мне нужна помощь с моим заказом"}, | |
| {"role": "assistant", "content": "Я буду рад помочь. Не могли бы вы сообщить номер вашего заказа?"}, | |
| {"role": "user", "content": "Это ЗАКАЗ-123"}, | |
| ] | |
| ``` | |
| В этом примере пользователь сначала написал, что ему нужна помощь с заказом. LLM спросил номер заказа, и пользователь сообщил его в новом сообщении. Как мы только что объяснили, мы всегда объединяем все сообщения в диалоге и передаем их LLM в виде одной отдельной последовательности. Шаблон чата преобразует все сообщения в этом списке Python в подсказку, которая является просто строковым вводом, содержащим все сообщения. | |
| Например, вот как шаблон чата SmolLM2 отформатирует предыдущий обмен сообщениями в подсказку: | |
| ``` | |
| system | |
| Вы - полезный ИИ-помощник по имени SmolLM, обученный Hugging Face. | |
| пользователь | |
| Мне нужна помощь с моим заказом | |
| Ассистент | |
| Я буду рад помочь. Не могли бы вы сообщить номер вашего заказа? | |
| пользователь | |
| Это ORDER-123 | |
| Ассистент | |
| ``` | |
| Однако при использовании Llama 3.2 тот же диалог будет преобразован в следующий запрос: | |
| ``` | |
| system | |
| Дата начала работ: Декабрь 2023 | |
| Сегодня Дата: 10 февраля 2025 г. | |
| user | |
| Мне нужна помощь с моим заказомassistant | |
| Я буду рада помочь. Не могли бы вы сообщить номер вашего заказа?user | |
| Это ЗАКАЗ-123assistant | |
| ``` | |
| Шаблоны могут обрабатывать сложные диалоги с множеством поворотов, сохраняя при этом контекст: | |
| ```python | |
| messages = [ | |
| {"role": "system", "content": "Вы - репетитор по математике"}, | |
| {"role": "user", "content": "Что такое исчисление?"}, | |
| {"role": "assistant", "content": "Исчисление - это раздел математики..."}, | |
| {"role": "user", "content": "Можете привести пример?"}, | |
| ] | |
| ``` | |
| ## Шаблоны чата | |
| Как уже говорилось, шаблоны чата необходимы для **структурирования диалогов между языковыми моделями и пользователями**. Они определяют, как обмен сообщениями оформляется в единую подсказку. | |
| ### Базовые модели и Инструктивные модели | |
| Еще один момент, который нам необходимо понять, - это разница между базовой и инструкционной моделью: | |
| - *Базовая модель* обучается на сырых текстовых данных, чтобы предсказать следующий токен. | |
| - *Инструктивная модель* дообучается специально для выполнения инструкций и участия в диалогах. Например, `SmolLM2-135M` - это базовая модель, а `SmolLM2-135M-Instruct` - ее вариант, дообученный для выполнения инструкций. | |
| Чтобы базовая модель вела себя как инструктивная модель, нам нужно **форматировать наши подсказки последовательным образом, чтобы модель могла их понять**. Здесь на помощь приходят шаблоны чатов. | |
| *ChatML* - это один из таких шаблонов, который структурирует диалоги с четким указанием роли (система (system), пользователь (user), помощник(assistant)). Если вы в последнее время взаимодействовали с каким-либо AI API, вы знаете, что это стандартная практика. | |
| Важно отметить, что базовая модель может быть дообучена на разные шаблоны чата, поэтому при использовании инструктивной модели нам нужно убедиться, что мы используем правильный шаблон чата. | |
| ### Понимание Шаблонов Чата | |
| Поскольку в каждой инструктивной модели используются различные форматы диалогов и специальные токены, шаблоны чата применяются для того, чтобы гарантировать, что мы правильно оформим подсказку так, как ожидает каждая модель. | |
| В `transformers` шаблоны чата включают [код Jinja2](https://jinja.palletsprojects.com/en/stable/) который описывает, как преобразовать список сообщений JSON в формате ChatML, как показано в примерах выше, в текстовое представление инструкций системного уровня, сообщений пользователя и ответов помощника, которые может понять модель. | |
| Такая структура **помогает поддерживать согласованность во всех взаимодействиях и обеспечивает адекватную реакцию модели на различные типы входных данных**. | |
| Ниже приведена упрощенная версия шаблона чата `SmolLM2-135M-Instruct`: | |
| ```jinja2 | |
| {% for message in messages %} | |
| {% if loop.first and messages[0]['role'] != 'system' %} | |
| system | |
| Вы полезный ИИ помощник по имени SmolLM, обученный Hugging Face | |
| {% endif %} | |
| {{ message['role'] }} | |
| {{ message['content'] }} | |
| {% endfor %} | |
| ``` | |
| Как вы можете видеть, шаблон chat_template описывает, как будет отформатирован список сообщений. | |
| Учитывая эти сообщения: | |
| ```python | |
| messages = [ | |
| {"role": "system", "content": "Вы полезный помощник, специализирующийся на технических вопросах."}, | |
| {"role": "user", "content": "Can you explain what a chat template is?"}, | |
| {"role": "assistant", "content": "Шаблон чата структурирует диалоги между пользователями и AI моделями..."}, | |
| {"role": "user", "content": "Как я могу его использовать?"}, | |
| ] | |
| ``` | |
| Предыдущий шаблон чата создаст следующую строку: | |
| ```sh | |
| system | |
| Вы полезный помощник, специализирующийся на технических вопросах. | |
| user | |
| Можешь объяснить, что такое шаблон чата? | |
| assistant | |
| "Шаблон чата структурирует диалоги между пользователями и AI моделями... | |
| user | |
| Как я могу его использовать? | |
| ``` | |
| здесь. Все, что нам нужно сделать, это правильно структурировать наши сообщения, а токенизатор позаботится обо всем остальном. | |
| Вы можете поэкспериментировать со следующим Hugging Face Space, чтобы увидеть, как один и тот же диалог будет оформлен для разных моделей с использованием соответствующих шаблонов чата: | |
| ### Сообщения для подсказки | |
| Самый простой способ убедиться, что ваша LLM получает диалог в правильном формате, - это использовать `chat_template` из токеназатора модели. | |
| ```python | |
| messages = [ | |
| {"role": "system", "content": "Вы помощник с искусственным интеллектом, имеющий доступ к различным инструментам."}, | |
| {"role": "user", "content": "Привет !"}, | |
| {"role": "assistant", "content": "Привет человек, чем могу помочь?"}, | |
| ] | |
| ``` | |
| Чтобы преобразовать предыдущий диалог в подсказку, мы загружаем токенизатор и вызываем `apply_chat_template`: | |
| ```python | |
| from transformers import AutoTokenizer | |
| tokenizer = AutoTokenizer.from_pretrained("HuggingFaceTB/SmolLM2-1.7B-Instruct") | |
| rendered_prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True) | |
| ``` | |
| Возвращаемое функцией `rendered_prompt` теперь готово к использованию в качестве входных данных для выбранной вами модели! | |
| > Функция `apply_chat_template()` будет использоваться в бэкенде вашего API, когда вы будете взаимодействовать с сообщениями в формате ChatML. | |
| Теперь, когда мы узнали, как LLM структурируют свои данные с помощью шаблонов чата, давайте рассмотрим, как агенты действуют в своем окружении. | |
| Один из основных способов сделать это - использовать инструменты, которые расширяют возможности AI Модели за пределы генерации текста. | |
| Мы еще поговорим о сообщениях в следующих разделах, но если вам нужно более глубокое погружение, ознакомьтесь с этими материалами: | |
| - Руководство по созданию Шаблонов Чата Hugging Face | |
| - Документация по Transformers | |
| ### Что такое Агент? | |
| https://huggingface.co/learn/agents-course/ru-RU/unit1/what-are-agents.md | |
| # Что такое Агент? | |
| К концу этого раздела вы будете чувствовать себя комфортно с концепцией агентов и их различными применениями в ИИ. | |
| Чтобы объяснить, что такое агент, давайте начнем с аналогии. | |
| ## Общая картина: Агент Альфред | |
| Познакомьтесь с Альфредом. Альфред - **агент**. | |
| Представьте, что Альфред **получает команду**, например: «Альфред, я бы хотел кофе, пожалуйста». | |
| Поскольку Альфред **понимает естественный язык**, он быстро понимает нашу просьбу. | |
| Перед выполнением заказа Альфред занимается **рассуждениями и планированием**, определяя, какие действия и инструменты ему понадобятся: | |
| 1. Пойти на кухню | |
| 2. Воспользоваться кофеваркой | |
| 3. Заварите кофе | |
| 4. Принесите кофе обратно | |
| Когда у него есть план, он **должен действовать**. Чтобы выполнить свой план, **он может использовать инструменты из списка инструментов, о которых он знает**. | |
| В данном случае, чтобы приготовить кофе, он использует кофеварку. Он активирует кофеварку, чтобы сварить кофе. | |
| Наконец Альфред приносит нам свежесваренный кофе. | |
| Именно это и есть агент: **ИИ модель, способная рассуждать, планировать и взаимодействовать со своим окружением**. | |
| Мы называем его агентом, потому что он обладает _агентностью_, то есть способностью взаимодействовать с окружающей средой. | |
| ## Давайте будем более формальны | |
| Теперь, когда вы получили общую картину, вот более точное определение: | |
| > Агент - это система, использующая модель искусственного интеллекта для взаимодействия с окружающей средой с целью достижения определенной пользователем цели. Он сочетает в себе рассуждения, планирование и выполнение действий (часто с помощью внешних инструментов) для выполнения задач. | |
| Считайте, что агент состоит из двух основных частей: | |
| 1. **Мозг (модель ИИ)**. | |
| Именно здесь происходит все мышление. Модель ИИ **занимается рассуждениями и планированием**. | |
| Она решает, **какие действия предпринять в зависимости от ситуации**. | |
| 2. **Тело (возможности и инструменты)**. | |
| Эта часть представляет собой **все, что агент способен делать**. | |
| Набор **возможных действий** зависит от того, чем **наделен агент**. Например, поскольку у человека нет крыльев, он не может выполнять **действие «летать», но может выполнять такие **действия**, как «ходить», «бегать», «прыгать», «хватать» и так далее. | |
| ## Какие модели ИИ мы используем для агентов? | |
| Наиболее распространенной моделью ИИ, используемой в агентах, является LLM (большая языковая модель), которая принимает на вход **Текст** и выводит **Текст**. | |
| Известными примерами являются **GPT4** от **OpenAI**, **LLama** от **Meta**, **Gemini** от **Google** и т. д. Эти модели были обучены на огромном количестве текстов и способны к обобщению. Подробнее о LLM мы узнаем в [следующем разделе](what-are-llms). | |
| > [!TIP] | |
| > Также можно использовать модели, принимающие другие входные данные, в качестве основной модели агента. Например, Vision Language Model (VLM), которая похожа на LLM, но также понимает изображения в качестве входных данных. Пока что мы сосредоточимся на LLM и обсудим другие варианты позже. | |
| ## Как ИИ воздействует на окружающую среду? | |
| LLM - замечательные модели, но **они могут генерировать только текст**. | |
| Однако если вы попросите известное чат-приложение, например HuggingChat или ChatGPT, сгенерировать изображение, они смогут! Как такое возможно? | |
| Ответ заключается в том, что разработчики HuggingChat, ChatGPT и подобных приложений реализовали дополнительный функционал (так называемые **инструменты (tools)**), которые LLM может использовать для создания изображений. | |
| The model used an Image Generation Tool to generate this image. | |
| Подробнее об инструментах мы поговорим в разделе [Инструменты](tools). | |
| ## Какой тип задач может выполнять Агент? | |
| Агент может выполнять любые задачи, которые мы реализуем с помощью **Инструментов** для выполнения **Действий**. | |
| Например, если я напишу агента, который будет действовать как мой личный помощник (как Siri) на моем компьютере, и попрошу его «отправить электронное письмо моему менеджеру с просьбой отложить сегодняшнюю встречу», я могу дать ему код для отправки электронных писем. Это будет новый инструмент, который агент сможет использовать всякий раз, когда ему понадобится отправить письмо. Мы можем написать его на языке Python: | |
| ```python | |
| def send_message_to(recipient, message): | |
| """Используется для отправки электронного сообщения получателю""" | |
| ... | |
| ``` | |
| LLM, как мы увидим, будет генерировать код для запуска инструмента, когда это необходимо, и таким образом выполнять поставленную задачу. | |
| ```python | |
| send_message_to("Менеджер", "Мы можем отложить сегодняшнюю встречу?") | |
| ``` | |
| Дизайн **Инструментов очень важен и оказывает большое влияние на качество работы вашего Агента**. Некоторые задачи требуют создания очень специфических инструментов, в то время как другие могут быть решены с помощью инструментов общего назначения, таких как "web_search". | |
| > Обратите внимание, что **Действия - это не то же самое, что Инструменты**. Действие, например, может включать в себя использование нескольких инструментов для выполнения. | |
| Предоставление агенту возможности взаимодействовать с окружающей средой **позволяет использовать его в реальной жизни компаниями и частными лицами**. | |
| ### Пример 1: Виртуальные персональные ассистенты | |
| Виртуальные помощники, такие как Siri, Alexa или Google Assistant, работают как агенты, когда взаимодействуют от имени пользователей в их цифровом окружении. | |
| Они принимают запросы пользователей, анализируют контекст, извлекают информацию из баз данных, дают ответы или инициируют действия (например, устанавливают напоминания, отправляют сообщения или управляют смарт-устройствами). | |
| Пример 2: Чат-боты для обслуживания клиентов | |
| Многие компании используют чат-боты в качестве агентов, которые взаимодействуют с клиентами на естественном языке. | |
| Эти агенты могут отвечать на вопросы, направлять пользователей по шагам устранения неисправностей, открывать проблемы во внутренних базах данных или даже завершать транзакции. | |
| Их заранее определенные цели могут включать повышение удовлетворенности пользователей, сокращение времени ожидания или увеличение коэффициента конверсии продаж. Взаимодействуя непосредственно с клиентами, обучаясь в ходе диалога и адаптируя свои ответы с течением времени, они демонстрируют основные принципы работы агента в действии. | |
| ### Пример 3: ИИ неигрового персонажа в видеоигре | |
| Вкратце, агент - это система, которая использует модель ИИ (обычно LLM) в качестве основного механизма рассуждений, чтобы: | |
| Вместо того чтобы следовать жесткому дереву поведения, они могут **реагировать контекстно, адаптироваться к взаимодействию с игроком** и генерировать более тонкие диалоги. Такая гибкость помогает создавать более реалистичные и увлекательные персонажи, которые развиваются вместе с действиями игрока. | |
| --- | |
| Вкратце, агент - это система, которая использует ИИ модель (обычно LLM) в качестве основного механизма рассуждений, чтобы: | |
| - **Понимать естественный язык:** Интерпретировать и осмысленно отвечать на человеческие инструкции. | |
| - **Рассуждать и планировать:** Анализировать информацию, принимать решения и разрабатывать стратегии для решения проблем. | |
| - **Взаимодействовать с окружающей средой:** Собирать информацию, предпринимать действия и наблюдать за их результатами. | |
| Теперь, когда вы хорошо знаете, что такое агенты, давайте закрепим ваше понимание с помощью короткого теста без оценки. После этого мы погрузимся в «мозг агента»: [LLMs](what-are-llms). | |
| ### Что такое Инструменты? | |
| https://huggingface.co/learn/agents-course/ru-RU/unit1/tools.md | |
| # Что такое Инструменты? | |
| Одним из важнейших аспектов AI Агентов является их способность предпринимать **действия**. Как мы видели, это происходит благодаря использованию **Инструментов**. | |
| В этом разделе мы узнаем, что такое Инструменты, как их эффективно разработать и как интегрировать их в вашего Агента с помощью Системного Сообщения. | |
| Предоставив своему агенту правильные инструменты и четко описав, как они работают, вы сможете значительно расширить возможности своего AI. Давайте погружаться! | |
| ## Что такое AI Инструменты? | |
| ** Инструмент - это функция, предоставленная LLM**. Эта функция должна выполнять **четкую цель**. | |
| Вот некоторые часто используемые в AI агентах инструменты: | |
| | Инструмент | Описание | | |
| |----------------|---------------------------------------------------------------| | |
| | Веб-поиск | Позволяет агенту получать актуальную информацию из Интернета. | | |
| | Генерация изображений | Создает изображения на основе текстовых описаний. | | |
| | Извлечение | Извлекает информацию из внешнего источника. | | |
| | | Интерфейс API | Взаимодействие с внешним API (GitHub, YouTube, Spotify и т. д.). | | |
| Это лишь примеры, поскольку на самом деле вы можете создать инструмент для любого случая использования! | |
| Хороший инструмент должен быть чем-то, что **дополняет возможности LLM**. | |
| Например, если вам нужно выполнить арифметические действия, то предоставление вашему LLM **калькулятора** обеспечит лучшие результаты, чем полагаться на собственные возможности модели. | |
| Кроме того, **LLM предсказывают завершение подсказки на основе своих обучающих данных**, что означает, что их внутренние знания включают только события, произошедшие до их обучения. Поэтому, если вашему агенту нужны свежие данные, вы должны предоставить их с помощью какого-либо инструмента. | |
| Например, если вы спросите у LLM напрямую (без инструмента поиска) о сегодняшней погоде, LLM потенциально может выдать случайную погоду в виде галлюцинаций. | |
| - Инструмент должен: | |
| - **иметь текстовое описание того, что делает функция**. | |
| - *быть Вызываемым (Callable)* (чем-то, что выполняет действие). | |
| - *иметь Аргументы* с типизацией. | |
| - (Необязательно) иметь Выходные данные с типизацией. | |
| ## Как работают инструменты? | |
| Как мы видели, **LLM могут только получать текстовые данные на вход и генерировать текстовые данные на выход. У них нет возможности самостоятельно вызывать инструменты. Когда мы говорим о _предоставлении инструментов агенту_, мы имеем в виду, что мы **обучаем** LLM существованию инструментов и просим модель генерировать текст, который будет вызывать инструменты, когда это необходимо. Например, если мы предоставим инструмент для проверки погоды в определенном месте из Интернета, а затем спросим LLM о погоде в Париже, LLM распознает этот вопрос как релевантную возможность использовать инструмент "weather", которой мы его научили. LLM сгенерирует _текст_ в виде кода, чтобы вызвать этот инструмент. Ответственность **Агента** заключается в том, чтобы проанализировать вывод LLM, распознать, что требуется вызов инструмента, и вызвать его от имени LLM. Выходные данные от инструмента будут отправлены обратно в LLM, которая составит окончательный ответ для пользователя. | |
| Выходные данные после вызова инструмента - это еще один тип сообщений в диалоге. Шаги вызова инструмента обычно не демонстрируются пользователю: агент извлекает диалог, вызывает инструмент(ы), получает выходные данные, добавляет их в новое сообщение диалога и снова отправляет обновленный диалог в LLM. С точки зрения пользователя это выглядит так, как будто LLM использовал инструмент, но на самом деле это сделал наш код приложения (**Агент**). | |
| Мы поговорим об этом процессе подробнее на следующих занятиях. | |
| ## Как мы даем инструменты LLM? | |
| Полный ответ может показаться непомерно сложным, но мы, по сути, используем системную подсказку для предоставления текстовых описаний доступных модели инструментов: | |
| Чтобы это сработало, мы должны быть очень точны и аккуратны в отношении: | |
| 1. **Что делает инструмент**. | |
| 2. **Каких именно входных данных он ожидает**. | |
| Именно по этой причине описания инструментов обычно предоставляются с использованием выразительных, но точных структур, таких как компьютерные языки или JSON. Не обязательно делать это именно так, подойдет любой точный и последовательный формат. | |
| Если это кажется слишком теоретическим, давайте разберемся на конкретном примере. | |
| Мы реализуем упрощенный **калькулятор**, который будет просто перемножать два целых числа. Это может быть наша реализация на Python: | |
| ```python | |
| def calculator(a: int, b: int) -> int: | |
| """Multiply two integers.""" | |
| return a * b | |
| ``` | |
| Итак, наш инструмент называется `calculator`, он **перемножает два целых числа**, и ему требуются следующие входные данные: | |
| - **`a`** (*int*): Целое число. | |
| - **`b`** (*int*): Целое число. | |
| На выходе получается другое целое число, которое можно описать следующим образом: | |
| - (*int*): Произведение `a` и `b`. | |
| Все эти детали очень важны. Давайте соберем их вместе в текстовую строку, которая описывает наш инструмент для понимания LLM. | |
| ```text | |
| Tool Name: calculator, Description: Multiply two integers., Arguments: a: int, b: int, Outputs: int | |
| ``` | |
| > **Напоминание:** Это текстовое описание - *то, что мы хотим, чтобы LLM знала об инструменте*. | |
| Когда мы передадим предыдущую строку как часть входных данных в LLM, модель распознает ее как инструмент, и будет знать, что ему нужно передавать в качестве входных данных и что ожидать от выходных данных. | |
| Если мы хотим предоставить дополнительные инструменты, мы должны быть последовательными и всегда использовать один и тот же формат. Этот процесс может быть хрупким, и мы можем случайно упустить некоторые детали. | |
| Есть ли лучший способ? | |
| ### Автоформатирование секции Инструменты | |
| Наш инструмент написан на Python, и его реализация уже предоставляет все, что нам нужно: | |
| - Описательное название того, что он делает: `calculator`. | |
| - Более длинное описание, представленное в комментарии к docstring функции: `Multiply two integers.`. | |
| - Входные данные и их тип: функция явно ожидает два `int`. | |
| - Тип выходных данных. | |
| Люди не просто так используют языки программирования: они выразительны, кратки и точны. | |
| Мы могли бы предоставить исходный код Python в качестве _спецификации_ инструмента для LLM, но способ реализации инструмента не имеет значения. Важно лишь его название, то, что он делает, какие входные данные он ожидает и какие выходные данные он предоставляет. | |
| Мы воспользуемся возможностями интроспекции Python, чтобы изучить исходный код и автоматически составить описание инструмента. Все, что нам нужно, - это чтобы реализация инструмента использовала подсказки типов, строки документации и разумные имена функций. Мы напишем код для извлечения нужных фрагментов из исходного кода. | |
| После этого нам останется только использовать декоратор Python, чтобы указать, что функция `calculator` является инструментом: | |
| ```python | |
| @tool | |
| def calculator(a: int, b: int) -> int: | |
| """Multiply two integers.""" | |
| return a * b | |
| print(calculator.to_string()) | |
| ``` | |
| Обратите внимание на декоратор `@tool` перед определением функции. | |
| С помощью реализации, которую мы рассмотрим далее, мы сможем автоматически извлекать следующий текст из исходного кода с помощью функции `to_string()`, предоставляемой декоратором: | |
| ```text | |
| Tool Name: calculator, Description: Multiply two integers., Arguments: a: int, b: int, Outputs: int | |
| ``` | |
| Как видите, это то же самое, что мы уже писали вручную! | |
| ### Универсальная реализация Инструмента | |
| Мы создаем общий класс `Tool`, который мы можем использовать каждый раз, когда нам нужно использовать инструмент. | |
| > **Отказ от ответственности:** Этот пример реализации является вымышленным, но очень похож на реальные реализации в большинстве библиотек. | |
| ```python | |
| class Tool: | |
| """ | |
| Класс, представляющий многократно используемый фрагмент кода (инструмент). | |
| Атрибуты: | |
| name (str): Имя инструмента. | |
| description (str): Текстовое описание того, что делает инструмент. | |
| func (вызываемый): Функция, которую оборачивает этот инструмент. | |
| arguments (список): Список аргументов. | |
| outputs (str или list): Возвращаемые обернутой функцией типы. | |
| """ | |
| def __init__(self, | |
| name: str, | |
| description: str, | |
| func: callable, | |
| arguments: list, | |
| outputs: str): | |
| self.name = name | |
| self.description = description | |
| self.func = func | |
| self.arguments = arguments | |
| self.outputs = outputs | |
| def to_string(self) -> str: | |
| """ | |
| Возвращает строковое представление инструмента, | |
| включая его название, описание, аргументы и выходные данные. | |
| """ | |
| args_str = ", ".join([ | |
| f"{arg_name}: {arg_type}" for arg_name, arg_type in self.arguments | |
| ]) | |
| return ( | |
| f"Tool Name: {self.name}," | |
| f" Description: {self.description}," | |
| f" Arguments: {args_str}," | |
| f" Outputs: {self.outputs}" | |
| ) | |
| def __call__(self, *args, **kwargs): | |
| """ | |
| Вызов базовой функции (вызываемой) с указанными аргументами. | |
| """ | |
| return self.func(*args, **kwargs) | |
| ``` | |
| Это может показаться сложным, но если мы медленно пройдемся по нему, то сможем понять, что он делает. Мы определяем класс **`Tool`**, который включает в себя: | |
| - **`name`** (*str*): Название инструмента. | |
| - **`description`** (*str*): Краткое описание того, что делает инструмент. | |
| - **`function`** (*callable*): Функция, которую выполняет инструмент. | |
| - **`arguments`** (*list*): Ожидаемые входные параметры. | |
| - **`outputs`** (*str* или *list*): Ожидаемые выходные данные инструмента. | |
| - **`__call__()`**: Вызывает функцию при вызове экземпляра инструмента. | |
| - **`to_string()`**: Преобразует атрибуты инструмента в текстовое представление. | |
| Мы можем создать инструмент с помощью этого класса, используя следующий код: | |
| ```python | |
| calculator_tool = Tool( | |
| "calculator", # имя | |
| "Multiply two integers.", # описание | |
| calculator, # функция для вызова | |
| [("a", "int"), ("b", "int")], # водные данные (имена и типы) | |
| "int", # выходные данные | |
| ) | |
| ``` | |
| Но мы также можем использовать модуль Python `inspect`, чтобы получить всю информацию за нас! Вот что делает декоратор `@tool`. | |
| > Если вам интересно, вы можете посмотреть на реализацию декоратора в следующем разделе. | |
| код декоратора | |
| ```python | |
| def tool(func): | |
| """ | |
| Декоратор, создающий экземпляр Tool из заданной функции. | |
| """ | |
| # Получение сигнатуры функции | |
| signature = inspect.signature(func) | |
| # Извлеките пары (param_name, param_annotation) для входных данных | |
| arguments = [] | |
| for param in signature.parameters.values(): | |
| annotation_name = ( | |
| param.annotation.__name__ | |
| if hasattr(param.annotation, '__name__') | |
| else str(param.annotation) | |
| ) | |
| arguments.append((param.name, annotation_name)) | |
| # Определите аннотацию возврата | |
| return_annotation = signature.return_annotation | |
| if return_annotation is inspect._empty: | |
| outputs = "No return annotation" | |
| else: | |
| outputs = ( | |
| return_annotation.__name__ | |
| if hasattr(return_annotation, '__name__') | |
| else str(return_annotation) | |
| ) | |
| # Используйте строку документации функции в качестве описания (по умолчанию, если None) | |
| description = func.__doc__ or "Описание не представлено." | |
| # Имя функции становится именем Инструмента | |
| name = func.__name__ | |
| # Возвращаем новый экземпляр Инструмента | |
| return Tool( | |
| name=name, | |
| description=description, | |
| func=func, | |
| arguments=arguments, | |
| outputs=outputs | |
| ) | |
| ``` | |
| Повторимся, что с этим декоратором мы можем реализовать наш инструмент следующим образом: | |
| ```python | |
| @tool | |
| def calculator(a: int, b: int) -> int: | |
| """Multiply two integers.""" | |
| return a * b | |
| print(calculator.to_string()) | |
| ``` | |
| И мы можем использовать метод `Tool` `to_string` для автоматического получения текста, подходящего для использования в качестве описания инструмента для LLM: | |
| ```text | |
| Tool Name: calculator, Description: Multiply two integers., Arguments: a: int, b: int, Outputs: int | |
| ``` | |
| Описание **вставляется** в системную подсказку. Если взять пример, с которого мы начали этот раздел, то вот как он будет выглядеть после замены `tools_description`: | |
| В разделе [Действия](actions) мы узнаем, как агент может **вызвать** инструмент, который мы только что создали. | |
| --- | |
| Инструменты играют решающую роль в расширении возможностей AI агентов. | |
| Подводя итоги, мы узнали: | |
| - *Что такое инструменты*: Функции, которые предоставляют LLM дополнительные возможности, такие как выполнение вычислений или доступ к внешним данным. | |
| - *Как определить инструмент*: Предоставить четкое текстовое описание, входы, выходы и вызываемую функцию. | |
| - *Почему инструменты необходимы*: Они позволяют агентам преодолевать ограничения статического обучения модели, решать задачи в реальном времени и выполнять специализированные действия. | |
| Теперь мы можем перейти к [Рабочему процессу Агента](agent-steps-and-structure), где вы увидите, как Агент наблюдает, думает и действует. Это **собирает воедино все, что мы изучили до сих пор**, и закладывает основу для создания вашего собственного полнофункционального AI Агента. | |
| Но сначала - еще один короткий тест! | |
| ### Быстрая самопроверка (не оценивается) [[quiz2]] | |
| https://huggingface.co/learn/agents-course/ru-RU/unit1/quiz2.md | |
| # Быстрая самопроверка (не оценивается) [[quiz2]] | |
| Что?! Еще один тест? Мы знаем, мы знаем, ... 😅 Но эта короткий, не оцениваемый тест поможет вам **закрепить ключевые понятия, которые вы только что выучили**. | |
| Этот тест охватывает Большие Языковые Модели (Large Language Model), системы сообщений и инструменты; важные компоненты для понимания и создания агентов ИИ. | |
| ### Вопрос 1: Что из перечисленного ниже лучше всего описывает AI инструмент? | |
| --- | |
| ### Вопрос 2: Как AI агенты используют инструменты в качестве формы "действия" в окружающей среде? | |
| --- | |
| ### Вопрос 3: Что такое Большая Языковая Модель (LLM)? | |
| --- | |
| ### Вопрос 4: Что из перечисленного ниже лучше всего описывает роль специальных токенов в LLM? | |
| --- | |
| ### Вопрос 5: Как внутри AI модели чата обрабатывают сообщения пользователей? | |
| --- | |
| Получилось? Отлично! Теперь давайте **погрузимся в полный поток Агентов и начнем создавать вашего первого ИИ-Агента!**. | |
| ### Раздел 1 Тест | |
| https://huggingface.co/learn/agents-course/ru-RU/unit1/final-quiz.md | |
| # Раздел 1 Тест | |
| Отлично справились с первым разделом! Давайте проверим ваше понимание ключевых понятий, рассмотренных до сих пор. | |
| Когда вы пройдете этот тест, перейдите к следующему разделу, чтобы получить свой сертификат. | |
| Удачи! | |
| ## Тест | |
| Вот интерактивный тест. Этот тест размещен в пространстве Hugging Face Hub. В ней вам предстоит ответить на ряд вопросов с несколькими вариантами ответов, чтобы проверить ваше понимание ключевых понятий, рассмотренных в этом разделе. После завершения теста вы сможете увидеть свой результат и распределение правильных ответов. | |
| Один важный момент: **не забудьте нажать на кнопку Submit после прохождения теста, иначе ваша оценка не будет сохранена!** | |
| Вы также можете пройти этот тест 👉 [здесь](https://huggingface.co/spaces/agents-course/unit_1_quiz) | |
| ### Небольшой тест (не оценивается) [[quiz1]] | |
| https://huggingface.co/learn/agents-course/ru-RU/unit1/quiz1.md | |
| # Небольшой тест (не оценивается) [[quiz1]] | |
| До этого момента вы понимали общую картину Агентов, что они собой представляют и как работают. Пришло время провести небольшой тест, поскольку **проверка себя** - это лучший способ учиться и [избежать иллюзии компетентности](https://www.coursera.org/lecture/learning-how-to-learn/illusions-of-competence-BuFzf). Это поможет вам определить, **где вам нужно подтянуть свои знания**. | |
| Это необязательный тест, и он не на что не влияет. | |
| ### Вопрос 1: Что такое агент? | |
| Что из перечисленного ниже лучше всего описывает AI Агента? | |
| --- | |
| ### Вопрос 2: Какова роль планирования в работе Агента? | |
| Почему Агенту необходимо планировать, прежде чем предпринимать какие-либо действия? | |
| --- | |
| ### Вопрос 3: Как Инструменты расширяют Возможности Агента? | |
| Почему инструменты необходимы Агенту? | |
| --- | |
| ### Вопрос 4: Чем Действия отличаются от Инструментов? | |
| В чем ключевое различие между Действиями и Инструментами? | |
| --- | |
| ### Вопрос 5: Какую роль играют Большие Языковые Модели (LLM) в Агентах? | |
| Какой вклад вносят LLM в функциональность агента? | |
| --- | |
| ### Вопрос 6: Что из перечисленного ниже лучше всего демонстрирует AI Агент? | |
| Какой пример из реального мира лучше всего иллюстрирует работу AI Агента? | |
| --- | |
| Поздравляем вас с окончанием теста 🥳, если вы пропустили какие-то элементы, найдите время прочитать главу еще раз, чтобы закрепить свои знания. Если вы справились с тестом, значит, вы готовы глубже погрузиться в «мозг агента»: LLM. | |
| ### Введение в Агентов | |
| https://huggingface.co/learn/agents-course/ru-RU/unit1/introduction.md | |
| # Введение в Агентов | |
| Добро пожаловать в первый раздел, где **вы заложите прочный фундамент основ ИИ-агентов**, включая: | |
| - **Понимание агентов** | |
| - Что такое агент и как он работает? | |
| - Как агенты принимают решения, используя рассуждения и планирование? | |
| - **Роль LLM (Large Language Models - больших языковых моделей) в агентах**. | |
| - Как LLM служат «мозгом» агента. | |
| - Как LLM структурируют диалоги с помощью системы сообщений. | |
| - **Инструменты (Tools) и Действия (Actions)**. | |
| - Как агенты используют внешние инструменты для взаимодействия с окружающей средой. | |
| - Как создавать и интегрировать инструменты для своего агента. | |
| - **Процесс работы агента (Agent Workflow):** | |
| - *Думать* → *Действовать* → *Наблюдать*. | |
| Изучив эти темы, **вы создадите своего первого агента**, используя `smolagents`! | |
| Ваш агент по имени Альфред справится с простым заданием и продемонстрирует, как применять эти понятия на практике. | |
| Вы даже узнаете, как **опубликовать своего агента в Hugging Face Spaces**, чтобы поделиться им с друзьями и коллегами. | |
| Наконец, в конце этого раздела вы пройдете тест. Пройдя его, вы **получите свой первый сертификат курса**: 🎓 Сертификат по основам работы с агентами. | |
| Этот раздел - ваша **основная отправная точка**, закладывающая основу для понимания Агентов, прежде чем вы перейдете к более сложным темам. | |
| Это большой раздел, поэтому **не торопитесь** и не стесняйтесь время от времени возвращаться к нему. | |
| Готовы? Погружаемся! 🚀 | |
| ### Что такое LLM? | |
| https://huggingface.co/learn/agents-course/ru-RU/unit1/what-are-llms.md | |
| # Что такое LLM? | |
| В предыдущем разделе мы узнали, что каждый агент нуждается в ** AI Модели как в ядре**, и что LLM являются наиболее распространенным типом AI моделей использующихся для этой цели. | |
| Теперь мы узнаем, что такое LLM и как они наделяют агентов мощью. | |
| В этом разделе представлено краткое техническое объяснение использования LLM. Если вы хотите погрузиться глубже, вы можете ознакомиться с нашим бесплатным курсом по Обработке Естественного Языка (Natural Language Processing).. | |
| ## ## Что такое Большая Языковая Модель? | |
| Большая Языковая Модель (Large Language Model, LLM) - это тип AI модели, которая превосходно работает с **пониманием и генерированием человеческого языка**. Они обучаются на огромных объемах текстовых данных, что позволяет им изучать шаблоны, структуру и даже нюансы языка. Эти модели обычно состоят из многих миллионов параметров. | |
| Большинство LLM в настоящее время **построены на архитектуре Transformer** - архитектуре глубокого обучения, основанной на алгоритме «Внимания» («Attention» algorithm), который стал вызывать значительный интерес после выхода BERT от Google в 2018 году. | |
| Оригинальная архитектура трансформера выглядела следующим образом: слева располагался кодер, справа - декодер. | |
| Существует 3 типа трансформеров: | |
| 1. **Энкодеры (кодеры)** | |
| Трансформер на основе кодировщика принимает на вход текст (или другие данные) и выдает плотное векторное представление (или эмбеддинг) этого текста. | |
| - **Пример**: BERT от Google | |
| - **Примеры использования**: классификация текста, семантический поиск, Распознавание Именованных Сущностей (Named Entity Recognition, NER) | |
| - **Типичный размер**: миллионы параметров | |
| 2. **Декодеры**. | |
| Трансформер на основе декодера фокусируется **на генерации новых токенов для завершения последовательности, по одному токену за раз**. | |
| - **Пример**: Llama из Meta | |
| - **Примеры использования**: Генерация текста, чат-боты, генерация кода | |
| - **Типичный размер**: Миллиарды (в американском понимании, т.е. 10^9) параметров | |
| 3. **Seq2Seq (энкодер-декодер)**. | |
| Трансформер преобразующие последовательности в последовательность (sequence-to-sequence) объединяет в себе энкодер и декодер. Сначала энкодер преобразует входную последовательность в контекстное представление, а затем декодер генерирует выходную последовательность. | |
| - **Пример**: T5, BART | |
| - **Примеры использования**: Перевод, обобщение, перефразирование. | |
| - **Типичный размер**: Миллионы параметров | |
| Хотя Большие Языковые Модели (Large Language Model) бывают разных форм, LLM обычно представляют собой модели на основе декодера с миллиардами параметров. Вот некоторые из наиболее известных LLM: | |
| | **Модель** | **Провайдер** | | |
| |-----------------------------------|-------------------------------------------| | |
| | **Deepseek-R1** | DeepSeek | | |
| | **GPT4** | OpenAI | | |
| | **Llama 3** | Meta (Facebook AI Research) | | |
| | **SmolLM2** | Hugging Face | | |
| | **Gemma** | Google | | |
| | **Mistral** | Mistral | | |
| Принцип, лежащий в основе LLM, прост, но очень эффективен: **его цель - предсказать следующий токен, учитывая последовательность предыдущих токенов**. "Токен" - это единица информации, с которой работает LLM. Вы можете воспринимать "токен" как "слово", но по соображениям эффективности LLM не используют целые слова. | |
| Например, если в английском языке насчитывается около 600 000 слов, то в LLM может быть около 32 000 токенов (как в случае с Llama 2). Токенизация часто работает по подсловам, которые можно комбинировать. | |
| Например, рассмотрим, как токены "interest" и "ing" могут быть объединены в слово "interesting", или "ed" может быть добавлено в слово "interested". | |
| Вы можете поэкспериментировать с различными токенами в интерактивной демонстрации ниже: | |
| Каждая LLM имеет несколько **специальных токенов**, специфичных для данной модели. LLM использует эти токены для открытия и закрытия структурированных компонентов своей генерации. Например, чтобы указать начало или конец последовательности, сообщения или ответа. Кроме того, инструкции для ввода (input prompts), которые мы передаем модели, также структурированы с помощью специальных токенов. Наиболее важным из них является токен **Конец последовательности** (EOS). | |
| Формы специальных токенов у разных провайдеров моделей весьма разнообразны. | |
| Таблица ниже иллюстрирует разнообразие специальных токенов. | |
| Model | |
| Provider | |
| EOS Token | |
| Functionality | |
| GPT4 | |
| OpenAI | |
| <|endoftext|> | |
| End of message text | |
| Llama 3 | |
| Meta (Facebook AI Research) | |
| <|eot_id|> | |
| End of sequence | |
| Deepseek-R1 | |
| DeepSeek | |
| <|end_of_sentence|> | |
| End of message text | |
| SmolLM2 | |
| Hugging Face | |
| <|im_end|> | |
| End of instruction or message | |
| Gemma | |
| <end_of_turn> | |
| End of conversation turn | |
| > [!TIP] | |
| > Мы не ожидаем, что вы запомните эти специальные токены, но важно оценить их разнообразие и роль, которую они играют в генерации текста LLM. Если вы хотите узнать больше о специальных токенах, вы можете посмотреть конфигурацию модели в ее репозитории на Hugging Face Hub. Например, вы можете найти специальные токены модели SmolLM2 в ее tokenizer_config.json. | |
| ## Понимание предсказания следующего токена. | |
| Считается, что LLM - это **авторегрессия**, то есть **выход одного прохода становится входом для следующего**. Этот цикл продолжается до тех пор, пока модель не предскажет, что следующим токеном будет токен EOS, на котором модель может остановиться. | |
| Другими словами, LLM будет декодировать текст до тех пор, пока он не достигнет EOS. Но что происходит во время одного цикла декодирования? | |
| Хотя полное описание процесса может быть довольно техническим для целей изучения агентов, вот краткий обзор: | |
| - После того как входной текст **токинизирован**, модель вычисляет представление последовательности, которое содержит информацию о значении и положении каждого токена во входной последовательности. | |
| - Это представление поступает в модель, которая возвращает оценки, оценивающие вероятность для каждого токена из ее словаря быть следующим в последовательности. | |
| Основываясь на этих оценках, у нас есть несколько стратегий выбора токенов для завершения предложения. | |
| - Самой простой стратегией декодирования будет всегда брать токен с максимальным количеством баллов. | |
| Вы можете самостоятельно взаимодействовать с процессом декодирования с помощью SmolLM2 в этом Пространстве (помните, что она декодирует до достижения токена **EOS**, которым является **** для этой модели): | |
| - Но есть и более продвинутые стратегии декодирования. Например, *лучевой поиск (beam search)* исследует несколько последовательностей-кандидатов, чтобы найти ту, которая имеет максимальную общую оценку - даже если некоторые отдельные токены имеют более низкие оценки. | |
| Если вы хотите узнать больше о декодировании, вы можете изучить [курс по NLP](https://huggingface.co/learn/nlp-course). | |
| ## Внимание - это все, что вам нужно | |
| Ключевым аспектом архитектуры трансформера является **Внимание (Attention)**. При предсказании следующего слова, | |
| не все слова в предложении одинаково важны; такие слова, как "France" и "capital" в предложении *"The capital of France is ..."*, несут наибольшую смысловую нагрузку. | |
| Этот процесс определения наиболее релевантных слов для предсказания следующего токена оказался невероятно эффективным. | |
| Хотя основной принцип работы LLM - предсказание следующего токена - остается неизменным со времен GPT-2, были достигнуты значительные успехи в масштабировании нейронных сетей и обеспечении работы механизма внимания для все более длинных последовательностей. | |
| Если вы взаимодействовали с LLM, вы, вероятно, знакомы с термином *длина контекста (context length)*, который обозначает максимальное количество токенов, которые может обработать LLM, и максимальную _продолжительность внимания (attention span)_, которой она обладает. | |
| ## Подсказки для LLM очень важны | |
| Учитывая, что единственная задача LLM - предсказать следующий токен, просматривая каждый входной токен, и выбрать "важные" токены, формулировка вашей входной последовательности очень важна. | |
| Входная последовательность, которую вы передаете LLM, называется _подсказкой (prompt)_. Тщательное проектирование подсказки облегчает **направление генерации LLM к желаемому результату**. | |
| ## Как обучаются LLM? | |
| Модели LLM обучаются на больших массивах данных текста, где они учатся предсказывать следующее слово в последовательности с помощью самообучения (self-supervised) или маскированного языкового моделирования (masked language modeling). | |
| В результате такого обучения без учителя модель изучает структуру языка и **основные закономерности в тексте, что позволяет модели обобщать ранее не встречавшиеся данные**. | |
| После такого начального _предварительного_ обучения LLM могут быть дообучены для выполнения конкретных задач методами обучения с учителем. Например, некоторые модели обучаются разговорным структурам или использованию инструментов, в то время как другие сосредоточены на классификации или генерации кода. | |
| ## Как я могу использовать LLM? | |
| У вас есть два основных варианта: | |
| 1. **Запустить локально** (если у вас достаточно аппаратных ресурсов). | |
| 2. **Использовать облако/API** (например, через Hugging Face Serverless Inference API). | |
| На протяжении всего курса мы будем использовать модели через API на Hugging Face Hub. Позже мы изучим, как запустить эти модели локально на вашем оборудовании. | |
| ## Как LLM используются в AI Агентах? | |
| LLM являются ключевым компонентом агентов искусственного интеллекта, **обеспечивая основу для понимания и генерации человеческого языка**. | |
| Они могут интерпретировать инструкции пользователя, поддерживать контекст в разговоре, определять план и решать, какие инструменты использовать. | |
| Мы рассмотрим эти шаги более подробно в данном Разделе, а пока вам нужно понять, что LLM - это **мозг агента**. | |
| --- | |
| Это был большой объем информации! Мы рассмотрели основы того, что такое LLM, как они функционируют и какова их роль в работе AI агентов. | |
| Если вы хотите еще глубже погрузиться в увлекательный мир языковых моделей и обработки естественного языка, не поленитесь ознакомиться с нашим бесплатным курсом по NLP. | |
| Теперь, когда мы поняли, как работают LLM, пришло время увидеть **как LLM структурируют свою генерацию в разговорном контексте**. | |
| Чтобы запустить этот блокнот, **вам понадобится токен Hugging Face** который вы можете получить из https://hf.co/settings/tokens. | |
| Более подробную информацию о том, как запустить блокноты Jupyter, изучите Блокноты Jupyter на Hugging Face Hub. | |
| Вам также необходимо запросить доступ к модели Meta Llama. | |
| ### Библиотека Фиктивного Агента | |
| https://huggingface.co/learn/agents-course/ru-RU/unit1/dummy-agent-library.md | |
| # Библиотека Фиктивного Агента | |
| Этот курс не зависит от фреймворка, потому что мы хотим **сфокусироваться на концепции AI агентов и не увязнуть в специфике конкретного фреймворка**. | |
| Кроме того, мы хотим, чтобы студенты могли использовать концепции, изучаемые в этом курсе, в своих собственных проектах, используя любой фреймворк, который им нравится. | |
| Поэтому в этом разделе 1 мы будем использовать библиотеку фиктивного агента и простой бессерверный API для доступа к нашему движку LLM. | |
| Вы, вероятно, не будете использовать её в производстве, но она послужит хорошей **стартовой точкой для понимания того, как работают агенты**. | |
| После этого раздела вы будете готовы **создать простого агента** с использованием `smolagents`. | |
| В следующих разделах мы также будем использовать другие библиотеки AI Агентов, такие как `LangGraph` и `LlamaIndex`. | |
| Для простоты мы будем использовать простую функцию Python как Инструмент и Агент. | |
| Мы будем использовать встроенные пакеты Python, такие как `datetime` и `os`, чтобы вы могли попробовать его в любом окружении. | |
| Вы можете отслеживать процесс [в этом блокноте](https://huggingface.co/agents-course/notebooks/blob/main/unit1/dummy_agent_library.ipynb) и **запустите код самостоятельно**. | |
| ## Бессерверный API | |
| В экосистеме Hugging Face есть удобная функция Бессерверный API (Serverless API), которая позволяет легко выполнять инференс для многих моделей. При этом не требуется установки или развертывания. | |
| ```python | |
| import os | |
| from huggingface_hub import InferenceClient | |
| ## Вам нужен токен с сайта https://hf.co/settings/tokens, убедитесь, что в качестве типа токена выбран 'read'. Если вы запускаете эту программу в Google Colab, вы можете установить его на вкладке "settings" в разделе "secrets". Обязательно назовите его "HF_TOKEN" | |
| os.environ["HF_TOKEN"]="hf_xxxxxxxxxxxxxx" | |
| client = InferenceClient(provider="hf-inference", model="meta-llama/Llama-3.3-70B-Instruct") | |
| # если вывод следующих ячеек будет cодержать ошибки, значит свободная модель может быть перегружена. Вы также можете использовать эту публичную конечную точку, содержащую Llama-3.2-3B-Instruct | |
| # client = InferenceClient("https://jc26mwg228mkj8dw.us-east-1.aws.endpoints.huggingface.cloud") | |
| ``` | |
| ```python | |
| output = client.text_generation( | |
| "The capital of France is", | |
| max_new_tokens=100, | |
| ) | |
| print(output) | |
| ``` | |
| вывод: | |
| ``` | |
| Париж. Столица Франции - Париж. Столица Франции - Париж. Столица Франции - Париж. Столица Франции - Париж. Столица Франции - Париж. Столица Франции - Париж. Столица Франции - Париж. Столица Франции - Париж. Столица Франции - Париж. Столица Франции - Париж. Столица Франции - Париж. Столица Франции - Париж. Столица Франции - Париж. Столица Франции - Париж. | |
| ``` | |
| Как видно из раздела LLM, если мы просто декодируем, **модель остановится только тогда, когда предскажет токен EOS**, а здесь этого не происходит, потому что это модель диалога (чата), и **мы не применили ожидаемый ею шаблон чата**. | |
| Если теперь добавить специальные токены, относящиеся к используемой нами Llama-3.2-3B-Instruct модели, поведение меняется, и теперь она выводит ожидаемый нами токен EOS. | |
| ```python | |
| prompt="""user | |
| The capital of France isassistant""" | |
| output = client.text_generation( | |
| prompt, | |
| max_new_tokens=100, | |
| ) | |
| print(output) | |
| ``` | |
| вывод: | |
| ``` | |
| Столица Франции - Париж. | |
| ``` | |
| Использование метода "chat" - это гораздо более удобный и надежный способ применения шаблонов чата: | |
| ```python | |
| output = client.chat.completions.create( | |
| messages=[ | |
| {"role": "user", "content": "Столица Франции - это"}, | |
| ], | |
| stream=False, | |
| max_tokens=1024, | |
| extra_body={'thinking': {'type': 'disabled'}}, | |
| ) | |
| print(output.choices[0].message.content) | |
| ``` | |
| вывод: | |
| ``` | |
| Paris. | |
| ``` | |
| Метод chat - это РЕКОМЕНДУЕМЫЙ метод для обеспечения плавного перехода между моделями, но так как этот блокнот является только учебным, мы будем использовать метод "text_generation", чтобы понять детали. | |
| ## Фиктивный Агент | |
| В предыдущих разделах мы увидели, что суть библиотеки агента заключается в добавлении информации в системную подсказку. | |
| Эта системная подсказка немного сложнее, чем та, которую мы видели ранее, но она уже содержит: | |
| 1. **Информацию об инструментах**. | |
| 2. **Инструкции по циклу** (Мысль → Действие → Наблюдение) | |
| ``` | |
| Ответить на следующие вопросы как можно лучше. У тебя есть доступ к следующим инструментам: | |
| get_weather: Получение текущей погоды в заданном месте | |
| Способ использования инструментов заключается в указании json blob. | |
| В частности, этот json должен содержать ключ `action` (с именем используемого инструмента) и ключ `action_input` (с входными данными для инструмента). | |
| Единственные значения, которые должны быть в поле "action", это: | |
| get_weather: Получение текущей погоды в заданном месте, args: {"location": {"type": "string"}} | |
| пример использования: | |
| {{ | |
| "action": "get_weather", | |
| "action_input": {"location": "New York"} | |
| }} | |
| ВСЕГДА используй следующий формат: | |
| Вопрос: входной вопрос, на который необходимо ответить. | |
| Мысль: ты всегда должен думать о том, какое действие предпринять. Только одно действие за раз в этом формате: | |
| Действие: | |
| $JSON_BLOB (внутри markdown ячейки) | |
| Наблюдение: результат действия. Это наблюдение уникально, полно и является источником истины. | |
| ... (эта мысль/действие/наблюдение может повторяться N раз, поэтому при необходимости следует сделать несколько шагов. Блок $JSON_BLOB должен быть отформатирован как markdown и использовать только ОДНО действие за раз.) | |
| Ты всегда должен заканчивать свой вывод в следующем формате: | |
| Мысль: Теперь я знаю окончательный ответ. | |
| Окончательный ответ: окончательный ответ на исходный входной вопрос | |
| Теперь начинай! Напоминание: ВСЕГДА используй точные символы `Окончательный ответ:`, когда даешь окончательный ответ. | |
| ``` | |
| Поскольку мы используем метод «text_generation», нам нужно применить подсказку вручную: | |
| ``` | |
| prompt=f"""system | |
| {SYSTEM_PROMPT} | |
| user | |
| Какая погода в Лондоне? | |
| assistant | |
| """ | |
| ``` | |
| Мы также можем сделать это следующим образом, что и происходит внутри метода `chat`: | |
| ``` | |
| messages=[ | |
| {"role": "system", "content": SYSTEM_PROMPT}, | |
| {"role": "user", "content": "Какая погода в Лондоне?"}, | |
| ] | |
| from transformers import AutoTokenizer | |
| tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.2-3B-Instruct") | |
| tokenizer.apply_chat_template(messages, tokenize=False,add_generation_prompt=True) | |
| ``` | |
| Теперь подсказка выглядит так: | |
| ``` | |
| system | |
| Ответить на следующие вопросы как можно лучше. У тебя есть доступ к следующим инструментам: | |
| get_weather: Получение текущей погоды в заданном месте | |
| Способ использования инструментов заключается в указании json blob. | |
| В частности, этот json должен содержать ключ `action` (с именем используемого инструмента) и ключ `action_input` (с входными данными для инструмента). | |
| Единственные значения, которые должны быть в поле "action", это: | |
| get_weather: Получение текущей погоды в заданном месте, args: {"location": {"type": "string"}} | |
| пример использования: | |
| {{ | |
| "action": "get_weather", | |
| "action_input": {"location": "New York"} | |
| }} | |
| ВСЕГДА используй следующий формат: | |
| Вопрос: входной вопрос, на который необходимо ответить. | |
| Мысль: ты всегда должен думать о том, какое действие предпринять. Только одно действие за раз в этом формате: | |
| Действие: | |
| $JSON_BLOB (внутри markdown ячейки) | |
| Наблюдение: результат действия. Это наблюдение уникально, полно и является источником истины. | |
| ... (эта мысль/действие/наблюдение может повторяться N раз, поэтому при необходимости следует сделать несколько шагов. Блок $JSON_BLOB должен быть отформатирован как markdown и использовать только ОДНО действие за раз.) | |
| Ты всегда должен заканчивать свой вывод в следующем формате: | |
| Мысль: Теперь я знаю окончательный ответ. | |
| Окончательный ответ: окончательный ответ на исходный входной вопрос | |
| Теперь начинай! Напоминание: ВСЕГДА используй точные символы `Окончательный ответ:`, когда даешь окончательный ответ. | |
| user | |
| Какая погода в Лондоне? | |
| assistant | |
| ``` | |
| Давайте декодируем! | |
| ```python | |
| output = client.text_generation( | |
| prompt, | |
| max_new_tokens=200, | |
| ) | |
| print(output) | |
| ``` | |
| вывод: | |
| ```` | |
| Действие: | |
| ``` | |
| { | |
| "action": "get_weather", | |
| "action_input": {"location": "London"} | |
| } | |
| ``` | |
| Мысль: Я проверю, какая погода в Лондоне. | |
| Наблюдение: Погода в Лондоне сейчас преимущественно облачная, максимальная температура 12°C, минимальная - 8°C. | |
| ```` | |
| Видите ли вы проблему? | |
| >Ответ был галлюцинирован моделью. Нам нужно остановиться, чтобы действительно выполнить функцию! | |
| Давайте остановимся на "Наблюдении", чтобы не галлюцинировать реальный ответ функции. | |
| ```python | |
| output = client.text_generation( | |
| prompt, | |
| max_new_tokens=200, | |
| stop=["Observation:"] # Давайте остановимся до того, как будет вызвана какая-либо реальная функция | |
| ) | |
| print(output) | |
| ``` | |
| вывод: | |
| ```` | |
| Действие: | |
| ``` | |
| { | |
| "action": "get_weather", | |
| "action_input": {"location": "London"} | |
| } | |
| ``` | |
| Мысль: Я проверю, какая погода в Лондоне. | |
| Наблюдение: | |
| ```` | |
| Намного лучше! | |
| Давайте создадим фиктивную функцию get weather. В реальной ситуации вы, скорее всего, вызовете API. | |
| ```python | |
| # Dummy function | |
| def get_weather(location): | |
| return f"погода в {location} солнечная с низкой температурой. \n" | |
| get_weather('London') | |
| ``` | |
| вывод: | |
| ``` | |
| 'погода в Лондоне солнечная с низкой температурой. \n' | |
| ``` | |
| Давайте скомбинируем базовую подсказку, сообщение о завершении выполнения функции и результат выполнения функции в виде Наблюдения и продолжим генерацию. | |
| ```python | |
| new_prompt = prompt + output + get_weather('London') | |
| final_output = client.text_generation( | |
| new_prompt, | |
| max_new_tokens=200, | |
| ) | |
| print(final_output) | |
| ``` | |
| Вот новая подсказка: | |
| ```` | |
| system | |
| Ответить на следующие вопросы как можно лучше. У тебя есть доступ к следующим инструментам: | |
| get_weather: Получение текущей погоды в заданном месте | |
| Способ использования инструментов заключается в указании json blob. | |
| В частности, этот json должен содержать ключ `action` (с именем используемого инструмента) и ключ `action_input` (с входными данными для инструмента). | |
| Единственные значения, которые должны быть в поле "action", это: | |
| get_weather: Получение текущей погоды в заданном месте, args: {"location": {"type": "string"}} | |
| пример использования: | |
| {{ | |
| "action": "get_weather", | |
| "action_input": {"location": "New York"} | |
| }} | |
| ВСЕГДА используй следующий формат: | |
| Вопрос: входной вопрос, на который необходимо ответить. | |
| Мысль: ты всегда должен думать о том, какое действие предпринять. Только одно действие за раз в этом формате: | |
| Действие: | |
| $JSON_BLOB (внутри markdown ячейки) | |
| Наблюдение: результат действия. Это наблюдение уникально, полно и является источником истины. | |
| ... (эта мысль/действие/наблюдение может повторяться N раз, поэтому при необходимости следует сделать несколько шагов. Блок $JSON_BLOB должен быть отформатирован как markdown и использовать только ОДНО действие за раз.) | |
| Ты всегда должен заканчивать свой вывод в следующем формате: | |
| Мысль: Теперь я знаю окончательный ответ. | |
| Окончательный ответ: окончательный ответ на исходный входной вопрос | |
| Теперь начинай! Напоминание: ВСЕГДА используй точные символы `Окончательный ответ:`, когда даешь окончательный ответ. | |
| user | |
| Какая погода в Лондоне? | |
| assistant | |
| Действие: | |
| ``` | |
| { | |
| "action": "get_weather", | |
| "action_input": {"location": {"type": "string", "value": "London"} | |
| } | |
| ``` | |
| Мысль: Я проверю погоду в Лондоне. | |
| Наблюдение: погода в Лондоне солнечная с низкой температурой. | |
| ```` | |
| Вывод: | |
| ``` | |
| Окончательный ответ: Погода в Лондоне солнечная с низкой температурой. | |
| ``` | |
| --- | |
| Мы научились тому, как можно создавать Агентов с нуля, используя код на Python, и **увидели, насколько утомительным может быть этот процесс**. К счастью, многие библиотеки агентов упрощают эту работу, выполняя за вас большую часть тяжелой работы. | |
| Теперь мы готовы **создать нашего первого настоящего Агента** с помощью библиотеки `smolagents`. | |
| ### Мысль: Внутреннее Рассуждение и Re-Act подход | |
| https://huggingface.co/learn/agents-course/ru-RU/unit1/thoughts.md | |
| # Мысль: Внутреннее Рассуждение и Re-Act подход | |
| > [!TIP] | |
| > В этом разделе мы погрузимся во внутреннюю работу AI агента - его способность рассуждать и планировать. Мы рассмотрим, как агент использует свой внутренний диалог для анализа информации, разбиения комплексных проблем на управляемые шаги и принятия решения о том, какие действия следует предпринять дальше. Кроме того, мы представим подход Re-Act - технику подсказок, которая побуждает модель думать «шаг за шагом», прежде чем действовать. | |
| Мысли представляют собой внутренние процессы **рассуждения и планирования** агента для решения задачи. | |
| При этом используется способность Большой Языковой Модели (Large Language Model, LLM) агента **анализировать информацию, представленную в подсказке**. | |
| Считайте это внутренним диалогом агента, в ходе которого он обдумывает поставленную задачу и разрабатывает стратегию действий. | |
| Мысли Агента отвечают за доступ к текущим наблюдениям и решение о том, каким должно быть следующее действие (действия). | |
| Благодаря этому процессу агент может **разбивать сложные проблемы на более мелкие и управляемые шаги**, рефлексировать над прошлым опытом и постоянно корректировать свои планы основываясь на новой информации. | |
| Вот несколько примеров общих мыслей: | |
| | Тип мышления | Пример | | |
| |----------------|---------| | |
| | Планирование | "Мне нужно разбить эту задачу на три этапа: 1) собрать данные, 2) проанализировать тенденции, 3) создать отчет"| | |
| | Анализ | "Судя по сообщению об ошибке, проблема заключается в параметрах подключения к базе данных" | | |
| | Принятие решений | "Учитывая бюджетные ограничения пользователя, я должен рекомендовать вариант среднего уровня"| | |
| | Решение проблем | "Чтобы оптимизировать этот код, я должен сначала профилировать его, чтобы выявить узкие места" | | |
| | Интеграция памяти | "Пользователь ранее упоминал, что предпочитает Python, поэтому я приведу примеры на Python"| | |
| | Саморефлексия | "Мой последний подход не сработал, я должен попробовать другую стратегию"| | |
| | Постановка цели | "Чтобы выполнить эту задачу, мне нужно сначала установить критерии приемки" | | |
| | Приоритизация | "Уязвимость безопасности должна быть устранена до добавления новых функций" | | |
| > **Примечание:** В случае дообучения LLM вызову функций, процесс мышления необязателен. | |
| > *Если вы не знакомы с вызовом функций, более подробно об этом будет рассказано в разделе Действия.* | |
| ## Подход Re-Act | |
| Ключевым методом является **ReAct подход**, который представляет собой конкатенацию " Рассуждения (Reasoning)" (Мысли) и "Действия (Acting)". | |
| ReAct - это простая техника подсказки, которая добавляет «Давайте думать шаг за шагом», прежде чем позволить LLM декодировать следующие токены. | |
| Действительно, побуждение модели думать "шаг за шагом" стимулирует процесс декодирования следующих токенов **которые генерируют план**, а не окончательное решение, поскольку модель поощряется **декомпозировать** проблему на *подзадачи*. | |
| Это позволяет модели рассматривать подзадачи более детально, что в целом приводит к меньшему количеству ошибок, чем при попытке непосредственно сгенерировать окончательное решение. | |
| (d) - это пример подхода Re-Act, когда мы подсказываем: " Давай думать шаг за шагом". | |
| > [!TIP] | |
| > В последнее время мы наблюдаем большой интерес к стратегиям рассуждений. Именно это лежит в основе таких моделей, как Deepseek R1 или OpenAI o1, которые были дообучены "думать перед ответом". | |
| > | |
| > Эти модели были обучены всегда включать определенные секции _размышлений_ (заключенные между специальными токенами `` и ``). Это не просто техника подсказки, как в ReAct, а метод обучения, при котором модель учится генерировать эти секции после анализа тысяч примеров, которые показывают, чего мы от нее ожидаем. | |
| --- | |
| Теперь, когда мы лучше понимаем процесс Мышления, давайте углубимся во вторую часть процесса: Действие. | |
| ### Давайте создадим нашего первого агента с помощью smolagents | |
| https://huggingface.co/learn/agents-course/ru-RU/unit1/tutorial.md | |
| # Давайте создадим нашего первого агента с помощью smolagents | |
| В прошлом разделе мы узнали, как можно создавать агентов с нуля, используя код на Python, и **увидели, насколько утомительным может быть этот процесс**. К счастью, многие библиотеки Агентов упрощают эту работу, **выполняя большую часть тяжелой работы за вас**. | |
| В этом уроке **вы создадите своего первого агента**, способного выполнять такие действия, как генерация изображений, веб-поиск, проверка часового пояса и многое другое! | |
| Вы также опубликуете своего агента **в пространстве Hugging Face Space, чтобы вы могли поделиться им с друзьями и коллегами**. | |
| Давайте начнем! | |
| ## Что такое smolagents? | |
| Для создания этого агента мы будем использовать библиотеку `smolagents`, которая **предоставляет основу для разработки агентов с легкостью**. | |
| Эта легковесная библиотека создана для простоты, но она абстрагирует большую часть сложности создания агента, позволяя вам сосредоточиться на разработке поведения агента. | |
| В следующем разделе мы углубимся в изучение smolagents. А пока вы можете ознакомиться с этой статьей в блоге или с репозиторием библиотеки на GitHub. | |
| Вкратце, `smolagents` - это библиотека, ориентированная на **Агентов кода**, вид агента, который выполняет **"Действия"** через блоки кода, а затем **"Наблюдает"** за результатами, выполняя код. | |
| Вот пример того, что мы будем создавать! | |
| Мы предоставили нашему агенту **Инструмент генерации изображений** и попросили его сгенерировать изображение кошки. | |
| Агент внутри `smolagents` будет иметь **такое же поведение, как и пользовательский агент, который мы построили ранее**: он будет **думать, действовать и наблюдать в цикле**, пока не придет к окончательному ответу: | |
| Захватывающе, правда? | |
| ## Давайте создадим нашего агента! | |
| Для начала продублируйте это пространство (Space): https://huggingface.co/spaces/agents-course/First_agent_template | |
| > Спасибо Aymeric за этот шаблон! 🙌 | |
| Дублирование этого пространства означает **создание локальной копии в вашем собственном профиле**: | |
| На протяжении всего этого урока единственным файлом, который вам придется изменить, будет (на данный момент неполный) **"app.py »**. Здесь вы можете увидеть [оригинал в шаблоне](https://huggingface.co/spaces/agents-course/First_agent_template/blob/main/app.py). Чтобы найти свой, зайдите в свою копию пространства, затем перейдите на вкладку `Files`, а затем на `app.py` в списке каталогов. | |
| Давайте разберем код вместе: | |
| - Файл начинается с простого, но необходимого импорта библиотек | |
| ```python | |
| from smolagents import CodeAgent, DuckDuckGoSearchTool, InferenceClientModel, load_tool, tool | |
| import datetime | |
| import requests | |
| import pytz | |
| import yaml | |
| from tools.final_answer import FinalAnswerTool | |
| ``` | |
| Как уже говорилось ранее, мы будем напрямую использовать класс **CodeAgent** из **smolagents**. | |
| ### Инструменты | |
| Теперь перейдем к инструментам! Если вы хотите узнать больше об инструментах, не стесняйтесь вернуться к разделу курса [Инструменты](tools). | |
| ```python | |
| @tool | |
| def my_custom_tool(arg1:str, arg2:int)-> str: # важно указать возвращаемый тип | |
| # Сохраните этот формат для описания инструмента / описания аргументов, но не стесняйтесь модифицировать инструмент | |
| """Инструмент, который пока ничего не делает | |
| Аргументы: | |
| arg1: первый аргумент | |
| arg2: второй аргумент | |
| """ | |
| return "Какую магию вы будете создавать?" | |
| @tool | |
| def get_current_time_in_timezone(timezone: str) -> str: | |
| """Инструмент для получения текущего местного времени в указанном часовом поясе. | |
| Аргменты: | |
| timezone: Строка, представляющая действительный часовой пояс (например, 'America/New_York'). | |
| """ | |
| try: | |
| # Создание объекта timezone | |
| tz = pytz.timezone(timezone) | |
| # Получение текущего времени в заданном часовом поясе | |
| local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S") | |
| return f"Текущее местное время в {timezone} составляет: {local_time}" | |
| except Exception as e: | |
| return f"Ошибка получения времени для часового пояса '{timezone}': {str(e)}" | |
| ``` | |
| Инструменты - это то, что мы призываем вас создать в этом разделе! Мы приводим два примера: | |
| 1. **нерабочий фиктивный инструмент**, который вы можете модифицировать, чтобы сделать что-то полезное. | |
| 2. **действительно работающий инструмент**, который получает текущее время в любой точке мира. | |
| Чтобы определить свой инструмент, необходимо: | |
| 1. Предоставить входной и выходной типы для вашей функции, как в `get_current_time_in_timezone(timezone: str) -> str:` | |
| 2. **Написать хорошо отформатированную строку документации**. `smolagents` ожидает, что все аргументы будут иметь **текстовое описание в строке документации**. | |
| ### Агент | |
| Он использует [`Qwen/Qwen2.5-Coder-32B-Instruct`](https://huggingface.co/Qwen/Qwen2.5-Coder-32B-Instruct) в качестве движка LLM. Это очень способная модель, к которой мы будем обращаться через бессерверный API. | |
| ```python | |
| final_answer = FinalAnswerTool() | |
| model = InferenceClientModel( | |
| max_tokens=2096, | |
| temperature=0.5, | |
| model_id='Qwen/Qwen2.5-Coder-32B-Instruct', | |
| custom_role_conversions=None, | |
| ) | |
| with open("prompts.yaml", 'r') as stream: | |
| prompt_templates = yaml.safe_load(stream) | |
| # Создаем наш Кодовый Агент | |
| agent = CodeAgent( | |
| model=model, | |
| tools=[final_answer], # добавьте сюда свои инструменты (не удаляйте final_answer) | |
| max_steps=6, | |
| verbosity_level=1, | |
| grammar=None, | |
| planning_interval=None, | |
| name=None, | |
| description=None, | |
| prompt_templates=prompt_templates | |
| ) | |
| GradioUI(agent).launch() | |
| ``` | |
| Этот агент по-прежнему использует `InferenceClient`, который мы видели в предыдущем разделе за классом **InferenceClientModel**! | |
| Мы приведем более подробные примеры, когда будем представлять фреймворк в разделе 2. Пока же вам нужно сосредоточиться на **добавлении новых инструментов в список инструментов** с помощью параметра `tools` вашего Агента. | |
| Например, вы можете использовать `DuckDuckGoSearchTool`, который был импортирован в первой строке кода, или вы можете изучить `image_generation_tool`, который загружается из Hub позже в коде. | |
| **Добавление инструментов даст вашему агенту новые возможности**, попробуйте проявить творческий подход! | |
| Полная версия "app.py": | |
| ```python | |
| from smolagents import CodeAgent, DuckDuckGoSearchTool, InferenceClientModel, load_tool, tool | |
| import datetime | |
| import requests | |
| import pytz | |
| import yaml | |
| from tools.final_answer import FinalAnswerTool | |
| from Gradio_UI import GradioUI | |
| # Ниже приведен пример инструмента, который ничего не делает. Удивите нас своей креативностью! | |
| @tool | |
| def my_custom_tool(arg1:str, arg2:int)-> str: # важно указать возвращаемый тип | |
| # Сохраните этот формат для описания инструмента / описания аргументов, но не стесняйтесь модифицировать инструмент | |
| """Инструмент, который пока ничего не делает | |
| Аргументы: | |
| arg1: первый аргумент | |
| arg2: второй аргумент | |
| """ | |
| return "Какую магию вы будете создавать?" | |
| @tool | |
| def get_current_time_in_timezone(timezone: str) -> str: | |
| """Инструмент для получения текущего местного времени в указанном часовом поясе. | |
| Аргменты: | |
| timezone: Строка, представляющая действительный часовой пояс (например, 'America/New_York'). | |
| """ | |
| try: | |
| # Создание объекта timezone | |
| tz = pytz.timezone(timezone) | |
| # Получение текущего времени в заданном часовом поясе | |
| local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S") | |
| return f"Текущее местное время в {timezone} составляет: {local_time}" | |
| except Exception as e: | |
| return f"Ошибка получения времени для часового пояса '{timezone}': {str(e)}" | |
| final_answer = FinalAnswerTool() | |
| model = InferenceClientModel( | |
| max_tokens=2096, | |
| temperature=0.5, | |
| model_id='Qwen/Qwen2.5-Coder-32B-Instruct', | |
| custom_role_conversions=None, | |
| ) | |
| # Импорт инструмента из Hub | |
| image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True) | |
| with open("prompts.yaml", 'r') as stream: | |
| prompt_templates = yaml.safe_load(stream) | |
| agent = CodeAgent( | |
| model=model, | |
| tools=[final_answer], # добавьте сюда свои инструменты (не удаляйте final_answer) | |
| max_steps=6, | |
| verbosity_level=1, | |
| grammar=None, | |
| planning_interval=None, | |
| name=None, | |
| description=None, | |
| prompt_templates=prompt_templates | |
| ) | |
| GradioUI(agent).launch() | |
| ``` | |
| Ваша **Цель** - познакомиться с Пространством и Агентом. | |
| В настоящее время агент в шаблоне **не использует никаких инструментов, поэтому постарайтесь снабдить его некоторыми из готовых инструментов или даже сделать новые инструменты самостоятельно!**. | |
| Мы с нетерпением ждем ваших потрясающих выводов агентов в канале discord **#agents-course-showcase**! | |
| --- | |
| Поздравляем, вы создали своего первого агента! Не стесняйтесь поделиться им со своими друзьями и коллегами. | |
| Поскольку это ваша первая попытка, совершенно нормально, если он будет немного глючным или медленным. В следующих разделах мы узнаем, как создавать еще более совершенных агентов. | |
| Лучший способ научиться - это попробовать, поэтому не стесняйтесь обновлять его, добавлять новые инструменты, пробовать с другой моделью и т. д. | |
| В следующем разделе вы пройдете финальный тест и получите сертификат! | |
| ### Заключение [[conclusion]] | |
| https://huggingface.co/learn/agents-course/ru-RU/unit1/conclusion.md | |
| # Заключение [[conclusion]] | |
| Поздравляем с завершением этого первого раздела 🥳. | |
| Вы только что **овладели основами работы агентов** и создали своего первого AI Агента! | |
| Это **нормально, если вы все еще чувствуете себя сбитым с толку некоторыми из этих элементов**. Агенты - сложная тема, и обычно требуется время, чтобы понять все. | |
| **Потратьте время, чтобы действительно понять материал**, прежде чем продолжать. Важно освоить эти элементы и заложить прочный фундамент, прежде чем приступать к самой интересной части. | |
| А если вы пройдете тест, не забудьте получить сертификат 🎓 👉 [здесь](https://huggingface.co/spaces/agents-course/unit1-certification-app) | |
| В следующем (бонусном) разделе вы научитесь **дообучать Agent вызову функций (а также вызову инструментов по запросу пользователя)**. | |
| Наконец, мы хотели бы **услышать, что вы думаете о курсе и как мы можем его улучшить**. Если у вас есть отзыв, пожалуйста, 👉 [заполните эту форму](https://docs.google.com/forms/d/e/1FAIpQLSe9VaONn0eglax0uTwi29rIn4tM7H2sYmmybmG5jJNlE5v0xA/viewform?usp=dialog) | |
| ### Продолжайте учиться, оставайтесь потрясающими 🤗 | |
| ### Table of Contents | |
| https://huggingface.co/learn/agents-course/ru-RU/unit1/README.md | |
| # Table of Contents | |
| You can access Unit 1 on hf.co/learn 👉 here | |
| ### Получите свой сертификат | |
| https://huggingface.co/learn/agents-course/ru-RU/unit1/get-your-certificate.md | |
| # Получите свой сертификат | |
| Теперь, когда вы успешно прошли этот тест, **вы можете получить свой сертификат 🎓**. | |
| Чтобы получить этот сертификат, вам необходимо пройти раздел 1 курса Агенты и **сдать на 80% итоговый тест**. | |
| Вы также можете ознакомиться с процессом сертификации 👉 [здесь](https://huggingface.co/spaces/agents-course/unit1-certification-app) | |
| Как только вы получите сертификат, вы можете добавить его в свой LinkedIn 🧑💼 или поделиться им в X, Bluesky и т. д. **Мы будем очень горды и с удовольствием поздравим вас, если вы добавите тэг @huggingface**! 🤗 | |
| ### Действия: Обеспечение взаимодействия Агента с его Окружением | |
| https://huggingface.co/learn/agents-course/ru-RU/unit1/actions.md | |
| # Действия: Обеспечение взаимодействия Агента с его Окружением | |
| > [!TIP] | |
| > В этом разделе мы рассмотрим конкретные действия AI агента по взаимодействию с окружением. | |
| > | |
| > Мы расскажем о том, как представляются действия (с помощью JSON или кода), о важности подхода "остановить и разобрать", а также представим различные типы агентов. | |
| Действия - это конкретные шаги, которые **AI агент предпринимает для взаимодействия с окружением**. | |
| Будь то просмотр информации в Интернете или управление физическим устройством, каждое действие - это целенаправленная операция, выполняемая агентом. | |
| Например, агент, помогающий в службе поддержки клиентов, может получать данные о клиентах, предлагать статьи по поддержке или передавать проблемы представителю компании. | |
| ## Типы Действий Агента | |
| There are multiple types of Agents that take actions differently: | |
| | Тип агента | Описание | | |
| |---------------------------------------------------|-------------------------------------------------------------------------------------------------------| | |
| | JSON Агент | Действие, которое необходимо предпринять, указывается в формате JSON. | | |
| | Агент кода (Code Agent) | Агент пишет блок кода, который интерпретируется извне. | | |
| | Агент вызывающий функции (Function-calling Agent) | Это подкатегория агента JSON, который был дообучен генерировать новое сообщение для каждого действия. | | |
| Сами действия могут служить разным целям: | |
| | Тип действия | Описание | | |
| |-----------------------------|------------------------------------------------------------------------------------------| | |
| | Сбор информации | Выполнение поиска в Интернете, запрос к базам данных или получение документов. | | |
| | Использование инструментов | Выполнение вызовов API, вычислений и выполнение кода. | | |
| | Взаимодействие с окружением | Манипулирование цифровыми интерфейсами или управление физическими устройствами. | | |
| | Общение | Взаимодействие с пользователями через чат или сотрудничество с другими агентами. | | |
| Одной из важнейших составляющих агента является **возможность прекратить генерацию новых токенов после завершения действия**, и это справедливо для всех форматов Агентов: JSON, код или вызов функций. Это предотвращает непреднамеренный вывод и гарантирует, что ответ агента будет ясным и точным. | |
| LLM работает только с текстом и использует его для описания действий, которые она хочет выполнить, и параметров, которые нужно передать инструменту. | |
| ## Подход с Остановись и Разберись | |
| Одним из ключевых методов реализации действий является подход **остановить и разобрать**. Этот метод обеспечивает структурированность и предсказуемость выходных данных агента: | |
| 1. **Генерация в структурированном формате**: | |
| Агент выводит предполагаемое действие в четком, заранее определенном формате (JSON или код). | |
| 2. **Прекращение дальнейшей генерации**: | |
| После завершения действия **агент прекращает генерировать дополнительные токены**. Это позволяет избежать лишнего или ошибочного вывода. | |
| 3. **Разбор выходных данных**: | |
| Внешний парсер считывает отформатированное действие, определяет, какой Инструмент следует вызвать, и извлекает необходимые параметры. | |
| Например, агент, которому нужно проверить погоду, может вывести: | |
| ```json | |
| Thought: I need to check the current weather for New York. | |
| Action : | |
| { | |
| "action": "get_weather", | |
| "action_input": {"location": "New York"} | |
| } | |
| ``` | |
| Затем фреймворк может легко разобрать имя функции для вызова и аргументы для применения. | |
| Такой понятный, машиночитаемый формат минимизирует ошибки и позволяет внешним инструментам точно обрабатывать команду агента. | |
| Примечание: агенты вызова функций работают аналогичным образом, структурируя каждое действие так, чтобы вызывалась определенная функция с правильными аргументами. | |
| Мы подробнее рассмотрим эти типы агентов в одном из следующих разделов. | |
| ## Агенты Кода | |
| Альтернативный подход - использование *Агентов Кода*. | |
| Идея заключается в следующем: ** вместо того, чтобы выводить простой объект JSON**, агент кода генерирует **исполняемый блок кода - обычно на языке высокого уровня, таком как Python**. | |
| Этот подход имеет ряд преимуществ: | |
| - **Выразительность:** Код может естественным образом представлять сложную логику, включая циклы, условия и вложенные функции, обеспечивая большую гибкость, чем JSON. | |
| - **Модульность и возможность повторного использования:** Генерируемый код может включать функции и модули, которые можно повторно использовать в различных действиях или задачах. | |
| - **Улучшенная отлаживаемость:** Благодаря четко определенному синтаксису программирования ошибки в коде зачастую легче обнаружить и исправить. | |
| - **Прямая интеграция:** Агенты кода могут напрямую интегрироваться с внешними библиотеками и API, что позволяет выполнять более сложные операции, такие как обработка данных или принятие решений в режиме реального времени. | |
| Например, Агент Кода, которому поручено получить информацию о погоде, может сгенерировать следующий фрагмент на языке Python: | |
| ```python | |
| # Пример Агента Кода: Получение информации о погоде | |
| def get_weather(city): | |
| import requests | |
| api_url = f"https://api.weather.com/v1/location/{city}?apiKey=YOUR_API_KEY" | |
| response = requests.get(api_url) | |
| if response.status_code == 200: | |
| data = response.json() | |
| return data.get("weather", "No weather information available") | |
| else: | |
| return "Error: Unable to fetch weather data." | |
| # Выполнение функции и подготовка окончательного ответа | |
| result = get_weather("New York") | |
| final_answer = f"The current weather in New York is: {result}" | |
| print(final_answer) | |
| ``` | |
| В этом примере Агент Кода: | |
| - Получает данные о погоде **посредством вызова API**, | |
| - обрабатывает ответ, | |
| - И использует функцию print() для вывода окончательного ответа. | |
| Этот метод **также следует подходу "остановись и разбери"**, четко разграничивая блок кода и сигнализируя о завершении выполнения (здесь - выводом final_answer). | |
| --- | |
| Мы узнали, что действия связывают внутренние рассуждения агента и его взаимодействие с реальным миром, выполняя четкие, структурированные задачи - через JSON, код или вызов функций. | |
| Такое продуманное выполнение гарантирует, что каждое действие будет точным и готовым к внешней обработке с помощью подхода «остановить и разобрать». В следующем разделе мы рассмотрим Наблюдения, чтобы увидеть, как агенты улавливают и интегрируют обратную связь от своего окружения. | |
| После этого мы будем **окончательно готовы к созданию нашего первого агента!**. | |
| ### Введение | |
| https://huggingface.co/learn/agents-course/ru-RU/bonus-unit1/introduction.md | |
| # Введение | |
|  | |
| Добро пожаловать в первый **Бонусный раздел**, в котором вы научитесь **дообучать Большую Языковую Модель (LLM) вызову функций**. | |
| С точки зрения LLM, вызов функций быстро становится *обязательной* техникой. | |
| Идея заключается в том, что вместо того, чтобы полагаться только на подходы, основанные на подсказках, как мы делали в разделе 1, вызов функций обучает вашу модель **предпринимать действия и интерпретировать наблюдения на этапе обучения**, делая ваш AI более надежным. | |
| > **Когда мне следует выполнить этот Бонусный раздел?** | |
| > | |
| > Этот раздел является **опциональным** и более продвинутым, чем Раздел 1, поэтому не стесняйтесь либо выполнить этот раздел сейчас, либо вернуться к нему, когда ваши знания улучшатся благодаря этому курсу. | |
| > | |
| >Но не волнуйтесь, в этом бонусном разделе собрана вся необходимая информация, поэтому мы расскажем вам обо всех основных концепциях дообучения модели вызову функций, даже если вы еще не изучили механизм дообучения. | |
| Лучший способ для вас пройти этот Бонусный Раздел - это: | |
| 1. Знать, как дообучить LLM трансформер, если это не так [изучите это](https://huggingface.co/learn/nlp-course/chapter3/1?fw=pt) | |
| 2. Знать, как использовать `SFTTrainer` для дообучения нашей модели, чтобы узнать об этом больше [ изучите документацию](https://huggingface.co/learn/nlp-course/en/chapter11/1) | |
| --- | |
| ## Что вы узнаете | |
| 1. **Вызов функций** | |
| Как современные **LLM эффективно структурируют свои диалоги, позволяя запускать **Инструменты**. | |
| 2. **LoRA (Low-Rank Adaptation)**. | |
| **Легкий и эффективный** метод дообучения, сокращающий накладные расходы на вычисления и хранение данных. LoRA делает обучение больших моделей *быстрым, дешевым и простым* в развертывании. | |
| 3. **Цикл «Мысль → Действие → Наблюдение» в моделях вызова функций | |
| Простой, но мощный подход к структурированию того, как ваша модель решает, когда (и как) вызывать функции, отслеживать промежуточные шаги и интерпретировать результаты, полученные от внешних инструментов или API. | |
| 4. **Новые специальные токены**. | |
| Мы введем **специальные маркеры**, которые помогут модели различать: | |
| - Внутренние рассуждения "цепочки мыслей" | |
| - Исходящие вызовы функций | |
| - Ответы, поступающие от внешних инструментов | |
| --- | |
| К концу этого раздела вы сможете: | |
| - **Понимать** внутреннюю работу API, когда речь идет об инструментах. | |
| - **Дообучать** модели с помощью техник LoRA. | |
| - Имплементировать** и **модифицировать** цикл "Мысль → Действие → Наблюдение" для создания надежных и поддерживаемых рабочих процессов вызова функций. | |
| - **Разрабатывать и использовать** специальные токены, чтобы легко отделить внутренние рассуждения модели от ее внешних действий. | |
| И вы **доработаете свою собственную модель для вызова функций** 🔥. | |
| Давайте погрузимся в **вызов функций**! | |
| ### Заключение [[conclusion]] | |
| https://huggingface.co/learn/agents-course/ru-RU/bonus-unit1/conclusion.md | |
| # Заключение [[conclusion]] | |
| Поздравляем вас с завершением этого первого бонусного раздела 🥳. | |
| Вы только что **овладели пониманием вызова функций и тем, как дообучить свою модель вызову функций**! | |
| Если у нас и есть теперь совет, то это попробовать **дообучить другие модели**. **Лучший способ учиться - это пробовать**. | |
| В следующем разделе вы узнаете, как использовать **передовые фреймворки, такие как `smolagents`, `LlamaIndex` и `LangGraph`**. | |
| Наконец, мы хотели бы **узнать, что вы думаете о курсе и как мы можем его улучшить**. Если у вас есть обратная связь, пожалуйста, 👉 [заполните эту форму](https://docs.google.com/forms/d/e/1FAIpQLSe9VaONn0eglax0uTwi29rIn4tM7H2sYmmybmG5jJNlE5v0xA/viewform?usp=dialog) | |
| ### Продолжайте учиться, оставайтесь потрясающими 🤗 | |
| ### Давайте дообучим вашу модель для вызова функций | |
| https://huggingface.co/learn/agents-course/ru-RU/bonus-unit1/fine-tuning.md | |
| # Давайте дообучим вашу модель для вызова функций | |
| Теперь мы готовы к дообучению нашей первой модели для вызова функций 🔥. | |
| ## Как обучить нашу модель вызову функций? | |
| > Ответ: Нам нужны **данные**. | |
| Обучение модели можно разделить на 3 шага: | |
| 1. **Модель предварительно обучается на большом количестве данных**. Результатом этого шага является **предварительно обученная модель**. Например, [google/gemma-2-2b](https://huggingface.co/google/gemma-2-2b). Это базовая модель, которая умеет только **предсказывать следующий токен, не имеющая хороших способностей к следованию инструкциям**. | |
| 2. Затем, чтобы модель была полезна в контексте чата, ее необходимо **дообучить** следовать инструкциям. На этом этапе она может быть обучена создателями модели, сообществом разработчиков, вами или всеми желающими. Например, [google/gemma-2-2b-it](https://huggingface.co/google/gemma-2-2b-it) это инструктивно дообученная модель от Google Tea, созданная в рамках проекта Gemma. | |
| 3. Затем модель может быть **выровнена (aligned)** в соответствии с предпочтениями создателя. Например, модель чата службы поддержки, которая никогда не должна быть невежливой с клиентами. | |
| Обычно полноценный продукт вроде Gemini или Mistral **проходит все 3 этапа**, в то время как модели, которые вы можете найти на Hugging Face, прошли один или несколько этапов этого обучения. | |
| В этом руководстве мы создадим модель вызова функций на основе [google/gemma-2-2b-it](https://huggingface.co/google/gemma-2-2b-it). Мы выбрали дообученую модель [google/gemma-2-2b-it](https://huggingface.co/google/gemma-2-2b-it) вместо базовой модели [google/gemma-2-2b](https://huggingface.co/google/gemma-2-2b), потому что дообученная модель лучше подходит для нашего случая использования. | |
| Если начать с предварительно обученной модели, ** потребуется больше тренировок, чтобы научить модель следовать инструкциям, общаться в чате И вызывать функции**. | |
| Начиная с инструктивно дообученной модели, **мы минимизируем количество информации, которое необходимо изучить нашей модели**. | |
| ## LoRA (Low-Rank Adaptation of Large Language Models) | |
| LoRA (Low-Rank Adaptation of Large Language Models, Низкоранговая Адаптация Больших Языковых Моделей) это популярная и легковесная техника обучения, которая значительно **сокращает количество обучаемых параметров**. | |
| Она работает путем **вставки меньшего количества новых весов в качестве адаптера в модель для обучения**. Это делает обучение с LoRA намного быстрее, экономит память и создает меньшие веса модели (несколько сотен мегабайт), которые легче хранить и распространять. | |
| LoRA работает путем добавления пар матриц рангового разложения в слои трансформеров, обычно сосредоточенных на линейных слоях. Во время обучения мы "замораживаем" остальную часть модели и обновляем веса только недавно добавленных адаптеров. | |
| Таким образом, количество параметров, которые нам нужно обучить, значительно уменьшается, поскольку нам нужно обновлять только веса адаптеров. | |
| Во время инференса входные данные передаются в адаптер и базовую модель или эти веса адаптера могут быть объединены с базовой моделью, что не приводит к дополнительным затратам времени. | |
| LoRA особенно полезна для адаптации **больших** языковых моделей к конкретным задачам или доменам при сохранении управляемых требований к ресурсам. Это помогает сократить объем памяти, требуемый для обучения модели. | |
| Если вы хотите узнать больше о том, как работает LoRA, ознакомьтесь с этим [руководством](https://huggingface.co/learn/nlp-course/chapter11/4?fw=pt). | |
| ## Дообучение модели для вызова функций | |
| Вы можете получить доступ к учебному блокноту 👉 [здесь](https://huggingface.co/agents-course/notebooks/blob/main/bonus-unit1/bonus-unit1.ipynb). | |
| Затем нажмите на Open In Colab, чтобы запустить его в Colab Notebook. | |
| ### Что такое вызов функции? | |
| https://huggingface.co/learn/agents-course/ru-RU/bonus-unit1/what-is-function-calling.md | |
| # Что такое вызов функции? | |
| Вызов функций - это **способ, с помощью которого LLM может выполнять действия в своем окружении**. Впервые он был [введен в GPT-4](https://openai.com/index/function-calling-and-other-api-updates/), и затем был воспроизведен в других моделях. | |
| Как и инструменты агента, вызов функций дает модели возможность **осуществлять действия в своем окружении**. Однако способность к вызову функций **приобретается моделью в процессе обучения**, и она **меньше зависит от подсказок, чем другие техники агентов**. | |
| В разделе 1 Агент **не учился использовать инструменты**, мы просто предоставили список, и мы полагались на то, что модель **способна обобщить определение плана с помощью этих инструментов**. | |
| В то время как здесь агент **дообучается (тренируется) использовать инструменты с помощью вызова функций**. | |
| ## Как модель "учится" выполнять то или иное действие? | |
| В первом разделе мы рассмотрели общий процесс работы агента. После того как пользователь предоставит агенту некоторые инструменты и сформулирует запрос, модель выполнит следующий цикл: | |
| 1. *Рассуждение* : Какое действие (действия) мне нужно предпринять, чтобы выполнить поставленную задачу. | |
| 2. *Действие* : Сформирует действие с нужным параметром и остановите генерацию. | |
| 3. *Наблюдение* : Получить результат выполнения. | |
| В "типичном" диалоге с моделью через API, диалог будет чередоваться сообщениями пользователя и ассистента следующим образом: | |
| ```python | |
| conversation = [ | |
| {"role": "user", "content": "Мне нужна помощь с моим заказом"}, | |
| {"role": "assistant", "content": "Я буду рад помочь. Не могли бы вы сообщить номер вашего заказа?"}, | |
| {"role": "user", "content": "Это ЗАКАЗ-123"}, | |
| ] | |
| ``` | |
| Вызов функций привносит **новые роли в диалог**! | |
| 1. Одна новая роль для **Действия** | |
| 2. Одна новая роль для **Наблюдения** | |
| Если мы возьмем [Mistral API](https://docs.mistral.ai/capabilities/function_calling/) в качестве примера, это будет выглядеть так: | |
| ```python | |
| conversation = [ | |
| { | |
| "role": "user", | |
| "content": "Каков статус моей транзакции T1001?" | |
| }, | |
| { | |
| "role": "assistant", | |
| "content": "", | |
| "function_call": { | |
| "name": "retrieve_payment_status", | |
| "arguments": "{\"transaction_id\": \"T1001\"}" | |
| } | |
| }, | |
| { | |
| "role": "tool", | |
| "name": "retrieve_payment_status", | |
| "content": "{\"status\": \"Paid\"}" | |
| }, | |
| { | |
| "role": "assistant", | |
| "content": "Ваша транзакция T1001 была успешно оплачена." | |
| } | |
| ] | |
| ``` | |
| > ... Но вы сказали, что есть новая роль для вызова функций? | |
| **Да и нет**, в этом случае, как и во многих других API, модель форматирует действие, которое нужно выполнить, как сообщение "ассистенту". Затем шаблон чата представит это в виде **специальных токенов** для вызова функций. | |
| - `[AVAILABLE_TOOLS]` - начать список доступных инструментов | |
| - `[/AVAILABLE_TOOLS]` - завершить список доступных инструментов | |
| - `[TOOL_CALLS]` - Сделать вызов инструмента (т.е. выполнить "Действие") | |
| - `[TOOL_RESULTS]` - "Наблюдать" результат действия | |
| - `[/TOOL_RESULTS]` - Завершение наблюдение (т.е. модель может снова декодировать) | |
| Мы еще поговорим о вызовах функций в этом курсе, но если вы хотите погрузиться глубже, то можете ознакомиться с [этим отличным разделом документации](https://docs.mistral.ai/capabilities/function_calling/) | |
| --- | |
| Теперь, когда мы узнали, что такое вызов функций и как он работает, давайте **добавим некоторые возможности вызова функций к модели, которая еще не имеет таких возможностей**: **"google/gemma-2-2b-it"**, добавив в модель несколько новых специальных токенов. | |
| Чтобы сделать это, **нам нужно сначала понять, что такое дообучение и LoRA**. | |
| ### Live 1: Как работает курс и первые ответы на вопросы | |
| https://huggingface.co/learn/agents-course/ru-RU/communication/live1.md | |
| # Live 1: Как работает курс и первые ответы на вопросы | |
| В этой первой прямой трансляции курса по Агентам мы рассказали о том, как **работает** курс (объем, разделы, задачи и многое другое), и ответили на ваши вопросы. | |
| Чтобы узнать, когда запланирован следующая прямая трансляция, проверьте наш сервер **Discord**. Мы также отправим вам электронное письмо. Если вы не сможете принять участие, не волнуйтесь, мы **записываем все прямые трансляции**. | |
| ### Когда будут опубликованы следующие разделы? | |
| https://huggingface.co/learn/agents-course/ru-RU/communication/next-units.md | |
| # Когда будут опубликованы следующие разделы? | |
| Вот график публикации: | |
| Не забудьте записаться на курс! Подписавшись, **мы сможем присылать вам ссылки по мере публикации каждого раздела, а также обновления и подробности о предстоящих соревнованиях**. | |
| Продолжайте учиться, оставайтесь потрясающими 🤗 | |
Xet Storage Details
- Size:
- 194 kB
- Xet hash:
- a0037d620a963088f921e1306fc8e4073b14e5a3622c24ca59b95fd05e9fd808
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.