Comment implémenter la logique ReAct à l'aide d'un agent dans LangChain ?

Comment Implementer La Logique React A L Aide D Un Agent Dans Langchain



LangChain est le cadre permettant de créer des modèles de langage et des chatbots capables de comprendre et de générer du texte en langage humain. Les performances du modèle reposent sur la compréhension du langage et de ses complexités lors de la phase de formation du processus. La phase suivante consiste à générer les données ou le texte dans le langage naturel qui peut être facilement lisible et compréhensible. Ces phases sont appelées « Raisonnement ' et ' Agissant » respectivement dans le domaine du traitement du langage naturel.

Aperçu rapide

Cet article démontrera :

Comment implémenter la logique ReAct à l'aide d'un agent dans LangChain ?

Le ' Réagir ' est la combinaison des phases Raison et Action pour améliorer les performances du modèle de langage comme ' Concernant » fait référence à la raison et « Acte ' à l'action. Une logique ReAct est souvent considérée comme la plus optimisée pour créer des LLM ou des chatbots permettant de comprendre et de générer du texte. L'agent est le décideur qui décide quelles actions effectuer et dans quel ordre elles seront exécutées.







Pour découvrir le processus d'implémentation de la logique ReAct à l'aide d'un agent dans LangChain, parcourez simplement le guide suivant :



Étape 1 : Installation des frameworks

Tout d’abord, installez LangChain pour commencer le processus d’implémentation de la logique ReAct :



pip installer langchain





Installez le module google-search-results pour obtenir les dépendances permettant de créer l'agent capable d'obtenir les résultats de recherche de Google :

pip installer openai google-search-results



Après cela, installez les modules OpenAI qui peuvent être utilisés pour charger les grands modèles de langage ou LLM pour implémenter la logique ReAct :

pip installer openai

Après avoir obtenu tous les modules requis, configurez simplement le Environnement OpenAI pour la construction de LLM et Environnement SerpAPI pour utiliser l'agent dans le modèle :

importer toi

importer obtenir un laissez-passer

toi . environ [ 'OPENAI_API_KEY' ] = obtenir un laissez-passer . obtenir un laissez-passer ( « Clé API OpenAI : » )

toi . environ [ 'SERPAPI_API_KEY' ] = obtenir un laissez-passer . obtenir un laissez-passer ( « Clé API Serpapi : » )

Étape 2 : chargement du modèle de langage

L'étape suivante consiste à charger les modèles de langage en important les bibliothèques requises à l'aide du framework LangChain :

depuis chaîne de langue. agents importer charger_tools

depuis chaîne de langue. agents importer initialiser_agent

depuis chaîne de langue. agents importer Type d'agent

depuis chaîne de langue. llms importer OpenAI

Utilisez la méthode OpenAI() pour créer le modèle de langage (llm), puis configurez les outils pour les agents à l'aide de SerpAPI :

llm = OpenAI ( température = 0 )

outils = charger_tools ( [ 'serpapi' , 'llm-math' ] , llm = llm )

Méthode 1 : utilisation du langage d'expression LandChain

LCEL est le processus d'intégration ou de composition de chaînes ensemble lors de la construction des modèles de langage dans LangChain. Démarrez le processus en installant LangChainHub pour obtenir ses dépendances pour créer et utiliser la logique ReAct avec des agents dans LangChain :

pip installer langchainhub

Importer les bibliothèques de LangChain comme ReActSingleInputOutputParser pour construire le modèle pouvant utiliser le modèle ReAct :

depuis chaîne de langue. outils . rendre importer rendu_text_description

depuis chaîne de langue. agents . analyseurs_de sortie importer ReActSingleInputOutputParser

depuis chaîne de langue. agents . format_scratchpad importer format_log_to_str

depuis chaîne de langue importer moyeu

Chargez le modèle de langage pour concevoir la logique ReAct à l'aide de la méthode pull() et stockez-le dans la variable d'invite. Définissez quelques outils qui peuvent être utilisés pour implémenter la logique sur l'ensemble de données chargé afin d'implémenter son travail avec un agent :

rapide = moyeu. tirer ( 'hwchase17/réagir' )

rapide = rapide. partiel (

outils = rendu_text_description ( outils ) ,

noms_outils = ', ' . rejoindre ( [ t. nom pour t dans outils ] ) ,

)

Agent de construction

Maintenant, configurez l'agent et ses outils en l'intégrant au modèle de langage chargé à l'étape 2 de ce guide :

llm_with_stop = llm. lier ( arrêt = [ ' \n Observation' ] )

Définissez une variable d'agent pour fournir les arguments et les outils permettant de configurer l'agent et expliquant son fonctionnement. Les parties précédemment configurées comme la méthode llm_with_stop et ReActSingleInputOutputParser() sont en cours d'intégration à l'agent :

agent = {

'saisir' : lambda x: x [ 'saisir' ] ,

'agent_scratchpad' : lambda x : format_log_to_str ( X [ 'étapes_intermédiaires' ] )

} | invite | llm_with_stop | ReActSingleInputOutputParser ( )

