Ocena aplikacji generowania sztucznej inteligencji lokalnie przy użyciu zestawu AZURE AI Evaluation SDK (wersja zapoznawcza)

Możesz dokładnie ocenić wydajność generowania aplikacji sztucznej inteligencji, stosując ją do istotnego zestawu danych. Oceń aplikację w środowisku projektowym przy użyciu zestawu AZURE AI Evaluation SDK.

Jeśli podasz testowy zestaw danych lub cel, generowanie danych wyjściowych aplikacji sztucznej inteligencji jest mierzone ilościowo przy użyciu metryk matematycznych oraz ewaluatorów jakości i bezpieczeństwa wspomaganych przez sztuczną inteligencję. Wbudowane lub niestandardowe ewaluatory mogą zapewnić kompleksowy wgląd w możliwości i ograniczenia aplikacji.

Z tego artykułu dowiesz się, jak uruchamiać wskaźniki na pojedynczym wierszu danych i większym zestawie danych testowych na docelowym obiekcie aplikacji. Używasz wbudowanych ewaluatorów korzystających z zestawu AZURE AI Evaluation SDK lokalnie. Następnie dowiesz się, jak śledzić wyniki i dzienniki oceny w projekcie Foundry.

Wprowadzenie

Najpierw zainstaluj pakiet ewaluatorów z zestawu AZURE AI Evaluation SDK:

pip install azure-ai-evaluation

Wbudowane ewaluatory

Wbudowane metryki dotyczące jakości i bezpieczeństwa akceptują pary zapytań i odpowiedzi oraz dodatkowe informacje dla określonych ewaluatorów.

Wymagania dotyczące danych dla wbudowanych ewaluatorów

Wbudowane osoby ewaluujące mogą akceptować pary zapytań i odpowiedzi, listę konwersacji w formacie JSON Lines (JSONL) lub oba te elementy.

Pliki oceniania Azure OpenAI wymagają szablonu opisującego sposób, w jaki ich kolumny wejściowe są przekształcane w rzeczywisty input używany przez oceniany. Jeśli na przykład masz dwa dane wejściowe nazywane zapytaniem i odpowiedzią, a szablon sformatowany jako {{item.query}}, jest używane tylko zapytanie. Podobnie, możesz mieć coś takiego jak {{item.conversation}} aby akceptować dane wejściowe konwersacji, ale zdolność systemu do obsługi tego zależy od tego, jak skonfigurujesz resztę mechanizmu oceny, aby oczekiwać tych danych wejściowych.

Aby uzyskać więcej informacji na temat wymagań dotyczących danych dla ewaluatorów agentów, zobacz Ocena agentów sztucznej inteligencji.

Obsługa tekstu w jednym etapie

Wszystkie wbudowane ewaluatory przyjmują jednowymiarowe dane wejściowe w formie par zapytań i odpowiedzi w ciągach znaków. Przykład:

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)

Aby uruchomić oceny wsadowe przy użyciu lokalnej oceny lub przekazać zestaw danych w celu uruchomienia oceny w chmurze, należy reprezentować zestaw danych w formacie JSONL. Poprzednie dane jednokrotne, które są parą zapytania i odpowiedzią, są równoważne wierszowi zestawu danych, jak w poniższym przykładzie, który pokazuje trzy wiersze:

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

Zestaw danych testowych oceny może zawierać następujące elementy, w zależności od wymagań każdego wbudowanego ewaluatora:

• Zapytanie: zapytanie wysyłane do aplikacji generowania sztucznej inteligencji.
• Odpowiedź: odpowiedź na zapytanie wygenerowane przez generowaną aplikację sztucznej inteligencji.
• Kontekst: wygenerowana odpowiedź jest oparta na źródle. Oznacza to, że dokumenty podstawowe.
• Rzeczywista wartość: Odpowiedź uznawana za dokładną, wygenerowana przez użytkownika lub człowieka.

Aby zobaczyć, czego wymaga każdy ewaluator, zobacz Ewaluatory.

Obsługa konwersacji dla tekstu

W przypadku ewaluatorów obsługujących konwersacje dotyczące tekstu można podać conversation jako dane wejściowe. Te dane wejściowe zawierają słownik języka Python z listą messages, która zawiera content, rolei opcjonalnie context.

Zobacz następującą dwuturową konwersację w języku Python:

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
        }
        ]
}

