Benutzerdefinierte Auswertungen (Vorschau)

Integrierte Bewerter bieten eine einfache Möglichkeit, die Qualität der Anwendungsgenerationen zu überwachen. Um Ihre Auswertungen anzupassen, können Sie eigene codebasierte, promptbasierte oder endpunktbasierte Evaluatoren erstellen.

Mit benutzerdefinierten Bewertern können Sie domänenspezifische Qualitätsmetriken definieren, die über den integrierten Evaluator-Katalog hinausgehen. Verwenden Sie einen benutzerdefinierten Evaluator, wenn Sie kriterien eindeutig für Ihre Anwendung messen müssen, z. B. Markenton, domänenspezifische Genauigkeit oder Kompatibilität des Ausgabeformats.

Sie können drei Typen von benutzerdefinierten Bewertern erstellen:

Nachdem Sie einen benutzerdefinierten Evaluator erstellt haben, können Sie ihn dem Evaluator-Katalog in Ihrem Foundry-Projekt hinzufügen und in Batchauswertungsläufen verwenden.

Codebasierte Bewertungen

Ein codebasierter Evaluator ist eine Python Funktion mit dem Namen grade, die zwei Diktierparameter empfängt (sample und item) und gibt eine Float-Bewertung zwischen 0,0 und 1,0 zurück (höher ist besser). In der Praxis erfolgt der Zugriff auf alle Daten über item:

• Datensatzauswertung: Eingabefelder wie response oder ground_truth können im Python Code wie item.get("response") oder item.get("ground_truth") abgerufen werden.
• Modell- oder Agentzielauswertung: Um generierten Antworttext abzurufen, verwenden Sie item.get("sample", {}).get("output_text").

Im folgenden Beispiel werden Antworten basierend auf der Länge bewertet, wobei antworten zwischen 50 und 500 Zeichen bevorzugt werden:

def grade(sample: dict, item: dict) -> float:
    """Score based on response length (prefer 50-500 chars)."""
    # For dataset evaluation, access fields directly from item:
    response = item.get("response", "")

    # For model/agent target evaluation, use item.get("sample") instead:
    # response = item.get("sample", {}).get("output_text", "")

    if not response:
        return 0.0

    length = len(response)
    if length < 50:
        return 0.2
    elif length > 500:
        return 0.5
    return 1.0

Unterstützte Pakete und Grenzwerte

Codebasierte Auswertungen werden in einer sandkastenbasierten Python Umgebung mit den folgenden Einschränkungen ausgeführt:

• Die Codegröße muss kleiner als 256 KB sein.
• Die Ausführung ist auf 2 Minuten pro Notierungsanruf beschränkt.
• Zur Laufzeit ist kein Netzwerkzugriff verfügbar.
• Die Speichergrenze beträgt 2 GB, die Datenträgergrenze beträgt 1 GB, und die CPU ist auf 2 Kerne beschränkt.

Die folgenden Drittanbieterpakete sind verfügbar:

Die NLTK Corpora punkt, stopwords, wordnet, omw-1.4und names werden vorgeladen.

Laufzeitparameter

pass_threshold und deployment_name sind als Initialisierungsparameter erforderlich, wenn Sie einen codebasierten Evaluator erstellen. Obwohl codebasierte Auswertungen keine LLM aufrufen, erfordert deployment_name das Dienst-API-Schema eine Auswertungsausführungs-Orchestrierung. Sie können einen beliebigen gültigen Modellbereitstellungsnamen aus Ihrem Projekt übergeben.

Promptbasierte Bewertungen

Ein promptbasierter Evaluator verwendet eine Bewertungsaufforderungsvorlage, die ein LLM für jedes Element auswertet. Vorlagenvariablen verwenden doppelte geschweifte Klammern (z {{query}}. B. ) und ordnen Sie Ihren Eingabedatenfeldern zu.

Promptbasierte Auswertungen unterstützen drei Bewertungsmethoden:

