Så här kör du utvärderingar online med Azure AI Foundry SDK

Artikel
01/23/2025

Viktigt!

Objekt markerade (förhandsversion) i den här artikeln är för närvarande i offentlig förhandsversion. Den här förhandsversionen tillhandahålls utan ett serviceavtal och vi rekommenderar det inte för produktionsarbetsbelastningar. Vissa funktioner kanske inte stöds eller kan vara begränsade. Mer information finns i Kompletterande villkor för användning av Microsoft Azure-förhandsversioner.

I den här artikeln får du lära dig hur du kör utvärderingar online på ett kontinuerligt sätt med Azure AI Foundry SDK. Utvärderingar i förproduktionsmiljöer är viktiga för att säkerställa att programmet är säkert, högpresterande och ger högkvalitativa resultat. Utvärderingen stoppas dock inte när programmet har distribuerats. I produktion kan olika saker ändras, till exempel vilka typer av frågor användarna skickar till ditt program, vilket kan påverka programmets prestanda. För att upprätthålla en hög grad av observerbarhet i ditt produktionsgenererande AI-program är det viktigt att spåra och kontinuerligt utvärdera programmets data. Genom att göra det kan du upprätthålla förtroende för programmets säkerhet, kvalitet och prestanda.

Så här fungerar onlineutvärdering

I det här avsnittet får du lära dig hur onlineutvärdering fungerar, hur den integreras med Azure Monitor Application Insights och hur du kan använda den för att köra kontinuerliga utvärderingar över spårningsdata från dina generativa AI-program.

När programmet har instrumenterats för att skicka spårningsdata till Application Insights konfigurerar du ett onlineutvärderingsschema för att kontinuerligt utvärdera dessa data. Onlineutvärdering är en tjänst som använder Azure AI-beräkning för att kontinuerligt köra en konfigurerbar uppsättning utvärderare. När du har konfigurerat ett onlineutvärderingsschema med Azure AI Foundry SDK körs det enligt ett konfigurerbart schema. Varje gång det schemalagda jobbet körs utför det följande steg:

Fråga programspårningsdata från den anslutna Application Insights-resursen med hjälp av den angivna Kusto-frågan (KQL).
Kör varje utvärderare över spårningsdata och beräkna varje mått (till exempel grundvärde: 3).
Skriv utvärderingspoängen tillbaka till varje spårning med hjälp av standardiserade semantiska konventioner.

Kommentar

Onlineutvärdering stöder samma mått som Azure AI Evaluation. Mer information om hur utvärdering fungerar och vilka utvärderingsmått som stöds finns i Utvärdera ditt Generative AI-program med Azure AI Evaluation SDK.

Anta till exempel att du har ett distribuerat chattprogram som tar emot många kundfrågor dagligen. Du vill kontinuerligt utvärdera kvaliteten på svaren från ditt program. Du konfigurerar ett onlineutvärderingsschema med en daglig upprepning. Du konfigurerar utvärderarna: Groundedness, Coherence och Fluency. Varje dag beräknar tjänsten utvärderingspoängen för dessa mått och skriver tillbaka data till Application Insights för varje spårning som samlades in under tidsperioden för upprepning (i det här exemplet de senaste 24 timmarna). Sedan kan data frågas från varje spårning och göras tillgängliga i Azure AI Foundry och Azure Monitor Application Insights.

Utvärderingsresultaten som skrivs tillbaka till varje spårning i Application Insights följer följande konventioner. Ett unikt spann läggs till i varje spårning för varje utvärderingsmått:

Property	Application Insights-tabell	Fält för en viss operation_ID	Exempelvärde
Utvärderingsmått	traces, AppTraces	`customDimensions[“event.name”]`	`gen_ai.evaluation.relevance`
Utvärderingsmåttpoäng	traces, AppTraces	`customDimensions[“gen_ai.evaluation.score”]`	`3`
Kommentar om utvärderingsmått (om tillämpligt)	traces, AppTraces	`message`	`{“comment”: “I like the response”}`

Nu när du förstår hur onlineutvärdering fungerar och hur den ansluter till Azure Monitor Application Insights är nästa steg att konfigurera tjänsten.

Konfigurera onlineutvärdering

I det här avsnittet får du lära dig hur du konfigurerar ett onlineutvärderingsschema för att kontinuerligt övervaka ditt distribuerade generativa AI-program. Azure AI Foundry SDK erbjuder sådana funktioner via. Ett Python-API och stöder alla funktioner som är tillgängliga i lokala utvärderingar. Använd följande steg för att skicka in ditt onlineutvärderingsschema för dina data med hjälp av inbyggda eller anpassade utvärderare.