Aby uruchomić oceny wsadowe przy użyciu lokalnej oceny lub prześlij zestaw danych w celu uruchomienia oceny w chmurze, musisz reprezentować zestaw danych w formacie JSONL. Poprzednia konwersacja jest równoważna wierszowi zestawu danych w pliku JSONL, podobnie jak w poniższym przykładzie:

{"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
        }
        ]
    }
}

Nasi ewaluatorzy rozumieją, że pierwsza faza rozmowy dostarcza prawidłowych query z user, context z assistant, oraz response z assistant w formacie zapytanie-odpowiedź. Konwersacje są następnie oceniane dla każdej tury, a wyniki są agregowane we wszystkich turach dla oceny rozmowy.

W przypadku trybu konwersacji oto przykład: 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))

W przypadku danych wyjściowych konwersacji wyniki poszczególnych tur są przechowywane na liście, a ogólny wynik konwersacji 'groundedness': 4.0 jest uśredniony na podstawie tur.

{
    "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
        ]
    }
}

Obsługa konwersacji dla obrazów i wielomodalnego tekstu i obrazów

W przypadku ewaluatorów obsługujących konwersacje dotyczące obrazów oraz wielomodalne obrazy i tekst, można przekazać adresy URL obrazów lub obrazy zakodowane w formacie Base64 w conversation.

Obsługiwane scenariusze obejmują:

• Wiele obrazów z tekstem wejściowym do generowania obrazu lub tekstu.
• Tylko tekstowe dane wejściowe do generowania obrazów.
• Wejście obrazowe tylko do generowania tekstu.

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)

Obecnie ewaluatory obrazów i wielomodalne obsługują:

• Tylko jedna wymiana: konwersacja może zawierać tylko jedną wiadomość użytkownika i jedną wiadomość asystenta.
• Konwersacje, które mają tylko jeden komunikat systemowy.
• Ładunki konwersacji, które są mniejsze niż 10 MB, w tym obrazy.
• Bezwzględne adresy URL i obrazy zakodowane w formacie Base64.
• Wiele obrazów w jednym ruchu.
• Formaty plików JPG/JPEG, PNG i GIF.

Ustawienia

W przypadku ewaluatorów jakości wspomaganych przez sztuczną inteligencję, z wyjątkiem GroundednessProEvaluator wersji zapoznawczej, należy określić model GPT (gpt-35-turbo, gpt-4, gpt-4-turbo, gpt-4olub gpt-4o-mini) w pliku model_config. Model GPT działa jako sędzia do oceny danych oceny. Obsługujemy zarówno schematy konfiguracji modelu Azure OpenAI, jak i OpenAI. Aby uzyskać najlepszą wydajność i analizowanie odpowiedzi z naszymi ewaluatorami, zalecamy używanie modeli GPT, które nie są dostępne w wersji zapoznawczej.

W przypadku wszystkich ewaluatorów ryzyka i bezpieczeństwa oraz GroundednessProEvaluator (wersja zapoznawcza), zamiast wdrożenia GPT w model_config, należy podać swoje azure_ai_project informacje. Uzyskuje to dostęp do usługi oceny zaplecza przy użyciu projektu Foundry.

Wskazówki dla wbudowanych ewaluatorów z wsparciem sztucznej inteligencji

Aby zapewnić przejrzystość, udostępniamy kody źródłowe naszych ewaluatorów jakości w naszej Bibliotece Ewaluatorów i w repozytorium Azure AI Evaluation Python SDK, z wyjątkiem ewaluatorów bezpieczeństwa i GroundednessProEvaluator, które jest obsługiwane przez Azure AI Content Safety. Te monity służą jako instrukcje dla modelu językowego do wykonania zadania oceny, które wymaga przyjaznej dla człowieka definicji metryki i skojarzonych z nią rubryk oceniania. Zdecydowanie zalecamy dostosowanie definicji i klasyfikacji rubryk do konkretnych scenariuszy. Aby uzyskać więcej informacji, zobacz Niestandardowe ewaluatory.

Oceny złożone

Złożone oceny są wbudowanymi algorytmami, które łączą poszczególne metryki jakości lub bezpieczeństwa. Zapewniają szeroką gamę metryk od razu po wyjęciu z pudełka, zarówno dla par zapytań i odpowiedzi, jak i wiadomości czatu.

Lokalna ocena testowych zestawów danych przy użyciu evaluate()

