Monitorización de aplicaciones de Inteligencia Artificial Generativa en producción

Importante

Esta característica se encuentra en su versión beta. Los administradores del área de trabajo pueden controlar el acceso a esta característica desde la página Vistas previas . Consulte Administrar Azure Databricks versiones preliminares.

La supervisión de producción le permite ejecutar automáticamente evaluadores de MLflow 3 en rastros de tus aplicaciones GenAI para evaluar continuamente la calidad. Usted programa puntuadores contra un experimento de MLflow, y el servicio de supervisión evalúa una muestra configurable de trazas entrantes. Los resultados se adjuntan como retroalimentación a cada traza evaluada.

La supervisión de producción incluye lo siguiente:

• Evaluación automatizada de la calidad mediante puntuadores integrados o personalizados, incluidos jueces de múltiples turnos para evaluar conversaciones enteras.
• Velocidades de muestreo configurables para que pueda controlar el equilibrio entre la cobertura y el costo computacional.
• Use los mismos puntuadores en desarrollo y producción para garantizar una evaluación coherente.
• Evaluación continua de la calidad con supervisión ejecutándose en segundo plano.

Nota:

La supervisión de producción de MLflow 3 es compatible con los seguimientos registrados en MLflow 2.

Prerrequisitos

Antes de configurar la supervisión de producción, asegúrese de que tiene:

• Experimento de MLflow: un experimento de MLflow donde se registran las trazas. Si no se especifica ningún experimento, se usa el experimento activo.
• Aplicación de producción instrumentada: Su aplicación GenAI debe registrar trazas usando MLflow Tracing. Consulte la guía de seguimiento de producción.
• Puntuadores definidos: Puntuadores probados que funcionan con el formato de trazado de la aplicación. Si usó su aplicación de producción como predict_fn en mlflow.genai.evaluate() durante el desarrollo, es probable que sus evaluadores ya sean compatibles.

• Identificador de almacén SQL (para seguimientos de Unity Catalog): Si los seguimientos se almacenan en Unity Catalog, debe configurar un identificador de almacén SQL para que la supervisión funcione. Consulte Habilitación de la supervisión de producción.

Empieza ahora

Para configurar la supervisión de producción, registre un marcador con el experimento de MLflow y, a continuación, inícielo con una configuración de muestreo. Este patrón de dos pasos (.register() a continuación .start()) se aplica a todos los tipos de puntuación.

Nota:

En un momento dado, se pueden asociar al máximo 20 puntuadores con un experimento para la supervisión continua de la calidad.

Para obtener más información sobre los puntuadores, consulte lo siguiente:

• Puntuadores y jueces LLM
• Jueces personalizados
• Creación de puntuadores basados en código personalizados

En las secciones siguientes se describe cómo usar los diferentes tipos de jueces y cómo combinarlos. Expanda una sección para obtener más información.

Crear y programar jueces LLM mediante la interfaz de usuario

Cree y programe jueces LLM mediante la interfaz de usuario

Puede utilizar la interfaz de usuario del experimento de MLflow para crear y probar evaluadores basados en jueces de LLM.

Para crear un nuevo juez LLM:

1. Vaya a la pestaña Jueces en la interfaz de usuario del experimento de MLflow.

   

2. Haga clic en Nuevo juez LLM.

   

3. Especifique lo que evaluará el puntuador seleccionando Seguimientos o Sesiones.

4. Escriba un nombre para el juez.

5. Haga clic en la flecha como se muestra para mostrar la sección Criterios de evaluación .

   

6. En el menú desplegable, seleccione el tipo de juez. Algunos tipos de juez permiten escribir instrucciones personalizadas, incluidas las variables.

7. Haga clic en la flecha como se muestra para mostrar la sección Evaluación automática .

   

8. Establezca el interruptor Ejecutar en todos los seguimientos futuros según sea necesario.

9. (Opcional) En Configuración avanzada, ajuste la frecuencia de muestreo y la cadena Filter para controlar qué seguimientos se evalúan.

10. (Opcional) Para probar el nuevo juez en un conjunto de trazas existentes:

    1. Haga clic en Seleccionar trazas en el panel izquierdo. Aparecerá una ventana emergente.
    2. Seleccione los seguimientos que se van a ejecutar y haga clic en Seleccionar (n).
    3. Haga clic en Run judge. Los rastros se evalúan y se muestran los resultados.
    4. Consulte los resultados. Use los botones Siguiente y Anterior para recorrer los resultados de cada seguimiento seleccionado.
    5. Si es necesario, edita el juez e itera hasta que estés satisfecho con el rendimiento del juez.

11. Para crear el juez, haga clic en Crear juez.

