Udostępnij przez

Uruchamianie ocen w chmurze przy użyciu zestawu Microsoft Foundry SDK

Ważna

Elementy oznaczone jako (wersja zapoznawcza) w tym artykule są aktualnie dostępne w publicznej wersji zapoznawczej. Ta wersja zapoznawcza jest udostępniana bez umowy dotyczącej poziomu usług i nie zalecamy korzystania z niej w przypadku obciążeń produkcyjnych. Niektóre funkcje mogą nie być obsługiwane lub mogą mieć ograniczone możliwości. Aby uzyskać więcej informacji, zobacz Warunki dodatkowe korzystania z testowych wersji Microsoft Azure.

Z tego artykułu dowiesz się, jak uruchamiać oceny w chmurze (wersja zapoznawcza) na potrzeby testowania wstępnego wdrożenia na testowym zestawie danych.

Korzystaj z ocen chmury w przypadku większości scenariuszy — szczególnie w przypadku testowania na dużą skalę, integrowania ocen z potokami ciągłej integracji i ciągłego dostarczania (CI/CD) lub przeprowadzania testów wstępnych. Uruchamianie ocen w chmurze eliminuje konieczność zarządzania lokalną infrastrukturą obliczeniową i obsługuje przepływy pracy testowania automatycznego na dużą skalę. Możesz również zaplanować uruchamianie ocen cyklicznie lub skonfigurować ciągłą ocenę w celu automatycznego oceniania przykładowych odpowiedzi agenta w środowisku produkcyjnym.

Wyniki oceny chmury są przechowywane w projekcie Foundry. Możesz przejrzeć wyniki w portalu, pobrać je za pośrednictwem zestawu SDK lub kierować je do usługi Application Insights, jeśli nawiązano połączenie. Ocena chmury obsługuje wszystkich wbudowanych ewaluatorów firmy Microsoft i własnych niestandardowych ewaluatorów. Ewaluatorzy są zarządzani w katalogu ewaluatorów przy użyciu tej samej kontroli dostępu opartej na rolach w zakresie projektu.

Wskazówka

Aby uzyskać pełne przykłady możliwych do uruchomienia, zobacz przykłady oceny zestawu SDK języka Python w witrynie GitHub.

Gdy używasz Foundry SDK, rejestruje wyniki oceny w projekcie Foundry dla lepszej obserwowalności. Ta funkcja obsługuje wszystkie wbudowane ewaluatory firmy Microsoft. i własnych spersonalizowanych ewaluatorów. Twoi ewaluatorzy mogą znajdować się w bibliotece ewaluatorów i mają takie same, projektowe zasady dostępu oparte na rolach.

Jak działa ocena chmury

Aby uruchomić ocenę w chmurze, należy utworzyć definicję oceny przy użyciu schematu danych i kryteriów testowania (ewaluatorów), a następnie utworzyć przebieg oceny. Przebieg wykonuje każdego z ewaluatorów względem twoich danych i zwraca ocenione wyniki, które możesz sprawdzać, czy ukończone.

Ocena chmury obsługuje następujące scenariusze:

Scenariusz Kiedy należy używać Typ źródła danych Target
Ocena zestawu danych Oceń wstępnie obliczone odpowiedzi w pliku JSONL. jsonl —
Ocena docelowa modelu Podaj zapytania i generuj odpowiedzi na podstawie modelu podczas działania, na potrzeby oceny. azure_ai_target_completions azure_ai_model
Ocena celów agenta Zadaj pytania i generuj odpowiedzi od agenta Foundry podczas działania na potrzeby oceny. azure_ai_target_completions azure_ai_agent
Ocena odpowiedzi agenta Pobierz i oceń odpowiedzi agenta usługi Foundry według identyfikatorów odpowiedzi. azure_ai_responses —
Ocena zespołu czerwonego Uruchom zautomatyzowane testowanie adwersarialne dla modelu lub agenta. azure_ai_red_team azure_ai_model lub azure_ai_agent

Większość scenariuszy wymaga danych wejściowych. Dane można udostępniać na dwa sposoby:

Typ źródła Opis
file_id Powołaj się na przekazany zestaw danych, używając jego identyfikatora.
file_content Podaj dane bezpośrednio w treści żądania.

Każda ocena wymaga data_source_config, który wskazuje usłudze, jakich pól oczekiwać w danych.

  • custom — Definiujesz element item_schema z nazwami pól i typami. Ustaw include_sample_schema na true podczas korzystania z elementu docelowego, aby ewaluatorzy mogli odwoływać się do wygenerowanych odpowiedzi.
  • azure_ai_source — schemat jest wnioskowany z usługi. Ustaw "scenario" na "responses" w przypadku oceny odpowiedzi agenta lub "red_team"red teamingu.

