Evaluación del rendimiento de la ia generativa en azure ai foundry: una guía para profesionales

Comienzo creando un nuevo archivo Python, a menudo llamado algo como evaluate_genai.py. Aquí es donde importo los módulos necesarios y configuro el cliente para conectarme a mi proyecto de Azure AI. Recuerda reemplazar los valores de marcador de posición a continuación con los detalles reales de tu proyecto; normalmente los almaceno en variables de entorno para una mayor seguridad y flexibilidad.

import os
from azure.identity import DefaultAzureCredential
from azure.ai.project import AIProjectClient

# --- Configuración --- #
# Reemplace con los detalles de su proyecto Azure AI. Normalmente encuentro el punto final
# en el portal de Azure AI Studio bajo la configuración de mi proyecto.
AZURE_AI_PROJECT_ENDPOINT = os.environ.get("AZURE_AI_PROJECT_ENDPOINT", "your_project_endpoint")
# El nombre de su modelo implementado que quiero evaluar.
EVALUATION_TARGET_DEPLOYMENT = os.environ.get("EVALUATION_TARGET_DEPLOYMENT", "your_model_deployment_name")

# Inicializar DefaultAzureCredential para la autenticación
credential = DefaultAzureCredential()
print("Azure credential initialized.")

# Inicializar AIProjectClient
project_client = AIProjectClient(endpoint=AZURE_AI_PROJECT_ENDPOINT, credential=credential)
print("AIProjectClient initialized.")

# Carpeta base para salidas
OUTPUT_FOLDER = "./eval_outputs"
os.makedirs(OUTPUT_FOLDER, exist_ok=True)
print(f"Output folder '{OUTPUT_FOLDER}' ensured.")

Este fragmento importa las clases necesarias para la interacción del proyecto y la autenticación. Configura el punto final para mi proyecto de IA e inicializa AIProjectClient, que es mi punto de entrada principal para administrar los recursos del proyecto. También configuro un directorio de salida para almacenar los resultados.

Para evaluar una aplicación RAG de manera efectiva, necesito un conjunto de datos que comprenda indicaciones y el contexto contra el cual se juzgará la respuesta del modelo. Fundamentalmente, la finalización del modelo no es parte de estos datos de entrada; se genera durante la propia ejecución de la evaluación.

# Este es un conjunto de datos de ejemplo que podría usar para la evaluación,
# imitando una sesión de preguntas y respuestas sobre documentos financieros.
# La estructura 'item' es requerida por el marco de evaluación.
data_for_evaluation = {
    "type": "file_content",
    "content": [
        {
            "item": {
                "prompt_text": "¿Cuál es el principal desafío financiero para NVIDIA en 2026?",
                "context_text": "El 15 de marzo de 2026, NVIDIA informó de sólidos resultados del cuarto trimestre de 2025, pero destacó posibles desafíos en el próximo año fiscal debido a la intensificación de la competencia de Intel y AMD en el mercado de aceleradores de IA. Los analistas de la cadena de suministro también señalaron complejidades persistentes para asegurar las capacidades de fabricación avanzadas para las GPU H200 y Blackwell de próxima generación de NVIDIA, lo que podría afectar el crecimiento de los ingresos."
            }
        },
        {
            "item": {
                "prompt_text": "Explique el impacto de la última subida de tipos de interés por parte del BCE en los mercados de bonos.",
                "context_text": "El 2 de abril de 2026, el Banco Central Europeo (BCE) anunció un aumento de 25 puntos básicos en sus tipos de interés clave, citando preocupaciones persistentes sobre la inflación. Tras este anuncio, los analistas de Bloomberg informaron de un fuerte aumento en los rendimientos de los Bund alemanes a 10 años, lo que indica una amplia revalorización de la deuda soberana en la Eurozona debido a mayores costes de financiación para los gobiernos y una menor atractivo de los bonos existentes con menor rendimiento."
            }
        }
    ]
}

print(f"Prepared {len(data_for_evaluation['content'])} data points for evaluation.")

Este diccionario define mi fuente de datos de evaluación. Cada item contiene el prompt_text (la consulta del usuario) y el context_text (la información recuperada). El modelo que estoy evaluando generará una respuesta basada en estas entradas, que los evaluadores luego evaluarán.

En el SDK de Azure AI Project, defino mis evaluadores como parte de los testing_criteria. Especifico el nombre de la métrica incorporada (como builtin.groundedness) y luego mapeo los campos de datos de mi conjunto de datos a las entradas requeridas por ese evaluador.

