gpt all local

Uso de LLM en datos privados, todos localmente

Este proyecto es un ejercicio de aprendizaje sobre el uso de modelos de idiomas grandes (LLM) para recuperar información de datos privados, ejecutando todas las piezas (incluido el modelo) localmente. El objetivo es ejecutar un LLM en su computadora para hacer preguntas en un conjunto de archivos también en su computadora. Los archivos pueden ser cualquier tipo de documento, como PDF, Word o archivos de texto.

Este método de combinación de LLM y datos privados se conoce como generación de recuperación acuática (RAG). Fue introducido en este documento.

Crédito donde se debe el crédito: basé este proyecto en el PRIVEDGPT original (lo que ahora llaman la versión primordial ). Reimplementé las piezas para comprender cómo funcionan. Ver más en la sección de fuentes.

Lo que estamos tratando de lograr: dado un conjunto de archivos en una computadora (a), queremos un modelo de idioma grande (b) que se ejecuta en esa computadora para responder preguntas (c) sobre ellas.

Sin embargo, no podemos alimentar los archivos directamente al modelo. Los modelos de lenguaje grande (LLM) tienen una ventana de contexto que limita cuánta información podemos alimentarlos (su memoria de trabajo). Para superar esa limitación, dividimos los archivos en piezas más pequeñas, llamados trozos y alimentamos solo los relevantes para el modelo (D).

Pero entonces, la pregunta es "¿Cómo encontramos los trozos relevantes?" . Utilizamos la búsqueda de similitud (e) para que coincida con la pregunta y los fragmentos. La búsqueda de similitud, a su vez, requiere incrustaciones de vectores (F), una representación de palabras con vectores que codifican relaciones semánticas (técnicamente, una incrustación de vectores denso , no para confundirlo con representaciones vectoriales dispersas como la bolsa de palabras y TF-IDF). Una vez que tenemos los fragmentos relevantes, los combinamos con la pregunta para crear un aviso (g) que le indique a la LLM a responder la pregunta.

Necesitamos una última pieza: almacenamiento persistente. Crear incrustaciones para los trozos lleva tiempo. No queremos hacer eso cada vez que hacemos una pregunta. Por lo tanto, necesitamos guardar los incrustaciones y el texto original (los fragmentos) en una tienda vectorial (o base de datos) (H). La tienda vectorial puede crecer a lo grande porque almacena los trozos de texto originales y sus incrustaciones vectoriales. Utilizamos un índice vectorial (i) para encontrar fragmentos relevantes de manera eficiente.

Ahora tenemos todas las piezas que necesitamos.

Podemos dividir la implementación en dos partes: ingerir y recuperar datos.

1. Ingestión: el objetivo es dividir los archivos locales en trozos más pequeños que se ajustan al tamaño de entrada LLM (ventana de contexto). También necesitamos crear integridades vectoriales para cada fragmento. Las incrustaciones de vectores nos permiten encontrar los trozos más relevantes para ayudar a responder la pregunta. Debido a que las fragmentos e incrustaciones toman tiempo, queremos hacerlo solo una vez, por lo que guardamos los resultados en una tienda vectorial (base de datos).
2. Recuperación: dada una pregunta del usuario, utilizamos la búsqueda de similitud para encontrar los fragmentos más relevantes (es decir, las piezas de los archivos locales relacionados con la pregunta). Una vez que determinamos los fragmentos más relevantes, podemos usar el LLM para responder la pregunta. Para hacerlo, combinamos la pregunta del usuario con los fragmentos relevantes y un aviso que le indica a la LLM que responda la pregunta.

Estos dos pasos se ilustran en el siguiente diagrama.

Cómo usar este proyecto

Si aún no lo ha hecho, prepare el medio ambiente. Si ya ha preparado el entorno, active con source venv/bin/activate .

Hay dos formas de usar este proyecto:

1. Interfaz de línea de comandos: use este para ver más registros y comprender lo que está sucediendo (vea el indicador --verbose a continuación).
2. Aplicación de transmisión: use esta para una experiencia más fácil de usar.

