ai-agents-for-beginners

(Faceți clic pe imaginea de mai sus pentru a viziona videoclipul acestei lecții)

Metacogniția în Agenții AI

Introducere

Bine ați venit la lecția despre metacogniția în agenții AI! Acest capitol este conceput pentru începători curioși despre cum agenții AI pot gândi despre propriile lor procese de gândire. La sfârșitul acestei lecții, veți înțelege concepte cheie și veți fi echipat cu exemple practice pentru a aplica metacogniția în proiectarea agenților AI.

Obiective de Învățare

După ce parcurgeți această lecție, veți putea:

1. Înțelege implicațiile buclelor de raționament în definițiile agenților.
2. Folosi tehnici de planificare și evaluare pentru a ajuta agenții să se autocorecteze.
3. Creați proprii agenți capabili să manipuleze coduri pentru a îndeplini sarcini.

Introducere în Metacogniție

Metacogniția se referă la procesele cognitive de ordin superior care implică gândirea despre propria gândire. Pentru agenții AI, aceasta înseamnă abilitatea de a evalua și ajusta acțiunile lor bazându-se pe conștientizarea de sine și experiențele trecute. Metacogniția, sau „gândirea despre gândire,” este un concept important în dezvoltarea sistemelor AI agentice. Aceasta implică ca sistemele AI să fie conștiente de propriile procese interne și să poată monitoriza, regla și adapta comportamentul în consecință. Asemenea modului în care facem noi când citim atmosfera sau analizăm o problemă. Această conștientizare de sine poate ajuta sistemele AI să ia decizii mai bune, să identifice erori și să își îmbunătățească performanța în timp - făcând legătura din nou cu testul Turing și dezbaterea dacă AI va prelua controlul.

În contextul sistemelor AI agentice, metacogniția poate ajuta la rezolvarea mai multor provocări, cum ar fi:

• Transparență: Asigurarea că sistemele AI pot explica raționamentul și deciziile lor.
• Raționament: Îmbunătățirea capacității sistemelor AI de a sintetiza informații și a lua decizii corecte.
• Adaptare: Permițând sistemelor AI să se adapteze la medii noi și condiții în schimbare.
• Percepție: Îmbunătățirea acurateței sistemelor AI în recunoașterea și interpretarea datelor din mediul înconjurător.

Ce este Metacogniția?

Metacogniția, sau „gândirea despre gândire,” este un proces cognitiv de ordin superior care implică conștientizarea de sine și autoreglarea propriilor procese cognitive. În domeniul AI, metacogniția oferă agenților puterea de a evalua și adapta strategiile și acțiunile lor, conducând la îmbunătățirea capacităților de rezolvare a problemelor și luare a deciziilor. Prin înțelegerea metacogniției, puteți proiecta agenți AI care nu sunt doar mai inteligenți, ci și mai adaptabili și eficienți. În adevărata metacogniție, ați vedea AI raționând explicit despre propriul său raționament.

Exemplu: „Am prioritizat zborurile mai ieftine pentru că… S-ar putea să pierd zboruri directe, așa că voi verifica din nou.”. Urmărind cum sau de ce a ales un anumit traseu.

• Observând că a făcut greșeli deoarece s-a bazat prea mult pe preferințele utilizatorului de data trecută, deci își modifică strategia de luare a deciziei și nu doar recomandarea finală.
• Diagnosticând tipare, cum ar fi „Ori de câte ori văd că utilizatorul menționează ‘prea aglomerat’, nu ar trebui doar să elimin anumite atracții, ci și să reflectez că metoda mea de selectare a ‘atracțiilor principale’ este defectuoasă dacă le ordonez întotdeauna după popularitate.”

Importanța Metacogniției în Agenții AI

Metacogniția joacă un rol esențial în proiectarea agenților AI din mai multe motive:

• Auto-reflecție: Agenții pot evalua propria performanță și pot identifica zone de îmbunătățit.
• Adaptabilitate: Agenții își pot modifica strategiile bazându-se pe experiențe trecute și medii în schimbare.
• Corectare a erorilor: Agenții pot detecta și corecta erori în mod autonom, conducând la rezultate mai precise.
• Gestionarea resurselor: Agenții pot optimiza utilizarea resurselor, cum ar fi timpul și puterea de calcul, prin planificarea și evaluarea acțiunilor lor.

Componentele unui Agent AI

Înainte de a intra în procese metacognitive, este esențial să înțelegem componentele de bază ale unui agent AI. Un agent AI constă de obicei din:

• Persona: Personalitatea și caracteristicile agentului, care definesc modul în care interacționează cu utilizatorii.
• Unelte: Capacitățile și funcțiile pe care le poate realiza agentul.
• Abilități: Cunoștințele și expertiza de care dispune agentul.

Aceste componente lucrează împreună pentru a crea o „unitate de expertiză” capabilă să execute sarcini specifice.

Exemplu: Luați în considerare un agent de turism, un serviciu agent care nu numai că vă planifică vacanța, dar își ajustează traseul pe baza datelor în timp real și a experiențelor trecute ale clienților.

Exemplu: Metacogniția într-un Serviciu Agent de Turism

Imaginați-vă că proiectați un serviciu agent de turism alimentat de AI. Acest agent, „Travel Agent,” asistă utilizatorii în planificarea vacanțelor lor. Pentru a integra metacogniția, Travel Agent trebuie să evalueze și să își ajusteze acțiunile bazându-se pe conștientizarea de sine și experiențele trecute. Iată cum ar putea juca metacogniția un rol:

Sarcina Curentă

Sarcina curentă este să ajute un utilizator să planifice o excursie la Paris.

Pași pentru Finalizarea Sarcinii

1. Colectarea Preferințelor Utilizatorului: Întrebați utilizatorul despre datele de călătorie, buget, interese (de ex., muzee, gastronomie, cumpărături) și orice cerințe specifice.
2. Recuperarea Informațiilor: Căutați opțiuni de zbor, cazare, atracții și restaurante care se potrivesc preferințelor utilizatorului.
3. Generarea Recomandărilor: Oferiți un itinerar personalizat cu detalii despre zbor, rezervări la hotel și activități sugerate.
4. Ajustarea pe baza Feedback-ului: Solicitați feedback utilizatorului asupra recomandărilor și faceți ajustările necesare.

