Wie arbeite ich mit Caching in LangChain?

Wie Arbeite Ich Mit Caching In Langchain



Beim Caching werden die neuesten oder am häufigsten verwendeten Daten aus dem Modell gespeichert und abgerufen, sodass sie nicht ständig neu berechnet werden müssen. Texteinbettungen können verwendet werden, um Textdaten in Zahlen umzuwandeln, und die Anwendung von Caching-Techniken kann die Effizienz des Modells verbessern. Mit LangChain können Entwickler das Caching-Modell mithilfe der CacheBackedEmbeddings-Bibliothek erstellen.

In diesem Beitrag wird der Prozess der Arbeit mit Caching in LangChain demonstriert.







Wie arbeite ich mit Caching in LangChain?

Das Caching in LangChain für Texteinbettungsmodelle kann über verschiedene Datensätze verwendet werden, z. B. über den Vektorspeicher, In-Memory-Daten oder Daten aus den Dateisystemen. Durch die Anwendung der Cache-Methoden kann die Ausgabe schneller erfolgen und das Modell kann Ähnlichkeitssuchen auf die Daten effektiver anwenden.



Um den Prozess der Arbeit mit Caching in LangChain zu erlernen, führen Sie einfach die aufgeführten Schritte durch:



Schritt 1: Module installieren
Beginnen Sie zunächst mit der Arbeit mit dem Caching, indem Sie die erforderlichen Modelle installieren. Das erste hier ist LangChain, das alle für den Prozess erforderlichen Bibliotheken enthält:





Pip Installieren langchain

Das FAISS-Modul ist erforderlich, um eine Ähnlichkeitssuche zum Extrahieren oder Generieren von Ausgaben basierend auf den vom Benutzer bereitgestellten Eingaben durchzuführen:



Pip Installieren faiss-gpu

Das letzte Modul für dieses Handbuch, das installiert werden muss, ist OpenAI, mit dem mithilfe der OpenAIEmbeddings()-Methode Einbettungen der Daten erstellt werden können:

Pip Installieren openai

Nach der Installation aller Module richten Sie einfach die Umgebung mit dem API-Schlüssel aus der OpenAI-Umgebung ein, indem Sie „ Du ' Und ' getpass ”Bibliotheken:

Importieren Sie uns
getpass importieren

os.environ [ „OPENAI_API_KEY“ ] = getpass.getpass ( „OpenAI-API-Schlüssel:“ )

Schritt 2: Bibliotheken importieren
Sobald die Einrichtung abgeschlossen ist, importieren Sie einfach die Bibliotheken für die Arbeit mit Caching-Techniken in LangChain:

aus langchain.storage InMemoryStore importieren
aus langchain.embeddings CacheBackedEmbeddings importieren
aus langchain.storage LocalFileStore importieren
aus langchain.embeddings importieren Sie OpenAIEmbeddings
aus langchain.document_loaders TextLoader importieren
aus langchain.embeddings.openai OpenAIEmbeddings importieren
aus langchain.text_splitter importiere CharacterTextSplitter
von langchain.vectorstores FAISS importieren

Schritt 3: Caching-Modell erstellen
Rufen Sie nach dem Importieren der Bibliotheken einfach die Methode OpenAIEmbeddings() auf, um das Modell zu erstellen und es in der Variablen zu speichern:

zugrunde liegende_embeddings = OpenAIEmbeddings ( )

Wenden Sie nun den Cache mit der Methode LocalFileStore() und den Methoden CacheBackedEmbeddings() mit mehreren Argumenten an:

fs = LocalFileStore ( './Zwischenspeicher/' )

zwischengespeicherter_embedder = CacheBackedEmbeddings.from_bytes_store (
zugrundeliegende_Einbettungen, fs, Namensraum =underlying_embeddings.model
)

Rufen Sie einfach die Liste der Einbettungen ab. Die Liste ist vorerst leer, da die Einbettungen nicht in der Liste gespeichert sind:

Liste ( fs.yield_keys ( ) )

Schritt 4: Vector Store erstellen
Holen Sie sich die Datei mithilfe der Dateibibliothek vom lokalen System und klicken Sie auf „ Wähle Dateien ” nach der Ausführung des Codes:

aus google.colab-Importdateien
uploaded = files.upload ( )