Kommentar

Utvärderingar stöds endast i samma regioner som AI-stödda risk- och säkerhetsmått.

Förutsättningar

Utför följande nödvändiga steg för att konfigurera din miljö och autentisering till nödvändiga resurser:

En Azure-prenumeration.
En resursgrupp i en region som stöds av utvärdering.
En ny användartilldelad hanterad identitet i samma resursgrupp och region. Anteckna clientId. Du behöver det senare.
En Azure AI Hub i samma resursgrupp och region.
Ett Azure AI-projekt i den här hubben finns i Skapa ett projekt i Azure AI Foundry-portalen.
En Azure Monitor Application Insights-resurs.
Gå till hubbsidan i Azure Portal och lägg till Application Insights-resursen. Mer information finns i Uppdatera Azure Application Insights och Azure Container Registry.
Azure OpenAI-distribution med GPT-modell som stöder chat completion, till exempel gpt-4.
Connection String för Azure AI-projekt för att enkelt skapa AIProjectClient objekt. Du kan hämta Project anslutningssträng under Projektinformation från projektets översiktssida.
Gå till application insights-resursen i Azure Portal och använd fliken Åtkomstkontroll (IAM) för att lägga Log Analytics Contributor till rollen i den användartilldelade hanterade identiteten som du skapade tidigare.
Koppla den användartilldelade hanterade identiteten till projektet.
Gå till Azure AI Services i Azure Portal och använd fliken Åtkomstkontroll (IAM) för att lägga Cognitive Services OpenAI Contributor till rollen i den användartilldelade hanterade identiteten som du skapade tidigare.

Installationsinstruktioner

Du installerar Azure CLI och loggar in från din lokala utvecklingsmiljö, så att du kan använda dina autentiseringsuppgifter för att anropa Azure OpenAI-tjänsten.

I de flesta fall kan du installera Azure CLI från terminalen med hjälp av följande kommando:

winget install -e --id Microsoft.AzureCLI

curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash

brew update && brew install azure-cli

Du kan följa anvisningarna Så här installerar du Azure CLI om dessa kommandon inte fungerar för ditt operativsystem eller din installation.

När du har installerat Azure CLI loggar du in med az login kommandot och loggar in med webbläsaren:

az login

Du kan också logga in manuellt via webbläsaren med en enhetskod.

az login --use-device-code

Skapa en ny Python-miljö

Först måste du skapa en ny Python-miljö som ska användas för att installera det paket du behöver för den här självstudien. Installera INTE paket i din globala Python-installation. Du bör alltid använda en virtuell miljö eller conda-miljö när du installerar Python-paket, annars kan du avbryta din globala installation av Python.

Installera Python om det behövs

Vi rekommenderar att du använder Python 3.10 eller senare, men minst Python 3.8 krävs. Om du inte har en lämplig version av Python installerad kan du följa anvisningarna i VS Code Python-självstudien för det enklaste sättet att installera Python på operativsystemet.

Skapa en virtuell miljö

Om du redan har Python 3.10 eller senare installerat kan du skapa en virtuell miljö med hjälp av följande kommandon:

py -3 -m venv .venv
.venv\scripts\activate

python3 -m venv .venv
source .venv/bin/activate

python3 -m venv .venv
source .venv/bin/activate

När du aktiverar Python-miljön innebär det att när du kör python eller pip från kommandoraden använder du sedan Python-tolken .venv som finns i mappen för ditt program.

Kommentar

Du kan använda deactivate kommandot för att avsluta den virtuella python-miljön och senare återaktivera den när det behövs.

Du kan också skapa en ny Python-miljö med hjälp av conda:

conda create -n online-evaluation
conda activate online-evaluation

Installera de paket som krävs:

pip install azure-identity azure-ai-projects azure-ai-ml

Dricks

Du kan också använda om du vill ha pip install azure-ai-evaluation en kod-första upplevelse för att hämta utvärderar-ID för inbyggda utvärderare i kod. Mer information om hur du gör detta finns i Ange utvärderare från utvärderingsbiblioteket.

Konfigurera spårning för ditt generativa AI-program

Innan du konfigurerar onlineutvärdering ska du se till att du först har konfigurerat spårning för ditt generativa AI-program.

Använda tjänstnamn i spårningsdata

Om du vill identifiera ditt program via ett unikt ID i Application Insights kan du använda egenskapen OpenTelemetry i dina spårningsdata. Detta är särskilt användbart om du loggar data från flera program till samma Application Insights-resurs och du vill skilja mellan dem. Anta till exempel att du har två program: App-1 och App-2, med spårning konfigurerad för att logga data till samma Application Insights-resurs. Kanske vill du konfigurera App-1 som ska utvärderas kontinuerligt av Relevans och App-2 som ska utvärderas kontinuerligt av Groundedness. Du kan använda tjänstnamnet för att skilja mellan programmen i dina onlineutvärderingskonfigurationer.

