Vyhodnoťte svou generativní AI aplikaci místně pomocí sady Azure AI Evaluation SDK (verze Preview) (Classic)

Platí jenom pro:Portál Foundry (Classic). Tento článek není k dispozici pro nový portál Foundry. Přečtěte si další informace o novém portálu.

Poznámka:

Některé odkazy v tomto článku můžou otevřít obsah v nové dokumentaci Microsoft Foundry místo dokumentace Foundry (klasické), kterou si právě prohlížíte.

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 Preview.

Výkon generující aplikace AI můžete důkladně posoudit tak, že ji použijete na podstatnou datovou sadu. Vyhodnoťte aplikaci ve vývojovém prostředí pomocí sady AZURE AI Evaluation SDK.

Když zadáte testovací datovou sadu nebo cíl, výstupy generující aplikace AI se kvantitativní měří pomocí matematických metrik i vyhodnocovačů kvality a bezpečnosti s asistencí umělé inteligence. Integrované nebo vlastní vyhodnocovače vám můžou poskytnout komplexní přehled o možnostech a omezeních aplikace.

V tomto článku se dozvíte, jak spustit vyhodnocovače na jednom řádku dat a větší testovací datové sadě v cíli aplikace. Používáte integrované vyhodnocovače, které používají sadu AZURE AI Evaluation SDK místně. Pak se naučíte sledovat výsledky a protokoly hodnocení v project Foundry.

Začínáme

Nejprve nainstalujte balíček vyhodnocovačů ze sady AZURE AI Evaluation SDK:

pip install azure-ai-evaluation

Poznámka:

Další informace najdete v tématu Azure klientská knihovna pro vyhodnocení AI pro Python.

Předdefinované vyhodnocovače

Integrované metriky kvality a bezpečnosti přijímají páry dotazů a odpovědí spolu s dalšími informacemi pro konkrétní vyhodnocovače.

Kategorie	Hodnotitelé
Obecné účely	`CoherenceEvaluator` `FluencyEvaluator`, `QAEvaluator`
Textová podobnost	`SimilarityEvaluator`, `F1ScoreEvaluator`, `BleuScoreEvaluator`, `GleuScoreEvaluator`, , `RougeScoreEvaluatorMeteorScoreEvaluator`
Generování rozšířené pomocí načítání (RAG)	`RetrievalEvaluator`, `DocumentRetrievalEvaluator`, `GroundednessEvaluator`, `GroundednessProEvaluator`, , `RelevanceEvaluatorResponseCompletenessEvaluator`
Rizika a bezpečnost	`ViolenceEvaluator`, `SexualEvaluator`, `SelfHarmEvaluator`, `HateUnfairnessEvaluator`, `IndirectAttackEvaluator`, `ProtectedMaterialEvaluator`, `UngroundedAttributesEvaluator`, `CodeVulnerabilityEvaluator`, `ContentSafetyEvaluator`
Agentic	`IntentResolutionEvaluator` `ToolCallAccuracyEvaluator`, `TaskAdherenceEvaluator`
Azure OpenAI	`AzureOpenAILabelGrader`, `AzureOpenAIStringCheckGrader`, , `AzureOpenAITextSimilarityGraderAzureOpenAIGrader`

Požadavky na data pro předdefinované vyhodnocovače

Předdefinované vyhodnocovače můžou přijímat páry dotazů a odpovědí, seznam konverzací ve formátu JSON Lines (JSONL) nebo obojí.

