ai-agents-for-beginners

(Кликнете върху горното изображение, за да гледате видеото на този урок)

Метакогниция при AI агенти

Въведение

Добре дошли в урока за метакогниция при AI агенти! Тази глава е предназначена за начинаещи, които се интересуват как AI агентите могат да мислят за собствените си процеси на мислене. В края на този урок ще разберете основните концепции и ще бъдете оборудвани с практически примери за прилагане на метакогницията в дизайна на AI агенти.

Цели на обучението

След завършване на този урок ще можете:

1. Да разберете последиците от цикъл на разсъждение в дефинициите на агенти.
2. Да използвате техники за планиране и оценка, за да подпомогнете самокоригиращи се агенти.
3. Да създавате собствени агенти, способни да манипулират код за изпълнение на задачи.

Въведение в Метакогницията

Метакогницията се отнася до по-висшия когнитивен процес, който включва мислене за собственото мислене. За AI агентите това означава способността да оценяват и коригират действията си въз основа на самосъзнание и минал опит. Метакогницията, или „мисленето за мислене“, е важна концепция в развитието на агентни AI системи. Тя включва AI системи, които са осъзнати за собствените си вътрешни процеси и могат да наблюдават, регулират и адаптират поведението си съответно. Подобно на това, което правим, когато „чете помещение“ или се взира в проблем. Това самосъзнание може да помогне на AI системите да вземат по-добри решения, да идентифицират грешки и да подобрят изпълнението си с течение на времето – отново връщайки се към теста на Тюринг и дебата дали AI ще поеме контрола.

В контекста на агентните AI системи, метакогницията може да помогне за справяне с няколко предизвикателства, като например:

• Прозрачност: Осигуряване на възможността AI системите да обясняват своето разсъждение и решения.
• Разсъждение: Подобряване на способността на AI системите да синтезират информация и да вземат обосновани решения.
• Адаптация: Позволяване на AI системите да се адаптират към нови среди и променящи се условия.
• Възприятие: Подобряване на точността на AI системите при разпознаване и интерпретиране на данни от тяхната среда.

Какво е Метакогниция?

Метакогницията, или „мислене за мислене“, е процес на по-високо ниво, който включва самосъзнание и саморегулация на когнитивните процеси. В областта на AI тя дава възможност на агентите да оценяват и адаптират своите стратегии и действия, което води до подобрени способности за решаване на проблеми и вземане на решения. Чрез разбирането на метакогницията можете да проектирате AI агенти, които не са само по-интелигентни, но и по-гъвкави и ефективни. При истинската метакогниция бихте видели как AI изрично разсъждава за собственото си разсъждение.

Пример: „Предпочетох по-евтини полети, защото… може би изпускам директни полети, така че ще проверя отново.“ Следене как или защо е избрала определен маршрут.

• Забелязване на грешки, защото се е доверила твърде много на предпочитанията на потребителя от предишния път, затова модифицира стратегията си за вземане на решения, а не само крайната препоръка.
• Диагностициране на модели като: „Винаги когато потребителят спомене „прекалено претъпкано“, не трябва само да премахвам определени атракции, но и да осъзная, че методът ми за избор на „най-добрите атракции“ е дефектен, ако винаги класирам по популярност.“

Значението на Метакогницията при AI Агенти

Метакогницията играе решаваща роля в дизайна на AI агенти по няколко причини:

• Саморефлексия: Агентите могат да оценяват собственото си изпълнение и да идентифицират области за подобрение.
• Адаптивност: Агентите могат да модифицират стратегиите си въз основа на минал опит и променяща се среда.
• Коригиране на грешки: Агентите могат автономно да откриват и коригират грешки, водещи до по-точни резултати.
• Управление на ресурси: Агентите могат да оптимизират използването на ресурси като време и изчислителна мощ чрез планиране и оценка на действията си.

Компоненти на AI агент

Преди да се потопим в метакогнитивните процеси, е важно да разберем основните компоненти на AI агент. Обикновено AI агентът се състои от:

• Личност: Личността и характеристиките на агента, които определят как взаимодейства с потребителите.
• Инструменти: Възможностите и функциите, които агентът може да изпълнява.
• Умения: Знанията и експертизата, с които агентът разполага.

Тези компоненти работят заедно, за да създадат „експертна единица“, способна да изпълнява конкретни задачи.

Пример: Помислете за туристически агент, услуга, която не само планира вашата почивка, но и адаптира пътя си въз основа на данни в реално време и минал опит на клиенти.

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

Представете си, че проектирате туристическа агентска услуга, управлявана от AI. Този агент, „Туристически агент“, помага на потребителите да планират ваканциите си. За да включи метакогниция, Туристически агент трябва да оценява и коригира действията си въз основа на самосъзнание и минал опит. Ето как метакогницията може да играе роля:

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

Текущата задача е да помогне на потребител да планира пътуване до Париж.

Стъпки за изпълнение на задачата

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. Планиране при агенти

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

Елементи на планирането

