Ocena agentów sztucznej inteligencji

Ocena jest niezbędna do zapewnienia, że agent spełnia standardy jakości i bezpieczeństwa przed wdrożeniem. Uruchamiając oceny podczas rozwoju, ustanawiasz punkt odniesienia dla wydajności agenta i ustalasz progi akceptacji, takie jak 85% wskaźnik zgodności zadań, przed udostępnieniem go użytkownikom.

W tym artykule dowiesz się, jak przeprowadzić ocenę ukierunkowaną na agenta Foundry lub agenta hostowanego używając wbudowanych ewaluatorów do oceny jakości, bezpieczeństwa i zachowania agenta. W szczególności:

  • Skonfiguruj klienta zestawu SDK do oceny.
  • Wybierz ewaluatorów pod kątem jakości, bezpieczeństwa i zachowania agenta.
  • Utwórz testowy zestaw danych i uruchom ocenę.
  • Interpretowanie wyników i integrowanie ich z przepływem pracy.

Wskazówka

Aby uzyskać ogólną ocenę generowania modeli i aplikacji sztucznej inteligencji, w tym niestandardowych ewaluatorów, różnych źródeł danych i dodatkowych opcji zestawu SDK, zobacz Run evaluations from the SDK (Uruchamianie ocen z zestawu SDK).

Wymagania wstępne

  • Python wersji 3.8 lub nowszej.
  • Projekt Foundry z agentem lub hostowanym agentem.
  • Wdrożenie Azure OpenAI z modelem GPT obsługującym uzupełnianie czatu (na przykład gpt-4o lub gpt-4o-mini).
  • Użytkownik Azure AI w roli na projekcie Foundry.

Uwaga

Niektóre funkcje oceny mają ograniczenia regionalne. Aby uzyskać szczegółowe informacje, zobacz obsługiwane regiony .

Konfigurowanie klienta

Zainstaluj zestaw SDK usługi Foundry i skonfiguruj uwierzytelnianie:

pip install "azure-ai-projects>=2.0.0"

Utwórz klienta projektu. W poniższym przykładzie kodu założono, że uruchamiasz je w tym kontekście:

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

endpoint = os.environ["AZURE_AI_PROJECT_ENDPOINT"]
model_deployment = os.environ["AZURE_AI_MODEL_DEPLOYMENT_NAME"]

credential = DefaultAzureCredential()
project_client = AIProjectClient(endpoint=endpoint, credential=credential)
client = project_client.get_openai_client()

Wybieranie ewaluatorów

Ewaluatory to funkcje, które oceniają odpowiedzi agenta. Niektórzy ewaluatorzy używają modeli sztucznej inteligencji jako sędziów, podczas gdy inni używają reguł lub algorytmów. W przypadku oceny agenta należy wziąć pod uwagę następujący zestaw:

Oceniającego Co mierzy
Przestrzeganie zadania Czy agent wykonuje instrukcje systemowe?
Spójności Czy odpowiedź jest logiczna i dobrze ustrukturyzowana?
Przemocy Czy odpowiedź zawiera brutalną zawartość?

Aby uzyskać więcej wbudowanych ewaluatorów, zobacz:

  • Ewaluatory agentów — ocenianie sposobu efektywnego obsługi zadań, narzędzi i intencji użytkownika przez agentów.
  • Ewaluatory jakości — mierzenie ogólnej jakości wygenerowanych odpowiedzi.
  • Ewaluatory podobieństwa tekstu — porównaj wygenerowany tekst z odpowiedziami referencyjnymi przy użyciu metryk NLP.
  • Ewaluatory bezpieczeństwa — identyfikowanie potencjalnych zagrożeń związanych z zawartością i bezpieczeństwem w wygenerowanych danych wyjściowych.

Aby utworzyć własnych ewaluatorów, zobacz Niestandardowe ewaluatory.

Tworzenie testowego zestawu danych

Utwórz plik JSONL z zapytaniami testowymi dla agenta. Każdy wiersz zawiera obiekt JSON z polem query :

{"query": "What's the weather in Seattle?"}
{"query": "Book a flight to Paris"}
{"query": "Tell me a joke"}