Hodnotitel	Podpora konverzace a jednoduchého otočení textu	Podpora konverzace a jednokrokové interakce pro text a obraz	Podpora pouze textu v jednom kroku	Požaduje `ground_truth`	Podporuje vstupy agentů.
Vyhodnocovače kvality
`IntentResolutionEvaluator`					✓
`ToolCallAccuracyEvaluator`					✓
`TaskAdherenceEvaluator`					✓
`GroundednessEvaluator`	✓				✓
`GroundednessProEvaluator`	✓
`RetrievalEvaluator`	✓
`DocumentRetrievalEvaluator`	✓			✓
`RelevanceEvaluator`	✓				✓
`CoherenceEvaluator`	✓
`FluencyEvaluator`	✓
`ResponseCompletenessEvaluator`			✓	✓
`QAEvaluator`			✓	✓
Vyhodnocovače zpracování přirozeného jazyka (NLP)
`SimilarityEvaluator`			✓	✓
`F1ScoreEvaluator`			✓	✓
`RougeScoreEvaluator`			✓	✓
`GleuScoreEvaluator`			✓	✓
`BleuScoreEvaluator`			✓	✓
`MeteorScoreEvaluator`			✓	✓
Bezpečnostní vyhodnocovače
`ViolenceEvaluator`		✓
`SexualEvaluator`		✓
`SelfHarmEvaluator`		✓
`HateUnfairnessEvaluator`		✓
`ProtectedMaterialEvaluator`		✓
`ContentSafetyEvaluator`		✓
`UngroundedAttributesEvaluator`			✓
`CodeVulnerabilityEvaluator`			✓
`IndirectAttackEvaluator`	✓
Azure OpenAI Graders
`AzureOpenAILabelGrader`	✓
`AzureOpenAIStringCheckGrader`	✓
`AzureOpenAITextSimilarityGrader`	✓			✓
`AzureOpenAIGrader`	✓

Poznámka:

Hodnocení kvality s asistencí umělé inteligence, s výjimkou SimilarityEvaluator, zahrnují pole důvod. Používají techniky, jako je řetěz myšlení, k vygenerování vysvětlení skóre.

V důsledku vyšší kvality hodnocení spotřebovávají větší množství tokenů při generování. max_token je konkrétně pro generování vyhodnocovačů nastavena na 800 pro většinu vyhodnocovačů s asistencí umělé inteligence. Má hodnotu 1600 pro RetrievalEvaluator a 3000, ToolCallAccuracyEvaluator aby vyhovovala delším vstupům.

Azure OpenAI posuzovatelé vyžadují šablonu, která popisuje, jak se jejich vstupní sloupce mění na skutečný vstup, který používá posuzovatel. Pokud máte například dva vstupy s názvem dotaz a odpověď a šablona formátovaná jako {{item.query}}, použije se pouze dotaz. Podobně můžete mít něco jako {{item.conversation}}, aby přijal konverzační vstup, ale schopnost systému toto zpracovat závisí na tom, jak nakonfigurujete zbytek klasifikačního nástroje pro očekávání tohoto vstupu.

Další informace o požadavcích na data pro evaluátory agentů najdete v Vyhodnocení vašich AI agentů.

Podpora textu s jedním otočením

Všechny integrované vyhodnocovače přebírají jednotlivé vstupy jako dvojice dotazu a odpovědi v řetězcích. Například:

from azure.ai.evaluation import RelevanceEvaluator

query = "What is the capital of life?"
response = "Paris."

# Initialize an evaluator:
relevance_eval = RelevanceEvaluator(model_config)
relevance_eval(query=query, response=response)

Pokud chcete spustit dávkové vyhodnocení pomocí místního vyhodnocení nebo nahrát datovou sadu ke spuštění cloudového vyhodnocení, představujte datovou sadu ve formátu JSONL. Předchozí údaje z jednoduchého dotazu, což je pár dotazu a odpovědi, jsou ekvivalentní řádku datové sady jako v následujícím příkladu se třemi řádky.

{"query":"What is the capital/major city of France?","response":"Paris."}
{"query":"What atoms compose water?","response":"Hydrogen and oxygen."}
{"query":"What color is my shirt?","response":"Blue."}

Testovací datová sada vyhodnocení může obsahovat následující prvky v závislosti na požadavcích každého integrovaného vyhodnocovače:

Dotaz: Dotaz odeslaný do aplikace generující umělé inteligence.
Odpověď: Odpověď na dotaz vygenerovaný generovanou aplikací AI.
Kontext: Zdroj vygenerované odpovědi je založen na. To znamená podkladové dokumenty.
Pravdivá pravda: Odpověď vygenerovaná uživatelem nebo člověkem jako pravdivá odpověď.