Resurse Necesare

• Acces la baze de date pentru rezervări de zboruri și hoteluri.
• Informații despre atracțiile și restaurantele pariziene.
• Date de feedback ale utilizatorilor din interacțiuni anterioare.

Experiență și Auto-reflecție

Travel Agent folosește metacogniția pentru a evalua performanța și a învăța din experiențele trecute. De exemplu:

1. Analiza Feedback-ului Utilizatorului: Travel Agent examinează feedback-ul utilizatorului pentru a determina care recomandări au fost bine primite și care nu. Își ajustează sugestiile viitoare în consecință.
2. Adaptabilitate: Dacă un utilizator a menționat anterior că nu îi plac locurile aglomerate, Travel Agent va evita să recomande puncte turistice populare în orele de vârf pe viitor.
3. Corectarea Erorilor: Dacă Travel Agent a făcut o eroare într-o rezervare anterioară, precum sugerarea unui hotel complet ocupat, învață să verifice disponibilitatea mai riguros înainte de a face recomandări.

Exemplu Practic pentru Dezvoltatori

Iată un exemplu simplificat de cod pentru Travel Agent care încorporează metacogniția:

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):
        # Caută zboruri, hoteluri și atracții în funcție de preferințe
        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)
        # Analizează feedback-ul și ajustează recomandările viitoare
        self.user_preferences = adjust_preferences(self.user_preferences, feedback)

# Exemplu de utilizare
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)

De ce este importantă Metacogniția

• Auto-reflecție: Agenții pot analiza performanța și identifica zone de îmbunătățit.
• Adaptabilitate: Agenții pot modifica strategiile bazându-se pe feedback și condiții schimbătoare.
• Corectarea Erorilor: Agenții pot detecta și corecta greșelile în mod autonom.
• Gestionarea Resurselor: Agenții pot optimiza utilizarea resurselor, cum ar fi timpul și puterea de calcul.

Prin încorporarea metacogniției, Travel Agent poate oferi recomandări de călătorie mai personalizate și mai precise, îmbunătățind experiența generală a utilizatorului.

---

2. Planificarea în Agenți

Planificarea este o componentă critică a comportamentului agenților AI. Aceasta implică conturarea pașilor necesari pentru atingerea unui scop, luând în considerare starea actuală, resursele și posibilele obstacole.

Elemente ale Planificării

• Sarcina Curentă: Definiți clar sarcina.
• Pași pentru Finalizarea Sarcinii: Descompuneți sarcina în pași gestionabili.
• Resurse Necesare: Identificați resursele necesare.
• Experiență: Utilizați experiențele trecute pentru a informa planificarea.

Exemplu: Iată pașii pe care Travel Agent trebuie să îi urmeze pentru a ajuta un utilizator să-și planifice eficient călătoria:

Pași pentru Travel Agent

1. Colectarea Preferințelor Utilizatorului
   • Întrebați utilizatorul detalii despre datele de călătorie, buget, interese și orice cerințe specifice.
   • Exemple: „Când intenționați să călătoriți?” „Care este intervalul dvs. de buget?” „Ce activități vă plac în vacanță?”
2. Recuperarea Informațiilor
   • Căutați opțiuni relevante de călătorie pe baza preferințelor utilizatorului.
   • Zboruri: Căutați zboruri disponibile în bugetul și datele de călătorie preferate ale utilizatorului.
   • Cazare: Găsiți hoteluri sau proprietăți de închiriat care corespund preferințelor utilizatorului privind locația, prețul și facilitățile.
   • Atracții și Restaurante: Identificați atracții populare, activități și opțiuni de luat masa care se aliniază intereselor utilizatorului.
3. Generarea Recomandărilor
   • Compilați informațiile recuperate într-un itinerar personalizat.
   • Oferiți detalii precum opțiuni de zbor, rezervări la hotel și activități sugerate, asigurându-vă că recomandările sunt adaptate preferințelor utilizatorului.
4. Prezentarea Itinerarului Utilizatorului
   • Partajați itinerariul propus cu utilizatorul pentru revizuire.
   • Exemplu: „Iată un itinerar sugerat pentru călătoria dvs. la Paris. Include detalii despre zbor, rezervări la hotel și o listă de activități și restaurante recomandate. Spuneți-mi părerile dvs.!”
5. Colectarea Feedback-ului
   • Cereți utilizatorului feedback despre itinerariul propus.
   • Exemple: „Vă plac opțiunile de zbor?” „Hotelul este potrivit pentru nevoile dvs.?” „Există activități pe care doriți să le adăugați sau eliminați?”
6. Ajustarea pe baza Feedback-ului
   • Modificați itinerarul bazându-vă pe feedback-ul utilizatorului.
   • Faceți schimbările necesare privind zborul, cazarea și recomandările de activități pentru a se potrivi mai bine preferințelor utilizatorului.
7. Confirmarea Finală
   • Prezentați itinerarul actualizat utilizatorului pentru confirmarea finală.
   • Exemplu: „Am făcut ajustările bazate pe feedback-ul dvs. Iată itinerarul actualizat. Totul arată bine pentru dvs.?”
8. Rezervarea și Confirmarea Rezervărilor
   • După aprobare, continuați cu rezervarea zborurilor, cazarelor și activităților preplanificate.
   • Trimiteți detaliile de confirmare utilizatorului.
9. Oferirea Suportului Continu
   • Rămâneți disponibil pentru a asista utilizatorul cu orice modificări sau cereri suplimentare înainte și în timpul călătoriei.
   • Exemplu: „Dacă aveți nevoie de orice ajutor suplimentar în timpul călătoriei, nu ezitați să mă contactați oricând!”

Exemplu de Interacțiune

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)

# Exemplu de utilizare într-o cerere de booing
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. Sistem RAG Corectiv

În primul rând, să înțelegem diferența dintre Instrumentul RAG și Încărcarea Contextuală Preemptivă

Generare Augmentată prin Recuperare (RAG)

RAG combină un sistem de recuperare cu un model generativ. Când se face o interogare, sistemul de recuperare extrage documente sau date relevante dintr-o sursă externă, iar aceste informații recuperate sunt folosite pentru a completa datele de intrare ale modelului generativ. Acest lucru ajută modelul să genereze răspunsuri mai exacte și contextuale.

