Evaluación de la aplicación de IA generativa localmente con el SDK de evaluación de Azure AI (versión preliminar)

Puede evaluar exhaustivamente el rendimiento de la aplicación de IA generativa aplicándolo a un conjunto de datos considerable. Evalúe la aplicación en el entorno de desarrollo con el SDK de evaluación de Azure AI.

Al proporcionar un conjunto de datos de prueba o un destino, las salidas de la aplicación de IA generativa se miden cuantitativamente con métricas basadas en matemáticas y evaluadores de calidad y seguridad asistidos por IA. Los evaluadores integrados o personalizados pueden proporcionarle información completa sobre las funcionalidades y limitaciones de la aplicación.

En este artículo, aprenderá a ejecutar evaluadores en una sola fila de datos y un conjunto de datos de prueba mayor en un destino de aplicación. Puede usar evaluadores integrados que usan el SDK de evaluación de Azure AI localmente. A continuación, aprenderá a realizar un seguimiento de los resultados y los registros de evaluación en un proyecto Foundry.

Comienza

En primer lugar, instale el paquete de evaluadores desde el SDK de evaluación de Azure AI:

pip install azure-ai-evaluation

Evaluadores integrados

Las métricas de seguridad y calidad integradas aceptan pares de consulta y respuesta, junto con información adicional para evaluadores específicos.

Requisitos de datos para evaluadores integrados

Los evaluadores integrados pueden aceptar pares de consulta y respuesta, una lista de conversaciones en formato JSON Lines (JSONL) o ambos.

Los calificadores de Azure OpenAI requieren una plantilla que describa cómo se convierten sus columnas de entrada en la entrada real que usa el calificador. Por ejemplo, si tiene dos entradas denominadas consulta y respuesta, y una plantilla con formato {{item.query}}, solo se usa la consulta. Del mismo modo, podría tener algo parecido a {{item.conversation}} para aceptar una entrada de conversación, pero la capacidad del sistema para controlarlo depende de cómo configure el resto del calificador para esperar esa entrada.

Para más información sobre los requisitos de datos para evaluadores agente, consulte Evaluación de los agentes de IA.

Soporte para una sola interacción con texto

Todos los evaluadores integrados toman entradas de un solo turno como pares de consulta y respuesta en cadenas. Por ejemplo:

from azure.ai.evaluation import RelevanceEvaluator

query = "What is the capital of life?"
response = "Paris."

# Initialize an evaluator:
relevance_eval = RelevanceEvaluator(model_config)
relevance_eval(query=query, response=response)

Para ejecutar evaluaciones por lotes mediante la evaluación local o cargar el conjunto de datos para ejecutar una evaluación en la nube, represente el conjunto de datos en formato JSONL. Los datos anteriores de un solo turno, que es un par de consulta y respuesta, equivalen a una línea de un conjunto de datos como el ejemplo siguiente, que muestra tres líneas:

{"query":"What is the capital of France?","response":"Paris."}
{"query":"What atoms compose water?","response":"Hydrogen and oxygen."}
{"query":"What color is my shirt?","response":"Blue."}

El conjunto de datos de prueba de evaluación puede contener los siguientes elementos, en función de los requisitos de cada evaluador integrado:

• Consulta: la consulta enviada a la aplicación de IA generativa.
• Respuesta: la respuesta a la consulta generada por la aplicación de IA generativa.
• Contexto: el origen en el que se basa la respuesta generada. Es decir, los documentos de base.
• Verdad básica: la respuesta generada por un usuario o un ser humano como la respuesta verdadera.

Para ver qué requiere cada evaluador, consulte Evaluadores.

Compatibilidad de conversación con texto

Para los evaluadores que admiten conversaciones de texto, puede proporcionar conversation como entrada. Esta entrada incluye un diccionario de Python con una lista de messages, que incluye content, roley opcionalmente context.

Consulte la siguiente conversación de dos turnos en Python:

conversation = {
        "messages": [
        {
            "content": "Which tent is the most waterproof?", 
            "role": "user"
        },
        {
            "content": "The Alpine Explorer Tent is the most waterproof",
            "role": "assistant", 
            "context": "From the our product list the alpine explorer tent is the most waterproof. The Adventure Dining Table has higher weight."
        },
        {
            "content": "How much does it cost?",
            "role": "user"
        },
        {
            "content": "The Alpine Explorer Tent is $120.",
            "role": "assistant",
            "context": None
        }
        ]
}

Para ejecutar evaluaciones por lotes mediante la evaluación local o cargar el conjunto de datos para ejecutar la evaluación en la nube, debe representar el conjunto de datos en formato JSONL. La conversación anterior es equivalente a una línea de conjunto de datos en un archivo JSONL como en el ejemplo siguiente:

{"conversation":
    {
        "messages": [
        {
            "content": "Which tent is the most waterproof?", 
            "role": "user"
        },
        {
            "content": "The Alpine Explorer Tent is the most waterproof",
            "role": "assistant", 
            "context": "From the our product list the alpine explorer tent is the most waterproof. The Adventure Dining Table has higher weight."
        },
        {
            "content": "How much does it cost?",
            "role": "user"
        },
        {
            "content": "The Alpine Explorer Tent is $120.",
            "role": "assistant",
            "context": null
        }
        ]
    }
}

Nuestros evaluadores comprenden que el primer turno de la conversación proporciona valores válidos query de user, context de assistant y response de assistant en el formato de consulta y respuesta. Las conversaciones se evalúan por turno y los resultados se agregan en todos los turnos para una puntuación de conversación.

Para el modo de conversación, este es un ejemplo de GroundednessEvaluator:

# Conversation mode:
import json
import os
from azure.ai.evaluation import GroundednessEvaluator, AzureOpenAIModelConfiguration

model_config = AzureOpenAIModelConfiguration(
    azure_endpoint=os.environ.get("AZURE_ENDPOINT"),
    api_key=os.environ.get("AZURE_API_KEY"),
    azure_deployment=os.environ.get("AZURE_DEPLOYMENT_NAME"),
    api_version=os.environ.get("AZURE_API_VERSION"),
)

# Initialize the Groundedness evaluator:
groundedness_eval = GroundednessEvaluator(model_config)

conversation = {
    "messages": [
        { "content": "Which tent is the most waterproof?", "role": "user" },
        { "content": "The Alpine Explorer Tent is the most waterproof", "role": "assistant", "context": "From the our product list the alpine explorer tent is the most waterproof. The Adventure Dining Table has higher weight." },
        { "content": "How much does it cost?", "role": "user" },
        { "content": "$120.", "role": "assistant", "context": "The Alpine Explorer Tent is $120."}
    ]
}

# Alternatively, you can load the same content from a JSONL file.
groundedness_conv_score = groundedness_eval(conversation=conversation)
print(json.dumps(groundedness_conv_score, indent=4))

Para las salidas de conversaciones, los resultados por turno se almacenan en una lista y la puntuación general de la conversación 'groundedness': 4.0 se promedia entre los turnos:

{
    "groundedness": 5.0,
    "gpt_groundedness": 5.0,
    "groundedness_threshold": 3.0,
    "evaluation_per_turn": {
        "groundedness": [
            5.0,
            5.0
        ],
        "gpt_groundedness": [
            5.0,
            5.0
        ],
        "groundedness_reason": [
            "The response accurately and completely answers the query by stating that the Alpine Explorer Tent is the most waterproof, which is directly supported by the context. There are no irrelevant details or incorrect information present.",
            "The RESPONSE directly answers the QUERY with the exact information provided in the CONTEXT, making it fully correct and complete."
        ],
        "groundedness_result": [
            "pass",
            "pass"
        ],
        "groundedness_threshold": [
            3,
            3
        ]
    }
}