Obtenez la bibliothèque AgentExecutor et configurez sa méthode à l'aide d'arguments tels que agent, tools et verbose pour obtenir une sortie plus lisible :

depuis chaîne de langue. agents importer AgentExécuteur

agent_exécuteur = AgentExécuteur ( agent = agent , outils = outils , verbeux = Vrai )

Invoquez la méthode agent_executor() avec la requête de chaîne comme entrée, ce qui déclenchera l'extraction de la sortie par l'agent :

agent_exécuteur. invoquer ( { 'saisir' : 'Qui est la petite amie de Leo DiCaprio' } )

Sortir

La capture d'écran suivante montre que l'agent a extrait les informations à l'aide de la logique ReAct et généré le texte en langage naturel :

Méthode 2 : utilisation de ZeroShotReactAgent

La logique ReAct peut également être implémentée en utilisant un autre agent comme ZeroShotReactAgent lors de la configuration de la variable agent_executor. Après cela, appelez simplement la variable agent_executor avec la question comme entrée pour appeler l'agent :

agent_exécuteur = initialiser_agent ( outils , llm , agent = Type d'agent. ZERO_SHOT_REACT_DESCRIPTION , verbeux = Vrai )

agent_exécuteur. invoquer ( { 'saisir' : 'Quel est l'âge de la petite amie de Leo DiCaprio élevé à la puissance 0,21' } )

Sortir

L'agent a extrait les informations en fonction de l'entrée demandée lors de l'appel de agent_executor :

Méthode 3 : utiliser des modèles de discussion

Un autre processus qui peut être utilisé pour implémenter la logique ReAct en utilisant les modèles de chat après avoir importé la bibliothèque ChatOpenAI :

depuis chaîne de langage. chat_models importer ChatOpenAI

Construisez le modèle de discussion en utilisant la méthode ChatOpenAI() avec la valeur de température égale à 0 qui peut contrôler le caractère aléatoire des résultats du modèle :

chat_model = ChatOpenAI ( température = 0 )

Chargez le modèle sur lequel l'utilisateur peut implémenter la logique ReAct pour le stocker dans la variable d'invite et configurer les outils à utiliser dans le processus :

rapide = moyeu. tirer ( 'hwchase17/réagir-json' )

rapide = rapide. partiel (

outils = rendu_text_description ( outils ) ,

noms_outils = ', ' . rejoindre ( [ t. nom pour t dans outils ] ) ,

)

Construire l'agent

Utilisez le modèle de chat pour stocker les observations ou les messages récents lorsque le modèle arrête de générer le texte :

chat_model_with_stop = chat_model. lier ( arrêt = [ ' \n Observation' ] )

Obtenez la bibliothèque ReActJsonSingleInputOutputParser pour implémenter la logique ReAct et produire les résultats au format JSON :

depuis chaîne de langage. agents . analyseurs_de sortie importer ReActJsonSingleInputOutputParser

Créez et configurez l'agent à l'aide de la variable et de la méthode chat_model pour produire des résultats en appelant l'agent :

agent = {

'saisir' : lambda x: x [ 'saisir' ] ,

'agent_scratchpad' : lambda x : format_log_to_str ( X [ 'étapes_intermédiaires' ] )

} | invite | chat_model_with_stop | ReActJsonSingleInputOutputParser ( )

Configurez agent_executor et exécutez-le pour obtenir les résultats basés sur la requête fournie dans la variable d'entrée :

agent_exécuteur = AgentExécuteur ( agent = agent , outils = outils , verbeux = Vrai )

agent_exécuteur. invoquer ( { 'saisir' : 'Quel est l'âge de la petite amie de Leo DiCaprio élevé à la puissance 0,21' } )

Sortir

L'agent a extrait le résultat comme indiqué dans la capture d'écran suivante :

Méthode 4 : utilisation de ChatZeroShotReactAgent

La modification de la valeur de l'agent peut également être utilisée pour implémenter la logique ReAct avec le framework LangChain :

agent = initialiser_agent ( outils , chat_model , agent = Type d'agent. CHAT_ZERO_SHOT_REACT_DESCRIPTION , verbeux = Vrai )

agent. courir ( 'Quel est l'âge de la petite amie de Leo DiCaprio élevé à la puissance 0,21' )

Sortir

La structure de sortie contient des informations détaillées sur le fonctionnement de l'agent à partir des jetons et du modèle utilisés pour extraire les informations :

Il s’agit du processus d’implémentation de la logique ReAct à l’aide d’un agent dans LangChain.

Conclusion

Pour implémenter la logique ReAct avec un agent à l'aide du framework LangChain, installez des modules comme google-search-results pour configurer l'agent. Après cela, configurez l'environnement à l'aide des informations d'identification OpenAI et SerpAPI de leurs comptes pour commencer à utiliser le modèle. La logique ReAct peut être implémentée à l'aide des modèles LCEL et de chat avec plusieurs agents proposés par le module LangChain. Ce guide a expliqué comment implémenter la logique ReAct à l'aide de l'agent dans LangChain.