Compartir a través de

Cómo ejecutar una evaluación y visualizar los resultados

  • Artículo

Importante

Esta característica está en versión preliminar pública.

En este artículo se describe cómo ejecutar una evaluación y ver los resultados a medida que desarrolla la aplicación de inteligencia artificial. Para obtener información sobre cómo supervisar la calidad de los agentes implementados en el tráfico de producción, consulte Cómo supervisar la calidad del agente en el tráfico de producción.

Para usar la evaluación del agente durante el desarrollo de aplicaciones, debe especificar un conjunto de evaluación. Un conjunto de evaluación es un conjunto de solicitudes típicas que un usuario realizaría en la aplicación. El conjunto de evaluación también puede incluir la respuesta esperada (verdad básica) para cada solicitud de entrada. Si se proporciona la respuesta esperada, la evaluación del agente puede calcular métricas de calidad adicionales, como la corrección y la suficiencia del contexto. El propósito del conjunto de evaluación es ayudarle a medir y predecir el rendimiento de la aplicación agente al probarlo en preguntas representativas.

Para obtener más información sobre los conjuntos de evaluación, vea Conjuntos de evaluación. Para ver el esquema necesario, consulte Esquema de entrada de evaluación del agente.

Para comenzar la evaluación, use el método mlflow.evaluate() de la API de MLflow. mlflow.evaluate() calcula las evaluaciones de calidad junto con las métricas de latencia y costo para cada entrada del conjunto de evaluación y también agrega estos resultados en todas las entradas. Estos resultados también se conocen como resultados de evaluación. En el código siguiente se muestra un ejemplo de llamada a mlflow.evaluate():

%pip install databricks-agents
dbutils.library.restartPython()

import mlflow
import pandas as pd

eval_df = pd.DataFrame(...)

# Puts the evaluation results in the current Run, alongside the logged model parameters
with mlflow.start_run():
        logged_model_info = mlflow.langchain.log_model(...)
        mlflow.evaluate(data=eval_df, model=logged_model_info.model_uri,
                       model_type="databricks-agent")

En este ejemplo, mlflow.evaluate() registra sus resultados de evaluación en la ejecución de MLflow envolvente, junto con la información registrada por otros comandos (como parámetros de modelo). Si llama a mlflow.evaluate() fuera de una ejecución de MLflow, se inicia una nueva ejecución y se registran los resultados de la evaluación en esa ejecución. Para obtener más información sobre mlflow.evaluate(), incluidos los detalles sobre los resultados de evaluación que se registran en la ejecución, consulte la documentación de MLflow.

Requisitos

Las funciones de asistente de IA con tecnología de IA de Azure deben estar habilitadas para el área de trabajo.

Cómo proporcionar entrada a una ejecución de evaluación

Hay dos maneras de proporcionar entrada a una ejecución de evaluación:

  • Proporcione salidas generadas anteriormente para compararlas con el conjunto de evaluación. Esta opción se recomienda si deseas evaluar las salidas de una aplicación que ya está implementada en producción, o si deseas comparar los resultados de evaluación entre configuraciones de evaluación.

    Con esta opción, se especifica un conjunto de evaluación como se muestra en el código siguiente. El conjunto de evaluación debe incluir salidas generadas anteriormente. Para obtener ejemplos más detallados, vea Ejemplo: Cómo pasar salidas generadas previamente a la evaluación del agente.

    evaluation_results = mlflow.evaluate(
    data=eval_set_with_chain_outputs_df,  # pandas DataFrame with the evaluation set and application outputs
    model_type="databricks-agent",
)

  • Pase la aplicación como argumento de entrada.mlflow.evaluate() llama a la aplicación para cada entrada del conjunto de evaluación e informa de las evaluaciones de calidad y otras métricas para cada salida generada. Esta opción se recomienda si la aplicación se registró con MLflow con seguimiento de MLflow habilitado, o si la aplicación se implementa como una función de Python en un cuaderno. Esta opción no se recomienda si la aplicación se desarrolló fuera de Databricks o se implementa fuera de Databricks.

    Con esta opción, se especifica el conjunto de evaluación y la aplicación en la llamada de función como se muestra en el código siguiente. Para obtener ejemplos más detallados, vea Ejemplo: Cómo pasar una aplicación a la evaluación del agente.

    evaluation_results = mlflow.evaluate(
    data=eval_set_df,  # pandas DataFrame containing just the evaluation set
    model=model,  # Reference to the MLflow model that represents the application
    model_type="databricks-agent",
)