No se puede crear un juez de código personalizado mediante la interfaz de usuario. Para ver el código de plantilla que puede copiar en el cuaderno y editar según sea necesario, haga lo siguiente:

1. Haga clic en la flecha desplegable situada junto al botón Nuevo juez LLM y seleccione Juez de código personalizado.

   

2. Aparece una ventana emergente con instrucciones y código de plantilla que muestran cómo definir y ejecutar un juez de código personalizado.

Usa jueces de LLM integrados

Uso de jueces LLM integrados

MLflow proporciona varios jueces LLM integrados que puede usar directamente.

from mlflow.genai.scorers import Safety, ScorerSamplingConfig

# Register the scorer with a name and start monitoring
safety_judge = Safety().register(name="my_safety_judge")  # name must be unique to experiment
safety_judge = safety_judge.start(sampling_config=ScorerSamplingConfig(sample_rate=0.7))

De forma predeterminada, cada juez usa un LLM hospedado en Databricks diseñado para realizar evaluaciones de calidad de GenAI. Puede cambiar el modelo de juez para que en su lugar use un endpoint de servicio del modelo de Databricks mediante el argumento model en la definición del evaluador. El modelo debe especificarse con el formato databricks:/<databricks-serving-endpoint-name>.

safety_judge = Safety(model="databricks:/databricks-gpt-oss-20b").register(name="my_custom_safety_judge")

Directrices de uso para jueces de LLM

Directrices para el uso por jueces del LLM (Modelo de Lenguaje Extenso)

Los jueces de LLM según las directrices evalúan las entradas y salidas utilizando criterios de lenguaje natural para aprobar o desaprobar.

from mlflow.genai.scorers import Guidelines

# Create and register the guidelines scorer
english_judge = Guidelines(
  name="english",
  guidelines=["The response must be in English"]
).register(name="is_english")  # name must be unique to experiment

# Start monitoring with the specified sample rate
english_judge = english_judge.start(sampling_config=ScorerSamplingConfig(sample_rate=0.7))

Al igual que los jueces integrados, puede cambiar el modelo de juez para que use un punto de conexión de servicio del modelo de Databricks.

english_judge = Guidelines(
  name="english",
  guidelines=["The response must be in English"],
  model="databricks:/databricks-gpt-oss-20b",
).register(name="custom_is_english")

Uso de jueces de LLM con avisos personalizados

Utilizar jueces de LLM con indicaciones personalizadas

Para obtener más flexibilidad que los jueces de directrices, use jueces de LLM con indicaciones personalizadas que permiten una evaluación de calidad de varios niveles con categorías de opciones personalizables.

from typing import Literal
from mlflow.genai import make_judge
from mlflow.genai.scorers import ScorerSamplingConfig

# Create a custom judge using make_judge
formality_judge = make_judge(
    name="formality",
    instructions="""You will look at the response and determine the formality of the response.

Request: {{ inputs }}
Response: {{ outputs }}

Evaluate whether the response is formal, somewhat formal, or not formal.
A response is somewhat formal if it mentions friendship, etc.""",
    feedback_value_type=Literal["formal", "semi_formal", "not_formal"],
    model="databricks:/databricks-gpt-oss-20b",  # optional
)

# Register the custom judge and start monitoring
registered_judge = formality_judge.register(name="my_formality_judge")  # name must be unique to experiment
registered_judge = registered_judge.start(sampling_config=ScorerSamplingConfig(sample_rate=0.1))

Uso de funciones de puntuación personalizadas

Uso de funciones de puntuación personalizadas

Para obtener la máxima flexibilidad, defina y use una función de puntuación personalizada.

:::importante Requisitos del puntuador personalizado para la supervisión de producción

• Solo @scorer se admiten los puntuadores basados en decoradores. Las subclases basadas en Scorer clases no se pueden registrar para la supervisión de producción. Si necesita un evaluador basado en clases, debería refactorizarlo para usar el decorador @scorer en su lugar.
• Los puntuadores deben definirse y registrarse desde un cuaderno de Databricks. El servicio de supervisión serializa el código de la función de evaluación para la ejecución remota, y esta serialización requiere el entorno de un notebook. Los puntuadores definidos en archivos Python independientes o entornos IDE locales no se pueden serializar para la supervisión de producción.
• Los puntuadores deben ser independientes. Dado que las funciones del puntuador se serializan como código para la ejecución remota, todas las importaciones deben realizarse en línea dentro del cuerpo de la función. La función no puede hacer referencia a variables, objetos o módulos definidos fuera de ella.

:::

Al definir los puntuadores personalizados, no use sugerencias de tipo que se deben importar en la firma de función. Si el cuerpo de la función de puntuación usa paquetes que deben importarse, importe en línea estos paquetes dentro de la función para garantizar la serialización adecuada.

