096_sammo_metaprompting - IUGO-Studio/tech-ia GitHub Wiki

Resumen general:

El video continúa la exploración de la biblioteca SAMMO de Microsoft, enfocándose en técnicas más avanzadas: "minibatching" (procesamiento por lotes) y "meta prompting" (generación de prompts a partir de otros prompts). Se muestra cómo utilizar estas técnicas para mejorar la eficiencia y la flexibilidad al interactuar con modelos de lenguaje. Además, se introduce la capacidad de SAMMO para realizar RAG (Retrieval-Augmented Generation) de forma local, simplificando la experimentación con esta técnica. El ejemplo práctico se centra en la clasificación de transacciones bancarias.

Conceptos clave:

  • Minibatching (Procesamiento por lotes): La técnica de procesar múltiples entradas (ej: prompts) simultáneamente en un solo lote, en lugar de procesarlas una por una. Esto puede mejorar significativamente la eficiencia al interactuar con modelos de lenguaje.
  • Meta Prompting: La técnica de generar un prompt a partir de otro prompt.
  • SAMMO: Una biblioteca de Microsoft para la creación, prueba y optimización de prompts.
  • Runner: En SAMMO, un objeto que se utiliza para ejecutar un modelo de lenguaje (ej: OpenAIChat para la API de OpenAI).
  • Component: En SAMMO, un bloque de construcción básico para crear prompts y procesar respuestas (ej: GenerateText, Output, ForEach, DataTable, ExtractRegex, MetaPrompt, EmbeddingFewShotExamples).
  • DataTable: Un componente de SAMMO que permite ejecutar un prompt en paralelo sobre un conjunto de datos.
  • ForEach: Un componente de SAMMO que permite iterar sobre una lista de elementos y aplicar un prompt a cada elemento.
  • ExtractRegex: Un componente de SAMMO que permite extraer información de una respuesta utilizando expresiones regulares.
  • MetaPrompt: Un componente de SAMMO que simplifica la creación de prompts complejos, permitiendo definir secciones como instrucciones, ejemplos, etiquetas de salida, etc.
  • EmbeddingFewShotExamples: Un componente de SAMMO que permite seleccionar ejemplos relevantes para un prompt utilizando embeddings (búsqueda por similitud).
  • RAG (Retrieval-Augmented Generation): Una técnica que combina la recuperación de información con la generación de texto.
  • Asíncrono (Async): Una técnica de programación que permite ejecutar múltiples tareas simultáneamente.
  • Prompt Engineering: El arte de diseñar prompts.
  • LLM: Modelo de lenguaje extenso.

Ejemplos prácticos:

  1. Clasificación de transacciones bancarias (enfoque manual):

    • Se define un prompt con instrucciones para clasificar transacciones, una lista de etiquetas de salida posibles (Rent, Other, Food, Entertainment, Utilities) y un marcador de posición para la descripción de la transacción.
    • Se utiliza GenerateText para generar la clasificación y ExtractRegex para extraer la etiqueta de la respuesta.
    • Se utiliza DataTable para procesar múltiples transacciones en paralelo (minibatching).
    • Se calcula la precisión de la clasificación comparando las respuestas generadas con las etiquetas verdaderas.

  2. Clasificación de transacciones bancarias (con MetaPrompt):

    • Se utiliza el componente MetaPrompt para simplificar la creación del prompt, definiendo secciones separadas para las instrucciones, los ejemplos (FewshotExamples), las etiquetas de salida (Paragraph) y los datos de entrada (InputData).
    • Se utiliza EmbeddingFewShotExamples para seleccionar dinámicamente ejemplos relevantes para cada transacción, utilizando embeddings y búsqueda por similitud. (RAG)
    • Se muestra cómo modificar el prompt (ej: cambiar el formato de salida a JSON) utilizando el método rebind().

Consejos y buenas prácticas:

  • Utiliza "minibatching" para mejorar la eficiencia: Procesa múltiples entradas simultáneamente para reducir el tiempo total de ejecución.
  • Utiliza "MetaPrompt" para simplificar la creación de prompts complejos: Define secciones separadas para diferentes partes del prompt (instrucciones, ejemplos, etc.).
  • Utiliza EmbeddingFewShotExamples para incorporar RAG de forma sencilla: Selecciona dinámicamente ejemplos relevantes para cada entrada utilizando embeddings.
  • Utiliza DataTable para paralelizar: Ejecuta prompts en paralelo.
  • Utiliza plot_trace() para visualizar: Permite entender el flujo de ejecución.
  • Utiliza plot_program() para entender la estructura: Permite entender la estructura del programa.
  • Aprovecha la capacidad de SAMMO para manejar la asincronía: Ejecuta múltiples tareas simultáneamente para mejorar la eficiencia.
  • Experimenta con diferentes componentes y configuraciones de SAMMO: Explora las diferentes opciones disponibles para encontrar lo que funciona mejor para tu tarea.
  • "Ground Truth Labels": Etiquetas reales.
  • "Output Labels": Posibles valores que puede tomar la clasificación.

