¿Cómo puede la indicación de lo más simple a lo más complejo habilitar el razonamiento complejo en los LLM?

Introducción

¿Qué pasaría si los modelos de lenguaje pudieran abordar problemas complejos con el mismo enfoque paso a paso que usan los humanos? En el ámbito de los grandes modelos de lenguaje (LLM), la estrategia de indicación de lo más simple a lo más complejo (Least-to-Most Prompting) ofrece una solución prometedora. Referenciando el artículo “Least-To-Most Prompting Enables Complex Reasoning in Large Language Models”, este blog explora cómo este método innovador mejora las capacidades de razonamiento de los LLM. Al descomponer tareas intrincadas en subproblemas manejables, la indicación de lo más simple a lo más complejo guía a los LLM a través de una secuencia progresiva desde la simplicidad hasta la complejidad.

¿Qué es la indicación de lo más simple a lo más complejo?

La indicación de lo más simple a lo más complejo (Least-to-Most Prompting) es una estrategia innovadora introducida en el artículo “Least-To-Most Prompting Enables Complex Reasoning in Large Language Models” para mejorar las capacidades de razonamiento de los grandes modelos de lenguaje (LLM). Este método está diseñado para ayudar a los LLM a abordar problemas complejos descomponiéndolos en una serie de subproblemas más simples y manejables. El proceso consta de dos etapas principales:

1. Descomposición: El problema complejo se descompone en una lista de subproblemas más fáciles. Esta etapa utiliza ejemplos constantes que demuestran el proceso de descomposición, seguidos por la pregunta específica que necesita ser desglosada.
2. Resolución de subproblemas: Luego se le pide al modelo que resuelva estos subproblemas de forma secuencial. La solución de cada subproblema se facilita con las respuestas a subproblemas resueltos previamente. Esta etapa incluye ejemplos de cómo se resuelven los subproblemas, una lista de subpreguntas ya respondidas y sus soluciones, y la siguiente pregunta a abordar.

Las indicaciones (prompts) se construyen de manera que guían al modelo a través de una secuencia progresiva, desde los aspectos más simples del problema hasta los más complejos, de ahí el nombre “de lo más simple a lo más complejo”.

¿Por qué necesitamos la indicación de lo más simple a lo más complejo?

La necesidad de la indicación de lo más simple a lo más complejo surge de las limitaciones observadas en las técnicas de indicación existentes, particularmente en la indicación de cadena de pensamiento (chain-of-thought prompting).

La indicación de cadena de pensamiento es un enfoque que anima a los grandes modelos de lenguaje a articular su proceso de razonamiento paso a paso, de manera similar a como un humano pensaría en un problema. Este método implica que el modelo declare explícitamente cada paso lógico que da para progresar desde la comprensión de la pregunta hasta llegar a la respuesta final. Al desglosar el problema en una serie de pasos intermedios de razonamiento, el modelo proporciona una ruta de solución transparente y justificable.

Si bien la indicación de cadena de pensamiento ha mostrado mejoras significativas en el rendimiento para diversas tareas de razonamiento en lenguaje natural, tiende a tener dificultades al generalizar para resolver problemas que son más complejos que los ejemplos proporcionados en las indicaciones.

¿Cómo puede la indicación de lo más simple a lo más complejo habilitar el razonamiento complejo en los LLM?

El diseño experimental del artículo “Least-To-Most Prompting Enables Complex Reasoning in Large Language Models” se puede desglosar en el siguiente proceso paso a paso:

Identificar el objetivo de la investigación

El objetivo es permitir que los grandes modelos de lenguaje realicen tareas de razonamiento complejo que requieran resolver problemas más difíciles que los demostrados en los ejemplos de entrenamiento.

Seleccionar las tareas

Los investigadores eligieron tareas representativas de diferentes tipos de razonamiento, incluyendo manipulación simbólica, generalización composicional y razonamiento matemático.

