ai-agents-for-beginners

Мультиагентный дизайн

(Щелкните на изображение выше, чтобы посмотреть видео этого урока)

Метакогниция в ИИ агентах

Введение

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

Цели обучения

После завершения урока вы сможете:

  1. Понять последствия циклов рассуждений в определениях агентов.
  2. Использовать методы планирования и оценки для помощи самоисправляющимся агентам.
  3. Создавать собственных агентов, способных манипулировать кодом для выполнения задач.

Введение в метакогницию

Метакогниция относится к высшим когнитивным процессам, включающим размышления о собственном мышлении. Для ИИ агентов это означает способность оценивать и корректировать свои действия, исходя из самосознания и прошлого опыта. Метакогниция, или «мышление о мышлении», является важной концепцией в разработке агентных систем ИИ. Она включает осознание ИИ собственных внутренних процессов и способность контролировать, регулировать и адаптировать свое поведение соответственно. Аналогично тому, как мы оцениваем ситуацию или смотрим на проблему. Это самосознание помогает ИИ системам принимать более правильные решения, выявлять ошибки и улучшать свою эффективность со временем — снова возвращаясь к тесту Тьюринга и обсуждениям о том, захватит ли ИИ власть.

В контексте агентных систем ИИ метакогниция может помочь решить несколько задач, таких как:

Что такое метакогниция?

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

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

Важность метакогниции в ИИ агентах

Метакогниция играет важную роль в дизайне ИИ агентов по нескольким причинам:

Важность метакогниции

Компоненты ИИ агента

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

Эти компоненты вместе создают «единицу экспертизы», способную выполнять конкретные задачи.

Пример: Представьте путешественнического агента, который не только планирует ваш отпуск, но и корректирует маршрут на основе данных в реальном времени и прошлого опыта клиентов.

Пример: Метакогниция в сервисе туристического агента

Представьте, что вы разрабатываете сервис туристического агента, управляемого ИИ. Этот агент, “Туристический агент”, помогает пользователям планировать отпуска. Чтобы включить метакогницию, агент должен оценивать и корректировать свои действия на основе самосознания и прошлого опыта. Вот как метакогниция может помочь:

Текущая задача

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

Шаги для выполнения задачи

  1. Сбор предпочтений пользователя: Узнать даты поездки, бюджет, интересы (например, музеи, кухня, шопинг) и специфические требования.
  2. Получение информации: Найти варианты перелетов, проживания, достопримечательностей и ресторанов, соответствующих предпочтениям пользователя.
  3. Создание рекомендаций: Предоставить персональный маршрут с деталями перелетов, бронью отелей и предложенными активностями.
  4. Корректировка на основе отзывов: Попросить пользователя оставить отзыв о рекомендациях и внести необходимые изменения.

Требуемые ресурсы

Опыт и саморефлексия

Туристический агент применяет метакогницию для оценки своей работы и обучения на прошлом опыте. Например:

  1. Анализ отзывов пользователей: Агент просматривает отзывы, чтобы определить, какие рекомендации были успешны, а какие — нет. Затем он корректирует будущие предложения.
  2. Адаптивность: Если пользователь ранее упоминал, что не любит многолюдные места, агент будет избегать рекомендовать популярные туристические места в часы пик.
  3. Исправление ошибок: Если агент допустил ошибку в прошлом бронировании, например, предложил отель с полной загрузкой, он научится более тщательно проверять доступность перед рекомендацией.

Практический пример для разработчика

Вот упрощенный пример кода для Туристического агента с применением метакогниции:

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}
        self.experience_data = []

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

    def retrieve_information(self):
        # Поиск авиабилетов, отелей и достопримечательностей на основе предпочтений
        flights = search_flights(self.user_preferences)
        hotels = search_hotels(self.user_preferences)
        attractions = search_attractions(self.user_preferences)
        return flights, hotels, attractions

    def generate_recommendations(self):
        flights, hotels, attractions = self.retrieve_information()
        itinerary = create_itinerary(flights, hotels, attractions)
        return itinerary

    def adjust_based_on_feedback(self, feedback):
        self.experience_data.append(feedback)
        # Анализ отзывов и корректировка будущих рекомендаций
        self.user_preferences = adjust_preferences(self.user_preferences, feedback)

# Пример использования
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
travel_agent.adjust_based_on_feedback(feedback)

Почему метакогниция важна

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

2. Планирование в агентах

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

Элементы планирования

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

Шаги для Туристического агента

  1. Сбор предпочтений пользователя
    • Запросить у пользователя детали о датах поездки, бюджете, интересах и специфических требованиях.
    • Примеры: «Когда вы планируете путешествовать?» «Какой у вас бюджет?» «Какие занятия на отдыхе вам нравятся?»
  2. Получение информации
    • Поиск подходящих вариантов путешествия на основе предпочтений пользователя.
    • Рейсы: Поиск доступных рейсов в пределах бюджета и предпочитаемых дат.
    • Проживание: Поиск отелей или аренды, соответствующих требованиям по расположению, цене и удобствам.
    • Достопримечательности и рестораны: Определение популярных мест и мероприятий, соответствующих интересам пользователя.
  3. Создание рекомендаций
    • Формирование персонального маршрута на основе полученной информации.
    • Предоставление деталей, таких как варианты перелетов, бронирование отелей и предложенные занятия с учетом предпочтений пользователя.
  4. Представление маршрута пользователю
    • Представление пользователю предложенного маршрута для ознакомления.
    • Пример: «Вот предложенный маршрут для вашей поездки в Париж. Включены данные о рейсах, бронировании отелей и список рекомендованных мероприятий и ресторанов. Сообщите, что вы думаете!»
  5. Сбор отзывов
    • Запросить у пользователя обратную связь по предложенному маршруту.
    • Примеры: «Вам нравятся выбранные рейсы?» «Подходит ли отель вашим требованиям?» «Хотите добавить или убрать какие-то мероприятия?»
  6. Корректировка на основе отзывов
    • Изменение маршрута с учетом отзывов пользователя.
    • Внесение необходимых изменений в рекомендации по рейсам, проживанию и активности для лучшего соответствия предпочтениям.
  7. Окончательное подтверждение
    • Представление обновленного маршрута пользователю для окончательного согласования.
    • Пример: «Я внес изменения с учетом ваших отзывов. Вот обновленный маршрут. Вас всё устраивает?»
  8. Бронирование и подтверждение
    • После одобрения маршрута пользователем, осуществить бронирование рейсов, проживания и подготовленных мероприятий.
    • Отправить пользователю подтверждения бронирований.
  9. Оказание поддержки
    • Быть доступным для помощи пользователю при любых изменениях или дополнительных запросах до и во время поездки.
    • Пример: «Если вам понадобится дополнительная помощь во время поездки, обращайтесь в любое время!»