Algunos paquetes están disponibles de forma predeterminada sin necesidad de una importación en línea. Estos incluyen databricks-agents, mlflow-skinny, openaiy todos los paquetes incluidos en la versión 2 del entorno sin servidor.

from mlflow.genai.scorers import scorer, ScorerSamplingConfig


# Custom metric: Check if response mentions Databricks
@scorer
def mentions_databricks(outputs):
    """Check if the response mentions Databricks"""
    return "databricks" in str(outputs.get("response", "")).lower()

# Register and start monitoring
databricks_scorer = mentions_databricks.register(name="databricks_mentions")
databricks_scorer = databricks_scorer.start(sampling_config=ScorerSamplingConfig(sample_rate=0.5))

Para obtener más ejemplos de puntuadores personalizados, consulte Creación de puntuadores basados en código personalizados.

Uso de jueces multiturno

Uso de jueces de múltiples turnos

La supervisión de producción admite jueces multiturno que evalúan conversaciones completas en lugar de seguimientos individuales. Estos jueces evalúan los patrones de calidad en varias interacciones, como la frustración del usuario y la integridad de la conversación. Los jueces multiturno se registran e inician de la misma manera que los jueces de un solo turno.

El trabajo de supervisión agrupa automáticamente las trazas en conversaciones en función de la etiqueta mlflow.trace.session. Los jueces de múltiples turnos se ejecutan después de que una conversación se considere completada; de forma predeterminada, se completa una conversación cuando no se ingieren nuevos rastros con ese identificador de sesión durante 5 minutos. Para configurar este búfer, establezca la MLFLOW_ONLINE_SCORING_DEFAULT_SESSION_COMPLETION_BUFFER_SECONDS variable de entorno en el trabajo de supervisión.

Para obtener la lista completa de los jueces multiturno disponibles, consulte Jueces multiturno. Para obtener más información sobre la evaluación de la conversación, consulte Evaluación de conversaciones.

Nota:

Para utilizar jueces de múltiples turnos, el agente debe asignar identificadores de sesión a las trazas. Consulte Seguimiento de usuarios y sesiones para obtener más información.

from mlflow.genai.scorers import (
    ConversationCompleteness,
    UserFrustration,
    ScorerSamplingConfig,
)

# Register and start multi-turn judges just like single-turn judges
completeness_scorer = ConversationCompleteness().register(name="conversation_completeness")
completeness_scorer = completeness_scorer.start(
    sampling_config=ScorerSamplingConfig(sample_rate=1.0),
)

frustration_scorer = UserFrustration().register(name="user_frustration")
frustration_scorer = frustration_scorer.start(
    sampling_config=ScorerSamplingConfig(sample_rate=1.0),
)

Combinar jueces

Combinar jueces

Puede combinar jueces de un solo turno y jueces de varios turnos en el mismo experimento. Registre e inicie cada marcador individualmente.

from mlflow.genai.scorers import Safety, Guidelines, UserFrustration, ScorerSamplingConfig

# Single-turn judges
safety_judge = Safety().register(name="safety")
safety_judge = safety_judge.start(sampling_config=ScorerSamplingConfig(sample_rate=1.0))

english_judge = Guidelines(
    name="english",
    guidelines=["The response must be in English"]
).register(name="is_english")
english_judge = english_judge.start(sampling_config=ScorerSamplingConfig(sample_rate=0.5))

# Multi-turn judge
frustration_judge = UserFrustration().register(name="frustration")
frustration_judge = frustration_judge.start(sampling_config=ScorerSamplingConfig(sample_rate=0.3))

Vista de resultados

Después de programar los puntuadores, permita entre 15 y 20 minutos para el procesamiento inicial. A continuación:

1. Acceda al experimento de MLflow.
2. Abra la pestaña Trazas para ver las evaluaciones adjuntas a las trazas.
3. Use los paneles de supervisión para realizar un seguimiento de las tendencias de calidad.

En el caso de los jueces multiturno, las evaluaciones se adjuntan al primer seguimiento de cada sesión. Consulte How assessments are stored (Cómo se almacenan las evaluaciones ) para obtener más información.

procedimientos recomendados

Estrategia de muestreo

• Para los puntuadores críticos, como las comprobaciones de seguridad y protección, use sample_rate=1.0.

• Para los puntuadores costosos, como los jueces de LLM complejos, use tasas de muestreo más bajas (0,05-0,2).

• Para una mejora iterativa durante el desarrollo, use tasas moderadas (0,3-0,5).

