Ejecuta una evaluación

Puedes usar el módulo de Gen AI Evaluation del SDK de Vertex AI para Python para evaluar de manera programática tus modelos y aplicaciones de lenguaje generativo con la API de Gen AI Evaluation Service. En esta página, se muestra cómo ejecutar evaluaciones con el SDK de Vertex AI.

Antes de comenzar

Instala el SDK de Vertex AI

Para instalar el módulo de Gen AI Evaluation desde el SDK de Vertex AI para Python, ejecuta el siguiente comando:

!pip install -q google-cloud-aiplatform[evaluation]

Si quieres obtener más información, consulta Instala el SDK de Vertex AI para Python.

Autentica el SDK de Vertex AI

Después de instalar el SDK de Vertex AI para Python, debes autenticarte. En los siguientes temas, se explica cómo autenticar con el SDK de Vertex AI si trabajas de forma local y en Colaboratory:

• Si desarrollas de manera local, configura las credenciales predeterminadas de la aplicación (ADC) en tu entorno local:

  1. Instala Google Cloud CLI y, luego, inicialízala a través de la ejecución del siguiente comando:

     gcloud init
     

  2. Crea credenciales de autenticación locales para tu Cuenta de Google:

     gcloud auth application-default login
     

     Se muestra una pantalla de acceso. Después de acceder, tus credenciales se almacenan en el archivo de credenciales local que usa ADC. Para obtener más información sobre cómo trabajar con ADC en un entorno local, consulta Entorno de desarrollo local.

• Si trabajas en Colaboratory, ejecuta el siguiente comando en una celda de Colab para autenticarte:

  from google.colab import auth
  auth.authenticate_user()
  

  Este comando abre una ventana en la que puedes completar la autenticación.

Comprende las cuentas de servicio

El servicio de evaluación de Gen AI usa la cuenta de servicio para obtener predicciones de la API de Gemini en Vertex AI para las métricas de evaluación basadas en modelos. Esta cuenta de servicio se aprovisiona automáticamente en la primera solicitud al servicio de evaluación de IA general.

Los permisos asociados con el agente de servicio de evaluación rápida son los siguientes:

Ejecuta la evaluación

Usa la clase EvalTask para ejecutar evaluaciones para los siguientes casos de uso:

• Métricas basadas en modelos

  • Usa ejemplos existentes

  • Usa una interfaz con plantillas

  • Define métricas desde cero

  • Evalúa un modelo de traducción

• Métricas basadas en el procesamiento

• Personalización adicional de las métricas

• Aumenta los límites de frecuencia y la cuota

Clase EvalTask

La clase EvalTask te ayuda a evaluar modelos y aplicaciones en función de tareas específicas. Para realizar comparaciones justas entre modelos generativos, por lo general, debes evaluar varios modelos y solicitar plantillas de forma repetida en un conjunto de datos de evaluación fijo con métricas específicas. También es importante evaluar varias métricas de forma simultánea en una sola ejecución de evaluación.

EvalTask también se integra en Vertex AI Experiments para ayudarte a hacer un seguimiento de la configuración y los resultados de cada ejecución de evaluación. Vertex AI Experiments ayuda a interpretar y administrar los resultados de la evaluación, lo que te permite tomar decisiones fundamentadas.

En el siguiente ejemplo, se muestra cómo crear una instancia de la clase EvalTask y ejecutar una evaluación:

from vertexai.evaluation import (
    EvalTask,
    PairwiseMetric,
    PairwiseMetricPromptTemplate,
    PointwiseMetric,
    PointwiseMetricPromptTemplate,
    MetricPromptTemplateExamples，
)

eval_task = EvalTask(
    dataset=DATASET,
    metrics=[METRIC_1, METRIC_2, METRIC_3],
    experiment=EXPERIMENT_NAME,
)

eval_result = eval_task.evaluate(
    model=MODEL,
    prompt_template=PROMPT_TEMPLATE,
    experiment_run=EXPERIMENT_RUN,
)

Ejecuta la evaluación con métricas basadas en modelos

Para las métricas basadas en modelos, usa las clases PointwiseMetric y PairwiseMetric para definir métricas adaptadas a tus criterios específicos. Ejecuta evaluaciones con las siguientes opciones:

• Usa ejemplos existentes

• Usa una interfaz con plantillas

• Define métricas desde cero

Usa ejemplos de métricas basadas en modelos

Puedes usar directamente la constante integrada Metric Prompt Template Examples dentro del SDK de Vertex AI. Como alternativa, puedes modificarlos e incorporarlos en la interfaz de definición de métricas de formato libre.

Para obtener la lista completa de ejemplos de plantillas de instrucciones de métricas que abarcan la mayoría de los casos de uso clave, consulta Plantillas de instrucciones de métricas.

