Sdílet prostřednictvím

Spusťte vyhodnocení z prostředí SDK

Důležité

Položky označené (Preview) v tomto článku jsou aktuálně ve verzi Public Preview. Tato verze Preview je poskytována bez smlouvy o úrovni služeb a nedoporučujeme ji pro produkční úlohy. Některé funkce se nemusí podporovat nebo mohou mít omezené možnosti. Další informace najdete v tématu Supplementální podmínky použití pro Microsoft Azure Verze Preview.

V tomto článku se dozvíte, jak spustit vyhodnocení v cloudu (Preview) pro testování před nasazením testovací datové sady.

Používejte dávkové vyhodnocení pro většinu scénářů, zejména při testování ve velkém měřítku, integraci vyhodnocení do kanálů kontinuální integrace a průběžného doručování (CI/CD) nebo provádění předem připravených testů. Spouštění vyhodnocení v cloudu eliminuje nutnost spravovat místní výpočetní infrastrukturu a podporuje rozsáhlé automatizované testovací pracovní postupy. Můžete také naplánovat, aby se hodnocení spouštěla opakovaně, nebo můžete nastavit průběžné hodnocení , aby se automaticky vyhodnocovaly vzorkované odpovědi agenta v produkčním prostředí.

Výsledky dávkového vyhodnocení se ukládají do projektu Foundry. Výsledky můžete zkontrolovat na portálu, načíst je prostřednictvím sady SDK nebo je směrovat do Application Insights, pokud jsou připojené. Dávkové vyhodnocení podporuje všechny předdefinované vyhodnocovače od Microsoftu a vlastní vyhodnocovače. Vyhodnocovače se spravují v katalogu vyhodnocovačů se stejným řízením přístupu na základě role v oboru projektu.

Návod

Kompletní spustitelné příklady najdete v ukázkách Python SDK pro vyhodnocení na GitHub.

Při použití sady Foundry SDK zaznamená výsledky vyhodnocení do projektu Foundry, aby se zlepšila pozorovatelnost. Tato funkce podporuje všechny integrované vyhodnocovače od Microsoftu a vlastní vyhodnocovače. Vyhodnocovače můžou být umístěny v knihovně vyhodnocovačů a mají stejné řízení přístupu na základě role v rámci projektu.

Jak funguje dávkové vyhodnocení

Pokud chcete spustit dávkové vyhodnocení, vytvoříte definici vyhodnocení se schématem dat a testovacími kritérii (vyhodnocovači) a pak vytvoříte spuštění vyhodnocení. Spuštění provede každý vyhodnocovací modul s vašimi daty a vrátí vyhodnocené výsledky, které můžete dotazovat na dokončení.

Dávkové vyhodnocení podporuje následující scénáře:

Scenario Kdy používat Typ zdroje dat Target
Vyhodnocení datové sady Vyhodnoťte předem vypočítané odpovědi v souboru JSONL. jsonl —
Vyhodnocení cíle modelu Zadejte dotazy a vygenerujte odpovědi z modelu za běhu pro vyhodnocení. azure_ai_target_completions azure_ai_model
Vyhodnocení cíle agenta Zadejte dotazy a vygenerujte odpovědi z agenta Foundry za běhu pro vyhodnocení. azure_ai_target_completions azure_ai_agent
Vyhodnocení odpovědi agenta Načtěte a vyhodnoťte odpovědi agenta Foundry podle ID odpovědí. azure_ai_responses —
Vyhodnocení syntetických dat (Preview) Vygenerujte syntetické testovací dotazy, odešlete je do modelu nebo agenta a vyhodnoťte odpovědi. azure_ai_synthetic_data_gen_preview azure_ai_model nebo azure_ai_agent
Vyhodnocení červeného týmu Spusťte automatizované adversariální testování proti modelu nebo agentovi. azure_ai_red_team azure_ai_model nebo azure_ai_agent

Většina scénářů vyžaduje vstupní data. Data můžete poskytnout dvěma způsoby:

Typ zdroje Description
file_id Odkaz na nahranou datovou sadu podle ID
file_content Poskytněte data přímo do požadavku.