Într-un sistem RAG, agentul recuperează informații relevante dintr-o bază de cunoștințe și le folosește pentru a genera răspunsuri sau acțiuni potrivite.

Abordarea RAG Corectiv

Abordarea RAG Corectiv se concentrează pe utilizarea tehnicilor RAG pentru a corecta erori și a îmbunătăți acuratețea agenților AI. Aceasta implică:

1. Tehnica de Promptare: Folosirea prompturilor specifice pentru a ghida agentul în recuperarea informațiilor relevante.
2. Instrument: Implementarea de algoritmi și mecanisme care permit agentului să evalueze relevanța informațiilor recuperate și să genereze răspunsuri precise.
3. Evaluare: Evaluarea continuă a performanței agentului și ajustarea pentru a îi îmbunătăți acuratețea și eficiența.

Exemplu: RAG Corectiv într-un Agent de Căutare

Luați în considerare un agent de căutare care preia informații de pe web pentru a răspunde la întrebările utilizatorilor. Abordarea RAG Corectiv ar putea implica:

1. Tehnica de Promptare: Formularea de interogări de căutare bazate pe inputul utilizatorului.
2. Instrument: Utilizarea procesării limbajului natural și algoritmi de învățare automată pentru a clasifica și filtra rezultatele căutării.
3. Evaluare: Analiza feedback-ului utilizatorului pentru a identifica și corecta inexactitățile din informațiile recuperate.

RAG Corectiv în Travel Agent

RAG Corectiv (Generare Augmentată prin Recuperare) îmbunătățește abilitatea AI de a recupera și genera informații în timp ce corectează orice inexactități. Să vedem cum poate Travel Agent să folosească abordarea RAG Corectiv pentru a oferi recomandări de călătorie mai precise și relevante.

Aceasta implică:

• Tehnica de Promptare: Folosirea prompturilor specifice pentru a ghida agentul în recuperarea informațiilor relevante.
• Instrument: Implementarea algoritmilor și mecanismelor care permit agentului să evalueze relevanța informațiilor recuperate și să genereze răspunsuri precise.
• Evaluare: Evaluarea continuă a performanței agentului și ajustări pentru a îmbunătăți acuratețea și eficiența.

Pași pentru implementarea RAG Corectiv în Travel Agent

1. Interacțiunea Inițială cu Utilizatorul
   • Travel Agent colectează preferințele inițiale ale utilizatorului, cum ar fi destinația, datele de călătorie, bugetul și interesele.

   • Exemplu:

     preferences = {
         "destination": "Paris",
         "dates": "2025-04-01 to 2025-04-10",
         "budget": "moderate",
         "interests": ["museums", "cuisine"]
     }
     

2. Recuperarea Informațiilor
   • Travel Agent preia informații despre zboruri, cazări, atracții și restaurante pe baza preferințelor utilizatorului.

   • Exemplu:

     flights = search_flights(preferences)
     hotels = search_hotels(preferences)
     attractions = search_attractions(preferences)
     

3. Generarea Recomandărilor Inițiale
   • Travel Agent folosește informațiile recuperate pentru a genera un itinerar personalizat.

   • Exemplu:

     itinerary = create_itinerary(flights, hotels, attractions)
     print("Suggested Itinerary:", itinerary)
     

4. Colectarea Feedback-ului Utilizatorului
   • Travel Agent solicită utilizatorului păreri despre recomandările inițiale.

   • Exemplu:

     feedback = {
         "liked": ["Louvre Museum"],
         "disliked": ["Eiffel Tower (too crowded)"]
     }
     

5. Procesul RAG Corectiv
   • Tehnica de Promptare: Travel Agent formulează noi interogări bazate pe feedback-ul utilizatorului.

     • Exemplu:

       if "disliked" in feedback:
           preferences["avoid"] = feedback["disliked"]
       

   • Instrument: Travel Agent folosește algoritmi pentru a clasifica și filtra noile rezultate de căutare, accentuând relevanța pe baza feedback-ului utilizatorului.

     • Exemplu:

       new_attractions = search_attractions(preferences)
       new_itinerary = create_itinerary(flights, hotels, new_attractions)
       print("Updated Itinerary:", new_itinerary)
       

   • Evaluare: Travel Agent evaluează continuu relevanța și precizia recomandărilor prin analiza feedback-ului utilizatorului și face ajustările necesare.

     • Exemplu:

       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)
       

Exemplu Practic

Iată un exemplu simplificat de cod Python care încorporează abordarea RAG Corectiv în Travel Agent:

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

# Exemplu de utilizare
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)

Încărcarea Contextuală Preemptivă

Încărcarea Contextului Pre-emptiv implică încărcarea contextului relevant sau a informațiilor de fundal în model înainte de a procesa o interogare. Aceasta înseamnă că modelul are acces la aceste informații încă de la început, ceea ce îl poate ajuta să genereze răspunsuri mai informate fără a fi nevoie să recupereze date suplimentare pe parcurs.

Iată un exemplu simplificat de cum ar putea arăta o încărcare a contextului pre-emptiv pentru o aplicație de agent de turism în Python:

class TravelAgent:
    def __init__(self):
        # Preîncărcați destinațiile populare și informațiile acestora
        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):
        # Preluați informații despre destinație din contextul preîncărcat
        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}."

# Exemplu de utilizare
travel_agent = TravelAgent()
print(travel_agent.get_destination_info("Paris"))
print(travel_agent.get_destination_info("Tokyo"))

Explicație

1. Inițializare (metoda __init__): Clasa TravelAgent încarcă preventiv un dicționar care conține informații despre destinații populare precum Paris, Tokyo, New York și Sydney. Acest dicționar include detalii precum țara, moneda, limba și principalele atracții pentru fiecare destinație.

2. Recuperarea Informațiilor (metoda get_destination_info): Când un utilizator interoghează despre o anumită destinație, metoda get_destination_info preia informațiile relevante din dicționarul de context încărcat preventiv.

Prin încărcarea contextului în prealabil, aplicația agentului de turism poate răspunde rapid la interogările utilizatorului fără a fi nevoie să recupereze aceste informații dintr-o sursă externă în timp real. Acest lucru face aplicația mai eficientă și mai receptivă.

