La memorizzazione nella cache è il processo di archiviazione e recupero dei dati più recenti o utilizzati di frequente dal modello in modo che non debbano essere ricalcolati continuamente. Gli incorporamenti di testo possono essere utilizzati per convertire i dati testuali in numeri e l'applicazione di tecniche di memorizzazione nella cache può migliorare l'efficienza del modello. LangChain consente agli sviluppatori di creare il modello di memorizzazione nella cache utilizzando la libreria CacheBackedEmbeddings.
Questo post dimostrerà il processo di lavoro con la memorizzazione nella cache in LangChain.
Come lavorare con la memorizzazione nella cache in LangChain?
La memorizzazione nella cache in LangChain sui modelli di incorporamento del testo può essere utilizzata attraverso diversi set di dati come l'utilizzo dell'archivio vettoriale, dei dati in memoria o dei dati dai file system. L'applicazione dei metodi della cache può ottenere l'output rapidamente e il modello può applicare ricerche di somiglianza sui dati in modo più efficace.
Per apprendere il processo di utilizzo della memorizzazione nella cache in LangChain, è sufficiente seguire i passaggi elencati:
Passaggio 1: installare i moduli
Innanzitutto, avvia il processo di utilizzo della memorizzazione nella cache installando i modelli richiesti, il primo qui è LangChain che contiene tutte le librerie richieste per il processo:
pip installare langchain
Il modulo FAISS è necessario per eseguire una ricerca di similarità per estrarre o generare output in base all'input fornito dall'utente:
pip installare faiss-gpu
L'ultimo modulo di questa guida che è necessario installare è OpenAI che può essere utilizzato per creare incorporamenti dei dati utilizzando il metodo OpenAIEmbeddings():
pip installare openai 
Dopo l'installazione di tutti i moduli, è sufficiente configurare l'ambiente utilizzando la chiave API dall'ambiente OpenAI utilizzando il pulsante ' Voi ' E ' getpass ”biblioteche:
importaciimporta getpass
os.ambiente [ 'OPENAI_API_KEY' ] = getpass.getpass ( 'Chiave API OpenAI:' )
Passaggio 2: importazione delle librerie
Una volta completata la configurazione, importa semplicemente le librerie per lavorare con le tecniche di caching in LangChain:
da langchain.embeddings importa CacheBackedEmbeddings
da langchain.storage importa LocalFileStore
da langchain.embeddings importa OpenAIEmbeddings
da langchain.document_loaders importa TextLoader
da langchain.embeddings.openai importa OpenAIEmbeddings
da langchain.text_splitter importa CharacterTextSplitter
da langchain.Vectorstores importa FAISS
Passaggio 3: creazione del modello di memorizzazione nella cache
Dopo aver importato le librerie, chiama semplicemente il metodo OpenAIEmbeddings() per costruire il modello e memorizzarlo nella variabile:
Ora applica la cache utilizzando il metodo LocalFileStore() e i metodi CacheBackedEmbeddings() con più argomenti:
fs = LocalFileStore ( './cache/' )cached_embedder = CacheBackedEmbeddings.from_bytes_store (
incorporamenti_sottostanti, fs, spazio dei nomi =incorporamenti_sottostanti.modello
)
Ottieni semplicemente l'elenco degli incorporamenti e per ora l'elenco è vuoto poiché gli incorporamenti non sono memorizzati nell'elenco:
elenco ( fs.yield_keys ( ) ) 
Passaggio 4: creazione dell'archivio vettoriale
Ottieni il file dal sistema locale utilizzando la libreria dei file e fai clic su ' Scegliere i file ' dopo aver eseguito il codice:
caricato = file.caricato ( )
Ora crea semplicemente un archivio vettoriale che può essere utilizzato per memorizzare gli incorporamenti utilizzando il metodo TextLoader() con il nome del documento. Successivamente, applica i metodi di suddivisione del testo con la dimensione dei blocchi e dividi i dati in blocchi più piccoli:
documenti_raw = Caricatore di testo ( 'stato_dell_unione.txt' ) .carico ( )text_splitter = CarattereTextSplitter ( dimensione_pezzo = 1000 , blocco_sovrapposizione = 0 )
documenti = text_splitter.split_documents ( documenti_grezzi )
Dopo aver diviso il testo, archiviare i dati nel file db variabile utilizzando la libreria FAISS per ottenere l'output utilizzando il metodo di ricerca per somiglianza:
db = FAISS.da_documenti ( documenti, cached_embedder ) 
Ora, ottieni nuovamente l'elenco degli incorporamenti dopo averli archiviati nel database e limita l'output a soli 5 indici:
elenco ( fs.yield_keys ( ) ) [ : 5 ] 
Passaggio 5: utilizzo della memorizzazione nella cache in memoria
La successiva memorizzazione nella cache può essere utilizzata tramite i metodi InMemoryStore() per definire la variabile del negozio:
Crea il modello di memorizzazione nella cache utilizzando i metodi OpenAIEmbeddings() e CacheBackedEmbeddings() con il modello, l'archivio e lo spazio dei nomi come parametri:
under_embeddings = OpenAIEmbeddings ( )embedder = CacheBackedEmbeddings.from_bytes_store (
incorporamenti_sottostanti, negozio, spazio dei nomi =incorporamenti_sottostanti.modello
)
Applicare gli incorporamenti al documento archiviato senza utilizzare gli incorporamenti della cache per ottenere dati dal documento:
incorporamenti = embedder.embed_documents ( [ 'Ciao' , 'arrivederci' ] )Ora applica la cache agli incorporamenti per recuperare rapidamente i dati dai documenti:
embeddings_from_cache = embedder.embed_documents ( [ 'Ciao' , 'arrivederci' ] )Memorizza gli incorporamenti della cache nella variabile embeddings in modo che la variabile embeddings contenga gli incorporamenti memorizzati nella cache:
incorporamenti == incorporamenti_da_cache 
Passaggio 6: utilizzo della memorizzazione nella cache del file system
L'ultimo metodo per applicare la memorizzazione nella cache negli incorporamenti dal documento test_cache utilizzando il File System Store:
Applica gli incorporamenti utilizzando il metodo CacheBackedEmbeddings() con il modello di incorporamento, l'archivio dati e lo spazio dei nomi come parametri:
embedder2 = CacheBackedEmbeddings.from_bytes_store (incorporamenti_sottostanti, fs, spazio dei nomi =incorporamenti_sottostanti.modello
)
Utilizza la variabile embeddings con i dati memorizzati nella cache al suo interno per chiamare il metodo embedder():
incorporamenti = embedder2.embed_documents ( [ 'Ciao' , 'arrivederci' ] )Ora ottieni gli incorporamenti per i due mondi menzionati sopra come parametri:
elenco ( fs.yield_keys ( ) ) 
Questo è tutto incentrato sul processo di creazione e utilizzo della memorizzazione nella cache in LangChain.
Conclusione
Per lavorare con le tecniche di memorizzazione nella cache per gli incorporamenti in LangChain, è sufficiente ottenere i moduli richiesti utilizzando il comando pip come FAISS, OpenAI, ecc. Successivamente, importare le librerie per creare e lavorare con la memorizzazione nella cache in LangChain. Ottiene in modo efficiente gli incorporamenti archiviati in diversi negozi. Gli sviluppatori possono utilizzare più archivi come database per archiviare incorporamenti come archivi vettoriali, file system o archivi in memoria. Questa guida ha dimostrato il processo di lavoro con la memorizzazione nella cache in LangChain.