Každé vyhodnocení vyžaduje data_source_config, který sdělí službě, jaká pole očekávat ve vašich datech.

  • custom — Definujete názvy item_schema a typy polí. Nastavte include_sample_schema na true při použití cíle, aby vyhodnocovače mohly odkazovat na generované odpovědi.
  • azure_ai_source – Schéma je odvozeno ze služby. Nastavte "scenario" na "responses" vyhodnocení odpovědí agenta, "synthetic_data_gen_preview" pro syntetické vyhodnocení dat (Preview) nebo "red_team" pro červené seskupování.

Každý scénář vyžaduje vyhodnocovače, které definují kritéria testování. Pokyny k výběru vyhodnocovačů najdete v předdefinovaných vyhodnocovacích nástrojích.

Předpoklady

Poznámka:

Některé funkce vyhodnocení mají regionální omezení. Podrobnosti najdete v podporovaných oblastech .

Začínáme

Nainstalujte sadu SDK a nastavte klienta:

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

import os
from azure.identity import DefaultAzureCredential 
from azure.ai.projects import AIProjectClient 
from openai.types.eval_create_params import DataSourceConfigCustom
from openai.types.evals.create_eval_jsonl_run_data_source_param import (
    CreateEvalJSONLRunDataSourceParam,
    SourceFileContent,
    SourceFileContentContent,
    SourceFileID,
)

# Azure AI Project endpoint
# Example: https://<account_name>.services.ai.azure.com/api/projects/<project_name>
endpoint = os.environ["AZURE_AI_PROJECT_ENDPOINT"]

# Model deployment name (for AI-assisted evaluators)
# Example: gpt-5-mini
model_deployment_name = os.environ.get("AZURE_AI_MODEL_DEPLOYMENT_NAME", "")

# Dataset details (optional, for reusing existing datasets)
dataset_name = os.environ.get("DATASET_NAME", "")
dataset_version = os.environ.get("DATASET_VERSION", "1")

# Create the project client
project_client = AIProjectClient( 
    endpoint=endpoint, 
    credential=DefaultAzureCredential(), 
)

# Get the OpenAI client for evaluation API
client = project_client.get_openai_client()

Příprava vstupních dat

Většina scénářů vyhodnocení vyžaduje vstupní data. Data můžete poskytnout dvěma způsoby:

Nahrajte soubor JSONL pro vytvoření datové sady s verzí v projektu Foundry. Datové sady podporují správu verzí a opakované použití napříč několika testovacími běhy. Tento přístup použijte pro produkční testování a pracovní postupy CI/CD.

Připravte soubor JSONL s jedním objektem JSON na řádek obsahující pole, která vaši vyhodnocovače potřebují:

{"query": "What is machine learning?", "response": "Machine learning is a subset of AI.", "ground_truth": "Machine learning is a type of AI that learns from data."}
{"query": "Explain neural networks.", "response": "Neural networks are computing systems inspired by biological neural networks.", "ground_truth": "Neural networks are a set of algorithms modeled after the human brain."}

# Upload a local JSONL file. Skip this step if you already have a dataset registered.
data_id = project_client.datasets.upload_file(
    name=dataset_name,
    version=dataset_version,
    file_path="./evaluate_test_data.jsonl",
).id

Poskytněte data v textu

Pro rychlé experimentování s malými testovacími sadami zadejte data přímo v žádosti o vyhodnocení pomocí file_content.

source = SourceFileContent(
    type="file_content",
    content=[
        SourceFileContentContent(
            item={
                "query": "How can I safely de-escalate a tense situation?",
                "ground_truth": "Encourage calm communication, seek help if needed, and avoid harm.",
            }
        ),
        SourceFileContentContent(
            item={
                "query": "What is the largest city in France?",
                "ground_truth": "Paris",
            }
        ),
    ],
)

Předejte source jako pole "source" v konfiguraci zdroje dat při vytvoření úlohy. Oddíly scénáře, které následují, používají file_id ve výchozím nastavení.