• Ordnungszahl: Ganzzahlige Bewertungen in einer einzelnen Skala, die Sie definieren (z. B. 1 bis 5). Höher ist besser.
• Fortlaufend: Float-Werte für feinkörnige Messungen in einem von Ihnen definierten Bereich (z. B. 0,0–1,0). Höher ist besser.
• Binary (true/false): Boolesches Ergebnis für schwellenwertbasierte Überprüfungen.

Der Evaluator muss ein JSON-Objekt mit result und reason. Der Typ der Übereinstimmung mit result Ihrer Bewertungsmethode: eine ganze Zahl für Ordinal, ein Float für fortlaufend oder ein boolescher Wert für die Binärdatei.

Im folgenden Beispiel wird die Ordinalbewertung (1–5) verwendet, um die Freundlichkeit einer Antwort zu bewerten:

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

1 - Unfriendly or hostile
2 - Mostly unfriendly
3 - Neutral
4 - Mostly friendly
5 - Very friendly

Assign a rating based on the tone and demeanor of the response.

Response:
{{response}}

Output Format (JSON):
{
  "result": <integer from 1 to 5>,
  "reason": "<brief explanation for the score>"
}

Laufzeitparameter

Beide deployment_name sind threshold als Initialisierungsparameter erforderlich, wenn Sie einen promptbasierten Evaluator erstellen.

Endpunktbasierte Auswertungen

Ein endpunktbasierter Evaluator delegiert die Bewertung an einen externen HTTP-Endpunkt, den Sie besitzen und betreiben. Der Auswertungsdienst ruft Ihren Endpunkt für jedes Element (oder jede Batch von Elementen) auf und übergibt die zugeordneten Eingabedaten als JSON-Nutzlast. Ihr Endpunkt verarbeitet die Daten mithilfe einer von Ihnen ausgewählten Logik und gibt eine JSON-Antwort mit Bewertungen zurück.

Verwenden Sie bei Bedarf einen endpunktbasierten Evaluator:

• Netzwerkzugriff auf externe Dienste oder Datenbanken während der Bewertung.
• Proprietäre Modelle oder ML-Pipelines, die in Ihrer eigenen Infrastruktur gehostet werden.
• Komplexe Bewertungslogik, die die Grenzen der sandkastenbasierten codebasierten Bewertung überschreitet.
• Integration in vorhandene Auswertungsdienste oder APIs.

So funktioniert es

1. Sie stellen einen HTTP-Endpunkt bereit, der POST-Anforderungen mit Auswertungsdaten akzeptiert.
2. Sie erstellen eine Verbindung in Ihrem Foundry-Projekt, in dem die Endpunkt-URL und die Authentifizierungsanmeldeinformationen gespeichert werden.
3. Sie registrieren einen endpunktbasierten Evaluator, der auf die Verbindung verweist.
4. Wenn eine Auswertung ausgeführt wird, löst der Dienst die Verbindung auf, ruft Ihren Endpunkt mit den Eingabedaten auf und zeichnet die Antwort als Auswertungsergebnis auf.

Endpunktanforderungsschema

Der Auswertungsdienst sendet eine POST-Anforderung an Ihren Endpunkt mit einem JSON-Textkörper, der Auswertungsmetadaten und die zugeordneten Eingabefelder enthält.

In der folgenden Tabelle werden die Felder beschrieben, die Ihr Endpunkt empfängt:

Beispielanforderung:

{
  "schema_version": "0.0.1",
  "evaluator_name": "my_endpoint_evaluator",
  "evaluator_version": "1",
  "evaluation_level": "turn",
  "data": {
    "item": {
      "query": "What is the capital of France?"
    },
    "sample": {
      "response": "Paris"
    }
  }
}

Endpunktantwortschema

In der folgenden Tabelle werden die Felder beschrieben, die Ihr Endpunkt zurückgeben kann:

Erfolgsantwort:

Ihr Endpunkt muss ein JSON-Objekt zurückgeben, das dem Standardbewertungsergebnisschema entspricht:

{
  "schema_version": "0.0.1",
  "score": 0.95,
  "reason": "The response accurately answers the question using the provided context.",
  "status": "completed",
  "properties": {
    "confidence": 0.87,
    "source_coverage": "full"
  },
  "threshold": 3,
  "passed": true
}

Fehlerbesetzung:

Im Falle eines Fehlers muss Ihr Endpunkt ein JSON-Objekt zurückgeben, das dem folgenden Schema entspricht:

 {
   "schema_version": "0.0.1",
   "status": "error",
   "error": {
     "code": "500",
     "message": "Model inference failed"
   }
 }

Authentifizierung

Endpunktbasierte Auswertungen unterstützen zwei Authentifizierungsmethoden über Projektverbindungen:

Erstellen der Endpunktverbindung

Verbindungen speichern die Endpunkt-URL und die Authentifizierungsanmeldeinformationen. Erstellen Sie eine Verbindung mit dem Azure Cognitive Services-Verwaltungsclient:

API-Schlüsselverbindung

from azure.mgmt.cognitiveservices import CognitiveServicesManagementClient
from azure.mgmt.cognitiveservices.models import ConnectionPropertiesV2BasicResource

mgmt_client = CognitiveServicesManagementClient(
    credential=credential,
    subscription_id=subscription_id,
)

connection = ConnectionPropertiesV2BasicResource(
    properties={
        "category": "ApiKey",
        "target": "https://your-endpoint.azurewebsites.net/api/evaluate",
        "authType": "ApiKey",
        "credentials": {
            "key": "<your-api-key>",
        },
    },
)

mgmt_client.account_connections.create(
    resource_group_name=resource_group,
    account_name=account_name,
    connection_name="my-endpoint-connection",
    connection=connection,
)

Microsoft Entra ID Verbindung

connection = ConnectionPropertiesV2BasicResource(
    properties={
        "category": "CustomKeys",
        "target": "https://your-endpoint.azurewebsites.net/api/evaluate",
        "authType": "AAD",
        "credentials": {
            "Audience": "api://<your-app-registration-client-id>",
        },
    },
)

mgmt_client.account_connections.create(
    resource_group_name=resource_group,
    account_name=account_name,
    connection_name="my-endpoint-entra-connection",
    connection=connection,
)

Für Entra ID Authentifizierung muss Ihr Endpunkt so konfiguriert sein, dass token akzeptiert werden, die von der verwalteten Identität des Projekts ausgestellt wurden. Dies umfasst in der Regel Folgendes:

• Registrieren einer Anwendung in Microsoft Entra ID für Ihren Endpunkt.
• Aktivieren von Easy Auth (oder gleichwertiger Tokenüberprüfung) auf Ihrem Endpunkt.
• Gewähren der verwalteten Identität des Projekts einer App-Rollenzuweisung für die Zielanwendung.

Registrieren des Evaluators

Registrieren Sie nach dem Erstellen der Verbindung einen endpunktbasierten Evaluator, der darauf verweist:

endpoint_evaluator = project_client.beta.evaluators.create_version(
    name="my-endpoint-evaluator",
    evaluator_version={
        "name": "my-endpoint-evaluator",
        "categories": [EvaluatorCategory.QUALITY],
        "display_name": "My Endpoint Evaluator",
        "description": "Scores responses using a custom evaluation endpoint",
        "definition": {
            "type": "endpoint",
            "connection_name": "my-endpoint-connection",
        },
    },
)

Ausführen einer Auswertung mit einem endpunktbasierten Evaluator

Verwenden Sie das data_mapping Feld, um anzugeben, welche Eingabedatenfelder an Ihren Endpunkt gesendet werden:

testing_criteria = [
    {
        "type": "azure_ai_evaluator",
        "name": "endpoint_eval",
        "evaluator_name": "my-endpoint-evaluator",
        "data_mapping": {
            "query": "{{item.query}}",
            "response": "{{item.response}}",
            "context": "{{item.context}}",
        },
    },
]

Die data_mapping Schlüssel werden zu den JSON-Feldern, die Ihr Endpunkt empfängt. Ordnen Sie sie den Spalten in Ihrem Auswertungsdatenset mithilfe von {{item.<field_name>}} Syntax zu.

Bereitstellen Ihres Endpunkts

Ihr Auswertungsendpunkt kann ein beliebiger HTTP-Dienst sein, der POST-Anforderungen akzeptiert und JSON zurückgibt. Zu den allgemeinen Hostingoptionen gehören:

