ai-agents-for-beginners

Progettazione Multi-Agente

(Clicca l’immagine sopra per guardare il video di questa lezione)

Metacognizione negli Agenti AI

Introduzione

Benvenuti alla lezione sulla metacognizione negli agenti AI! Questo capitolo è pensato per principianti curiosi di capire come gli agenti AI possano riflettere sui propri processi di pensiero. Alla fine di questa lezione, comprenderai i concetti chiave e sarai dotato di esempi pratici per applicare la metacognizione nella progettazione degli agenti AI.

Obiettivi di Apprendimento

Dopo aver completato questa lezione, sarai in grado di:

  1. Comprendere le implicazioni dei cicli di ragionamento nelle definizioni degli agenti.
  2. Usare tecniche di pianificazione e valutazione per aiutare agenti auto-correggenti.
  3. Creare i tuoi agenti capaci di manipolare codice per svolgere compiti.

Introduzione alla Metacognizione

La metacognizione si riferisce ai processi cognitivi di ordine superiore che implicano il pensare riguardo al proprio pensiero. Per gli agenti AI, questo significa essere in grado di valutare e modificare le proprie azioni basandosi sulla consapevolezza di sé e sulle esperienze passate. La metacognizione, o “pensare al pensiero”, è un concetto importante nello sviluppo di sistemi AI agentici. Coinvolge i sistemi AI nell’essere consapevoli dei propri processi interni e nella capacità di monitorare, regolare e adattare il proprio comportamento di conseguenza. Proprio come facciamo noi quando capiamo un ambiente o analizziamo un problema. Questa consapevolezza di sé può aiutare i sistemi AI a prendere decisioni migliori, identificare errori e migliorare le loro prestazioni nel tempo - richiamando ancora una volta il test di Turing e il dibattito sul fatto che l’AI prenderà il sopravvento.

Nel contesto dei sistemi AI agentici, la metacognizione può aiutare ad affrontare diverse sfide, come:

Cos’è la Metacognizione?

La metacognizione, o “pensare al pensiero”, è un processo cognitivo di ordine superiore che implica la consapevolezza di sé e l’auto-regolazione dei propri processi cognitivi. Nell’ambito dell’AI, la metacognizione permette agli agenti di valutare e adattare le proprie strategie e azioni, portando a migliorate capacità di risoluzione dei problemi e presa di decisioni. Capendo la metacognizione, puoi progettare agenti AI non solo più intelligenti ma anche più adattabili ed efficienti. In una vera metacognizione, vedresti l’AI ragionare esplicitamente sul proprio ragionamento.

Esempio: “Ho dato priorità ai voli più economici perché… potrei perdere i voli diretti, quindi ricontrollo.”. Tenere traccia di come o perché ha scelto un certo percorso.

Importanza della Metacognizione negli Agenti AI

La metacognizione svolge un ruolo cruciale nella progettazione degli agenti AI per diversi motivi:

Importanza della Metacognizione

Componenti di un Agente AI

Prima di entrare nei processi metacognitivi, è essenziale comprendere le componenti di base di un agente AI. Un agente AI tipicamente consiste di:

Questi componenti lavorano insieme per creare un’”unità di competenza” che può svolgere compiti specifici.

Esempio: Considera un agente di viaggio, un servizio agente che non solo pianifica la tua vacanza ma aggiusta il percorso basandosi su dati in tempo reale e esperienze precedenti del viaggio del cliente.

Esempio: Metacognizione in un Servizio Agente di Viaggio

Immagina di progettare un servizio agente di viaggio alimentato da AI. Questo agente, “Agente di Viaggio”, aiuta gli utenti a pianificare le vacanze. Per incorporare la metacognizione, l’Agente di Viaggio deve valutare e aggiustare le proprie azioni basandosi su consapevolezza di sé ed esperienze passate. Ecco come la metacognizione potrebbe svolgere un ruolo:

Compito Attuale

Il compito attuale è aiutare un utente a pianificare un viaggio a Parigi.

Passi per Completare il Compito

  1. Raccogliere Preferenze Utente: Chiedere all’utente delle date di viaggio, del budget, degli interessi (es. musei, cucina, shopping) e requisiti specifici.
  2. Recuperare Informazioni: Cercare opzioni di volo, sistemazioni, attrazioni e ristoranti che corrispondano alle preferenze dell’utente.
  3. Generare Raccomandazioni: Fornire un itinerario personalizzato con dettagli di voli, prenotazioni hotel e attività suggerite.
  4. Aggiustare in Base al Feedback: Chiedere feedback all’utente sulle raccomandazioni e apportare le modifiche necessarie.

Risorse Necessarie

Esperienza e Auto-Riflessione

L’Agente di Viaggio usa la metacognizione per valutare le proprie prestazioni e imparare dalle esperienze passate. Per esempio:

  1. Analizzare Feedback Utente: L’Agente di Viaggio rivede il feedback per determinare quali raccomandazioni sono state ben accette e quali no. Modifica di conseguenza i suggerimenti futuri.
  2. Adattabilità: Se un utente ha precedentemente indicato di non gradire i posti affollati, l’Agente di Viaggio eviterà di raccomandare luoghi turistici popolari durante le ore di punta in futuro.
  3. Correzione degli Errori: Se l’Agente di Viaggio ha commesso un errore in una prenotazione passata, come suggerire un hotel già pieno, impara a controllare la disponibilità in modo più rigoroso prima di fare raccomandazioni.

