Caching er processen med at gemme og hente de seneste eller hyppigst anvendte data fra modellen, så det ikke skal genberegnes hele tiden. Tekstindlejringer kan bruges til at konvertere tekstdata til tal, og anvendelse af caching-teknikker kan forbedre modellens effektivitet. LangChain gør det muligt for udviklerne at bygge caching-modellen ved hjælp af CacheBackedEmbeddings-biblioteket.
Dette indlæg vil demonstrere processen med at arbejde med caching i LangChain.
Hvordan arbejder man med caching i LangChain?
Caching i LangChain på tekstindlejringsmodeller kan bruges gennem forskellige datasæt som ved hjælp af vektorlageret, data i hukommelsen eller data fra filsystemerne. Anvendelse af cache-metoderne kan få output hurtigt, og modellen kan anvende lighedssøgninger på dataene mere effektivt.
For at lære processen med at arbejde med caching i LangChain skal du blot gennemgå de anførte trin:
Trin 1: Installer moduler
Start først processen med at arbejde med caching ved at installere de nødvendige modeller, den første her er LangChain, som indeholder alle de nødvendige biblioteker til processen:
pip installere langkæde
FAISS-modulet er påkrævet for at udføre en lighedssøgning for at udtrække eller generere output baseret på input fra brugeren:
pip installere faiss-gpu
Det sidste modul til denne vejledning, der skal installeres, er OpenAI, som kan bruges til at oprette indlejringer af data ved hjælp af OpenAIEmbeddings()-metoden:
pip installere openai 
Efter installationen af alle modulerne skal du blot opsætte miljøet ved hjælp af API-nøglen fra OpenAI-miljøet ved hjælp af ' du ' og ' getpass ” biblioteker:
import osimportere getpass
os.miljø [ 'OPENAI_API_KEY' ] = getpass.getpass ( 'OpenAI API-nøgle:' )
Trin 2: Import af biblioteker
Når opsætningen er fuldført, skal du blot importere bibliotekerne til at arbejde med caching-teknikker i LangChain:
fra langchain.embeddings importer CacheBackedEmbeddings
fra langchain.storage importer LocalFileStore
fra langchain.embeddings importer OpenAIEmbeddings
fra langchain.document_loaders importerer TextLoader
fra langchain.embeddings.openai importer OpenAIEmbeddings
fra langchain.text_splitter importer CharacterTextSplitter
fra langchain.vectorstores importerer FAISS
Trin 3: Opbygning af cachemodel
Efter import af bibliotekerne skal du blot kalde OpenAIEmbeddings() metoden for at bygge modellen og gemme den i variablen:
Anvend nu cache ved hjælp af LocalFileStore()-metoden og CacheBackedEmbeddings()-metoderne med flere argumenter:
fs = LocalFileStore ( './cache/' )cached_embedder = CacheBackedEmbeddings.from_bytes_store (
underliggende_indlejringer, fs, navneområde =underliggende_indlejringer.model
)
Du skal blot hente listen over indlejringer, og indtil videre er listen tom, da indlejringerne ikke er gemt på listen:
liste ( fs.yield_keys ( ) ) 
Trin 4: Oprettelse af Vector Store
Hent filen fra det lokale system ved hjælp af filbiblioteket og klik på ' Vælg Filer ” efter at have udført koden:
uploadet = filer.upload ( )
Nu skal du blot oprette et vektorlager, der kan bruges til at gemme indlejringerne ved hjælp af TextLoader()-metoden med navnet på dokumentet. Anvend derefter tekstsplittermetoderne med størrelsen af bidderne og opdel dataene i mindre bidder:
raw_documents = TextLoader ( 'state_of_the_union.txt' ) .belastning ( )text_splitter = CharacterTextSplitter ( chunk_size = 1000 , chunk_overlap = 0 )
dokumenter = tekst_splitter.split_dokumenter ( rå_dokumenter )
Efter opdeling af teksten skal du gemme dataene i db variabel ved hjælp af FAISS-biblioteket for at få output ved hjælp af lighedssøgemetoden:
db = FAISS.fra_dokumenter ( dokumenter, cached_embedder ) 
Få nu igen listen over indlejringer efter at have gemt dem i databasen og begræns outputtet til kun 5 indekser:
liste ( fs.yield_keys ( ) ) [ : 5 ] 
Trin 5: Brug af In-Memory Caching
Den næste caching kan bruges gennem InMemoryStore() metoder til at definere lagervariablen:
Byg cachemodellen ved hjælp af OpenAIEmbeddings()- og CacheBackedEmbeddings()-metoderne med modellen, butikken og navneområdet som dens parametre:
underlying_embeddings = OpenAIE-indlejringer ( )embedder = CacheBackedEmbeddings.from_bytes_store (
underliggende_indlejringer, butik, navneområde =underliggende_indlejringer.model
)
Anvend indlejringer på det lagrede dokument uden at bruge cache-indlejringer til at hente data fra dokumentet:
embeddings = embedder.embed_documents ( [ 'Hej' , 'farvel' ] )Anvend nu cache til indlejringerne for hurtigt at hente data fra dokumenterne:
embeddings_from_cache = embedder.embed_documents ( [ 'Hej' , 'farvel' ] )Gem cache-indlejringer til indlejringsvariablen, så indlejringsvariablen har gemt cacheindlejringer:
indlejringer == indlejringer_fra_cache 
Trin 6: Brug af filsystemcaching
Den sidste metode til at anvende caching i indlejringerne fra test_cache-dokumentet ved hjælp af filsystemlageret:
Anvend indlejringer ved hjælp af metoden CacheBackedEmbeddings() med indlejringsmodellen, datalageret og navneområdet som parametrene:
embedder2 = CacheBackedEmbeddings.from_bytes_store (underliggende_indlejringer, fs, navneområde =underliggende_indlejringer.model
)
Brug embeddings-variablen med de cachelagrede data gemt i den til at kalde embedder()-metoden:
embeddings = embedder2.embed_documents ( [ 'Hej' , 'farvel' ] )Få nu indlejringerne for de to ovennævnte verdener nævnt som parametrene:
liste ( fs.yield_keys ( ) ) 
Det handler om processen med at bygge og arbejde med caching i LangChain.
Konklusion
For at arbejde med caching-teknikker til indlejring i LangChain skal du blot hente de nødvendige moduler ved hjælp af pip-kommandoen som FAISS, OpenAI osv. Importer derefter bibliotekerne til opbygning og arbejde med caching i LangChain. Det får effektivt embeddings opbevaret i forskellige butikker. Udviklerne kan bruge flere butikker som databaser til at gemme indlejringer som vektorlagre, filsystemer eller lagre i hukommelsen. Denne guide demonstrerede processen med at arbejde med caching i LangChain.