Curso introdutório de agente de IA da Microsoft: Metacognição (pensar por si mesmo) em agentes de IA

breve

Bem-vindo ao curso sobre Metacognição no AI Agent! Este capítulo foi criado para iniciantes interessados em saber como os agentes de IA pensam sobre seus próprios processos de pensamento. Ao final deste curso, você entenderá os principais conceitos e terá exemplos práticos de aplicação da metacognição no projeto do AI Agent.

meta de aprendizado

Após a conclusão deste curso, você será capaz de:

1. Entenda o significado do loop de raciocínio na definição do Agente.
2. Use técnicas de planejamento e avaliação para ajudar a auto-calibrar o Agente.
3. Crie seu próprio agente que possa manipular o código para realizar tarefas.

Introdução à metacognição

Metacognição refere-se a processos cognitivos de ordem superior que envolvem pensar sobre o próprio pensamento. Para um agente de IA, isso significa ser capaz de avaliar e ajustar suas ações com base na autoconsciência e nas experiências passadas. Metacognição, ou "pensar sobre o pensamento", é um conceito importante no desenvolvimento de sistemas de IA baseados em agentes. Ela envolve um sistema de IA que se torna consciente de seus próprios processos internos e é capaz de monitorar, regular e ajustar seu comportamento de acordo com isso. Da mesma forma que fazemos quando observamos uma situação ou examinamos um problema. Essa autoconsciência pode ajudar os sistemas de IA a tomar melhores decisões, reconhecer erros e melhorar seu desempenho ao longo do tempo - mais uma vez, fazendo uma ligação com o teste de Turing e o debate sobre se a IA substituirá os seres humanos.

No contexto dos sistemas de IA baseados em agentes, a metacognição pode ajudar a enfrentar vários desafios, como:

• Transparência: garantir que o sistema de IA possa explicar seu raciocínio e suas decisões.
• Raciocínio: aprimorar a capacidade dos sistemas de IA de sintetizar informações e tomar decisões racionais.
• Adaptabilidade: permite que o sistema de IA se adapte a novos ambientes e situações variáveis.
• Percepção: melhorar a precisão com que os sistemas de IA reconhecem e interpretam os dados de seu ambiente.

O que é metacognição?

A metacognição, ou "pensar sobre o pensamento", é um processo cognitivo de ordem superior que envolve a autoconsciência e a autorregulação dos processos cognitivos. Na IA, a metacognição permite que os agentes avaliem e adaptem suas estratégias e ações para melhorar a resolução de problemas e a tomada de decisões. Ao compreender a metacognição, é possível projetar agentes de IA que não sejam apenas mais inteligentes, mas também mais adaptáveis e eficientes e, na verdadeira metacognição, você verá a IA raciocinando explicitamente sobre seu próprio raciocínio.

Por exemplo, "Dou prioridade a voos mais baratos porque ...... posso ter perdido meu voo direto, então vou verificar novamente." . Acompanhe como ou por que ele escolheu uma determinada rota.

• Observe que ele cometeu o erro de confiar demais na última preferência do usuário e, portanto, modificou não apenas a recomendação final, mas também sua estratégia de tomada de decisão.
• modelo de diagnóstico, por exemplo, "Sempre que vejo usuários mencionando 'muito lotado', não devo apenas remover certas atrações, mas também refletir sobre o fato de que, se eu sempre classificar por popularidade, meu método de seleção de 'atrações populares' é é falho".

A importância da metacognição em agentes de IA

A metacognição desempenha uma função crucial no projeto do agente de IA pelos seguintes motivos:

• Autorreflexão: os agentes podem avaliar seu próprio desempenho e identificar áreas para aprimoramento.
• Adaptabilidade: o agente pode modificar sua estratégia com base na experiência anterior e nas circunstâncias variáveis.
• Correção de erros: o agente pode detectar e corrigir erros de forma autônoma para obter resultados mais precisos.
• Gerenciamento de recursos: os agentes podem otimizar o uso de recursos, como tempo e capacidade de computação, planejando e avaliando suas ações.

Componentes de um agente de IA

Antes de se aprofundar no processo metacognitivo, é fundamental entender os componentes básicos de um agente de IA:

• Persona: a personalidade e as características de um agente que definem a maneira como ele interage com o usuário.
• Ferramentas: funções e recursos que um agente pode executar.
• Habilidades: o conhecimento e a experiência que o Agente possui.

Esses componentes trabalham juntos para criar uma "unidade especializada" que pode executar tarefas específicas.

exemplo típicoConsidere um agente de viagens, um serviço de agente que não apenas planeja suas férias, mas também ajusta seu caminho com base em dados em tempo real e na experiência anterior de jornada do cliente.

Exemplo: Metacognição em serviços de agentes de viagem

Suponha que você esteja projetando um serviço de agente de viagens com tecnologia de IA. Esse agente, "Travel Agent", ajuda os usuários a planejar suas férias. Para incorporar a metacognição, o Travel Agent precisa avaliar e adaptar suas ações com base na autoconsciência e nas experiências anteriores. Veja como funciona a metacognição:

tarefa atual

A tarefa atual é ajudar o usuário a planejar uma viagem a Paris.

Etapas para cumprir o mandato

1. Coleta de preferências do usuárioSolicite as datas de viagem do usuário, o orçamento, os interesses (por exemplo, museus, alimentação, compras) e quaisquer requisitos específicos.
2. recuperarPesquisa de opções de voos, acomodações, atrações e restaurantes que correspondam às preferências do usuário.
3. Geração de recomendaçõesOferece itinerários personalizados com detalhes de voos, reservas de hotéis e sugestões de atividades.
4. Ajustes com base no feedbackPeça feedback aos usuários sobre as sugestões e faça os ajustes necessários.

Requisitos de recursos

• Acesso a bancos de dados de reservas de voos e hotéis.
• Informações sobre atrações e restaurantes em Paris.
• Dados de feedback do usuário de interações anteriores.

Experiência e autorreflexão

O agente de viagens usa a metacognição para avaliar seu desempenho e aprender com experiências passadas. Exemplo:

1. Análise do feedback do usuárioO Travel Agent analisa os comentários dos usuários para determinar quais sugestões foram aceitas e quais não foram. Ele ajustará suas recomendações futuras de acordo com isso.
2. flexibilidadeNo futuro, o agente de viagens evitará recomendar atrações turísticas populares durante os horários de pico se o usuário tiver mencionado anteriormente que não gosta de lugares lotados.
3. Correção de errosSe o agente de viagens tiver cometido um erro em uma reserva anterior, como recomendar um hotel que estava lotado, ele aprenderá a verificar a disponibilidade com mais rigor antes de fazer uma recomendação.

Exemplo de um desenvolvedor real

Este é um exemplo simplificado de como o código do agente de viagens pode se parecer quando combinado com a metacognição:

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)

Por que a metacognição é importante

• autorreflexãoO Agente pode analisar seu desempenho e identificar áreas para aprimoramento.
• flexibilidadeO agente pode modificar a política com base no feedback e nas mudanças de condições.
• Correção de errosAgente: O agente pode detectar e corrigir erros de forma autônoma.
• Gerenciamento de recursosAgente: O agente pode otimizar o uso de recursos, como tempo e capacidade de computação.

Ao incorporar a metacognição, o agente de viagens pode fornecer conselhos de viagem mais personalizados e precisos para aprimorar a experiência geral do usuário.

2. planejamento no agente

O planejamento é um componente essencial do comportamento do agente de IA. Ele envolve a definição das etapas necessárias para atingir uma meta, levando em conta o estado atual, os recursos e os possíveis obstáculos.

Elementos de planejamento

• tarefa atualDefinição clara do mandato.
• Etapas para cumprir o mandatoDivisão das tarefas em etapas gerenciáveis.
• Requisitos de recursosIdentificação dos recursos necessários.
• experiênciasUse a experiência anterior para orientar o planejamento.

exemplo típico: A seguir estão as etapas que o agente de viagens precisa seguir para ajudar o usuário a planejar sua viagem de forma eficaz:

Etapas para o agente de viagens

1. Coleta de preferências do usuário
   • Peça aos usuários detalhes sobre suas datas de viagem, orçamento, interesses e quaisquer requisitos específicos.
   • EXEMPLO: "Quando você está planejando viajar?" "Qual é a sua faixa de orçamento?" "Que atividades você gosta de fazer durante as férias?"
2. recuperar
   • Pesquise opções de viagem relevantes com base nas preferências do usuário.
   • navegação programadaEncontre voos disponíveis que atendam ao orçamento do usuário e às datas de viagem preferidas.
   • ficar emEncontre hotéis ou propriedades para aluguel que correspondam às preferências do usuário em termos de localização, preço e comodidades.
   • Atrações e restaurantesIdentificar atrações populares, atividades e opções de restaurantes que correspondam aos interesses dos usuários.
3. Geração de recomendações
   • Compilar as informações recuperadas em um itinerário personalizado.
   • O fornecimento de detalhes de opções de voos, reservas de hotéis e atividades sugeridas garante que as sugestões sejam personalizadas de acordo com as preferências do usuário.
4. Mostrar o itinerário ao usuário
   • Os itinerários sugeridos são compartilhados com os usuários para análise.
   • Exemplo: "Esta é uma sugestão de itinerário para sua viagem a Paris. Ele inclui detalhes do voo, reservas de hotel e uma lista de atividades e restaurantes recomendados. Por favor, deixe-me saber o que você acha!"
5. Coleta de feedback
   • Peça feedback aos usuários sobre as jornadas propostas.
   • EXEMPLO: "Você gosta das opções de voo?" "O hotel atende às suas necessidades?" "Você deseja adicionar ou remover alguma atividade?"
6. Ajustes com base no feedback
   • Modifique o itinerário com base no feedback do usuário.
   • Faça as alterações necessárias nas sugestões de voos, acomodações e atividades para melhor atender às preferências do usuário.