Inițializarea Planului cu un Scop Înainte de Iterare

Inițializarea unui plan cu un scop implică pornirea cu un obiectiv clar sau un rezultat țintă în minte. Definind acest scop de la început, modelul îl poate folosi ca principiu călăuzitor pe parcursul procesului iterativ. Acest lucru ajută să se asigure că fiecare iterare se apropie mai mult de atingerea rezultatului dorit, făcând procesul mai eficient și concentrat.

Iată un exemplu de cum ai putea inițializa un plan de călătorie cu un scop înainte de a itera pentru un agent de turism în Python:

Scenariu

Un agent de turism dorește să planifice o vacanță personalizată pentru un client. Scopul este de a crea un itinerar de călătorie care să maximizeze satisfacția clientului bazat pe preferințele și bugetul său.

Pași

1. Definirea preferințelor clientului și a bugetului.
2. Inițializarea planului inițial bazat pe aceste preferințe.
3. Iterarea pentru a rafina planul, optimizând satisfacția clientului.

Cod 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']

# Exemplu de utilizare
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)

Explicație Cod

1. Inițializare (metoda __init__): Clasa TravelAgent este inițializată cu o listă de destinații potențiale, fiecare având atribute precum nume, cost și tip de activitate.

2. Inițializarea Planului (metoda bootstrap_plan): Această metodă creează un plan inițial de călătorie bazat pe preferințele și bugetul clientului. Iterează prin lista de destinații și le adaugă în plan dacă se potrivesc preferințelor clientului și se încadrează în buget.

3. Potrivirea Preferințelor (metoda match_preferences): Această metodă verifică dacă o destinație se potrivește preferințelor clientului.

4. Iterarea Planului (metoda iterate_plan): Această metodă rafinează planul inițial încercând să înlocuiască fiecare destinație din plan cu o potrivire mai bună, ținând cont de preferințele clientului și constrângerile de buget.

5. Calcularea Costului (metoda calculate_cost): Această metodă calculează costul total al planului curent, inclusiv o posibilă destinație nouă.

Exemplu de Utilizare

• Plan Inițial: Agentul de turism creează un plan inițial bazat pe preferințele clientului pentru vizitarea obiectivelor turistice și un buget de 2000$.
• Plan Rafințat: Agentul de turism iterază planul, optimizând pentru preferințele și bugetul clientului.

Prin inițializarea planului cu un scop clar (de exemplu, maximizarea satisfacției clientului) și iterarea pentru a rafina planul, agentul de turism poate crea un itinerar personalizat și optimizat pentru client. Această abordare asigură că planul de călătorie se aliniază cu preferințele și bugetul clientului de la început și se îmbunătățește cu fiecare iterație.

Folosirea Modelului LLM pentru Re-rangare și Scorare

Modelele Mari de Limbaj (LLM) pot fi folosite pentru re-rangare și scorare prin evaluarea relevanței și calității documentelor recuperate sau a răspunsurilor generate. Iată cum funcționează:

Recuperare: Pasul inițial de recuperare obține un set de documente sau răspunsuri candidate bazate pe interogare.

Re-rangare: LLM evaluează acești candidați și îi re-rângează în funcție de relevanța și calitatea lor. Acest pas asigură că cele mai relevante și de calitate informații sunt prezentate primele.

Scorare: LLM atribuie scoruri fiecărui candidat, reflectând relevanța și calitatea lor. Acest lucru ajută la selectarea celui mai bun răspuns sau document pentru utilizator.

Prin utilizarea LLM pentru re-rangare și scorare, sistemul poate oferi informații mai precise și contextual relevante, îmbunătățind experiența generală a utilizatorului.

Iată un exemplu de cum un agent de turism ar putea folosi un Model Mare de Limbaj (LLM) pentru re-rangarea și scorarea destinațiilor de călătorie bazate pe preferințele utilizatorului în Python:

Scenariu - Călătorie bazată pe Preferințe

Un agent de turism dorește să recomande cele mai bune destinații de călătorie unui client, bazat pe preferințele sale. LLM îl va ajuta să re-rânneze și să evalueze destinațiile pentru a asigura că cele mai relevante opțiuni sunt prezentate.

Pași:

1. Colectarea preferințelor utilizatorului.
2. Recuperarea unei liste de destinații potențiale de călătorie.
3. Folosirea LLM pentru re-rangarea și scorarea destinațiilor bazate pe preferințele utilizatorului.

Iată cum poți actualiza exemplul anterior pentru a folosi serviciile Azure OpenAI:

Cerințe

1. Trebuie să ai un abonament Azure.
2. Creează o resursă Azure OpenAI și obține cheia ta API.

Exemplu Cod Python

import requests
import json

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

    def get_recommendations(self, preferences, api_key, endpoint):
        # Generează un prompt pentru Azure OpenAI
        prompt = self.generate_prompt(preferences)
        
        # Definește anteturile și conținutul pentru cerere
        headers = {
            'Content-Type': 'application/json',
            'Authorization': f'Bearer {api_key}'
        }
        payload = {
            "prompt": prompt,
            "max_tokens": 150,
            "temperature": 0.7
        }
        
        # Apelează API-ul Azure OpenAI pentru a obține destinațiile reordonate și evaluate
        response = requests.post(endpoint, headers=headers, json=payload)
        response_data = response.json()
        
        # Extrage și returnează recomandările
        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

# Exemplu de utilizare
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)

Explicație Cod - Booker de Preferințe

1. Inițializare: Clasa TravelAgent este inițializată cu o listă de destinații potențiale de călătorie, fiecare având atribute precum nume și descriere.

2. Obținerea Recomandărilor (metoda get_recommendations): Această metodă generează un prompt pentru serviciul Azure OpenAI bazat pe preferințele utilizatorului și face o cerere HTTP POST la API-ul Azure OpenAI pentru a obține destinațiile re-rânzate și evaluate.

3. Generarea Promptului (metoda generate_prompt): Această metodă construiește un prompt pentru Azure OpenAI, incluzând preferințele utilizatorului și lista de destinații. Promptul ghidează modelul să re-rânzească și să evalueze destinațiile bazându-se pe preferințele furnizate.