Po szybkiej weryfikacji wbudowanych lub niestandardowych ewaluatorów na jednym wierszu danych, można połączyć wiele ewaluatorów z interfejsem API evaluate() w całym zbiorze danych testowych.

Kroki konfiguracji wymagań wstępnych dla projektów Microsoft Foundry

Jeśli ta sesja jest pierwszym uruchomieniem ocen i ich rejestrowaniem w projekcie Foundry, konieczne może być wykonanie następujących kroków konfiguracji:

1. Utwórz i połącz swoje konto przechowywania z projektem Foundry na poziomie zasobów. Ten szablon Bicep zapewnia i łączy konto magazynu z projektem Foundry za pomocą uwierzytelniania za pomocą klucza.
2. Upewnij się, że połączone konto przechowywania ma dostęp do wszystkich projektów.
3. Jeśli połączono konto magazynu z identyfikatorem Entra firmy Microsoft, upewnij się, że nadaj właścicielowi danych obiektu blob usługi Storage uprawnienia zarówno do twojego konta, jak i zasobu projektu Foundry w witrynie Azure Portal.

Ocena zestawu danych i zapisywanie wyników do Foundry

Aby upewnić się, że evaluate() interfejs API może poprawnie przeanalizować dane, należy określić mapowanie kolumn, aby zamapować kolumnę z zestawu danych na kluczowe słowa, które akceptują ewaluatorzy. W tym przykładzie określono mapowanie danych dla , queryresponsei 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"
)

Ewaluator zwraca wyniki w postaci słownika, który zawiera dane agregowane metrics oraz dane i metryki na poziomie wiersza. Zobacz następujące przykładowe dane wyjściowe:

{'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': {}}

Wymagania dotyczące evaluate()

Interfejs evaluate() API wymaga określonego formatu danych i nazw kluczy parametrów ewaluatora w celu poprawnego wyświetlenia wykresów wyników oceny w projekcie Foundry.

Format danych

Interfejs evaluate() API akceptuje tylko dane w formacie JSONL. W przypadku wszystkich wbudowanych evaluate() ewaluatorów wymagane są dane w następującym formacie z wymaganymi polami wejściowymi. Zobacz poprzednią sekcję dotyczącą wymaganych danych wejściowych dla wbudowanych ewaluatorów. Poniższy fragment kodu jest przykładem tego, jak może wyglądać jeden wiersz:

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

Format parametru ewaluatora

Gdy przekazujesz wbudowane ewaluatory, określ odpowiednie mapowanie słów kluczowych w evaluators liście parametrów. W poniższej tabeli przedstawiono mapowanie słów kluczowych wymaganych dla wyników wbudowanych ewaluatorów w celu wyświetlenia w interfejsie użytkownika po zalogowaniu się do projektu Foundry.

Oto przykład ustawiania evaluators parametrów:

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

Lokalna ocena celu

Jeśli masz listę zapytań, które chcesz uruchomić, a następnie ocenić, interfejs API evaluate() obsługuje również parametr target. Ten parametr wysyła zapytania do aplikacji w celu zbierania odpowiedzi, a następnie uruchamia ewaluatorów na wynikowych zapytaniach i odpowiedziach.

Element docelowy może być dowolną klasą wywoływaną w katalogu. W tym przykładzie istnieje skrypt askwiki.py języka Python z wywoływaną klasą askwiki() ustawioną jako element docelowy. Jeśli masz zestaw danych zapytań, które można wysłać do prostej askwiki aplikacji, możesz ocenić uzasadnienie danych wyjściowych. Upewnij się, że określono odpowiednie mapowanie kolumn dla danych w pliku "column_mapping". "default" Służy do określania mapowania kolumn dla wszystkich ewaluatorów.

Oto zawartość w pliku "data.jsonl":

{"query":"When was United States found ?", "response":"1776"}
{"query":"What is the capital 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}"
            } 
        }
    }
)

Powiązana zawartość

• Biblioteka klienta oceny sztucznej inteligencji platformy Azure dla języka Python
• Rozwiązywanie problemów z zestawem AI Evaluation SDK
• Obserwowalność w generatywnej sztucznej inteligencji
• Uruchamianie ocen w chmurze przy użyciu zestawu Microsoft Foundry SDK
• Generowanie syntetycznych i symulowanych danych do oceny
• Zobacz wyniki oceny w portalu Foundry
• Wprowadzenie do usługi Foundry
• Rozpocznij pracę z przykładami oceny