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

Evaluaciones fuera de línea: mide antes de desplegar

Lección 14 de 16 Actualizado el 3 de noviembre de 2026 Avanzado
En esta página
  1. De casos aislados a la escala
  2. El modelo mental
  3. Una primera evaluación
  4. Dos tipos de evaluadores
  5. Comparar versiones
  6. Establecer objetivos
  7. Puntos clave

Lección reescrita el 2 de noviembre de 2026 basándose en la documentación de Offline evaluations de Mistral: las «Campañas» de la versión anterior y sus métodos campaigns.* ya no existen. La evaluación a gran escala utiliza ahora el SDK mistralai-evaluations, que ejecuta una tarea sobre un conjunto de datos, la puntúa con evaluadores y publica los resultados en Studio. Fuentes: Offline evaluations · Evaluators · Goals. Actualización del 3 de noviembre: mistralai-evaluations 0.9.1 requiere mistralai < 3 y sustituye el SDK 3.x por una versión 2.x cuando se instala junto a él; la lección recomienda usar un entorno dedicado (dependencias en PyPI).

De casos aislados a la escala

Un juez validado en veinte conversaciones no te dice nada sobre tu aplicación en su conjunto. Para decidir si un nuevo prompt, modelo o configuración es mejor que el actual, debes medirlo frente a un conjunto de casos representativo y consistente, y comparar los resultados. Esta es la función de las evaluaciones fuera de línea.

Estas están reservadas a organizaciones Enterprise y requieren Python 3.12 o superior:

pip install mistralai-evaluations

Instálalo en un entorno separado. La versión 0.9.1, la más reciente a 3 de noviembre de 2026, requiere mistralai 2.x (mistralai>=2.7.1,<3). En un entorno que ya contenga el SDK 3.x, pip lo desinstala e instala una versión 2.x, sin más advertencia que las líneas de su salida: verificado con mistralai 3.7.0, sustituido por 2.10.1. Un entorno virtual dedicado para evaluaciones evita regresiones en tu aplicación.

El modelo mental

El SDK sigue un flujo sencillo:

Dataset  →  Task  →  Evaluators  →  Results
  • Dataset: una lista de registros (diccionarios) o un dataset de Studio.
  • Task: una función, preferiblemente asíncrona, que recibe un TaskContext y produce una salida; este es el código que estás evaluando.
  • Evaluators: funciones que reciben un ScorerContext y puntúan cada salida.
  • Results: estadísticas y puntuaciones por registro, mostradas en el terminal y publicadas en Studio.

Una primera evaluación

import asyncio
import os

from mistralai.evaluations import (
    Evaluation, Evaluator, Goal, Mistral, Project, ScorerContext, System, TaskContext,
)

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

dataset = [
    {"ticket": "I haven't been able to log in since this morning.", "categorie": "acces"},
    {"ticket": "My October invoice charges the same subscription twice.", "categorie": "facturation"},
    {"ticket": "The PDF export crashes as soon as the report exceeds 50 pages.", "categorie": "bug"},
]


async def tache(ctx: TaskContext) -> str:
    response = await client.chat.complete_async(
        model=str(ctx.system.params["model"]),
        messages=[
            {"role": "system", "content": str(ctx.system.params["system_prompt"])},
            {"role": "user", "content": ctx.input_record["ticket"]},
        ],
    )
    return str(response.choices[0].message.content)


def exactitude(ctx: ScorerContext) -> int:
    return 1 if ctx.input_record["categorie"] == str(ctx.output).strip().lower() else 0


async def main():
    run = await client.evaluation.run(
        project=Project(name="Tri des tickets"),
        evaluation=Evaluation(name="Exactitude du classement"),
        system=System(name="small-prompt-v1", params={
            "model": "mistral-small-latest",
            "system_prompt": "Classe le ticket : acces, facturation ou bug. Réponds par le seul mot.",
        }),
        dataset=dataset,
        task=tache,
        evaluators=[
            Evaluator(
                name="exactitude",
                description="1 si la catégorie prédite est la bonne, 0 sinon.",
                scorer=exactitude,
                goal=Goal.gte(0.8),
            ),
        ],
    )
    run.show(level="records")


asyncio.run(main())

Los resultados aparecen en el terminal y se publican en Studio bajo Observability > Evaluate > Evaluations. El SDK calcula la media, el mínimo, el máximo y la desviación estándar para cada evaluador.

Prefiere una tarea asíncrona para procesos de larga duración: una tarea síncrona se ejecuta en el bucle de eventos que también envía señales de latido (heartbeat) de la ejecución a Studio, y una llamada bloqueada durante varios minutos puede hacer que la ejecución se marque como cancelada.

Dos tipos de evaluadores

Un evaluador asocia un nombre, una descripción opcional, una función de puntuación y, si es necesario, un objetivo. La función puede ser:

  • Basada en reglas: un cálculo directo sobre la salida; exacto, rápido y gratuito.
  • Un juez LLM: una función que llama a un modelo para puntuar aquello que es difícil de codificar: utilidad, precisión factual, tono.
JUDGE_PROMPT = """Tu es un correcteur exigeant. Note de 0 à 5 l'utilité de la réponse
pour la request ci-dessous. Réponds par le seul chiffre.

Demande : {request}
Réponse : {response}
"""


def judge_utility(ctx: ScorerContext) -> int:
    response = client.chat.complete(
        model="mistral-large-latest",
        messages=[{"role": "user", "content": JUDGE_PROMPT.format(
            request=ctx.input_record["ticket"], response=ctx.output)}],
        temperature=0,
    )
    raw = str(response.choices[0].message.content).strip()
    return int(raw[0]) if raw[:1].isdigit() else 0

Puedes mezclar libremente ambos tipos en una sola ejecución: pásalos juntos en la lista evaluators. Un evaluador también puede devolver una cadena o un booleano; en ese caso, el SDK produce una distribución de frecuencias en lugar de medias.

Comparar versiones

El objeto System captura la configuración de la tarea: modelo, temperatura, prompt de sistema o cualquier otro ajuste, en un diccionario de forma libre. Cada ejecución registra su System, y Studio te permite comparar ejecuciones lado a lado. Para decidir entre dos prompts o dos modelos, vuelve a ejecutar la misma evaluación con dos objetos System diferentes, sin tocar el código de la tarea.

Establecer objetivos

Un objetivo convierte una puntuación en un veredicto PASS o FAIL: Goal.gte(0.8) exige una media de al menos 0,8, Goal.lte(...) establece un techo y Goal.between(...) define un rango. Cada objetivo se dirige a la media por defecto, o a otra estadística mediante metric ("min", "max", "std"): Goal.gte(0.8, metric="min") exige que cada registro alcance 0,8. Esto es lo que convierte una evaluación en una barrera de seguridad: una nueva versión que haga caer una puntuación por debajo de su objetivo no pasa a producción.

Puntos clave

  • Las evaluaciones fuera de línea (mistralai-evaluations, Python 3.12+, organizaciones Enterprise) sustituyen a las antiguas Campañas.
  • Dataset, tarea, evaluadores, resultados: client.evaluation.run(...) encadena todo y publica en Studio.
  • Los evaluadores son funciones: reglas exactas o jueces LLM, combinables libremente.
  • System registra la configuración evaluada y permite la comparación de versiones.
  • Los objetivos (Goal.gte, Goal.lte, Goal.between) proporcionan veredictos PASS o FAIL.