A gyorsítótárazás a modell legfrissebb vagy leggyakrabban használt adatok tárolásának és lekérésének folyamata, így nem kell folyamatosan újraszámolni. Szövegbeágyazásokkal szöveges adatokat lehet számokká alakítani, a gyorsítótárazási technikák pedig javíthatják a modell hatékonyságát. A LangChain lehetővé teszi a fejlesztők számára, hogy a CacheBackedEmbeddings könyvtár segítségével készítsék el a gyorsítótárazási modellt.
Ez a bejegyzés bemutatja a LangChain gyorsítótárazási folyamatát.
Hogyan kell dolgozni a gyorsítótárral a LangChainben?
A LangChain gyorsítótárazása a szövegbeágyazási modelleken különböző adatkészleteken keresztül használható, például a vektortároló, a memórián belüli adatok vagy a fájlrendszerekből származó adatok használatával. A cache metódusok alkalmazásával gyorsan megkapható a kimenet, és a modell hatékonyabban alkalmazhat hasonlósági kereséseket az adatokon.
A LangChain gyorsítótárazási folyamatának megismeréséhez egyszerűen hajtsa végre a felsorolt lépéseket:
1. lépés: Modulok telepítése
Először indítsa el a gyorsítótárazási folyamatot a szükséges modellek telepítésével, az első itt a LangChain, amely tartalmazza a folyamathoz szükséges összes könyvtárat:
csipog telepítés langchain
A FAISS modul szükséges ahhoz, hogy hasonlósági keresést végezzen a kimenet kivonásához vagy generálásához a felhasználó által megadott bemenet alapján:
csipog telepítés faiss-gpu
Az útmutató utolsó modulja, amelyet telepíteni kell, az OpenAI, amely az adatok OpenAIEMbeddings() metódussal történő beágyazására használható:
csipog telepítés openai 
Az összes modul telepítése után egyszerűen állítsa be a környezetet az OpenAI környezet API-kulcsával a „ te ” és „ getpass ” könyvtárak:
importálni minketimport getpass
os.environ [ 'OPENAI_API_KEY' ] = getpass.getpass ( 'OpenAI API kulcs:' )
2. lépés: Könyvtárak importálása
A beállítás befejezése után egyszerűen importálja a könyvtárakat a LangChain gyorsítótárazási technikáinak használatához:
a langchain.embeddings-ből importálja a CacheBackedEmbeddings-t
a langchain.storage import LocalFileStore-ból
a langchain.embeddings-ből importálja az OpenAIEmbeddings-et
a langchain.document_loaders fájlból importálja a TextLoader-t
a langchain.embeddings.openai webhelyről importálja az OpenAIEMbeddings-et
innen: langchain.text_splitter import CharacterTextSplitter
a langchain.vectorstores webhelyről importálja a FAISS-t
3. lépés: Gyorsítótárazási modell létrehozása
A könyvtárak importálása után egyszerűen hívja meg az OpenAIEMbeddings() metódust a modell felépítéséhez, és tárolja azt a változóban:
Most alkalmazza a gyorsítótárat a LocalFileStore() metódussal és a CacheBackedEmbeddings() metódusokkal több argumentummal:
fs = LocalFileStore ( './cache/' )cached_embedder = CacheBackedEmbeddings.from_bytes_store (
underlying_embeddings, fs, névtér =underlying_beágyazások.modell
)
Egyszerűen szerezze be a beágyazások listáját, és a lista egyelőre üres, mivel a beágyazások nincsenek a listában tárolva:
lista ( fs.yield_keys ( ) ) 
4. lépés: A Vector Store létrehozása
Szerezze le a fájlt a helyi rendszerről a fájlkönyvtár segítségével, és kattintson a „ Válassza a Fájlok lehetőséget ” a kód végrehajtása után:
feltöltve = fájlok.feltöltés ( )
Most egyszerűen hozzon létre egy vektortárolót, amely a beágyazások tárolására használható a TextLoader() metódus segítségével a dokumentum nevével. Ezt követően alkalmazza a szövegosztó módszereket a darabok méretével, és ossza fel az adatokat kisebb darabokra:
raw_documents = TextLoader ( 'a_szakszervezet_állapota.txt' ) .Betöltés ( )text_splitter = KarakterTextSplitter ( chunk_size = 1000 , chunk_overlap = 0 )
dokumentumok = text_splitter.split_documents ( nyers_dokumentumok )
A szöveg felosztása után tárolja az adatokat a db változó a FAISS könyvtár használatával, hogy megkapja a kimenetet a hasonlóságkeresési módszerrel:
db = FAISS.from_documents ( dokumentumok, cached_embedder ) 
Most ismét szerezze be a beágyazások listáját, miután eltárolta őket az adatbázisban, és korlátozza a kimenetet csak 5 indexre:
lista ( fs.yield_keys ( ) ) [ : 5 ] 
5. lépés: A memórián belüli gyorsítótár használata
A következő gyorsítótárazás az InMemoryStore() metódusokon keresztül használható a tárolóváltozó meghatározásához:
Készítse el a gyorsítótárazási modellt OpenAIEMbeddings() és CacheBackedEmbeddings() metódusokkal, paramétereiként a modellt, tárolót és névteret:
underlying_embeddings = OpenAIEmbeddings ( )embedder = CacheBackedEmbeddings.from_bytes_store (
underlying_embeddings, store, névtér =underlying_beágyazások.modell
)
Alkalmazzon beágyazásokat a tárolt dokumentumon a gyorsítótár-beágyazások használata nélkül, hogy adatokat kapjon a dokumentumból:
embeddings = beágyazó.embed_documents ( [ 'Helló' , 'viszontlátásra' ] )Most alkalmazza a gyorsítótárat a beágyazásokhoz az adatok gyors lekéréséhez a dokumentumokból:
embeddings_from_cache = embedder.embed_documents ( [ 'Helló' , 'viszontlátásra' ] )Tárolja a gyorsítótár-beágyazásokat az embeddings változóban, hogy a beágyazási változó tárolja a gyorsítótárazott beágyazásokat:
beágyazások == beágyazások_gyorsítótárból 
6. lépés: A fájlrendszer gyorsítótár használata
Az utolsó módszer a gyorsítótárazás alkalmazására a test_cache dokumentum beágyazásaiban a Fájlrendszertár használatával:
Alkalmazza a beágyazásokat a CacheBackedEmbeddings() metódussal, paraméterként a beágyazási modellt, adattárat és névteret:
embedder2 = CacheBackedEmbeddings.from_bytes_store (underlying_embeddings, fs, névtér =underlying_beágyazások.modell
)
Az embedder() metódus meghívásához használja az embeddings változót a benne tárolt gyorsítótárazott adatokkal:
beágyazások = embedder2.embed_documents ( [ 'Helló' , 'viszontlátásra' ] )Most szerezze be a paraméterként említett fenti két világ beágyazásait:
lista ( fs.yield_keys ( ) ) 
Ez minden a LangChain gyorsítótár létrehozásának és használatának folyamatáról szól.
Következtetés
A LangChain beágyazási gyorsítótárazási technikáinak használatához egyszerűen szerezze be a szükséges modulokat a pip paranccsal, mint például a FAISS, OpenAI stb. Ezt követően importálja a könyvtárakat a LangChain gyorsítótárazásához és a gyorsítótárazáshoz. Hatékonyan kapja meg a különböző üzletekben tárolt beágyazásokat. A fejlesztők több tárolót is használhatnak adatbázisként a beágyazások, például vektortárolók, fájlrendszerek vagy memórián belüli tárolók tárolására. Ez az útmutató bemutatta a LangChain gyorsítótárazási folyamatát.