El perfeccionamiento de los modelos de aprendizaje automático empieza por disponer de conjuntos de datos bien preparados. Esta guía le mostrará cómo crear estos conjuntos de datos, desde la recopilación de datos hasta la creación de archivos de instrucciones. Al final, dispondrá de conocimientos prácticos y herramientas para preparar conjuntos de datos de alta calidad para sus tareas de ajuste.
Este post continúa las guías detalladas de preparar los datos para el GARy creación de aplicaciones RAG de extremo a extremo con la búsqueda vectorial de Couchbase.
Panorama general
Recogida de datos
El primer paso consiste en recopilar datos de diversas fuentes. Se trata de recopilar información en bruto que luego se limpiará y organizará en conjuntos de datos estructurados.
Para obtener una guía detallada, paso a paso, sobre la preparación de datos para la generación aumentada de recuperación, consulte nuestra completa entrada de blog: "Guía paso a paso para preparar los datos para su recuperación Generación aumentada".
Nuestro enfoque de la recogida de datos
En nuestro planteamiento, utilizamos múltiples métodos para recopilar todos los datos pertinentes:
-
- Web scraping con Scrapy:
- Chatarra es un potente framework de Python para extraer datos de sitios web. Permite escribir arañas que rastreen sitios web y extraigan datos de forma eficiente.
- Extracción de documentos de Confluence:
- Descargamos directamente los documentos almacenados en nuestro espacio de trabajo de Confluence. Pero esto también se puede hacer utilizando la función API de Confluence lo que implicaría escribir scripts para automatizar el proceso de extracción.
- Recuperación de archivos relevantes de repositorios Git:
- Se escribieron secuencias de comandos personalizadas para clonar los repositorios y extraer los archivos pertinentes. Así nos aseguramos de recopilar todos los datos necesarios almacenados en nuestros sistemas de control de versiones.
- Web scraping con Scrapy:
Combinando estos métodos, garantizamos un proceso de recopilación de datos exhaustivo y eficaz, que abarcaba todas las fuentes necesarias.
Extracción del contenido del texto
Una vez recopilados los datos, el siguiente paso crucial es extraer el texto de documentos como páginas web y PDF. Este proceso implica analizar estos documentos para obtener datos de texto limpios y estructurados.
Para obtener pasos detallados y ejemplos de código sobre la extracción de texto de estas fuentes, consulte nuestra guía completa en la entrada del blog: "Guía paso a paso para preparar los datos para su recuperación Generación aumentada".
Bibliotecas utilizadas para la extracción de texto
-
- HTML: BeautifulSoup se utiliza para navegar por estructuras HTML y extraer contenido de texto.
- PDF: PyPDF2 facilita la lectura de archivos PDF y la extracción de texto de cada página.
Estas herramientas nos permiten transformar documentos no estructurados en datos de texto organizados listos para su posterior procesamiento.
Creación de datos JSON de muestra
Esta sección se centra en la generación de instrucciones para la creación de conjuntos de datos utilizando funciones como generar_contenido() y generar_instrucciones()que derivan preguntas basadas en el conocimiento del dominio.
Generar instrucciones (preguntas)
Para generar preguntas de instrucción, seguiremos estos pasos:
-
- Secciones de trozos: El texto se fragmenta semánticamente para garantizar preguntas significativas y contextualmente relevantes.
- Formule preguntas: Estos trozos se envían a un modelo lingüístico (LLM), que genera preguntas basadas en el trozo recibido.
- Crear formato JSON: Por último, estructuraremos las preguntas y la información asociada en un formato JSON para facilitar el acceso y la utilización.
Muestra instrucciones.json
He aquí un ejemplo de lo que instrucciones.json después de generar y guardar las instrucciones:
|
1 2 3 4 |
[ "¿Cuál es la importancia de KV-Engine en el contexto de Magma Storage Engine?", "¿Cuál es la importancia de la arquitectura en el contexto del motor de almacenamiento Magma?" ] |
Aplicación
Para aplicar este proceso:
-
- Cargar el conocimiento del dominiorecuperar información específica de un dominio a partir de un archivo designado
- Generar instruccionesutilizan funciones como
generar_contenido()desglosar los datos y formular preguntas utilizandogenerar_instrucciones() - Guardar preguntas: uso
guardar_instrucciones()para almacenar las preguntas generadas en un archivo JSON
generar_contenido función
En generar_contenido tokeniza el conocimiento del dominio en frases y, a continuación, genera preguntas lógicas basadas en esas frases:
|
1 2 3 4 5 6 7 8 9 10 11 |
def generar_contenido(conocimiento_del_dominio, contexto): preguntas = [] # Tokenizar el conocimiento del dominio en frases frases = nltk.sent_tokenize(conocimiento_del_dominio) # Generar preguntas lógicas a partir de frases para frase en frases: pregunta = generar_instrucciones(frase, contexto) preguntas.añadir(pregunta) devolver preguntas |
generar_instrucciones función
Esta función demuestra cómo generar preguntas de instrucción utilizando una API de modelo de lenguaje:
|
1 2 3 4 5 6 7 8 |
def generar_instrucciones(dominio, contexto): consulte = "Genere una pregunta a partir del conocimiento del dominio proporcionado que pueda responderse con el conocimiento del dominio dado. No cree ni imprima ninguna lista numerada, ni saludos, imprima directamente la pregunta". url = http://localhost:11434/api/generate datos = {"modelo": modelo, "arroyo": Falso, "prompt": f"[DOMINIO] {dominio} [/DOMINIO] [CONTEXTO] {contexto} [/CONTEXT] {prompt}"} respuesta = solicita.Correo electrónico:(url, json=datos) respuesta.subir_por_estado() devolver respuesta.json()[respuesta].tira() |
Cargar y guardar el conocimiento del dominio
Utilizamos dos funciones adicionales: cargar_conocimiento_del_dominio() para cargar el conocimiento del dominio desde un archivo y save_instructions() para guardar las instrucciones generadas en un archivo JSON.
cargar_conocimiento_del_dominio función
Esta función carga el conocimiento del dominio desde un archivo especificado.
|
1 2 3 4 |
def cargar_conocimiento_del_dominio(archivo_de_dominio): con abra(archivo_de_dominio, 'r') como archivo: conocimiento_del_dominio = archivo.leer() devolver conocimiento_del_dominio |
guardar_instrucciones función
Esta función guarda las instrucciones generadas en un archivo JSON:
|
1 2 3 |
def guardar_instrucciones(instrucciones, nombre de archivo): con abra(nombre de archivo, 'w') como archivo: json.vertedero(instrucciones, archivo, sangría=4) |
Ejemplo de uso
He aquí un ejemplo que demuestra cómo estas funciones trabajan juntas:
|
1 2 3 4 5 6 |
# Ejemplo de uso archivo_de_dominio = "conocimiento_del_dominio.txt" contexto = "muestra de contexto" conocimiento_del_dominio = cargar_conocimiento_del_dominio(archivo_de_dominio) instrucciones = generar_contenido(conocimiento_del_dominio, contexto) guardar_instrucciones(instrucciones, "instrucciones.json") |
Este flujo de trabajo permite crear y almacenar eficazmente preguntas para la preparación de conjuntos de datos.
Generación de conjuntos de datos (entrenamiento, prueba, validación)
Esta sección le guiará en la creación de conjuntos de datos para afinar varios modelos, como Mistral 7B, utilizando Llama2 de Ollama. Para garantizar la precisión, necesitará el conocimiento del dominio almacenado en archivos como dominio.txt.
Funciones de Python para la creación de conjuntos de datos
query_ollama Función
Esta función pide al modelo Llama 2 de Ollama respuestas y preguntas de seguimiento basadas en indicaciones específicas y en el contexto del dominio:
|
1 2 3 4 5 6 7 8 9 10 11 |
def consulta_ollama(consulte, dominio, contexto='', modelo=llama2): url = http://localhost:11434/api/generate datos = {"modelo": modelo, "arroyo": Falso, "prompt": f"[DOMINIO] {dominio} [/DOMINIO] [CONTEXTO] {contexto} [/CONTEXT] {prompt}"} respuesta = solicita.Correo electrónico:(url, json=datos) respuesta.subir_por_estado() datos_seguimiento = {"modelo": modelo, "arroyo": Falso, "prompt": respuesta.json()[respuesta].tira() + "¿Cuál es una pregunta o solicitud de seguimiento probable? Devuelve sólo el texto de una pregunta o petición".} respuesta_seguimiento = solicita.Correo electrónico:(url, json=datos_seguimiento) respuesta_seguimiento.subir_por_estado() devolver respuesta.json()[respuesta].tira(), respuesta_seguimiento.json()[respuesta].sustituir("\"", "").tira() |
crear_archivo_validación función
Esta función divide los datos en conjuntos de entrenamiento, prueba y validación, y los guarda en archivos separados para el entrenamiento del modelo:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
def crear_archivo_validación(archivo_temporal, archivo_de_entrenamiento, archivo_valido, archivo_de_prueba): con abra(archivo_temporal, 'r') como archivo: líneas = archivo.líneas de lectura() líneas_tren = líneas[:int(len(líneas) * 0.8)] líneas_de_prueba = líneas[int(len(líneas) * 0.8):int(len(líneas) * 0.9)] líneas_válidas = líneas[int(len(líneas) * 0.9):] con abra(archivo_de_entrenamiento, 'a') como archivo: archivo.líneas de escritura(líneas_tren) con abra(archivo_valido, 'a') como archivo: archivo.líneas de escritura(líneas_válidas) con abra(archivo_de_prueba, 'a') como archivo: archivo.líneas de escritura(líneas_de_prueba) |
Gestión de la creación de conjuntos de datos
principal función
La función principal coordina la generación del conjunto de datos, desde la consulta a Llama 2 de Ollama hasta el formateo de los resultados en archivos JSONL para el entrenamiento del modelo:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
def principal(archivo_temporal, archivo_de_instrucciones, archivo_de_entrenamiento, archivo_valido, archivo_de_prueba, archivo_de_dominio, contexto=''): # Comprobar si existe el archivo de instrucciones si no Ruta(archivo_de_instrucciones).is_file(): sys.salida(f'{archivo_instrucciones} no encontrado.') # Comprobar si existe el archivo de dominio si no Ruta(archivo_de_dominio).is_file(): sys.salida(f'{archivo_dominio} no encontrado.') # Conocimiento del dominio de carga dominio = cargar_dominio(archivo_de_dominio) # Cargar instrucciones del archivo con abra(archivo_de_instrucciones, 'r') como archivo: instrucciones = json.carga(archivo) # Procesar cada instrucción para i, instrucción en enumerar(instrucciones, iniciar=1): imprimir(f"Procesando ({i}/{len(instrucciones)}): {instrucción}") # Consulta el modelo llama2 de Ollama para obtener la respuesta del modelo y la pregunta de seguimiento responder, pregunta_seguimiento = consulta_ollama(instrucción, dominio, contexto) # Formatear el resultado en formato JSONL resultado = json.vuelca({ texto: f' }) + "\n" # Escribir el resultado en un fichero temporal con abra(archivo_temporal, 'a') como archivo: archivo.escriba a(resultado) # Creación de archivos de entrenamiento, prueba y validación crear_archivo_validación(archivo_temporal, archivo_de_entrenamiento, archivo_valido, archivo_de_prueba) imprimir("¡Hecho! Archivos JSONL de entrenamiento, prueba y validación creados".) |
Utilizar estas herramientas
Para empezar a refinar modelos como el Mistral 7B con el Llama 2 de Ollama:
-
- Preparar el conocimiento del dominio: almacenar detalles específicos del dominio en
dominio.txt - Generar instrucciones: crear un archivo JSON,
instrucciones.jsoncon indicaciones para la creación de conjuntos de datos - Ejecuta la función principal: ejecutar
main()con rutas de archivos para crear conjuntos de datos para el entrenamiento y la validación de modelos
- Preparar el conocimiento del dominio: almacenar detalles específicos del dominio en
Estas funciones de Python le permiten desarrollar conjuntos de datos que optimizan los modelos de aprendizaje automático, mejorando el rendimiento y la precisión de las aplicaciones avanzadas.
Conclusión
¡Eso es todo por hoy! Con estos pasos, ahora tiene el conocimiento y las herramientas para mejorar su proceso de formación de modelos de aprendizaje automático. Gracias por leer esta guía y esperamos que le haya resultado útil. Asegúrese de explorar nuestros otros blogs para obtener más información. Esté atento a la próxima parte de esta serie y eche un vistazo a otros blogs. blogs relacionados con la búsqueda de vectores. Feliz modelaje, ¡y hasta la próxima!
Referencias
Colaboradores
Sanjivani Patra – Nishanth VM – Ashok Kumar Alluri
