Cours Microsoft d'introduction aux agents d'intelligence artificielle : métacognition (penser par soi-même) dans les agents d'intelligence artificielle

Informations sur le coursPosté il y a 6 mois Cercle de partage de l'IA
1.6K 00

bref

Bienvenue dans le cours sur la métacognition dans les agents d'intelligence artificielle ! Ce chapitre est destiné aux débutants intéressés par la façon dont les agents d'intelligence artificielle réfléchissent à leurs propres processus de pensée. A la fin de ce cours, vous comprendrez les concepts clés et aurez des exemples pratiques d'application de la métacognition dans la conception d'un agent d'IA.

 

objectif d'apprentissage

A l'issue de ce cours, vous serez en mesure de :

  1. Comprendre la signification de la boucle de raisonnement dans la définition de l'agent.
  2. Utiliser des techniques de planification et d'évaluation pour aider l'agent à s'auto-calibrer.
  3. Créez votre propre agent qui peut manipuler du code pour accomplir des tâches.

 

Introduction à la métacognition

La métacognition fait référence aux processus cognitifs d'ordre supérieur qui impliquent de penser à sa propre pensée. Pour un agent d'intelligence artificielle, cela signifie être capable d'évaluer et d'ajuster ses actions en fonction de sa conscience de soi et de ses expériences passées. La métacognition, ou "réflexion sur la réflexion", est un concept important dans le développement de systèmes d'IA basés sur des agents. Elle implique qu'un système d'IA prenne conscience de ses propres processus internes et soit capable de surveiller, de réguler et d'ajuster son comportement en conséquence. Un peu comme nous le faisons lorsque nous examinons une situation ou un problème. Cette conscience de soi peut aider les systèmes d'IA à prendre de meilleures décisions, à reconnaître les erreurs et à améliorer leurs performances au fil du temps - ce qui renvoie une fois de plus au test de Turing et au débat sur la question de savoir si l'IA remplacera les humains.

Dans le contexte des systèmes d'IA basés sur des agents, la métacognition peut aider à relever plusieurs défis, tels que :

  • Transparence : veiller à ce que le système d'IA puisse expliquer son raisonnement et ses décisions.
  • Raisonnement : améliorer la capacité des systèmes d'IA à synthétiser des informations et à prendre des décisions rationnelles.
  • Adaptabilité : permet au système d'IA de s'adapter à de nouveaux environnements et à des situations changeantes.
  • Perception : amélioration de la précision avec laquelle les systèmes d'IA reconnaissent et interprètent les données de leur environnement.

Qu'est-ce que la métacognition ?

La métacognition, ou "penser à la pensée", est un processus cognitif d'ordre supérieur impliquant la conscience de soi et l'autorégulation des processus cognitifs. En IA, la métacognition permet aux agents d'évaluer et d'adapter leurs stratégies et leurs actions afin d'améliorer la résolution des problèmes et la prise de décision. En comprenant la métacognition, vous pouvez concevoir des agents d'IA qui sont non seulement plus intelligents, mais aussi plus adaptatifs et plus efficaces, et dans une véritable métacognition, vous verrez l'IA raisonner explicitement sur son propre raisonnement.

Par exemple, "Je donne la priorité aux vols moins chers parce que ...... j'ai peut-être raté mon vol direct, alors je vais revérifier". . Suivre comment ou pourquoi il a choisi un itinéraire particulier.

  • Remarquez qu'il a commis l'erreur de trop se fier à la dernière préférence de l'utilisateur, ce qui l'a amené à modifier non seulement la recommandation finale, mais aussi sa stratégie de prise de décision.
  • Lorsque je vois des utilisateurs mentionner "trop de monde", je devrais non seulement supprimer certaines attractions, mais aussi réfléchir au fait que si je classe toujours par popularité, ma méthode de sélection des "attractions populaires" est erronée. est défectueuse."

 

L'importance de la métacognition dans les agents d'intelligence artificielle

La métacognition joue un rôle crucial dans la conception des agents d'IA pour les raisons suivantes :

微软 AI Agent 入门课程：AI Agent 中的元认知（自我思考）
  • Auto-réflexion : les agents peuvent évaluer leurs propres performances et identifier les domaines à améliorer.
  • Adaptabilité : l'agent peut modifier sa stratégie en fonction de son expérience passée et de l'évolution des circonstances.
  • Correction des erreurs : l'agent peut détecter et corriger les erreurs de manière autonome pour obtenir des résultats plus précis.
  • Gestion des ressources : les agents peuvent optimiser l'utilisation des ressources, telles que le temps et la puissance de calcul, en planifiant et en évaluant leurs actions.

 

Composantes d'un agent d'intelligence artificielle

Avant d'aborder le processus métacognitif, il est essentiel de comprendre les composants de base d'un agent d'intelligence artificielle. Un agent d'intelligence artificielle est généralement composé des éléments suivants :

  • Persona : La personnalité et les caractéristiques d'un agent qui définissent la manière dont il interagit avec l'utilisateur.
  • Outils : fonctions et capacités qu'un agent peut exécuter.
  • Compétences : les connaissances et l'expertise que possède l'agent.

Ces composants fonctionnent ensemble pour créer une "unité spécialisée" capable d'effectuer des tâches spécifiques.

exemple typiqueLe cas d'un agent de voyage : il s'agit d'un service d'agent qui ne se contente pas de planifier vos vacances, mais qui adapte également son itinéraire en fonction des données en temps réel et de l'expérience acquise par le client au cours de son voyage.

Exemple : la métacognition dans les services des agents de voyage

Supposons que vous conceviez un service d'agence de voyage alimenté par l'IA. Cet agent, "Travel Agent", aide les utilisateurs à planifier leurs vacances. Pour intégrer la métacognition, l'agent de voyage doit évaluer et adapter ses actions en fonction de sa conscience de soi et de ses expériences passées. Voici comment fonctionne la métacognition :

tâche en cours

La tâche actuelle consiste à aider l'utilisateur à planifier un voyage à Paris.

Étapes de l'exécution du mandat

  1. Collecte des préférences des utilisateursLes informations sur le voyage : Demandez à l'utilisateur ses dates de voyage, son budget, ses centres d'intérêt (par exemple, les musées, la gastronomie, le shopping) et toute autre exigence spécifique.
  2. récupérerLes services d'aide à la décision : Recherche de vols, d'hébergements, d'attractions et de restaurants en fonction des préférences de l'utilisateur.
  3. Générer des recommandationsLe site web de l'association : propose des itinéraires personnalisés avec les détails des vols, des réservations d'hôtels et des suggestions d'activités.
  4. Ajustements sur la base du retour d'informationLes utilisateurs sont invités à donner leur avis sur les suggestions et à procéder aux ajustements nécessaires.

Besoins en ressources

  • Accès aux bases de données de réservation de vols et d'hôtels.
  • Informations sur les attractions et les restaurants de Paris.
  • Données sur les réactions de l'utilisateur lors d'interactions précédentes.

Expérience et autoréflexion