Esempio Pratico per Sviluppatori

Ecco un esempio semplificato di come potrebbe apparire il codice dell’Agente di Viaggio incorporando la metacognizione:

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):
        # Cerca voli, hotel e attrazioni in base alle preferenze
        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)
        # Analizza il feedback e adatta le raccomandazioni future
        self.user_preferences = adjust_preferences(self.user_preferences, feedback)

# Esempio di utilizzo
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)

Perché la Metacognizione Conta

Incorporando la metacognizione, l’Agente di Viaggio può fornire raccomandazioni di viaggio più personalizzate e precise, migliorando l’esperienza complessiva dell’utente.

2. Pianificazione negli Agenti

La pianificazione è una componente critica del comportamento di un agente AI. Coinvolge il delineare i passi necessari per raggiungere un obiettivo, considerando lo stato attuale, le risorse e gli eventuali ostacoli.

Elementi della Pianificazione

Esempio: Ecco i passi che l’Agente di Viaggio deve compiere per assistere efficacemente un utente nella pianificazione del viaggio:

Passi per l’Agente di Viaggio

  1. Raccogliere Preferenze Utente
    • Chiedere all’utente dettagli su date di viaggio, budget, interessi e requisiti specifici.
    • Esempi: “Quando prevedi di viaggiare?” “Qual è il tuo budget?” “Quali attività ti piacciono in vacanza?”
  2. Recuperare Informazioni
    • Cercare opzioni di viaggio pertinenti basate sulle preferenze dell’utente.
    • Voli: Cercare voli disponibili entro il budget e le date preferite.
    • Alloggi: Trovare hotel o proprietà in affitto che corrispondano a preferenze di posizione, prezzo e servizi.
    • Attrazioni e Ristoranti: Identificare attrazioni popolari, attività e ristoranti in linea con gli interessi dell’utente.
  3. Generare Raccomandazioni
    • Compilare le informazioni recuperate in un itinerario personalizzato.
    • Fornire dettagli come opzioni di volo, prenotazioni alberghiere e attività suggerite, assicurandosi di adattare le raccomandazioni alle preferenze dell’utente.
  4. Presentare l’Itinerario all’Utente
    • Condividere l’itinerario proposto con l’utente per la revisione.
    • Esempio: “Ecco un itinerario suggerito per il tuo viaggio a Parigi. Include dettagli dei voli, prenotazioni hotel e una lista di attività e ristoranti consigliati. Fammi sapere cosa ne pensi!”
  5. Raccogliere Feedback
    • Chiedere all’utente un feedback sull’itinerario proposto.
    • Esempi: “Ti piacciono le opzioni di volo?” “L’hotel è adatto alle tue esigenze?” “Ci sono attività che vorresti aggiungere o rimuovere?”
  6. Aggiustare in Base al Feedback
    • Modificare l’itinerario secondo il feedback dell’utente.
    • Apportare cambiamenti necessari a voli, alloggi e attività per meglio rispecchiare le preferenze dell’utente.
  7. Conferma Finale
    • Presentare l’itinerario aggiornato all’utente per la conferma finale.
    • Esempio: “Ho apportato le modifiche basate sul tuo feedback. Ecco l’itinerario aggiornato. Ti sembra tutto a posto?”
  8. Prenotare e Confermare le Prenotazioni
    • Una volta che l’utente approva l’itinerario, procedere con la prenotazione di voli, alloggi e attività pianificate.
    • Inviare i dettagli di conferma all’utente.
  9. Fornire Supporto Continuo
    • Rimanere disponibili per aiutare l’utente con cambiamenti o richieste aggiuntive prima e durante il viaggio.
    • Esempio: “Se hai bisogno di ulteriore assistenza durante il viaggio, non esitare a contattarmi in qualsiasi momento!”

Esempio di Interazione

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)

# Esempio di utilizzo all'interno di una richiesta di prenotazione
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. Sistema RAG Correttivo

Prima di tutto iniziamo comprendendo la differenza tra Strumento RAG e Caricamento Contesto Pre-emptive

RAG vs Caricamento Contesto

Generazione Amplificata da Recupero (RAG)

RAG combina un sistema di recupero con un modello generativo. Quando viene effettuata una query, il sistema di recupero preleva documenti o dati rilevanti da una fonte esterna, e queste informazioni recuperate vengono usate per ampliare l’input al modello generativo. Questo aiuta il modello a generare risposte più accurate e contestualmente rilevanti.

In un sistema RAG, l’agente recupera informazioni rilevanti da una base di conoscenza e le usa per generare risposte o azioni appropriate.

Approccio RAG Correttivo

L’approccio RAG Correttivo si concentra sull’uso delle tecniche RAG per correggere errori e migliorare l’accuratezza degli agenti AI. Ciò implica:

  1. Tecnica di Prompting: Usare prompt specifici per guidare l’agente nel recupero di informazioni rilevanti.
  2. Strumento: Implementare algoritmi e meccanismi che permettono all’agente di valutare la rilevanza delle informazioni recuperate e generare risposte accurate.
  3. Valutazione: Valutare continuamente le prestazioni dell’agente e apportare aggiustamenti per migliorare accuratezza ed efficienza.

Esempio: RAG Correttivo in un Agente di Ricerca