Każdy scenariusz wymaga ewaluatorów, które definiują kryteria testowania. Aby uzyskać wskazówki dotyczące wybierania ewaluatorów, zobacz wbudowane ewaluatory.

Wymagania wstępne

  • Projekt Foundry.
  • Wdrożenie usługi Azure OpenAI z modelem GPT obsługującym uzupełnianie czatu (na przykład gpt-5-mini).
  • Rola użytkownika sztucznej inteligencji platformy Azure w projekcie Foundry.
  • Opcjonalnie możesz użyć własnego konta magazynu do przeprowadzania ocen.

Uwaga / Notatka

Niektóre funkcje oceny mają ograniczenia regionalne. Aby uzyskać szczegółowe informacje, zobacz obsługiwane regiony .

Wprowadzenie

Zainstaluj zestaw SDK i skonfiguruj klienta:

pip install "azure-ai-projects>=2.0.0b1" azure-identity openai

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

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

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

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

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

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

Przygotowywanie danych wejściowych

Większość scenariuszy oceny wymaga danych wejściowych. Dane można udostępniać na dwa sposoby:

Przekaż plik JSONL, aby utworzyć wersjonowany zestaw danych w projekcie Foundry. Zestawy danych obsługują wersjonowanie i ponowne użycie w wielu iteracjach oceny. Użyj tego podejścia do testowania w środowisku produkcyjnym i procesów CI/CD.

Przygotuj plik JSONL z jednym obiektem JSON na wiersz zawierający pola, których potrzebują ewaluatorzy:

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

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

Podawanie danych w linii

Aby szybko eksperymentować z małymi zestawami testów, podaj dane bezpośrednio w żądaniu oceny przy użyciu polecenia file_content.

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

Przekaż source jako pole "source" w konfiguracji źródła danych przy tworzeniu przebiegu. Domyślnie używane są sekcje scenariusza oznaczone jako file_id.

Ocena zestawu danych

Oceń wstępnie obliczone odpowiedzi w pliku JSONL przy użyciu jsonl typu źródła danych. Ten scenariusz jest przydatny, gdy masz już dane wyjściowe modelu i chcesz ocenić ich jakość.

Wskazówka

Przed rozpoczęciem ukończ kroki rozpoczynania pracy i przygotowywania danych wejściowych.

Definiowanie schematu danych i ewaluatorów

Określ schemat zgodny z polami JSONL i wybierz ewaluatorów (kryteria testowania), które mają zostać uruchomione. Użyj parametru data_mapping , aby połączyć pola z danych wejściowych z parametrami ewaluatora ze składnią {{item.field}} . Zawsze dołączaj data_mapping do wymaganych pól wejściowych dla każdego ewaluatora. Nazwy pól muszą być zgodne z tymi w pliku JSONL — na przykład jeśli Twoje dane mają "question" zamiast "query", użyj "{{item.question}}" w mapowaniu. Aby zapoznać się z wymaganymi parametrami dla każdego ewaluatora, zobacz sekcję wbudowane ewaluatory.

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

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

Utwórz ocenę i uruchom

Utwórz ocenę, a następnie rozpocznij proces względem przekazanego zestawu danych. Przebieg wykonuje każdego ewaluatora w każdym wierszu w zestawie danych.

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

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

Aby uzyskać pełny przykład z możliwością uruchamiania, zobacz sample_evaluations_builtin_with_dataset_id.py w witrynie GitHub. Aby sondować pod kątem ukończenia i interpretowania wyników, zobacz Pobieranie wyników.

Ocena docelowa modelu

Wysyłaj zapytania do wdrożonego modelu w czasie wykonywania i oceniaj odpowiedzi przy użyciu azure_ai_target_completions typu źródła danych z obiektem azure_ai_model docelowym. Dane wejściowe zawierają zapytania; model generuje odpowiedzi, które następnie są oceniane.

Wskazówka

Przed rozpoczęciem ukończ kroki rozpoczynania pracy i przygotowywania danych wejściowych.

Definiowanie szablonu wiadomości i elementu docelowego

Szablon input_messages określa sposób wysyłania zapytań do modelu. Użyj {{item.query}}, aby odwołać się do pól z danych wejściowych. Określ model do oceny i opcjonalnych parametrów próbkowania:

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

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

Konfigurowanie ewaluatorów i mapowań danych

Gdy model generuje odpowiedzi w czasie wykonywania, użyj {{sample.output_text}} w data_mapping do odwoływania się do danych wyjściowych modelu. Użyj {{item.field}}, aby odwołać się do pól z danych wejściowych.

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

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

