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 |
[ "What is the significance of KV-Engine in the context of Magma Storage Engine?", "What is the significance of Architecture in the context of Magma Storage Engine?" ] |
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 generate_content(domain_knowledge, context): questions = [] # Tokenize domain knowledge into sentences sentences = nltk.sent_tokenize(domain_knowledge) # Generate logical questions based on sentences for sentence in sentences: question = generate_instructions(sentence, context) questions.append(question) return questions |
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 generate_instructions(domain, context): prompt = "Generate a question from the domain knowledge provided which can be answered with the domain knowledge given. Don't create or print any numbered lists, no greetings, directly print the question." url = 'https://localhost:11434/api/generate' data = {"model": model, "stream": False, "prompt": f"[DOMAIN] {domain} [/DOMAIN] [CONTEXT] {context} [/CONTEXT] {prompt}"} response = requests.post(url, json=data) response.raise_for_status() return response.json()['response'].strip() |
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 load_domain_knowledge(domain_file): with open(domain_file, 'r') as file: domain_knowledge = file.read() return domain_knowledge |
guardar_instrucciones función
Esta función guarda las instrucciones generadas en un archivo JSON:
|
1 2 3 |
def save_instructions(instructions, filename): with open(filename, 'w') as file: json.dump(instructions, file, indent=4) |
Ejemplo de uso
He aquí un ejemplo que demuestra cómo estas funciones trabajan juntas:
|
1 2 3 4 5 6 |
# Example usage domain_file = "domain_knowledge.txt" context = "sample context" domain_knowledge = load_domain_knowledge(domain_file) instructions = generate_content(domain_knowledge, context) save_instructions(instructions, "instructions.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 query_ollama(prompt, domain, context='', model='llama2'): url = 'https://localhost:11434/api/generate' data = {"model": model, "stream": False, "prompt": f"[DOMAIN] {domain} [/DOMAIN] [CONTEXT] {context} [/CONTEXT] {prompt}"} response = requests.post(url, json=data) response.raise_for_status() followup_data = {"model": model, "stream": False, "prompt": response.json()['response'].strip() + "What is a likely follow-up question or request? Return just the text of one question or request."} followup_response = requests.post(url, json=followup_data) followup_response.raise_for_status() return response.json()['response'].strip(), followup_response.json()['response'].replace("\"", "").strip() |
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 create_validation_file(temp_file, train_file, valid_file, test_file): with open(temp_file, 'r') as file: lines = file.readlines() train_lines = lines[:int(len(lines) * 0.8)] test_lines = lines[int(len(lines) * 0.8):int(len(lines) * 0.9)] valid_lines = lines[int(len(lines) * 0.9):] with open(train_file, 'a') as file: file.writelines(train_lines) with open(valid_file, 'a') as file: file.writelines(valid_lines) with open(test_file, 'a') as file: file.writelines(test_lines) |
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 main(temp_file, instructions_file, train_file, valid_file, test_file, domain_file, context=''): # Check if instructions file exists if not Path(instructions_file).is_file(): sys.exit(f'{instructions_file} not found.') # Check if domain file exists if not Path(domain_file).is_file(): sys.exit(f'{domain_file} not found.') # Load domain knowledge domain = load_domain(domain_file) # Load instructions from file with open(instructions_file, 'r') as file: instructions = json.load(file) # Process each instruction for i, instruction in enumerate(instructions, start=1): print(f"Processing ({i}/{len(instructions)}): {instruction}") # Query Ollama's llama2 model to get model answer and follow-up question answer, followup_question = query_ollama(instruction, domain, context) # Format the result in JSONL format result = json.dumps({ 'text': f'<s>[INST] {instruction}[/INST] {answer}</s>[INST]{followup_question}[/INST]' }) + "\n" # Write the result to temporary file with open(temp_file, 'a') as file: file.write(result) # Create train, test, and validate files create_validation_file(temp_file, train_file, valid_file, test_file) print("Done! Training, testing, and validation JSONL files created.") |
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