7. Confirmação final
   • Mostre o itinerário atualizado ao usuário para confirmação final.
   • EXEMPLO: "Fiz ajustes com base em seus comentários. Aqui está o itinerário atualizado. Está tudo certo?"
8. Reserva e confirmação de reservas
   • Depois que o usuário aprovar o itinerário, prossiga com a reserva de voos, acomodações e quaisquer atividades pré-planejadas.
   • Envia detalhes de confirmação para o usuário.
9. Fornecimento de suporte contínuo
   • Auxiliar o usuário com quaisquer alterações ou outras solicitações a qualquer momento antes e durante a viagem.
   • EXEMPLO: "Se precisar de mais assistência durante sua viagem, sinta-se à vontade para entrar em contato comigo!"

Exemplo de interação

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. sistema RAG modificado

Em primeiro lugar, vamos entender RAG A diferença entre ferramentas e carregamento pré-contextualizado.

Geração de aumento de recuperação (RAG)

O RAG combina um sistema de recuperação com um modelo generativo. Quando uma consulta é feita, o sistema de recuperação obtém documentos ou dados relevantes de fontes externas e usa essas informações recuperadas para aumentar as entradas do modelo generativo. Isso ajuda o modelo a gerar respostas mais precisas e contextualizadas.

Em um sistema RAG, um corpo inteligente (Agente) recupera informações relevantes de uma base de conhecimento e as utiliza para gerar uma resposta ou ação apropriada.

Método RAG modificado

Uma abordagem de RAG corretiva se concentra no uso de técnicas de RAG para corrigir erros e melhorar a precisão de uma inteligência de IA (agente). Isso inclui:

1. Tecnologia CueUse prompts específicos para orientar o agente na recuperação de informações relevantes.
2. artefatoImplementação de algoritmos e mecanismos que permitem que agentes inteligentes (agentes) avaliem a relevância das informações recuperadas e gerem respostas precisas.
3. avaliaçãoAgente: avalia continuamente o desempenho de um corpo inteligente (Agente) e faz ajustes para melhorar sua precisão e eficiência.

Exemplo: RAG modificado em inteligência de busca (agente)

Considere uma inteligência de busca (agente) que recupera informações da Web para responder a uma consulta do usuário. Os métodos RAG modificados podem incluir:

1. Tecnologia CueFormular consultas de pesquisa com base na entrada do usuário.
2. artefatoUse algoritmos de processamento de linguagem natural e aprendizado de máquina para classificar e filtrar resultados de pesquisa.
3. avaliaçãoAnálise do feedback do usuário para identificar e corrigir imprecisões nas informações recuperadas.

RAG modificado em inteligência itinerante (agente)

O RAG (Retrieval Augmented Generation) corretivo aprimora a capacidade da IA de recuperar e gerar informações e, ao mesmo tempo, corrigir quaisquer imprecisões. Vamos dar uma olhada em como o Travel Agent usa uma abordagem RAG modificada para fornecer recomendações de viagem mais precisas e relevantes.

Isso inclui:

• Tecnologia de taco: Use prompts específicos para orientar o agente a recuperar informações relevantes.
• Ferramentas: Implementar algoritmos e mecanismos que permitam que agentes inteligentes (agentes) avaliem a relevância das informações recuperadas e gerem respostas precisas.
• Avaliação: Avaliar continuamente o desempenho das inteligências (agentes) e fazer ajustes para melhorar sua precisão e eficiência.

Etapas para implementar o RAG modificado no agente de viagens

1. Interação inicial com o usuário
   • O Travel Agent coleta as preferências iniciais do usuário, como destino, datas de viagem, orçamento e interesses.
   • Exemplo:

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

2. recuperação de informações
   • O Travel Agent recupera informações sobre voos, acomodações, atrações e restaurantes com base nas preferências do usuário.
   • Exemplo:

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

3. Gerar recomendações iniciais
   • O agente de viagens usa as informações recuperadas para gerar um itinerário personalizado.
   • Exemplo:

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

4. Coleta de feedback do usuário
   • O agente de viagens pede ao usuário um feedback sobre a recomendação inicial.
   • Exemplo:

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

5. Processo RAG modificado
   • Tecnologia CueO Travel Agent desenvolve novas consultas de pesquisa com base no feedback do usuário.
     • Exemplo:

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

   • artefatoO Travel Agent usa algoritmos para classificar e filtrar novos resultados de pesquisa e enfatizar a relevância com base no feedback do usuário.
     • Exemplo:

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

   • avaliaçãoO Travel Agent avalia continuamente a relevância e a precisão de suas recomendações, analisando o feedback do usuário e fazendo ajustes conforme necessário.
     • Exemplo:

       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)
       

exemplo prático

Este é um exemplo simplificado de código Python em que o Travel Agent usa uma abordagem RAG modificada:

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)

carregamento pré-contextualizado

