Azure OpenAI Evaluation (Vorschau)

Auswertung erstellen

1. Wählen Sie die Azure OpenAI Evaluation (PREVIEW) im Azure AI Foundry-Portal aus. Um diese Ansicht als Option anzuzeigen, wählen Sie zuerst eine vorhandene Azure OpenAI-Ressource in einer unterstützten Region aus.

2. Auswählen +Neue Auswertung

   

3. Wählen Sie aus, wie Sie Testdaten für die Auswertung bereitstellen möchten. Sie können gespeicherte Chatabschlusse importieren, Daten mithilfe der bereitgestellten Standardvorlagen erstellen oder Eigene Daten hochladen. Gehen wir durch das Hochladen Ihrer eigenen Daten.

   

4. Wählen Sie Ihre Auswertungsdaten aus, die im .jsonl Format vorliegen. Wenn Sie bereits über vorhandene Daten verfügen, können Sie ein Datenobjekt auswählen oder neue Daten hochladen.

   

   Wenn Sie neue Daten hochladen, werden die ersten drei Zeilen der Datei als Vorschau auf der rechten Seite angezeigt:

   

   Wenn Sie eine Beispieltestdatei benötigen, können Sie diesen Beispieltext .jsonl verwenden. Dieses Beispiel enthält Sätze verschiedener technischer Inhalte, und wir werden die semantische Ähnlichkeit in diesen Sätzen bewerten.

   {"input": [{"role": "system", "content": "Provide a clear and concise summary of the technical content, highlighting key concepts and their relationships. Focus on the main ideas and practical implications."}, {"role": "user", "content": "Tokenization is a key step in preprocessing for natural language processing, involving the division of text into smaller components called tokens. These can be words, subwords, or characters, depending on the method chosen. Word tokenization divides text at word boundaries, while subword techniques like Byte Pair Encoding (BPE) or WordPiece can manage unknown words by breaking them into subunits. Character tokenization splits text into individual characters, useful for multiple languages and misspellings. The tokenization method chosen greatly affects model performance and its capacity to handle various languages and vocabularies."}], "output": "Tokenization divides text into smaller units (tokens) for NLP applications, using word, subword (e.g., BPE), or character methods. Each has unique benefits, impacting model performance and language processing capabilities."}      
   {"input": [{"role": "system", "content": "Create a comprehensive yet concise summary that captures the essential technical details and significance of the topic."}, {"role": "user", "content": "Self-attention mechanisms are vital in modern transformer models, allowing them to evaluate the relevance of different parts of an input sequence when processing each element. In self-attention, each position in a sequence learns to focus on all other positions, forming a weighted sum of their values. Attention weights are derived using queries, keys, and values, with compatibility between a query and key determining attention to each value. This mechanism enables capturing long-range dependencies and relationships within a sequence, making it effective for tasks needing context understanding and inter-part relationships."}], "output": "Self-attention is crucial in transformers, enabling each sequence position to evaluate and collect data from all others. It uses queries, keys, and values for attention weights, effectively capturing long-range dependencies and contextual links."}      
   {"input": [{"role": "system", "content": "Synthesize the technical information into a brief, accurate summary that maintains the core concepts and their significance."}, {"role": "user", "content": "The transformer architecture significantly changed natural language processing by introducing a new method for sequence processing. Unlike recurrent neural networks, transformers process whole sequences at once using self-attention. The architecture consists of an encoder and decoder, each with multiple layers of multi-head attention, feed-forward networks, and normalization layers. The encoder processes the input sequence, and the decoder produces the output sequence. Positional encodings are added to retain sequence order information since the model lacks inherent sequence position awareness. This architecture underlies many leading language models like BERT and GPT."}], "output": "Transformers are a transformative neural architecture processing sequences with self-attention instead of recurrence. Their encoder-decoder design, with multi-head attention and position encodings, is fundamental to modern language models like BERT and GPT."}      
   {"input": [{"role": "system", "content": "Distill the technical content into a clear, concise summary that preserves the most important concepts and their practical applications."}, {"role": "user", "content": "Cosine similarity is a metric for measuring similarity between vectors by calculating the cosine of the angle between them. The outcome ranges from -1 to 1, with 1 indicating identical orientation, 0 orthogonality, and -1 opposite orientation. In machine learning and NLP, cosine similarity is useful for comparing document vectors, word embeddings, or any high-dimensional representations. It's often preferred over Euclidean distance because it's invariant to vector magnitude, focusing instead on orientation. This makes it particularly useful for comparing documents or embeddings of various lengths or scales."}], "output": "Cosine similarity evaluates vector similarity by computing their angle's cosine, with values from -1 to 1. It's widely used in ML and NLP for comparing document vectors and embeddings due to its magnitude-invariant nature."}      
   {"input": [{"role": "system", "content": "Provide a succinct summary that captures the key technical concepts and their relationships while maintaining clarity and accuracy."}, {"role": "user", "content": "Neural network activation functions are crucial for introducing non-linearity to deep learning models. Commonly used activation functions include ReLU (Rectified Linear Unit), which outputs the input directly if positive and zero otherwise, sigmoid, which compresses values between 0 and 1, and tanh, which normalizes values between -1 and 1. Each function has specific benefits and applications: ReLU avoids vanishing gradients and enables sparse activation, sigmoid is useful for binary classification, and tanh is often used in hidden layers for its zero-centered output. The activation function choice greatly affects model training dynamics and ultimate performance."}], "output": "Activation functions introduce non-linearity to neural networks, with ReLU, sigmoid, and tanh being the most common. Each serves distinct purposes: ReLU prevents vanishing gradients, sigmoid is suitable for binary classification, and tanh offers zero-centered output, all affecting model performance differently."}      
   {"input": [{"role": "system", "content": "Create a focused summary that emphasizes the main technical concepts and their practical implications while maintaining accuracy."}, {"role": "user", "content": "Batch normalization is a technique that stabilizes and accelerates deep neural network training by normalizing each layer's inputs. It normalizes activations using the mean and variance computed over the current data batch. This normalization reduces internal covariate shift, where the input distribution changes during training. Batch normalization includes learnable parameters (gamma and beta) allowing the network to reverse normalization if necessary. Benefits include enabling higher learning rates, lessening the importance of precise parameter initialization, and serving as a regularizer, potentially removing the need for dropout."}], "output": "Batch normalization stabilizes neural network training by normalizing layer inputs using batch statistics. It addresses internal covariate shift with learnable parameters, allowing higher learning rates and improved training dynamics, while offering regularization benefits."}      
   {"input": [{"role": "system", "content": "Summarize the technical content while preserving the essential concepts and their interconnections, ensuring clarity and precision."}, {"role": "user", "content": "Gradient descent optimization algorithms are foundational to training machine learning models. The basic version updates parameters in the steepest descent direction of the loss function. Variants like Stochastic Gradient Descent (SGD) use random samples to estimate gradients, enhancing computational efficiency. Advanced optimizers like Adam combine momentum (helping overcome local minima) and RMSprop (adapting learning rates for each parameter). These optimizers maintain running averages of gradients and their squares, enabling adaptive learning rates and more efficient training. The optimizer choice can significantly influence model convergence speed and final performance."}], "output": "Gradient descent algorithms optimize ML models by updating parameters based on loss gradients. Variants like SGD use sampling for efficiency, while advanced optimizers like Adam combine momentum with adaptive learning rates for improved training performance."}      
   {"input": [{"role": "system", "content": "Deliver a concise yet comprehensive summary that highlights the key technical aspects and their practical significance."}, {"role": "user", "content": "Cross-validation is a resampling method used to evaluate machine learning models on limited data. The most common form, k-fold cross-validation, involves dividing the dataset into k equal parts, training the model on k-1 folds while validating on the remaining fold, and rotating through all combinations. This provides a more robust model performance assessment than a single train-test split, helping detect overfitting and estimate model generalization to unseen data. Variations include stratified k-fold (maintaining class distribution), leave-one-out (k equals dataset size), and time series cross-validation for temporal data."}], "output": "Cross-validation evaluates ML models by training and testing on different data splits, typically using k-fold methodology. This approach offers better performance assessment than single splits, with variations for different data types and requirements."}      
   {"input": [{"role": "system", "content": "Generate a clear and focused summary that captures the essential technical details while maintaining their relationships and significance."}, {"role": "user", "content": "Transfer learning is a machine learning method where a model developed for one task is reused as the starting point for a model on a second task. This approach is powerful in deep learning, where pre-trained models on large datasets (like ImageNet for computer vision or BERT for NLP) are fine-tuned on specific downstream tasks. Transfer learning reduces the need for large amounts of task-specific training data and computational resources, as the model has already learned useful features from the source ___domain. Common strategies include feature extraction (freezing pre-trained layers) and fine-tuning (updating all or some pre-trained weights)."}], "output": "Transfer learning reuses models trained on one task for different tasks, particularly effective in deep learning. It leverages pre-trained models through feature extraction or fine-tuning, reducing data and computational needs for new tasks."}      
   {"input": [{"role": "system", "content": "Provide a precise and informative summary that distills the key technical concepts while maintaining their relationships and practical importance."}, {"role": "user", "content": "Ensemble methods combine multiple machine learning models to create a more robust and accurate predictor. Common techniques include bagging (training models on random data subsets), boosting (sequentially training models to correct earlier errors), and stacking (using a meta-model to combine base model predictions). Random Forests, a popular bagging method, create multiple decision trees using random feature subsets. Gradient Boosting builds trees sequentially, with each tree correcting the errors of previous ones. These methods often outperform single models by reducing overfitting and variance while capturing different data aspects."}], "output": "Ensemble methods enhance prediction accuracy by combining multiple models through techniques like bagging, boosting, and stacking. Popular implementations include Random Forests (using multiple trees with random features) and Gradient Boosting (sequential error correction), offering better performance than single models."}
   