Para obtener más información sobre el esquema del conjunto de evaluación, consulte Esquema de entrada de evaluación del agente.

Salidas de ejecución de evaluación

La evaluación del agente devuelve sus salidas de como tramas de mlflow.evaluate() datos y también registra estas salidas en la ejecución de MLflow. Puede inspeccionar las salidas en el cuaderno o desde la página de la ejecución de MLflow correspondiente.

Revisión de la salida en el cuaderno

En el código siguiente se muestran algunos ejemplos de cómo revisar los resultados de una ejecución de evaluación desde el cuaderno.

%pip install databricks-agents pandas
dbutils.library.restartPython()

import mlflow
import pandas as pd

###
# Run evaluation
###
evaluation_results = mlflow.evaluate(..., model_type="databricks-agent")

###
# Access aggregated evaluation results across the entire evaluation set
###
results_as_dict = evaluation_results.metrics
results_as_pd_df = pd.DataFrame([evaluation_results.metrics])

# Sample usage
print(f"The percentage of generated responses that are grounded: {results_as_dict['response/llm_judged/groundedness/percentage']}")

###
# Access data about each question in the evaluation set
###

per_question_results_df = evaluation_results.tables['eval_results']

# Show information about responses that are not grounded
per_question_results_df[per_question_results_df["response/llm_judged/groundedness/rating"] == "no"].display()

La per_question_results_df trama de datos incluye todas las columnas del esquema de entrada y todos los resultados de evaluación específicos de cada solicitud. Para obtener más información sobre los resultados calculados, consulte Cómo la evaluación del agente evalúa la calidad, el costo y la latencia.

Revisión de la salida mediante la interfaz de usuario de MLflow

Los resultados de la evaluación también están disponibles en la interfaz de usuario de MLflow. Para acceder a la interfaz de usuario de MLflow, haga clic en el icono Experimento Icono de experimento en la barra lateral derecha del cuaderno y, a continuación, en la ejecución correspondiente o haga clic en los vínculos que aparecen en los resultados de la celda del cuaderno en la que ejecutó mlflow.evaluate().

Revisión de los resultados de la evaluación de una sola ejecución

En esta sección se describe cómo revisar los resultados de evaluación de una ejecución individual. Para comparar los resultados entre ejecuciones, consulte Comparación de los resultados de evaluación entre ejecuciones.

Información general sobre las evaluaciones de calidad por parte de los jueces de LLM

Las evaluaciones de juez por solicitud están disponibles en databricks-agents la versión 0.3.0 y posteriores.

Para ver información general sobre la calidad juzgada de LLM de cada solicitud en el conjunto de evaluación, haga clic en la pestaña Resultados de la evaluación de la página Ejecución de MLflow. En esta página se muestra una tabla de resumen de cada ejecución de evaluación. Para obtener más información, haga clic en el identificador de evaluación de una ejecución.

overview_judges

En esta introducción se muestran las evaluaciones de diferentes jueces para cada solicitud, el estado de calidad de paso y error de cada solicitud en función de estas evaluaciones y la causa principal de las solicitudes con error. Al hacer clic en una fila de la tabla, se le llevará a la página de detalles de esa solicitud que incluye lo siguiente:

  • Salida del modelo: la respuesta generada de la aplicación agente y su seguimiento si se incluye.
  • Salida esperada: la respuesta esperada para cada solicitud.
  • Evaluaciones detalladas: las evaluaciones de los jueces de LLM sobre estos datos. Haga clic en Ver detalles para mostrar las justificaciones proporcionadas por los jueces.

details_judges

Resultados agregados en el conjunto de evaluación completo

Para ver los resultados agregados en el conjunto de evaluación completo, haga clic en la pestaña Información general (para valores numéricos) o en la pestaña Métricas del modelo (para gráficos).

métricas de evaluación, valores

métricas de evaluación, gráficos

Comparación de los resultados de evaluación entre ejecuciones

Es importante comparar los resultados de evaluación entre ejecuciones para ver cómo responde la aplicación agente a los cambios. Comparar los resultados puede ayudarle a comprender si los cambios afectan positivamente a la calidad o ayudan a solucionar los problemas de cambio de comportamiento.

Comparación de los resultados por solicitud entre ejecuciones