Considera un agente di ricerca che recupera informazioni dal web per rispondere alle query degli utenti. L’approccio RAG Correttivo potrebbe coinvolgere:

  1. Tecnica di Prompting: Formulare query di ricerca basate sull’input dell’utente.
  2. Strumento: Usare algoritmi di elaborazione del linguaggio naturale e apprendimento automatico per classificare e filtrare i risultati.
  3. Valutazione: Analizzare il feedback degli utenti per identificare e correggere imprecisioni nelle informazioni recuperate.

RAG Correttivo nell’Agente di Viaggio

Il RAG Correttivo (Generazione Amplificata da Recupero) migliora la capacità di un’AI di recuperare e generare informazioni correggendo eventuali inesattezze. Vediamo come l’Agente di Viaggio può usare l’approccio RAG Correttivo per fornire raccomandazioni di viaggio più accurate e rilevanti.

Questo implica:

Passi per Implementare il RAG Correttivo nell’Agente di Viaggio

  1. Interazione Iniziale con l’Utente
    • L’Agente di Viaggio raccoglie le preferenze iniziali dall’utente, come destinazione, date di viaggio, budget e interessi.

    • Esempio:

      preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
  2. Recupero delle Informazioni
    • L’Agente di Viaggio recupera informazioni su voli, alloggi, attrazioni e ristoranti basandosi sulle preferenze utente.

    • Esempio:

      flights = search_flights(preferences)
hotels = search_hotels(preferences)
attractions = search_attractions(preferences)
  3. Generazione delle Raccomandazioni Iniziali
    • L’Agente di Viaggio usa le informazioni recuperate per generare un itinerario personalizzato.

    • Esempio:

      itinerary = create_itinerary(flights, hotels, attractions)
print("Suggested Itinerary:", itinerary)
  4. Raccolta del Feedback Utente
    • L’Agente di Viaggio chiede all’utente un feedback sulle raccomandazioni iniziali.

    • Esempio:

      feedback = {
    "liked": ["Louvre Museum"],
    "disliked": ["Eiffel Tower (too crowded)"]
}
  5. Processo RAG Correttivo
    • Tecnica di Prompting: L’Agente di Viaggio formula nuove query di ricerca basate sul feedback dell’utente.

      • Esempio:

        if "disliked" in feedback:
    preferences["avoid"] = feedback["disliked"]
    • Strumento: L’Agente di Viaggio usa algoritmi per classificare e filtrare nuovi risultati di ricerca, enfatizzando la rilevanza basata sul feedback.

      • Esempio:

        new_attractions = search_attractions(preferences)
new_itinerary = create_itinerary(flights, hotels, new_attractions)
print("Updated Itinerary:", new_itinerary)
    • Valutazione: L’Agente di Viaggio valuta continuamente la rilevanza e accuratezza delle sue raccomandazioni analizzando il feedback degli utenti e facendo aggiustamenti necessari.

      • Esempio:

        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)

Esempio Pratico

Ecco un esempio semplificato di codice Python che incorpora l’approccio RAG Correttivo nell’Agente di Viaggio:

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

# Esempio di utilizzo
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)

Caricamento Contestuale Pre-emptive

Il caricamento preventivo del contesto consiste nel caricare informazioni pertinenti o di background nel modello prima di elaborare una query. Ciò significa che il modello ha accesso a queste informazioni fin dall’inizio, il che può aiutarlo a generare risposte più informate senza dover recuperare dati aggiuntivi durante il processo.

Ecco un esempio semplificato di come potrebbe apparire un caricamento preventivo del contesto per un’applicazione di agenzia di viaggi in Python:

class TravelAgent:
    def __init__(self):
        # Pre-carica le destinazioni popolari e le loro informazioni
        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):
        # Recupera le informazioni sulla destinazione dal contesto pre-caricato
        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}."

# Esempio di utilizzo
travel_agent = TravelAgent()
print(travel_agent.get_destination_info("Paris"))
print(travel_agent.get_destination_info("Tokyo"))

Spiegazione

  1. Inizializzazione (metodo __init__): La classe TravelAgent pre-carica un dizionario contenente informazioni sulle destinazioni popolari come Parigi, Tokyo, New York e Sydney. Questo dizionario include dettagli come paese, valuta, lingua e principali attrazioni per ogni destinazione.

  2. Recupero Informazioni (metodo get_destination_info): Quando un utente fa una domanda su una destinazione specifica, il metodo get_destination_info recupera le informazioni pertinenti dal dizionario di contesto pre-caricato.

Pre-caricando il contesto, l’applicazione dell’agenzia di viaggi può rispondere rapidamente alle domande degli utenti senza dover recuperare queste informazioni da una fonte esterna in tempo reale. Questo rende l’applicazione più efficiente e reattiva.

Inizializzare il Piano con un Obiettivo Prima di Iterare

Inizializzare un piano con un obiettivo significa partire con un obiettivo chiaro o un risultato target in mente. Definendo questo obiettivo in anticipo, il modello può usarlo come principio guida durante tutto il processo iterativo. Questo aiuta a garantire che ogni iterazione avanzi verso il raggiungimento del risultato desiderato, rendendo il processo più efficiente e focalizzato.

Ecco un esempio di come potresti inizializzare un piano di viaggio con un obiettivo prima di iterare per un’agenzia di viaggi in Python:

Scenario

Un’agenzia di viaggi vuole pianificare una vacanza personalizzata per un cliente. L’obiettivo è creare un itinerario di viaggio che massimizzi la soddisfazione del cliente basandosi sulle sue preferenze e sul budget.