4. Apel API: Biblioteca requests este folosită pentru a face o cerere HTTP POST la endpoint-ul API-ului Azure OpenAI. Răspunsul conține destinațiile re-rânzate și evaluate.

5. Exemplu de Utilizare: Agentul de turism colectează preferințele utilizatorului (de exemplu, interes pentru vizite turistice și cultură diversă) și folosește serviciul Azure OpenAI pentru a obține recomandări re-rânzate și evaluate pentru destinațiile de călătorie.

Asigură-te că înlocuiești your_azure_openai_api_key cu cheia ta API Azure OpenAI reală și https://your-endpoint.com/... cu URL-ul real al endpoint-ului implementării tale Azure OpenAI.

Folosind LLM pentru re-rangare și scorare, agentul de turism poate oferi recomandări de călătorie mai personalizate și relevante clienților, îmbunătățindu-le experiența generală.

RAG: Tehnică de Promptare vs Unealtă

Generarea cu Recuperare (RAG) poate fi atât o tehnică de promptare, cât și o unealtă în dezvoltarea agenților AI. Înțelegerea diferenței dintre cele două te poate ajuta să folosești RAG mai eficient în proiectele tale.

RAG ca Tehnică de Promptare

Ce este?

• Ca tehnică de promptare, RAG implică formularea unor interogări sau prompturi specifice pentru a ghida recuperarea informațiilor relevante dintr-un corp mare sau o bază de date. Aceste informații sunt apoi folosite pentru a genera răspunsuri sau acțiuni.

Cum funcționează:

1. Formularea Prompturilor: Creează prompturi sau interogări bine structurate bazate pe sarcina curentă sau pe input-ul utilizatorului.
2. Recuperarea Informațiilor: Folosește prompturile pentru a căuta date relevante dintr-o bază de cunoștințe sau set de date existent.
3. Generarea Răspunsului: Combină informațiile recuperate cu modele generative AI pentru a produce un răspuns cuprinzător și coerent.

Exemplu în agent de turism:

• Input utilizator: “Vreau să vizitez muzee în Paris.”
• Prompt: “Găsește cele mai bune muzee din Paris.”
• Informații recuperate: Detalii despre Muzeul Luvru, Musée d’Orsay, etc.
• Răspuns generat: “Iată câteva muzee de top din Paris: Muzeul Luvru, Musée d’Orsay și Centre Pompidou.”

RAG ca Unealtă

Ce este?

• Ca unealtă, RAG este un sistem integrat care automatizează procesul de recuperare și generare, facilitând dezvoltatorilor implementarea funcționalităților AI complexe fără a crea manual prompturi pentru fiecare interogare.

Cum funcționează:

1. Integrare: Încorporează RAG în arhitectura agentului AI, permițându-i să gestioneze automat sarcinile de recuperare și generare.
2. Automatizare: Unealta gestionează întregul proces, de la primirea input-ului utilizatorului până la generarea răspunsului final, fără a necesita prompturi explicite pentru fiecare pas.
3. Eficiență: Îmbunătățește performanța agentului prin simplificarea procesului de recuperare și generare, oferind răspunsuri mai rapide și mai precise.

Exemplu în agent de turism:

• Input utilizator: “Vreau să vizitez muzee în Paris.”
• Unealta RAG: Recuperează automat informații despre muzee și generează un răspuns.
• Răspuns generat: “Iată câteva muzee de top din Paris: Muzeul Luvru, Musée d’Orsay și Centre Pompidou.”

Comparație

Aspect	Tehnică de Promptare	Unealtă
Manual vs Automat	Formulare manuală a prompturilor pentru fiecare interogare.	Proces automat pentru recuperare și generare.
Control	Oferă mai mult control asupra procesului de recuperare.	Simplifică și automatizează recuperarea și generarea.
Flexibilitate	Permite prompturi personalizate bazate pe nevoi specifice.	Mai eficient pentru implementări la scară largă.
Complexitate	Necesită crearea și ajustarea prompturilor.	Mai ușor de integrat în arhitectura unui agent AI.

Exemple Practice

Exemplu Tehnică de Promptare:

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)

Exemplu Unealtă:

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)

Evaluarea Relevanței

Evaluarea relevanței este un aspect crucial al performanței agenților AI. Ea asigură că informațiile recuperate și generate de agent sunt adecvate, corecte și utile pentru utilizator. Să explorăm cum să evaluăm relevanța în agenții AI, inclusiv exemple practice și tehnici.

Concepte Cheie în Evaluarea Relevanței

1. Conștientizarea Contextului:
   • Agentul trebuie să înțeleagă contextul interogării utilizatorului pentru a recupera și genera informații relevante.
   • Exemplu: Dacă un utilizator întreabă pentru “cele mai bune restaurante din Paris,” agentul ar trebui să ia în considerare preferințele utilizatorului, precum tipul de bucătărie și bugetul.
2. Acuratețe:
   • Informațiile oferite de agent trebuie să fie corecte din punct de vedere factual și actualizate.
   • Exemplu: Recomandarea restaurantelor deschise în prezent cu recenzii bune, în locul opțiunilor învechite sau închise.
3. Intenția Utilizatorului:
   • Agentul trebuie să deducă intenția utilizatorului din spatele interogării pentru a oferi cele mai relevante informații.
   • Exemplu: Dacă un utilizator cere “hoteluri cu prețuri accesibile,” agentul ar trebui să prioritizeze opțiunile accesibile.
4. Buclă de Feedback:
   • Colectarea și analizarea continuă a feedback-ului utilizatorului ajută agentul să-și rafineze procesul de evaluare a relevanței.
   • Exemplu: Includerea evaluărilor și feedback-ului utilizatorilor asupra recomandărilor anterioare pentru a îmbunătăți răspunsurile viitoare.

Tehnici Practice pentru Evaluarea Relevanței

1. Scorarea Relevanței:
   • Atribuie un scor de relevanță fiecărui element recuperat bazat pe cât de bine se potrivește cu interogarea și preferințele utilizatorului.

   • Exemplu:

     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. Filtrarea și Clasarea:
   • Filtrează elementele irelevante și clasifică pe cele rămase în funcție de scorurile lor de relevanță.

   • Exemplu:

     def filter_and_rank(items, query):
         ranked_items = sorted(items, key=lambda item: relevance_score(item, query), reverse=True)
         return ranked_items[:10]  # Returnează primele 10 elemente relevante
     