Para comparar los datos de cada solicitud individual entre ejecuciones, haga clic en la pestaña Evaluación de la página Experimento. En una tabla se muestra cada pregunta del conjunto de evaluación. Use los menús desplegables para seleccionar las columnas que se van a ver.

preguntas individuales en el conjunto de evaluación

Comparación de los resultados agregados entre ejecuciones

Puede acceder a los mismos resultados agregados desde la página Experimento, que también le permite comparar los resultados en distintas ejecuciones. Para acceder a la página Experimento, haga clic en el icono Experimento Icono de experimento en la barra lateral derecha del cuaderno o haga clic en los vínculos que aparecen en los resultados de la celda del cuaderno en la que ejecutó mlflow.evaluate().

En la página Experimento, haga clic en icono de gráfico para mostrar. Esto le permite visualizar los resultados agregados de la ejecución seleccionada y compararlos con ejecuciones anteriores.

resultados agregados

¿Qué jueces se ejecutan?

De forma predeterminada, para cada registro de evaluación, mosaic AI Agent Evaluation aplica el subconjunto de jueces que mejor coincidan con la información presente en el registro. Específicamente:

  • Si el registro incluye una respuesta de verdad básica, la evaluación del agente aplica los context_sufficiencyjueces , groundedness, correctnessy safety .
  • Si el registro no incluye una respuesta de verdad básica, la evaluación del agente aplica los chunk_relevancejueces , groundedness, relevance_to_queryy safety .

También puede especificar explícitamente los jueces que se aplicarán a cada solicitud mediante el argumento de como evaluator_config mlflow.evaluate() se indica a continuación:

# Complete list of built-in LLM judges
# "chunk_relevance", "context_sufficiency", "correctness", "groundedness", "relevance_to_query", "safety"

evaluation_results = mlflow.evaluate(
  data=eval_df,
  model_type="databricks-agent",
  evaluator_config={
    "databricks-agent": {
      # Run only LLM judges that don't require ground-truth. Use an empty list to not run any built-in judge.
      "metrics": ["groundedness", "relevance_to_query", "chunk_relevance", "safety"]
    }
  }
)

Nota:

No se pueden deshabilitar las métricas de juez que no sean de LLM para la recuperación de fragmentos, recuentos de tokens de cadena o latencia.

Además de los jueces integrados, puede definir un juez LLM personalizado para evaluar los criterios específicos de su caso de uso. Consulte Personalización de jueces de LLM.

Consulte Información sobre los modelos que impulsan los jueces de LLM para obtener información sobre confianza y seguridad de los jueces de LLM.

Para obtener más información sobre los resultados y las métricas de evaluación, consulte Cómo la evaluación del agente evalúa la calidad, el costo y la latencia.

Ejemplo: Cómo pasar una aplicación a la evaluación del agente

Para pasar una aplicación a mlflow_evaluate(), use el model argumento . Hay 5 opciones para pasar una aplicación en el model argumento .

  • Modelo registrado en el catálogo de Unity.
  • Un modelo registrado de MLflow en el experimento de MLflow actual.
  • Modelo PyFunc que se carga en el cuaderno.
  • Una función local en el cuaderno.
  • Un punto de conexión del agente implementado.

Consulte las secciones siguientes para ver ejemplos de código que ilustran cada opción.

Opción 1. Modelo registrado en el catálogo de Unity

%pip install databricks-agents pandas
dbutils.library.restartPython()

import mlflow
import pandas as pd

evaluation_results = mlflow.evaluate(
    data=eval_set_df,  # pandas DataFrame with just the evaluation set
    model = "models:/catalog.schema.model_name/1"  # 1 is the version number
    model_type="databricks-agent",
)

Opción 2. Modelo registrado de MLflow en el experimento de MLflow actual

%pip install databricks-agents pandas
dbutils.library.restartPython()

import mlflow
import pandas as pd

# In the following lines, `6b69501828264f9s9a64eff825371711` is the run_id, and `chain` is the artifact_path that was
# passed with mlflow.xxx.log_model(...).
# If you called model_info = mlflow.langchain.log_model() or mlflow.pyfunc.log_model(), you can access this value using `model_info.model_uri`.
evaluation_results = mlflow.evaluate(
    data=eval_set_df,  # pandas DataFrame with just the evaluation set
    model = "runs:/6b69501828264f9s9a64eff825371711/chain"
    model_type="databricks-agent",
)