L'agence de voyage utilise la métacognition pour évaluer ses performances et tirer les leçons de ses expériences passées. Exemple de métacognition :

  1. Analyse du retour d'information des utilisateursL'agent de voyage examine les commentaires des utilisateurs pour déterminer quelles suggestions ont été acceptées et lesquelles n'ont pas été retenues. Il ajustera ses futures recommandations en conséquence.
  2. flexibilitéL'agent de voyage évitera à l'avenir de recommander des attractions touristiques populaires pendant les heures de pointe si l'utilisateur a déjà indiqué qu'il n'aimait pas les endroits bondés.
  3. Correction des erreursSi l'agent de voyage a commis une erreur lors d'une réservation antérieure, par exemple en recommandant un hôtel qui était complet, il apprendra à vérifier plus rigoureusement les disponibilités avant de faire une recommandation.

Exemple d'un développeur réel

Il s'agit d'un exemple simplifié de ce à quoi le code de l'agence de voyage pourrait ressembler lorsqu'il est combiné à la métacognition :

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):
# Search for flights, hotels, and attractions based on preferences
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)
# Analyze feedback and adjust future recommendations
self.user_preferences = adjust_preferences(self.user_preferences, feedback)
# Example usage
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)

L'importance de la métacognition

  • l'autoréflexionL'agent peut analyser ses performances et identifier les domaines à améliorer.
  • flexibilitéL'agent peut modifier la politique en fonction du retour d'information et de l'évolution de la situation.
  • Correction des erreursL'agent peut détecter et corriger les erreurs de manière autonome.
  • Gestion des ressourcesL'agent peut optimiser l'utilisation des ressources telles que le temps et la puissance de calcul.

En intégrant la métacognition, l'agent de voyage peut fournir des conseils de voyage plus personnalisés et plus précis afin d'améliorer l'expérience globale de l'utilisateur.

 

2. la planification dans l'agent

La planification est un élément clé du comportement d'un agent d'IA. Elle consiste à définir les étapes nécessaires pour atteindre un objectif, en tenant compte de l'état actuel, des ressources et des obstacles éventuels.

Éléments de planification

  • tâche en coursDéfinition claire du mandat.
  • Étapes de l'exécution du mandatLes tâches : diviser les tâches en étapes faciles à gérer.
  • Besoins en ressourcesLes ressources nécessaires à la mise en œuvre du programme sont identifiées.
  • expériencesLes expériences passées peuvent servir de guide à la planification.

exemple typiqueLes étapes suivantes sont celles que l'agent de voyage doit suivre pour aider l'utilisateur à planifier son voyage de manière efficace :

Étapes pour l'agent de voyage

  1. Collecte des préférences des utilisateurs
    • Demandez aux utilisateurs des précisions sur leurs dates de voyage, leur budget, leurs centres d'intérêt et leurs besoins spécifiques.
    • EXEMPLE : "Quand prévoyez-vous de voyager ?" "Quel est votre budget ? "Quelles sont les activités que vous aimez pratiquer pendant vos vacances ?
  2. récupérer
    • Recherche d'options de voyage pertinentes en fonction des préférences de l'utilisateur.
    • navigation programméeLes vols : Trouver des vols disponibles qui correspondent au budget de l'utilisateur et à ses dates de voyage préférées.
    • séjourner àLes services d'aide à la décision : Trouver des hôtels ou des locations qui correspondent aux préférences de l'utilisateur en termes de localisation, de prix et d'équipements.
    • Attractions et restaurantsLes services d'aide à la décision : Identifier les attractions, les activités et les restaurants populaires qui correspondent aux centres d'intérêt des utilisateurs.
  3. Générer des recommandations
    • Compiler les informations récupérées dans un itinéraire personnalisé.
    • En fournissant des détails sur les options de vol, les réservations d'hôtel et les activités suggérées, les suggestions sont personnalisées en fonction des préférences de l'utilisateur.
  4. Montrer l'itinéraire à l'utilisateur
    • Les suggestions d'itinéraires sont communiquées aux utilisateurs pour examen.
    • Exemple : "Voici une suggestion d'itinéraire pour votre voyage à Paris. Il comprend les détails du vol, les réservations d'hôtel et une liste d'activités et de restaurants recommandés. N'hésitez pas à me faire part de vos commentaires !"
  5. Recueillir un retour d'information
    • Demander aux utilisateurs leur avis sur les trajets proposés.
    • EXEMPLE : "Les options de vol vous plaisent-elles ?" "L'hôtel vous convient-il ? "Voulez-vous ajouter ou supprimer des activités ?
  6. Ajustements sur la base du retour d'information
    • Modifier l'itinéraire en fonction des commentaires des utilisateurs.
    • Apporter les modifications nécessaires aux suggestions de vols, d'hébergements et d'activités pour mieux correspondre aux préférences des utilisateurs.
  7. Confirmation finale
    • Montrer l'itinéraire mis à jour à l'utilisateur pour confirmation finale.
    • EXEMPLE : "J'ai fait des ajustements en fonction de vos commentaires. Voici l'itinéraire mis à jour. Tout vous paraît-il correct ?"
  8. Réservation et confirmation des réservations
    • Une fois que l'utilisateur a approuvé l'itinéraire, il est possible de réserver les vols, l'hébergement et les activités prévues.
    • Envoie les détails de la confirmation à l'utilisateur.
  9. Fourniture d'un soutien continu
    • Aider l'utilisateur à apporter des modifications ou à formuler d'autres demandes à tout moment avant et pendant le voyage.
    • EXEMPLE : "Si vous avez besoin d'aide pendant votre voyage, n'hésitez pas à me contacter !".

Exemple d'interaction

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)
# Example usage within a booing request
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. le système RAG modifié

Tout d'abord, comprenons RAG La différence entre les outils et le chargement pré-contextualisé.

微软 AI Agent 入门课程：AI Agent 中的元认知（自我思考）

Génération d'augmentation de la recherche (RAG)

RAG combine un système de recherche et un modèle génératif. Lorsqu'une requête est formulée, le système de recherche obtient des documents ou des données pertinents à partir de sources externes et utilise ces informations pour enrichir les données d'entrée du modèle génératif. Cela permet au modèle de générer des réponses plus précises et contextualisées.

Dans un système RAG, un organisme intelligent (agent) extrait des informations pertinentes d'une base de connaissances et les utilise pour générer une réponse ou une action appropriée.

Méthode RAG modifiée

Une approche RAG corrective se concentre sur l'utilisation des techniques RAG pour corriger les erreurs et améliorer la précision d'une intelligence artificielle (agent). Il s'agit notamment de

  1. Technologie de la queueLes agents doivent être en mesure de trouver des informations pertinentes à l'aide de messages-guides spécifiques.
  2. artefactLes agents intelligents : mettre en œuvre des algorithmes et des mécanismes qui permettent aux agents intelligents d'évaluer la pertinence des informations recherchées et de générer des réponses précises.
  3. évaluationLe système de gestion de l'information : il évalue en permanence les performances d'un organisme intelligent (agent) et procède à des ajustements pour en améliorer la précision et l'efficacité.

Exemple : RAG modifié dans le cadre de la recherche de renseignements (agent)

