092_eval_metrics_with_dspy_coding - IUGO-Studio/tech-ia GitHub Wiki

Resumen general:

El video continúa la discusión sobre DSPY, centrándose en cómo crear un evaluador personalizado (custom evaluator) para una tarea específica (determinar si un chiste es gracioso o no) y cómo usar ese evaluador dentro de DSPY para optimizar un prompt. Se explica cómo generar un conjunto de datos de entrenamiento para el evaluador, utilizando tanto chistes "graciosos" (obtenidos de internet) como chistes "no graciosos" (generados por ChatGPT). Se entrena un modelo GPT-3.5 Turbo con DSPY, utilizando un modelo GPT-4 como "profesor" para generar ejemplos sintéticos y mejorar el prompt. Se demuestra cómo el evaluador entrenado puede usarse para medir la calidad de los chistes generados por otro LLM y cómo la optimización con DSPY (tanto con ejemplos como modificando instrucciones) mejora el rendimiento del evaluador.

Conceptos clave:

  • Custom Evaluator (Evaluador personalizado): Una función o modelo que evalúa la calidad de las respuestas generadas por un LLM para una tarea específica, según criterios definidos por el usuario.
  • Evaluación sintética: Usar un LLM para evaluar.
  • Conjunto de datos de entrenamiento (Training Data): Un conjunto de datos etiquetados (en este caso, chistes clasificados como "graciosos" o "no graciosos") utilizado para entrenar el evaluador.
  • Conjunto de datos de prueba (Test Data): Un conjunto de datos separado del conjunto de entrenamiento, utilizado para evaluar el rendimiento del evaluador durante la optimización.
  • Conjunto de datos de desarrollo (Dev Data): Un conjunto de datos separado tanto del conjunto de entrenamiento como del de prueba, utilizado para una evaluación final e imparcial del evaluador.
  • DSPY: Framework para optimizar prompts.
  • Few-shot learning: Dar ejemplos.
  • Prompt Engineering: El arte de diseñar prompts.
  • LLM: Modelo de lenguaje extenso.
  • BootstrapFewShot: Optimizador que entrena a base de ejemplos.
  • BootstrapFewShotWithRandomSearch: Optimizador que entrena con ejemplos y hace una busqueda de los mejores ejemplos.
  • COPRO: Optimizador que solo entrena las instrucciones del prompt.
  • MIPRO: Optimizador que entrena tanto las instrucciones del prompt, como la selección de ejemplos.

Pasos para crear y usar un evaluador personalizado con DSPY:

  1. Recopilar datos de entrenamiento:
    • Obtener ejemplos de chistes "graciosos" de internet.
    • Utilizar ChatGPT para generar ejemplos de chistes "no graciosos".
    • Combinar los ejemplos en un conjunto de datos, etiquetando cada chiste como "gracioso" (1) o "no gracioso" (0).
    • Se le puede pedir a un LLM que genere los tópicos.
  2. Dividir el conjunto de datos:
    • Separar el conjunto de datos en tres partes: entrenamiento, prueba y desarrollo.
  3. Definir una "signature" para el evaluador:
    • Especificar los campos de entrada (ej: topic, joke, question_to_assess_the_joke) y el campo de salida (ej: answer, que indica si el chiste es gracioso o no).
  4. Crear un "module" para el evaluador:
    • Se usa un modulo Predict.
  5. Definir una función de métrica (eval):
    • Esta función toma como entrada un ejemplo (con el chiste y su etiqueta "verdadera") y la predicción del evaluador, y calcula una puntuación (ej: 1 si la predicción es correcta, 0 si no lo es).
  6. Entrenar el evaluador con DSPY:
    • Utilizar un optimizador de DSPY (ej: BootstrapFewShotWithRandomSearch) para entrenar el evaluador.
    • El optimizador utilizará el conjunto de entrenamiento y la función de métrica para mejorar el prompt del evaluador (agregando ejemplos y/o modificando las instrucciones).
    • Se especifica que el "profesor" sea GPT-4 (para que genere buenos ejemplos sintéticos) y el modelo a entrenar sea GPT-3.5 Turbo (más económico).
  7. Evaluar el evaluador entrenado:
    • Utilizar el conjunto de desarrollo para evaluar el rendimiento final del evaluador.
  8. Usar el evaluador: Usar para evaluar nuevos chistes.

Ejemplo práctico (evaluador de chistes):

  • Se recopilan chistes "graciosos" y "no graciosos".
  • Se define una "signature" con campos de entrada (topic, joke, question_to_assess_the_joke) y un campo de salida (answer).
  • Se define una función de métrica que compara la predicción del evaluador con la etiqueta "verdadera".
  • Se entrena un evaluador GPT-3.5 Turbo con DSPY, utilizando GPT-4 como "profesor" y el optimizador BootstrapFewShotWithRandomSearch.
  • Se evalúa el rendimiento del evaluador en el conjunto de desarrollo, mostrando una mejora significativa en la precisión (de 46% a 79.5%).
  • Se prueba el optimizador MIPRO.