Utwórz ocenę i uruchom

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

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

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

Aby uzyskać pełny przykład z możliwością uruchamiania, zobacz sample_model_evaluation.py w witrynie GitHub. Aby sondować pod kątem ukończenia i interpretowania wyników, zobacz Pobieranie wyników.

Wskazówka

Aby dodać kolejny przebieg oceny, możesz użyć tego samego kodu.

Ocena celu agenta

Wysyłaj zapytania do agenta Foundry w czasie wykonywania i oceniaj odpowiedzi, korzystając z typu źródła danych azure_ai_target_completions oraz docelowego obiektu azure_ai_agent.

Wskazówka

Przed rozpoczęciem ukończ kroki rozpoczynania pracy i przygotowywania danych wejściowych.

Definiowanie szablonu wiadomości i elementu docelowego

Szablon input_messages określa sposób wysyłania zapytań do agenta. Użyj {{item.query}}, aby odwołać się do pól z danych wejściowych. Określ agenta do oceny według nazwy:

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

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

Konfigurowanie ewaluatorów i mapowań danych

Gdy agent generuje odpowiedzi w czasie pracy, użyj {{sample.*}} zmiennych w data_mapping, aby odwołać się do wyników agenta.

Variable Opis Użyj dla
{{sample.output_text}} Odpowiedź agenta w postaci zwykłego tekstu. Moduły oceniające, które oczekują odpowiedzi w postaci ciągu znaków (na przykład coherence, violence).
{{sample.output_items}} Ustrukturyzowane dane wyjściowe JSON agenta, w tym wywołania narzędzi. Ewaluatorzy, którzy potrzebują pełnego kontekstu interakcji (na przykład task_adherence).
{{item.field}} Pole z danych wejściowych. Pola wejściowe, takie jak query lub ground_truth.

Wskazówka

Pole query może zawierać ustrukturyzowany kod JSON, w tym komunikaty systemowe i historię konwersacji. Niektórzy ewaluatorzy agentów, na przykład task_adherence używają tego kontekstu do dokładniejszego oceniania. Aby uzyskać szczegółowe informacje na temat formatowania zapytań, zobacz ewaluatory agentów.

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

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

Utwórz ocenę i uruchom

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

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

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

Aby uzyskać pełny przykład z możliwością uruchamiania, zobacz sample_agent_evaluation.py w witrynie GitHub. Aby sondować pod kątem ukończenia i interpretowania wyników, zobacz Pobieranie wyników.

Ocena odpowiedzi agenta

Pobieranie i ocenianie odpowiedzi agenta usługi Foundry według identyfikatorów odpowiedzi z wykorzystaniem azure_ai_responses typu źródła danych. Użyj tego scenariusza, aby ocenić konkretne interakcje agentów po ich wystąpieniu.

Wskazówka

Zanim zaczniesz, ukończ Get started.

Identyfikator odpowiedzi jest unikatowym identyfikatorem zwracanym za każdym razem, gdy agent rozwiązania Foundry generuje odpowiedź. Identyfikatory odpowiedzi można zbierać z interakcji agenta przy użyciu interfejsu API odpowiedzi lub dzienników śledzenia aplikacji. Podaj wbudowane identyfikatory jako zawartość pliku lub przekaż je jako zestaw danych (zobacz Przygotowywanie danych wejściowych).

Zbieranie identyfikatorów odpowiedzi

Każde wywołanie interfejsu API odpowiedzi zwraca obiekt odpowiedzi z unikatowym id polem. Zbierz te identyfikatory z interakcji aplikacji lub wygeneruj je bezpośrednio:

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

Identyfikatory odpowiedzi można również zbierać z interakcji agenta w logach śledzenia aplikacji lub procesie monitorowania. Każdy identyfikator odpowiedzi jednoznacznie identyfikuje przechowywaną odpowiedź, którą może pobrać usługa oceny.

Utwórz ocenę i uruchom

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

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

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

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

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

Aby uzyskać pełny przykład możliwości uruchamiania, zobacz sample_agent_response_evaluation.py w witrynie GitHub. Aby sondować pod kątem ukończenia i interpretowania wyników, zobacz Pobieranie wyników.

Pobieranie wyników

Po zakończeniu przebiegu oceny pobierz wyniki oceny i przejrzyj je w portalu lub programowo.

Sonduj wyniki

Przebiegi oceny są asynchroniczne. Sonduj stan przebiegu, dopóki nie zostanie ukończony, a następnie pobierz wyniki:

import time
from pprint import pprint

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

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

Interpretowanie wyników