5. Wenn Sie neue Antworten mithilfe von Eingaben aus Ihren Testdaten erstellen möchten, können Sie "Neue Antworten generieren" auswählen. Dadurch werden die Eingabefelder aus unserer Auswertungsdatei in einzelne Aufforderungen für ein Modell Ihrer Wahl zum Generieren der Ausgabe eingefügt.

Sie wählen das Modell Ihrer Wahl aus. Wenn Sie kein Modell haben, können Sie eine neue Modellimplementierung erstellen. Das ausgewählte Modell verwendet die Eingabedaten und generiert eigene eindeutige Ausgaben, die in diesem Fall in einer Variablen namens {{sample.output_text}} gespeichert werden. Wir werden dieses Ergebnis später als Teil unserer Testkriterien verwenden. Alternativ können Sie ihre eigenen benutzerdefinierten Systemnachrichten und einzelne Nachrichtenbeispiele manuell bereitstellen.

6. Zum Erstellen einer Testkriterien wählen Sie "Hinzufügen" aus. Für die bereitgestellte Beispieldatei werden wir die semantische Ähnlichkeit bewerten. Wählen Sie "Model Scorer" aus, der Testkriterienvoreinstellungen für die semantische Ähnlichkeit enthält.

   

   Wählen Sie oben die semantische Ähnlichkeit aus. Scrollen Sie nach unten und geben Sie im User Abschnitt {{item.output}} als Ground truth an und {{sample.output_text}} als Output an. Dadurch wird die ursprüngliche Referenzausgabe ihrer Auswertungsdatei .jsonl (die bereitgestellte Beispieldatei) verwendet und mit der Ausgabe verglichen, die vom im vorherigen Schritt ausgewählten Modell generiert wird.

   

