Compartir a través de

Cómo ejecutar evaluaciones en línea con el SDK de la Fundición de IA de Azure

  • Artículo

Importante

Los elementos marcados (versión preliminar) en este artículo se encuentran actualmente en versión preliminar pública. Esta versión preliminar se ofrece sin acuerdo de nivel de servicio y no se recomienda para las cargas de trabajo de producción. Es posible que algunas características no sean compatibles o que tengan sus funcionalidades limitadas. Para más información, consulte Términos de uso complementarios de las Versiones Preliminares de Microsoft Azure.

En este artículo, aprenderá a ejecutar evaluaciones en línea de forma continua con el SDK de la Fundición de IA de Azure. Las evaluaciones en entornos de preproducción son esenciales para garantizar que la aplicación sea segura, eficaz y genere resultados de alta calidad. Sin embargo, la evaluación no se detiene después de implementar la aplicación. En producción, pueden cambiar varios aspectos, como los tipos de consultas que los usuarios envían a la aplicación, lo que puede influir en el rendimiento de la aplicación. Para mantener un alto grado de observabilidad en la aplicación de IA generativa de producción, es importante realizar un seguimiento y evaluar continuamente los datos de la aplicación. Al hacerlo, puede mantener la confianza en la seguridad, la calidad y el rendimiento de la aplicación.

Funcionamiento de la evaluación en línea

En esta sección, aprenderá cómo funciona la evaluación en línea, cómo se integra con Azure Monitor Application Insights y cómo se puede usar para ejecutar evaluaciones continuas en los datos de seguimiento de las aplicaciones de IA generativa.

Una vez instrumentada la aplicación para que envíe datos de seguimiento a Application Insights, configure una programación de evaluación en línea para evaluar continuamente estos datos. La evaluación en línea es un servicio que usa el proceso de Azure AI para ejecutar continuamente un conjunto configurable de evaluadores. Tras configurar una programación de evaluación en línea con el SDK de la Fundición de IA de Azure, se ejecuta según una programación configurable. Cada vez que se ejecuta el trabajo programado, realiza los pasos siguientes:

  1. Consulte los datos de seguimiento de la aplicación desde el recurso de Application Insights conectado, para lo que debe usar la consulta de Kusto (KQL) proporcionada.
  2. Ejecute todos los evaluadores en los datos de seguimiento y calcule todas las métricas (por ejemplo, solidez: 3).
  3. Vuelva a escribir las puntuaciones de la evaluación en cada seguimiento y utilice convenciones semánticas normalizadas para hacerlo.

Nota:

La evaluación en línea admite las mismas métricas que Azure AI Evaluation. Para más información sobre el funcionamiento de la evaluación y las métricas de evaluación que se admiten, consulte Evaluación de una aplicación de IA generativa con el SDK de evaluación de Azure AI.

Por ejemplo, supongamos que tiene implementada una aplicación de chat que recibe muchas preguntas de clientes todos los días. Quiere evaluar continuamente la calidad de las respuestas de la aplicación. Configure una programación de evaluación en línea con una periodicidad diaria. Configure los evaluadores: Solidez, Coherencia y Fluidez. Todos los días el servicio calcula las puntuaciones de evaluación de estas métricas y escribe en Application Insights los datos de cada seguimiento que se han recopilado durante el período de tiempo de periodicidad (en este ejemplo, las últimas 24 horas). De esta forma los datos se podrán consultar posteriormente desde cada seguimiento y se podrá permitir el acceso a ellos en Azure AI Foundry y Azure Monitor Application Insights.

Los resultados de evaluación que se escriben en cada seguimiento de Application Insights siguen las convenciones que se indican a continuación. Se agrega un intervalo único a cada seguimiento de cada métrica de evaluación:

Propiedad Tabla de Application Insights Campos de un operation_ID determinado Valor de ejemplo
Métrica de evaluación seguimientos, AppTraces customDimensions[“event.name”] gen_ai.evaluation.relevance
Puntuación de métrica de evaluación seguimientos, AppTraces customDimensions[“gen_ai.evaluation.score”] 3
Comentario de métrica de evaluación (si procede) seguimientos, AppTraces message {“comment”: “I like the response”}

Ahora que conoces el funcionamiento la evaluación en línea y cómo se conecta a Azure Monitor Application Insights, el siguiente paso es configurar el servicio.

Configurar evaluación en línea