En el siguiente ejemplo del SDK de Vertex AI, se muestra cómo usar la clase MetricPromptTemplateExamples para definir tus métricas:

# View all the available examples of model-based metrics
MetricPromptTemplateExamples.list_example_metric_names()

# Display the metric prompt template of a specific example metric
print(MetricPromptTemplateExamples.get_prompt_template('fluency'))

# Use the pre-defined model-based metrics directly
eval_task = EvalTask(
    dataset=EVAL_DATASET,
    metrics=[MetricPromptTemplateExamples.Pointwise.FLUENCY],
)

eval_result = eval_task.evaluate(
    model=MODEL,
)

Usa una interfaz de plantillas de métricas basadas en modelos

Para personalizar tus métricas, propaga campos como Criteria y Rating Rubrics con las clases PointwiseMetricPromptTemplate y PairwiseMetricPromptTemplate del SDK de Vertex AI. A ciertos campos, como Instruction, se les asigna un valor predeterminado si no proporcionas una entrada.

De manera opcional, puedes especificar input_variables, que es una lista de campos de entrada que usa la plantilla de instrucciones de métricas para generar resultados de evaluación basados en modelos. De forma predeterminada, se incluye la columna response del modelo para las métricas puntuales, y se incluyen las columnas response y baseline_model_response del modelo candidato para las métricas por pares.

Para obtener más información, consulta la sección "Cómo estructurar una plantilla de instrucción de métrica" en Plantillas de instrucciones de métricas.

# Define a pointwise metric with two custom criteria
custom_text_quality = PointwiseMetric(
    metric="custom_text_quality",
    metric_prompt_template=PointwiseMetricPromptTemplate(
        criteria={
          "fluency": "Sentences flow smoothly and are easy to read, avoiding awkward phrasing or run-on sentences. Ideas and sentences connect logically, using transitions effectively where needed.",
          "entertaining": "Short, amusing text that incorporates emojis, exclamations and questions to convey quick and spontaneous communication and diversion.",
        },
        rating_rubric={
          "1": "The response performs well on both criteria.",
          "0": "The response is somewhat aligned with both criteria",
          "-1": "The response falls short on both criteria",
        },
        input_variables=["prompt"],
    ),
)

# Display the serialized metric prompt template
print(custom_text_quality.metric_prompt_template)

# Run evaluation using the custom_text_quality metric
eval_task = EvalTask(
    dataset=EVAL_DATASET,
    metrics=[custom_text_quality],
)
eval_result = eval_task.evaluate(
    model=MODEL,
)

Usa la interfaz de SDK de formato libre de métricas basadas en modelos

Para obtener más flexibilidad a la hora de personalizar la plantilla de instrucciones de métricas, puedes definir una métrica directamente con la interfaz de formato libre, que acepta una entrada de cadena directa.

# Define a pointwise multi-turn chat quality metric
pointwise_chat_quality_metric_prompt = """Evaluate the AI's contribution to a meaningful conversation, considering coherence, fluency, groundedness, and conciseness.
 Review the chat history for context. Rate the response on a 1-5 scale, with explanations for each criterion and its overall impact.

# Conversation History
{history}

# Current User Prompt
{prompt}

# AI-generated Response
{response}
"""

freeform_multi_turn_chat_quality_metric = PointwiseMetric(
    metric="multi_turn_chat_quality_metric",
    metric_prompt_template=pointwise_chat_quality_metric_prompt,
)

# Run evaluation using the freeform_multi_turn_chat_quality_metric metric
eval_task = EvalTask(
    dataset=EVAL_DATASET,
    metrics=[freeform_multi_turn_chat_quality_metric],
)
eval_result = eval_task.evaluate(
    model=MODEL,
)

Cómo evaluar un modelo de traducción

Para evaluar tu modelo de traducción, puedes especificar BLEU, MetricX o COMET como métricas de evaluación cuando usas el SDK de Vertex AI.

#Prepare the dataset for evaluation.
sources = [
    "Dem Feuer konnte Einhalt geboten werden",
    "Schulen und Kindergärten wurden eröffnet.",
]

responses = [
    "The fire could be stopped",
    "Schools and kindergartens were open",
]

references = [
    "They were able to control the fire.",
    "Schools and kindergartens opened",
]

eval_dataset = pd.DataFrame({
    "source": sources,
    "response": responses,
    "reference": references,
})

# Set the metrics.

metrics = [
    "bleu",
    pointwise_metric.Comet(),
    pointwise_metric.MetricX(),
]

eval_task = evaluation.EvalTask(
    dataset=eval_dataset,
    metrics=metrics,
)
eval_result = eval_task.evaluate()

Ejecuta la evaluación con métricas basadas en procesamiento

Puedes usar las métricas basadas en el procesamiento de forma independiente o junto con las métricas basadas en modelos.