7. Wählen Sie "Hinzufügen" aus, um diese Testkriterien hinzuzufügen. Wenn Sie zusätzliche Testkriterien hinzufügen möchten, können Sie diese zu diesem Schritt hinzufügen.

8. Sie sind bereit, Ihre Auswertung zu erstellen. Geben Sie Ihren Bewertungsname an, überprüfen Sie, ob alles korrekt ist, und reichen Sie den Bewertungsauftrag ein. Sie werden zu einer Statusseite für Ihren Auswertungsauftrag weitergeleitet, auf der der Status " Warten" angezeigt wird.

9. Nachdem Ihr Auswertungsauftrag erstellt wurde, können Sie den Auftrag auswählen, um die vollständigen Details des Auftrags anzuzeigen:

10. Für die semantische Ähnlichkeit enthält Anzeigen von Ausgabedetails eine JSON-Darstellung, die Sie kopieren/einfügen können, um die bestandenen Tests zu kopieren/einzufügen.

11. Sie können auch weitere Evaluierungsläufe hinzufügen, indem Sie in der oberen linken Ecke Ihrer Auswertungsauftragsseite die Schaltfläche + Lauf hinzufügen auswählen.

Auswertung erstellen

Sie können eine Auswertung erstellen, indem Sie eine Datenquellenkonfiguration und die Auswertungstestkriterien angeben. Nachfolgend finden Sie eine von vielen Möglichkeiten, eine Datenquellenkonfiguration zu definieren. Sie können auch ein oder mehrere Testkriterien angeben.