O carregamento pré-contexto envolve o carregamento de informações relevantes sobre o contexto ou o histórico no modelo antes do processamento da consulta. Isso significa que o modelo tem acesso a essas informações desde o início, o que pode ajudá-lo a gerar respostas mais informadas sem precisar recuperar dados adicionais durante o processamento.

A seguir, um exemplo simplificado de uma implementação Python de carregamento de pré-contexto em um aplicativo Travel Agent:

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"))

instruções

1. Inicialização (__init__ método)::TravelAgent A classe é pré-carregada com um dicionário que contém informações sobre destinos populares, como Paris, Tóquio, Nova York e Sydney. O dicionário inclui informações detalhadas sobre o país, a moeda, o idioma e as principais atrações de cada destino.
2. Recuperar informações (get_destination_info método)Quando um usuário faz uma consulta sobre um destino específico, oget_destination_info obtém as informações relevantes do dicionário de contexto pré-carregado.

Com o pré-carregamento do contexto, os aplicativos do agente de viagens podem responder rapidamente às consultas dos usuários sem precisar recuperar essas informações de uma fonte externa em tempo real. Isso torna o aplicativo mais eficiente e ágil.

Use um plano direcionado por metas antes da iteração

O uso de um plano direcionado por metas envolve manter um objetivo claro ou um resultado desejado em mente desde o início. Ao definir essa meta com antecedência, o modelo pode usá-la como um princípio orientador durante todo o processo de iteração. Isso ajuda a garantir que cada iteração esteja mais próxima de alcançar o resultado desejado, tornando o processo mais eficiente e focado.

Aqui está um exemplo que mostra como usar o planejamento de viagem direcionado por metas em Python para o Travel Agent antes da iteração:

tomar

O agente de viagens quer planejar férias sob medida para seus clientes. O objetivo é criar um itinerário de viagem com base nas preferências e no orçamento do cliente para maximizar sua satisfação.

mover

1. Definir as preferências e os orçamentos dos clientes.
2. Oriente o plano inicial de acordo com essas preferências.
3. Iterar para otimizar os planos e maximizar a satisfação do cliente.

Código 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)

Código Descrição

1. Inicialização (__init__ método)::TravelAgent A classe é inicializada usando uma lista de possíveis destinos, cada um com atributos como nome, custo e tipo de atividade.
2. Programa de orientação (bootstrap_plan método)Método de planejamento de viagem: Esse método cria um plano de viagem inicial com base nas preferências e no orçamento do cliente. Ele percorre a lista de destinos e os adiciona ao plano se eles corresponderem às preferências do cliente e se ajustarem ao orçamento.
3. Preferências de correspondência (match_preferences método)Método de verificação: Esse método verifica se o destino corresponde às preferências do cliente.
4. Plano de iteração (iterate_plan método)Esse método otimiza o plano inicial tentando substituir cada destino do plano por uma correspondência melhor, levando em conta as preferências do cliente e as restrições orçamentárias.
5. Cálculo de custos (calculate_cost método)Custo total: Esse método calcula o custo total do programa atual, incluindo novos destinos potenciais.

Exemplo de uso

• plano inicialO agente de viagens cria um plano inicial com base nas preferências do cliente para passeios turísticos e um orçamento de US$ 2.000.
• Plano de otimizaçãoPrograma iterativo do agente de viagens, otimizado para as preferências e os orçamentos dos clientes.

Ao usar objetivos claros (por exemplo, maximizar a satisfação do cliente) para orientar o plano e iterar para otimizá-lo, o Travel Agent cria itinerários de viagem personalizados e otimizados para os clientes. Essa abordagem garante que os planos de viagem estejam alinhados com as preferências e os orçamentos dos clientes desde o início e sejam aprimorados a cada iteração.

Reordenação e pontuação com modelos de linguagem grandes (LLM)

Os modelos de linguagem ampla (LLMs) podem ser usados para reordenar e pontuar documentos recuperados ou respostas geradas, avaliando sua relevância e qualidade. Eles funcionam da seguinte forma:

Recuperado: A etapa de recuperação inicial obtém um conjunto de documentos ou respostas candidatas com base na consulta.

Reordenação: O LLM avalia esses candidatos e os reordena de acordo com sua relevância e qualidade. Essa etapa garante que as informações mais relevantes e de melhor qualidade sejam apresentadas primeiro.

Classificação: O LLM atribui pontuações a cada objeto candidato, refletindo sua relevância e qualidade. Isso ajuda a selecionar a melhor resposta ou documento para o usuário.

Ao utilizar o LLM para reordenação e pontuação, o sistema pode fornecer informações mais precisas e contextualmente relevantes, melhorando assim a experiência geral do usuário.

Veja um exemplo de como um agente de viagens pode usar um modelo de linguagem grande (LLM) para reordenar e classificar destinos com base nas preferências do usuário em Python:

Cenários - viagens baseadas em preferências