Tarea 1: Manipulación simbólica (tarea de concatenación de la última letra):

• Problema: Dada una lista de palabras, la tarea consiste en generar la concatenación de las últimas letras de cada palabra de la lista.
• Ejemplo: Para la entrada “think, machine, learning”, la salida correcta es “keg”.
• Indicación de lo más simple a lo más complejo:
• Descomponer el problema: Dividir la lista en sublistas secuenciales (“think”, “think, machine”, “think, machine, learning”).
• Resolver subproblemas: Concatenar las últimas letras de las palabras de cada sublista (“think” da “k”, “machine” da “e”, “learning” da “g”).
• Combinar soluciones: Usar las soluciones de los subproblemas para construir la respuesta final (“k” + “e” = “ke” y “ke” + “g” = “keg”).

Tarea 2: Generalización composicional (benchmark SCAN):

• Problema: Mapear comandos en lenguaje natural a secuencias de acciones. El desafío es generalizar a secuencias de acciones más largas que las vistas durante el entrenamiento.
• Ejemplo: El comando “look opposite right thrice after walk” debe traducirse a la secuencia de acciones “TURN RIGHT, TURN RIGHT, LOOK, WALK”.
• Indicación de lo más simple a lo más complejo:
• Descomponer el comando: Dividir el comando complejo en partes más simples (“look opposite right thrice” y “walk”).
• Mapear a acciones: Traducir cada parte a acciones (“look opposite right thrice” se convierte en “TURN RIGHT, TURN RIGHT, LOOK” repetido tres veces, y “walk” permanece como “WALK”).
• Combinar acciones: Ejecutar las acciones secuencialmente para formar la secuencia final.

Tarea 3: Razonamiento matemático (conjuntos de datos GSM8K y DROP):

• Problema: Resolver problemas matemáticos con palabras que pueden requerir múltiples pasos de razonamiento.
• Ejemplo: “Elsa tiene 5 manzanas. Ana tiene 2 manzanas más que Elsa. ¿Cuántas manzanas tienen juntas?”
• Indicación de lo más simple a lo más complejo:
• Descomponer el problema: Identificar los subproblemas (¿Cuántas manzanas tiene Ana? ¿Cuántas manzanas tienen juntas?).
• Resolver subproblemas: Calcular las manzanas de Ana (5 + 2 = 7) y luego el total (5 + 7 = 12).
• Respuesta final: Concluir que Elsa y Ana tienen 12 manzanas juntas.

Diseñar las estrategias de indicación

Se comparan dos estrategias principales de indicación:

• Indicación de cadena de pensamiento: Implica proporcionar al modelo ejemplos que demuestran un proceso de razonamiento paso a paso para resolver un problema.

• Indicación de lo más simple a lo más complejo: Esta nueva estrategia implica descomponer un problema complejo en subproblemas más simples y resolverlos secuencialmente, utilizando las soluciones de subproblemas anteriores para facilitar la solución del siguiente.

Crear ejemplos de indicaciones

Para cada estrategia de indicación, los investigadores elaboraron ejemplos que demuestran cómo abordar las tareas. Para la indicación de lo más simple a lo más complejo, esto incluye ejemplos tanto de descomposición de problemas como de resolución de subproblemas.

Implementar la indicación en el modelo

Luego se le dan estas indicaciones al modelo de lenguaje como entrada. Para la indicación de lo más simple a lo más complejo, esto implica dos etapas:

• Etapa de descomposición: Se pide al modelo que descomponga el problema original en una serie de subproblemas más simples.
• Etapa de resolución de subproblemas: Luego se pide al modelo que resuelva estos subproblemas secuencialmente, utilizando las respuestas de subproblemas anteriores para informar la solución del siguiente.

Construir los conjuntos de prueba

Para cada tarea, los investigadores crearon conjuntos de prueba con distintos niveles de dificultad.

Tarea 1: Manipulación simbólica (tarea de concatenación de la última letra):