Passi

  1. Definire le preferenze e il budget del cliente.
  2. Inizializzare il piano iniziale basato su queste preferenze.
  3. Iterare per perfezionare il piano, ottimizzando la soddisfazione del cliente.

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

# Esempio di utilizzo
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)

Spiegazione del Codice

  1. Inizializzazione (metodo __init__): La classe TravelAgent viene inizializzata con una lista di possibili destinazioni, ognuna delle quali ha attributi come nome, costo e tipo di attività.

  2. Inizializzare il Piano (metodo bootstrap_plan): Questo metodo crea un piano di viaggio iniziale basato sulle preferenze e sul budget del cliente. Scorre la lista delle destinazioni e le aggiunge al piano se corrispondono alle preferenze del cliente e rientrano nel budget.

  3. Corrispondenza delle Preferenze (metodo match_preferences): Questo metodo verifica se una destinazione corrisponde alle preferenze del cliente.

  4. Iterare il Piano (metodo iterate_plan): Questo metodo perfeziona il piano iniziale cercando di sostituire ogni destinazione nel piano con una corrispondenza migliore, considerando le preferenze del cliente e i vincoli di budget.

  5. Calcolo del Costo (metodo calculate_cost): Questo metodo calcola il costo totale del piano attuale, inclusa una potenziale nuova destinazione.

Esempio d’Uso

Inizializzando il piano con un obiettivo chiaro (ad esempio, massimizzare la soddisfazione del cliente) e iterando per perfezionare il piano, l’agenzia può creare un itinerario di viaggio personalizzato e ottimizzato per il cliente. Questo approccio garantisce che il piano di viaggio sia allineato alle preferenze e al budget del cliente fin dall’inizio e migliori a ogni iterazione.

Sfruttare LLM per il Ri-ordinamento e la Valutazione

I Large Language Models (LLM) possono essere utilizzati per il ri-ordinamento e la valutazione esaminando la rilevanza e la qualità dei documenti recuperati o delle risposte generate. Ecco come funziona:

Recupero: Il primo passaggio recupera un insieme di documenti o risposte candidate basate sulla query.

Ri-ordinamento: L’LLM valuta questi candidati e li ri-ordina in base alla loro rilevanza e qualità. Questo passaggio assicura che le informazioni più rilevanti e di alta qualità siano presentate per prime.

Valutazione: L’LLM assegna punteggi a ogni candidato, riflettendo la loro rilevanza e qualità. Questo aiuta a selezionare la migliore risposta o documento per l’utente.

Sfruttando gli LLM per il ri-ordinamento e la valutazione, il sistema può fornire informazioni più precise e contestualmente rilevanti, migliorando l’esperienza complessiva dell’utente.

Ecco un esempio di come un’agenzia di viaggi potrebbe utilizzare un Large Language Model (LLM) per ri-ordinare e valutare le destinazioni di viaggio basate sulle preferenze dell’utente in Python:

Scenario - Viaggiare basandosi sulle Preferenze

Un agente di viaggi vuole raccomandare le migliori destinazioni di viaggio a un cliente basandosi sulle sue preferenze. L’LLM aiuterà a ri-ordinare e valutare le destinazioni per assicurare che vengano presentate le opzioni più rilevanti.

Passi:

  1. Raccogliere le preferenze dell’utente.
  2. Recuperare una lista di possibili destinazioni di viaggio.
  3. Usare l’LLM per ri-ordinare e valutare le destinazioni basandosi sulle preferenze dell’utente.

Ecco come puoi aggiornare l’esempio precedente per utilizzare Azure OpenAI Services:

Requisiti

  1. Devi avere un abbonamento Azure.
  2. Crea una risorsa Azure OpenAI e ottieni la tua chiave API.

Esempio di Codice Python

import requests
import json

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

    def get_recommendations(self, preferences, api_key, endpoint):
        # Genera un prompt per Azure OpenAI
        prompt = self.generate_prompt(preferences)
        
        # Definisci intestazioni e payload per la richiesta
        headers = {
            'Content-Type': 'application/json',
            'Authorization': f'Bearer {api_key}'
        }
        payload = {
            "prompt": prompt,
            "max_tokens": 150,
            "temperature": 0.7
        }
        
        # Chiama l'API Azure OpenAI per ottenere le destinazioni riordinate e valutate
        response = requests.post(endpoint, headers=headers, json=payload)
        response_data = response.json()
        
        # Estrai e restituisci le raccomandazioni
        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

# Esempio di utilizzo
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)

Spiegazione del Codice - Preference Booker

  1. Inizializzazione: La classe TravelAgent viene inizializzata con una lista di potenziali destinazioni di viaggio, ognuna con attributi come nome e descrizione.

  2. Ottenere Raccomandazioni (metodo get_recommendations): Questo metodo genera un prompt per il servizio Azure OpenAI basato sulle preferenze dell’utente e fa una richiesta HTTP POST all’API Azure OpenAI per ottenere destinazioni ri-ordinate e valutate.

  3. Generare Prompt (metodo generate_prompt): Questo metodo costruisce un prompt per Azure OpenAI, includendo le preferenze dell’utente e la lista delle destinazioni. Il prompt guida il modello a ri-ordinare e valutare le destinazioni basandosi sulle preferenze fornite.

  4. Chiamata API: Si usa la libreria requests per effettuare una richiesta HTTP POST all’endpoint dell’API Azure OpenAI. La risposta contiene le destinazioni ri-ordinate e valutate.

  5. Esempio d’Uso: L’agente raccoglie le preferenze dell’utente (ad esempio, interesse per visite turistiche e cultura diversificata) e usa il servizio Azure OpenAI per ottenere raccomandazioni ri-ordinate e valutate sulle destinazioni di viaggio.