Opción 3. Modelo pyFunc que se carga en el cuaderno

%pip install databricks-agents pandas
dbutils.library.restartPython()

import mlflow
import pandas as pd

evaluation_results = mlflow.evaluate(
    data=eval_set_df,  # pandas DataFrame with just the evaluation set
    model = mlflow.pyfunc.load_model(...)
    model_type="databricks-agent",
)

Opción 4. Función local en el cuaderno

La función recibe un formato de entrada como se indica a continuación:

{
  "messages": [
    {
      "role": "user",
      "content": "What is MLflow?",
    }
  ],
  ...
}

La función debe devolver un valor en uno de los tres formatos admitidos siguientes:

  • Cadena sin formato que contiene la respuesta del modelo.

  • Diccionario en ChatCompletionResponse formato. Por ejemplo:

    {
  "choices": [
    {
      "message": {
        "role": "assistant",
        "content": "MLflow is a machine learning toolkit.",
      },
     ...
    }
  ],
  ...,
}

  • Diccionario en StringResponse formato, como { "content": "MLflow is a machine learning toolkit.", ... }.

En el ejemplo siguiente se usa una función local para ajustar un punto de conexión del modelo de base y evaluarlo:

  %pip install databricks-agents pandas
  dbutils.library.restartPython()

  import mlflow
  import pandas as pd

  def model(model_input):
    client = mlflow.deployments.get_deploy_client("databricks")
    return client.predict(endpoint="endpoints:/databricks-meta-llama-3-1-405b-instruct", inputs={"messages": model_input["messages"]})

  evaluation_results = mlflow.evaluate(
    data=eval_set_df,  # pandas DataFrame with just the evaluation set
    model = model
    model_type="databricks-agent",
  )

Opción 5. Punto de conexión del agente implementado

Esta opción solo funciona cuando se usan puntos de conexión de agente que se han implementado mediante databricks.agents.deploy y con databricks-agents la versión 0.8.0 del SDK o superior. Para modelos de base o versiones anteriores del SDK, use la opción 4 para encapsular el modelo en una función local.

%pip install databricks-agents pandas
dbutils.library.restartPython()

import mlflow
import pandas as pd

# In the following lines, `endpoint-name-of-your-agent` is the name of the agent endpoint.
evaluation_results = mlflow.evaluate(
    data=eval_set_df,  # pandas DataFrame with just the evaluation set
    model = "endpoints:/endpoint-name-of-your-agent"
    model_type="databricks-agent",
)

Cómo pasar el conjunto de evaluación cuando la aplicación se incluye en la mlflow_evaluate() llamada

En el código siguiente, data es un DataFrame pandas con el conjunto de evaluación. Estos son ejemplos sencillos. Consulte el esquema de entrada para obtener más información.

# You do not have to start from a dictionary - you can use any existing pandas or Spark DataFrame with this schema.

# Minimal evaluation set
bare_minimum_eval_set_schema = [
    {
        "request": "What is the difference between reduceByKey and groupByKey in Spark?",
    }]

# Complete evaluation set
complete_eval_set_schema = [
    {
        "request_id": "your-request-id",
        "request": "What is the difference between reduceByKey and groupByKey in Spark?",
        "expected_retrieved_context": [
            {
                # In `expected_retrieved_context`, `content` is optional, and does not provide any additional functionality.
                "content": "Answer segment 1 related to What is the difference between reduceByKey and groupByKey in Spark?",
                "doc_uri": "doc_uri_2_1",
            },
            {
                "content": "Answer segment 2 related to What is the difference between reduceByKey and groupByKey in Spark?",
                "doc_uri": "doc_uri_2_2",
            },
        ],
        "expected_response": "There's no significant difference.",
    }]

# Convert dictionary to a pandas DataFrame
eval_set_df = pd.DataFrame(bare_minimum_eval_set_schema)

# Use a Spark DataFrame
import numpy as np
spark_df = spark.table("catalog.schema.table") # or any other way to get a Spark DataFrame
eval_set_df = spark_df.toPandas()

Ejemplo: Cómo pasar salidas generadas previamente a la evaluación del agente

En esta sección se describe cómo pasar salidas generadas previamente en la mlflow_evaluate() llamada. Para ver el esquema del conjunto de evaluación necesario, consulte Esquema de entrada de evaluación del agente.