Przekaż ten plik jako zestaw danych w projekcie:

dataset = project_client.datasets.upload_file(
    name="agent-test-queries",
    version="1",
    file_path="./test-queries.jsonl",
)

Uruchamianie oceny

Po uruchomieniu oceny usługa wysyła każde zapytanie testowe do agenta, przechwytuje odpowiedź i stosuje wybranych ewaluatorów w celu oceny wyników.

Najpierw skonfiguruj ewaluatorów. Każdy ewaluator potrzebuje mapowania danych, które informuje o tym, gdzie można znaleźć dane wejściowe:

  • {{item.X}} odwołuje się do pól z danych testowych, takich jak query.
  • {{sample.output_items}} odwołuje się do pełnej odpowiedzi agenta, w tym wywołań narzędzi.
  • {{sample.output_text}} odwołuje się tylko do tekstu wiadomości odpowiedzi.

Narzędzia ewaluacyjne wspomagane przez sztuczną inteligencję, takie jak Zgodność Zadań i Spójność, wymagają nazwy wdrożenia modelu w initialization_parameters. Wartość musi być zgodna z nazwą wdrożenia GPT w projekcie — jest to model oceny używany do oceniania odpowiedzi. Niektórzy ewaluatorzy mogą wymagać dodatkowych pól, takich jak ground_truth lub definicje narzędzi. Aby uzyskać więcej informacji, zobacz dokumentację ewaluatora.

testing_criteria = [
    {
        "type": "azure_ai_evaluator",
        "name": "Task Adherence",
        "evaluator_name": "builtin.task_adherence",
        "data_mapping": {
            "query": "{{item.query}}",
            "response": "{{sample.output_items}}",
        },
        "initialization_parameters": {"deployment_name": model_deployment},
    },
    {
        "type": "azure_ai_evaluator",
        "name": "Coherence",
        "evaluator_name": "builtin.coherence",
        "data_mapping": {
            "query": "{{item.query}}",
            "response": "{{sample.output_text}}",
        },
        "initialization_parameters": {"deployment_name": model_deployment},
    },
    {
        "type": "azure_ai_evaluator",
        "name": "Violence",
        "evaluator_name": "builtin.violence",
        "data_mapping": {
            "query": "{{item.query}}",
            "response": "{{sample.output_text}}",
        },
    },
]

Następnie utwórz ocenę. Ocena definiuje schemat danych testowych i kryteria testowania. Serwuje jako kontener dla wielu procesów. Wszystkie przebiegi w ramach tej samej oceny są zgodne z takim samym schematem i produkują taki sam zestaw metryk. Ta spójność jest ważna w przypadku porównywania wyników między przebiegami.

data_source_config = {
    "type": "custom",
    "item_schema": {
        "type": "object",
        "properties": {
            "query": {"type": "string"},
        },
        "required": ["query"],
    },
    "include_sample_schema": True,
}

evaluation = client.evals.create(
    name="Agent Quality Evaluation",
    data_source_config=data_source_config,
    testing_criteria=testing_criteria,
)

Na koniec utwórz sesję, która wysyła zapytania testowe do agenta i stosuje ewaluatory.

eval_run = client.evals.runs.create(
    eval_id=evaluation.id,
    name="Agent Evaluation Run",
    data_source={
        "type": "azure_ai_target_completions",
        "source": {
            "type": "file_id",
            "id": dataset.id,
        },
        "input_messages": {
            "type": "template",
            "template": [{"type": "message", "role": "user", "content": {"type": "input_text", "text": "{{item.query}}"}}],
        },
        "target": {
            "type": "azure_ai_agent",
            "name": "my-agent",  # Replace with your agent name
            "version": "1",  # Optional; omit to use latest version
        },
    },
)

print(f"Evaluation run started: {eval_run.id}")

Wskazówka

Ten przykład działa zarówno w przypadku agentów monitów, jak i hostowanych agentów korzystających z protokołu odpowiedzi. W przypadku agentów hostowanych korzystających z protokołu input_messages wywołań format jest inny — podaj dowolny obiekt JSON zamiast szablonu strukturalnego. Aby uzyskać szczegółowe informacje i przykłady kodu, zobacz Protokół wywołań hostowanych agentów w przewodniku oceny chmury.