3. Procesarea Limbajului Natural (NLP):
   • Folosește tehnici NLP pentru a înțelege interogarea utilizatorului și pentru a recupera informații relevante.

   • Exemplu:

     def process_query(query):
         # Folosiți procesarea limbajului natural (NLP) pentru a extrage informații cheie din interogarea utilizatorului
         processed_query = nlp(query)
         return processed_query
     

4. Integrarea Feedback-ului Utilizatorului:
   • Colectează feedback-ul utilizatorilor asupra recomandărilor oferite și îl folosește pentru a ajusta evaluările viitoare de relevanță.

   • Exemplu:

     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
     

Exemplu: Evaluarea Relevanței în Agent de Turism

Iată un exemplu practic de cum Travel Agent poate evalua relevanța recomandărilor de călătorie:

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]  # Returnează primele 10 articole relevante

    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

# Exemplu de utilizare
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)

Căutare cu Intenție

Căutarea cu intenție implică înțelegerea și interpretarea scopului sau obiectivului din spatele unei interogări a utilizatorului pentru a recupera și genera cele mai relevante și utile informații. Această abordare depășește simpla potrivire a cuvintelor cheie și se concentrează pe înțelegerea nevoilor reale și a contextului utilizatorului.

Concepte Cheie în Căutarea cu Intenție

1. Înțelegerea Intenției Utilizatorului:
   • Intenția utilizatorului poate fi clasificată în trei tipuri principale: informațională, navigațională și tranzacțională.
     • Intenție Informațională: Utilizatorul caută informații despre un subiect (ex: “Care sunt cele mai bune muzee din Paris?”).
     • Intenție Navigațională: Utilizatorul dorește să navigheze către un site sau o pagină specifică (ex: “Site oficial Muzeul Luvru”).
     • Intenție Tranzacțională: Utilizatorul dorește să efectueze o tranzacție, cum ar fi rezervarea unui zbor sau efectuarea unei achiziții (ex: “Rezervă un zbor către Paris”).
2. Conștientizarea Contextului:
   • Analiza contextului interogării utilizatorului ajută la identificarea precisă a intenției acestuia. Aceasta include luarea în considerare a interacțiunilor anterioare, a preferințelor utilizatorului și a detaliilor specifice ale interogării curente.
3. Procesarea Limbajului Natural (NLP):
   • Tehnicile NLP sunt folosite pentru a înțelege și interpreta interogările în limbaj natural oferite de utilizatori. Acestea includ sarcini precum recunoașterea entităților, analiza sentimentelor și parsarea interogărilor.
4. Personalizare:
   • Personalizarea rezultatelor căutării bazat pe istoricul, preferințele și feedback-ul utilizatorului îmbunătățește relevanța informațiilor recuperate.

Exemplu Practic: Căutarea cu Intenție în Agent de Turism

Să luăm Travel Agent ca exemplu pentru a vedea cum poate fi implementată căutarea cu intenție.

1. Colectarea Preferințelor Utilizatorului

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

2. Înțelegerea Intenției Utilizatorului

   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. Conștientizarea Contextului

   def analyze_context(query, user_history):
       # Combină interogarea curentă cu istoricul utilizatorului pentru a înțelege contextul
       context = {
           "current_query": query,
           "user_history": user_history
       }
       return context
   

4. Căutare și Personalizare a Rezultatelor

   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):
       # Exemplu de logică de căutare pentru intenție informațională
       results = search_web(f"best {preferences['interests']} in {preferences['destination']}")
       return results
   
   def search_navigation(query):
       # Exemplu de logică de căutare pentru intenție navigațională
       results = search_web(query)
       return results
   
   def search_transaction(query, preferences):
       # Exemplu de logică de căutare pentru intenție tranzacțională
       results = search_web(f"book {query} to {preferences['destination']}")
       return results
   
   def personalize_results(results, user_history):
       # Exemplu de logică de personalizare
       personalized = [result for result in results if result not in user_history]
       return personalized[:10]  # Returnează primele 10 rezultate personalizate
   

5. Exemplu de Utilizare

   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. Generarea Codului ca Instrument

Agenții generativi de cod utilizează modele AI pentru a scrie și executa cod, rezolvând probleme complexe și automatizând sarcini.

Agenți Generativi de Cod

Agenții generativi de cod folosesc modele generative AI pentru a scrie și executa cod. Acești agenți pot rezolva probleme complexe, automatiza sarcini și oferi perspective valoroase generând și rulând cod în diverse limbaje de programare.

Aplicații Practice

1. Generare Automată de Cod: Generează fragmente de cod pentru sarcini specifice, precum analiza datelor, web scraping sau învățare automată.
2. SQL ca RAG: Utilizează interogări SQL pentru a prelua și manipula date din baze de date.
3. Rezolvare de Probleme: Creează și execută cod pentru a rezolva probleme specifice, cum ar fi optimizarea algoritmilor sau analiza datelor.

Exemplu: Agent Generativ de Cod pentru Analiza Datelor

Imaginează-ți că proiectezi un agent generativ de cod. Iată cum ar putea funcționa:

1. Sarcina: Analizează un set de date pentru a identifica tendințe și modele.
2. Pași:
   • Încarcă setul de date într-un instrument de analiză a datelor.
   • Generează interogări SQL pentru a filtra și agrega datele.
   • Execută interogările și preia rezultatele.
   • Folosește rezultatele pentru a genera vizualizări și perspective.
3. Resurse Necesare: Acces la setul de date, unelte de analiză a datelor și capabilități SQL.
4. Experiență: Folosește rezultatele analizelor anterioare pentru a îmbunătăți acuratețea și relevanța analizelor viitoare.

Exemplu: Agent Generativ de Cod pentru Agent de Turism

În acest exemplu, vom proiecta un agent generativ de cod, Agent de Turism, pentru a asista utilizatorii în planificarea călătoriilor lor prin generarea și executarea de cod. Acest agent poate gestiona sarcini precum preluarea opțiunilor de călătorie, filtrarea rezultatelor și compilarea unui itinerar folosind AI generativ.

Prezentare Generală a Agentului Generativ de Cod