Vyhodnocení datové sady

Vyhodnoťte předem vypočítané odpovědi v souboru JSONL pomocí jsonl typu zdroje dat. Tento scénář je užitečný, pokud už máte výstupy modelu a chcete posoudit jejich kvalitu.

Návod

Než začnete, dokončete začínáme a připravte vstupní data.

Definování schématu dat a vyhodnocovačů

Zadejte schéma, které odpovídá vašim polím JSONL, a vyberte vyhodnocovače (testovací kritéria) ke spuštění. Pomocí parametru data_mapping připojte pole ze vstupních dat k vyhodnocovačovým parametrům pomocí {{item.field}} syntaxe. Vždy zahrňte data_mapping do požadovaných vstupních polí každého vyhodnocovače. Názvy vašich polí musí odpovídat názvům ve vašem souboru JSONL — například pokud vaše data obsahují "question" místo "query", použijte v mapování "{{item.question}}". Požadované parametry na vyhodnocovače najdete v předdefinovaných vyhodnocovacích nástrojích.

data_source_config = DataSourceConfigCustom(
    type="custom",
    item_schema={
        "type": "object",
        "properties": {
            "query": {"type": "string"},
            "response": {"type": "string"},
            "ground_truth": {"type": "string"},
        },
        "required": ["query", "response", "ground_truth"],
    },
)

testing_criteria = [
    {
        "type": "azure_ai_evaluator",
        "name": "coherence",
        "evaluator_name": "builtin.coherence",
        "initialization_parameters": {
            "deployment_name": model_deployment_name
        },
        "data_mapping": {
            "query": "{{item.query}}",
            "response": "{{item.response}}",
        },
    },
    {
        "type": "azure_ai_evaluator",
        "name": "violence",
        "evaluator_name": "builtin.violence",
        "initialization_parameters": {
            "deployment_name": model_deployment_name
        },
        "data_mapping": {
            "query": "{{item.query}}",
            "response": "{{item.response}}",
        },
    },
    {
        "type": "azure_ai_evaluator",
        "name": "f1",
        "evaluator_name": "builtin.f1_score",
        "data_mapping": {
            "response": "{{item.response}}",
            "ground_truth": "{{item.ground_truth}}",
        },
    },
]

Vytvořit hodnocení a spustit

Vytvořte vyhodnocení a pak spusťte akci proti své nahrané datové sadě. Spuštění spouští každého hodnotitele na každém řádku datové sady.

# Create the evaluation
eval_object = client.evals.create(
    name="dataset-evaluation",
    data_source_config=data_source_config,
    testing_criteria=testing_criteria,
)

# Create a run using the uploaded dataset
eval_run = client.evals.runs.create(
    eval_id=eval_object.id,
    name="dataset-run",
    data_source=CreateEvalJSONLRunDataSourceParam(
        type="jsonl",
        source=SourceFileID(
            type="file_id",
            id=data_id,
        ),
    ),
)

Úplný spustitelný příklad najdete v sample_evaluations_builtin_with_dataset_id.py na GitHub. Pro dotazování na dokončení a interpretaci výsledků, viz Získání výsledků.

Vyhodnocení cíle modelu

Odešlete dotazy do nasazeného modelu za běhu a vyhodnoťte odpovědi pomocí azure_ai_target_completions typu zdroje dat s azure_ai_model cílem. Vstupní data obsahují dotazy; model generuje odpovědi, které se pak vyhodnocují.

Návod

Než začnete, dokončete začínáme a připravte vstupní data.

Definování šablony zprávy a cíle

Šablona input_messages řídí způsob odesílání dotazů do modelu. Slouží {{item.query}} k odkazování na pole ze vstupních dat. Zadejte model pro vyhodnocení a volitelné parametry vzorkování:

input_messages = {
    "type": "template",
    "template": [
        {
            "type": "message",
            "role": "user",
            "content": {
                "type": "input_text",
                "text": "{{item.query}}"
            }
        }
    ]
}

target = {
    "type": "azure_ai_model",
    "model": "gpt-5-mini",
    "sampling_params": {
        "top_p": 1.0,
        "max_completion_tokens": 2048,
    },
}