W przypadku pojedynczego przykładu danych wszyscy oceniający generują następujący schemat:

  • Etykieta: binarna etykieta "pass" lub "fail", podobna do danych wyjściowych testu jednostkowego. Użyj tego wyniku, aby ułatwić porównania między ewaluatorami.
  • Wynik: wynik z naturalnej skali każdego ewaluatora. Niektórzy ewaluatorzy używają szczegółowej rubryki, oceniają na 5-punktowej skali (ewaluatorzy jakości) lub 7-punktowej skali (ewaluatorzy bezpieczeństwa treści). Inne, takie jak ewaluatory podobieństw tekstowych, używają wyników F1, które są liczbami zmiennoprzecinkowymi w zakresie od 0 do 1. Każdy niebinarny "wynik" jest binarizowany na wartość "pass" lub "fail" w polu "label" na podstawie wartości "threshold".
  • Próg: wszystkie wyniki inne niż binarne są przekształcane w binarne do "zdania" lub "niezdania" na podstawie domyślnego progu, który użytkownik może zastąpić w interfejsie SDK.
  • Powód: Aby zwiększyć zrozumiałość, wszyscy ewaluatorzy LLM-judge również wyświetlają pole rozumowania, aby wyjaśnić, dlaczego dany wynik jest podany.
  • Szczegóły: (opcjonalnie) W przypadku niektórych ewaluatorów, takich jak tool_call_accuracy, może istnieć pole lub flagi zawierające dodatkowe informacje ułatwiające użytkownikom debugowanie aplikacji.

Przykładowe dane wyjściowe (pojedynczy element)

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

Przykładowe dane wyjściowe (agregacja)

W przypadku agregowania wyników z wielu przykładów (zestawu danych), średni współczynnik przykładów z "zdaniem" stanowi współczynnik zdawalności dla tego zestawu danych.

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

Rozwiązywanie problemów

Zadanie działa od dłuższego czasu

Zadanie oceny może pozostać w stanie Uruchomiony przez dłuższy czas. Dzieje się tak zwykle, gdy wdrożenie modelu Usługi Azure OpenAI nie ma wystarczającej pojemności, co powoduje ponawianie żądań przez usługę.

Rozwiązanie:

  1. Anuluj bieżące zadanie oceny przy użyciu polecenia client.evals.runs.cancel(run_id, eval_id=eval_id).
  2. Zwiększ pojemność modelu w Azure Portal.
  3. Uruchom ponownie ocenę.

Błędy uwierzytelniania

Jeśli otrzymasz błąd 401 Unauthorized lub 403 Forbidden, sprawdź, czy:

  • Poprawnie skonfigurowano DefaultAzureCredential (uruchom az login przy korzystaniu z Azure CLI).
  • Twoje konto ma rolę użytkownika sztucznej inteligencji platformy Azure w projekcie Foundry.
  • Adres URL punktu końcowego projektu jest poprawny i zawiera zarówno nazwy konta, jak i projektu.

Błędy formatu danych

Jeśli ocena zakończy się niepowodzeniem z powodu błędu schematu lub mapowania danych:

  • Sprawdź, czy plik JSONL ma jeden prawidłowy obiekt JSON na wiersz.
  • Upewnij się, że nazwy pól w data_mapping dokładnie odpowiadają nazwom pól w pliku JSONL (z uwzględnieniem wielkości liter).
  • Sprawdź, czy item_schema właściwości są zgodne z polami w zestawie danych.

Błędy limitu szybkości

Tworzenie przebiegów oceny jest limitowane na poziomie dzierżawy, subskrypcji i projektu. Jeśli otrzymasz 429 Too Many Requests odpowiedź:

  • retry-after Sprawdź nagłówek w odpowiedzi pod kątem zalecanego czasu oczekiwania.
  • Przejrzyj treść odpowiedzi, aby uzyskać szczegóły limitu szybkości.
  • Podczas ponawiania żądań, które zakończyły się niepowodzeniem, należy użyć wycofywania wykładniczego.

Jeśli zadanie oceny zakończy się niepowodzeniem z powodu błędu 429 podczas wykonywania:

  • Zmniejsz rozmiar zestawu danych oceny lub podziel go na mniejsze partie.
  • Zwiększ limit przydziału tokenów na minutę (TPM) dla wdrożenia modelu w Azure Portal.

Błędy narzędzia ewaluatora agenta

Jeśli agent ewaluatora zwraca błąd dla nieobsługiwanych narzędzi:

  • Sprawdź obsługiwane narzędzia dla oceniających agentów.
  • Aby obejść ten problem, opakuj nieobsługiwane narzędzia jako narzędzia funkcji zdefiniowane przez użytkownika, aby ewaluator mógł je ocenić.

Treści powiązane

  • Last updated on