Pokud chcete zjistit, co každý vyhodnocovací modul vyžaduje, podívejte se na předdefinované vyhodnocovače.

Podpora textových konverzací

Pro vyhodnocovače, kteří podporují konverzace pro text, můžete zadat conversation jako vstup. Tento vstup zahrnuje slovník Pythonu se seznamem messages, který zahrnuje content, rolea volitelně context.

Podívejte se na následující oboustrannou konverzaci v Pythonu:

conversation = {
        "messages": [
        {
            "content": "Which tent is the most waterproof?", 
            "role": "user"
        },
        {
            "content": "The Alpine Explorer Tent is the most waterproof",
            "role": "assistant", 
            "context": "From the our product list the alpine explorer tent is the most waterproof. The Adventure Dining Table has higher weight."
        },
        {
            "content": "How much does it cost?",
            "role": "user"
        },
        {
            "content": "The Alpine Explorer Tent is $120.",
            "role": "assistant",
            "context": None
        }
        ]
}

Pokud chcete spustit dávkové vyhodnocení pomocí místního vyhodnocení nebo nahrát datovou sadu ke spuštění cloudového vyhodnocení, musíte datovou sadu reprezentovat ve formátu JSONL. Předchozí konverzace odpovídá řádku datové sady v souboru JSONL jako v následujícím příkladu:

{"conversation":
    {
        "messages": [
        {
            "content": "Which tent is the most waterproof?", 
            "role": "user"
        },
        {
            "content": "The Alpine Explorer Tent is the most waterproof",
            "role": "assistant", 
            "context": "From the our product list the alpine explorer tent is the most waterproof. The Adventure Dining Table has higher weight."
        },
        {
            "content": "How much does it cost?",
            "role": "user"
        },
        {
            "content": "The Alpine Explorer Tent is $120.",
            "role": "assistant",
            "context": null
        }
        ]
    }
}

Naši hodnotitelé chápou, že první závrat konverzace poskytuje platné query od user, context od assistanta response z assistant formátu odpovědi dotazu. Konverzace se pak vyhodnocují pro každé kolo a výsledky se agregují přes všechny tahy, aby se určil výsledek konverzace.

Poznámka:

Ve druhém kole, i když context je null nebo chybí klíč, vyhodnocovač interpretuje krok jako prázdný řetězec místo toho, aby selhal s chybou, což může vést k zavádějícím výsledkům.

Důrazně doporučujeme ověřit data vyhodnocení tak, aby vyhovovala požadavkům na data.

Pro konverzační režim, tady je příklad pro GroundednessEvaluator:

# Conversation mode:
import json
import os
from azure.ai.evaluation import GroundednessEvaluator, AzureOpenAIModelConfiguration

model_config = AzureOpenAIModelConfiguration(
    azure_endpoint=os.environ.get("AZURE_ENDPOINT"),
    api_key=os.environ.get("AZURE_API_KEY"),
    azure_deployment=os.environ.get("AZURE_DEPLOYMENT_NAME"),
    api_version=os.environ.get("AZURE_API_VERSION"),
)

# Initialize the Groundedness evaluator:
groundedness_eval = GroundednessEvaluator(model_config)

conversation = {
    "messages": [
        { "content": "Which tent is the most waterproof?", "role": "user" },
        { "content": "The Alpine Explorer Tent is the most waterproof", "role": "assistant", "context": "From the our product list the alpine explorer tent is the most waterproof. The Adventure Dining Table has higher weight." },
        { "content": "How much does it cost?", "role": "user" },
        { "content": "$120.", "role": "assistant", "context": "The Alpine Explorer Tent is $120."}
    ]
}

# Alternatively, you can load the same content from a JSONL file.
groundedness_conv_score = groundedness_eval(conversation=conversation)
print(json.dumps(groundedness_conv_score, indent=4))

U výstupů konverzací se výsledky pro jednotlivé tahy ukládají do seznamu a celkové skóre 'groundedness': 4.0 konverzace se průměruje.