Nastavení vyhodnocovačů a mapování dat

Když model generuje odpovědi během běhu programu, použijte {{sample.output_text}} v data_mapping k odkazování na výstup modelu. Slouží {{item.field}} k odkazování na pole ze vstupních dat.

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

testing_criteria = [
    {
        "type": "azure_ai_evaluator",
        "name": "coherence",
        "evaluator_name": "builtin.coherence",
        "initialization_parameters": {
            "deployment_name": model_deployment_name,
        },
        "data_mapping": {
            "query": "{{item.query}}",
            "response": "{{sample.output_text}}",
        },
    },
    {
        "type": "azure_ai_evaluator",
        "name": "violence",
        "evaluator_name": "builtin.violence",
        "data_mapping": {
            "query": "{{item.query}}",
            "response": "{{sample.output_text}}",
        },
    },
]

Vytvořit hodnocení a spustit

eval_object = client.evals.create(
    name="Model Target Evaluation",
    data_source_config=data_source_config,
    testing_criteria=testing_criteria,
)

data_source = {
    "type": "azure_ai_target_completions",
    "source": {
        "type": "file_id",
        "id": data_id,
    },
    "input_messages": input_messages,
    "target": target,
}

eval_run = client.evals.runs.create(
    eval_id=eval_object.id,
    name="model-target-evaluation",
    data_source=data_source,
)

Úplný příklad s možností spuštění najdete v tématu sample_model_evaluation.py na GitHub. Pro dotazování na dokončení a interpretaci výsledků, viz Získání výsledků.

Návod

Chcete-li přidat další kolo hodnocení, spusťte stejné hodnocení znovu s použitím téže hodnotící skupiny. Každé spuštění vytvoří nové spuštění ve stejné skupině, které vám umožní porovnat >výsledky napříč spuštěními po změně věcí, jako je model, výzva nebo datová sada – bez vytvoření nového vyhodnocení nebo použití jiného rozhraní API.

Podívejte se na ukázku, která opět použije stejnou skupinu hodnocení k vytvoření několika běhů pro porovnání.

Vyhodnocení cíle agenta

Odešlete dotazy do agenta Foundry za běhu a vyhodnoťte odpovědi pomocí azure_ai_target_completions typu zdroje dat s azure_ai_agent cílem.

Návod

Než začnete, dokončete začínáme a připravte vstupní data.

Definování šablony zprávy a cíle

Šablona input_messages určuje, jak se dotazy odesílají agentovi. Slouží {{item.query}} k odkazování na pole ze vstupních dat. Zadejte jméno agenta, který se má vyhodnotit:

input_messages = {
    "type": "template",
    "template": [
        {
            "type": "message",
            "role": "developer",
            "content": {
                "type": "input_text",
                "text": "You are a helpful assistant. Answer clearly and safely."
            }
        },
        {
            "type": "message",
            "role": "user",
            "content": {
                "type": "input_text",
                "text": "{{item.query}}"
            }
        }
    ]
}

target = {
    "type": "azure_ai_agent",
    "name": "my-agent",
    "version": "1"  # Optional. Uses latest version if omitted.
}

Nastavení vyhodnocovačů a mapování dat

Když agent generuje odpovědi za běhu, použijte {{sample.*}} proměnné data_mapping k odkazování na výstup agenta:

Proměnná Description Použít pro
{{sample.output_text}} Odpověď agenta ve formátu prostého textu. Vyhodnocovače, které očekávají řetězcovou odpověď (například coherence, violence).
{{sample.output_items}} Strukturovaný výstup JSON agenta, včetně volání nástrojů. Vyhodnocovače, kteří potřebují úplný kontext interakce (například task_adherence).
{{item.field}} Pole ze vstupních dat Vstupní pole jako query nebo ground_truth.

Návod

Pole query může obsahovat strukturovaný JSON, včetně systémových zpráv a historie konverzací. Některé vyhodnocovače agentů, jako například task_adherence, používají tento kontext k přesnějšímu hodnocení. Podrobnosti o formátování dotazů najdete v části vyhodnocovače agentů.

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

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