Assicurati di sostituire your_azure_openai_api_key con la tua vera chiave API Azure OpenAI e https://your-endpoint.com/... con l’URL reale dell’endpoint del tuo deployment Azure OpenAI.

Sfruttando l’LLM per il ri-ordinamento e la valutazione, l’agente di viaggi può fornire raccomandazioni di viaggio più personalizzate e pertinenti ai clienti, migliorando la loro esperienza complessiva.

RAG: Tecnica di Prompting vs Strumento

La Retrieval-Augmented Generation (RAG) può essere sia una tecnica di prompting sia uno strumento nello sviluppo di agenti AI. Comprendere la differenza tra i due può aiutarti a sfruttare RAG in modo più efficace nei tuoi progetti.

RAG come Tecnica di Prompting

Cos’è?

Come funziona:

  1. Formulare Prompt: Creare prompt o query ben strutturate basate sul compito o sull’input dell’utente.
  2. Recuperare Informazioni: Usare i prompt per cercare dati rilevanti da una base di conoscenza o dataset preesistente.
  3. Generare Risposta: Combinare le informazioni recuperate con modelli AI generativi per produrre una risposta completa e coerente.

Esempio nell’Agenzia di Viaggi:

RAG come Strumento

Cos’è?

Come funziona:

  1. Integrazione: Integrare RAG nell’architettura dell’agente AI, permettendogli di gestire automaticamente i compiti di recupero e generazione.
  2. Automazione: Lo strumento gestisce l’intero processo, dal ricevere l’input dell’utente fino alla generazione della risposta finale, senza richiedere prompt espliciti per ogni passaggio.
  3. Efficienza: Migliora le prestazioni dell’agente semplificando il processo di recupero e generazione, permettendo risposte più rapide e accurate.

Esempio nell’Agenzia di Viaggi:

Confronto

Aspetto Tecnica di Prompting Strumento
Manuale vs Automatico Formulazione manuale di prompt per ogni query. Processo automatizzato per recupero e generazione.
Controllo Offre maggiore controllo sul processo di recupero. Semplifica e automatizza recupero e generazione.
Flessibilità Permette prompt personalizzati basati su necessità specifiche. Più efficiente per implementazioni su larga scala.
Complessità Richiede la creazione e la modifica dei prompt. Più facile da integrare nell’architettura di un agente AI.

Esempi Pratici

Esempio di Tecnica di Prompting:

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)

Esempio di Strumento:

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)

Valutazione della Rilevanza

La valutazione della rilevanza è un aspetto cruciale delle prestazioni di un agente AI. Assicura che le informazioni recuperate e generate dall’agente siano appropriate, accurate e utili per l’utente. Esploriamo come valutare la rilevanza negli agenti AI, inclusi esempi pratici e tecniche.

Concetti Chiave nella Valutazione della Rilevanza

  1. Consapevolezza del Contesto:
    • L’agente deve comprendere il contesto della query dell’utente per recuperare e generare informazioni rilevanti.
    • Esempio: Se un utente chiede “i migliori ristoranti a Parigi,” l’agente dovrebbe considerare le preferenze dell’utente, come tipo di cucina e budget.
  2. Accuratezza:
    • Le informazioni fornite dall’agente devono essere fattualmente corrette e aggiornate.
    • Esempio: Raccomandare ristoranti attualmente aperti con buone recensioni invece di opzioni obsolete o chiuse.
  3. Intento dell’Utente:
    • L’agente dovrebbe inferire l’intento dell’utente dietro la query per fornire le informazioni più rilevanti.
    • Esempio: Se un utente chiede “hotel economici,” l’agente dovrebbe dare priorità alle opzioni accessibili.
  4. Ciclo di Feedback:
    • Raccogliere e analizzare continuamente i feedback degli utenti aiuta l’agente a perfezionare il processo di valutazione della rilevanza.
    • Esempio: Incorporare le valutazioni e i feedback degli utenti sulle raccomandazioni precedenti per migliorare le risposte future.

Tecniche Pratiche per la Valutazione della Rilevanza

  1. Attribuzione del Punteggio di Rilevanza:
    • Assegnare un punteggio di rilevanza a ogni elemento recuperato basandosi su quanto corrisponde alla query e alle preferenze dell’utente.

    • Esempio:

      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. Filtraggio e Ordinamento:
    • Filtrare gli elementi non pertinenti e ordinare quelli rimanenti in base ai loro punteggi di rilevanza.

    • Esempio:

      def filter_and_rank(items, query):
    ranked_items = sorted(items, key=lambda item: relevance_score(item, query), reverse=True)
    return ranked_items[:10]  # Restituisce i primi 10 elementi rilevanti
  3. Elaborazione del Linguaggio Naturale (NLP):
    • Utilizzare tecniche NLP per comprendere la query dell’utente e recuperare informazioni pertinenti.

    • Esempio:

      def process_query(query):
    # Usa NLP per estrarre informazioni chiave dalla query dell'utente
    processed_query = nlp(query)
    return processed_query
  4. Integrazione del Feedback dell’Utente:
    • Raccogliere il feedback degli utenti sulle raccomandazioni fornite e usarlo per adeguare le valutazioni di rilevanza future.

    • Esempio:

      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

