Este tutorial muestra cómo aplicar la técnica de Auto-Mejora (Self-Refine) utilizando modelos de lenguaje a gran escala (LLMs) con Mirascope, un potente framework para construir flujos de trabajo con prompts estructurados. La idea central de Self-Refine es que el propio modelo evalúe su respuesta, genere feedback y use esa retroalimentación para mejorarla de manera iterativa. Este ciclo de refinamiento puede repetirse varias veces para obtener respuestas cada vez más precisas y de mejor calidad.
Esta estrategia resulta especialmente útil en tareas que requieren razonamiento, generación de código o creación de contenido, donde pequeñas mejoras sucesivas logran resultados mucho más efectivos.
Para comenzar, es necesario instalar las dependencias con el comando:
``` !pip install "mirascope[openai]" ```
Luego, hay que obtener una API Key de OpenAI desde https://platform.openai.com/settings/organization/api-keys. Si eres nuevo, deberás agregar los datos de facturación y hacer un pago mínimo de $5 para activar el acceso.
Una vez configurado el entorno, podemos implementar una versión básica de Self-Refine usando los decoradores `@openai.call` y `@prompt_template` de Mirascope. El proceso: primero el modelo genera una respuesta inicial a una consulta, luego se evalúa esa respuesta para producir feedback, y por último, se genera una respuesta mejorada tomando en cuenta ese feedback. Esta iteración se puede repetir las veces que se desee mediante una función que controla la profundidad del refinamiento. Por ejemplo:
```python from mirascope.core import openai, prompt_template from mirascope.core.openai import OpenAICallResponse
@openai.call(model="gpt-4o-mini") def call(query: str) -> str: return query
@openai.call(model="gpt-4o-mini") @prompt_template(""" Aquí tienes una consulta y una respuesta. Da feedback sobre la respuesta, indicando lo correcto e incorrecto. Consulta: {query} Respuesta: {response} """) def evaluate_response(query: str, response: OpenAICallResponse): ...
@openai.call(model="gpt-4o-mini") @prompt_template(""" Para esta consulta: {query} Se dio la siguiente respuesta: {response} Aquí hay un feedback sobre esa respuesta: {feedback}
Usa el feedback para generar una nueva respuesta. """) def generate_new_response(query: str, response: OpenAICallResponse) -> openai.OpenAIDynamicConfig: feedback = evaluate_response(query, response) return {"computed_fields": {"feedback": feedback}}
def self_refine(query: str, depth: int) -> str: response = call(query) for _ in range(depth): response = generate_new_response(query, response) return response.content
query = "Un tren recorre 120 km a cierta velocidad. Si la velocidad fuera 20 km/h mayor, tardaría 30 minutos menos en recorrer la misma distancia. ¿Cuál era la velocidad original del tren?"
print(self_refine(query, 1)) ```
Además, se puede mejorar este proceso definiendo un modelo de respuesta estructurado para matemáticas usando Pydantic, que capture tanto los pasos de la solución como la respuesta numérica final. La versión mejorada crea respuestas más claras y consistentes, lo que es útil especialmente en problemas matemáticos o técnicos. Así:
```python from pydantic import BaseModel, Field
class MathSolution(BaseModel): steps: list[str] = Field(..., description="Los pasos para resolver el problema") final_answer: float = Field(..., description="La respuesta numérica final")
@openai.call(model="gpt-4o-mini", response_model=MathSolution) @prompt_template(""" Para esta consulta: {query} Se dio la siguiente respuesta: {response} Aquí hay un feedback sobre esa respuesta: {feedback}
Ten en cuenta el feedback para generar una nueva respuesta. Proporciona los pasos de la solución y la respuesta numérica final. """) def enhanced_generate_new_response(query: str, response: OpenAICallResponse) -> openai.OpenAIDynamicConfig: feedback = evaluate_response(query, response) return {"computed_fields": {"feedback": feedback}}
def enhanced_self_refine(query: str, depth: int) -> MathSolution: response = call(query) for _ in range(depth): solution = enhanced_generate_new_response(query, response) response = f"Pasos: {solution.steps}\nRespuesta Final: {solution.final_answer}" return solution
result = enhanced_self_refine(query, 1) print(result) ```
Con esta técnica mejorada, el modelo resolvió correctamente el problema del tren, mostrando un razonamiento claro y detallado y llegando a la respuesta correcta de 60 km/h tras una sola iteración de mejora.
En resumen, Self-Refine ofrece varios beneficios clave:
- Mayor precisión gracias a iteraciones basadas en feedback. - Explicaciones claras que facilitan la comprensión del proceso. - Transparencia y confianza en las respuestas generadas.
Este método es prometedor para tareas que requieren precisión, estructuración y mejoras continuas, desde problemas técnicos hasta escritura creativa y profesional. Eso sí, hay que considerar que cada ciclo de refinamiento implica un gasto computacional adicional, por lo que es importante ajustar la cantidad de iteraciones y los prompts según la necesidad del proyecto.
En definitiva, Self-Refine con Mirascope es una herramienta poderosa que aporta un enfoque iterativo para mejorar las respuestas generadas por los modelos de lenguaje.