Vytvořit hodnocení a spustit

eval_object = client.evals.create(
    name="Agent Target Evaluation",
    data_source_config=data_source_config,
    testing_criteria=testing_criteria,
)

data_source = {
    "type": "azure_ai_target_completions",
    "source": {
        "type": "file_id",
        "id": data_id,
    },
    "input_messages": input_messages,
    "target": target,
}

agent_eval_run = client.evals.runs.create(
    eval_id=eval_object.id,
    name="agent-target-evaluation",
    data_source=data_source,
)

Úplný příklad s možností spuštění najdete v tématu sample_agent_evaluation.py na GitHub. Pro dotazování na dokončení a interpretaci výsledků, viz Získání výsledků.

Návod

Pokud chcete přidat další spuštění vyhodnocení, spusťte stejné vyhodnocení znovu pomocí stejné skupiny hodnocení. Každé spuštění vytvoří nové spuštění ve stejné skupině, které vám umožní porovnat >výsledky napříč spuštěními po změně věcí, jako je model, výzva nebo datová sada – bez vytvoření nového vyhodnocení nebo použití jiného rozhraní API.

Podívejte se na ukázku, která využívá stejnou skupinu hodnocení k provádění více běhů pro porovnání.

Vyhodnocení odpovědi agenta

Načtěte a vyhodnoťte odpovědi agenta Foundry podle ID odpovědí pomocí azure_ai_responses typu zdroje dat. Tento scénář použijte k vyhodnocení konkrétních interakcí agentů po jejich výskytu.

Návod

Než začnete, dokončete Začínáme.

ID odpovědi je jedinečný identifikátor vrácený pokaždé, když agent Foundry vygeneruje odpověď. ID odpovědí můžete shromažďovat z interakcí agentů pomocí rozhraní API odpovědí nebo z protokolů trasování vaší aplikace. Zadejte ID jako obsah souboru nebo je nahrajte jako datovou sadu (viz Příprava vstupních dat).

Shromažďování ID odpovědí

Každé volání rozhraní API odpovědi vrátí objekt odpovědi s jedinečným id polem. Shromážděte tato ID z interakcí vaší aplikace nebo je vygenerujte přímo:

# Generate response IDs by calling a model through the Responses API
response = client.responses.create(
    model=model_deployment_name,
    input="What is machine learning?",
)
print(response.id)  # Example: resp_abc123

ID odpovědí můžete shromažďovat také z interakcí agentů v protokolech trasování vaší aplikace nebo v kanálu monitorování. Každé ID odpovědi jednoznačně identifikuje uloženou odpověď, kterou může služba vyhodnocení načíst.

Vytvořit hodnocení a spustit

data_source_config = {"type": "azure_ai_source", "scenario": "responses"}

testing_criteria = [
    {
        "type": "azure_ai_evaluator",
        "name": "coherence",
        "evaluator_name": "builtin.coherence",
        "initialization_parameters": {
            "deployment_name": model_deployment_name,
        },
    },
    {
        "type": "azure_ai_evaluator",
        "name": "violence",
        "evaluator_name": "builtin.violence",
    },
]

eval_object = client.evals.create(
    name="Agent Response Evaluation",
    data_source_config=data_source_config,
    testing_criteria=testing_criteria,
)

data_source = {
    "type": "azure_ai_responses",
    "item_generation_params": {
        "type": "response_retrieval",
        "data_mapping": {"response_id": "{{item.resp_id}}"},
        "source": {
            "type": "file_content",
            "content": [
                {"item": {"resp_id": "resp_abc123"}},
                {"item": {"resp_id": "resp_def456"}},
            ]
        },
    },
}

eval_run = client.evals.runs.create(
    eval_id=eval_object.id,
    name="agent-response-evaluation",
    data_source=data_source,
)

Úplný příklad spustitelného příkazu najdete v tématu sample_agent_response_evaluation.py na GitHub. Pro dotazování na dokončení a interpretaci výsledků, viz Získání výsledků.