Os agentes de viagem querem recomendar os melhores destinos para seus clientes com base em suas preferências. O LLM ajudará a reordenar e classificar os destinos para garantir que as opções mais relevantes sejam apresentadas.

Passos:

1. Colete as preferências do usuário.
2. Recuperar uma lista de possíveis destinos de viagem.
3. Use o LLM para reordenar e classificar os destinos com base nas preferências do usuário.

Veja como atualizar o exemplo anterior para usar o serviço Azure OpenAI:

solicitação

1. Você precisa ter uma assinatura do Azure.
2. Crie um recurso do Azure OpenAI e obtenha sua chave de API.

Exemplo de código 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)

Explicação do código - Booker de preferências

1. inicialização::TravelAgent A classe é inicializada usando uma lista de possíveis destinos de viagem, cada um com atributos como nome e descrição.
2. Obter aconselhamento (get_recommendations (Métodos)Método de solicitação: esse método gera prompts para o serviço do Azure OpenAI com base nas preferências do usuário e envia uma solicitação HTTP POST para a API do Azure OpenAI para reordenar e pontuar destinos.
3. Gerar um prompt (generate_prompt (Métodos)Sinal: Esse método cria um prompt para o Azure OpenAI que inclui as preferências do usuário e uma lista de destinos. A sugestão direciona o modelo para reordenar e pontuar os destinos com base nas preferências fornecidas.
4. Chamadas de API::requests Biblioteca para fazer solicitações HTTP POST para pontos de extremidade da API do Azure OpenAI. A resposta contém os destinos reordenados e pontuados.
5. Exemplo de usoAgentes de viagem coletam as preferências do usuário (por exemplo, interesse em passeios turísticos e multiculturalismo) e usam o serviço Azure OpenAI para obter sugestões de reclassificação e classificação para destinos de viagem.

garantir que your_azure_openai_api_key Substitua-o por sua chave real da API do Azure OpenAI e substitua o https://your-endpoint.com/... Substitua pela URL real do endpoint de sua implantação do Azure OpenAI.

Ao aproveitar o LLM para reordenar e pontuar, os agentes de viagens podem oferecer aos seus clientes orientações de viagem mais personalizadas e relevantes, melhorando assim sua experiência geral.

{Críticos do domínio da tecnologia Sharp: o exemplo de código acima demonstra claramente como o conteúdo pode ser reordenado e pontuado usando um modelo de linguagem grande. Isso é feito por meio da construção de TravelAgent e combinada com os serviços do Azure OpenAI, pode efetivamente fornecer recomendações de viagem personalizadas com base nas preferências do usuário. Essa abordagem não apenas melhora a precisão das recomendações, mas também aprimora a experiência do usuário}.

RAG: Técnicas e ferramentas de solicitação

O Retrieval Augmented Generation (RAG) pode ser tanto uma técnica de solicitação quanto uma ferramenta no desenvolvimento de agentes de IA. Compreender a diferença entre as duas pode ajudá-lo a usar o RAG de forma mais eficaz em seus projetos.

RAG como uma técnica de estímulo

O que é isso?

• Como uma técnica de solicitação, o RAG envolve a formulação de consultas ou solicitações específicas para orientar a recuperação de informações relevantes de um grande corpus ou banco de dados. Essas informações são então usadas para gerar respostas ou ações.

Como funciona:

1. Dicas de desenvolvimentoCrie prompts ou consultas bem estruturados com base na tarefa em questão ou na entrada do usuário.
2. recuperarUse prompts para pesquisar dados relevantes em bases de conhecimento ou conjuntos de dados pré-existentes.
3. Geração de uma respostaCombinação de informações recuperadas com modelos de IA generativos para produzir uma resposta abrangente e coerente.

Exemplo de agente de viagens::

• Entrada do usuário, "I want to visit the museums in Paris" (Quero visitar os museus em Paris).
• Cue: "Encontre os principais museus de Paris".
• Informações recuperadas: informações detalhadas sobre o Museu do Louvre, o Museu d'Orsay e muito mais.
• Resposta gerada "Aqui estão alguns dos principais museus de Paris: o Museu do Louvre, o Musée d'Orsay e o Centre Pompidou."

RAG como ferramenta

O que é isso?

• Como ferramenta, o RAG é um sistema integrado que automatiza o processo de recuperação e geração, facilitando para os desenvolvedores a implementação de funcionalidades complexas de IA sem a necessidade de criar manualmente prompts para cada consulta.

Como funciona:

1. integrado (como em um circuito integrado)RAG: A incorporação do RAG na arquitetura de um agente de IA permite que ele automatize as tarefas de recuperação e geração.
2. automáticoA ferramenta gerencia todo o processo, desde o recebimento da entrada do usuário até a geração da resposta final, sem a necessidade de fornecer avisos explícitos para cada etapa.
3. eficiênciaMelhorar o desempenho do agente, simplificando o processo de recuperação e geração para obter respostas mais rápidas e precisas.

Exemplo de agente de viagens::

• Entrada do usuário, "I want to visit the museums in Paris" (Quero visitar os museus em Paris).
• Ferramenta RAG: recupera automaticamente informações sobre o museu e gera uma resposta.
• Resposta gerada "Aqui estão alguns dos principais museus de Paris: o Museu do Louvre, o Musée d'Orsay e o Centre Pompidou."

{Comentário do crítico de tecnologia: a distinção entre descrever o RAG como uma técnica de dicas e como uma ferramenta é importante. Como uma técnica de aviso, o RAG enfatiza a importância de formular consultas manualmente; como uma ferramenta, o RAG enfatiza a automação e a integração. Ambas as abordagens têm suas vantagens e podem ser escolhidas com flexibilidade de acordo com as necessidades específicas}.

comparações

Exemplo prático

Exemplo de técnicas de sugestão:

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)

Exemplo de ferramenta:

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)