Dudas o preguntas:

  • ¿Cómo se puede integrar SAMMO con otras bibliotecas o herramientas, como LangChain o DSPY? Investigación: Si bien el video no cubre específicamente la integración con otras bibliotecas, es probable que se puedan combinar componentes de SAMMO con componentes de LangChain o DSPY, ya que todos se basan en Python y están diseñados para trabajar con modelos de lenguaje.

  • ¿Cómo se puede personalizar aún más el proceso de "minibatching" en SAMMO? Investigación: Se pueden utilizar opciones adicionales del componente DataTable, como la configuración del tamaño máximo del lote o la definición de una función de manejo de errores.

  • ¿Cómo funciona internamente el componente EmbeddingFewShotExamples? Investigación: El componente EmbeddingFewShotExamples utiliza un modelo de embedding (ej: el modelo de embedding de OpenAI) para generar representaciones vectoriales de los ejemplos y de la entrada actual. Luego, utiliza una métrica de distancia (ej: similitud coseno) para encontrar los ejemplos más similares a la entrada y los incluye en el prompt.

  • Diferencia principal entre usar ForEach y usar DataTable:

    • ForEach:

      • Itera sobre una lista de elementos que se generan dinámicamente (por ejemplo, a partir de la salida de otro prompt).
      • Aplica un prompt a cada elemento de la lista.
      • Es útil cuando la lista de elementos no se conoce de antemano o cuando se necesita procesar la salida de un prompt antes de generar la lista.

    • DataTable:

      • Trabaja con un conjunto de datos estático (similar a un DataFrame de Pandas).
      • Aplica un prompt a cada fila del conjunto de datos.
      • Es útil cuando se tiene un conjunto de datos predefinido y se quiere procesar cada fila de forma independiente y paralela.
      • Ofrece opciones de minibatching para controlar el paralelismo.

    En resumen:

    • ForEach: Iteración dinámica sobre una lista generada.
    • DataTable: Procesamiento paralelo de un conjunto de datos estático.

    El video muestra ambos enfoques. Primero usa ForEach para iterar sobre una lista de modelos generados por un prompt. Luego usa DataTable para procesar un conjunto de datos de transacciones bancarias.

  • ¿Qué hace rebind()? rebind() es un método de SAMMO que permite modificar un componente existente (en este caso, un MetaPrompt) sin tener que crear uno nuevo desde cero. Esencialmente, permite reemplazar o actualizar partes específicas de la configuración de un componente.

    En el ejemplo del video, se usa rebind() para cambiar el data_formatter del MetaPrompt de PlainTextDataFormatter (que usa texto plano) a JSONDataFormatter (que usa JSON). Esto hace que el LLM genere la salida en formato JSON en lugar de texto plano.

    modified_mprompt = mprompt.clone().rebind(data_formatter=JSONDataFormatter())
    • mprompt: Es la instancia original del MetaPrompt.
    • .clone(): Crea una copia del MetaPrompt original. Esto es importante para no modificar el original directamente.
    • .rebind(...): Aplica las modificaciones deseadas. En este caso, se reemplaza el valor de data_formatter.
    • data_formatter=JSONDataFormatter(): Especifica el nuevo valor para data_formatter.

    rebind() es útil para:

    • Experimentación: Probar diferentes configuraciones de un componente sin tener que redefinirlo completamente.
    • Reutilización: Adaptar un componente existente a nuevos casos de uso.
    • Claridad del código: Hacer que los cambios en la configuración sean explícitos y fáciles de seguir.

  • ¿Cómo funciona el RAG local de SAMMO?

    1. EmbeddingFewShotExamples: Este componente es el centro del RAG local en el ejemplo. Reemplaza al FewShotExamples tradicional.
    2. embedder: Se crea una instancia de un modelo de embedding (OpenAIEmbeddingModel en el ejemplo). Este modelo se encargará de convertir texto en vectores numéricos (embeddings).
    3. fewshot_data: Se proporciona un conjunto de datos de ejemplos (en este caso, transacciones bancarias con sus clasificaciones).
    4. examples_per_prompt: Se especifica cuántos ejemplos se deben incluir en el prompt (3 en el ejemplo).
    5. budget: controla como se seleccionan los ejemplos.
    6. Funcionamiento interno:
      • Cuando se ejecuta el prompt:
        • El componente EmbeddingFewShotExamples recibe la entrada actual (la descripción de la transacción a clasificar).
        • Utiliza el embedder para calcular el embedding de la entrada actual.
        • Utiliza el embedder para calcular los embeddings de todos los ejemplos en fewshot_data (esto se hace una sola vez al principio, no para cada entrada).
        • Compara el embedding de la entrada actual con los embeddings de los ejemplos, usando una métrica de distancia (implícitamente, SAMMO usa similitud coseno).
        • Selecciona los ejemplos más similares a la entrada actual (hasta el número especificado por examples_per_prompt).
        • Incluye esos ejemplos en el prompt, junto con la entrada actual.
        • El LLM recibe el prompt completo (instrucciones + ejemplos relevantes + entrada actual) y genera la respuesta.

    Puntos clave:

    • No hay una base de datos vectorial externa: SAMMO maneja los embeddings y la búsqueda de similitud internamente. Por eso se llama "local RAG".
    • Eficiencia: El cálculo de los embeddings de los ejemplos se hace una sola vez. Para cada nueva entrada, solo se calcula el embedding de la entrada y se compara con los embeddings precalculados.
    • Limitaciones: Este enfoque "local" es adecuado para experimentación y conjuntos de datos pequeños. Para grandes conjuntos de datos, una base de datos vectorial dedicada (como Pinecone, Weaviate, Faiss, etc.) sería más eficiente.
⚠️ **GitHub.com Fallback** ⚠️