• El conjunto de prueba para esta tarea implicó generar listas de palabras con longitudes variables para probar la capacidad del modelo de concatenar las últimas letras de cada palabra de la lista.
• Los investigadores utilizaron una lista de las 10,000 palabras en inglés más comunes de Wiktionary, excluyendo palabras obscenas, obteniendo una lista de 9,694 palabras.
• Para cada tamaño de lista deseado (de 4 a 12 palabras), generaron 500 secuencias aleatorias de estas palabras. Cada secuencia sirvió como entrada, y la salida correspondiente era la secuencia de las últimas letras de las palabras.

Tarea 2: Generalización composicional (benchmark SCAN):

• El benchmark SCAN consta de comandos en lenguaje natural que deben mapearse a secuencias de acciones. El conjunto de prueba desafía al modelo a generalizar de secuencias de acciones más cortas a más largas.
• Los investigadores utilizaron las divisiones existentes del conjunto de datos SCAN, centrándose particularmente en la división por longitud, que contiene secuencias de acciones más largas que las del conjunto de entrenamiento.
• También se aseguraron de que el conjunto de prueba cubriera una variedad de comandos para evaluar la capacidad del modelo para manejar diferentes tipos de generalización composicional.

Tarea 3: Razonamiento matemático (conjuntos de datos GSM8K y DROP):

• Para el razonamiento matemático, los investigadores utilizaron problemas con palabras del conjunto de datos GSM8K y el subconjunto de razonamiento numérico del conjunto de datos DROP.
• El conjunto de prueba incluyó problemas que requerían un número variable de pasos de razonamiento para resolver, lo que permitió a los investigadores evaluar qué tan bien podía generalizar el modelo desde problemas más simples a otros más complejos.
• Los problemas se seleccionaron para representar un rango de niveles de dificultad y para asegurar que algunos problemas requirieran más pasos que los demostrados en las indicaciones.

Al construir conjuntos de prueba de esta manera, los investigadores pudieron evaluar rigurosamente la estrategia de indicación de lo más simple a lo más complejo y comparar su efectividad con las técnicas de indicación estándar en diferentes tareas de razonamiento.

Ejecutar experimentos y recopilar resultados

Los investigadores realizaron experimentos utilizando el modelo GPT-3 (específicamente la versión code-davinci-002) con ambas estrategias de indicación. Registraron la precisión de las respuestas del modelo en los conjuntos de prueba.

Analizar los resultados

Los investigadores compararon el rendimiento del modelo utilizando diferentes estrategias de indicación. Observaron la precisión general y también desglosaron los resultados según la cantidad de pasos de razonamiento necesarios para resolver los problemas.

Análisis de errores

Para la indicación de lo más simple a lo más complejo, los investigadores realizaron un análisis detallado de errores para comprender los errores comunes, como la descomposición incorrecta de problemas o la resolución incorrecta de subproblemas.

¿Cuánto mejor es el rendimiento de los LLM con la indicación de lo más simple a lo más complejo?

El artículo “Least-To-Most Prompting Enables Complex Reasoning in Large Language Models” demuestra la efectividad de la indicación de lo más simple a lo más complejo en varias tareas y compara su rendimiento con la indicación de cadena de pensamiento y los métodos de indicación estándar. A continuación, se presenta un resumen de las mejoras de rendimiento para cada tarea según lo detallado en el artículo:

Manipulación simbólica (tarea de concatenación de la última letra):

La indicación de lo más simple a lo más complejo superó significativamente a la indicación de cadena de pensamiento, especialmente cuando aumentaba la longitud de las listas de palabras.

Para listas con longitudes que oscilaban entre 4 y 12 palabras, la precisión de la indicación de lo más simple a lo más complejo con el modelo GPT-3 code-davinci-002 osciló entre 74.0% y 94.0%, que fue sustancialmente más alta que la precisión de la indicación de cadena de pensamiento, que osciló entre 31.8% y 84.2%.

Generalización composicional (benchmark SCAN):