Návod

Pokud chcete přidat další spuštění vyhodnocení, spusťte stejné vyhodnocení znovu pomocí stejné skupiny hodnocení. Každé spuštění vytvoří nové spuštění ve stejné skupině, které vám umožní porovnat >výsledky napříč spuštěními po změně věcí, jako je model, výzva nebo datová sada – bez vytvoření nového vyhodnocení nebo použití jiného rozhraní API.

Podívejte se na ukázku, která znovu použije stejnou skupinu hodnocení k vytvoření více iterací pro porovnání.

Vyhodnocení syntetických dat (Preview)

Vygenerujte syntetické testovací dotazy, odešlete je do nasazeného modelu nebo agenta Foundry a vyhodnoťte odpovědi pomocí azure_ai_synthetic_data_gen_preview typu zdroje dat. Tento scénář použijte, pokud nemáte testovací datovou sadu – služba generuje dotazy na základě výzvy, kterou zadáte (nebo z pokynů agenta), spustí je proti cíli a vyhodnotí odpovědi.

Návod

Než začnete, dokončete Začínáme.

Jak funguje hodnocení syntetických dat

  1. Služba generuje syntetické dotazy na základě vašich prompt a volitelných počátečních datových souborů.
  2. Každý dotaz se odešle do zadaného cíle (modelu nebo agenta) a vygeneruje odpověď.
  3. Vyhodnocovače vyhodnotí jednotlivé odpovědi pomocí vygenerovaného dotazu a odpovědi.
  4. Vygenerované dotazy se ve vašem projektu ukládají jako datová sada pro opakované použití.

Parametry

Parameter Povinné Description
samples_count Ano Maximální počet syntetických testovacích dotazů, které se mají vygenerovat.
model_deployment_name Ano Nasazení modelu, které se použije ke generování syntetických dotazů Podporují se jenom modely s funkcí rozhraní API pro odpovědi. Dostupnost najdete v tématu Dostupnost oblastí rozhraní API odpovědí.
prompt Ne Pokyny popisující typ dotazů, které se mají vygenerovat. Volitelné, pokud jsou pro cíl agenta nakonfigurovány pokyny.
output_dataset_name Ne Název výstupní datové sady, ve které se ukládají vygenerované dotazy. Pokud není k dispozici, služba automaticky vygeneruje název.
sources Ne Počáteční datové soubory (podle ID souboru) pro zlepšení relevance vygenerovaných dotazů. V současné době je podporován pouze jeden soubor.

Nastavení vyhodnocovačů a mapování dat

Generátor syntetických dat vytváří dotazy v {{item.query}} poli. Cíl generuje odpovědi, které jsou k dispozici v {{sample.output_text}}. Mapujte tato pole na své hodnotitele:

data_source_config = {"type": "azure_ai_source", "scenario": "synthetic_data_gen_preview"}

testing_criteria = [
    {
        "type": "azure_ai_evaluator",
        "name": "coherence",
        "evaluator_name": "builtin.coherence",
        "initialization_parameters": {
            "deployment_name": model_deployment_name,
        },
        "data_mapping": {
            "query": "{{item.query}}",
            "response": "{{sample.output_text}}",
        },
    },
    {
        "type": "azure_ai_evaluator",
        "name": "violence",
        "evaluator_name": "builtin.violence",
        "data_mapping": {
            "query": "{{item.query}}",
            "response": "{{sample.output_text}}",
        },
    },
]

Vytvořit hodnocení a spustit

Cíl modelu

Vygenerujte syntetické dotazy a vyhodnoťte model:

eval_object = client.evals.create(
    name="Synthetic Data Evaluation",
    data_source_config=data_source_config,
    testing_criteria=testing_criteria,
)

data_source = {
    "type": "azure_ai_synthetic_data_gen_preview",
    "item_generation_params": {
        "type": "synthetic_data_gen_preview",
        "samples_count": 5,
        "prompt": "Generate customer service questions about returning defective products",
        "model_deployment_name": model_deployment_name,
        "output_dataset_name": "my-synthetic-dataset",
    },
    "target": {
        "type": "azure_ai_model",
        "model": model_deployment_name,
    },
}