1. Colectarea Preferințelor Utilizatorului: Colectează inputul utilizatorului, cum ar fi destinația, datele de călătorie, bugetul și interesele.
2. Generarea Codului pentru Preluarea Datelor: Generează fragmente de cod pentru a prelua date despre zboruri, hoteluri și atracții.
3. Executarea Codului Generat: Rulează codul generat pentru a prelua informații în timp real.
4. Generarea Itinerarului: Compilează datele preluate într-un plan de călătorie personalizat.
5. Ajustarea pe Baza Feedback-ului: Primește feedback de la utilizator și regenerează codul dacă este necesar pentru a rafina rezultatele.

Implementare Pas cu Pas

1. Colectarea Preferințelor Utilizatorului

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

2. Generarea Codului pentru Preluarea Datelor

   def generate_code_to_fetch_data(preferences):
       # Exemplu: Generează cod pentru a căuta zboruri în funcție de preferințele utilizatorului
       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):
       # Exemplu: Generează cod pentru a căuta hoteluri
       code = f"""
       def search_hotels():
           import requests
           response = requests.get('https://api.example.com/hotels', params={preferences})
           return response.json()
       """
       return code
   

3. Executarea Codului Generat

   def execute_code(code):
       # Executați codul generat folosind 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. Generarea Itinerarului

   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. Ajustarea pe Baza Feedback-ului

   def adjust_based_on_feedback(feedback, preferences):
       # Ajustați preferințele pe baza feedback-ului utilizatorului
       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)
      
   # Regenerați și executați codul cu preferințe actualizate
   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)
   

Valorificarea conștientizării mediului și a raționamentului

Bazarea pe schema tabelei poate îmbunătăți într-adevăr procesul de generare a interogărilor prin valorificarea conștientizării mediului și a raționamentului.

Iată un exemplu despre cum poate fi realizat acest lucru:

1. Înțelegerea Schemei: Sistemul va înțelege schema tabelei și va folosi această informație pentru a fundamenta generarea interogărilor.
2. Ajustarea pe Baza Feedback-ului: Sistemul va ajusta preferințele utilizatorului pe baza feedback-ului și va raționa asupra câmpurilor din schemă care trebuie actualizate.
3. Generarea și Executarea Interogărilor: Sistemul va genera și executa interogări pentru a prelua date actualizate despre zboruri și hoteluri, în funcție de noile preferințe.

Iată un exemplu actualizat de cod Python care încorporează aceste concepte:

def adjust_based_on_feedback(feedback, preferences, schema):
    # Ajustați preferințele pe baza feedback-ului utilizatorului
    if "liked" in feedback:
        preferences["favorites"] = feedback["liked"]
    if "disliked" in feedback:
        preferences["avoid"] = feedback["disliked"]
    # Raționament bazat pe schemă pentru ajustarea altor preferințe conexe
    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):
    # Logică personalizată pentru ajustarea preferințelor bazate pe schemă și feedback
    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):
    # Generați cod pentru a prelua datele despre zboruri bazat pe preferințele actualizate
    return f"fetch_flights(preferences={preferences})"

def generate_code_to_fetch_hotels(preferences):
    # Generați cod pentru a prelua datele despre hoteluri bazat pe preferințele actualizate
    return f"fetch_hotels(preferences={preferences})"

def execute_code(code):
    # Simulați execuția codului și returnați date false
    return {"data": f"Executed: {code}"}

def generate_itinerary(flights, hotels, attractions):
    # Generați itinerariul bazat pe zboruri, hoteluri și atracții
    return {"flights": flights, "hotels": hotels, "attractions": attractions}

# Exemplu de schemă
schema = {
    "favorites": {"positive_adjustment": "increase", "negative_adjustment": "decrease", "default": "neutral"},
    "avoid": {"positive_adjustment": "decrease", "negative_adjustment": "increase", "default": "neutral"}
}

# Exemplu de utilizare
preferences = {"favorites": "sightseeing", "avoid": "crowded places"}
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
updated_preferences = adjust_based_on_feedback(feedback, preferences, schema)

# Regenerați și executați codul cu preferințele actualizate
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)

Explicație - Rezervare pe Baza Feedback-ului

1. Conștientizarea Schemei: Dicționarul schema definește cum trebuie ajustate preferințele pe baza feedback-ului. Include câmpuri precum favorites și avoid cu ajustările corespunzătoare.
2. Ajustarea Preferințelor (metoda adjust_based_on_feedback): Această metodă ajustează preferințele pe baza feedback-ului utilizatorului și a schemei.
3. Ajustări Bazate pe Mediul Înconjurător (metoda adjust_based_on_environment): Această metodă personalizează ajustările pe baza schemei și feedback-ului.
4. Generarea și Executarea Interogărilor: Sistemul generează cod pentru a prelua date actualizate despre zboruri și hoteluri pe baza preferințelor ajustate și simulează execuția acestor interogări.
5. Generarea Itinerarului: Sistemul creează un itinerar actualizat pe baza noilor date despre zboruri, hoteluri și atracții.

Prin faptul că sistemul este conștient de mediul înconjurător și raționează pe baza schemei, poate genera interogări mai precise și relevante, conducând la recomandări de călătorie mai bune și o experiență mai personalizată pentru utilizator.

Utilizarea SQL ca Tehnică de Generare Augmentată prin Recuperare (RAG)

SQL (Structured Query Language) este un instrument puternic pentru interacțiunea cu bazele de date. Atunci când este folosit ca parte a unei abordări Retrieval-Augmented Generation (RAG), SQL poate prelua date relevante din baze de date pentru a informa și genera răspunsuri sau acțiuni în agenții AI. Să explorăm cum poate fi folosit SQL ca tehnică RAG în contextul Agentului de Turism.

Concepte Cheie

1. Interacțiunea cu Baza de Date:
   • SQL este folosit pentru a interoga baze de date, a prelua informații relevante și a manipula date.
   • Exemplu: Preluarea detaliilor zborurilor, informațiilor despre hoteluri și atracții dintr-o bază de date de turism.
2. Integrarea cu RAG:
   • Interogările SQL sunt generate pe baza inputului și preferințelor utilizatorului.
   • Datele recuperate sunt apoi folosite pentru a genera recomandări sau acțiuni personalizate.