Esempio: Valutazione della Rilevanza nell’Agenzia di Viaggi

Ecco un esempio pratico di come Travel Agent può valutare la rilevanza delle raccomandazioni di viaggio:

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]  # Restituisci i 10 elementi più rilevanti

    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

# Esempio di utilizzo
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)

Ricerca con Intento

Ricercare con intento significa comprendere e interpretare lo scopo o obiettivo sottostante dietro la query di un utente per recuperare e generare le informazioni più rilevanti e utili. Questo approccio va oltre la semplice corrispondenza di parole chiave e si concentra sulla comprensione dei reali bisogni e del contesto dell’utente.

Concetti Chiave nella Ricerca con Intento

  1. Comprendere l’Intento dell’Utente:
    • L’intento dell’utente può essere categorizzato in tre tipi principali: informativo, di navigazione e transazionale.
      • Intento Informativo: L’utente cerca informazioni su un argomento (es. “Quali sono i migliori musei a Parigi?”).
      • Intento di Navigazione: L’utente vuole navigare verso un sito web o pagina specifica (es. “Sito ufficiale Museo del Louvre”).
      • Intento Transazionale: L’utente vuole effettuare una transazione, come prenotare un volo o fare un acquisto (es. “Prenota un volo per Parigi”).
  2. Consapevolezza del Contesto:
    • Analizzare il contesto della query dell’utente aiuta a identificare accuratamente il suo intento. Questo include considerare interazioni precedenti, preferenze e dettagli specifici della query corrente.
  3. Elaborazione del Linguaggio Naturale (NLP):
    • Le tecniche NLP sono impiegate per comprendere e interpretare le query in linguaggio naturale degli utenti. Ciò include compiti come il riconoscimento delle entità, l’analisi del sentimento e il parsing della query.
  4. Personalizzazione:
    • Personalizzare i risultati di ricerca basandosi sulla storia, le preferenze e il feedback dell’utente migliora la rilevanza delle informazioni recuperate.

Esempio Pratico: Ricerca con Intento nell’Agenzia di Viaggi

Prendiamo Travel Agent come esempio per vedere come possa essere implementata la ricerca con intento.

  1. Raccolta delle Preferenze dell’Utente

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

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

  2. Comprendere l’Intento dell’Utente

    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. Consapevolezza del Contesto

    def analyze_context(query, user_history):
    # Combina la query attuale con la cronologia dell'utente per comprendere il contesto
    context = {
        "current_query": query,
        "user_history": user_history
    }
    return context

  4. Ricerca e Personalizzazione dei Risultati

    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):
    # Esempio di logica di ricerca per intento informativo
    results = search_web(f"best {preferences['interests']} in {preferences['destination']}")
    return results

def search_navigation(query):
    # Esempio di logica di ricerca per intento navigazionale
    results = search_web(query)
    return results

def search_transaction(query, preferences):
    # Esempio di logica di ricerca per intento transazionale
    results = search_web(f"book {query} to {preferences['destination']}")
    return results

def personalize_results(results, user_history):
    # Esempio di logica di personalizzazione
    personalized = [result for result in results if result not in user_history]
    return personalized[:10]  # Restituisce i primi 10 risultati personalizzati

  5. Esempio di Utilizzo

    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. Generare Codice come Strumento

Gli agenti generativi di codice utilizzano modelli di IA per scrivere ed eseguire codice, risolvendo problemi complessi e automatizzando compiti.

Agenti di Generazione del Codice

Gli agenti di generazione del codice utilizzano modelli di IA generativa per scrivere ed eseguire codice. Questi agenti possono risolvere problemi complessi, automatizzare compiti e fornire preziose informazioni generando ed eseguendo codice in vari linguaggi di programmazione.

Applicazioni Pratiche

  1. Generazione Automatica di Codice: Generare frammenti di codice per compiti specifici, come analisi dati, web scraping o apprendimento automatico.
  2. SQL come RAG: Utilizzare query SQL per recuperare e manipolare dati da database.
  3. Risoluzione di Problemi: Creare ed eseguire codice per risolvere problemi specifici, come ottimizzare algoritmi o analizzare dati.

Esempio: Agente Generatore di Codice per Analisi Dati

Immagina di progettare un agente generatore di codice. Ecco come potrebbe funzionare:

  1. Compito: Analizzare un set di dati per identificare tendenze e modelli.
  2. Passaggi:
    • Caricare il set di dati in uno strumento di analisi dati.
    • Generare query SQL per filtrare e aggregare i dati.
    • Eseguire le query e recuperare i risultati.
    • Utilizzare i risultati per generare visualizzazioni e approfondimenti.
  3. Risorse Necessarie: Accesso al set di dati, strumenti di analisi dati e capacità SQL.
  4. Esperienza: Utilizzare risultati di analisi passate per migliorare accuratezza e rilevanza delle analisi future.

Esempio: Agente Generatore di Codice per Agente di Viaggio

In questo esempio, progetteremo un agente generatore di codice, Agente di Viaggio, per assistere gli utenti nella pianificazione del loro viaggio generando ed eseguendo codice. Questo agente può gestire compiti come recuperare opzioni di viaggio, filtrare risultati e compilare un itinerario usando l’IA generativa.