# Defino los evaluadores aquí. Estos aprovechan los modelos GPT fundamentales
# aprovisionados dentro de mi proyecto Azure AI. El 'data_mapping' conecta
# las columnas de mi conjunto de datos con las entradas esperadas del evaluador.
testing_criteria = [
    {
        "type": "azure_ai_evaluator",
        "name": "groundedness_eval",
        "evaluator_name": "builtin.groundedness",
        "data_mapping": {
            "question": "{{item.prompt_text}}",
            "context": "{{item.context_text}}",
            "answer": "{{target.response}}" # 'target.response' es la respuesta generada por el modelo
        },
    },
    {
        "type": "azure_ai_evaluator",
        "name": "relevance_eval",
        "evaluator_name": "builtin.relevance",
        "data_mapping": {
            "question": "{{item.prompt_text}}",
            "answer": "{{target.response}}"
        },
    }
]

print(f"Configured {len(testing_criteria)} AI-assisted evaluators.")

Aquí, estoy configurando una lista de diccionarios, cada uno configurando un evaluador. evaluator_name especifica la métrica, y data_mapping utiliza una sintaxis de plantilla para conectar las entradas. {{item.prompt_text}} y {{item.context_text}} se refieren a campos en mi conjunto de datos, mientras que {{target.response}} es un marcador de posición especial para la finalización generada por el modelo bajo evaluación. A menudo me refiero a la documentación de Azure sobre métricas de evaluación para los mapeos exactos.

Con mis datos y evaluadores definidos, el siguiente paso es crear un objeto de evaluación y luego activar una ejecución. Este es un proceso asíncrono gestionado por Azure AI. Normalmente lo inicio y luego superviso su progreso en el portal.

# Obtengo el cliente de OpenAI del cliente del proyecto para interactuar con las evaluaciones.
openai_client = project_client.get_openai_client()

print("Creating evaluation object...")
eval_object = openai_client.evals.create(
    name="Financial QA Evaluation",
    testing_criteria=testing_criteria, # type: ignore
)
print(f"Evaluation object created (id: {eval_object.id}).")

# Defino la fuente de datos y el modelo de destino a evaluar.
data_source = {
    "type": "azure_ai_target_completions",
    "source": data_for_evaluation,
    "input_messages": {
        "type": "template",
        "template": [
            {
                "type": "message",
                "role": "user",
                "content": [
                    {"type": "input_text", "text": "Context: {{item.context_text}}\n\nQuestion: {{item.prompt_text}}"}
                ]
            }
        ],
    },
    "target": {
        "type": "azure_ai_model_deployment",
        "name": EVALUATION_TARGET_DEPLOYMENT
    },
}

print("Starting evaluation run...")
# Nota: Esta operación incurrirá en costos basados en el uso de tokens de los LLM subyacentes.
# A principios de 2026, un costo representativo podría ser de aproximadamente
# 0,01 € por 1k tokens de entrada y 0,03 € por 1k tokens de salida. (Usando $1 \u2248 0,92 € de conversión)

eval_run = openai_client.evals.runs.create(
    eval_id=eval_object.id,
    name="financial_qa_eval_202604",
    data_source=data_source # type: ignore
)

print(f"Evaluation run created and is in progress (id: {eval_run.id}).")
print("Monitor the run status and view results in the Azure AI Foundry portal.")

La función evals.create registra mi definición de evaluación, y evals.runs.create inicia la ejecución real. Utiliza el eval_id del paso anterior, un name legible para la ejecución (que aparece en el portal) y un objeto data_source. Este objeto le indica a Azure los datos de entrada, cómo formatearlos en una solicitud para el modelo y qué modelo implementado (target) quiero evaluar. Toda la ejecución se realiza en segundo plano en Azure.

Una vez que la ejecución de la evaluación se completa en el portal de Azure AI Foundry, puedo descargar los resultados como un archivo JSONL para un análisis detallado. Normalmente navego a la sección "Evaluaciones" en mi Proyecto de IA en el portal, encuentro mi ejecución (financial_qa_eval_202604) y luego descargo el archivo evaluation_results.jsonl en mi carpeta eval_outputs. A partir de ahí, utilizo Python para analizar los resultados usando pandas para la manipulación de datos y tabulate para un formato markdown limpio.

import pandas as pd
import json

# Este paso asume que he descargado los resultados del portal.
results_path = os.path.join(OUTPUT_FOLDER, "evaluation_results.jsonl")

try:
    # El archivo de resultados contiene un objeto JSON por línea.
    with open(results_path, 'r') as f:
        lines = f.readlines()

    # Cada línea tiene una estructura compleja; necesito extraer las partes relevantes.
    parsed_results = []
    for line in lines:
        data = json.loads(line)
        # Extraer datos de entrada y métricas de evaluación.
        # La estructura exacta puede variar; normalmente inspecciono mi archivo JSONL primero.
        result_item = data.get('item', {})
        metrics = data.get('metrics', {})

        parsed_results.append({
            'prompt_text': result_item.get('prompt_text'),
            'completion_text': data.get('response'), # La respuesta generada
            'groundedness_score': metrics.get('groundedness_eval.groundedness'),
            'relevance_score': metrics.get('relevance_eval.relevance')
        })

    results_df = pd.DataFrame(parsed_results)

    print("\n--- Resultados detallados por instancia (primeras 2 filas) ---")
    print(results_df.head(2).to_markdown(index=False))

    # Ejemplo: calcular y mostrar métricas agregadas.
    print("\n--- Resultados de evaluación agregados ---")
    print(f"  Fundamentación promedio: {results_df['groundedness_score'].mean():.2f}")
    print(f"  Relevancia promedio: {results_df['relevance_score'].mean():.2f}")