Consejos y buenas prácticas:

  • Comienza con un conjunto de datos de entrenamiento de alta calidad: La calidad de tus datos de entrenamiento afectará directamente el rendimiento de tu evaluador.

  • Elige una función de métrica que refleje tus objetivos: La métrica debe medir lo que realmente te importa (ej: precisión, exhaustividad, F1-score).

  • Experimenta con diferentes optimizadores y parámetros de DSPY: Prueba diferentes optimizadores y configuraciones para encontrar lo que funciona mejor para tu tarea.

  • Evalúa el evaluador en un conjunto de datos de desarrollo separado: Esto te dará una estimación imparcial del rendimiento del evaluador en datos no vistos.

  • Utiliza el evaluador entrenado para mejorar tus prompts o modelos: Puedes usar el evaluador para evaluar diferentes prompts, para generar más datos de entrenamiento (seleccionando los mejores ejemplos), o para ajustar finamente un modelo.

  • "Bootstrapping": Se refiere a un proceso iterativo en el que el LLM se usa para mejorarse a sí mismo. En el contexto de DSPY, esto implica:

    1. Generar ejemplos sintéticos: El LLM ("profesor", en este caso GPT-4) genera nuevos ejemplos (chistes, en este caso) basados en el prompt actual y los ejemplos existentes.
    2. Evaluar los ejemplos: Se usa la métrica de evaluación (en este caso, otro LLM) para calificar los ejemplos generados.
    3. Seleccionar los mejores ejemplos: Se seleccionan los ejemplos con las mejores puntuaciones para agregarlos al prompt (como few-shot examples) o para entrenar un modelo más pequeño.
    4. Repetir: El proceso se repite, generando nuevos ejemplos basados en el prompt mejorado, y así sucesivamente.

    Este proceso de "bootstrapping" permite al LLM aprender de sus propios errores y mejorar gradualmente su rendimiento en la tarea.

  • "Overfitting": Se produce cuando un modelo de IA se ajusta demasiado a los datos de entrenamiento y pierde la capacidad de generalizar a datos nuevos y no vistos. En el contexto de DSPY, el overfitting podría ocurrir si el optimizador se enfoca demasiado en los ejemplos del conjunto de entrenamiento y prueba, y no funciona bien en el conjunto de desarrollo.

  • Prompt de evaluación creado vs prompt de evaluación ideal: El prompt de evaluación que crea el usuario no es perfecto. La idea es usar un LLM más potente (GPT-4) para generar ejemplos y "entrenar" a un LLM más económico (GPT-3.5 Turbo).

Dudas o preguntas:

  • ¿Cómo se puede adaptar esta técnica para crear evaluadores personalizados para otras tareas, como la clasificación de texto, la generación de resúmenes o la respuesta a preguntas? Investigación: Se pueden seguir los mismos pasos generales, pero adaptando la "signature", la función de métrica y el conjunto de datos de entrenamiento a la tarea específica.

  • ¿Cómo se puede mejorar la calidad de los datos de entrenamiento generados sintéticamente? Investigación: Se pueden utilizar técnicas como el filtrado basado en reglas, la revisión manual, o el uso de modelos de lenguaje más potentes para generar los datos.

  • ¿Cuáles son las ventajas y desventajas de utilizar un LLM como evaluador en comparación con la evaluación humana o programática? Ventajas: Más flexible que la evaluación programática, más barato y rápido que la evaluación humana. Desventajas: Depende de la calidad del modelo evaluador, puede ser menos preciso que la evaluación humana.

  • ¿Por qué se usan dos LLMs (GPT-4 como "profesor" y GPT-3.5 Turbo como "estudiante")?

    • Costo: GPT-3.5 Turbo es mucho más barato que GPT-4. Usar GPT-4 para todo el proceso (generación de ejemplos, evaluación, optimización) sería muy costoso.
    • Eficiencia: GPT-3.5 Turbo es más rápido que GPT-4. Esto es importante para la iteración y la experimentación.
    • Generalización: Al entrenar un modelo más pequeño (GPT-3.5 Turbo) con ejemplos generados por un modelo más grande (GPT-4), se busca que el modelo más pequeño aprenda a generalizar mejor y no solo a memorizar los ejemplos.
    • "Destilación de conocimiento": Se puede ver como una forma de transferir el conocimiento de un modelo grande y potente a un modelo más pequeño y eficiente.

    La idea es usar GPT-4 estratégicamente para las tareas que requieren mayor capacidad (generar ejemplos de alta calidad y evaluar inicialmente), y luego usar GPT-3.5 Turbo para la tarea principal (clasificar chistes), una vez que ha sido "entrenado" con los ejemplos y el prompt optimizado.

⚠️ **GitHub.com Fallback** ⚠️