• Текуща задача: Задайте ясно задачата.
• Стъпки за изпълнение на задачата: Разбийте задачата на управляеми стъпки.
• Необходими ресурси: Идентифицирайте необходимите ресурси.
• Опит: Използвайте минал опит за информиране на планирането.

Пример: Ето стъпките, които Туристически агент трябва да предприеме, за да помогне ефективно на потребител при планирането на пътуване:

Стъпки за Туристически агент

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 инструмент и предварително зареждане на контекст

Retrieval-Augmented Generation (RAG)

RAG комбинира система за извличане със генеративен модел. Когато се направи заявка, системата за извличане намира подходящи документи или данни от външен източник, а тази извлечена информация се използва за обогатяване на входните данни към генеративния модел. Това помага на модела да генерира по-точни и контекстуално подходящи отговори.

В RAG система агентът извлича релевантна информация от база знания и я използва, за да генерира подходящи отговори или действия.

Коригиращ RAG подход

Коригиращият RAG подход се фокусира върху използване на RAG техники за коригиране на грешки и подобряване на точността на AI агентите. Това включва:

1. Техника на подканване: Използване на конкретни подканващи заявки, които да насочат агента към извличане на релевантна информация.
2. Инструмент: Прилагане на алгоритми и механизми, които позволяват на агента да оцени релевантността на извлечената информация и да генерира точни отговори.
3. Оценяване: Непрекъснато оценяване на изпълнението на агента и правене на корекции за подобряване на точността и ефективността.

Пример: Коригиращ RAG при търсещ агент

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

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

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

Коригиращият RAG (Retrieval-Augmented Generation) подобрява способността на AI да извлича и генерира информация, като коригира неточности. Нека видим как Туристически агент може да използва този подход, за да предостави по-точни и релевантни препоръки за пътуване.

Това включва:

• Техника на подканване: Използване на конкретни подканващи заявки за насочване към релевантна информация.
• Инструмент: Прилагане на алгоритми и механизми, позволяващи на агента да оцени релевантността на извлечената информация и да генерира точни отговори.
• Оценяване: Непрекъснато оценяване на изпълнението и корекциите за повишаване на точността и ефективността.

Стъпки за прилагане на Коригиращия 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): Този метод изчислява общата цена на текущия план, включително потенциална нова дестинация.

Примерна употреба

• Начален план: Туристическият агент създава начален план въз основа на предпочитанията на клиента за разглеждане на забележителности и бюджет от $2000.
• Усъвършенстван план: Туристическият агент прави итерации на плана, оптимизирайки го според предпочитанията и бюджета на клиента.

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

Използване на големи езикови модели (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
        }
        
        # Извикай Azure OpenAI API, за да получиш ребалансирани и оценени дестинации
        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)

Обяснение на кода – Preference Booker

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

2. Получаване на препоръки (метод get_recommendations): Този метод генерира запитване към Azure OpenAI услугата, базирано на потребителските предпочитания, и прави HTTP POST заявка към Azure OpenAI API за получаване на преподредени и оценени дестинации.

3. Генериране на запитване (метод generate_prompt): Този метод съставя запитване за Azure OpenAI, включващо потребителските предпочитания и списъка с дестинации. Запитването насочва модела да преподреди и оцени дестинациите според предоставените предпочитания.

4. API извикване: Библиотеката requests се използва за HTTP POST заявка към края на API на Azure OpenAI. Отговорът съдържа преподредени и оценени дестинации.

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

Уверете се, че сте заменили your_azure_openai_api_key с вашия реален Azure OpenAI API ключ и https://your-endpoint.com/... с действителния URL на крайна точка за вашето Azure OpenAI разполагане.

Чрез използване на LLM за преподреждане и оценка, туристическият агент може да предоставя по-персонализирани и релевантни препоръки за пътуване на клиентите, подобрявайки цялостното им изживяване.

RAG: Техника за подсказване срещу Инструмент

Retrieval-Augmented Generation (RAG) може да бъде както техника за подсказване, така и инструмент при разработката на AI агенти. Разбирането на разликата между двете може да ви помогне да използвате RAG по-ефективно във вашите проекти.

RAG като техника за подсказване

Какво представлява?

• Като техника за подсказване, RAG включва формулиране на конкретни заявки или подсказки за насочване към извличане на релевантна информация от голям корпус или база данни. Тази информация след това се използва за генериране на отговори или действия.

Как работи:

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

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

• Вход от потребителя: “Искам да посетя музеи в Париж.”
• Подсказка: “Намери най-добрите музеи в Париж.”
• Извлечена информация: Детайли за Лувъра, Музеят Орсе и други.
• Генериран отговор: “Ето някои от най-добрите музеи в Париж: Лувър, Музей Орсе и Център Помпиду.”

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

Какво представлява?

• Като инструмент, RAG е интегрирана система, която автоматизира процеса на извличане и генериране, улеснявайки разработчиците при реализирането на комплексни AI функционалности без нужда ръчно да се изготвят подсказки за всяка заявка.

Как работи:

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

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