Compatibilidad de conversación para imágenes y texto e imagen multimodal

Para los evaluadores que admiten conversaciones multimodales de imagen y texto, puede pasar direcciones URL de imágenes o imágenes codificadas en Base64 en conversation.

Entre los escenarios admitidos se incluyen:

• Múltiples imágenes con entrada de texto para la generación de imágenes o texto.
• Entrada de solo texto para las generaciones de imágenes.
• Entrada de imagen solamente para la generación de texto.

from pathlib import Path
from azure.ai.evaluation import ContentSafetyEvaluator
import base64

# Create an instance of an evaluator with image and multi-modal support.
safety_evaluator = ContentSafetyEvaluator(credential=azure_cred, azure_ai_project=project_scope)

# Example of a conversation with an image URL:
conversation_image_url = {
    "messages": [
        {
            "role": "system",
            "content": [
                {"type": "text", "text": "You are an AI assistant that understands images."}
            ],
        },
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Can you describe this image?"},
                {
                    "type": "image_url",
                    "image_url": {
                        "url": "https://cdn.britannica.com/68/178268-050-5B4E7FB6/Tom-Cruise-2013.jpg"
                    },
                },
            ],
        },
        {
            "role": "assistant",
            "content": [
                {
                    "type": "text",
                    "text": "The image shows a man with short brown hair smiling, wearing a dark-colored shirt.",
                }
            ],
        },
    ]
}

# Example of a conversation with base64 encoded images:
base64_image = ""

with Path.open("Image1.jpg", "rb") as image_file:
    base64_image = base64.b64encode(image_file.read()).decode("utf-8")

conversation_base64 = {
    "messages": [
        {"content": "create an image of a branded apple", "role": "user"},
        {
            "content": [{"type": "image_url", "image_url": {"url": f"data:image/jpg;base64,{base64_image}"}}],
            "role": "assistant",
        },
    ]
}

# Run the evaluation on the conversation to output the result.
safety_score = safety_evaluator(conversation=conversation_image_url)

Actualmente, los evaluadores de imágenes y multimodales admiten:

• Solo turno único: una conversación solo puede tener un mensaje de usuario y un mensaje de asistente.
• Conversaciones que solo tienen un mensaje del sistema.
• Cargas de conversación que son menores de 10 MB, incluidas las imágenes.
• Direcciones URL absolutas y imágenes codificadas en Base64.
• Varias imágenes en un solo turno.
• Formatos de archivo JPG/JPEG, PNG y GIF.

Configuración

En el caso de los evaluadores de calidad asistidos por IA, excepto para la GroundednessProEvaluator versión preliminar, debe especificar un modelo de GPT (gpt-35-turbo, gpt-4, gpt-4-turbo, gpt-4o o gpt-4o-mini) en su model_config. El modelo GPT actúa como juez para puntuar los datos de evaluación. Se admiten esquemas de configuración de modelos de Azure OpenAI o OpenAI. Para obtener el mejor rendimiento y respuestas analizables con nuestros evaluadores, se recomienda usar modelos GPT que no estén en versión preliminar.

Para todos los evaluadores de riesgos y seguridad y GroundednessProEvaluator (versión preliminar), en lugar de una implementación de GPT en model_config, debe proporcionar su azure_ai_project información. Se accede al servicio de evaluación del backend utilizando tu proyecto Foundry.

Solicitudes de evaluadores integrados asistidos por IA

Para transparencia, publicamos como código abierto las instrucciones de nuestros evaluadores de calidad en nuestra biblioteca de evaluadores y en el repositorio del SDK de Python de evaluación de Azure AI, excepto los evaluadores de seguridad y GroundednessProEvaluator, impulsados por la tecnología de Azure AI Content Safety. Estas indicaciones sirven como instrucciones para que un modelo de lenguaje realice su tarea de evaluación, lo que requiere una definición fácil de usar de la métrica y sus rubrices de puntuación asociadas. Le recomendamos encarecidamente que personalice las definiciones y la calificación de las rubrices a los detalles de su escenario. Para obtener más información, consulte Evaluadores personalizados.

