Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Verwenden Sie die Bibliothek `fmeval`, um eine automatische Evaluierung durchzuführen
Die Verwendung der `fmeval` Bibliothek in Ihrem eigenen Code bietet Ihnen die größte Flexibilität bei der Anpassung Ihres Workflows. Sie können die `fmeval` Bibliothek verwenden, um jedes LLM auszuwerten und um mehr Flexibilität bei Ihren benutzerdefinierten Eingabedatensätzen zu haben. Die folgenden Schritte zeigen Ihnen, wie Sie Ihre Umgebung einrichten und sowohl einen Start- als auch einen benutzerdefinierten Workflow mithilfe der `fmeval` Bibliothek ausführen.
## `Beginnen Sie mit der Verwendung der Fmeval-Bibliothek`
Sie können Ihre Foundation-Model-Evaluierung konfigurieren und an Ihren Anwendungsfall in einem Studio-Notebook anpassen. Ihre Konfiguration hängt sowohl von der Art der Aufgabe ab, für die Ihr Foundation-Modell erstellt wurde, als auch davon, wie Sie sie bewerten möchten. FMEval unterstützt unbefristete Generierung, Textzusammenfassung, Beantwortung von Fragen und Klassifizierungsaufgaben. Die Schritte in diesem Abschnitt zeigen Ihnen, wie Sie einen Start-Workflow einrichten. Dieser Startablauf umfasst die Einrichtung Ihrer Umgebung und die Ausführung eines Bewertungsalgorithmus, der entweder ein JumpStart oder ein Amazon Bedrock Foundation-Modell mit integrierten Datensätzen verwendet. Sollten Sie für einen spezifischeren Anwendungsfall einen benutzerdefinierten Eingabedatensatz und einen benutzerdefinierten Workflow verwenden müssen, finden Sie weitere Informationen unter [`Passen Sie Ihren Arbeitsablauf mithilfe der Fmeval-Bibliothek an`](clarify-foundation-model-evaluate-auto-lib-custom.md).
## So richten Sie Ihre Umgebung ein
Wenn Sie keine Modellevaluierung in einem Studio-Notebook durchführen möchten, fahren Sie mit Schritt 11 im folgenden Abschnitt **Erste Schritte mit Studio** fort.
**Voraussetzungen**
+ Um eine Modellevaluierung in einer Studio-Benutzeroberfläche durchzuführen, müssen Ihre AWS Identity and Access Management (IAM-) Rolle und alle Eingabe-Datasets über die richtigen Berechtigungen verfügen. Wenn Sie keine SageMaker AI-Domain- oder IAM-Rolle haben, folgen Sie den Schritten unter. [Leitfaden zur Einrichtung von Amazon SageMaker AI](gs.md)
**So legen Sie Berechtigungen für Ihren Amazon-S3-Bucket fest**
Gehen Sie nach der Erstellung Ihrer Domain und Rolle wie folgt vor, um die für die Evaluierung Ihres Modells erforderlichen Berechtigungen hinzuzufügen.
1. Öffnen Sie die Amazon SageMaker AI-Konsole unter [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Geben Sie im Navigationsbereich **S3** in die Suchleiste oben auf der Seite ein.
1. Wählen Sie **S3** unter **Services** aus.
1. Wählen Sie im Navigationsbereich die Option **Buckets** aus.
1. Wählen Sie im Abschnitt **Allgemeine Buckets** unter **Name** den Namen des S3-Buckets aus, den Sie zum Speichern Ihrer Modelleingabe und -ausgabe in der Konsole verwenden möchten. Wenn noch kein S3-Bucket vorliegt, gehen Sie wie folgt vor:
1. Wählen Sie **Bucket erstellen** aus, um eine neue Seite „**Bucket erstellen**“ zu öffnen.
1. Wählen Sie im Abschnitt **Allgemeine Konfiguration** unter **AWS -Region** die AWS -Region aus, in der sich Ihr Grundlagenmodell befindet.
1. Benennen Sie Ihren S3-Bucket im Eingabefeld unter **Bucket-Name**.
1. Akzeptieren Sie alle Standardoptionen.
1. Wählen Sie **Bucket erstellen** aus.
1. Wählen Sie im Abschnitt **Allgemeine Buckets** unter **Name** den Namen des S3-Buckets aus, den Sie erstellt haben.
1. Wählen Sie die Registerkarte **Berechtigungen**.
1. Scrollen Sie unten im Fenster zum Abschnitt **Cross-origin Resource Sharing (CORS)**. Wählen Sie **Bearbeiten** aus.
1. Um Ihrem Bucket Berechtigungen für Foundation-Evaluationen hinzuzufügen, stellen Sie sicher, dass der folgende Code im Eingabefeld erscheint. Sie können auch Folgendes kopieren und in das Eingabefeld einfügen.
```
[
{
"AllowedHeaders": [
"*"
],
"AllowedMethods": [
"GET",
"PUT",
"POST",
"DELETE"
],
"AllowedOrigins": [
"*"
],
"ExposeHeaders": [
"Access-Control-Allow-Origin"
]
}
]
```
1. Wählen Sie **Änderungen speichern ** aus.
**So fügen Sie Berechtigungen zu Ihrer IAM-Richtlinie hinzu**
1. Geben Sie in die Suchleiste oben auf der Seite **IAM** ein.
1. Wählen Sie unter **Dienste** die Option **Identity and Access Management (IAM)** aus.
1. Wählen Sie im Navigationsbereich **Richtlinien** aus.
1. Eingabe [AmazonSageMakerFullAccess](https://docs.aws.amazon.com/sagemaker/latest/dg/security-iam-awsmanpol.html#security-iam-awsmanpol-AmazonSageMakerFullAccess)in die Suchleiste. Wählen Sie das Optionsfeld neben der Richtlinie aus, die angezeigt wird. Die Schaltfläche **Aktionen** kann jetzt ausgewählt werden.
1. Wählen Sie den Abwärtspfeil neben **Aktionen aus**. Zwei Optionen werden angezeigt.
1. Wählen Sie **Anfügen** aus.
1. Suchen Sie in der angezeigten IAM-Liste nach dem Namen der von Ihnen erstellten Rolle. Aktivieren Sie das Kontrollkästchen neben dem Namen.
1. Wählen Sie **Richtlinie anfügen** aus.
**Erste Schritte mit der Verwendung von Studio**
1. Geben Sie in die Suchleiste oben auf der Seite **SageMaker AI** ein.
1. Wählen Sie unter **Services** **Amazon SageMaker AI** aus.
1. Wählen Sie im Navigationsbereich **Studio** aus.
1. Wählen Sie Ihre Domain im Bereich **Erste Schritte** aus, nachdem Sie den Abwärtspfeil unter Domain **auswählen** erweitert haben.
1. Wählen Sie im Abschnitt **Erste Schritte** Ihr Benutzerprofil aus, nachdem Sie den Abwärtspfeil unter **Benutzerprofil auswählen** erweitert haben.
1. Wählen Sie **Studio öffnen**, um die Landingpage für Studio zu öffnen.
1. Wählen Sie im Navigationsbereich den Dateibrowser aus und navigieren Sie zum Stammverzeichnis.
1. Wählen Sie **Notebook erstellen** aus.
1. Wählen Sie im sich öffnenden Dialogfeld für die Notebook-Umgebung das **Data Science 3.0-Image** aus.
1. Wählen Sie **Select (Auswählen)**.
1. Installieren Sie das `fmeval` Paket in Ihrer Entwicklungsumgebung, wie im folgenden Beispielcode gezeigt:
```
!pip install fmeval
```
**Anmerkung**
Installieren Sie die `fmeval` Bibliothek in einer Umgebung, die verwendetPython 3.10. Weitere Informationen zu den für die Ausführung `fmeval` erforderlichen Anforderungen finden Sie unter [`fmeval`Abhängigkeiten](https://github.com/aws/fmeval/blob/main/pyproject.toml).
## Konfigurieren von `ModelRunner`
FMEval verwendet einen High-Level-Wrapper, der aufgerufen wird, `ModelRunner` um Eingaben zu verfassen, aufzurufen und Ausgaben aus Ihrem Modell zu extrahieren. Das `fmeval` Paket kann jedes LLM auswerten, das zu konfigurierende Verfahren `ModelRunner` hängt jedoch davon ab, welche Art von Modell Sie evaluieren möchten. In diesem Abschnitt wird die Konfiguration `ModelRunner` für ein JumpStart oder ein Amazon Bedrock-Modell erläutert. Wenn Sie einen benutzerdefinierten Eingabedatensatz und benutzerdefinierten `ModelRunner` verwenden möchten, finden Sie weitere Informationen unter [`Passen Sie Ihren Arbeitsablauf mithilfe der Fmeval-Bibliothek an`](clarify-foundation-model-evaluate-auto-lib-custom.md).
### Verwenden Sie ein Modell JumpStart
Um ein JumpStart Modell `ModelRunner` zu evaluieren, einen Endpunkt zu erstellen oder bereitzustellen, das Modell und den integrierten Datensatz zu definieren, zu konfigurieren und zu testen`ModelRunner`.
**Definieren Sie ein JumpStart Modell und konfigurieren Sie ein ModelRunner**
1. Stellen Sie einen Endpunkt bereit, indem Sie einen der folgenden Schritte ausführen:
+ Geben Sie [EndpointName](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html#API_runtime_InvokeEndpoint_RequestSyntax)für einen vorhandenen JumpStart Endpunkt das`model_id`, und an`model_version`.
+ Geben Sie das `model_id` und `model_version` für Ihr Modell an, und erstellen Sie einen JumpStart Endpunkt.
Das folgende Codebeispiel zeigt, wie ein Endpunkt für a erstellt wird [https://aws.amazon.com/blogs/machine-learning/llama-2-foundation-models-from-meta-are-now-available-in-amazon-sagemaker-jumpstart/](https://aws.amazon.com/blogs/machine-learning/llama-2-foundation-models-from-meta-are-now-available-in-amazon-sagemaker-jumpstart/), der über verfügbar ist JumpStart.
```
import sagemaker
from sagemaker.jumpstart.model import JumpStartModel
#JumpStart model and version
model_id, model_version = "meta-textgeneration-llama-2-7b-f", "*"
my_model = JumpStartModel(model_id=model_id)
predictor = my_model.deploy()
endpoint_name = predictor.endpoint_name
# Accept the EULA, and test the endpoint to make sure it can predict.
predictor.predict({"inputs": [[{"role":"user", "content": "Hello how are you?"}]]}, custom_attributes='accept_eula=true')
```
Das vorherige Codebeispiel bezieht sich auf EULA, was für End-Use-License-Agreement (EULA) steht. Die EULA finden Sie in der Modellkartenbeschreibung des Modells, das Sie verwenden. Um einige JumpStart Modelle zu verwenden, müssen Sie angeben`accept_eula=true`, wie im vorherigen Aufruf von gezeigt`predict`. Weitere Informationen zur EULA finden Sie im Abschnitt **Lizenzen und Modellquellen** unter [Modellquellen und Lizenzvereinbarungen](jumpstart-foundation-models-choose.md).
Eine Liste der verfügbaren JumpStart Modelle finden Sie unter [Tabelle mit Built-in Algorithmen mit vortrainiertem Modell](https://sagemaker.readthedocs.io/en/stable/doc_utils/pretrainedmodels.html#built-in-algorithms-with-pre-trained-model-table).
1. Konfigurieren Sie `ModelRunner` mithilfe von`JumpStartModelRunner`, wie im folgenden Konfigurationsbeispiel gezeigt:
```
from fmeval.model_runners.sm_jumpstart_model_runner import JumpStartModelRunner
js_model_runner = JumpStartModelRunner(
endpoint_name=endpoint_name,
model_id=model_id,
model_version=model_version
)
```
Verwenden Sie im vorherigen Konfigurationsbeispiel dieselben Werte für`endpoint_name`,`model_id`, und `model_version` die Sie zum Erstellen des Endpunkts verwendet haben.
1. Testen Sie Ihre`ModelRunner`. Senden Sie eine Musteranforderung an Ihr Modell wie im folgenden Beispielcode gezeigt zu umschließen:
```
js_model_runner.predict("What is the capital of London")
```
### Verwenden eines Amazon Bedrock-Modells
Um ein Amazon Bedrock-Modell auszuwerten, müssen Sie das Modell und den integrierten Datensatz definieren und konfigurieren`ModelRunner`.
**Definieren Sie ein Amazon Bedrock-Modell und konfigurieren Sie ein ModelRunner**
1. Verwenden Sie das folgende Codebeispiel für ein Titan-Modell, das über Amazon Bedrock erhältlich ist, um Modelldetails zu definieren und zu drucken:
```
import boto3
import json
bedrock = boto3.client(service_name='bedrock')
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
model_id = "amazon.titan-tg1-large"
accept = "application/json"
content_type = "application/json"
print(bedrock.get_foundation_model(modelIdentifier=modelId).get('modelDetails'))
```
Im vorherigen Codebeispiel gibt der `accept` Parameter das Format der Daten an, die Sie zur Auswertung Ihres LLM verwenden möchten. `contentType`Gibt das Format der Eingabedaten in der Anforderung an. `MIME_TYPE_JSON`Wird nur für `accept` und `contentType` für Amazon Bedrock-Modelle unterstützt. Weitere Informationen zu diesen Parametern finden Sie unter [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html#API_runtime_InvokeModelWithResponseStream_RequestSyntax).
1. Verwenden Sie zur Konfiguration den`ModelRunner`, wie im folgenden `BedrockModelRunner` Konfigurationsbeispiel gezeigt:
```
from fmeval.model_runners.bedrock_model_runner import BedrockModelRunner
bedrock_model_runner = BedrockModelRunner(
model_id=model_id,
output='results[0].outputText',
content_template='{"inputText": $prompt, "textGenerationConfig": \
{"maxTokenCount": 4096, "stopSequences": [], "temperature": 1.0, "topP": 1.0}}',
)
```
Parametrisieren Sie die `ModelRunner` Konfiguration wie folgt.
+ Verwenden Sie dieselben Werte für `model_id` die Bereitstellung des Modells.
+ `output`Dient zur Angabe des Formats der generierten `json` Antwort. Beispiel: Wenn Ihr LLM die Antwort bereitgestellt hat`[{"results": "this is the output"}]`, `output='results[0].outputText'` kehrt `this is the output` er zurück.
+ Geben Sie `content_template` damit an, wie Ihr LLM mit Anfragen interagiert. Die folgende Konfigurationsvorlage dient lediglich der Erläuterung des vorherigen Konfigurationsbeispiels und ist nicht erforderlich.
+ Im vorherigen Konfigurationsbeispiel `inputText` gibt die Variable die Eingabeaufforderung an, die die vom Benutzer gestellte Anfrage erfasst.
+ Die Variable `textGenerationConfig` gibt wie folgt an, wie das LLM Antworten generiert:
+ Der Parameter `maxTokenCount` wird verwendet, um die Länge der Antwort zu begrenzen, indem die Anzahl der vom LLM zurückgegebenen Token begrenzt wird.
+ Der Parameter `stopSequences` wird verwendet, um eine Liste von Zeichenfolgen anzugeben, die Ihrem LLM mitteilen, dass es keine Antwort mehr generieren soll. Die Modellausgabe wird gestoppt, wenn eine der aufgelisteten Zeichenketten zum ersten Mal in der Ausgabe gefunden wird. Sie können beispielsweise eine Wagenrücklaufsequenz verwenden, um die Modellantwort auf eine einzige Zeile zu beschränken.
+ Der Parameter `topP` steuert die Zufälligkeit, indem er die Menge der Token begrenzt, die bei der Generierung des nächsten Tokens berücksichtigt werden sollen. Dieser Parameter akzeptiert Werte zwischen `0.0` und`1.0`. Höhere Werte von `topP` ermöglichen einen Satz, der ein breiteres Vokabular enthält, und niedrigere Werte beschränken den Tokensatz auf wahrscheinlichere Wörter.
+ Der Parameter `temperature` steuert die Zufälligkeit des generierten Textes und akzeptiert positive Werte. Höhere Werte von `temperature` weisen das Modell an, mehr zufällige und vielfältigere Antworten zu generieren. Niedrigere Werte führen zu besser vorhersehbaren Antworten. Typische Bereiche für `temperature` liegen zwischen `0.2` und`2.0`.
Weitere Informationen zu Parametern für ein bestimmtes Amazon Bedrock Foundation-Modell finden Sie unter [Inferenzparameter für Foundation-Modelle](https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters.html#model-parameters-titan).
Das Format des Parameters content\_template hängt von den Eingaben und Parametern ab, die von Ihrem LLM unterstützt werden. Ein [Anthropic’s Claude 2Modell kann beispielsweise Folgendes](https://www.anthropic.com/index/claude-2) unterstützen: `content_template`
```
"content_template": "{\"prompt\": $prompt, \"max_tokens_to_sample\": 500}"
```
Als weiteres Beispiel kann das [Modell Falcon 7b](https://huggingface.co/tiiuae/falcon-7b) Folgendes unterstützen. `content_template`
```
"content_template": "{\"inputs\": $prompt, \"parameters\":{\"max_new_tokens\": \
10, \"top_p\": 0.9, \"temperature\": 0.8}}"
```
Testen Sie abschließend Ihre. `ModelRunner` Senden Sie eine Musteranforderung an Ihr Modell wie im folgenden Beispielcode gezeigt zu umschließen:
```
bedrock_model_runner.predict("What is the capital of London?")
```
## Bewerten Ihres Modells
Nachdem Sie Ihre Daten konfiguriert haben`ModelRunner`, können Sie einen Bewertungsalgorithmus für die von Ihrem LLM generierten Antworten ausführen. Führen Sie den folgenden Code aus, um eine Liste aller verfügbaren Bewertungsalgorithmen anzuzeigen:
```
from fmeval.eval_algo_mapping import EVAL_ALGORITHMS
print(EVAL_ALGORITHMS.keys())
```
Jeder Algorithmus hat sowohl eine Auswertung als auch eine `evaluate_sample` Methode. Die `evaluate` Methode berechnet eine Punktzahl für den gesamten Datensatz. Die `evaluate_sample` Methode bewertet die Punktzahl für eine einzelne Instance.
Die `evaluate_sample` Methode gibt `EvalScore` Objekte zurück. `EvalScore`Objekte enthalten aggregierte Werte dafür, wie gut Ihr Modell bei der Evaluierung abgeschnitten hat. Die Methode `evaluate_sample` hat die folgenden optionalen Parameter:
+ `model_output` – Die Modellantwort für eine einzelne Anfrage.
+ `model_input` – Eine Aufforderung, die die Anfrage an Ihr Modell enthält.
+ `target_output` – Die erwartete Antwort auf die Eingabeaufforderung in`model_input`.
Das folgende Codebeispiel veranschaulicht die Verwendung von `evaluate_sample`:
```
#Evaluate your custom sample
model_output = model_runner.predict("London is the capital of?")[0]
eval_algo.evaluate_sample(target_output="UKEnglandUnited Kingdom", model_output=model_output)
```
Die Methode `evaluate` hat die folgenden optionalen Parameter:
+ `model` – Ein Beispiel für die `ModelRunner` Verwendung des Modells, das Sie auswerten möchten.
+ `dataset_config` – die Datasatzkonfiguration. Wenn `dataset_config` nicht angegeben, wird das Modell anhand aller integrierten Datensätze ausgewertet, die für diese Aufgabe konfiguriert sind.
+ `prompt_template` – Eine Vorlage, die zum Generieren von Eingabeaufforderungen verwendet wird. Falls nicht angegeben, `prompt_template` wird Ihr Modell anhand einer Standardvorlage für Eingabeaufforderungen bewertet.
+ `save` – Wenn diese Option auf gesetzt ist`True`, werden eintragsweise Eingabeaufforderungen und Ergebnisse in der Datei gespeichert. `EvalAlgorithmInterface.EVAL_RESULTS_PATH` Standardeinstellung: `False`.
+ `num_records` – Die Anzahl der Datensätze, die nach dem Zufallsprinzip aus dem Eingabedatensatz zur Auswertung ausgewählt werden. Standardeinstellung: `300`.
Der `evaluate` Algorithmus gibt eine Liste von `EvalOutput` Objekten zurück, die Folgendes beinhalten können:
+ `eval_name` – Der Name des Bewertungsalgorithmus.
`dataset_name` – Der Name des vom Bewertungsalgorithmus verwendeten Datensatzes.
`prompt_template` – Eine Vorlage zum Verfassen von Eingabeaufforderungen, die verwendet `model_output` wird, wenn der Parameter nicht im Datensatz angegeben ist. Weitere Informationen finden Sie `prompt_template` im ** JumpStart `ModelRunner`Abschnitt Konfiguration**.
`dataset_scores` – Eine aggregierte Punktzahl, die für den gesamten Datensatz berechnet wurde.
`category_scores` – Eine Liste von `CategoryScore` Objekten, die die Punktzahlen für jede Kategorie im Datensatz enthalten.
`output_path` – Der lokale Pfad zur Bewertungsausgabe. Diese Ausgabe enthält Sofortantworten mit Bewertungsergebnissen, die sich auf die einzelnen Datensätze beziehen.
`error` – Eine Fehlermeldung mit einer Zeichenfolge für einen fehlgeschlagenen Bewertungsauftrag.
Die folgenden Dimensionen stehen für die Modellbewertung zur Verfügung:
+ Accuracy
+ Faktenwissen
+ Prompt-Stereotypisierung
+ Semantische Robustheit
+ Toxizität
### Accuracy
Sie können einen Genauigkeitsalgorithmus für eine Aufgabe zur Beantwortung von Fragen, zur Textzusammenfassung oder zur Klassifizierung ausführen. Die Algorithmen sind für jede Aufgabe unterschiedlich, um den unterschiedlichen Dateneingabetypen und Problemen wie folgt Rechnung zu tragen:
+ Führen Sie bei Aufgaben zur Beantwortung von Fragen den `QAAccuracy` Algorithmus mit einer `QAAccuracyConfig` Datei aus.
+ Für Aufgaben zur Textzusammenfassung führen Sie den `SummarizationAccuracy` Algorithmus mit einem `SummarizationAccuracyConfig` aus.
+ Für Klassifizierungsaufgaben führen Sie den `ClassificationAccuracy` Algorithmus mit einem `ClassificationAccuracyConfig` aus.
Der `QAAccuracy` Algorithmus gibt eine Liste von `EvalOutput` Objekten zurück, die für jede Stichprobe einen Genauigkeitswert enthält. Um den Algorithmus für die Genauigkeit von Fragen und Antworten auszuführen, instanziieren Sie eine `QAAccuracygeConfig` und übergeben Sie entweder `` oder `None` als `target_output_delimiter`. Der Algorithmus für die Genauigkeit der Frage und Antwort vergleicht die Antwort, die Ihr Modell generiert, mit einer bekannten Antwort. Wenn Sie `` als Zieltrennzeichen angeben, bewertet der Algorithmus die Antwort als korrekt, wenn er Inhalte generiert, die `` in der Antwort durch getrennt sind. Wenn Sie eine leere Zeichenfolge als `None` oder übergeben`target_output_delimiter`, gibt der Code einen Fehler aus.
Rufen Sie die `evaluate` Methode auf und übergeben Sie die gewünschten Parameter, wie im folgenden Codebeispiel gezeigt:
```
from fmeval.eval import get_eval_algorithm
from fmeval.eval_algorithms.qa_accuracy import QAAccuracy, QAAccuracyConfig
eval_algo = QAAccuracy(QAAccuracyConfig(target_output_delimiter="")))
eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True)
```
Der `SummarizationAccuracy` Algorithmus gibt eine Liste von `EvalOutput` Objekten zurück, die Punktzahlen für [https://huggingface.co/spaces/evaluate-metric/rouge](https://huggingface.co/spaces/evaluate-metric/rouge), und enthalten [https://huggingface.co/spaces/evaluate-metric/bertscore](https://huggingface.co/spaces/evaluate-metric/bertscore). Weitere Informationen zu diesen Ergebnissen finden Sie im Abschnitt Textzusammenfassung unter[Verwenden von Prompt-Datensätzen und verfügbaren Bewertungsdimensionen bei Aufträgen zur Modellbewertung](clarify-foundation-model-evaluate-overview.md). Um den Algorithmus für die Genauigkeit der Textzusammenfassung auszuführen, instanziieren Sie eine `SummarizationAccuracyConfig` und übergeben Sie Folgendes:
+ Geben Sie den Typ der [https://en.wikipedia.org/wiki/ROUGE_(metric)](https://en.wikipedia.org/wiki/ROUGE_(metric))Metrik an, die Sie in Ihrer Auswertung verwenden möchten. `rouge_type` Sie können `rouge1`, `rouge2` oder `rougeL` wählen. Diese Kennzahlen vergleichen generierte Zusammenfassungen mit Referenzzusammenfassungen. ROUGE-1vergleicht die generierten Zusammenfassungen und Referenzzusammenfassungen anhand überlappender Unigramme (Sequenzen eines Elements wie „der“, „ist“). ROUGE-2vergleicht die generierten Zusammenfassungen und die Referenzzusammenfassungen anhand von Bigrammen (Gruppen von zwei Sequenzen wie „the large“, „is home“). ROUGE-Lvergleicht die längste übereinstimmende Wortfolge. Weitere Informationen finden Sie ROUGE unter [ROUGE: Ein Package zur automatischen Auswertung von Zusammenfassungen](https://aclanthology.org/W04-1013.pdf).
+ Setzen Sie `use_stemmer_for_rouge` auf `True` oder `False`. Ein Stemmer entfernt Affixe von Wörtern, bevor er sie miteinander vergleicht. Ein Stemmer entfernt zum Beispiel die Affixe von „schwimmen“ und „schwamm“, sodass nach der Wortstammbildung beide Wörter „schwimmen“ lauten.
+ Legen Sie model\_type\_for\_bertscore auf das Modell fest, das Sie zur Berechnung von [https://huggingface.co/spaces/evaluate-metric/bertscore](https://huggingface.co/spaces/evaluate-metric/bertscore) verwenden möchten. [https://huggingface.co/docs/transformers/model_doc/roberta](https://huggingface.co/docs/transformers/model_doc/roberta)
Rufen Sie abschließend die `evaluate` Methode auf und übergeben Sie die gewünschten Parameter, wie im folgenden Codebeispiel gezeigt:
```
from fmeval.eval import get_eval_algorithm
from fmeval.eval_algorithms.summarization_accuracy import SummarizationAccuracy, SummarizationAccuracyConfig
eval_algo = SummarizationAccuracy(SummarizationAccuracyConfig(rouge_type="rouge1",model_type_for_bertscore="MICROSOFT_DEBERTA_MODEL"))
eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True)
```
Der `ClassificationAccuracy` Algorithmus gibt eine Liste von `EvalOutput` Objekten zurück, die die Werte für Klassifikationsgenauigkeit, Präzision, Erinnerungsvermögen und ausgewogene Genauigkeit für jede Stichprobe enthalten. Weitere Informationen zu diesen Werten finden Sie im Abschnitt **Klassifikation** unter[Verwenden von Prompt-Datensätzen und verfügbaren Bewertungsdimensionen bei Aufträgen zur Modellbewertung](clarify-foundation-model-evaluate-overview.md). Um den Algorithmus für die Genauigkeit der Klassifizierung auszuführen, instanziieren Sie eine `ClassificationAccuracyConfig` und übergeben Sie eine Mittelungsstrategie an `multiclass_average_strategy`. Sie können `micro`, `macro`, `samples`, `weighted` oder `binary` auswählen. Der Standardwert ist `micro`. Übergeben Sie dann eine Liste mit den Namen der Spalten, die die wahren Bezeichnungen für Ihre Klassifizierungskategorien enthalten, an valid\_labels. Rufen Sie abschließend die `evaluate` Methode auf und übergeben Sie die gewünschten Parameter, wie im folgenden Codebeispiel gezeigt:
```
from fmeval.eval import get_eval_algorithm
from fmeval.eval_algorithms.classification_accuracy import ClassificationAccuracy, ClassificationAccuracyConfig
eval_algo = ClassificationAccuracy(ClassificationAccuracyConfig(multiclass_average_strategy="samples",valid_labels=["animal_type","plant_type","fungi_type"]))
eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True)
```
### Faktenwissen
Sie können den Algorithmus für Faktenwissen für die Generierung mit offenem Ende ausführen. Um den Algorithmus für Faktenwissen auszuführen, instanziieren Sie eine `FactualKnowledgeConfig` und übergeben Sie optional eine Trennzeichenfolge (standardmäßig ist das ``). Der Algorithmus für Faktenwissen vergleicht die Antwort, die Ihr Modell generiert, mit einer bekannten Antwort. Der Algorithmus bewertet die Antwort als korrekt, wenn er Inhalte generiert, die in der Antwort durch das Trennzeichen getrennt sind. Wenn Sie `None` als „übergeben“`target_output_delimiter`, muss das Modell dieselbe Antwort wie die Antwort generieren, um als richtig bewertet zu werden. Rufen Sie abschließend die `evaluate` Methode auf und übergeben Sie die gewünschten Parameter.
Faktenwissen gibt eine Liste von `EvalScore` Objekten zurück. Diese enthalten aggregierte Ergebnisse darüber, wie gut Ihr Modell in der Lage ist, Faktenwissen zu kodieren, wie im Abschnitt Übersicht über die **Foundation-Modellbewertung** beschrieben. Die Punktzahlen liegen zwischen `0` und `1` wobei die niedrigste Punktzahl einem geringeren Wissen über reale Fakten entspricht.
Das folgende Codebeispiel zeigt, wie Sie Ihr LLM mithilfe des Algorithmus für Faktenwissen evaluieren:
```
from fmeval.eval import get_eval_algorithm
from fmeval.eval_algorithms.factual_knowledge import FactualKnowledge, FactualKnowledgeConfig
eval_algo = FactualKnowledge(FactualKnowledgeConfig())
eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True)
```
### Prompt-Stereotypisierung
Sie können den Algorithmus zur Prompt-Stereotypisierung für die Generierung mit offenem Ende ausführen. Um den Algorithmus zur Stereotypisierung von Eingabeaufforderungen auszuführen, `DataConfig` müssen Sie die Spalten in Ihrem Eingabedatensatz identifizieren, die einen weniger stereotypen Satz in und einen eher stereotypen Satz in `sent_less_input_location` enthalten. `sent_more_output_location` Weitere Informationen über `DataConfig` finden Sie im vorhergehenden Abschnitt **2. Konfiguration`ModelRunner`**. Rufen Sie als Nächstes die `evaluate` Methode auf und übergeben Sie die gewünschten Parameter.
Bei der Prompt-Stereotypisierung wird eine Liste von `EvalOutput` Objekten zurückgegeben, die eine Punktzahl für jeden Eingabedatensatz und Gesamtwerte für jede Art von Verzerrung enthalten. Die Punktzahlen werden berechnet, indem die Wahrscheinlichkeit der mehr und weniger stereotypen Sätze miteinander verglichen wird. Die Gesamtpunktzahl gibt an, wie oft das Modell den stereotypen Satz bevorzugt hat, indem das Modell dem stereotyperen Satz eine höhere Wahrscheinlichkeit zuweist als dem weniger stereotypen Satz. Ein Wert von `0.5` gibt an, dass Ihr Modell unvoreingenommen ist oder dass es mehr und weniger stereotype Sätze zu gleichen Teilen bevorzugt. Ein Wert größer als `0.5` gibt an, dass Ihr Modell wahrscheinlich eine eher stereotype Antwort generiert. Werte unter 0 `0.5` weisen darauf hin, dass Ihr Modell wahrscheinlich eine weniger stereotype Antwortvariable generiert.
Das folgende Codebeispiel zeigt, wie Sie Ihr LLM mit dem Prompt-Stereotyping-Algorithmus evaluieren:
```
from fmeval.eval import get_eval_algorithm
from fmeval.eval_algorithms.prompt_stereotyping import PromptStereotyping
eval_algo = PromptStereotyping()
eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True)
```
### Semantische Robustheit
Sie können einen Algorithmus zur semantischen Robustheit für jede FMEval-Aufgabe ausführen, Ihr Modell sollte jedoch deterministisch sein. Ein deterministisches Modell ist ein Modell, das immer dieselbe Ausgabe für dieselbe Eingabe generiert. Typischerweise kann man Determinismus erreichen, indem man beim Decodieren einen zufälligen Startwert festlegt. Die Algorithmen sind für jede Aufgabe unterschiedlich, um den unterschiedlichen Dateneingabetypen und Problemen wie folgt Rechnung zu tragen:
+ Für die Generierung ohne Ende, die Beantwortung von Fragen oder die Aufgabenklassifizierung führen Sie den `GeneralSemanticRobustness` Algorithmus mit einer `GeneralSemanticRobustnessConfig` Datei aus.
+ Führen Sie den `SummarizationAccuracySemanticRobustness` Algorithmus für die Textzusammenfassung mit einer `SummarizationAccuracySemanticRobustnessConfig` Datei aus.
Der `GeneralSemanticRobustness` Algorithmus gibt eine Liste von `EvalScore` Objekten zurück, die Genauigkeit aufweisen, wobei Werte zwischen den gestörten `0` und ungestörten Modellausgaben liegen und deren Unterschied `1` quantifiziert wird. Um den allgemeinen Algorithmus für semantische Robustheit auszuführen, instanziieren Sie eine `GeneralSemanticRobustnessConfig` und übergeben Sie sie in einen `perturbation_type`. Sie können eine der folgenden Optionen für `perturbation_type` auswählen:
+ `Butterfinger` – Eine Störung, die Rechtschreibfehler nachahmt, indem Zeichen auf der Tastatur ausgetauscht werden. Geben Sie die Wahrscheinlichkeit ein, dass ein bestimmtes Zeichen gestört ist. Butterfinger ist der Standardwert für. `perturbation_type`
+ `RandomUpperCase` – Eine Störung, bei der ein Bruchteil der Zeichen in Großbuchstaben umgewandelt wird. Geben Sie eine Dezimalzahl von bis ein. `0` `1`
+ `WhitespaceAddRemove` – Die Wahrscheinlichkeit, dass ein Leerraumzeichen vor einem Leerzeichen, das kein Leerzeichen ist, zu Weiß hinzugefügt wird.
Sie können auch die folgenden Parameter angeben:
+ `num_perturbations` – Die Anzahl der Störungen, die für jede Probe in den generierten Text eingebracht werden sollen. Der Standardwert ist `5`.
+ `butter_finger_perturbation_prob` – Die Wahrscheinlichkeit, dass ein Zeichen gestört wird. Nur verwendet, wenn `perturbation_type` `Butterfinger` ist. Der Standardwert ist `0.1`.
+ `random_uppercase_corrupt_proportion` – Der Bruchteil der Zeichen, der in Großbuchstaben umgewandelt werden soll. Nur verwendet, wenn `perturbation_type` `RandomUpperCase` ist. Der Standardwert ist `0.1`.
+ `whitespace_add_prob` – Bei gegebenem Leerraum die Wahrscheinlichkeit, dass er aus einer Stichprobe entfernt wird. Nur verwendet, wenn `perturbation_type` `WhitespaceAddRemove` ist. Der Standardwert ist `0.05`.
+ `whitespace_remove_prob` – Bei einem Leerraum, der kein Leerraum ist, die Wahrscheinlichkeit, dass davor ein Leerraum hinzugefügt wird. Nur verwendet, wenn `perturbation_type` `WhitespaceAddRemove` ist. Der Standardwert ist `0.1`.
Rufen Sie abschließend die `evaluate` Methode auf und übergeben Sie die gewünschten Parameter, wie im folgenden Codebeispiel gezeigt:
```
from fmeval.eval import get_eval_algorithm
from fmeval.eval_algorithms.general_semantic_robustness import GeneralSemanticRobustness, GeneralSemanticRobustnessConfig
eval_algo = GeneralSemanticRobustness(GeneralSemanticRobustnessConfig(perturbation_type="RandomUpperCase",num_perturbations=2,random_uppercase_corrupt_proportion=0.3)))
eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True)
```
Der `SummarizationAccuracySemanticRobustness` Algorithmus gibt eine Liste von `EvalScore` Objekten zurück, die die Differenz (oder das Delta) zwischen den Werten [https://huggingface.co/spaces/evaluate-metric/rouge](https://huggingface.co/spaces/evaluate-metric/rouge), und den [https://huggingface.co/spaces/evaluate-metric/bertscore](https://huggingface.co/spaces/evaluate-metric/bertscore)Werten zwischen der generierten Zusammenfassung und der Referenzzusammenfassung enthalten. Weitere Informationen zu diesen Ergebnissen finden Sie im Abschnitt **Textzusammenfassung** unter [Verwenden von Prompt-Datensätzen und verfügbaren Bewertungsdimensionen bei Aufträgen zur Modellbewertung](clarify-foundation-model-evaluate-overview.md). Um die Textzusammenfassung für semantische Robustheit auszuführen, instanziieren Sie eine `SummarizationAccuracySemanticRobustnessConfig` und übergeben Sie sie in einen `perturbation_type`.
Sie können eine der folgenden Optionen für `perturbation_type` auswählen:
+ `Butterfinger` – Eine Störung, die Rechtschreibfehler nachahmt, indem Zeichen auf der Tastatur ausgetauscht werden. Geben Sie die Wahrscheinlichkeit ein, dass ein bestimmtes Zeichen gestört ist. `Butterfinger`ist der Standardwert für. `perturbation_type`
+ `RandomUpperCase` – Eine Störung, bei der ein Bruchteil der Zeichen in Großbuchstaben umgewandelt wird. Geben Sie eine Dezimalzahl von bis ein. `0` `1`
+ `WhitespaceAddRemove` – Geben Sie die Wahrscheinlichkeit ein, dass ein Leerraumzeichen vor einem Leerzeichen, das kein Leerzeichen ist, zu Weiß hinzugefügt wird.
Sie können auch die folgenden Parameter angeben:
+ `num_perturbations` – Die Anzahl der Störungen, die für jede Probe in den generierten Text eingebracht werden sollen. Der Standardwert ist `5`.
+ `butter_finger_perturbation_prob` – Die Wahrscheinlichkeit, dass ein Zeichen gestört wird. Nur verwendet, wenn `perturbation_type` `Butterfinger` ist. Der Standardwert ist `0.1`.
+ `random_uppercase_corrupt_proportion` – Der Bruchteil der Zeichen, der in Großbuchstaben umgewandelt werden soll. Nur verwendet, wenn `perturbation_type` `RandomUpperCase` ist. Der Standardwert ist `0.1`.
+ `whitespace_add_prob` – Bei gegebenem Leerraum die Wahrscheinlichkeit, dass er aus einer Stichprobe entfernt wird. Nur verwendet, wenn `perturbation_type` `WhitespaceAddRemove` ist. Der Standardwert ist `0.05`.
+ `whitespace_remove_prob` – Bei einem Leerraum, der kein Leerraum ist, die Wahrscheinlichkeit, dass davor ein Leerraum hinzugefügt wird. Wird nur verwendet, wenn `perturbation_type` ist`WhitespaceAddRemove`, Standard ist`0.1`.
+ `rouge_type` – Metriken, die generierte Zusammenfassungen mit Referenzzusammenfassungen vergleichen. Geben Sie den Typ der [https://en.wikipedia.org/wiki/ROUGE_(metric)](https://en.wikipedia.org/wiki/ROUGE_(metric))Metrik an, die Sie in Ihrer Auswertung verwenden möchten. `rouge_type` Sie können `rouge1``rouge2`, oder wählen`rougeL`. ROUGE-1vergleicht die generierten Zusammenfassungen und Referenzzusammenfassungen anhand überlappender Unigramme (Sequenzen eines Elements wie „der“, „ist“). ROUGE-2vergleicht die generierten Zusammenfassungen und die Referenzzusammenfassungen anhand von Bigrammen (Gruppen von zwei Sequenzen wie „the large“, „is home“). ROUGE-Lvergleicht die längste übereinstimmende Wortfolge. Weitere Informationen finden Sie ROUGE unter [ROUGE: Ein Package zur automatischen Auswertung von Zusammenfassungen](https://aclanthology.org/W04-1013.pdf).
+ Setzen Sie `user_stemmer_for_rouge` auf `True` oder `False`. Ein Stemmer entfernt Affixe von Wörtern, bevor er sie miteinander vergleicht. Ein Stemmer entfernt zum Beispiel die Affixe von „schwimmen“ und „schwamm“, sodass nach der Wortstammbildung beide Wörter „schwimmen“ lauten.
+ Legen Sie `model_type_for_bertscore` auf das Modell fest, das Sie zur Berechnung von [https://huggingface.co/spaces/evaluate-metric/bertscore](https://huggingface.co/spaces/evaluate-metric/bertscore) verwenden möchten. [https://huggingface.co/docs/transformers/model_doc/roberta](https://huggingface.co/docs/transformers/model_doc/roberta)
Rufen Sie die `evaluate` Methode auf und übergeben Sie die gewünschten Parameter, wie im folgenden Codebeispiel gezeigt:
```
from fmeval.eval import get_eval_algorithm
from fmeval.eval_algorithms.summarization_accuracy_semantic_robustness import SummarizationAccuracySemanticRobustness, SummarizationAccuracySemanticRobustnessConfig
eval_algo = SummarizationAccuracySemanticRobustness(SummarizationAccuracySemanticRobustnessConfig(perturbation_type="Butterfinger",num_perturbations=3,butter_finger_perturbation_prob=0.2)))
eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True)
```
### Toxizität
Sie können einen Toxizitätsalgorithmus für die Generierung ohne Ende, die Textzusammenfassung oder die Beantwortung von Fragen ausführen. Je nach Aufgabe gibt es drei unterschiedliche Klassen.
+ Führen Sie für die Generierung mit offenem Ende den Toxicity-Algorithmus mit einer `ToxicityConfig` Datei aus.
+ Verwenden Sie zur Zusammenfassung die Klasse. `Summarization_Toxicity`
+ Verwenden Sie für die Beantwortung von Fragen die Klasse`QAToxicity`.
Der Toxizitätsalgorithmus gibt eine oder mehrere `EvalScore` Objekte (abhängig vom Toxizitätsdetektor) zurück, deren Werte zwischen `0` und liegen`1`. Um den Toxizitätsalgorithmus auszuführen, instanziieren Sie eine `ToxicityConfig` und übergeben Sie es in ein Toxizitätsmodell, das zur Bewertung Ihres Modells in `model_type` verwendet werden soll. Sie können Folgendes für `model_type` auswählen:
+ [`detoxify` für UnitaryAI Detoxify-unbiased, einen Textklassifizierer mit mehreren Bezeichnungen](https://github.com/unitaryai/detoxify)[, der speziell auf die [Toxic Comment Classification Challenge und Jigsaw Unintended Bias in Toxicity Classification spezialisiert](https://www.kaggle.com/c/jigsaw-toxic-comment-classification-challenge) wurde.](https://www.kaggle.com/c/jigsaw-unintended-bias-in-toxicity-classification) Das Modell bietet `7` Punktzahlen für die folgenden Klassen: Toxizität, schwere Toxizität, Obszönität, Bedrohung, Beleidigung, sexuelle Explizität und Identitätsangriff.
Es folgt eine Beispielausgabe aus dem Detoxity-Modell:
```
EvalScore(name='toxicity', value=0.01936926692724228),
EvalScore(name='severe_toxicity', value=3.3755677577573806e-06),
EvalScore(name='obscene', value=0.00022437423467636108),
EvalScore(name='identity_attack', value=0.0006707844440825284),
EvalScore(name='insult', value=0.005559926386922598),
EvalScore(name='threat', value=0.00016682750720065087),
EvalScore(name='sexual_explicit', value=4.828436431125738e-05)
```
+ [`toxigen` for Toxigen-roberta](https://github.com/microsoft/TOXIGEN), ein binärer RoBERTa-based Textklassifikator, der genau auf den Datensatz abgestimmt ist und Sätze mit subtiler und impliziter Toxizität für Minderheitengruppen enthält. ToxiGen `13`
Rufen Sie abschließend die Methode auf und übergeben Sie die gewünschten Parameter, wie im folgenden Codebeispiel gezeigt. `evaluate`
```
from fmeval.eval import get_eval_algorithm
from fmeval.eval_algorithms.toxicity import Toxicity, ToxicityConfig
eval_algo = Toxicity(ToxicityConfig(model_type="detoxify"))
eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True)
```