Пример взаимодействия

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}
        self.experience_data = []

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

    def retrieve_information(self):
        flights = search_flights(self.user_preferences)
        hotels = search_hotels(self.user_preferences)
        attractions = search_attractions(self.user_preferences)
        return flights, hotels, attractions

    def generate_recommendations(self):
        flights, hotels, attractions = self.retrieve_information()
        itinerary = create_itinerary(flights, hotels, attractions)
        return itinerary

    def adjust_based_on_feedback(self, feedback):
        self.experience_data.append(feedback)
        self.user_preferences = adjust_preferences(self.user_preferences, feedback)

# Пример использования в запросе бронирования
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
travel_agent.adjust_based_on_feedback(feedback)

3. Система корректирующего RAG

Для начала давайте разберемся в различиях между инструментом RAG и предвосхищающей загрузкой контекста.

RAG против загрузки контекста

Генерация с расширенным доступом к данным (RAG)

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

В системе RAG агент извлекает релевантную информацию из базы знаний и использует её для формирования подходящих ответов или действий.

Подход корректирующего RAG

Подход корректирующего RAG фокусируется на использовании техник RAG для исправления ошибок и повышения точности ИИ агентов. Это включает:

  1. Техника подсказки: Использование конкретных подсказок для направления агента в извлечении релевантной информации.
  2. Инструмент: Реализация алгоритмов и механизмов, позволяющих агенту оценивать релевантность извлеченной информации и генерировать точные ответы.
  3. Оценка: Постоянная оценка эффективности агента и внесение корректировок для улучшения точности и эффективности.

Пример: корректирующий RAG в поисковом агенте

Рассмотрим поискового агента, который извлекает информацию из интернета, чтобы отвечать на запросы пользователей. Подход корректирующего RAG может включать:

  1. Техника подсказки: Формулирование поисковых запросов на основе ввода пользователя.
  2. Инструмент: Использование алгоритмов обработки естественного языка и машинного обучения для ранжирования и фильтрации результатов поиска.
  3. Оценка: Анализ отзывов пользователей для выявления и исправления неточностей в полученной информации.

Корректирующий RAG в туристическом агенте

Корректирующий RAG (генерация с расширением извлечением данных) улучшает способность ИИ извлекать и генерировать информацию с исправлением неточностей. Посмотрим, как Туристический агент может использовать подход корректирующего RAG для предоставления более точных и релевантных рекомендаций.

Это включает:

Шаги внедрения корректирующего RAG в Туристическом агенте

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

    • Пример:

      preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
  2. Извлечение информации
    • Туристический агент извлекает информацию о рейсах, проживании, достопримечательностях и ресторанах на основе предпочтений пользователя.

    • Пример:

      flights = search_flights(preferences)
hotels = search_hotels(preferences)
attractions = search_attractions(preferences)
  3. Генерация начальных рекомендаций
    • Туристический агент использует полученную информацию для создания персонального маршрута.

    • Пример:

      itinerary = create_itinerary(flights, hotels, attractions)
print("Suggested Itinerary:", itinerary)
  4. Сбор отзывов пользователя
    • Туристический агент запрашивает отзывы пользователя о первоначальных рекомендациях.

    • Пример:

      feedback = {
    "liked": ["Louvre Museum"],
    "disliked": ["Eiffel Tower (too crowded)"]
}
  5. Процесс корректирующего RAG
    • Техника подсказки: Туристический агент формулирует новые поисковые запросы с учетом отзывов пользователя.

      • Пример:

        if "disliked" in feedback:
    preferences["avoid"] = feedback["disliked"]
    • Инструмент: Туристический агент использует алгоритмы для ранжирования и фильтрации новых результатов поиска, уделяя внимание релевантности на основе отзывов.

      • Пример:

        new_attractions = search_attractions(preferences)
new_itinerary = create_itinerary(flights, hotels, new_attractions)
print("Updated Itinerary:", new_itinerary)
    • Оценка: Туристический агент регулярно оценивает релевантность и точность рекомендаций, анализирует отзывы пользователей и вносит необходимые корректировки.

      • Пример:

        def adjust_preferences(preferences, feedback):
    if "liked" in feedback:
        preferences["favorites"] = feedback["liked"]
    if "disliked" in feedback:
        preferences["avoid"] = feedback["disliked"]
    return preferences

preferences = adjust_preferences(preferences, feedback)

Практический пример

Вот упрощенный пример кода на Python с применением подхода корректирующего RAG в Туристическом агенте:

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}
        self.experience_data = []

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

    def retrieve_information(self):
        flights = search_flights(self.user_preferences)
        hotels = search_hotels(self.user_preferences)
        attractions = search_attractions(self.user_preferences)
        return flights, hotels, attractions

    def generate_recommendations(self):
        flights, hotels, attractions = self.retrieve_information()
        itinerary = create_itinerary(flights, hotels, attractions)
        return itinerary

    def adjust_based_on_feedback(self, feedback):
        self.experience_data.append(feedback)
        self.user_preferences = adjust_preferences(self.user_preferences, feedback)
        new_itinerary = self.generate_recommendations()
        return new_itinerary

# Пример использования
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
new_itinerary = travel_agent.adjust_based_on_feedback(feedback)
print("Updated Itinerary:", new_itinerary)

