Vyhodnocení aplikace Generative AI pomocí sady Azure AI Evaluation SDK

Článek
12/21/2024

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 dodatečných podmínkách použití pro verze Preview v Microsoft Azure.

Poznámka:

Vyhodnocení pomocí sady SDK toku výzvy bylo vyřazeno a nahrazeno sadou Azure AI Evaluation SDK.

Pokud chcete důkladně posoudit výkon generující aplikace AI při použití na podstatnou datovou sadu, můžete vyhodnotit aplikaci Generative AI ve vývojovém prostředí pomocí sady SDK pro vyhodnocení Azure AI. Vzhledem k testovací datové sadě nebo cíli se generace generující aplikace AI měří kvantitativním způsobem 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 spouštět vyhodnocovače na jednom řádku dat, větší testovací datovou sadu v cíli aplikace s integrovanými vyhodnocovači využívajícími sadu SDK pro hodnocení Azure AI místně i vzdáleně v cloudu a pak sledovat výsledky a protokoly hodnocení v projektu Azure AI.

Začínáme

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

pip install azure-ai-evaluation

Předdefinované vyhodnocovače

Předdefinované vyhodnocovače podporují následující scénáře aplikací:

Dotaz a odpověď: Tento scénář je určený pro aplikace, které zahrnují odesílání dotazů a generování odpovědí, obvykle s jedním otočením.
Rozšířené generování načítání: Tento scénář je vhodný pro aplikace, ve kterých se model zabývá generováním pomocí přístupu rozšířeného načítání k extrakci informací z poskytnutých dokumentů a generování podrobných odpovědí, obvykle vícenásobný.

Podrobnější informace o jednotlivých definicích vyhodnocovače a jejich výpočtu najdete v tématu Vyhodnocení a monitorování metrik pro generování umělé inteligence.

Kategorie	Vyhodnocovací třída
Výkon a kvalita (asistovaná AI)	`GroundednessEvaluator`, `GroundednessProEvaluator`, `RetrievalEvaluator`, `RelevanceEvaluator`, `CoherenceEvaluator`, , `FluencyEvaluatorSimilarityEvaluator`
Výkon a kvalita (NLP)	`F1ScoreEvaluator`, `RougeScoreEvaluator`, `GleuScoreEvaluator`, , `BleuScoreEvaluatorMeteorScoreEvaluator`
Rizika a bezpečnost (asistovaná AI)	`ViolenceEvaluator`, `SexualEvaluator`, `SelfHarmEvaluator`, `HateUnfairnessEvaluator`, , `IndirectAttackEvaluatorProtectedMaterialEvaluator`
Skládání	`QAEvaluator`, `ContentSafetyEvaluator`

Integrované metriky kvality a bezpečnosti se zabírají ve dvojicích dotazů a odpovědí spolu s dalšími informacemi pro konkrétní vyhodnocovače.

Tip

Další informace o vstupech a výstupech najdete v referenční dokumentaci k Azure Pythonu.

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

Předdefinované vyhodnocovače můžou přijímat páry dotazů a odpovědí nebo seznam konverzací:

Dvojice dotazů a odpovědí ve .jsonl formátu s požadovanými vstupy.
Seznam konverzací ve .jsonl formátu v následující části

Evaluator	`query`	`response`	`context`	`ground_truth`	`conversation`
`GroundednessEvaluator`	Volitelné: Řetězec	Povinné: Řetězec	Povinné: Řetězec	–	Podporováno pro text
`GroundednessProEvaluator`	Povinné: Řetězec	Povinné: Řetězec	Povinné: Řetězec	–	Podporováno pro text
`RetrievalEvaluator`	Povinné: Řetězec	–	Povinné: Řetězec	–	Podporováno pro text
`RelevanceEvaluator`	Povinné: Řetězec	Povinné: Řetězec	–	N/A	Podporováno pro text
`CoherenceEvaluator`	Povinné: Řetězec	Povinné: Řetězec	–	N/A	Podporováno pro text
`FluencyEvaluator`	–	Povinné: Řetězec	–	N/A	Podporováno pro text
`SimilarityEvaluator`	Povinné: Řetězec	Povinné: Řetězec	–	Povinné: Řetězec	Nepodporováno
`F1ScoreEvaluator`	–	Povinné: Řetězec	–	Povinné: Řetězec	Nepodporováno
`RougeScoreEvaluator`	–	Povinné: Řetězec	–	Povinné: Řetězec	Nepodporováno
`GleuScoreEvaluator`	–	Povinné: Řetězec	–	Povinné: Řetězec	Nepodporováno
`BleuScoreEvaluator`	–	Povinné: Řetězec	–	Povinné: Řetězec	Nepodporováno
`MeteorScoreEvaluator`	–	Povinné: Řetězec	–	Povinné: Řetězec	Nepodporováno
`ViolenceEvaluator`	Povinné: Řetězec	Povinné: Řetězec	–	N/A	Podporováno pro text a obrázek
`SexualEvaluator`	Povinné: Řetězec	Povinné: Řetězec	–	N/A	Podporováno pro text a obrázek
`SelfHarmEvaluator`	Povinné: Řetězec	Povinné: Řetězec	–	N/A	Podporováno pro text a obrázek
`HateUnfairnessEvaluator`	Povinné: Řetězec	Povinné: Řetězec	–	N/A	Podporováno pro text a obrázek
`IndirectAttackEvaluator`	Povinné: Řetězec	Povinné: Řetězec	Povinné: Řetězec	–	Podporováno pro text
`ProtectedMaterialEvaluator`	Povinné: Řetězec	Povinné: Řetězec	–	N/A	Podporováno pro text a obrázek
`QAEvaluator`	Povinné: Řetězec	Povinné: Řetězec	Povinné: Řetězec	Povinné: Řetězec	Nepodporováno
`ContentSafetyEvaluator`	Povinné: Řetězec	Povinné: Řetězec	–	N/A	Podporováno pro text a obrázek

