Caching er prosessen med å lagre og hente de nyeste eller mest brukte dataene fra modellen, slik at de ikke trenger å beregnes på nytt hele tiden. Tekstinnbygginger kan brukes til å konvertere tekstdata til tall, og bruk av caching-teknikker kan forbedre effektiviteten til modellen. LangChain gjør det mulig for utviklerne å bygge bufringsmodellen ved å bruke CacheBackedEmbeddings-biblioteket.
Dette innlegget vil demonstrere prosessen med å jobbe med caching i LangChain.
Hvordan jobbe med caching i LangChain?
Bufring i LangChain på tekstinnbyggingsmodeller kan brukes gjennom forskjellige datasett som å bruke vektorlageret, data i minnet eller data fra filsystemene. Bruk av cache-metodene kan få utdataene raskt og modellen kan bruke likhetssøk på dataene mer effektivt.
For å lære prosessen med å jobbe med caching i LangChain, gå ganske enkelt gjennom trinnene som er oppført:
Trinn 1: Installer moduler
Start først prosessen med å jobbe med caching ved å installere de nødvendige modellene, den første her er LangChain som inneholder alle nødvendige biblioteker for prosessen:
pip installere langkjede
FAISS-modulen er nødvendig for å utføre et likhetssøk for å trekke ut eller generere utdata basert på input fra brukeren:
pip installere faiss-gpu
Den siste modulen for denne veiledningen som kreves for å installere er OpenAI som kan brukes til å lage innbygginger av dataene ved hjelp av OpenAIEmbeddings()-metoden:
pip installere openai 
Etter installasjonen av alle modulene, sett opp miljøet ved å bruke API-nøkkelen fra OpenAI-miljøet ved å bruke ' du ' og ' få pass ' biblioteker:
importere ossimportere getpass
os.miljø [ 'OPENAI_API_KEY' ] = getpass.getpass ( 'OpenAI API Key:' )
Trinn 2: Importere biblioteker
Når oppsettet er fullført, importerer du bare bibliotekene for å jobbe med caching-teknikker i LangChain:
fra langchain.embeddings importer CacheBackedEmbeddings
fra langchain.storage importer LocalFileStore
fra langchain.embeddings importer OpenAIEmbeddings
fra langchain.document_loaders importer TextLoader
fra langchain.embeddings.openai importer OpenAIEmbeddings
fra langchain.text_splitter importer CharacterTextSplitter
fra langchain.vectorstores importerer FAISS
Trinn 3: Bygg hurtigbufringsmodell
Etter å ha importert bibliotekene, ring ganske enkelt OpenAIEmbeddings()-metoden for å bygge modellen og lagre den i variabelen:
Bruk nå cache ved å bruke LocalFileStore()-metoden og CacheBackedEmbeddings()-metodene med flere argumenter:
fs = LocalFileStore ( './cache/' )cached_embedder = CacheBackedEmbeddings.from_bytes_store (
underliggende_embeddings, fs, navneområde =underliggende_embeddings.model
)
Bare hent listen over innebygginger, og foreløpig er listen tom da innebyggingene ikke er lagret i listen:
liste ( fs.yield_keys ( ) ) 
Trinn 4: Opprette Vector Store
Få filen fra det lokale systemet ved å bruke filbiblioteket og klikk på ' Velg Filer ' etter å ha utført koden:
lastet opp = filer.opplasting ( )
Nå er det bare å lage et vektorlager som kan brukes til å lagre innebyggingene ved å bruke TextLoader()-metoden med navnet på dokumentet. Etter det, bruk tekstsplittermetodene med størrelsen på bitene og del dataene i mindre biter:
raw_documents = TextLoader ( 'state_of_the_union.txt' ) .laste ( )text_splitter = CharacterTextSplitter ( chunk_size = 1000 , chunk_overlapp = 0 )
dokumenter = tekst_splitter.split_dokumenter ( rå_dokumenter )
Etter å ha delt teksten lagrer du dataene i db variabel ved å bruke FAISS-biblioteket for å få utdata ved å bruke likhetssøkemetoden:
db = FAISS.fra_dokumenter ( dokumenter, cached_embedder ) 
Nå, få igjen listen over innebygginger etter å ha lagret dem i databasen og begrense utdataene til bare 5 indekser:
liste ( fs.yield_keys ( ) ) [ : 5 ] 
Trinn 5: Bruke caching i minnet
Den neste hurtigbufringen kan brukes gjennom InMemoryStore()-metoder for å definere lagringsvariabelen:
Bygg hurtigbufringsmodellen ved å bruke metodene OpenAIEmbeddings() og CacheBackedEmbeddings() med modellen, butikken og navneområdet som parametere:
underlying_embeddings = OpenAIEbeddings ( )embedder = CacheBackedEmbeddings.from_bytes_store (
underliggende_embeddings, store, navneområde =underliggende_embeddings.model
)
Bruk innebygginger på det lagrede dokumentet uten å bruke cache-innbyggingene for å hente data fra dokumentet:
embeddings = embedder.embed_documents ( [ 'Hallo' , 'ha det' ] )Bruk nå cache på innebyggingene for raskt å hente data fra dokumentene:
embeddings_from_cache = embedder.embed_documents ( [ 'Hallo' , 'ha det' ] )Lagre cache-innbyggingene til innebyggingsvariabelen slik at innebyggingsvariabelen har de hurtigbufrede innebyggingene lagret:
embeddings == embeddings_from_cache 
Trinn 6: Bruke filsystembufring
Den siste metoden for å bruke caching i innebyggingene fra test_cache-dokumentet ved å bruke filsystemlageret:
Bruk innebygginger ved å bruke CacheBackedEmbeddings()-metoden med innebyggingsmodellen, datalageret og navneområdet som parametere:
embedder2 = CacheBackedEmbeddings.from_bytes_store (underliggende_embeddings, fs, navneområde =underliggende_embeddings.model
)
Bruk embeddings-variabelen med de bufrede dataene lagret i den for å kalle embedder()-metoden:
embeddings = embedder2.embed_documents ( [ 'Hallo' , 'ha det' ] )Få nå innebyggingene for de to ovennevnte verdenene nevnt som parametrene:
liste ( fs.yield_keys ( ) ) 
Det handler om prosessen med å bygge og jobbe med caching i LangChain.
Konklusjon
For å jobbe med caching-teknikker for innebygging i LangChain, hent ganske enkelt de nødvendige modulene ved å bruke pip-kommandoen som FAISS, OpenAI, etc. Etter det importerer du bibliotekene for å bygge og jobbe med caching i LangChain. Den får embeddings effektivt lagret i forskjellige butikker. Utviklerne kan bruke flere butikker som databaser for å lagre innebygginger som vektorbutikker, filsystemer eller lagre i minnet. Denne veiledningen demonstrerte prosessen med å jobbe med caching i LangChain.