Considérons une intelligence de recherche (agent) qui récupère des informations sur le web pour répondre à une requête de l'utilisateur. Les méthodes RAG modifiées peuvent inclure

  1. Technologie de la queueLes services de recherche : formuler des requêtes de recherche sur la base des données fournies par l'utilisateur.
  2. artefactLes résultats de recherche sont classés et filtrés à l'aide d'algorithmes de traitement du langage naturel et d'apprentissage automatique.
  3. évaluationLes utilisateurs ont la possibilité d'identifier et de corriger les inexactitudes dans l'information recherchée en analysant les réactions des utilisateurs.

RAG modifié en Travelling Intelligence (Agent)

La RAG corrective (Retrieval Augmented Generation) améliore la capacité de l'IA à récupérer et à générer des informations tout en corrigeant les éventuelles inexactitudes. Voyons comment Travel Agent utilise une approche RAG modifiée pour fournir des recommandations de voyage plus précises et plus pertinentes.

Il s'agit notamment de

  • Technologie de repérage : Utiliser des invites spécifiques pour guider l'agent dans la recherche d'informations pertinentes.
  • Outils : Mettre en œuvre des algorithmes et des mécanismes qui permettent aux agents intelligents (agents) d'évaluer la pertinence des informations recherchées et de générer des réponses précises.
  • Évaluation : Évaluer en permanence les performances des intelligences (agents) et procéder à des ajustements pour améliorer leur précision et leur efficacité.

Étapes de la mise en œuvre du RAG modifié dans l'agence de voyage

  1. Interaction initiale avec l'utilisateur
    • L'agent de voyage recueille les préférences initiales de l'utilisateur, telles que la destination, les dates de voyage, le budget et les centres d'intérêt.
    • Exemple : 
      preferences = {
"destination": "Paris",
"dates": "2025-04-01 to 2025-04-10",
"budget": "moderate",
"interests": ["museums", "cuisine"]
}
  2. recherche d'informations
    • L'agent de voyage récupère des informations sur les vols, l'hébergement, les attractions et les restaurants en fonction des préférences de l'utilisateur.
    • Exemple : 
      flights = search_flights(preferences)
hotels = search_hotels(preferences)
attractions = search_attractions(preferences)
  3. Formuler des recommandations initiales
    • L'agent de voyage utilise les informations récupérées pour créer un itinéraire personnalisé.
    • Exemple : 
      itinerary = create_itinerary(flights, hotels, attractions)
print("Suggested Itinerary:", itinerary)
  4. Recueillir le retour d'information des utilisateurs
    • L'agent de voyage demande à l'utilisateur son avis sur la recommandation initiale.
    • Exemple : 
      feedback = {
"liked": ["Louvre Museum"],
"disliked": ["Eiffel Tower (too crowded)"]
}
  5. Processus RAG modifié
    • Technologie de la queueL'agent de voyage développe de nouvelles requêtes de recherche basées sur les commentaires des utilisateurs.
      • Exemple : 
        if "disliked" in feedback:
preferences["avoid"] = feedback["disliked"]
    • artefactL'agent de voyage utilise des algorithmes pour classer et filtrer les nouveaux résultats de recherche et mettre l'accent sur la pertinence en fonction des commentaires des utilisateurs.
      • Exemple : 
        new_attractions = search_attractions(preferences)
new_itinerary = create_itinerary(flights, hotels, new_attractions)
print("Updated Itinerary:", new_itinerary)
    • évaluationL'agent de voyage évalue en permanence la pertinence et l'exactitude de ses recommandations en analysant les commentaires des utilisateurs et en procédant aux ajustements nécessaires.
      • Exemple : 
        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)

exemple pratique

Il s'agit d'un exemple simplifié de code Python dans lequel l'agent de voyage utilise une approche RAG modifiée :

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
# Example usage
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)

chargement pré-contextualisé

Le chargement pré-contexte consiste à charger des informations contextuelles pertinentes dans le modèle avant que la requête ne soit traitée. Cela signifie que le modèle a accès à ces informations dès le départ, ce qui peut l'aider à générer des réponses plus éclairées sans avoir à extraire des données supplémentaires au cours du traitement.

Voici un exemple simplifié d'une implémentation Python du chargement de pré-contexte dans une application d'agence de voyage :

class TravelAgent:
def __init__(self):
# Pre-load popular destinations and their information
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):
# Fetch destination information from pre-loaded context
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}."
# Example usage
travel_agent = TravelAgent()
print(travel_agent.get_destination_info("Paris"))
print(travel_agent.get_destination_info("Tokyo"))

instructions

  1. Initialisation (__init__ méthode): :TravelAgent est préchargée avec un dictionnaire contenant des informations sur des destinations populaires telles que Paris, Tokyo, New York et Sydney. Le dictionnaire comprend des informations détaillées sur le pays, la monnaie, la langue et les principales attractions de chaque destination.
  2. Récupérer des informations (get_destination_info méthode)Lorsqu'un utilisateur recherche une destination spécifique, le système d'information de l'Union européenne (UE) est mis à jour et le système d'information de l'UE est modifié.get_destination_info obtient les informations pertinentes à partir du dictionnaire contextuel préchargé.

En préchargeant le contexte, les applications des agences de voyage peuvent répondre rapidement aux demandes des utilisateurs sans avoir à extraire ces informations d'une source externe en temps réel. L'application est ainsi plus efficace et plus réactive.

Utiliser un plan axé sur les objectifs avant l'itération

L'utilisation d'un plan axé sur les objectifs implique de garder à l'esprit un objectif clair ou un résultat souhaité dès le départ. En définissant cet objectif à l'avance, le modèle peut l'utiliser comme principe directeur tout au long du processus d'itération. Cela permet de s'assurer que chaque itération se rapproche du résultat souhaité, rendant ainsi le processus plus efficace et plus ciblé.

Voici un exemple montrant comment utiliser la planification de voyage par objectifs en Python pour l'agent de voyage avant l'itération :

prendre

Un agent de voyage souhaite organiser des vacances sur mesure pour ses clients. L'objectif est de créer un itinéraire de voyage basé sur les préférences et le budget du client afin de maximiser sa satisfaction.

déplacer

  1. Définir les préférences et les budgets des clients.
  2. Orienter le plan initial en fonction de ces préférences.
  3. Répéter pour optimiser les plans afin de maximiser la satisfaction du client.

Code 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']
# Example usage
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)

Code Description

  1. Initialisation (__init__ méthode): :TravelAgent Les classes sont initialisées à l'aide d'une liste de destinations potentielles, chacune ayant des attributs tels que le nom, le coût et le type d'activité.
  2. Programme d'orientation (bootstrap_plan méthode)Cette méthode crée un plan de voyage initial basé sur les préférences et le budget du client. Elle parcourt la liste des destinations et les ajoute au plan si elles correspondent aux préférences du client et au budget.
  3. Correspondance des préférences (match_preferences méthode): Cette méthode permet de vérifier si la destination correspond aux préférences du client.
  4. Plan d'itération (iterate_plan méthode)Cette méthode optimise le plan initial en essayant de remplacer chaque destination du plan par une destination mieux adaptée, en tenant compte des préférences du client et des contraintes budgétaires.
  5. Calcul des coûts (calculate_cost méthode)Cette méthode calcule le coût total du programme actuel, y compris les nouvelles destinations potentielles.

