Vorhandene Datensätze mit dem Microsoft Foundry SDK auswerten

# 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

// Upload a local JSONL file. Skip this step if you already have a dataset registered.
FileDataset dataset = await projectClient.Datasets.UploadFileAsync(
    name: datasetName,
    version: datasetVersion,
    filePath: "./evaluate_test_data.jsonl");
string dataId = dataset.Id;

Referenz: AIProjectDatasetsOperations.UploadFileAsync

// Upload a local JSONL file. Skip this step if you already have a
// dataset registered.
const dataset = await projectClient.datasets.uploadFile(
  datasetName,
  datasetVersion,
  "./evaluate_test_data.jsonl",
);
const dataId = dataset.id;

Referenz: datasets.uploadFile

In den cURL-Beispielen wird eine vorhandene Dataset-ID oder ein Inlineinhalt verwendet. Verwenden Sie die Registerkarte Python oder JavaScript/TypeScript, um eine lokale Datei hochzuladen, und stellen Sie dann die Dataset-ID in der cURL-Anforderung bereit.

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

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

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

Sie müssen keine separate Anforderung senden. Fügen Sie das file_content Objekt direkt in den CURL-Anforderungstext ein, der im entsprechenden Abschnitt "Auswertung erstellen und ausführen " angezeigt wird.

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 = [
    TestingCriterionAzureAIEvaluator(
        type="azure_ai_evaluator",
        name="coherence",
        evaluator_name="builtin.coherence",
        initialization_parameters={"model": model_deployment_name},
        data_mapping={
            "query": "{{item.query}}",
            "response": "{{item.response}}",
        },
    ),
    TestingCriterionAzureAIEvaluator(
        type="azure_ai_evaluator",
        name="violence",
        evaluator_name="builtin.violence",
        data_mapping={
            "query": "{{item.query}}",
            "response": "{{item.response}}",
        },
    ),
]

object dataSourceConfig = new
{
  type = "custom",
  item_schema = new
  {
    type = "object",
    properties = new
    {
      query = new { type = "string" },
      response = new { type = "string" },
      ground_truth = new { type = "string" }
    },
    required = new[] { "query", "response", "ground_truth" }
  }
};

object[] testingCriteria =
[
  new
  {
    type = "azure_ai_evaluator",
    name = "coherence",
    evaluator_name = "builtin.coherence",
    initialization_parameters = new { model = modelDeploymentName },
    data_mapping = new
    {
      query = "{{item.query}}",
      response = "{{item.response}}"
    }
  },
  new
  {
    type = "azure_ai_evaluator",
    name = "violence",
    evaluator_name = "builtin.violence",
    data_mapping = new
    {
      query = "{{item.query}}",
      response = "{{item.response}}"
    }
  },
  new
  {
    type = "azure_ai_evaluator",
    name = "f1",
    evaluator_name = "builtin.f1_score",
    data_mapping = new
    {
      response = "{{item.response}}",
      ground_truth = "{{item.ground_truth}}"
    }
  }
];

const dataSourceConfig = {
  type: "custom",
  item_schema: {
    type: "object",
    properties: {
      query: { type: "string" },
      response: { type: "string" },
      ground_truth: { type: "string" },
    },
    required: ["query", "response", "ground_truth"],
  },
};

const testingCriteria = [
  {
    type: "azure_ai_evaluator",
    name: "coherence",
    evaluator_name: "builtin.coherence",
    initialization_parameters: { model: modelDeploymentName },
    data_mapping: {
      query: "{{item.query}}",
      response: "{{item.response}}",
    },
  },
  {
    type: "azure_ai_evaluator",
    name: "violence",
    evaluator_name: "builtin.violence",
    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}}",
    },
  },
];