Om du vill konfigurera egenskapen för tjänstnamn kan du göra det direkt i programkoden genom att följa stegen i Använda flera spårningsproviders med olika resurser. Du kan också ange miljövariabeln OTEL_SERVICE_NAME innan du distribuerar din app. Mer information om hur du arbetar med tjänstnamnet finns i OTEL-miljövariabler och semantiska konventioner för tjänstresurser.

Mer information om hur du använder tjänstnamnet för att skilja mellan dina generativa AI-program finns i spårning.

Fråga lagrade spårningsdata i Application Insights

Med hjälp av Kusto-frågespråk (KQL) kan du köra frågor mot ditt generativa AI-programs spårningsdata från Application Insights för kontinuerlig onlineutvärdering. Om du använder Azure AI Tracing-paketet för att spåra ditt generativa AI-program kan du använda följande Kusto-fråga:

Viktigt!

KQL-frågan som används av onlineutvärderingstjänsten måste mata ut följande kolumner: operation_Id, operation_ParentIdoch gen_ai_response_id. Dessutom har varje utvärderare sina egna krav på indata. KQL-frågan måste mata ut dessa kolumner för att kunna användas som indata till själva utvärderarna. En lista över datakrav för utvärderare finns i datakrav för inbyggda utvärderare.

let gen_ai_spans = (
    dependencies
    | where isnotnull(customDimensions["gen_ai.system"])
    | extend response_id = tostring(customDimensions["gen_ai.response.id"])
    | project id, operation_Id, operation_ParentId, timestamp, response_id
);
let gen_ai_events = (
    traces
    | where message in ("gen_ai.choice", "gen_ai.user.message", "gen_ai.system.message")
        or tostring(customDimensions["event.name"]) in ("gen_ai.choice", "gen_ai.user.message", "gen_ai.system.message")
    | project 
        id = operation_ParentId, 
        operation_Id, 
        operation_ParentId, 
        user_input = iff(
            message == "gen_ai.user.message" or tostring(customDimensions["event.name"]) == "gen_ai.user.message", 
            parse_json(iff(message == "gen_ai.user.message", tostring(customDimensions["gen_ai.event.content"]), message)).content, 
            ""
        ), 
        system = iff(
            message == "gen_ai.system.message" or tostring(customDimensions["event.name"]) == "gen_ai.system.message", 
            parse_json(iff(message == "gen_ai.system.message", tostring(customDimensions["gen_ai.event.content"]), message)).content, 
            ""
        ), 
        llm_response = iff(
            message == "gen_ai.choice", 
            parse_json(tostring(parse_json(tostring(customDimensions["gen_ai.event.content"])).message)).content, 
            iff(tostring(customDimensions["event.name"]) == "gen_ai.choice", parse_json(parse_json(message).message).content, "")
        )
    | summarize 
        operation_ParentId = any(operation_ParentId), 
        Input = maxif(user_input, user_input != ""), 
        System = maxif(system, system != ""), 
        Output = maxif(llm_response, llm_response != "") 
    by operation_Id, id
);
gen_ai_spans
| join kind=inner (gen_ai_events) on id, operation_Id
| project Input, System, Output, operation_Id, operation_ParentId, gen_ai_response_id = response_id

Om du använder OTEL_SERVICE_NAME miljövariabeln i ditt generativa AI-program för cloud_RoleName att ange tjänstnamnet kan du fråga efter i ditt onlineutvärderingsschema genom att lägga till följande rad i din Kusto-fråga (KQL):

| where cloud_RoleName == "service_name"

Du kan också använda exempeloperatorn eller ta operatorn i Kusto-frågan så att den bara returnerar en delmängd av spårningar. Eftersom AI-assisterade utvärderingar kan vara kostsamma i stor skala kan den här metoden hjälpa dig att kontrollera kostnaderna genom att bara utvärdera ett slumpmässigt urval (eller n spårningar) av dina data.

Konfigurera onlineutvärdering med Azure AI Project SDK

Du kan skicka ett schemalagt onlineutvärderingsjobb med Azure AI Project SDK via ett Python-API. Se skriptet nedan för att lära dig hur du konfigurerar onlineutvärdering med utvärderare av prestanda och kvalitet (AI-assisterad). En omfattande lista över utvärderare som stöds finns i Utvärdera med Azure AI Evaluation SDK. Mer information om hur du använder anpassade utvärderare finns i anpassade utvärderare.

