Cachning är processen att lagra och hämta den senaste eller mest använda data från modellen så att den inte behöver beräknas om hela tiden. Textinbäddningar kan användas för att konvertera textdata till siffror och att tillämpa cachingtekniker på det kan förbättra modellens effektivitet. LangChain gör det möjligt för utvecklarna att bygga cachningsmodellen med CacheBackedEmbeddings-biblioteket.
Det här inlägget kommer att demonstrera processen att arbeta med cachning i LangChain.
Hur man arbetar med cachelagring i LangChain?
Cachning i LangChain på textinbäddningsmodeller kan användas genom olika datauppsättningar som att använda vektorlagringen, data i minnet eller data från filsystemen. Att tillämpa cachemetoderna kan få utdata snabbt och modellen kan tillämpa likhetssökningar på data mer effektivt.
För att lära dig processen att arbeta med cachning i LangChain, gå helt enkelt igenom stegen i listan:
Steg 1: Installera moduler
Börja först processen att arbeta med cachning genom att installera de modeller som krävs, den första här är LangChain som innehåller alla nödvändiga bibliotek för processen:
pip Installera långkedja
FAISS-modulen krävs för att utföra en likhetssökning för att extrahera eller generera utdata baserat på indata från användaren:
pip Installera faiss-gpu
Den sista modulen för den här guiden som krävs för att installera är OpenAI som kan användas för att skapa inbäddningar av data med metoden OpenAIEmbeddings():
pip Installera openai 
Efter installationen av alla moduler, ställ bara in miljön med API-nyckeln från OpenAI-miljön med hjälp av ' du ' och ' getpass ” bibliotek:
importera ossimportera getpass
os.environ [ 'OPENAI_API_KEY' ] = getpass.getpass ( 'OpenAI API Key:' )
Steg 2: Importera bibliotek
När installationen är klar, importera helt enkelt biblioteken för att arbeta med cachingtekniker i LangChain:
från langchain.embeddings importera CacheBackedEmbeddings
från langchain.storage importera LocalFileStore
från langchain.embeddings importera OpenAIEmbeddings
från langchain.document_loaders importera TextLoader
från langchain.embeddings.openai importera OpenAIEmbeddings
från langchain.text_splitter importera CharacterTextSplitter
från langchain.vectorstores importera FAISS
Steg 3: Bygg cachingmodell
Efter att ha importerat biblioteken, anrop helt enkelt OpenAIEmbeddings()-metoden för att bygga modellen och lagra den i variabeln:
Applicera nu cache med metoden LocalFileStore() och CacheBackedEmbeddings()-metoderna med flera argument:
fs = LocalFileStore ( './cache/' )cached_embedder = CacheBackedEmbeddings.from_bytes_store (
underliggande_inbäddningar, fs, namnutrymme =underliggande_inbäddningar.modell
)
Hämta helt enkelt listan över inbäddningar och för närvarande är listan tom eftersom inbäddningarna inte lagras i listan:
lista ( fs.yield_keys ( ) ) 
Steg 4: Skapa Vector Store
Hämta filen från det lokala systemet med hjälp av filbiblioteket och klicka på ' Välj Filer ” efter att ha kört koden:
uppladdad = filer.uppladdning ( )
Skapa nu helt enkelt ett vektorlager som kan användas för att lagra inbäddningarna med metoden TextLoader() med namnet på dokumentet. Efter det, tillämpa textdelningsmetoderna med storleken på bitarna och dela upp data i mindre bitar:
raw_documents = TextLoader ( 'state_of_the_union.txt' ) .ladda ( )text_splitter = CharacterTextSplitter ( chunk_size = 1000 , chunk_overlap = 0 )
documents = text_splitter.split_documents ( råa_dokument )
Efter att ha delat upp texten, lagra data i db variabel med hjälp av FAISS-biblioteket för att få utdata med hjälp av likhetssökningsmetoden:
db = FAISS.from_documents ( dokument, cached_embedder ) 
Skaffa nu listan över inbäddningar igen efter att ha lagrat dem i databasen och begränsa utdata till endast 5 index:
lista ( fs.yield_keys ( ) ) [ : 5 ] 
Steg 5: Använda In-Memory Caching
Nästa cachning kan användas genom InMemoryStore()-metoder för att definiera lagringsvariabeln:
Bygg cachingmodellen med metoderna OpenAIEmbeddings() och CacheBackedEmbeddings() med modellen, arkivet och namnutrymmet som parametrar:
underlying_embeddings = ÖppnaAIE-inbäddningar ( )embedder = CacheBackedEmbeddings.from_bytes_store (
underliggande_inbäddningar, lagra, namnutrymme =underliggande_inbäddningar.modell
)
Tillämpa inbäddningar på det lagrade dokumentet utan att använda cache-inbäddningar för att hämta data från dokumentet:
inbäddningar = embedder.embed_documents ( [ 'Hallå' , 'adjö' ] )Applicera nu cache på inbäddningarna för att snabbt hämta data från dokumenten:
inbäddade_från_cache = inbäddade.inbäddade_dokument ( [ 'Hallå' , 'adjö' ] )Lagra cache-inbäddningarna till inbäddningsvariabeln så att inbäddningsvariabeln har cachelagrade inbäddningar:
inbäddningar == inbäddningar_från_cache 
Steg 6: Använda filsystemscachning
Den sista metoden för att tillämpa cachelagring i inbäddningarna från test_cache-dokumentet med hjälp av filsystemarkivet:
Tillämpa inbäddningar med metoden CacheBackedEmbeddings() med inbäddningsmodellen, datalagret och namnutrymmet som parametrar:
embedder2 = CacheBackedEmbeddings.from_bytes_store (underliggande_inbäddningar, fs, namnutrymme =underliggande_inbäddningar.modell
)
Använd inbäddningsvariabeln med cachad data lagrad i den för att anropa metoden embedder():
inbäddningar = embedder2.embed_documents ( [ 'Hallå' , 'adjö' ] )Få nu inbäddningarna för de två ovanstående världarna som nämns som parametrarna:
lista ( fs.yield_keys ( ) ) 
Det handlar om processen att bygga och arbeta med cachning i LangChain.
Slutsats
För att arbeta med cachningstekniker för inbäddningar i LangChain, skaffa helt enkelt de nödvändiga modulerna med hjälp av pip-kommandot som FAISS, OpenAI, etc. Efter det importerar du biblioteken för att bygga och arbeta med cachning i LangChain. Den lagrar effektivt inbäddningarna i olika butiker. Utvecklarna kan använda flera butiker som databaser för att lagra inbäddningar som vektorbutiker, filsystem eller in-memory-butiker. Den här guiden demonstrerade processen att arbeta med cachning i LangChain.