import asyncio
import json
import requests

async def create_eval():
    response = await asyncio.to_thread(
        requests.post,
        f'{API_ENDPOINT}/openai/v1/evals',
        headers={
            'api-key': API_KEY,
            'aoai-evals': 'preview'
        },
        json={
            'name': 'My Evaluation',
            'data_source_config': {
                'type': 'custom',
                'item_schema': {
                'type': 'object',
                'properties': {
                    'question': {
                    'type': 'string'
                    },
                    'subject': {
                    'type': 'string'
                    },
                    'A': {
                    'type': 'string'
                    },
                    'B': {
                    'type': 'string'
                    },
                    'C': {
                    'type': 'string'
                    },
                    'D': {
                    'type': 'string'
                    },
                    'answer': {
                    'type': 'string'
                    },
                    'completion': {
                    'type': 'string'
                    }
                }
                }
            },
            'testing_criteria': [
                {
                'type': 'string_check',
                'reference': '{{item.completion}}',
                'input': '{{item.answer}}',
                'operation': 'eq',
                'name': 'string check'
                }
            ]
        })

    print(response.status_code)
    print(json.dumps(response.json(), indent=2))

Erstellen eines Einzeldurchlaufs

Azure OpenAI Evaluation ermöglicht das Erstellen mehrerer Ausführungen unter einem Auswertungsauftrag. Wenn Sie einer vorhandenen Auswertung einen einzelnen Auswertungslauf hinzufügen möchten, können Sie die eval_id der vorhandenen Auswertung angeben:

import asyncio
import requests
import json


response = await asyncio.to_thread(
    requests.post,
    f'{API_ENDPOINT}/openai/v1/evals/{eval_id}/runs',
    headers={
        'api-key': API_KEY,
        'aoai-evals': 'preview'
    },
    json={
        "name": "No sample",
        "metadata": {
            "sample_generation": "off",
            "file_format": "jsonl"
        },
        "data_source": {
            "type": "jsonl",
            "source": {
            "type": "file_id",
            "id": "file-75099d8d4b5b4abca7cc91e9eca7bba1"
            }
        }
    })

print(response.status_code)
print(json.dumps(response.json(), indent=2))

Vorhandene Auswertung aktualisieren

import asyncio
import requests
import json

async def update_eval():
    response = await asyncio.to_thread(
        requests.post,
        f'{API_ENDPOINT}/openai/v1/evals/{eval_id}',
        headers={
            'api-key': API_KEY,
            'aoai-evals': 'preview'
        },
        json={
            "name": "Updated Eval Name",
            "metadata": {
                "sample_generation": "off",
                "file_format": "jsonl",
                "updated": "metadata"
            }
        })

    print(response.status_code)
    print(json.dumps(response.json(), indent=2))