curl --request POST \
  --url "https://${ACCOUNT}.services.ai.azure.com/api/projects/${PROJECT}/openai/v1/evals" \
  --header "Authorization: Bearer ${TOKEN}" \
  --header "Content-Type: application/json" \
  --data '{
    "name": "dataset-evaluation",
    "data_source_config": {
      "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": {"model": "gpt-5-mini"},
        "data_mapping": {
          "query": "{{item.query}}",
          "response": "{{item.response}}"
        }
      },
      {
        "type": "azure_ai_evaluator",
        "name": "violence",
        "evaluator_name": "builtin.violence",
        "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}}"
        }
      }
    ]
  }'

# Create the evaluation
eval_object = openai_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 = openai_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,
        ),
    ),
)

BinaryData evaluationData = BinaryData.FromObjectAsJson(new
{
  name = "dataset-evaluation",
  data_source_config = dataSourceConfig,
  testing_criteria = testingCriteria
});
using BinaryContent evaluationContent = BinaryContent.Create(evaluationData);
ClientResult evaluation = await evaluationClient.CreateEvaluationAsync(
  evaluationContent);
string evaluationId = GetString(evaluation, "id");

object dataSource = new
{
  type = "jsonl",
  source = new { type = "file_id", id = dataId }
};
BinaryData runData = BinaryData.FromObjectAsJson(new
{
  name = "dataset-run",
  data_source = dataSource
});
using BinaryContent runContent = BinaryContent.Create(runData);
ClientResult evaluationRun = await evaluationClient.CreateEvaluationRunAsync(
  evaluationId: evaluationId,
  content: runContent);
Console.WriteLine($"Evaluation run created: {GetString(evaluationRun, "id")}");

Referenz: EvaluationClient Protokollmethoden

// Create the evaluation
const evalObject = await openaiClient.evals.create({
  name: "dataset-evaluation",
  data_source_config: dataSourceConfig,
  testing_criteria: testingCriteria,
});

// Create a run using the uploaded dataset
const evalRun = await openaiClient.evals.runs.create(evalObject.id, {
  name: "dataset-run",
  data_source: {
    type: "jsonl",
    source: {
      type: "file_id",
      id: dataId,
    },
  },
});

# Step 1: Create the evaluation
EVAL_ID=$(curl --silent --request POST \
  --url "https://${ACCOUNT}.services.ai.azure.com/api/projects/${PROJECT}/openai/v1/evals" \
  --header "Authorization: Bearer ${TOKEN}" \
  --header "Content-Type: application/json" \
  --data '{
    "name": "dataset-evaluation",
    "data_source_config": {
      "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": { "model": "gpt-5-mini" },
        "data_mapping": {
          "query": "{{item.query}}",
          "response": "{{item.response}}"
        }
      },
      {
        "type": "azure_ai_evaluator",
        "name": "violence",
        "evaluator_name": "builtin.violence",
        "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}}"
        }
      }
    ]
  }' | jq -r '.id')

# Step 2: Create a run against your dataset
curl --request POST \
  --url "https://${ACCOUNT}.services.ai.azure.com/api/projects/${PROJECT}/openai/v1/evals/${EVAL_ID}/runs" \
  --header "Authorization: Bearer ${TOKEN}" \
  --header "Content-Type: application/json" \
  --data '{
    "name": "dataset-run",
    "data_source": {
      "type": "jsonl",
      "source": {
        "type": "file_id",
        "id": "YOUR_DATASET_ID"
      }
    }
  }'

# Upload the CSV file
data_id = project_client.datasets.upload_file(
    name="eval-csv-data",
    version="1",
    file_path="./evaluation_data.csv",
).id

# Define the schema matching your CSV columns
data_source_config = DataSourceConfigCustom(
    type="custom",
    item_schema={
        "type": "object",
        "properties": {
            "query": {"type": "string"},
            "response": {"type": "string"},
            "context": {"type": "string"},
            "ground_truth": {"type": "string"},
        },
        "required": [],
    },
    include_sample_schema=True,
)