Предвосхищающая загрузка контекста

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

Вот упрощённый пример того, как может выглядеть предварительная загрузка контекста для приложения туристического агента на Python:

class TravelAgent:
    def __init__(self):
        # Предварительная загрузка популярных направлений и их информации
        self.context = {
            "Paris": {"country": "France", "currency": "Euro", "language": "French", "attractions": ["Eiffel Tower", "Louvre Museum"]},
            "Tokyo": {"country": "Japan", "currency": "Yen", "language": "Japanese", "attractions": ["Tokyo Tower", "Shibuya Crossing"]},
            "New York": {"country": "USA", "currency": "Dollar", "language": "English", "attractions": ["Statue of Liberty", "Times Square"]},
            "Sydney": {"country": "Australia", "currency": "Dollar", "language": "English", "attractions": ["Sydney Opera House", "Bondi Beach"]}
        }

    def get_destination_info(self, destination):
        # Получить информацию о месте назначения из предварительно загруженного контекста
        info = self.context.get(destination)
        if info:
            return f"{destination}:\nCountry: {info['country']}\nCurrency: {info['currency']}\nLanguage: {info['language']}\nAttractions: {', '.join(info['attractions'])}"
        else:
            return f"Sorry, we don't have information on {destination}."

# Пример использования
travel_agent = TravelAgent()
print(travel_agent.get_destination_info("Paris"))
print(travel_agent.get_destination_info("Tokyo"))

Объяснение

  1. Инициализация (метод __init__): Класс TravelAgent предварительно загружает словарь, содержащий информацию о популярных направлениях, таких как Париж, Токио, Нью-Йорк и Сидней. В этом словаре содержатся детали, такие как страна, валюта, язык и основные достопримечательности для каждого направления.

  2. Получение информации (метод get_destination_info): Когда пользователь запрашивает информацию о конкретном направлении, метод get_destination_info извлекает соответствующую информацию из предварительно загруженного словаря контекста.

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

Инициализация плана с целью перед итерацией

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

Вот пример того, как можно инициализировать план поездки с целью перед итерацией для туристического агента на Python:

Сценарий

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

Шаги

  1. Определить предпочтения клиента и бюджет.
  2. Инициализировать начальный план на основе этих предпочтений.
  3. Итеративно уточнять план, оптимизируя для удовлетворения клиента.

Код на Python

class TravelAgent:
    def __init__(self, destinations):
        self.destinations = destinations

    def bootstrap_plan(self, preferences, budget):
        plan = []
        total_cost = 0

        for destination in self.destinations:
            if total_cost + destination['cost'] <= budget and self.match_preferences(destination, preferences):
                plan.append(destination)
                total_cost += destination['cost']

        return plan

    def match_preferences(self, destination, preferences):
        for key, value in preferences.items():
            if destination.get(key) != value:
                return False
        return True

    def iterate_plan(self, plan, preferences, budget):
        for i in range(len(plan)):
            for destination in self.destinations:
                if destination not in plan and self.match_preferences(destination, preferences) and self.calculate_cost(plan, destination) <= budget:
                    plan[i] = destination
                    break
        return plan

    def calculate_cost(self, plan, new_destination):
        return sum(destination['cost'] for destination in plan) + new_destination['cost']

# Пример использования
destinations = [
    {"name": "Paris", "cost": 1000, "activity": "sightseeing"},
    {"name": "Tokyo", "cost": 1200, "activity": "shopping"},
    {"name": "New York", "cost": 900, "activity": "sightseeing"},
    {"name": "Sydney", "cost": 1100, "activity": "beach"},
]

preferences = {"activity": "sightseeing"}
budget = 2000

travel_agent = TravelAgent(destinations)
initial_plan = travel_agent.bootstrap_plan(preferences, budget)
print("Initial Plan:", initial_plan)

refined_plan = travel_agent.iterate_plan(initial_plan, preferences, budget)
print("Refined Plan:", refined_plan)

Объяснение кода

  1. Инициализация (метод __init__): Класс TravelAgent инициализируется списком возможных направлений, каждое из которых имеет атрибуты, такие как название, стоимость и тип активности.

  2. Инициализация плана (метод bootstrap_plan): Этот метод создаёт начальный план поездки на основе предпочтений клиента и бюджета. Он перебирает список направлений и добавляет их в план, если они соответствуют предпочтениям клиента и укладываются в бюджет.

  3. Соответствие предпочтениям (метод match_preferences): Этот метод проверяет, соответствует ли направление предпочтениям клиента.

  4. Итерация плана (метод iterate_plan): Этот метод уточняет начальный план, пытаясь заменить каждое направление в плане на более подходящее, учитывая предпочтения клиента и ограничения бюджета.

  5. Расчёт стоимости (метод calculate_cost): Этот метод вычисляет общую стоимость текущего плана, включая потенциальное новое направление.

Пример использования

Благодаря инициализации плана с чёткой целью (например, максимизация удовлетворённости клиента) и итеративному улучшению плана, туристический агент может создать индивидуальный и оптимизированный маршрут поездки для клиента. Такой подход гарантирует, что план поездки соответствует предпочтениям и бюджету клиента с самого начала и улучшается с каждой итерацией.

Использование LLM для повторного ранжирования и оценки

Крупные языковые модели (LLM) могут использоваться для повторного ранжирования и оценки путём анализа релевантности и качества извлечённых документов или сгенерированных ответов. Вот как это работает:

Извлечение: На начальном этапе извлекается набор кандидатных документов или ответов на основе запроса.

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

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

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

Вот пример того, как туристический агент может использовать крупную языковую модель (LLM) для повторного ранжирования и оценки туристических направлений на основе предпочтений пользователя на Python:

Сценарий — путешествие по предпочтениям

Туристический агент хочет рекомендовать лучшие направления для путешествий клиенту на основе его предпочтений. LLM поможет повторно ранжировать и оценивать направления, чтобы обеспечить представление наиболее релевантных вариантов.