Auswertungsergebnisse

Sobald die Auswertung abgeschlossen ist, können Sie die Auswertungsergebnisse für den Auswertungsauftrag abrufen, indem Sie die angegebene ID eval_id verwenden.

import asyncio
import requests

async def get_eval():
    response = await asyncio.to_thread(
        requests.get,
        f'{API_ENDPOINT}/openai/v1/evals/{eval_id}',
        headers={
            'api-key': API_KEY,
            'aoai-evals': 'preview'
        })

    print(response.status_code)
    print(response.json())

Ergebnis eines einzelnen Bewertungslaufs

Genau wie Sie eine einzelne Auswertung unter einem vorhandenen Auswertungsauftrag erstellen können, können Sie auch das Ergebnis für eine einzelne Ausführung abrufen:

import asyncio
import requests
import json

async def get_eval_run():
    response = await asyncio.to_thread(
        requests.get,
        f'{API_ENDPOINT}/openai/v1/evals/eval_67fd95c864f08190817f0dff5f42f49e/runs/evalrun_67fe987a6c548190ba6f33f7cd89343d',
        headers={
            'api-key': API_KEY,
            'aoai-evals': 'preview'
        })

    print(response.status_code)
    print(json.dumps(response.json(), indent=2))

Zusätzlich zu den Parametern in den obigen Beispielen können Sie optional diese Parameter für spezifischere Drilldowns zu den Auswertungsergebnissen hinzufügen:

Auswertungsliste

Um die Liste aller erstellten Auswertungsaufträge zu sehen:

import asyncio
import requests
import json

async def get_eval_list():
    response = await asyncio.to_thread(
        requests.get,
        f'{API_ENDPOINT}/openai/v1/evals',
        headers={
            'api-key': API_KEY,
            'aoai-evals': 'preview'
        })

    print(response.status_code)
    print(json.dumps(response.json(), indent=2))

Ausgabedetails für eine Ausführung

Sie können die einzelnen Ausgaben anzeigen, die von den Gradern für einen einzelnen Auswertungslauf generiert wurden:

import asyncio
import requests
import json

async def get_eval_output_item_list():
    response = await asyncio.to_thread(
        requests.get,
        f'{API_ENDPOINT}/openai/v1/evals/eval_67fd95c864f08190817f0dff5f42f49e/runs/evalrun_67fe987a6c548190ba6f33f7cd89343d/output_items',
        headers={
            'api-key': API_KEY,
            'aoai-evals': 'preview'
        })

    print(response.status_code)
    print(json.dumps(response.json(), indent=2))

Wenn Sie ein bestimmtes Ausgabeergebnis sehen möchten, können Sie die Ausgabeelement-ID angeben:

import asyncio
import requests
import json

async def get_eval_output_item():
    response = await asyncio.to_thread(
        requests.get,
        f'{API_ENDPOINT}/openai/v1/evals/eval_67fd95c864f08190817f0dff5f42f49e/runs/evalrun_67fe987a6c548190ba6f33f7cd89343d/output_items/outputitem_67fe988369308190b50d805120945deb',
        headers={'api-key': API_KEY})

    print(response.status_code)
    print(json.dumps(response.json(), indent=2))

Auswertung erstellen

Sie können eine Auswertung erstellen, indem Sie eine Datenquellenkonfiguration und die Auswertungstestkriterien angeben. Nachfolgend finden Sie eine von vielen Möglichkeiten, eine Datenquellenkonfiguration zu definieren. Sie können auch ein oder mehrere Testkriterien angeben.

