gpt all local

Usando LLMs em dados privados, todos localmente

Este projeto é um exercício de aprendizado sobre o uso de grandes modelos de idiomas (LLMS) para recuperar informações de dados privados, executando todas as peças (incluindo o modelo) localmente. O objetivo é executar um LLM no seu computador para fazer perguntas em um conjunto de arquivos também no seu computador. Os arquivos podem ser qualquer tipo de documento, como arquivos de PDF, Word ou Text.

Este método de combinação de LLMs e dados privados é conhecido como geração de recuperação upmentada por recuperação (RAG). Foi introduzido neste artigo.

Crédito onde o crédito é devido: baseei este projeto no privateGPT original (o que eles chamam de versão primordial ). Reimplei as peças para entender como elas funcionam. Veja mais na seção de fontes.

O que estamos tentando alcançar: dado um conjunto de arquivos em um computador (a), queremos um grande modelo de idioma (b) em execução nesse computador para responder às perguntas (c) nelas.

No entanto, não podemos alimentar os arquivos diretamente ao modelo. Os grandes modelos de idiomas (LLMs) têm uma janela de contexto que limita a quantidade de informações que podemos alimentar neles (sua memória de trabalho). Para superar essa limitação, dividimos os arquivos em peças menores, chamadas pedaços e alimentamos apenas os relevantes ao modelo (d).

Mas então, a pergunta se torna "como encontramos os pedaços relevantes?" . Usamos a pesquisa de similaridade (e) para corresponder à pergunta e aos pedaços. A pesquisa de similaridade, por sua vez, requer incorporações vetoriais (F), uma representação de palavras com vetores que codificam relacionamentos semânticos (tecnicamente, uma incorporação dense de vetor, para não confundi-lo com representações vetoriais esparsas, como saco de palavras e TF-IDF). Depois de termos os pedaços relevantes, combinamos -os com a pergunta para criar um prompt (g) que instrua o LLM a responder à pergunta.

Precisamos de uma última peça: armazenamento persistente. Criar incorporações para os pedaços leva tempo. Não queremos fazer isso toda vez que fazemos uma pergunta. Portanto, precisamos salvar as incorporações e o texto original (os pedaços) em um loja de vetores (ou banco de dados) (h). O Vector Store pode crescer grande porque armazena os pedaços de texto originais e suas incorporações de vetor. Usamos um índice vetorial (i) para encontrar pedaços relevantes com eficiência.

Agora temos todas as peças que precisamos.

Podemos dividir a implementação em duas partes: ingerir e recuperar dados.

1. Ingestão: O objetivo é dividir os arquivos locais em pedaços menores que se encaixam no tamanho de entrada LLM (janela de contexto). Também precisamos criar incorporações vetoriais para cada pedaço. As incorporações do vetor nos permitem encontrar os pedaços mais relevantes para ajudar a responder à pergunta. Como o Chunking e a incorporação levam tempo, queremos fazer isso apenas uma vez, por isso salvamos os resultados em um Vector Store (banco de dados).
2. Recuperação: Dada uma pergunta do usuário, usamos a pesquisa de similaridade para encontrar os pedaços mais relevantes (ou seja, as peças dos arquivos locais relacionados à pergunta). Depois de determinarmos os pedaços mais relevantes, podemos usar o LLM para responder à pergunta. Para fazer isso, combinamos a pergunta do usuário com os pedaços relevantes e um rápido instruindo o LLM a responder à pergunta.

Essas duas etapas são ilustradas no diagrama a seguir.

Como usar este projeto

Se você ainda não fez isso, prepare o meio ambiente. Se você já preparou o ambiente, ative -o com source venv/bin/activate .

Existem duas maneiras de usar este projeto:

1. Interface da linha de comando: use este para ver mais logs e entender o que está acontecendo (consulte o sinalizador --verbose abaixo).
2. App StreamLit: use este para uma experiência mais fácil de usar.

