Cache é o processo de armazenar e buscar os dados mais recentes ou usados com frequência do modelo para que não precisem ser recalculados o tempo todo. A incorporação de texto pode ser usada para converter dados textuais em números e a aplicação de técnicas de cache a eles pode melhorar a eficiência do modelo. LangChain permite que os desenvolvedores construam o modelo de cache usando a biblioteca CacheBackedEmbeddings.
Este post irá demonstrar o processo de trabalho com cache no LangChain.
Como trabalhar com cache no LangChain?
O armazenamento em cache no LangChain em modelos de incorporação de texto pode ser usado por meio de diferentes conjuntos de dados, como o uso do armazenamento de vetores, dados na memória ou dados dos sistemas de arquivos. A aplicação dos métodos de cache pode obter a saída rapidamente e o modelo pode aplicar pesquisas de similaridade nos dados de forma mais eficaz.
Para aprender o processo de trabalho com cache no LangChain, basta seguir as etapas listadas:
Etapa 1: instalar módulos
Primeiro, inicie o processo de trabalho com cache instalando os modelos necessários. O primeiro aqui é LangChain que contém todas as bibliotecas necessárias para o processo:
pip instalar cadeia de idiomas
O módulo FAISS é necessário para realizar uma busca por similaridade para extrair ou gerar saída com base na entrada fornecida pelo usuário:
pip instalar faiss-gpu
O último módulo deste guia necessário para instalação é o OpenAI, que pode ser usado para criar embeddings dos dados usando o método OpenAIEmbeddings():
pip instalar aberto 
Após a instalação de todos os módulos, basta configurar o ambiente utilizando a chave API do ambiente OpenAI utilizando o “ os ' e ' Obter passagem ”bibliotecas:
importe-nosimportar getpass
os.environ [ 'OPENAI_API_KEY' ] = getpass.getpass ( 'Chave de API OpenAI:' )
Passo 2: Importando Bibliotecas
Assim que a configuração for concluída, basta importar as bibliotecas para trabalhar com técnicas de cache no LangChain:
de langchain.embeddings importar CacheBackedEmbeddings
de langchain.storage importar LocalFileStore
de langchain.embeddings importar OpenAIEmbeddings
de langchain.document_loaders importar TextLoader
de langchain.embeddings.openai importar OpenAIEmbeddings
de langchain.text_splitter importar CharacterTextSplitter
de langchain.vectorstores importar FAISS
Etapa 3: Construindo Modelo de Cache
Após importar as bibliotecas, basta chamar o método OpenAIEmbeddings() para construir o modelo e armazená-lo na variável:
Agora, aplique o cache usando o método LocalFileStore() e os métodos CacheBackedEmbeddings() com vários argumentos:
fs = LocalFileStore ( './cache/' )cached_embedder=CacheBackedEmbeddings.from_bytes_store (
subjacente_embeddings, fs, espaço para nome =underlying_embeddings.model
)
Basta obter a lista de embeddings e, por enquanto, a lista está vazia porque os embeddings não estão armazenados na lista:
lista ( fs.yield_keys ( ) ) 
Etapa 4: Criando armazenamento de vetores
Obtenha o arquivo do sistema local usando a biblioteca de arquivos e clique no botão “ Escolher os arquivos ”depois de executar o código:
carregado = arquivos.upload ( )
Agora, basta criar um armazenamento de vetores que possa ser usado para armazenar os embeddings usando o método TextLoader() com o nome do documento. Depois disso, aplique os métodos de divisão de texto com o tamanho dos pedaços e divida os dados em pedaços menores:
raw_documents=TextLoader ( 'estado_da_união.txt' ) .carregar ( )text_splitter = CharacterTextSplitter ( tamanho do pedaço = 1000 , pedaço_sobreposição = 0 )
documentos = text_splitter.split_documents ( documentos_brutos )
Após dividir o texto, armazene os dados no banco de dados variável usando a biblioteca FAISS para obter a saída usando o método de pesquisa por similaridade:
banco de dados = FAISS.from_documents ( documentos, cached_embedder ) 
Agora, obtenha novamente a lista de embeddings após armazená-los no banco de dados e limite a saída a apenas 5 índices:
lista ( fs.yield_keys ( ) ) [ : 5 ] 
Etapa 5: usando cache na memória
O próximo cache pode ser usado através dos métodos InMemoryStore() para definir a variável de armazenamento:
Construa o modelo de cache usando os métodos OpenAIEmbeddings() e CacheBackedEmbeddings() com o modelo, armazenamento e namespace como parâmetros:
subjacente_embeddings=OpenAIEmbeddings ( )incorporador = CacheBackedEmbeddings.from_bytes_store (
subjacente_embeddings, loja, espaço para nome =underlying_embeddings.model
)
Aplique embeddings no documento armazenado sem usar os embeddings de cache para obter dados do documento:
embeddings = embedder.embed_documents ( [ 'olá' , 'adeus' ] )Agora, aplique o cache aos embeddings para buscar rapidamente os dados dos documentos:
embeddings_from_cache = embedder.embed_documents ( [ 'olá' , 'adeus' ] )Armazene os embeddings de cache na variável embeddings para que a variável embeddings tenha os embeddings armazenados em cache:
embeddings == embeddings_from_cache 
Etapa 6: usando o cache do sistema de arquivos
O último método para aplicar cache nos embeddings do documento test_cache usando o armazenamento do sistema de arquivos:
Aplique embeddings usando o método CacheBackedEmbeddings() com o modelo de incorporação, armazenamento de dados e namespace como parâmetros:
embedder2=CacheBackedEmbeddings.from_bytes_store (subjacente_embeddings, fs, espaço para nome =underlying_embeddings.model
)
Use a variável embeddings com os dados armazenados em cache para chamar o método embedder():
embeddings = embedder2.embed_documents ( [ 'olá' , 'adeus' ] )Agora obtenha os embeddings para os dois mundos acima mencionados como parâmetros:
lista ( fs.yield_keys ( ) ) 
Isso é tudo sobre o processo de construção e trabalho com cache no LangChain.
Conclusão
Para trabalhar com técnicas de cache para embeddings no LangChain, basta obter os módulos necessários usando o comando pip como FAISS, OpenAI, etc. Depois disso, importe as bibliotecas para construir e trabalhar com cache no LangChain. Ele armazena com eficiência os embutimentos em diferentes lojas. Os desenvolvedores podem usar vários armazenamentos como bancos de dados para armazenar embeddings, como armazenamentos de vetores, sistemas de arquivos ou armazenamentos na memória. Este guia demonstrou o processo de trabalho com cache no LangChain.