except FileNotFoundError:
    print(f"\nAnálisis omitido: No se pudo encontrar '{results_path}'. Descárguelo primero del portal de Azure AI Foundry.")

Este script lee el archivo JSONL descargado línea por línea, analiza la compleja estructura JSON para extraer la indicación de entrada, la finalización generada por el modelo y las puntuaciones de cada métrica. Luego cargo estos datos en un DataFrame de Pandas, lo que simplifica el análisis y la agregación.

Aunque el SDK me brinda control programático, sigo confiando mucho en el portal de Azure AI Foundry. Ofrece una interfaz de usuario centralizada para monitorear mis ejecuciones de evaluación, lo cual es particularmente útil para la supervisión operativa.

1. Navegar a Azure AI Foundry : Inicie sesión en el portal de Azure AI Studio.
2. Localizar mi proyecto : Seleccione su proyecto de Azure AI.
3. Buscar ejecuciones de evaluación : Vaya a la sección "Evaluaciones". Debería ver una lista de evaluaciones y sus ejecuciones, incluida financial_qa_eval_202604.
4. Revisar métricas y detalles : Al hacer clic en mi ejecución de evaluación, se me muestran métricas agregadas, resultados detallados por instancia y visualizaciones del rendimiento. Es la interfaz principal para rastrear tendencias en métricas como la fundamentación y la relevancia a lo largo del tiempo.

• Menor privilegio : Siempre me aseguro de que cualquier principal de servicio o identidad administrada utilizada por mis pipelines de evaluación tenga solo los permisos necesarios, nada más.
• Protección de datos : Cifrar los conjuntos de datos de evaluación en reposo y en tránsito no es negociable. También implemento la anonimización de datos para cualquier dato sensible.
• Identidades administradas : Para cargas de trabajo de producción, utilizo exclusivamente identidades administradas de Azure para autenticarme en los servicios de Azure. Esto simplifica la gestión de credenciales y mejora la seguridad.

• Procesamiento por lotes : El marco de evaluación está intrínsecamente diseñado para procesar conjuntos de datos en lotes de manera eficiente, así que lo aprovecho.
• Elección del evaluador : Si bien GPT-4 ofrece un razonamiento superior, he descubierto que puede ser más costoso y lento. Para evaluaciones a gran escala donde el costo y la latencia son preocupaciones, a menudo opto por GPT-3.5 Turbo si su calidad es aceptable para la tarea.

• Pipelines de azure machine learning : La integración de mi lógica de evaluación en pipelines de Azure Machine Learning permite una ejecución automatizada y escalable en flujos de trabajo de MLOps.
• Despliegue regional : Para mis proyectos europeos, siempre implemento recursos de Azure AI en regiones europeas como westeurope o northeurope para minimizar la latencia para los usuarios con sede en la UE y garantizar el cumplimiento de la residencia de datos.

• Alertas : La configuración de alertas de Azure Monitor sobre métricas de evaluación clave es crucial. Por ejemplo, podría activar una alerta si la puntuación media de fundamentación cae por debajo de un umbral predefinido.
• Paneles : Creo paneles personalizados, ya sea en Azure AI Foundry o Azure Monitor, para visualizar las tendencias en las métricas de evaluación a lo largo del tiempo. Esto me ayuda a detectar regresiones rápidamente.
• Monitoreo de costos : El monitoreo continuo del costo asociado con mis llamadas LLM para la evaluación es vital. Establezco presupuestos y alertas de costos para evitar gastos inesperados excesivos.

• Azure AI Foundry proporciona una plataforma robusta para la evaluación programática de modelos de IA generativa, crucial para las aplicaciones RAG.
• El SDK azure.ai.project permite definir criterios de evaluación, conectar conjuntos de datos y activar ejecuciones de evaluación directamente desde Python.
• Las métricas clave como Groundedness y Relevance se evalúan automáticamente utilizando evaluadores asistidos por IA alojados dentro del Proyecto de Azure AI.
• El monitoreo de los resultados en el portal de Azure AI Foundry y la integración del análisis en los pipelines de CI/CD son esenciales para mantener la calidad del modelo.
• El monitoreo de costos del uso de LLM durante las evaluaciones es fundamental para administrar los gastos, con costos típicos de aproximadamente 0,01 € por 1k tokens de entrada y 0,03 € por 1k tokens de salida (utilizando 1 $ \u2248 0,92 €).