Erstellen Sie nun einfach einen Vektorspeicher, der zum Speichern der Einbettungen verwendet werden kann, indem Sie die TextLoader()-Methode mit dem Namen des Dokuments verwenden. Wenden Sie anschließend die Textteilermethoden entsprechend der Größe der Blöcke an und teilen Sie die Daten in kleinere Blöcke auf:

raw_documents = TextLoader ( „state_of_the_union.txt“ ) .Belastung ( )
text_splitter = CharacterTextSplitter ( chunk_size = 1000 , chunk_overlap = 0 )
Dokumente = text_splitter.split_documents ( raw_documents )

Speichern Sie die Daten nach dem Teilen des Textes im db Variable mithilfe der FAISS-Bibliothek, um die Ausgabe mithilfe der Ähnlichkeitssuchmethode zu erhalten:

db = FAISS.from_documents ( Dokumente, zwischengespeicherter_embedder )

Rufen Sie nun erneut die Liste der Einbettungen ab, nachdem Sie sie in der Datenbank gespeichert haben, und beschränken Sie die Ausgabe auf nur 5 Indizes:

Liste ( fs.yield_keys ( ) ) [ : 5 ]

Schritt 5: In-Memory-Caching verwenden
Das nächste Caching kann über InMemoryStore()-Methoden verwendet werden, um die Speichervariable zu definieren:

store = InMemoryStore ( )

Erstellen Sie das Caching-Modell mit den Methoden OpenAIEmbeddings() und CacheBackedEmbeddings() mit dem Modell, dem Speicher und dem Namespace als Parameter:

zugrunde liegende_embeddings = OpenAIEmbeddings ( )
embedder = CacheBackedEmbeddings.from_bytes_store (
zugrunde liegende_embeddings, speichern, Namensraum =underlying_embeddings.model
)

Wenden Sie Einbettungen auf das gespeicherte Dokument an, ohne die Cache-Einbettungen zu verwenden, um Daten aus dem Dokument abzurufen:

Embeddings = Embedder.embed_documents ( [ 'Hallo' , 'Verabschiedung' ] )

Wenden Sie nun den Cache auf die Einbettungen an, um schnell Daten aus den Dokumenten abzurufen:

embeddings_from_cache = embedder.embed_documents ( [ 'Hallo' , 'Verabschiedung' ] )

Speichern Sie die Cache-Einbettungen in der Variable „embeddings“, sodass die Variable „embeddings“ die zwischengespeicherten Einbettungen speichert:

Embeddings == Embeddings_from_cache

Schritt 6: Dateisystem-Caching verwenden
Die letzte Methode zum Anwenden von Caching in den Einbettungen aus dem test_cache-Dokument mithilfe des Dateisystemspeichers:

fs = LocalFileStore ( './test_cache/' )

Wenden Sie Einbettungen mit der Methode CacheBackedEmbeddings() mit dem Einbettungsmodell, dem Datenspeicher und dem Namespace als Parameter an:

embedder2 = CacheBackedEmbeddings.from_bytes_store (
zugrundeliegende_Einbettungen, fs, Namensraum =underlying_embeddings.model
)

Verwenden Sie die Variable „embeddings“ mit den darin gespeicherten zwischengespeicherten Daten, um die Methode „embedder()“ aufzurufen:

Embeddings = Embedder2.embed_documents ( [ 'Hallo' , 'Verabschiedung' ] )

Holen Sie sich nun die Einbettungen für die beiden oben genannten Welten als Parameter:

Liste ( fs.yield_keys ( ) )

Dabei geht es um den Prozess des Erstellens und Arbeitens mit Caching in LangChain.

Abschluss

Um mit Caching-Techniken für Einbettungen in LangChain zu arbeiten, rufen Sie einfach die erforderlichen Module mit dem pip-Befehl ab, z. B. FAISS, OpenAI usw. Anschließend importieren Sie die Bibliotheken zum Erstellen und Arbeiten mit Caching in LangChain. Die Einbettungen werden effizient in verschiedenen Geschäften gespeichert. Die Entwickler können mehrere Stores als Datenbanken verwenden, um Einbettungen wie Vektorstores, Dateisysteme oder In-Memory-Stores zu speichern. Dieser Leitfaden demonstrierte den Prozess der Arbeit mit Caching in LangChain.