VEREDITO: as diferenças entre as técnicas e as ferramentas de prompting são claramente demonstradas por meio da comparação de tabelas e exemplos de códigos específicos. A formulação manual de dicas oferece mais flexibilidade e controle, enquanto as ferramentas aumentam a eficiência por meio da automação. Isso permite que os desenvolvedores façam escolhas mais informadas com base nas necessidades e nos recursos do projeto.

Avaliação da relevância

A avaliação da relevância é um aspecto fundamental do desempenho do Agente de IA. Ela garante que as informações recuperadas e geradas pelo Agente sejam apropriadas, precisas e úteis para o usuário. Vamos explorar como avaliar a relevância no AI Agent, incluindo exemplos práticos e dicas.

Conceitos-chave para avaliar a relevância

1. consciência situacional::
   • O agente deve entender o contexto da consulta do usuário para recuperar e gerar informações relevantes.
   • Exemplo: se um usuário perguntar "os melhores restaurantes de Paris", o agente deverá levar em conta as preferências do usuário, como o tipo de cozinha e o orçamento.
2. precisão::
   • As informações fornecidas pelo Agente devem ser factualmente corretas e atualizadas.
   • Exemplo: Sugira restaurantes que estejam abertos no momento e tenham boas avaliações, em vez de opções desatualizadas ou fechadas.
3. intenção do usuário::
   • O agente deve inferir a intenção por trás da consulta do usuário para fornecer as informações mais relevantes.
   • Exemplo: se um usuário perguntar por "hotéis econômicos", o agente deverá priorizar as opções acessíveis.
4. loop de feedback::
   • A coleta e a análise contínuas do feedback do usuário ajudam o Agent a aprimorar seu processo de avaliação de relevância.
   • Exemplo: combinação de classificações de usuários e feedback sobre recomendações anteriores para melhorar as respostas futuras.

Dicas práticas para avaliar a relevância

1. pontuação de relevância::
   • A cada item de pesquisa é atribuída uma pontuação de relevância com base na correspondência com a consulta e as preferências do usuário.
   • Exemplo:

     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. Filtragem e classificação::
   • Filtre os itens irrelevantes e classifique os itens restantes com base em suas pontuações de relevância.
   • Exemplo:

     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. Processamento de linguagem natural (NLP)::
   • Use técnicas de PNL para entender as consultas dos usuários e recuperar informações relevantes.
   • Exemplo:

     def process_query(query):
     # 使用 NLP 从用户的查询中提取关键信息
     processed_query = nlp(query)
     return processed_query
     

4. Integração do feedback do usuário::
   • Colete o feedback dos usuários sobre as orientações fornecidas e use-o para ajustar futuras avaliações de relevância.
   • Exemplo:

     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
     

Exemplo: Avaliação da relevância em um agente de viagens

Veja abaixo um exemplo prático de como o Travel Agent avalia a relevância das recomendações de viagem:

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)

Pesquisa intencional

A pesquisa intencional envolve a compreensão e a interpretação da finalidade ou do objetivo subjacente à consulta de um usuário para recuperar e gerar as informações mais relevantes e úteis. Essa abordagem vai além da simples correspondência de palavras-chave e se concentra em compreender as necessidades e o contexto reais do usuário.

Conceitos-chave da busca intencional

1. Entendendo a intenção do usuário::
   • A intenção do usuário pode ser categorizada em três tipos principais: informativa, de navegação e transacional.
     • Intenção informativaUsuários que buscam informações sobre um determinado tópico (por exemplo, "Quais são os melhores museus de Paris?"). .
     • Intenção de navegaçãoSite oficial do Museu do Louvre: O usuário deseja navegar para um site ou uma página específica (por exemplo, "site oficial do Museu do Louvre").
     • Intenção transacionalO usuário deseja realizar uma transação, como reservar um voo ou fazer uma compra (por exemplo, "Book a flight to Paris").
2. consciência situacional::
   • Analisar o contexto da consulta de um usuário ajuda a identificar com precisão sua intenção. Isso inclui considerar as interações anteriores, as preferências do usuário e os detalhes específicos da consulta atual.