Evaluadores compuestos

Los evaluadores compuestos son evaluadores integrados que combinan métricas de seguridad o calidad individuales. Proporcionan una amplia gama de métricas directamente de fábrica para los pares de respuesta de consulta o los mensajes de chat.

Evaluación local en conjuntos de datos de prueba mediante evaluate()

Después de comprobar los evaluadores integrados o personalizados en una sola fila de datos, puede combinar varios evaluadores con la API evaluate() en un conjunto de datos de prueba completo.

Pasos de configuración de requisitos previos para proyectos de Microsoft Foundry

Si esta sesión es la primera vez que ejecuta evaluaciones y la registra en el proyecto foundry, es posible que tenga que realizar los pasos de configuración siguientes:

1. Cree y conecte su cuenta de almacenamiento a su proyecto Foundry a nivel de recurso. Esta plantilla de Bicep aprovisiona y conecta una cuenta de almacenamiento al proyecto Foundry con autenticación de clave.
2. Asegúrese de que la cuenta de almacenamiento conectada tiene acceso a todos los proyectos.
3. Si ha conectado la cuenta de almacenamiento con el identificador de Entra de Microsoft, asegúrese de conceder permisos de identidad de Microsoft al propietario de datos de Storage Blob a su cuenta y al recurso del proyecto Foundry en Azure Portal.

Evaluar en un conjunto de datos y registrar los resultados en Foundry

Para asegurarse de que la evaluate() API puede analizar correctamente los datos, debe especificar la asignación de columnas para asignar la columna del conjunto de datos a palabras clave que aceptan los evaluadores. En este ejemplo se especifica la asignación de datos para query, responsey context.

from azure.ai.evaluation import evaluate

result = evaluate(
    data="data.jsonl", # Provide your data here:
    evaluators={
        "groundedness": groundedness_eval,
        "answer_length": answer_length
    },
    # Column mapping:
    evaluator_config={
        "groundedness": {
            "column_mapping": {
                "query": "${data.queries}",
                "context": "${data.context}",
                "response": "${data.response}"
            } 
        }
    },
    # Optionally, provide your Foundry project information to track your evaluation results in your project portal.
    azure_ai_project = azure_ai_project,
    # Optionally, provide an output path to dump a JSON file of metric summary, row-level data, and the metric and Foundry project URL.
    output_path="./myevalresults.json"
)

El evaluador produce resultados en un diccionario, que contiene datos y métricas agregadas metrics y a nivel de fila. Consulte la salida del ejemplo siguiente:

{'metrics': {'answer_length.value': 49.333333333333336,
             'groundedness.gpt_groundeness': 5.0, 'groundedness.groundeness': 5.0},
 'rows': [{'inputs.response': 'Paris is the capital of France.',
           'inputs.context': 'Paris has been the capital of France since '
                                  'the 10th century and is known for its '
                                  'cultural and historical landmarks.',
           'inputs.query': 'What is the capital of France?',
           'outputs.answer_length.value': 31,
           'outputs.groundeness.groundeness': 5,
           'outputs.groundeness.gpt_groundeness': 5,
           'outputs.groundeness.groundeness_reason': 'The response to the query is supported by the context.'},
          {'inputs.response': 'Albert Einstein developed the theory of '
                            'relativity.',
           'inputs.context': 'Albert Einstein developed the theory of '
                                  'relativity, with his special relativity '
                                  'published in 1905 and general relativity in '
                                  '1915.',
           'inputs.query': 'Who developed the theory of relativity?',
           'outputs.answer_length.value': 51,
           'outputs.groundeness.groundeness': 5,
           'outputs.groundeness.gpt_groundeness': 5,
           'outputs.groundeness.groundeness_reason': 'The response to the query is supported by the context.'},
          {'inputs.response': 'The speed of light is approximately 299,792,458 '
                            'meters per second.',
           'inputs.context': 'The exact speed of light in a vacuum is '
                                  '299,792,458 meters per second, a constant '
                                  "used in physics to represent 'c'.",
           'inputs.query': 'What is the speed of light?',
           'outputs.answer_length.value': 66,
           'outputs.groundeness.groundeness': 5,
           'outputs.groundeness.gpt_groundeness': 5,
           'outputs.groundeness.groundeness_reason': 'The response to the query is supported by the context.'}],
 'traces': {}}