En esta sección, aprenderá a configurar una programación de evaluación en línea para supervisar de forma continua una aplicación de IA generativa implementada. El SDK de la Fundición de IA de Azure ofrece estas funcionalidades a través de una API de Python y admite todas las características disponibles en las evaluaciones locales. Siga los pasos que se indican a continuación para enviar la programación de evaluación en línea en los datos mediante evaluadores integrados o personalizados.

Nota:

Las evaluaciones solo se admiten en las mismas regiones que las métricas de seguridad y riesgo asistidas por IA.

Requisitos previos

Lleve a cabo los siguientes pasos previos para configurar el entorno y la autenticación en los recursos necesarios:

  1. Una suscripción a Azure.
  2. Un grupo de recursos de una región admitida por la evaluación.
  3. Una nueva identidad administrada asignada por el usuario en el mismo grupo de recursos y región. Tome nota de clientId, ya que lo necesitará más adelante.
  4. Una instancia de Azure AI Hub en el mismo grupo de recursos y región.
  5. Un proyecto de Azure AI en este centro. Consulte Creación de un proyecto en Estudio de IA de Azure.
  6. Un recurso de Azure Monitor Application Insights.
  7. Vaya a la página del centro en Azure Portal y agregue un recurso de Application Insights. Consulte Actualización de Azure Application Insights y Azure Container Registry.
  8. Implementación de Azure OpenAI con el modelo GPT compatible con chat completion, por ejemplo gpt-4.
  9. Connection String para que el proyecto de Azure AI cree fácilmente un objeto AIProjectClient. Puede obtener la cadena de conexión del proyecto en Detalles del proyecto en la página Información general del proyecto.
  10. Vaya al recurso de Application Insights en Azure Portal y use la pestaña Control de acceso (IAM) para agregar el rol Log Analytics Contributor a la identidad administrada asignada por el usuario que creó anteriormente.
  11. Adjunte la identidad administrada asignada por el usuario al proyecto.
  12. Vaya a Servicios de Azure AI en Azure Portal y use la pestaña Control de acceso (IAM) para agregar el rol Cognitive Services OpenAI Contributor a la identidad administrada asignada por el usuario que creó anteriormente.

Instrucciones de instalación

Instale la CLI de Azure e inicie sesión.

Instale la CLI de Azure e inicie sesión desde el entorno de desarrollo local, de modo que pueda usar las credenciales de usuario para llamar al servicio Azure OpenAI.

En la mayoría de los casos, puede instalar la CLI de Azure desde el terminal mediante el siguiente comando:

winget install -e --id Microsoft.AzureCLI

Puede seguir las instrucciones Cómo instalar la CLI de Azure si estos comandos no funcionan para su sistema operativo o configuración concretos.

Después de instalar la CLI de Azure, inicie sesión con el comando az login e inicie sesión con el explorador:

az login

Como alternativa, puede iniciar sesión manualmente a través del explorador con un código de dispositivo.

az login --use-device-code

Creación de un entorno de Python

En primer lugar, debe crear un nuevo entorno de Python y usarlo para instalar el paquete que necesita para este tutorial. NO instale paquetes en la instalación global de Python. Siempre debe usar un entorno virtual o conda al instalar paquetes de Python; de lo contrario, puede interrumpir la instalación global de Python.

Si es necesario, instale Python.

Se recomienda usar Python 3.10 o posterior, pero se requiere al menos Python 3.8. Si no tiene instalada una versión adecuada de Python, puede seguir las instrucciones del Tutorial de Python de VS Code para la manera más fácil de instalar Python en el sistema operativo.

Creación de un entorno virtual

Si ya tiene Instalado Python 3.10 o superior, puede crear un entorno virtual con los siguientes comandos:

py -3 -m venv .venv
.venv\scripts\activate

La activación del entorno de Python significa que, al ejecutar python o pip desde la línea de comandos, se usa el intérprete de Python incluido en la carpeta .venv de la aplicación.

Nota:

Puede usar el comando deactivate para salir del entorno virtual de Python y, posteriormente, volver a activarlo cuando sea necesario.

También puede crear un nuevo entorno de Python mediante conda:

conda create -n online-evaluation
conda activate online-evaluation

Instale los paquetes necesarios:

pip install azure-identity azure-ai-projects azure-ai-ml

Sugerencia

Opcionalmente, puede usar pip install azure-ai-evaluation si desea una experiencia de tipo código primero para capturar el identificador del evaluador en los evaluadores integrados en el código. Para aprender a hacerlo, consulte Especificación de evaluadores de la biblioteca de evaluadores.