Exemple d'utilisation

  • plan initialL'agent de voyage : L'agent de voyage élabore un plan initial en fonction des préférences du client en matière de visites touristiques et d'un budget de 2 000 dollars.
  • Plan d'optimisationLe programme itératif de l'agent de voyage, optimisé en fonction des préférences et des budgets des clients.

En se basant sur des objectifs clairs (par exemple, maximiser la satisfaction du client) pour orienter le plan et en procédant par itérations pour l'optimiser, Travel Agent crée des itinéraires de voyage personnalisés et optimisés pour les clients. Cette approche garantit que les plans de voyage sont alignés sur les préférences et les budgets des clients dès le départ et qu'ils sont améliorés à chaque itération.

Réorganisation et notation à l'aide de grands modèles linguistiques (LLM)

Les grands modèles linguistiques (LLM) peuvent être utilisés pour réorganiser et classer les documents récupérés ou les réponses générées en évaluant leur pertinence et leur qualité. Ils fonctionnent de la manière suivante :

Récupéré : L'étape de recherche initiale permet d'obtenir un ensemble de documents candidats ou de réponses en fonction de la requête.

Réorganisation : LLM évalue ces candidats et les réorganise en fonction de leur pertinence et de leur qualité. Cette étape garantit que les informations les plus pertinentes et de meilleure qualité sont présentées en premier.

Evaluation : LLM attribue des scores à chaque objet candidat, reflétant leur pertinence et leur qualité. Cela permet de sélectionner la meilleure réponse ou le meilleur document pour l'utilisateur.

En utilisant le LLM pour le réordonnancement et la notation, le système peut fournir des informations plus précises et contextuelles, améliorant ainsi l'expérience globale de l'utilisateur.

Voici un exemple de la manière dont un agent de voyage peut utiliser un grand modèle linguistique (LLM) pour réorganiser et classer les destinations en fonction des préférences de l'utilisateur en Python :

Scénarios - voyages basés sur les préférences

Les agents de voyage veulent recommander les meilleures destinations à leurs clients en fonction de leurs préférences. LLM aidera à re-trier et à classer les destinations pour s'assurer que les options les plus pertinentes sont présentées.

Les étapes :

  1. Recueillir les préférences des utilisateurs.
  2. Récupérer une liste de destinations de voyage potentielles.
  3. Utilisez le LLM pour réorganiser et classer les destinations en fonction des préférences de l'utilisateur.

Voici comment mettre à jour l'exemple précédent pour utiliser le service Azure OpenAI :

demande

  1. Vous devez disposer d'un abonnement Azure.
  2. Créez une ressource Azure OpenAI et obtenez votre clé API.

Exemple de code Python

import requests
import json
class TravelAgent:
def __init__(self, destinations):
self.destinations = destinations
def get_recommendations(self, preferences, api_key, endpoint):
# 为 Azure OpenAI 生成提示
prompt = self.generate_prompt(preferences)
# 定义请求的标头和负载
headers = {
'Content-Type': 'application/json',
'Authorization': f'Bearer {api_key}'
}
payload = {
"prompt": prompt,
"max_tokens": 150,
"temperature": 0.7
}
# 调用 Azure OpenAI API 以获取重新排序和评分的目的地
response = requests.post(endpoint, headers=headers, json=payload)
response_data = response.json()
# 提取并返回建议
recommendations = response_data['choices'][0]['text'].strip().split('\n')
return recommendations
def generate_prompt(self, preferences):
prompt = "以下是根据以下用户偏好排名和评分的旅游目的地：\n"
for key, value in preferences.items():
prompt += f"{key}: {value}\n"
prompt += "\n目的地：\n"
for destination in self.destinations:
prompt += f"- {destination['name']}: {destination['description']}\n"
return prompt
# 示例用法
destinations = [
{"name": "Paris", "description": "光之城，以其艺术、时尚和文化而闻名。"},
{"name": "Tokyo", "description": "充满活力的城市，以其现代性和传统寺庙而闻名。"},
{"name": "New York", "description": "不夜城，拥有标志性地标和多元文化。"},
{"name": "Sydney", "description": "美丽的海港城市，以其歌剧院和迷人的海滩而闻名。"},
]
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("推荐目的地：")
for rec in recommendations:
print(rec)

Explication du code - Registre des préférences

  1. initialisation: :TravelAgent La classe est initialisée à l'aide d'une liste de destinations de voyage potentielles, chacune ayant des attributs tels que le nom et la description.
  2. Obtenir des conseils (get_recommendations (Méthodes)Cette méthode génère des invites pour le service Azure OpenAI en fonction des préférences de l'utilisateur et envoie une requête HTTP POST à l'API Azure OpenAI pour réorganiser et noter les destinations.
  3. Générer une invite (generate_prompt (Méthodes)Cette méthode crée une invite pour Azure OpenAI qui inclut les préférences de l'utilisateur et une liste de destinations. L'invite demande au modèle de réorganiser et de noter les destinations en fonction des préférences fournies.
  4. Appels de l'API: :requests Bibliothèque permettant d'effectuer des requêtes HTTP POST aux points d'extrémité de l'API Azure OpenAI. La réponse contient les destinations réorganisées et notées.
  5. Exemple d'utilisationLes agents de voyage recueillent les préférences des utilisateurs (par exemple, l'intérêt pour les visites touristiques et le multiculturalisme) et utilisent le service Azure OpenAI pour obtenir des suggestions de reclassement et d'évaluation des destinations de voyage.

garantir que your_azure_openai_api_key Remplacez-la par votre clé d'API Azure OpenAI, et remplacez le fichier https://your-endpoint.com/... Remplacer par l'URL du point de terminaison de votre déploiement Azure OpenAI.

En exploitant le LLM pour la réorganisation et l'évaluation, les agences de voyage peuvent fournir à leurs clients des conseils de voyage plus personnalisés et plus pertinents, améliorant ainsi leur expérience globale.

{L'exemple de code ci-dessus montre clairement comment le contenu peut être réorganisé et noté à l'aide d'un grand modèle linguistique. Pour ce faire, on construit TravelAgent et combinées aux services Azure OpenAI, peuvent fournir efficacement des recommandations de voyage personnalisées basées sur les préférences de l'utilisateur. Cette approche permet non seulement d'améliorer la précision des recommandations, mais aussi d'améliorer l'expérience de l'utilisateur}.

RAG : Techniques et outils d'incitation

La génération augmentée par récupération (RAG) peut être à la fois une technique d'incitation et un outil dans le développement d'agents d'intelligence artificielle. Comprendre la différence entre les deux peut vous aider à utiliser plus efficacement la RAG dans vos projets.

Le RAG comme technique d'incitation

Qu'est-ce que c'est ?

  • En tant que technique d'incitation, le RAG implique la formulation de requêtes ou d'incitations spécifiques pour guider la recherche d'informations pertinentes à partir d'un grand corpus ou d'une base de données. Ces informations sont ensuite utilisées pour générer des réponses ou des actions.

Comment cela fonctionne-t-il ?

  1. Conseils de développementLes services d'aide à la décision : créer des messages-guides ou des requêtes bien structurés en fonction de la tâche à accomplir ou des données fournies par l'utilisateur.
  2. récupérerLes données de la base de connaissances ou des ensembles de données préexistants sont recherchées à l'aide de messages-guides.
  3. Générer une réponseLes informations sont combinées avec des modèles génératifs d'intelligence artificielle afin de produire une réponse complète et cohérente.

Exemple d'agent de voyage: :

  • L'utilisateur saisit "Je veux visiter les musées de Paris".
  • Cue : "Trouvez les meilleurs musées de Paris".
  • Informations extraites : informations détaillées sur le musée du Louvre, le musée d'Orsay et plus encore.
  • Réponse générée "Voici quelques-uns des plus grands musées de Paris : le musée du Louvre, le musée d'Orsay et le Centre Pompidou."

Le RAG en tant qu'outil

Qu'est-ce que c'est ?

  • En tant qu'outil, RAG est un système intégré qui automatise le processus de recherche et de génération, ce qui permet aux développeurs de mettre en œuvre plus facilement des fonctionnalités complexes d'intelligence artificielle sans avoir à créer manuellement des messages-guides pour chaque requête.

Comment cela fonctionne-t-il ?

  1. intégré (comme dans circuit intégré)L'intégration de RAG dans l'architecture d'un agent d'intelligence artificielle lui permet d'automatiser les tâches de recherche et de génération.
  2. automatiqueL'outil gère l'ensemble du processus, depuis la réception des données de l'utilisateur jusqu'à la génération de la réponse finale, sans qu'il soit nécessaire de fournir des messages explicites à chaque étape.
  3. l'efficacitéAméliorer les performances des agents en simplifiant le processus de recherche et de génération pour des réponses plus rapides et plus précises.

Exemple d'agent de voyage: :

  • L'utilisateur saisit "Je veux visiter les musées de Paris".
  • Outil RAG : recherche automatiquement des informations sur le musée et génère une réponse.
  • Réponse générée "Voici quelques-uns des plus grands musées de Paris : le musée du Louvre, le musée d'Orsay et le Centre Pompidou."

{Commentaire du critique technologique : La distinction entre la description de RAG en tant que technique de guidage et en tant qu'outil est importante. En tant que technique d'aide, RAG souligne l'importance de la formulation manuelle des requêtes ; en tant qu'outil, RAG met l'accent sur l'automatisation et l'intégration. Les deux approches ont leurs avantages et peuvent être choisies de manière flexible en fonction des besoins spécifiques.}

comparaisons

perspectiveTechnologie de la queueartefact
Manuel ou automatiqueÉlaborer manuellement des messages-guides pour chaque requête.Automatiser le processus d'extraction et de génération.
confinementPermet de mieux contrôler le processus de recherche.Récupération et génération simplifiées et automatisées.
dextéritéPermet d'adapter les messages-guides à des besoins spécifiques.Une mise en œuvre à grande échelle plus efficace.
sophisticationDes conseils doivent être créés et ajustés.Intégration plus facile dans l'architecture de l'agent d'intelligence artificielle.

Exemple pratique

Exemple de techniques de repérage :

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)

Exemple d'outil :

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)

