Avaliação da IA autêntica

Avaliações dentro do circuito

As avaliações in-the-loop são realizadas durante a execução do agente. O resultado da avaliação pode ser usado imediatamente como um ponto de decisão para controlar a lógica do agente.

Por exemplo, em um fluxo de trabalho Agentic RAG (retrieval-augmented generation), você pode computar uma pontuação de relevância de contexto para os dados recuperados de um banco de dados vetorial:

• Se a pontuação de relevância for alta, o agente continua e gera uma resposta.
• Se a pontuação de relevância for baixa, o agente pode ser configurado para interromper a execução e retornar uma mensagem indicando que não pode responder à pergunta.

As avaliações in-the-loop o ajudam:

• Impedir que o agente produza respostas de baixa qualidade ou enganosas.
• Crie agentes de IA mais confiáveis e de alta qualidade que se adaptem dinamicamente às entradas que processam.

Avaliações off-line

As avaliações off-line são realizadas fora da execução do tempo de execução, geralmente durante o desenvolvimento e os testes. Essas avaliações o ajudam a medir e refinar a qualidade de um agente ou de suas ferramentas antes da implementação.

Por exemplo, você pode:

• Avalie uma única ferramenta usada por um agente para medir a precisão ou a confiabilidade.
• Avalie todo o fluxo do agente após a conclusão, usando dados ou cenários de teste.

As avaliações off-line fornecem percepções que ajudam os desenvolvedores a melhorar iterativamente o design e o desempenho do agente antes de colocá-lo em produção.

Avaliadores

O módulo de avaliação de IA agêntica usa os seguintes avaliadores para medir o desempenho dos casos de uso de RAGs agênticos:

• MetricGroup avaliadores

evaluator.evaluate_retrieval_quality

Um decorador de avaliação que calcula métricas de qualidade de recuperação em uma ferramenta agêntica. As métricas incluem relevância do contexto, precisão da recuperação, precisão média, taxa de acerto, classificação recíproca e NDCG.

evaluator.evaluate_answer_quality

Um decorador de avaliação que calcula métricas de qualidade de resposta em uma ferramenta agêntica. As métricas incluem relevância da resposta, fidelidade, similaridade da resposta e solicitações sem êxito.

evaluator.evaluate_content_safety

Um decorador de avaliação que calcula métricas de segurança de conteúdo em uma ferramenta agêntica. As métricas incluem HAP, PII, danos, preconceito social, profanação, conteúdo sexual, comportamento antiético, violência, envolvimento com danos, evasão e fuga da prisão.

evaluator.evaluate_readability

Um decorador de avaliação que calcula métricas de legibilidade em uma ferramenta agêntica. As métricas de legibilidade incluem Facilidade de Leitura do Texto e Nível de Escolha do Texto.

• Avaliadores de métricas

evaluator.evaluate_context_relevance

Calcula a métrica de relevância do contexto para sua ferramenta de recuperação de conteúdo.

evaluator.evaluate_faithfulness

Calcula a métrica de fidelidade para sua ferramenta de geração de respostas. Essa métrica não requer verdade fundamental.

evaluator.evaluate_answer_similarity

Calcula a métrica de similaridade de respostas para sua ferramenta de geração de respostas. Essa métrica requer verdade terrestre para o cálculo.

evaluator.evaluate_retrieval_precision

Um decorador de avaliação que calcula a métrica de precisão de recuperação em uma ferramenta agêntica. Essa métrica usa valores de relevância de contexto como um pré-requisito.

evaluator.evaluate_average_precision

Um decorador de avaliação que calcula a métrica de precisão média em uma ferramenta agêntica. Essa métrica usa valores de relevância de contexto como um pré-requisito.

evaluator.evaluate_hit_rate

Um decorador de avaliação que calcula a métrica de taxa de acerto em uma ferramenta agêntica. Essa métrica usa valores de relevância de contexto como um pré-requisito.

evaluator.evaluate_reciprocal_rank

