Aperçu rapide
Cet article affichera :
Comment ajouter un type de mémoire personnalisé dans LangChain
- Installation de frameworks
- Importation de bibliothèques
- Création d'une mémoire personnalisée
- Configuration du modèle d'invite
- Tester le modèle
Comment ajouter un type de mémoire personnalisé dans LangChain ?
L'ajout d'un type de mémoire personnalisé dans LangChain permet à l'utilisateur d'obtenir les meilleures performances en termes de mémoire. L'utilisateur peut configurer le type de mémoire selon ses besoins. Pour ajouter un type de mémoire personnalisé dans LangChain, suivez simplement les étapes suivantes :
Étape 1 : Installation des frameworks
Tout d’abord, installez le framework LangChain pour commencer le processus d’ajout d’un type de mémoire personnalisé :
pip installer langchainL’exécution de la commande ci-dessus dans Python Notebook installera les dépendances de LangChain comme indiqué dans l’extrait suivant :
Installez le module OpenAI pour obtenir ses bibliothèques pouvant être utilisées pour configurer les LLM :
pip installer openai 
Ce guide utilisera le framework spaCy pour concevoir le type de mémoire personnalisé dans LangChain et le code suivant est utilisé pour installer le module :
pip installer spacy 
Le modèle spaCy utilise la table de hachage pour stocker les informations sous forme d'observation comme les messages de discussion précédents. Le code suivant est utilisé pour télécharger le Large Language Model ou LLM à partir de la bibliothèque spaCy afin de créer un modèle NLP avancé :
! python -m spacy télécharger en_core_web_lg 
Importer ' toi ' et ' obtenir un laissez-passer 'Les bibliothèques permettent de saisir la clé API du compte OpenAI pour configurer son environnement :
importer toiimporter obtenir un laissez-passer
toi . environ [ 'OPENAI_API_KEY' ] = obtenir un laissez-passer . obtenir un laissez-passer ( « Clé API OpenAI : » )
Étape 2 : Importer des bibliothèques
L'étape suivante consiste à importer les bibliothèques requises pour personnaliser le type de mémoire en fonction du modèle de chat :
depuis chaîne de langage. schéma importer Mémoire de basedepuis chaîne de langage. Chaînes importer Chaîne de conversations
depuis pydantique importer Modèle de base
depuis chaîne de langage. llms importer OpenAI
depuis dactylographie importer Liste , Dicté , N'importe lequel
Importer le « SpaCy ' bibliothèque pour charger le ' fr_core_web_lg ' modèle et attribuez-le au modèle ' PNL ' variable car il s'agit du modèle de traitement du langage naturel :
importer espacePNL = spacieux. charger ( 'en_core_web_lg' )
Étape 3 : Création d'une mémoire personnalisée
Après cela, créez simplement la mémoire personnalisée à l’aide des arguments BaseMemory et BaseModel dans la classe Memory. Ensuite, configurez les entités (collectées/stockées à partir des données) qui peuvent être stockées dans la mémoire sous forme d'informations complètes ou sous forme d'unité unique. La mémoire est configurée pour contenir toutes les entités du document afin d'optimiser les performances de la mémoire et du modèle :
classe SpacyEntityMémoire ( Mémoire de base , Modèle de base ) :''' Classe mémoire pour stocker des informations sur les entités '''
entités : dicter = { }
clé_mémoire : str = 'entités'
déf clair ( soi ) :
soi . entités = { }
@ propriété
déf variables_mémoire ( soi ) - > Liste [ str ] :
''' Initialiser les variables fournies à la requête '''
retour [ soi . clé_mémoire ]
#définir les variables mémoire en utilisant les arguments
déf load_memory_variables ( soi , entrées : Dictée [ str , N'importe lequel ] ) - > Dicté [ str , str ] :
''' Appelez les variables pour la mémoire, c'est-à-dire la clé d'entité '''
doc = PNL ( contributions [ liste ( contributions. clés ( ) ) [ 0 ] ] )
#configurer les entités à stocker dans la mémoire pour une unité individuelle
entités = [
soi . entités [ str ( ent ) ] pour ent dans doc. ents si str ( ent ) dans soi . entités
]
retour { soi . clé_mémoire : ' \n ' . rejoindre ( entités ) }
#définissez le save_context() pour utiliser la mémoire
déf sauvegarder_contexte ( soi , entrées : Dictée [ str , N'importe lequel ] , sorties : Dictée [ str , str ] ) - > Aucun :
'''Stocker les observations de cette discussion dans la mémoire'''
texte = contributions [ liste ( contributions. clés ( ) ) [ 0 ] ]
doc = PNL ( texte )
pour ent dans doc. ents :
ent_str = str ( ent )
si ent_str dans soi . entités :
soi . entités [ ent_str ] + = F ' \n {texte}'
autre :
soi . entités [ ent_str ] = texte
Étape 4 : configuration du modèle d'invite
Après cela, configurez simplement le modèle d'invite qui explique la structure de l'entrée fournie par l'utilisateur/humain :
depuis chaîne de langage. instructions . rapide importer Modèle d'invitemodèle = '''Ce qui suit est une interaction entre une machine et un humain Elle dit qu'elle ne sait pas Si la machine ne connaît pas la réponse La machine (IA) fournit des détails à partir de son contexte et si elle ne comprend pas la réponse à une question qu'elle dit simplement désolé
Informations sur l'entité :
{entités}
Communication:
Humain : {entrée}
IA : '''
rapide = Modèle d'invite ( variables_d'entrée = [ 'entités' , 'saisir' ] , modèle = modèle )
Étape 5 : tester le modèle
Avant de tester le modèle, configurez simplement le LLM à l'aide de la méthode OpenAI() et configurez la fonction ConversationChain() avec des arguments :
llm = OpenAI ( température = 0 )conversation = Chaîne de conversations (
llm = llm , rapide = rapide , verbeux = Vrai , mémoire = SpacyEntityMémoire ( )
)
Donnez des informations au modèle en utilisant l'argument d'entrée tout en appelant la méthode prédiction() avec la variable de conversation :
conversation. prédire ( saisir = 'Harrison aime l'apprentissage automatique' )Sortir
Le modèle a absorbé les informations et les a stockées dans la mémoire et a également posé la question relative aux informations pour poursuivre la conversation :
L'utilisateur peut répondre à la question du modèle pour ajouter plus d'informations à la mémoire ou tester la mémoire en posant la question sur les informations :
conversation. prédire (saisir = 'Quel est le sujet préféré d'Harrison'
)
Le modèle donne le résultat basé sur les informations précédentes et l'affiche à l'écran comme le montre l'extrait suivant :
Il s’agit d’ajouter un type de mémoire personnalisé dans LangChain.
Conclusion
Pour ajouter un type de mémoire personnalisé dans LangChain, installez simplement les modules requis pour importer des bibliothèques afin de créer la mémoire personnalisée. Le spaCy est la bibliothèque importante utilisée dans ce guide pour ajouter une mémoire personnalisée à l'aide de son modèle NLP. Après cela, configurez la mémoire personnalisée et le modèle d'invite pour donner la structure de l'interface de discussion. Une fois la configuration effectuée, testez simplement la mémoire du modèle en demandant les informations liées aux données stockées.