VERDICT : Les différences entre les techniques d'incitation et les outils sont clairement démontrées par la comparaison de tableaux et d'exemples de code spécifiques. La formulation manuelle de conseils offre plus de flexibilité et de contrôle, tandis que les outils augmentent l'efficacité grâce à l'automatisation. Cela permet aux développeurs de faire des choix plus éclairés en fonction des besoins et des ressources du projet.

Évaluer la pertinence

L'évaluation de la pertinence est un aspect essentiel des performances de l'agent d'IA. Elle permet de s'assurer que les informations récupérées et générées par l'agent sont appropriées, précises et utiles à l'utilisateur. Voyons comment évaluer la pertinence d'un agent d'intelligence artificielle, à l'aide d'exemples pratiques et de conseils.

Concepts clés pour l'évaluation de la pertinence

  1. la connaissance de la situation: :
    • L'agent doit comprendre le contexte de la requête de l'utilisateur afin d'extraire et de générer des informations pertinentes.
    • Exemple : si un utilisateur demande "les meilleurs restaurants de Paris", l'agent doit tenir compte des préférences de l'utilisateur, telles que le type de cuisine et le budget.
  2. précision: :
    • Les informations fournies par l'agent doivent être factuellement correctes et à jour.
    • Exemple : suggérer des restaurants actuellement ouverts et ayant de bonnes critiques, plutôt que des options périmées ou fermées.
  3. intention de l'utilisateur: :
    • L'agent doit déduire l'intention qui sous-tend la requête de l'utilisateur afin de fournir les informations les plus pertinentes.
    • Exemple : si un utilisateur demande des "hôtels bon marché", l'agent doit donner la priorité aux options abordables.
  4. boucle de rétroaction: :
    • La collecte et l'analyse continues des commentaires des utilisateurs permettent à Agent d'améliorer son processus d'évaluation de la pertinence.
    • Exemple : combiner les évaluations des utilisateurs et le retour d'information sur les recommandations précédentes afin d'améliorer les réponses futures.

Conseils pratiques pour évaluer la pertinence

  1. score de pertinence: :
    • Chaque élément de recherche se voit attribuer un score de pertinence en fonction de sa correspondance avec la requête et les préférences de l'utilisateur.
    • Exemple : 
      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. Filtrage et tri: :
    • Filtrez les éléments non pertinents et triez les éléments restants en fonction de leur score de pertinence.
    • Exemple : 
      def filter_and_rank(items, query):
ranked_items = sorted(items, key=lambda item: relevance_score(item, query), reverse=True)
return ranked_items[:10]  # 返回前 10 个相关项目
  3. Traitement du langage naturel (NLP): :
    • Utiliser des techniques NLP pour comprendre les requêtes des utilisateurs et extraire les informations pertinentes.
    • Exemple : 
      def process_query(query):
# 使用 NLP 从用户的查询中提取关键信息
processed_query = nlp(query)
return processed_query
  4. Intégration du retour d'information de l'utilisateur: :
    • Recueillir les commentaires des utilisateurs sur les conseils fournis et les utiliser pour ajuster les futures évaluations de la pertinence.
    • Exemple : 
      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

Exemple : évaluation de la pertinence dans une agence de voyage

Vous trouverez ci-dessous un exemple pratique de la manière dont l'agence de voyage évalue la pertinence des recommandations de voyage :

