Implementar salidas predichas en Python
En esta página
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
predictionsimplemente se añade a la llamadachat.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