Requisitos para evaluate()

La evaluate() API requiere un formato de datos específico y nombres de clave de parámetro del evaluador para mostrar los gráficos de resultados de evaluación en el proyecto Foundry correctamente.

Formato de datos

La evaluate() API solo acepta datos en formato JSONL. Para todos los evaluadores integrados, evaluate() requiere datos con el siguiente formato con los campos de entrada necesarios. Consulte la sección anterior sobre la entrada de datos necesaria para evaluadores integrados. El siguiente fragmento de código es un ejemplo del aspecto que puede tener una línea:

{
  "query":"What is the capital of France?",
  "context":"France is in Europe",
  "response":"Paris is the capital of France.",
  "ground_truth": "Paris"
}

Formato de los parámetro de evaluador

Al pasar los evaluadores integrados, especifique la correcta asignación de palabras clave en la lista de parámetros evaluators. En la tabla siguiente se muestra la asignación de palabras clave necesaria para que los resultados de los evaluadores integrados se muestren en la interfaz de usuario al iniciar sesión en el proyecto foundry.

Este es un ejemplo de cómo establecer los evaluators parámetros:

result = evaluate(
    data="data.jsonl",
    evaluators={
        "sexual":sexual_evaluator,
        "self_harm":self_harm_evaluator,
        "hate_unfairness":hate_unfairness_evaluator,
        "violence":violence_evaluator
    }
)

Evaluación local en un destino

Si tiene una lista de consultas que desea ejecutar y evaluar, la evaluate() API también admite un target parámetro. Este parámetro envía consultas a una aplicación para recopilar respuestas y, a continuación, ejecuta sus evaluadores sobre la consulta y la respuesta resultantes.

Un destino puede ser cualquier clase invocable en el directorio. En este ejemplo, hay un script de askwiki.py Python con una clase askwiki() invocable que se establece como destino. Si tiene un conjunto de datos de consultas que puede enviar a la aplicación sencilla askwiki, puede evaluar la fundamentación de las salidas. Asegúrese de que especifique la asignación de columnas correcta para sus datos en "column_mapping". Puede usar "default" para especificar la asignación de columna para todos los evaluadores.

Este es el contenido de "data.jsonl":

{"query":"When was United States found ?", "response":"1776"}
{"query":"What is the capital of France?", "response":"Paris"}
{"query":"Who is the best tennis player of all time ?", "response":"Roger Federer"}

from askwiki import askwiki

result = evaluate(
    data="data.jsonl",
    target=askwiki,
    evaluators={
        "groundedness": groundedness_eval
    },
    evaluator_config={
        "default": {
            "column_mapping": {
                "query": "${data.queries}",
                "context": "${outputs.context}",
                "response": "${outputs.response}"
            } 
        }
    }
)

Contenido relacionado

• Biblioteca cliente de evaluación de Azure AI para Python
• Solución de problemas del SDK de evaluación de IA
• Observabilidad en IA generativa
• Ejecución de evaluaciones en la nube mediante el SDK de Microsoft Foundry
• Generación de datos sintéticos y simulados para la evaluación
• Consulte los resultados de evaluación en el portal de Foundry.
• Introducción a Foundry
• Introducción a los ejemplos de evaluación