# Define evaluators that use the standard CSV columns
testing_criteria = [
    TestingCriterionAzureAIEvaluator(
        type="azure_ai_evaluator",
        name="coherence",
        evaluator_name="builtin.coherence",
        initialization_parameters={"model": model_deployment_name},
        data_mapping={
            "query": "{{item.query}}",
            "response": "{{item.response}}",
        },
    ),
    TestingCriterionAzureAIEvaluator(
        type="azure_ai_evaluator",
        name="violence",
        evaluator_name="builtin.violence",
        data_mapping={
            "query": "{{item.query}}",
            "response": "{{item.response}}",
        },
    ),
]

# Create the evaluation
eval_object = openai_client.evals.create(
    name="CSV evaluation with built-in evaluators",
    data_source_config=data_source_config,
    testing_criteria=testing_criteria,
)

# Create a run using the CSV data source type
eval_run = openai_client.evals.runs.create(
    eval_id=eval_object.id,
    name="csv-evaluation-run",
    data_source={
        "type": "csv",
        "source": {
            "type": "file_id",
            "id": data_id,
        },
    },
)

object csvDataSourceConfig = new
{
    type = "custom",
    item_schema = new
    {
        type = "object",
        properties = new
        {
            query = new { type = "string" },
            response = new { type = "string" },
            context = new { type = "string" },
            ground_truth = new { type = "string" }
        },
        required = Array.Empty<string>()
    },
    include_sample_schema = true
};
object[] csvTestingCriteria =
[
    new
    {
        type = "azure_ai_evaluator",
        name = "coherence",
        evaluator_name = "builtin.coherence",
        initialization_parameters = new { model = modelDeploymentName },
        data_mapping = new
        {
          query = "{{item.query}}",
          response = "{{item.response}}"
        }
    },
    new
    {
        type = "azure_ai_evaluator",
        name = "violence",
        evaluator_name = "builtin.violence",
        data_mapping = new
        {
          query = "{{item.query}}",
          response = "{{item.response}}"
        }
    },
    new
    {
        type = "azure_ai_evaluator",
        name = "f1",
        evaluator_name = "builtin.f1_score",
        data_mapping = new
        {
          response = "{{item.response}}",
          ground_truth = "{{item.ground_truth}}"
        }
    }
];

FileDataset csvDataset = await projectClient.Datasets.UploadFileAsync(
    name: "eval-csv-data",
    version: "1",
    filePath: "./evaluation_data.csv");

BinaryData evaluationData = BinaryData.FromObjectAsJson(new
{
    name = "CSV evaluation with built-in evaluators",
    data_source_config = csvDataSourceConfig,
    testing_criteria = csvTestingCriteria
});
using BinaryContent evaluationContent = BinaryContent.Create(evaluationData);
ClientResult evaluation = await evaluationClient.CreateEvaluationAsync(
    evaluationContent);
string evaluationId = GetString(evaluation, "id");

BinaryData runData = BinaryData.FromObjectAsJson(new
{
    name = "csv-evaluation-run",
    data_source = new
    {
      type = "csv",
      source = new { type = "file_id", id = csvDataset.Id }
    }
});
using BinaryContent runContent = BinaryContent.Create(runData);
ClientResult evaluationRun = await evaluationClient.CreateEvaluationRunAsync(
    evaluationId: evaluationId,
    content: runContent);
Console.WriteLine($"Evaluation run created: {GetString(evaluationRun, "id")}");

Referenz: AIProjectDatasetsOperations.UploadFileAsync und EvaluationClient Protokollmethoden.

Die aktuellen JavaScript/TypeScript SDK-Beispiele veranschaulichen keine CSV-Auswertung. Verwenden Sie für diesen Ablauf die Registerkarte „Python“ oder „C#“.

Verwenden Sie die Registerkarte Python oder C#, um die CSV-Datei hochzuladen. Anschließend können Sie die Evals-REST-Endpunkte mit dem csv Datenquellentyp und der hochgeladenen Dataset-ID verwenden.