Börja med att importera de nödvändiga paketen och konfigurera de variabler som krävs:

from azure.ai.projects import AIProjectClient 
from azure.identity import DefaultAzureCredential 
from azure.ai.projects.models import ( 
    ApplicationInsightsConfiguration,
    EvaluatorConfiguration,
    EvaluationSchedule,
    RecurrenceTrigger,
)
from azure.ai.evaluation import CoherenceEvaluator 

# This sample includes the setup for an online evaluation schedule using the Azure AI Project SDK and Azure AI Evaluation SDK
# The schedule is configured to run daily over the collected trace data while running two evaluators: CoherenceEvaluator and RelevanceEvaluator
# This sample can be modified to fit your application's requirements

# Name of your online evaluation schedule
SAMPLE_NAME = "online_eval_name"

# Connection string to your Azure AI Foundry project
# Currently, it should be in the format "<HostName>;<AzureSubscriptionId>;<ResourceGroup>;<HubName>"
PROJECT_CONNECTION_STRING = "<HostName>;<AzureSubscriptionId>;<ResourceGroup>;<HubName>"

# Your Application Insights resource ID
APPLICATION_INSIGHTS_RESOURCE_ID = "appinsights_resource_id"

# Kusto Query Language (KQL) query to query data from Application Insights resource
# This query is compatible with data logged by the Azure AI Inferencing Tracing SDK (linked in documentation)
# You can modify it depending on your data schema
# The KQL query must output these required columns: operation_ID, operation_ParentID, and gen_ai_response_id
# You can choose which other columns to output as required by the evaluators you are using
KUSTO_QUERY = "let gen_ai_spans=(dependencies | where isnotnull(customDimensions[\"gen_ai.system\"]) | extend response_id = tostring(customDimensions[\"gen_ai.response.id\"]) | project id, operation_Id, operation_ParentId, timestamp, response_id); let gen_ai_events=(traces | where message in (\"gen_ai.choice\", \"gen_ai.user.message\", \"gen_ai.system.message\") or tostring(customDimensions[\"event.name\"]) in (\"gen_ai.choice\", \"gen_ai.user.message\", \"gen_ai.system.message\") | project id= operation_ParentId, operation_Id, operation_ParentId, user_input = iff(message == \"gen_ai.user.message\" or tostring(customDimensions[\"event.name\"]) == \"gen_ai.user.message\", parse_json(iff(message == \"gen_ai.user.message\", tostring(customDimensions[\"gen_ai.event.content\"]), message)).content, \"\"), system = iff(message == \"gen_ai.system.message\" or tostring(customDimensions[\"event.name\"]) == \"gen_ai.system.message\", parse_json(iff(message == \"gen_ai.system.message\", tostring(customDimensions[\"gen_ai.event.content\"]), message)).content, \"\"), llm_response = iff(message == \"gen_ai.choice\", parse_json(tostring(parse_json(tostring(customDimensions[\"gen_ai.event.content\"])).message)).content, iff(tostring(customDimensions[\"event.name\"]) == \"gen_ai.choice\", parse_json(parse_json(message).message).content, \"\")) | summarize operation_ParentId = any(operation_ParentId), Input = maxif(user_input, user_input != \"\"), System = maxif(system, system != \"\"), Output = maxif(llm_response, llm_response != \"\") by operation_Id, id); gen_ai_spans | join kind=inner (gen_ai_events) on id, operation_Id | project Input, System, Output, operation_Id, operation_ParentId, gen_ai_response_id = response_id"

Definiera sedan en klient och en Azure OpenAI GPT-distribution (till exempel ) som GPT-4ska användas för att köra ditt onlineutvärderingsschema. Anslut också till din Application Insights-resurs:

# Connect to your Azure AI Foundry Project
project_client = AIProjectClient.from_connection_string(
    credential=DefaultAzureCredential(),
    conn_str=PROJECT_CONNECTION_STRING
)

# Connect to your Application Insights resource 
app_insights_config = ApplicationInsightsConfiguration(
    resource_id=APPLICATION_INSIGHTS_RESOURCE_ID,
    query=KUSTO_QUERY
)

# Connect to your Azure OpenAI Service resource. You must use a GPT model deployment for this example.
deployment_name = "gpt-4"
api_version = "2024-08-01-preview"

# This is your Azure OpenAI Service connection name, which can be found in your Azure AI Foundry project under the 'Models + Endpoints' tab.
default_connection = project_client.connections._get_connection(
    "aoai_connection_name"
)

model_config = {
    "azure_deployment": deployment_name,
    "api_version": api_version,
    "type": "azure_openai",
    "azure_endpoint": default_connection.properties["target"]
}