3. Processamento de linguagem natural (NLP)::
   • As técnicas de PNL são empregadas para entender e interpretar as consultas de linguagem natural fornecidas pelos usuários. Isso inclui tarefas como reconhecimento de entidades, análise de sentimentos e análise de consultas.
4. personalizado::
   • A personalização dos resultados de pesquisa com base no histórico, nas preferências e no feedback do usuário pode melhorar a relevância das informações recuperadas.

Exemplo prático: pesquisa intencional em agência de viagens

Vejamos o Travel Agent como um exemplo de como implementar a pesquisa intencional.

1. Coleta de preferências do usuário

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

2. Entendendo a intenção do usuário

   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. consciência situacional

   def analyze_context(query, user_history):
   # 将当前查询与用户历史记录相结合以理解情境
   context = {
   "current_query": query,
   "user_history": user_history
   }
   return context
   

4. Pesquisa e resultados personalizados

   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. Exemplo de uso

   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) Geração de código como uma ferramenta

As inteligências geradoras de código (agentes) usam modelos de IA para escrever e executar códigos, resolver problemas complexos e automatizar tarefas.

inteligência geradora de código

As inteligências geradoras de código escrevem e executam códigos usando modelos de IA generativos. Essas inteligências podem resolver problemas complexos, automatizar tarefas e fornecer insights valiosos gerando e executando códigos em uma variedade de linguagens de programação.

aplicação prática

1. Geração automatizada de códigoGeração de trechos de código para tarefas específicas, como análise de dados, rastreamento da Web ou aprendizado de máquina.
2. SQL como RAGUso de consultas SQL para recuperar e manipular dados de um banco de dados.
3. Solução de problemasCriação e execução de código para resolver um problema específico, como a otimização de um algoritmo ou a análise de dados.

Exemplo: inteligências geradoras de códigos para análise de dados

Suponha que você esteja projetando uma inteligência geradora de código. Veja como ela pode funcionar:

1. mandatosAnálise de conjuntos de dados para identificar tendências e padrões.
2. mover::
   • Carregue o conjunto de dados na ferramenta de análise de dados.
   • Gerar consultas SQL para filtrar e agregar dados.
   • Execute a consulta e recupere os resultados.
   • Use os resultados para gerar visualizações e percepções.
3. Requisitos de recursosAcesso a conjuntos de dados, ferramentas de análise de dados e funções SQL.
4. experiênciasUso de análises anteriores para melhorar a precisão e a relevância de análises futuras.

Exemplo: Inteligência de geração de códigos para agentes de viagens

Neste exemplo, projetaremos uma inteligência geradora de código, o Travel Agent, que auxilia os usuários no planejamento de uma viagem, gerando e executando códigos. A inteligência pode lidar com tarefas como buscar opções de viagem, filtrar resultados e compilar itinerários usando IA generativa.

Visão geral da inteligência de geração de código

1. Coleta de preferências do usuárioColeta de informações do usuário, como destino, datas de viagem, orçamento e interesses.
2. Gerar código para obter os dadosGerar trechos de código para recuperar dados sobre voos, hotéis e atrações.
3. Executar o código geradoExecute o código gerado para obter informações em tempo real.
4. Gerar uma viagemCompilar os dados adquiridos em um plano de viagem personalizado.
5. Ajustes com base no feedbackReceber feedback do usuário e regenerar o código quando necessário para otimizar os resultados.

passo a passo

1. Coleta de preferências do usuário

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

2. Gerar código para obter os dados

   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. Executar o código gerado

   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. Gerar uma viagem

   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. Ajustes com base no feedback

   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)
   

Uso da percepção e do raciocínio ambiental

De acordo com o esquema da tabela, o processo de geração de consultas pode, de fato, ser aprimorado com a exploração da consciência e do raciocínio do contexto.

Veja abaixo um exemplo de como isso pode ser feito:

1. Compreensão de padrõesO sistema entenderá o esquema da tabela e usará essas informações para determinar a base para a geração de consultas.
2. Ajustes com base no feedbackO sistema ajustará as preferências do usuário com base no feedback e no raciocínio sobre os campos do esquema que precisam ser atualizados.
3. Geração e execução de consultasO sistema gerará e executará consultas para obter dados atualizados de voos e hotéis com base em novas preferências.

Abaixo está um exemplo de código Python atualizado que incorpora esses conceitos:

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)

Descrição - Reserva baseada em feedback

1. reconhecimento de padrões::schema O dicionário define como as preferências devem ser ajustadas em resposta ao feedback. Ele inclui favorites responder cantando avoid etc., e os ajustes correspondentes.
2. Ajuste de preferências (adjust_based_on_feedback método)Esse método ajusta as preferências com base no feedback e nos padrões do usuário.
3. Ajustes baseados no meio ambiente (adjust_based_on_environment método)Esse método é ajustado de forma personalizada para o modo e o feedback.
4. Geração e execução de consultasO sistema gera código para obter dados atualizados de voos e hotéis com base nas preferências ajustadas e simula a execução dessas consultas.
5. Gerar uma viagemO sistema cria itinerários atualizados com base em novos dados de voos, hotéis e atrações.