La indicación de lo más simple a lo más complejo alcanzó una precisión del 99.7% en la condición de división por longitud utilizando solo 14 ejemplares, un resultado notable considerando que los modelos neuro-simbólicos especializados entrenados en todo el conjunto de datos de más de 15,000 ejemplos a menudo tienen dificultades con esta tarea.

En contraste, la indicación de cadena de pensamiento alcanzó solo un 16.2% de precisión con el mismo modelo en la condición de división por longitud.

Razonamiento matemático (conjuntos de datos GSM8K y DROP):

En el conjunto de datos GSM8K, la indicación de lo más simple a lo más complejo mejoró ligeramente respecto a la indicación de cadena de pensamiento, con una precisión general del 62.39% frente al 60.87% de la indicación de cadena de pensamiento.

Sin embargo, para problemas que requieren al menos 5 pasos para resolver, la indicación de lo más simple a lo más complejo mostró una mejora significativa, con una precisión del 45.23% frente al 39.07% de la indicación de cadena de pensamiento.

En el conjunto de datos DROP, la indicación de lo más simple a lo más complejo superó ampliamente a la indicación de cadena de pensamiento, con precisiones del 82.45% y 74.77% para los subconjuntos de no fútbol y fútbol, respectivamente, frente al 58.78% y 59.56% de la indicación de cadena de pensamiento.

Estos resultados indican que la indicación de lo más simple a lo más complejo es particularmente efectiva en tareas que requieren que el modelo generalice desde ejemplos más simples a problemas más complejos. La estrategia de descomponer problemas complejos en una serie de subproblemas más simples y resolverlos secuencialmente permite que el modelo alcance tasas de precisión más altas en diferentes tareas de razonamiento.

¿Cómo integrar la indicación de lo más simple a lo más complejo en mi propio LLM?

Basándonos en los enfoques presentados por los autores de “Least-To-Most Prompting Enables Complex Reasoning in Large Language Models”, creamos esta guía paso a paso para ti:

Paso 1: Obtener una API de LLM

Primero, necesitas tener acceso a un LLM que puedas usar para tu tarea. Novita AI LLM API proporciona a los desarrolladores muchas opciones de LLM rentables, incluyendo Llama3–8b, Llama3–70b, Mythomax-13b, etc.

Aquí hay un ejemplo de cómo hacer una llamada a la API de Chat Completion con Novita AI LLM API:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.novita.ai/v3/openai",
    # Obtén la clave API de Novita AI consultando: https://novita.ai/get-started/Quick_Start.html#_3-create-an-api-key
    api_key="<TU Clave API de Novita AI>",
)

model = "Nous-Hermes-2-Mixtral-8x7B-DPO"
stream = True # o False
max_tokens = 512

chat_completion_res = client.chat.completions.create(
    model=model,
    messages=[
        {
            "role": "system",
            "content": "Actúa como si fueras un asistente útil.",
        },
        {
            "role": "user",
            "content": "¡Hola!",
        }
    ],
    stream=stream,
    max_tokens=max_tokens,
 )

if stream:
    for chunk in chat_completion_res:
        print(chunk.choices[0].delta.content or "", end="")
else:
    print(chat_completion_res.choices[0].message.content)

Paso 2: Preparar la indicación para la descomposición

Crea un conjunto de ejemplos de indicaciones que demuestren cómo descomponer un problema complejo en una serie de subproblemas más simples. Los ejemplos deben mostrar la estructura de la descomposición, pero no necesariamente el contenido específico de los subproblemas.

Paso 3: Preparar la indicación para la resolución de subproblemas

Crea un conjunto de ejemplos de indicaciones que demuestren cómo resolver los subproblemas individuales. Estos ejemplos deben mostrar el proceso de construcción de la solución paso a paso, utilizando los resultados de subproblemas resueltos previamente.

Paso 4: Implementar el algoritmo de indicación de lo más simple a lo más complejo