Konfigurera sedan de utvärderare som du vill använda:

# RelevanceEvaluator
# id for each evaluator can be found in your Azure AI Foundry registry - please see documentation for more information
# init_params is the configuration for the model to use to perform the evaluation
# data_mapping is used to map the output columns of your query to the names required by the evaluator
relevance_evaluator_config = EvaluatorConfiguration(
    id="azureml://registries/azureml-staging/models/Relevance-Evaluator/versions/4",
    init_params={"model_config": model_config},
    data_mapping={"query": "${data.Input}", "response": "${data.Output}"}
)

# CoherenceEvaluator
coherence_evaluator_config = EvaluatorConfiguration(
    id=CoherenceEvaluator.id,
    init_params={"model_config": model_config},
    data_mapping={"query": "${data.Input}", "response": "${data.Output}"}
)

Slutligen definierar du upprepningen och skapar schemat:

Obs! I de nödvändiga stegen skapade du en användartilldelad hanterad identitet för att autentisera onlineutvärderingsschemat till din Application Insights-resurs. I AzureMSIClientId parametern properties för EvaluationSchedule klassen är den här identiteten clientId .

# Frequency to run the schedule
recurrence_trigger = RecurrenceTrigger(frequency="day", interval=1)

# Dictionary of evaluators
evaluators = {
    "relevance": relevance_evaluator_config,
    "coherence" : coherence_evaluator_config
}

name = SAMPLE_NAME
description = f"{SAMPLE_NAME} description"
# AzureMSIClientId is the clientID of the User-assigned managed identity created during set-up - see documentation for how to find it
properties = {"AzureMSIClientId": "your_client_id"}

# Configure the online evaluation schedule
evaluation_schedule = EvaluationSchedule(
    data=app_insights_config,
    evaluators=evaluators,
    trigger=recurrence_trigger,
    description=description,
    properties=properties)

# Create the online evaluation schedule 
created_evaluation_schedule = project_client.evaluations.create_or_replace_schedule(name, evaluation_schedule)
print(f"Successfully submitted the online evaluation schedule creation request - {created_evaluation_schedule.name}, currently in {created_evaluation_schedule.provisioning_state} state.")

Utföra åtgärder enligt ett onlineutvärderingsschema

Du kan hämta, lista och inaktivera onlineutvärderingsscheman genom att lägga till följande kod i konfigurationsskriptet för onlineutvärdering:

Varning! Vänta en liten stund (~30 sekunder) mellan att skapa ett onlineutvärderingsschema och köra API:et get_schedule() .

Hämta ett onlineutvärderingsschema:

name = "<my-online-evaluation-name>"
get_evaluation_schedule = project_client.evaluations.get_schedule(name)

Visa en lista över alla utvärderingsscheman online:

count = 0
for evaluation_schedule in project_client.evaluations.list_schedule():
    count += 1
        print(f"{count}. {evaluation_schedule.name} "
        f"[IsEnabled: {evaluation_schedule.is_enabled}]")
        print(f"Total evaluation schedules: {count}")

Inaktivera (mjuk borttagning) onlineutvärderingsschema:

name = "<my-online-evaluation-name>"
project_client.evaluations.disable_schedule(name)

Dela via

Så här kör du utvärderingar online med Azure AI Foundry SDK

Så här fungerar onlineutvärdering

Konfigurera onlineutvärdering

Förutsättningar

Installationsinstruktioner

Skapa en ny Python-miljö

Installera Python om det behövs

Skapa en virtuell miljö

Installera de paket som krävs:

Konfigurera spårning för ditt generativa AI-program

Använda tjänstnamn i spårningsdata

Fråga lagrade spårningsdata i Application Insights

Konfigurera onlineutvärdering med Azure AI Project SDK

Utföra åtgärder enligt ett onlineutvärderingsschema

Feedback

Ytterligare resurser

Dela via

Så här kör du utvärderingar online med Azure AI Foundry SDK

Så här fungerar onlineutvärdering

Konfigurera onlineutvärdering

Förutsättningar

Installationsinstruktioner

Installera Azure CLI och logga in

Skapa en ny Python-miljö

Installera Python om det behövs

Skapa en virtuell miljö

Installera de paket som krävs:

Konfigurera spårning för ditt generativa AI-program

Använda tjänstnamn i spårningsdata

Fråga lagrade spårningsdata i Application Insights

Konfigurera onlineutvärdering med Azure AI Project SDK

Utföra åtgärder enligt ett onlineutvärderingsschema

Relaterat innehåll

Feedback

Ytterligare resurser