La mise en cache est le processus de stockage et de récupération des données les plus récentes ou les plus fréquemment utilisées à partir du modèle afin qu'elles n'aient pas besoin d'être recalculées à tout moment. Les intégrations de texte peuvent être utilisées pour convertir des données textuelles en nombres et leur appliquer des techniques de mise en cache peut améliorer l'efficacité du modèle. LangChain permet aux développeurs de créer le modèle de mise en cache à l'aide de la bibliothèque CacheBackedEmbeddings.
Cet article démontrera le processus de travail avec la mise en cache dans LangChain.
Comment travailler avec la mise en cache dans LangChain ?
La mise en cache dans LangChain sur les modèles d'incorporation de texte peut être utilisée via différents ensembles de données, comme l'utilisation du magasin vectoriel, des données en mémoire ou des données des systèmes de fichiers. L'application des méthodes de cache peut obtenir le résultat rapidement et le modèle peut appliquer plus efficacement des recherches de similarité sur les données.
Pour apprendre le processus de travail avec la mise en cache dans LangChain, suivez simplement les étapes répertoriées :
Étape 1 : Installer les modules
Tout d'abord, démarrez le processus de travail avec la mise en cache en installant les modèles requis. Le premier ici est LangChain qui contient toutes les bibliothèques requises pour le processus :
pépin installer chaîne de langue
Le module FAISS est requis pour effectuer une recherche de similarité pour extraire ou générer une sortie basée sur l'entrée fournie par l'utilisateur :
pépin installer faiss-gpu
Le dernier module de ce guide dont l'installation est nécessaire est OpenAI qui peut être utilisé pour créer des intégrations de données à l'aide de la méthode OpenAIEmbeddings() :
pépin installer ouvert 
Après l'installation de tous les modules, configurez simplement l'environnement à l'aide de la clé API de l'environnement OpenAI à l'aide du « toi ' et ' obtenir un laissez-passer « bibliothèques :
importez-nousimporter getpass
os.environ [ 'OPENAI_API_KEY' ] = getpass.getpass ( « Clé API OpenAI : » )
Étape 2 : Importer des bibliothèques
Une fois la configuration terminée, importez simplement les bibliothèques pour travailler avec les techniques de mise en cache dans LangChain :
à partir de langchain.embeddings importer CacheBackedEmbeddings
à partir de langchain.storage importer LocalFileStore
à partir de langchain.embeddings importer OpenAIEmbeddings
à partir de langchain.document_loaders importer TextLoader
à partir de langchain.embeddings.openai importer OpenAIEmbeddings
à partir de langchain.text_splitter importer CharacterTextSplitter
à partir de langchain.vectorstores importer FAISS
Étape 3 : Création d'un modèle de mise en cache
Après avoir importé les bibliothèques, appelez simplement la méthode OpenAIEmbeddings() pour construire le modèle et stockez-le dans la variable :
Maintenant, appliquez le cache en utilisant la méthode LocalFileStore() et les méthodes CacheBackedEmbeddings() avec plusieurs arguments :
fs = LocalFileStore ( './cache/' )cached_embedder = CacheBackedEmbeddings.from_bytes_store (
sous-jacents_embeddings, fs, espace de noms =underlying_embeddings.model
)
Obtenez simplement la liste des intégrations et pour l'instant, la liste est vide car les intégrations ne sont pas stockées dans la liste :
liste ( fs.yield_keys ( ) ) 
Étape 4 : Création d'un magasin de vecteurs
Récupérez le fichier sur le système local en utilisant la bibliothèque de fichiers et cliquez sur le bouton « Choisir des fichiers » après avoir exécuté le code :
téléchargé = fichiers.upload ( )
Maintenant, créez simplement un magasin de vecteurs qui peut être utilisé pour stocker les intégrations à l'aide de la méthode TextLoader() avec le nom du document. Après cela, appliquez les méthodes de séparation de texte avec la taille des morceaux et divisez les données en morceaux plus petits :
raw_documents = Chargeur de texte ( 'état_of_the_union.txt' ) .charger ( )text_splitter = CaractèreTextSplitter ( taille_morceau = 1000 , chunk_overlap = 0 )
documents = text_splitter.split_documents ( raw_documents )
Après avoir divisé le texte, stockez les données dans le base de données variable en utilisant la bibliothèque FAISS pour obtenir le résultat en utilisant la méthode de recherche de similarité :
db = FAISS.from_documents ( documents, cached_embedder ) 
Maintenant, récupérez à nouveau la liste des intégrations après les avoir stockées dans la base de données et limitez la sortie à seulement 5 index :
liste ( fs.yield_keys ( ) ) [ : 5 ] 
Étape 5 : Utilisation de la mise en cache en mémoire
La mise en cache suivante peut être utilisée via les méthodes InMemoryStore() pour définir la variable store :
Créez le modèle de mise en cache à l'aide des méthodes OpenAIEmbeddings() et CacheBackedEmbeddings() avec le modèle, le magasin et l'espace de noms comme paramètres :
sous-jacent_embeddings = OpenAIEmbeddings ( )embedder = CacheBackedEmbeddings.from_bytes_store (
sous-jacents_embeddings, magasin, espace de noms =underlying_embeddings.model
)
Appliquez des intégrations sur le document stocké sans utiliser les intégrations de cache pour obtenir les données du document :
intégrations = embedder.embed_documents ( [ 'Bonjour' , 'au revoir' ] )Maintenant, appliquez le cache aux intégrations pour récupérer rapidement les données des documents :
embeddings_from_cache = embedder.embed_documents ( [ 'Bonjour' , 'au revoir' ] )Stockez les intégrations de cache dans la variable d'intégration afin que la variable d'intégration conserve les intégrations mises en cache :
intégrations == intégrations_from_cache 
Étape 6 : Utilisation de la mise en cache du système de fichiers
La dernière méthode pour appliquer la mise en cache dans les intégrations du document test_cache à l'aide du File System Store :
Appliquez des intégrations à l'aide de la méthode CacheBackedEmbeddings() avec le modèle d'intégration, le magasin de données et l'espace de noms comme paramètres :
embedder2 = CacheBackedEmbeddings.from_bytes_store (sous-jacents_embeddings, fs, espace de noms =underlying_embeddings.model
)
Utilisez la variable embeddings avec les données mises en cache qui y sont stockées pour appeler la méthode embedder() :
intégrations = embedder2.embed_documents ( [ 'Bonjour' , 'au revoir' ] )Obtenez maintenant les intégrations pour les deux mondes ci-dessus mentionnés comme paramètres :
liste ( fs.yield_keys ( ) ) 
Il s’agit du processus de création et d’utilisation de la mise en cache dans LangChain.
Conclusion
Pour travailler avec les techniques de mise en cache pour les intégrations dans LangChain, obtenez simplement les modules requis à l'aide de la commande pip comme FAISS, OpenAI, etc. Après cela, importez les bibliothèques pour créer et utiliser la mise en cache dans LangChain. Il stocke efficacement les intégrations dans différents magasins. Les développeurs peuvent utiliser plusieurs magasins comme bases de données pour stocker des intégrations telles que des magasins de vecteurs, des systèmes de fichiers ou des magasins en mémoire. Ce guide a démontré le processus de travail avec la mise en cache dans LangChain.