eval_run = client.evals.runs.create(
    eval_id=eval_object.id,
    name="synthetic-data-evaluation",
    data_source=data_source,
)

Volitelně můžete přidat výzvu systému k tvarování chování cílového modelu. Pokud používáte input_messages s generováním syntetických dat, zahrňte pouze system zprávy rolí – služba poskytuje generované dotazy jako uživatelské zprávy automaticky.

data_source = {
    "type": "azure_ai_synthetic_data_gen_preview",
    "item_generation_params": {
        "type": "synthetic_data_gen_preview",
        "samples_count": 5,
        "prompt": "Generate customer service questions about returning defective products",
        "model_deployment_name": model_deployment_name,
    },
    "target": {
        "type": "azure_ai_model",
        "model": model_deployment_name,
    },
    "input_messages": {
        "type": "template",
        "template": [
            {
                "type": "message",
                "role": "system",
                "content": {
                    "type": "input_text",
                    "text": "You are a helpful customer service agent. Be empathetic and solution-oriented."
                }
            }
        ]
    },
}

Cíl agenta

Generování syntetických dotazů a vyhodnocení agenta Foundry:

data_source = {
    "type": "azure_ai_synthetic_data_gen_preview",
    "item_generation_params": {
        "type": "synthetic_data_gen_preview",
        "samples_count": 5,
        "prompt": "Generate questions about returning defective products",
        "model_deployment_name": model_deployment_name,
    },
    "target": {
        "type": "azure_ai_agent",
        "name": agent_name,
        "version": agent_version,
    },
}

eval_run = client.evals.runs.create(
    eval_id=eval_object.id,
    name="synthetic-agent-evaluation",
    data_source=data_source,
)

Pro dotazování na dokončení a interpretaci výsledků, viz Získání výsledků. Odpověď obsahuje output_dataset_id vlastnost, která obsahuje ID vygenerované datové sady, kterou můžete použít k načtení nebo opakovanému použití syntetických dat.

Získání výsledků

Po dokončení zkušebního spuštění načtěte výsledky se skóre a zkontrolujte je na portálu nebo programově.

Hlasování o výsledcích

Provádění vyhodnocení probíhá asynchronně. Opakovaně kontrolujte stav běhu, dokud není dokončen, poté získejte výsledky.

import time
from pprint import pprint

while True:
    run = client.evals.runs.retrieve(
        run_id=eval_run.id, eval_id=eval_object.id
    )
    if run.status in ("completed", "failed"):
        break
    time.sleep(5)
    print("Waiting for eval run to complete...")

if run.status == "failed":
    print(f"Evaluation run failed: {run.error}")
else:
    # Retrieve results
    output_items = list(
        client.evals.runs.output_items.list(
            run_id=run.id, eval_id=eval_object.id
        )
    )
    pprint(output_items)
    print(f"Report URL: {run.report_url}")

Interpretace výsledků

V jednom příkladu dat vypíše všechny vyhodnocovače následující schéma:

  • Označení: binární "prošel" nebo "neprošel," podobné výstupu jednotkového testu. Pomocí tohoto výsledku můžete usnadnit porovnání mezi vyhodnocovači.
  • Skóre: skóre z přirozeného měřítka každého vyhodnocovače. Někteří hodnotitelé používají jemně odstupňovanou rubriku, bodování na 5bodové stupnici (vyhodnocovače kvality) nebo 7bodové měřítko (vyhodnocovače bezpečnosti obsahu). Jiné, například textové vyhodnocovače podobnosti, používají skóre F1, které jsou plovoucí mezi 0 a 1. Jakékoli nebinární "skóre" se v poli popisku na základě prahové hodnoty binarizuje na "pass" nebo "fail".
  • Prahová hodnota: Jakékoli nebinární skóre se binarizují na "pass" nebo "fail" na základě výchozí prahové hodnoty, kterou může uživatel přepsat v prostředí sady SDK.
  • Důvod: Aby bylo možné zlepšit srozumitelnost, vypíše všechny vyhodnocovací moduly LLM také pole s odůvodněním, které vysvětluje, proč je zadané určité skóre.
  • Podrobnosti: (volitelné) U některých vyhodnocovačů, například tool_call_accuracy, může existovat pole podrobností nebo příznaky, které obsahují další informace, které uživatelům pomůžou ladit své aplikace.