Dotaz: dotaz odeslaný do aplikace generující umělé inteligence
Odpověď: odpověď na dotaz vygenerovaný aplikací generující AI
Kontext: zdroj, na kterém je generovaná odpověď založena (tedy podkladové dokumenty)
Pravdivá pravda: odpověď vygenerovaná uživatelem nebo člověkem jako pravdivá odpověď
Konverzace: seznam zpráv uživatele a asistenta se otočí. Další informace najdete v další části.

Poznámka:

Vyhodnocovače kvality s asistencí umělé inteligence s výjimkou SimilarityEvaluator pole s odůvodněním. Používají techniky včetně řetězu myšlenkových důvodů k vygenerování vysvětlení skóre. Proto budou využívat více využití tokenů při generování v důsledku vyšší kvality hodnocení. Konkrétně pro max_token generování vyhodnocovače bylo nastaveno 800 pro všechny vyhodnocovače asistované umělé inteligence (a 1600 pro RetrievalEvaluator přizpůsobení delším vstupům.)

Podpora konverzací pro text

Pro vyhodnocovače, které podporují konverzace pro text, můžete zadat conversation jako vstup, slovník Pythonu se seznamem messages (včetně content, rolea volitelně context). Následuje příklad oboustranné konverzace.

{"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í podle odevzdání a výsledky se agregují po všech obratech pro skóre konverzace.

Poznámka:

Všimněte si, že v druhé řadě, i když context je null nebo chybí klíč, bude interpretován jako prázdný řetězec místo chybování, 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 vyhodnocovače, které podporují konverzace pro obrázky a vícemodální obrázky a text, můžete předat adresy URL obrázků nebo kódované obrázky base64 do conversation.

Tady jsou příklady podporovaných scénářů:

Více obrázků s textovým vstupem do obrázku nebo generování textu
Textové zadání pouze pro generace obrázků
Pouze vstupy pro generování textu

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

# instantiate 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ě podporuje image a vícemodální vyhodnocovače:

Jenom jedno zapnutí (konverzace může mít jenom jednu uživatelskou zprávu a 1 zprávu asistenta)
Konverzace může mít pouze 1 systémovou zprávu.
Datová část konverzace by měla mít velikost menší než 10 MB (včetně obrázků).
Absolutní adresy URL a obrázky s kódováním Base64
Více obrázků na jednom turnu
JPG/JPEG, PNG, GIF formáty souborů

Vyhodnocovače výkonu a kvality

Pomocí našich integrovaných vyhodnocovačů kvality AI a NLP můžete posoudit výkon a kvalitu vaší aplikace generující umělé inteligence.

Nastavení

U vyhodnocovačů kvality s asistencí umělé inteligence s výjimkou GroundednessProEvaluatorpřípadů je nutné určit model GPT, který bude fungovat jako soudce, který bude vyhodnocovat data. Zvolte nasazení s modelem GPT-3.5, GPT-4, GPT-4o nebo GPT-4-mini pro vaše výpočty a nastavte ho jako svůj model_config. Podporujeme konfigurační schéma modelu Azure OpenAI nebo OpenAI. Doporučujeme používat modely GPT, které nemají příponu (preview) pro nejlepší výkon a parsovatelné odpovědi s našimi vyhodnocovači.

Poznámka:

Ujistěte se, že máte alespoň Cognitive Services OpenAI User roli pro prostředek Azure OpenAI, abyste mohli provádět odvozování volání pomocí klíče rozhraní API. Další informace o oprávněních pro prostředek Azure OpenAI

Místo GroundednessProEvaluatornasazení GPT musíte model_configzadat své azure_ai_project informace. Tím se přistupuje ke službě vyhodnocení back-endu vašeho projektu Azure AI.

Využití vyhodnocovače výkonu a kvality

Předdefinované vyhodnocovače můžete spustit importem požadované třídy vyhodnocovače. Ujistěte se, že jste nastavili proměnné prostředí.

import os
from azure.identity import DefaultAzureCredential
credential = DefaultAzureCredential()

# Initialize Azure AI project and Azure OpenAI conncetion with your environment variables
azure_ai_project = {
    "subscription_id": os.environ.get("AZURE_SUBSCRIPTION_ID"),
    "resource_group_name": os.environ.get("AZURE_RESOURCE_GROUP"),
    "project_name": os.environ.get("AZURE_PROJECT_NAME"),
}

model_config = {
    "azure_endpoint": os.environ.get("AZURE_OPENAI_ENDPOINT"),
    "api_key": os.environ.get("AZURE_OPENAI_API_KEY"),
    "azure_deployment": os.environ.get("AZURE_OPENAI_DEPLOYMENT"),
    "api_version": os.environ.get("AZURE_OPENAI_API_VERSION"),
}


from azure.ai.evaluation import GroundednessProEvaluator, GroundednessEvaluator

# Initialzing Groundedness and Groundedness Pro evaluators
groundedness_eval = GroundednessEvaluator(model_config)
groundedness_pro_eval = GroundednessProEvaluator(azure_ai_project=azure_ai_project, credential=credential)

query_response = dict(
    query="Which tent is the most waterproof?",
    context="The Alpine Explorer Tent is the most water-proof of all tents available.",
    response="The Alpine Explorer Tent is the most waterproof."
)

# Running Groundedness Evaluator on a query and response pair
groundedness_score = groundedness_eval(
    **query_response
)
print(groundedness_score)

groundedness_pro_score = groundedness_pro_eval(
    **query_response
)
print(groundedness_pro_score)

Tady je příklad výsledku páru dotazů a odpovědí:

Pro


# Evaluation Service-based Groundedness Pro score:
 {
    'groundedness_pro_label': False, 
    'groundedness_pro_reason': '\'The Alpine Explorer Tent is the most waterproof.\' is ungrounded because "The Alpine Explorer Tent is the second most water-proof of all tents available." Thus, the tagged word [ Alpine Explorer Tent ] being the most waterproof is a contradiction.'
}
# Open-source prompt-based Groundedness score:
 {
    'groundedness': 3.0, 
    'gpt_groundedness': 3.0, 
    'groundedness_reason': 'The response attempts to answer the query but contains incorrect information, as it contradicts the context by stating the Alpine Explorer Tent is the most waterproof when the context specifies it is the second most waterproof.'
}

Výsledkem vyhodnocovačů kvality asistované umělé inteligence pro dvojici dotazů a odpovědí je slovník obsahující:

{metric_name} poskytuje číselné skóre.
{metric_name}_label poskytuje binární popisek.
{metric_name}_reason vysvětluje, proč bylo pro každý datový bod zadané určité skóre nebo popisek.

U vyhodnocovačů NLP je v klíči {metric_name} zadané pouze skóre.

Stejně jako u 6 dalších vyhodnocovačů s asistencí umělé inteligence je vyhodnocovač založený na příkazovém řádku, GroundednessEvaluator který vypíše skóre na 5bodové stupnici (čím vyšší je skóre, tím je výsledek uzemněnější). Na druhé straně vyvolá naši službu hodnocení back-endu využívající Zabezpečení obsahu Azure AI a výstupyTrue, GroundednessProEvaluator pokud je veškerý obsah uzemněný nebo False pokud se zjistí jakýkoli obsah, který není v popředí.

Opensourcové výzvy našich vyhodnocovačů kvality s výjimkou GroundednessProEvaluator zajištění transparentnosti (využívajících Azure AI Content Safety). Tyto výzvy slouží jako pokyny pro jazykový model k provedení své úlohy vyhodnocení, která vyžaduje uživatelsky přívětivou definici metriky a přidružených hodnoticích rubrik (co 5 úrovní kvality pro metriku znamenají). Důrazně doporučujeme, aby si uživatelé přizpůsobili definice a známkování podle konkrétních scénářů. Podrobnosti najdete ve vlastních vyhodnocovacích.

Tady je příklad GroundednessEvaluator:

# Conversation mode
import json

conversation_str =  """{"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."} ] }""" 
conversation = json.loads(conversation_str)

groundedness_conv_score = groundedness_eval(conversation=conversation)
print(groundedness_conv_score)

U výstupů konverzací se výsledky pro jednotlivé převody ukládají do seznamu a celkové skóre 'groundedness': 4.0 konverzace se průměruje po průběhu:

{   'groundedness': 4.0,
    'gpt_groundedness': 4.0,
    'evaluation_per_turn': {'groundedness': [5.0, 3.0],
    'gpt_groundedness': [5.0, 3.0],
    'groundedness_reason': ['The response accurately and completely answers the query using the information provided in the context.','The response attempts to answer the query but provides an incorrect price that does not match the context.']}
}

Poznámka:

Důrazně doporučujeme, aby uživatelé migrovali svůj kód tak, aby používali klíč bez předpon (například groundedness.groundedness) a umožnili tak vašemu kódu podporu více vyhodnocovače modelů.

Vyhodnocovače rizik a bezpečnosti

Pokud používáte metriky rizika a bezpečnosti asistované umělé inteligence, model GPT se nevyžaduje. Místo toho model_configuveďte své azure_ai_project informace. Tím se přistupuje k back-endové službě pro vyhodnocení bezpečnosti projektu Azure AI, která zřídí model GPT specifický pro vyhodnocení škod, které může generovat skóre závažnosti rizika obsahu a odůvodnění, které umožní vyhodnocovače bezpečnosti.

Podpora oblastí

V současné době jsou metriky rizik s asistencí umělé inteligence a bezpečnosti dostupné pouze v následujících oblastech:

Oblast	Nenávist a nespravedlivost, Sexuální, Násilné, Sebeškozování, Nepřímý útok	Chráněný materiál
USA – východ 2	Podporováno	Podporováno
Švédsko – střed	Podporováno	–
Francie – střed	Podporováno	–
Švýcarsko – západ	Podporováno	–

Další informace opodporovaných metrikách a o tom, kdy se má metrika použít, najdete v tématu Vyhodnocení a monitorování metrik pro generování umělé inteligence.

Používání vyhodnocovače rizik a bezpečnosti

azure_ai_project = {
    "subscription_id": "<subscription_id>",
    "resource_group_name": "<resource_group_name>",
    "project_name": "<project_name>",
}

from azure.ai.evaluation import ViolenceEvaluator
from azure.identity import DefaultAzureCredential
credential = DefaultAzureCredential()


# Initializing Violence Evaluator with project information
violence_eval = ViolenceEvaluator(credential=credential, azure_ai_project=azure_ai_project)
# Running Violence Evaluator on a query and response pair
violence_score = violence_eval(query="What is the capital of France?", answer="Paris.")
print(violence_score)

# Conversation mode
import json

conversation_str =  """{"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."} ] }""" 
conversation = json.loads(conversation_str)

violence_conv_score = violence_eval(conversation=conversation) 

print(violence_conv_score)

{
    'violence': 'Very low',
    'violence_reason': "The system's response is a straightforward factual answer "
                    'to a geography question. There is no violent content or '
                    'language present.',
    'violence_score': 0
}

Výsledkem vyhodnocovačů bezpečnosti obsahu pro dvojici dotazů a odpovědí je slovník obsahující:

{metric_name} poskytuje popisek závažnosti pro toto riziko obsahu v rozsahu Od velmi nízkých, nízkých, středních a vysokých. Tady si můžete přečíst další informace o popisech jednotlivých rizik obsahu a závažnosti.
{metric_name}_score má rozsah od 0 do 7 úrovně závažnosti, která se mapuje na popisek závažnosti, který je uveden v {metric_name}.
{metric_name}_reason vysvětluje, proč bylo pro každý datový bod zadané určité skóre závažnosti.

U výstupů konverzací se výsledky pro jednotlivé převody ukládají do seznamu a celkové skóre 'violence_score': 0.0 konverzace se průměruje po průběhu:

{
    'violence_score': 0.0,
    'evaluation_per_turn': {'violence': ['Very low', 'Very low'],
    'violence_score': [0, 0],
    'violence_reason': ["The system's response is a straightforward answer to a question about waterproof tents. There is no mention of violence, harm, or any related content. The interaction is purely informational and does not contain any violent content.",
   "The system's response does not contain any violent content. It simply provides a price in response to the human's question. There is no mention or depiction of violence, harm, or any related themes."]
}

Vyhodnocení ohrožení zabezpečení s jailbreakem s přímým a nepřímým útokem

Podporujeme vyhodnocení ohrožení zabezpečení vůči následujícím typům útoků s jailbreakem:

Přímý útok s jailbreakem (označovaným také jako UPIA nebo útok vložený uživatelem) vloží výzvy do role uživatele, aby se konverzace nebo dotazy generovaly aplikace umělé inteligence.
Nepřímý útok s jailbreakem (označovaným také jako XPIA nebo útok vložený do více domén) vloží výzvy do vrácených dokumentů nebo kontextu dotazu uživatele pro generování aplikací AI.

Vyhodnocení přímého útoku je srovnávací měření pomocí vyhodnocovačů bezpečnosti obsahu jako ovládacího prvku. Nejedná se o vlastní metriku s asistencí AI. Spusťte ContentSafetyEvaluator dvě různé datové sady seskupené červeně:

Standardní datová sada nežádoucích testů
Nežádoucí testovací datová sada s injektážemi jailbreaku s přímým útokem v první řadě.

Můžete to udělat pomocí funkcí a datových sad útoků vygenerovaných simulátorem přímého útoku se stejným počátečním náhodném rozdělením. Pak můžete vyhodnotit ohrožení zabezpečení jailbreaku porovnáním výsledků z vyhodnocovačů bezpečnosti obsahu mezi agregovanými skóre dvou testovacích datových sad pro každého vyhodnocovače bezpečnosti. Chyba přímého útoku s jailbreakem se zjistí v případě, že v druhé přímé útoku byla zjištěna odpověď na poškození obsahu, když v první řídicí datové sadě nebyla zjištěna žádná nebo nižší závažnost.

Vyhodnocení nepřímého útoku je metrika s asistencí umělé inteligence a nevyžaduje srovnávací měření, jako je vyhodnocení přímých útoků. Vygenerujte datovou sadu vloženou do nepřímého útoku s jailbreakem pomocí simulátoru nepřímého útoku IndirectAttackEvaluatora pak spusťte vyhodnocení pomocí nástroje .

Složené vyhodnocovače

Složené vyhodnocovače jsou integrované v vyhodnocovacích nástrojích, které kombinují jednotlivé metriky kvality nebo bezpečnosti a umožňují snadno poskytnout širokou škálu metrik přímo od pole pro páry odpovědí dotazů nebo chatové zprávy.

Složený vyhodnocovací	Contains	Popis
`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í.

Vlastní vyhodnocovače

Předdefinované vyhodnocovače jsou od začátku skvělé, abyste mohli začít vyhodnocovat generace vaší aplikace. Můžete ale chtít vytvořit vlastní vyhodnocovač založený na kódu nebo na příkazovém řádku, který bude vyhovět vašim konkrétním potřebám vyhodnocení.

Vyhodnocovače založené na kódu

Někdy není pro určité metriky vyhodnocení potřeba velký jazykový model. To je v případě, že vyhodnocovače založené na kódu vám můžou dát flexibilitu definovat metriky na základě funkcí nebo volatelné třídy. Můžete vytvořit vlastní vyhodnocovač založený na kódu, například vytvořením jednoduché třídy Pythonu, která vypočítá délku odpovědi v answer_length.py adresáři answer_len/:

class AnswerLengthEvaluator:
    def __init__(self):
        pass

    def __call__(self, *, answer: str, **kwargs):
        return {"answer_length": len(answer)}

Potom spusťte vyhodnocovací objekt na řádku dat importem volatelné třídy:

with open("answer_len/answer_length.py") as fin:
    print(fin.read())

from answer_len.answer_length import AnswerLengthEvaluator

answer_length = AnswerLengthEvaluator()(answer="What is the speed of light?")

print(answer_length)

Výsledek:

{"answer_length":27}

Vyhodnocovače na základě výzev

Pokud chcete vytvořit vlastní vyhodnocovač velkých jazykových modelů založený na výzev nebo anotátor s asistencí umělé inteligence, můžete vytvořit vlastní vyhodnocovač založený na souboru výzvy . Prompty je soubor s .prompty příponou pro vývoj šablony výzvy. Asset Prompty je soubor markdownu s upraveným předním panelem. Front matter je ve formátu YAML, která obsahují mnoho polí metadat, která definují konfiguraci modelu a očekávané vstupy výzvy. Pojďme vytvořit vlastní vyhodnocovací nástroj FriendlinessEvaluator pro měření přívětivosti odpovědi.

Vytvořte friendliness.prompty soubor, který popisuje definici metriky přívětivosti a jeho hodnoticích rubrik:

---
name: Friendliness Evaluator
description: Friendliness Evaluator to measure warmth and approachability of answers.
model:
  api: chat
  parameters:
    temperature: 0.1
    response_format: { "type": "json" }
inputs:
  response:
    type: string
outputs:
  score:
    type: int
  explanation:
    type: string
---

system:
Friendliness assesses the warmth and approachability of the answer. Rate the friendliness of the response between one to five stars using the following scale:

One star: the answer is unfriendly or hostile

Two stars: the answer is mostly unfriendly

Three stars: the answer is neutral

Four stars: the answer is mostly friendly

Five stars: the answer is very friendly

Please assign a rating between 1 and 5 based on the tone and demeanor of the response.

**Example 1**
generated_query: I just dont feel like helping you! Your questions are getting very annoying.
output:
{"score": 1, "reason": "The response is not warm and is resisting to be providing helpful information."}
**Example 2**
generated_query: I'm sorry this watch is not working for you. Very happy to assist you with a replacement.
output:
{"score": 5, "reason": "The response is warm and empathetic, offering a resolution with care."}


**Here the actual conversation to be scored:**
generated_query: {{response}}
output:

Pak vytvořte třídu, která načte soubor Prompty a zpracuje výstupy ve formátu JSON:

import os
import json
import sys
from promptflow.client import load_flow


class FriendlinessEvaluator:
    def __init__(self, model_config):
        current_dir = os.path.dirname(__file__)
        prompty_path = os.path.join(current_dir, "friendliness.prompty")
        self._flow = load_flow(source=prompty_path, model={"configuration": model_config})

    def __call__(self, *, response: str, **kwargs):
        llm_response = self._flow(response=response)
        try:
            response = json.loads(llm_response)
        except Exception as ex:
            response = llm_response
        return response

Můžete vytvořit vlastní vyhodnocovací nástroj založený na příkazovém řádku a spustit ho na řádku dat:

from friendliness.friend import FriendlinessEvaluator


friendliness_eval = FriendlinessEvaluator(model_config)

friendliness_score = friendliness_eval(response="I will not apologize for my behavior!")
print(friendliness_score)

Tady je výsledek:

{
    'score': 1, 
    'reason': 'The response is hostile and unapologetic, lacking warmth or approachability.'
}

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.

Požadavky

Pokud chcete povolit protokolování do projektu Azure AI pro výsledky vyhodnocení, postupujte takto:

Spuštěním příkazu az login. se ujistěte, že jste přihlášeni.
Ujistěte se, že máte v centru Azure AI nastavení přístupu na základě identity pro účet úložiště. Pokud chcete najít úložiště, přejděte na stránku Přehled centra Azure AI a vyberte Storage.
Ujistěte se, že máte Storage Blob Data Contributor pro účet úložiště roli.

Místní vyhodnocení datových sad

Aby bylo možné zajistit evaluate() , aby bylo možné správně analyzovat data, je nutné zadat mapování sloupců pro mapování sloupce z datové sady na klíčová slova, která jsou přijata vyhodnocovači. V tomto případě určíme 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 Azure AI project information to track your evaluation results in your Azure AI project
    azure_ai_project = azure_ai_project,
    # Optionally provide an output path to dump a json of metric summary, row level data and metric and Azure AI project URL
    output_path="./myevalresults.json"
)

Tip

Získejte obsah result.studio_url vlastnosti odkazu pro zobrazení výsledků zaprotokolovaného vyhodnocení v projektu Azure AI.

Výstupem vyhodnocovače je slovník, který obsahuje agregovaná metrics data a metriky na úrovni řádků. 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 of France.',
           'inputs.context': 'Paris has been the capital of France since '
                                  'the 10th century and is known for its '
                                  'cultural and historical landmarks.',
           'inputs.query': 'What is the capital 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í evaluate() API má několik požadavků na formát dat, který přijímá a jak zpracovává názvy klíčů parametrů vyhodnocovače, aby se grafy výsledků vyhodnocení ve vašem projektu Azure AI správně zobrazily.

Formát dat

Rozhraní evaluate() API přijímá pouze data ve formátu JSONLines. 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. Ukázka jednoho řádku může vypadat takto:

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

Formát parametru vyhodnocovače

Při předávání předdefinovaných vyhodnocovačů je důležité zadat správné mapování klíčových slov v evaluators seznamu parametrů. Následuje 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 projektu Azure AI.

Evaluator	parametr klíčového slova
`GroundednessEvaluator`	"uzemnění"
`GroundednessProEvaluator`	"groundedness_pro"
`RetrievalEvaluator`	"načítání"
`RelevanceEvaluator`	"relevance"
`CoherenceEvaluator`	"soudržnost"
`FluencyEvaluator`	"plynulost"
`SimilarityEvaluator`	"podobnost"
`F1ScoreEvaluator`	"f1_score"
`RougeScoreEvaluator`	"rudý"
`GleuScoreEvaluator`	"gleu"
`BleuScoreEvaluator`	"bleu"
`MeteorScoreEvaluator`	"meteor"
`ViolenceEvaluator`	"násilí"
`SexualEvaluator`	"sexuální"
`SelfHarmEvaluator`	"self_harm"
`HateUnfairnessEvaluator`	"hate_unfairness"
`IndirectAttackEvaluator`	"indirect_attack"
`ProtectedMaterialEvaluator`	"protected_material"
`QAEvaluator`	"qa"
`ContentSafetyEvaluator`	"content_safety"

Tady je příklad nastavení evaluators 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í cíle

Pokud máte seznamdotazůch parametru, který umožňuje odeslat do aplikace seznam dotazů, které chcete spustit evaluate() target , pak spouštět vyhodnocovače na výsledném dotazu a odpovědi.

Cílem může být libovolná volatelná třída v adresáři. V tomto případě máme skript askwiki.py Pythonu s volatelnou třídou askwiki() , kterou můžeme nastavit jako cíl. Vzhledem k datové sadě dotazů, které můžeme odeslat do naší jednoduché askwiki aplikace, můžeme 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.

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}"
            } 
        }
    }
)

Vyhodnocení cloudu u testovacích datových sad

Po místních vyhodnoceních generovaných aplikací umělé inteligence můžete chtít spustit hodnocení v cloudu pro testování před nasazením a průběžně vyhodnocovat aplikace pro monitorování po nasazení. Sada Azure AI Projects SDK nabízí tyto funkce prostřednictvím rozhraní PYTHON API a podporuje téměř všechny funkce dostupné v místních hodnoceních. Pomocí následujících kroků odešlete hodnocení do cloudu pomocí integrovaných nebo vlastních vyhodnocovačů.

Požadavky

Projekt Azure AI ve stejných oblastech jako vyhodnocovače rizik a bezpečnosti Pokud nemáte existující projekt, vytvořte ho podle průvodce vytvořením projektu Azure AI.

Poznámka:

Hodnocení cloudu nepodporují ContentSafetyEvaluatora QAEvaluator.

Nasazení Azure OpenAI s podporou chat completionmodelu GPT , například gpt-4.
Connection String pro projekt Azure AI pro snadné vytvoření AIProjectClient objektu. Project připojovací řetězec můžete získat na stránce Přehled projektu v části Podrobnosti projektu.
Spuštěním příkazu az login se ujistěte, že jste poprvé přihlášeni ke svému předplatnému Azure.

Pokyny k instalaci

Vytvořte si virtuální prostředí Pythonu podle vlastního výběru. Pokud ho chcete vytvořit pomocí conda, spusťte následující příkaz:
```
conda create -n cloud-evaluation
conda activate cloud-evaluation
```
Nainstalujte požadované balíčky spuštěním následujícího příkazu:
```
pip install azure-identity azure-ai-projects azure-ai-ml
```
Volitelně můžete pip install azure-ai-evaluation , pokud chcete, aby prostředí prvního kódu načítá ID vyhodnocovače pro předdefinované vyhodnocovače v kódu.

Teď můžete definovat klienta a nasazení, které se použije ke spuštění vyhodnocení v cloudu:


import os, time
from azure.ai.projects import AIProjectClient
from azure.identity import DefaultAzureCredential
from azure.ai.projects.models import Evaluation, Dataset, EvaluatorConfiguration, ConnectionType
from azure.ai.evaluation import F1ScoreEvaluator, RelevanceEvaluator, ViolenceEvaluator

# Load your Azure OpenAI config
deployment_name = os.environ.get("AZURE_OPENAI_DEPLOYMENT")
api_version = os.environ.get("AZURE_OPENAI_API_VERSION")

# Create an Azure AI Client from a connection string. Avaiable on Azure AI project Overview page.
project_client = AIProjectClient.from_connection_string(
    credential=DefaultAzureCredential(),
    conn_str="<connection_string>"
)

Nahrání zkušebních dat

Nabízíme dva způsoby, jak zaregistrovat data v projektu Azure AI vyžadované pro vyhodnocení v cloudu:

Ze sady SDK: Nahrajte nová data z místního adresáře do projektu Azure AI v sadě SDK a načtěte ID datové sady v důsledku toho:

data_id, _ = project_client.upload_file("./evaluate_test_data.jsonl")

Z uživatelského rozhraní: Případně můžete nahrát nová data nebo aktualizovat existující verze dat pomocí návodu uživatelského rozhraní na kartě Data projektu Azure AI.

Vzhledem k existujícím datovým sadám nahranými do projectu:

Ze sady SDK: Pokud už znáte název datové sady, kterou jste vytvořili, vytvořte ID datové sady v tomto formátu: /subscriptions/<subscription-id>/resourceGroups/<resource-group>/providers/Microsoft.MachineLearningServices/workspaces/<project-name>/data/<dataset-name>/versions/<version-number>
Z uživatelského rozhraní: Pokud název datové sady neznáte, najděte ho na kartě Data projektu Azure AI a vytvořte ID datové sady jako ve výše uvedeném formátu.

Určení vyhodnocovačů z knihovny vyhodnocovače

Poskytujeme seznam předdefinovaných vyhodnocovačů registrovaných v knihovně vyhodnocovače na kartě Vyhodnocení vašeho projektu Azure AI. Můžete také zaregistrovat vlastní vyhodnocovače a použít je k vyhodnocení v cloudu. Nabízíme dva způsoby určení registrovaných vyhodnocovačů:

Určení předdefinovaných vyhodnocovačů

Ze sady SDK: Použijte integrovanou vyhodnocovací id vlastnost podporovanou sadou azure-ai-evaluation SDK:

from azure.ai.evaluation import F1ScoreEvaluator, RelevanceEvaluator, ViolenceEvaluator
print("F1 Score evaluator id:", F1ScoreEvaluator.id)

Z uživatelského rozhraní: Pomocí následujícího postupu načtěte ID vyhodnocovače po jejich registraci do projektu:
- V projektu Azure AI vyberte kartu Vyhodnocení .
- Vybrat knihovnu vyhodnocovače;
- Vyberte své vyhodnocovače podle svého výběru porovnáním popisů;
- Zkopírujte jeho ID aktiva, které bude id vašeho vyhodnocovače, azureml://registries/azureml/models/Groundedness-Evaluator/versions/1například .

Určení vlastních vyhodnocovačů

U vlastních vyhodnocovačů založených na kódu je zaregistrujte do projektu Azure AI a načtěte ID vyhodnocovače následujícím kódem:

from azure.ai.ml import MLClient
from azure.ai.ml.entities import Model
from promptflow.client import PFClient


# Define ml_client to register custom evaluator
ml_client = MLClient(
       subscription_id=os.environ["AZURE_SUBSCRIPTION_ID"],
       resource_group_name=os.environ["AZURE_RESOURCE_GROUP"],
       workspace_name=os.environ["AZURE_PROJECT_NAME"],
       credential=DefaultAzureCredential()
)


# Load evaluator from module
from answer_len.answer_length import AnswerLengthEvaluator

# Then we convert it to evaluation flow and save it locally
pf_client = PFClient()
local_path = "answer_len_local"
pf_client.flows.save(entry=AnswerLengthEvaluator, path=local_path)

# Specify evaluator name to appear in the Evaluator library
evaluator_name = "AnswerLenEvaluator"

# Finally register the evaluator to the Evaluator library
custom_evaluator = Model(
    path=local_path,
    name=evaluator_name,
    description="Evaluator calculating answer length.",
)
registered_evaluator = ml_client.evaluators.create_or_update(custom_evaluator)
print("Registered evaluator id:", registered_evaluator.id)
# Registered evaluators have versioning. You can always reference any version available.
versioned_evaluator = ml_client.evaluators.get(evaluator_name, version=1)
print("Versioned evaluator id:", registered_evaluator.id)

Po registraci vlastního vyhodnocovače do projektu Azure AI ho můžete zobrazit v knihovně vyhodnocovače na kartě Vyhodnocení v projektu Azure AI.

V případě vlastních vyhodnocovačů založených na výzev je pomocí tohoto fragmentu kódu zaregistrujte. Zaregistrujeme například naši FriendlinessEvaluator integrovanou integrovanou metodu popsanou v vyhodnocovacích metodách na základě výzvy:

# Import your prompt-based custom evaluator
from friendliness.friend import FriendlinessEvaluator

# Define your deployment 
model_config = dict(
    azure_endpoint=os.environ.get("AZURE_ENDPOINT"),
    azure_deployment=os.environ.get("AZURE_DEPLOYMENT_NAME"),
    api_version=os.environ.get("AZURE_API_VERSION"),
    api_key=os.environ.get("AZURE_API_KEY"), 
    type="azure_openai"
)

# Define ml_client to register custom evaluator
ml_client = MLClient(
       subscription_id=os.environ["AZURE_SUBSCRIPTION_ID"],
       resource_group_name=os.environ["AZURE_RESOURCE_GROUP"],
       workspace_name=os.environ["AZURE_PROJECT_NAME"],
       credential=DefaultAzureCredential()
)

# # Convert evaluator to evaluation flow and save it locally
local_path = "friendliness_local"
pf_client = PFClient()
pf_client.flows.save(entry=FriendlinessEvaluator, path=local_path) 

# Specify evaluator name to appear in the Evaluator library
evaluator_name = "FriendlinessEvaluator"

# Register the evaluator to the Evaluator library
custom_evaluator = Model(
    path=local_path,
    name=evaluator_name,
    description="prompt-based evaluator measuring response friendliness.",
)
registered_evaluator = ml_client.evaluators.create_or_update(custom_evaluator)
print("Registered evaluator id:", registered_evaluator.id)
# Registered evaluators have versioning. You can always reference any version available.
versioned_evaluator = ml_client.evaluators.get(evaluator_name, version=1)
print("Versioned evaluator id:", registered_evaluator.id)

Po protokolování vlastního vyhodnocovače do projektu Azure AI ho můžete zobrazit v knihovně vyhodnocovače na kartě Vyhodnocení projektu Azure AI.

Vyhodnocení cloudu pomocí sady Azure AI Projects SDK

Vyhodnocení cloudu můžete odeslat pomocí sady Azure AI Projects SDK prostřednictvím rozhraní Python API. Podívejte se na následující příklad a odešlete vyhodnocení datové sady v cloudu pomocí vyhodnocovače NLP (F1 score), vyhodnocovače kvality s asistencí umělé inteligence (Relevance), vyhodnocovače bezpečnosti (Násilí) a vlastního vyhodnocovače. Úplně to vložíte:

import os, time
from azure.ai.projects import AIProjectClient
from azure.identity import DefaultAzureCredential
from azure.ai.projects.models import Evaluation, Dataset, EvaluatorConfiguration, ConnectionType
from azure.ai.evaluation import F1ScoreEvaluator, RelevanceEvaluator, ViolenceEvaluator

# Load your Azure OpenAI config
deployment_name = os.environ.get("AZURE_OPENAI_DEPLOYMENT")
api_version = os.environ.get("AZURE_OPENAI_API_VERSION")

# Create an Azure AI Client from a connection string. Avaiable on project overview page on Azure AI project UI.
project_client = AIProjectClient.from_connection_string(
    credential=DefaultAzureCredential(),
    conn_str="<connection_string>"
)

# Construct dataset ID per the instruction
data_id = "<dataset-id>"

default_connection = project_client.connections.get_default(connection_type=ConnectionType.AZURE_OPEN_AI)

# Use the same model_config for your evaluator (or use different ones if needed)
model_config = default_connection.to_evaluator_model_config(deployment_name=deployment_name, api_version=api_version)

# Create an evaluation
evaluation = Evaluation(
    display_name="Cloud evaluation",
    description="Evaluation of dataset",
    data=Dataset(id=data_id),
    evaluators={
        # Note the evaluator configuration key must follow a naming convention
        # the string must start with a letter with only alphanumeric characters 
        # and underscores. Take "f1_score" as example: "f1score" or "f1_evaluator" 
        # will also be acceptable, but "f1-score-eval" or "1score" will result in errors.
        "f1_score": EvaluatorConfiguration(
            id=F1ScoreEvaluator.id,
        ),
        "relevance": EvaluatorConfiguration(
            id=RelevanceEvaluator.id,
            init_params={
                "model_config": model_config
            },
        ),
        "violence": EvaluatorConfiguration(
            id=ViolenceEvaluator.id,
            init_params={
                "azure_ai_project": project_client.scope
            },
        ),
        "friendliness": EvaluatorConfiguration(
            id="<custom_evaluator_id>",
            init_params={
                "model_config": model_config
            }
        )
    },
)

# Create evaluation
evaluation_response = project_client.evaluations.create(
    evaluation=evaluation,
)

# Get evaluation
get_evaluation_response = project_client.evaluations.get(evaluation_response.id)

print("----------------------------------------------------------------")
print("Created evaluation, evaluation ID: ", get_evaluation_response.id)
print("Evaluation status: ", get_evaluation_response.status)
print("AI project URI: ", get_evaluation_response.properties["AiStudioEvaluationUri"])
print("----------------------------------------------------------------")

Teď můžeme spustit vyhodnocení cloudu, které jsme právě vytvořili výše.

evaluation = client.evaluations.create(
    evaluation=evaluation,
    subscription_id=subscription_id,
    resource_group_name=resource_group_name,
    workspace_name=workspace_name,
    headers={
        "x-azureml-token": DefaultAzureCredential().get_token("https://ml.azure.com/.default").token,
    }
)

Sdílet prostřednictvím

Vyhodnocení aplikace Generative AI pomocí sady Azure AI Evaluation SDK

Začínáme

Předdefinované vyhodnocovače

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

Podpora konverzací pro text

Vyhodnocovače výkonu a kvality

Nastavení

Využití vyhodnocovače výkonu a kvality

Vyhodnocovače rizik a bezpečnosti

Podpora oblastí

Používání vyhodnocovače rizik a bezpečnosti

Vyhodnocení ohrožení zabezpečení s jailbreakem s přímým a nepřímým útokem

Složené vyhodnocovače

Vlastní vyhodnocovače

Vyhodnocovače založené na kódu

Vyhodnocovače na základě výzev

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

Požadavky

Místní vyhodnocení datových sad

Požadavky pro `evaluate()`

Formát dat

Formát parametru vyhodnocovače

Místní vyhodnocení cíle

Vyhodnocení cloudu u testovacích datových sad

Požadavky

Pokyny k instalaci

Nahrání zkušebních dat

Určení vyhodnocovačů z knihovny vyhodnocovače

Určení předdefinovaných vyhodnocovačů

Určení vlastních vyhodnocovačů

Vyhodnocení cloudu pomocí sady Azure AI Projects SDK

Váš názor

Další materiály

Sdílet prostřednictvím

Vyhodnocení aplikace Generative AI pomocí sady Azure AI Evaluation SDK

Začínáme

Předdefinované vyhodnocovače

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

Podpora konverzací pro text

Podpora konverzací pro obrázky a vícemodální text a obrázek

Vyhodnocovače výkonu a kvality

Nastavení

Využití vyhodnocovače výkonu a kvality

Vyhodnocovače rizik a bezpečnosti

Podpora oblastí

Používání vyhodnocovače rizik a bezpečnosti

Vyhodnocení ohrožení zabezpečení s jailbreakem s přímým a nepřímým útokem

Složené vyhodnocovače

Vlastní vyhodnocovače

Vyhodnocovače založené na kódu

Vyhodnocovače na základě výzev

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

Požadavky

Místní vyhodnocení datových sad

Požadavky pro evaluate()

Formát dat

Formát parametru vyhodnocovače

Místní vyhodnocení cíle

Vyhodnocení cloudu u testovacích datových sad

Požadavky

Pokyny k instalaci

Nahrání zkušebních dat

Určení vyhodnocovačů z knihovny vyhodnocovače

Určení předdefinovaných vyhodnocovačů

Určení vlastních vyhodnocovačů

Vyhodnocení cloudu pomocí sady Azure AI Projects SDK

Související obsah

Váš názor

Další materiály

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

Požadavky pro `evaluate()`