Ir al contenido principal
Español— Elegir un idioma
Menú

Implementar salidas predichas en Python

Lección 7 de 16 Actualizado el 2 de noviembre de 2026 Avanzado
En esta página
  1. Del concepto al código de producción
  2. Implementación básica
  3. Clase de utilidad para producción
  4. Benchmark: con y sin predicción
  5. Gestión de errores
  6. Restricciones a tener en cuenta
  7. Puntos clave

Del concepto al código de producción

Ya conoces el principio de las salidas predichas y sus casos de uso. Esta lección te proporciona código Python completo, listo para integrar en tus aplicaciones, que incluye gestión de errores y medición del rendimiento.

Implementación básica

El patrón mínimo requiere un único parámetro: prediction, donde indicas el contenido esperado. Todo lo demás en la llamada permanece igual: el mismo modelo, los mismos mensajes y la misma gestión de la respuesta. Esto hace que la función sea fácil de adoptar y tan fácil de eliminar si las métricas no confirman la mejora:

from mistralai.client import Mistral

client = Mistral(api_key="your-api-key")

source_code = """
import pandas as pd

def load_data(filepath):
    df = pd.read_csv(filepath)
    df['date'] = pd.to_datetime(df['date'])
    df = df.dropna(subset=['value'])
    return df

def compute_stats(df):
    return {
        'mean': df['value'].mean(),
        'median': df['value'].median(),
        'std': df['value'].std()
    }
"""

prompt = (
    "Añade un parámetro 'separator' a la función load_data "
    "(por defecto ',') y úsalo en read_csv. "
    "Responde solo con el código modificado completo."
)

response = client.chat.complete(
    model="codestral-latest",
    messages=[
        {"role": "user", "content": prompt},
        {"role": "user", "content": source_code}
    ],
    prediction={"type": "content", "content": source_code}
)

modified_code = response.choices[0].message.content
print(modified_code)

Clase de utilidad para producción

La encapsulación aquí ofrece ventajas más allá de un código limpio: centraliza la decisión de activar o desactivar la predicción. Este es exactamente el tipo de configuración que querrás conmutar al instante. Si un despliegue revela predicciones incorrectas de forma consistente, puedes desactivarlas en un único punto en lugar de buscar el parámetro por todo tu código:

from mistralai.client import Mistral
import time
from dataclasses import dataclass


@dataclass
class PredictionResult:
    content: str
    latency_ms: float
    tokens_input: int
    tokens_output: int
    model: str


class PredictedEditor:
    """Editor de contenido que utiliza salidas predichas."""

    def __init__(self, api_key: str, model: str = "mistral-large-latest"):
        self.client = Mistral(api_key=api_key)
        self.model = model

    def edit(
        self,
        original: str,
        instruction: str,
        system_prompt: str | None = None
    ) -> PredictionResult:
        """Edita contenido con predicción de salida."""
        messages = []

        if system_prompt:
            messages.append({"role": "system", "content": system_prompt})

        messages.extend([
            {"role": "user", "content": instruction},
            {"role": "user", "content": original}
        ])

        start = time.perf_counter()

        response = self.client.chat.complete(
            model=self.model,
            messages=messages,
            prediction={"type": "content", "content": original}
        )

        latency = (time.perf_counter() - start) * 1000

        choice = response.choices[0]
        return PredictionResult(
            content=choice.message.content,
            latency_ms=round(latency, 1),
            tokens_input=response.usage.prompt_tokens,
            tokens_output=response.usage.completion_tokens,
            model=self.model
        )

    def edit_code(self, code: str, instruction: str) -> PredictionResult:
        """Atajo para edición de código."""
        return self.edit(
            original=code,
            instruction=instruction,
            system_prompt=(
                "Eres un asistente de programación. "
                "Responde solo con el código modificado, "
                "sin explicaciones ni markdown."
            )
        )

    def edit_text(self, text: str, instruction: str) -> PredictionResult:
        """Atajo para edición de texto."""
        return self.edit(
            original=text,
            instruction=instruction,
            system_prompt=(
                "Eres un editor de texto profesional. "
                "Aplica la modificación solicitada conservando "
                "el estilo y la estructura del texto original. "
                "Responde solo con el texto modificado."
            )
        )