curl -X POST "$AZURE_OPENAI_ENDPOINT/openai/v1/evals" \
  -H "Content-Type: application/json" \
  -H "api-key: $AZURE_OPENAI_API_KEY" \
  -H "aoai-evals: preview" \
  -d '{
    "name": "Math Quiz",
    "data_source_config": {
      "type": "custom",
      "include_sample_schema": true,
      "item_schema": {
        "type": "object",
        "properties": {
          "question": { "type": "string" },
          "A": { "type": "string" },
          "B": { "type": "string" },
          "C": { "type": "string" },
          "D": { "type": "string" },
          "answer": { "type": "string" }
        }
      }
    },
    "testing_criteria": [
      {
        "type": "string_check",
        "reference": "{{item.answer}}",
        "input": "{{sample.output_text}}",
        "operation": "eq",
        "name": "string check"
      }
    ]
  }'

Einen einzelnen Lauf erstellen

Azure OpenAI Evaluation ermöglicht das Erstellen mehrerer Ausführungen unter einem Auswertungsauftrag. Sie können dem im vorherigen Schritt erstellten Auswertungsauftrag neue Auswertungsläufe hinzufügen, indem Sie angeben eval-id.

curl -X POST "$AZURE_OPENAI_ENDPOINT/openai/v1/evals/{eval-id}/runs" \
  -H "Content-Type: application/json" \
  -H "api-key: $AZURE_OPENAI_API_KEY" 
  -H "aoai-evals: preview" \

Vorhandene Auswertung aktualisieren

curl -X POST "$AZURE_OPENAI_ENDPOINT/openai/v1/evals/{eval-id} \
  -H "Content-Type: application/json" \
  -H "api-key: $AZURE_OPENAI_API_KEY" 
  -H "aoai-evals: preview" \

Auswertungsergebnisse

Sobald die Auswertung abgeschlossen ist, können Sie die Auswertungsergebnisse für den Auswertungsauftrag abrufen, indem Sie die eval_id angeben.

curl -X GET "$AZURE_OPENAI_ENDPOINT/openai/v1/evals/{eval-id}" \
  -H "Content-Type: application/json" \
  -H "api-key: $AZURE_OPENAI_API_KEY" 
  -H "aoai-evals: preview" \

Ergebnis des Einzelauswertungslaufs

Genau wie Sie eine einzelne Auswertung unter einem vorhandenen Auswertungsauftrag erstellen können, können Sie auch das Ergebnis für eine einzelne Ausführung abrufen:

curl -X GET "$AZURE_OPENAI_ENDPOINT/openai/v1/evals/{eval-id}/runs/{run-id}" \
  -H "Content-Type: application/json" \
  -H "api-key: $AZURE_OPENAI_API_KEY" 
  -H "aoai-evals: preview" \

Zusätzlich zu den Parametern in den obigen Beispielen können Sie optional diese Parameter für spezifischere Drilldowns zu den Auswertungsergebnissen hinzufügen:

Auswertungsliste

Um die Liste aller erstellten Auswertungsaufträge anzuzeigen:

curl -X GET "$AZURE_OPENAI_ENDPOINT/openai/v1/evals/{eval-id}/runs" \
  -H "Content-Type: application/json" \
  -H "api-key: $AZURE_OPENAI_API_KEY" 
  -H "aoai-evals: preview" \

Ausgabedetails für eine Ausführung

Sie können die einzelnen Ergebnisse anzeigen, die von den Bewertungsinstanzen für einen einzelnen Auswertungslauf generiert wurden:

curl -X GET "$AZURE_OPENAI_ENDPOINT/openai/v1/evals/{eval-id}/runs/{run-id}/output_items" \
  -H "Content-Type: application/json" \
  -H "api-key: $AZURE_OPENAI_API_KEY" 
  -H "aoai-evals: preview" \

Wenn Sie ein bestimmtes Ausgabeergebnis sehen möchten, können Sie die Ausgabeelement-ID angeben:

curl -X GET "$AZURE_OPENAI_ENDPOINT/openai/v1/evals/{eval-id}/runs/{run-id}/output_items/{output-item-id}" \
  -H "Content-Type: application/json" \
  -H "api-key: $AZURE_OPENAI_API_KEY"
  -H "aoai-evals: preview" \