Шаги:

  1. Собрать предпочтения пользователя.
  2. Извлечь список потенциальных туристических направлений.
  3. Использовать LLM для повторного ранжирования и оценки направлений на основе предпочтений пользователя.

Вот как можно обновить предыдущий пример для использования сервисов Azure OpenAI:

Требования

  1. У вас должна быть подписка Azure.
  2. Создайте ресурс Azure OpenAI и получите ваш API-ключ.

Пример кода на Python

import requests
import json

class TravelAgent:
    def __init__(self, destinations):
        self.destinations = destinations

    def get_recommendations(self, preferences, api_key, endpoint):
        # Сгенерировать запрос для Azure OpenAI
        prompt = self.generate_prompt(preferences)
        
        # Определить заголовки и тело запроса
        headers = {
            'Content-Type': 'application/json',
            'Authorization': f'Bearer {api_key}'
        }
        payload = {
            "prompt": prompt,
            "max_tokens": 150,
            "temperature": 0.7
        }
        
        # Вызвать API Azure OpenAI для получения переназначенных и оцененных направлений
        response = requests.post(endpoint, headers=headers, json=payload)
        response_data = response.json()
        
        # Извлечь и вернуть рекомендации
        recommendations = response_data['choices'][0]['text'].strip().split('\n')
        return recommendations

    def generate_prompt(self, preferences):
        prompt = "Here are the travel destinations ranked and scored based on the following user preferences:\n"
        for key, value in preferences.items():
            prompt += f"{key}: {value}\n"
        prompt += "\nDestinations:\n"
        for destination in self.destinations:
            prompt += f"- {destination['name']}: {destination['description']}\n"
        return prompt

# Пример использования
destinations = [
    {"name": "Paris", "description": "City of lights, known for its art, fashion, and culture."},
    {"name": "Tokyo", "description": "Vibrant city, famous for its modernity and traditional temples."},
    {"name": "New York", "description": "The city that never sleeps, with iconic landmarks and diverse culture."},
    {"name": "Sydney", "description": "Beautiful harbour city, known for its opera house and stunning beaches."},
]

preferences = {"activity": "sightseeing", "culture": "diverse"}
api_key = 'your_azure_openai_api_key'
endpoint = 'https://your-endpoint.com/openai/deployments/your-deployment-name/completions?api-version=2022-12-01'

travel_agent = TravelAgent(destinations)
recommendations = travel_agent.get_recommendations(preferences, api_key, endpoint)
print("Recommended Destinations:")
for rec in recommendations:
    print(rec)

Объяснение кода — Бронирование по предпочтениям

  1. Инициализация: Класс TravelAgent инициализируется списком потенциальных туристических направлений, каждое имеет атрибуты, такие как название и описание.

  2. Получение рекомендаций (метод get_recommendations): Этот метод формирует промпт для сервиса Azure OpenAI на основе предпочтений пользователя и выполняет HTTP POST-запрос к API Azure OpenAI, чтобы получить повторно ранжированные и оценённые направления.

  3. Генерация промпта (метод generate_prompt): Этот метод создаёт промпт для Azure OpenAI, включающий предпочтения пользователя и список направлений. Промпт направляет модель на повторное ранжирование и оценку направлений в соответствии с указанными предпочтениями.

  4. Вызов API: Библиотека requests используется для выполнения HTTP POST-запроса к конечной точке API Azure OpenAI. Ответ содержит повторно ранжированные и оценённые направления.

  5. Пример использования: Туристический агент собирает предпочтения пользователя (например, интерес к достопримечательностям и разнообразной культуре) и использует сервис Azure OpenAI для получения повторно ранжированных и оценённых рекомендаций по направлениям путешествия.

Обязательно замените your_azure_openai_api_key на ваш реальный API-ключ Azure OpenAI и https://your-endpoint.com/... на реальный URL конечной точки вашего развертывания Azure OpenAI.

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

RAG: техника промптинга против инструмента

Retrieval-Augmented Generation (RAG) может быть как техникой промптинга, так и инструментом в разработке AI-агентов. Понимание различия между ними помогает эффективнее использовать RAG в ваших проектах.

RAG как техника промптинга

Что это?

Как это работает:

  1. Формулирование промптов: Создавайте хорошо структурированные промпты или запросы на основе задачи или ввода пользователя.
  2. Извлечение информации: Используйте промпты для поиска релевантных данных из предсуществующей базы знаний или набора данных.
  3. Генерация ответа: Комбинируйте извлечённую информацию с генеративными AI-моделями для создания комплексного и связного ответа.

Пример в туристическом агенте:

RAG как инструмент

Что это?

Как это работает:

  1. Интеграция: Встраивайте RAG в архитектуру AI-агента, позволяя ему автоматически выполнять задачи извлечения и генерации.
  2. Автоматизация: Инструмент управляет всем процессом — от получения ввода пользователя до генерации окончательного ответа, без необходимости явных промптов на каждом этапе.
  3. Эффективность: Повышает производительность агента, упрощая процесс извлечения и генерации, обеспечивая более быстрые и точные ответы.

Пример в туристическом агенте:

Сравнение

Аспект Техника промптинга Инструмент
Ручное vs Автоматическое Ручное формулирование промптов для каждого запроса. Автоматизированный процесс извлечения и генерации.
Контроль Предоставляет больше контроля над процессом извлечения. Оптимизирует и автоматизирует процесс извлечения и генерации.
Гибкость Позволяет создавать кастомизированные промпты под конкретные задачи. Более эффективен для масштабных внедрений.
Сложность Требует создания и настройки промптов. Проще интегрируется в архитектуру AI-агента.

Практические примеры

Пример техники промптинга:

def search_museums_in_paris():
    prompt = "Find top museums in Paris"
    search_results = search_web(prompt)
    return search_results

museums = search_museums_in_paris()
print("Top Museums in Paris:", museums)

Пример инструмента:

class Travel_Agent:
    def __init__(self):
        self.rag_tool = RAGTool()

    def get_museums_in_paris(self):
        user_input = "I want to visit museums in Paris."
        response = self.rag_tool.retrieve_and_generate(user_input)
        return response