Interface da linha de comando

1. Copie os arquivos que você deseja usar na pasta data .
2. Execute python main.py ingest para ingerir os arquivos no Vector Store.
3. Execute python main.py retrieve para recuperar dados do Vector Store. Isso o levará a uma pergunta.

Use o sinalizador --verbose para obter mais detalhes sobre o que o programa está fazendo nos bastidores.

Para reinomizar os dados, exclua a pasta vector_store e execute python main.py ingest novamente.

App StreamLit

Execute streamlit run app.py Ele abrirá o aplicativo em uma janela do navegador.

Este comando pode falhar no primeiro que você o executa. Há uma falha em algum lugar de como o ambiente Python funciona em conjunto com o Pyenv. Se o streamlit mostrar uma mensagem "Não é possível importar o módulo", desative o ambiente Python com deactivate , ative -o novamente com source venv/bin/activate e executar streamlit run app.py

Projeto

Ingestão de dados

Se você ainda não fez isso, prepare o meio ambiente. Se você já preparou o ambiente, ative -o com source venv/bin/activate .

Comando: python main.py ingest [--verbose]

O objetivo deste estágio é tornar os dados pesquisáveis. No entanto, a pergunta do usuário e o conteúdo dos dados podem não corresponder exatamente. Portanto, não podemos usar um mecanismo de pesquisa simples. Precisamos realizar uma pesquisa de similaridade suportada por incorporações de vetor. A incorporação do vetor é a parte mais importante deste estágio.

A ingestão de dados tem as seguintes etapas:

1. Carregue o arquivo: um leitor de documentos que corresponde ao tipo de documento é usado para carregar o arquivo. Neste ponto, temos uma variedade de caracteres com o conteúdo do arquivo (um "documento" a partir de agora). Metadados, fotos, etc., são ignorados.
2. Divida o documento em pedaços: um divisor de documentos divide o documento em pedaços do tamanho especificado. Precisamos dividir o documento para ajustar o tamanho do contexto do modelo (e enviar menos tokens ao usar um modelo pago). O tamanho exato de cada pedaço depende do divisor de documentos. Por exemplo, um divisor de frases tenta se separar no nível da frase, tornando alguns pedaços menores que o tamanho especificado.
3. Crie incorporações de vetor para cada pedaço: um modelo de incorporação cria um vetor incorporando para cada pedaço. Esta é a etapa crucial que nos permite encontrar os pedaços mais relevantes para ajudar a responder à pergunta.
4. Salve as incorporações no banco de dados do vetor (armazenamento): persista todo o trabalho que fizemos acima, para que não precisemos repeti -lo no futuro.

Melhorias futuras:

• Parsing de documentos mais inteligente. Por exemplo, não misture legendas com o texto da seção; Não analise a seção de referência (alternativamente, substitua as referências em linha pelo texto de referência real).
• Melhorar o paralelismo. Idealmente, queremos executar todo o fluxo de trabalho (documento de carregamento, bloco, incorporação, persistência) em paralelo para cada arquivo. Isso requer uma solução que paralelize não apenas as tarefas ligadas a E/S, mas também ligadas à CPU. O Vector Store também deve suportar vários escritores.
• Experimente diferentes estratégias de chunking, por exemplo, verifique se os divisores de frases ( NLTKTextSplitter ou SpacyTextSplitter ) melhoram as respostas.
• Escolha o tamanho de chunking com base no tamanho da entrada LLM (contexto). Atualmente, é codificado em um pequeno número, o que pode afetar a qualidade dos resultados. Por outro lado, economiza custos na API LLM. Precisamos encontrar um equilíbrio.
• Automatize o processo de ingestão: detecte se houver arquivos novos ou alterados e ingeri -los.

Recuperar dados

Se você ainda não fez isso, prepare o meio ambiente. Se você já preparou o ambiente, ative -o com source venv/bin/activate .