Configuración del seguimiento de una aplicación de IA generativa

Antes de configurar la evaluación en línea, asegúrese de haber configurado primero el seguimiento de la aplicación de IA generativa.

Uso del nombre del servicio en los datos de seguimiento

Para identificar la aplicación a través de un id. exclusivo en Application Insights, puede usar la propiedad OpenTelemetry del nombre de servicio en los datos de seguimiento. Esto es especialmente útil si va a registrar datos de varias aplicaciones en el mismo recurso de Application Insights y desea diferenciarlos. Por ejemplo, supongamos que tiene dos aplicaciones: App-1 y App-2, con el seguimiento configurado para registrar datos en el mismo recurso de Application Insights. Quizás le gustaría configurar App-1 para que se evalúe continuamente por Relevancia y App-2 para que se evalúe continuamente por Solidez. Puede usar el nombre del servicio para marcar la diferencia entre las aplicaciones de las configuraciones de evaluación en línea.

Para configurar la propiedad del nombre de servicio, puede hacerlo directamente en el código de la aplicación siguiendo los pasos descritos, consulte Uso de varios proveedores de seguimiento con un recurso diferente. Como alternativa, puede establecer la variable de entorno OTEL_SERVICE_NAME antes de implementar la aplicación. Para más información sobre cómo trabajar con el nombre del servicio, consulte Variables de entorno de OTEL y Convenciones semánticas de recursos de servicio.

Para obtener más información sobre el uso del nombre del servicio para diferenciar entre las aplicaciones de IA generativa, consulte seguimiento.

Consulta de datos de seguimiento almacenados en Application Insights

Con el lenguaje de consulta Kusto (KQL), puede consultar los datos de seguimiento de la aplicación de IA generativa desde Application Insights para usarlos para la evaluación continua en línea. Si utilizar el paquete Azure AI Tracing para realizar un seguimiento de la aplicación de IA generativa, puede usar la siguiente consulta de Kusto:

Importante

La consulta KQL que usa el servicio de evaluación en línea debe generar las siguientes columnas: operation_Id, operation_ParentId y gen_ai_response_id. Además, cada evaluador tiene sus propios requisitos de datos de entrada. La consulta KQL debe generar estas columnas para usarlas como entradas para los propios evaluadores. Para obtener una lista de los requisitos de datos para los evaluadores, consulte los requisitos de datos para los evaluadores integrados.

let gen_ai_spans = (
    dependencies
    | where isnotnull(customDimensions["gen_ai.system"])
    | extend response_id = tostring(customDimensions["gen_ai.response.id"])
    | project id, operation_Id, operation_ParentId, timestamp, response_id
);
let gen_ai_events = (
    traces
    | where message in ("gen_ai.choice", "gen_ai.user.message", "gen_ai.system.message")
        or tostring(customDimensions["event.name"]) in ("gen_ai.choice", "gen_ai.user.message", "gen_ai.system.message")
    | project 
        id = operation_ParentId, 
        operation_Id, 
        operation_ParentId, 
        user_input = iff(
            message == "gen_ai.user.message" or tostring(customDimensions["event.name"]) == "gen_ai.user.message", 
            parse_json(iff(message == "gen_ai.user.message", tostring(customDimensions["gen_ai.event.content"]), message)).content, 
            ""
        ), 
        system = iff(
            message == "gen_ai.system.message" or tostring(customDimensions["event.name"]) == "gen_ai.system.message", 
            parse_json(iff(message == "gen_ai.system.message", tostring(customDimensions["gen_ai.event.content"]), message)).content, 
            ""
        ), 
        llm_response = iff(
            message == "gen_ai.choice", 
            parse_json(tostring(parse_json(tostring(customDimensions["gen_ai.event.content"])).message)).content, 
            iff(tostring(customDimensions["event.name"]) == "gen_ai.choice", parse_json(parse_json(message).message).content, "")
        )
    | summarize 
        operation_ParentId = any(operation_ParentId), 
        Input = maxif(user_input, user_input != ""), 
        System = maxif(system, system != ""), 
        Output = maxif(llm_response, llm_response != "") 
    by operation_Id, id
);
gen_ai_spans
| join kind=inner (gen_ai_events) on id, operation_Id
| project Input, System, Output, operation_Id, operation_ParentId, gen_ai_response_id = response_id