Um decorador de avaliação que calcula a métrica de classificação recíproca em uma ferramenta agêntica. Essa métrica usa valores de relevância de contexto como um pré-requisito.

evaluator.evaluate_ndcg

Um decorador de avaliação que calcula a métrica NDCG (Normalized Discounted Cumulative Gain) em uma ferramenta agêntica. Essa métrica usa valores de relevância de contexto como um pré-requisito.

evaluator.evaluate_answer_relevance

Um decorador de avaliação que calcula a métrica de relevância da resposta em uma ferramenta agêntica.

evaluator.evaluate_unsuccessful_requests

Um decorador de avaliação que calcula a métrica de solicitações malsucedidas em uma ferramenta agêntica.

evaluator.evaluate_tool_call_syntactic_accuracy

Um decorador de avaliação que calcula a métrica de precisão sintática da chamada da ferramenta em uma ferramenta agêntica.

evaluator.evaluate_answer_quality

Um decorador de avaliação que calcula métricas de qualidade de resposta em uma ferramenta agêntica. As métricas incluem relevância da resposta, fidelidade, similaridade da resposta e solicitações sem êxito.

evaluator.evaluate_hap

Um decorador de avaliação que calcula a métrica HAP em uma ferramenta agêntica.

evaluator.evaluate_pii

Um decorador de avaliação que calcula a métrica PII em uma ferramenta agêntica.

evaluator.evaluate_harm

Um decorador de avaliação que calcula o risco de danos em uma ferramenta agêntica por meio do Granite Guardian.

evaluator.evaluate_social_bias

Um decorador de avaliação que calcula o risco de viés social em uma ferramenta agêntica por meio do Granite Guardian.

evaluator.evaluate_profanity

Um decorador de avaliação que calcula o risco de profanação em uma ferramenta agêntica por meio do Granite Guardian.

evaluator.evaluate_sexual_content

Um decorador de avaliação que calcula o risco de conteúdo sexual em uma ferramenta agêntica por meio do Granite Guardian.

evaluator.evaluate_unethical_behavior

Um decorador de avaliação que calcula o risco de comportamento antiético em uma ferramenta agêntica por meio do Granite Guardian.

evaluator.evaluate_violence

Um decorador de avaliação que calcula o risco de violência em uma ferramenta agêntica por meio do Granite Guardian.

evaluator.evaluate_harm_engagement

Um decorador de avaliação que calcula o risco de engajamento de danos em uma ferramenta agêntica por meio do Granite Guardian.

evaluator.evaluate_evasiveness

Um decorador de avaliação que calcula o risco de evasão em uma ferramenta agêntica por meio do Granite Guardian.

evaluator.evaluate_jailbreak

Um decorador de avaliação que calcula o risco de jailbreak em uma ferramenta autêntica por meio do Granite Guardian.

evaluator.evaluate_text_reading_ease

A métrica de facilidade de leitura de texto mede a legibilidade do texto. Ele é calculado usando o método flesch_reading_ease .

evaluator.evaluate_text_grade_level

A métrica de nível de série do texto mede o nível aproximado de U.S. série de um texto. Ele é calculado usando o método flesch_kincaid_grade .

evaluator.evaluate_prompt_safety_risk

A métrica Prompt Safety Risk avalia a probabilidade de uma IA responder com conteúdo prejudicial, inseguro ou inadequado. Disponível apenas nas regiões de Dallas (us-south) e Frankfurt (eu-de).

evaluator.evaluate_topic_relevance

A métrica Topic Relevance avalia a proximidade do conteúdo de entrada com o tópico especificado pelo site system_prompt. Disponível apenas nas regiões de Dallas (us-south) e Frankfurt (eu-de).

Para usar o módulo de avaliação do agentic AI, você deve instalar o ibm-watsonx-gov Python SDK com configurações específicas:

pip install "ibm-watsonx-gov[agentic]"

Configurar o estado

O SDK ibm-watsonx-gov Python fornece uma classe de estado baseada em pydantic que você pode estender:

from ibm_watsonx_gov.entities.state import EvaluationState

class AppState(EvaluationState):
    pass

Configurar o avaliador

Para avaliar os aplicativos de IA agêntica, você deve instanciar a classe AgenticEvaluation para definir avaliadores para calcular diferentes métricas:

from ibm_watsonx_gov.evaluators.agentic_evaluator import AgenticEvaluator

evaluator = AgenticEvaluator()

Você também pode executar uma versão avançada do avaliador:

from ibm_watsonx_gov.evaluators.agentic_evaluator import AgenticEvaluator
from ibm_watsonx_gov.config import AgenticAIConfiguration
from ibm_watsonx_gov.entities.agentic_app import (AgenticApp, MetricsConfiguration, Node)
from ibm_watsonx_gov.metrics import AnswerRelevanceMetric
from ibm_watsonx_gov.entities.enums import MetricGroup

# Define the metrics to be computed at the agentic app(interaction) level in metrics_configuration under AgenticApp,
# these metrics use the agent input and output fields.
# The node level metrics to be computed post the graph invocation can be specified in the nodes parameter of AgenticApp.
retrieval_quality_config_web_search_node = {
   "input_fields": ["input_text"],
   "context_fields": ["web_context"]
}

nodes = [Node(name="Web \nSearch \nNode",
             metrics_configurations=[MetricsConfiguration(configuration=AgenticAIConfiguration(**retrieval_quality_config_web_search_node),
                                                          metrics=[ContextRelevanceMetric()])])]

agent_app = AgenticApp(name="Rag agent",
                      metrics_configuration=MetricsConfiguration(metrics=[AnswerRelevanceMetric()],
                                                                 metric_groups=[MetricGroup.CONTENT_SAFETY]),
                      nodes=nodes)

evaluator = AgenticEvaluator(agentic_app=agent_app)

Adicione seus avaliadores

Calcule a métrica de relevância do contexto definindo a ferramenta retrieval_node e decorando-a com a ferramenta de avaliação evaluate_context_relevance :

@evaluator.evaluate_context_relevance
def retrieval_node(state: AppState, config: RunnableConfig):
    # do something
    pass

Você também pode empilhar avaliadores para calcular várias métricas com uma ferramenta. O exemplo a seguir mostra a ferramenta generate_node decorada com as ferramentas evaluate_faithfulness e evaluate_answer_similarity para calcular as métricas de qualidade da resposta:

@evaluator.evaluate_faithfulness
@evaluator.evaluate_answer_similarity
def generate_node(state: AppState, config: RunnableConfig):
    # do something
    pass

Fazer uma invocação

Quando você invoca um aplicativo para uma linha de dados, uma chave interaction_id é adicionada às entradas para rastrear linhas individuais e associar métricas a cada linha:

evaluator.start_run()
result = rag_app.invoke({"input_text": "What is concept drift?", "ground_truth": "Concept drift occurs when the statistical properties of the target variable change over time, causing a machine learning model’s predictions to become less accurate."})
evaluator.end_run()

eval_result = evaluator.get_result()
eval_result.to_df()

A invocação gera um resultado, conforme mostrado no exemplo a seguir:

Chamar o gráfico em várias linhas

Para concluir a invocação em lote, você pode definir um quadro de dados com perguntas e verdades básicas para essas perguntas:

import pandas as pd

question_bank_df = pd.read_csv("https://raw.githubusercontent.com/IBM/ibm-watsonx-gov/refs/heads/samples/notebooks/data/agentic/medium_question_bank.csv")
question_bank_df["interaction_id"] = question_bank_df.index.astype(str)
evaluator.start_run()
result = rag_app.batch(inputs=question_bank_df.to_dict("records"))
evaluator.end_run()

eval_result = evaluator.get_result()
eval_result.to_df()

O índice da estrutura de dados é usado como um identificador interaction_id único para cada linha.

A invocação gera um resultado, conforme mostrado no exemplo a seguir:

Para obter mais informações, consulte o exemplo de notebook.