• Azure Functions: Einfaches, serverloses Hosting für einfache Bewertungslogik.
• Azure App Service: Vollständiges Web-App-Hosting für komplexe Auswertungspipelinen.
• Azure Container Apps: Containerbasiertes Hosting für ML-Modellinference.

Der Endpunkt muss innerhalb des Timeouts des Auswertungsdiensts (30 Sekunden) antworten und für jede Anforderung eine gültige JSON-Antwort zurückgeben.

Erstellen eines benutzerdefinierten Evaluators mit dem SDK

Voraussetzungen und Setup

Installieren Sie das SDK, und richten Sie Ihren Client ein:

pip install "azure-ai-projects>=2.0.0"

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

# 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 (required for prompt-based evaluators)
# Example: gpt-5-mini
model_deployment_name = os.environ.get("AZURE_AI_MODEL_DEPLOYMENT_NAME", "")

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

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

Erstellen eines codebasierten Evaluators

Übergeben Sie die grade() Funktion als Zeichenfolge im code_text Feld. Definieren Sie die data_schema zu deklarierenden Eingabefelder, die Ihre Funktion erwartet, und beschreiben Sie die metrics zurückgegebene Bewertung der Funktion. Codebasierte Auswertungen verwenden den continuous Metriktyp mit einem Bereich von 0,0 bis 1,0.

Definieren Sie zunächst das Versionsschema der Evaluator:

code_evaluator = project_client.beta.evaluators.create_version(
    name="response_length_scorer",
    evaluator_version={
        "name": "response_length_scorer",
        "categories": [EvaluatorCategory.QUALITY],
        "display_name": "Response Length Scorer",
        "description": "Scores responses based on length, preferring 50-500 characters",
        "definition": {
            "type": EvaluatorDefinitionType.CODE,
            "code_text": (
                'def grade(sample: dict, item: dict) -> float:\n'
                '    """Score based on response length (prefer 50-500 chars)."""\n'
                '    response = item.get("response", "")\n'
                '    if not response:\n'
                '        return 0.0\n'
                '    length = len(response)\n'
                '    if length < 50:\n'
                '        return 0.2\n'
                '    elif length > 500:\n'
                '        return 0.5\n'
                '    return 1.0\n'
            ),
            "init_parameters": {
                "type": "object",
                "properties": {
                    "deployment_name": {"type": "string"},
                    "pass_threshold": {"type": "number"},
                },
                "required": ["deployment_name", "pass_threshold"],
            },
            "metrics": {
                "result": {
                    "type": "continuous",
                    "desirable_direction": "increase",
                    "min_value": 0.0,
                    "max_value": 1.0,
                }
            },
            "data_schema": {
                "type": "object",
                "required": ["item"],
                "properties": {
                    "item": {
                        "type": "object",
                        "properties": {
                            "response": {"type": "string"},
                        },
                    },
                },
            },
        },
    },
)

Ein vollständiges Beispiel finden Sie im codebasierten Evaluator Python SDK-Beispiel.

Erstellen eines promptbasierten Evaluators

Übergeben Sie die Richteraufforderung im prompt_text Feld. Definieren Sie die data_schema Eingabefelder, die Ihre Eingabeaufforderung erwartet, und beschreiben Sie die metrics Bewertungsmethode und den Bereich. Deklarieren Sie init_parameters die Modellbereitstellung und legen Sie den Schwellenwert fest, den der Evaluator zur Laufzeit benötigt.