# Combine computation-based metrics "ROUGE" and "BLEU" with model-based metrics
eval_task = EvalTask(
    dataset=EVAL_DATASET,
    metrics=["rouge_l_sum", "bleu", custom_text_quality],
)
eval_result = eval_task.evaluate(
    model=MODEL,
)

Personalización adicional de métricas

Si necesitas personalizar aún más tus métricas, como elegir un modelo de juez diferente para las métricas basadas en modelos o definir una nueva métrica basada en el procesamiento, puedes usar la clase CustomMetric en el SDK de Vertex AI. Para obtener más detalles, consulta los siguientes notebooks:

Ejecuta la evaluación basada en modelos con límites de frecuencia y cuotas aumentados

Una sola solicitud de evaluación para una métrica basada en modelos genera varias solicitudes subyacentes a la API de Gemini en Vertex AI y consume la cuota de gemini-1.5-pro del modelo de juez. La cuota de solicitudes de modelos por minuto (RPM) se calcula por proyecto, lo que significa que tanto las solicitudes al modelo de juez gemini-1.5-pro como las solicitudes al servicio de evaluación de IA generativa para las métricas basadas en modelos se consideran para la cuota de RPM del modelo de juez del proyecto en una región específica para gemini-1.5-pro.

Debes aumentar la cuota de RPM del modelo de juez y establecer un límite de frecuencia del servicio de evaluación evaluation_service_qps más alto en los siguientes casos de uso:

• Mayor volumen de datos: Si procesas muchos más datos con las métricas basadas en modelos, es probable que alcances la cuota predeterminada de RPM. Aumentar la cuota te permite controlar el volumen más grande sin interrupciones ni degradación del rendimiento.

• Evaluación más rápida: Si tu aplicación requiere un tiempo de respuesta más rápido para las evaluaciones, es posible que necesites una cuota de RPM más alta. Esto es especialmente importante para las aplicaciones urgentes o con interacciones en tiempo real, en las que las demoras en la evaluación pueden afectar la experiencia del usuario.

• Tareas de evaluación complejas: Una cuota de RPM más alta garantiza que tengas suficiente capacidad para controlar evaluaciones que consumen muchos recursos para tareas complejas o grandes cantidades de texto.

• Coincidencia alta de usuarios: Si prevés que una gran cantidad de usuarios solicitará de forma simultánea evaluaciones y conclusiones basadas en modelos dentro de tu proyecto, un límite de RPM de modelo más alto es fundamental para evitar cuellos de botella y mantener la capacidad de respuesta.

Para aumentar la cuota del modelo y usar el SDK de Gen AI Evaluation Service con límites de frecuencia más altos, haz lo siguiente:

1. En la consola de Google Cloud, ve a la página Cuotas de IAM y administración.
   

   Ver cuotas en la consola

2. En el campo Filtro, especifica la dimensión (identificador de modelo) y la métrica (identificador de cuota para modelos de Gemini): base_model:gemini-1.5-pro y Metric:aiplatform.googleapis.com/generate_content_requests_per_minute_per_project_per_base_model.

3. En la cuota que deseas aumentar, haz clic en el botón more_vert del menú más acciones.

4. En el menú desplegable, haz clic en Editar cuota. Se abrirá el panel Cambios en la cuota.

5. En Editar cuota, ingresa un nuevo valor de cuota.

6. Haz clic en Enviar solicitud.

7. La solicitud de aumento de cuota se confirmará por correo electrónico y, por lo general, tarda dos días hábiles en procesarse.

8. Una vez que se apruebe tu solicitud de aumento de cuota por correo electrónico, puedes configurar el parámetro evaluation_service_qps de la siguiente manera:

from vertexai.evaluation import EvalTask

# GEMINI_RPM is the requests per minute (RPM) quota for gemini-1.5-pro in your region
# Evaluation Service QPS limit is equal to (gemini-1.5-pro RPM / 60 sec / default number of samples)
CUSTOM_EVAL_SERVICE_QPS_LIMIT = GEMINI_RPM / 60 / 4

eval_task = EvalTask(
    dataset=DATASET,
    metrics=[METRIC_1, METRIC_2, METRIC_3],
)

eval_result = eval_task.evaluate(
    evaluation_service_qps=CUSTOM_EVAL_SERVICE_QPS_LIMIT,
    # Specify a retry_timeout limit for a more responsive evaluation run
    # the default value is 600 (in seconds, or 10 minutes)
    retry_timeout=RETRY_TIMEOUT,
)

Para obtener más información sobre las cuotas y los límites, consulta Cuotas de Gen AI Evaluation Service y API de Gen AI Evaluation Service.

¿Qué sigue?

• Consulta los resultados de la evaluación.

• Busca una plantilla de métricas basadas en modelos.

• Prueba un notebook de ejemplo de evaluación.