Interpretowanie wyników

Oceny zazwyczaj są wykonywane w ciągu kilku minut, w zależności od liczby zapytań. Sonduj pod kątem ukończenia i pobierz adres URL raportu, aby wyświetlić wyniki w portalu Microsoft Foundry na karcie Evaluations:

import time

# Wait for completion
while True:
    run = client.evals.runs.retrieve(run_id=eval_run.id, eval_id=evaluation.id)
    if run.status in ["completed", "failed"]:
        break
    time.sleep(5)

print(f"Status: {run.status}")
print(f"Report URL: {run.report_url}")

Zrzut ekranu przedstawiający wyniki oceny agenta w portalu Microsoft Foundry.

Zagregowane wyniki

Na poziomie przebiegu można zobaczyć zagregowane dane, w tym liczbę zaliczonych i niezaliczonych testów, użycie tokenów na model oraz wyniki według ewaluatora.

{
    "result_counts": {
        "total": 3,
        "passed": 1,
        "failed": 2,
        "errored": 0
    },
    "per_model_usage": [
        {
            "model_name": "gpt-4o-mini-2024-07-18",
            "invocation_count": 6,
            "total_tokens": 9285,
            "prompt_tokens": 8326,
            "completion_tokens": 959
        },
        ...
    ],
    "per_testing_criteria_results": [
        {
            "testing_criteria": "Task Adherence",
            "passed": 1,
            "failed": 2
        },
        ... // remaining testing criteria
    ]
}

Dane wyjściowe na poziomie wiersza

Każdy przebieg oceny zwraca elementy wyjściowe dla każdego wiersza w zestawie danych testowych, zapewniając szczegółowy obraz wydajności agenta. Elementy wyjściowe obejmują oryginalne zapytanie, odpowiedź agenta, indywidualne wyniki ewaluatora z wynikami i uzasadnieniem oraz użyciem tokenu:

{
    "object": "eval.run.output_item",
    "id": "1",
    "run_id": "evalrun_abc123",
    "eval_id": "eval_xyz789",
    "status": "completed",
    "datasource_item": {
        "query": "What's the weather in Seattle?",
        "response_id": "resp_abc123",
        "agent_name": "my-agent",
        "agent_version": "10",
        "sample.output_text": "I'd be happy to help with the weather! However, I need to check the current conditions. Let me look that up for you.",
        "sample.output_items": [
            ... // agent response messages with tool calls
        ]
    },
    "results": [
        {
            "type": "azure_ai_evaluator",
            "name": "Task Adherence",
            "metric": "task_adherence",
            "label": "pass",
            "reason": "Agent followed system instructions correctly",
            "threshold": 3,
            "passed": true,
            "sample":
            {
               ... // evaluator input/output and token usage
            }
        },
        ... // remaining evaluation results
    ]
}

Włącz do swojego przepływu pracy

  • Potok ciągłej integracji/ciągłego wdrażania: użyj oceny jako punktu kontrolnego jakości w potoku wdrażania. Aby uzyskać szczegółową integrację, zobacz Run evaluations with GitHub Actions (Uruchamianie ocen za pomocą GitHub Actions
  • Monitorowanie produkcji: monitoruj agenta w środowisku produkcyjnym przy użyciu ciągłej oceny. Aby uzyskać instrukcje dotyczące konfiguracji, zobacz Konfigurowanie ciągłej oceny.

Optymalizowanie i porównywanie wersji

Użyj oceny, aby iterować i ulepszać agenta:

  1. Uruchom ocenę, aby zidentyfikować słabe obszary. Użyj analizy klastra , aby znaleźć wzorce i błędy.
  2. Dostosuj instrukcje lub narzędzia agenta na podstawie wyników.
  3. Ponownie ocenić i porównać wyniki, aby zmierzyć poprawę.
  4. Powtarzaj, aż zostaną spełnione progi jakości.

Powiązana zawartość

  • Last updated on