prompt_evaluator = project_client.beta.evaluators.create_version(
    name="friendliness_evaluator",
    evaluator_version={
        "name": "friendliness_evaluator",
        "categories": [EvaluatorCategory.QUALITY],
        "display_name": "Friendliness Evaluator",
        "description": "Evaluates the warmth and approachability of a response",
        "definition": {
            "type": EvaluatorDefinitionType.PROMPT,
            "prompt_text": (
                "Friendliness assesses the warmth and approachability of the response.\n"
                "Rate the friendliness of the response between one and five "
                "using the following scale:\n\n"
                "1 - Unfriendly or hostile\n"
                "2 - Mostly unfriendly\n"
                "3 - Neutral\n"
                "4 - Mostly friendly\n"
                "5 - Very friendly\n\n"
                "Assign a rating based on the tone and demeanor of the response.\n\n"
                "Response:\n{{response}}\n\n"
                "Output Format (JSON):\n"
                '{\n  "result": <integer from 1 to 5>,\n'
                '  "reason": "<brief explanation for the score>"\n}\n'
            ),
            "init_parameters": {
                "type": "object",
                "properties": {
                    "deployment_name": {"type": "string"},
                    "threshold": {"type": "number"},
                },
                "required": ["deployment_name", "threshold"],
            },
            "data_schema": {
                "type": "object",
                "properties": {
                    "response": {"type": "string"},
                },
                "required": ["response"],
            },
            "metrics": {
                "custom_prompt": {
                    "type": "ordinal",
                    "desirable_direction": "increase",
                    "min_value": 1,
                    "max_value": 5,
                }
            },
        },
    },
)

Ein vollständiges Beispiel finden Sie im prompt-basierten Evaluator Python SDK-Beispiel.

Ausführen einer Auswertung mit einem benutzerdefinierten Evaluator

Nachdem Sie benutzerdefinierte Bewerter erstellt haben, verwenden Sie sie in einer Auswertung auf die gleiche Weise wie integrierte Evaluatoren. Sie können mehrere Auswertungen in eine einzelne Ausführung einschließen.

Im folgenden Beispiel werden sowohl die codebasierte response_length_scorer als auch die aufforderungsbasierte friendliness_evaluator Zusammenarbeit ausgeführt.

Definieren und Ausführen der Auswertung

# Define the data schema
data_source_config = DataSourceConfigCustom(
    type="custom",
    item_schema={
        "type": "object",
        "properties": {
            "response": {"type": "string"},
        },
        "required": ["response"],
    },
)

# Reference both custom evaluators in testing criteria
testing_criteria = [
    {
        "type": "azure_ai_evaluator",
        "name": "response_length_scorer",
        "evaluator_name": "response_length_scorer",
        "initialization_parameters": {
            "deployment_name": model_deployment_name,
            "pass_threshold": 0.5,
        },
    },
    {
        "type": "azure_ai_evaluator",
        "name": "friendliness_evaluator",
        "evaluator_name": "friendliness_evaluator",
        "data_mapping": {
            "response": "{{item.response}}",
        },
        "initialization_parameters": {
            "deployment_name": model_deployment_name,
            "threshold": 3,
        },
    },
]

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

# Run the evaluation with inline data
eval_run = client.evals.runs.create(
    eval_id=eval_object.id,
    name="custom-eval-run-01",
    data_source=CreateEvalJSONLRunDataSourceParam(
        type="jsonl",
        source=SourceFileContent(
            type="file_content",
            content=[
                SourceFileContentContent(
                    item={
                        "response": "I'm sorry this watch isn't working for you. I'd be happy to help you with a replacement!",
                    }
                ),
                SourceFileContentContent(
                    item={
                        "response": "I will not apologize for my behavior!",
                    }
                ),
            ],
        ),
    ),
)

Ergebnisse abrufen

Rufen Sie die Auswertung ab, bis sie abgeschlossen ist, und rufen Sie dann die Ergebnisse pro Element und berichts-URL ab.

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)

# Get per-item results
output_items = list(
    client.evals.runs.output_items.list(run_id=run.id, eval_id=eval_object.id)
)

print(f"Status: {run.status}")
print(f"Report: {run.report_url}")

Bereinigen von Ressourcen

Löschen Sie eine benutzerdefinierte Bewertungsversion und die Auswertung, wenn Sie sie nicht mehr benötigen:

# Delete the custom evaluator version
project_client.beta.evaluators.delete_version(
    name="response_length_scorer",
    version=code_evaluator.version,
)

# Delete the evaluation
client.evals.delete(eval_id=eval_object.id)

Weitere Informationen zu Datenquellenoptionen, Bewertungszuordnungen und erweiterten Szenarien finden Sie unter Ausführen von Auswertungen aus dem SDK.