{
    "groundedness": 5.0,
    "gpt_groundedness": 5.0,
    "groundedness_threshold": 3.0,
    "evaluation_per_turn": {
        "groundedness": [
            5.0,
            5.0
        ],
        "gpt_groundedness": [
            5.0,
            5.0
        ],
        "groundedness_reason": [
            "The response accurately and completely answers the query by stating that the Alpine Explorer Tent is the most waterproof, which is directly supported by the context. There are no irrelevant details or incorrect information present.",
            "The RESPONSE directly answers the QUERY with the exact information provided in the CONTEXT, making it fully correct and complete."
        ],
        "groundedness_result": [
            "pass",
            "pass"
        ],
        "groundedness_threshold": [
            3,
            3
        ]
    }
}

Poznámka:

Pokud chcete podporovat více modelů vyhodnocovače, použijte klíč bez předpon. Například použijte groundedness.groundedness.

Podpora konverzací pro obrázky a multimodální text a obrázek

Pro vyhodnocovače, kteří podporují konverzace pro obrázky a multimodální obrázky a text, můžete předat adresy URL obrázků nebo obrázky kódované v Base64 .conversation

Mezi podporované scénáře patří:

Více obrázků s textovým vstupem pro vytváření obrázků nebo generování textu.
Zadávání pouze textu pro generování obrázků
Vstup pouze obrázků pro generování textu

from pathlib import Path
from azure.ai.evaluation import ContentSafetyEvaluator
import base64

# Create an instance of an evaluator with image and multi-modal support.
safety_evaluator = ContentSafetyEvaluator(credential=azure_cred, azure_ai_project=project_scope)

# Example of a conversation with an image URL:
conversation_image_url = {
    "messages": [
        {
            "role": "system",
            "content": [
                {"type": "text", "text": "You are an AI assistant that understands images."}
            ],
        },
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Can you describe this image?"},
                {
                    "type": "image_url",
                    "image_url": {
                        "url": "https://cdn.britannica.com/68/178268-050-5B4E7FB6/Tom-Cruise-2013.jpg"
                    },
                },
            ],
        },
        {
            "role": "assistant",
            "content": [
                {
                    "type": "text",
                    "text": "The image shows a man with short brown hair smiling, wearing a dark-colored shirt.",
                }
            ],
        },
    ]
}

# Example of a conversation with base64 encoded images:
base64_image = ""

with Path.open("Image1.jpg", "rb") as image_file:
    base64_image = base64.b64encode(image_file.read()).decode("utf-8")

conversation_base64 = {
    "messages": [
        {"content": "create an image of a branded apple", "role": "user"},
        {
            "content": [{"type": "image_url", "image_url": {"url": f"data:image/jpg;base64,{base64_image}"}}],
            "role": "assistant",
        },
    ]
}

# Run the evaluation on the conversation to output the result.
safety_score = safety_evaluator(conversation=conversation_image_url)

V současné době podporují vyhodnocovače obrazu a vícerozměrné vyhodnocovače:

Jenom jeden krok: Konverzace může mít jenom jednu zprávu uživatele a jednu zprávu asistenta.
Konverzace, které mají jenom jednu systémovou zprávu.
Datové části konverzace, které jsou menší než 10 MB, včetně obrázků.
Absolutní adresy URL a obrázky s kódováním Base64
Několik obrázků na jednom turnu
Formáty souborů JPG/JPEG, PNG a GIF

Nastavení

U vyhodnocovačů kvality s asistencí umělé inteligence, s výjimkou náhledu GroundednessProEvaluator, je nutné zadat model GPT (gpt-35-turbo, gpt-4, gpt-4-turbo, gpt-4o, nebo gpt-4o-mini) ve vašem model_config. Model GPT funguje jako soudce, který vyhodnotí data vyhodnocení. Podporujeme jak schémata konfigurace modelu Azure OpenAI, tak OpenAI. Pro zajištění nejlepšího výkonu a parsovatelných odpovědí s našimi vyhodnocovači doporučujeme používat modely GPT, které nejsou ve verzi Preview.

Poznámka:

Nahraďte gpt-3.5-turbo za gpt-4o-mini ve vašem modelu vyhodnocovače. Podle OpenAI je gpt-4o-mini levnější, schopnější a stejně rychle.

Pokud chcete provádět odvozování pomocí klíče rozhraní API, ujistěte se, že máte alespoň roli Cognitive Services OpenAI User pro prostředek Azure OpenAI. Další informace o oprávněních najdete v tématu Permissions pro prostředek Azure OpenAI.

Pro všechny hodnotitele rizik a bezpečnosti a GroundednessProEvaluator (Preview), místo nasazení GPT v model_config, musíte poskytnout své azure_ai_project údaje. Tato služba přistupuje k back-endové službě hodnocení pomocí projektu Foundry.

Výzvy k vestavěným evalueátorům s asistencí umělé inteligence

Pro transparentnost jsme zveřejnili jako open source výzvy našich hodnotitelů kvality v knihovně hodnotitelů a úložišti sady Python SDK pro vyhodnocení Azure AI, s výjimkou hodnotitelů bezpečnosti a GroundednessProEvaluator, které chrání obsah Azure AI. Tyto výzvy slouží jako pokyny pro jazykový model k provedení úlohy vyhodnocení, která vyžaduje definici metriky a přidružených hodnoticích rubrik pro člověka. Důrazně doporučujeme přizpůsobit definice a klasifikační rubriky konkrétním scénářům. Další informace naleznete v tématu Vlastní vyhodnocovače.

Složené vyhodnocovače

Složené vyhodnocovače jsou integrované vyhodnocovače, které kombinují individuální metriky kvality nebo bezpečnosti. Poskytují širokou škálu metrik ihned k použití jak pro páry otázka-odpověď, tak pro chatové zprávy.

Složený hodnotitel	Obsahuje	Description
`QAEvaluator`	`GroundednessEvaluator`, `RelevanceEvaluator`, `CoherenceEvaluator`, `FluencyEvaluator`, , `SimilarityEvaluatorF1ScoreEvaluator`	Kombinuje všechny vyhodnocovače kvality pro jeden výstup kombinovaných metrik pro páry dotazů a odpovědí.
`ContentSafetyEvaluator`	`ViolenceEvaluator`, `SexualEvaluator`, , `SelfHarmEvaluatorHateUnfairnessEvaluator`	Kombinuje všechny vyhodnocovače bezpečnosti pro jeden výstup kombinovaných metrik pro páry dotazů a odpovědí.

Místní vyhodnocení testovacích datových sad pomocí `evaluate()`

Po kontrole předdefinovaných nebo vlastních vyhodnocovačů na jednom řádku dat můžete kombinovat více vyhodnocovačů s rozhraním evaluate() API pro celou testovací datovou sadu.

Přípravné kroky nastavení pro projekty Microsoft Foundry

Pokud je tato relace vaším prvním pokusem o provádění hodnocení a zapisování do svého projektu ve Foundry, možná budete potřebovat provést následující kroky nastavení:

Vytvořte a připojte svůj účet úložiště k vašemu projektu Foundry na úrovni prostředků. Tato šablona Bicep zřídí a připojí účet úložiště k vašemu projektu Foundry s ověřováním pomocí klíče.
Ujistěte se, že připojený účet úložiště má přístup ke všem projektům.
Pokud jste svůj účet úložiště připojili k Microsoft Entra ID, nezapomeňte udělit Microsoft Identity oprávnění k vlastníkovi dat objektů blob úložiště jak pro váš účet, tak pro prostředek projektu Foundry v Azure portálu.

Vyhodnoťte na datové sadě a zaznamenejte výsledky do Foundry

Aby rozhraní evaluate() API mohlo správně zpracovat data, musíte zadat mapování sloupců, které přiřazuje sloupce z datové sady k klíčovým slovům přijímaným hodnotiteli. Tento příklad určuje mapování dat pro query, responsea context.

from azure.ai.evaluation import evaluate