Ao tornar o sistema consciente do contexto e raciocinar com base em padrões, ele pode gerar consultas mais precisas e relevantes, o que resulta em melhores recomendações de viagem e em uma experiência de usuário mais personalizada.

Uso do SQL como uma técnica de geração de aumento de recuperação (RAG)

A SQL (Structured Query Language, Linguagem de Consulta Estruturada) é uma ferramenta poderosa para interagir com bancos de dados. Quando usado como parte de uma abordagem RAG (Retrieval Augmented Generation, geração aumentada de recuperação), o SQL pode recuperar dados relevantes de um banco de dados para informar e gerar uma resposta ou ação em uma inteligência de IA. Vamos explorar como usar o SQL como uma técnica RAG no contexto de um agente de viagens.

Conceitos-chave

1. Interação com o banco de dados::
   • O SQL é usado para consultar bancos de dados, recuperar informações relevantes e manipular dados.
   • Exemplo: obter detalhes de voos, informações sobre hotéis e atrações em um banco de dados de viagens.
2. Integração com o RAG::
   • Gerar consultas SQL com base nas entradas e preferências do usuário.
   • Os dados recuperados são então usados para gerar recomendações ou ações personalizadas.
3. Geração de consultas dinâmicas::
   • As inteligências de IA geram consultas SQL dinâmicas com base no contexto e nos requisitos do usuário.
   • Exemplo: personalize uma consulta SQL para filtrar os resultados por orçamento, data e juros.

aparelho

• Geração automatizada de códigoGeração de trechos de código para tarefas específicas.
• SQL como RAGUso de consultas SQL para manipular dados.
• Solução de problemasCriar e executar código para resolver o problema.

exemplo típicoCorpo de inteligência de análise de dados:

1. mandatosAnálise de conjuntos de dados para procurar tendências.
2. mover::
   • Carregar o conjunto de dados.
   • Gerar consultas SQL para filtrar dados.
   • Execute a consulta e recupere os resultados.
   • Gerar visualizações e percepções.
3. recurso (como mão de obra ou turismo)Acesso ao conjunto de dados, funções SQL.
4. experiênciasUse os resultados anteriores para melhorar as análises futuras.

Exemplo prático: usando SQL no agente de viagens

1. Coleta de preferências do usuário

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

2. Geração de consultas 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. Execução de consultas 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. Geração de recomendações

   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)
   

Exemplo de consulta SQL

1. Informações sobre voos

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

2. Informações sobre o hotel

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

3. Informações sobre atrações

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

Ao aproveitar o SQL como parte da tecnologia Retrieval Augmented Generation (RAG), as inteligências de IA, como o Travel Agent, podem recuperar e aproveitar dinamicamente os dados relevantes para fornecer recomendações precisas e personalizadas.

Exemplos de metacognição

Para demonstrar a implementação da metacognição, vamos criar uma inteligência simples que resolve problemas quando éRefletindo sobre seu processo de tomada de decisão. Neste exemplo, construiremos um sistema no qual um corpo inteligente tenta otimizar a escolha de um hotel e, em seguida, avalia seu próprio raciocínio e ajusta sua estratégia quando erra ou faz uma escolha abaixo do ideal.

Simularemos isso usando um exemplo básico em que a inteligência escolhe um hotel com base em uma combinação de preço e qualidade, mas "reflete" sobre sua decisão e a ajusta de acordo.

Como isso explica a metacognição?

1. Tomada de decisão inicialIntelligentsia: a Intelligentsia escolherá o hotel mais barato, independentemente das implicações de qualidade.
2. Reflexão e avaliaçãoDepois de fazer uma escolha inicial, o corpo inteligente usará o feedback do usuário para verificar se o hotel é uma escolha "ruim". Se ele achar que a qualidade do hotel é muito baixa, ele refletirá sobre seu raciocínio.
3. alinhar a estratégiaA inteligência ajusta sua estratégia com base em suas reflexões, mudando de "mais barato" para "mais alta qualidade", melhorando assim seu processo de tomada de decisão em iterações futuras.

Os exemplos são mostrados abaixo:

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

capacidade cognitiva do metabolismo corporal inteligente (IBM)

A chave aqui é a capacidade das inteligências:

• Avaliar seus processos prévios de seleção e tomada de decisão.
• Adaptar suas estratégias com base nessa reflexão, ou seja, a aplicação prática da metacognição.

Essa é uma forma simples de metacognição na qual o sistema é capaz de adaptar seu processo de raciocínio em resposta ao feedback interno.

chegar a um veredicto

A metacognição é uma ferramenta poderosa que pode aprimorar significativamente os recursos das inteligências de IA. Ao incorporar processos metacognitivos, você pode projetar inteligências mais inteligentes, mais adaptáveis e mais eficientes. Use outros recursos para explorar ainda mais o fascinante mundo da metacognição nas inteligências de IA.