Vertex AI Gen AI Evaluierungsdienst

Die Funktion vertex-eval verbindet adk-eval mit dem Vertex AI Gen AI Evaluierungsdienst. Modellbasierte Beurteilungen werden vom Autorater des Dienstes anstelle eines lokalen LLM ausgeführt, und Tool-Trajektorien werden anhand der rechenbasierten Trajektorienmetriken des Dienstes bewertet. Jeder Aufruf ist ein einzelner POST an projects.locations:evaluateInstances (v1beta1).

Einrichtung

[dependencies]
adk-eval = { version = "2.1.0", features = ["vertex-eval"] }

Für die Authentifizierung werden Application Default Credentials (gcloud auth application-default login oder die Workload Identity eines bereitgestellten Containers) verwendet. Der Aufrufer benötigt die Berechtigung aiplatform.endpoints.predict (roles/aiplatform.user).

Dienstgestützter Judge

VertexEvalJudge spiegelt die Bewertungsschnittstelle von LlmJudge wider – dieselben Methodennamen, dieselben Ergebnistypen – und kann daher in Code eingesetzt werden, der für den lokalen Judge geschrieben wurde:

use adk_eval::{VertexEvalClient, VertexEvalConfig, VertexEvalJudge};
use adk_eval::criteria::{Rubric, RubricConfig};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = VertexEvalConfig::from_env()?;
    let judge = VertexEvalJudge::new(VertexEvalClient::new_with_adc(config)?);

    // Semantic equivalence (pointwiseMetricInput under the hood)
    let result = judge
        .semantic_match("The capital is Paris", "Paris is the capital of France", None)
        .await?;
    println!("score={} equivalent={}", result.score, result.equivalent);

    // Rubric-based quality, weight-normalized like LlmJudge
    let rubrics = RubricConfig {
        rubrics: vec![
            Rubric::new("Accuracy", "Response is factually correct").with_weight(2.0),
            Rubric::new("Clarity", "Response is easy to follow"),
        ],
    };
    let quality = judge.evaluate_rubrics("agent output", "task context", &rubrics).await?;
    println!("overall={}", quality.overall_score);

    // Safety and hallucination checks
    let safety = judge.evaluate_safety("agent output").await?;
    let hallucination = judge
        .detect_hallucinations("agent output", "provided context", Some("ground truth"))
        .await?;
    println!("safe={} grounded={}", safety.is_safe, hallucination.hallucination_free);
    Ok(())
}

Unterschiede zu LlmJudge, die beide daraus resultieren, dass der Dienst pro Bewertung ein {score, explanation}-Paar zurückgibt:

• Boolesche Bewertungen (equivalent, is_safe, hallucination_free) werden aus dem Score abgeleitet – ein Wert von mindestens 0,5 gilt als bestanden.
• issues enthält die Erklärung des Dienstes als einzelnen Eintrag statt als geparste Liste.

Trajektorienmetriken

VertexEvalClient::evaluate_trajectory bildet die Werte von adk-eval ToolUse auf die Drahtformat-Struktur Trajectory ab (name → toolName, args → JSON-kodiertes toolInput) und gibt den Score zurück:

use adk_eval::{TrajectoryMetric, VertexEvalClient, VertexEvalConfig};
use adk_eval::schema::ToolUse;
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = VertexEvalClient::new_with_adc(VertexEvalConfig::from_env()?)?;

    let predicted = vec![ToolUse::new("get_weather").with_args(json!({ "city": "Paris" }))];
    let reference = predicted.clone();

    let score = client
        .evaluate_trajectory(TrajectoryMetric::ExactMatch, &predicted, &reference)
        .await?;
    assert_eq!(score, 1.0);
    Ok(())
}

Konfiguration des Bewertungsmodells

AutoraterConfig wählt das Bewertungsmodell und die Stichprobenentnahme für modellbasierte Metriken aus; der Server ignoriert diese Einstellung bei berechnungsbasierten Metriken:

use adk_eval::{AutoraterConfig, VertexEvalClient, VertexEvalConfig};

fn build() -> adk_core::Result<VertexEvalClient> {
    let client = VertexEvalClient::new_with_adc(VertexEvalConfig::from_env()?)?
        .with_autorater_config(
            AutoraterConfig::new()
                .with_autorater_model(
                    "projects/p/locations/us-central1/publishers/google/models/gemini-3.7-flash",
                )
                .with_sampling_count(1),
        );
    Ok(client)
}

Benutzerdefinierte Metriken

evaluate_pointwise akzeptiert ein beliebiges PointwiseMetricSpec — das metricPromptTemplate enthält {placeholder}-Variablen, die serverseitig aus dem Instanzobjekt gerendert werden:

use adk_eval::{PointwiseMetricSpec, VertexEvalClient, VertexEvalConfig};
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = VertexEvalClient::new_with_adc(VertexEvalConfig::from_env()?)?;

    let spec = PointwiseMetricSpec::new(
        "Rate the politeness of the response from 0.0 to 1.0.\n\nResponse:\n{response}",
    );
    let result = client
        .evaluate_pointwise(&spec, &json!({ "response": "Thanks for asking!" }))
        .await?;
    println!("score={:?} explanation={:?}", result.score, result.explanation);
    Ok(())
}

evaluate_instances ist der unverarbeitete Ausweg: Es sendet einen beliebigen EvaluateInstancesRequest-Body per POST und gibt die unverarbeitete Antwort zurück, sodass jede andere vom Dienst unterstützte Metrik erreicht werden kann (BLEU, ROUGE, paarweise Metriken, Tool-Aufruf-Metriken).

Fehlerbehandlung

Fehler sind strukturierte AdkError-Werte mit der Komponente eval und eval.vertex.*-Codes (eval.vertex.rate_limited, eval.vertex.unauthorized, eval.vertex.invalid_response, ...). VertexEvalJudge-Methoden geben den EvalError::JudgeError des Crates zurück, entsprechend LlmJudge.

Siehe auch

• Agentenbewertung — der Evaluator, Kriterien und lokale Bewertungsmodelle
• Übersicht zur Gen-AI-Bewertung in Vertex AI
• Referenz zu projects.locations.evaluateInstances REST