Uso de la clase

editor = PredictedEditor(api_key="your-api-key", model="codestral-latest")

# Editar código
result = editor.edit_code(
    code=my_python_file,
    instruction="Sustituye todas las llamadas a print() por llamadas a logging.info()"
)

print(f"Latencia: {result.latency_ms} ms")
print(f"Tokens: {result.tokens_input} de entrada / {result.tokens_output} de salida")
print(result.content)

Benchmark: con y sin predicción

No saltes este paso. La mejora que aportan las salidas predichas depende enteramente de la precisión de tus predicciones, la cual depende de tus datos. Ninguna cifra de la documentación sustituye a la medición sobre tus propios ejemplos. Este script compara ambos modos con las mismas entradas y te da la respuesta en segundos:

import statistics

def benchmark_prediction(
    client, model, messages, prediction_content, runs=5
):
    """Compara la latencia con y sin salida predicha."""
    times_normal = []
    times_predicted = []

    for _ in range(runs):
        # Sin predicción
        start = time.perf_counter()
        client.chat.complete(model=model, messages=messages)
        times_normal.append((time.perf_counter() - start) * 1000)

        # Con predicción
        start = time.perf_counter()
        client.chat.complete(
            model=model,
            messages=messages,
            prediction={"type": "content", "content": prediction_content}
        )
        times_predicted.append((time.perf_counter() - start) * 1000)

    avg_normal = statistics.mean(times_normal)
    avg_predicted = statistics.mean(times_predicted)
    gain_pct = (1 - avg_predicted / avg_normal) * 100

    return {
        "without_prediction_ms": round(avg_normal, 1),
        "with_prediction_ms": round(avg_predicted, 1),
        "gain_percentage": round(gain_pct, 1),
        "runs": runs
    }

Gestión de errores

La gestión de errores es sencilla aquí por una razón estructural: una predicción incorrecta no es un error. El modelo la ignora y genera con normalidad; pierdes la mejora de latencia, nunca la calidad. Los casos límite reales están en otro sitio:

def safe_edit(editor, original, instruction):
    """Edición con gestión robusta de errores."""
    try:
        result = editor.edit(original, instruction)

        # Comprobar que la respuesta no está vacía
        if not result.content or len(result.content.strip()) < 10:
            raise ValueError("Respuesta demasiado corta o vacía")

        return result

    except Exception as e:
        # Fallback: reintentar sin predicción
        print(f"Salida predicha fallida ({e}), volviendo al modo estándar...")
        response = editor.client.chat.complete(
            model=editor.model,
            messages=[
                {"role": "user", "content": instruction},
                {"role": "user", "content": original}
            ]
        )
        return PredictionResult(
            content=response.choices[0].message.content,
            latency_ms=0,
            tokens_input=response.usage.prompt_tokens,
            tokens_output=response.usage.completion_tokens,
            model=editor.model
        )

Restricciones a tener en cuenta

Antes de desplegar, integra tres puntos en tu revisión de código. Primero, el parámetro n (generaciones múltiples) es incompatible con prediction. Si tu pipeline solicita varias completaciones, debes elegir. Segundo, la coincidencia entre la predicción y la salida la gestiona el modelo independientemente de la posición del contenido en la respuesta; no necesitas preparar ninguna alineación. Por último, y esto es lo que hace segura la función para su despliegue: una mala predicción nunca degrada la calidad de la respuesta; solo te cuesta la mejora de latencia. El peor de los casos es simplemente volver a la velocidad normal en los dos modelos compatibles (mistral-large-latest y codestral-latest).

Puntos clave

  • El parámetro prediction simplemente se añade a la llamada chat.complete()
  • Encapsula la lógica en una clase reutilizable para producción
  • Mide sistemáticamente la mejora con un benchmark antes de desplegar
  • Planifica un fallback sin predicción por si hay errores
  • Una mala predicción no degrada la calidad, solo la latencia