• Equilibre la cobertura con costo, como se muestra en los ejemplos siguientes:

  # High-priority scorers: higher sampling
  safety_judge = Safety().register(name="safety")
  safety_judge = safety_judge.start(sampling_config=ScorerSamplingConfig(sample_rate=1.0))  # 100% coverage for critical safety
  
  # Expensive scorers: lower sampling
  complex_scorer = ComplexCustomScorer().register(name="complex_analysis")
  complex_scorer = complex_scorer.start(sampling_config=ScorerSamplingConfig(sample_rate=0.05))  # 5% for expensive operations
  

Filtrar seguimientos

Utiliza el parámetro filter_string en ScorerSamplingConfig para controlar qué rastros evalúa un puntuador. Esto usa la misma sintaxis de filtro que mlflow.search_traces().

from mlflow.genai.scorers import Safety, ScorerSamplingConfig

# Only evaluate traces that completed successfully
safety_judge = Safety().register(name="safety")
safety_judge = safety_judge.start(
    sampling_config=ScorerSamplingConfig(
        sample_rate=1.0,
        filter_string="attributes.status = 'OK'"
    ),
)

Puede combinar varias condiciones:

import time

# Evaluate successful traces from the last 24 hours
one_day_ago = int((time.time() - 86400) * 1000)
safety_judge = safety_judge.start(
    sampling_config=ScorerSamplingConfig(
        sample_rate=0.5,
        filter_string=f"attributes.status = 'OK' AND attributes.timestamp_ms > {one_day_ago}"
    ),
)

Diseño del puntuador personalizado

Mantenga independientes los puntuadores personalizados, como se muestra en el ejemplo siguiente:

@scorer
def well_designed_scorer(inputs, outputs):
    # All imports inside the function
    import re
    import json

    # Handle missing data gracefully
    response = outputs.get("response", "")
    if not response:
        return 0.0

    # Return consistent types
    return float(len(response) > 100)

Solución de problemas

Los puntuadores no están en ejecución

Si los evaluadores no están funcionando, compruebe lo siguiente:

1. Comprobar Experimento: asegúrese de que los rastros se registran en el experimento, no en las ejecuciones individuales.
2. Frecuencia de muestreo: con tasas de muestreo bajas, puede tardar tiempo en ver los resultados.
3. Comprobar cadena de filtro: asegúrese de que filter_string coincide con las trazas reales.

Problemas de serialización

Los puntuadores personalizados para la supervisión de producción se serializan para que el servicio de supervisión pueda ejecutarlo de forma remota. Esto impone varias restricciones:

• Requisito del cuaderno: las funciones personalizadas @scorer deben definirse y registrarse desde un cuaderno de Databricks. El mecanismo de serialización se basa en el entorno del cuaderno.
• Funciones independientes: todas las importaciones deben estar insertadas en el cuerpo de la función. Las referencias a variables externas, módulos o objetos definidos fuera de la función no se capturan durante la serialización.
• No hay puntuadores basados en clases: solo se pueden registrar @scorer los puntuadores basados en decoradores. Las subclases de Scorer, basadas en clases, no se pueden serializar para ejecución remota.
• Sin sugerencias de tipo que requieran importaciones: las sugerencias de tipo en la firma de función que requieren instrucciones de importación (por ejemplo, List desde typing) pueden provocar errores de serialización.

Al crear un evaluador personalizado, incluya las importaciones en la definición de función.

# Avoid external dependencies
import external_library  # Outside function

@scorer
def bad_scorer(outputs):
    return external_library.process(outputs)

# Include imports in the function definition
@scorer
def good_scorer(outputs):
    import json  # Inside function
    return len(json.dumps(outputs))

# Avoid using type hints in scorer function signature that requires imports
from typing import List

@scorer
def scorer_with_bad_types(outputs: List[str]):
    return False

# Class-based scorers are not supported for production monitoring
class MyScorer(Scorer):
    name: str = "my_scorer"
    def __call__(self, outputs):
        return len(outputs) > 10

Pasos siguientes

• Administrar los puntuadores de producción: Administre el ciclo de vida de sus puntuadores de producción.
• Relleno de trazas históricas con puntuadores: aplica de forma retroactiva los puntuadores a las trazas históricas.
• Archivar seguimientos en una tabla Delta : guarde seguimientos y evaluaciones en una tabla Delta.
• Crear puntuadores personalizados basados en código: construya puntuadores adaptados a sus necesidades.
• Evaluar conversaciones : obtenga información sobre la evaluación de conversaciones multiturno y los jueces de varios turnos.
• Creación de conjuntos de datos de evaluación de MLflow : use los resultados de la supervisión para mejorar la calidad.

Guías de referencia

• Referencia de API de administración del ciclo de vida del evaluador - referencia de API para la administración del ciclo de vida del evaluador.
• Puntuadores y jueces de LLM : comprenda las métricas que impulsan la supervisión.
• Evaluar GenAI durante el desarrollo - cómo se relaciona la evaluación offline con la producción.