travel_agent = Travel_Agent()
museums = travel_agent.get_museums_in_paris()
print("Top Museums in Paris:", museums)

Оценка релевантности

Оценка релевантности — важный аспект работы AI-агентов. Она обеспечивает, что информация, извлечённая и сгенерированная агентом, является подходящей, точной и полезной для пользователя. Рассмотрим, как оценивать релевантность в AI-агентах на примерах и с использованием различных техник.

Ключевые понятия в оценке релевантности

  1. Осознание контекста:
    • Агент должен понимать контекст запроса пользователя, чтобы извлекать и генерировать релевантную информацию.
    • Пример: Если пользователь запрашивает «лучшие рестораны в Париже», агент должен учитывать предпочтения пользователя, например, тип кухни и бюджет.
  2. Точность:
    • Информация, предоставляемая агентом, должна быть фактически верной и актуальной.
    • Пример: Рекомендация ресторанов, которые сейчас открыты и имеют хорошие отзывы, а не устаревших или закрытых заведений.
  3. Намерение пользователя:
    • Агент должен выводить намерение пользователя за запросом, чтобы предоставить наиболее релевантную информацию.
    • Пример: Если пользователь запрашивает «бюджетные отели», агент должен отдавать приоритет доступным вариантам.
  4. Обратная связь:
    • Постоянный сбор и анализ отзывов пользователей помогает агенту улучшать процесс оценки релевантности.
    • Пример: Включение оценок и отзывов пользователей о предыдущих рекомендациях для улучшения будущих ответов.

Практические техники для оценки релевантности

  1. Оценка релевантности (Relevance Scoring):
    • Назначайте каждой извлечённой единице оценку релевантности на основе того, насколько хорошо она соответствует запросу и предпочтениям пользователя.

    • Пример:

      def relevance_score(item, query):
    score = 0
    if item['category'] in query['interests']:
        score += 1
    if item['price'] <= query['budget']:
        score += 1
    if item['location'] == query['destination']:
        score += 1
    return score
  2. Фильтрация и ранжирование:
    • Отфильтровывайте нерелевантные элементы и ранжируйте оставшиеся на основе их оценок релевантности.

    • Пример:

      def filter_and_rank(items, query):
    ranked_items = sorted(items, key=lambda item: relevance_score(item, query), reverse=True)
    return ranked_items[:10]  # Вернуть 10 наиболее релевантных элементов
  3. Обработка естественного языка (NLP):
    • Используйте техники NLP для понимания запроса пользователя и извлечения релевантной информации.

    • Пример:

      def process_query(query):
    # Используйте обработку естественного языка (NLP) для извлечения ключевой информации из запроса пользователя
    processed_query = nlp(query)
    return processed_query
  4. Интеграция обратной связи пользователей:
    • Собирайте отзывы пользователей о предоставленных рекомендациях и используйте их для корректировки будущих оценок релевантности.

    • Пример:

      def adjust_based_on_feedback(feedback, items):
    for item in items:
        if item['name'] in feedback['liked']:
            item['relevance'] += 1
        if item['name'] in feedback['disliked']:
            item['relevance'] -= 1
    return items

Пример: оценка релевантности в приложении туристического агента

Вот практический пример того, как приложение туристического агента может оценивать релевантность туристических рекомендаций:

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}
        self.experience_data = []

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

    def retrieve_information(self):
        flights = search_flights(self.user_preferences)
        hotels = search_hotels(self.user_preferences)
        attractions = search_attractions(self.user_preferences)
        return flights, hotels, attractions

    def generate_recommendations(self):
        flights, hotels, attractions = self.retrieve_information()
        ranked_hotels = self.filter_and_rank(hotels, self.user_preferences)
        itinerary = create_itinerary(flights, ranked_hotels, attractions)
        return itinerary

    def filter_and_rank(self, items, query):
        ranked_items = sorted(items, key=lambda item: self.relevance_score(item, query), reverse=True)
        return ranked_items[:10]  # Вернуть 10 наиболее релевантных элементов

    def relevance_score(self, item, query):
        score = 0
        if item['category'] in query['interests']:
            score += 1
        if item['price'] <= query['budget']:
            score += 1
        if item['location'] == query['destination']:
            score += 1
        return score

    def adjust_based_on_feedback(self, feedback, items):
        for item in items:
            if item['name'] in feedback['liked']:
                item['relevance'] += 1
            if item['name'] in feedback['disliked']:
                item['relevance'] -= 1
        return items

# Пример использования
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
updated_items = travel_agent.adjust_based_on_feedback(feedback, itinerary['hotels'])
print("Updated Itinerary with Feedback:", updated_items)

Поиск с учётом намерений

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

Ключевые понятия в поиске с учётом намерений

  1. Понимание намерения пользователя:
    • Намерения пользователя можно разделить на три основные категории: информационное, навигационное и транзакционное.
      • Информационное намерение: пользователь ищет информацию по теме (например, «Какие лучшие музеи в Париже?»).
      • Навигационное намерение: пользователь хочет перейти на конкретный сайт или страницу (например, «официальный сайт музея Лувр»).
      • Транзакционное намерение: пользователь хочет совершить действие, например, забронировать билет или совершить покупку (например, «Забронировать билет на рейс в Париж»).
  2. Осознание контекста:
    • Анализ контекста запроса пользователя помогает точно определить его намерение. Это включает учёт предыдущих взаимодействий, предпочтений пользователя и конкретных деталей текущего запроса.
  3. Обработка естественного языка (NLP):
    • Применяются техники NLP для понимания и интерпретации естественно-языковых запросов пользователя. Это включает распознавание сущностей, анализ настроений и парсинг запросов.
  4. Персонализация:
    • Персонализация результатов поиска на основе истории, предпочтений и отзывов пользователя повышает релевантность извлечённой информации.

Практический пример: поиск с учётом намерений в приложении туристического агента