Si usa la variable de entorno OTEL_SERVICE_NAME en la aplicación de IA generativa para establecer el nombre del servicio, puede consultar el cloud_RoleName dentro de la programación de evaluación en línea agregando la siguiente línea a la consulta de Kusto (KQL):

| where cloud_RoleName == "service_name"

Opcionalmente, puede usar el operador sample o el operador take en la consulta de Kusto de forma que solo devuelva un subconjunto de seguimientos. Dado que las evaluaciones asistidas por IA pueden ser caras a escala, este enfoque puede ayudarle a controlar los costos, ya que solo se evalúa una muestra aleatoria (o n seguimientos) de los datos.

Configurar evaluación en línea con el SDK Azure AI Project

Puede enviar un trabajo programado de evaluación en línea con el SDK de Azure AI Project a través de una API de Python. Consulte el siguiente script para obtener información sobre cómo configurar una evaluación en línea con evaluadores de rendimiento y calidad (asistido por IA). Para ver una lista completa de los evaluadores admitidos, consulte Evaluación con el SDK de Azure AI Evaluation. Para obtener información sobre cómo usar evaluadores personalizados, consulte el apartado relativo a los evaluadores personalizados.

Para empezar, importe los paquetes necesarios y configure las variables necesarias:

from azure.ai.projects import AIProjectClient 
from azure.identity import DefaultAzureCredential 
from azure.ai.projects.models import ( 
    ApplicationInsightsConfiguration,
    EvaluatorConfiguration,
    EvaluationSchedule,
    RecurrenceTrigger,
)
from azure.ai.evaluation import CoherenceEvaluator 

# This sample includes the setup for an online evaluation schedule using the Azure AI Project SDK and Azure AI Evaluation SDK
# The schedule is configured to run daily over the collected trace data while running two evaluators: CoherenceEvaluator and RelevanceEvaluator
# This sample can be modified to fit your application's requirements

# Name of your online evaluation schedule
SAMPLE_NAME = "online_eval_name"

# Connection string to your Azure AI Foundry project
# Currently, it should be in the format "<HostName>;<AzureSubscriptionId>;<ResourceGroup>;<HubName>"
PROJECT_CONNECTION_STRING = "<HostName>;<AzureSubscriptionId>;<ResourceGroup>;<HubName>"

# Your Application Insights resource ID
APPLICATION_INSIGHTS_RESOURCE_ID = "appinsights_resource_id"

# Kusto Query Language (KQL) query to query data from Application Insights resource
# This query is compatible with data logged by the Azure AI Inferencing Tracing SDK (linked in documentation)
# You can modify it depending on your data schema
# The KQL query must output these required columns: operation_ID, operation_ParentID, and gen_ai_response_id
# You can choose which other columns to output as required by the evaluators you are using
KUSTO_QUERY = "let gen_ai_spans=(dependencies | where isnotnull(customDimensions[\"gen_ai.system\"]) | extend response_id = tostring(customDimensions[\"gen_ai.response.id\"]) | project id, operation_Id, operation_ParentId, timestamp, response_id); let gen_ai_events=(traces | where message in (\"gen_ai.choice\", \"gen_ai.user.message\", \"gen_ai.system.message\") or tostring(customDimensions[\"event.name\"]) in (\"gen_ai.choice\", \"gen_ai.user.message\", \"gen_ai.system.message\") | project id= operation_ParentId, operation_Id, operation_ParentId, user_input = iff(message == \"gen_ai.user.message\" or tostring(customDimensions[\"event.name\"]) == \"gen_ai.user.message\", parse_json(iff(message == \"gen_ai.user.message\", tostring(customDimensions[\"gen_ai.event.content\"]), message)).content, \"\"), system = iff(message == \"gen_ai.system.message\" or tostring(customDimensions[\"event.name\"]) == \"gen_ai.system.message\", parse_json(iff(message == \"gen_ai.system.message\", tostring(customDimensions[\"gen_ai.event.content\"]), message)).content, \"\"), llm_response = iff(message == \"gen_ai.choice\", parse_json(tostring(parse_json(tostring(customDimensions[\"gen_ai.event.content\"])).message)).content, iff(tostring(customDimensions[\"event.name\"]) == \"gen_ai.choice\", parse_json(parse_json(message).message).content, \"\")) | summarize operation_ParentId = any(operation_ParentId), Input = maxif(user_input, user_input != \"\"), System = maxif(system, system != \"\"), Output = maxif(llm_response, llm_response != \"\") by operation_Id, id); gen_ai_spans | join kind=inner (gen_ai_events) on id, operation_Id | project Input, System, Output, operation_Id, operation_ParentId, gen_ai_response_id = response_id"