result = evaluate(
    data="data.jsonl", # Provide your data here:
    evaluators={
        "groundedness": groundedness_eval,
        "answer_length": answer_length
    },
    # Column mapping:
    evaluator_config={
        "groundedness": {
            "column_mapping": {
                "query": "${data.queries}",
                "context": "${data.context}",
                "response": "${data.response}"
            } 
        }
    },
    # Optionally, provide your Foundry project information to track your evaluation results in your project portal.
    azure_ai_project = azure_ai_project,
    # Optionally, provide an output path to dump a JSON file of metric summary, row-level data, and the metric and Foundry project URL.
    output_path="./myevalresults.json"
)

Návod

Získejte obsah vlastnosti result.studio_url pro odkaz, který umožňuje zobrazení vašich uložených výsledků vyhodnocení ve vašem projektu Foundry.

Výsledkem výstupu vyhodnocovače je slovník, který obsahuje agregovaná metrics data a metriky na úrovni řádků. Podívejte se na následující příklad výstupu:

{'metrics': {'answer_length.value': 49.333333333333336,
             'groundedness.gpt_groundeness': 5.0, 'groundedness.groundeness': 5.0},
 'rows': [{'inputs.response': 'Paris is the capital/major city of France.',
           'inputs.context': 'Paris has been the capital/major city of France since '
                                  'the 10th century and is known for its '
                                  'cultural and historical landmarks.',
           'inputs.query': 'What is the capital/major city of France?',
           'outputs.answer_length.value': 31,
           'outputs.groundeness.groundeness': 5,
           'outputs.groundeness.gpt_groundeness': 5,
           'outputs.groundeness.groundeness_reason': 'The response to the query is supported by the context.'},
          {'inputs.response': 'Albert Einstein developed the theory of '
                            'relativity.',
           'inputs.context': 'Albert Einstein developed the theory of '
                                  'relativity, with his special relativity '
                                  'published in 1905 and general relativity in '
                                  '1915.',
           'inputs.query': 'Who developed the theory of relativity?',
           'outputs.answer_length.value': 51,
           'outputs.groundeness.groundeness': 5,
           'outputs.groundeness.gpt_groundeness': 5,
           'outputs.groundeness.groundeness_reason': 'The response to the query is supported by the context.'},
          {'inputs.response': 'The speed of light is approximately 299,792,458 '
                            'meters per second.',
           'inputs.context': 'The exact speed of light in a vacuum is '
                                  '299,792,458 meters per second, a constant '
                                  "used in physics to represent 'c'.",
           'inputs.query': 'What is the speed of light?',
           'outputs.answer_length.value': 66,
           'outputs.groundeness.groundeness': 5,
           'outputs.groundeness.gpt_groundeness': 5,
           'outputs.groundeness.groundeness_reason': 'The response to the query is supported by the context.'}],
 'traces': {}}

Požadavky pro `evaluate()`

Rozhraní API evaluate() vyžaduje pro správné zobrazení grafů výsledků vyhodnocení ve vašem project Foundry konkrétní formát dat a názvy klíčů parametrů vyhodnocovače.

Formát dat

Rozhraní evaluate() API přijímá pouze data ve formátu JSONL. Pro všechny předdefinované vyhodnocovače vyžaduje evaluate() data v následujícím formátu s požadovanými vstupními poli. Viz předchozí část o požadovaném vstupu dat pro předdefinované vyhodnocovače. Následující fragment kódu je ukázka toho, jak může jeden řádek vypadat:

{
  "query":"What is the capital/major city of France?",
  "context":"France is in Europe",
  "response":"Paris is the capital/major city of France.",
  "ground_truth": "Paris"
}

Formát parametru vyhodnocovače

Když předáte integrované vyhodnocovače, zadejte správné mapování klíčových slov v evaluators seznamu parametrů. Následující tabulka ukazuje mapování klíčových slov vyžadované pro výsledky předdefinovaných vyhodnocovačů, které se zobrazí v uživatelském rozhraní při přihlášení k vašemu project Foundry.

