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.user_preferences = {}
self.experience_data = []
def gather_preferences(self, preferences): self.user_preferences = {} self.experience_data = [].
self.user_preferences = preferências
def retrieve_information(self): self.user_preferences = preferences
# Pesquisar voos, hotéis e atrações com base nas preferências
voos = search_flights(self.user_preferences)
hotéis = search_hotels(self.user_preferences)
atrações = search_attractions(self.user_preferences)
retornar voos, hotéis, atrações
def generate_recommendations(self): voos, hotéis, atrações = search_attractions(self.user_preferences)
voos, hotéis, atrações = self.retrieve_information()
itinerário = create_itinerary(voos, hotéis, atrações)
return itinerary
def adjust_based_on_feedback(self, feedback).
self.experience_data.append(feedback)
# Analisar o feedback e ajustar as recomendações futuras
self.user_preferences = adjust_preferences(self.user_preferences, feedback)
# Exemplo de uso
travel_agent = Travel_Agent()
preferências = {



"interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerário = travel_agent.generate_recommendations()
print("Itinerário sugerido:", itinerário)
feedback = {"gostei": ["Museu do Louvre"], "não gostei": ["Torre Eiffel (muito lotada)"]}
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.user_preferences = {}
self.experience_data = []
def gather_preferences(self, preferences): self.user_preferences = {} self.experience_data = [].
self.user_preferences = preferências
def retrieve_information(self): flights = search_flights(self): flights = search_flights(self, preferences)
voos = search_flights(self.user_preferences)
voos = search_flights(self.user_preferences)
atrações = search_attractions(self.user_preferences)
retornar voos, hotéis, atrações
def generate_recommendations(self): voos, hotéis, atrações = search_attractions(self.user_preferences)
voos, hotéis, atrações = self.retrieve_information()
itinerário = create_itinerary(voos, hotéis, atrações)
return itinerary
def adjust_based_on_feedback(self, feedback).
self.experience_data.append(feedback)
self.user_preferences = adjust_preferences(self.user_preferences, feedback)
Exemplo de uso do # em uma solicitação de booing
travel_agent = Travel_Agent()
preferências = {


"budget": "moderate", "museums": ["museums"], ["dates": "2025-04-01 to 2025-04-10", "travel_agent" = Travel_Agent( preferences)
"interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerário = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"gostei": ["Museu do Louvre"], "não gostei": ["Torre Eiffel (muito lotada)"]}
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:

     preferências = {
     
     "dates": "2025-04-01 a 2025-04-10",
     
     "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)
     atrações = search_attractions(preferences)
     

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

     itinerário = create_itinerary(voos, hotéis, atrações)
     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 = {
     "gostei": ["Museu do Louvre"],
     "não gostei": ["Torre Eiffel (muito lotada)"]]
     }
     

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

       se "disliked" em feedback.
       preferências["evitar"] = feedback["não gostei"]
       

   • 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("Itinerário atualizado:", novo_itinerário)
       

   • 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"].
       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.user_preferences = {}
self.experience_data = []
def gather_preferences(self, preferences): self.user_preferences = {} self.experience_data = [].
self.user_preferences = preferências
def retrieve_information(self): flights = search_flights(self): flights = search_flights(self, preferences)
voos = search_flights(self.user_preferences)
voos = search_flights(self.user_preferences)
atrações = search_attractions(self.user_preferences)
retornar voos, hotéis, atrações
def generate_recommendations(self): voos, hotéis, atrações = search_attractions(self.user_preferences)
voos, hotéis, atrações = self.retrieve_information()
itinerário = create_itinerary(voos, hotéis, atrações)
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
Exemplo de uso do #
travel_agent = Travel_Agent()
preferências = {



"interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerário = travel_agent.generate_recommendations()
print("Itinerário sugerido:", itinerário)
feedback = {"gostei": ["Museu do Louvre"], "não gostei": ["Torre Eiffel (muito lotada)"]}
new_itinerary = travel_agent.adjust_based_on_feedback(feedback)
print("Itinerário atualizado:", 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:

classe TravelAgent.
def __init__(self).
# Pré-carregar destinos populares e suas informações
self.context = {
"Paris": {"país": "França", "moeda": "Euro", "idioma": "Francês", "atrações": ["Torre Eiffel", "Museu do Louvre"]}, "Tóquio": {"país", "Japão", "Museu do Louvre"]}, "travelAgent.class


"Sydney": {"country": "Australia", "currency": "Dollar", "language": "English", "attractions": ["Sydney Opera House", "Bondi Beach"]}
}
def get_destination_info(self, destination):
# Obtém informações de destino do contexto pré-carregado
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 "Desculpe, não temos informações sobre {destino}."
# Exemplo de uso
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

classe TravelAgent.
def __init__(self, destinations).
self.destinations = destinations
def bootstrap_plan(self, preferences, budget): self.plan = [].
plano = []
total_cost = 0
for destination in self.destinations: if total_cost + destination[].
if total_cost + destination['cost'] <= budget and self.match_preferences(destination, preferences): plan.append(destination, preferences).
plan.append(destination)
total_cost += destination['cost']: plan.append(destination)
return plan
def match_preferences(self, destination, preferences): for key, value in preferences.
for key, value in preferences.items(): if destination.get(key) !
se destination.get(key) ! = valor: if destination.get(key) !
return False
return False: return True
def iterate_plan(self, plan, preferences, budget): for i in range(len(plan)): for i in range(len(plan))
for i in range(len(plan)): for destination in self.
for destination in self.destinations: if destination not in plan and self.match_preferences.
if destination not in plan and self.match_preferences(destination, preferences) and self.calculate_cost(plan, destination) <= budget: plan[i] = destination.
plano[i] = destino
plano[i] = destino
return plan
def calculate_cost(self, plan, new_destination):: return sum(destination['cost']).
return sum(destination['cost'] for destination in plan) + new_destination['cost']
Exemplo de uso do #
destinos = [




]
preferências = {"activity": "sightseeing"}
orçamento = 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

importar solicitações
importar json
class TravelAgent.
def __init__(self, destinations).
self.destinations = destinations
def get_recommendations(self, preferences, api_key, endpoint):
# Gerar prompts para o Azure OpenAI
prompt = self.generate_prompt(preferences)
# Definir os cabeçalhos e carregar a solicitação
headers = {
'Content-Type': 'application/json', 'Authorisation': f'Bearer': f'Browser': f'Browser'.
'Authorization': f'Bearer {api_key}'
}
payload = {
"prompt": prompt, "max_tokens": max_tokens": max_tokens
"max_tokens": 150,
"temperature": 0,7
}
# Chame a API do Azure OpenAI para obter os destinos reordenados e pontuados
response = requests.post(endpoint, headers=headers, json=payload)
response_data = response.json()
# Extrair e retornar recomendações
recommendations = response_data['choices'][0]['text'].strip().split('\n')
retornar recomendações
def generate_prompt(self, preferences):
prompt = "Os seguintes destinos são classificados e avaliados de acordo com as seguintes preferências do usuário:\n"
for key, value in preferences.items(): prompt += f"{key}{value}".
prompt += f"{chave}: {valor}\n"
prompt += "\n destinos: \n"
for destination in self.destinations:
prompt += f"- {destination['name']}: {destination['description']}\n"
return prompt
Exemplo de uso do #
destinations = [
{"name": "Paris", "description": "A cidade da luz, conhecida por sua arte, moda e cultura."} ,
{"name": "Tokyo", "description": "Cidade vibrante conhecida por sua modernidade e templos tradicionais."} ,
{"name": "New York", "description": "A cidade que nunca dorme, com marcos icônicos e uma cultura diversificada."} ,
{"name": "Sydney", "description": "Linda cidade portuária conhecida por sua casa de ópera e praias deslumbrantes."} ,
]
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("Destinos recomendados:")
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 (gerar_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::solicitações 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 sua chave_azure_openai_api 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 = "Encontre os principais museus em Paris".
prompt = "Encontre os melhores museus em Paris"
search_results = search_web(prompt)
return search_results
museums = search_museums_in_paris()
print("Principais museus em Paris:", museums)

Exemplo de ferramenta:

class Travel_Agent.
def __init__(self).
self.rag_tool = RAGTool()
def get_museums_in_paris(self): user_input = "Quero visitar museus em Paris.".
user_input = "Quero visitar museus em Paris".
response = self.rag_tool.retrieve_and_generate(user_input)
response = self.rag_tool.retrieve_and_generate(user_input)
travel_agent = Travel_Agent()
museums = travel_agent.get_museums_in_paris()
print("Principais museus em 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
     
     pontuação += 1
     if item['price'] <= query['budget']: score += 1
     pontuação += 1
     if item['location'] == query['destination']: score += 1
     pontuação += 1
     if item['location'] == query['destination']: score += 1
     

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] # Retorna os 10 primeiros itens relevantes
     

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).
     O # usa NLP para extrair informações importantes da consulta de um usuário
     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['liked']: item['relevance'] += 1
     item['relevância'] -= 1
     retornar itens
     

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.user_preferences = {}
self.experience_data = []
def gather_preferences(self, preferences): self.user_preferences = {} self.experience_data = [].
self.user_preferences = preferências
def retrieve_information(self): flights = search_flights(self): flights = search_flights(self, preferences)
voos = search_flights(self.user_preferences)
voos = search_flights(self.user_preferences)
atrações = search_attractions(self.user_preferences)
retornar voos, hotéis, atrações
def generate_recommendations(self): voos, hotéis, atrações = search_attractions(self.user_preferences)
voos, hotéis, atrações = self.retrieve_information()
ranked_hotels = self.filter_and_rank(hotels, self.user_preferences)
itinerário = create_itinerary(flights, ranked_hotels, attractions)
return itinerary
def filter_and_rank(self, items, query): itinerary = create_itinerary(flights, ranked_hotels, attractions): return itinerary
ranked_items = sorted(items, key=lambda item: self.relevance_score(item, query), reverse=True)
return ranked_items[:10] # Retorna os 10 principais itens relevantes
def relevance_score(self, item, query):
score = 0
if item['category'] in query['interests']:
score += 1
if item['price'] <= query['budget']: score += 1
pontuação += 1
if item['location'] == query['destination']: score += 1
pontuação += 1
if item['location'] == query['destination']: score += 1
def adjust_based_on_feedback(self, feedback, items): for item in items.
def adjust_based_on_feedback(self, feedback, items): for item in items.
if item['name'] in feedback['liked']: item['relevance']: if item['name'] in feedback['liked'].
item['relevância'] += 1
if item['name'] in feedback['liked']: item['relevance'] += 1
item['relevância'] -= 1
retornar itens
Exemplo de uso do #
travel_agent = Travel_Agent()
preferências = {
"destino": "Paris",


"interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerário = travel_agent.generate_recommendations()
print("Itinerário sugerido:", itinerário)
feedback = {"gostei": ["Museu do Louvre"], "não gostei": ["Torre Eiffel (muito lotada)"]}
updated_items = travel_agent.adjust_based_on_feedback(feedback, itinerário['hotéis'])
print("Itinerário atualizado com 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 = {}
   self.user_preferences = {}
   def gather_preferences(self, preferences): self.
   self.user_preferences = preferences
   

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

   def identify_intent(query): if "book" in query or "purchase" in query.
   if "book" in query or "purchase" in query: return "transactional".
   return "transacional"
   elif "website" in query or "official" in query: return "navigational".
   return "navigational"
   else.
   return "informational" (informativo)
   

3. consciência situacional

   def analyze_context(query, user_history).
   # Combine a consulta atual com o histórico do usuário para entender o contexto
   context = {
   "current_query": consulta,
   "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)
   se intent == "informational".
   search_results = search_information(query, preferences)
   elif intent == "navigational": search_results = search_information(query, preferences)
   search_results = search_navigation(query)
   elif intent == "transactional": search_results = search_navigation(query)
   search_results = search_transaction(query, preferences)
   personalised_results = personalize_results(search_results, user_history)
   return personalised_results
   def search_information(query, preferences).
   # Exemplo de lógica de pesquisa para fins informativos
   results = search_web(f "melhores {preferências['interesses']} em {preferências['destino']}")
   return results
   def search_navigation(query).
   # Exemplo de lógica de pesquisa para intenções de navegação
   results = search_web(query)
   return results
   def search_transaction(query, preferences).
   # Exemplo de lógica de pesquisa para uma intenção transacional
   results = search_web(f "book {query} to {preferences['destination']}")
   return results
   def personalize_results(results, user_history):
   # Exemplo de lógica de personalização
   personalised = [result for result in results if result not in user_history]
   return personalized[:10] # Retorna os 10 primeiros resultados personalizados
   

5. Exemplo de uso

   travel_agent = Travel_Agent()
   preferências = {
   "destination": "Paris", "interests": ["museums", "cuisine"], "travel_agent
   "interests": ["museums", "cuisine"]
   }
   travel_agent.gather_preferences(preferences)
   user_history = ["Site do Museu do Louvre", "Reservar voo para Paris"]
   query = "melhores museus em Paris"
   results = search_with_intent(query, preferences, user_history)
   print("Resultados da pesquisa:", resultados)
   

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 = {}
   self.user_preferences = {}
   def gather_preferences(self, preferences): self.
   self.user_preferences = preferences
   

2. Gerar código para obter os dados

   def generate_code_to_fetch_data(preferences).
   # Exemplo: geração de um código para pesquisar voos com base nas preferências do usuário
   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):
   # Exemplo: gerar código para pesquisar hotéis
   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).
   # Executar o código gerado usando exec
   exec(código)
   result = locals()
   return result
   travel_agent = Travel_Agent()
   preferences = {
   
   "dates": "2025-04-01 a 2025-04-10", "budget": "moderate", "travel_agent = Travel_Agent()
   
   "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("Opções de voo:", voos)
   print("Opções de hotéis:", hotels)
   

4. Gerar uma viagem

   def generate_itinerary(voos, hotéis, atrações).
   itinerário = {
   "flights": voos, "hotels": hotéis, atrações
   "hotels": hotéis, "attractions": atrações
   "attractions": atrações
   }
   return itinerary
   atrações = search_attractions(preferences)
   itinerary = generate_itinerary(flights, hotels, attractions)
   itinerary = generate_itinerary(flights, hotels, attractions) print("Suggested Itinerary:", itinerary)
   

5. Ajustes com base no feedback

   def adjust_based_on_feedback(feedback, preferences).
   # Ajusta as preferências com base no feedback do usuário
   if "liked" in feedback.
   preferences["favorites"] = feedback["liked"]
   se "não gostei" no feedback: preferências["evitar"] = feedback["gostei"].
   preferences["avoid"] = feedback["disliked"]
   return preferences
   feedback = {"gostei": ["Museu do Louvre"], "não gostei": ["Torre Eiffel (muito lotada)"]}
   updated_preferences = adjust_based_on_feedback(feedback, preferences)
   # Gerar e executar novamente o código usando as preferências atualizadas
   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("Itinerário atualizado:", 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).
# Ajusta as preferências com base no feedback do usuário
if "liked" in feedback.
preferences["favorites"] = feedback["liked"]
se "não gostei" no feedback: preferências["evitar"] = feedback["gostei"].
preferences["avoid"] = feedback["disliked"]
# Raciocínio a partir do esquema para ajustar outras preferências relevantes
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):
# Lógica personalizada para ajustar as preferências com base no esquema e no feedback
if field in feedback["liked"]::
return schema[field]["positive_adjustment"]
elif field in feedback["disliked"]:: return schema[field]["positive_adjustment"].
return schema[field]["negative_adjustment"]
return schema[field]["default"]
def generate_code_to_fetch_data(preferences)::
# Gerar código para buscar dados de voo com base em preferências atualizadas
return f "fetch_flights(preferences={preferences})"
def generate_code_to_fetch_hotels(preferences).
# Gerar código para buscar dados de hotéis com base em preferências atualizadas
return f "fetch_hotels(preferences={preferences})""
def execute_code(code):
# Simular a execução do código e retornar os dados simulados
return {"data": f "Executed: {code}"}
def generate_itinerary(flights, hotels, attractions).
# Gerar um itinerário com base em voos, hotéis e atrações
return {"flights": voos, "hotels": hotéis, "attractions": atrações}
# Exemplo de esquema
schema = {

"avoid": {"positive_adjustment": "decrease", "negative_adjustment": "increase", "default": "neutral"}
}
# Exemplo de uso
preferências = {"favoritas": "turismo", "evitar": "lugares lotados"}
feedback = {"gostei": ["Museu do Louvre"], "não gostei": ["Torre Eiffel (muito lotada)"]}
updated_preferences = adjust_based_on_feedback(feedback, preferences, schema)
# Gerar novamente e executar o código usando as preferências atualizadas
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("Itinerário atualizado:", updated_itinerary)

Descrição - Reserva baseada em feedback

1. reconhecimento de padrões::esquema O dicionário define como as preferências devem ser ajustadas em resposta ao feedback. Ele inclui favoritos responder cantando evitar 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 = {}
   self.user_preferences = {}
   def gather_preferences(self, preferences): self.
   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}="{table}")
   conditions.append(f"{key}='{value}'")
   query += " AND ".join(conditions)
   retornar consulta
   

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)
   resultados = cursor.fetchall()
   conexão.close()
   retornar resultados
   

4. Geração de recomendações

   def generate_recommendations(preferences): flight_query = generate_sql_query("flights", 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)
   atrações = execute_sql_query(attraction_query)
   itinerário = {
   "flights": voos, "hotels": hotéis, itinerary = {
   "flights": voos, "hotels": hotéis, "attractions": attractions_query(hotel_query)
   "attractions": atrações
   }
   return itinerary
   travel_agent = Travel_Agent()
   preferências = {
   "destination": "Paris", "dates": "2025-04-01 to 2025-04-10", "travel_agent": travel_agent()
   
   
   "interests": ["museums", "cuisine"]
   }
   travel_agent.gather_preferences(preferences)
   itinerário = 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:

classe HotelRecommendationAgent.
def __init__(self).
self.previous_choices = [] # Armazena os hotéis selecionados anteriormente.
self.corrected_choices = [] # Armazena as escolhas corrigidas.
self.recommendation_strategies = ['cheapest', 'highest_quality'] # Estratégias disponíveis
def recommend_hotel(self, hotels, strategies).
"""
Recomenda um hotel com base na estratégia escolhida.
A estratégia pode ser 'cheapest' (mais barata) ou 'highest_quality' (mais alta qualidade).
"""
if strategy == 'cheapest': recommended = min(hotels, key): ""
recommended = min(hotels, key=lambda x: x['price'])
elif strategy == 'highest_quality': recommended = max(hotels, key=lambda x: x['price'])
recommended = max(hotels, key=lambda x: x['quality'])
else: recommended = None
recommended = None
self.previous_choices.append((strategy, recommended))
return recommended
def reflect_on_choice(self).
"""
Reflete sobre a última escolha feita e decide se a inteligência deve ajustar sua estratégia.
A inteligência considerará se a escolha anterior levou a um resultado pior.
"""
if not self.previous_choices:
return "Nenhuma escolha foi feita ainda."
last_choice_strategy, last_choice = self.previous_choices[-1]
# Suponha que tenhamos algum feedback do usuário que nos diga se a última escolha foi boa ou ruim
user_feedback = self.get_user_feedback(last_choice)
se user_feedback == "ruim".
# Se a escolha anterior foi insatisfatória, ajuste a estratégia
new_strategy = 'highest_quality' if last_choice_strategy == 'cheapest' else 'cheapest'
self.corrected_choices.append((new_strategy, last_choice))
return f "Rethinking Choices. Ajuste a estratégia para {new_strategy}."
else.
return "A escolha é boa. Nenhum ajuste é necessário."
def get_user_feedback(self, hotel).
"""
Simula o feedback do usuário com base nos atributos do hotel.
Para simplificar, suponha que, se o hotel for muito barato, o feedback será "ruim".
Se a qualidade do hotel for inferior a 7, o feedback será "ruim".
"""

return "ruim"
return "good" (bom)
# Simular uma lista de hotéis (preço e qualidade)
hotels = [
{'name': 'Budget Inn', 'price': 80, 'quality': 6},
{'name': 'Comfort Suites', 'price': 120, 'quality': 8},
{'name': 'Luxury Stay', 'price': 200, 'quality': 9}
]
# Criar um agente
agent = HotelRecommendationAgent()
# Etapa 1: O agente recomenda um hotel usando a estratégia "mais barata".
recommended_hotel = agent.recommend_hotel(hotels, 'cheapest')
print(f "Hotel recomendado (mais barato): {recommended_hotel['name']}")
# Etapa 2: O agente inteligente reflete sobre a escolha e ajusta a estratégia, se necessário
reflection_result = agent.reflect_on_choice()
print(reflection_result)
# Etapa 3: A inteligência recomenda novamente, desta vez usando a estratégia ajustada
adjusted_recommendation = agent.recommend_hotel(hotels, 'highest_quality')
print(f "Recomendação de hotel ajustada (qualidade mais alta): {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.