Comando: python main.py retrieve [--verbose]

O objetivo deste estágio é recuperar informações dos dados locais. Fazemos isso buscando os pedaços mais relevantes da loja de vetores e combinando -os com a pergunta do usuário e um prompt. O prompt instrui o Modelo de Idioma (LLM) a responder à pergunta.

A recuperação de dados tem as seguintes etapas:

1. Encontre os pedaços mais relevantes: a loja de vetores é consultada para encontrar os pedaços mais relevantes para a questão.
2. Combine os pedaços com a pergunta e um rápido: os pedaços são combinados com a pergunta e um aviso. O prompt instrui o LLM a responder à pergunta.
3. Envie o texto combinado para o LLM: o texto combinado é enviado ao LLM para obter a resposta.

Melhorias futuras:

• Adicione os retornos de chamada do Langchain para visualizar as etapas do processo de recuperação.
• Melhore o aviso para responder apenas com o que está nos documentos locais, por exemplo, "Use apenas informações dos seguintes documentos: ...". Sem esta etapa, o modelo parece sonhar com uma resposta dos dados de treinamento, que nem sempre é relevante.
• Adicione a moderação para filtrar respostas ofensivas.
• Melhore as respostas com reranger: "Experimente nossos resultados de pesquisa e, em seguida, certificadamente reernqueia com base em um modificador ou conjunto de modificadores". .
• Experimente diferentes tipos de cadeia (relacionados ao ponto anterior).

Melhorando os resultados

Tivemos que fazer alguns compromissos para fazê -lo em uma máquina local em um período de tempo razoável.

• Usamos um modelo pequeno. Este é difícil de mudar. O modelo deve ser executado em uma CPU e se encaixar na memória.
• Usamos um pequeno tamanho de incorporação. Podemos aumentar o tamanho da incorporação se esperarmos mais pelo processo de ingestão.
• Mantenha tudo da mesma forma e tente diferentes correntes.

Fontes

A maior parte do código de ingestão/recuperação é baseada no PrivateGPT original, o que eles chamam de agora primordial .

O que é diferente:

• App de streamlit para a interface do usuário.
• Use incorporação mais recente e versões de modelos de linguagem grande.
• Modernizou o código Python. Por exemplo, ele usa pathlib em vez de os.path e possui log adequado em vez de instruções impressas.
• Adicionado mais log para entender o que está acontecendo. Use o sinalizador --verbose para ver os detalhes.
• Adicionado um programa principal para executar as etapas de ingestão/recuperar.
• Preenchido requirements.txt com as dependências indiretas, por exemplo, para Huggingface Transformers e Langchain Document Loaders.

Consulte este arquivo para obter mais notas coletadas durante o desenvolvimento deste projeto.

Preparando o meio ambiente

Este é um passo único. Se você já fez isso, basta ativar o ambiente virtual com source venv/bin/activate .

Ambiente Python

Execute os seguintes comandos para criar um ambiente virtual e instalar os pacotes necessários.

python3 -m venv venv
source venv/bin/activate
pip install --upgrade pip
pip install -r requirements.txt

PDF Parsing

O analisador PDF em unstructured é uma camada na parte superior dos pacotes reais do analisador. Siga as instruções no ReadMe unstructured , sob as balas "Instale as seguintes dependências do sistema". Os pacotes Poppler e Tesseract são necessários (ignore os outros).

Modelo

Sugiro começar com um modelo pequeno que seja executado na CPU. O GPT4all tem uma lista de modelos aqui. Testei com Mistral-7b-Openorca Q4. Requer 8 GB de RAM para executar. Observe que alguns dos modelos têm licenças restritivas. Verifique a licença antes de usá -los em projetos comerciais.

1. Crie uma pasta denominada models .
2. Clique aqui para baixar o Mistral 7B Openorca (download de 3,8 GB, 8 GB de RAM).
3. Copie o modelo para a pasta models .