Panoramica dell’Agente Generatore di Codice

  1. Raccolta Preferenze Utente: Raccoglie input dell’utente come destinazione, date di viaggio, budget e interessi.
  2. Generazione di Codice per il Recupero Dati: Genera frammenti di codice per recuperare dati su voli, hotel e attrazioni.
  3. Esecuzione del Codice Generato: Esegue il codice generato per ottenere informazioni in tempo reale.
  4. Generazione Itinerario: Compila i dati recuperati in un piano di viaggio personalizzato.
  5. Regolazione Basata sul Feedback: Riceve feedback dell’utente e rigenera codice se necessario per perfezionare i risultati.

Implementazione Passo-Passo

  1. Raccolta Preferenze Utente

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

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

  2. Generazione di Codice per il Recupero Dati

    def generate_code_to_fetch_data(preferences):
    # Esempio: Genera codice per cercare voli in base alle preferenze dell'utente
    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):
    # Esempio: Genera codice per cercare hotel
    code = f"""
    def search_hotels():
        import requests
        response = requests.get('https://api.example.com/hotels', params={preferences})
        return response.json()
    """
    return code

  3. Esecuzione del Codice Generato

    def execute_code(code):
    # Esegui il codice generato utilizzando 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. Generazione Itinerario

    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. Regolazione Basata sul Feedback

    def adjust_based_on_feedback(feedback, preferences):
    # Regola le preferenze in base al feedback dell'utente
    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)
   
# Rigenera ed esegui il codice con le preferenze aggiornate
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)

Sfruttare la Consapevolezza Ambientale e il Ragionamento

Basarsi sullo schema della tabella può effettivamente migliorare il processo di generazione delle query sfruttando la consapevolezza ambientale e il ragionamento.

Ecco un esempio di come questo può essere fatto:

  1. Comprensione dello Schema: Il sistema comprenderà lo schema della tabella e userà queste informazioni per ancorare la generazione di query.
  2. Regolazione Basata sul Feedback: Il sistema regolerà le preferenze dell’utente in base al feedback e ragionerà su quali campi nello schema debbano essere aggiornati.
  3. Generazione ed Esecuzione delle Query: Il sistema genererà ed eseguirà query per recuperare dati aggiornati su voli e hotel basandosi sulle nuove preferenze.

Qui un esempio aggiornato di codice Python che incorpora questi concetti:

def adjust_based_on_feedback(feedback, preferences, schema):
    # Regola le preferenze in base al feedback dell'utente
    if "liked" in feedback:
        preferences["favorites"] = feedback["liked"]
    if "disliked" in feedback:
        preferences["avoid"] = feedback["disliked"]
    # Ragionamento basato sullo schema per regolare altre preferenze correlate
    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):
    # Logica personalizzata per regolare le preferenze basata su schema e 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 codice per recuperare dati sui voli basati sulle preferenze aggiornate
    return f"fetch_flights(preferences={preferences})"

def generate_code_to_fetch_hotels(preferences):
    # Genera codice per recuperare dati sugli hotel basati sulle preferenze aggiornate
    return f"fetch_hotels(preferences={preferences})"

def execute_code(code):
    # Simula l'esecuzione del codice e restituisce dati fittizi
    return {"data": f"Executed: {code}"}

def generate_itinerary(flights, hotels, attractions):
    # Genera l'itinerario basato su voli, hotel e attrazioni
    return {"flights": flights, "hotels": hotels, "attractions": attractions}

# Esempio di schema
schema = {
    "favorites": {"positive_adjustment": "increase", "negative_adjustment": "decrease", "default": "neutral"},
    "avoid": {"positive_adjustment": "decrease", "negative_adjustment": "increase", "default": "neutral"}
}

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

# Rigenera ed esegui il codice con le preferenze aggiornate
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)

Spiegazione - Prenotazioni Basate sul Feedback

  1. Consapevolezza dello Schema: Il dizionario schema definisce come le preferenze devono essere regolate in base al feedback. Include campi come favorites e avoid, con relative regolazioni.
  2. Regolazione delle Preferenze (metodo adjust_based_on_feedback): Questo metodo regola le preferenze basandosi sul feedback dell’utente e sullo schema.
  3. Regolazioni Basate sull’Ambiente (metodo adjust_based_on_environment): Questo metodo personalizza le regolazioni basate sullo schema e sul feedback.
  4. Generazione ed Esecuzione delle Query: Il sistema genera codice per recuperare dati aggiornati su voli e hotel basandosi sulle preferenze regolate e simula l’esecuzione di queste query.
  5. Generazione Itinerario: Il sistema crea un itinerario aggiornato basato sui nuovi dati di voli, hotel e attrazioni.

Rendendo il sistema consapevole dell’ambiente e usando il ragionamento basato sullo schema, può generare query più accurate e rilevanti, portando a raccomandazioni di viaggio migliori e a un’esperienza utente più personalizzata.

Uso di SQL come Tecnica di Retrieval-Augmented Generation (RAG)

SQL (Structured Query Language) è uno strumento potente per interagire con i database. Quando usato come parte di un approccio Retrieval-Augmented Generation (RAG), SQL può recuperare dati rilevanti dai database per informare e generare risposte o azioni negli agenti IA. Esploriamo come SQL può essere usato come tecnica RAG nel contesto di Agente di Viaggio.

Concetti Chiave

  1. Interazione con il Database:
    • SQL viene usato per interrogare database, recuperare informazioni rilevanti e manipolare dati.
    • Esempio: Recupero dettagli voli, informazioni hotel e attrazioni da un database di viaggi.
  2. Integrazione con RAG:
    • Le query SQL vengono generate sulla base degli input e delle preferenze dell’utente.
    • I dati recuperati vengono poi usati per generare raccomandazioni o azioni personalizzate.
  3. Generazione Dinamica delle Query:
    • L’agente IA genera query SQL dinamiche basate sul contesto e sulle esigenze dell’utente.
    • Esempio: Personalizzare query SQL per filtrare risultati in base a budget, date e interessi.