• Вход от потребителя: “Искам да посетя музеи в Париж.”
• RAG инструмент: Автоматично извлича информация за музеи и генерира отговор.
• Генериран отговор: “Ето някои от най-добрите музеи в Париж: Лувър, Музей Орсе и Център Помпиду.”

Сравнение

Аспект	Техника за подсказване	Инструмент
Ръчно срещу Автоматично	Ръчно формулиране на подсказки за всяка заявка	Автоматизиран процес за извличане и генериране
Контрол	Предлага повече контрол над процеса на извличане	Оптимизира и автоматизира процеса на извличане и генериране
Гъвкавост	Позволява персонализиране на подсказките според конкретни нужди	По-ефективен за големи реализации
Сложност	Изисква изготвяне и оптимизиране на подсказки	По-лесно се интегрира в архитектурата на 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. Оценка на релевантност:
   • Присвояване на оценка за релевантност на всеки изведен елемент въз основа на съвпадението му със заявката и предпочитанията на потребителя.

   • Пример:

     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. Персонализация:
   • Персонализиране на резултатите от търсенето въз основа на историята, предпочитанията и обратната връзка на потребителя, което подобрява релевантността на извлечената информация.

Практически пример: Търсене с намерение в туристически агент

Нека вземем туристически агент като пример, за да видим как може да се реализира търсене с намерение.

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. Генериране на код като инструмент

Агентите, които генерират код, използват AI модели за писане и изпълнение на код, решавайки комплексни задачи и автоматизирайки процеси.

Агентите за генериране на код

Агентите за генериране на код използват генеративни AI модели за писане и изпълнение на код. Тези агенти могат да решават сложни проблеми, да автоматизират задачи и да предоставят ценни прозрения чрез генериране и изпълнение на код на различни програмни езици.

Практически приложения

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

Пример: Агент за генериране на код за анализ на данни

Представете си, че проектирате агент за генериране на код. Ето как може да работи:

1. Задача: Анализирайте набор от данни, за да идентифицирате тенденции и модели.
2. Стъпки:
   • Заредете набора от данни в инструмент за анализ на данни.
   • Генерирайте SQL заявки за филтриране и агрегиране на данните.
   • Изпълнете заявките и извлечете резултатите.
   • Използвайте резултатите за създаване на визуализации и прозрения.
3. Необходими ресурси: Достъп до набора от данни, инструменти за анализ на данни и възможности за SQL.
4. Опит: Използвайте предишни анализи, за да подобрите точността и релевантността на бъдещите анализи.

Пример: Агент за генериране на код за туристически агент

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

Преглед на агента за генериране на код

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 може да извлича релевантни данни от бази данни, които да информират и генерират отговори или действия в AI агенти. Нека разгледаме как SQL може да се използва като RAG техника в контекста на Туристическия агент.

Ключови понятия

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

Приложения

• Автоматизирано генериране на код: Генериране на кодови фрагменти за конкретни задачи.
• SQL като RAG: Използване на 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), AI агенти като Туристическия агент могат динамично да извличат и използват релевантни данни, за да предоставят точни и персонализирани препоръки.

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

За да демонстрираме имплементация на метакогниция, нека създадем прост агент, който размисля върху процеса си на вземане на решения при решаването на проблем. За този пример ще изградим система, в която агентът се опитва да оптимизира избора на хотел, но след това оценява собственото си разсъждение и коригира стратегията си при допускане на грешки или подоптимални решения.

Ще симулираме това с базов пример, в който агентът избира хотели въз основа на комбинация от цена и качество, но „размисля“ върху решенията и се адаптира съответно.

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

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']}")

Метакогнитивни способности на агентите

Ключовото тук е способността на агента да:

• Оценява предишните си избори и процеса на вземане на решения.
• Коригира стратегията си въз основа на този размисъл, т.е. метакогниция в действие.

Това е проста форма на метакогниция, при която системата може да адаптира процеса си на разсъждение въз основа на вътрешна обратна връзка.

Заключение

Метакогницията е мощен инструмент, който значително може да подобри възможностите на AI агентите. Като включите метакогнитивни процеси, можете да проектирате агенти, които са по-интелигентни, адаптивни и ефективни. Използвайте допълнителните ресурси, за да изследвате по-нататък завладяващия свят на метакогницията в AI агентите.

Имали ли сте още въпроси относно дизайна на метакогницията?

Присъединете се към Microsoft Foundry Discord, за да се срещнете с други обучаващи се, да посещавате консултации и да получите отговори на въпросите си за AI агенти.

Предишен урок

Многоагентен дизайн патърн

Следващ урок

AI агенти в продукция

---

Отказ от отговорност: Този документ е преведен с помощта на AI преводачески услуга Co-op Translator. Въпреки че се стремим към точност, моля имайте предвид, че автоматизираните преводи могат да съдържат грешки или неточности. Оригиналният документ на неговия роден език трябва да се счита за авторитетен източник. За критична информация се препоръчва професионален човешки превод. Ние не носим отговорност за каквито и да е недоразумения или неправилни тълкувания, произтичащи от използването на този превод.

This site is open source. Improve this page.