Luego, defina un cliente y una implementación de Azure OpenAI GPT (como GPT-4), que se usará para ejecutar la programación de evaluación en línea. Además, conecte con el de Application Insights:

# Connect to your Azure AI Foundry Project
project_client = AIProjectClient.from_connection_string(
    credential=DefaultAzureCredential(),
    conn_str=PROJECT_CONNECTION_STRING
)

# Connect to your Application Insights resource 
app_insights_config = ApplicationInsightsConfiguration(
    resource_id=APPLICATION_INSIGHTS_RESOURCE_ID,
    query=KUSTO_QUERY
)

# Connect to your Azure OpenAI Service resource. You must use a GPT model deployment for this example.
deployment_name = "gpt-4"
api_version = "2024-08-01-preview"

# This is your Azure OpenAI Service connection name, which can be found in your Azure AI Foundry project under the 'Models + Endpoints' tab.
default_connection = project_client.connections._get_connection(
    "aoai_connection_name"
)

model_config = {
    "azure_deployment": deployment_name,
    "api_version": api_version,
    "type": "azure_openai",
    "azure_endpoint": default_connection.properties["target"]
}

Luego, configure los evaluadores que desea usar:

# RelevanceEvaluator
# id for each evaluator can be found in your Azure AI Foundry registry - please see documentation for more information
# init_params is the configuration for the model to use to perform the evaluation
# data_mapping is used to map the output columns of your query to the names required by the evaluator
relevance_evaluator_config = EvaluatorConfiguration(
    id="azureml://registries/azureml-staging/models/Relevance-Evaluator/versions/4",
    init_params={"model_config": model_config},
    data_mapping={"query": "${data.Input}", "response": "${data.Output}"}
)

# CoherenceEvaluator
coherence_evaluator_config = EvaluatorConfiguration(
    id=CoherenceEvaluator.id,
    init_params={"model_config": model_config},
    data_mapping={"query": "${data.Input}", "response": "${data.Output}"}
)

Por último, defina la periodicidad y cree la programación:

Nota: En los pasos de los requisitos previos, ha creado una identidad administrada asignada por el usuario para autenticar la programación de evaluación en línea en su recurso de Application Insights. El identificador AzureMSIClientId del parámetro properties de la clase EvaluationSchedule es el clientId de esta identidad.

# Frequency to run the schedule
recurrence_trigger = RecurrenceTrigger(frequency="day", interval=1)

# Dictionary of evaluators
evaluators = {
    "relevance": relevance_evaluator_config,
    "coherence" : coherence_evaluator_config
}

name = SAMPLE_NAME
description = f"{SAMPLE_NAME} description"
# AzureMSIClientId is the clientID of the User-assigned managed identity created during set-up - see documentation for how to find it
properties = {"AzureMSIClientId": "your_client_id"}

# Configure the online evaluation schedule
evaluation_schedule = EvaluationSchedule(
    data=app_insights_config,
    evaluators=evaluators,
    trigger=recurrence_trigger,
    description=description,
    properties=properties)

# Create the online evaluation schedule 
created_evaluation_schedule = project_client.evaluations.create_or_replace_schedule(name, evaluation_schedule)
print(f"Successfully submitted the online evaluation schedule creation request - {created_evaluation_schedule.name}, currently in {created_evaluation_schedule.provisioning_state} state.")

Realización de operaciones en una programación de evaluación en línea

Para obtener, enumerar y deshabilitar programaciones de evaluación en línea, agregue el siguiente código al script de configuración de evaluación en línea:

Advertencia: espere un poco (aproximadamente 30 segundos) entre la creación de una programación de evaluación en línea y la ejecución de la get_schedule() API.

Obtener una programación de evaluación en línea:

name = "<my-online-evaluation-name>"
get_evaluation_schedule = project_client.evaluations.get_schedule(name)

Enumerar todas las programaciones de evaluación en línea:

count = 0
for evaluation_schedule in project_client.evaluations.list_schedule():
    count += 1
        print(f"{count}. {evaluation_schedule.name} "
        f"[IsEnabled: {evaluation_schedule.is_enabled}]")
        print(f"Total evaluation schedules: {count}")

Deshabilitar (eliminación temporal) una programación de evaluación en línea:

name = "<my-online-evaluation-name>"
project_client.evaluations.disable_schedule(name)

Contenido relacionado