Caching is het proces waarbij de meest recente of vaak gebruikte gegevens uit het model worden opgeslagen en opgehaald, zodat deze niet steeds opnieuw hoeven te worden berekend. Tekstinsluitingen kunnen worden gebruikt om tekstuele gegevens in cijfers om te zetten en het toepassen van cachingtechnieken daarop kan de efficiëntie van het model verbeteren. Met LangChain kunnen de ontwikkelaars het cachingmodel bouwen met behulp van de CacheBackedEmbeddings-bibliotheek.
Dit bericht demonstreert het proces van het werken met caching in LangChain.
Hoe te werken met caching in LangChain?
Caching in LangChain op modellen voor het insluiten van tekst kan worden gebruikt via verschillende datasets, zoals het gebruik van de vectoropslag, in-memory-gegevens of gegevens uit de bestandssystemen. Door de cachemethoden toe te passen, kan de uitvoer snel worden verkregen en kan het model zoekopdrachten naar gelijkenissen effectiever op de gegevens toepassen.
Om het proces van het werken met caching in LangChain te leren, doorloopt u eenvoudigweg de vermelde stappen:
Stap 1: Modules installeren
Start eerst het proces van het werken met caching door de vereiste modellen te installeren. De eerste hier is LangChain, die alle vereiste bibliotheken voor het proces bevat:
Pip installeren langketen
De FAISS-module is vereist om een overeenkomstzoekopdracht uit te voeren voor het extraheren of genereren van uitvoer op basis van de invoer van de gebruiker:
Pip installeren faiss-gpu
De laatste module voor deze handleiding die moet worden geïnstalleerd, is OpenAI, die kan worden gebruikt om gegevens in te sluiten met behulp van de OpenAIEmbeddings()-methode:
Pip installeren openai 
Na de installatie van alle modules stelt u eenvoudig de omgeving in met behulp van de API-sleutel uit de OpenAI-omgeving met behulp van de “ Jij ' En ' Krijg een pas ” bibliotheken:
importeer onsgetpass importeren
os.omgeving [ 'OPENAI_API_KEY' ] = getpass.getpass ( 'OpenAI API-sleutel:' )
Stap 2: Bibliotheken importeren
Zodra de installatie is voltooid, importeert u eenvoudig de bibliotheken om met cachingtechnieken in LangChain te werken:
van langchain.embeddings importeer CacheBackedEmbeddings
van langchain.storage importeer LocalFileStore
van langchain.embeddings importeer OpenAIEmbeddings
van langchain.document_loaders importeer TextLoader
van langchain.embeddings.openai importeer OpenAIEmbeddings
van langchain.text_splitter importeer CharacterTextSplitter
van langchain.vectorstores importeer FAISS
Stap 3: Cachingmodel bouwen
Na het importeren van de bibliotheken kunt u eenvoudig de methode OpenAIEmbeddings() aanroepen om het model te bouwen en op te slaan in de variabele:
Pas nu cache toe met behulp van de LocalFileStore() -methode en de CacheBackedEmbeddings() -methoden met meerdere argumenten:
fs = LokaalBestandStore ( './cache/' )cached_embedder=CacheBackedEmbeddings.from_bytes_store (
onderliggende_embeddings, fs, naamruimte =onderliggende_embeddings.model
)
Haal eenvoudigweg de lijst met insluitingen op en voorlopig is de lijst leeg omdat de insluitingen niet in de lijst zijn opgeslagen:
lijst ( fs.yield_keys ( ) ) 
Stap 4: Vectorwinkel maken
Haal het bestand op van het lokale systeem met behulp van de bestandsbibliotheek en klik op de knop “ Kies documenten ”na het uitvoeren van de code:
geüpload = bestanden.upload ( )
Maak nu eenvoudig een vectorarchief dat kan worden gebruikt om de insluitingen op te slaan met behulp van de TextLoader() -methode met de naam van het document. Pas daarna de tekstsplittermethoden toe met de grootte van de brokken en splits de gegevens in kleinere brokken:
raw_documents=TekstLoader ( 'staat_van_de_union.txt' ) .laden ( )text_splitter = KarakterTextSplitter ( formaat van een blokje = 1000 , chunk_overlap = 0 )
documenten = tekst_splitter.split_documents ( onbewerkte_documenten )
Nadat u de tekst hebt gesplitst, slaat u de gegevens op in het db variabele met behulp van de FAISS-bibliotheek om de uitvoer te verkrijgen met behulp van de zoekmethode voor overeenkomsten:
db = FAISS.from_documents ( documenten, cached_embedder ) 
Haal nu opnieuw de lijst met insluitingen op nadat u ze in de database hebt opgeslagen en beperk de uitvoer tot slechts 5 indexen:
lijst ( fs.yield_keys ( ) ) [ : 5 ] 
Stap 5: Caching in het geheugen gebruiken
De volgende caching kan worden gebruikt via InMemoryStore()-methoden om de winkelvariabele te definiëren:
Bouw het cachingmodel met behulp van de methoden OpenAIEmbeddings() en CacheBackedEmbeddings() met het model, de winkel en de naamruimte als parameters:
onderliggende_embeddings = OpenAIEmbeddings ( )embedder = CacheBackedEmbeddings.from_bytes_store (
onderliggende_inbedding, opslaan, naamruimte =onderliggende_embeddings.model
)
Pas insluitingen toe op het opgeslagen document zonder de cache-insluitingen te gebruiken om gegevens uit het document te halen:
embeddings = embedder.embed_documents ( [ 'Hallo' , 'tot ziens' ] )Pas nu cache toe op de insluitingen om snel gegevens uit de documenten op te halen:
embeddings_from_cache = embedder.embed_documents ( [ 'Hallo' , 'tot ziens' ] )Sla de cache-insluitingen op in de embeddings-variabele, zodat de insluitingen in de cache-variabele de in de cache opgeslagen insluitingen bevat:
insluitingen == insluitingen_uit_cache 
Stap 6: Bestandssysteemcaching gebruiken
De laatste methode om caching toe te passen in de insluitingen van het test_cache-document met behulp van de File System Store:
Pas insluitingen toe met behulp van de methode CacheBackedEmbeddings() met het insluitingsmodel, het gegevensarchief en de naamruimte als parameters:
embedder2 = CacheBackedEmbeddings.from_bytes_store (onderliggende_embeddings, fs, naamruimte =onderliggende_embeddings.model
)
Gebruik de variabele embeddings met de daarin opgeslagen gegevens in de cache om de methode embedder() aan te roepen:
embeddings = embedder2.embed_documents ( [ 'Hallo' , 'tot ziens' ] )Haal nu de inbedding voor de bovengenoemde twee werelden op als parameters:
lijst ( fs.yield_keys ( ) ) 
Dat gaat allemaal over het proces van het bouwen en werken met caching in LangChain.
Conclusie
Om met cachingtechnieken voor inbedding in LangChain te werken, haalt u eenvoudigweg de vereiste modules op met behulp van de pip-opdracht zoals FAISS, OpenAI, enz. Importeert daarna de bibliotheken voor het bouwen en werken met caching in LangChain. Het haalt op efficiënte wijze de inbedding op die in verschillende winkels is opgeslagen. De ontwikkelaars kunnen meerdere winkels gebruiken als databases om insluitingen op te slaan, zoals vectorwinkels, bestandssystemen of in-memory-winkels. Deze handleiding demonstreerde het proces van het werken met caching in LangChain.