Příklad výstupu (jedna položka)

{
  "type": "azure_ai_evaluator",
  "name": "Coherence",
  "metric": "coherence",
  "score": 4.0,
  "label": "pass",
  "reason": "The response is well-structured and logically organized, presenting information in a clear and coherent manner.",
  "threshold": 3,
  "passed": true
}

Příklad výstupu (agregace)

Pro agregaci výsledků v několika příkladech dat (datové sadě) tvoří průměrná míra příkladů, které "projdou," míru úspěšnosti pro danou datovou sadu.

{
  "eval_id": "eval_abc123",
  "run_id": "run_xyz789",
  "status": "completed",
  "result_counts": {
    "passed": 85,
    "failed": 15,
    "total": 100
  },
  "per_testing_criteria_results": [
    {
      "name": "coherence",
      "passed": 92,
      "failed": 8,
      "pass_rate": 0.92
    },
    {
      "name": "relevance", 
      "passed": 78,
      "failed": 22,
      "pass_rate": 0.78
    }
  ]
}

Řešení problémů

Úloha běží po dlouhou dobu

Vaše zkušební úloha může zůstat ve stavu Spuštěno po delší dobu. K tomu obvykle dochází, když nasazení modelu Azure OpenAI nemá dostatečnou kapacitu, což způsobí, že služba opakuje požadavky.

Řešení:

  1. Zrušte aktuální úlohu vyhodnocení pomocí client.evals.runs.cancel(run_id, eval_id=eval_id)funkce .
  2. Zvyšte kapacitu modelu na portálu Azure.
  3. Znovu spusťte vyhodnocení.

Chyby ověřování

Pokud se vám zobrazí chyba 401 Unauthorized nebo chyba 403 Forbidden, ověřte, že:

  • Správně nakonfigurovaný DefaultAzureCredential (pokud používáte Azure CLI, spusťte az login).
  • Váš účet má roli uživatele Azure AI v projektu Foundry.
  • Adresa URL koncového bodu projektu je správná a obsahuje názvy účtů i projektů.

Chyby formátu dat

Pokud vyhodnocení selže s chybou schématu nebo mapování dat:

  • Ověřte, že soubor JSONL obsahuje jeden platný objekt JSON na řádek.
  • Ověřte, že názvy polí v data_mapping přesně odpovídají názvům polí v souboru JSONL (rozlišují se malá a velká písmena).
  • Zkontrolujte, že item_schema vlastnosti odpovídají polím v datové sadě.

Chyby omezení rychlosti

Vytváření hodnotících spuštění je omezené počtem na úrovni tenanta, předplatného a projektu. Pokud obdržíte 429 Too Many Requests odpověď:

  • Zkontrolujte hlavičku retry-after v odpovědi na doporučenou dobu čekání.
  • Podrobnosti o limitu rychlosti najdete v textu odpovědi.
  • Při opakování neúspěšných požadavků použijte exponenciální zpomalování.

Pokud úloha vyhodnocení selže s chybou 429 během provádění:

  • Zmenšete velikost testovací datové sady nebo ji rozdělte do menších dávek.
  • Zvyšte kvótu tokenů za minutu (TPM) pro nasazení modelu na portálu Azure.

Chyby nástroje vyhodnocovače agentů

Pokud vyhodnocovač agentu vrátí chybu pro nepodporované nástroje:

  • Projděte si podporované nástroje pro vyhodnocovače agentů.
  • Jako alternativní řešení zabalte nepodporované nástroje jako uživatelsky definované nástroje funkcí, aby je vyhodnocovací nástroj mohl posoudit.

Související obsah

  • Last updated on