Hodnotitel	Parametr klíčového slova
`GroundednessEvaluator`	`"groundedness"`
`GroundednessProEvaluator`	`"groundedness_pro"`
`RetrievalEvaluator`	`"retrieval"`
`RelevanceEvaluator`	`"relevance"`
`CoherenceEvaluator`	`"coherence"`
`FluencyEvaluator`	`"fluency"`
`SimilarityEvaluator`	`"similarity"`
`F1ScoreEvaluator`	`"f1_score"`
`RougeScoreEvaluator`	`"rouge"`
`GleuScoreEvaluator`	`"gleu"`
`BleuScoreEvaluator`	`"bleu"`
`MeteorScoreEvaluator`	`"meteor"`
`ViolenceEvaluator`	`"violence"`
`SexualEvaluator`	`"sexual"`
`SelfHarmEvaluator`	`"self_harm"`
`HateUnfairnessEvaluator`	`"hate_unfairness"`
`IndirectAttackEvaluator`	`"indirect_attack"`
`ProtectedMaterialEvaluator`	`"protected_material"`
`CodeVulnerabilityEvaluator`	`"code_vulnerability"`
`UngroundedAttributesEvaluator`	`"ungrounded_attributes"`
`QAEvaluator`	`"qa"`
`ContentSafetyEvaluator`	`"content_safety"`

Tady je příklad evaluators nastavení parametrů:

result = evaluate(
    data="data.jsonl",
    evaluators={
        "sexual":sexual_evaluator,
        "self_harm":self_harm_evaluator,
        "hate_unfairness":hate_unfairness_evaluator,
        "violence":violence_evaluator
    }
)

Místní vyhodnocení zaměřené na cíl

Pokud máte seznam dotazů, které chcete spustit a pak vyhodnotit, evaluate() rozhraní API také podporuje target parametr. Tento parametr odesílá dotazy do aplikace, aby shromáždil odpovědi, a potom spustí vyhodnocovače na výsledném dotazu a jeho odpovědi.

Cílem může být libovolná volatelná třída ve vašem adresáři. V tomto příkladu je skript askwiki.py Pythonu s volatelnou třídou askwiki() , která je nastavená jako cíl. Pokud máte datovou sadu dotazů, které můžete odeslat do jednoduché askwiki aplikace, můžete vyhodnotit základ výstupů. Ujistěte se, že jste zadali správné mapování sloupců pro vaše data v "column_mapping". Můžete použít "default" k určení mapování sloupců pro všechny vyhodnocovače.

Tady je obsah v "data.jsonl":

{"query":"When was United States found ?", "response":"1776"}
{"query":"What is the capital/major city of France?", "response":"Paris"}
{"query":"Who is the best tennis player of all time ?", "response":"Roger Federer"}

from askwiki import askwiki

result = evaluate(
    data="data.jsonl",
    target=askwiki,
    evaluators={
        "groundedness": groundedness_eval
    },
    evaluator_config={
        "default": {
            "column_mapping": {
                "query": "${data.queries}",
                "context": "${outputs.context}",
                "response": "${outputs.response}"
            } 
        }
    }
)

Váš názor

Byla tato stránka užitečná?

Last updated on 2026-03-11

Sdílet prostřednictvím

Vyhodnoťte svou generativní AI aplikaci místně pomocí sady Azure AI Evaluation SDK (verze Preview) (Classic)

Začínáme

Předdefinované vyhodnocovače

Požadavky na data pro předdefinované vyhodnocovače

Podpora textu s jedním otočením

Podpora textových konverzací

Podpora konverzací pro obrázky a multimodální text a obrázek

Nastavení

Výzvy k vestavěným evalueátorům s asistencí umělé inteligence

Složené vyhodnocovače

Místní vyhodnocení testovacích datových sad pomocí evaluate()

Přípravné kroky nastavení pro projekty Microsoft Foundry

Vyhodnoťte na datové sadě a zaznamenejte výsledky do Foundry

Požadavky pro evaluate()

Formát dat

Formát parametru vyhodnocovače

Místní vyhodnocení zaměřené na cíl

Související obsah

Váš názor

Další materiály

Místní vyhodnocení testovacích datových sad pomocí `evaluate()`

Požadavky pro `evaluate()`