En el código siguiente, data es un DataFrame de Pandas con el conjunto de evaluación y salidas generados por la aplicación. Estos son ejemplos sencillos. Consulte el esquema de entrada para obtener más información.

%pip install databricks-agents pandas
dbutils.library.restartPython()

import mlflow
import pandas as pd

evaluation_results = mlflow.evaluate(
    data=eval_set_with_app_outputs_df,  # pandas DataFrame with the evaluation set and application outputs
    model_type="databricks-agent",
)

# You do not have to start from a dictionary - you can use any existing pandas or Spark DataFrame with this schema.

# Minimum required input
bare_minimum_input_schema = [
    {
        "request": "What is the difference between reduceByKey and groupByKey in Spark?",
        "response": "reduceByKey aggregates data before shuffling, whereas groupByKey shuffles all data, making reduceByKey more efficient.",
    }]

# Input including optional arguments
complete_input_schema  = [
    {
        "request_id": "your-request-id",
        "request": "What is the difference between reduceByKey and groupByKey in Spark?",
        "expected_retrieved_context": [
            {
                # In `expected_retrieved_context`, `content` is optional, and does not provide any additional functionality.
                "content": "Answer segment 1 related to What is the difference between reduceByKey and groupByKey in Spark?",
                "doc_uri": "doc_uri_2_1",
            },
            {
                "content": "Answer segment 2 related to What is the difference between reduceByKey and groupByKey in Spark?",
                "doc_uri": "doc_uri_2_2",
            },
        ],
        "expected_response": "There's no significant difference.",
        "response": "reduceByKey aggregates data before shuffling, whereas groupByKey shuffles all data, making reduceByKey more efficient.",
        "retrieved_context": [
            {
                # In `retrieved_context`, `content` is optional. If provided, the Databricks Context Relevance LLM Judge is executed to check the `content`'s relevance to the `request`.
                "content": "reduceByKey reduces the amount of data shuffled by merging values before shuffling.",
                "doc_uri": "doc_uri_2_1",
            },
            {
                "content": "groupByKey may lead to inefficient data shuffling due to sending all values across the network.",
                "doc_uri": "doc_uri_6_extra",
            },
        ],
    }]

# Convert dictionary to a pandas DataFrame
eval_set_with_app_outputs_df = pd.DataFrame(bare_minimum_input_schema)

# Use a Spark DataFrame
import numpy as np
spark_df = spark.table("catalog.schema.table") # or any other way to get a Spark DataFrame
eval_set_with_app_outputs_df = spark_df.toPandas()

Ejemplo: Uso de una función personalizada para procesar respuestas de LangGraph

Los agentes de LangGraph, especialmente aquellos con la funcionalidad de chat, pueden devolver varios mensajes para una sola llamada de inferencia. Es responsabilidad del usuario convertir la respuesta del agente a un formato que admite La evaluación del agente.

Un enfoque consiste en usar una función personalizada para procesar la respuesta. En el ejemplo siguiente se muestra una función personalizada que extrae el último mensaje de chat de un modelo langGraph. A continuación, esta función se usa en mlflow.evaluate() para devolver una única respuesta de cadena, que se puede comparar con la ground_truth columna.

El código de ejemplo realiza las suposiciones siguientes:

  • El modelo acepta la entrada en el formato {"messages": [{"role": "user", "content": "hello"}]}.
  • El modelo devuelve una lista de cadenas con el formato ["response 1", "response 2"].

El código siguiente envía las respuestas concatenadas al juez en este formato: "response 1nresponse2"

import mlflow
import pandas as pd
from typing import List

loaded_model = mlflow.langchain.load_model(model_uri)
eval_data = pd.DataFrame(
    {
        "inputs": [
            "What is MLflow?",
            "What is Spark?",
        ],
        "expected_response": [
            "MLflow is an open-source platform for managing the end-to-end machine learning (ML) lifecycle. It was developed by Databricks, a company that specializes in big data and machine learning solutions. MLflow is designed to address the challenges that data scientists and machine learning engineers face when developing, training, and deploying machine learning models.",
            "Apache Spark is an open-source, distributed computing system designed for big data processing and analytics. It was developed in response to limitations of the Hadoop MapReduce computing model, offering improvements in speed and ease of use. Spark provides libraries for various tasks such as data ingestion, processing, and analysis through its components like Spark SQL for structured data, Spark Streaming for real-time data processing, and MLlib for machine learning tasks",
        ],
    }
)