Weitere Beispiele, einschließlich Auflistung, Aktualisierung und Löschen von Bewertungen, finden Sie im evaluator-Katalogverwaltungsbeispiel Python SDK-Beispiel.

Erstellen eines benutzerdefinierten Evaluators im Portal

Sie können benutzerdefinierte Bewerter direkt im Azure AI Foundry -Portal erstellen, ohne SDK-Code zu schreiben.

1. Wechseln Sie in Ihrem Foundry-Projekt zumEvaluierungs-Evaluator-Katalog>.
2. Wählen Sie "Benutzerdefinierter Evaluator> aus.
3. Füllen Sie die folgenden Felder aus:

Verwenden eines benutzerdefinierten Evaluators in einer Portalauswertung

Nachdem Sie einen benutzerdefinierten Evaluator erstellt haben, verwenden Sie ihn in einer Auswertungsausführung aus dem Portal:

1. Wechseln Sie in Ihrem Foundry-Projekt zu "Auswertung ", und wählen Sie " Erstellen" aus.
2. Folgen Sie dem Auswertungserstellungs-Assistenten. Wählen Sie im Schritt "Kriterien " die Option "Evaluator hinzufügen" aus.
3. Wählen Sie ihren benutzerdefinierten Evaluator aus dem Evaluator-Katalog aus.
4. Geben Sie die erforderlichen Initialisierungsparameter an. Stellen Sie für promptbasierte Auswertungen die Modellbereitstellung und den Schwellenwert bereit. Geben Sie für codebasierte Auswertungen den Übergabeschwellenwert an.
5. Schließen Sie den Assistenten ab, und starten Sie die Auswertungsausführung.

Detaillierte Schritte zum Ausführen von Auswertungen aus dem Portal finden Sie unter Ausführen von Auswertungen aus dem Portal.

Benutzerdefinierte Bewerter auf Unterhaltungsebene

Benutzerdefinierte Auswertungen können ganze Unterhaltungen statt einzelner Wendungen bewerten. So aktivieren Sie die Auswertung auf Unterhaltungsebene:

1. Festlegen evaluation_level="conversation" für die Auswertungsausführung
2. Entwerfen Sie Ihre grade() Funktion so, dass sie als Unterhaltungsarray erwartet item["messages"] wird

Wenn das Diktat auf Unterhaltungsebene ausgeführt wird, empfängt das item Diktat das Array für vollständige Unterhaltungsnachrichten anstelle eines einzelnen Abfrage-/Antwortpaars. Auf diese Weise können Sie benutzerdefinierte Metriken erstellen, die die gesamte Benutzerinteraktion bewerten.

Beispiel: Complianceüberprüfung auf Sitzungsebene

In diesem Beispiel wird überprüft, ob der Agent zu einem beliebigen Zeitpunkt während der Unterhaltung einen erforderlichen Haftungsausschluss offengelegt hat:

def grade(sample: dict, item: dict) -> float:
    """Check if agent disclosed required disclaimer during conversation."""
    messages = item.get("messages", [])
    
    for msg in messages:
        if msg.get("role") == "assistant":
            content = msg.get("content", "")
            if isinstance(content, str) and "not financial advice" in content.lower():
                return 1.0
    
    return 0.0  # Disclaimer never provided

Beispiel: Unterhaltungslängenbewertung

In diesem Beispiel werden Unterhaltungen basierend darauf bewertet, ob sie innerhalb einer Zielanzahl von Wendungen aufgelöst wurden:

def grade(sample: dict, item: dict) -> float:
    """Score based on conversation length (prefer shorter resolutions)."""
    messages = item.get("messages", [])
    
    # Count user turns (excludes system messages)
    user_turns = sum(1 for msg in messages if msg.get("role") == "user")
    
    if user_turns <= 2:
        return 1.0  # Resolved quickly
    elif user_turns <= 4:
        return 0.7  # Reasonable length
    elif user_turns <= 6:
        return 0.4  # Getting long
    else:
        return 0.2  # Too many turns

Verwandte Inhalte

• Ausführen von Auswertungen aus dem SDK
• Integrierte Evaluatoren