Interfaz de línea de comandos

1. Copie los archivos que desea usar en la carpeta data .
2. Ejecute python main.py ingest para ingerir los archivos en la tienda Vector.
3. Ejecute python main.py retrieve para recuperar datos del almacén Vector. Te solicitará una pregunta.

Use la bandera --verbose para obtener más detalles sobre lo que el programa está haciendo detrás de escena.

Para volver a realizar los datos, elimine la carpeta vector_store y ejecute python main.py ingest nuevamente.

Aplicación de racionalización

Ejecute streamlit run app.py Abrirá la aplicación en una ventana del navegador.

Este comando puede fallar el primero que lo ejecuta. Hay una falla en algún lugar en la forma en que el entorno de Python funciona junto con Pyenv. Si Streamlit muestra un "mensaje del módulo no importar", desactive el entorno de Python con deactivate , activelo nuevamente con source venv/bin/activate , y ejecute streamlit run app.py

Diseño

Ingerir datos

Si aún no lo ha hecho, prepare el medio ambiente. Si ya ha preparado el entorno, active con source venv/bin/activate .

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

El objetivo de esta etapa es hacer que los datos se puedan buscar. Sin embargo, la pregunta del usuario y el contenido de los datos pueden no coincidir exactamente. Por lo tanto, no podemos usar un motor de búsqueda simple. Necesitamos realizar una búsqueda de similitud respaldada por Vector Incrustaciones. La incrustación vectorial es la parte más importante de esta etapa.

La ingestión de datos tiene los siguientes pasos:

1. Cargue el archivo: un lector de documentos que coincida con el tipo de documento se usa para cargar el archivo. En este punto, tenemos una variedad de caracteres con el contenido del archivo (un "documento" a partir de ahora). Se ignoran los metadatos, las imágenes, etc.
2. Divida el documento en trozos: un divisor de documento divide el documento en trozos del tamaño especificado. Necesitamos dividir el documento para que se ajuste al tamaño de contexto del modelo (y para enviar menos tokens al usar un modelo pagado). El tamaño exacto de cada fragmento depende del divisor del documento. Por ejemplo, un divisor de oraciones intenta dividir en el nivel de oración, haciendo que algunos trozos sean más pequeños que el tamaño especificado.
3. Cree incrustaciones de vectores para cada fragmento: un modelo de incrustación crea una incrustación vectorial para cada fragmento. Este es el paso crucial que nos permite encontrar los trozos más relevantes para ayudar a responder la pregunta.
4. Guarde los incrustaciones en la base de datos Vector (tienda): persista todo el trabajo que hicimos anteriormente para que no tengamos que repetirlo en el futuro.

Mejoras futuras:

• Analización de documentos más inteligente. Por ejemplo, no mezcle los subtítulos de figura con el texto de la sección; No analice la sección de referencia (alternativamente, reemplace las referencias en línea con el texto de referencia real).
• Mejorar el paralelismo. Idealmente, queremos ejecutar todo el flujo de trabajo (documento de carga, fragmento, incrustarse, persistir) en paralelo para cada archivo. Esto requiere una solución que paralelice no solo a las tareas unidas a E/S sino también a CPU. La tienda Vector también debe admitir múltiples escritores.
• Pruebe diferentes estrategias de fragmentación, por ejemplo, verifique si los divisores de oraciones ( NLTKTextSplitter o SpacyTextSplitter ) mejoran las respuestas.
• Elija el tamaño de fragmentación basado en el tamaño de entrada (contexto) LLM. Actualmente está codificado a un pequeño número, lo que puede afectar la calidad de los resultados. Por otro lado, ahorra costos en la API LLM. Necesitamos encontrar un equilibrio.
• Automatice el proceso de ingestión: detecte si hay archivos nuevos o modificados y ingiere.

Recuperar datos

Si aún no lo ha hecho, prepare el medio ambiente. Si ya ha preparado el entorno, active con source venv/bin/activate .

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