def custom_langgraph_wrapper(model_input):
    predictions = loaded_model.invoke({"messages": model_input["messages"]})
    # Assuming `predictions` is a list of strings
    return predictions.join("\n")

with mlflow.start_run() as run:
    results = mlflow.evaluate(
        custom_langgraph_wrapper,  # Pass the function defined above
        data=eval_data,
        model_type="databricks-agent",
    )

print(results.metrics)

Creación de un panel con métricas

Al iterar en la calidad del agente, es posible que quiera compartir un panel con las partes interesadas que muestre cómo ha mejorado la calidad con el tiempo. Puede extraer las métricas de las ejecuciones de evaluación de MLflow, guardar los valores en una tabla Delta y crear un panel.

En el ejemplo siguiente se muestra cómo extraer y guardar los valores de métrica de la ejecución de evaluación más reciente en el cuaderno:

uc_catalog_name = "catalog"
uc_schema_name = "schema"
table_name = "results"

eval_results = mlflow.evaluate(
    model=logged_agent_info.model_uri, # use the logged Agent
    data=evaluation_set, # Run the logged Agent for all queries defined above
    model_type="databricks-agent", # use Agent Evaluation
)

# The `append_metrics_to_table function` is defined below
append_metrics_to_table("<identifier-for-table>", eval_results.metrics, f"{uc_catalog_name}.{uc_schema_name}.{table_name}")

En el ejemplo siguiente se muestra cómo extraer y guardar valores de métricas para ejecuciones anteriores que ha guardado en el experimento de MLflow.

import pandas as pd

def get_mlflow_run(experiment_name, run_name):
  runs = mlflow.search_runs(experiment_names=[experiment_name], filter_string=f"run_name = '{run_name}'", output_format="list")

  if len(runs) != 1:
    raise ValueError(f"Found {len(runs)} runs with name {run_name}. {run_name} must identify a single run. Alternatively, you can adjust this code to search for a run based on `run_id`")

   return runs[0]

run = get_mlflow_run(experiment_name ="/Users/<user_name>/db_docs_mlflow_experiment", run_name="evaluation__2024-10-09_02:27:17_AM")

# The `append_metrics_to_table` function is defined below
append_metrics_to_table("<identifier-for-table>", run.data.metrics, f"{uc_catalog_name}.{uc_schema_name}.{table_name}")

Ahora puede crear un panel con estos datos.

El código siguiente define la función append_metrics_to_table que se usa en los ejemplos anteriores.

# Definition of `append_metrics_to_table`

def append_metrics_to_table(run_name, mlflow_metrics, delta_table_name):
  data = mlflow_metrics.copy()

  # Add identifying run_name and timestamp
  data["run_name"] = run_name
  data["timestamp"] = pd.Timestamp.now()

  # Remove metrics with error counts
  data = {k: v for k, v in mlflow_metrics.items() if "error_count" not in k}

  # Convert to a Spark DataFrame(
  metrics_df = pd.DataFrame([data])
  metrics_df_spark = spark.createDataFrame(metrics_df)

  # Append to the Delta table
  metrics_df_spark.write.mode("append").saveAsTable(delta_table_name)

Limitación

En el caso de las conversaciones multiturno, la salida de evaluación registra solo la última entrada de la conversación.

Información sobre los modelos que impulsan los jueces de LLM

  • Los jueces de LLM pueden usar servicios de terceros para evaluar las aplicaciones de GenAI, incluido Azure OpenAI operado por Microsoft.
  • Para Azure OpenAI, Databricks ha optado por no realizar la supervisión de abusos, por lo que no se almacenan solicitudes ni respuestas con Azure OpenAI.
  • En el caso de las áreas de trabajo de la Unión Europea (UE), los jueces de LLM usan modelos hospedados en la UE. Todas las demás regiones usan modelos hospedados en Estados Unidos.
  • La deshabilitación de las características de asistencia de IA con tecnología de Azure AI impide que el juez de LLM llame a modelos con tecnología de Azure AI.
  • Los datos enviados al juez de LLM no se usan para ningún entrenamiento del modelo.
  • Los jueces de LLM están pensados para ayudar a los clientes a evaluar sus aplicaciones RAG, y los resultados de los jueces de LLM no deben utilizarse para entrenar, mejorar o ajustar un LLM.