Los pasos clave en el algoritmo de indicación de lo más simple a lo más complejo son:
a. Pasar el problema original a la indicación de descomposición y obtener la lista de subproblemas.
b. Para cada subproblema, construir una indicación que incluya las soluciones de subproblemas anteriores (si las hay) y el subproblema actual, y pasarla al LLM para obtener la solución.
c. Combinar las soluciones de los subproblemas para obtener la solución final al problema original.

Paso 5: Integrar con tu aplicación

Incorpora el algoritmo de indicación de lo más simple a lo más complejo en el flujo de trabajo de tu aplicación. Esto puede implicar preprocesar la entrada, construir las indicaciones, llamar a la API del LLM y posprocesar las salidas.

Paso 6: Evaluar e iterar

Prueba tu implementación en una variedad de tareas y dificultades de problemas. Analiza los errores y refina el diseño de tus indicaciones o el algoritmo de indicación según sea necesario.

Este es un ejemplo de alto nivel creado por un LLM, y es posible que necesites adaptarlo a tu caso de uso y LLM específicos.

import openai

# Configurar la clave API de Novita AI
openai.api_key = "<TU Clave API de Novita AI>"
openai.base_url = "https://api.novita.ai/v3/openai"

def decomp_prompt(original_problem):
    """
    Genera una indicación para descomponer el problema original en una serie de subproblemas.

    Args:
        original_problem (str): El problema original a descomponer.

    Returns:
        str: La indicación para descomponer el problema.
    """
    return f"""
    Por favor, descomponga el siguiente problema en una serie de subproblemas que se puedan resolver paso a paso:
    {original_problem}
    
    Subproblemas:
    {{{decomp_steps}}}
    """

def solve_prompt(prev_solutions, subproblem):
    """
    Genera una indicación para resolver un subproblema específico, dados los subproblemas resueltos anteriormente.

    Args:
        prev_solutions (str): Los subproblemas resueltos anteriormente.
        subproblem (str): El subproblema a resolver.

    Returns:
        str: La indicación para resolver el subproblema.
    """
    return f"""
    Dados los siguientes subproblemas resueltos anteriormente:
    {prev_solutions}
    
    Por favor, resuelva el siguiente subproblema:
    {subproblem}
    """

def solve_problem(original_problem):
    """
    Resuelve el problema original utilizando el algoritmo de indicación de lo más simple a lo más complejo.

    Args:
        original_problem (str): El problema original a resolver.

    Returns:
        list: Una lista de soluciones para los subproblemas.
    """
    # Descomponer el problema original en subproblemas
    decomp_result = openai.Completion.create(
        engine="text-davinci-002",
        prompt=decomp_prompt(original_problem),
        max_tokens=1024,
        n=1,
        stop=None,
        temperature=0.7,
    )
    decomp_steps = decomp_result.choices[0].text.strip()

    # Resolver los subproblemas uno por uno
    solutions = []
    for step in decomp_steps.split("\n"):
        step = step.strip()
        if step:
            solve_result = openai.Completion.create(
                engine="text-davinci-002",
                prompt=solve_prompt("\n".join(solutions), step),
                max_tokens=1024,
                n=1,
                stop=None,
                temperature=0.7,
            )
            solutions.append(solve_result.choices[0].text.strip())

    return solutions

# Ejemplo de uso
original_problem = "Resuelve un problema matemático complejo paso a paso."
solutions = solve_problem(original_problem)
print("\n".join(solutions))

¿Cuáles son las limitaciones de la indicación de lo más simple a lo más complejo?

Especificidad de dominio:

Las indicaciones de descomposición a menudo se adaptan a dominios específicos y pueden no generalizarse bien a diferentes tipos de problemas. Una indicación que funciona bien para problemas matemáticos con palabras puede no ser efectiva para problemas de razonamiento de sentido común o de otros dominios.

Desafío de generalización intra-dominio:

Incluso dentro del mismo dominio, generalizar el proceso de descomposición puede ser difícil. Las indicaciones deben diseñarse cuidadosamente para demostrar la descomposición correcta para que el modelo alcance un rendimiento óptimo.

Complejidad de la descomposición:

Algunos problemas complejos pueden requerir una comprensión sofisticada de cómo desglosarlos en subproblemas más simples. Diseñar indicaciones que guíen eficazmente al modelo a través de este proceso puede ser un desafío.

Dependencia secuencial:

Los subproblemas generados en la indicación de lo más simple a lo más complejo a menudo son dependientes y deben resolverse en un orden específico. Este requisito secuencial puede hacer que el proceso de indicación sea más complejo en comparación con subproblemas independientes.

Propagación de errores:

Si el modelo comete un error en las primeras etapas de descomposición del problema o de resolución de subproblemas, este error puede propagarse a través de los pasos posteriores, lo que lleva a una solución final incorrecta.

Rendimiento específico del modelo:

El rendimiento de la indicación de lo más simple a lo más complejo puede variar entre diferentes modelos o versiones del mismo modelo. Algunos modelos pueden estar mejor adaptados para manejar la naturaleza iterativa y recursiva de la tarea.

Ingeniería de indicaciones:

La efectividad de la indicación de lo más simple a lo más complejo puede depender en gran medida de la calidad de la ingeniería de indicaciones. Crear indicaciones efectivas que conduzcan a una descomposición y generación de soluciones precisas requiere una cuidadosa consideración y experiencia.

Escalabilidad:

Si bien la indicación de lo más simple a lo más complejo puede ser efectiva, es posible que no escale tan bien a problemas muy grandes o altamente complejos debido al aumento de la dificultad para diseñar indicaciones apropiadas y el potencial de propagación de errores.

Falta de interacción bidireccional:

Los autores sugieren que la indicación, en general, podría no ser el método óptimo para enseñar habilidades de razonamiento a los LLM porque es una forma de comunicación unidireccional. Una progresión más natural podría implicar evolucionar la indicación hacia conversaciones completamente bidireccionales que permitan retroalimentación inmediata y un aprendizaje más eficiente.

Conclusión

Al descomponer problemas complejos en pasos más simples y resolverlos secuencialmente, los LLM con indicación de lo más simple a lo más complejo no solo mejoran su razonamiento, sino que también demuestran un rendimiento notable en diversas tareas, desde la manipulación simbólica hasta la generalización composicional y el razonamiento matemático.

Sin embargo, es importante reconocer los desafíos que acompañan a este método. La especificidad del dominio, las dificultades de generalización intra-dominio y la complejidad de la descomposición pueden presentar obstáculos. Además, la dependencia secuencial de los subproblemas y la posible propagación de errores subrayan la necesidad de una ingeniería de indicaciones cuidadosa y consideraciones específicas del modelo.

A medida que continuamos explorando nuevas fronteras en el desarrollo de la IA, la indicación de lo más simple a lo más complejo se destaca como una estrategia fundamental que permite a los LLM navegar los desafíos de tareas de razonamiento complejo con una precisión y eficiencia sin precedentes, al mismo tiempo que impulsa la investigación continua para optimizar su aplicación en diversos dominios problemáticos.

Referencias

Zhou, D., Schärli, N., Hou, L., Wei, J., Scales, N., Wang, X., Schuurmans, D., Cui, C., Bousquet, O., & Chi, E. (2023). Least-to-Most Prompting Enables Complex Reasoning in Large Language Models. En Proceedings of the International Conference on Learning Representations.

Novita AI es la plataforma integral en la nube que impulsa tus ambiciones de IA. Con API integradas sin problemas, computación sin servidor y aceleración de GPU, proporcionamos las herramientas rentables que necesitas para construir y escalar rápidamente tu negocio impulsado por IA. Elimina los dolores de cabeza de infraestructura y comienza gratis: Novita AI hace realidad tus sueños de IA.