Рассмотрим Travel Agent как пример реализации поиска с учётом намерений.

  1. Сбор предпочтений пользователя

    class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

  2. Понимание намерения пользователя

    def identify_intent(query):
    if "book" in query or "purchase" in query:
        return "transactional"
    elif "website" in query or "official" in query:
        return "navigational"
    else:
        return "informational"

  3. Осознание контекста

    def analyze_context(query, user_history):
    # Объединить текущий запрос с историей пользователя для понимания контекста
    context = {
        "current_query": query,
        "user_history": user_history
    }
    return context

  4. Поиск и персонализация результатов

    def search_with_intent(query, preferences, user_history):
    intent = identify_intent(query)
    context = analyze_context(query, user_history)
    if intent == "informational":
        search_results = search_information(query, preferences)
    elif intent == "navigational":
        search_results = search_navigation(query)
    elif intent == "transactional":
        search_results = search_transaction(query, preferences)
    personalized_results = personalize_results(search_results, user_history)
    return personalized_results

def search_information(query, preferences):
    # Пример логики поиска для информационного запроса
    results = search_web(f"best {preferences['interests']} in {preferences['destination']}")
    return results

def search_navigation(query):
    # Пример логики поиска для навигационного запроса
    results = search_web(query)
    return results

def search_transaction(query, preferences):
    # Пример логики поиска для транзакционного запроса
    results = search_web(f"book {query} to {preferences['destination']}")
    return results

def personalize_results(results, user_history):
    # Пример логики персонализации
    personalized = [result for result in results if result not in user_history]
    return personalized[:10]  # Возврат топ 10 персонализированных результатов

  5. Пример использования

    travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
user_history = ["Louvre Museum website", "Book flight to Paris"]
query = "best museums in Paris"
results = search_with_intent(query, preferences, user_history)
print("Search Results:", results)

4. Генерация кода как инструмент

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

Агенты генерации кода

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

Практические применения

  1. Автоматизированная генерация кода: Генерация фрагментов кода для конкретных задач, таких как анализ данных, веб-скрапинг или машинное обучение.
  2. SQL как RAG: Использование SQL-запросов для извлечения и обработки данных из баз данных.
  3. Решение задач: Создание и выполнение кода для решения конкретных задач, таких как оптимизация алгоритмов или анализ данных.

Пример: агент генерации кода для анализа данных

Представьте, что вы разрабатываете агента генерации кода. Вот как это может работать:

  1. Задача: Проанализировать набор данных для выявления тенденций и закономерностей.
  2. Шаги:
    • Загрузить набор данных в инструмент для анализа данных.
    • Сгенерировать SQL-запросы для фильтрации и агрегирования данных.
    • Выполнить запросы и получить результаты.
    • Использовать результаты для создания визуализаций и инсайтов.
  3. Требуемые ресурсы: Доступ к набору данных, инструменты анализа данных и возможности SQL.
  4. Опыт: Использование прошлых результатов анализа для повышения точности и релевантности будущих исследований.

Пример: агент генерации кода для туристического агента

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

Обзор агента генерации кода

  1. Сбор предпочтений пользователя: Сбор данных пользователя, таких как пункт назначения, даты поездки, бюджет и интересы.
  2. Генерация кода для получения данных: Генерация фрагментов кода для извлечения данных о перелетах, отелях и достопримечательностях.
  3. Выполнение сгенерированного кода: Запуск сгенерированного кода для получения актуальной информации.
  4. Составление маршрута: Компиляция полученных данных в персонализированный план путешествия.
  5. Коррекция на основе обратной связи: Получение отзывов пользователя и повторная генерация кода при необходимости для улучшения результатов.

Пошаговая реализация

  1. Сбор предпочтений пользователя

    class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

  2. Генерация кода для получения данных

    def generate_code_to_fetch_data(preferences):
    # Пример: Сгенерировать код для поиска авиарейсов на основе предпочтений пользователя
    code = f"""
    def search_flights():
        import requests
        response = requests.get('https://api.example.com/flights', params={preferences})
        return response.json()
    """
    return code

def generate_code_to_fetch_hotels(preferences):
    # Пример: Сгенерировать код для поиска отелей
    code = f"""
    def search_hotels():
        import requests
        response = requests.get('https://api.example.com/hotels', params={preferences})
        return response.json()
    """
    return code

  3. Выполнение сгенерированного кода

    def execute_code(code):
    # Выполнить сгенерированный код с помощью exec
    exec(code)
    result = locals()
    return result

travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
   
flight_code = generate_code_to_fetch_data(preferences)
hotel_code = generate_code_to_fetch_hotels(preferences)
   
flights = execute_code(flight_code)
hotels = execute_code(hotel_code)

print("Flight Options:", flights)
print("Hotel Options:", hotels)

  4. Составление маршрута

    def generate_itinerary(flights, hotels, attractions):
    itinerary = {
        "flights": flights,
        "hotels": hotels,
        "attractions": attractions
    }
    return itinerary

attractions = search_attractions(preferences)
itinerary = generate_itinerary(flights, hotels, attractions)
print("Suggested Itinerary:", itinerary)

  5. Коррекция на основе обратной связи

    def adjust_based_on_feedback(feedback, preferences):
    # Настроить предпочтения на основе отзывов пользователей
    if "liked" in feedback:
        preferences["favorites"] = feedback["liked"]
    if "disliked" in feedback:
        preferences["avoid"] = feedback["disliked"]
    return preferences

feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
updated_preferences = adjust_based_on_feedback(feedback, preferences)
   
# Перегенерировать и выполнить код с обновленными предпочтениями
updated_flight_code = generate_code_to_fetch_data(updated_preferences)
updated_hotel_code = generate_code_to_fetch_hotels(updated_preferences)
   
updated_flights = execute_code(updated_flight_code)
updated_hotels = execute_code(updated_hotel_code)
   
updated_itinerary = generate_itinerary(updated_flights, updated_hotels, attractions)
print("Updated Itinerary:", updated_itinerary)

Использование осведомленности об окружении и рассуждений

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