3. Generare Dinamică a Interogărilor:
   • Agentul AI generează interogări SQL dinamice în funcție de context și nevoile utilizatorului.
   • Exemplu: Personalizarea interogărilor SQL pentru a filtra rezultatele în funcție de buget, date și interese.

Aplicații

• Generare Automată de Cod: Generează fragmente de cod pentru sarcini specifice.
• SQL ca RAG: Utilizează interogări SQL pentru a manipula date.
• Rezolvare de Probleme: Creează și execută cod pentru a rezolva probleme.

Exemplu: Un agent de analiză a datelor:

1. Sarcina: Analizează un set de date pentru a găsi tendințe.
2. Pași:
   • Încarcă setul de date.
   • Generează interogări SQL pentru a filtra datele.
   • Execută interogările și preia rezultatele.
   • Generează vizualizări și perspective.
3. Resurse: Acces la setul de date, capabilități SQL.
4. Experiență: Folosește rezultatele anterioare pentru a îmbunătăți analizele viitoare.

Exemplu Practic: Utilizarea SQL în Agentul de Turism

1. Colectarea Preferințelor Utilizatorului

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

2. Generarea Interogărilor 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. Executarea Interogărilor 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. Generarea Recomandărilor

   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)
   

Exemplu de Interogări SQL

1. Interogare Zboruri

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

2. Interogare Hoteluri

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

3. Interogare Atracții

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

Prin valorificarea SQL ca parte a tehnicii Retrieval-Augmented Generation (RAG), agenți AI precum Agentul de Turism pot prelua și utiliza dinamic date relevante pentru a oferi recomandări precise și personalizate.

Exemplu de Metacogniție

Pentru a demonstra o implementare a metacogniției, să creăm un agent simplu care reflectă asupra procesului său decizional în timp ce rezolvă o problemă. Pentru acest exemplu, vom construi un sistem în care un agent încearcă să optimizeze alegerea unui hotel, dar apoi își evaluează propriul raționament și își ajustează strategia când face greșeli sau alegeri suboptime.

Vom simula acest lucru folosind un exemplu simplu unde agentul selectează hoteluri pe baza unei combinații de preț și calitate, dar va „reflecta” asupra deciziilor sale și se va ajusta în consecință.

Cum ilustrează aceasta metacogniția:

1. Decizia Inițială: Agentul va alege cel mai ieftin hotel, fără a înțelege impactul calității.
2. Reflecție și Evaluare: După alegerea inițială, agentul va verifica dacă hotelul este o alegere „proastă” folosind feedback-ul utilizatorului. Dacă constată că calitatea hotelului a fost prea scăzută, reflectă asupra raționamentului său.
3. Ajustarea Strategiei: Agentul își ajustează strategia pe baza reflecției, trecând de la „cel mai ieftin” la „cea mai bună calitate”, îmbunătățindu-și astfel procesul decizional în iterațiile viitoare.

Iată un exemplu:

class HotelRecommendationAgent:
    def __init__(self):
        self.previous_choices = []  # Stochează hotelurile alese anterior
        self.corrected_choices = []  # Stochează alegerile corectate
        self.recommendation_strategies = ['cheapest', 'highest_quality']  # Strategii disponibile

    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]
        # Să presupunem că avem un feedback de la utilizator care ne spune dacă ultima alegere a fost bună sau nu
        user_feedback = self.get_user_feedback(last_choice)

        if user_feedback == "bad":
            # Ajustează strategia dacă alegerea anterioară a fost nesatisfăcătoare
            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"

# Simulează o listă de hoteluri (preț și calitate)
hotels = [
    {'name': 'Budget Inn', 'price': 80, 'quality': 6},
    {'name': 'Comfort Suites', 'price': 120, 'quality': 8},
    {'name': 'Luxury Stay', 'price': 200, 'quality': 9}
]

# Creează un agent
agent = HotelRecommendationAgent()

# Pasul 1: Agentul recomandă un hotel folosind strategia „cel mai ieftin”
recommended_hotel = agent.recommend_hotel(hotels, 'cheapest')
print(f"Recommended hotel (cheapest): {recommended_hotel['name']}")

# Pasul 2: Agentul reflectă asupra alegerii și ajustează strategia dacă este necesar
reflection_result = agent.reflect_on_choice()
print(reflection_result)

# Pasul 3: Agentul recomandă din nou, de data aceasta folosind strategia ajustată
adjusted_recommendation = agent.recommend_hotel(hotels, 'highest_quality')
print(f"Adjusted hotel recommendation (highest_quality): {adjusted_recommendation['name']}")

Abilitățile de Metacogniție ale Agenților

Esențial aici este abilitatea agentului de a:

• Evalua alegerile și procesul decizional anterior.
• Ajusta strategia pe baza acestei reflecții, adică metacogniția în acțiune.

Aceasta este o formă simplă de metacogniție în care sistemul este capabil să își ajusteze procesul de raționament pe baza feedback-ului intern.

Concluzie

Metacogniția este un instrument puternic care poate îmbunătăți semnificativ capabilitățile agenților AI. Prin încorporarea proceselor metacognitive, poți proiecta agenți mai inteligenți, adaptabili și eficienți. Folosește resursele suplimentare pentru a explora mai profund fascinanta lume a metacogniției în agenții AI.

Ai Mai Multe Întrebări despre Modelul de Design Metacogniție?

Alătură-te Microsoft Foundry Discord pentru a întâlni alți cursanți, a participa la sesiuni de office hours și a primi răspunsuri la întrebările tale despre Agenți AI.

Lecția Anterioară

Modelul de Design Multi-Agent

Lecția Următoare

Agenți AI în Producție

---

Declinare a responsabilității: Acest document a fost tradus folosind serviciul de traducere AI Co-op Translator. În timp ce ne străduim pentru acuratețe, vă rugăm să rețineți că traducerile automate pot conține erori sau inexactități. Documentul original în limba sa nativă trebuie considerat sursa autorizată. Pentru informații critice, se recomandă traducerea profesională realizată de un om. Nu ne asumăm responsabilitatea pentru eventualele neînțelegeri sau interpretări greșite care decurg din utilizarea acestei traduceri.

This site is open source. Improve this page.