El objetivo de esta etapa es recuperar información de los datos locales. Lo hacemos obteniendo los trozos más relevantes de la tienda Vector y combinándolos con la pregunta del usuario y un aviso. El aviso instruye al modelo de idioma (LLM) que responda la pregunta.

La recuperación de datos tiene los siguientes pasos:

1. Encuentre los fragmentos más relevantes: la tienda Vector se consulta para encontrar los trozos más relevantes para la pregunta.
2. Combine los trozos con la pregunta y un aviso: los trozos se combinan con la pregunta y un aviso. El aviso le indica al LLM que responda la pregunta.
3. Envíe el texto combinado al LLM: el texto combinado se envía al LLM para obtener la respuesta.

Mejoras futuras:

• Agregue las devoluciones de llamada Langchain para ver los pasos del proceso de recuperación.
• Mejore la solicitud para responder solo con lo que hay en los documentos locales, por ejemplo, "use solo información de los siguientes documentos: ...". Sin este paso, el modelo parece soñar con una respuesta de los datos de capacitación, que no siempre es relevante.
• Agregue moderación para filtrar respuestas ofensivas.
• Mejore las respuestas con Reranking: "Extrae a nuestros resultados de búsqueda y luego se vuelva a ser determinista basado en un modificador o conjunto de modificadores". .
• Pruebe diferentes tipos de cadena (relacionados con el punto anterior).

Mejora de los resultados

Tuvimos que hacer algunos compromisos para que se ejecute en una máquina local en una cantidad razonable de tiempo.

• Usamos un modelo pequeño. Este es difícil de cambiar. El modelo tiene que ejecutarse en una CPU y caber en la memoria.
• Usamos un pequeño tamaño de incrustación. Podemos aumentar el tamaño de la incrustación si esperamos más para el proceso de ingestión.
• Mantenga todo igual y pruebe diferentes cadenas.

Fuentes

La mayor parte del código de ingesta/recuperación se basa en el PRIVEDGPT original, el que llaman ahora primordial .

Qué es diferente:

• Aplicación de optimización para la interfaz de usuario.
• Utilice incrustaciones más nuevas y versiones de modelos de idiomas grandes.
• Modernizó el código Python. Por ejemplo, usa pathlib en lugar de os.path y tiene un registro adecuado en lugar de declaraciones de impresión.
• Se agregó más registro para comprender lo que está sucediendo. Use la bandera --verbose para ver los detalles.
• Se agregó un programa principal para ejecutar los pasos de ingesta/recuperación.
• Completado requirements.txt con las dependencias indirectas, por ejemplo, para los transformadores de la cara de abrazo y los cargadores de documentos Langchain.

Consulte este archivo para obtener más notas recopiladas durante el desarrollo de este proyecto.

Preparando el medio ambiente

Este es un paso único. Si ya ha hecho esto, simplemente active el entorno virtual con source venv/bin/activate .

Ambiente de pitón

Ejecute los siguientes comandos para crear un entorno virtual e instalar los paquetes requeridos.

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

Análisis de pdf

El analizador PDF en unstructured es una capa encima de los paquetes de analizador reales. Siga las instrucciones en el ReadMe unstructured , debajo de las balas "Instale las siguientes dependencias del sistema". Se requieren los paquetes Poppler y Tesseract (ignorar los otros).

Modelo

Sugiero comenzar con un pequeño modelo que se ejecute en CPU. GPT4All tiene una lista de modelos aquí. Probé con Mistral-7B-Openorca Q4. Requiere 8 GB de RAM para ejecutar. Tenga en cuenta que algunos de los modelos tienen licencias restrictivas. Consulte la licencia antes de usarlos en proyectos comerciales.

1. Crea una carpeta con nombre de models .
2. Haga clic aquí para descargar Mistral 7B OpenORCA (Descarga de 3.8 GB, 8 GB RAM).
3. Copie el modelo a la carpeta models .