Вот пример того, как это можно реализовать:

  1. Понимание схемы: Система понимает схему таблицы и использует эту информацию для обоснования генерации запросов.
  2. Корректировка на основе обратной связи: Система корректирует предпочтения пользователя на основе отзывов и рассуждает о том, какие поля схемы необходимо обновить.
  3. Генерация и выполнение запросов: Система генерирует и выполняет запросы для получения обновленных данных о рейсах и отелях согласно новым предпочтениям.

Ниже приведён обновленный пример кода на Python, в котором реализованы эти концепции:

def adjust_based_on_feedback(feedback, preferences, schema):
    # Настроить параметры на основе отзывов пользователей
    if "liked" in feedback:
        preferences["favorites"] = feedback["liked"]
    if "disliked" in feedback:
        preferences["avoid"] = feedback["disliked"]
    # Логика на основе схемы для настройки других связанных параметров
    for field in schema:
        if field in preferences:
            preferences[field] = adjust_based_on_environment(feedback, field, schema)
    return preferences

def adjust_based_on_environment(feedback, field, schema):
    # Пользовательская логика для настройки параметров на основе схемы и отзывов
    if field in feedback["liked"]:
        return schema[field]["positive_adjustment"]
    elif field in feedback["disliked"]:
        return schema[field]["negative_adjustment"]
    return schema[field]["default"]

def generate_code_to_fetch_data(preferences):
    # Сгенерировать код для получения данных о рейсах на основе обновленных параметров
    return f"fetch_flights(preferences={preferences})"

def generate_code_to_fetch_hotels(preferences):
    # Сгенерировать код для получения данных о гостиницах на основе обновленных параметров
    return f"fetch_hotels(preferences={preferences})"

def execute_code(code):
    # Смоделировать выполнение кода и вернуть тестовые данные
    return {"data": f"Executed: {code}"}

def generate_itinerary(flights, hotels, attractions):
    # Сгенерировать маршрут на основе рейсов, гостиниц и достопримечательностей
    return {"flights": flights, "hotels": hotels, "attractions": attractions}

# Пример схемы
schema = {
    "favorites": {"positive_adjustment": "increase", "negative_adjustment": "decrease", "default": "neutral"},
    "avoid": {"positive_adjustment": "decrease", "negative_adjustment": "increase", "default": "neutral"}
}

# Пример использования
preferences = {"favorites": "sightseeing", "avoid": "crowded places"}
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
updated_preferences = adjust_based_on_feedback(feedback, preferences, schema)

# Перегенерировать и выполнить код с обновленными параметрами
updated_flight_code = generate_code_to_fetch_data(updated_preferences)
updated_hotel_code = generate_code_to_fetch_hotels(updated_preferences)

updated_flights = execute_code(updated_flight_code)
updated_hotels = execute_code(updated_hotel_code)

updated_itinerary = generate_itinerary(updated_flights, updated_hotels, feedback["liked"])
print("Updated Itinerary:", updated_itinerary)

Объяснение — бронирование на основе обратной связи

  1. Осведомленность о схеме: Словарь schema определяет, как предпочтения должны корректироваться на основе отзывов. Включает поля как favorites и avoid с соответствующими настройками.
  2. Корректировка предпочтений (метод adjust_based_on_feedback): Этот метод корректирует предпочтения на основе отзывов пользователя и схемы.
  3. Корректировки с учётом окружения (метод adjust_based_on_environment): Этот метод настраивает изменения с учётом схемы и отзывов.
  4. Генерация и выполнение запросов: Система генерирует код для получения обновленных данных о рейсах и отелях на основе скорректированных предпочтений и моделирует выполнение этих запросов.
  5. Генерация маршрута: Система создает обновленный маршрут на основе новых данных о рейсах, отелях и достопримечательностях.

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

Использование SQL как техники Retrieval-Augmented Generation (RAG)

SQL (Structured Query Language) — мощный инструмент для взаимодействия с базами данных. Используя его как часть подхода Retrieval-Augmented Generation (RAG), SQL может извлекать релевантные данные из баз данных для информирования и генерации ответов или действий в ИИ-агентах. Рассмотрим, как SQL может использоваться как техника RAG в контексте Туристического агента.

Основные понятия

  1. Взаимодействие с базой данных:
    • SQL используется для запросов к базам данных, извлечения релевантной информации и манипуляции данными.
    • Пример: получение информации о рейсах, отелях и достопримечательностях из базы данных по путешествиям.
  2. Интеграция с RAG:
    • SQL-запросы генерируются на основе ввода пользователя и его предпочтений.
    • Извлечённые данные затем используются для создания персонализированных рекомендаций или действий.
  3. Динамическая генерация запросов:
    • ИИ-агент генерирует динамические SQL-запросы на основе контекста и потребностей пользователя.
    • Пример: настройка SQL-запросов для фильтрации результатов по бюджету, датам и интересам.

Применения

Пример: Агент анализа данных:

  1. Задача: анализировать набор данных для выявления трендов.
  2. Шаги:
    • Загрузить набор данных.
    • Генерировать SQL-запросы для фильтрации данных.
    • Выполнить запросы и получить результаты.
    • Создать визуализации и инсайты.
  3. Ресурсы: доступ к набору данных, возможности SQL.
  4. Опыт: использование прошлых результатов для улучшения будущего анализа.

Практический пример: использование SQL в Туристическом агенте

  1. Сбор предпочтений пользователя

    class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

  2. Генерация SQL-запросов

    def generate_sql_query(table, preferences):
    query = f"SELECT * FROM {table} WHERE "
    conditions = []
    for key, value in preferences.items():
        conditions.append(f"{key}='{value}'")
    query += " AND ".join(conditions)
    return query

  3. Выполнение SQL-запросов

    import sqlite3