Applicazioni

Esempio: Un agente di analisi dati:

  1. Compito: Analizzare un set di dati per trovare tendenze.
  2. Passaggi:
    • Caricare il set di dati.
    • Generare query SQL per filtrare dati.
    • Eseguire query e recuperare risultati.
    • Generare visualizzazioni e approfondimenti.
  3. Risorse: Accesso al set di dati, capacità SQL.
  4. Esperienza: Usare risultati passati per migliorare analisi future.

Esempio Pratico: Uso di SQL in Agente di Viaggio

  1. Raccolta Preferenze Utente

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

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

  2. Generazione di Query 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. Esecuzione delle Query 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. Generazione Raccomandazioni

    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)

Esempi di Query SQL

  1. Query Voli

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

  2. Query Hotel

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

  3. Query Attrazioni

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

Sfruttando SQL come parte della tecnica Retrieval-Augmented Generation (RAG), agenti IA come Agente di Viaggio possono recuperare e utilizzare dinamicamente dati rilevanti per fornire raccomandazioni accurate e personalizzate.

Esempio di Metacognizione

Per dimostrare un’implementazione della metacognizione, creiamo un semplice agente che riflette sul proprio processo decisionale mentre risolve un problema. Per questo esempio, costruiremo un sistema in cui un agente cerca di ottimizzare la scelta di un hotel, ma poi valuta il proprio ragionamento e modifica la strategia quando commette errori o scelte non ottimali.

Simuleremo questo con un esempio base in cui l’agente seleziona hotel in base a una combinazione di prezzo e qualità, ma “rifletterà” sulle sue decisioni per adeguarsi di conseguenza.

Come questo illustra la metacognizione:

  1. Decisione Iniziale: L’agente sceglierà l’hotel più economico, senza comprendere l’impatto della qualità.
  2. Riflessione e Valutazione: Dopo la scelta iniziale, l’agente controllerà se l’hotel è una “scelta sbagliata” usando il feedback dell’utente. Se scopre che la qualità dell’hotel era troppo bassa, riflette sul proprio ragionamento.
  3. Modifica della Strategia: L’agente modifica la propria strategia basata sulla riflessione, passando da “più economico” a “massima qualità”, migliorando così il processo decisionale nelle iterazioni future.

Ecco un esempio:

class HotelRecommendationAgent:
    def __init__(self):
        self.previous_choices = []  # Memorizza gli hotel scelti in precedenza
        self.corrected_choices = []  # Memorizza le scelte corrette
        self.recommendation_strategies = ['cheapest', 'highest_quality']  # Strategie disponibili

    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]
        # Supponiamo di avere un feedback dell'utente che ci dice se l'ultima scelta è stata buona o no
        user_feedback = self.get_user_feedback(last_choice)

        if user_feedback == "bad":
            # Regola la strategia se la scelta precedente è stata insoddisfacente
            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"

# Simula una lista di hotel (prezzo e qualità)
hotels = [
    {'name': 'Budget Inn', 'price': 80, 'quality': 6},
    {'name': 'Comfort Suites', 'price': 120, 'quality': 8},
    {'name': 'Luxury Stay', 'price': 200, 'quality': 9}
]

# Crea un agente
agent = HotelRecommendationAgent()

# Passo 1: L'agente consiglia un hotel usando la strategia "più economico"
recommended_hotel = agent.recommend_hotel(hotels, 'cheapest')
print(f"Recommended hotel (cheapest): {recommended_hotel['name']}")

# Passo 2: L'agente riflette sulla scelta e regola la strategia se necessario
reflection_result = agent.reflect_on_choice()
print(reflection_result)

# Passo 3: L'agente consiglia di nuovo, questa volta usando la strategia regolata
adjusted_recommendation = agent.recommend_hotel(hotels, 'highest_quality')
print(f"Adjusted hotel recommendation (highest_quality): {adjusted_recommendation['name']}")

Abilità di Metacognizione degli Agenti

Il punto chiave è la capacità dell’agente di:

Questa è una forma semplice di metacognizione dove il sistema è capace di adattare il proprio processo di ragionamento basandosi su feedback interni.

Conclusione

La metacognizione è uno strumento potente che può migliorare significativamente le capacità degli agenti IA. Incorporando processi metacognitivi, puoi progettare agenti più intelligenti, adattabili ed efficienti. Usa le risorse aggiuntive per esplorare ulteriormente il mondo affascinante della metacognizione negli agenti IA.

Hai altre domande sul Design Pattern della Metacognizione?

Unisciti al Microsoft Foundry Discord per incontrare altri studenti, partecipare alle ore d’ufficio e ricevere risposte alle tue domande sugli Agenti IA.

Lezione Precedente

Multi-Agent Design Pattern

Prossima Lezione

Agenti IA in Produzione

Disclaimer: Questo documento è stato tradotto utilizzando il servizio di traduzione AI Co-op Translator. Sebbene ci impegniamo per garantire la precisione, si prega di notare che le traduzioni automatizzate possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa deve essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale effettuata da un essere umano. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall’uso di questa traduzione.

This site is open source. Improve this page.