class Travel_Agent:
def __init__(self):
self.user_preferences = {}
self.experience_data = []
def gather_preferences(self, preferences):
self.user_preferences = preferences
def retrieve_information(self):
flights = search_flights(self.user_preferences)
hotels = search_hotels(self.user_preferences)
attractions = search_attractions(self.user_preferences)
return flights, hotels, attractions
def generate_recommendations(self):
flights, hotels, attractions = self.retrieve_information()
ranked_hotels = self.filter_and_rank(hotels, self.user_preferences)
itinerary = create_itinerary(flights, ranked_hotels, attractions)
return itinerary
def filter_and_rank(self, items, query):
ranked_items = sorted(items, key=lambda item: self.relevance_score(item, query), reverse=True)
return ranked_items[:10]  # 返回前 10 个相关项目
def relevance_score(self, item, query):
score = 0
if item['category'] in query['interests']:
score += 1
if item['price'] <= query['budget']:
score += 1
if item['location'] == query['destination']:
score += 1
return score
def adjust_based_on_feedback(self, feedback, items):
for item in items:
if item['name'] in feedback['liked']:
item['relevance'] += 1
if item['name'] in feedback['disliked']:
item['relevance'] -= 1
return items
# 示例用法
travel_agent = Travel_Agent()
preferences = {
"destination": "Paris",
"dates": "2025-04-01 to 2025-04-10",
"budget": "moderate",
"interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
updated_items = travel_agent.adjust_based_on_feedback(feedback, itinerary['hotels'])
print("Updated Itinerary with Feedback:", updated_items)

Recherche intentionnelle

La recherche intentionnelle consiste à comprendre et à interpréter l'objectif sous-jacent à la requête de l'utilisateur afin de récupérer et de générer les informations les plus pertinentes et les plus utiles. Cette approche va au-delà de la simple correspondance des mots-clés et se concentre sur la compréhension des besoins et du contexte réels de l'utilisateur.

Concepts clés de la recherche intentionnelle

  1. Comprendre l'intention de l'utilisateur: :
    • L'intention de l'utilisateur peut être classée en trois catégories principales : information, navigation et transaction.
      • Intention informative: Utilisateurs recherchant des informations sur un sujet donné (par exemple, "Quels sont les meilleurs musées de Paris ?"). .
      • Intention de navigationL'utilisateur souhaite se rendre sur un site ou une page spécifique (par exemple, "site officiel du musée du Louvre").
      • Intention transactionnelleL'utilisateur souhaite effectuer une transaction, par exemple réserver un vol ou effectuer un achat (par exemple, "Réserver un vol pour Paris").
  2. la connaissance de la situation: :
    • L'analyse du contexte de la requête d'un utilisateur permet d'identifier avec précision son intention. Il s'agit notamment de prendre en compte les interactions précédentes, les préférences de l'utilisateur et les détails spécifiques de la requête en cours.
  3. Traitement du langage naturel (NLP): :
    • Les techniques NLP sont employées pour comprendre et interpréter les requêtes en langage naturel fournies par les utilisateurs. Elles comprennent des tâches telles que la reconnaissance des entités, l'analyse des sentiments et l'analyse syntaxique des requêtes.
  4. personnalisé: :
    • La personnalisation des résultats de recherche en fonction de l'historique de l'utilisateur, de ses préférences et de ses commentaires peut améliorer la pertinence des informations recherchées.

Exemple pratique : recherche intentionnelle dans une agence de voyage

Prenons l'exemple de l'agence de voyage pour illustrer la recherche intentionnelle.

  1. Collecte des préférences des utilisateurs 
    class Travel_Agent:
def __init__(self):
self.user_preferences = {}
def gather_preferences(self, preferences):
self.user_preferences = preferences
  2. Comprendre l'intention de l'utilisateur 
    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. la connaissance de la situation 
    def analyze_context(query, user_history):
# 将当前查询与用户历史记录相结合以理解情境
context = {
"current_query": query,
"user_history": user_history
}
return context
  4. Recherche et résultats personnalisés 
    def search_with_intent(query, preferences, user_history):
intent = identify_intent(query)
context = analyze_context(query, user_history)
if intent == "informational":
search_results = search_information(query, preferences)
elif intent == "navigational":
search_results = search_navigation(query)
elif intent == "transactional":
search_results = search_transaction(query, preferences)
personalized_results = personalize_results(search_results, user_history)
return personalized_results
def search_information(query, preferences):
# 信息型意图的示例搜索逻辑
results = search_web(f"best {preferences['interests']} in {preferences['destination']}")
return results
def search_navigation(query):
# 导航型意图的示例搜索逻辑
results = search_web(query)
return results
def search_transaction(query, preferences):
# 交易型意图的示例搜索逻辑
results = search_web(f"book {query} to {preferences['destination']}")
return results
def personalize_results(results, user_history):
# 示例个性化逻辑
personalized = [result for result in results if result not in user_history]
return personalized[:10]  # 返回前 10 个个性化结果
  5. Exemple d'utilisation 
    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. la génération de code en tant qu'outil

Les intelligences génératrices de code (agents) utilisent des modèles d'IA pour écrire et exécuter du code, résoudre des problèmes complexes et automatiser des tâches.

intelligence génératrice de codes

Les intelligences génératrices de code écrivent et exécutent du code en utilisant des modèles d'IA générative. Ces intelligences peuvent résoudre des problèmes complexes, automatiser des tâches et fournir des informations précieuses en générant et en exécutant du code dans divers langages de programmation.

application pratique

  1. Génération automatisée de codesGénérer des extraits de code pour des tâches spécifiques, telles que l'analyse de données, l'exploration de sites web ou l'apprentissage automatique.
  2. SQL comme RAGLes requêtes SQL permettent d'extraire et de manipuler des données à partir d'une base de données.
  3. Résolution de problèmesLes services d'assistance technique sont des services de conseil et d'assistance en matière de gestion des ressources humaines, de gestion des ressources humaines et d'assistance technique.

Exemple : intelligences génératrices de codes pour l'analyse des données

Supposons que vous conceviez une intelligence génératrice de codes. Voici comment elle pourrait fonctionner :

  1. mandatsLes services d'appui à la décision : Analyser des ensembles de données pour identifier des tendances et des modèles.
  2. déplacer: :
    • Chargez l'ensemble de données dans l'outil d'analyse des données.
    • Générer des requêtes SQL pour filtrer et agréger les données.
    • Exécutez la requête et récupérez les résultats.
    • Utiliser les résultats pour générer des visualisations et des analyses.
  3. Besoins en ressourcesAccès aux ensembles de données, aux outils d'analyse des données et aux fonctions SQL.
  4. expériencesLes analyses antérieures permettent d'améliorer la précision et la pertinence des analyses futures.

Exemple : Génération de codes intelligents pour les agents de voyage

Dans cet exemple, nous allons concevoir une intelligence génératrice de code, Travel Agent, qui aide l'utilisateur à planifier un voyage en générant et en exécutant du code. L'intelligence peut gérer des tâches telles que l'obtention d'options de voyage, le filtrage des résultats et la compilation d'itinéraires à l'aide de l'IA générative.

Aperçu de l'intelligence de la génération de code

  1. Collecte des préférences des utilisateursLes services d'aide à la décision : recueillir les données de l'utilisateur telles que la destination, les dates de voyage, le budget et les centres d'intérêt.
  2. Générer du code pour obtenir les donnéesLes services d'information sur les vols, les hôtels et les attractions : générez des extraits de code pour récupérer des données sur les vols, les hôtels et les attractions.
  3. Exécuter le code généréLe code généré peut être exécuté pour obtenir des informations en temps réel.
  4. Générer un voyageLes données recueillies sont compilées dans un plan de voyage personnalisé.
  5. Ajustements sur la base du retour d'informationLes résultats de l'analyse de l'impact sur l'environnement : Recevoir les commentaires des utilisateurs et régénérer le code si nécessaire afin d'optimiser les résultats.

étape par étape

  1. Collecte des préférences des utilisateurs 
    class Travel_Agent:
def __init__(self):
self.user_preferences = {}
def gather_preferences(self, preferences):
self.user_preferences = preferences
  2. Générer du code pour obtenir les données 
    def generate_code_to_fetch_data(preferences):
# 示例：生成代码以根据用户偏好搜索航班
code = f"""
def search_flights():
import requests
response = requests.get('https://api.example.com/flights', params={preferences})
return response.json()
"""
return code
def generate_code_to_fetch_hotels(preferences):
# 示例：生成代码以搜索酒店
code = f"""
def search_hotels():
import requests
response = requests.get('https://api.example.com/hotels', params={preferences})
return response.json()
"""
return code
  3. Exécuter le code généré 
    def execute_code(code):
# 使用 exec 执行生成的代码
exec(code)
result = locals()
return result
travel_agent = Travel_Agent()
preferences = {
"destination": "Paris",
"dates": "2025-04-01 to 2025-04-10",
"budget": "moderate",
"interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
flight_code = generate_code_to_fetch_data(preferences)
hotel_code = generate_code_to_fetch_hotels(preferences)
flights = execute_code(flight_code)
hotels = execute_code(hotel_code)
print("Flight Options:", flights)
print("Hotel Options:", hotels)
  4. Générer un voyage 
    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. Ajustements sur la base du retour d'information 
    def adjust_based_on_feedback(feedback, preferences):
# 根据用户反馈调整偏好
if "liked" in feedback:
preferences["favorites"] = feedback["liked"]
if "disliked" in feedback:
preferences["avoid"] = feedback["disliked"]
return preferences
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
updated_preferences = adjust_based_on_feedback(feedback, preferences)
# 使用更新的偏好重新生成并执行代码
updated_flight_code = generate_code_to_fetch_data(updated_preferences)
updated_hotel_code = generate_code_to_fetch_hotels(updated_preferences)
updated_flights = execute_code(updated_flight_code)
updated_hotels = execute_code(updated_hotel_code)
updated_itinerary = generate_itinerary(updated_flights, updated_hotels, attractions)
print("Updated Itinerary:", updated_itinerary)

Utiliser la perception et le raisonnement environnementaux

Selon le schéma du tableau, le processus de génération de requêtes peut en effet être amélioré en exploitant la connaissance du contexte et le raisonnement.

Vous trouverez ci-dessous un exemple de la manière dont cela peut être réalisé :

  1. Comprendre les modèlesLe système comprendra le schéma de la table et utilisera cette information pour déterminer la base de la génération de la requête.
  2. Ajustements sur la base du retour d'informationLe système ajustera les préférences de l'utilisateur en fonction du retour d'information et du raisonnement concernant les champs du schéma qui doivent être mis à jour.
  3. Générer et exécuter des requêtesLe système génère et exécute des requêtes pour obtenir des données actualisées sur les vols et les hôtels en fonction des nouvelles préférences.

Voici un exemple de code Python mis à jour qui intègre ces concepts :

def adjust_based_on_feedback(feedback, preferences, schema):
# 根据用户反馈调整偏好
if "liked" in feedback:
preferences["favorites"] = feedback["liked"]
if "disliked" in feedback:
preferences["avoid"] = feedback["disliked"]
# 根据模式进行推理以调整其他相关偏好
for field in schema:
if field in preferences:
preferences[field] = adjust_based_on_environment(feedback, field, schema)
return preferences
def adjust_based_on_environment(feedback, field, schema):
# 根据模式和反馈调整偏好的自定义逻辑
if field in feedback["liked"]:
return schema[field]["positive_adjustment"]
elif field in feedback["disliked"]:
return schema[field]["negative_adjustment"]
return schema[field]["default"]
def generate_code_to_fetch_data(preferences):
# 生成代码以根据更新的偏好获取航班数据
return f"fetch_flights(preferences={preferences})"
def generate_code_to_fetch_hotels(preferences):
# 生成代码以根据更新的偏好获取酒店数据
return f"fetch_hotels(preferences={preferences})"
def execute_code(code):
# 模拟代码执行并返回模拟数据
return {"data": f"Executed: {code}"}
def generate_itinerary(flights, hotels, attractions):
# 根据航班、酒店和景点生成行程
return {"flights": flights, "hotels": hotels, "attractions": attractions}
# 示例模式
schema = {
"favorites": {"positive_adjustment": "increase", "negative_adjustment": "decrease", "default": "neutral"},
"avoid": {"positive_adjustment": "decrease", "negative_adjustment": "increase", "default": "neutral"}
}
# 示例用法
preferences = {"favorites": "sightseeing", "avoid": "crowded places"}
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
updated_preferences = adjust_based_on_feedback(feedback, preferences, schema)
# 使用更新的偏好重新生成并执行代码
updated_flight_code = generate_code_to_fetch_data(updated_preferences)
updated_hotel_code = generate_code_to_fetch_hotels(updated_preferences)
updated_flights = execute_code(updated_flight_code)
updated_hotels = execute_code(updated_hotel_code)
updated_itinerary = generate_itinerary(updated_flights, updated_hotels, feedback["liked"])
print("Updated Itinerary:", updated_itinerary)

Description - Réservation basée sur le retour d'information

  1. Perception des formes: :schema Le dictionnaire définit la manière dont les préférences doivent être ajustées en fonction du retour d'information. Il comprend favorites répondre en chantant avoid etc. et les ajustements correspondants.
  2. Ajustement des préférences (adjust_based_on_feedback méthode)Cette méthode permet d'ajuster les préférences en fonction du retour d'information de l'utilisateur et de ses habitudes.
  3. Ajustements basés sur l'environnement (adjust_based_on_environment méthode)Cette méthode est adaptée au mode et au retour d'information.
  4. Générer et exécuter des requêtesLe système génère un code pour obtenir des données actualisées sur les vols et les hôtels en fonction des préférences ajustées et simule l'exécution de ces requêtes.
  5. Générer un voyageLe système crée des itinéraires actualisés sur la base des nouvelles données relatives aux vols, aux hôtels et aux attractions.

En rendant le système sensible au contexte et en raisonnant sur la base de modèles, il peut générer des requêtes plus précises et plus pertinentes, ce qui se traduit par de meilleurs conseils de voyage et une expérience plus personnalisée pour l'utilisateur.

Utilisation de SQL comme technique de génération d'augmentation de la recherche (RAG)

Le langage SQL (Structured Query Language) est un outil puissant pour interagir avec les bases de données. Lorsqu'il est utilisé dans le cadre d'une approche RAG (Retrieval Augmented Generation), SQL peut extraire des données pertinentes d'une base de données afin d'informer et de générer une réponse ou une action au sein d'une intelligence artificielle. Voyons comment utiliser SQL comme technique de RAG dans le contexte d'une agence de voyage.

Concepts clés

  1. Interaction avec la base de données: :
    • Le langage SQL est utilisé pour interroger les bases de données, récupérer les informations pertinentes et manipuler les données.
    • Exemple : obtenir des informations sur les vols, les hôtels et les attractions à partir d'une base de données de voyages.
  2. Intégration avec le RAG: :
    • Générer des requêtes SQL en fonction des entrées et des préférences de l'utilisateur.
    • Les données récupérées sont ensuite utilisées pour générer des recommandations ou des actions personnalisées.
  3. Génération dynamique de requêtes: :
    • Les intelligences IA génèrent des requêtes SQL dynamiques basées sur le contexte et les besoins de l'utilisateur.
    • Exemple : Personnaliser une requête SQL pour filtrer les résultats par budget, date et intérêt.

appareil

  • Génération automatisée de codesGénérer des extraits de code pour des tâches spécifiques.
  • SQL comme RAGLes données de l'entreprise : Utiliser des requêtes SQL pour manipuler des données.
  • Résolution de problèmesLes problèmes de santé publique : créer et exécuter le code pour résoudre le problème.

exemple typique: Data Analytics Intelligence Body :

  1. mandatsLes services d'aide à la décision : Analyser des ensembles de données afin de dégager des tendances.
  2. déplacer: :
    • Charger le jeu de données.
    • Générer des requêtes SQL pour filtrer les données.
    • Exécutez la requête et récupérez les résultats.
    • Générer des visualisations et des analyses.
  3. ressource (comme la main-d'œuvre ou le tourisme)Accès aux données, fonctions SQL.
  4. expériencesLes résultats de l'analyse des données sont utilisés pour améliorer les analyses futures.

Exemple pratique : utilisation de SQL dans une agence de voyage

  1. Collecte des préférences des utilisateurs 
    class Travel_Agent:
def __init__(self):
self.user_preferences = {}
def gather_preferences(self, preferences):
self.user_preferences = preferences
  2. Générer des requêtes 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. Exécution de requêtes 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. Générer des recommandations 
    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)

Exemple de requête SQL

  1. Demande de renseignements sur les vols 
    SELECT * FROM flights WHERE destination='Paris' AND dates='2025-04-01 to 2025-04-04-10' AND budget='moderate';
  2. Demande de renseignements sur l'hôtel 
    SELECT * FROM hotels WHERE destination='Paris' AND budget='moderate';
  3. Demande de renseignements sur les attractions 
    SELECT * FROM attractions WHERE destination='Paris' AND interests='museums, cuisine';

En exploitant SQL dans le cadre de la technologie Retrieval Augmented Generation (RAG), les intelligences IA comme Travel Agent peuvent récupérer et exploiter dynamiquement des données pertinentes pour fournir des recommandations précises et personnalisées.

Exemples de métacognition

Pour démontrer la mise en œuvre de la métacognition, créons une intelligence simple qui résout les problèmes lorsqu'elle est en mesure de les résoudre.Réflexion sur son processus décisionnel. Dans cet exemple, nous construirons un système dans lequel un corps intelligent tente d'optimiser le choix d'un hôtel, puis évalue son propre raisonnement et ajuste sa stratégie lorsqu'il se trompe ou fait un choix sous-optimal.

Nous simulerons cela à l'aide d'un exemple de base où l'intelligence choisit un hôtel sur la base d'une combinaison de prix et de qualité, mais elle "réfléchit" à sa décision et l'ajuste en conséquence.

Comment cela rend-il compte de la métacognition ?

  1. Prise de décision initialeIntelligentsia choisira l'hôtel le moins cher, quelles que soient les implications en termes de qualité.
  2. Réflexion et évaluationAprès avoir fait un premier choix, l'organisme intelligent utilisera les commentaires de l'utilisateur pour vérifier si l'hôtel est un "mauvais" choix. S'il estime que la qualité de l'hôtel est trop faible, il réfléchira à son raisonnement.
  3. aligner la stratégieL'intelligence ajuste sa stratégie sur la base de ses réflexions, passant du "moins cher" à la "meilleure qualité", améliorant ainsi son processus de prise de décision dans les itérations futures.

Des exemples sont présentés ci-dessous :

class HotelRecommendationAgent:
def __init__(self):
self.previous_choices = []  # 存储之前选择的酒店
self.corrected_choices = []  # 存储更正后的选择
self.recommendation_strategies = ['cheapest', 'highest_quality']  # 可用策略
def recommend_hotel(self, hotels, strategy):
"""
根据所选策略推荐酒店。
策略可以是“最便宜”或“最高质量”。
"""
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):
"""
反思上次做出的选择，并决定智能体是否应调整其策略。
智能体会考虑之前的选择是否导致了较差的结果。
"""
if not self.previous_choices:
return "尚未做出选择。"
last_choice_strategy, last_choice = self.previous_choices[-1]
# 假设我们有一些用户反馈告诉我们上次的选择是好是坏
user_feedback = self.get_user_feedback(last_choice)
if user_feedback == "bad":
# 如果之前的选择不令人满意，则调整策略
new_strategy = 'highest_quality' if last_choice_strategy == 'cheapest' else 'cheapest'
self.corrected_choices.append((new_strategy, last_choice))
return f"反思选择。将策略调整为 {new_strategy}。"
else:
return "选择很好。无需调整。"
def get_user_feedback(self, hotel):
"""
模拟基于酒店属性的用户反馈。
为简单起见，假设如果酒店太便宜，则反馈为“差”。
如果酒店质量低于 7，则反馈为“差”。
"""
if hotel['price'] < 100 or hotel['quality'] < 7:
return "bad"
return "good"
# 模拟酒店列表（价格和质量）
hotels = [
{'name': 'Budget Inn', 'price': 80, 'quality': 6},
{'name': 'Comfort Suites', 'price': 120, 'quality': 8},
{'name': 'Luxury Stay', 'price': 200, 'quality': 9}
]
# 创建一个智能体
agent = HotelRecommendationAgent()
# 第 1 步：智能体使用“最便宜”策略推荐酒店
recommended_hotel = agent.recommend_hotel(hotels, 'cheapest')
print(f"推荐酒店（最便宜）：{recommended_hotel['name']}")
# 第 2 步：智能体反思选择并在必要时调整策略
reflection_result = agent.reflect_on_choice()
print(reflection_result)
# 第 3 步：智能体再次推荐，这次使用调整后的策略
adjusted_recommendation = agent.recommend_hotel(hotels, 'highest_quality')
print(f"调整后的酒店推荐（最高质量）：{adjusted_recommendation['name']}")

la capacité cognitive du métabolisme corporel intelligent (IBM)

L'élément clé est la capacité des intelligences :

  • Évaluer leurs processus de sélection et de prise de décision antérieurs.
  • Adapter leurs stratégies en fonction de cette réflexion, c'est-à-dire l'application pratique de la métacognition.

Il s'agit d'une forme simple de métacognition dans laquelle le système est capable d'adapter son processus de raisonnement en réponse à un retour d'information interne.

 

rendre un verdict

La métacognition est un outil puissant qui peut améliorer considérablement les capacités des intelligences artificielles. En intégrant des processus métacognitifs, vous pouvez concevoir des intelligences plus intelligentes, plus adaptatives et plus efficaces. Utilisez d'autres ressources pour explorer plus avant le monde fascinant de la métacognition dans les intelligences IA.

© déclaration de droits d'auteur
L'article est protégé par le droit d'auteur et ne doit pas être reproduit sans autorisation.
AiPPT

Articles connexes

Pas de commentaires

Vous devez être connecté pour participer aux commentaires !
S'inscrire maintenant
aucun
Pas de commentaires...

Outils d'IA sélectionnés

Dernières collections

Derniers articles