def execute_sql_query(query, database="travel.db"):
    connection = sqlite3.connect(database)
    cursor = connection.cursor()
    cursor.execute(query)
    results = cursor.fetchall()
    connection.close()
    return results

  4. Генерация рекомендаций

    def generate_recommendations(preferences):
    flight_query = generate_sql_query("flights", preferences)
    hotel_query = generate_sql_query("hotels", preferences)
    attraction_query = generate_sql_query("attractions", preferences)
       
    flights = execute_sql_query(flight_query)
    hotels = execute_sql_query(hotel_query)
    attractions = execute_sql_query(attraction_query)
       
    itinerary = {
        "flights": flights,
        "hotels": hotels,
        "attractions": attractions
    }
    return itinerary

travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = generate_recommendations(preferences)
print("Suggested Itinerary:", itinerary)

Пример SQL-запросов

  1. Запрос по рейсам

    SELECT * FROM flights WHERE destination='Paris' AND dates='2025-04-01 to 2025-04-10' AND budget='moderate';

  2. Запрос по отелям

    SELECT * FROM hotels WHERE destination='Paris' AND budget='moderate';

  3. Запрос по достопримечательностям

    SELECT * FROM attractions WHERE destination='Paris' AND interests='museums, cuisine';

Используя SQL как часть техники Retrieval-Augmented Generation (RAG), ИИ-агенты, такие как Туристический агент, могут динамически извлекать и использовать релевантные данные для предоставления точных и персонализированных рекомендаций.

Пример метакогниции

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

Мы смоделируем это на базовом примере, где агент выбирает отели на основе сочетания цены и качества, но “задумывается” о своих решениях и корректируется соответственно.

Как это иллюстрирует метакогницию:

  1. Первоначальное решение: агент выберет самый дешевый отель, не учитывая качество.
  2. Рефлексия и оценка: после первого выбора агент проверит, является ли отель “плохим”, используя отзывы пользователя. Если качество отеля окажется слишком низким, агент рефлексирует над своими рассуждениями.
  3. Коррекция стратегии: агент изменит свою стратегию на основе рефлексии, переключаясь с “самого дешевого” на “самое высокое качество”, улучшая процесс принятия решений в будущих итерациях.

Вот пример:

class HotelRecommendationAgent:
    def __init__(self):
        self.previous_choices = []  # Сохраняет ранее выбранные отели
        self.corrected_choices = []  # Сохраняет исправленные выборы
        self.recommendation_strategies = ['cheapest', 'highest_quality']  # Доступные стратегии

    def recommend_hotel(self, hotels, strategy):
        """
        Recommend a hotel based on the chosen strategy.
        The strategy can either be 'cheapest' or 'highest_quality'.
        """
        if strategy == 'cheapest':
            recommended = min(hotels, key=lambda x: x['price'])
        elif strategy == 'highest_quality':
            recommended = max(hotels, key=lambda x: x['quality'])
        else:
            recommended = None
        self.previous_choices.append((strategy, recommended))
        return recommended

    def reflect_on_choice(self):
        """
        Reflect on the last choice made and decide if the agent should adjust its strategy.
        The agent considers if the previous choice led to a poor outcome.
        """
        if not self.previous_choices:
            return "No choices made yet."

        last_choice_strategy, last_choice = self.previous_choices[-1]
        # Предположим, у нас есть обратная связь от пользователя, которая говорит, был ли последний выбор хорошим или нет
        user_feedback = self.get_user_feedback(last_choice)

        if user_feedback == "bad":
            # Корректировать стратегию, если предыдущий выбор был неудовлетворительным
            new_strategy = 'highest_quality' if last_choice_strategy == 'cheapest' else 'cheapest'
            self.corrected_choices.append((new_strategy, last_choice))
            return f"Reflecting on choice. Adjusting strategy to {new_strategy}."
        else:
            return "The choice was good. No need to adjust."

    def get_user_feedback(self, hotel):
        """
        Simulate user feedback based on hotel attributes.
        For simplicity, assume if the hotel is too cheap, the feedback is "bad".
        If the hotel has quality less than 7, feedback is "bad".
        """
        if hotel['price'] < 100 or hotel['quality'] < 7:
            return "bad"
        return "good"

# Смоделировать список отелей (цена и качество)
hotels = [
    {'name': 'Budget Inn', 'price': 80, 'quality': 6},
    {'name': 'Comfort Suites', 'price': 120, 'quality': 8},
    {'name': 'Luxury Stay', 'price': 200, 'quality': 9}
]

# Создать агента
agent = HotelRecommendationAgent()

# Шаг 1: Агент рекомендует отель, используя стратегию "самый дешевый"
recommended_hotel = agent.recommend_hotel(hotels, 'cheapest')
print(f"Recommended hotel (cheapest): {recommended_hotel['name']}")

# Шаг 2: Агент анализирует выбор и при необходимости корректирует стратегию
reflection_result = agent.reflect_on_choice()
print(reflection_result)

# Шаг 3: Агент снова рекомендует отель, на этот раз используя скорректированную стратегию
adjusted_recommendation = agent.recommend_hotel(hotels, 'highest_quality')
print(f"Adjusted hotel recommendation (highest_quality): {adjusted_recommendation['name']}")

Способности метакогниции агентов

Главное здесь — способность агента:

Это простая форма метакогниции, при которой система способна корректировать процесс рассуждений на основе внутренней обратной связи.

Заключение

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

Есть вопросы по шаблону проектирования метакогниции?

Присоединяйтесь к Microsoft Foundry Discord, чтобы встретиться с другими изучающими, посетить офисные часы и получить ответы на вопросы по ИИ-агентам.

Предыдущий урок

Multi-Agent Design Pattern

Следующий урок

AI Agents in Production

Отказ от ответственности: Этот документ был переведен с использованием сервиса машинного перевода Co-op Translator. Несмотря на наши усилия по обеспечению точности, имейте в виду, что автоматический перевод может содержать ошибки или неточности. Оригинальный документ на его исходном языке следует считать авторитетным источником. Для получения критически важной информации рекомендуется обратиться к профессиональному человеческому переводу. Мы не несем ответственности за любые недоразумения или неправильные толкования, возникшие в результате использования этого перевода.

This site is open source. Improve this page.