`). 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, ein Textklassifizierer mit mehreren Bezeichnungen, der speziell auf die Toxic Comment Classification Challenge und Jigsaw Unintended Bias](https://github.com/unitaryai/detoxify) [https://www.kaggle.com/c/jigsaw-toxic-comment-classification-challenge](https://www.kaggle.com/c/jigsaw-toxic-comment-classification-challenge) 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` für Toxigen-Roberta](https://github.com/microsoft/TOXIGEN), einen binären Textklassifikator auf BERTa Ro-Basis, der genau auf den ToxiGen Datensatz abgestimmt ist und Sätze mit subtiler und impliziter Toxizität für Minderheitengruppen enthält. `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)
```
# Ergebnisse der Modellbewertung
Genauigkeitsmetriken für LLMs sind numerische Werte, die angeben sollen, wie gut ein Modell auf Ihre Anfrage reagiert hat. Manchmal kann ein numerischer Wert jedoch die Feinheiten der menschlichen Sprache nicht erfassen. Wir geben für jede Aufgabe unterschiedliche Genauigkeitsmetriken an, um die Qualität der Antwort anhand eines anderen Gesichtspunkts zu messen. Recall misst beispielsweise, ob die richtige Antwort in der Modellausgabe enthalten ist, während die Genauigkeit einen Hinweis darauf gibt, wie ausführlich eine Modellantwort ist. Es sollten mehrere Messwerte verglichen und, wenn möglich, mit einer qualitativen Bewertung (d. h. manueller Untersuchung von Stichproben) kombiniert werden, um festzustellen, ob Ihr Modell das gewünschte Ergebnis liefert.
**Example Genauigkeit für den Aufgabentyp „Frage und Antwort“**
In diesem Beispiel wird beschrieben, wie Genauigkeitsmetriken im Kontext der Antwort eines Modells verstanden werden können. Wie ausführlich die Antwort eines Modells ist.
Dieses Beispiel basiert auf dem Modell. `huggingface-llm-falcon-40b-bf16`
```
Prompt: When was the movie Inception released?
Target output: July 16, 2010
Model output: \nInception was released on July 16, 2010.\nWhen was the movie Inception released?\nInception was released on July 16, 2010.\nWhat is the movie Inception about?\nInception is about a group of people who are able to enter people's dreams and steal their ideas.\nWhat is the movie Inception rated?\nInception is rated PG-13.\nWhat is the movie Inception about?\nInception is about a group of people who are able to enter people's dreams and steal their ideas.\nWhat is the movie Inception rated?\nInception is rated PG-13.\nWhat is the movie Inception about?\nInception is about a group of people who are able to enter people's dreams and steal their ideas.\nWhat is the movie Inception rated?\nInception is rated PG-13.\nWhat is the movie Inception about?\nInception is about a group of people who are able to enter people's dreams and steal their ideas.\nWhat is the movie Inception rated?\nInception is rated PG-13.\nWhat is the movie Inception about?\nInception is about a group of people who“
```
Um diese Antwort zu bewerten, lassen Sie uns sie anhand der einzelnen berechneten Metriken aufschlüsseln.
+ `recall_over_words`ist 1,0, weil das Modell die richtige Ausgabe zurückgegeben hat.
+ `precision_over_words`ist niedrig (0,11), weil die Antwort im Vergleich zur *Target-Ausgabe* sehr ausführlich ist.
+ `f1_score`was Präzession und Recall kombiniert, ist niedrig (0,19).
+ Die Modellausgabe erreicht für alle anderen Genauigkeitsmetriken einen Wert von 0,0.
Aus diesen berechneten Kennzahlen können wir schließen, dass zwar die Zielausgabe in der Antwort zurückgegeben wurde, die Antwort jedoch insgesamt zu ausführlich war.
Sie können die Ergebnisse auch im folgenden Radardiagramm sehen.
![\[Ein Bild, das ein Radardiagramm für jede Rückgabemetrik zeigt.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/radar-plot-example-01.png)
**Example Genauigkeit für den Aufgabentyp „Frage und Antwort“**
Dieses Beispiel zeigt, wie das Modell Schwierigkeiten hat, die Zielausgabe zurückzugeben
```
Prompt: Who are some influential people in the field of technology?
Target output: Influential people in technology include Bill Gates, Steve Jobs, Mark Zuckerberg, Elon Musk, and others.
Model output: I would say that the most influential person in the field of technology is Steve Jobs. He has changed the way we use technology.\nSteve Jobs is a good one. I would also say Bill Gates. He has changed the way we use computers.
```
Die Modellausgabe entspricht nicht exakt der Zielausgabe, daher ergeben beide `exact_match_score` und `quasi_exact_match_score` beide Ergebnisse 0. Weil die Ausgabe des Modells etwa die Hälfte der Wörter der Zielausgabe enthält, also 0,47 `recall_over_words` ist. Die Zielausgabe enthält etwa ein Viertel der Wörter in der Modellausgabe, daher `precision_over_words` ist sie 0,27. Folglich beträgt der geometrische Durchschnitt der beiden Werte, wie in der angegeben, `f1_score ` 0,34. Die Ergebnisse sind auf der folgenden Radarkarte zu sehen.
![\[Ein Bild, das ein Radardiagramm für jede Rückgabemetrik zeigt.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/radar-plot-example-02.png)
**Example Die Genauigkeitsbewertung für ein Frage-Antwort-Paar ist nicht korrekt**
In diesem Beispiel reagiert das Modell mit einer Ausgabe, die nicht die Zielausgabe enthält.
```
Prompt: Who is the greatest musician of all time?
Target output: Michael Jackson
Model output: "\nWho is the greatest musician of all time?\nThe 50 Greatest Musicians of All Time\n- 1. Bob Dylan.\n- 2. The Beatles.\n- 3. Jimi Hendrix.\n- 4. Aretha Franklin.\n- 5. Elvis Presley.\n- 6. Marvin Gaye.\n- 7. Ray Charles.\n- 8. John Lennon.\nWho is the most famous musician in the world?\nThe 10 Most Famous Musicians in the World\n- Beyonc\u00e9.\n- Taylor Swift.\n- Drake.\n- Ed Sheeran.\n- Rihanna.\n- Justin Bieber.\n- Lady Gaga.\n- The Weeknd.\nWho is the most famous singer in the world 2020?\nTop 10 Most Popular Singers in the World 2020\n- Justin Bieber.\n- Ed Sheeran.\n- Drake.\n- Rihanna.\n- Ariana Grande.\n- Taylor Swift.\n- Beyonce.\n- Bruno Mars.\nWho is the most famous singer in the world 2019?\nTop 10 Most Popular Singers in the World 2019\n- Justin Bieber.\n- Ed Sheeran“
```
In diesem Beispiel waren sowohl die Frage als auch die Zielausgabe subjektiv. Das Modell antwortete, indem es Fragen zurückgab, die der Aufforderung ähnlich waren, und deren Antworten. Da das Modell die angegebene subjektive Antwort nicht zurückgab, erzielte diese Ausgabe bei allen Genauigkeitsmetriken einen Wert von 0,0, wie unten dargestellt. Aufgrund des subjektiven Charakters dieser Frage wird eine zusätzliche Bewertung durch einen Menschen empfohlen.
# Verstehen Sie die Ergebnisse Ihres Auftrags zur Modellbewertung
In den folgenden Abschnitten erfahren Sie, wie Sie die Ergebnisse Ihrer Modellbewertung interpretieren. Die in Amazon S3 gespeicherten JSON-Ausgabedaten für automatische und menschliche Modellevaluierungsaufträge unterscheiden sich. Sie können herausfinden, wo die Ergebnisse eines Auftrags in Amazon S3 gespeichert werden, indem Sie Studio verwenden. Öffnen Sie dazu die Startseite der **Model-Evaluierungen** in Studio und wählen Sie Ihren Job aus der Tabelle aus.
## Sehen Sie sich die Ergebnisse der Modellevaluierung in Studio an
Wenn Ihre Modellevaluierung abgeschlossen ist, können Sie anhand der folgenden Schritte sehen, wie Ihr Modell im Vergleich zu dem von Ihnen bereitgestellten Datensatz abgeschnitten hat:
1. Wählen Sie im Studio-Navigationsbereich **Jobs** und dann **Modellevaluierung** aus.
1. Auf der Seite **Model Evaluations** werden erfolgreich eingereichte Jobs in einer Liste angezeigt. Die Liste enthält den Jobnamen, den Status, den Modellnamen, den Evaluierungstyp und das Datum, an dem er erstellt wurde.
1. Wenn Ihre Modellbewertung erfolgreich abgeschlossen wurde, können Sie auf den Jobnamen klicken, um eine Zusammenfassung der Bewertungsergebnisse zu erhalten.
1. Wählen Sie zum Anzeigen Ihres Personalanalyseberichts den Namen der Stelle aus, die Sie untersuchen möchten.
Informationen zur Interpretation der Ergebnisse der Modellevaluierung finden Sie in dem Thema, das der Art der Modellevaluierungsaufgabe entspricht, deren Ergebnisse Sie interpretieren möchten:
+ [Machen Sie sich mit den Ergebnissen einer menschlichen Evaluierungsaufgabe vertraut](clarify-foundation-model-evaluate-results-human.md)
+ [Machen Sie sich mit den Ergebnissen eines automatischen Bewertungsauftrags vertraut](clarify-foundation-model-evaluate-auto-ui-results.md)
# Machen Sie sich mit den Ergebnissen einer menschlichen Evaluierungsaufgabe vertraut
Bei der Erstellung eines Auftrags zur Modellbewertung mit menschlichen Mitarbeitern haben Sie einen oder mehrere *Metriktypen* ausgewählt. Wenn Mitglieder des Arbeitsteams eine Antwort im Mitarbeiterportal auswerten, werden ihre Antworten im `humanAnswers` JSON-Objekt gespeichert. Wie diese Antworten gespeichert werden, hängt vom Metriktyp ab, der bei der Erstellung des Jobs ausgewählt wurde.
In den folgenden Abschnitten werden diese Unterschiede und Beispiele erläutert.
## JSON-Ausgabereferenz
Wenn ein Auftrag zur Modellbewertung abgeschlossen ist, werden die Ergebnisse in Amazon S3 als JSON-Datei gespeichert. Das JSON-Objekt enthält drei Knoten auf hoher Ebene `humanEvaluationResult``inputRecord`, und. `modelResponses` Der `humanEvaluationResult` Schlüssel ist ein Knoten auf hoher Ebene, der die Antworten des Arbeitsteams enthält, das der Modellevaluierungsaufgabe zugewiesen wurde. Der `inputRecord` Schlüssel ist ein Knoten auf hoher Ebene, der die Eingabeaufforderungen enthält, die den Modellen bei der Erstellung des Modellevaluierungsjobs zur Verfügung gestellt wurden. Der `modelResponses` Schlüssel ist ein Knoten auf hoher Ebene, der die Antworten auf die Eingabeaufforderungen der Modelle enthält.
In der folgenden Tabelle sind die Schlüssel-Wert-Paare zusammengefasst, die in der JSON-Ausgabe des Modellevaluierungsjobs gefunden wurden.
Die nachfolgenden Abschnitte enthalten detailliertere Informationen zu den einzelnen Schlüssel-Wert-Paaren.
****
| Parameter | Beispiel | Description |
| --- | --- | --- |
| `flowDefinitionArn` | arn:aws:sagemaker:us-west-2:111122223333:flow-definition/flow-definition-name | Der ARN des Workflows für die menschliche Überprüfung (Flow-Definition), der den Human Loop erstellt hat. |
| humanAnswers | Eine Liste von JSON-Objekten, die für die ausgewählten Bewertungsmetriken spezifisch sind. Weitere Informationen hierzu finden Sie unter [Schlüsselwertpaare finden Sie unter `humanAnswers`](#clarify-foundation-model-evaluate-humanAnswers). | Eine Liste von JSON-Objekten, die Antworten von Mitarbeitern enthalten. |
| `humanLoopName` | system-generated-hash | Eine systemseitig generierte Hexadezimalzeichenfolge mit 40 Zeichen. |
| inputRecord | "inputRecord": {
"prompt": {
"text": "Who invented the airplane?"
},
"category": "Airplanes",
"referenceResponse": {
"text": "Orville and Wilbur Wright"
},
"responses":
[{
"modelIdentifier": "meta-textgeneration-llama-codellama-7b",
"text": "The Wright brothers, Orville and Wilbur Wright are widely credited with inventing and manufacturing the world's first successful airplane."
}]
} | Ein JSON-Objekt, das eine Eingabeaufforderung aus dem Eingabedatensatz enthält. |
| modelResponses | "modelResponses": [{
"modelIdentifier": "arn:aws:bedrock:us-west-2::foundation-model/model-id",
"text": "the-models-response-to-the-prompt"
}] | Die einzelnen Antworten der Modelle. |
| inputContent | {
"additionalDataS3Uri":"s3://user-specified-S3-URI-path/datasets/dataset-name/records/record-number/human-loop-additional-data.json",
"evaluationMetrics":[
{
"description":"brief-name",
"metricName":"metric-name",
"metricType":"IndividualLikertScale"
}
],
"instructions":"example instructions"
} | Der Inhalt des Human-Loop-Eingangs, der zum Starten des Human-Loops in Ihrem Amazon-S3-Bucket erforderlich ist. |
| modelResponseIdMap | {
"0": "sm-margaret-meta-textgeneration-llama-2-7b-1711485008-0612",
"1": "jumpstart-dft-hf-llm-mistral-7b-ins-20240327-043352"
} | Beschreibt, wie jedes Modell in der dargestellt wird`answerContent`. |
### Schlüsselwertpaare finden Sie unter `humanEvaluationResult`
Die folgenden Schlüsselwertpaare wurden `humanEvaluationResult` in der Ausgabe Ihres Modellbewertungsjobs unter gefunden.
Informationen zu den Schlüssel-Wert-Paaren, die mit verknüpft sind`humanAnswers`, finden Sie unter[Schlüsselwertpaare finden Sie unter `humanAnswers`](#clarify-foundation-model-evaluate-humanAnswers).
**`flowDefinitionArn`**
+ Der ARN der Flow-Definition, die verwendet wurde, um den Modellevaluierungsjob abzuschließen.
+ *Beispiel:*`arn:aws:sagemaker:us-west-2:111122223333:flow-definition/flow-definition-name`
**`humanLoopName`**
+ Eine systemseitig generierte Hexadezimalzeichenfolge mit 40 Zeichen.
**`inputContent`**
+ Dieser Schlüsselwert beschreibt die *Metriktypen* und die Anweisungen, die Sie für Mitarbeiter im Mitarbeiterportal bereitgestellt haben.
+ `additionalDataS3Uri`: Der Ort in Amazon S3, an dem die Anweisungen für Mitarbeiter gespeichert werden.
+ `instructions`: Die Anweisungen, die Sie den Mitarbeitern im Worker-Portal zur Verfügung gestellt haben.
+ `evaluationMetrics`: Der Name der Metrik und ihre Beschreibung. Der entscheidende Wert `metricType` ist das Tool, das den Mitarbeitern zur Verfügung gestellt wird, um die Antworten der Modelle zu bewerten.
**`modelResponseIdMap`**
+ Dieses Schlüsselwertpaar gibt die vollständigen Namen der ausgewählten Modelle an und gibt an, wie die Auswahlmöglichkeiten der Mitarbeiter den Modellen in den `humanAnswers` Schlüsselwertpaaren zugeordnet werden.
### Schlüsselwertpaare finden Sie unter `inputRecord`
Die folgenden Einträge beschreiben die `inputRecord` Schlüssel-Wert-Paare.
**`prompt`**
+ Der Text der an das Modell gesendeten Aufforderung.
**`category`**
+ Eine optionale Kategorie, die die Aufforderung klassifiziert. Sichtbar für Mitarbeiter während der Modellevaluierung im Mitarbeiterportal.
+ *Beispiel:*`"American cities"`
**`referenceResponse`**
+ Ein optionales Feld aus dem Eingabe-JSON, das verwendet wird, um den Ground Truth anzugeben, auf den sich die Mitarbeiter bei der Bewertung beziehen sollen
**`responses`**
+ Ein optionales Feld aus dem Eingabe-JSON, das Antworten aus anderen Modellen enthält.
Ein Beispiel für einen JSON-Eingabedatensatz.
```
{
"prompt": {
"text": "Who invented the airplane?"
},
"category": "Airplanes",
"referenceResponse": {
"text": "Orville and Wilbur Wright"
},
"responses":
// The same modelIdentifier must be specified for all responses
[{
"modelIdentifier": "meta-textgeneration-llama-codellama-7b" ,
"text": "The Wright brothers, Orville and Wilbur Wright are widely credited with inventing and manufacturing the world's first successful airplane."
}]
}
```
### Schlüsselwertpaare finden Sie unter `modelResponses`
Ein Array von Schlüsselwertpaaren, das die Antworten der Modelle und das Modell, das die Antworten geliefert hat, enthält.
**`text`**
+ Die Reaktion des Modells auf die Aufforderung.
**`modelIdentifier`**
+ Der Name des Modells
### Schlüsselwertpaare finden Sie unter `humanAnswers`
Eine Reihe von Schlüsselwertpaaren, die die Antworten aus den Modellen und die Art und Weise, wie Mitarbeiter die Modelle bewertet haben, enthält.
**`acceptanceTime`**
+ Wenn der Mitarbeiter die Aufgabe im Workerportal angenommen hat.
**`submissionTime`**
+ Als der Arbeitnehmer seine Antwort eingereicht hat.
**`timeSpentInSeconds`**
+ Wie viel Zeit hat der Mitarbeiter mit der Erledigung der Aufgabe verbracht?
**`workerId`**
+ Die ID des Mitarbeiters, der die Aufgabe erledigt hat.
**`workerMetadata`**
+ Metadaten darüber, welchem Arbeitsteam dieser Modellevaluierungsaufgabe zugewiesen wurde.
#### Format des `answerContent` JSON-Arrays
Die Struktur der Antwort hängt von den Bewertungsmetriken ab, die bei der Erstellung des Model-Evaluierungsjobs ausgewählt wurden. Jede Antwort oder Antwort eines Mitarbeiters wird in einem neuen JSON-Objekt aufgezeichnet.
**`answerContent`**
+ `evaluationResults`enthält die Antworten des Arbeiters.
+ Wenn **die Auswahlschaltflächen** ausgewählt sind, lauten die Ergebnisse der einzelnen Mitarbeiter wie folgt`"evaluationResults": "comparisonChoice"`.
`metricName`: Name der Metrik.
`result`: Das JSON-Objekt gibt an, welches Modell der Worker mit einem `0` oder ausgewählt hat`1`. Um zu sehen, welchem Wert ein Modell zugeordnet ist,`modelResponseIdMap`.
+ Wenn die **Likert-Skala „Vergleich**“ ausgewählt ist, sind die Ergebnisse der einzelnen Mitarbeiter identisch. `"evaluationResults": "comparisonLikertScale"`
`metricName`: Name der Metrik.
`leftModelResponseId`: Gibt an, `modelResponseIdMap` was auf der linken Seite des Arbeiterportals angezeigt wurde.
`rightModelResponseId`: Gibt an, `modelResponseIdMap` was auf der linken Seite des Arbeiterportals angezeigt wurde.
`result`: Das JSON-Objekt gibt an, welches Modell der Worker mit einem `0` oder ausgewählt hat`1`. Um zu sehen, welchem Wert ein Modell zugeordnet ist, `modelResponseIdMap`
+ Wenn die Option **Ordinaler Rang** ausgewählt ist, sind die Ergebnisse für jeden Mitarbeiter gleich. `"evaluationResults": "comparisonRank"`
`metricName`: Name der Metrik.
`result`: Array von JSON-Objekten. Für jedes Modell (`modelResponseIdMap`) geben die Arbeiter eine `rank` an.
```
"result": [{
"modelResponseId": "0",
"rank": 1
}, {
"modelResponseId": "1",
"rank": 1
}]
```
+ Wenn bei der **Likert-Skala die Auswertung einer einzelnen Modellantwort** ausgewählt ist, werden die Ergebnisse gespeichert, in `"evaluationResults": "individualLikertScale"` denen ein Mitarbeiter arbeitet. Dies ist ein JSON-Array, das die Punktzahlen enthält, die bei der Erstellung des Jobs `metricName` angegeben wurden.
`metricName`: Name der Metrik.
`modelResponseId`: Das Modell, das bewertet wurde. Um zu sehen, welchem Wert ein Modell zugeordnet ist,`modelResponseIdMap`.
`result`: Ein Schlüsselwertpaar, das den vom Mitarbeiter ausgewählten Likert-Skalenwert angibt.
+ Wenn „**Daumen hoch/runter**“ ausgewählt ist, werden die Ergebnisse eines Workers als JSON-Array gespeichert. `"evaluationResults": "thumbsUpDown"`
`metricName`: Name der Metrik.
`result`: Entweder `true` oder `false` wie es sich auf die bezieht. `metricName` Wenn ein Arbeitnehmer Daumen hoch wählt,`"result" : true`.
## Beispielausgabe einer Jobausgabe zur Modellbewertung
Das folgende JSON-Objekt ist eine Beispielausgabe eines Auftrags zur Modellbewertung, die in Amazon S3 gespeichert wird. Weitere Informationen zu den einzelnen Schlüsselwertepaaren finden Sie unter[JSON-Ausgabereferenz](#clarify-foundation-model-evaluate-results-human-ref).
Aus Gründen der Übersichtlichkeit enthält dieser Job nur die Antworten von zwei Mitarbeitern. Einige Schlüsselwertpaare wurden aus Gründen der besseren Lesbarkeit möglicherweise auch gekürzt
```
{
"humanEvaluationResult": {
"flowDefinitionArn": "arn:aws:sagemaker:us-west-2:111122223333:flow-definition/flow-definition-name",
"humanAnswers": [
{
"acceptanceTime": "2024-06-07T22:31:57.066Z",
"answerContent": {
"evaluationResults": {
"comparisonChoice": [
{
"metricName": "Fluency",
"result": {
"modelResponseId": "0"
}
}
],
"comparisonLikertScale": [
{
"leftModelResponseId": "0",
"metricName": "Coherence",
"result": 1,
"rightModelResponseId": "1"
}
],
"comparisonRank": [
{
"metricName": "Toxicity",
"result": [
{
"modelResponseId": "0",
"rank": 1
},
{
"modelResponseId": "1",
"rank": 1
}
]
}
],
"individualLikertScale": [
{
"metricName": "Correctness",
"modelResponseId": "0",
"result": 2
},
{
"metricName": "Correctness",
"modelResponseId": "1",
"result": 3
},
{
"metricName": "Completeness",
"modelResponseId": "0",
"result": 1
},
{
"metricName": "Completeness",
"modelResponseId": "1",
"result": 4
}
],
"thumbsUpDown": [
{
"metricName": "Accuracy",
"modelResponseId": "0",
"result": true
},
{
"metricName": "Accuracy",
"modelResponseId": "1",
"result": true
}
]
}
},
"submissionTime": "2024-06-07T22:32:19.640Z",
"timeSpentInSeconds": 22.574,
"workerId": "ead1ba56c1278175",
"workerMetadata": {
"identityData": {
"identityProviderType": "Cognito",
"issuer": "https://cognito-idp.us-west-2.amazonaws.com/us-west-2_WxGLvNMy4",
"sub": "cd2848f5-6105-4f72-b44e-68f9cb79ba07"
}
}
},
{
"acceptanceTime": "2024-06-07T22:32:19.721Z",
"answerContent": {
"evaluationResults": {
"comparisonChoice": [
{
"metricName": "Fluency",
"result": {
"modelResponseId": "1"
}
}
],
"comparisonLikertScale": [
{
"leftModelResponseId": "0",
"metricName": "Coherence",
"result": 1,
"rightModelResponseId": "1"
}
],
"comparisonRank": [
{
"metricName": "Toxicity",
"result": [
{
"modelResponseId": "0",
"rank": 2
},
{
"modelResponseId": "1",
"rank": 1
}
]
}
],
"individualLikertScale": [
{
"metricName": "Correctness",
"modelResponseId": "0",
"result": 3
},
{
"metricName": "Correctness",
"modelResponseId": "1",
"result": 4
},
{
"metricName": "Completeness",
"modelResponseId": "0",
"result": 1
},
{
"metricName": "Completeness",
"modelResponseId": "1",
"result": 5
}
],
"thumbsUpDown": [
{
"metricName": "Accuracy",
"modelResponseId": "0",
"result": true
},
{
"metricName": "Accuracy",
"modelResponseId": "1",
"result": false
}
]
}
},
"submissionTime": "2024-06-07T22:32:57.918Z",
"timeSpentInSeconds": 38.197,
"workerId": "bad258db224c3db6",
"workerMetadata": {
"identityData": {
"identityProviderType": "Cognito",
"issuer": "https://cognito-idp.us-west-2.amazonaws.com/us-west-2_WxGLvNMy4",
"sub": "84d5194a-3eed-4ecc-926d-4b9e1b724094"
}
}
}
],
"humanLoopName": "a757 11d3e75a 8d41f35b9873d 253f5b7bce0256e",
"inputContent": {
"additionalDataS3Uri": "s3://mgrt-test-us-west-2/test-2-workers-2-model/datasets/custom_dataset/0/task-input-additional-data.json",
"instructions": "worker instructions provided by the model evaluation job administrator",
"evaluationMetrics": [
{
"metricName": "Fluency",
"metricType": "ComparisonChoice",
"description": "Measures the linguistic quality of a generated text."
},
{
"metricName": "Coherence",
"metricType": "ComparisonLikertScale",
"description": "Measures the organization and structure of a generated text."
},
{
"metricName": "Toxicity",
"metricType": "ComparisonRank",
"description": "Measures the harmfulness of a generated text."
},
{
"metricName": "Accuracy",
"metricType": "ThumbsUpDown",
"description": "Indicates the accuracy of a generated text."
},
{
"metricName": "Correctness",
"metricType": "IndividualLikertScale",
"description": "Measures a generated answer's satisfaction in the context of the question."
},
{
"metricName": "Completeness",
"metricType": "IndividualLikertScale",
"description": "Measures a generated answer's inclusion of all relevant information."
}
],
"disableRandomization": "true"
},
"modelResponseIdMap": {
"0": "sm-margaret-meta-textgeneration-llama-2-7b-1711485008-0612",
"1": "jumpstart-dft-hf-llm-mistral-7b-ins-20240327-043352"
}
},
"inputRecord": {
"prompt": {
"text": "What is high intensity interval training?"
},
"category": "Fitness",
"referenceResponse": {
"text": "High-Intensity Interval Training (HIIT)"
}
},
"modelResponses": [
{
"text": "High Intensity Interval Training (HIIT) is a form of exercise that alternates between periods of high intensity work and low intensity recovery.HIIT is an excellent way to increase your fitness and improve your health, but it can be difficult to get started.In this article, we will",
"modelIdentifier": "sm-margaret-meta-textgeneration-llama-2-7b-1711485008-0612"
},
{
"text": "High intensity interval training is a form of exercise consisting of short bursts of maximum effort followed by periods of rest. The theory behind HIIT is that it can often be more effective at improving cardiovascular and metabolic health than longer, lower intensity workouts.The work intervals can range in length depending on the specific type of exercise, but are typically between 20 and 90 seconds. The recovery periods are generally longer, lasting between 1 and 5 minutes. This pattern is then repeated for multiple sets.\n\nSince the work intervals are high intensity, they require more effort from your body and therefore result in a greater calorie burn. The body also continues to burn calories at an increased rate after the workout due to an effect called excess post exercise oxygen consumption (EPOC), also know as the afterburn effect.\n\nHIIT is a versatile form of training that can be adapted to different fitness levels and can be performed using a variety of exercises including cycling, running, bodyweight movements, and even swimming. It can be done in as little as 20 minutes once or twice a week, making it an efficient option for busy individuals.\n\nWhat are the benefits of high intensity interval training",
"modelIdentifier": "jumpstart-dft-hf-llm-mistral-7b-ins-20240327-043352"
}
]
}
```
# Machen Sie sich mit den Ergebnissen eines automatischen Bewertungsauftrags vertraut
Wenn Sie den Auftrag zur automatischen Modellbewertung abgeschlossen haben, werden die Ergebnisse in Amazon S3 gespeichert. In den folgenden Abschnitten werden die generierten Dateien und ihre Interpretation beschrieben.
## Interpretation der `output.json` Dateistruktur
Die `output.json` Datei enthält aggregierte Ergebnisse für Ihre ausgewählten Datensätze und Metriken.
Im Folgenden finden Sie eine Beispielausgabe.
```
{
"evaluations": [{
"evaluation_name": "factual_knowledge",
"dataset_name": "trex",
## The structure of the prompt template changes based on the foundation model selected
"prompt_template": "[INST] <>Answer the question at the end in as few words as possible. Do not repeat the question. Do not answer in complete sentences.< Question: $feature [/INST]",
"dataset_scores": [{
"name": "factual_knowledge",
"value": 0.2966666666666667
}],
"category_scores": [{
"name": "Author",
"scores": [{
"name": "factual_knowledge",
"value": 0.4117647058823529
}]
},
....
{
"name": "Capitals",
"scores": [{
"name": "factual_knowledge",
"value": 0.2857142857142857
}]
}
]
}]
}
```
## Interpretation der Struktur der Instance-bezogenen Ergebnisdatei
Eine *evaluation\$1name* \$1 *dataset\$1name* .jsonl-Datei mit instanzbezogenen Ergebnissen für jede Jsonlines-Anfrage. Wenn Ihre Jsonlines-Eingabedaten `300` Anfragen enthielten, enthält diese Jsonlines-Ausgabedatei Antworten. `300` Die Ausgabedatei enthält die Anfrage an Ihr Modell, gefolgt von der Punktzahl für diese Bewertung. Es folgt ein Beispiel für eine Instance-weite Ausgabe.
## Interpretieren des Berichts
Ein **Bewertungsbericht** enthält die Ergebnisse Ihrer Bewertungsaufgabe für das Stiftungsmodell. Der Inhalt des Bewertungsberichts hängt von der Art der Aufgabe ab, mit der Sie Ihr Modell bewertet haben. Jeder Bericht enthält die folgenden Abschnitte:
1. Die **Gesamtpunktzahl** für jede erfolgreiche Bewertung im Rahmen der Bewertungsaufgabe. Als Beispiel für eine Bewertung mit einem Datensatz: Wenn Sie Ihr Modell für eine Klassifikationsaufgabe auf Genauigkeit und semantische Robustheit bewertet haben, wird oben in Ihrem Bericht eine Tabelle mit einer Zusammenfassung der Bewertungsergebnisse für Genauigkeit und Genauigkeit (Semantische Robustheit) angezeigt. Andere Auswertungen mit anderen Datensätzen können anders strukturiert sein.
1. Die Konfiguration für Ihren Bewertungsjob, einschließlich Modellname, Typ, welcher Bewertungsmethoden verwendet wurden und anhand welcher Datensätze Ihr Modell bewertet wurde.
1. Ein Abschnitt mit **detaillierten Evaluationsergebnissen**, in dem der Bewertungsalgorithmus zusammengefasst wird, Informationen und Links zu allen integrierten Datensätzen, zur Berechnung von Punktzahlen sowie Tabellen mit einigen Beispieldaten und den zugehörigen Ergebnissen bereitgestellt werden.
1. Ein Abschnitt „**Fehlgeschlagene Evaluierungen**“, der eine Liste der Bewertungen enthält, die nicht abgeschlossen wurden. Wenn keine Evaluierungen fehlschlugen, wird dieser Abschnitt des Berichts weggelassen.
# Passen Sie Ihren Arbeitsablauf mithilfe der `fmeval` Bibliothek an
Sie können Ihre Modellevaluierung so anpassen, dass sie ein Modell berücksichtigt, das kein Amazon Bedrock-Modell ist, oder einen benutzerdefinierten Workflow für die Bewertung verwenden. JumpStart Wenn Sie Ihr eigenes Modell verwenden, müssen Sie ein benutzerdefiniertes Modell erstellen. `ModelRunner` Wenn Sie Ihren eigenen Datensatz für die Auswertung verwenden, müssen Sie ein `DataConfig` Objekt konfigurieren. Im folgenden Abschnitt wird gezeigt, wie Sie Ihren Eingabedatensatz formatieren, ein `DataConfig` Objekt so anpassen, dass er Ihren benutzerdefinierten Datensatz verwendet, und einen benutzerdefinierten Datensatz erstellen`ModelRunner`.
## Verwenden Sie einen benutzerdefinierten Eingabedatensatz
Wenn Sie Ihren eigenen Datensatz verwenden möchten, um Ihr Modell auszuwerten, müssen Sie ein `DataConfig` Objekt verwenden, um das `dataset_name` und das `dataset_uri` des Datensatzes anzugeben, den Sie auswerten möchten. Wenn Sie einen integrierten Datensatz verwenden, ist das `DataConfig` Objekt bereits als Standard für Bewertungsalgorithmen konfiguriert.
Sie können jedes Mal, wenn Sie die `evaluate` Funktion verwenden, einen benutzerdefinierten Datensatz verwenden. Sie können `evaluate` beliebig oft aufrufen, um eine beliebige Anzahl von Datensätzen zu verwenden.
Konfigurieren Sie einen benutzerdefinierten Datensatz mit Ihrer Modellanforderung, die in der Fragenspalte angegeben ist, und der Zielantwort, die in der Spaltenantwort angegeben ist, wie folgt:
```
from fmeval.data_loaders.data_config import DataConfig
from fmeval.constants import MIME_TYPE_JSONLINES
config = DataConfig(
dataset_name="tiny_dataset",
dataset_uri="tiny_dataset.jsonl",
dataset_mime_type=MIME_TYPE_JSONLINES,
model_input_location="question",
target_output_location="answer",
)
```
Die `DataConfig`-Klasse enthält die folgenden Parameter:
+ `dataset_name` – Der Name des Datensatzes, den Sie zur Bewertung Ihres LLM verwenden möchten.
`dataset_uri` – Der lokale Pfad oder der Uniform Resource Identifier (URI) zum S3-Speicherort Ihres Datensatzes.
+ `dataset_mime_type` – Das Profil, das Sie für die Bewertung Ihres LLM verwenden möchten. Die FMEval Bibliothek kann sowohl als auch `MIME_TYPE_JSON` unterstützen. `MIME_TYPE_JSONLINES`
+ `model_input_location` – (Optional) Der Name der Spalte in Ihrem Datensatz, die die Modelleingaben oder Eingabeaufforderungen enthält, die Sie auswerten möchten.
Verwenden Sie eine`model_input_location`, die den Namen Ihrer Spalte angibt. Die Spalte muss die folgenden Werte enthalten, die den folgenden zugehörigen Aufgaben entsprechen:
+ Geben Sie **für Generierungs** -, **Toxizitäts** - und **Genauigkeitsbeurteilungen** die Spalte an, die die **Aufforderung** enthält, auf die Ihr Modell reagieren soll.
+ Geben Sie für eine Aufgabe zur **Beantwortung von Fragen** die Spalte an, die die **Frage** enthält, auf die Ihr Modell eine Antwort generieren soll.
+ Geben Sie für eine **Aufgabe zur Textzusammenfassung** den Namen der Spalte an, die den **Text** enthält, den Ihr Modell zusammenfassen soll.
+ Geben Sie für eine **Klassifizierungsaufgabe** den Namen der Spalte an, die den **Text** enthält, den Ihr Modell klassifizieren soll.
+ Geben Sie für Bewertungen von **Faktenwissen** den Namen der Spalte an, die die **Frage** enthält, auf die das Modell die Antwort vorhersagen soll.
+ Geben Sie für Bewertungen der **semantischen Robustheit** den Namen der Spalte an, die die **Eingabe** enthält, die Ihr Modell stören soll.
+ Verwenden **Sie für schnelle Stereotypauswertungen** das `sent_more_input_location` und ` sent_less_input_location` anstelle von`model_input_location`, wie in den folgenden Parametern gezeigt.
+ `model_output_location` – (Optional) Der Name der Spalte in Ihrem Datensatz, die die prognostizierte Ausgabe enthält, die Sie mit der Referenzausgabe vergleichen möchten, die in enthalten ist. `target_output_location` Wenn Sie angeben`model_output_location`, FMEval wird keine Anfrage an Ihr Modell gesendet, um Rückschlüsse zu ziehen. Stattdessen verwendet es die in der angegebenen Spalte enthaltene Ausgabe, um Ihr Modell auszuwerten.
+ `target_output_location` – Der Name der Spalte im Referenzdatensatz, die den wahren Wert enthält, der mit dem vorhergesagten Wert verglichen werden soll, der in enthalten ist`model_output_location`. Nur für Faktenwissen, Genauigkeit und semantische Robustheit erforderlich. Für Faktenwissen sollte jede Zeile in dieser Spalte alle möglichen Antworten enthalten, die durch ein Trennzeichen getrennt sind. Lauten die Antworten auf eine Frage beispielsweise [„UK“, „England“], dann sollte die Spalte „UK England“ enthalten. Die Modellvorhersage ist korrekt, wenn sie eine der Antworten enthält, die durch das Trennzeichen getrennt sind.
+ `category_location` – Der Name der Spalte, in der der Name einer Kategorie gespeichert ist. Wenn Sie einen Wert für angeben`category_location`, werden die Ergebnisse aggregiert und für jede Kategorie gemeldet.
+ `sent_more_input_location` – Der Name der Spalte, in der eine Prompt mit mehr Voreingenommenheit gespeichert ist. Nur für die Stereotypisierung von Aufforderungen erforderlich. Vermeiden Sie unbewusste Vorurteile. Beispiele für Verzerrungen finden Sie im Datensatz [Crows-pairs](https://paperswithcode.com/dataset/crows-pairs).
+ `sent_less_input_location` – Der Name der Spalte, in der eine weniger voreingenommene Aufforderung gespeichert ist. Nur für die Stereotypisierung von Aufforderungen erforderlich. Vermeiden Sie unbewusste Vorurteile. Beispiele für Verzerrungen finden Sie im Datensatz [Crows-pairs](https://paperswithcode.com/dataset/crows-pairs).
+ `sent_more_output_location` – (Optional) Der Name der Spalte, die die prognostizierte Wahrscheinlichkeit enthält, dass die von Ihrem Modell generierte Antwortvariable mehr systematische Abweichungen enthält. Dieser Parameter wird nur bei Aufgaben zur Stereotypisierung von Eingabeaufforderungen verwendet.
+ `sent_less_output_location` – (Optional) Der Name der Spalte, die die prognostizierte Wahrscheinlichkeit enthält, dass die von Ihrem Modell generierte Antwortvariable weniger systematische Messabweichung enthält. Dieser Parameter wird nur bei Aufgaben zur Stereotypisierung von Eingabeaufforderungen verwendet.
Wenn Sie der `DataConfig` Klasse ein neues Attribut hinzufügen möchten, das einer Datensatzspalte entspricht, müssen Sie das `suffix _location` am Ende des Attributnamens hinzufügen.
## Verwenden Sie ein benutzerdefiniertes `ModelRunner`
Um ein benutzerdefiniertes Modell auszuwerten, verwenden Sie eine Basisdatenklasse, um Ihr Modell zu konfigurieren und ein benutzerdefiniertes Modell zu erstellen`ModelRunner`. Anschließend können Sie `ModelRunner` damit jedes beliebige Sprachmodell evaluieren. Verwenden Sie die folgenden Schritte, um eine Modellkonfiguration zu definieren, eine benutzerdefinierte `ModelRunner` zu erstellen und sie zu testen.
Die `ModelRunner` Schnittstelle hat eine abstrakte Methode wie folgt:
```
def predict(self, prompt: str) → Tuple[Optional[str], Optional[float]]
```
Diese Methode akzeptiert eine Eingabeaufforderung als Zeichenketteneingabe und gibt ein Tuple zurück, das eine Modelltextantwort und eine Eingabe-Log-Wahrscheinlichkeit enthält. Jeder `ModelRunner` muss eine `predict` Methode implementieren.
**Erstellen Sie ein benutzerdefiniertes `ModelRunner`**
1. Definieren Sie eine Modellkonfiguration.
Das folgende Codebeispiel zeigt, wie Sie einen `dataclass` Decorator auf eine benutzerdefinierte `HFModelConfig` Klasse anwenden, sodass Sie eine Modellkonfiguration für ein **Hugging Face**Modell definieren können:
```
from dataclasses import dataclass
@dataclass
class HFModelConfig:
model_name: str
max_new_tokens: int
seed: int = 0
remove_prompt_from_generated_text: bool = True
```
Im vorherigen Codebeispiel gilt Folgendes:
+ Der Parameter `max_new_tokens` wird verwendet, um die Länge der Antwort zu begrenzen, indem die Anzahl der von einem LLM zurückgegebenen Token begrenzt wird. Der Modelltyp wird festgelegt, indem bei der Instanziierung der Klasse ein Wert für `model_name` übergeben wird. In diesem Beispiel ist der Modellname auf gesetzt`gpt2`, wie am Ende dieses Abschnitts gezeigt. Der Parameter `max_new_tokens` ist eine Option zur Konfiguration von Textgenerierungsstrategien mithilfe einer `gpt2` Modellkonfiguration für ein vortrainiertes OpenAI-GPT-Modell. [AutoConfig](https://huggingface.co/transformers/v3.5.1/model_doc/auto.html)Weitere Modelltypen finden Sie unter.
+ Wenn der Parameter auf gesetzt `remove_prompt_from_generated_text` ist`True`, enthält die generierte Antwort nicht die ursprüngliche Aufforderung, die in der Anfrage gesendet wurde.
Weitere Parameter für die Textgenerierung finden Sie in der [Hugging FaceDokumentation für GenerationConfig](https://huggingface.co/docs/transformers/v4.34.1/en/main_classes/text_generation#transformers.GenerationConfig).
1. Erstellen Sie eine benutzerdefinierte Methode `ModelRunner` und implementieren Sie eine Vorhersagemethode. Das folgende Codebeispiel zeigt, wie Sie mithilfe der im vorherigen Codebeispiel erstellten `HFModelConfig` Klasse einen benutzerdefinierten Code `ModelRunner` für ein Hugging Face Modell erstellen.
```
from typing import Tuple, Optional
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from fmeval.model_runners.model_runner import ModelRunner
class HuggingFaceCausalLLMModelRunner(ModelRunner):
def __init__(self, model_config: HFModelConfig):
self.config = model_config
self.model = AutoModelForCausalLM.from_pretrained(self.config.model_name)
self.tokenizer = AutoTokenizer.from_pretrained(self.config.model_name)
def predict(self, prompt: str) -> Tuple[Optional[str], Optional[float]]:
input_ids = self.tokenizer(prompt, return_tensors="pt").to(self.model.device)
generations = self.model.generate(
**input_ids,
max_new_tokens=self.config.max_new_tokens,
pad_token_id=self.tokenizer.eos_token_id,
)
generation_contains_input = (
input_ids["input_ids"][0] == generations[0][: input_ids["input_ids"].shape[1]]
).all()
if self.config.remove_prompt_from_generated_text and not generation_contains_input:
warnings.warn(
"Your model does not return the prompt as part of its generations. "
"`remove_prompt_from_generated_text` does nothing."
)
if self.config.remove_prompt_from_generated_text and generation_contains_input:
output = self.tokenizer.batch_decode(generations[:, input_ids["input_ids"].shape[1] :])[0]
else:
output = self.tokenizer.batch_decode(generations, skip_special_tokens=True)[0]
with torch.inference_mode():
input_ids = self.tokenizer(self.tokenizer.bos_token + prompt, return_tensors="pt")["input_ids"]
model_output = self.model(input_ids, labels=input_ids)
probability = -model_output[0].item()
return output, probability
```
Der vorherige Code verwendet eine benutzerdefinierte `HuggingFaceCausalLLMModelRunner` Klasse, die Eigenschaften von der FMEval `ModelRunner` Klasse erbt. Die benutzerdefinierte Klasse enthält einen Konstruktor und eine Definition für eine Vorhersagefunktion, die a zurückgibt. `Tuple`
Weitere `ModelRunner` Beispiele finden Sie im Abschnitt [model\$1runner](https://github.com/aws/fmeval/tree/main/src/fmeval/model_runners) der Bibliothek. `fmeval`
Der `HuggingFaceCausalLLMModelRunner` Konstruktor enthält die folgenden Definitionen:
+ Die Konfiguration ist auf eingestellt`HFModelConfig`, wie am Anfang dieses Abschnitts definiert.
+ Das Modell wird auf ein vortrainiertes Modell aus der Hugging Face[Auto-Klasse](https://huggingface.co/transformers/v3.5.1/model_doc/auto.html) gesetzt, das bei der Instanziierung mit dem Parameter model\$1name angegeben wird.
+ Der Tokenizer ist auf eine Klasse aus der Tokenizer-Bibliothek festgelegt, die dem von angegebenen [Hugging Facevortrainierten Modell entspricht](https://huggingface.co/docs/transformers/model_doc/auto#transformers.AutoTokenizer). `model_name`
Die Methode `predict` in der Klasse `HuggingFaceCausalLLMModelRunner` verwendet die folgenden Definitionen:
+ `input_ids` – Eine Variable, die Eingaben für Ihr Modell enthält. Das Modell generiert die Eingabe wie folgt.
+ A `tokenizer` Konvertiert die in enthaltene Anfrage `prompt` in Token-Identifikatoren ()IDs. Diese Token IDs, bei denen es sich um numerische Werte handelt, die ein bestimmtes Token (Wort, Unterwort oder Zeichen) darstellen, können direkt von Ihrem Modell als Eingabe verwendet werden. Das Token IDs wird als PyTorch Tensor-Objekt zurückgegeben, wie von angegeben. `return_tensors="pt"` [Weitere Arten von Rückgabe-Tensortypen finden Sie in der Hugging Face Dokumentation zu apply\$1chat\$1template.](https://huggingface.co/docs/transformers/main_classes/tokenizer#transformers.PreTrainedTokenizer.apply_chat_template)
+ Token IDs werden an ein Gerät gesendet, auf dem sich das Modell befindet, sodass sie vom Modell verwendet werden können.
+ `generations` – Eine Variable, die die von Ihrem LLM generierte Antwort enthält. Die Generierungsfunktion des Modells verwendet die folgenden Eingaben, um die Antwort zu generieren:
+ Das `input_ids` aus dem vorherigen Schritt.
+ Der in `max_new_tokens` angegebene Parameter`HFModelConfig`.
+ A `pad_token_id` fügt der Antwort ein Satzende-Token (EOS) hinzu. Weitere Token, die Sie verwenden können, finden Sie in der Hugging Face Dokumentation zu [PreTrainedTokenizer](https://huggingface.co/docs/transformers/main_classes/tokenizer#transformers.PreTrainedTokenizer).
+ `generation_contains_input` – Eine boolesche Variable, die zurückkehrt, `True` wenn die generierte Antwort die Eingabeaufforderung in ihrer Antwort enthält, und andernfalls. `False` Der Rückgabewert wird anhand eines elementweisen Vergleichs der folgenden Werte berechnet.
+ Alle Token IDs in der Eingabeaufforderung, die in enthalten sind`input_ids["input_ids"][0]`.
+ Der Anfang des generierten Inhalts, der in enthalten ist`generations[0][: input_ids["input_ids"].shape[1]]`.
Die `predict` Methode gibt eine Warnung zurück, wenn Sie das LLM `remove_prompt_from_generated_text` in Ihrer Konfiguration darauf hingewiesen haben, die generierte Antwort jedoch nicht die Eingabeaufforderung enthält.
Die Ausgabe der `predict` Methode enthält eine von der Methode zurückgegebene Zeichenfolge, die das `batch_decode` in der Antwort IDs zurückgegebene Token in für Menschen lesbaren Text umwandelt. Wenn Sie `remove_prompt_from_generated_text` als angegeben haben`True`, wird die Eingabeaufforderung aus dem generierten Text entfernt. Wenn Sie `remove_prompt_from_generated_text` als angegeben haben`False`, wird der generierte Text ohne spezielle Tokens zurückgegeben, die Sie in das Wörterbuch aufgenommen haben`special_token_dict`, wie von angegeben`skip_special_tokens=True`.
1. Testen Sie Ihre`ModelRunner`. Senden Sie eine Musteranfrage an Ihr Modell.
Das folgende Beispiel zeigt, wie man ein Modell mit Hilfe des `gpt2` vortrainierten Modells aus der Hugging Face `AutoConfig` Klasse testet:
```
hf_config = HFModelConfig(model_name="gpt2", max_new_tokens=32)
model = HuggingFaceCausalLLMModelRunner(model_config=hf_config)
```
`model_name`Gibt im vorherigen Codebeispiel den Namen des vortrainierten Modells an. Die `HFModelConfig`-Klasse wird als hf\$1config mit einem Wert für den `max_new_tokens`-Parameter instanziiert und zur Initialisierung von `ModelRunner` verwendet.
Wenn Sie ein anderes vortrainiertes Modell von verwenden möchtenHugging Face, wählen Sie `pretrained_model_name_or_path` `from_pretrained` unter [AutoClass](https://huggingface.co/transformers/v3.5.1/model_doc/auto.html)ein.
Testen Sie abschließend Ihre. `ModelRunner` Senden Sie eine Musteranforderung an Ihr Modell wie im folgenden Beispielcode gezeigt zu umschließen:
```
model_output = model.predict("London is the capital of?")[0]
print(model_output)
eval_algo.evaluate_sample()
```
# Notebook-Tutorials zur Modellbewertung
Dieser Abschnitt enthält die folgenden Notebook-Tutorials, die Beispielcode und Erklärungen enthalten:
+ Wie bewertet man ein JumpStart Modell auf schnelle Stereotypisierung?
+ So bewerten Sie ein Amazon Bedrock-Modell auf die Genauigkeit der Textzusammenfassung.
**Topics**
+ [Evaluieren Sie ein JumpStart Modell für die schnelle Stereotypisierung](clarify-foundation-model-evaluate-auto-tutorial-one.md)
+ [Evaluieren Sie ein Amazon Bedrock-Modell auf Genauigkeit bei der Textzusammenfassung](clarify-foundation-model-evaluate-auto-tutorial-two.md)
+ [Zusätzliche Notebooks](#clarify-foundation-model-evaluate-auto-tutorial-ex)
# Evaluieren Sie ein JumpStart Modell für die schnelle Stereotypisierung
Sie können einen `ModelRunner` Wrapper auf hoher Ebene verwenden, um ein SageMaker JumpStart Amazon-Modell auf schnelle Stereotypisierung hin zu evaluieren. Der Algorithmus für die Eingabeaufforderung zur Stereotypisierung misst die Wahrscheinlichkeit, dass Ihr Modell bei seiner Reaktion Verzerrungen kodiert. Zu diesen Vorurteilen gehören Vorurteile in Bezug auf Rasse, Geschlecht, sexuelle Orientierung, Religion, Alter, Nationalität, Behinderung, körperliches Erscheinungsbild und sozioökonomischen Status.
Dieses Tutorial zeigt, wie Sie das [Falcon 7-B-Modell](https://huggingface.co/tiiuae/falcon-7b) vom [Technology Innovation Institute](https://www.tii.ae/) (verfügbar unter) laden und dieses Modell bitten, Antworten auf JumpStart Eingabeaufforderungen zu generieren. [Anschließend wird in diesem Tutorial gezeigt, wie die Antworten auf die Stereotypisierung von Eingabeaufforderungen anhand des integrierten Open-Source-Challenge-Datensatzes von Crows-Pairs bewertet werden.](https://github.com/nyu-mll/crows-pairs)
Die Abschnitte dieses Tutorials zeigen Ihnen, wie Sie Folgendes tun können:
+ Einrichten Ihrer Umgebung
+ Führen Sie Ihre Modellevaluierung durch.
+ Zeigen Sie Ihre Analyseergebnisse an.
## So richten Sie Ihre Umgebung ein
**Voraussetzungen**
+ Verwenden Sie eine Basis-Kernelumgebung Python 3.10 und eine `ml.g4dn.2xlarge` Amazon Elastic Compute Cloud (Amazon EC2) -Instance, bevor Sie dieses Tutorial starten.
Weitere Informationen zu Instance-Typen und zu ihren empfohlenen Anwendungsfällen finden Sie unter[Instance-Typen, die für die Verwendung mit Amazon SageMaker Studio Classic-Notebooks verfügbar sind](notebooks-available-instance-types.md).
**Installieren erforderlicher Bibliotheken**
1. Installieren Sie die SageMaker KI und andere erforderliche Bibliotheken wie folgt in Ihrem Code: `fmeval`
```
!pip3 install sagemaker
!pip3 install -U pyarrow
!pip3 install -U accelerate
!pip3 install "ipywidgets>=8"
!pip3 install jsonlines
!pip install fmeval
!pip3 install boto3==1.28.65
import sagemaker
```
1. Laden Sie den `JSON Lines` Beispieldatensatz [crows-pairs\$1sample.jsonl](https://github.com/aws/fmeval/blob/main/examples/crows-pairs_sample.jsonl) in Ihr aktuelles Arbeitsverzeichnis herunter.
1. Überprüfen Sie mithilfe des folgenden Codes, ob Ihre Umgebung die Beispiel-Eingabedatei enthält:
```
import glob
# Check for fmeval wheel and built-in dataset
if not glob.glob("crows-pairs_sample.jsonl"):
print("ERROR - please make sure file exists: crows-pairs_sample.jsonl")
```
1. Definieren Sie ein JumpStart Modell wie folgt:
```
from sagemaker.jumpstart.model import JumpStartModel
model_id, model_version, = (
"huggingface-llm-falcon-7b-instruct-bf16",
"*",
)
```
1. Stellen Sie das JumpStart Modell bereit und erstellen Sie einen Endpunkt wie folgt:
```
my_model = JumpStartModel(model_id=model_id)
predictor = my_model.deploy()
endpoint_name = predictor.endpoint_name
```
1. Definieren Sie eine Eingabeaufforderung und das Format der Modellanforderung oder Payload wie folgt:
```
prompt = "London is the capital of"
payload = {
"inputs": prompt,
"parameters": {
"do_sample": True,
"top_p": 0.9,
"temperature": 0.8,
"max_new_tokens": 1024,
"decoder_input_details" : True,
"details" : True
},
}
```
Im vorherigen Codebeispiel sind die folgenden Parameter in der Modellanforderung enthalten:
+ `do_sample` – Weist das Modell an, während der Modellinferenz Stichproben aus den Rohdaten des Modells (vor der Normalisierung) zu ziehen, um den Modellantworten Vielfalt und Kreativität zu verleihen. Standardeinstellung: `False`. Wenn Sie `do_sample` auf einstellen`True`, müssen Sie einen Wert für einen der folgenden Parameter angeben:`temperature`,`top_k`, `top_p` oder. `typical_p`
+ `top_p` – Steuert die Zufälligkeit, indem der Satz von Tokens begrenzt wird, der bei der Generierung des nächsten Tokens berücksichtigt werden soll. Höhere Werte von `top_p` ermöglichen einen Satz, der ein breiteres Vokabular enthält. Niedrigere Werte beschränken den Tokensatz auf Wörter mit höherer Wahrscheinlichkeit. Die Bereiche für `top_p` sind größer als `0` und kleiner als`1`.
+ `temperature` – Steuert die Zufälligkeit des generierten Textes. 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. Werte für `temperature` müssen positiv sein.
+ `max_new_tokens` – Beschränkt die Länge der Antwort, indem die Anzahl der von Ihrem Modell zurückgegebenen Token begrenzt wird. Standardeinstellung: `20`.
+ `decoder_input_details`— Gibt Informationen über die Log-Wahrscheinlichkeiten zurück, die das Modell jedem potenziellen nächsten Token und dem entsprechenden Token IDs zugewiesen hat. Wenn auf gesetzt `decoder_input_details` ist`True`, müssen Sie auch `details` auf setzen, `True` um die angeforderten Details zu erhalten. Standardeinstellung: `False`.
Weitere Informationen zu Parametern für dieses `Hugging Face` Modell finden Sie unter [types.py](https://github.com/huggingface/text-generation-inference/blob/v0.9.3/clients/python/text_generation/types.py#L8).
## Senden Sie eine Beispiel-Inferenzanfrage
Um Ihr Modell zu testen, senden Sie eine Musteranfrage an Ihr Modell und drucken Sie die Modellantwort wie folgt aus:
```
response = predictor.predict(payload)
print(response[0]["generated_text"])
```
Wenn Ihr Modell im vorherigen Codebeispiel die Antwort geliefert hat`[{"response": "this is the output"}]`, wird die `print` Anweisung zurückgegeben`this is the output`.
## Richten Sie ein FMEval
1. Laden Sie die erforderlichen Bibliotheken für die Ausführung FMEval wie folgt:
```
import fmeval
from fmeval.data_loaders.data_config import DataConfig
from fmeval.model_runners.sm_jumpstart_model_runner import JumpStartModelRunner
from fmeval.constants import MIME_TYPE_JSONLINES
from fmeval.eval_algorithms.prompt_stereotyping import PromptStereotyping, PROMPT_STEREOTYPING
from fmeval.eval_algorithms import EvalAlgorithm
```
1. Richten Sie die Datenkonfiguration für Ihren Eingabedatensatz ein.
Wenn Sie kein integriertes Dataset verwenden, muss Ihre Datenkonfiguration die Spalte identifizieren, in der die meisten Verzerrungen enthalten sind`sent_more_input_location`. Sie müssen auch die Spalte identifizieren, die weniger systematische Verzerrung enthält`sent_less_input_location`. Wenn Sie einen integrierten Datensatz von verwenden JumpStart, werden diese Parameter FMEval automatisch über die Modellmetadaten übergeben.
Geben Sie die `sent_less_input_location` Spalten `sent_more_input_location` und für eine Aufgabe zur Stereotypisierung von Eingabeaufforderungen, den Namen, den URI (Uniform Resource Identifier) und den Typ an. `MIME`
```
config = DataConfig(
dataset_name="crows-pairs_sample",
dataset_uri="crows-pairs_sample.jsonl",
dataset_mime_type=MIME_TYPE_JSONLINES,
sent_more_input_location="sent_more",
sent_less_input_location="sent_less",
category_location="bias_type",
)
```
Weitere Informationen zu Spalteninformationen, die für andere Aufgaben erforderlich sind, finden Sie im Abschnitt **Verwenden eines benutzerdefinierten Eingabedatensatzes** unter [Verwenden Sie einen benutzerdefinierten Eingabedatensatz](clarify-foundation-model-evaluate-auto-lib-custom.md#clarify-foundation-model-evaluate-auto-lib-custom-input).
1. Richten Sie einen benutzerdefinierten `ModelRunner` ein, wie im folgenden Codebeispiel gezeigt:
```
js_model_runner = JumpStartModelRunner(
endpoint_name=endpoint_name,
model_id=model_id,
model_version=model_version,
output='[0].generated_text',
log_probability='[0].details.prefill[*].logprob',
content_template='{"inputs": $prompt, "parameters":
{"do_sample": true, "top_p": 0.9, "temperature": 0.8, "max_new_tokens": 1024,
"decoder_input_details": true,"details": true}}',
)
```
Das vorherige Codebeispiel spezifiziert Folgendes:
+ `endpoint_name` – Der Name des Endpunkts, den Sie im vorherigen Schritt **Erforderliche Bibliotheken installieren** erstellt haben.
+ `model_id` – Die ID, die zur Angabe Ihres Modells verwendet wurde. Dieser Parameter wurde bei der Definition des JumpStart Modells angegeben.
+ `model_version` – Die Version Ihres Modells, mit der Ihr Modell spezifiziert wurde. Dieser Parameter wurde bei der Definition des JumpStart Modells angegeben.
+ `output` – Erfasst die Ausgabe des [Falcon 7b-Modells](https://huggingface.co/tiiuae/falcon-7b), das seine Antwort in einem Schlüssel zurückgibt. `generated_text` Wenn Ihr Modell die Antwort geliefert hat`[{"generated_text": "this is the output"}]`, kehrt `[0].generated_text` es zurück. `this is the output`
+ `log_probability`— Erfasst die von diesem JumpStart Modell zurückgegebene logarithmische Wahrscheinlichkeit.
+ `content_template` – Gibt an, wie Ihr Modell mit Anfragen interagiert. Die Beispielkonfigurationsvorlage dient lediglich der Erläuterung des vorherigen Beispiels und ist nicht erforderlich. Die Parameter in der Inhaltsvorlage sind dieselben, für die deklariert wurden`payload`. Weitere Informationen zu Parametern für dieses `Hugging Face` Modell finden Sie unter [types.py](https://github.com/huggingface/text-generation-inference/blob/v0.9.3/clients/python/text_generation/types.py#L8).
1. Konfigurieren Sie Ihren Bewertungsbericht und speichern Sie ihn in einem Verzeichnis, wie im folgenden Beispielcode gezeigt:
```
import os
eval_dir = "results-eval-prompt-stereotyping"
curr_dir = os.getcwd()
eval_results_path = os.path.join(curr_dir, eval_dir) + "/"
os.environ["EVAL_RESULTS_PATH"] = eval_results_path
if os.path.exists(eval_results_path):
print(f"Directory '{eval_results_path}' exists.")
else:
os.mkdir(eval_results_path)
```
1. Richten Sie einen Parallelisierungsfaktor wie folgt ein:
```
os.environ["PARALLELIZATION_FACTOR"] = "1"
```
A `PARALLELIZATION_FACTOR` ist ein Multiplikator für die Anzahl der gleichzeitigen Batches, die an Ihre Compute-Instance gesendet werden. Wenn Ihre Hardware Parallelisierung zulässt, können Sie diese Zahl so einstellen, dass die Anzahl der Aufrufe für Ihren Evaluierungsjob multipliziert wird. Wenn Sie beispielsweise `100` Aufrufe haben und diese Option auf eingestellt `PARALLELIZATION_FACTOR` ist, führt Ihr Job Aufrufe aus. `2` `200` Sie können die Variable `PARALLELIZATION_FACTOR` auf einen Wert erhöhen oder sie `10` ganz entfernen. Einen Blog zur Verwendung von AWS Lambda finden Sie `PARALLELIZATION_FACTOR` unter [Neue AWS Lambda-Skalierungssteuerungen für Kinesis- und DynamoDB-Ereignisquellen](https://aws.amazon.com/blogs/compute/new-aws-lambda-scaling-controls-for-kinesis-and-dynamodb-event-sources/).
## Führen Sie Ihre Modellbewertung durch
1. Definieren Sie Ihren Bewertungsalgorithmus. Das folgende Beispiel zeigt, wie Sie einen `PromptStereotyping`-Algorithmus definieren.
```
eval_algo = PromptStereotyping()
```
Beispiele für Algorithmen, die Metriken für andere Bewertungsaufgaben berechnen, finden Sie unter **Evaluieren Sie Ihr Modell** in [Verwenden Sie die `fmeval` Bibliothek, um eine automatische Bewertung durchzuführen](clarify-foundation-model-evaluate-auto-lib.md).
1. Führen Sie Ihren Bewertungsalgorithmus aus. Das folgende Codebeispiel verwendet das Modell und die Datenkonfiguration, die zuvor definiert wurden, und eine`prompt_template`, mit der Ihre Eingabeaufforderung wie folgt an das Modell übergeben wird: `feature`
```
eval_output = eval_algo.evaluate(model=js_model_runner, dataset_config=config,
prompt_template="$feature", save=True)
```
Ihre Modellausgabe kann sich von der vorherigen Beispielausgabe unterscheiden.
## Zeigen Sie Ihre Analyseergebnisse an
1. Analysieren Sie einen Bewertungsbericht anhand des vom Bewertungsalgorithmus zurückgegebenen `eval_output` Objekts wie folgt:
```
import json
print(json.dumps(eval_output, default=vars, indent=4))
```
Der vorherige Befehl gibt die folgende Ausgabe zurück (aus Platzgründen gekürzt):
```
[
{
"eval_name": "prompt_stereotyping",
"dataset_name": "crows-pairs_sample",
"dataset_scores": [
{
"name": "prompt_stereotyping",
"value": 0.6666666666666666
}
],
"prompt_template": "$feature",
"category_scores": [
{
"name": "disability",
"scores": [
{
"name": "prompt_stereotyping",
"value": 0.5
}
]
},
...
],
"output_path": "/home/sagemaker-user/results-eval-prompt-stereotyping/prompt_stereotyping_crows-pairs_sample.jsonl",
"error": null
}
]
```
In der vorherigen Beispielausgabe wird eine Gesamtpunktzahl für den folgenden `"name": prompt_stereotyping` Datensatz angezeigt. Dieser Wert ist der normalisierte Unterschied zwischen den logarithmischen Wahrscheinlichkeiten zwischen der Modellantwort, die **mehr** als weniger systematische Abweichung ergibt. Wenn der Wert größer als ist, bedeutet dies`0.5`, dass Ihre Modellantwort mit größerer Wahrscheinlichkeit eine Antwortvariable mit stärkerer Verzerrung zurückgibt. Wenn die Punktzahl kleiner als ist, ist es wahrscheinlicher`0.5`, dass Ihr Modell eine Antwortvariable mit weniger systematischer Verzerrung zurückgibt. Wenn der Wert gleich ist`0.5`, enthält die Modellantwort keine Verzerrung, wie sie anhand des Eingabedatensatzes gemessen wurde. Im nächsten Schritt verwenden Sie die`output_path`, `Pandas` `DataFrame` um eine zu erstellen.
1. Importieren Sie Ihre Ergebnisse`DataFrame`, lesen Sie sie in eine ein und fügen Sie die Stereotypisierungswerte der Eingabeaufforderung wie folgt an die Modelleingabe, Modellausgabe und Zielausgabe an:
```
import pandas as pd
data = []
with open(os.path.join(eval_results_path,
"prompt_stereotyping_crows-pairs_sample.jsonl"), "r") as file:
for line in file:
data.append(json.loads(line))
df = pd.DataFrame(data)
df['eval_algo'] = df['scores'].apply(lambda x: x[0]['name'])
df['eval_score'] = df['scores'].apply(lambda x: x[0]['value'])
df
```
[Ein Notizbuch, das die in diesem Abschnitt angegebenen Codebeispiele enthält, finden Sie unter .ipnyb. jumpstart-falcon-stereotyping](https://github.com/aws/fmeval/blob/main/examples/jumpstart-falcon-stereotyping.ipynb)
# Evaluieren Sie ein Amazon Bedrock-Modell auf Genauigkeit bei der Textzusammenfassung
Sie können einen `ModelRunner` Wrapper auf hoher Ebene verwenden, um eine benutzerdefinierte Evaluierung auf der Grundlage eines Modells zu erstellen, das außerhalb von gehostet wird. JumpStart
Dieses Tutorial zeigt, wie Sie das [Modell Anthropic Claude 2](https://www.anthropic.com/index/claude-2), das in Amazon Bedrock verfügbar ist, laden und dieses Modell bitten, Textanfragen zusammenzufassen. Anschließend zeigt dieses Tutorial, wie die Genauigkeit der Modellantwort anhand der Metriken [https://huggingface.co/spaces/evaluate-metric/rouge](https://huggingface.co/spaces/evaluate-metric/rouge), [https://huggingface.co/spaces/evaluate-metric/meteor](https://huggingface.co/spaces/evaluate-metric/meteor)und bewertet wird. [https://huggingface.co/spaces/evaluate-metric/bertscore](https://huggingface.co/spaces/evaluate-metric/bertscore)
Die Tutorials zeigen, wie Sie Folgendes durchführen können:
+ Einrichten Ihrer Umgebung
+ Führen Sie Ihre Modellevaluierung durch.
+ Zeigen Sie Ihre Analyseergebnisse an.
## So richten Sie Ihre Umgebung ein
**Voraussetzungen**
+ Verwenden Sie eine Basis-Kernelumgebung Python 3.10 und eine `ml.m5.2xlarge` Amazon Elastic Compute Cloud (Amazon EC2) -Instance, bevor Sie dieses Tutorial starten.
Weitere Informationen zu Instance-Typen und ihren empfohlenen Anwendungsfällen finden Sie unter [Instance-Typen, die für die Verwendung mit Amazon SageMaker Studio Classic-Notebooks verfügbar sind](notebooks-available-instance-types.md).
**Einrichten von Amazon Bedrock**
Bevor Sie ein Amazon Bedrock-Modell verwenden können, müssen Sie den Zugriff darauf beantragen.
1. Melden Sie sich bei Ihrem an AWS-Konto.
1. Wenn Sie noch kein AWS Konto haben, finden Sie weitere Informationen unter [Eröffnen eines AWS Kontos](https://docs.aws.amazon.com/bedrock/latest/userguide/setting-up.html#sign-up-for-aws) unter **Amazon Bedrock einrichten**.
1. Öffnen Sie die [Amazon-Bedrock-Konsole](https://console.aws.amazon.com/bedrock).
1. Im **Willkommen bei Amazon Bedrock**\$1 Wählen Sie im sich öffnenden Bereich die Option **Modellzugriff verwalten** aus.
1. Wählen Sie im daraufhin angezeigten Abschnitt **Modellzugriff** die Option **Modellzugriff verwalten** aus.
1. Aktivieren Sie im daraufhin angezeigten Abschnitt **Grundlagenmodelle** das Kästchen neben **Claude**, das im Unterabschnitt **Anthropic** von **Models** aufgeführt ist.
1. Wählen Sie **Modellzugriff anfordern** aus.
1. Wenn Ihre Anfrage erfolgreich ist, sollte unter ****Zugriffsstatus neben dem ausgewählten Modell ein Häkchen mit der Aufschrift Zugriff** gewährt** angezeigt werden.
1. Möglicherweise müssen Sie sich erneut bei Ihrem anmelden AWS-Konto , um auf das Modell zugreifen zu können.
**Installieren erforderlicher Bibliotheken**
1. Installieren Sie in Ihrem Code die `boto3` Bibliotheken `fmeval` und wie folgt:
```
!pip install fmeval
!pip3 install boto3==1.28.65
```
1. Importieren Sie Bibliotheken, legen Sie einen Parallelisierungsfaktor fest und rufen Sie einen Amazon Bedrock-Client wie folgt auf:
```
import boto3
import json
import os
# Dependent on available hardware and memory
os.environ["PARALLELIZATION_FACTOR"] = "1"
# Bedrock clients for model inference
bedrock = boto3.client(service_name='bedrock')
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
```
Im vorherigen Codebeispiel gilt Folgendes:
+ `PARALLELIZATION_FACTOR` – Ein Multiplikator für die Anzahl der gleichzeitigen Batches, die an Ihre Compute-Instance gesendet werden. Wenn Ihre Hardware Parallelisierung zulässt, können Sie diese Zahl so einstellen, dass die Anzahl der Aufrufe für Ihren Evaluierungsjob mit multipliziert wird. Wenn Sie beispielsweise `100` Aufrufe haben und diese Option auf eingestellt `PARALLELIZATION_FACTOR` ist, führt Ihr Job Aufrufe aus. `2` `200` Sie können die Variable `PARALLELIZATION_FACTOR` auf einen Wert erhöhen oder sie `10` ganz entfernen. Einen Blog zur Verwendung von AWS Lambda finden Sie `PARALLELIZATION_FACTOR` unter [Neue Lambda-Skalierungssteuerungen für Kinesis- und DynamoDB-Ereignisquellen](https://aws.amazon.com/blogs/compute/new-aws-lambda-scaling-controls-for-kinesis-and-dynamodb-event-sources/).
1. Laden Sie den `JSON Lines` Beispieldatensatz [sample-dataset.jsonl](https://github.com/aws/fmeval/blob/8da27af2f20369fd419c03d5bb0707ab24010b14/examples/xsum_sample.jsonl) in Ihr aktuelles Arbeitsverzeichnis herunter.
1. Überprüfen Sie wie folgt, ob Ihre Umgebung die Beispiel-Eingabedatei enthält:
```
import glob
# Check for the built-in dataset
if not glob.glob("sample-dataset.jsonl"):
print("ERROR - please make sure file exists: sample-dataset.jsonl")
```
**Senden Sie eine Muster-Inferenzanfrage für Ihr Modell**
1. Definieren Sie das Modell und den `MIME` Typ Ihrer Aufforderung. Für ein [Modell von Anthropic Claude 2](https://www.anthropic.com/index/claude-2), das auf Amazon Bedrock gehostet wird, muss Ihre Aufforderung wie folgt strukturiert sein:
```
import json
model_id = 'anthropic.claude-v2'
accept = "application/json"
contentType = "application/json"
# Ensure that your prompt has the correct format
prompt_data = """Human: Who is Barack Obama?
Assistant:
"""
```
Weitere Informationen zur Strukturierung des Hauptteils Ihrer Anfrage finden Sie unter Textfeld [Modellaufrufanforderung](https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-claude.html#model-parameters-claude-request-body). Andere Modelle haben möglicherweise andere Formate.
1. Senden Sie eine Musteranfrage an Ihr Modell. Der Hauptteil Ihrer Anfrage enthält die Aufforderung und alle zusätzlichen Parameter, die Sie festlegen möchten. Eine Beispielanforderung mit `500` folgendem `max_tokens_to_sample` Satz:
```
body = json.dumps({"prompt": prompt_data, "max_tokens_to_sample": 500})
response = bedrock_runtime.invoke_model(
body=body, modelId=model_id, accept=accept, contentType=contentType
)
response_body = json.loads(response.get("body").read())
print(response_body.get("completion"))
```
Im vorherigen Codebeispiel können Sie die folgenden Parameter angeben:
+ `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. Bereiche für `temperature` liegen zwischen `0` und`1`, mit einem Standardwert von 0,5.
+ `topP` – Steuert die Zufälligkeit, indem der Satz von Tokens begrenzt wird, der bei der Generierung des nächsten Tokens berücksichtigt werden soll. 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. Die Wertebereiche für `topP` sind `0` bis`1`, der `1` Standardwert ist.
+ `topK` – Beschränkt die Modellvorhersagen auf die Tokens mit der `k` höchsten Wahrscheinlichkeit. Höhere Werte von `topK` ermöglichen einfallsreichere Antworten. Niedrigere Werte führen zu kohärenteren Antworten. Die Wertebereiche für `topK` sind `0` bis`500`, der `250` Standardwert ist.
+ `max_tokens_to_sample` – Beschränkt die Länge der Antwort, indem die Anzahl der von Ihrem Modell zurückgegebenen Token begrenzt wird. Die Wertebereiche für `max_tokens_to_sample` sind `0` bis`4096`, der `200` Standardwert ist.
+ `stop_sequences` – Gibt eine Liste von Zeichenfolgen an, die Ihr Modell anweisen, die Generierung einer Antwort zu beenden. Die Modellausgabe wird gestoppt, wenn eine der aufgelisteten Zeichenketten zum ersten Mal in der Ausgabe gefunden wird. Die Antwort enthält keine Stoppsequenz. Sie können beispielsweise eine Wagenrücklaufsequenz verwenden, um die Modellantwort auf eine einzige Zeile zu beschränken. Sie können Sequenzen bis zu einem `4` Stopp konfigurieren.
Weitere Informationen zu den Parametern, die Sie in einer Anfrage angeben können, finden Sie unter [Modelle von Anthropic Claude.](https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-claude.html)
**Richten Sie ein FMEval**
1. Laden Sie die erforderlichen Bibliotheken für die Ausführung FMEval wie folgt:
```
from fmeval.data_loaders.data_config import DataConfig
from fmeval.model_runners.bedrock_model_runner import BedrockModelRunner
from fmeval.constants import MIME_TYPE_JSONLINES
from fmeval.eval_algorithms.summarization_accuracy import SummarizationAccuracy, SummarizationAccuracyConfig
```
1. Richten Sie die Datenkonfiguration für Ihren Eingabedatensatz ein.
Die folgende Beispieleingabe stammt aus einer Zeile von`sample-dataset.jsonl`:
```
{
"document": "23 October 2015 Last updated at 17:44
BST\nIt's the highest rating a tropical storm
can get and is the first one of this magnitude
to hit mainland Mexico since 1959.\nBut how are
the categories decided and what do they mean?
Newsround reporter Jenny Lawrence explains.",
"summary": "Hurricane Patricia has been rated as
a category 5 storm.",
"id": "34615665",
}
```
Die vorherige Beispieleingabe enthält den Text, der im `document` Schlüssel zusammengefasst werden soll. Die Referenz, anhand derer Sie Ihre Modellantwort auswerten können, befindet sich im `summary` Schlüssel. Sie müssen diese Schlüssel in Ihrer Datenkonfiguration verwenden, um anzugeben, welche Spalten die Informationen enthalten, die zur Auswertung der Modellantwort FMEval benötigt werden.
Ihre Datenkonfiguration muss den Text identifizieren, in `model_input_location` dem Ihr Modell zusammenfassen soll. Sie müssen den Referenzwert mit `target_output_location` identifizieren.
Das folgende Beispiel für eine Datenkonfiguration bezieht sich auf das vorherige Eingabebeispiel, um die für eine Aufgabe zur Textzusammenfassung erforderlichen Spalten, den Namen, den URI (Uniform Resource Identifier) und den `MIME` Typ anzugeben:
```
config = DataConfig(
dataset_name="sample-dataset",
dataset_uri="sample-dataset.jsonl",
dataset_mime_type=MIME_TYPE_JSONLINES,
model_input_location="document",
target_output_location="summary"
)
```
Weitere Informationen zu den Spalteninformationen, die für andere Aufgaben erforderlich sind, finden Sie im [Automatische Modellbewertung](clarify-foundation-model-evaluate-auto.md) Abschnitt **Verwenden eines benutzerdefinierten Eingabedatensatzes** unter.
1. Richten Sie einen benutzerdefinierten `ModelRunner` ein, wie im folgenden Codebeispiel gezeigt:
```
bedrock_model_runner = BedrockModelRunner(
model_id=model_id,
output='completion',
content_template='{"prompt": $prompt, "max_tokens_to_sample": 500}'
)
```
Das vorherige Codebeispiel spezifiziert Folgendes:
+ `model_id` – Die ID, die zur Angabe Ihres Modells verwendet wurde.
+ `output` – Erfasst die Ausgabe des Modells [Anthropic Claude 2](https://www.anthropic.com/index/claude-2), das seine Antwort in einem `completion` Schlüssel zurückgibt.
+ `content_template` – Gibt an, wie Ihr Modell mit Anfragen interagiert. Die Beispielkonfigurationsvorlage wird im Folgenden lediglich zur Erläuterung des vorherigen Beispiels detailliert beschrieben und ist nicht erforderlich.
+ Im vorherigen `content_template` Beispiel gilt Folgendes:
+ Die Variable `prompt` gibt die Eingabeaufforderung an, die die vom Benutzer gestellte Anfrage erfasst.
+ Die Variable `max_tokens_to_sample` gibt die maximale Anzahl von Tokens an`500`, um die Länge der Antwort zu begrenzen.
Weitere Informationen zu den Parametern, die Sie in Ihrer Anfrage angeben können, finden Sie unter [Anthropic Claude-Modelle.](https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-claude.html)
Das Format des `content_template` Parameters hängt von den Eingaben und Parametern ab, die von Ihrem LLM unterstützt werden. In diesem Tutorial verwendet das [Claude 2-Modell von Anthropic](https://www.anthropic.com/index/claude-2) Folgendes: `content_template`
```
"content_template": "{\"prompt\": $prompt, \"max_tokens_to_sample\": 500}"
```
Als weiteres Beispiel kann das [Falcon 7b-Modell Folgendes](https://huggingface.co/tiiuae/falcon-7b) unterstützen: `content_template`
```
"content_template": "{\"inputs\": $prompt, \"parameters\":{\"max_new_tokens\": \
10, \"top_p\": 0.9, \"temperature\": 0.8}}"
```
## Führen Sie Ihre Modellbewertung durch
**Definieren Sie Ihren Bewertungsalgorithmus und führen Sie ihn aus**
1. Definieren Sie Ihren Bewertungsalgorithmus. Das folgende Beispiel zeigt, wie Sie einen `SummarizationAccuracy` Algorithmus definieren, der verwendet wird, um die Genauigkeit von Aufgaben zur Textzusammenfassung zu bestimmen:
```
eval_algo = SummarizationAccuracy(SummarizationAccuracyConfig())
```
Beispiele für Algorithmen, die Metriken für andere Bewertungsaufgaben berechnen, finden Sie unter **Evaluieren Sie Ihr Modell** in [Verwenden Sie die `fmeval` Bibliothek, um eine automatische Bewertung durchzuführen](clarify-foundation-model-evaluate-auto-lib.md).
1. Führen Sie Ihren Bewertungsalgorithmus aus. Das folgende Codebeispiel verwendet die Datenkonfiguration, die zuvor definiert wurde, und eine`prompt_template`, die die `Assistant` Schlüssel `Human` und verwendet:
```
eval_output = eval_algo.evaluate(model=bedrock_model_runner,
dataset_config=config,
prompt_template="Human: $feature\n\nAssistant:\n", save=True)
```
`feature`Enthält im vorherigen Codebeispiel die Eingabeaufforderung in dem Format, das das Amazon Bedrock-Modell erwartet.
## Zeigen Sie Ihre Analyseergebnisse an
1. Analysieren Sie einen Bewertungsbericht anhand des vom Bewertungsalgorithmus zurückgegebenen `eval_output` Objekts wie folgt:
```
# parse report
print(json.dumps(eval_output, default=vars, indent=4))
```
Der vorherige Befehl gibt die folgende Ausgabe zurück:
```
[
{
"eval_name": "summarization_accuracy",
"dataset_name": "sample-dataset",
"dataset_scores": [
{
"name": "meteor",
"value": 0.2048823008681274
},
{
"name": "rouge",
"value": 0.03557697913367101
},
{
"name": "bertscore",
"value": 0.5406564395678671
}
],
"prompt_template": "Human: $feature\n\nAssistant:\n",
"category_scores": null,
"output_path": "/tmp/eval_results/summarization_accuracy_sample_dataset.jsonl",
"error": null
}
]
```
In der vorherigen Beispielausgabe werden die drei Genauigkeitswerte angezeigt: [https://huggingface.co/spaces/evaluate-metric/meteor](https://huggingface.co/spaces/evaluate-metric/meteor),, und [https://huggingface.co/spaces/evaluate-metric/bertscore](https://huggingface.co/spaces/evaluate-metric/bertscore), die Eingabe`prompt_template`, a, `category_score` falls Sie eine angefordert haben, alle Fehler und die`output_path`. Im folgenden Schritt werden Sie die verwenden, `output_path` `Pandas DataFrame` um eine zu erstellen.
1. Importieren Sie Ihre Ergebnisse`DataFrame`, lesen Sie sie in eine ein und fügen Sie die Genauigkeitswerte wie folgt der Modelleingabe, Modellausgabe und Zielausgabe hinzu:
```
import pandas as pd
data = []
with open("/tmp/eval_results/summarization_accuracy_sample_dataset.jsonl", "r") as file:
for line in file:
data.append(json.loads(line))
df = pd.DataFrame(data)
df['meteor_score'] = df['scores'].apply(lambda x: x[0]['value'])
df['rouge_score'] = df['scores'].apply(lambda x: x[1]['value'])
df['bert_score'] = df['scores'].apply(lambda x: x[2]['value'])
df
```
Bei diesem Aufruf gibt das vorherige Codebeispiel die folgende Ausgabe zurück (der Kürze halber gekürzt):
```
model_input model_output target_output prompt scores meteor_score rouge_score bert_score
0 John Edward Bates, formerly of Spalding, Linco... I cannot make any definitive judgments, as th... A former Lincolnshire Police officer carried o... Human: John Edward Bates, formerly of Spalding... [{'name': 'meteor', 'value': 0.112359550561797... 0.112360 0.000000 0.543234 ...
1 23 October 2015 Last updated at 17:44 BST\nIt'... Here are some key points about hurricane/trop... Hurricane Patricia has been rated as a categor... Human: 23 October 2015 Last updated at 17:44 B... [{'name': 'meteor', 'value': 0.139822692925566... 0.139823 0.017621 0.426529 ...
2 Ferrari appeared in a position to challenge un... Here are the key points from the article:\n\n... Lewis Hamilton stormed to pole position at the... Human: Ferrari appeared in a position to chall... [{'name': 'meteor', 'value': 0.283411142234671... 0.283411 0.064516 0.597001 ...
3 The Bath-born player, 28, has made 36 appearan... Okay, let me summarize the key points from th... Newport Gwent Dragons number eight Ed Jackson ... Human: The Bath-born player, 28, has made 36 a... [{'name': 'meteor', 'value': 0.089020771513353... 0.089021 0.000000 0.533514 ...
...
```
Ihre Modellausgabe kann sich von der vorherigen Beispielausgabe unterscheiden.
Ein Notizbuch, das die in diesem Abschnitt angegebenen Codebeispiele enthält, finden Sie unter [bedrock-claude-summarization-accuracy.ipnyb.](https://github.com/aws/fmeval/blob/main/examples/bedrock-claude-summarization-accuracy.ipynb)
## Zusätzliche Notebooks
Das GitHub Verzeichnis [fmeval](https://github.com/aws/fmeval/tree/main/examples) enthält die folgenden zusätzlichen Beispiel-Notebooks:
+ [bedrock-claude-factual-knowledge.ipnyb](https://github.com/aws/fmeval/blob/main/examples/bedrock-claude-factual-knowledge.ipynb) — Evaluiert ein [anthropisches Claude 2-Modell](https://www.anthropic.com/index/claude-2), das auf Amazon Bedrock gehostet wird, auf Faktenwissen.
+ [byo-model-outputs.ipynb](https://github.com/aws/fmeval/blob/main/examples/byo-model-outputs.ipynb) — Evaluiert ein auf Faktenwissen gehostetes [Falcon 7b-Modell, bei dem Sie Ihre eigenen Modellergebnisse](https://huggingface.co/tiiuae/falcon-7b) einbringen, JumpStart anstatt Inferenzanfragen an Ihr Modell zu senden.
+ [`ChatGPT 3.5`custom\$1model\$1runner\$1chat\$1gpt.ipnyb](https://github.com/aws/fmeval/blob/main/examples/custom_model_runner_chat_gpt.ipynb) – Evaluiert ein benutzerdefiniertes Modell, `Hugging Face` auf dem Faktenwissen gehostet wird.
# Fehler bei der Erstellung eines Modellevaluierungsjobs in Amazon SageMaker AI beheben
**Wichtig**
Um SageMaker Clarify Foundation Model Evaluations (FMEval) verwenden zu können, müssen Sie auf das neue Studio-Erlebnis aktualisieren.
Seit dem 30. November 2023 heißt das vorherige Amazon SageMaker Studio-Erlebnis jetzt Amazon SageMaker Studio Classic. FMEval ist in Amazon SageMaker Studio Classic nicht verfügbar.
Weitere Informationen zum Upgrade auf das neue Studio-Erlebnis finden Sie unter [Migration von Amazon SageMaker Studio Classic](studio-updated-migrate.md). Informationen zur Verwendung der Studio-Classic-Anwendung finden Sie unter [Amazon SageMaker Studio Klassisch](studio.md).
Wenn Sie beim Erstellen eines Auftrags zur Modellbewertung auf einen Fehler stoßen, verwenden Sie die folgende Liste, um Fehler bei Ihrer Auswertung zu beheben. Wenn Sie weitere Unterstützung benötigen, wenden Sie sich an [SupportAWS](https://console.aws.amazon.com/support/)[unsere Entwicklerforen für Amazon SageMaker AI](https://forums.aws.amazon.com/forum.jspa?forumID=285).
**Topics**
+ [Fehler beim Hochladen Ihrer Daten aus einem Amazon-S3-Bucket](#clarify-foundation-model-evaluate-troubleshooting-cors)
+ [Der Verarbeitungsauftrag konnte nicht abgeschlossen werden](#clarify-foundation-model-evaluate-troubleshooting-failure)
+ [In der SageMaker AI-Konsole finden Sie keine Evaluierungen von Fundamentmodellen](#clarify-foundation-model-evaluate-troubleshooting-upgrade)
+ [Ihr Modell unterstützt keine Prompt-Stereotypisierung](#clarify-foundation-model-evaluate-troubleshooting-ps)
+ [Fehler bei der Validierung von Datensätzen (menschlich)](#clarify-foundation-model-evaluate-troubleshooting-valid)
## Fehler beim Hochladen Ihrer Daten aus einem Amazon-S3-Bucket
Wenn Sie eine Foundation-Model-Evaluierung erstellen, müssen Sie die richtigen Berechtigungen für den S3-Bucket festlegen, in dem Sie Ihre Modelleingabe und -ausgabe speichern möchten. Wenn die CORS-Berechtigungen (Cross-Origin Resource Sharing) nicht korrekt festgelegt sind, generiert SageMaker AI den folgenden Fehler:
Fehler: Objekt konnte nicht in S3 abgelegt werden: Fehler beim Hochladen des Objekts auf S3 Fehler: Objekt konnte nicht in S3 abgelegt werden: NetworkError Beim Versuch, die Ressource abzurufen.
Um die richtigen Bucket-Berechtigungen festzulegen, folgen Sie den Anweisungen unter Umgebung **einrichten** in. [Erstellen eines Auftrags zur automatischen Modellbewertung in Studio](clarify-foundation-model-evaluate-auto-ui.md)
## Der Verarbeitungsauftrag konnte nicht abgeschlossen werden
Zu den häufigsten Gründen, warum Ihr Verarbeitungsauftrag nicht abgeschlossen werden konnte, gehören die folgenden:
+ [Unzureichende Quote](#clarify-foundation-model-evaluate-troubleshooting-failure-quota)
+ [Unzureichender Speicher](#clarify-foundation-model-evaluate-troubleshooting-failure-memory)
+ [Die Ping-Prüfung wurde nicht bestanden](#clarify-foundation-model-evaluate-troubleshooting-failure-ping)
In den folgenden Abschnitten finden Sie Informationen zur Behebung der einzelnen Probleme.
### Unzureichende Quote
Wenn Sie eine Foundation-Model-Evaluierung für ein nicht bereitgestelltes JumpStart Modell durchführen, stellt SageMaker Clarify Ihr Large Language Model (LLM) auf einem KI-Endpunkt in Ihrem Konto bereit. SageMaker Wenn Ihr Konto nicht über ein ausreichendes Kontingent für die Ausführung des ausgewählten JumpStart Modells verfügt, schlägt der Job mit einem fehl. `ClientError` Gehen Sie wie folgt vor, um Ihr Kontingent zu erhöhen:
**Eine Erhöhung der AWS Service Quotas beantragen**
1. Bitte entnehmen Sie den Instance-Namen, das aktuelle Kontingent und das erforderliche Kontingent der Fehlermeldung auf dem Bildschirm. Beispielsweise im folgenden Fehler:
+ Der Instance-Name lautet `ml.g5.12xlarge`.
+ Das aktuelle Kontingent aus der folgenden Zahl `current utilization` lautet `0 instances`
+ Das zusätzlich erforderliche Kontingent aus der folgenden Zahl `request delta` ist`1 instances`.
Der Beispielfehler folgt:
`ClientError: An error occurred (ResourceLimitExceeded) when calling the CreateEndpoint operation: The account-level service limit 'ml.g5.12xlarge for endpoint usage' is 0 Instances, with current utilization of 0 Instances and a request delta of 1 Instances. Please use AWS Service Quotas to request an increase for this quota. If AWS Service Quotas is not available, contact AWS support to request an increase for this quota`
1. Melden Sie sich bei der [Service Quotas Quotas-Konsole](https://console.aws.amazon.com/servicequotas/home) an AWS-Managementkonsole und öffnen Sie sie.
1. Geben Sie im Navigationsbereich unter **Kontingente verwalten** die Eingabe ein**Amazon SageMaker AI**.
1. Wählen Sie **Kontingente anzeigen** aus.
1. Geben Sie in der Suchleiste unter **Dienstkontingente** den Namen der Instance aus Schritt 1 ein. Verwenden Sie beispielsweise die Informationen, die in der Fehlermeldung aus Schritt 1 enthalten sind, und geben Sie ein**ml.g5.12xlarge**.
1. Wählen Sie den **Kontingentnamen** aus, der neben Ihrem Instance-Namen angezeigt wird und mit **für Endpunktnutzung** endet. Wählen Sie beispielsweise anhand der in der Fehlermeldung aus Schritt 1 enthaltenen Informationen **ml.g5.12xlarge** für die Endpunktnutzung aus.
1. Wählen Sie **Erhöhung auf Kontoebene beantragen**.
1. Geben **Sie unter Kontingentwert erhöhen** das erforderliche Kontingent aus den Informationen in der Fehlermeldung aus Schritt 1 ein. Geben Sie die **Summe** von `current utilization` und ein`request delta`. Im vorherigen Beispiel `current utilization` ist der Fehler „ist`0 Instances`“ und „`request delta`ist`1 Instances`“. Fordern Sie in diesem Beispiel ein Kontingent von `1` an, um das erforderliche Kontingent bereitzustellen.
1. Wählen Sie **Anfrage** aus.
1. Wählen Sie im **Navigationsbereich Historie der Kontingentanträge** aus.
1. Wenn sich der **Status** von **Ausstehend** in **Genehmigt** ändert, führen Sie Ihren Job erneut aus. Möglicherweise müssen Sie Ihren Browser aktualisieren, um die Änderung zu sehen.
Weitere Informationen zum Anfordern einer Kontingenterhöhung finden Sie unter [Beantragen einer Kontingenterhöhung](https://docs.aws.amazon.com/servicequotas/latest/userguide/request-quota-increase.html).
### Unzureichender Speicher
Wenn Sie eine Grundlagenmodellbewertung auf einer Amazon-EC2-Instance starten, die nicht über genügend Arbeitsspeicher verfügt, um einen Bewertungsalgorithmus auszuführen, schlägt der Auftrag mit folgendem Fehler fehl:
`The actor is dead because its worker process has died. Worker exit type: SYSTEM_ERROR Worker exit detail: Worker unexpectedly exits with a connection error code 2. End of file. There are some potential root causes. (1) The process is killed by SIGKILL by OOM killer due to high memory usage. (2) ray stop --force is called. (3) The worker is crashed unexpectedly due to SIGSEGV or other unexpected errors. The actor never ran - it was cancelled before it started running.`
Um den für Ihren Evaluierungsjob verfügbaren Arbeitsspeicher zu erhöhen, ändern Sie Ihre Instance in eine Instance mit mehr Arbeitsspeicher. Wenn Sie die Benutzeroberfläche verwenden, können Sie in **Schritt 2** unter **Prozessorkonfiguration** einen Instance-Typ auswählen. Wenn Sie Ihren Job in der SageMaker AI-Konsole ausführen, starten Sie einen neuen Bereich mit einer Instanz mit erhöhter Speicherkapazität.
Eine Liste der Amazon-EC2-Instances finden Sie unter [Instance-Typen](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html#AvailableInstanceTypes).
Weitere Informationen zu Instances mit größerer Speicherkapazität finden Sie unter [Speicheroptimierte](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/memory-optimized-instances.html) Instances.
### Die Ping-Prüfung wurde nicht bestanden
In einigen Fällen schlägt Ihr Evaluierungsauftrag für das Foundation-Modell fehl, weil er bei der Bereitstellung Ihres Endpunkts durch SageMaker KI keine Ping-Überprüfung bestanden hat. Wenn es einen Ping-Test nicht besteht, wird der folgende Fehler angezeigt:
`ClientError: Error hosting endpoint your_endpoint_name: Failed. Reason: The primary container for production variant AllTraffic did not pass the ping health check. Please check CloudWatch logs for this endpoint..., Job exited for model: your_model_name of model_type: your_model_type `
Wenn Ihr Auftrag diesen Fehler generiert, warten Sie einige Minuten und führen Sie Ihren Auftrag erneut aus. Wenn der Fehler weiterhin besteht, wenden Sie sich an den [AWS Support](https://console.aws.amazon.com/support/) oder die [AWS Entwicklerforen für Amazon SageMaker AI](https://forums.aws.amazon.com/forum.jspa?forumID=285).
## In der SageMaker AI-Konsole finden Sie keine Evaluierungen von Fundamentmodellen
Um SageMaker Clarify Foundation Model Evaluations verwenden zu können, müssen Sie auf das neue Studio-Erlebnis aktualisieren. Seit dem 30. November 2023 heißt das vorherige Amazon SageMaker Studio-Erlebnis jetzt Amazon SageMaker Studio Classic. Die Foundation-Evaluierungsfunktion kann nur in der aktualisierten Version verwendet werden. Weitere Informationen zur Aktualisierung von Studio finden Sie unter [Migration von Amazon SageMaker Studio Classic](studio-updated-migrate.md).
## Ihr Modell unterstützt keine Prompt-Stereotypisierung
Nur einige JumpStart Modelle unterstützen Prompt-Stereotypisierung. Wenn Sie ein JumpStart Modell auswählen, das nicht unterstützt wird, wird der folgende Fehler angezeigt:
`{"evaluationMetrics":"This model does not support Prompt stereotyping evaluation. Please remove that evaluation metric or select another model that supports it."}`
Wenn Sie diesen Fehler erhalten, können Sie Ihr ausgewähltes Modell nicht in einer Foundation-Evaluierung verwenden. SageMaker Clarify arbeitet derzeit daran, alle JumpStart Modelle für Prompt-Stereotypisierungsaufgaben zu aktualisieren, sodass sie bei einer Evaluierung des Fundamentmodells verwendet werden können.
## Fehler bei der Validierung von Datensätzen (menschlich)
Der benutzerdefinierte Prompt-Datensatz in einem Model-Evaluierungsjob, bei dem menschliche Arbeiter verwendet werden, muss mithilfe der `.jsonl` Erweiterung im JSON-Zeilenformat formatiert werden.
Wenn Sie einen Job starten, wird jedes JSON-Objekt im Prompt-Datensatz voneinander abhängig validiert. Wenn eines der JSON-Objekte nicht gültig ist, erhalten Sie die folgende Fehlermeldung.
```
Customer Error: Your input dataset could not be validated. Your dataset can have up to 1000 prompts. The dataset must be a valid jsonl file, and each prompt valid json object.To learn more about troubleshooting dataset validations errors, see Troubleshooting guide. Job executed for models: meta-textgeneration-llama-2-7b-f, pytorch-textgeneration1-alexa20b.
```
*Damit ein benutzerdefinierter Prompt-Datensatz alle Validierungen bestehen kann, muss Folgendes für alle JSON-Objekte in der JSON-Zeilendatei gelten.*
+ Jede Zeile in der Prompt-Datensatzdatei muss ein gültiges JSON-Objekt sein.
+ Sonderzeichen wie Anführungszeichen (`"`) müssen korrekt maskiert werden. Wenn Ihre Eingabeaufforderung beispielsweise wie folgt lauten würde, müssten `"Claire said to the crowd, "Bananas are the best!""` die Anführungszeichen mit einem`\`, maskiert werden`"Claire said to the crowd, \"Bananas are the best!\""`.
+ Gültige JSON-Objekte müssen mindestens das `prompt` Schlüssel/Wert-Paar enthalten.
+ Eine Prompt-Datensatzdatei darf nicht mehr als 1.000 JSON-Objekte in einer einzigen Datei enthalten.
+ *Wenn Sie den `responses` Schlüssel in einem JSON-Objekt angeben, muss er in *allen* JSON-Objekten vorhanden sein.*
+ Die maximale Anzahl von Objekten im `responses` Schlüssel ist 1. Wenn Sie Antworten aus mehreren Modellen haben, die Sie vergleichen möchten, ist für jedes Modell ein eigener BYOI-Datensatz erforderlich.
+ *Wenn Sie den `responses` Schlüssel in einem JSON-Objekt angeben, muss er auch die `text` Schlüssel `modelIdentifier` und in *allen* `responses` Objekten enthalten.*
# Bewertung und Vergleich von SageMaker JumpStart Amazon-Textklassifizierungsmodellen
SageMaker KI JumpStart bietet mehrere Textklassifizierungsmodelle, die Text in vordefinierte Klassen einteilen. Diese Modelle übernehmen Aufgaben wie Stimmungsanalyse, Themenklassifizierung und Inhaltsmoderation. Die Auswahl des richtigen Modells für die Produktion erfordert eine sorgfältige Bewertung anhand wichtiger Kennzahlen wie Genauigkeit, F1-Score und Matthews Correlation Coefficient (MCC).
In diesem Leitfaden gehen Sie wie folgt vor:
+ Stellen Sie mehrere Textklassifizierungsmodelle (DistilBERT und BERT) aus dem Katalog bereit. JumpStart
+ Führen Sie umfassende Bewertungen von ausgewogenen, verzerrten und schwierigen Datensätzen durch.
+ Interpretieren Sie erweiterte Kennzahlen wie Matthews Correlation Coefficient (MCC) und Area Under the Curve Receiver Operating Characteristics.
+ Treffen Sie datengestützte Entscheidungen zur Modellauswahl mithilfe systematischer Vergleichsrahmen.
+ Richten Sie Produktionsbereitstellungen mit auto-scaling und CloudWatch Überwachung ein.
Laden Sie das vollständige Evaluierungsframework herunter: [JumpStart Model Evaluation Package](samples/sagemaker-text-classification-evaluation-2.zip). **Das Paket enthält Ergebnisse vor der Ausführung mit Beispielausgaben**, sodass Sie sich eine Vorschau des Evaluierungsprozesses und der Kennzahlen ansehen können, bevor Sie die Modelle selbst implementieren.
## Voraussetzungen
Stellen Sie vor dem Beginn sicher, dass Sie über Folgendes verfügen:
+ [AWS Konto mit SageMaker KI-Berechtigungen](https://docs.aws.amazon.com/sagemaker/latest/dg/gs-set-up.html).
+ [SageMaker KI-Zugriff auf Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/onboard-quick-start.html).
+ Grundkenntnisse in Python.
+ Verständnis von Konzepten der Textklassifizierung.
Zeit und Kosten: 45 Minuten Gesamtzeit. Die Kosten variieren je nach Instance-Typ und Nutzungsdauer. Aktuelle Tarife finden Sie unter [SageMaker KI-Preise](https://aws.amazon.com/sagemaker/pricing/).
Dieses Tutorial enthält Anweisungen zur step-by-step Bereinigung, mit denen Sie alle Ressourcen entfernen und laufende Gebühren vermeiden können.
**Topics**
+ [Voraussetzungen](#w2aac37c15c11)
+ [Einrichten der Evaluierungsumgebung](jumpstart-text-classification-setup.md)
+ [Wählen Sie Modelle zur Textklassifizierung aus und setzen Sie sie ein](jumpstart-text-classification-deploy.md)
+ [Bewerten und vergleichen Sie die Leistung des Modells](jumpstart-text-classification-evaluate.md)
+ [Interpretieren Ihrer Ergebnisse](jumpstart-text-classification-interpret.md)
+ [Bereitstellen Ihres Modells](jumpstart-text-classification-scale.md)
# Einrichten der Evaluierungsumgebung
Richten Sie SageMaker AI Studio ein, um auf JumpStart Modelle für die Bewertung der Textklassifizierung zuzugreifen. In diesem Abschnitt werden die Konfiguration von Berechtigungen und die damit verbundenen Kosten behandelt, bevor Sie Modelle bereitstellen.
## Voraussetzungen
Bevor Sie beginnen, stellen Sie sicher, dass Sie über ein AWS Konto mit SageMaker KI-Berechtigungen verfügen. Anweisungen zur Kontoeinrichtung finden Sie unter [ SageMaker KI-Voraussetzungen einrichten](https://docs.aws.amazon.com/sagemaker/latest/dg/gs-set-up.html).
## Richten Sie SageMaker AI Studio für die JumpStart Modellevaluierung ein
Wenn Sie keinen Zugriff auf SageMaker AI Studio haben, finden Sie weitere Informationen unter [Schnelleinrichtung](https://docs.aws.amazon.com/sagemaker/latest/dg/onboard-quick-start.html) zum Erstellen einer Domain.
Um mit Ihrem Textklassifizierungsprojekt in SageMaker Studio zu beginnen:
1. Öffnen Sie das SageMaker AI Studio Control Panel.
1. Wählen Sie Ihr Benutzerprofil aus.
1. Wählen Sie **Open Studio**.
1. Warten Sie, bis Studio geladen ist (dies kann beim ersten Start 2-3 Minuten dauern).
1. Vergewissern Sie sich, dass dies im linken Navigationsbereich JumpStart angezeigt wird.
## Die Kosten von SageMaker KI verstehen
Wenn Sie SageMaker AI Studio verwenden, entstehen Ihnen Kosten für:
+ SageMaker KI-Endpunkt-Hosting (variiert je nach Instanztyp und Dauer).
+ Amazon-S3-Speicher für Datensätze und Modellartefakte.
+ Laufzeit der Notebook-Instanz (ein Teil der Nutzung wird durch das AWS kostenlose Kontingent für berechtigte Konten abgedeckt).
**Anmerkung**
Für die Nutzung der Studio-Oberfläche wird keine zusätzliche Gebühr erhoben.
### Empfehlungen zum Kostenmanagement
Folgen Sie diesen Empfehlungen, um die Kosten bei Ihrer Bewertung zu minimieren:
+ Verwenden Sie die für DistilBERT- und BERT-Modelle angegebenen StandardInstances.
+ Löschen Sie Endpoints sofort nach der Evaluierung.
+ Überwachen Sie Ihre Nutzung mit dem [AWS Preisrechner](https://aws.amazon.com/calculator.aws/#/addService/SageMaker).
+ Aktuelle Speicherpreise finden Sie unter [Amazon Simple Storage Service – Preise](https://aws.amazon.com/s3/pricing/).
**Warnung**
Achten Sie darauf, Endgeräte herunterzufahren und Ressourcen zu bereinigen, nachdem Sie dieses Tutorial abgeschlossen haben, um laufende Gebühren zu vermeiden.
Fahren Sie fort mit [Wählen Sie Modelle zur Textklassifizierung aus und setzen Sie sie ein](jumpstart-text-classification-deploy.md).
# Wählen Sie Modelle zur Textklassifizierung aus und setzen Sie sie ein
Stellen Sie zwei Textklassifizierungsmodelle zum Vergleich bereit: DistilBert Base Cased und BERT Base Uncased. Sie werden die Unterschiede zwischen diesen Modellen erkennen und sie mit der optimalen Instance-Konfiguration bereitstellen.
## Warum diese beiden Modelle
Diese Modelle zeigen die typische Wahl, mit der Kunden bei der Produktion zwischen Leistung und Kosten konfrontiert sind:
+ **BERT Base Uncased**: Größer, genauer, aber langsamer und ressourcenintensiver.
+ **DistilBert Base Cased**: Kleiner, schneller, kostengünstiger, aber möglicherweise weniger genau.
Dieser Vergleich hilft Ihnen bei der Auswahl des richtigen Modells für Ihre spezifischen Bedürfnisse.
## Grundlegendes zu den Modellnamen im Katalog
Die Modellnamen der Textklassifizierung im Katalog enthalten die folgenden Komponenten:
+ BERT: Bidirektionale Encoder-Repräsentationen von Transformers.
+ L-X\$1H-Y\$1A-Z: Modellstruktur, wobei:
+ L-X: Anzahl der Schichten (X).
+ H-Y: Versteckte Größe (Y).
+ A-Z: Anzahl der Aufmerksamkeitsköpfe (Z).
+ Small/Base/Large: Modellgröße und Komplexität.
+ Ohne Groß-/Kleinschreibung – Einstellung zur Berücksichtigung von Groß- und Kleinschreibung.
Beispiel: `Small BERT L-2_H-128_A-2` steht für ein kleines BERT-Modell mit:
+ 2 Schichten
+ 128 versteckte Einheiten.
+ 2 aufmerksame Köpfe.
## Greifen Sie auf den JumpStart Modellkatalog zu
Navigieren Sie zu den Textklassifizierungsmodellen im JumpStart Katalog.
1. Öffnen Sie SageMaker AI Studio
1. Wählen Sie im linken Navigationsbereich die Option **JumpStart** aus.
1. Wählen Sie auf der JumpStart Seite **Hugging** Face aus.
1. Wählen Sie **Textklassifizierung** aus.
Im Katalog sollte eine Liste der verfügbaren Textklassifizierungsmodelle angezeigt werden, einschließlich der Varianten DistilBERT und BERT.
## Bereitstellen von Distilbert Base Cases
Stellen Sie das DistilBert-Modell mit der Standardkonfiguration bereit.
1. Suchen Sie in der Modellliste nach **DistilBert Base Cased (von Distilbert**) und wählen Sie es aus.
1. Behalten Sie auf der Seite mit den Modelldetails den standardmäßigen Instance-Typ bei.
1. Behalten Sie alle anderen Standardeinstellungen bei und wählen Sie **Bereitstellen** aus.
1. Warten Sie 5-10 Minuten, bis die Bereitstellung abgeschlossen ist.
1. Um zu überprüfen, ob die Bereitstellung erfolgreich war, gehen Sie zu **Bereitstellungen und** dann zu **Endpoints**.
1. Vergewissern Sie sich, dass der DistilBert-Endpunkt den Status anzeigt. `InService`
## Bereitstellen von BERT-Base ohne Hülle
Stellen Sie das BERT-Modell zum Vergleich mit DistilBERT bereit.
1. Kehren Sie zu den Textklassifizierungsmodellen von Hugging Face unter zurück. JumpStart
1. Suchen Sie **BERT Base Uncased (von google-bert**) und wählen Sie es aus.
1. **Behalten Sie den Standard-Instance-Typ bei und wählen Sie Deploy.**
1. Um beide Bereitstellungen zu bestätigen, überprüfen Sie, ob auf beiden Endpunkten der `InService` Status in der Endpunktliste angezeigt wird.
Beide Modelle werden in Ihrer Endpunkteliste mit Status angezeigt. `InService`
**Wichtig**
Kopieren und speichern Sie die Endpunktnamen. Sie benötigen die Werte für den Bewertungsprozess.
## Fehlerbehebung
Wenn Sie auf Probleme bei der Bereitstellung stoßen:
+ Stellen Sie bei Instance-Typfehlern sicher, dass Sie den Standard-Instance-Typ verwenden und nicht CPU-Instances wie`ml.m5.large`.
+ Wenn Sie keine Modelle finden können, suchen Sie nach den genauen Modellnamen, einschließlich des Herausgebers in Klammern.
+ Überprüfen Sie bei fehlgeschlagenen Bereitstellungen den Dienststatus in Ihrer Region oder versuchen Sie es mit einer anderen Region.
Wenn Ihr Modell `InService` den Status anzeigt, fahren Sie mit [Bewerten und vergleichen Sie die Leistung des Modells](jumpstart-text-classification-evaluate.md) der Evaluierung Ihres bereitgestellten Modells fort.
# Bewerten und vergleichen Sie die Leistung des Modells
Evaluieren Sie Ihre eingesetzten Textklassifizierungsmodelle mithilfe des Evaluierungsrahmens. Das Framework unterstützt sowohl überwachte als auch unbeaufsichtigte Bewertungsmodi mithilfe eines Notebook-basierten Ansatzes.
## Verwenden integrierter Datensätze
**Wir empfehlen, für dieses Tutorial den integrierten Datensatz für überwachte Evaluierung zu verwenden**, da die meisten Benutzer nicht sofort über beschriftete Bewertungsdaten verfügen. Die integrierten Datensätze ermöglichen eine umfassende Leistungsanalyse für verschiedene Szenarien:
+ **Ausgewogene Datensätze**: Gleiche Klassenverteilung bei der Ausgangsleistung.
+ **Verzerrte Datensätze**: Unausgewogene Klassen für Tests unter realen Bedingungen.
+ **Herausfordernde Datensätze**: Randfälle für die Robustheit von Stresstest-Modellen.
Bei der Auswertung werden wichtige Kennzahlen wie Genauigkeit, Präzision, Erinnerungsvermögen, F1-Score, Matthews-Korrelationskoeffizient (MCC) und die Betriebseigenschaften des Empfängers für die Fläche unter der Kurve mit visuellen Kurven für den Modellvergleich generiert.
## Verwenden benutzerdefinierter Daten
Wenn Sie einen eigenen beschrifteten Datensatz haben, können Sie ihn im Notebook ersetzen. Das Framework passt sich automatisch an Ihr Datenformat an und generiert dieselben umfassenden Metriken.
**Unterstützte Datumsformate:**
+ **CSV-Format:** Zwei Spalten: `text` und `label`
+ **Etikettenformate:** „positiv“ /"negativ“, „LABEL\$10"/"LABEL\$11", „True“ /"False“ oder „0"/"1"
+ **`text`Unbeaufsichtigt**: Eine Spalte für die Konfidenzanalyse
## Einrichten der Evaluierungsumgebung
Erstellen Sie in SageMaker Amazon SageMaker Studio einen JupyterLab Bereich, in dem Sie das Test-Notizbuch ausführen können.
1. Wählen Sie in Studio auf dem Startbildschirm **JupyterLab**aus.
1. Wenn Sie noch kein Leerzeichen haben:
1. Wählen Sie **Bereich erstellen** aus.
1. Geben Sie einen aussagekräftigen Namen ein (z. B. **TextModelEvaluation)**
1. Behalten Sie den standardmäßigen Instance-Typ bei.
1. Wählen Sie **Bereich ausführen** aus.
1. Wenn der Bereich erstellt wurde, wählen Sie **Öffnen JupyterLab**.
### Rufen Sie das Evaluierungs-Notebook auf
Laden Sie die ZIP-Datei herunter und extrahieren Sie auf Ihrem lokalen Computer. Laden Sie den gesamten entpackten Ordner in Ihren JupyterLab Bereich hoch, um mit dem Testen Ihrer Modelle zu beginnen. Das Paket enthält das Haupt-Evaluierungs-Notebook, Beispieldatensätze, unterstützende Python-Module und detaillierte Anweisungen für das komplette Evaluierungs-Framework.
**Anmerkung**
Nach dem Extrahieren des Pakets finden Sie in der README-Datei detaillierte Anweisungen zur Einrichtung und eine Übersicht über das Framework.
Erfahren Sie [Interpretieren Ihrer Ergebnisse](jumpstart-text-classification-interpret.md) weiter, wie Sie die Ergebnisse der Evaluierung analysieren und datengestützte Entscheidungen zur Modellauswahl treffen können.
# Interpretieren Ihrer Ergebnisse
Analysieren Sie Bewertungskennzahlen aus Ihrem Vergleich mit Textklassifizierungsmodellen, um datengestützte Entscheidungen für den Produktionseinsatz zu treffen.
## Verständnis von Bewertungsmetriken
Die Bewertung bietet mehrere wichtige Kennzahlen für jedes Modell in allen Datensätzen:
### Accuracy
Misst den Prozentsatz der korrekten Vorhersagen und eignet sich am besten für ausgewogene Datensätze. Bei unausgewogenen Daten kann es jedoch irreführend sein und zu künstlich hohen Ergebnissen führen, wenn eine Klasse dominiert.
### Genauigkeit
Evaluiert, wie gut das Modell falsch positive Ergebnisse vermeidet, indem gemessen wird, wie viel Prozent der positiven Prognosen richtig waren. Diese Metrik reicht von 0,0 bis 1,0 (höher ist besser) und wird entscheidend, wenn falsch positive Ergebnisse kostspielig sind.
### Wiedererkennung
Beurteilt, wie gut das Modell alle positiven Fälle erfasst, indem gemessen wird, wie viel Prozent der tatsächlich positiven Fälle gefunden wurden. Es reicht von 0,0 bis 1,0 (höher ist besser) und wird kritisch, wenn das Fehlen positiver Ergebnisse kostspielig ist.
### F1-Ergebnis
Stellt das harmonische Mittel für Präzision und Erinnerungsvermögen bereit und gleicht beide Messwerte zu einem einzigen Wert aus, der zwischen 0,0 und 1,0 liegt (höher ist besser).
### Matthews Korrelationskoeffizient (MCC)
Misst die allgemeine Qualität der binären Klassifikation und dient als beste Metrik für unausgewogene Daten. Sie reicht von -1,0 bis 1,0, wobei höhere Werte für eine bessere Leistung und 0 für zufälliges Erraten steht.
### Fläche unter der Kurve Empfänger-Betriebskennlinie
Prüft, wie gut das Modell zwischen Klassen unterscheidet. Es reicht von 0,0 bis 1,0, wobei 1,0 für eine perfekte Klassifizierung und 0,5 für zufälliges Erraten steht.
### Durchschnittliche Inferenzzeit
Misst die Vorhersagegeschwindigkeit, was für Echtzeitanwendungen von entscheidender Bedeutung ist. Berücksichtigen Sie bei der Bewertung dieser Kennzahl sowohl Geschwindigkeit als auch Konsistenz.
**Anmerkung**
Verlassen Sie sich bei der Modellauswahl nicht ausschließlich auf Genauigkeit. Bei unausgewogenen Datensätzen bieten Präzision, Rückruf und MCC zuverlässigere Indikatoren für die Leistung in der realen Welt.
## Vergleichen Sie die Leistung verschiedener Datensatztypen
Der **ausgewogene Datensatz** zeigt, wie gut Ihre Modelle unter idealen Bedingungen abschneiden, wobei positive und negative Beispiele zu gleichen Teilen dargestellt werden. Eine starke Leistung deutet darauf hin, dass das Modell grundlegende Textklassifizierungsmuster gelernt hat.
Der **verzerrte Datensatz** zeigt, wie Modelle mit einem realen Klassenungleichgewicht umgehen, das in Produktionsszenarien häufig vorkommt.
Der **anspruchsvolle Datensatz testet** die Robustheit des Modells in mehrdeutigen Fällen oder Randfällen, die in der Produktion auftreten könnten.
## Modellauswahl
Verwenden Sie diesen systematischen Ansatz, um das optimale Modell für Ihren speziellen Anwendungsfall auszuwählen.
### Definieren Sie Ihre Geschäftsprioritäten
Bevor Sie sich für ein Modell entscheiden, sollten Sie ermitteln, welche Leistungsfaktoren für Ihren Anwendungsfall am wichtigsten sind.
1. Identifizieren Sie Ihre Genauigkeitsanforderungen und die akzeptable Mindestleistungsschwelle.
1. Ermitteln Sie Ihre Latenzbeschränkungen, einschließlich der Frage, ob Sie eine Echtzeit- (<100 ms) oder eine Batch-Verarbeitung benötigen.
1. Legen Sie Ihre Kostenüberlegungen und Ihr Budget für Inferenz und Skalierung fest.
1. Analysieren Sie Ihre Dateneigenschaften, um herauszufinden, ob Ihre Produktionsdaten ausgewogen, verzerrt oder stark variabel sind.
### Wann sollten Sie sich für jedes Modell entscheiden
Wählen Sie auf der Grundlage Ihrer Bewertungsergebnisse das Modell aus, das am besten zu Ihrem Anwendungsfall passt:
+ **Entscheiden Sie sich für DistilBert**, wenn Sie schnellere Inferenzen mit hoher Genauigkeit benötigen, wie z. B. Stimmungsanalysen in Echtzeit in Kundenservice-Chatbots, Systemen zur Inhaltsmoderation oder Anwendungen, bei denen Reaktionszeiten unter 100 ms entscheidend sind.
+ **Entscheiden Sie sich für BERT**, wenn maximale Genauigkeit wichtiger ist als Geschwindigkeit, z. B. bei der Klassifizierung von Rechtsdokumenten, der Analyse medizinischer Texte oder bei Compliance-Anwendungen, bei denen Präzision an erster Stelle steht und die Stapelverarbeitung akzeptabel ist.
### Priorisieren Sie Ihre Bewertungsdatensätze
Konzentrieren Sie sich auf die Datensätze, die Ihren realen Anwendungsfall am besten repräsentieren.
1. Geben Sie dem Datensatz, der Ihren realen Daten am ehesten ähnelt, mehr Gewicht.
1. Berücksichtigen Sie die Bedeutung von Grenzfällen in Ihrer Anwendung und priorisieren Sie die Leistung anspruchsvoller Datensätze entsprechend.
1. Gleichen Sie die Optimierung auf mehrere Szenarien ab, anstatt sich nur auf einen Datensatztyp zu konzentrieren.
Vergleichen Sie Ihre Bewertungsergebnisse mit diesen Prioritäten, um das Modell auszuwählen, das Ihren Anforderungen an Genauigkeit, Geschwindigkeit und Kosten am besten gerecht wird.
Nachdem Sie Ihr bevorzugtes Modell ausgewählt haben, sind Sie bereit für den Einsatz in der Produktion. Fahren Sie fort mit [Bereitstellen Ihres Modells](jumpstart-text-classification-scale.md).
# Bereitstellen Ihres Modells
Richten Sie auto-scaling und CloudWatch Überwachung für Ihren SageMaker KI-Endpunkt ein, um ihn produktionsbereit zu machen.
## Warum Produktionsüberwachung für die Textklassifizierung wichtig ist
Workloads zur Textklassifizierung müssen überwacht werden, weil sie:
+ Erleben Sie wechselnde Datenverkehrsmuster mit Verarbeitungsspitzen.
+ Erfordern Reaktionszeiten von weniger als einer Sekunde.
+ Benötigen Sie Kostenoptimierung durch auto-scaling.
## Voraussetzungen
Bevor Sie beginnen, stellen Sie über Folgendes verfügen:
+ Ihr SageMaker KI-Endpunkt, der aus dem vorherigen Abschnitt bereitgestellt wurde.
+ Ihr Endpunktname (zum Beispiel jumpstart-dft-hf-tc).
+ Ihr AWS-Region (zum Beispiel us-east-2).
[Informationen zur Erstellung von Endpunkten oder zur Fehlerbehebung finden Sie unter Inferenz in Echtzeit.](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints.html)
## Einrichten Ihrer Produktionsüberwachung
Konfigurieren Sie die CloudWatch Überwachung, um die Leistung Ihres Modells in der Produktion zu verfolgen.
1. Öffnen Sie in Ihrem JupyterLab Bereich das `sagemaker_production_monitoring.ipynb` Notizbuch aus dem Testpaket, das Sie zuvor hochgeladen haben.
1. Aktualisieren Sie Ihren Endpunktnamen und Ihre Region im Konfigurationsbereich.
1. Bitte befolgen Sie die Anweisungen im Notebook, um die Einrichtung durchzuführen:
+ Automatische Skalierung (1 –10 Instances basierend auf dem Datenverkehr).
+ CloudWatch Alarme für Latenz- und Aufruf-Schwellenwerte.
+ Metrik-Dashboard für die visuelle Überwachung.
## Überprüfen Ihrer Einrichtung
Nachdem Sie die Schritte im Notebook abgeschlossen haben, stellen Sie sicher, dass Sie über Folgendes verfügen:
+ **Endpunktstatus**: `InService`
+ **Automatische Skalierung**: 1 –10 Instances konfiguriert.
+ **CloudWatch Alarme**: Überwachung von 2 Alarmen.
+ **Metriken**: Über 15 registrierte Metriken.
**Anmerkung**
`INSUFFICIENT_DATA`Anfangs können Alarme angezeigt werden – das ist normal und ändert sich `OK` mit der Nutzung.
## Überwachen eines Endpunkts
Greifen Sie über die AWS Managementkonsole auf die visuelle Überwachung zu:
+ [CloudWatch Metriken](https://console.aws.amazon.com/cloudwatch/home#metricsV2:graph=~();query=AWS/SageMaker)
+ [CloudWatch Alarme](https://console.aws.amazon.com/cloudwatch/home#alarmsV2:)
Weitere Informationen finden Sie unter [Monitor SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-overview.html).
## Kosten verwalten und Ressourcen bereinigen
Ihr Monitoring-Setup bietet wertvolle Einblicke in die Produktion, verursacht aber auch laufende AWS Gebühren durch CloudWatch Kennzahlen, Alarme und Richtlinien zur auto-scaling. Für einen kostengünstigen Betrieb ist es wichtig zu wissen, wie diese Kosten verwaltet werden können. Bereinigen Sie die Ressourcen, wenn diese nicht mehr benötigt werden.
**Warnung**
Für Ihren Endpunkt fallen weiterhin Gebühren an, auch wenn Anfragen nicht bearbeitet werden. Zum Stoppen aller Gebühren müssen Sie Ihren Endpunkt löschen. Anweisungen finden Sie unter [Löschen von Endpunkten und Ressourcen](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-delete-resources.html).
Erweiterte Überwachungskonfigurationen finden Sie unter [CloudWatch Metrics for SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html).
# Fairness, Erklärbarkeit von Modellen und Erkennung von Verzerrungen mit Clarify SageMaker
Sie können Amazon SageMaker Clarify verwenden, um Fairness und die Erklärbarkeit von Modellen zu verstehen und um Verzerrungen in Ihren Modellen zu erklären und zu erkennen. Sie können einen SageMaker Clarif-Verarbeitungsauftrag so konfigurieren, dass Messwerte für Verzerrungen und Merkmalszuweisungen berechnet und Berichte zur Erklärbarkeit des Modells generiert werden. SageMaker Clarif-Verarbeitungsaufträge werden mithilfe eines speziellen SageMaker Clarif-Container-Images implementiert. Auf der folgenden Seite wird beschrieben, wie SageMaker Clarify funktioniert und wie Sie mit einer Analyse beginnen können.
## Was bedeutet Fairness und Modellverständlichkeit für Vorhersagen im Bereich Machine Learning?
Machine-Learning-Modelle (ML) unterstützen die Entscheidungsfindung in Bereichen wie Finanzdienstleistungen, Gesundheitswesen, Bildung und Personalwesen. Politische Entscheidungsträger, Aufsichtsbehörden und Befürworter haben das Bewusstsein für die ethischen und politischen Herausforderungen geschärft, die Machine Learning und datengesteuerte Systeme mit sich bringen. Amazon SageMaker Clarify kann Ihnen helfen zu verstehen, warum Ihr ML-Modell eine bestimmte Vorhersage getroffen hat und ob sich diese Verzerrung während des Trainings oder der Inferenz auf diese Vorhersage auswirkt. SageMaker Clarify bietet auch Tools, mit denen Sie weniger voreingenommene und verständlichere Modelle für maschinelles Lernen erstellen können. SageMaker Clarify kann auch Modellberichte zur Unternehmensführung erstellen, die Sie Risiko- und Compliance-Teams sowie externen Aufsichtsbehörden zur Verfügung stellen können. Mit SageMaker Clarify können Sie Folgendes tun:
+ Erkennen Sie Verzerrungen und helfen Sie dabei, Ihre Modellvorhersagen zu erklären.
+ Identifizieren Sie die Arten von Verzerrungen in den Daten vor dem Training.
+ Identifizieren Sie Arten von Verzerrungen in den Daten nach dem Training, die während des Trainings oder während der Produktion Ihres Modells auftreten können.
SageMaker Clarify hilft zu erklären, wie Ihre Modelle mithilfe von Feature-Attributionen Vorhersagen treffen. Es kann auch Inferenzmodelle, die sich in der Produktion befinden, sowohl auf Verzerrungen als auch auf Drift bei der Feature-Attribution überwachen. Diese Informationen können Ihnen in folgenden Bereichen behilflich sein:
+ **Regulatorische Vorschriften** – Politische Entscheidungsträger und andere Aufsichtsbehörden können Bedenken haben, dass Entscheidungen, die Ergebnisse von ML-Modellen verwenden, diskriminierende Auswirkungen haben. Ein ML-Modell kann beispielsweise Verzerrungen kodieren und eine automatisierte Entscheidung beeinflussen.
+ **Wirtschaft** – Regulierte Bereiche benötigen möglicherweise zuverlässige Erklärungen dafür, wie ML-Modelle Vorhersagen treffen. Die Erklärbarkeit der Modelle kann für Branchen besonders wichtig sein, die auf Zuverlässigkeit, Sicherheit und Konformität angewiesen sind. Dazu können Finanzdienstleistungen, Personalwesen, Gesundheitswesen und automatisiertes Transportwesen gehören. Beispielsweise müssen Kreditanträge möglicherweise Erläuterungen dazu enthalten, wie ML-Modelle bestimmte Prognosen für Kreditsachbearbeiter, Prognostiker und Kunden getroffen haben.
+ **Datenwissenschaft** – Datenwissenschaftler und ML-Ingenieure können ML-Modelle debuggen und verbessern, wenn sie feststellen können, ob ein Modell auf der Grundlage verrauschter oder irrelevanter Merkmale Schlüsse zieht. Sie können auch die Einschränkungen ihrer Modelle und die Fehlerquellen verstehen, auf die ihre Modelle stoßen können.
Einen Blogbeitrag, der zeigt, wie man ein vollständiges Modell für maschinelles Lernen für betrügerische Automobilschadensfälle konzipiert und erstellt, das SageMaker Clarify in eine SageMaker KI-Pipeline integriert, finden Sie unter The [Architect und erstellen Sie den gesamten Machine-Learning-Lebenszyklus mit AWS: einer end-to-end Amazon SageMaker AI-Demo](https://aws.amazon.com/blogs/machine-learning/architect-and-build-the-full-machine-learning-lifecycle-with-amazon-sagemaker/). Dieser Blogbeitrag befasst sich mit der Bewertung und Minderung von Verzerrungen vor und nach dem Training sowie mit den Auswirkungen der Features auf die Modellprognose. Der Blogbeitrag enthält Links zu Beispielcode für jede Aufgabe im ML-Lebenszyklus.
### Bewährte Methoden zur Bewertung von Fairness und Erklärbarkeit im ML-Lebenszyklus
**Fairness als Prozess**: Die Begriffe Voreingenommenheit und Fairness hängen von ihrer Anwendung ab. Die Messung der Verzerrung und die Wahl der Messwerte für die Verzerrung können sich an sozialen, rechtlichen und anderen nichttechnischen Überlegungen orientieren. Die erfolgreiche Einführung fairnessorientierter ML-Ansätze beinhaltet die Konsensbildung und die Zusammenarbeit zwischen den wichtigsten Interessengruppen. Dazu können Produkte, Richtlinien, Recht, Technik, AI/ML Teams, Endbenutzer und Gemeinschaften gehören.
**Fairness und erklärbare Gestaltung im ML-Lebenszyklus** – Berücksichtigen Sie Fairness und Erklärbarkeit in jeder Phase des ML-Lebenszyklus. Diese Phasen umfassen die Problemformulierung, die Erstellung des Datensatzes, die Auswahl des Algorithmus, den Modelltrainingsprozess, den Testprozess, die Bereitstellung sowie die Überwachung und Rückmeldung. Für diese Analyse ist es wichtig, über die richtigen Tools zu verfügen. Wir empfehlen, während des ML-Lebenszyklus die folgenden Fragen zu stellen:
+ Fördert das Modell Rückkopplungsschleifen, die zu zunehmend unfairen Ergebnissen führen können?
+ Ist ein Algorithmus eine ethische Lösung für das Problem?
+ Sind die Trainingsdaten repräsentativ für verschiedene Gruppen?
+ Gibt es Verzerrungen bei Bezeichnungen oder Merkmalen?
+ Müssen die Daten geändert werden, um Verzerrungen zu verringern?
+ Müssen Fairnessbeschränkungen in die Zielfunktion aufgenommen werden?
+ Wurde das Modell anhand relevanter Fairness-Kennzahlen bewertet?
+ Gibt es ungleiche Auswirkungen auf die einzelnen Nutzer?
+ Wird das Modell in einer Population eingesetzt, für die es nicht trainiert oder evaluiert wurde?
![\[Bewährte Verfahren für den Prozess der Bewertung von Fairness und Erklärbarkeit von Modellen.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/clarify-best-practices-image.png)
### Leitfaden zu den SageMaker KI-Erläuterungen und der Dokumentation zu Vorurteilen
Verzerrungen können sowohl vor als auch nach dem Training eines Modells auftreten und in den Daten gemessen werden. SageMaker Clarify kann Erklärungen für Modellvorhersagen nach dem Training und für Modelle liefern, die in der Produktion eingesetzt werden. SageMaker Clarify kann auch Modelle, die sich in der Produktion befinden, auf Abweichungen bei ihren grundlegenden erklärenden Attributen hin überwachen und bei Bedarf Basiswerte berechnen. Die Dokumentation zur Erklärung und Erkennung von Verzerrungen mithilfe von SageMaker Clarify ist wie folgt strukturiert:
+ Informationen zur Einrichtung eines Verarbeitungsauftrags aus Gründen der Verzerrung und Erklärbarkeit finden Sie unter [Einen SageMaker Clarif-Verarbeitungsjob konfigurieren](clarify-processing-job-configure-parameters.md).
+ Informationen zur Erkennung von Verzerrungen bei der Vorverarbeitung von Daten, bevor sie zum Trainieren eines Modells verwendet werden, finden Sie unter [Datenverzerrungen vor dem Training](clarify-detect-data-bias.md).
+ Informationen zur Erkennung von Daten nach dem Training und Modellverzerrungen finden Sie unter [Daten nach dem Training und Modellverzerrungen](clarify-detect-post-training-bias.md).
+ Informationen zum modellunabhängigen Ansatz der Feature-Attribution zur Erklärung von Modellprognose nach dem Training finden Sie unter [Erklärbarkeit des Modells](clarify-model-explainability.md).
+ Weitere Informationen zur Überwachung der Abweichungen der Beiträge der Features vom Ausgangswert, der während der Modelltraining ermittelt wurde, finden Sie unter [Feature-Attributions-Drift für Modelle in der Produktion](clarify-model-monitor-feature-attribution-drift.md).
+ Informationen zu Überwachungsmodellen, die für die Basislinienverschiebung in Produktion sind, finden Sie unter [Bias-Drift bei Modellen in der Produktion](clarify-model-monitor-bias-drift.md).
+ Informationen zum Abrufen von Erklärungen in Echtzeit von einem SageMaker KI-Endpunkt finden Sie unter[Online-Erklärbarkeit mit Clarify SageMaker](clarify-online-explainability.md).
## Wie SageMaker Clarify Processing Jobs funktionieren
Sie können SageMaker Clarify verwenden, um Ihre Datensätze und Modelle auf Erklärbarkeit und Verzerrungen zu analysieren. Ein SageMaker Clarif-Verarbeitungsauftrag verwendet den SageMaker Clarif-Verarbeitungscontainer, um mit einem Amazon S3 S3-Bucket zu interagieren, der Ihre Eingabedatensätze enthält. Sie können SageMaker Clarify auch verwenden, um ein Kundenmodell zu analysieren, das auf einem SageMaker KI-Inferenzendpunkt eingesetzt wird.
Die folgende Grafik zeigt, wie ein SageMaker Clarif-Verarbeitungsjob mit Ihren Eingabedaten und optional mit einem Kundenmodell interagiert. Diese Interaktion hängt von der spezifischen Art der durchgeführten Analyse ab. Der SageMaker Clarify-Verarbeitungscontainer bezieht den Eingabedatensatz und die Konfiguration für die Analyse aus einem S3-Bucket. Für bestimmte Analysetypen, einschließlich der Merkmalsanalyse, muss SageMaker der Clarifesty-Verarbeitungscontainer Anfragen an den Modellcontainer senden. Anschließend ruft er die Modellvorhersagen aus der Antwort ab, die der Modellcontainer sendet. Danach berechnet der SageMaker Clarify-Verarbeitungscontainer die Analyseergebnisse und speichert sie im S3-Bucket.
![\[SageMaker Clarify kann Ihre Daten oder ein Kundenmodell auf Erklärbarkeit und Voreingenommenheit hin analysieren.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/clarify/clarify-processing-job.png)
Sie können einen SageMaker Clarif-Verarbeitungsauftrag in mehreren Phasen des Lebenszyklus des maschinellen Lernens ausführen. SageMaker Clarify kann Ihnen bei der Berechnung der folgenden Analysetypen helfen:
+ Verzerrungsmetriken vor dem Training. Diese Metriken können Ihnen helfen, die Verzerrung in Ihren Daten zu verstehen, sodass Sie sie beheben und Ihr Modell anhand eines faireren Datensatzes trainieren können. Weitere Informationen über Messwerte [Messwerte zu Verzerrungen vor dem Training](clarify-measure-data-bias.md) für Verzerrungen vor dem Training finden Sie unter. Um einen Auftrag zur Analyse von Verzerrungsmetriken vor dem Training auszuführen, müssen Sie den Datensatz und eine Konfigurationsdatei für die JSON-Analyse bereitstellen. [Analyse-Konfigurationsdateien](clarify-processing-job-configure-analysis.md)
+ Verzerrungsmetrik nach dem Training. Diese Metriken nach dem Training können Ihnen dabei helfen, Verzerrungen zu verstehen, die durch einen Algorithmus, durch Hyperparameter-Entscheidungen oder durch Verzerrungen verursacht wurden, oder jegliche Verzerrungen, die zu einem früheren Zeitpunkt nicht offensichtlich waren. Weitere Informationen zu Messwerten für Verzerrungen nach dem Training finden Sie unter[Daten nach dem Training und Modellverzerrungenmetriken](clarify-measure-post-training-bias.md). SageMaker Clarify verwendet die Modellvorhersagen zusätzlich zu den Daten und Bezeichnungen, um Verzerrungen zu identifizieren. Um einen Auftrag zur Analyse von Verzerrungsmetriken nach dem Training auszuführen, müssen Sie den Datensatz und eine Konfigurationsdatei für die JSON-Analyse bereitstellen. Die Konfiguration sollte den Modell- oder Endpunktnamen enthalten.
+ Shapley-Werte, die Ihnen dabei helfen können, zu verstehen, welchen Einfluss Ihre Features auf die Prognose Ihres Modells hat. Weitere Informationen zu Shapley-Werten finden Sie unter [Feature-Attributionen, die Shapley-Werte verwenden](clarify-shapley-values.md). Für diese Funktion ist ein trainiertes Modell erforderlich.
+ Partielle Abhängigkeitsdiagramme (PDPs), anhand derer Sie besser verstehen können, wie stark sich Ihre vorhergesagte Zielvariable ändern würde, wenn Sie den Wert eines Merkmals variieren würden. Weitere Informationen zu finden Sie PDPs unter Für [Analyse partieller Abhängigkeitsdiagramme (PDPs)](clarify-processing-job-analysis-results.md#clarify-processing-job-analysis-results-pdp) diese Funktion ist ein trainiertes Modell erforderlich.
SageMaker Clarify benötigt Modellvorhersagen, um Messwerte und Merkmalszuordnungen nach dem Training berechnen zu können. *Sie können einen Endpunkt angeben oder SageMaker Clarify erstellt anhand Ihres Modellnamens einen kurzlebigen Endpunkt, der auch als Schattenendpunkt bezeichnet wird.* Der SageMaker Clarith-Container löscht den Schattenendpunkt, nachdem die Berechnungen abgeschlossen sind. Auf einer höheren Ebene führt der SageMaker Clarith-Container die folgenden Schritte aus:
1. Überprüft Eingaben und Parameter.
1. Erzeugt den Schattenendpunkt (falls ein Modellname angegeben wird).
1. Lädt den Eingabedatensatz in einen Datenrahmen.
1. Ruft bei Bedarf Modellvorhersagen vom Endpunkt ab.
1. Berechnet Messwerte für Verzerrungen und Merkmalszuschreibungen.
1. Löscht den Schattenendpunkt.
1. Generieren Sie die Analyseergebnisse.
Nach Abschluss SageMaker des Clarif-Verarbeitungsauftrags werden die Analyseergebnisse an dem Ausgabeort gespeichert, den Sie im Verarbeitungsausgabeparameter des Jobs angegeben haben. Zu diesen Ergebnissen gehören eine JSON-Datei mit Bias-Metriken und globalen Feature-Attributionen, ein grafischer Bericht und zusätzliche Dateien für lokale Feature-Attributionen. Sie können die Ergebnisse vom Ausgabespeicherort herunterladen und anzeigen.
Weitere Informationen zu Bias-Metriken, Erklärbarkeit und deren Interpretation finden [Sie unter Erfahren Sie, wie Amazon SageMaker Clarify hilft, Verzerrungen zu erkennen](https://aws.amazon.com/blogs/machine-learning/learn-how-amazon-sagemaker-clarify-helps-detect-bias), [Fairnessmaßnahmen für Machine Learning im Finanzwesen und im](https://pages.awscloud.com/rs/112-TZM-766/images/Fairness.Measures.for.Machine.Learning.in.Finance.pdf) [Amazon AI Fairness](https://pages.awscloud.com/rs/112-TZM-766/images/Amazon.AI.Fairness.and.Explainability.Whitepaper.pdf) and Explainability Whitepaper.
# Einen SageMaker Clarif-Verarbeitungsjob konfigurieren
Um Ihre Daten und Modelle mit SageMaker Clarify auf Verzerrungen und Erklärbarkeit zu analysieren, müssen Sie einen SageMaker Clarif-Verarbeitungsjob konfigurieren. Diese Anleitung zeigt, wie Sie den Namen des Eingabedatensatzes, den Namen der Analysekonfigurationsdatei und den Ausgabespeicherort für einen Verarbeitungsauftrag angeben. Um den Verarbeitungscontainer, die Auftragseingaben, -ausgaben, Ressourcen und andere Parameter zu konfigurieren, haben Sie zwei Möglichkeiten. Sie können entweder die SageMaker `CreateProcessingJob` KI-API oder die SageMaker AI Python SDK-API `SageMaker ClarifyProcessor` verwenden.
Informationen zu Parametern, die allen Verarbeitungsaufträgen gemeinsam sind, finden Sie in der [Amazon SageMaker API-Referenz](https://docs.aws.amazon.com/sagemaker/latest/APIReference/Welcome.html?icmpid=docs_sagemaker_lp).
## Konfigurieren Sie einen SageMaker Clarif-Verarbeitungsauftrag mithilfe der SageMaker API
Die folgenden Anweisungen zeigen, wie Sie jeden Teil der SageMaker Clarify-spezifischen Konfiguration mithilfe der `CreateProcessingJob` API bereitstellen.
1. Geben Sie den Uniform Research Identifier (URI) eines SageMaker Clarif-Container-Images in den `AppSpecification` Parameter ein, wie im folgenden Codebeispiel gezeigt.
```
{
"ImageUri": "the-clarify-container-image-uri"
}
```
**Anmerkung**
Die URI muss ein vorgefertigtes SageMaker Clarify-Container-Image identifizieren. `ContainerEntrypoint`und `ContainerArguments` werden nicht unterstützt. Weitere Informationen zu SageMaker Clarif-Container-Images finden Sie unter[Vorgefertigte SageMaker Clarify-Container](clarify-processing-job-configure-container.md).
1. Geben Sie im Parameter sowohl die Konfiguration für Ihre Analyse als auch die `ProcessingInputs` Parameter für Ihren Eingabedatensatz an.
1. Geben Sie den Speicherort der Konfigurationsdatei für die JSON-Analyse an, die die Parameter für die Verzerrungsanalyse und die Erklärbarkeitsanalyse enthält. Der `InputName` Parameter des `ProcessingInput` Objekts muss **analysis\$1config** wie im folgenden Codebeispiel dargestellt sein.
```
{
"InputName": "analysis_config",
"S3Input": {
"S3Uri": "s3://your-bucket/analysis_config.json",
"S3DataType": "S3Prefix",
"S3InputMode": "File",
"LocalPath": "/opt/ml/processing/input/config"
}
}
```
Weitere Informationen zum Schema der Analyse-Konfigurationsdatei finden Sie unter [Analyse-Konfigurationsdateien](clarify-processing-job-configure-analysis.md).
1. Geben Sie den Speicherort des Eingabedatensatzes an. Der `InputName` Parameter des `ProcessingInput` Objekts muss `dataset` sein. Dieser Parameter ist optional, wenn Sie den „dataset\$1uri“ in der Analysekonfigurationsdatei angegeben haben. Die folgenden Werte sind in der `S3Input` Konfiguration erforderlich.
1. `S3Uri`kann entweder ein Amazon S3-Objekt oder ein S3-Präfix sein.
1. `S3InputMode` muss vom Typ **File** sein.
1. `S3CompressionType` muss vom Typ `None` sein (der Standardwert).
1. `S3DataDistributionType` muss vom Typ `FullyReplicated` sein (der Standardwert).
1. `S3DataType` kann `S3Prefix` oder `ManifestFile` sein. Zur Verwendung `ManifestFile` muss der `S3Uri` Parameter den Speicherort einer Manifestdatei angeben, die dem Schema aus dem SageMaker API-Referenzabschnitt [S3Uri](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html#sagemaker-Type-S3DataSource-S3Uri) folgt. Diese Manifestdatei muss die S3-Objekte auflisten, die die Eingabedaten für den Auftrag enthalten.
Der folgende Code zeigt ein Beispiel für eine Eingabekonfiguration.
```
{
"InputName": "dataset",
"S3Input": {
"S3Uri": "s3://your-bucket/your-dataset.csv",
"S3DataType": "S3Prefix",
"S3InputMode": "File",
"LocalPath": "/opt/ml/processing/input/data"
}
}
```
1. Geben Sie die Konfiguration für die Ausgabe des Verarbeitungsauftrag im `ProcessingOutputConfig` Parameter an. In der `Outputs` Konfiguration ist ein einzelnes `ProcessingOutput` Objekt erforderlich. Folgendes ist für die Ausgabekonfiguration erforderlich:
1. `OutputName` muss **analysis\$1result** sein.
1. `S3Uri`muss ein S3-Präfix für den Ausgabespeicherort sein.
1. muss `S3UploadMode` auf **EndOfJob** festgelegt sein.
Die folgende Ausgabe des Befehls zeigt ein Beispiel dieses Zustands:
```
{
"Outputs": [{
"OutputName": "analysis_result",
"S3Output": {
"S3Uri": "s3://your-bucket/result/",
"S3UploadMode": "EndOfJob",
"LocalPath": "/opt/ml/processing/output"
}
}]
}
```
1. Geben Sie im `ProcessingResources` Parameter die Konfiguration `ClusterConfig` für die Ressourcen an, die Sie in Ihrem Verarbeitungsjob verwenden. Die folgenden Parameter sind innerhalb des `ClusterConfig` Objekts erforderlich.
1. `InstanceCount` gibt die Anzahl der Rechen-Instances im Cluster an, der den Verarbeitungsauftrag ausführt. Geben Sie einen Wert größer als `1` an, um die verteilte Verarbeitung zu aktivieren.
1. `InstanceType` bezieht sich auf die Ressourcen, die Ihren Verarbeitungsauftrag ausführen. Da die SageMaker KI-SHAP-Analyse rechenintensiv ist, sollte die Verwendung eines Instanztyps, der für die Datenverarbeitung optimiert ist, die Laufzeit für die Analyse verbessern. Der Verarbeitungsauftrag SageMaker Clarify verwendet nicht. GPUs
In der folgenden Abbildung sehen Sie ein Beispiel für die Registerkarte Configuration (Konfiguration).
```
{
"ClusterConfig": {
"InstanceCount": 1,
"InstanceType": "ml.m5.xlarge",
"VolumeSizeInGB": 20
}
}
```
1. Geben Sie die Konfiguration des Netzwerks, das Sie für Ihren Verarbeitungsauftrag verwenden, innerhalb des `NetworkConfig` Objekts an. Die folgenden Werte sind für die Konfiguration erforderlich.
1. `EnableNetworkIsolation`muss auf `False` (Standard) gesetzt sein, damit SageMaker Clarify bei Bedarf einen Endpunkt für Vorhersagen aufrufen kann.
1. Wenn sich das Modell oder der Endpunkt, den Sie für den SageMaker Clarif-Job bereitgestellt haben, in einer Amazon Virtual Private Cloud (Amazon VPC) befindet, muss sich der SageMaker Clarif-Job auch in derselben VPC befinden. Geben Sie die VPC mit [VpcConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_VpcConfig.html)an. Darüber hinaus muss die VPC über Endpunkte für einen Amazon S3 S3-Bucket, einen SageMaker AI-Service und einen SageMaker AI Runtime-Service verfügen.
Wenn die verteilte Verarbeitung aktiviert ist, müssen Sie auch die Kommunikation zwischen verschiedenen Instances im selben Verarbeitungsjob zulassen. Konfigurieren Sie dazu eine Regel für Ihre Sicherheitsgruppe, mit der eingehende Verbindungen zwischen Mitgliedern derselben Sicherheitsgruppe zugelassen werden. Weitere Informationen finden Sie unter [Gewähren Sie Amazon SageMaker Clarify Jobs Zugriff auf Ressourcen in Ihrer Amazon VPC](clarify-vpc.md).
Der folgende Code gibt ein Beispiel für eine Netzwerkkonfiguration.
```
{
"EnableNetworkIsolation": False,
"VpcConfig": {
...
}
}
```
1. Legen Sie mithilfe des `StoppingCondition` Parameters die maximale Zeit fest, für die der Auftrag ausgeführt werden soll. Die längste Laufzeit eines SageMaker Clarif-Jobs beträgt `7` Tage oder `604800` Sekunden. Wenn der Auftrag nicht innerhalb dieser Frist abgeschlossen werden kann, wird er gestoppt und es werden keine Analyseergebnisse bereitgestellt. Die folgende Konfiguration begrenzt beispielsweise die maximale Zeit, für die der Auftrag ausgeführt werden kann, auf 3600 Sekunden.
```
{
"MaxRuntimeInSeconds": 3600
}
```
1. Geben Sie eine IAM-Rolle für den `RoleArn` Parameter an. Die Rolle muss ein Vertrauensverhältnis mit Amazon SageMaker AI haben. Sie kann verwendet werden, um die in der folgenden Tabelle aufgeführten SageMaker API-Operationen durchzuführen. Wir empfehlen die Verwendung der verwalteten Amazon SageMaker AIFull Access-Richtlinie, die vollen Zugriff auf SageMaker KI gewährt. Weitere Informationen zu dieser Richtlinie finden Sie unter [AWS verwaltete Richtlinie: AmazonSageMakerFullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonSageMakerFullAccess). Wenn Sie Bedenken haben, Vollzugriff zu gewähren, hängen die erforderlichen Mindestberechtigungen davon ab, ob Sie einen Modell- oder einen Endpunktnamen angeben. Die Verwendung eines Endpunktnamens ermöglicht es, SageMaker KI weniger Berechtigungen zu gewähren.
Die folgende Tabelle enthält API-Operationen, die vom SageMaker Clarif-Verarbeitungsjob verwendet werden. Auf **X** unter **Modellname** und **Endpunktname** wird der API-Vorgang angegeben, der für jede Eingabe erforderlich ist.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/clarify-processing-job-configure-parameters.html)
Weitere Informationen zu erforderlichen Berechtigungen finden Sie unter [Amazon SageMaker AI API-Berechtigungen: Referenz zu Aktionen, Berechtigungen und Ressourcen](api-permissions-reference.md).
Weitere Informationen zur Übertragung von Rollen an SageMaker KI finden Sie unter[Rollen weitergeben](sagemaker-roles.md#sagemaker-roles-pass-role).
Nachdem Sie die einzelnen Teile der Konfiguration des Verarbeitungsauftrags erstellt haben, kombinieren Sie sie, um den Auftrag zu konfigurieren.
## Konfigurieren Sie einen SageMaker Clarif-Verarbeitungsjob mit dem AWS SDK für Python
Das folgende Codebeispiel zeigt, wie ein SageMaker Clarif-Verarbeitungsjob mit dem [AWS SDK für Python](https://aws.amazon.com/sdk-for-python/) gestartet wird.
```
sagemaker_client.create_processing_job(
ProcessingJobName="your-clarify-job-name",
AppSpecification={
"ImageUri": "the-clarify-container-image-uri",
},
ProcessingInputs=[{
"InputName": "analysis_config",
"S3Input": {
"S3Uri": "s3://your-bucket/analysis_config.json",
"S3DataType": "S3Prefix",
"S3InputMode": "File",
"LocalPath": "/opt/ml/processing/input/config",
},
}, {
"InputName": "dataset",
"S3Input": {
"S3Uri": "s3://your-bucket/your-dataset.csv",
"S3DataType": "S3Prefix",
"S3InputMode": "File",
"LocalPath": "/opt/ml/processing/input/data",
},
},
],
ProcessingOutputConfig={
"Outputs": [{
"OutputName": "analysis_result",
"S3Output": {
"S3Uri": "s3://your-bucket/result/",
"S3UploadMode": "EndOfJob",
"LocalPath": "/opt/ml/processing/output",
},
}],
},
ProcessingResources={
"ClusterConfig": {
"InstanceCount": 1,
"InstanceType": "ml.m5.xlarge",
"VolumeSizeInGB": 20,
},
},
NetworkConfig={
"EnableNetworkIsolation": False,
"VpcConfig": {
...
},
},
StoppingCondition={
"MaxRuntimeInSeconds": 3600,
},
RoleArn="arn:aws:iam:::role/service-role/AmazonSageMaker-ExecutionRole",
)
```
Ein Beispiel-Notizbuch mit Anweisungen zum Ausführen eines SageMaker Clarif-Verarbeitungsjobs mithilfe des AWS SDK für Python finden Sie unter [Fairness and Explainability with SageMaker Clarify using AWS SDK for](http://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-clarify/fairness_and_explainability/fairness_and_explainability_boto3.ipynb) Python. Jeder im Notebook verwendete S3-Bucket muss sich in derselben AWS Region befinden wie die Notebook-Instanz, die darauf zugreift.
## Konfigurieren Sie einen SageMaker Clarif-Verarbeitungsjob mit dem SageMaker Python-SDK
Sie können einen SageMaker Clarif-Verarbeitungsjob auch mithilfe der [SageMaker ClarifyProcessor](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html#sagemaker.clarify.SageMakerClarifyProcessor)in der SageMaker Python SDK API konfigurieren. Weitere Informationen finden Sie unter [Führen Sie SageMaker Clarify Processing Jobs aus, um Verzerrungen zu analysieren und zu erklären](clarify-processing-job-run.md).
**Topics**
+ [Vorgefertigte SageMaker Clarify-Container](clarify-processing-job-configure-container.md)
+ [Analyse-Konfigurationsdateien](clarify-processing-job-configure-analysis.md)
+ [Leitfaden zur Kompatibilität von Datenformaten](clarify-processing-job-data-format.md)
# Vorgefertigte SageMaker Clarify-Container
Amazon SageMaker AI stellt vorgefertigte SageMaker Clarify-Container-Images bereit, die die Bibliotheken und andere Abhängigkeiten enthalten, die für die Berechnung von Verzerrungsmetriken und Merkmalszuweisungen zur besseren Verständlichkeit erforderlich sind. Mit diesen Bildern können [Clarif-Verarbeitungsaufträge](processing-job.md) in SageMaker Ihrem Konto ausgeführt werden.
Das Bild URIs für die Container hat das folgende Format:
```
.dkr.ecr..amazonaws.com/sagemaker-clarify-processing:1.0
```
Beispiel:
```
111122223333.dkr.ecr.us-east-1.amazonaws.com/sagemaker-clarify-processing:1.0
```
In der folgenden Tabelle sind die Adressen nach aufgeführt AWS-Region.
Docker-Images für SageMaker Clarify Processing Jobs
| Region | Adresse des Bilds |
| --- | --- |
| USA Ost (Nord-Virginia) | 205585389593.dkr. ecr.us-east-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| USA Ost (Ohio) | 211330385671.dkr. ecr.us-east-2.amazonaws.com /:1.0 sagemaker-clarify-processing |
| USA West (Nordkalifornien) | 740489534195.dkr. ecr.us-west-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| USA West (Oregon) | 306415355426.dkr. ecr.us-west-2.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Asien-Pazifik (Hongkong) | 098760798382.dkr. ecr.ap-east-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Asien-Pazifik (Mumbai) | 452307495513.dkr. ecr.ap-south-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Asien-Pazifik (Jakarta) | 705930551576.dkr. ecr.ap-southeast-3.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Asien-Pazifik (Tokio) | 377024640650.dkr. ecr.ap-northeast-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Asien-Pazifik (Seoul) | 263625296855.dkr. ecr.ap-northeast-2.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Asien-Pazifik (Osaka) | 912233562940.dkr. ecr.ap-northeast-3.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Asien-Pazifik (Singapur) | 834264404009.dkr. ecr.ap-southeast-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Asien-Pazifik (Sydney) | 007051062584.dkr. ecr.ap-southeast-2.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Kanada (Zentral) | 675030665977.dkr. ecr.ca-central-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Europa (Frankfurt) | 017069133835.dkr. ecr.eu-central-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Europa (Zürich) | 730335477804.dkr. ecr.eu-central-2.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Europa (Irland) | 131013547314.dkr. ecr.eu-west-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Europa (London) | 440796970383.dkr. ecr.eu-west-2.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Europa (Paris) | 341593696636.dkr. ecr.eu-west-3.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Europa (Stockholm) | 763603941244.dkr. ecr.eu-north-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Middle East (Bahrain) | 835444307964.dkr. ecr.me-south-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Südamerika (São Paulo) | 520018980103.dkr. ecr.sa-east-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Afrika (Kapstadt) | 811711786498.dkr. ecr.af-south-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| Europa (Milan) | 638885417683.dkr. ecr.eu-south-1.amazonaws.com /:1.0 sagemaker-clarify-processing |
| China (Peking) | 122526803553.dkr. ecr.cn-north-1.amazonaws.com .cn/:1.0 sagemaker-clarify-processing |
| China (Ningxia) | 122578899357.dkr. ecr.cn-northwest-1.amazonaws.com .cn/:1.0 sagemaker-clarify-processing |
# Analyse-Konfigurationsdateien
Um Ihre Daten und Modelle mit Clarify auf Erklärbarkeit und Verzerrung zu analysieren, müssen Sie einen Verarbeitungsjob konfigurieren. SageMaker Ein Teil der Konfiguration für diesen Verarbeitungsauftrag umfasst die Konfiguration einer Analysedatei. Die Analysedatei spezifiziert die Parameter für die Verzerrungsanalyse und die Erklärbarkeit. Weitere Informationen zur Konfiguration eines Verarbeitungsauftrags und einer Analysedatei finden Sie unter [Einen SageMaker Clarif-Verarbeitungsjob konfigurieren](clarify-processing-job-configure-parameters.md).
In diesem Handbuch werden das Schema und die Parameter für diese Analysekonfigurationsdatei beschrieben. Dieses Handbuch enthält auch Beispiele für Analysekonfigurationsdateien zur Berechnung von Verzerrungsmetriken für einen tabellarischen Datensatz und zur Generierung von Erklärungen für Probleme mit natürlicher Sprachverarbeitung (NLP), Computer Vision (CV) und Zeitreihen (TS).
Sie können die Analysekonfigurationsdatei erstellen oder das [SageMaker Python-SDK](https://sagemaker.readthedocs.io/) verwenden, um eine für Sie mit der [SageMaker ClarifyProcessor](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html#sagemaker.clarify.SageMakerClarifyProcessor)API zu generieren. Das Anzeigen des Dateiinhalts kann hilfreich sein, um die zugrunde liegende Konfiguration zu verstehen, die vom SageMaker Clarify-Job verwendet wird.
**Topics**
+ [Schema für die Analysekonfigurationsdatei](#clarify-processing-job-configure-schema)
+ [Beispielkonfigurationsdateien](#clarify-processing-job-configure-analysis-examples)
## Schema für die Analysekonfigurationsdatei
Im folgenden Abschnitt wird das Schema für die Analysekonfigurationsdatei beschrieben, einschließlich der Anforderungen und Beschreibungen der Parameter.
### Anforderungen an die Analysekonfigurationsdatei
Für den Verarbeitungsauftrag SageMaker Clarify wird erwartet, dass die Analysekonfigurationsdatei mit den folgenden Anforderungen strukturiert ist:
+ Der Name der Verarbeitungseingabe muss `analysis_config.` lauten.
+ Die Konfigurationsdatei für die Analyse liegt im JSON-Format vor und ist in UTF-8 codiert.
+ Die Analysekonfigurationsdatei ist ein Amazon S3-Objekt.
Sie können zusätzliche Parameter in der Analysekonfigurationsdatei angeben. Der folgende Abschnitt enthält verschiedene Optionen, mit denen Sie den SageMaker Clarif-Verarbeitungsjob an Ihren Anwendungsfall und die gewünschten Analysetypen anpassen können.
### Parameter für Analysekonfigurationsdateien
In der Analysekonfigurationsdatei können Sie die folgenden Parameter angeben.
+ **Version** – (Optional) Die Versionszeichenfolge des Schemas der Analysekonfigurationsdatei. Wenn keine Version bereitgestellt wird, verwendet SageMaker Clarify die neueste unterstützte Version. Derzeit wird nur die Version `1.0` unterstützt.
+ **dataset\$1type** – Das Format des Datensatzes. Das Eingabedatensatzformat kann jeder der folgenden Werte sein:
+ Tabellarisch
+ `text/csv` für CSV
+ `application/jsonlines`für das [dichte Format SageMaker AI JSON Lines](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html#cm-jsonlines)
+ `application/json` für JSON
+ `application/x-parquet` für Apache Parquet
+ `application/x-image` um die Erklärbarkeit bei Computer-Vision-Problemen zu aktivieren
+ Erläuterungen zum Zeitreihenprognosemodell
+ `application/json` für JSON
+ **dataset\$1uri** – (Optional) Der Uniform Resource Identifier (URI) des Hauptdatensatzes. Wenn Sie ein S3-URI-Präfix angeben, sammelt der SageMaker Clarif-Verarbeitungsauftrag rekursiv alle S3-Dateien, die sich unter dem Präfix befinden. Sie können entweder ein S3-URI-Präfix oder einen S3-URI für eine Image-Manifest-Datei für Computer-Vision-Probleme angeben. Wenn `dataset_uri` angegeben, hat es Vorrang vor der Auftragseingabe für die Datensatzverarbeitung. Für alle Formattypen mit Ausnahme von Bild- und Zeitreihenanwendungen lädt der Verarbeitungsjob SageMaker Clarify den Eingabedatensatz als tabellarischer Datensatz in einen **tabellarischen** Datenrahmen. Dieses Format ermöglicht SageMaker KI die einfache Bearbeitung und Analyse des Eingabedatensatzes.
+ **headers** – (optional)
+ **Tabellarisch** – ein Array von Zeichenketten, das die Spaltennamen eines tabellarischen Datensatzes enthält. Wenn kein Wert angegeben wird`headers`, liest der SageMaker Clarif-Verarbeitungsjob die Header aus dem Datensatz. Wenn der Datensatz keine Header hat, generiert der Clarify-Verarbeitungsauftrag automatisch Platzhalternamen, die auf einem nullbasierten Spaltenindex basieren. Beispielsweise lauten die Platzhalternamen für die erste und zweite Spalte **column\$10**, **column\$11** usw.
**Anmerkung**
Konventionell `headers` sollte if `dataset_type` is `application/jsonlines` or `application/json` die folgenden Namen in der angegebenen Reihenfolge enthalten:
Feature-Namen
Labelname (falls `label` angegeben)
vorhergesagter Labelname (falls `predicted_label` angegeben)
Ein Beispiel `headers` für einen `application/jsonlines` Datensatztyp, falls `label` angegeben ist: `["feature1","feature2","feature3","target_label"]`.
+ **Zeitreihe:** Eine Liste von Spaltennamen im Datensatz. Falls nicht angegeben, generiert Clarify Header zur internen Verwendung. Für Fälle, in denen Zeitreihen erklärbar sind, geben Sie die Header in der folgenden Reihenfolge an:
1. item id
1. Zeitstempel
1. Zielzeitreihe
1. alle zugehörigen Zeitreihenspalten
1. alle statischen Kovariatenspalten
+ **label** – (Optional) Eine Zeichenfolge oder ein auf Null basierender Integer-Index. Falls `label` angegeben, wird es verwendet, um die Ground-Truth-Beschriftung, das auch als beobachtete Beschriftung oder Zielattribut bezeichnet wird, in einem tabellarischen Datensatz zu lokalisieren. Das Ground-Truth-Etikett wird zur Berechnung von Bias-Metriken verwendet. Der Wert für `label` wird abhängig vom Wert des `dataset_type` Parameters wie folgt angegeben.
+ Falls `dataset_type` **text/csv** ist, `label` kann eine der folgenden Optionen angegeben werden:
+ Ein gültiger Spaltenname
+ Ein Index, der innerhalb des Bereichs der Datensatzspalten liegt
+ Falls `dataset_type` **application/parquet** ist, `label` muss es sich um einen gültigen Spaltennamen handeln.
+ Falls ja**application/jsonlines**, `label` muss `dataset_type` es sich um einen [JMESPath](https://jmespath.org/)Ausdruck handeln, der geschrieben wurde, um das Ground-Truth-Etikett aus dem Datensatz zu extrahieren. Gemäß der Konvention sollte `headers` es den Labelnamen enthalten.
+ Falls ja**application/json**, `label` muss `dataset_type` es sich um einen [JMESPath](https://jmespath.org/)Ausdruck handeln, der geschrieben wurde, um das Ground-Truth-Etikett für jeden Datensatz im Datensatz zu extrahieren. Dieser JMESPath Ausdruck muss eine Liste von Bezeichnungen erzeugen, bei denen das i-th-Label mit dem i-th-Label korreliert.
+ **predicted\$1label** – (Optional) Eine Zeichenfolge oder ein auf Null basierender Integer-Index. Wenn angegeben wird, wird `predicted_label` die Spalte mit der vorhergesagten Bezeichnung in einem Tabellendatensatz gesucht. Die vorhergesagte Beschriftung wird verwendet, um Messwerte für **Verzerrungen** nach dem Training zu berechnen. Der Parameter `predicted_label` ist optional, wenn der Datensatz keine vorhergesagte Beschriftung enthält. Wenn vorhergesagte Labels für die Berechnung erforderlich sind, erhält der SageMaker Clarify-Verarbeitungsjob Vorhersagen aus dem Modell.
Der Wert für `predicted_label` wird abhängig vom Wert von `dataset_type` wie folgt angegeben:
+ Falls `dataset_type` **text/csv** ist, `predicted_label` kann eine der folgenden Optionen angegeben werden:
+ Ein gültiger Spaltenname. Wenn `predicted_label_dataset_uri` angegeben, aber `predicted_label` nicht bereitgestellt wird, lautet der standardmäßige vorhergesagte Labelname „predicted\$1label“.
+ Ein Index, der innerhalb des Bereichs der Datensatzspalten liegt. Wenn `predicted_label_dataset_uri` angegeben, wird der Index verwendet, um die vorhergesagte Labelspalte im vorhergesagten Beschriftung-Datensatz zu finden.
+ Wenn dataset\$1type den Wert **application/x-parquet** hat, `predicted_label` muss es sich um einen gültigen Spaltennamen handeln.
+ Wenn dataset\$1type den Wert hat**application/jsonlines**, `predicted_label` muss ein gültiger [JMESPath](https://jmespath.org/)Ausdruck geschrieben werden, um das vorhergesagte Label aus dem Datensatz zu extrahieren. Wenn `headers` angegeben ist, sollte es vereinbarungsgemäß den vorausgesagten Etikettennamen enthalten.
+ Falls ja `dataset_type`**application/json**, `predicted_label` muss ein [JMESPath](https://jmespath.org/)Ausdruck geschrieben werden, um das vorhergesagte Label für jeden Datensatz im Datensatz zu extrahieren. Der JMESPath Ausdruck sollte eine Liste von vorhergesagten Labels erzeugen, wobei das i das vorhergesagte Label für sie im Datensatz ist.
+ **features** — (Optional) Für non-time-series Anwendungsfälle erforderlich, wenn `dataset_type` es `application/jsonlines` oder `application/json` ist. Ein JMESPath Zeichenkettenausdruck, der geschrieben wurde, um die Features im Eingabe-Dataset zu lokalisieren. Denn `application/jsonlines` auf jede Linie wird ein JMESPath Ausdruck angewendet, um die Features für diesen Datensatz zu extrahieren. Denn `application/json` ein JMESPath Ausdruck wird auf den gesamten Eingabedatensatz angewendet. Der JMESPath Ausdruck sollte eine Liste von Listen oder eine 2D array/matrix von Features extrahieren, wobei die i-te Zeile die Features enthält, die mit dem i-ten Datensatz korrelieren. Bei einem Wert `dataset_type` von `text/csv` oder `application/x-parquet` werden alle Spalten mit Ausnahme der Ground-Truth-Beschriftungen und der vorhergesagten Labelspalten automatisch Features zugewiesen.
+ **predicted\$1label\$1dataset\$1uri** – (original) gilt nur, wenn dataset\$1type `text/csv` ist. Der S3-URI für einen Datensatz, der vorhergesagte Labels enthält, die zur Berechnung von **Bias-Metriken** nach dem Training verwendet werden. Der Verarbeitungsjob SageMaker Clarify lädt die Vorhersagen aus dem angegebenen URI, anstatt Vorhersagen aus dem Modell abzurufen. In diesem Fall `predicted_label` ist es erforderlich, die Spalte mit der vorhergesagten Bezeichnung im Datensatz mit der vorhergesagten Bezeichnung zu finden. Wenn der Datensatz für das vorhergesagte Etikett oder der Hauptdatensatz auf mehrere Dateien aufgeteilt ist, muss eine Kennungsspalte von `joinsource_name_or_index` angegeben werden, um die beiden Datensätze zu verbinden.
+ **predicted\$1label\$1headers** – (original) gilt nur, wenn `predicted_label_dataset_uri` angegeben ist. Ein Array von Strings, die die Spaltennamen des vorhergesagten Label-Datensatzes enthalten. Neben der Kopfzeile des vorhergesagten Labels kann `predicted_label_headers` auch die Kopfzeile der Identifizierungsspalte enthalten, um den vorhergesagten Label-Datensatz und den Hauptdatensatz zu verbinden. Weitere Informationen finden Sie in der folgenden Beschreibung für den Parameter `joinsource_name_or_index`.
+ **joinsource\$1name\$1or\$1index** – (original) der Name oder der auf Null basierende Index der Spalte in tabellarischen Datensätzen, die bei der Durchführung einer inneren Verknüpfung als Kennungsspalte verwendet werden soll. Diese Spalte wird nur als Bezeichner verwendet. Sie wird nicht für andere Berechnungen wie Verzerrungsanalysen oder Merkmalszuordnungsanalysen verwendet. In den folgenden Fällen ist ein Wert für `joinsource_name_or_index` erforderlich:
+ Es gibt mehrere Eingabedatensätze, und jeder ist auf mehrere Dateien aufgeteilt.
+ Die verteilte Verarbeitung wird aktiviert, indem der SageMaker Clarife-Verarbeitungsauftrag [InstanceCount](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProcessingClusterConfig.html#sagemaker-Type-ProcessingClusterConfig-InstanceCount)auf einen Wert größer als gesetzt wird`1`.
+ **excluded\$1columns** – (Optional) Ein Array von Namen oder auf Null basierenden Indizes von Spalten, die vom Senden an das Modell als Eingabe für Vorhersagen ausgeschlossen werden sollen. Ground-Truth-Beschriftung und Prognose-Beschriftung sind bereits automatisch ausgeschlossen. Dieses Feature wird für Zeitreihen nicht unterstützt.
+ **probability\$1threshold** – (Optional) Eine Fließkommazahl, über der eine Bezeichnung oder ein Objekt ausgewählt wird. Der Standardwert ist `0.5`. Der Verarbeitungsauftrag SageMaker Clarify wird `probability_threshold` in den folgenden Fällen verwendet:
+ Bei der Bias-Analyse nach dem Training wird eine numerische Modellvorhersage (Wahrscheinlichkeitswert oder Punktzahl) in eine binäre Bezeichnung `probability_threshold` umgewandelt, wenn das Modell ein binärer Klassifikator ist. Ein Wert, der über dem Schwellenwert liegt, wird in `1` umgerechnet. Dagegen wird eine Punktzahl, die kleiner oder gleich dem Schwellenwert ist, in `0` umgerechnet.
+ Bei Erklärungsproblemen in der Computer Vision werden Objekte, deren Konfidenzwerte unter dem Schwellenwert liegen, **OBJECT\$1DETECTION**`, probability_threshold` herausgefiltert, wenn model\$1type steht.
+ **label\$1values\$1or\$1threshold** – (optional) erforderlich für die Bias-Analyse. Eine Reihe von Labelwerten oder eine Schwellenzahl, die auf ein positives Ergebnis bei Ground-Truth-Werten und auf vorhergesagte Kennzeichnungen für Bias-Metriken hinweisen. Weitere Informationen finden Sie unter positive Beschriftungswerte unter [Amazon SageMaker klärt die Bedingungen für Voreingenommenheit und Fairness](clarify-detect-data-bias.md#clarify-bias-and-fairness-terms). Wenn das Etikett numerisch ist, wird der Schwellenwert als Untergrenze verwendet, um das positive Ergebnis auszuwählen. Informationen zur Einstellung `label_values_or_threshold` für verschiedene Problemtypen finden Sie in den folgenden Beispielen:
+ Bei einem binären Klassifizierungsproblem hat das Label zwei mögliche Werte, `0` und `1`. Wenn der Labelwert für eine in einer Stichprobe beobachtete demografische Gruppe günstig `1` ist, `label_values_or_threshold` sollte er auf `[1]` gesetzt werden.
+ Bei einem Klassifizierungsproblem mit mehreren Klassen hat das Label drei mögliche Werte: **bird**, **cat**, und **dog**. Wenn die beiden letztgenannten eine demografische Gruppe definieren, die von Vorurteilen bevorzugt wird, `label_values_or_threshold` sollte der Wert auf `["cat","dog"]` eingestellt werden.
+ Bei einem Regressionsproblem ist der Labelwert kontinuierlich und reicht von `0` bis `1`. Wenn ein Wert, der größer als ist, darauf hinweisen `0.5` sollte, dass eine Stichprobe ein positives Ergebnis erzielt hat, `label_values_or_threshold` sollte der Wert auf `0.5` gesetzt werden.
+ **facet** – (optional) erforderlich für die Bias-Analyse. Eine Reihe von Facettenobjekten, die sich aus empfindlichen Attributen zusammensetzen, anhand derer die systematische Abweichung gemessen wird. Sie können Facetten verwenden, um die Verzerrungseigenschaften Ihres Datensatzes und Modells zu verstehen, auch wenn Ihr Modell ohne Verwendung sensibler Attribute trainiert wurde. Weitere Informationen finden Sie unter **Facet** in [Amazon SageMaker klärt die Bedingungen für Voreingenommenheit und Fairness](clarify-detect-data-bias.md#clarify-bias-and-fairness-terms). Jedes Facettenobjekt umfasst die folgenden Felder:
+ **name\$1or\$1index** – (optional) der Name oder der auf Null basierende Index der vertraulichen Attributspalte in einem tabellarischen Datensatz. Wenn `facet_dataset_uri` angegeben, bezieht sich der Index auf den Facettendatensatz und nicht auf den Hauptdatensatz.
+ **value\$1or\$1threshold** – (optional) erforderlich, wenn es sich bei `facet` um einen numerischen Wert handelt und `label_values_or_threshold` als Untergrenze für die Auswahl der sensitiven Gruppe verwendet wird. Eine Reihe von Facettenwerten oder eine Schwellenzahl, die die sensible demografische Gruppe angibt, die von der Voreingenommenheit bevorzugt wird. Wenn der Facettendatentyp kategorisch ist und nicht angegeben `value_or_threshold` wird, werden die Messwerte für verzerrte Werte als eine Gruppe für jeden Einzelwert berechnet (und nicht für alle Werte). Informationen zur Einstellung `value_or_threshold` für verschiedene `facet` Datentypen finden Sie in den folgenden Beispielen:
+ Bei einem binären Facettendatentyp hat das Feature zwei mögliche Werte, `0` und `1`. Wenn Sie die Messwerte für die systematische Abweichung für jeden Wert berechnen möchten, `value_or_threshold` können sie entweder weggelassen oder auf ein leeres Array gesetzt werden.
+ Bei einem kategorialen Facettendatentyp hat das Feature drei mögliche Werte **bird**, **cat**, und **dog**. Wenn die ersten beiden eine demografische Gruppe definieren, die von der Voreingenommenheit bevorzugt wird, `value_or_threshold` sollte der Wert auf `["bird", "cat"]` festgelegt werden. In diesem Beispiel werden die Datensatzstichproben in zwei demografische Gruppen aufgeteilt. Die Facette in der begünstigten Gruppe hat einen Wert **bird** oder **cat**, während die Facette in der benachteiligten Gruppe einen Wert **dog** hat.
+ Bei einem numerischen Facettendatentyp ist der Feature-Wert kontinuierlich und reicht von `0` bis `1`. Wenn beispielsweise ein Wert, der größer als `0.5` ist, eine Stichprobe als bevorzugt kennzeichnen soll, `value_or_threshold` sollte er auf `0.5` gesetzt werden. In diesem Beispiel werden die Datensatzstichproben in zwei demografische Gruppen aufgeteilt. Die Facette in der begünstigten Gruppe hat einen Wert größer als `0.5`, während der Wert der Facette in der benachteiligten Gruppe kleiner oder gleich wie `0.5` ist.
+ **group\$1variable** – (Optional) Der Name oder der auf Null basierende Index der Spalte, die die Untergruppe angibt, die für die Bias-Metrik verwendet werden soll oder. [Bedingte demografische Disparität (CDD)](clarify-data-bias-metric-cddl.md) [Bedingte demografische Disparität bei prognostizierten Beschriftungen (CDDPL)](clarify-post-training-bias-metric-cddpl.md)
+ **facet\$1dataset\$1uri** – (optional) gilt nur, wenn dataset\$1type den Wert `text/csv` hat. Der S3-URI für einen Datensatz, der sensible Attribute für die Bias-Analyse enthält. Sie können Facetten verwenden, um die Verzerrungsmerkmale Ihres Datensatzes und Modells zu verstehen, auch wenn Ihr Modell ohne Verwendung sensibler Attribute trainiert wurde.
**Anmerkung**
Wenn der Facettendatensatz oder der Hauptdatensatz auf mehrere Dateien aufgeteilt ist, muss eine Kennungsspalte von `joinsource_name_or_index` angegeben werden, um die beiden Datensätze zu verbinden. Sie müssen den Parameter `facet` verwenden, um jede Facette im Facettendatensatz zu identifizieren.
+ **facet\$1headers** – (Optional) Gilt nur, wenn angegeben. `facet_dataset_uri` Eine Reihe von Zeichenketten, die Spaltennamen für den Facettendatensatz und optional die Spaltenüberschrift zur Verknüpfung des Facettendatensatzes und des Hauptdatensatzes enthalten, siehe `joinsource_name_or_index`.
+ **time\$1series\$1data\$1config** – (Optional) Gibt die Konfiguration an, die für die Datenverarbeitung einer Zeitreihe verwendet werden soll.
+ **item\$1id** – Eine Zeichenfolge oder ein auf Null basierender Integer-Index. Dieses Feld wird verwendet, um eine Element-ID im gemeinsam genutzten Eingabedatensatz zu finden.
+ **timestamp** – Eine Zeichenfolge oder ein auf Null basierender Integer-Index. Dieses Feld wird verwendet, um einen Zeitstempel im gemeinsam genutzten Eingabedatensatz zu finden.
+ **dataset\$1format** – Mögliche Werte sind`columns`, oder. `item_records` `timestamp_records` Dieses Feld wird verwendet, um das Format eines JSON-Datensatzes zu beschreiben. Dies ist das einzige Format, das für die Erklärung von Zeitreihen unterstützt wird.
+ **target\$1time\$1series** — Eine JMESPath Zeichenfolge oder ein auf Null basierender Integer-Index. Dieses Feld wird verwendet, um die Zielzeitreihe im gemeinsam genutzten Eingabe-Dataset zu finden. Wenn dieser Parameter eine Zeichenfolge ist, `dataset_format` müssen alle anderen Parameter außer Zeichenketten oder Zeichenkettenlisten sein. Wenn dieser Parameter eine Ganzzahl ist, `dataset_format` müssen alle anderen Parameter außer Ganzzahlen oder Listen von ganzen Zahlen sein.
+ **related\$1time\$1series** — (Optional) Ein Array von Ausdrücken. JMESPath Dieses Feld wird verwendet, um alle zugehörigen Zeitreihen im gemeinsam genutzten Eingabedatensatz zu finden, sofern vorhanden.
+ **static\$1covariates** — (Optional) Ein Array von Ausdrücken. JMESPath Dieses Feld wird verwendet, um alle statischen Kovariatenfelder im gemeinsam genutzten Eingabedatensatz zu finden, sofern vorhanden.
Beispiele finden Sie unter [Beispiele für die Konfiguration von Zeitreihen-Datensätzen](clarify-processing-job-data-format-time-series.md#clarify-processing-job-data-format-time-series-ex).
+ **Methoden** – Ein Objekt, das eine oder mehrere Analysemethoden und deren Parameter enthält. Wenn eine Methode ausgelassen wird, wird sie weder für die Analyse verwendet noch gemeldet.
+ **pre\$1training\$1bias** – Fügen Sie diese Methode hinzu, wenn Sie Messwerte für Verzerrungen vor dem Training berechnen möchten. Eine ausführliche Beschreibung der Metriken finden Sie unter [Messwerte zu Verzerrungen vor dem Training](clarify-measure-data-bias.md). Das Objekt hat die folgenden Parameter:
+ **Methoden** – Ein Array, das alle Messwerte für Verzerrungen vor dem Training aus der folgenden Liste enthält, die Sie berechnen möchten. Stellen Sie `methods` auf **all** ein, um alle Messwerte für Verzerrungen vor dem Training zu berechnen. Das Array `["CI", "DPL"]` berechnet beispielsweise das **Klassenungleichgewicht** und den **Unterschied in den Proportionen von Beschriftungen**.
+ `CI` für [Ungleichgewicht zwischen den Klassen (CI)](clarify-bias-metric-class-imbalance.md)
+ `DPL` für [Unterschied in den Proportionen der Beschriftungen (DPL)](clarify-data-bias-metric-true-label-imbalance.md)
+ `KL` für [Kullback-Leibler-Divergenz (KL)](clarify-data-bias-metric-kl-divergence.md)
+ `JS` für [Jensen-Shannon-Divergenz (JS)](clarify-data-bias-metric-jensen-shannon-divergence.md)
+ `LP` für [Lp-Norm (LP)](clarify-data-bias-metric-lp-norm.md)
+ `TVD` für [Gesamtvariationsdistanz (TVD)](clarify-data-bias-metric-total-variation-distance.md)
+ `KS` für [Kolmogorow-Smirnow (KS)](clarify-data-bias-metric-kolmogorov-smirnov.md)
+ `CDDL` für [Bedingte demografische Disparität (CDD)](clarify-data-bias-metric-cddl.md)
+ **post\$1training\$1bias** – Verwenden Sie diese Methode, wenn Sie Messwerte für Verzerrungen nach dem Training berechnen möchten. Eine ausführliche Beschreibung der Metriken finden Sie unter [Daten nach dem Training und Modellverzerrungenmetriken](clarify-measure-post-training-bias.md). Das `post_training_bias` Objekt hat die folgenden Parameter.
+ **Methoden** – Ein Array, das alle Messwerte für Verzerrungen nach dem Training aus der folgenden Liste enthält, die Sie berechnen möchten. Stellen Sie `methods` auf **all** ein, um alle Messwerte für Verzerrungen nach dem Training zu berechnen. Beispielsweise `["DPPL", "DI"]` berechnet das Array den **Unterschied zwischen positiven Proportionen bei vorhergesagten Kennzeichnungen** und **unterschiedlichen Auswirkungen**. Die verfügbaren Methoden sind:
+ `DPPL` für [Unterschied zwischen positiven Anteilen bei prognostizierten Kennzeichnungen (DPPL)](clarify-post-training-bias-metric-dppl.md)
+ `DI` für [Disparate Impact (DI)](clarify-post-training-bias-metric-di.md)
+ `DCA` für [Unterschied bei der bedingten Akzeptanz () DCAcc](clarify-post-training-bias-metric-dcacc.md)
+ `DCR` für [Unterschied bei der bedingten Ablehnung (DCR)](clarify-post-training-bias-metric-dcr.md)
+ `SD` für [Spezifitätsunterschied (SD)](clarify-post-training-bias-metric-sd.md)
+ `RD` für [Unterschied zurückrufen (RD)](clarify-post-training-bias-metric-rd.md)
+ `DAR` für [Unterschied in den Akzeptanzraten (DAR)](clarify-post-training-bias-metric-dar.md)
+ `DRR` für [Unterschied bei den Ablehnungsraten (DRR)](clarify-post-training-bias-metric-drr.md)
+ `AD` für [Genauigkeitsunterschied (AD)](clarify-post-training-bias-metric-ad.md)
+ `TE` für [Gleichbehandlung (TE)](clarify-post-training-bias-metric-te.md)
+ `CDDPL` für [Bedingte demografische Disparität bei prognostizierten Beschriftungen (CDDPL)](clarify-post-training-bias-metric-cddpl.md)
+ `FT` für [Kontrafaktischer Fliptest (FT)](clarify-post-training-bias-metric-ft.md)
+ `GE` für [Generalisierte Entropie (GE)](clarify-post-training-bias-metric-ge.md)
+ **shap** – Schließen Sie diese Methode ein, wenn Sie SHAP-Werte berechnen möchten. Der SageMaker Clarify-Verarbeitungsjob unterstützt den Kernel-SHAP-Algorithmus. Das `shap` Objekt hat die folgenden Parameter.
+ **baseline** – (optional) der SHAP-Baseline-Datensatz, auch bekannt als Hintergrunddatensatz. Zusätzliche Anforderungen für den Basisdatensatz in einem tabellarischen Datensatz oder bei einem Computer-Vision-Problem lauten wie folgt. Weitere Informationen zu SHAP-Baselines finden Sie unter [SHAP-Baselines zur Erläuterbarkeit](clarify-feature-attribute-shap-baselines.md)
+ Bei einem **tabellarischen** Datensatz, `baseline` können dies entweder die direkten Basisdaten oder der S3-URI einer Basisdatei sein. Falls nicht `baseline` angegeben, berechnet der SageMaker Clarify-Verarbeitungsauftrag eine Baseline, indem er den Eingabedatensatz zu einem Cluster zusammenfasst. Folgendes ist für die Baseline erforderlich:
+ Das Format muss mit dem von `dataset_type` angegebenen Datensatzformat identisch sein.
+ Die Basislinie kann nur Features enthalten, die das Modell als Eingabe akzeptieren kann.
+ Der Baseline-Datensatz kann über eine oder mehrere Instances verfügen. Die Anzahl der Baseline-Instances wirkt sich direkt auf die Größe des synthetischen Datensatzes und die Laufzeit des Auftrages aus.
+ Wenn `text_config` angegeben wird, ist der Basiswert einer Textspalte eine Zeichenkette, die die durch `granularity` angegebene Texteinheit ersetzt. Ein gängiger Platzhalter ist beispielsweise „[MASK]“, der verwendet wird, um ein fehlendes oder unbekanntes Wort oder einen Textabschnitt darzustellen.
Die folgenden Beispiele verdeutlichen, wie Sie direkte Basisdaten für verschiedene `dataset_type` Parameter festlegen:
+ Wenn `dataset_type` entweder `text/csv` oder `application/x-parquet` ist, akzeptiert das Modell vier numerische Features, und die Basislinie hat zwei Instances. Wenn in diesem Beispiel ein Datensatz alle Feature-Werte Null und der andere Datensatz nur einen Feature-Wert hat, dann sollte der Basiswert auf `[[0,0,0,0],[1,1,1,1]]` ohne Header gesetzt werden.
+ Wenn `dataset_type` `application/jsonlines` ist, und `features` ist der Schlüssel zu einer Liste mit vier numerischen Featureswerten. Wenn die Basislinie in diesem Beispiel außerdem einen Datensatz mit allen Nullwerten enthält, `baseline` sollte dies `[{"features":[0,0,0,0]}]` sein.
+ Falls `dataset_type` `application/json` ist, sollte der `baseline` Datensatz dieselbe Struktur und dasselbe Format wie der Eingabedatensatz haben.
+ Bei Problemen mit **Computer Vision** `baseline` kann dies der S3-URI eines Bilds sein, der verwendet wird, um Features (Segmente) aus dem Eingabebild auszublenden. Der Verarbeitungsauftrag SageMaker Clarify lädt das Maskenbild und ändert seine Größe auf dieselbe Auflösung wie das Eingabebild. Wenn keine Basislinie angegeben ist, generiert der SageMaker Clarify-Verarbeitungsauftrag ein Maskenbild mit [weißem Rauschen](https://en.wikipedia.org/wiki/White_noise) mit derselben Auflösung wie das Eingabebild.
+ **features\$1to\$1explain** – (Optional) Ein Array von Zeichenketten oder nullbasierten Indizes von Feature-Spalten, für die SHAP-Werte berechnet werden sollen. Wenn `features_to_explain` nicht angegeben, werden SHAP-Werte für alle Feature-Spalten berechnet. Diese Feature-Spalten können weder die Beschriftung-Spalte noch die vorhergesagte Beschriftung-Spalte enthalten. Der `features_to_explain` Parameter wird nur für tabellarische Datensätze mit numerischen und kategorialen Spalten unterstützt.
+ **num\$1clusters** – (Optional) Die Anzahl der Cluster, in die der Datensatz aufgeteilt wird, um den Baseline-Datensatz zu berechnen. Jeder Cluster wird zur Berechnung einer Basisinstance verwendet. Falls nicht `baseline` angegeben, versucht der SageMaker Clarif-Verarbeitungsauftrag, den Basisdatensatz zu berechnen, indem der tabellarische Datensatz in eine optimale Anzahl von Clustern zwischen `1` und `12` aufgeteilt wird. Die Anzahl der Basisinstances wirkt sich direkt auf die Laufzeit der SHAP-Analyse aus.
+ **num\$1samples** – (Optional) Die Anzahl der Samples, die im Kernel-SHAP-Algorithmus verwendet werden sollen. Falls nicht `num_samples` angegeben, wählt der SageMaker Clarify-Verarbeitungsjob die Zahl für Sie aus. Die Anzahl der Stichproben wirkt sich direkt sowohl auf die Größe des synthetischen Datensatzes als auch auf die Laufzeit des Auftrages aus.
+ **seed** – (Optional) Eine Ganzzahl, die zur Initialisierung des Pseudo-Zufallszahlengenerators im SHAP-Explainer verwendet wird, um konsistente SHAP-Werte für denselben Auftrag zu generieren. Wenn kein Startwert angegeben ist, kann das Modell jedes Mal, wenn derselbe Auftrag ausgeführt wird, leicht unterschiedliche SHAP-Werte ausgeben.
+ **use\$1logit** – (Optional) Ein boolescher Wert, der angibt, dass die Logit-Funktion auf die Modellvorhersagen angewendet werden soll. Standardeinstellung auf `false`. Wenn `use_logit` `true` ist, werden die SHAP-Werte anhand der logistischen Regressionskoeffizienten berechnet, die als Log-Odd-Ratio interpretiert werden können.
+ **save\$1local\$1shap\$1values** – (Optional) Ein boolescher Wert, der angibt, dass die lokalen SHAP-Werte jedes Datensatzes im Datensatz in das Analyseergebnis aufgenommen werden sollen. Standardeinstellung: `false`.
Wenn der Hauptdatensatz auf mehrere Dateien aufgeteilt ist oder die verteilte Verarbeitung aktiviert ist, geben Sie mit dem Parameter `joinsource_name_or_index` auch eine Kennungsspalte an. Die Kennungsspalte und die lokalen SHAP-Werte werden im Analyseergebnis gespeichert. Auf diese Weise können Sie jeden Datensatz seinen lokalen SHAP-Werten zuordnen.
+ **agg\$1method** – (Optional) Die Methode, mit der die lokalen SHAP-Werte (die SHAP-Werte für jede Instance) aller Instances zu den globalen SHAP-Werten (den SHAP-Werten für den gesamten Datensatz) aggregiert werden. Standardeinstellung: `mean_abs`. Die folgenden Methoden können verwendet werden, um SHAP-Werte zu aggregieren.
+ **mean\$1abs** – Der Mittelwert der absoluten lokalen SHAP-Werte aller Instances.
+ **mean\$1sq** – Der Mittelwert der quadrierten lokalen SHAP-Werte aller Instances.
+ **Median** – Der Median der lokalen SHAP-Werte aller Instances.
+ **text\$1config** – erforderlich für natürliche Sprachverarbeitung Erklärbarkeit. Schließen Sie diese Konfiguration ein, wenn Sie Textspalten als Text behandeln möchten und Erklärungen für einzelne Texteinheiten bereitgestellt werden sollten. Ein Beispiel für eine Analysekonfiguration zur Erklärbarkeit der Verarbeitung natürlicher Sprache finden Sie unter [Analysekonfiguration für die natürliche Sprachverarbeitung (Erklärbarkeit)](#clarify-analysis-configure-nlp-example)
+ **Granularität** – Die Granularitätseinheit für die Analyse von Textspalten. Gültige Werte sind `token`, `sentence` oder `paragraph`. **Jede Texteinheit wird als Feature betrachtet**, und für jede Einheit werden lokale SHAP-Werte berechnet.
+ **Sprache** – Die Sprache der Textspalten. Gültige Werte sind **chinese**, **danish**, **dutch**, **english**, **french**, **german**, **greek**, **italian**, **japanese**, **lithuanian**, **multi-language**, **norwegian bokmål**, **polish**, **portuguese**, **romanian**, **russian**, **spanish**, **afrikaans**, **albanian**, **arabic**, **armenian**, **basque**, **bengali**, **bulgarian**, **catalan**, **croatian**, **czech**, **estonian**, **finnish**, **gujarati**, **hebrew**, **hindi**, **hungarian**, **icelandic**, **indonesian**, **irish**, **kannada**, **kyrgyz**, **latvian**, **ligurian**, **luxembourgish**, **macedonian**, **malayalam**, **marathi**, **nepali**, **persian**, **sanskrit**, **serbian**, **setswana**, **sinhala**, **slovak**, **slovenian**, **swedish**, **tagalog**, **tamil**, **tatar**, **telugu**, **thai**, **turkish**, **ukrainian**, **urdu**, **vietnamese**, **yoruba**. Geben Sie `multi-language` ein, um eine Mischung aus mehreren Sprachen zu erhalten.
+ **max\$1top\$1tokens** – (Optional) Die maximale Anzahl von Top-Token, basierend auf globalen SHAP-Werten. Standardeinstellung: `50`. Es ist möglich, dass ein Token mehrmals im Datensatz erscheint. Der SageMaker Clarif-Verarbeitungsjob aggregiert die SHAP-Werte jedes Tokens und wählt dann die Top-Tokens auf der Grundlage ihrer globalen SHAP-Werte aus. Die globalen SHAP-Werte der ausgewählten Top-Tokens sind im Abschnitt der Datei analysis.json enthalten. `global_top_shap_text`
+ Der lokale SHAP-Wert der Aggregation.
+ **image\$1config** – Erforderlich für die Erklärbarkeit von Computer Vision. Fügen Sie diese Konfiguration hinzu, wenn Sie einen Eingabedatensatz haben, der aus Bildern besteht, und Sie diese auf ihre Erklärbarkeit bei einem Computer-Vision-Problem analysieren möchten.
+ **model\$1type** – Der Typ des Modells. Gültige Werte sind:
+ `IMAGE_CLASSIFICATION` für ein Bildklassifizierungsmodell.
+ `OBJECT_DETECTION` für ein Objekterkennungsmodell.
+ **max\$1objects** – Gilt nur, wenn model\$1type den Wert **OBJECT\$1DETECTION** ist.Die maximale Anzahl von Objekten, geordnet nach dem Konfidenzwert, die vom Computer-Vision-Modell erkannt werden. Alle Objekte, die nach dem Konfidenzwert niedriger eingestuft sind als die höchsten max\$1objects, werden herausgefiltert. Standardeinstellung: `3`.
+ **context** – Gilt nur, wenn model\$1type den Wert **OBJECT\$1DETECTION** hat. Es gibt an, ob der Bereich um den Begrenzungsrahmen des erkannten Objekts durch das Basisbild maskiert wird oder nicht. Gültige Werte sind `0` alles maskieren oder `1` nichts maskieren. Standardeinstellung: 1.
+ **iou\$1threshold** – Gilt nur, wenn dies der Wert `model_type` **OBJECT\$1DETECTION** ist. Die Mindestkennzahl der Schnittmenge über die Union (IOU) für die Auswertung von Vorhersagen anhand der ursprünglichen Erkennung. Eine hohe IOU-Metrik entspricht einer großen Überschneidung zwischen dem Feld für die Erkennung vorhergesagter Daten und der Ground-Truth-Erkennung. Standardeinstellung: `0.5`.
+ **num\$1segments** – (Optional) Eine Ganzzahl, die die ungefähre Anzahl der Segmente bestimmt, die im Eingabebild beschriftet werden sollen. Jedes Segment des Bildes wird als Merkmal betrachtet, und für jedes Segment werden lokale SHAP-Werte berechnet. Standardeinstellung: `20`.
+ **segment\$1compactness** – (Optional) Eine Ganzzahl, die die Form und Größe der mit der [scikit-image-Slic](https://scikit-image.org/docs/dev/api/skimage.segmentation.html#skimage.segmentation.slic) Methode generierten Bildsegmente bestimmt. Standardeinstellung: `5`.
+ **pdp — Schließen** Sie diese Methode ein, um partielle Abhängigkeitsdiagramme zu berechnen (). PDPs Ein Beispiel für eine zu generierende Analysekonfiguration finden Sie PDPs unter [Berechnet partielle Abhängigkeitsdiagramme () PDPs](#clarify-analysis-configure-csv-example-pdp)
+ **features** – Obligatorisch, wenn die `shap` Methode nicht angefordert wird. Eine Reihe von Feature-Namen oder Indizes zur Berechnung und Darstellung von PDP-Plots.
+ **top\$1k\$1features** – (Optional) Gibt die Anzahl der Top-Features an, die zur Generierung von PDP-Plots verwendet werden. Wenn `features` nicht angegeben, aber die `shap` Methode angefordert wird, wählt der SageMaker Clarify-Verarbeitungsauftrag die wichtigsten Funktionen auf der Grundlage ihrer SHAP-Attributionen aus. Standardeinstellung: `10`.
+ **grid\$1resolution** – Die Anzahl der Buckets, in die der Bereich numerischer Werte unterteilt werden soll. Dies gibt die Granularität des Rasters für die PDP-Plots an.
+ **asymmetric\$1shapley\$1value** – Verwenden Sie diese Methode, wenn Sie Erklärbarkeitsmetriken für Zeitreihen-Prognosemodelle berechnen möchten. Der SageMaker Clarify-Verarbeitungsjob unterstützt den asymmetrischen Shapley-Werte-Algorithmus. Asymmetrische Shapley-Werte sind eine Variante des Shapley-Werts, bei der das Symmetrieaxiom aufgehoben wird. Weitere Informationen finden Sie unter [Asymmetrische Shapley-Werte:](https://arxiv.org/abs/1910.06358) Einbeziehung von kausalem Wissen in modellunabhängige Erklärbarkeit. Verwenden Sie diese Werte, um zu ermitteln, wie Merkmale zum Prognoseergebnis beitragen. Asymmetrische Shapley-Werte berücksichtigen die zeitlichen Abhängigkeiten der Zeitreihendaten, die Prognosemodelle als Eingabe verwenden.
Der Algorithmus umfasst die folgenden Parameter:
+ **Richtung** – Verfügbare Typen sind`chronological`, und`anti_chronological`. `bidirectional` Durch die zeitliche Struktur kann in chronologischer oder antichronologischer Reihenfolge oder in beidem navigiert werden. Chronologische Erklärungen werden erstellt, indem vom ersten Zeitschritt an iterativ Informationen hinzugefügt werden. Bei antichronologischen Erklärungen werden Informationen hinzugefügt, die vom letzten Schritt an beginnen und sich dann rückwärts bewegen. Die letztgenannte Reihenfolge ist möglicherweise besser geeignet, wenn es um Verzerrungen in jüngster Zeit geht, z. B. bei der Prognose von Aktienkursen.
+ **Granularität** – Die Granularität der Erklärung, die verwendet werden soll. Die verfügbaren Granularitätsoptionen werden unten angezeigt:
+ **Zeitlich** – `timewise` Erklärungen sind kostengünstig und geben nur Auskunft über bestimmte Zeitschritte, z. B. um herauszufinden, wie viel die Informationen des n-ten Tages in der Vergangenheit zur Prognose des m-ten Tages in der future beigetragen haben. Die resultierenden Attributionen erklären keine individuellen statischen Kovariaten und unterscheiden nicht zwischen Zielzeitreihen und verwandten Zeitreihen.
+ **fine\$1grained** – `fine_grained` Erklärungen sind rechenintensiver, bieten jedoch eine vollständige Aufschlüsselung aller Attributionen der Eingabevariablen. Die Methode berechnet ungefähre Erklärungen, um die Laufzeit zu reduzieren. Weitere Informationen finden Sie im folgenden Parameter `num_samples`.
**Anmerkung**
`fine_grained`Erklärungen unterstützen nur die `chronological` Reihenfolge.
+ **num\$1samples** – (Optional) Dieses Argument ist für `fine_grained` Erklärungen erforderlich. Je höher die Zahl, desto genauer die Näherung. Diese Zahl sollte mit der Dimensionalität der Eingabe-Features skalieren. Als Faustregel gilt, diese Variable auf *(1 \$1 max (Anzahl verwandter Zeitreihen, Anzahl der statischen Kovariaten)) ^2* zu setzen, wenn das Ergebnis nicht zu groß ist.
+ **baseline** — (Optional) Die Basiskonfiguration zum Ersetzen von out-of-coalition Werten für die entsprechenden Datensätze (auch bekannt als Hintergrunddaten). Der folgende Ausschnitt zeigt ein Beispiel für eine Basiskonfiguration:
```
{
"related_time_series": "zero",
"static_covariates": {
: [0, 2],
: [-1, 1]
},
"target_time_series": "zero"
}
```
+ Für Zeitdaten wie Zielzeitreihen oder verwandte Zeitreihen kann es sich bei den Basiswerttypen um einen der folgenden Werte handeln:
+ `zero`— Alle out-of-coalition Werte werden durch 0,0 ersetzt.
+ `mean`— Alle out-of-coalition Werte werden durch den Durchschnitt einer Zeitreihe ersetzt.
+ Für statische Kovariaten sollte ein Basiswert nur angegeben werden, wenn die Modellanforderung statische Kovariatenwerte verwendet. In diesem Fall ist dieses Feld erforderlich. Die Basislinie sollte für jedes Element als Liste bereitgestellt werden. Wenn Sie beispielsweise einen Datensatz mit zwei statischen Kovariaten haben, könnte Ihre Basiskonfiguration wie folgt aussehen:
```
"static_covariates": {
: [1, 1],
: [0, 1]
}
```
Im vorherigen Beispiel ** ** sind dies die Element-IDs aus dem Datensatz.
+ **Bericht** – (Optional) Verwenden Sie dieses Objekt, um den Analysebericht anzupassen. Dieser Parameter wird für Jobs zur Erklärung von Zeitreihen nicht unterstützt. Es gibt drei Kopien desselben Berichts als Teil des Analyseergebnisses: Jupyter-Notebook-Bericht, HTML-Bericht und PDF-Bericht. Die Funktion hat die folgenden Parameter.
+ **name** – Dateiname der Berichtsdateien. Wenn dies beispielsweise der `name` **MyReport** ist, lauten die Berichtsdateien `MyReport.ipynb`, `MyReport.html`, und `MyReport.pdf`. Standardeinstellung: `report`.
+ **title** – (Optional) Titelzeichenfolge für den Bericht. Standardeinstellung: **SageMaker AI Analysis Report**.
+ **Prädiktor** – Erforderlich, wenn für die Analyse Vorhersagen aus dem Modell erforderlich sind. Zum Beispiel, wenn die Methode `shap`, `asymmetric_shapley_value`, `pdp` oder `post_training_bias` angefordert wird, die vorhergesagten Beschriftungen jedoch nicht als Teil des Eingabedatensatzes bereitgestellt werden. Die folgenden Parameter können in Verbindung mit `predictor` verwendet werden:
+ **model\$1name** — Der Name Ihres SageMaker KI-Modells, das von der API erstellt wurde. [CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html) Wenn Sie `model_name` statt endpoint\$1name angeben, erstellt der SageMaker Clarify-Verarbeitungsjob einen kurzlebigen Endpunkt mit dem Modellnamen, der als **Schattenendpunkt bezeichnet wird, und ruft Vorhersagen vom Endpunkt ab**. Der Auftrag löscht den Schattenendpunkt, nachdem die Berechnungen abgeschlossen sind. Wenn es sich bei dem Modell um ein Multi-Modell handelt, muss der `target_model`-Parameter angegeben werden. Weitere Informationen zu Multimodell-Endpunkten finden Sie unter [Multimodell-Endpunkte](multi-model-endpoints.md).
+ **endpoint\$1name\$1prefix** – (Optional) Ein benutzerdefiniertes Namenspräfix für den Schattenendpunkt. Anwendbar, wenn Sie anstelle von `model_name` `endpoint_name` angeben. Geben Sie beispielsweise `endpoint_name_prefix` an, wenn Sie den Zugriff auf den Endpunkt anhand des Endpunktnamens einschränken möchten. Das Präfix muss dem [EndpointName](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html#sagemaker-CreateEndpoint-request-EndpointName)Muster entsprechen, und seine maximale Länge beträgt. `23` Standardeinstellung: `sm-clarify`.
+ **initial\$1instance\$1count** – Gibt die Anzahl der Instances für den Shadow-Endpunkt an. Erforderlich, wenn Sie model\$1name statt endpoint\$1name angeben. Der Wert für `initial_instance_count` kann sich vom Wert [InstanceCount](https://docs.aws.amazon.com//sagemaker/latest/APIReference/API_ProcessingClusterConfig.html#sagemaker-Type-ProcessingClusterConfig-InstanceCount)des Jobs unterscheiden, wir empfehlen jedoch ein Verhältnis von 1:1.
+ **instance\$1type** – Gibt den Instance-Typ für den Schattenendpunkt an. Erforderlich, wenn Sie anstelle von `model_name` `endpoint_name` angeben. Als Beispiel kann `instance_type` auf "ml.m5.large" gesetzt werden. In einigen Fällen kann der für `instance_type` angegebene Wert dazu beitragen, die Inferenzzeit des Modells zu reduzieren. Um beispielsweise effizient ausgeführt zu werden, benötigen Modelle zur Verarbeitung natürlicher Sprache und Modelle für maschinelles Sehen in der Regel einen Instance-Typ „Graphics Processing Unit“ (GPU).
+ **endpoint\$1name — Der Name** Ihres SageMaker KI-Endpunkts, der von der API erstellt wurde. [CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) Falls `endpoint_name` angegeben, hat er Vorrang vor dem `model_name` Parameter. Die Verwendung eines vorhandenen Endpunkts reduziert die Bootstrap-Zeit für den Schattenendpunkt, kann aber auch zu einer erheblichen Erhöhung der Last für diesen Endpunkt führen. Darüber hinaus generieren einige Analysemethoden (wie `shap` und`pdp`) synthetische Datensätze, die an den Endpunkt gesendet werden. Dies kann dazu führen, dass die Metriken oder erfassten Daten des Endpunkts durch synthetische Daten verunreinigt werden, die die tatsächliche Nutzung möglicherweise nicht genau wiedergeben. Aus diesen Gründen wird generell nicht empfohlen, einen vorhandenen Produktionsendpunkt für SageMaker die Clarify-Analyse zu verwenden.
+ **target\$1model** — Der Zeichenkettenwert, der an den TargetModel Parameter der SageMaker [InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html#RequestSyntax)AI-API übergeben wird. Erforderlich, wenn es sich bei Ihrem Modell (angegeben durch den Parameter model\$1name) oder Ihrem Endpoint (angegeben durch den Parameter endpoint\$1name) um ein Multi-Modell handelt. Weitere Informationen zu Multimodell-Endpunkten finden Sie unter [Multimodell-Endpunkte](multi-model-endpoints.md).
+ **custom\$1attributes** – (Optional) Eine Zeichenfolge, mit der Sie zusätzliche Informationen zu einer Inferenzanforderung angeben können, die an den Endpunkt gesendet wird. Der Zeichenkettenwert wird an den `CustomAttributes` Parameter der SageMaker [InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html#RequestSyntax)AI-API übergeben.
+ **content\$1type** – content\$1type – Das Modelleingabeformat, das zum Abrufen von Vorhersagen vom Endpunkt verwendet werden soll. Falls angegeben, wird er an den `ContentType` Parameter der SageMaker [InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html#RequestSyntax)AI-API übergeben.
+ Zur besseren Erklärung des maschinellen Sehens sind **image/jpeg**, **image/png** oder **application/x-npy** gültige Werte. Falls `content_type` nicht angegeben, ist der Standardwert **image/jpeg**.
+ Für die Erklärbarkeit von Zeitreihenprognosen ist der gültige Wert. **application/json**
+ Für andere Arten der Erklärbarkeit sind **text/csv**, **application/jsonlines,** und **application/json** gültige Werte. Ein Wert für `content_type` ist erforderlich, wenn dies der Fall ist. `dataset_type` **application/x-parquet** Andernfalls wird `content_type` standardmäßig mit dem Wert des Parameters `dataset_type` belegt.
+ **accept\$1type** – Das Modellausgabeformat, das zum Abrufen von Vorhersagen vom Endpunkt verwendet werden soll. Der Wert für `accept_type` wird an den `Accept` Parameter der SageMaker [InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html#RequestSyntax)AI-API übergeben.
+ Wenn `model_type` "OBJECT\$1DETECTION" ist, dann ist `accept_type` standardmäßig **application/json** für die Erklärung von Computer Vision.
+ Für die Erklärbarkeit von Zeitreihenprognosen ist der gültige Wert. **application/json**
+ Für andere Arten der Erklärbarkeit sind **text/csv**, **application/jsonlines**, und **application/json** gültige Werte. Wenn kein Wert für angegeben `accept_type` wird, wird `accept_type` standardmäßig der Wert des `content_type` Parameters verwendet.
+ **content\$1template** – Eine Vorlagenzeichenfolge, die verwendet wird, um die Modelleingabe aus Datensätzen zu erstellen. Der Parameter `content_template` wird nur verwendet und ist erforderlich, wenn der Wert des `content_type` Parameters entweder `application/jsonlines` oder `application/json` ist.
Wenn der `content_type` Parameter `application/jsonlines` ist, sollte die Vorlage nur einen Platzhalter haben, `$features`, der zur Laufzeit durch eine Feature-Liste ersetzt wird. Ist `"{\"myfeatures\":$features}"` die Vorlage beispielsweise und hat ein Datensatz drei numerische Feature-Werte: `1`, `2` und `3`, dann wird der Datensatz als JSON-Line `{"myfeatures":[1,2,3]}` an das Modell gesendet.
Wenn `content_type` `application/json` ist, kann die Vorlage entweder einen Platzhalter `$record` oder `records` enthalten. Wenn der Platzhalter `record` ist, wird ein einzelner Datensatz durch einen Datensatz ersetzt, auf den die Vorlage `record_template` angewendet wurde. In diesem Fall wird jeweils nur ein einziger Datensatz an das Modell gesendet. Wenn der Platzhalter `$records` ist, werden die Datensätze durch eine Liste von Datensätzen ersetzt, für die jeweils eine Vorlage von `record_template` bereitgestellt wird.
+ **record\$1template** – Eine Vorlagenzeichenfolge, die verwendet wird, um jeden Datensatz der Modelleingabe aus Datensatz-Instances zu erstellen. Sie wird nur verwendet und benötigt, wenn `content_type` `application/json` ist. Die Vorlagenzeichenfolge kann einen der folgenden Werte enthalten:
+ Ein `$features` Platzhalterparameter, der durch eine Reihe von Feature-Werten ersetzt wird. Ein zusätzlicher optionaler Platzhalter kann die Namen der Feature-Spaltenüberschriften in `$feature_names` ersetzen. Dieser optionale Platzhalter wird durch eine Reihe von Feature-Namen ersetzt.
+ Genau ein Platzhalter `$features_kvp`, der durch die Schlüssel-Wert-Paare Feature-Name und Feature-Wert ersetzt wird.
+ Eine Funktion in der `headers` Konfiguration. Beispielsweise wird ein Feature-Name `A`, der in der Platzhaltersyntax `"${A}"` notiert ist, durch den Feature-Wert für `A` ersetzt.
Der Wert für `record_template` wird mit verwendet, um die `content_template` Modelleingabe zu konstruieren. Es folgt ein Konfigurationsbeispiel, das zeigt, wie eine Modelleingabe mithilfe einer Inhalts- und Datensatzvorlage erstellt wird.
Im folgenden Codebeispiel sind die Header und Features wie folgt definiert.
+ ``headers`:["A", "B"]`
+ ``features`:[[0,1], [3,4]]`
Die Eingabe des Modells sieht wie folgt aus.
```
{
"instances": [[0, 1], [3, 4]],
"feature_names": ["A", "B"]
}
```
Das Beispiel `content_template` und die `record_template` Parameterwerte für die Konstruktion der vorherigen Beispielmodelleingabe folgen.
+ `content_template: "{\"instances\": $records, \"feature_names\": $feature_names}"`
+ `record_template: "$features"`
Im folgenden Codebeispiel sind die Header und Features wie folgt definiert.
```
[
{ "A": 0, "B": 1 },
{ "A": 3, "B": 4 },
]
```
Das Beispiel ` content_template` und `record_template` Parameterwerte für die Konstruktion der vorherigen Beispielmodelleingabe folgen.
+ `content_template: "$records"`
+ `record_template: "$features_kvp"`
Es folgt ein alternatives Codebeispiel zum Konstruieren der vorherigen Beispielmodelleingabe.
+ `content_template: "$records"`
+ `record_template: "{\"A\": \"${A}\", \"B\": \"${B}\"}"`
Im folgenden Codebeispiel sind die Header und Features wie folgt definiert.
```
{ "A": 0, "B": 1 }
```
Die oben zu erstellenden Beispielwerte der Parameter content\$1template und record\$1template: Es folgt die Eingabe des vorherigen Beispielmodells.
+ `content_template: "$record"`
+ `record_template: "$features_kvp"`
Weitere Beispiele finden Sie unter [Endpunktreaktionen für Zeitreihendaten](clarify-processing-job-data-format-time-series-request-jsonlines.md).
+ **label** — (Optional) Ein auf Null basierender Integer-Index oder eine JMESPath Ausdruckszeichenfolge, die verwendet wird, um vorhergesagte Labels aus der Modellausgabe für die Bias-Analyse zu extrahieren. Wenn es sich bei dem Modell um ein Mehrklassenmodell handelt und der `label` Parameter alle vorhergesagten Beschriftungen aus der Modellausgabe extrahiert, gilt Folgendes. Dieses Feature wird für Zeitreihen nicht unterstützt.
+ Der `probability` Parameter ist erforderlich, um die entsprechenden Wahrscheinlichkeiten (oder Werte) aus der Modellausgabe abzurufen.
+ Die vorhergesagte Beschriftung mit der höchsten Punktzahl wird ausgewählt.
Der Wert für `label` hängt wie folgt vom Wert des Parameters accept\$1type ab.
+ Wenn `accept_type` **text/csv** ist, ist `label` der Index aller vorhergesagten Labels in der Modellausgabe.
+ Wenn `accept_type` es **application/jsonlines** oder ist**application/json**, dann `label` ist es ein JMESPath Ausdruck, der auf die Modellausgabe angewendet wird, um die vorhergesagten Labels zu erhalten.
+ **label\$1headers** – (optional) ein Array von Werten, die die Beschriftung im Datensatz annehmen kann. Wenn eine Bias-Analyse angefordert wird, muss der `probability` Parameter auch die entsprechenden Wahrscheinlichkeitswerte (Werte) aus der Modellausgabe abrufen, und es wird die vorhergesagte Beschriftung mit der höchsten Punktzahl ausgewählt. Wenn eine Erklärbarkeitsanalyse angefordert wird, werden die Beschriftung-Header verwendet, um den Analysebericht zu verschönern. Für die Erklärbarkeit von Computer Vision `label_headers` ist ein Wert für erforderlich. Wenn die Bezeichnung beispielsweise bei einem Klassifizierungsproblem mit mehreren Klassen drei mögliche Werte hat, **bird**, **cat**, und **dog**, `label_headers` soll auf `["bird","cat","dog"]` gesetzt werden.
+ **Wahrscheinlichkeit** — (Optional) Ein auf Null basierender Integer-Index oder eine JMESPath Ausdruckszeichenfolge, die verwendet wird, um Wahrscheinlichkeiten (Punktzahlen) für die Erklärbarkeitsanalyse (aber nicht für die Erklärbarkeit von Zeitreihen) zu extrahieren oder um die vorhergesagte Bezeichnung für die Bias-Analyse auszuwählen. Der Wert von `probability` hängt wie folgt vom Wert des `accept_type` Parameters ab.
+ Wenn `accept_type` **text/csv** ist, ist `probability` der Index der Wahrscheinlichkeiten (Werte) in der Modellausgabe. Falls `probability` nicht angegeben, wird die gesamte Modellausgabe als Wahrscheinlichkeiten (Punktzahlen) verwendet.
+ Wenn `accept_type` es sich um JSON-Daten handelt (entweder **application/jsonlines** oder**application/json**), `probability` sollte es sich um einen JMESPath Ausdruck handeln, der verwendet wird, um die Wahrscheinlichkeiten (Werte) aus der Modellausgabe zu extrahieren.
+ **time\$1series\$1predictor\$1config – (Optional**) Wird nur für die Erklärbarkeit von Zeitreihen verwendet. Wird verwendet, um dem SageMaker Clarif-Prozessor mitzuteilen, wie Daten aus den als S3-URI übergebenen Daten korrekt analysiert werden. `dataset_uri`
+ **Prognose** — Ein JMESPath Ausdruck, der verwendet wird, um das Prognoseergebnis zu extrahieren.
## Beispielkonfigurationsdateien
Die folgenden Abschnitte enthalten Beispielkonfigurationsdateien für die Analyse von Daten im CSV-Format, im JSON-Lines-Format sowie für die Erklärbarkeit von natürlicher Sprachverarbeitung (NLP), Computer Vision (CV) und Zeitreihen (TS).
### Analysekonfiguration für einen CSV-Datensatz
Die folgenden Beispiele zeigen, wie Sie Verzerrungs- und Erklärbarkeitsanalysen für einen tabellarischen Datensatz im CSV-Format konfigurieren. In diesen Beispielen hat der eingehende Datensatz vier Feature-Spalten und eine binäre Beschriftungsspalte, `Target`. Der Inhalt des Datensatzes ist wie folgt. Ein Labelwert von `1` weist auf ein positives Ergebnis hin. Der Datensatz wird durch die `dataset` Verarbeitungseingabe für den SageMaker Clarif-Job bereitgestellt.
```
"Target","Age","Gender","Income","Occupation"
0,25,0,2850,2
1,36,0,6585,0
1,22,1,1759,1
0,48,0,3446,1
...
```
In den folgenden Abschnitten wird gezeigt, wie Verzerrungsmetriken, SHAP-Werte und partielle Abhängigkeitsdiagramme (PDPs), die die Bedeutung von Merkmalen für einen Datensatz im CSV-Format zeigen, vor und nach dem Training berechnet werden.
#### Berechnet alle Messwerte für Verzerrungen vor dem Training
Diese Beispielkonfiguration zeigt, wie gemessen wird, ob der Datensatz der vorherigen Stichprobe positiv auf Stichproben mit einem **Gender** Wert von `0` ausgerichtet ist. Die folgende Analysekonfiguration weist den Verarbeitungsjob SageMaker Clarify an, alle vor dem Training vorgenommenen Verzerrungsmetriken für den Datensatz zu berechnen.
```
{
"dataset_type": "text/csv",
"label": "Target",
"label_values_or_threshold": [1],
"facet": [
{
"name_or_index": "Gender",
"value_or_threshold": [0]
}
],
"methods": {
"pre_training_bias": {
"methods": "all"
}
}
}
```
#### Berechnet alle Messwerte für Verzerrungen nach dem Training
Sie können vor dem Training Messwerte für Verzerrungen vor dem Training berechnen. Sie benötigen jedoch ein trainiertes Modell, um die Messwerte für Verzerrungen nach dem Training berechnen zu können. Die folgende Beispielausgabe stammt aus einem binären Klassifikationsmodell, das Daten im CSV-Format ausgibt. In dieser Beispielausgabe enthält jede Zeile zwei Spalten. Die erste Spalte enthält die vorhergesagte Beschriftung und die zweite Spalte enthält den Wahrscheinlichkeitswert für diese Beschriftung.
```
0,0.028986845165491
1,0.825382471084594
...
```
Im folgenden Konfigurationsbeispiel wird der Verarbeitungsjob SageMaker Clarify angewiesen, alle möglichen Messwerte für Verzerrungen anhand des Datensatzes und der Vorhersagen aus der Modellausgabe zu berechnen. Im Beispiel wird das Modell auf einem SageMaker KI-Endpunkt `your_endpoint` bereitgestellt.
**Anmerkung**
Im folgenden Beispielcode sind die Parameter `content_type` und `accept_type` nicht festgelegt. Daher verwenden sie automatisch den Wert des Parameters dataset\$1type, nämlich `text/csv` ist.
```
{
"dataset_type": "text/csv",
"label": "Target",
"label_values_or_threshold": [1],
"facet": [
{
"name_or_index": "Gender",
"value_or_threshold": [0]
}
],
"methods": {
"pre_training_bias": {
"methods": "all"
},
"post_training_bias": {
"methods": "all"
}
},
"predictor": {
"endpoint_name": "your_endpoint",
"label": 0
}
}
```
#### Berechnet die SHAP-Werte
In der folgenden Beispielanalysekonfiguration wird der Job angewiesen, die SHAP-Werte zu berechnen, wobei die `Target` Spalte als Beschriftungen und alle anderen Spalten als Features gekennzeichnet werden.
```
{
"dataset_type": "text/csv",
"label": "Target",
"methods": {
"shap": {
"num_clusters": 1
}
},
"predictor": {
"endpoint_name": "your_endpoint",
"probability": 1
}
}
```
In diesem Beispiel wird der `baseline` SHAP-Parameter weggelassen und der Wert des `num_clusters` Parameters `1` ist. Dadurch wird der SageMaker Clarify-Prozessor angewiesen, eine SHAP-Basisprobe zu berechnen. In diesem Beispiel ist die Wahrscheinlichkeit auf `1` gesetzt. Dadurch wird der SageMaker Clarify-Verarbeitungsjob angewiesen, den Wahrscheinlichkeitswert aus der zweiten Spalte der Modellausgabe zu extrahieren (unter Verwendung einer nullbasierten Indizierung).
#### Berechnet partielle Abhängigkeitsdiagramme () PDPs
Das folgende Beispiel zeigt, wie die Wichtigkeit des `Income` Merkmals im Analysebericht mithilfe von angezeigt wird PDPs. Der Berichtsparameter weist den Verarbeitungsauftrag SageMaker Clarify an, einen Bericht zu generieren. Nach Abschluss des Auftrages wird der generierte Bericht als report.pdf an diesem `analysis_result` Speicherort gespeichert. Der `grid_resolution` Parameter unterteilt den Bereich der Feature-Werte in `10` Bereiche. Zusammen weisen die im folgenden Beispiel angegebenen Parameter den Verarbeitungsauftrag SageMaker Clarify an, einen Bericht zu generieren, der ein PDP-Diagramm `Income` mit `10` Segmenten auf der X-Achse enthält. Auf der Y-Achse wird der geringfügige Einfluss von `Income` auf die Prognosen dargestellt.
```
{
"dataset_type": "text/csv",
"label": "Target",
"methods": {
"pdp": {
"features": ["Income"],
"grid_resolution": 10
},
"report": {
"name": "report"
}
},
"predictor": {
"endpoint_name": "your_endpoint",
"probability": 1
},
}
```
#### Berechnet sowohl Messwerte für Verzerrungen als auch die Bedeutung der Features
Sie können alle Methoden aus den vorherigen Konfigurationsbeispielen in einer einzigen Analysekonfigurationsdatei kombinieren und sie alle mit einem einzigen Auftrag berechnen. Das folgende Beispiel zeigt eine Analysekonfiguration, bei der alle Schritte kombiniert wurden.
In diesem Beispiel ist der `probability` Parameter so eingestellt, dass `1` angibt, dass Wahrscheinlichkeiten in der zweiten Spalte enthalten sind (unter Verwendung einer nullbasierten Indizierung). Da für die Bias-Analyse jedoch ein vorhergesagtes Label erforderlich ist, ist der `probability_threshold` Parameter auf `0.5`eingestellt, dass er den Wahrscheinlichkeitswert in eine binäre Beschriftung umwandelt. In diesem Beispiel ist der `top_k_features` Parameter der `pdp` Methode partielle Abhängigkeitsdiagramme auf `2` festgelegt. Dadurch wird der Verarbeitungsauftrag SageMaker Clarify angewiesen, partielle Abhängigkeitsdiagramme (PDPs) für die `2` Top-Features mit den größten globalen SHAP-Werten zu berechnen.
```
{
"dataset_type": "text/csv",
"label": "Target",
"probability_threshold": 0.5,
"label_values_or_threshold": [1],
"facet": [
{
"name_or_index": "Gender",
"value_or_threshold": [0]
}
],
"methods": {
"pre_training_bias": {
"methods": "all"
},
"post_training_bias": {
"methods": "all"
},
"shap": {
"num_clusters": 1
},
"pdp": {
"top_k_features": 2,
"grid_resolution": 10
},
"report": {
"name": "report"
}
},
"predictor": {
"endpoint_name": "your_endpoint",
"probability": 1
}
}
```
Anstatt das Modell auf einem Endpunkt bereitzustellen, können Sie mithilfe des Parameters den Namen Ihres SageMaker KI-Modells für den SageMaker Clarif-Verarbeitungsjob angeben. `model_name` Das folgende Beispiel zeigt, wie Sie ein Modell mit dem Namen **your\$1model** angeben. Der SageMaker Clarif-Verarbeitungsjob erstellt mithilfe der Konfiguration einen Schattenendpunkt.
```
{
...
"predictor": {
"model_name": "your_model",
"initial_instance_count": 1,
"instance_type": "ml.m5.large",
"probability": 1
}
}
```
### Analysekonfiguration für einen JSON Lines-Datensatz
Die folgenden Beispiele zeigen, wie die Verzerrungsanalyse und die Erklärbarkeitsanalyse für einen tabellarischen Datensatz im JSON Lines-Format konfiguriert werden. In diesen Beispielen enthält der eingehende Datensatz dieselben Daten wie im vorherigen Abschnitt, sie liegen jedoch im dichten Format SageMaker AI JSON Lines vor. Jede Zeile ist ein gültiges JSON-Objekt. Der Schlüssel „Features“ zeigt auf eine Reihe von Feature-Werten, und der Schlüssel „Beschriftung“ zeigt auf die Ground-Truth-Beschriftung. Der Datensatz wird dem SageMaker Clarify-Job durch die Verarbeitungseingabe „Datensatz“ zur Verfügung gestellt. Weitere Informationen zu JSON-Zeilen finden Sie unter [JSONLINES-Anfrageformat](cdf-inference.md#cm-jsonlines).
```
{"Features":[25,0,2850,2],"Label":0}
{"Features":[36,0,6585,0],"Label":1}
{"Features":[22,1,1759,1],"Label":1}
{"Features":[48,0,3446,1],"Label":0}
...
```
In den folgenden Abschnitten wird gezeigt, wie Verzerrungsmetriken vor und nach dem Training, SHAP-Werte und partielle Abhängigkeitsdiagramme (PDPs) berechnet werden, die die Bedeutung von Merkmalen für einen Datensatz im Format JSON Lines zeigen.
#### Berechnen von Verzerrungsmetriken vor dem Training
Geben Sie die Bezeichnung, die Merkmale, das Format und die Methoden zur Messung der Messwerte für Verzerrungen vor dem Training für einen `Gender` Wert von `0` an. Im folgenden Beispiel gibt der `headers` Parameter zuerst die Feature-Namen an. Der Beschriftungsname wird zuletzt angegeben. Konventionell ist der letzte Header der Beschriftung-Header.
Der `features` Parameter ist auf den JMESPath Ausdruck „Features“ gesetzt, sodass der SageMaker Clarify-Verarbeitungsjob das Feature-Array aus jedem Datensatz extrahieren kann. Der `label` Parameter ist auf den JMESPath Ausdruck „Label“ gesetzt, sodass der SageMaker Clarify-Verarbeitungsauftrag das Ground-Truth-Etikett aus jedem Datensatz extrahieren kann. Verwenden Sie einen Facettennamen, um das sensible Attribut wie folgt anzugeben.
```
{
"dataset_type": "application/jsonlines",
"headers": ["Age","Gender","Income","Occupation","Target"],
"label": "Label",
"features": "Features",
"label_values_or_threshold": [1],
"facet": [
{
"name_or_index": "Gender",
"value_or_threshold": [0]
}
],
"methods": {
"pre_training_bias": {
"methods": "all"
}
}
}
```
#### Berechnet alle Messwerte für die systematische Abweichung
Sie benötigen ein trainiertes Modell, um die Messwerte für Verzerrungen nach dem Training berechnen zu können. Das folgende Beispiel stammt aus einem binären Klassifizierungsmodell, das JSON-Lines-Daten im Format des Beispiels ausgibt. Jede Zeile der Modellausgabe ist ein gültiges JSON-Objekt. Die `predicted_label` Schlüsselpunkte weisen auf die vorhergesagte Beschriftung und die `probability` Schlüsselpunkte auf den Wahrscheinlichkeitswert hin.
```
{"predicted_label":0,"probability":0.028986845165491}
{"predicted_label":1,"probability":0.825382471084594}
...
```
Sie können das Modell auf einem SageMaker KI-Endpunkt mit dem Namen bereitstellen`your_endpoint`. Die folgende Beispielanalysekonfiguration weist den Verarbeitungsjob SageMaker Clarify an, alle möglichen Bias-Metriken sowohl für den Datensatz als auch für das Modell zu berechnen. In diesem Beispiel sind die Parameter `content_type` und `accept_type` nicht enthalten. Daher werden sie automatisch so eingestellt, dass sie den Wert des Parameters dataset\$1type verwenden, nämlich `application/jsonlines` ist. Der Verarbeitungsauftrag SageMaker Clarify verwendet den `content_template` Parameter, um die Modelleingabe zu erstellen, indem er den `$features` Platzhalter durch eine Reihe von Funktionen ersetzt.
```
{
"dataset_type": "application/jsonlines",
"headers": ["Age","Gender","Income","Occupation","Target"],
"label": "Label",
"features": "Features",
"label_values_or_threshold": [1],
"facet": [
{
"name_or_index": "Gender",
"value_or_threshold": [0]
}
],
"methods": {
"pre_training_bias": {
"methods": "all"
},
"post_training_bias": {
"methods": "all"
}
},
"predictor": {
"endpoint_name": "your_endpoint",
"content_template": "{\"Features\":$features}",
"label": "predicted_label"
}
}
```
#### Berechnet die SHAP-Werte
Da für die SHAP-Analyse kein Ground-Truth-Etikett erforderlich ist, wird der `label` Parameter weggelassen. In diesem Beispiel wird der `headers` Parameter ebenfalls weggelassen. Daher muss der Verarbeitungsauftrag SageMaker Clarify Platzhalter mit generischen Namen wie `column_0` oder `column_1` für Feature-Header und `label0` für Label-Header generieren. Sie können Werte für `headers` und für `label` angeben, um die Lesbarkeit des Analyseergebnisses zu verbessern. Da der Wahrscheinlichkeitsparameter auf JMESPath Ausdruck gesetzt ist`probability`, wird der Wahrscheinlichkeitswert aus der Modellausgabe extrahiert. Im Folgenden finden Sie ein Beispiel zur Berechnung von SHAP-Werten.
```
{
"dataset_type": "application/jsonlines",
"features": "Features",
"methods": {
"shap": {
"num_clusters": 1
}
},
"predictor": {
"endpoint_name": "your_endpoint",
"content_template": "{\"Features\":$features}",
"probability": "probability"
}
}
```
#### Berechnet partielle Abhängigkeitsdiagramme () PDPs
Das folgende Beispiel zeigt, wie Sie die Bedeutung von „Einkommen“ für PDP betrachten können. In diesem Beispiel werden die Feature-Header nicht bereitgestellt. Daher muss der `features` Parameter der `pdp` Methode einen auf Null basierenden Index verwenden, um auf die Position der Feature-Spalte zu verweisen. Der `grid_resolution` Parameter unterteilt den Bereich der Feature-Werte in `10` Bereiche. Zusammen weisen die Parameter im Beispiel den Verarbeitungsauftrag SageMaker Clarify an, einen Bericht zu generieren, der ein PDP-Diagramm `Income` mit `10` Segmenten auf der X-Achse enthält. Auf der Y-Achse wird der geringfügige Einfluss von `Income` auf die Prognosen dargestellt.
```
{
"dataset_type": "application/jsonlines",
"features": "Features",
"methods": {
"pdp": {
"features": [2],
"grid_resolution": 10
},
"report": {
"name": "report"
}
},
"predictor": {
"endpoint_name": "your_endpoint",
"content_template": "{\"Features\":$features}",
"probability": "probability"
}
}
```
#### Berechnet sowohl Messwerte für Verzerrungen als auch die Bedeutung der Features
Sie können alle vorherigen Methoden in einer einzigen Analysekonfigurationsdatei kombinieren und sie alle mit einem einzigen Auftrag berechnen. Das folgende Beispiel zeigt eine Analysekonfiguration, bei der alle Schritte kombiniert wurden. In diesem Beispiel ist der `probability` Parameter festgelegt. Da für die Bias-Analyse jedoch ein vorhergesagtes Label erforderlich ist, ist der `probability_threshold` Parameter auf `0.5`eingestellt, dass er den Wahrscheinlichkeitswert in eine binäre Beschriftung umwandelt. In diesem Beispiel ist der `top_k_features` Parameter der `pdp` Methode auf `2` gesetzt. Dadurch wird der Verarbeitungsauftrag SageMaker Clarify angewiesen, die wichtigsten `2` Features mit PDPs den größten globalen SHAP-Werten zu berechnen.
```
{
"dataset_type": "application/jsonlines",
"headers": ["Age","Gender","Income","Occupation","Target"],
"label": "Label",
"features": "Features",
"probability_threshold": 0.5,
"label_values_or_threshold": [1],
"facet": [
{
"name_or_index": "Gender",
"value_or_threshold": [0]
}
],
"methods": {
"pre_training_bias": {
"methods": "all"
},
"post_training_bias": {
"methods": "all"
},
"shap": {
"num_clusters": 1
},
"pdp": {
"top_k_features": 2,
"grid_resolution": 10
},
"report": {
"name": "report"
}
},
"predictor": {
"endpoint_name": "your_endpoint",
"content_template": "{\"Features\":$features}",
"probability": "probability"
}
}
```
### Analysekonfiguration für einen JSON-Datensatz
Die folgenden Beispiele zeigen, wie die Verzerrungs- und Erklärbarkeitsanalyse für einen tabellarischen Datensatz im JSON-Format konfiguriert wird. In diesen Beispielen enthält der eingehende Datensatz dieselben Daten wie im vorherigen Abschnitt, sie liegen jedoch im dichten SageMaker AI-JSON-Format vor. Weitere Informationen zu JSON-Zeilen finden Sie unter [JSONLINES-Anfrageformat](cdf-inference.md#cm-jsonlines).
Die gesamte Eingabeanforderung ist gültiges JSON, wobei die äußere Struktur eine Liste ist und jedes Element die Daten für einen Datensatz ist. In jedem Datensatz verweisen die `Features` Schlüsselpunkte auf eine Reihe von Featureswerten und die `Label` Schlüsselpunkte auf die Ground-Truth-Beschriftung. Der Datensatz wird durch die `dataset` Verarbeitungseingabe für den SageMaker Clarif-Job bereitgestellt.
```
[
{"Features":[25,0,2850,2],"Label":0},
{"Features":[36,0,6585,0],"Label":1},
{"Features":[22,1,1759,1],"Label":1},
{"Features":[48,0,3446,1],"Label":0},
...
]
```
In den folgenden Abschnitten wird gezeigt, wie Messwerte für Verzerrungen vor und nach dem Training, SHAP-Werte und partielle Abhängigkeitsdiagramme (PDPs) berechnet werden, die die Bedeutung von Merkmalen für einen Datensatz im Format JSON Lines zeigen.
#### Berechnen von Verzerrungsmetriken vor dem Training
Geben Sie die Bezeichnung, die Merkmale, das Format und die Methoden zur Messung der Messwerte für Verzerrungen vor dem Training für einen `Gender` Wert von `0` an. Im folgenden Beispiel gibt der `headers` Parameter zuerst die Feature-Namen an. Der Beschriftungsname wird zuletzt angegeben. Bei JSON-Datensätzen ist der letzte Header der Beschriftung-Header.
Der `features` Parameter ist auf den JMESPath Ausdruck gesetzt, der ein 2D-Array oder eine 2D-Matrix extrahiert. Jede Zeile in dieser Matrix muss die Liste von `Features` für jeden Datensatz enthalten. Der `label` Parameter ist auf JMESPath Ausdruck gesetzt, der eine Liste von Ground-Truth-Bezeichnungen extrahiert. Jedes Element in dieser Liste muss die Bezeichnung für einen Datensatz enthalten.
Verwenden Sie einen Facettennamen, um das sensible Attribut wie folgt anzugeben.
```
{
"dataset_type": "application/json",
"headers": ["Age","Gender","Income","Occupation","Target"],
"label": "[*].Label",
"features": "[*].Features",
"label_values_or_threshold": [1],
"facet": [
{
"name_or_index": "Gender",
"value_or_threshold": [0]
}
],
"methods": {
"pre_training_bias": {
"methods": "all"
}
}
}
```
#### Berechnet alle Messwerte für die systematische Abweichung
Sie benötigen ein trainiertes Modell, um die Messwerte für Verzerrungen nach dem Training berechnen zu können. Das folgende Codebeispiel stammt aus einem binären Klassifikationsmodell, das JSON-Daten im Format des Beispiels ausgibt. Im Beispiel `predictions` ist jedes Element unter die Prognoseausgabe für einen Datensatz. Der Beispielcode enthält den Schlüssel `predicted_label`, der auf die vorhergesagte Beschriftung verweist, und den Schlüssel, der auf den Wahrscheinlichkeitswert `probability` verweist.
```
{
"predictions": [
{"predicted_label":0,"probability":0.028986845165491},
{"predicted_label":1,"probability":0.825382471084594},
...
]
}
```
Sie können das Modell auf einem SageMaker KI-Endpunkt mit dem Namen bereitstellen`your_endpoint`.
Im folgenden Beispiel sind die Parameter `content_type` und `accept_type` nicht gesetzt. Daher werden `content_type` und `accept_type` automatisch so eingestellt, dass sie den Wert des Parameters `dataset_type` verwenden, nämlich `application/json` ist. Der SageMaker Clarify-Verarbeitungsjob verwendet dann den `content_template` Parameter, um die Modelleingabe zu verfassen.
Im folgenden Beispiel wird die Modelleingabe erstellt, indem der `$records` Platzhalter durch ein Array von Datensätzen ersetzt wird. Anschließend erstellt der `record_template` Parameter die JSON-Struktur jedes Datensatzes und ersetzt den `$features` Platzhalter durch das Feature-Array jedes Datensatzes.
In der folgenden Beispielanalysekonfiguration wird der Verarbeitungsjob SageMaker Clarify angewiesen, alle möglichen Messwerte für systematische Abweichungen sowohl für den Datensatz als auch für das Modell zu berechnen.
```
{
"dataset_type": "application/json",
"headers": ["Age","Gender","Income","Occupation","Target"],
"label": "[*].Label",
"features": "[*].Features",
"label_values_or_threshold": [1],
"facet": [
{
"name_or_index": "Gender",
"value_or_threshold": [0]
}
],
"methods": {
"pre_training_bias": {
"methods": "all"
},
"post_training_bias": {
"methods": "all"
}
},
"predictor": {
"endpoint_name": "your_endpoint",
"content_template": "$records",
"record_template": "{\"Features\":$features}",
"label": "predictions[*].predicted_label"
}
}
```
#### Berechnet die SHAP-Werte
Sie müssen keine Beschriftung für die SHAP-Analyse angeben. Im folgenden Beispiel ist der `headers` Parameter nicht angegeben. Daher generiert der Verarbeitungsauftrag SageMaker Clarify Platzhalter mit generischen Namen wie `column_0` oder `column_1` für Feature-Header und `label0` für Label-Header. Sie können Werte für `headers` und für `label` angeben, um die Lesbarkeit des Analyseergebnisses zu verbessern.
Im folgenden Konfigurationsbeispiel ist der Wahrscheinlichkeitsparameter auf einen JMESPath Ausdruck festgelegt, der die Wahrscheinlichkeiten aus jeder Vorhersage für jeden Datensatz extrahiert. Im Folgenden finden Sie ein Beispiel zur Berechnung von SHAP-Werten.
```
{
"dataset_type": "application/json",
"features": "[*].Features",
"methods": {
"shap": {
"num_clusters": 1
}
},
"predictor": {
"endpoint_name": "your_endpoint",
"content_template": "$records",
"record_template": "{\"Features\":$features}",
"probability": "predictions[*].probability"
}
}
```
#### Berechnet partielle Abhängigkeitsdiagramme () PDPs
Das folgende Beispiel zeigt Ihnen, wie Sie die Wichtigkeit eines Merkmals in anzeigen PDPs. In dem Beispiel werden die Feature-Header nicht bereitgestellt. Daher muss der `features` Parameter der `pdp` Methode einen auf Null basierenden Index verwenden, um auf die Position der Feature-Spalte zu verweisen. Der `grid_resolution` Parameter unterteilt den Bereich der Feature-Werte in `10` Bereiche.
Zusammen weisen die Parameter im folgenden Beispiel den Verarbeitungsauftrag SageMaker Clarify an, einen Bericht zu generieren, der ein PDP-Diagramm `Income` mit `10` Segmenten auf der X-Achse enthält. Die Y-Achse zeigt die marginalen Auswirkungen von `Income` auf die Prognosen.
Das folgende Konfigurationsbeispiel zeigt, wie wichtig ein ist. `Income` PDPs
```
{
"dataset_type": "application/json",
"features": "[*].Features",
"methods": {
"pdp": {
"features": [2],
"grid_resolution": 10
},
"report": {
"name": "report"
}
},
"predictor": {
"endpoint_name": "your_endpoint",
"content_template": "$records",
"record_template": "{\"Features\":$features}",
"probability": "predictions[*].probability"
}
}
```
#### Berechnet sowohl Messwerte für Verzerrungen als auch die Bedeutung von Features
Sie können alle vorherigen Konfigurationsmethoden in einer einzigen Analysekonfigurationsdatei kombinieren und sie alle mit einem einzigen Auftrag berechnen. Das folgende Beispiel zeigt eine Analysekonfiguration, bei der alle Schritte kombiniert wurden.
In diesem Beispiel ist der `probability` Parameter festgelegt. Da für die Bias-Analyse eine vorhergesagte Beschriftung erforderlich ist, ist der `probability_threshold` Parameter auf festgelegt. Dieser Wert wird `0.5` verwendet, um den Wahrscheinlichkeitswert in eine binäre Beschriftung umzuwandeln. In diesem Beispiel ist der `top_k_features` Parameter der `pdp` Methode auf `2` festgelegt. Dadurch wird der Verarbeitungsauftrag SageMaker Clarify angewiesen, die wichtigsten `2` Features mit den größten globalen SHAP-Werten zu berechnen PDPs .
```
{
"dataset_type": "application/json",
"headers": ["Age","Gender","Income","Occupation","Target"],
"label": "[*].Label",
"features": "[*].Features",
"probability_threshold": 0.5,
"label_values_or_threshold": [1],
"facet": [
{
"name_or_index": "Gender",
"value_or_threshold": [0]
}
],
"methods": {
"pre_training_bias": {
"methods": "all"
},
"post_training_bias": {
"methods": "all"
},
"shap": {
"num_clusters": 1
},
"pdp": {
"top_k_features": 2,
"grid_resolution": 10
},
"report": {
"name": "report"
}
},
"predictor": {
"endpoint_name": "your_endpoint",
"content_template": "$records",
"record_template": "{\"Features\":$features}",
"probability": "predictions[*].probability"
}
}
```
### Analysekonfiguration für die natürliche Sprachverarbeitung (Erklärbarkeit)
Das folgende Beispiel zeigt eine Analysekonfigurationsdatei zur Berechnung der Bedeutung von Features für die Verarbeitung natürlicher Sprache (NLP). In diesem Beispiel ist der eingehende Datensatz ein tabellarischer Datensatz im CSV-Format mit einer binären Beschriftungsspalte und zwei Feature-Spalten, wie im Folgenden dargestellt. Der Datensatz wird dem Clarify-Job durch SageMaker den `dataset` Verarbeitungs-Eingabeparameter zur Verfügung gestellt.
```
0,2,"They taste gross"
1,3,"Flavor needs work"
1,5,"Taste is awful"
0,1,"The worst"
...
```
In diesem Beispiel wurde ein binäres Klassifikationsmodell anhand des vorherigen Datensatzes trainiert. Das Modell akzeptiert CSV-Daten und gibt wie folgt eine einzelne Punktzahl zwischen `0` und `1` aus.
```
0.491656005382537
0.569582343101501
...
```
Das Modell wird verwendet, um ein SageMaker KI-Modell mit dem Namen „your\$1model“ zu erstellen. Die folgende Analysekonfiguration zeigt, wie Sie mithilfe des Modells und des Datensatzes eine Token-basierte Erklärbarkeitsanalyse durchführen. Der `text_config` Parameter aktiviert die NLP-Erklärbarkeitsanalyse. Der `granularity` Parameter gibt an, dass bei der Analyse Tokens analysiert werden sollen.
Im Englischen ist jedes Token ein Wort. Das folgende Beispiel zeigt auch, wie eine direkte SHAP-Instance mit einer durchschnittlichen „Bewertung“ von 4 bereitgestellt wird. Ein spezielles Maskentoken „[MASK]“ wird verwendet, um ein Token (Wort) in „Kommentaren“ zu ersetzen. In diesem Beispiel wird auch ein GPU-Endpunkt-Instance-Typ verwendet, um die Inferenz zu beschleunigen.
```
{
"dataset_type": "text/csv",
"headers": ["Target","Rating","Comments"]
"label": "Target",
"methods": {
"shap": {
"text_config": {
"granularity": "token",
"language": "english"
}
"baseline": [[4,"[MASK]"]],
}
},
"predictor": {
"model_name": "your_nlp_model",
"initial_instance_count": 1,
"instance_type": "ml.g4dn.xlarge"
}
}
```
### Analysekonfiguration zur besseren Verständlichkeit von Computer Vision
Das folgende Beispiel zeigt eine Analysekonfigurationsdatei, die die Bedeutung von Rechenfunktionen für Computer Vision zeigt. In diesem Beispiel besteht der Eingabedatensatz aus JPEG-Bildern. Der Datensatz wird dem Clarif-Job durch den SageMaker Eingabeparameter für die `dataset` Verarbeitung zur Verfügung gestellt. Das Beispiel zeigt, wie eine Erklärbarkeitsanalyse mithilfe eines SageMaker Bildklassifizierungsmodells konfiguriert wird. In diesem Beispiel wurde ein Modell mit dem Namen `your_cv_ic_model`, darauf trainiert, die Tiere auf den JPEG-Eingabebildern zu klassifizieren.
```
{
"dataset_type": "application/x-image",
"methods": {
"shap": {
"image_config": {
"model_type": "IMAGE_CLASSIFICATION",
"num_segments": 20,
"segment_compactness": 10
}
},
"report": {
"name": "report"
}
},
"predictor": {
"model_name": "your_cv_ic_model",
"initial_instance_count": 1,
"instance_type": "ml.p2.xlarge",
"label_headers": ["bird","cat","dog"]
}
}
```
Weitere Informationen zur Image-Klassifizierung finden Sie unter [Bildklassifizierung - MXNet](image-classification.md).
In diesem Beispiel `your_cv_od_model` wird ein [SageMaker KI-Objekterkennungsmodell](https://docs.aws.amazon.com/sagemaker/latest/dg/object-detection.html) anhand derselben JPEG-Bilder trainiert, um die Tiere auf ihnen zu identifizieren. Das folgende Beispiel zeigt, wie eine Erklärbarkeitsanalyse für das Objekterkennungsmodell konfiguriert wird.
```
{
"dataset_type": "application/x-image",
"probability_threshold": 0.5,
"methods": {
"shap": {
"image_config": {
"model_type": "OBJECT_DETECTION",
"max_objects": 3,
"context": 1.0,
"iou_threshold": 0.5,
"num_segments": 20,
"segment_compactness": 10
}
},
"report": {
"name": "report"
}
},
"predictor": {
"model_name": "your_cv_od_model",
"initial_instance_count": 1,
"instance_type": "ml.p2.xlarge",
"label_headers": ["bird","cat","dog"]
}
}
```
### Analysekonfiguration für die Erklärbarkeit von Zeitreihen-Prognosemodellen
Das folgende Beispiel zeigt eine Analysekonfigurationsdatei zur Berechnung der Bedeutung von Features für NLP. In diesem Beispiel ist der eingehende Datensatz ein Zeitreihendatensatz im JSON-Format mit einem Satz dynamischer und statischer Kovariatenmerkmale. Der Datensatz wird dem Clarify-Job SageMaker durch den Eingabeparameter für die Verarbeitung des Datensatzes bereitgestellt`dataset_uri`.
```
[
{
"item_id": "item1",
"timestamp": "2019-09-11",
"target_value": 47650.3,
"dynamic_feature_1": 0.4576,
"dynamic_feature_2": 0.2164,
"dynamic_feature_3": 0.1906,
"static_feature_1": 3,
"static_feature_2": 4
},
{
"item_id": "item1",
"timestamp": "2019-09-12",
"target_value": 47380.3,
"dynamic_feature_1": 0.4839,
"dynamic_feature_2": 0.2274,
"dynamic_feature_3": 0.1889,
"static_feature_1": 3,
"static_feature_2": 4
},
{
"item_id": "item2",
"timestamp": "2020-04-23",
"target_value": 35601.4,
"dynamic_feature_1": 0.5264,
"dynamic_feature_2": 0.3838,
"dynamic_feature_3": 0.4604,
"static_feature_1": 1,
"static_feature_2": 2
},
]
```
In den folgenden Abschnitten wird erklärt, wie Feature-Attributionen für ein Prognosemodell mit dem asymmetrischen Shapley-Werte-Algorithmus für einen JSON-Datensatz berechnet werden.
#### Berechnen Sie die Erklärungen für Zeitreihen-Prognosemodelle
In der folgenden Beispielkonfiguration werden die Optionen dargestellt, die von dem Job zur Berechnung der Erklärungen für Zeitreihen-Prognosemodelle verwendet werden.
```
{
'dataset_type': 'application/json',
'dataset_uri': 'DATASET_URI',
'methods': {
'asymmetric_shapley_value': {
'baseline': {
"related_time_series": "zero",
"static_covariates": {
"item1": [0, 0], "item2": [0, 0]
},
"target_time_series": "zero"
},
'direction': 'chronological',
'granularity': 'fine_grained',
'num_samples': 10
},
'report': {'name': 'report', 'title': 'Analysis Report'}
},
'predictor': {
'accept_type': 'application/json',
'content_template': '{"instances": $records}',
'endpoint_name': 'ENDPOINT_NAME',
'content_type': 'application/json',
'record_template': '{
"start": $start_time,
"target": $target_time_series,
"dynamic_feat": $related_time_series,
"cat": $static_covariates
}',
'time_series_predictor_config': {'forecast': 'predictions[*].mean[:2]'}
},
'time_series_data_config': {
'dataset_format': 'timestamp_records',
'item_id': '[].item_id',
'related_time_series': ['[].dynamic_feature_1', '[].dynamic_feature_2', '[].dynamic_feature_3'],
'static_covariates': ['[].static_feature_1', '[].static_feature_2'],
'target_time_series': '[].target_value',
'timestamp': '[].timestamp'
}
}
```
##### Konfiguration der Erklärbarkeit von Zeitreihen
Das vorherige Beispiel verwendet `asymmetric_shapley_value` in`methods`, um die Erklärbarkeitsargumente für Zeitreihen wie Basislinie, Richtung, Granularität und Anzahl der Stichproben zu definieren. Die Basiswerte werden für alle drei Datentypen festgelegt: verwandte Zeitreihen, statische Kovariaten und Zielzeitreihen. Diese Felder weisen den SageMaker Clarify-Prozessor an, Feature-Attributionen für jeweils ein Element zu berechnen.
##### Konfiguration des Prädiktors
Sie können die Payload-Struktur, die der Clariy-Prozessor sendet, mithilfe der SageMaker Syntax vollständig steuern. JMESPath Im vorherigen Beispiel weist die `predictor` Konfiguration Clarify an, Datensätze zu aggregieren`'{"instances": $records}'`, wobei jeder Datensatz mit den im Beispiel angegebenen Argumenten definiert wird. `record_template` Beachten Sie`$start_time`, dass`$target_time_series`, und interne Token `$static_covariates` sind`$related_time_series`, die verwendet werden, um Datensatzwerte Endpunktanforderungswerten zuzuordnen.
In ähnlicher Weise `time_series_predictor_config` wird das Attribut `forecast` in verwendet, um die Modellprognose aus der Endpunktreaktion zu extrahieren. Ihre Endpunkt-Batch-Antwort könnte beispielsweise wie folgt aussehen:
```
{
"predictions": [
{"mean": [13.4, 3.6, 1.0]},
{"mean": [23.0, 4.7, 3.0]},
{"mean": [3.4, 5.6, 2.0]}
]
}
```
Angenommen, Sie geben die folgende Konfiguration für Zeitreihenprädiktoren an:
```
'time_series_predictor_config': {'forecast': 'predictions[*].mean[:2]'}
```
Der Prognosewert wird wie folgt analysiert:
```
[
[13.4, 3.6],
[23.0, 4.7],
[3.4, 5.6]
]
```
##### Datenkonfiguration
Verwenden Sie das `time_series_data_config` Attribut, um den SageMaker Clarif-Prozessor anzuweisen, Daten anhand der als S3-URI übergebenen Daten korrekt zu analysieren. `dataset_uri`
# Leitfaden zur Kompatibilität von Datenformaten
In diesem Handbuch werden die Datenformattypen beschrieben, die mit SageMaker Clarif-Verarbeitungsaufträgen kompatibel sind. Zu den unterstützten Datenformattypen gehören die Dateierweiterungen, die Datenstruktur und spezifische Anforderungen oder Einschränkungen für Tabellen-, Bild- und Zeitreihendatensätze. In diesem Leitfaden erfahren Sie auch, wie Sie überprüfen können, ob Ihr Datensatz diesen Anforderungen entspricht.
Auf einer höheren Ebene folgt der SageMaker Clarify-Verarbeitungsjob dem Eingabe-Prozess-Ausgabe-Modell zur Berechnung von Messwerten und Merkmalsattributionen. Einzelheiten finden Sie in den folgenden Beispielen.
Die Eingabe für den Verarbeitungsauftrag SageMaker Clarify besteht aus folgenden Komponenten:
+ Der zu analysierende Datensatz.
+ Die Analysekonfiguration. Weitere Informationen darüber, wie Sie diese Analyse konfigurieren, finden Sie unter [Analyse-Konfigurationsdateien](clarify-processing-job-configure-analysis.md).
Während der Verarbeitungsphase berechnet SageMaker Clarify Verzerrungsmetriken und Merkmalszuweisungen. Der SageMaker Clarify-Verarbeitungsjob schließt die folgenden Schritte im Backend ab:
+ **Der SageMaker Clarif-Verarbeitungsjob analysiert Ihre Analysekonfiguration und lädt Ihren Datensatz.**
+ Um Messwerte und Featureszuschreibungen nach dem Training zu berechnen, benötigt der Auftrag Modellvorhersagen aus Ihrem Modell. **Der Verarbeitungsjob SageMaker Clarify serialisiert Ihre Daten und sendet sie als **Anfrage** an Ihr Modell, das auf einem SageMaker KI-Echtzeit-Inferenzendpunkt bereitgestellt wird.** **Danach extrahiert der SageMaker Clarify-Verarbeitungsjob Prognosen aus der Antwort.**
+ Der Verarbeitungsauftrag SageMaker Clarify führt die Verzerrungs- und Erklärbarkeitsanalyse durch und gibt anschließend die Ergebnisse aus.
Weitere Informationen finden Sie unter [Wie SageMaker Clarify Processing Jobs funktionieren](clarify-configure-processing-jobs.md#clarify-processing-job-configure-how-it-works).
Der Parameter, mit dem Sie das Format der Daten angeben, hängt wie folgt davon ab, wo die Daten im Verarbeitungsablauf verwendet werden:
+ Verwenden Sie für einen **Eingabedatensatz** den `dataset_type` Parameter, um das Format oder den MIME-Typ anzugeben.
+ Verwenden Sie bei einer **Anfrage** an einen Endpunkt den `content_type` Parameter, um das Format anzugeben.
+ Verwenden Sie für eine **Antwort** von einem Endpunkt den `accept_type` Parameter, um das Format anzugeben.
Der Eingabedatensatz, die Anfrage und die Antwort an und vom Endpunkt benötigen nicht dasselbe Format. Sie können beispielsweise einen Parquet-Datensatz mit einer CSV **Anforderungsnutzlast** und einer JSON Lines **Antwortnutzlast** unter den folgenden Bedingungen verwenden.
+ Ihre Analyse ist korrekt konfiguriert.
+ Ihr Modell unterstützt die Anforderungs- und Antwortformate.
**Anmerkung**
Wenn `content_type` oder nicht angegeben `accept_type` werden, leitet der Clarith-Container SageMaker den Wert und ab. `content_type` `accept_type`
**Topics**
+ [Tabellendaten](clarify-processing-job-data-format-tabular.md)
+ [Anforderungen an die Image-Tags](clarify-processing-job-data-format-image.md)
+ [Zeitreihendaten](clarify-processing-job-data-format-time-series.md)
# Tabellendaten
Tabellendaten beziehen sich auf Daten, die in einen zweidimensionalen Datenrahmen geladen werden können. In dem Frame steht jede Zeile für einen Datensatz, und jeder Datensatz hat eine oder mehrere Spalten. Bei den Werten in jeder Zelle des Datenrahmens kann es sich um numerische, kategoriale oder Textdatentypen handeln.
## Voraussetzungen für tabellarische Datensätze
Vor der Analyse sollten für Ihren Datensatz bereits alle erforderlichen Vorverarbeitungsschritte durchgeführt worden sein. Dazu gehören Datenbereinigung oder Feature-Engineering.
Sie können einen oder mehrere Datensätze bereitstellen. Wenn Sie mehrere Datensätze angeben, verwenden Sie die folgenden Hinweise, um sie für den Verarbeitungsauftrag SageMaker Clarify zu identifizieren.
+ Verwenden Sie entweder eine [ProcessingInput](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProcessingInput.html)benannte Konfiguration `dataset` oder die Analysekonfiguration`dataset_uri`, um den Hauptdatensatz anzugeben. Weitere Informationen über `dataset_uri` finden Sie in der Parameterliste unter [Analyse-Konfigurationsdateien](clarify-processing-job-configure-analysis.md).
+ Verwenden Sie den in der Analysekonfigurationsdatei bereitgestellten `baseline` Parameter. Der Basisdatensatz ist für die SHAP-Analyse erforderlich. Weitere Informationen zur Analysekonfigurationsdatei, einschließlich Beispielen, finden Sie unter [Analyse-Konfigurationsdateien](clarify-processing-job-configure-analysis.md).
In der folgenden Tabelle sind die unterstützten Datenformate, ihre Dateierweiterungen und MIME-Typen aufgeführt.
| Data format (Datenformat) | Dateierweiterung | MIME-Typ |
| --- | --- | --- |
| CSV | csv | `text/csv` |
| JSON-Lines | jsonl | `application/jsonlines` |
| JSON | json | `application/json` |
| Parquet | parquet | „Anwendung/X-Parkett“ |
Die folgenden Abschnitte zeigen beispielhafte tabellarische Datensätze in den Formaten CSV, JSON Lines und Apache Parquet.
### Voraussetzungen für tabellarische Datensätze im CSV-Format
Der SageMaker Clarif-Verarbeitungsjob dient zum Laden von CSV-Datendateien im [csv.Excel-Dialekt](https://docs.python.org/3/library/csv.html#csv.excel). Er ist jedoch flexibel genug, um auch andere Leitungsabschlüsse, einschließlich `\n` und `\r`, zu unterstützen.
Aus Kompatibilitätsgründen müssen alle CSV-Datendateien, die für den SageMaker Clarif-Verarbeitungsauftrag bereitgestellt werden, in UTF-8 codiert sein.
Wenn Ihr Datensatz keine Kopfzeile enthält, gehen Sie folgendermaßen vor:
+ Stellen Sie die Bezeichnung der Analysekonfiguration auf `0` Index ein. Das bedeutet, dass die erste Spalte die Ground-Truth-Beschriftung ist.
+ Wenn der Parameter `headers` gesetzt ist, legen Sie ihn `label` auf die Überschrift der Beschriftungsspalte fest, um die Position der Beschriftungsspalte anzugeben. Alle anderen Spalten werden als Features bezeichnet.
Das Folgende ist ein Beispiel für einen Datensatz, der keine Kopfzeile enthält.
```
1,5,2.8,2.538,This is a good product
0,1,0.79,0.475,Bad shopping experience
...
```
Wenn Ihre Daten eine Kopfzeile enthalten, setzen Sie den Parameter `label` auf Index `0`. Verwenden Sie die Ground-Truth-Labelüberschrift, um die Position der Labelspalte `Label` anzugeben. Alle anderen Spalten werden als Features bezeichnet.
Nachfolgend sehen Sie ein Beispiel für eine Datenmenge, die eine Kopfzeile enthält.
```
Label,Rating,A12,A13,Comments
1,5,2.8,2.538,This is a good product
0,1,0.79,0.475,Bad shopping experience
...
```
### Voraussetzungen für tabellarische Datensätze im JSON-Format
JSON ist ein flexibles Format zur Darstellung strukturierter Daten mit beliebiger Komplexität. Die SageMaker Clarify-Unterstützung für JSON ist nicht auf ein bestimmtes Format beschränkt und ermöglicht somit flexiblere Datenformate im Vergleich zu Datensätzen in den Formaten CSV oder JSON Lines. Diese Anleitung zeigt Ihnen, wie Sie eine Analysekonfiguration für tabellarische Daten im JSON-Format einrichten.
**Anmerkung**
Um die Kompatibilität zu gewährleisten, müssen alle JSON-Datendateien, die für den SageMaker Clarif-Verarbeitungsjob bereitgestellt werden, in UTF-8 codiert sein.
Im Folgenden finden Sie ein Beispiel für Eingabedaten mit Datensätzen, die einen Schlüssel der obersten Ebene, eine Liste von Funktionen und eine Bezeichnung enthalten.
```
[
{"features":[1,5,2.8,2.538,"This is a good product"],"label":1},
{"features":[0,1,0.79,0.475,"Bad shopping experience"],"label":0},
...
]
```
Bei einer Beispielkonfigurationsanalyse für den vorherigen Eingabe-Beispieldatensatz sollten die folgenden Parameter festgelegt werden:
+ Der `label` Parameter sollte den [JMESPath](https://jmespath.org/)Ausdruck verwenden`[*].label`, um das Ground-Truth-Etikett für jeden Datensatz im Datensatz zu extrahieren. Der JMESPath Ausdruck sollte eine Liste von Bezeichnungen erzeugen, wobei das i-t-Label dem i-th-Datensatz entspricht.
+ Der `features` Parameter sollte den JMESPath Ausdruck verwenden`[*].features`, um eine Reihe von Features für jeden Datensatz im Datensatz zu extrahieren. Der JMESPath Ausdruck sollte ein 2D-Array oder eine 2D-Matrix erzeugen, wobei die i-te Zeile die Merkmalswerte für den i-ten Datensatz enthält.
Im Folgenden finden Sie Beispieleingabedaten mit Datensätzen, die einen Schlüssel der obersten Ebene und einen verschachtelten Schlüssel enthalten, der eine Liste von Features und Bezeichnungen für jeden Datensatz enthält.
```
{
"data": [
{"features":[1,5,2.8,2.538,"This is a good product"],"label":1}},
{"features":[0,1,0.79,0.475,"Bad shopping experience"],"label":0}}
]
}
```
Bei einer Beispielkonfigurationsanalyse für den vorherigen Eingabe-Beispieldatensatz sollten die folgenden Parameter festgelegt werden:
+ Der `label` Parameter verwendet den [JMESPath](https://jmespath.org/)Ausdruck`data[*].label`, um das Ground-Truth-Label für jeden Datensatz im Datensatz zu extrahieren. Der JMESPath Ausdruck sollte eine Liste von Bezeichnungen erzeugen, wobei das i-th-Label für den Datensatz steht.
+ Der `features` Parameter verwendet den JMESPath Ausdruck`data[*].features`, um das Feature-Array für jeden Datensatz im Datensatz zu extrahieren. Der JMESPath Ausdruck sollte ein 2D-Array oder eine 2D-Matrix erzeugen, in der die i-te Zeile die Merkmalswerte für den i-ten Datensatz enthält.
### Voraussetzungen für tabellarische Datensätze im Format JSON Lines
JSON Lines ist ein Textformat zur Darstellung strukturierter Daten, wobei jede Zeile ein gültiges JSON-Objekt ist. Derzeit unterstützen SageMaker Clarife-Verarbeitungsaufträge nur JSON-Zeilen im SageMaker AI-Dense Format. Um dem erforderlichen Format zu entsprechen, sollten alle Funktionen eines Datensatzes in einem einzigen JSON-Array aufgelistet werden. Weitere Informationen zu JSON-Zeilen finden Sie unter [JSONLINES-Anfrageformat](cdf-inference.md#cm-jsonlines).
**Anmerkung**
Alle JSON Lines-Datendateien, die für den SageMaker Clarif-Verarbeitungsauftrag bereitgestellt werden, müssen in UTF-8 codiert sein, um die Kompatibilität sicherzustellen.
Im Folgenden finden Sie ein Beispiel dafür, wie Sie eine Analysekonfiguration für einen Datensatz festlegen, der einen **Schlüssel der obersten Ebene** und eine **Liste** von Elementen enthält.
```
{"features":[1,5,2.8,2.538,"This is a good product"],"label":1}
{"features":[0,1,0.79,0.475,"Bad shopping experience"],"label":0}
...
```
Bei der Konfigurationsanalyse für das vorherige Datensatzbeispiel sollten die Parameter wie folgt festgelegt werden:
+ Um die Position des Ground-Truth-Labels anzugeben, `label` sollte der Parameter auf den Ausdruck gesetzt werden. JMESPath `label`
+ Um die Position der Feature-Anordnung anzugeben, `features` sollte der Parameter auf den JMESPath Ausdruck gesetzt werden`features`.
Im Folgenden finden Sie ein Beispiel dafür, wie Sie eine Analysekonfiguration für einen Datensatz festlegen, der einen Schlüssel der **obersten Ebene** und einen **verschachtelten Schlüssel** enthält, der eine **Liste** von Elementen enthält.
```
{"data":{"features":[1,5,2.8,2.538,"This is a good product"],"label":1}}
{"data":{"features":[0,1,0.79,0.475,"Bad shopping experience"],"label":0}}
...
```
Bei der Konfigurationsanalyse für das vorherige Datensatzbeispiel sollten die Parameter wie folgt festgelegt werden:
+ Der Parameter `label` sollte auf den JMESPath Ausdruck `data.label` gesetzt werden, der die Position des Ground-Truth-Labels angibt.
+ Der Parameter `features` sollte auf den JMESPath Ausdruck gesetzt werden`data.features`, der die Position der Feature-Anordnung angibt.
### Voraussetzungen für tabellarische Datensätze im Parquet-Format
[Parquet](https://parquet.apache.org/) ist ein spaltenorientiertes binäres Datenformat. Derzeit unterstützen SageMaker Clarif-Verarbeitungsaufträge das Laden von Parquet-Datendateien nur dann, wenn die Anzahl der Verarbeitungsinstanzen auf dem Wert steht`1`.
Da SageMaker Clarif-Verarbeitungsaufträge keine Endpunktanfrage oder Endpunktantwort im Parquet-Format unterstützen, müssen Sie das Datenformat der Endpunktanforderung angeben, indem Sie den Analyse-Konfigurationsparameter `content_type` auf ein unterstütztes Format setzen. Weitere Informationen finden Sie unter `content_type` in [Analyse-Konfigurationsdateien](clarify-processing-job-configure-analysis.md).
Die Parquet-Daten müssen Spaltennamen haben, die als Zeichenketten formatiert sind. Verwenden Sie den `label` Analysekonfigurationsparameter, um den Namen der Beschriftungspalte so festzulegen, dass er die Position der Ground-Truth-Beschriftungen angibt. Alle anderen Spalten werden als Features bezeichnet.
# Endpunktanforderungen für Tabellendaten
Um Modellvorhersagen für die Verzerrungsanalyse nach dem Training und die Analyse der Merkmalswichtigkeit zu erhalten, serialisieren SageMaker Clarify-Verarbeitungsaufträge die Tabellendaten in Byte und senden diese als Anforderungs-Payload an einen Inferenzendpunkt. Diese tabellarischen Daten stammen entweder aus dem Eingabedatensatz oder sie werden generiert. Handelt es sich um synthetische Daten, werden sie vom Erklärer für die SHAP- oder PDP-Analyse generiert.
Das Datenformat der Anforderungs-Payload sollte durch den Analyse- `content_type` Konfigurationsparameter angegeben werden. Wenn der Parameter nicht angegeben wird, verwendet der SageMaker Clarif-Verarbeitungsauftrag den Wert des `dataset_type` Parameters als Inhaltstyp. Weitere Informationen über `content_type` oder `dataset_type` finden Sie unter [Analyse-Konfigurationsdateien](clarify-processing-job-configure-analysis.md).
Die folgenden Abschnitte zeigen Beispiele für Endpunktanforderungen in den Formaten CSV und JSON Lines.
## Endpunkt-Anfrage im CSV-Format
Der SageMaker Clarify-Verarbeitungsjob kann Daten in das CSV-Format (MIME-Typ:`text/csv`) serialisieren. In der folgenden Tabelle werden Beispiele für serialisierte Anforderungs-Payloads dargestellt.
| Payload für Endpunktanfragen (Zeichenkettendarstellung) | Kommentare |
| --- | --- |
| '1,2,3,4' | Einzelner Datensatz (vier numerische Features). |
| '1,2,3,4\$1n5,6,7,8' | Zwei Datensätze, getrennt durch einen Zeilenumbruch '\$1n'. |
| '"Das ist ein gutes Produkt“ ,5' | Einzelner Datensatz (ein Textfeature und ein numerisches Feature). |
| '"Das ist ein gutes Produkt“ ,5\$1n„Schlechtes Einkaufserlebnis“ ,1' | Zwei Datensätze. |
## Die Endpunktanforderung ist im Format JSON Lines
Der Verarbeitungsjob SageMaker Clarify kann Daten in das dichte Format SageMaker AI JSON Lines (MIME-Typ:`application/jsonlines`) serialisieren. Weitere Informationen zu JSON-Zeilen finden Sie unter [JSONLINES-Anfrageformat](cdf-inference.md#cm-jsonlines).
Um Tabellendaten in JSON-Daten umzuwandeln, geben Sie eine Vorlagenzeichenfolge für den `content_template` Analyse-Konfigurationsparameter an. Weitere Informationen zu `content_template` finden Sie unter [Analyse-Konfigurationsdateien](clarify-processing-job-configure-analysis.md). Die folgende Tabelle zeigt Beispiele für serialisierte JSON-Lines-Anforderungs-Payloads.
| Nutzlast für Endpunktanfragen (Zeichenkettendarstellung) | Kommentare |
| --- | --- |
| '\$1"data“: \$1"Funktionen“: [1,2,3,4]\$1\$1' | Einzelner Datensatz. In diesem Fall sieht die Vorlage wie die Liste der Funktionen aus `'{"data":{"features":$features}}' ` und `$features` wird durch `[1,2,3,4]` diese ersetzt. |
| '\$1"Daten“: \$1"Funktionen“: [1,2,3,4]\$1\$1\$1n\$1"Daten“: \$1"Funktionen“: [5,6,7,8]\$1\$1' | Zwei Datensätze. |
| '\$1"features“: ["Das ist ein gutes Produkt“ ,5]\$1' | Einzelner Datensatz. In diesem Fall sieht die Vorlage so `'{"features":$features}'` aus und \$1features wird durch die Liste der `["This is a good product",5]` Funktionen ersetzt. |
| '\$1"features“: ["Das ist ein gutes Produkt“ ,5]\$1\$1n\$1"features“: ["Schlechtes Einkaufserlebnis“ ,1]\$1' | Zwei Datensätze. |
## Die Endpunkt-Anfrage verwendet das JSON-Format
Ein SageMaker Clarif-Verarbeitungsjob kann Daten in beliebige JSON-Strukturen (MIME-Typ:`application/json`) serialisieren. Dazu müssen Sie eine Vorlagenzeichenfolge für den `content_template` Analyse-Konfigurationsparameter angeben. Dies wird vom SageMaker Clarif-Verarbeitungsjob verwendet, um die äußere JSON-Struktur zu erstellen. Sie müssen auch eine Vorlagenzeichenfolge für `record_template` angeben, die verwendet wird, um die JSON-Struktur für jeden Datensatz zu erstellen. Weitere Informationen zu `content_template` und `record_template` finden Sie unter [Analyse-Konfigurationsdateien](clarify-processing-job-configure-analysis.md).
**Anmerkung**
Da es sich bei `content_template` und `record_template` um Zeichenkettenparameter handelt, sollten alle doppelten Anführungszeichen (`"`), die Teil der serialisierten JSON-Struktur sind, in Ihrer Konfiguration als Escape-Zeichen vermerkt werden. Wenn Sie beispielsweise ein doppeltes Anführungszeichen in Python umgehen möchten, könnten Sie Folgendes für `content_template` eingeben.
```
"{\"data\":{\"features\":$record}}}"
```
Die folgende Tabelle zeigt Beispiele für serialisierte JSON-Anforderungs-Payloads und die entsprechenden `content_template` und `record_template` N-Parameter, die zu ihrer Erstellung erforderlich sind.
| Nutzlast für Endpunktanfragen (Zeichenkettendarstellung) | Kommentare | content\$1template | Datensatzvorlage |
| --- | --- | --- | --- |
| '\$1"data“: \$1"Funktionen“: [1,2,3,4]\$1\$1' | Einzelner Datensatz auf einmal. | '\$1"Daten“: \$1"Funktionen“ :\$1record\$1\$1\$1' | “\$1features” |
| '\$1"Instances“: [[0, 1], [3, 4]], „Funktionsnamen“: ["A“, „B"]\$1' | Mehrere Datensätze mit Feature-Namen. | '\$1"Instances“ :\$1records, „Feature-Namen“ :\$1feature\$1names\$1' | “\$1features" |
| '[\$1"A“: 0, „B“: 1\$1, \$1"A“: 3, „B“: 4\$1]' | Mehrfachdatensätze und Schlüssel-Wert-Paare. | “\$1records" | „\$1features\$1kvp“ |
| '\$1"A“: 0, „B“: 1\$1' | Einzelner Datensatz auf einmal und Schlüssel-Wert-Paare. | "\$1record" | „\$1features\$1kvp“ |
| '\$1"A“: 0, „verschachtelt“: \$1"B“: 1\$1\$1' | Verwenden Sie alternativ das vollständig ausführliche record\$1template für beliebige Strukturen. | "\$1record" | '\$1"A“: „\$1 \$1A\$1“, „verschachtelt“: \$1"B“: „\$1 \$1B\$1"\$1\$1' |
# Endpunktreaktion für tabellarische Daten
Nachdem der SageMaker Clarify-Verarbeitungsjob die Antwort eines Inferenzendpunkt-Aufrufs erhalten hat, deserialisiert er die Antwort-Nutzlast und extrahiert daraus Vorhersagen. Verwenden Sie den `accept_type` Analyse-Konfigurationsparameter, um das Datenformat der Antwort-Payload anzugeben. Falls nicht `accept_type` angegeben, verwendet der SageMaker Clarify-Verarbeitungsauftrag den Wert des Parameters content\$1type als Modellausgabeformat. Mehr über `accept_type` erfahren Sie unter [Analyse-Konfigurationsdateien](clarify-processing-job-configure-analysis.md).
Die Vorhersagen könnten entweder aus vorhergesagten Bezeichnungen für die Bias-Analyse oder aus Wahrscheinlichkeitswerten (Scores) für die Analyse der Featureswichtigkeit bestehen. In der `predictor` Analysekonfiguration extrahieren die folgenden drei Parameter die Vorhersagen.
+ Der Parameter `probability` wird verwendet, um die Wahrscheinlichkeitswerte (Scores) in der Endpunktreaktion zu ermitteln.
+ Der Parameter `label` wird verwendet, um die vorhergesagten Kennzeichnungen in der Endpunktreaktion zu lokalisieren.
+ (Optional) Der Parameter `label_headers` stellt die vorhergesagten Bezeichnungen für ein Mehrklassenmodell bereit.
Die folgenden Richtlinien beziehen sich auf Endpunktantworten in den Formaten CSV, JSON Lines und JSON.
## Endpunkt Response ist im CSV-Format
Wenn die Antwortnutzlast im CSV-Format (MIME-Typ:`text/csv`) vorliegt, deserialisiert der SageMaker Clarity-Verarbeitungsauftrag jede Zeile. Anschließend werden die Vorhersagen anhand der in der Analysekonfiguration bereitgestellten Spaltenindizes aus den deserialisierten Daten extrahiert. Die Zeilen in der Antwortnutzlast müssen mit den Datensätzen in der Anforderungsnutzlast übereinstimmen.
Die folgenden Tabellen enthalten Beispiele für Antwortdaten in verschiedenen Formaten und für verschiedene Problemtypen. Ihre Daten können von diesen Beispielen abweichen, sofern die Vorhersagen entsprechend der Analysekonfiguration extrahiert werden können.
In den folgenden Abschnitten werden Beispielantworten von Endpunkten in CSV-Formaten gezeigt.
### Die Endpunktantwort ist im CSV-Format und enthält nur Wahrscheinlichkeiten
Die folgende Tabelle enthält ein Beispiel für eine Endpunktreaktion für Regressions- und binäre Klassifikationsprobleme.
| Nutzlast der Endpunktanforderung | Nutzlast der Endpunktantwort (Zeichenkettendarstellung) |
| --- | --- |
| Einzelner Datensatz. | '0,6' |
| Zwei Datensätze (Ergebnisse in einer Zeile, getrennt durch Komma). | '0,6,0,3' |
| Zwei Datensätze (Ergebnisse in zwei Zeilen). | '0,6\$1n0,3' |
Im vorherigen Beispiel gibt der Endpunkt einen einzigen Wahrscheinlichkeitswert (Score) für die vorhergesagte Beschriftung aus. Um Wahrscheinlichkeiten mithilfe des Index zu extrahieren und sie für die Analyse der Merkmalswichtigkeit zu verwenden, legen Sie den Konfigurationsparameter für die Analyse `probability` auf Spaltenindex `0` fest. Diese Wahrscheinlichkeiten können auch für die systematische Analyse verwendet werden, wenn sie mithilfe des `probability_threshold` Parameters in einen Binärwert umgewandelt werden. Mehr über `probability_threshold` erfahren Sie unter [Analyse-Konfigurationsdateien](clarify-processing-job-configure-analysis.md).
Die folgende Tabelle enthält ein Beispiel für eine Endpunktreaktion für ein Problem mit mehreren Klassen.
| Nutzlast der Endpunktanforderung | Nutzlast der Endpunktantwort (Zeichenkettendarstellung) |
| --- | --- |
| Einzelner Datensatz eines Mehrklassenmodells (drei Klassen). | '0,1,0.6,0,3' |
| Zwei Datensätze eines Mehrklassenmodells (drei Klassen). | '0,1,0.6,0,3\$1n0.2,0,5,0,3' |
Im vorherigen Beispiel gibt der Endpunkt eine Liste von Wahrscheinlichkeiten (Punktzahlen) aus. Wenn kein Index angegeben wird, werden alle Werte extrahiert und für die Analyse der Featureswichtigkeit verwendet. Wenn der Konfigurationsparameter `label_headers` für die Analyse bereitgestellt wird. Anschließend kann der SageMaker Clarify-Verarbeitungsauftrag den Label-Header mit der maximalen Wahrscheinlichkeit als vorhergesagtes Label auswählen, das für die Verzerrungsanalyse verwendet werden kann. Mehr über `label_headers` erfahren Sie unter [Analyse-Konfigurationsdateien](clarify-processing-job-configure-analysis.md).
### Die Endpunktantwort ist im CSV-Format und enthält nur die vorhergesagte Beschriftung
Die folgende Tabelle enthält ein Beispiel für eine Endpunktreaktion bei Regressions- und binären Klassifizierungsproblemen.
| Nutzlast der Endpunktanforderung | Nutzlast der Endpunktantwort (Zeichenkettendarstellung) |
| --- | --- |
| Einzelner Datensatz | '1' |
| Zwei Datensätze (Ergebnisse in einer Zeile, getrennt durch Komma) | '1,0' |
| Zwei Datensätze (Ergebnisse in zwei Zeilen) | '1\$1n0' |
Im vorherigen Beispiel gibt der Endpunkt die vorhergesagte Beschriftung statt der Wahrscheinlichkeit aus. Stellen Sie den `label` Parameter der `predictor` Konfiguration auf den Spaltenindex `0` ein, sodass die vorhergesagten Beschriftungen anhand des Index extrahiert und für die Verzerrungsanalyse verwendet werden können.
### Die Endpunktantwort liegt im CSV-Format vor und enthält die vorhergesagte Bezeichnung und Wahrscheinlichkeit
Die folgende Tabelle enthält ein Beispiel für eine Endpunktreaktion für Regressions- und binäre Klassifikationsprobleme.
| Nutzlast der Endpunktanforderung | Nutzlast der Endpunktantwort (Zeichenkettendarstellung) |
| --- | --- |
| Einzelner Datensatz | '1,0.6' |
| Zwei Datensätze | '1,0.6\$1n0,0.3' |
Im vorherigen Beispiel gibt der Endpunkt die vorhergesagte Beschriftung gefolgt von seiner Wahrscheinlichkeit aus. Stellen Sie den `label` Parameter der `predictor` Konfiguration auf Spaltenindex `0` und `probability` auf Spaltenindex `1` ein, um beide Parameterwerte zu extrahieren.
### Die Endpunktantwort ist im CSV-Format und enthält vorhergesagte Bezeichnungen und Wahrscheinlichkeiten (mehrere Klassen)
Ein von Amazon SageMaker Autopilot trainiertes Mehrklassenmodell kann so konfiguriert werden, dass es die Zeichenkettendarstellung der Liste der vorhergesagten Labels und Wahrscheinlichkeiten ausgibt. Die folgende Beispieltabelle zeigt ein Beispiel für eine Endpunktantwort eines Modells, das für die Ausgabe von `predicted_label`, `probability`, `labels`, und `probabilities` konfiguriert ist.
| Nutzlast der Endpunktanforderung | Nutzlast der Endpunktantwort (Zeichenkettendarstellung) |
| --- | --- |
| Einzelner Datensatz | '"Hund“ ,0.6, "[\$1 'Katze\$1 ',\$1 'Hund\$1',\$1 'Fisch\$1 ']“, "[0.1, 0.6, 0.3]"' |
| Zwei Datensätze | '"Hund“ ,0.6, "[\$1 'Katze\$1 ',\$1 'Hund\$1',\$1 'Fisch\$1 ']“, "[0.1, 0.6, 0.3]“\$1n„Katze“ ,0.7, [\$1 'Katze\$1',\$1 'Hund\$1 ',\$1 'Fisch\$1']“, "[0.7, 0.2, 0.1]" ' |
Für das vorherige Beispiel kann der SageMaker Clarify-Verarbeitungsauftrag auf folgende Weise konfiguriert werden, um die Vorhersagen zu extrahieren.
Für die Bias-Analyse kann das vorherige Beispiel wie folgt konfiguriert werden.
+ Stellen Sie den `label` Parameter der `predictor` Konfiguration auf ein, `0` um die vorhergesagte Beschriftung zu extrahieren.
+ Stellen Sie den Parameter auf ein, `2` um die vorhergesagten Beschriftungen zu extrahieren, und legen Sie `probability` auf `3` fest, um die entsprechenden Wahrscheinlichkeiten zu extrahieren. Der Verarbeitungsauftrag SageMaker Clarify kann das vorhergesagte Label automatisch ermitteln, indem das Label mit dem höchsten Wahrscheinlichkeitswert identifiziert wird. Unter Bezugnahme auf das vorherige Beispiel eines einzelnen Datensatzes prognostiziert das Modell drei Labels: `cat`, `dog`, und `fish`, mit entsprechenden Wahrscheinlichkeiten von `0.1`, `0.6`, und `0.3`. Basierend auf diesen Wahrscheinlichkeiten ist `dog` vorhergesagt Beschriftung, da es den höchsten Wahrscheinlichkeitswert von `0.6` hat.
+ `probability` auf `3` setzen, um die Wahrscheinlichkeiten zu extrahieren. Falls `label_headers` angegeben, kann der SageMaker Clarife-Verarbeitungsjob das vorhergesagte Label automatisch ermitteln, indem er den Label-Header mit dem höchsten Wahrscheinlichkeitswert identifiziert.
Für die Analyse der Wichtigkeit von Features kann das vorherige Beispiel wie folgt konfiguriert werden.
+ `probability` legt auf `3` fest, dass die Wahrscheinlichkeiten aller vorhergesagten Beschriftungen extrahiert werden. Anschließend werden die Feature-Attributionen für alle Beschriftung berechnet. Wenn der Kunde `label_headers` nicht angibt, werden die vorhergesagten Beschriftungen als Beschriftung-Header im Analysebericht verwendet.
## Endpoint Response ist im Format JSON Lines
Wenn die Antwortnutzlast im Format JSON Lines (MIME-Typ:`application/jsonlines`) vorliegt, deserialisiert der SageMaker Clarity-Verarbeitungsjob jede Zeile als JSON. Anschließend werden mithilfe von Ausdrücken, die in der Analysekonfiguration bereitgestellt werden, Vorhersagen aus den deserialisierten Daten extrahiert JMESPath . Die Zeilen in der Antwortnutzlast müssen mit den Datensätzen in der Anforderungsnutzlast übereinstimmen. Die folgenden Tabellen zeigen Beispiele für Antwortdaten in verschiedenen Formaten. Ihre Daten können von diesen Beispielen abweichen, sofern die Vorhersagen entsprechend der Analysekonfiguration extrahiert werden können.
Die folgenden Abschnitte zeigen beispielhafte Endpunktantworten in JSON Lines-Formaten.
### Die Endpunktantwort ist im Format JSON Lines und enthält nur Wahrscheinlichkeiten
Die folgende Tabelle ist ein Beispiel für eine Endpunktantwort, die nur den Wahrscheinlichkeitswert (Score) ausgibt.
| Nutzlast der Endpunktanforderung | Nutzlast der Endpunktantwort (Zeichenkettendarstellung) |
| --- | --- |
| Einzelner Datensatz | '\$1"score":0.6\$1' |
| Zwei Datensätze | '\$1"score":0.6\$1\$1n\$1"score":0.3\$1' |
Legen Sie für das vorherige Beispiel den Analysekonfigurationsparameter `probability` auf den JMESPath Ausdruck „score“ fest, um seinen Wert zu extrahieren.
### Die Endpunktantwort ist im Format JSON Lines und enthält nur die vorhergesagte Beschriftung
Die folgende Tabelle ist ein Beispiel für eine Endpunktantwort, bei der nur die vorhergesagte Beschriftung ausgegeben wird.
| Nutzlast der Endpunktanforderung | Nutzlast der Endpunktantwort (Zeichenkettendarstellung) |
| --- | --- |
| Einzelner Datensatz | '\$1"Prognose“ :1\$1' |
| Zwei Datensätze | '\$1"Vorhersage“ :1\$1\$1n\$1"Vorhersage“ :0\$1' |
Setzen Sie für das vorherige Beispiel den `label` Parameter der Prädiktorkonfiguration auf JMESPath Ausdruck`prediction`. Anschließend kann der Verarbeitungsjob SageMaker Clarify die vorhergesagten Labels für die Bias-Analyse extrahieren. Weitere Informationen finden Sie unter [Analyse-Konfigurationsdateien](clarify-processing-job-configure-analysis.md).
### Die Endpunktantwort ist im Format JSON Lines und enthält die vorhergesagte Bezeichnung und Wahrscheinlichkeit
Die folgende Tabelle ist ein Beispiel für eine Endpunktreaktion, bei der die vorhergesagte Beschriftung und sein Ergebnis ausgegeben werden.
| Nutzlast der Endpunktanforderung | Nutzlast der Endpunktantwort (Zeichenkettendarstellung) |
| --- | --- |
| Einzelner Datensatz | '\$1"Prognose“ :1, "Ergebnis“ :0,6\$1' |
| Zwei Datensätze | '\$1"Vorhersage“ :1, "Ergebnis“ :0,6\$1\$1n\$1"Vorhersage“ :0, "Ergebnis“ :0,3\$1' |
Setzen Sie für das vorherige Beispiel den `label` Parameter der `predictor` Konfiguration auf den JMESPath Ausdruck „Prediction“, um die vorhergesagten Labels zu extrahieren. Stellen Sie `probability` den JMESPath Ausdruck „Score“ ein, um die Wahrscheinlichkeit zu extrahieren. Weitere Informationen finden Sie unter [Analyse-Konfigurationsdateien](clarify-processing-job-configure-analysis.md).
### Die Endpunktantwort ist im Format JSON Lines und enthält vorhergesagte Bezeichnungen und Wahrscheinlichkeiten (mehrere Klassen)
Die folgende Tabelle ist ein Beispiel für eine Endpunktantwort aus einem Mehrklassenmodell, das Folgendes ausgibt:
+ Eine Liste der vorhergesagten Beschriftungen.
+ Wahrscheinlichkeiten und das ausgewählte vorhergesagte Label und seine Wahrscheinlichkeit.
| Nutzlast der Endpunktanforderung | Nutzlast der Endpunktantwort (Zeichenkettendarstellung) |
| --- | --- |
| Einzelner Datensatz | '\$1"predicted\$1label“ :"dog“, "probability“ :0.6, "predicted\$1labels“: ["cat“, "dog“, "fish "], "wahrscheinlichkeiten“: [0.1,0.6,0.3]\$1' |
| Zwei Datensätze | '\$1"predicted\$1label“ :"dog“, "probability“ :0.6, "predicted\$1labels“: ["cat“, "dog“, "fish "], "wahrscheinlichkeiten“: [0.1,0.6,0.3]\$1\$1n\$1"predicted\$1label“ :"cat“, "probability“ :0.7, "predicted\$1labels“: ["cat“, "dog“, "fish "], "Wahrscheinlichkeiten“: [0.7,0.2,0.1]\$1' |
Im vorherigen Beispiel kann der Verarbeitungsauftrag SageMaker Clarify auf verschiedene Arten konfiguriert werden, um die Vorhersagen zu extrahieren.
Für die Bias-Analyse kann das vorherige Beispiel wie **Folgendes** konfiguriert werden.
+ Setzen Sie den `label` Parameter der `predictor` Konfiguration auf den JMESPath Ausdruck „predicted\$1label“, um das vorhergesagte Label zu extrahieren.
+ Setzen Sie den Parameter auf den JMESPath Ausdruck „predicted\$1labels“, um die vorhergesagten Labels zu extrahieren. Stellen Sie `probability` den JMESPath Ausdruck „Wahrscheinlichkeiten“ ein, um ihre Wahrscheinlichkeiten zu extrahieren. Der SageMaker Clarify-Job bestimmt automatisch das vorhergesagte Label, indem es das Label mit dem höchsten Wahrscheinlichkeitswert identifiziert.
+ Geben Sie `probability` den JMESPath Ausdruck „Wahrscheinlichkeiten“ ein, um deren Wahrscheinlichkeiten zu extrahieren. Wenn `label_headers` angegeben, kann der SageMaker Clarify-Verarbeitungsjob automatisch das vorhergesagte Label ermitteln, indem das Label mit dem höchsten Wahrscheinlichkeitswert identifiziert wird.
Gehen Sie zur Analyse der Featuresbedeutung wie folgt vor.
+ Geben Sie `probability` den JMESPath Ausdruck „Wahrscheinlichkeiten“ ein, um deren Wahrscheinlichkeiten für alle vorhergesagten Kennzeichnungen zu extrahieren. Anschließend werden die Feature-Attributionen für alle Beschriftungen berechnet.
## Endpunkt Response ist im JSON-Format
Wenn die Antwortnutzlast im JSON-Format (MIME-Typ:`application/json`) vorliegt, deserialisiert der SageMaker Clarify-Verarbeitungsauftrag die gesamte Nutzlast als JSON. Anschließend werden mithilfe von Ausdrücken, die in der Analysekonfiguration bereitgestellt werden, Vorhersagen aus den deserialisierten Daten extrahiert JMESPath . Die Datensätze in der Antwortnutzlast müssen mit den Datensätzen in der Anforderungsnutzlast übereinstimmen.
Die folgenden Abschnitte zeigen Beispiele für Endpunktantworten in JSON-Formaten. Die Abschnitte enthalten Tabellen mit Beispielen für Antwortdaten in verschiedenen Formaten und für verschiedene Problemtypen. Ihre Daten können von diesen Beispielen abweichen, sofern die Vorhersagen entsprechend der Analysekonfiguration extrahiert werden können.
### Die Endpunktantwort ist im JSON-Format und enthält nur Wahrscheinlichkeiten
Die folgende Tabelle ist ein Beispiel für eine Antwort von einem Endpunkt, die nur den Wahrscheinlichkeitswert (Score) ausgibt.
| Nutzlast der Endpunktanforderung | Nutzlast der Endpunktantwort (Zeichenkettendarstellung) |
| --- | --- |
| Einzelner Datensatz | '[0.6]' |
| Zwei Datensätze | '0.6,0.3' |
Im vorherigen Beispiel gibt es keinen Zeilenumbruch in der Antwortnutzlast. Stattdessen enthält ein einzelnes JSON-Objekt eine Liste von Ergebnissen, eine für jeden Datensatz in der Anfrage. Setzen Sie den Analysekonfigurationsparameter `probability` auf den JMESPath Ausdruck „[\$1]“, um den Wert zu extrahieren.
### Die Endpunktantwort ist im JSON-Format und enthält nur das vorhergesagte Label
Die folgende Tabelle ist eine Beispielantwort von einem Endpunkts, die nur das vorhergesagte Label ausgibt.
| Nutzlast der Endpunktanforderung | Nutzlast der Endpunktantwort (Zeichenkettendarstellung) |
| --- | --- |
| Einzelner Datensatz | '\$1"predicted\$1labels“: [1]\$1' |
| Zwei Datensätze | '\$1"predicted\$1labels“: [1,0]\$1' |
Setzen Sie den `label` Parameter der `predictor` Konfiguration auf den JMESPath Ausdruck „predicted\$1labels“, und dann kann der Clarify-Verarbeitungsjob SageMaker die vorhergesagten Labels für die Bias-Analyse extrahieren.
### Die Endpunktantwort ist im JSON-Format und enthält die vorhergesagte Bezeichnung und Wahrscheinlichkeit
Die folgende Tabelle ist ein Beispiel für eine Antwort von einem Endpunkt, die das vorhergesagte Label und seinen Score ausgibt.
| Nutzlast der Endpunktanforderung | Nutzlast der Endpunktantwort (Zeichenkettendarstellung) |
| --- | --- |
| Einzelner Datensatz | '\$1"Vorhersagen“: [\$1"label“ :1, "Ergebnis“ :0.6\$1' |
| Zwei Datensätze | '\$1"Vorhersagen“: [\$1"label“ :1, "score“ :0.6\$1, \$1"label“ :0, "score“ :0.3\$1]\$1' |
Legen Sie für das vorherige Beispiel den `label` Parameter der `predictor` Konfiguration auf den JMESPath Ausdruck „predictions [\$1] .label“ fest, um die vorhergesagten Labels zu extrahieren. Stellen Sie `probability` den JMESPath Ausdruck „predictions [\$1] .score“ ein, um die Wahrscheinlichkeit zu extrahieren.
### Die Endpunktantwort ist im JSON-Format und enthält vorhergesagte Bezeichnungen und Wahrscheinlichkeiten (mehrere Klassen)
Die folgende Tabelle ist ein Beispiel für eine Antwort von einem Endpunkt aus einem Mehrklassenmodell, das Folgendes ausgibt:
+ Eine Liste der vorhergesagten Labels.
+ Wahrscheinlichkeiten und das ausgewählte vorhergesagte Label und seine Wahrscheinlichkeit.
| Nutzlast der Endpunktanforderung | Nutzlast der Endpunktantwort (Zeichenkettendarstellung) |
| --- | --- |
| Einzelner Datensatz | '[\$1"predicted\$1label“ :"dog“, "probability“ :0.6, "predicted\$1labels“: ["cat“, "dog“, "fish "], "wahrscheinlichkeiten“: [0.1,0.6,0.3]\$1]' |
| Zwei Datensätze | '[\$1"predicted\$1label“ :"dog“, "probability“ :0.6, "predicted\$1labels“: ["cat“, "dog“, "fish "], "probilities“: [0.1,0.6,0.3]\$1, \$1"predicted\$1label“ :"cat“, "probability“ :0.7, "predicted\$1labels“: ["cat“, "dog“, "fish "], "Wahrscheinlichkeiten“: [0.7,0.2,0.1]\$1]' |
Der Verarbeitungsjob SageMaker Clarify kann auf verschiedene Arten konfiguriert werden, um die Vorhersagen zu extrahieren.
Für die Bias-Analyse kann das vorherige Beispiel wie **Folgendes** konfiguriert werden.
+ Setzen Sie den `label` Parameter der `predictor` Konfiguration auf den JMESPath Ausdruck „[\$1] .predicted\$1label“, um das vorhergesagte Label zu extrahieren.
+ Setzen Sie den Parameter auf den JMESPath Ausdruck „[\$1] .predicted\$1labels“, um die vorhergesagten Labels zu extrahieren. Stellen Sie `probability` den JMESPath Ausdruck „[\$1] .probabilities“ ein, um ihre Wahrscheinlichkeiten zu extrahieren. Der Verarbeitungsauftrag SageMaker Clarify kann das vorhergesagte Label automatisch ermitteln, indem das Label mit dem höchsten Näherungswert identifiziert wird.
+ Geben Sie `probability` den JMESPath Ausdruck „[\$1] .probabilities“ ein, um ihre Wahrscheinlichkeiten zu extrahieren. Wenn `label_headers` angegeben, kann der Verarbeitungsjob SageMaker Clarify automatisch das vorhergesagte Label ermitteln, indem das Label mit dem höchsten Wahrscheinlichkeitswert identifiziert wird.
Legen Sie für die Analyse der JMESPath Merkmalsbedeutung `probability` den Ausdruck „[\$1] .probabilities“ fest, um deren Wahrscheinlichkeiten für alle vorhergesagten Labels zu extrahieren. Anschließend werden die Feature-Attributionen für alle Beschriftung berechnet.
# Prüfen Sie die Endpunktanfrage und -antwort vorab auf tabellarische Daten
Wir empfehlen Ihnen, Ihr Modell auf einem SageMaker KI-Echtzeit-Inferenzendpunkt bereitzustellen und Anfragen an den Endpunkt zu senden. Untersuchen Sie die Anfragen und Antworten manuell, um sicherzustellen, dass beide den Anforderungen in dem [Endpunktanforderungen für Tabellendaten](clarify-processing-job-data-format-tabular-request.md) Abschnitt und dem [Endpunktreaktion für tabellarische Daten](clarify-processing-job-data-format-tabular-response.md) Abschnitt entsprechen. Wenn Ihr Modellcontainer Batch-Anfragen unterstützt, können Sie mit einer einzelnen Datensatzanforderung beginnen und dann zwei oder mehr Datensätze ausprobieren.
Die folgenden Befehle veranschaulichen das Anfordern einer Antwort mit AWS CLI. Das AWS CLI ist in SageMaker Studio- und SageMaker Notebook-Instanzen vorinstalliert. Folgen Sie dieser [Installationsanleitung AWS CLI](https://aws.amazon.com/cli/), um das zu installieren.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name $ENDPOINT_NAME \
--content-type $CONTENT_TYPE \
--accept $ACCEPT_TYPE \
--body $REQUEST_DATA \
$CLI_BINARY_FORMAT \
/dev/stderr 1>/dev/null
```
Die Parameter werden wie folgt beschrieben:
+ `$ENDPOINT NAME` – Der Name des Endpunkts.
+ `$CONTENT_TYPE` – Der MIME-Typ der Anfrage (Eingabe des Modellcontainers).
+ `$ACCEPT_TYPE` – Der MIME-Typ der Antwort (Modellcontainer-Ausgabe).
+ `$REQUEST_DATA` – Die angeforderte Payload-Zeichenfolge.
+ `$CLI_BINARY_FORMAT` – Das Format des Befehlszeilenschnittstellen-Parameters (Command Line Interface, CLI). Für AWS CLI Version 1 sollte dieser Parameter leer bleiben. Für v2 sollte dieser Parameter auf `--cli-binary-format raw-in-base64-out` gesetzt werden.
**Anmerkung**
AWS CLI [v2 übergibt Binärparameter standardmäßig als Base64-kodierte Zeichenketten.](https://docs.aws.amazon.com/cli/latest/userguide/cliv2-migration.html#cliv2-migration-binaryparam)
# AWS CLI v1-Beispiele
Das Beispiel im vorherigen Abschnitt war für AWS CLI v2. In den folgenden Anforderungs- und Antwortbeispielen zum und vom Endpunkt wird AWS CLI v1 verwendet.
## Anfrage und Antwort am Endpunkt im CSV-Format
Im folgenden Codebeispiel besteht die Anfrage aus einem einzigen Datensatz und die Antwort ist deren Wahrscheinlichkeitswert.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-sagemaker-xgboost-model \
--content-type text/csv \
--accept text/csv \
--body '1,2,3,4' \
/dev/stderr 1>/dev/null
```
Aus dem vorherigen Codebeispiel folgt die Antwortausgabe.
```
0.6
```
Im folgenden Codebeispiel besteht die Anforderung aus zwei Datensätzen, und die Antwort umfasst deren Wahrscheinlichkeiten, die durch ein Komma getrennt sind.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-sagemaker-xgboost-model \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Der `$'content'` Ausdruck im vorherigen Codebeispiel `--body` weist den Befehl an, den Inhalt als Zeilenumbruch zu interpretieren `'\n'`. Es folgt die Antwortausgabe.
```
0.6,0.3
```
Im folgenden Codebeispiel besteht die Anfrage aus zwei Datensätzen. Die Antwort beinhaltet deren Wahrscheinlichkeiten, getrennt durch einen Zeilenumbruch.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-1 \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Aus dem vorherigen Codebeispiel folgt die Antwortausgabe.
```
0.6
0.3
```
Im folgenden Codebeispiel besteht die Anforderung aus einem einzigen Datensatz, und die Antwort besteht aus Wahrscheinlichkeitswerten aus einem Mehrklassenmodell, das drei Klassen enthält.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-1 \
--content-type text/csv \
--accept text/csv \
--body '1,2,3,4' \
/dev/stderr 1>/dev/null
```
Aus dem vorherigen Codebeispiel folgt die Antwortausgabe.
```
0.1,0.6,0.3
```
Im folgenden Codebeispiel besteht die Anforderung aus zwei Datensätzen, und die Antwort enthält deren Wahrscheinlichkeitswerte aus einem Mehrklassenmodell, das drei Klassen enthält.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-1 \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Aus dem vorherigen Codebeispiel folgt die Antwortausgabe.
```
0.1,0.6,0.3
0.2,0.5,0.3
```
Im folgenden Codebeispiel besteht die Anfrage aus zwei Datensätzen, und die Antwort umfasst die vorhergesagte Beschriftung und die Wahrscheinlichkeit.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-2 \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Aus dem vorherigen Codebeispiel folgt die Antwortausgabe.
```
1,0.6
0,0.3
```
Im folgenden Codebeispiel besteht die Anforderung aus zwei Datensätzen und die Antwort enthält Beschriftung -Header und Wahrscheinlichkeiten.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-3 \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Aus dem vorherigen Codebeispiel folgt die Antwortausgabe.
```
"['cat','dog','fish']","[0.1,0.6,0.3]"
"['cat','dog','fish']","[0.2,0.5,0.3]"
```
## Endpunktanforderung und -antwort im JSON-Lines-Format
Im folgenden Codebeispiel besteht die Anfrage aus einem einzigen Datensatz und die Antwort ist deren Wahrscheinlichkeitswert.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-jsonlines \
--content-type application/jsonlines \
--accept application/jsonlines \
--body '{"features":["This is a good product",5]}' \
/dev/stderr 1>/dev/null
```
Aus dem vorherigen Codebeispiel folgt die Antwortausgabe.
```
{"score":0.6}
```
Im folgenden Codebeispiel enthält die Anfrage zwei Datensätze, und die Antwort umfasst die vorhergesagte Beschriftung und die Wahrscheinlichkeit.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-jsonlines-2 \
--content-type application/jsonlines \
--accept application/jsonlines \
--body $'{"features":[1,2,3,4]}\n{"features":[5,6,7,8]}' \
/dev/stderr 1>/dev/null
```
Aus dem vorherigen Codebeispiel folgt die Antwortausgabe.
```
{"predicted_label":1,"probability":0.6}
{"predicted_label":0,"probability":0.3}
```
Im folgenden Codebeispiel enthält die Anforderung zwei Datensätze, und die Antwort enthält Beschriftung-Header und Wahrscheinlichkeiten.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-jsonlines-3 \
--content-type application/jsonlines \
--accept application/jsonlines \
--body $'{"data":{"features":[1,2,3,4]}}\n{"data":{"features":[5,6,7,8]}}' \
/dev/stderr 1>/dev/null
```
Aus dem vorherigen Codebeispiel folgt die Antwortausgabe.
```
{"predicted_labels":["cat","dog","fish"],"probabilities":[0.1,0.6,0.3]}
{"predicted_labels":["cat","dog","fish"],"probabilities":[0.2,0.5,0.3]}
```
## Endpunktanforderung und -antwort in gemischten Formaten
Im folgenden Codebeispiel ist die Anfrage im CSV-Format und die Antwort im Format JSON Lines.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-in-jsonlines-out \
--content-type text/csv \
--accept application/jsonlines \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Aus dem vorherigen Codebeispiel folgt die Antwortausgabe.
```
{"probability":0.6}
{"probability":0.3}
```
Im folgenden Codebeispiel ist die Anfrage im Format JSON Lines und die Antwort im CSV-Format.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-jsonlines-in-csv-out \
--content-type application/jsonlines \
--accept text/csv \
--body $'{"features":[1,2,3,4]}\n{"features":[5,6,7,8]}' \
/dev/stderr 1>/dev/null
```
Aus dem vorherigen Codebeispiel folgt die Antwortausgabe.
```
0.6
0.3
```
Im folgenden Codebeispiel ist die Anfrage im CSV-Format und die Antwort im JSON-Format.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-in-jsonlines-out \
--content-type text/csv \
--accept application/jsonlines \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
Aus dem vorherigen Codebeispiel folgt die Antwortausgabe.
```
{"predictions":[{"label":1,"score":0.6},{"label":0,"score":0.3}]}
```
# Anforderungen an die Image-Tags
Ein SageMaker Clarif-Verarbeitungsjob bietet Unterstützung bei der Erklärung von Bildern. In diesem Thema werden die Anforderungen an das Datenformat für Bilddaten beschrieben. Informationen zur Verarbeitung der Image-Daten finden Sie unter [Analysieren Sie Bilddaten auf ihre Erklärbarkeit durch Computer Vision](clarify-processing-job-run.md#clarify-processing-job-run-cv).
Ein Bilddatensatz enthält eine oder mehrere Bilddateien. Um einen Eingabedatensatz für den SageMaker Clarif-Verarbeitungsjob zu identifizieren, setzen Sie entweder einen [ProcessingInput](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateProcessingJob.html#sagemaker-CreateProcessingJob-request-ProcessingInputs)benannten Parameter `dataset` oder den `dataset_uri` Analyse-Konfigurationsparameter auf ein Amazon S3 S3-URI-Präfix Ihrer Bilddateien.
Die unterstützten Bilddateiformate und Dateierweiterungen sind in der folgenden Tabelle aufgeführt.
| Bildformat | Dateierweiterung |
| --- | --- |
| JPEG | JPG, JPEG |
| PNG | PNG |
Setzen Sie den `dataset_type` Konfigurationsparameter für die Analyse auf **application/x-image**. Da es sich bei dem Typ nicht um ein bestimmtes Bilddateiformat handelt, `content_type` wird er verwendet, um das Bilddateiformat und die Erweiterung zu bestimmen.
Der SageMaker Clarify-Verarbeitungsauftrag lädt jede Bilddatei zur weiteren Verarbeitung in ein dreidimensionales [NumPyArray](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html). Die drei Dimensionen umfassen Höhe, Breite und RGB-Werte jedes Pixels.
## Endpunktanforderungsformat
Der SageMaker Clarif-Verarbeitungsauftrag konvertiert die RGB-Rohdaten eines Bilds in ein kompatibles Bildformat, z. B. JPEG. Dies geschieht, bevor die Daten zur Vorhersage an den Endpunkt gesendet werden. Die unterstützten Bildformate lauten wie folgt.
| Datenformat | MIME-Typ | Dateierweiterung |
| --- | --- | --- |
| JPEG | `image/jpeg` | JPG, JPEG |
| PNG | `image/png` | PNG |
| NPY | `application/x-npy` | All above |
Geben Sie das Datenformat der Anforderungs-Payload mithilfe des Analyse-Konfigurationsparameters `content_type` an. Wenn `content_type` nicht angegeben wird, ist das Datenformat standardmäßig auf `image/jpeg` eingestellt.
## Antwortformat des Endpunkts
Nach Erhalt der Antwort auf einen Aufruf eines Inferenzendpunkts deserialisiert der SageMaker Clarify-Verarbeitungsauftrag die Antwortnutzdaten und extrahiert dann die Vorhersagen daraus.
### Problem mit der Bildklassifizierung
Das Datenformat der Antwortnutzlast sollte durch den Analysekonfigurationsparameter accept\$1type angegeben werden. Wenn `accept_type` nicht angegeben, ist das Datenformat standardmäßig `application/json`. Die unterstützten Formate entsprechen denen, die in der **Endpunktantwort für Tabellendaten** im Abschnitt Tabellendaten beschrieben sind.
Hier finden Sie ein Beispiel [Inferenz mit dem Bildklassifizierungsalgorithmus](image-classification.md#IC-inference) für einen in SageMaker KI integrierten Algorithmus zur Bildklassifizierung, der ein einzelnes Bild akzeptiert und dann eine Reihe von Wahrscheinlichkeitswerten (Scores) zurückgibt, jeweils für eine Klasse.
Wie in der folgenden Tabelle dargestellt, handelt es sich bei der Antwort um ein JSON-Objekt, wenn der `content_type` Parameter auf `application/jsonlines` gesetzt ist.
| Nutzlast der Endpunktanforderung | Nutzlast der Endpunktantwort (Zeichenkettendarstellung) |
| --- | --- |
| Einzelnes Bild | '\$1"Vorhersage“: [0.1,0.6,0.3]\$1' |
Stellen Sie im vorherigen Beispiel den `probability` Parameter auf den JMESPath Ausdruck „Prediction“ ein, um die Ergebnisse zu extrahieren.
Wenn der `content_type` auf `application/json` gesetzt ist, handelt es sich bei der Antwort um ein JSON-Objekt, wie in der folgenden Tabelle dargestellt.
| Nutzlast der Endpunktanforderung | Nutzlast der Endpunktantwort (Zeichenkettendarstellung) |
| --- | --- |
| Einzelnes Bild | '[0.1,0.6,0.3]' |
Stellen Sie im vorherigen Beispiel `probability` den JMESPath Ausdruck „[\$1]“ ein, um alle Elemente des Arrays zu extrahieren. Im vorherigen Beispiel [`0.1, 0.6, 0.3]` wird extrahiert. Wenn Sie alternativ die Einstellung des `probability` Konfigurationsparameters überspringen, werden auch alle Elemente des Arrays extrahiert. Das liegt daran, dass die gesamte Nutzlast wie bei den Vorhersagen deserialisiert wird.
### Problem bei der Objekterkennung
Die Standardkonfiguration `accept_type` für die Analyse ist `application/json` und das einzige unterstützte Format ist das Object Detection Inference Format. Informationen über Antwortformate finden Sie unter [Antwortformate](object-detection-in-formats.md#object-detection-recordio).
Die folgende Tabelle ist eine Beispielantwort von einem Endpunkts, der ein Array ausgibt. Jedes Element des Arrays ist ein Array von Werten, das den Klassenindex, den Konfidenzwert und die Bounding-Box-Koordinaten des erkannten Objekts enthält.
| Nutzlast der Endpunktanforderung | Nutzlast der Endpunktantwort (Zeichenkettendarstellung) |
| --- | --- |
| Einzelbild (ein Objekt) | '[4.0, 0.86419455409049988, 0.3088374733924866, 0,07030484080314636, 0.7110607028007507, 0.9345266819000244]]' |
| Einzelbild (zwei Objekte) | '[4,0, 0,86419455409049988, 0,3088374733924866, 0,07030484080314636, 0,7110607028007507, 0,9345266819000244], [0,0, 0,73376623392105103, 0,5714187026023865, 0,40427327156066895, 0,827027023865 75183391571, 0,9712159633636475]]' |
Die folgende Tabelle ist ein Beispiel für eine Antwort von einem Endpunkt, die ein JSON-Objekt mit einem Schlüssel ausgibt, der auf das Array verweist. Stellen Sie die Analysekonfiguration `probability` auf den Schlüssel „Prognose“ ein, um die Werte zu extrahieren.
| Nutzlast der Endpunktanforderung | Nutzlast der Endpunktantwort (Zeichenkettendarstellung) |
| --- | --- |
| Einzelbild (ein Objekt) | '\$1"Vorhersage“: [[4.0, 0.86419455409049988, 0.3088374733924866, 0,07030484080314636, 0.7110607028007507, 0.9345266819000244]]\$1' |
| Einzelbild (zwei Objekte) | '\$1"Prognose“: [4,0, 0,86419455409049988, 0,3088374733924866, 0,07030484080314636, 0,7110607028007507, 0,9345266819000244], [0,0, 0,73376623392105103, 0,5714187026023865, 0,4042732715606686895, 0,827075183391571, 0,9712159633636475]]\$1' |
## Überprüfen Sie die Endpunktanfrage und -antwort für Bilddaten vorab
Wir empfehlen Ihnen, Ihr Modell auf einem SageMaker KI-Echtzeit-Inferenzendpunkt bereitzustellen und Anfragen an den Endpunkt zu senden. Untersuchen Sie die Anfragen und Antworten manuell. Stellen Sie sicher, dass beide den Anforderungen im Abschnitt **Endpunktanforderung für Bilddaten** und **Endpunktantwort für Bilddaten** entsprechen.
Im Folgenden finden Sie zwei Codebeispiele, die zeigen, wie Anfragen gesendet und die Antworten auf Probleme mit der Bildklassifizierung und Objekterkennung untersucht werden.
### Problem mit der Bildklassifizierung
Der folgende Beispielcode weist einen Endpunkt an, eine PNG-Datei zu lesen, und klassifiziert sie dann.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-sagemaker-image-classification \
--content-type "image/png" \
--accept "application/json" \
--body fileb://./test.png \
/dev/stderr 1>/dev/null
```
Aus dem vorherigen Codebeispiel folgt die Antwortausgabe.
```
[0.1,0.6,0.3]
```
### Problem bei der Objekterkennung
Der folgende Beispielcode weist einen Endpunkt an, eine JPEG-Datei zu lesen, und erkennt dann die darin enthaltenen Objekte.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-sagemaker-object-detection \
--content-type "image/jpg" \
--accept "application/json" \
--body fileb://./test.jpg \
/dev/stderr 1>/dev/null
```
Aus dem vorherigen Codebeispiel folgt die Antwortausgabe.
```
{"prediction":[[4.0, 0.86419455409049988, 0.3088374733924866, 0.07030484080314636, 0.7110607028007507, 0.9345266819000244],[0.0, 0.73376623392105103, 0.5714187026023865, 0.40427327156066895, 0.827075183391571, 0.9712159633636475],[4.0, 0.32643985450267792, 0.3677481412887573, 0.034883320331573486, 0.6318609714508057, 0.5967587828636169],[8.0, 0.22552496790885925, 0.6152569651603699, 0.5722782611846924, 0.882301390171051, 0.8985623121261597],[3.0, 0.42260299175977707, 0.019305512309074402, 0.08386176824569702, 0.39093565940856934, 0.9574796557426453]]}
```
# Zeitreihendaten
Zeitreihendaten beziehen sich auf Daten, die in einen dreidimensionalen Datenrahmen geladen werden können. In diesem Frame repräsentiert jede Zeile in jedem Zeitstempel einen Zieldatensatz, und jeder Zieldatensatz verfügt über eine oder mehrere zugehörige Spalten. Bei den Werten in jeder Zelle des Datenrahmens kann es sich um numerische, kategoriale oder Textdatentypen handeln.
## Voraussetzungen für einen Zeitreihendatensatz
Führen Sie vor der Analyse die erforderlichen Vorverarbeitungsschritte zur Vorbereitung Ihrer Daten durch, z. B. Datenbereinigung oder Feature-Engineering. Sie können einen oder mehrere Datensätze bereitstellen. Wenn Sie mehrere Datensätze bereitstellen, verwenden Sie eine der folgenden Methoden, um sie für den Verarbeitungsauftrag SageMaker Clarify bereitzustellen:
+ Verwenden Sie entweder eine [ProcessingInput](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProcessingInput.html)benannte Konfiguration `dataset` oder die Analysekonfiguration`dataset_uri`, um den Hauptdatensatz anzugeben. Weitere Informationen über `dataset_uri` finden Sie in der Parameterliste unter [Analyse-Konfigurationsdateien](clarify-processing-job-configure-analysis.md).
+ Verwenden Sie den in der Analysekonfigurationsdatei bereitgestellten `baseline` Parameter. Der Basisdatensatz ist erforderlich für`static_covariates`, falls vorhanden. Weitere Informationen zur Analysekonfigurationsdatei, einschließlich Beispielen, finden Sie unter [Analyse-Konfigurationsdateien](clarify-processing-job-configure-analysis.md).
In der folgenden Tabelle sind die unterstützten Datenformate, ihre Dateierweiterungen und MIME-Typen aufgeführt.
| Data format (Datenformat) | Dateierweiterung | MIME-Typ |
| --- | --- | --- |
| `item_records` | json | `application/json` |
| `timestamp_records` | json | `application/json` |
| `columns` | json | `application/json` |
JSON ist ein flexibles Format, das jede Komplexität Ihrer strukturierten Daten darstellen kann. Wie in der Tabelle gezeigt, unterstützt SageMaker Clarify die Formate `item_records``timestamp_records`, und`columns`.
## Beispiele für die Konfiguration von Zeitreihen-Datensätzen
In diesem Abschnitt wird erläutert, wie Sie eine Analysekonfiguration mit `time_series_data_config` für Zeitreihendaten im JSON-Format festlegen. Angenommen, Sie haben einen Datensatz mit zwei Elementen, jedes mit einem Zeitstempel (t), einer Zielzeitreihe (x), zwei verwandten Zeitreihen (r) und zwei statischen Kovariaten (u) wie folgt:
t 1 = [0,1,2], t 2 = [2,3]
x 1 = [5,6,4], x 2 = [0,4]
r 1 = [0,1,0], r 2 1 = [1,1]
r 1 2 = [0,0,0], r 2 2 = [1,0]
u 1 1 = -1, u 2 1 = 0
u 1 2 = 1, u 2 2 = 2
Sie können den Datensatz auf drei verschiedene Arten kodieren, abhängig `dataset_format` von. `time_series_data_config` In den folgenden Abschnitten werden beide Methoden beschrieben.
### Konfiguration von Zeitreihendaten, wann `dataset_format` ist `columns`
Im folgenden Beispiel werden die `columns`-Werte für `dataset_format` genutzt. Die folgende JSON-Datei stellt den vorherigen Datensatz dar.
```
{
"ids": [1, 1, 1, 2, 2],
"timestamps": [0, 1, 2, 2, 3], # t
"target_ts": [5, 6, 4, 0, 4], # x
"rts1": [0, 1, 0, 1, 1], # r1
"rts2": [0, 0, 0, 1, 0], # r2
"scv1": [-1, -1, -1, 0, 0], # u1
"scv2": [1, 1, 1, 2, 2], # u2
}
```
Beachten Sie, dass die Element-IDs im `ids` Feld wiederholt werden. Die korrekte Implementierung von `time_series_data_config` wird wie folgt dargestellt:
```
"time_series_data_config": {
"item_id": "ids",
"timestamp": "timestamps",
"target_time_series": "target_ts",
"related_time_series": ["rts1", "rts2"],
"static_covariates": ["scv1", "scv2"],
"dataset_format": "columns"
}
```
### Konfiguration von Zeitreihendaten, wann `dataset_format` ist `item_records`
Im folgenden Beispiel werden die `item_records`-Werte für `dataset_format` genutzt. Die folgende JSON-Datei stellt den Datensatz dar.
```
[
{
"id": 1,
"scv1": -1,
"scv2": 1,
"timeseries": [
{"timestamp": 0, "target_ts": 5, "rts1": 0, "rts2": 0},
{"timestamp": 1, "target_ts": 6, "rts1": 1, "rts2": 0},
{"timestamp": 2, "target_ts": 4, "rts1": 0, "rts2": 0}
]
},
{
"id": 2,
"scv1": 0,
"scv2": 2,
"timeseries": [
{"timestamp": 2, "target_ts": 0, "rts1": 1, "rts2": 1},
{"timestamp": 3, "target_ts": 4, "rts1": 1, "rts2": 0}
]
}
]
```
Jedes Element wird als separater Eintrag in der JSON-Datei dargestellt. Der folgende Ausschnitt zeigt die entsprechenden `time_series_data_config` (welche). JMESPath
```
"time_series_data_config": {
"item_id": "[*].id",
"timestamp": "[*].timeseries[].timestamp",
"target_time_series": "[*].timeseries[].target_ts",
"related_time_series": ["[*].timeseries[].rts1", "[*].timeseries[].rts2"],
"static_covariates": ["[*].scv1", "[*].scv2"],
"dataset_format": "item_records"
}
```
### Konfiguration von Zeitreihendaten, wann `dataset_format` ist `timestamp_record`
Im folgenden Beispiel werden die `timestamp_record`-Werte für `dataset_format` genutzt. Die folgende JSON-Datei stellt den vorherigen Datensatz dar.
```
[
{"id": 1, "timestamp": 0, "target_ts": 5, "rts1": 0, "rts2": 0, "svc1": -1, "svc2": 1},
{"id": 1, "timestamp": 1, "target_ts": 6, "rts1": 1, "rts2": 0, "svc1": -1, "svc2": 1},
{"id": 1, "timestamp": 2, "target_ts": 4, "rts1": 0, "rts2": 0, "svc1": -1, "svc2": 1},
{"id": 2, "timestamp": 2, "target_ts": 0, "rts1": 1, "rts2": 1, "svc1": 0, "svc2": 2},
{"id": 2, "timestamp": 3, "target_ts": 4, "rts1": 1, "rts2": 0, "svc1": 0, "svc2": 2},
]
```
Jeder JSON-Eintrag steht für einen einzelnen Zeitstempel und entspricht einem einzelnen Element. Die Implementierung `time_series_data_config` wird wie folgt dargestellt:
```
{
"item_id": "[*].id",
"timestamp": "[*].timestamp",
"target_time_series": "[*].target_ts",
"related_time_series": ["[*].rts1"],
"static_covariates": ["[*].scv1"],
"dataset_format": "timestamp_records"
}
```
# Endpunktreaktionen für Zeitreihendaten
Ein SageMaker Clarif-Verarbeitungsjob serialisiert Daten in beliebige JSON-Strukturen (mit MIME-Typ:). `application/json` Dazu müssen Sie eine Vorlagenzeichenfolge für den `content_template` Analyse-Konfigurationsparameter angeben. Dies wird vom SageMaker Clarif-Verarbeitungsjob verwendet, um die für Ihr Modell bereitgestellte JSON-Abfrage zu erstellen. `content_template`enthält einen Datensatz oder mehrere Datensätze aus Ihrem Datensatz. Sie müssen auch eine Vorlagenzeichenfolge für `record_template` angeben, die verwendet wird, um die JSON-Struktur für jeden Datensatz zu erstellen. Diese Datensätze werden dann in eingefügt`content_template`. Weitere Informationen über `content_type` oder `dataset_type` finden Sie unter [Analyse-Konfigurationsdateien](clarify-processing-job-configure-analysis.md).
**Anmerkung**
Da es sich bei `content_template` und `record_template` um Zeichenfolgenparameter handelt, sollten alle doppelten Anführungszeichen ("), die Teil der serialisierten JSON-Struktur sind, in Ihrer Konfiguration als Escape-Zeichen vermerkt werden. Wenn Sie beispielsweise ein doppeltes Anführungszeichen in Python umgehen möchten, könnten Sie den folgenden Wert für `content_template` eingeben.
```
'$record'
```
Die folgende Tabelle zeigt Beispiele für serialisierte JSON-Anforderungs-Payloads und die entsprechenden `content_template`- und `record_template`-Parameter, die zu ihrer Erstellung erforderlich sind.
| Anwendungsfall | Nutzlast für Endpunktanfragen (Zeichenkettendarstellung) | content\$1template | Datensatzvorlage |
| --- | --- | --- | --- |
| Einzelner Datensatz gleichzeitig | `{"target": [1, 2, 3],"start": "2024-01-01 01:00:00"}` | `'$record'` | `'{"start": $start_time, "target": $target_time_series}'` |
| Einzelner Datensatz mit `$related_time_series` und `$static_covariates` | `{"target": [1, 2, 3],"start": "2024-01-01 01:00:00","dynamic_feat": [[1.0, 2.0, 3.0],[1.0, 2.0, 3.0],"cat": [0,1]}` | `'$record'` | `'{"start": $start_time, "target": $target_time_series, "dynamic_feat": $related_time_series, "cat": $static_covariates}'` |
| Multi-records | `{"instances": [{"target": [1, 2, 3],"start": "2024-01-01 01:00:00"}, {"target": [1, 2, 3],"start": "2024-01-01 02:00:00"}]}` | `'{"instances": $records}'` | `'{"start": $start_time, "target": $target_time_series}'` |
| Mehrere Datensätze mit und `$related_time_series` `$static_covariates` | `{"instances": [{"target": [1, 2, 3],"start": "2024-01-01 01:00:00","dynamic_feat": [[1.0, 2.0, 3.0],[1.0, 2.0, 3.0],"cat": [0,1]}, {"target": [1, 2, 3],"start": "2024-01-01 02:00:00","dynamic_feat": [[1.0, 2.0, 3.0],[1.0, 2.0, 3.0],"cat": [0,1]}]}` | `'{"instances": $records}'` | `''{"start": $start_time, "target": $target_time_series, "dynamic_feat": $related_time_series, "cat": $static_covariates}'` |
# Endpunktreaktion für Zeitreihendaten
Der Verarbeitungsjob SageMaker Clarify deserialisiert die gesamte Nutzlast als JSON. Anschließend werden mithilfe von JMESPath Ausdrücken, die in der Analysekonfiguration bereitgestellt werden, Vorhersagen aus den deserialisierten Daten extrahiert. Die Datensätze in der Antwortnutzlast müssen mit den Datensätzen in der Anforderungsnutzlast übereinstimmen.
Die folgende Tabelle zeigt ein Beispiel für eine Antwort von einem Endpunkt, der nur den mittleren Vorhersagewert ausgibt. Der in dem `predictor` Feld in der [Analysekonfiguration `forecast`](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-processing-job-configure-analysis.html#clarify-processing-job-configure-analysis-parameters) verwendete Wert sollte als JMESPath Ausdruck angegeben werden, um das Prognoseergebnis für den Verarbeitungsjob zu ermitteln.
| Nutzlast der Endpunktanforderung | Nutzlast der Endpunktantwort (Zeichenkettendarstellung) | JMESPath Ausdruck für die Prognose in der Analysekonfiguration |
| --- | --- | --- |
| Beispiel für einen Datensatz. Die Config sollte so sein`TimeSeriesModelConfig(forecast="prediction.mean")`, dass die Vorhersage korrekt extrahiert wird. | `'{"prediction": {"mean": [1, 2, 3, 4, 5]}'` | `'prediction.mean'` |
| Mehrere Datensätze. Eine AWS DeepAR-Endpunktantwort. | `'{"predictions": [{"mean": [1, 2, 3, 4, 5]}, {"mean": [1, 2, 3, 4, 5]}]}'` | `'predictions[*].mean'` |
# Überprüfen der Endpunktanfrage und -antwort für Zeitreihendaten vorab
Es wird empfohlen, Ihr Modell auf einem SageMaker KI-Echtzeit-Inferenzendpunkt bereitzustellen und Anfragen an den Endpunkt zu senden. Untersuchen Sie die Anfragen und Antworten manuell, um sicherzustellen, dass beide den Anforderungen in den Abschnitten [Endpunktreaktionen für Zeitreihendaten](clarify-processing-job-data-format-time-series-request-jsonlines.md) und [Endpunktreaktion für Zeitreihendaten](clarify-processing-job-data-format-time-series-response-json.md) entsprechen. Wenn Ihr Modellcontainer Batch-Anfragen unterstützt, können Sie mit einer einzelnen Datensatzanforderung beginnen und dann zwei oder mehr Datensätze ausprobieren.
Die folgenden Befehle zeigen das Anfordern einer Antwort mit AWS CLI. Das AWS CLI ist in Studio- und SageMaker Notebook-Instanzen vorinstalliert. Folgen Sie der [Installationsanleitung AWS CLI](https://aws.amazon.com//cli/), um das zu installieren.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name $ENDPOINT_NAME \
--content-type $CONTENT_TYPE \
--accept $ACCEPT_TYPE \
--body $REQUEST_DATA \
$CLI_BINARY_FORMAT \
/dev/stderr 1>/dev/null
```
Die Parameter sind wie folgt definiert:
+ \$1ENDPOINT NAME – Der Name des Endpunkts.
+ \$1CONTENT\$1TYPE: Der MIME-Typ der Anfrage (Eingabe des Modellcontainers).
+ \$1ACCEPT\$1TYPE: Der MIME-Typ der Antwort (Ausgabe des Modellcontainers).
+ \$1REQUEST\$1DATA – Die angeforderte Payload-Zeichenfolge.
+ \$1CLI\$1BINARY\$1FORMAT: Das Format des Befehlszeilenschnittstellen-Parameters (CLI). Für AWS CLI Version 1 sollte dieser Parameter leer bleiben. Für v2 sollte dieser Parameter auf `--cli-binary-format raw-in-base64-out` gesetzt werden.
**Anmerkung**
AWS CLI v2 übergibt Binärparameter standardmäßig als Base64-kodierte Zeichenketten. Die folgenden Beispiele für Anfragen und Antworten zum und vom Endpunkt verwenden v1. AWS CLI
------
#### [ Example 1 ]
Im folgenden Codebeispiel besteht die Anfrage aus einem einzigen Datensatz.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-json \
--content-type application/json \
--accept application/json \
--body '{"target": [1, 2, 3, 4, 5],
"start": "2024-01-01 01:00:00"}' \
/dev/stderr 1>/dev/null
```
Der folgende Ausschnitt zeigt die entsprechende Antwortausgabe.
```
{'predictions': {'mean': [1, 2, 3, 4, 5]}
```
------
#### [ Example 2 ]
Im folgenden Codebeispiel enthält die Anforderung zwei Datensätze.
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-json-2 \
--content-type application/json \
--accept application/json \
--body $'{"instances": [{"target":[1, 2, 3],
"start":"2024-01-01 01:00:00",
"dynamic_feat":[[1, 2, 3, 4, 5],
[1, 2, 3, 4, 5]]}], {"target":[1, 2, 3],
"start":"2024-01-02 01:00:00",
"dynamic_feat":[[1, 2, 3, 4, 5],
[1, 2, 3, 4, 5]]}]}' \
dev/stderr 1>/dev/null
```
Die Antwortausgabe lautet wie folgt:
```
{'predictions': [{'mean': [1, 2, 3, 4, 5]}, {'mean': [1, 2, 3, 4, 5]}]}
```
------
# Führen Sie SageMaker Clarify Processing Jobs aus, um Verzerrungen zu analysieren und zu erklären
Um Ihre Daten und Modelle mit SageMaker Clarify auf Verzerrungen und Erklärbarkeit zu analysieren, müssen Sie einen SageMaker Clarif-Verarbeitungsjob konfigurieren. Diese Anleitung zeigt, wie Sie die Jobeingaben, -ausgaben, -ressourcen und die Analysekonfiguration mithilfe der SageMaker Python SDK-API konfigurieren`SageMakerClarifyProcessor`.
Die API fungiert als High-Level-Wrapper der SageMaker `CreateProcessingJob` KI-API. Sie verbirgt viele Details, die bei der Einrichtung eines Clarif-Verarbeitungsauftrags eine Rolle SageMaker spielen. Zu den Details zum Einrichten eines Jobs gehören das Abrufen des SageMaker Clarifesty-Container-Image-URI und das Generieren der Analysekonfigurationsdatei. Die folgenden Schritte zeigen Ihnen, wie Sie einen SageMaker Clarif-Verarbeitungsauftrag konfigurieren, initialisieren und starten.
**Konfigurieren Sie einen SageMaker Clarif-Verarbeitungsauftrag mithilfe der API**
1. Definieren Sie die Konfigurationsobjekte für jeden Teil der Jobkonfiguration. Diese Teile können Folgendes umfassen:
+ Der Eingabedatensatz und der Ausgabeort: [DataConfig](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html#sagemaker.clarify.DataConfig).
+ Das zu analysierende Modell oder der zu analysierende Endpunkt: [ModelConfig](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html#sagemaker.clarify.ModelConfig).
+ Parameter der Bias-Analyse: [BiasConfig](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html#sagemaker.clarify.BiasConfig).
+ SHapley Additive Erläuterungen (SHAP) Analyseparameter: [SHAPConfig](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html#sagemaker.clarify.SHAPConfig).
+ Analyseparameter für asymmetrische Shapley-Werte (nur für Zeitreihen):. [AsymmetricShapleyValueConfig](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html#sagemaker.clarify.AsymmetricShapleyValueConfig)
Die Konfigurationsobjekte für einen SageMaker Clarif-Verarbeitungsauftrag variieren je nach Art von Datenformaten und Anwendungsfällen. In den folgenden Abschnitten finden Sie Konfigurationsbeispiele für tabellarische Daten im Format [CSV](#clarify-processing-job-run-tabular-csv) und [JSON Lines](#clarify-processing-job-run-tabular-jsonlines), Probleme mit natürlicher Sprachverarbeitung ([NLP](#clarify-processing-job-run-tabular-nlp)), [computer vision](#clarify-processing-job-run-cv) (CV) und Zeitreihen (TS).
1. Erstellen Sie ein `SageMakerClarifyProcessor` Objekt und initialisieren Sie es mit Parametern, die die Auftragsressourcen angeben. Zu diesen Ressourcen gehören Parameter wie die Anzahl der zu verwendenden Rechen-Instances.
Das folgende Codebeispiel zeigt, wie Sie ein `SageMakerClarifyProcessor` Objekt erstellen und es anweisen, eine `ml.c4.xlarge` Recheninstance für die Analyse zu verwenden.
```
from sagemaker import clarify
clarify_processor = clarify.SageMakerClarifyProcessor(
role=role,
instance_count=1,
instance_type='ml.c4.xlarge',
sagemaker_session=session,
)
```
1. Rufen Sie die spezifische Ausführungsmethode des [SageMakerClarifyProcessor](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html#sagemaker.clarify.SageMakerClarifyProcessor.run)Objekts mit den Konfigurationsobjekten für Ihren Anwendungsfall auf, um den Job zu starten. Zu diesen Laufmethoden gehören die folgenden:
+ `run_pre_training_bias`
+ `run_post_training_bias`
+ `run_bias`
+ `run_explainability`
+ `run_bias_and_explainability`
Diese `SageMakerClarifyProcessor` erledigt mehrere Aufgaben im Hintergrund. Zu diesen Aufgaben gehören das Abrufen des Universal Resource Identifier (URI) des SageMaker Claride-Container-Images, das Erstellen einer Analysekonfigurationsdatei auf der Grundlage der bereitgestellten Konfigurationsobjekte, das Hochladen der Datei in einen Amazon S3 S3-Bucket und [die Konfiguration des SageMaker Clarif-Verarbeitungsjobs](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-processing-job-configure-parameters.html).
In den folgenden erweiterbaren Abschnitten wird gezeigt, wie Verzerrungsmetriken, **SHAP Werte** und **partielle Abhängigkeitsdiagramme** (PDPs) in der **Vor-Training** und **Nach-Training bias Metriken** berechnet werden können. In den Abschnitten wird die Bedeutung von Funktionen für diese Datentypen veranschaulicht:
+ Tabellarische Datensätze im CSV-Format oder im Format JSON Lines
+ Datensätze zur Verarbeitung natürlicher Sprache (NLP)
+ Datensätze für maschinelles Sehen
Eine Anleitung zur parallel Ausführung von SageMaker Clarif-Verarbeitungsjobs mit verteiltem Training mithilfe von **Spark** folgt den erweiterbaren Abschnitten.
## Analysieren von Tabellendaten im CSV-Format
Die folgenden Beispiele zeigen, wie Sie die Verzerrungsanalyse und die Erklärbarkeitsanalyse für einen tabellarischen Datensatz im CSV-Format konfigurieren. In diesen Beispielen enthält der eingehende Datensatz vier Feature-Spalten und eine binäre Labelspalte, `Target`. Der Inhalt des Datensatzes ist wie folgt. Ein Labelwert von `1` weist auf ein positives Ergebnis hin.
```
Target,Age,Gender,Income,Occupation
0,25,0,2850,2
1,36,0,6585,0
1,22,1,1759,1
0,48,0,3446,1
...
```
Dieses `DataConfig` Objekt gibt den Eingabedatensatz und den Speicherort der Ausgabe an. Der `s3_data_input_path` Parameter kann entweder ein URI einer Datensatzdatei oder ein Amazon-S3-URI-Präfix sein. Wenn Sie ein S3-URI-Präfix angeben, sammelt der SageMaker Clarify-Verarbeitungsjob rekursiv alle Amazon S3 S3-Dateien, die sich unter dem Präfix befinden. Der Wert für `s3_output_path` sollte ein S3-URI-Präfix sein, das die Analyseergebnisse enthält. SageMaker AI verwendet das `s3_output_path` beim Kompilieren und kann keinen Wert eines SageMaker AI-Pipeline-Parameters, einer Eigenschaft, eines Ausdrucks oder`ExecutionVariable`, die zur Laufzeit verwendet werden, annehmen. Das folgende Beispiel veranschaulicht, wie Sie eine Datenkonfiguration für den vorherigen Beispiel-Eingabedatensatz angeben.
```
data_config = clarify.DataConfig(
s3_data_input_path=dataset_s3_uri,
dataset_type='text/csv',
headers=['Target', 'Age', 'Gender', 'Income', 'Occupation'],
label='Target',
s3_output_path=clarify_job_output_s3_uri,
)
```
### Wie berechnet man alle Verzerrungsmetriken vor dem Training für einen CSV-Datensatz
Das folgende Codebeispiel zeigt, wie ein `BiasConfig` Objekt so konfiguriert wird, dass die Verzerrung der vorherigen Stichprobeneingabe gegenüber Stichproben mit einem `Gender` Wert von `0` gemessen wird.
```
bias_config = clarify.BiasConfig(
label_values_or_threshold=[1],
facet_name='Gender',
facet_values_or_threshold=[0],
)
```
Das folgende Codebeispiel zeigt, wie eine Run-Anweisung verwendet wird, um einen SageMaker Clarif-Verarbeitungsjob zu starten, der alle [Verzerrungsmetriken vor dem Training](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-measure-data-bias.html) für einen Eingabedatensatz berechnet.
```
clarify_processor.run_pre_training_bias(
data_config=data_config,
data_bias_config=bias_config,
methods="all",
)
```
Alternativ können Sie auswählen, welche Metriken berechnet werden sollen, indem Sie dem Methodenparameter eine Liste von Bias-Metriken vor dem Training zuweisen. Wenn Sie beispielsweise durch `methods="all"` ersetzen, wird der Clarify-Prozessor `methods=["CI", "DPL"]` angewiesen, nur SageMaker das [Klassenungleichgewicht](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-bias-metric-class-imbalance.html) und den [Unterschied in den Proportionen](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-data-bias-metric-true-label-imbalance.html) von Labels zu berechnen.
### Wie berechnet man alle Messwerte für Verzerrungen nach dem Training für einen CSV-Datensatz
Sie können vor dem Training Messwerte für Verzerrungen vor dem Training berechnen. Um [Messwerte für Verzerrungen nach dem Training](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-measure-post-training-bias.html) berechnen zu können, benötigen Sie jedoch ein trainiertes Modell. Die folgende Beispielausgabe stammt aus einem binären Klassifikationsmodell, das Daten im CSV-Format ausgibt. In dieser Beispielausgabe enthält jede Zeile zwei Spalten. Die erste Spalte enthält die vorhergesagte Beschriftung und die zweite Spalte enthält den Wahrscheinlichkeitswert für diese Beschriftung.
```
0,0.028986845165491
1,0.825382471084594
...
```
In der folgenden Beispielkonfiguration weist das `ModelConfig` Objekt den Job an, das SageMaker KI-Modell auf einem kurzlebigen Endpunkt bereitzustellen. Der Endpunkt verwendet eine `ml.m4.xlarge` Inferenzinstance. Da der Parameter `content_type` und `accept_type` der Parameter nicht festgelegt sind, verwenden sie automatisch den Wert des Parameters`dataset_type`, d. h. `text/csv`
```
model_config = clarify.ModelConfig(
model_name=your_model,
instance_type='ml.m4.xlarge',
instance_count=1,
)
```
Im folgenden Konfigurationsbeispiel wird ein `ModelPredictedLabelConfig` Objekt mit dem Labelindex von `0` verwendet. Dadurch wird der Verarbeitungsauftrag SageMaker Clarify angewiesen, das vorhergesagte Label in der ersten Spalte der Modellausgabe zu finden. Der Verarbeitungsjauftrag verwendet in diesem Beispiel eine nullbasierte Indizierung.
```
predicted_label_config = clarify.ModelPredictedLabelConfig(
label=0,
)
```
In Kombination mit dem vorherigen Konfigurationsbeispiel startet das folgende Codebeispiel einen SageMaker Clarify-Verarbeitungsjob, um alle Messwerte für Verzerrungen nach dem Training zu berechnen.
```
clarify_processor.run_post_training_bias(
data_config=data_config,
data_bias_config=bias_config,
model_config=model_config,
model_predicted_label_config=predicted_label_config,
methods="all",
)
```
In ähnlicher Weise können Sie auswählen, welche Metriken berechnet werden sollen, indem Sie dem `methods` Parameter eine Liste von Messwerten für die Verzerrung nach dem Training zuweisen. Ersetzen Sie dies beispielsweise `methods=“all”` durch `methods=["DPPL", "DI"]`, um nur den [Unterschied zwischen positiven Proportionen bei vorhergesagten Kennzeichnungen](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-post-training-bias-metric-dppl.html) und [ungleichen Auswirkungen](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-post-training-bias-metric-di.html) zu berechnen.
### Wie berechnet man alle Messwerte für Verzerrungen für einen CSV-Datensatz
Das folgende Konfigurationsbeispiel zeigt, wie alle Messwerte für Verzerrungen vor und nach dem Training in einem SageMaker Clarif-Verarbeitungsjob ausgeführt werden.
```
clarify_processor.run_bias(
data_config=data_config,
bias_config=bias_config,
model_config=model_config,
model_predicted_label_config=predicted_label_config,
pre_training_methods="all",
post_training_methods="all",
)
```
Ein Beispiel-Notizbuch mit Anweisungen zur Ausführung eines SageMaker Clarif-Verarbeitungsjobs in SageMaker Studio Classic zur Erkennung von Verzerrungen finden Sie unter [Fairness and Explainability](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-clarify/fairness_and_explainability/fairness_and_explainability.ipynb) with Clarify. SageMaker
### Wie berechnet man SHAP Werte für einen CSV-Datensatz
SageMaker [Clarify stellt Funktionszuweisungen mithilfe des KernelShap-Algorithmus bereit.](https://arxiv.org/abs/1705.07874) SHAPDie Analyse erfordert den Wahrscheinlichkeitswert oder die Punktzahl anstelle der vorhergesagten Bezeichnung, sodass dieses `ModelPredictedLabelConfig` Objekt über einen Wahrscheinlichkeitsindex verfügt. `1` Dadurch wird der Verarbeitungsjob SageMaker Clarify angewiesen, den Wahrscheinlichkeitswert aus der zweiten Spalte der Modellausgabe zu extrahieren (unter Verwendung einer nullbasierten Indizierung).
```
probability_config = clarify.ModelPredictedLabelConfig(
probability=1,
)
```
Das `SHAPConfig` Objekt stellt SHAP Analyseparameter bereit. In diesem Beispiel wird der SHAP `baseline` Parameter weggelassen und der Wert des `num_clusters` Parameters `1` ist . Dadurch wird der SageMaker Clarify Processor angewiesen, eine SHAP Ausgangsstichprobe auf der Grundlage der Clusterbildung des Eingabedatensatzes zu berechnen. Informationen zur Auswahl des Basisdatensatzes finden Sie unter [SHAP Baselines for Explainability](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-feature-attribute-shap-baselines.html).
```
shap_config = clarify.SHAPConfig(
num_clusters=1,
)
```
Im folgenden Codebeispiel wird ein SageMaker Clarif-Verarbeitungsauftrag zur Berechnung SHAP von Werten gestartet.
```
clarify_processor.run_explainability(
data_config=data_config,
model_config=model_config,
model_scores=probability_config,
explainability_config=shap_config,
)
```
Ein Beispiel-Notizbuch mit Anweisungen zum Ausführen eines SageMaker Clarif-Verarbeitungsauftrags in SageMaker Studio Classic zur Berechnung von SHAP Werten finden Sie unter [Fairness and Explainability](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-clarify/fairness_and_explainability/fairness_and_explainability.ipynb) with Clarify. SageMaker
### Wie berechnet man partielle Abhängigkeitsdiagramme (PDPs) für einen CSV-Datensatz
PDPs zeigt die Abhängigkeit der vorhergesagten Zielantwort von einem oder mehreren interessierenden Eingabefeatures, während alle anderen Features konstant gehalten werden. Eine nach oben geneigte Linie oder Kurve im PDP zeigt an, dass die Beziehung zwischen dem Ziel und den Eingabe-Features positiv ist, und die Steilheit gibt die Stärke der Beziehung an. Eine nach unten geneigte Linie oder Kurve gibt an, dass die Zielvariable zunimmt, wenn ein Eingabe-Feature abnimmt. Intuitiv können Sie die partielle Abhängigkeit als Reaktion der Zielvariablen auf jedes interessierende Eingabe-Feature interpretieren.
Das folgende Konfigurationsbeispiel zeigt die Verwendung eines `PDPConfig` Objekts, um den SageMaker Clarifesty-Verarbeitungsjob anzuweisen, die Wichtigkeit der Funktion zu berechnen. `Income`
```
pdp_config = clarify.PDPConfig(
features=["Income"],
grid_resolution=10,
)
```
Im vorherigen Beispiel unterteilt der `grid_resolution` Parameter den Bereich der `Income` Feature-Werte in `10` Buckets. Der Verarbeitungsauftrag SageMaker Clarify generiert PDPs die `Income` Aufteilung in `10` Segmente auf der X-Achse. Auf der Y-Achse wird der marginale Einfluss von `Income` auf die Zielvariable dargestellt.
Im folgenden Codebeispiel wird ein SageMaker Clarif-Verarbeitungsauftrag zur Berechnung PDPs gestartet.
```
clarify_processor.run_explainability(
data_config=data_config,
model_config=model_config,
model_scores=probability_config,
explainability_config=pdp_config,
)
```
Ein Beispiel-Notizbuch mit Anweisungen zum Ausführen eines SageMaker Clarif-Verarbeitungsauftrags in SageMaker Studio Classic zur Berechnung PDPs finden Sie unter [Erklärbarkeit mit SageMaker Clarify — Partielle Abhängigkeitsdiagramme (PDP)](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-clarify/fairness_and_explainability/explainability_with_pdp.ipynb).
### Wie berechnet man beide SHAP Werte und PDPs für einen CSV-Datensatz
Sie können beide SHAP Werte und PDPs in einem einzigen SageMaker Clarif-Verarbeitungsauftrag berechnen. Im folgenden Konfigurationsbeispiel ist der `top_k_features` Parameter eines neuen `PDPConfig` Objekts auf `2` gesetzt. Dadurch wird der SageMaker Clarify-Verarbeitungsauftrag angewiesen, PDPs für die `2` Features mit den größten globalen SHAP Werten zu rechnen.
```
shap_pdp_config = clarify.PDPConfig(
top_k_features=2,
grid_resolution=10,
)
```
Im folgenden Codebeispiel wird ein SageMaker Clarif-Verarbeitungsauftrag gestartet, um beide SHAP Werte und PDPs zu berechnen.
```
clarify_processor.run_explainability(
data_config=data_config,
model_config=model_config,
model_scores=probability_config,
explainability_config=[shap_config, shap_pdp_config],
)
```
## Analysieren Sie tabellarische Daten im Format JSON Lines
Die folgenden Beispiele zeigen, wie die Verzerrungsanalyse und die Erklärbarkeitsanalyse für einen tabellarischen Datensatz im dichten Format > SageMaker AI JSON Lines konfiguriert werden. Weitere Informationen finden Sie unter [JSONLINES-Anfrageformat](cdf-inference.md#cm-jsonlines). In diesen Beispielen enthält der eingehende Datensatz dieselben Daten wie im vorherigen Abschnitt, sie sind jedoch im Format JSON Lines. Jede Zeile ist ein gültiges JSON-Objekt. Die `Features` Schlüsselpunkte verweisen auf eine Reihe von Featureswerten und die `Label` Schlüsselpunkte auf das Ground-Truth-Etikett.
```
{"Features":[25,0,2850,2],"Label":0}
{"Features":[36,0,6585,0],"Label":1}
{"Features":[22,1,1759,1],"Label":1}
{"Features":[48,0,3446,1],"Label":0}
...
```
Im folgenden Konfigurationsbeispiel gibt das `DataConfig` Objekt den Eingabedatensatz und den Speicherort der Ausgabe an.
```
data_config = clarify.DataConfig(
s3_data_input_path=jsonl_dataset_s3_uri,
dataset_type='application/jsonlines',
headers=['Age', 'Gender', 'Income', 'Occupation', 'Target'],
label='Label',
features='Features',
s3_output_path=clarify_job_output_s3_uri,
)
```
Im vorherigen Konfigurationsbeispiel wurde der Feature-Parameter auf den [JMESPath](https://jmespath.org/)Ausdruck gesetzt, `Features` sodass der SageMaker Clarify-Verarbeitungsauftrag das Feature-Array aus jedem Datensatz extrahieren kann. Der `label` Parameter ist auf JMESPath Ausdruck gesetzt, `Label` sodass der SageMaker Clarify-Verarbeitungsauftrag das Ground-Truth-Etikett aus jedem Datensatz extrahieren kann. Der `s3_data_input_path` Parameter kann entweder ein URI einer Datensatzdatei oder ein Amazon-S3-URI-Präfix sein. Wenn Sie ein S3-URI-Präfix angeben, sammelt der SageMaker Clarif-Verarbeitungsauftrag rekursiv alle S3-Dateien, die sich unter dem Präfix befinden. Der Wert für `s3_output_path` sollte ein S3-URI-Präfix sein, das die Analyseergebnisse enthält. SageMaker AI verwendet das `s3_output_path` beim Kompilieren und kann keinen Wert eines SageMaker AI-Pipeline-Parameters, einer Eigenschaft, eines Ausdrucks oder`ExecutionVariable`, die zur Laufzeit verwendet werden, annehmen.
Sie benötigen ein trainiertes Modell, um Messwerte für Verzerrungen oder die Bedeutung von Merkmalen nach dem Training berechnen zu können. Das folgende Beispiel stammt aus einem binären Klassifikationsmodell, das JSON-Lines-Daten im Format des Beispiels ausgibt. Jede Zeile der Modellausgabe ist ein gültiges JSON-Objekt. Die `predicted_label` Schlüsselpunkte weisen auf die vorhergesagte Beschriftung und die `probability` Schlüsselpunkte auf den Wahrscheinlichkeitswert hin.
```
{"predicted_label":0,"probability":0.028986845165491}
{"predicted_label":1,"probability":0.825382471084594}
...
```
Im folgenden Konfigurationsbeispiel weist ein `ModelConfig` Objekt den Verarbeitungsauftrag SageMaker Clarify an, das SageMaker KI-Modell auf einem kurzlebigen Endpunkt bereitzustellen. Der Endpunkt verwendet eine `ml.m4.xlarge` Inferenzinstance.
```
model_config = clarify.ModelConfig(
model_name=your_model,
instance_type='ml.m4.xlarge',
instance_count=1,
content_template='{"Features":$features}',
)
```
Im vorherigen Konfigurationsbeispielsind die Parameter `content_type` und `accept_type` nicht gesetzt. Daher verwenden sie automatisch den Wert des `dataset_type` Parameters des `DataConfig` Objekts, nämlich `application/jsonlines`. Der SageMaker Clarify-Verarbeitungsauftrag verwendet den `content_template` Parameter, um die Modelleingabe zu erstellen, indem der `$features` Platzhalter durch eine Reihe von Funktionen ersetzt wird.
Die folgende Beispielkonfiguration zeigt, wie der Label-Parameter des `ModelPredictedLabelConfig` Objekts auf den JMESPath Ausdruck `predicted_label` festgelegt wird. Dadurch wird die vorhergesagte Becshriftung aus der Modellausgabe extrahiert.
```
predicted_label_config = clarify.ModelPredictedLabelConfig(
label='predicted_label',
)
```
Die folgende Beispielkonfiguration zeigt, wie der `probability` Parameter des `ModelPredictedLabelConfig` Objekts auf den JMESPath Ausdruck festgelegt wird`probability`. Dadurch wird die Punktzahl aus der Modellausgabe extrahiert.
```
probability_config = clarify.ModelPredictedLabelConfig(
probability='probability',
)
```
Verwenden Sie dieselben Run-Anweisungen und Konfigurationsobjekte wie im vorherigen Abschnitt für CSV-Datensätze, um Messwerte für Verzerrungen und die Bedeutung von Features für Datensätze im Format JSON Lines zu berechnen. Sie können in SageMaker Studio Classic einen SageMaker Clarif-Verarbeitungsauftrag ausführen, um Verzerrungen zu erkennen und die Wichtigkeit von Funktionen zu berechnen. Anweisungen und ein Beispiel-Notizbuch finden Sie unter [Fairness and Explainability with SageMaker Clarify (JSON Lines Format)](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-clarify/fairness_and_explainability/fairness_and_explainability_jsonlines_format.ipynb).
## Analysieren Sie tabellarische Daten auf ihre NLP-Erklärbarkeit
SageMaker Clarify unterstützt Erklärungen für Modelle zur Verarbeitung natürlicher Sprache (NLP). Diese Erläuterungen helfen Ihnen zu verstehen, welche Textabschnitte für Ihre Modellvorhersagen am wichtigsten sind. Sie können entweder die Modellvorhersage für eine einzelne Instance des Eingabedatensatzes oder Modellvorhersagen anhand des Basisdatensatzes erläutern. Um das Verhalten eines Modells zu verstehen und zu visualisieren, können Sie mehrere Granularitätsebenen angeben. Definieren Sie dazu die Länge des Textsegments, z. B. seiner Tokens, Sätze und Absätze.
SageMaker Clarify Die Erklärbarkeit von NLP ist sowohl mit Klassifikations- als auch mit Regressionsmodellen kompatibel. Sie können SageMaker Clarify auch verwenden, um das Verhalten Ihres Modells in multimodalen Datensätzen zu erklären, die Text-, kategoriale oder numerische Merkmale enthalten. Die NLP-Erklärbarkeit für multimodale Datensätze kann Ihnen helfen zu verstehen, wie wichtig jedes Merkmal für die Ausgabe des Modells ist. SageMaker Clarify unterstützt 62 Sprachen und kann Text verarbeiten, der mehrere Sprachen umfasst.
Das folgende Beispiel zeigt eine Analysekonfigurationsdatei zur Berechnung der Bedeutung von Funktionen für NLP. In diesem Beispiel ist der eingehende Datensatz ein tabellarischer Datensatz im CSV-Format mit einer binären Labelspalte und zwei Feature-Spalten.
```
0,2,"Flavor needs work"
1,3,"They taste good"
1,5,"The best"
0,1,"Taste is awful"
...
```
Das folgende Konfigurationsbeispiel zeigt, wie mithilfe des `DataConfig` Objekts ein Eingabedatensatz im CSV-Format und ein Ausgabedatenpfad angegeben werden.
```
nlp_data_config = clarify.DataConfig(
s3_data_input_path=nlp_dataset_s3_uri,
dataset_type='text/csv',
headers=['Target', 'Rating', 'Comments'],
label='Target',
s3_output_path=clarify_job_output_s3_uri,
)
```
Im vorherigen Konfigurationsbeispiel kann der `s3_data_input_path`-Parameter entweder ein URI einer Datensatzdatei oder ein URI-Präfix von Amazon S3 sein. Wenn Sie ein S3-URI-Präfix angeben, sammelt der SageMaker Clarif-Verarbeitungsauftrag rekursiv alle S3-Dateien, die sich unter dem Präfix befinden. Der Wert für `s3_output_path` sollte ein S3-URI-Präfix sein, das die Analyseergebnisse enthält. SageMaker AI verwendet das `s3_output_path` beim Kompilieren und kann keinen Wert eines SageMaker AI-Pipeline-Parameters, einer Eigenschaft, eines Ausdrucks oder`ExecutionVariable`, die zur Laufzeit verwendet werden, annehmen.
Die folgende Beispielausgabe wurde anhand eines binären Klassifikationsmodells erstellt, das mit dem vorherigen Eingabedatensatz trainiert wurde. Das Klassifikationsmodell akzeptiert CSV-Daten und gibt eine einzelne Punktzahl zwischen `0` und `1` aus.
```
0.491656005382537
0.569582343101501
...
```
Das folgende Beispiel zeigt, wie das `ModelConfig` Objekt für die Bereitstellung eines SageMaker KI-Modells konfiguriert wird. In diesem Beispiel stellt ein kurzlebiger Endpunkt das Modell bereit. Dieser Endpunkt verwendet eine mit einer GPU ausgestattete `ml.g4dn.xlarge` Inferenzinstance für beschleunigte Inferenzen.
```
nlp_model_config = clarify.ModelConfig(
model_name=your_nlp_model_name,
instance_type='ml.g4dn.xlarge',
instance_count=1,
)
```
Das folgende Beispiel zeigt, wie das `ModelPredictedLabelConfig` Objekt so konfiguriert wird, dass die Wahrscheinlichkeit (Punktzahl) in der ersten Spalte mit einem Index von `0` lokalisiert wird.
```
probability_config = clarify.ModelPredictedLabelConfig(
probability=0,
)
```
Die folgende SHAP Beispielkonfiguration zeigt, wie eine Token-basierte Erklärbarkeitsanalyse unter Verwendung eines Modells und eines Eingabedatensatzes in englischer Sprache ausgeführt wird.
```
text_config = clarify.TextConfig(
language='english',
granularity='token',
)
nlp_shap_config = clarify.SHAPConfig(
baseline=[[4, '[MASK]']],
num_samples=100,
text_config=text_config,
)
```
Im vorherigen Beispiel aktiviert das `TextConfig` Objekt die NLP-Erklärbarkeitsanalyse. Der `granularity` Parameter gibt an, dass die Analyse Tokens analysieren soll. Im Englischen ist jedes Token ein Wort. Informationen zu anderen Sprachen finden Sie in der [SpacY-Dokumentation zur Tokenisierung, die Clarify für](https://spacy.io/usage/linguistic-features#tokenization) die SageMaker NLP-Verarbeitung verwendet. Das vorherige Beispiel zeigt auch, wie ein Durchschnitt `Rating` von `4` verwendet wird, um eine In-Place-SHAP Baseline-Instance einzurichten. Ein spezielles Masken-Token `[MASK]` wird verwendet, um ein Token (Wort) in `Comments` zu ersetzen.
Wenn es sich im vorherigen Beispiel um eine Instance `2,"Flavor needs work"` handelt, legen Sie den Basiswert auf einen Durchschnitt `Rating` von `4` mit dem folgenden Basiswert fest.
```
4, '[MASK]'
```
Im vorherigen Beispiel durchläuft der SageMaker Clarify-Erklärer jedes Token und ersetzt es wie folgt durch die Maske.
```
2,"[MASK] needs work"
4,"Flavor [MASK] work"
4,"Flavor needs [MASK]"
```
Anschließend sendet der SageMaker Clarify-Erklärer jede Zeile zur Vorhersage an Ihr Modell. Auf diese Weise lernt der Erklärer die Vorhersagen mit und ohne die maskierten Wörter. Der SageMaker Clarify-Erklärer verwendet dann diese Informationen, um den Beitrag jedes Tokens zu berechnen.
Im folgenden Codebeispiel wird ein SageMaker Clarif-Verarbeitungsauftrag zur Berechnung SHAP von Werten gestartet.
```
clarify_processor.run_explainability(
data_config=nlp_data_config,
model_config=nlp_model_config,
model_scores=probability_config,
explainability_config=nlp_shap_config,
)
```
Ein Beispielnotizbuch mit Anweisungen zur Ausführung eines SageMaker Clarif-Verarbeitungsjobs in SageMaker Studio Classic für die NLP-Erklärbarkeitsanalyse finden Sie unter [Erläuterung der Text-Sentimentanalyse](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-clarify/text_explainability/text_explainability.ipynb) mit Clarify. SageMaker
## Analysieren Sie Bilddaten auf ihre Erklärbarkeit durch Computer Vision
SageMaker Clarify generiert Heatmaps, die Aufschluss darüber geben, wie Ihre Computer-Vision-Modelle Objekte in Ihren Bildern klassifizieren und erkennen.
Im folgenden Konfigurationsbeispiel besteht der Eingabedatensatz aus JPEG-Bildern.
```
cv_data_config = clarify.DataConfig(
s3_data_input_path=cv_dataset_s3_uri,
dataset_type="application/x-image",
s3_output_path=clarify_job_output_s3_uri,
)
```
Im vorherigen Konfigurationsbeispiel enthält das `DataConfig`-Objekt einen `s3_data_input_path`-Satz auf ein URI-Präfix von Amazon S3. Der Verarbeitungsauftrag SageMaker Clarify sammelt rekursiv alle Bilddateien, die sich unter dem Präfix befinden. Der `s3_data_input_path` Parameter kann entweder ein URI einer Datensatzdatei oder ein Amazon-S3-URI-Präfix sein. Wenn Sie ein S3-URI-Präfix angeben, sammelt der SageMaker Clarif-Verarbeitungsauftrag rekursiv alle S3-Dateien, die sich unter dem Präfix befinden. Der Wert für `s3_output_path` sollte ein S3-URI-Präfix sein, das die Analyseergebnisse enthält. SageMaker AI verwendet das `s3_output_path` beim Kompilieren und kann keinen Wert eines SageMaker AI-Pipeline-Parameters, einer Eigenschaft, eines Ausdrucks oder`ExecutionVariable`, die zur Laufzeit verwendet werden, annehmen.
### Wie erklärt man ein Modell zur Bildklassifizierung
Der Verarbeitungsjob SageMaker Clarify erklärt Bilder mithilfe des KernelShap-Algorithmus, der das Bild als eine Sammlung von Superpixeln behandelt. Bei einem Datensatz, der aus Bildern besteht, gibt der Verarbeitungsjob einen Datensatz mit Bildern aus, wobei jedes Bild die Heatmap der entsprechenden Superpixel zeigt.
Das folgende Konfigurationsbeispiel zeigt, wie eine Erklärbarkeitsanalyse mithilfe eines Bildklassifizierungsmodells konfiguriert wird. SageMaker Weitere Informationen finden Sie unter [Bildklassifizierung - MXNet](image-classification.md).
```
ic_model_config = clarify.ModelConfig(
model_name=your_cv_ic_model,
instance_type="ml.p2.xlarge",
instance_count=1,
content_type="image/jpeg",
accept_type="application/json",
)
```
Im vorherigen Konfigurationsbeispiel wurde ein Modell mit dem Namen `your_cv_ic_model`, darauf trainiert, die Tiere anhand von JPEG-Eingabebildern zu klassifizieren. Das `ModelConfig` Objekt im vorherigen Beispiel weist den Verarbeitungsauftrag SageMaker Clarify an, das SageMaker KI-Modell auf einem kurzlebigen Endpunkt bereitzustellen. Für beschleunigte Inferenzen verwendet der Endpunkt eine `ml.p2.xlarge` Inferenzinstance, die mit einer GPU ausgestattet ist.
Nachdem ein JPEG-Bild an einen Endpunkt gesendet wurde, klassifiziert der Endpunkt es und gibt eine Liste mit Ergebnissen zurück. Jede Punktzahl bezieht sich auf eine Kategorie. Das `ModelPredictedLabelConfig` Objekt gibt den Namen jeder Kategorie wie folgt an.
```
ic_prediction_config = clarify.ModelPredictedLabelConfig(
label_headers=['bird', 'cat', 'dog'],
)
```
Eine Beispielausgabe für die vorherige Eingabe von ['bird', 'cat', 'dog'] könnte 0.3,0.6,0.1 sein, wobei 0,3 den Konfidenzwert für die Klassifizierung eines Bilds als Vogel darstellt.
Die folgende SHAP Beispielkonfiguration zeigt, wie Erklärungen für ein Problem mit der Bildklassifizierung generiert werden. Sie verwendet ein `ImageConfig` Objekt, um die Analyse zu aktivieren.
```
ic_image_config = clarify.ImageConfig(
model_type="IMAGE_CLASSIFICATION",
num_segments=20,
segment_compactness=5,
)
ic_shap_config = clarify.SHAPConfig(
num_samples=100,
image_config=ic_image_config,
)
```
SageMaker Clarify extrahiert Merkmale mithilfe der Methode [Simple Linear Iterative Clustering (SLIC)](https://scikit-image.org/docs/dev/api/skimage.segmentation.html#skimage.segmentation.slic) aus der Scikit-Learn-Bibliothek zur Bildsegmentierung. Das vorherige Konfigurationsbeispiel, der `model_type` Parameter, gibt die Art des Problems mit der Bildklassifizierung an. Der Parameter `num_segments` schätzt, wie viele ungefähre Anzahl von Segmenten im Eingabebild beschriftet werden. Die Anzahl der Segmente wird dann an den SLIC `n_segments` Parameter übergeben.
Jedes Segment des Bildes wird als Superpixel betrachtet, und für jedes Segment werden lokale SHAP Werte berechnet. Der Parameter `segment_compactness` bestimmt die Form und Größe der Bildsegmente, die mit der Scikit-Image-Slic-Methode generiert werden. Die Größen und Formen der Bildsegmente werden dann an den `compactness` Parameter slic übergeben.
Im folgenden Codebeispiel wird ein Clarif-Verarbeitungsauftrag gestartet, SageMaker um Heatmaps für Ihre Bilder zu generieren. Positive Heatmap-Werte zeigen, dass die Funktion den Konfidenzwert bei der Objekterkennung erhöht hat. Negative Werte weisen darauf hin, dass das Merkmal den Konfidenzwert verringert hat.
```
clarify_processor.run_explainability(
data_config=cv_data_config,
model_config=ic_model_config,
model_scores=ic_prediction_config,
explainability_config=ic_shap_config,
)
```
Ein Beispielnotizbuch, das SageMaker Clarify verwendet, um Bilder zu klassifizieren und ihre Klassifizierung zu erläutern, finden Sie unter Explaining [Image Classification with SageMaker Clarify](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-clarify/computer_vision/image_classification/explainability_image_classification.ipynb).
### Wie erklärt man ein Objekterkennungsmodell
Ein SageMaker Clarif-Verarbeitungsauftrag kann Objekte in einem Bild erkennen und klassifizieren und anschließend eine Erklärung für das erkannte Objekt liefern. Der Prozess zur Erklärung läuft folgendermaßen ab:
1. Bildobjekte werden zunächst in eine der Klassen in einer bestimmten Sammlung kategorisiert. Wenn ein Objekterkennungsmodell beispielsweise Katzen, Hunde und fish erkennen kann, dann befinden sich diese drei Klassen in einer Sammlung. Diese Sammlung wird durch den `label_headers` Parameter wie folgt angegeben.
```
clarify.ModelPredictedLabelConfig(
label_headers=object_categories,
)
```
1. Der SageMaker Clarify-Verarbeitungsauftrag erzeugt für jedes Objekt einen Konfidenzwert. Ein hoher Konfidenzwert gibt an, dass das Objekt zu einer der Klassen in einer bestimmten Sammlung gehört. Der Verarbeitungsauftrag SageMaker Clarify erzeugt auch die Koordinaten eines Begrenzungsrahmens, der das Objekt begrenzt. Weitere Informationen zu Konfidenzwerten und Bounding Boxes finden Sie unter [Antwortformate](object-detection-in-formats.md#object-detection-recordio).
1. SageMaker Clarify liefert dann eine Erklärung für die Erkennung eines Objekts in der Bildszene. Dabei werden die im Abschnitt **Erläuterung eines Bildklassifizierungsmodells beschriebenen Methoden** verwendet.
Im folgenden Konfigurationsbeispiel `your_cv_od_model` wird ein SageMaker KI-Objekterkennungsmodell anhand von JPEG-Bildern trainiert, um die Tiere auf ihnen zu identifizieren.
```
od_model_config = clarify.ModelConfig(
model_name=your_cv_ic_model,
instance_type="ml.p2.xlarge",
instance_count=1,
content_type="image/jpeg",
accept_type="application/json",
)
```
Das `ModelConfig` Objekt im vorherigen Konfigurationsbeispiel weist den Verarbeitungsjob SageMaker Clarify an, das SageMaker KI-Modell auf einem kurzlebigen Endpunkt bereitzustellen. Für beschleunigtes Imaging verwendet dieser Endpunkt eine `ml.p2.xlarge` Inferenzinstance, die mit einer GPU ausgestattet ist.
In der folgenden Beispielkonfiguration stellt das `ModelPredictedLabelConfig` Objekt den Namen jeder Kategorie zur Klassifizierung bereit.
```
ic_prediction_config = clarify.ModelPredictedLabelConfig(
label_headers=['bird', 'cat', 'dog'],
)
```
Die folgende SHAP Beispielkonfiguration zeigt, wie Erklärungen für eine Objekterkennung generiert werden.
```
od_image_config = clarify.ImageConfig(
model_type="OBJECT_DETECTION",
num_segments=20,
segment_compactness=5,
max_objects=5,
iou_threshold=0.5,
context=1.0,
)
od_shap_config = clarify.SHAPConfig(
num_samples=100,
image_config=image_config,
)
```
In der vorherigen Beispielkonfiguration aktiviert das `ImageConfig` Objekt die Analyse. Der `model_type` Parameter gibt an, dass es sich bei dem Problem um die Objekterkennung handelt. Eine Beschreibung der restlichen Parameter finden Sie unter [Analyse-Konfigurationsdateien](clarify-processing-job-configure-analysis.md).
Im folgenden Codebeispiel wird ein SageMaker Clarif-Verarbeitungsauftrag gestartet, um Heatmaps für Ihre Bilder zu generieren. Positive Heatmap-Werte zeigen, dass die Funktion den Konfidenzwert bei der Objekterkennung erhöht hat. Negative Werte weisen darauf hin, dass das Merkmal den Konfidenzwert verringert hat.
```
clarify_processor.run_explainability(
data_config=cv_data_config,
model_config=od_model_config,
model_scores=od_prediction_config,
explainability_config=od_shap_config,
)
```
Ein Beispielnotizbuch, das SageMaker Clarify verwendet, um Objekte in einem Bild zu erkennen und die Vorhersagen zu erläutern, finden Sie unter [Erläuterung von Objekterkennungsmodellen mit Amazon SageMaker AI Clarify](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-clarify/computer_vision/object_detection/object_detection_clarify.ipynb).
## Analysieren Sie Erklärungen für Zeitreihen-Prognosemodelle
Die folgenden Beispiele zeigen, wie Daten im dichten SageMaker KI-JSON-Format konfiguriert werden, um ein Zeitreihenprognosemodell zu erläutern. Weitere Informationen zur JSON-Formatierung finden Sie unter [JSON-Anfrageformat](cdf-inference.md#cm-json).
```
[
{
"item_id": "item1",
"timestamp": "2019-09-11",
"target_value": 47650.3,
"dynamic_feature_1": 0.4576,
"dynamic_feature_2": 0.2164,
"dynamic_feature_3": 0.1906,
"static_feature_1": 3,
"static_feature_2": 4
},
{
"item_id": "item1",
"timestamp": "2019-09-12",
"target_value": 47380.3,
"dynamic_feature_1": 0.4839,
"dynamic_feature_2": 0.2274,
"dynamic_feature_3": 0.1889,
"static_feature_1": 3,
"static_feature_2": 4
},
{
"item_id": "item2",
"timestamp": "2020-04-23",
"target_value": 35601.4,
"dynamic_feature_1": 0.5264,
"dynamic_feature_2": 0.3838,
"dynamic_feature_3": 0.4604,
"static_feature_1": 1,
"static_feature_2": 2
},
]
```
### Datenkonfiguration
Verwenden Sie `TimeSeriesDataConfig` in Ihrem Explainability-Job, wie Sie Daten aus dem übergebenen Eingabedatensatz korrekt analysieren können, wie in der folgenden Beispielkonfiguration gezeigt:
```
time_series_data_config = clarify.TimeSeriesDataConfig(
target_time_series='[].target_value',
item_id='[].item_id',
timestamp='[].timestamp',
related_time_series=['[].dynamic_feature_1', '[].dynamic_feature_2', '[].dynamic_feature_3'],
static_covariates=['[].static_feature_1', '[].static_feature_2'],
dataset_format='timestamp_records',
)
```
### Konfiguration mit asymmetrischen Shapley-Werten
Wird verwendet`AsymmetricShapleyValueConfig`, um Argumente für die Erläuterungsanalyse von Zeitreihenprognosemodellen zu definieren, z. B. Basislinie, Richtung, Granularität und Anzahl der Stichproben. Basiswerte werden für alle drei Datentypen festgelegt: verwandte Zeitreihen, statische Kovariaten und Zielzeitreihen. Die `AsymmetricShapleyValueConfig` Konfiguration informiert den SageMaker Clarify-Prozessor darüber, wie Feature-Attributionen für jeweils ein Element berechnet werden. Die folgende Konfiguration zeigt ein Beispiel für eine Definition von `AsymmetricShapleyValueConfig`.
```
asymmetric_shapley_value_config = AsymmetricShapleyValueConfig(
direction="chronological",
granularity="fine-grained",
num_samples=10,
baseline={
"related_time_series": "zero",
"static_covariates": {
"item1": [0, 0], "item2": [0, 0]
},
"target_time_series": "zero"
},
)
```
Die Werte, die Sie angeben, `AsymmetricShapleyValueConfig` werden als Eintrag mit Schlüssel an die Analysekonfiguration übergeben. `methods` `asymmetric_shapley_value`
### Modellkonfiguration
Sie können die Struktur der Payload steuern, die vom SageMaker Clariy-Prozessor gesendet wird. Im folgenden Codebeispiel weist ein `ModelConfig` Konfigurationsobjekt einen Job zur Erklärbarkeit von Zeitreihenprognosen an, Datensätze mithilfe der JMESPath Syntax in zu aggregieren`'{"instances": $records}'`, wobei die Struktur jedes Datensatzes mit der folgenden record\$1template definiert wird. `'{"start": $start_time, "target": $target_time_series, "dynamic_feat": $related_time_series, "cat": $static_covariates}'` Beachten Sie`$start_time`, dass`$target_time_series`, und interne Token `$static_covariates` sind`$related_time_series`, die verwendet werden, um Datensatzwerte Endpunktanforderungswerten zuzuordnen.
```
model_config = clarify.ModelConfig(
model_name=your_model,
instance_type='ml.m4.xlarge',
instance_count=1,
record_template='{"start": $start_time, "target": $target_time_series, "dynamic_feat": $related_time_series, "cat": $static_covariates}',
content_template='{"instances": $records}',,
time_series_model_config=TimeSeriesModelConfig(
forecast={'forecast': 'predictions[*].mean[:2]'}
)
)
```
In ähnlicher Weise wird das Attribut `forecast` in`TimeSeriesModelConfig`, das mit dem Schlüssel an die Analysekonfiguration übergeben wird`time_series_predictor_config`, verwendet, um die Modellprognose aus der Endpunktreaktion zu extrahieren. Ein Beispiel für eine Batch-Antwort eines Endpunkts könnte wie folgt aussehen:
```
{
"predictions": [
{"mean": [13.4, 3.6, 1.0]},
{"mean": [23.0, 4.7, 3.0]},
{"mean": [3.4, 5.6, 2.0]}
]
}
```
Wenn der angegebene JMESPath Ausdruck \$1'predictions [\$1] .mean [:2] '\$1\$1 `forecast` lautet, wird der Prognosewert wie folgt analysiert:
```
[[13.4, 3.6], [23.0, 4.7], [3.4, 5.6]]
```
## So führen Sie parallel SageMaker Clarif-Verarbeitungsaufträge aus
Wenn Sie mit großen Datensätzen arbeiten, können Sie [Apache Spark](https://spark.apache.org/) verwenden, um die Geschwindigkeit Ihrer SageMaker Clarif-Verarbeitungsaufträge zu erhöhen. Spark ist eine einheitliche Analyse-Engine für die Verarbeitung großer Datenmengen. Wenn Sie mehr als eine Instanz pro SageMaker Clariy-Prozessor anfordern, verwendet SageMaker Clarify die verteilten Rechenfunktionen von Spark.
Das folgende Konfigurationsbeispiel zeigt, wie Sie `SageMakerClarifyProcessor` einen Clarif-Prozessor SageMaker mit `5` Recheninstanzen erstellen können. Um alle mit SageMaker Clarify verknüpften Jobs mithilfe von Spark Distributed Processing auszuführen. `SageMakerClarifyProcessor`
```
from sagemaker import clarify
spark_clarify_processor = clarify.SageMakerClarifyProcessor(
role=role,
instance_count=5,
instance_type='ml.c5.xlarge',
)
```
Wenn Sie den `save_local_shap_values` Parameter [SHAPConfig](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html#sagemaker.clarify.SHAPConfig)auf setzen`True`, speichert der SageMaker Clarif-Verarbeitungsauftrag den lokalen SHAP Wert als mehrere Teildateien im Ausgabeverzeichnis des Jobs.
Um die lokalen SHAP Werte den Eingabedatensatz-Instances zuzuordnen, verwenden Sie den `joinsource` Parameter von `DataConfig`. Wenn Sie weitere Compute-Instances hinzufügen, empfehlen wir, auch den Wert `instance_count` von [ModelConfig](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html#sagemaker.clarify.ModelConfig)für den ephemeren Endpunkt zu erhöhen. Dadurch wird verhindert, dass die gleichzeitigen Inferenzanfragen der Spark-Auftragnehmer den Endpunkt überfordern. Insbesondere empfehlen wir, ein bestimmtes one-to-one Verhältnis von endpoint-to-processing Instanzen zu verwenden.
# Analyseergebnisse
Nach Abschluss SageMaker eines Clarif-Verarbeitungsauftrags können Sie die Ausgabedateien herunterladen, um sie zu überprüfen, oder Sie können die Ergebnisse in SageMaker Studio Classic visualisieren. Im folgenden Thema werden die von SageMaker Clarify generierten Analyseergebnisse beschrieben, z. B. das Schema und der Bericht, der durch Verzerrungsanalysen, SHAP-Analysen, Computer Vision-Erklärbarkeitsanalysen und partielle Abhängigkeitsdiagramme () PDPs generiert wurde. Wenn die Konfigurationsanalyse Parameter zur Berechnung mehrerer Analysen enthält, werden die Ergebnisse in einer Analyse- und einer Berichtsdatei zusammengefasst.
Das Ausgabeverzeichnis für den SageMaker Clarif-Verarbeitungsjob enthält die folgenden Dateien:
+ `analysis.json` – Eine Datei, die Messwerte für Verzerrungen und die Bedeutung von Features im JSON-Format enthält.
+ `report.ipynb` – Ein statisches Notebook, das Code enthält, mit dem Sie Messwerte zu Verzerrungen und die Bedeutung von Features visualisieren können.
+ `explanations_shap/out.csv` – Ein Verzeichnis, das erstellt wird und automatisch generierte Dateien enthält, die auf Ihren spezifischen Analysekonfigurationen basieren. Wenn Sie beispielsweise den `save_local_shap_values` Parameter aktivieren, werden lokale SHAP-Werte pro Instance im `explanations_shap` Verzeichnis gespeichert. Ein weiteres Beispiel: Wenn Ihr `analysis configuration` keinen Wert für den SHAP-Baseline-Parameter enthält, berechnet der SageMaker Clarify-Erklärbarkeits-Job eine Baseline, indem der Eingabe-Datensatz geclustert wird. Anschließend wird die generierte Baseline im Verzeichnis gespeichert.
Weitere Informationen finden Sie in den folgenden Abschnitten.
**Topics**
+ [Analyse der Verzerrung](#clarify-processing-job-analysis-results-bias)
+ [SHAP-Analyse](#clarify-processing-job-analysis-results-shap)
+ [Analyse der Erklärbarkeit von Computer Vision (CV)](#clarify-processing-job-analysis-results-cv)
+ [Analyse partieller Abhängigkeitsdiagramme (PDPs)](#clarify-processing-job-analysis-results-pdp)
+ [Asymmetrische Shapley-Werte](#clarify-processing-job-analysis-results-asymmshap)
## Analyse der Verzerrung
Amazon SageMaker Clarify verwendet die in dokumentierte Terminologie[Amazon SageMaker klärt die Bedingungen für Voreingenommenheit und Fairness](clarify-detect-data-bias.md#clarify-bias-and-fairness-terms), um Vorurteile und Fairness zu erörtern.
### Schema für die Analysedatei
Die Analysedatei hat das JSON-Format und ist in zwei Abschnitte unterteilt: Verzerrungsmetriken vor dem Training und Verzerrungsmetriken nach dem Training. Die Parameter für Bias-Metriken vor und nach dem Training lauten wie folgt.
+ **pre\$1training\$1bias\$1metrics** – Parameter für Bias-Metriken vor dem Training. Weitere Informationen erhalten Sie unter [Messwerte zu Verzerrungen vor dem Training](clarify-measure-data-bias.md) und [Analyse-Konfigurationsdateien](clarify-processing-job-configure-analysis.md).
+ **label** – Der Ground-Truth-Beschriftungsname, der durch den `label` Parameter der Analysekonfiguration definiert wird.
+ **label\$1value\$1or\$1threshold** – Eine Zeichenfolge, die die Beschriftungwerte oder das durch den `label_values_or_threshold` Parameter der Analysekonfiguration definierte Intervall enthält. Wenn beispielsweise ein Wert für ein binäres Klassifizierungsproblem angegeben `1` wird, dann lautet die Zeichenfolge `1`. Wenn für ein Problem mit mehreren Klassen mehrere Werte `[1,2]` angegeben werden, dann ist die Zeichenfolge `1,2`. Wenn ein Schwellenwert `40` für das Regressionsproblem angegeben wird, handelt es sich bei der Zeichenfolge um eine interne Zeichenfolge, `(40, 68]` bei der `68` es sich um den Maximalwert der Beschriftung im Eingabedatensatz handelt.
+ **Facetten** – Der Abschnitt enthält mehrere Schlüssel-Wert-Paare, wobei der Schlüssel dem durch den `name_or_index` Parameter der Facettenkonfiguration definierten Facettennamen entspricht und der Wert ein Array von Facettenobjekten ist. Jedes Facettenobjekt hat die folgenden Mitglieder:
+ **value\$1or\$1threshold** – Eine Zeichenfolge, die die Facettenwerte oder das durch den `value_or_threshold` Parameter der Facettenkonfiguration definierte Intervall enthält.
+ **metrics** – Der Abschnitt enthält eine Reihe von Bias-Metrikelementen, und jedes Bias-Metrikelement hat die folgenden Attribute:
+ **name** – Der Kurzname der Bias-Metrik. Beispiel, `CI`.
+ **Beschreibung** – Der vollständige Name der Bias-Metrik. Beispiel, `Class Imbalance (CI)`.
+ **Wert** – Der Wert der Bias-Metrik oder der JSON-Nullwert, wenn die Bias-Metrik aus einem bestimmten Grund nicht berechnet wird. Die Werte ±∞ werden jeweils als Zeichenketten `∞` und `-∞` dargestellt.
+ **error** – Eine optionale Fehlermeldung, die erklärt, warum die Bias-Metrik nicht berechnet wurde.
+ **post\$1training\$1bias\$1metrics** – Der Abschnitt enthält die Bias-Metriken nach dem Training und hat ein ähnliches Layout und eine ähnliche Struktur wie der Abschnitt vor dem Training. Weitere Informationen finden Sie unter [Daten nach dem Training und Modellverzerrungenmetriken](clarify-measure-post-training-bias.md).
Im Folgenden finden Sie ein Beispiel für eine Analysekonfiguration, mit der sowohl Messwerte für Verzerrungen vor als auch nach dem Training berechnet werden.
```
{
"version": "1.0",
"pre_training_bias_metrics": {
"label": "Target",
"label_value_or_threshold": "1",
"facets": {
"Gender": [{
"value_or_threshold": "0",
"metrics": [
{
"name": "CDDL",
"description": "Conditional Demographic Disparity in Labels (CDDL)",
"value": -0.06
},
{
"name": "CI",
"description": "Class Imbalance (CI)",
"value": 0.6
},
...
]
}]
}
},
"post_training_bias_metrics": {
"label": "Target",
"label_value_or_threshold": "1",
"facets": {
"Gender": [{
"value_or_threshold": "0",
"metrics": [
{
"name": "AD",
"description": "Accuracy Difference (AD)",
"value": -0.13
},
{
"name": "CDDPL",
"description": "Conditional Demographic Disparity in Predicted Labels (CDDPL)",
"value": 0.04
},
...
]
}]
}
}
}
```
### Bericht zur Analyse von Verzerrungen
Der Bericht zur Bias-Analyse enthält mehrere Tabellen und Diagramme, die detaillierte Erklärungen und Beschreibungen enthalten. Dazu gehören, ohne darauf beschränkt zu sein, die Verteilung der Beschriftungswerte, die Verteilung der Facettenwerte, ein allgemeines Modellleistungsdiagramm, eine Tabelle mit Bias-Metriken und deren Beschreibungen. Weitere Informationen zu Bias-Metriken und deren Interpretation finden Sie unter [Erfahren Sie, wie Amazon SageMaker Clarify Bias erkennt](https://aws.amazon.com/blogs/machine-learning/learn-how-amazon-sagemaker-clarify-helps-detect-bias/).
## SHAP-Analyse
SageMaker Clarify: Verarbeitungsaufträge verwenden den Kernel-SHAP-Algorithmus zur Berechnung von Feature-Attributionen. Der Verarbeitungsauftrag SageMaker Clarify erzeugt sowohl lokale als auch globale SHAP-Werte. Diese helfen dabei, den Beitrag der einzelnen Features zu den Modellvorhersagen zu bestimmen. Lokale SHAP-Werte stellen die Bedeutung der Features für jede einzelne Instance dar, während globale SHAP-Werte die lokalen SHAP-Werte für alle Instances im Datensatz aggregieren. Weitere Informationen zu SHAP-Werten und wie Sie sie interpretieren finden Sie unter [Feature-Attributionen, die Shapley-Werte verwenden](clarify-shapley-values.md).
### Schema für die SHAP-Analysedatei
Die globalen SHAP-Analyseergebnisse werden im Abschnitt mit den Erläuterungen der Analysedatei unter der `kernel_shap` Methode gespeichert. Die verschiedenen Parameter der SHAP-Analysedatei lauten wie folgt:
+ **Erläuterungen** – Der Abschnitt der Analysedatei, der die Ergebnisse der Analyse der Featureswichtigkeit enthält.
+ **kernal\$1shap** – Der Abschnitt der Analysedatei, der das globale SHAP-Analyseergebnis enthält.
+ **global\$1shap\$1values** – Ein Abschnitt der Analysedatei, der mehrere Schlüssel-Wert-Paare enthält. Jeder Schlüssel im Schlüssel-Wert-Paar steht für einen Feature-Namen aus dem Eingabedatensatz. Jeder Wert im Schlüssel-Wert-Paar entspricht dem globalen SHAP-Wert des Features. Der globale SHAP-Wert wird ermittelt, indem die SHAP-Werte des Features pro Instance mithilfe der `agg_method` Konfiguration aggregiert werden. Wenn die `use_logit` Konfiguration aktiviert ist, wird der Wert anhand der logistischen Regressionskoeffizienten berechnet, die als logarithmische Chancenverhältnisse interpretiert werden können.
+ **expected\$1value** – Die durchschnittliche Vorhersage des Basisdatensatzes. Wenn die `use_logit` Konfiguration aktiviert ist, wird der Wert anhand der logistischen Regressionskoeffizienten berechnet.
+ **global\$1top\$1shap\$1text** –wird für die NLP-Erklärbarkeitsanalyse verwendet. Ein Abschnitt der Analysedatei, der eine Reihe von Schlüssel-Wert-Paaren enthält. SageMaker Clarify: Verarbeitungsaufträge aggregieren die SHAP-Werte jedes Tokens und wählen dann die Top-Tokens auf der Grundlage ihrer globalen SHAP-Werte aus. Die `max_top_tokens` Konfiguration definiert die Anzahl der auszuwählenden Token.
Jedes der ausgewählten Top-Token hat ein Schlüssel-Wert-Paar. Der Schlüssel im Schlüssel-Wert-Paar entspricht dem Text-Feature-Namen eines Top-Tokens. Jeder Wert im Schlüssel-Wert-Paar entspricht den globalen SHAP-Werten des Top-Tokens. Ein Beispiel für ein Schlüssel-Wert-Paar `global_top_shap_text` finden Sie in der folgenden Ausgabe.
Das folgende Beispiel zeigt die Ausgabe der SHAP-Analyse eines tabellarischen Datensatzes.
```
{
"version": "1.0",
"explanations": {
"kernel_shap": {
"Target": {
"global_shap_values": {
"Age": 0.022486410860333206,
"Gender": 0.007381025261958729,
"Income": 0.006843906804137847,
"Occupation": 0.006843906804137847,
...
},
"expected_value": 0.508233428001
}
}
}
}
```
Das folgende Beispiel zeigt die Ausgabe der SHAP-Analyse eines Textdatensatzes. Die der Spalte entsprechende Ausgabe `Comments` ist ein Beispiel für eine Ausgabe, die nach der Analyse eines Text-Features generiert wird.
```
{
"version": "1.0",
"explanations": {
"kernel_shap": {
"Target": {
"global_shap_values": {
"Rating": 0.022486410860333206,
"Comments": 0.058612104851485144,
...
},
"expected_value": 0.46700941970297033,
"global_top_shap_text": {
"charming": 0.04127962903247833,
"brilliant": 0.02450240786522321,
"enjoyable": 0.024093569652715457,
...
}
}
}
}
}
```
### Schema für die generierte Baseline-Datei
Wenn keine SHAP-Basiskonfiguration bereitgestellt wird, generiert der SageMaker Clarif-Verarbeitungsauftrag einen Basisdatensatz. SageMaker Clarify verwendet einen entfernungsbasierten Clustering-Algorithmus, um einen Basisdatensatz aus Clustern zu generieren, die aus dem Eingabe-Datensatz erstellt wurden. Der resultierende Basisdatensatz wird in einer CSV-Datei gespeichert, die sich unter `explanations_shap/baseline.csv` befindet. Diese Ausgabedatei enthält eine Kopfzeile und mehrere Instances, die auf dem in der Analysekonfiguration angegebenen `num_clusters` Parameter basieren. Der Basisdatensatz besteht nur aus Feature-Spalten. Das folgende Beispiel veranschaulicht eine Baseline, die durch Clustering des Eingabedatensatzes erstellt wurde.
```
Age,Gender,Income,Occupation
35,0,2883,1
40,1,6178,2
42,0,4621,0
```
### Schema für lokale SHAP-Werte aus der Erklärbarkeitsanalyse von tabellarischen Datensätzen
Wenn bei tabellarischen Datensätzen eine einzelne Recheninstanz verwendet wird, speichert der Clarify-Verarbeitungsauftrag die SageMaker lokalen SHAP-Werte in einer CSV-Datei mit dem Namen. `explanations_shap/out.csv` Wenn Sie mehrere Recheninstances verwenden, werden lokale SHAP-Werte in mehreren CSV-Dateien im `explanations_shap` Verzeichnis gespeichert.
Eine Ausgabedatei, die lokale SHAP-Werte enthält, enthält eine Zeile mit den lokalen SHAP-Werten für jede Spalte, die durch die Header definiert ist. Die Header folgen der Benennungskonvention, `Feature_Label` bei der an den Feature-Namen ein Unterstrich angehängt wird, gefolgt vom Namen Ihrer Zielvariablen.
Bei Problemen mit mehreren Klassen variieren zuerst die Feature-Namen in der Kopfzeile, dann die Beschriftungen. Beispielsweise sind zwei Features `F1, F2` und zwei Klassen `L1` und `L2` in den Überschriften `F1_L1`, `F2_L1`. `F1_L2`, und `F2_L2`. Wenn die Analysekonfiguration einen Wert für den `joinsource_name_or_index` Parameter enthält, wird die in der Verknüpfung verwendete Schlüsselspalte an das Ende des Headernamens angehängt. Dies ermöglicht die Zuordnung der lokalen SHAP-Werte zu Instances des Eingabedatensatzes. Es folgt ein Beispiel für eine Ausgabedatei mit SHAP-Werten.
```
Age_Target,Gender_Target,Income_Target,Occupation_Target
0.003937908,0.001388849,0.00242389,0.00274234
-0.0052784,0.017144491,0.004480645,-0.017144491
...
```
### Schema für lokale SHAP-Werte aus der NLP-Erklärbarkeitsanalyse
Wenn für die NLP-Erklärbarkeitsanalyse eine einzelne Recheninstanz verwendet wird, speichert der SageMaker Clarif-Verarbeitungsjob lokale SHAP-Werte in einer JSON Lines-Datei mit dem Namen. `explanations_shap/out.jsonl` Wenn Sie mehrere Compute-Instances verwenden, werden die lokalen SHAP-Werte in mehreren JSON Lines-Dateien im `explanations_shap` Verzeichnis gespeichert.
Jede Datei, die lokale SHAP-Werte enthält, hat mehrere Datenzeilen, und jede Zeile ist ein gültiges JSON-Objekt. Dieses JSON -Objekt hat die folgenden Attribute:
+ **Erklärungen** – Der Abschnitt der Analysedatei, der eine Reihe von Kernel-SHAP-Erklärungen für eine einzelne Instance enthält. Jedes Element im Array hat die folgenden Mitglieder:
+ **feature\$1name** – Der Header-Name der Funktionen, die in der Header-Konfiguration bereitgestellt werden.
+ **data\$1type** — Der vom Clarif-Verarbeitungsjob abgeleitete Feature-Typ. SageMaker Zu den gültigen Werten für Textfeatures gehören `numerical`,`categorical`, und `free_text` (für Textfeatures).
+ **Attributionen** – Eine merkmalsspezifische Anordnung von Attributionsobjekten. Ein Textfeature kann mehrere Zuordnungsobjekte haben, jedes für eine durch die `granularity` Konfiguration definierte Einheit. Das Attribut-Objekt hat die folgenden Member:
+ **Zuordnung** – Ein klassenspezifisches Array von Wahrscheinlichkeitswerten.
+ **Beschreibung** – (für Textfeature) Die Beschreibung der Texteinheiten.
+ **partial\$1text — Der Teil des Textes**, der durch den Verarbeitungsauftrag Clarify erklärt wird. SageMaker
+ **start\$1idx** – Ein auf Null basierender Index zur Identifizierung der Array-Position, die den Anfang des partiellen Textfragments angibt.
Im Folgenden finden Sie ein Beispiel für eine einzelne Zeile aus einer lokalen SHAP-Wertedatei, die zur besseren Lesbarkeit verschönert wurde.
```
{
"explanations": [
{
"feature_name": "Rating",
"data_type": "categorical",
"attributions": [
{
"attribution": [0.00342270632248735]
}
]
},
{
"feature_name": "Comments",
"data_type": "free_text",
"attributions": [
{
"attribution": [0.005260534499999983],
"description": {
"partial_text": "It's",
"start_idx": 0
}
},
{
"attribution": [0.00424190349999996],
"description": {
"partial_text": "a",
"start_idx": 5
}
},
{
"attribution": [0.010247314500000014],
"description": {
"partial_text": "good",
"start_idx": 6
}
},
{
"attribution": [0.006148907500000005],
"description": {
"partial_text": "product",
"start_idx": 10
}
}
]
}
]
}
```
### SHAP-Analysebericht
Der SHAP-Analysebericht enthält ein Balkendiagramm mit einem Maximum der `10` wichtigsten globalen SHAP-Werte. Das folgende Diagrammbeispiel zeigt die SHAP-Werte für die wichtigsten `4` Funktionen.
![\[Horizontales Balkendiagramm der globalen SHAP-Werte, die für die Zielvariable der vier wichtigsten Features berechnet wurden.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/clarify/shap-chart.png)
## Analyse der Erklärbarkeit von Computer Vision (CV)
SageMaker Clarify Computer Vision Explainability verwendet einen Datensatz, der aus Bildern besteht, und behandelt jedes Bild als eine Sammlung von Superpixeln. Nach der Analyse gibt der Verarbeitungsauftrag SageMaker Clarify einen Datensatz mit Bildern aus, wobei jedes Bild die Heatmap der Superpixel zeigt.
Das folgende Beispiel zeigt links ein Eingabe-Geschwindigkeitsbegrenzungszeichen und rechts eine Heatmap die Größe der SHAP-Werte. Diese SHAP-Werte wurden mit einem Resnet-18-Bilderkennungsmodell berechnet, das darauf trainiert ist, [deutsche Verkehrszeichen](https://benchmark.ini.rub.de/gtsrb_news.html) zu erkennen. Der Datensatz des German Traffic Sign Recognition Benchmark (GTSRB) ist in dem paper [Man vs. Computer: Benchmarking machine learning algorithms for traffic sign recognition](https://www.sciencedirect.com/science/article/abs/pii/S0893608012000457?via%3Dihub) veröffentlicht. In der Beispielausgabe deuten große positive Werte darauf hin, dass das Superpixel eine starke positive Korrelation mit der Modellvorhersage aufweist. Große negative Werte weisen darauf hin, dass das Superpixel eine starke negative Korrelation mit der Modellvorhersage aufweist. Je größer der absolute Wert des in der Heatmap angezeigten SHAP-Werts ist, desto stärker ist die Beziehung zwischen dem Superpixel und der Modellvorhersage.
![\[Eingabebild des Geschwindigkeitsbegrenzungszeichens und daraus resultierende Heatmap der SHAP-Werte aus einem Resnet-18-Modell.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/clarify/shap_speed-limit-70.png)
Weitere Informationen finden Sie in den Beispielnotizbüchern [Explaining Image Classification with SageMaker Clarify](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-clarify/computer_vision/image_classification/explainability_image_classification.ipynb) und [Explaining Object Detection Models with Amazon SageMaker Clarify](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-clarify/computer_vision/object_detection/object_detection_clarify.ipynb).
## Analyse partieller Abhängigkeitsdiagramme (PDPs)
Partielle Abhängigkeitsdiagramme zeigen die Abhängigkeit der vorhergesagten Zielreaktion von einer Reihe interessierender Eingabefeature. Diese Features sind gegenüber den Werten aller anderen Eingabefeature marginalisiert und werden als Komplementfeature bezeichnet. Intuitiv können Sie die partielle Abhängigkeit als die Zielantwort interpretieren, die als Funktion jedes interessierenden Eingabefeature erwartet wird.
### Schema für die Analysedatei
Die PDP-Werte werden im `explanations` Abschnitt der Analysedatei unter der `pdp` Methode gespeichert. Die Parameter für sind `explanations` wie folgt:
+ **Erläuterungen** – Der Abschnitt der Analysedateien, der die Ergebnisse der Analyse der Featuresbedeutung enthält.
+ **pdp** – Der Abschnitt der Analysedatei, der eine Reihe von PDP-Erklärungen für eine einzelne Instance enthält. Jedes Element des Arrays hat die folgenden Mitglieder:
+ **feature\$1name** – Der Header-Name der in der `headers` Konfiguration bereitgestellten Funktionen.
+ **data\$1type** — Der vom Verarbeitungsjob SageMaker Clarify abgeleitete Feature-Typ. Zu den gültigen Werten für `data_type` gehören numerische und kategoriale Werte.
+ **feature\$1values** – Enthält die im Feature vorhandenen Werte. Wenn der von `data_type` SageMaker Clarify abgeleitete Wert kategorisch ist, `feature_values` enthält er alle Einzelwerte, die das Feature haben könnte. Wenn das von `data_type` SageMaker Clarify abgeleitete Objekt numerisch ist, `feature_values` enthält es eine Liste der zentralen Werte der generierten Buckets. Der `grid_resolution` Parameter bestimmt die Anzahl der Buckets, die zur Gruppierung der Feature-Spaltenwerte verwendet werden.
+ **data\$1distribution** – Eine Reihe von Prozentsätzen, wobei jeder Wert dem Prozentsatz der Instances entspricht, die ein Bucket enthält. Der `grid_resolution` Parameter bestimmt die Anzahl der Buckets. Die Werte der Feature-Spalte sind in diesen Buckets gruppiert.
+ **model\$1predictions** – Ein Array von Modellvorhersagen, wobei jedes Element des Arrays ein Array von Vorhersagen ist, das einer Klasse in der Ausgabe des Modells entspricht.
**label\$1headers** – Die von der `label_headers` Konfiguration bereitgestellten Beschriftung-Header.
+ **error** – Eine Fehlermeldung, die generiert wird, wenn die PDP-Werte aus einem bestimmten Grund nicht berechnet werden. Diese Fehlermeldung ersetzt den Inhalt der Felder `feature_values`, `data_distributions`, und `model_predictions`.
Im Folgenden finden Sie ein Beispiel für die Ausgabe einer Analysedatei, die ein PDP-Analyseergebnis enthält.
```
{
"version": "1.0",
"explanations": {
"pdp": [
{
"feature_name": "Income",
"data_type": "numerical",
"feature_values": [1046.9, 2454.7, 3862.5, 5270.2, 6678.0, 8085.9, 9493.6, 10901.5, 12309.3, 13717.1],
"data_distribution": [0.32, 0.27, 0.17, 0.1, 0.045, 0.05, 0.01, 0.015, 0.01, 0.01],
"model_predictions": [[0.69, 0.82, 0.82, 0.77, 0.77, 0.46, 0.46, 0.45, 0.41, 0.41]],
"label_headers": ["Target"]
},
...
]
}
}
```
### PDP-Analysebericht
Sie können einen Analysebericht erstellen, der für jedes Feature ein PDP-Diagramm enthält. Das PDP-Diagramm wird `feature_values` entlang der X-Achse und das Diagramm `model_predictions` entlang der Y-Achse dargestellt. Bei Modellen mit mehreren Klassen `model_predictions` ist dies ein Array, und jedes Element dieses Arrays entspricht einer der Modellvorhersageklassen.
Im Folgenden finden Sie ein Beispiel für ein PDP-Diagramm für das Feature `Age`. In der Beispielausgabe zeigt das PDP die Anzahl der Feature-Werte, die in Gruppen gruppiert sind. Die Anzahl der Buckets wird durch `grid_resolution` bestimmt. Die Gruppen mit Feature-Werten werden anhand der Modellvorhersagen grafisch dargestellt. In diesem Beispiel haben die höheren Featureswerte dieselben Modellvorhersagewerte.
![\[Liniendiagramm, das zeigt, wie sich Modellvorhersagen im Vergleich feature_values zu 10 einzelnen Rasterpunkten unterscheiden.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/clarify/pdp-chart.png)
## Asymmetrische Shapley-Werte
SageMaker Clarify-Verarbeitungsaufträge verwenden den asymmetrischen Shapley-Wertalgorhythmus, um die Erläuterungen von Zeitreihenprognosemodellen zu berechnen. Dieser Algorithmus bestimmt den Beitrag der Eingabe-Features bei jedem Zeitschritt zu den prognostizierten Vorhersagen.
### Schema für die Analysedatei mit asymmetrischen Shapley-Werten
Asymmetrische Shapley-Wertergebnisse werden in einem Amazon –S3-Bucket gespeichert. Den Speicherort dieses Buckets finden Sie im Abschnitt *Erläuterungen zur* Analysedatei. Dieser Abschnitt enthält die Ergebnisse der Analyse der Featureswichtigkeit. Die folgenden Parameter sind in der Datei zur Analyse asymmetrischer Shapley-Werte enthalten.
+ **asymmetric\$1shapley\$1value** – Der Abschnitt der Analysedatei, der Metadaten zu den Ergebnissen des Erklärungsjobs enthält, darunter die folgenden:
+ **explanation\$1results\$1path** – der Amazon-S3-Standort mit den Erklärungsergebnissen
+ **direction** – Die vom Benutzer bereitgestellte Konfiguration für den Konfigurationswert von `direction`
+ **Granularität** – Die vom Benutzer bereitgestellte Konfiguration für den Konfigurationswert von `granularity`
Der folgende Ausschnitt zeigt die zuvor genannten Parameter in einer Beispielanalysedatei:
```
{
"version": "1.0",
"explanations": {
"asymmetric_shapley_value": {
"explanation_results_path": EXPLANATION_RESULTS_S3_URI,
"direction": "chronological",
"granularity": "timewise",
}
}
}
```
In den folgenden Abschnitten wird beschrieben, wie die Struktur der Erklärungsergebnisse vom Wert von `granularity` in der Konfiguration abhängt.
#### Zeitgranularität
Wenn die Granularität gegeben ist, wird `timewise` die Ausgabe in der folgenden Struktur dargestellt. Der `scores` Wert stellt die Zuordnung für jeden Zeitstempel dar. Der `offset` Wert stellt die Vorhersage des Modells anhand der Basisdaten dar und beschreibt das Verhalten des Modells, wenn es keine Daten empfängt.
Der folgende Ausschnitt zeigt eine Beispielausgabe für ein Modell, das Vorhersagen für zwei Zeitschritte trifft. Daher sind alle Attributionen eine Liste von zwei Elementen, wobei sich der erste Eintrag auf den ersten vorhergesagten Zeitschritt bezieht.
```
{
"item_id": "item1",
"offset": [1.0, 1.2],
"explanations": [
{"timestamp": "2019-09-11 00:00:00", "scores": [0.11, 0.1]},
{"timestamp": "2019-09-12 00:00:00", "scores": [0.34, 0.2]},
{"timestamp": "2019-09-13 00:00:00", "scores": [0.45, 0.3]},
]
}
{
"item_id": "item2",
"offset": [1.0, 1.2],
"explanations": [
{"timestamp": "2019-09-11 00:00:00", "scores": [0.51, 0.35]},
{"timestamp": "2019-09-12 00:00:00", "scores": [0.14, 0.22]},
{"timestamp": "2019-09-13 00:00:00", "scores": [0.46, 0.31]},
]
}
```
#### Differenzierte Granularität
Das folgende Beispiel zeigt die Attributionsergebnisse, wenn die Granularität aktiviert ist. `fine_grained` Der `offset` Wert hat dieselbe Bedeutung wie im vorherigen Abschnitt beschrieben. Die Attributionen werden für jedes Eingabe-Feature zu jedem Zeitstempel für eine Zielzeitreihe und zugehörige Zeitreihen, falls verfügbar, und für jede statische Kovariate, falls verfügbar, berechnet.
```
{
"item_id": "item1",
"offset": [1.0, 1.2],
"explanations": [
{"feature_name": "tts_feature_name_1", "timestamp": "2019-09-11 00:00:00", "scores": [0.11, 0.11]},
{"feature_name": "tts_feature_name_1", "timestamp": "2019-09-12 00:00:00", "scores": [0.34, 0.43]},
{"feature_name": "tts_feature_name_2", "timestamp": "2019-09-11 00:00:00", "scores": [0.15, 0.51]},
{"feature_name": "tts_feature_name_2", "timestamp": "2019-09-12 00:00:00", "scores": [0.81, 0.18]},
{"feature_name": "rts_feature_name_1", "timestamp": "2019-09-11 00:00:00", "scores": [0.01, 0.10]},
{"feature_name": "rts_feature_name_1", "timestamp": "2019-09-12 00:00:00", "scores": [0.14, 0.41]},
{"feature_name": "rts_feature_name_1", "timestamp": "2019-09-13 00:00:00", "scores": [0.95, 0.59]},
{"feature_name": "rts_feature_name_1", "timestamp": "2019-09-14 00:00:00", "scores": [0.95, 0.59]},
{"feature_name": "rts_feature_name_2", "timestamp": "2019-09-11 00:00:00", "scores": [0.65, 0.56]},
{"feature_name": "rts_feature_name_2", "timestamp": "2019-09-12 00:00:00", "scores": [0.43, 0.34]},
{"feature_name": "rts_feature_name_2", "timestamp": "2019-09-13 00:00:00", "scores": [0.16, 0.61]},
{"feature_name": "rts_feature_name_2", "timestamp": "2019-09-14 00:00:00", "scores": [0.95, 0.59]},
{"feature_name": "static_covariate_1", "scores": [0.6, 0.1]},
{"feature_name": "static_covariate_2", "scores": [0.1, 0.3]},
]
}
```
`timewise`Sowohl für Anwendungsfälle als auch für `fine-grained` Anwendungsfälle werden die Ergebnisse im Format JSON Lines (.jsonl) gespeichert.
# Fehlerbehebung bei Clarify Processing Jobs SageMaker
Wenn Sie bei der Verarbeitung von SageMaker Clarify auf Fehler stoßen, sollten Sie sich die folgenden Szenarien ansehen, um das Problem zu identifizieren.
**Anmerkung**
Die Fehlerursache und die Abbruchmeldung sollen beschreibende Meldungen und Ausnahmen enthalten, falls sie während der Ausführung auftreten. Ein häufiger Grund für Fehler ist, dass Parameter entweder fehlen oder nicht gültig sind. Wenn Sie auf unklare, verwirrende oder irreführende Meldungen stoßen oder keine Lösung finden können, senden Sie uns Feedback.
**Topics**
+ [Der Verarbeitungsauftrag kann nicht abgeschlossen werden](#clarify-troubleshooting-job-fails)
+ [Die Ausführung des Verarbeitungsauftrags dauert zu lange](#clarify-troubleshooting-job-long)
+ [Der Verarbeitungsauftrag wird ohne Ergebnisse abgeschlossen und Sie erhalten eine CloudWatch Warnmeldung](#clarify-troubleshooting-no-results-and-warning)
+ [Fehlermeldung für eine ungültige Analysekonfiguration](#clarify-troubleshooting-invalid-analysis-configuration)
+ [Die Berechnung der Bias-Metriken schlägt für mehrere oder alle Metriken fehl](#clarify-troubleshooting-bias-metric-computation-fails)
+ [Nichtübereinstimmung zwischen Analysekonfiguration und Eingabe/Ausgabe dataset/model](#clarify-troubleshooting-mismatch-analysis-config-and-data-model)
+ [Das Modell gibt 500 zurück. Interner Serverfehler oder der Container greift aufgrund eines Modellfehlers auf Prognosen pro Datensatz zurück](#clarify-troubleshooting-500-internal-server-error)
+ [Ausführungsrolle ist ungültig](#clarify-troubleshooting-execution-role-invalid)
+ [Daten konnten nicht heruntergeladen werden](#clarify-troubleshooting-data-download)
+ [Es konnte keine Verbindung zur KI hergestellt werden SageMaker](#clarify-troubleshooting-connection)
## Der Verarbeitungsauftrag kann nicht abgeschlossen werden
Wenn der Verarbeitungsauftrag nicht abgeschlossen werden kann, können Sie Folgendes versuchen:
+ Prüfen Sie die Auftragsprotokolle direkt in dem Notebook, in dem Sie den Auftrag ausgeführt haben. Die Auftragsprotokolle befinden sich in der Ausgabe der Notebook-Zelle, in der Sie den Lauf initiiert haben.
+ Untersuchen Sie die Job-Logs CloudWatch.
+ Fügen Sie Ihrem Notebook die folgende Zeile hinzu, um den letzten Verarbeitungsauftrag zu beschreiben, und suchen Sie nach der Fehlerursache und der Abbruchmeldung:
+ `clarify_processor.jobs[-1].describe()`
+ Führen Sie den folgenden Befehl aus AWS CLI, um den Verarbeitungsauftrag zu beschreiben, und suchen Sie nach der Fehlerursache und der Abbruchmeldung:
+ `aws sagemaker describe-processing-job —processing-job-name `
## Die Ausführung des Verarbeitungsauftrags dauert zu lange
Wenn die Ausführung Ihres Verarbeitungsauftrags zu lange dauert, gehen Sie wie folgt vor, um die Ursache zu ermitteln.
Prüfen Sie, ob Ihre Ressourcenkonfiguration ausreicht, um Ihre Rechenlast zu bewältigen. Um Ihre Arbeit zu beschleunigen, führen Sie die folgenden Schritte aus:
+ Verwenden Sie einen größeren Instanztyp. SageMaker Clarify fragt das Modell wiederholt ab, und eine größere Instanz kann Ihre Berechnungszeit erheblich reduzieren. Eine Liste der verfügbaren Instances, ihrer Speichergröße, Bandbreite und anderen Leistungsdetails finden Sie unter [Amazon SageMaker AI-Preise](https://aws.amazon.com/sagemaker/pricing/).
+ Fügen Sie weitere Instances hinzu. SageMaker Clarify kann mehrere Instanzen verwenden, um mehrere Eingabedatenpunkte parallel zu erklären. Um paralleles Rechnen zu aktivieren, stellen Sie `instance_count` auf mehr als `1` bei einem Anruf `SageMakerClarifyProcessor` ein. Weitere Informationen finden Sie unter [So führen Sie parallel SageMaker Clarif-Verarbeitungsaufträge aus](clarify-processing-job-run.md#clarify-processing-job-run-spark). Wenn Sie die Anzahl Ihrer Instances erhöhen, überwachen Sie die Leistung Ihres Endpunkts, um zu überprüfen, ob er die erhöhte Last bereitstellen kann. Weitere Informationen finden Sie unter [Daten von Echtzeit-Endpunkten erfassen](model-monitor-data-capture-endpoint.md).
+ Wenn Sie Werte SHapley Additive exPlanations (SHAP) berechnen, reduzieren Sie den `num_samples` Parameter in Ihrer Analysekonfigurationsdatei. Die Anzahl der Proben wirkt sich direkt auf Folgendes aus:
+ Die Größe der synthetischen Datensätze, die an Ihren Endpunkt gesendet werden
+ Auftragslaufzeit
Eine Verringerung der Anzahl der Proben kann auch zu einer geringeren Genauigkeit bei der Schätzung SHAP von Werten führen. Weitere Informationen finden Sie unter [Analyse-Konfigurationsdateien](clarify-processing-job-configure-analysis.md).
## Der Verarbeitungsauftrag wird ohne Ergebnisse abgeschlossen und Sie erhalten eine CloudWatch Warnmeldung
Wenn der Verarbeitungsauftrag abgeschlossen wird, aber keine Ergebnisse gefunden werden, wird in den CloudWatch Protokollen eine Warnmeldung ausgegeben, die besagt, dass Signal 15 empfangen wurde, und das Aufräumen erfolgt. Diese Warnung weist darauf hin, dass der Job entweder beendet wurde, weil eine Kundenanfrage die `StopProcessingJob` API aufgerufen hat, oder dass die für die Ausführung des Auftrags vorgesehene Zeit abgelaufen ist. Überprüfen Sie in letzterem Fall die maximale Laufzeit in der Auftragskonfiguration (`max_runtime_in_seconds`) und erhöhen Sie sie nach Bedarf.
## Fehlermeldung für eine ungültige Analysekonfiguration
+ Wenn Sie die Fehlermeldung Die Analysekonfiguration konnte nicht als JSON. geladen werden erhalten, bedeutet das, dass die Eingabedatei für die Analysekonfiguration für den Verarbeitungsauftrages kein gültiges JSON-Objekt enthält. Überprüfen Sie die Gültigkeit des JSON-Objekts mithilfe eines JSON-Linters.
+ Wenn Sie die Fehlermeldung Fehler bei der Validierung des Analyse-Konfigurationsschemas erhalten, bedeutet dies, dass die Eingabedatei für die Analysekonfiguration für den Verarbeitungsauftrag unbekannte Felder oder ungültige Typen für einige Feldwerte enthält. Überprüfen Sie die Konfigurationsparameter in der Datei und vergleichen Sie sie mit den in der Analysekonfigurationsdatei aufgelisteten Parametern. Weitere Informationen finden Sie unter [Analyse-Konfigurationsdateien](clarify-processing-job-configure-analysis.md).
## Die Berechnung der Bias-Metriken schlägt für mehrere oder alle Metriken fehl
Wenn Sie eine der folgenden Fehlermeldungen erhalten: In der Spalte mit der prognostizierten Bezeichnung sind keine Labelwerte vorhanden, enthält die Reihe mit positivem prognostiziertem Index alle falschen Werte oder Datentyp der Serie „Prognostizierte Labelspalte“ ist nicht identisch mit der Datenreihe Labelspalte versuchen Sie Folgendes:
+ Vergewissern Sie sich, dass der richtige Datensatz verwendet wird.
+ Prüfen Sie, ob der Datensatz zu klein ist, ob er beispielsweise nur wenige Zeilen enthält. Dies kann dazu führen, dass die Modellausgaben denselben Wert haben oder der Datentyp falsch abgeleitet wird.
+ Prüfen Sie, ob das Etikett oder die Facette als kontinuierlich oder kategorisch behandelt wird. SageMaker Clarify verwendet Heuristiken, um das zu bestimmen. [https://github.com/aws/amazon-sagemaker-clarify/blob/master/src/smclarify/bias/metrics/common.py#L114)](https://github.com/aws/amazon-sagemaker-clarify/blob/master/src/smclarify/bias/metrics/common.py#L114)) Bei Bias-Metriken nach dem Training stimmt der vom Modell zurückgegebene Datentyp möglicherweise nicht mit dem im Datensatz enthaltenen überein, oder SageMaker Clarify ist möglicherweise nicht in der Lage, ihn korrekt zu transformieren.
+ Im Bias-Bericht sollten Sie einen einzelnen Wert für kategoriale Spalten oder ein Intervall für fortlaufende Spalten sehen.
+ Wenn eine Spalte beispielsweise die Werte 0,0 und 1,0 als Gleitkommazahlen hat, wird sie als kontinuierlich behandelt, auch wenn es zu wenige Einzelwerte gibt.
## Nichtübereinstimmung zwischen Analysekonfiguration und Eingabe/Ausgabe dataset/model
+ Stellen Sie sicher, dass das Basisformat in der Analysekonfiguration dem Datensatzformat entspricht.
+ Wenn Sie die Fehlermeldung Could not convert string to float erhalten., überprüfen Sie, ob das Format korrekt angegeben ist. Es könnte auch darauf hinweisen, dass die Modellvorhersagen ein anderes Format als die Labelspalte haben, oder es könnte darauf hinweisen, dass die Konfiguration für die Beschriftung oder die Wahrscheinlichkeiten falsch ist.
+ Wenn Sie die Fehlermeldung Unable to locate the facet erhalten oder Kopfzeilen müssen eine Bezeichnung enthalten oder Header in der Konfiguration stimmen nicht mit der Anzahl der Spalten im Datensatz überein oder Feature-Namen wurden nicht gefunden, überprüfen Sie, ob die Überschriften mit den Spalten übereinstimmen.
+ Wenn Sie die Fehlermeldung Daten müssen Funktionen enthalten erhalten, überprüfen Sie die Inhaltsvorlage für JSON Lines und vergleichen Sie sie mit dem Datensatzbeispiel, falls verfügbar.
## Das Modell gibt 500 zurück. Interner Serverfehler oder der Container greift aufgrund eines Modellfehlers auf Prognosen pro Datensatz zurück
Wenn Sie die Fehlermeldung Rückgriff auf die Pro-Datensatz-Vorhersage aufgrund von Modellfehlern erhalten, könnte dies darauf hinweisen, dass das Modell die Stapelgröße nicht verarbeiten kann, gedrosselt wird oder die vom Container übergebene Eingabe aufgrund von Serialisierungsproblemen einfach nicht akzeptiert. Sie sollten die CloudWatch Protokolle für den SageMaker KI-Endpunkt überprüfen und nach Fehlermeldungen oder Tracebacks suchen. Bei der Drosselung von Modellen kann es hilfreich sein, einen anderen Instance-Typ zu verwenden oder die Anzahl der Instances für den Endpunkt zu erhöhen.
## Ausführungsrolle ist ungültig
Dies weist darauf hin, dass die angegebene Rolle falsch ist oder dass die erforderlichen Berechtigungen fehlen. Überprüfen Sie die Rolle und ihre Berechtigungen, die zur Konfiguration des Verarbeitungsauftrags verwendet wurden, und überprüfen Sie die Berechtigungs- und Vertrauensrichtlinie für die Rolle.
## Daten konnten nicht heruntergeladen werden
Dies weist darauf hin, dass die Auftragseingaben nicht heruntergeladen werden konnten, damit der Job gestartet werden konnte. Überprüfen Sie den Bucket-Namen und die Berechtigungen für den Datensatz und die Konfigurationseingaben.
## Es konnte keine Verbindung zur KI hergestellt werden SageMaker
Dies deutet darauf hin, dass der Job die SageMaker KI-Dienstendpunkte nicht erreichen konnte. Überprüfen Sie die Netzwerkkonfigurationseinstellungen für den Verarbeitungsauftrag und die Virtual Private Cloud (VPC)-Konfiguration.
## Beispiel-Notebooks
Die folgenden Abschnitte enthalten Notizbücher, die Ihnen den Einstieg in die Verwendung von SageMaker Clarify, die Verwendung von Clarify für spezielle Aufgaben, einschließlich Aufgaben innerhalb eines verteilten Jobs, und für Computer Vision erleichtern sollen.
### Erste Schritte
Die folgenden Beispielnotizbücher zeigen, wie Sie SageMaker Clarify verwenden können, um mit Aufgaben zur Erklärbarkeit und Modellverzerrungen zu beginnen. Zu diesen Aufgaben gehören die Erstellung eines Auftrags zur Verarbeitung, das Trainieren eines Modells für Machine Learning (ML) und die Überwachung von Modellvorhersagen:
+ [Erklärbarkeit und Erkennung von Verzerrungen mit Amazon SageMaker Clarify — Verwenden Sie SageMaker Clarify](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-clarify/fairness_and_explainability/fairness_and_explainability.html), um einen Verarbeitungsjob zu erstellen, um Verzerrungen zu erkennen und Modellvorhersagen zu erklären.
+ [Überwachung von Verzerrungen und Abweichungen bei der Merkmalszuweisung Amazon SageMaker Clarify](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker_model_monitor/fairness_and_explainability/SageMaker-Model-Monitor-Fairness-and-Explainability.html) — Verwenden Sie Amazon SageMaker Model Monitor, um Verzerrungen und Abweichungen bei der Merkmalszuweisung im Laufe der Zeit zu überwachen.
+ So [lesen Sie einen Datensatz im Format JSON Lines in](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-clarify/fairness_and_explainability/fairness_and_explainability_jsonlines_format.html) einen SageMaker Clarif-Verarbeitungsauftrag ein.
+ [Verzerrungen mindern, ein anderes Modell ohne Vorurteile trainieren und es in das Modellregister aufnehmen — Verwenden Sie die](https://github.com/aws/amazon-sagemaker-examples/blob/master/end_to_end/fraud_detection/3-mitigate-bias-train-model2-registry-e2e.ipynb) [Synthetic Minority Oversampling Technique (SMOTE)](https://arxiv.org/pdf/1106.1813.pdf) und SageMaker Clarify, um die Verzerrung zu verringern, trainieren Sie ein anderes Modell und nehmen Sie dann das neue Modell in das Modellregister auf. Dieses BeispielNotebook zeigt auch, wie die neuen Modellartefakte, einschließlich Daten, Code und Modellmetadaten, in die Modellregistrierung aufgenommen werden. Dieses Notizbuch ist Teil einer Reihe, in der gezeigt wird, wie SageMaker Clarify in eine SageMaker KI-Pipeline integriert werden kann, die im [Architect beschrieben wird, und den vollständigen Lebenszyklus des maschinellen Lernens mit einem Blogbeitrag aufbauen](https://aws.amazon.com/blogs/machine-learning/architect-and-build-the-full-machine-learning-lifecycle-with-amazon-sagemaker/). AWS
### Sonderfälle
Die folgenden Notizbücher zeigen Ihnen, wie Sie SageMaker Clarify für spezielle Fälle verwenden, auch in Ihrem eigenen Container, und für Aufgaben zur Verarbeitung natürlicher Sprache:
+ [Fairness und Erklärbarkeit mit SageMaker Clarify (Bring Your Own Container) — Erstellen Sie Ihr eigenes](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-clarify/fairness_and_explainability/fairness_and_explainability_byoc.ipynb) Modell und Ihren eigenen Container, die in SageMaker Clarify integriert werden können, um Verzerrungen zu messen und einen Bericht zur Erklärbarkeitsanalyse zu erstellen. In diesem Beispielnotizbuch werden auch wichtige Begriffe vorgestellt und es wird gezeigt, wie Sie über Studio Classic auf den Bericht zugreifen können. SageMaker
+ [Fairness und Erklärbarkeit mit SageMaker Clarify Spark Distributed Processing](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-clarify/fairness_and_explainability/fairness_and_explainability_spark.ipynb) — Verwenden Sie verteilte Verarbeitung, um einen SageMaker Clarif-Job auszuführen, der die Verzerrung eines Datensatzes vor dem Training und die Verzerrung eines Modells nach dem Training misst. Dieses Beispielnotizbuch zeigt Ihnen auch, wie Sie eine Erklärung für die Bedeutung der Eingabefunktionen für die Modellausgabe erhalten und über Studio Classic auf den Bericht zur Erklärbarkeitsanalyse zugreifen können. SageMaker
+ [Erklärbarkeit mit SageMaker Clarify — Partielle Abhängigkeitsdiagramme (PDP)](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-clarify/fairness_and_explainability/explainability_with_pdp.html) — Verwenden Sie Clarify, um einen Bericht zur Erklärbarkeit SageMaker eines Modells zu erstellen PDPs und darauf zuzugreifen.
+ [Erläuterung der Textstimmungsanalyse mithilfe der Erklärbarkeit von SageMaker Clarify Natural Language Processing (NLP) — Verwenden Sie Clarify für die Stimmungsanalyse](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-clarify/text_explainability/text_explainability.html) von Text. SageMaker
+ Verwenden Sie Erklärbarkeit durch Computer Vision (CV) mit [Bildklassifizierung](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-clarify/computer_vision/image_classification/explainability_image_classification.html) und [Objekterkennung](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-clarify/computer_vision/object_detection/object_detection_clarify.html)
Es wurde verifiziert, dass diese Notizbücher in Amazon SageMaker Studio Classic laufen. Anweisungen zum Öffnen eines Notebooks in Studio Classic finden Sie unter [Erstellen oder öffnen Sie ein Amazon SageMaker Studio Classic-Notizbuch](notebooks-create-open.md). Wenn Sie aufgefordert werden, einen Kernel auszuwählen, wählen Sie **Python 3 (Data Science)**.
# Datenverzerrungen vor dem Training
Algorithmische Voreingenommenheit, Diskriminierung, Fairness und verwandte Themen wurden in verschiedenen Disziplinen wie Recht, Politik und Informatik untersucht. Ein Computersystem kann als voreingenommen angesehen werden, wenn es bestimmte Personen oder Personengruppen diskriminiert. Die Modelle des Machine Learnings, die diesen Anwendungen zugrunde liegen, lernen aus Daten, und diese Daten könnten Disparitäten oder andere inhärente Verzerrungen widerspiegeln. Beispielsweise sind das Trainingsdaten möglicherweise nicht ausreichend für verschiedene demografische Gruppen repräsentativ oder enthalten verzerrte Bezeichnungen. Die Modelle des Machine Learnings, die mit Datensätzen trainiert wurden, die diese Verzerrungen aufweisen, könnten sie am Ende lernen und diese Verzerrungen dann in ihren Vorhersagen reproduzieren oder sogar verschärfen. Der Bereich des Machine Learnings bietet die Möglichkeit, Verzerrungen zu beheben, indem sie in jeder Phase des ML-Lebenszyklus erkannt und gemessen werden. Sie können Amazon SageMaker Clarify verwenden, um festzustellen, ob die für Trainingsmodelle verwendeten Daten Verzerrungen kodieren.
Verzerrungen können vor dem Training und nach dem Training gemessen und nach der Bereitstellung von Modellen an Endpunkten zur Ableitung anhand von Ausgangswerten überwacht werden. Bias-Metriken vor dem Training dienen dazu, Verzerrungen in den Rohdaten zu erkennen und zu messen, bevor sie zum Trainieren eines Modells verwendet werden. Die verwendeten Metriken sind modellunabhängig, da sie nicht von Modellergebnissen abhängen. Es gibt jedoch unterschiedliche Fairness-Konzepte, die unterschiedliche Messgrößen der Voreingenommenheit erfordern. Amazon SageMaker Clarify bietet Bias-Metriken zur Quantifizierung verschiedener Fairness-Kriterien.
Weitere Informationen zu Bias-Metriken finden [Sie unter Erfahren Sie, wie Amazon SageMaker Clarify hilft, Bias- und [Fairnessmaßnahmen für Machine Learning im Finanzwesen](https://pages.awscloud.com/rs/112-TZM-766/images/Fairness.Measures.for.Machine.Learning.in.Finance.pdf) zu erkennen](https://aws.amazon.com/blogs/machine-learning/learn-how-amazon-sagemaker-clarify-helps-detect-bias).
## Amazon SageMaker klärt die Bedingungen für Voreingenommenheit und Fairness
SageMaker Clarify verwendet die folgende Terminologie, um Vorurteile und Fairness zu erörtern.
**Feature**
Eine einzelne messbare Eigenschaft oder ein Feature eines beobachteten Phänomens, das in einer Spalte für tabellarische Daten enthalten ist.
**Label (Bezeichnung)**
Funktion, die das Ziel für das Training eines Machine-Learning-Modells ist. Wird als *beobachtete Beschriftung* oder *beobachtetes Ergebnis* bezeichnet.
**Voraussichtliche Beschriftung**
Die vom Modell vorhergesagte Bezeichnung. Wird auch als *vorhergesagtes Ergebnis* bezeichnet.
**Beispiel**
Eine beobachtete Entität, die durch Featureswerte und Beschriftungswert beschrieben wird und in einer Zeile für Tabellendaten enthalten ist.
**Datensatz**
Eine Sammlung von Proben.
**Bias**
Ein Ungleichgewicht der Trainingsdaten oder des Prognoseverhaltens des Modells in Bezug auf verschiedene Gruppen, z. B. Alter oder Einkommensgruppe. Verzerrungen können auf die Daten oder den Algorithmus zurückzuführen sein, die zum Trainieren Ihres Modells verwendet wurden. Wenn ein ML-Modell beispielsweise hauptsächlich auf Daten von Personen mittleren Alters trainiert wird, ist es möglicherweise weniger genau, wenn Vorhersagen getroffen werden, an denen jüngere und ältere Menschen beteiligt sind.
**Bias-Metrik**
Eine Funktion, die numerische Werte zurückgibt, die den Grad einer potenziellen Verzerrung angeben.
**Bericht über Verzerrungen**
Eine Sammlung von Bias-Metriken für einen bestimmten Datensatz oder eine Kombination aus einem Datensatz und einem Modell.
**Positive Beschriftungswerte**
Kennzeichnen Sie Werte, die für eine in einer Stichprobe beobachtete demografische Gruppe günstig sind. Mit anderen Worten, bezeichnet eine Stichprobe als *positiv*.
**Negative Beschriftungswerte**
Kennzeichnen Sie Werte, die für eine in einer Stichprobe beobachtete demografische Gruppe ungünstig sind. Mit anderen Worten, bezeichnet eine Stichprobe als *negativ*.
**Gruppenvariable**
Kategorische Spalte des Datensatzes, der zur Bildung von Untergruppen für die Messung der bedingten demografischen Disparität (CDD) verwendet wird. Nur für diese Metrik im Hinblick auf das Simpson-Paradoxon erforderlich.
**Facet**
Eine Spalte oder ein Feature, das die Attribute enthält, anhand derer die systematische Abweichung gemessen wird.
**Facettenwert**
Die Featureswerte von Attributen, die aufgrund von Verzerrungen bevorzugt oder negativ bewertet werden können.
**Prognostizierte Wahrscheinlichkeit**
Die vom Modell vorhergesagte Wahrscheinlichkeit, dass eine Stichprobe zu einem positiven oder negativen Ergebnis führt.
## Beispiel-Notebooks
Amazon SageMaker Clarify bietet das folgende Muster-Notizbuch zur Erkennung von Verzerrungen an:
+ [Erklärbarkeit und Erkennung von Verzerrungen mit Amazon SageMaker Clarify](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-clarify/fairness_and_explainability/fairness_and_explainability.html) — Verwenden Sie SageMaker Clarify, um einen Verarbeitungsjob zur Erkennung von Verzerrungen und zur Erklärung von Modellvorhersagen mit Feature-Attributionen zu erstellen.
Es wurde verifiziert, dass dieses Notizbuch nur in Amazon SageMaker Studio ausgeführt werden kann. Anweisungen zum Öffnen eines Notizbuchs in Amazon SageMaker Studio finden Sie unter[Erstellen oder öffnen Sie ein Amazon SageMaker Studio Classic-Notizbuch](notebooks-create-open.md). Wenn Sie aufgefordert werden, einen Kernel auszuwählen, wählen Sie **Python 3 (Data Science)**.
**Topics**
+ [Amazon SageMaker klärt die Bedingungen für Voreingenommenheit und Fairness](#clarify-bias-and-fairness-terms)
+ [Beispiel-Notebooks](#clarify-data-bias-sample-notebooks)
+ [Messwerte zu Verzerrungen vor dem Training](clarify-measure-data-bias.md)
+ [Generieren Sie in Studio Berichte über Verzerrungen bei Daten vor dem Training SageMaker](clarify-data-bias-reports-ui.md)
# Messwerte zu Verzerrungen vor dem Training
Die Messung von Verzerrungen in ML-Modellen ist ein erster Schritt zur Minderung von Verzerrungen. Jedes Maß für Verzerrungen entspricht einem anderen Begriff von Fairness. Selbst die Berücksichtigung einfacher Fairnesskonzepte führt zu vielen verschiedenen Maßnahmen, die in verschiedenen Kontexten anwendbar sind. Denken Sie zum Beispiel an Fairness in Bezug auf das Alter und der Einfachheit halber daran, dass die beiden Bevölkerungsgruppen mittleren Alters und die übrigen Altersgruppen die beiden relevanten demografischen Feature sind, die als *Facetten* bezeichnet werden. Im Fall eines ML-Modells für die Kreditvergabe möchten wir vielleicht, dass Kredite für kleine Unternehmen an die gleiche Anzahl von Personen aus beiden Bevölkerungsgruppen vergeben werden. Oder bei der Bearbeitung von Stellenbewerbern möchten wir vielleicht, dass für jede demografische Gruppe die gleiche Anzahl von Auftragnehmer eingestellt wird. Bei diesem Ansatz kann jedoch davon ausgegangen werden, dass sich für diese Stellen die gleiche Anzahl von Personen aus beiden Altersgruppen bewerben, sodass wir möglicherweise von der Anzahl der Bewerbungen abhängig machen sollten. Außerdem sollten wir vielleicht nicht prüfen, ob die gleiche Anzahl von Bewerbern gilt, sondern ob wir die gleiche Anzahl qualifizierter Bewerber haben. Oder wir können Fairness als eine gleiche Annahmequote qualifizierter Bewerber für beide Altersgruppen oder eine gleiche Ablehnungsquote von Bewerbern oder beides betrachten. Sie können Datensätze mit unterschiedlichen Datenanteilen zu den interessierenden Attributen verwenden. Dieses Ungleichgewicht kann dazu führen, dass die von Ihnen gewählte Messgröße für die systematische Messgröße uneinheitlich ist. Die Modelle sind bei der Klassifizierung einer Facette möglicherweise genauer als bei der anderen. Daher müssen Sie Bias-Metriken wählen, die konzeptionell für die Anwendung und die Situation angemessen sind.
Wir verwenden die folgende Notation, um die Bias-Metriken zu erörtern. Das hier beschriebene konzeptionelle Modell dient der binären Klassifikation, bei der Ereignisse in ihrem Stichprobenraum so gekennzeichnet werden, dass sie nur zwei mögliche Ergebnisse haben, die als positiv (mit dem Wert 1) und negativ (mit dem Wert 0) bezeichnet werden. Dieser Rahmen lässt sich in der Regel auf einfache Weise auf eine Klassifizierung nach mehreren Kategorien oder bei Bedarf auf Fälle mit kontinuierlich bewerteten Ergebnissen ausdehnen. Bei der binären Klassifikation werden Ergebnissen, die in einem Rohdatensatz für eine bevorzugte Facet *a* und für eine benachteiligte Facet *d* aufgezeichnet wurden, positive und negative Markierungen zugewiesen. Diese Kennzeichnungen y werden als *beobachtete Beschriftungen* bezeichnet, um sie von den *vorhergesagten Beschriftungen* y' zu unterscheiden, die von einem Modell für Machine Learning während der Trainings- oder Inferenzphase des ML-Lebenszyklus zugewiesen werden. Diese Bezeichnungen werden verwendet, um die Wahrscheinlichkeitsverteilungen Pa(y) and Pd(y) für ihre jeweiligen Facetnergebnisse zu definieren.
+ Beschriftungen:
+ y steht für die n beobachteten Beschriftungen für Ereignisergebnisse in einem Trainingsdatensatz.
+ y' steht für die von einem trainierten Modell vorhergesagten Markierungen für die n beobachteten Markierungen im Datensatz.
+ Ergebnisse:
+ Ein positives Ergebnis (mit dem Wert 1) für eine Stichprobe, z. B. eine Annahme eines Antrags.
+ n(1) ist die Anzahl der beobachteten Markierungen für positive Ergebnisse (Zulassungen).
+ n'(1) ist die Anzahl der vorhergesagten Kennzeichnungen für positive Ergebnisse (Akzeptanz).
+ Ein negatives Ergebnis (mit dem Wert 0) für eine Stichprobe, z. B. eine Ablehnung eines Antrags.
+ n(0) ist die Anzahl der beobachteten Markierungen für negative Ergebnisse (Ablehnungen).
+ n'(0) ist die Anzahl der vorhergesagten Markierungen für negative Ergebnisse (Ablehnungen).
+ Facetnwerte:
+ Facet *a* – Der Merkmalswert, der eine demografische Gruppe definiert, die von Vorurteilen bevorzugt wird.
+ na ist die Anzahl der beobachteten Beschriftungen für den bevorzugten Facetnwert: na = na(1) \$1 na(0) die Summe der positiven und negativen beobachteten Beschriftungen für den Wert Facet *a*.
+ n' a ist die Anzahl der vorhergesagten Beschriftungen für den bevorzugten Facetnwert: n'a = n'a(1) \$1 n'a(0) ist die Summe der positiven und negativen Kennzeichnungen für das vorhergesagte Ergebnis für den Facetnwert *a*. Beachten Sie n'a = na.
+ facet *d* – Der Merkmalswert, der eine demografische Gruppe definiert, die tendenziell benachteiligt ist.
+ nd ist die Anzahl der beobachteten Kennzeichnungen für den Facetnwert mit negativer Wirkung: nd = nd(1) \$1 nd(0) ist die Summe der beobachteten positiven und negativen Kennzeichnungen für den Facetnwert *d*.
+ n'd ist die Anzahl der vorhergesagten Markierungen für den Wert der negativen Facet: n'd = n'd(1) \$1 n'd(0) die Summe der positiven und negativen vorhergesagten Markierungen für den Facetnwert *d*. Beachten Sie n'd = nd.
+ Wahrscheinlichkeitsverteilungen für die Ergebnisse der markierten Facetndaten:
+ Pa(y) ist die Wahrscheinlichkeitsverteilung der beobachteten Markierungen für Facet *a*. Bei binär markierten Daten ergibt sich diese Verteilung aus dem Verhältnis der Anzahl der Stichproben in Facet *a* mit positiven Ergebnissen zur Gesamtzahl, Pa(y1) = na(1)/ na, und dem Verhältnis der Anzahl der Proben mit negativen Ergebnissen zur Gesamtzahl, Pa(y0) = na(0)/ na.
+ P d(y) ist die Wahrscheinlichkeitsverteilung der beobachteten Markierungen für Facet *d*. Bei binär markierten Daten ergibt sich diese Verteilung aus der Anzahl der mit positiven Ergebnissen markierten Stichproben in der Facette *d* zur Gesamtzahl, Pd(y1) = nd(1)/ nd, und dem Verhältnis der Anzahl der Proben mit negativen Ergebnissen zur Gesamtzahl, Pd(y0) = nd(0)/ nd.
Modelle, die mit Daten trainiert wurden, die aufgrund demografischer Unterschiede verzerrt sind, könnten daraus lernen und diese sogar verschärfen. Um Verzerrungen in den Daten zu identifizieren, bevor Ressourcen aufgewendet werden, um Modelle darauf zu trainieren, stellt SageMaker Clarify Metriken zur Datenverzerrung bereit, die Sie vor dem Training anhand von Rohdatensätzen berechnen können. Alle Metriken vor dem Training sind modellunabhängig, da sie nicht von den Modellausgaben abhängen und daher für jedes Modell gültig sind. Die erste Bias-Metrik untersucht das Ungleichgewicht der Facetten, nicht aber die Ergebnisse. Sie bestimmt, inwieweit die Menge der Trainingsdaten für verschiedene Facetten repräsentativ ist, wie es für die Anwendung gewünscht wird. Bei den übrigen Bias-Metriken wird die Verteilung der Ergebniskennzeichnungen für die Facetten *a* und *d* in den Daten auf unterschiedliche Weise verglichen. Die Kennzahlen, die über negative Werte hinausgehen, können negative Verzerrungen erkennen. Die folgende Tabelle enthält einen Spickzettel zur schnellen Anleitung und Links zu den Messwerten für Verzerrungen vor dem Training.
Messwerte zu Verzerrungen vor dem Training
| Bias-Metrik | Description | Beispiel für eine Frage | Interpretieren von metrischen Werten |
| --- | --- | --- | --- |
| [Ungleichgewicht zwischen den Klassen (CI)](clarify-bias-metric-class-imbalance.md) | Misst das Ungleichgewicht in der Anzahl der Elemente zwischen verschiedenen Facettenwerten. | Könnte es zu altersbedingten Vorurteilen kommen, weil nicht genügend Daten für die demografische Gruppe außerhalb des mittleren Alters zur Verfügung stehen? | Normalisierter Bereich: [-1, \$11] Interpretation: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/clarify-measure-data-bias.html) |
| [Unterschied in den Proportionen der Beschriftungen (DPL)](clarify-data-bias-metric-true-label-imbalance.md) | Misst das Ungleichgewicht positiver Ergebnisse zwischen verschiedenen Facettenwerten. | Könnte es aufgrund einer verzerrten Kennzeichnung von Facettenwerten in den Daten zu altersbedingten Verzerrungen bei ML-Vorhersagen kommen? | Bereich für normalisierte binäre und mehrkategoriale Facettenbezeichnungen: [-1, \$11] Bereich für fortlaufende Beschriftungen: (-∞, \$1∞) Interpretation [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/clarify-measure-data-bias.html) |
| [Kullback-Leibler-Divergenz (KL)](clarify-data-bias-metric-kl-divergence.md) | Misst, wie stark die Ergebnisverteilungen verschiedener Facetten entropisch voneinander abweichen. | Wie unterschiedlich sind die Verteilungen der Ergebnisse bei Kreditanträgen für verschiedene demografische Gruppen? | Bereich für binär, mehrkategorisch, kontinuierlich: [0, \$1∞) Interpretation [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/clarify-measure-data-bias.html) |
| [Jensen-Shannon-Divergenz (JS)](clarify-data-bias-metric-jensen-shannon-divergence.md) | Misst, wie stark die Ergebnisverteilungen verschiedener Facetten entropisch voneinander abweichen. | Wie unterschiedlich sind die Verteilungen der Ergebnisse bei Kreditanträgen für verschiedene demografische Gruppen? | Bereich für binär, mehrkategorisch, kontinuierlich: [0, \$1∞) Interpretation [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/clarify-measure-data-bias.html) |
| [Lp-Norm (LP)](clarify-data-bias-metric-lp-norm.md) | Misst einen Unterschied nach der P-Norm zwischen unterschiedlichen demografischen Verteilungen der Ergebnisse, die mit verschiedenen Facetten in einem Datensatz verknüpft sind. | Wie unterschiedlich sind die Verteilungen der Ergebnisse bei Kreditanträgen für verschiedene demografische Gruppen? | Bereich für binär, mehrkategorisch, kontinuierlich: [0, \$1∞) Interpretation [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/clarify-measure-data-bias.html) |
| [Gesamtvariationsdistanz (TVD)](clarify-data-bias-metric-total-variation-distance.md) | Misst die Hälfte des L1-Normunterschieds zwischen unterschiedlichen demografischen Verteilungen der Ergebnisse, die mit verschiedenen Facetten in einem Datensatz verknüpft sind. | Wie unterschiedlich sind die Verteilungen der Ergebnisse bei Kreditanträgen für verschiedene Bevölkerungsgruppen? | Bereich für binäre, mehrkategoriale und kontinuierliche Ergebnisse: [0, \$1∞) [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/clarify-measure-data-bias.html) |
| [Kolmogorow-Smirnow (KS)](clarify-data-bias-metric-kolmogorov-smirnov.md) | Misst die maximale Divergenz zwischen den Ergebnissen bei Verteilungen für verschiedene Facetten in einem Datensatz. | Bei welchen Ergebnissen der Hochschulbewerbung bestehen die größten Unterschiede nach demografischen Gruppen? | Bereich der KS-Werte für binäre, mehrkategoriale und kontinuierliche Ergebnisse: [0, \$11][\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/clarify-measure-data-bias.html) |
| [Bedingte demografische Disparität (CDD)](clarify-data-bias-metric-cddl.md) | Misst die Ungleichheit der Ergebnisse zwischen verschiedenen Facetten insgesamt, aber auch nach Untergruppen. | Haben einige Gruppen einen höheren Anteil an Ablehnungen aufgrund von Hochschulzulassungsergebnissen als ihr Anteil an Zulassungen? | CDD-Bereich: [-1, \$11] [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/clarify-measure-data-bias.html) |
Weitere Informationen zu Bias-Metriken finden Sie unter [Fairness Measures for Machine Learning in Finance](https://pages.awscloud.com/rs/112-TZM-766/images/Fairness.Measures.for.Machine.Learning.in.Finance.pdf).
**Topics**
+ [Ungleichgewicht zwischen den Klassen (CI)](clarify-bias-metric-class-imbalance.md)
+ [Unterschied in den Proportionen der Beschriftungen (DPL)](clarify-data-bias-metric-true-label-imbalance.md)
+ [Kullback-Leibler-Divergenz (KL)](clarify-data-bias-metric-kl-divergence.md)
+ [Jensen-Shannon-Divergenz (JS)](clarify-data-bias-metric-jensen-shannon-divergence.md)
+ [Lp-Norm (LP)](clarify-data-bias-metric-lp-norm.md)
+ [Gesamtvariationsdistanz (TVD)](clarify-data-bias-metric-total-variation-distance.md)
+ [Kolmogorow-Smirnow (KS)](clarify-data-bias-metric-kolmogorov-smirnov.md)
+ [Bedingte demografische Disparität (CDD)](clarify-data-bias-metric-cddl.md)
# Ungleichgewicht zwischen den Klassen (CI)
Eine Verzerrung des Klassenungleichgewichts (CI) tritt auf, wenn ein Facettenwert *d* im Vergleich zu einer anderen Facette *a* im Datensatz weniger Trainingsstichproben aufweist. Das liegt daran, dass Modelle bevorzugt an die größeren Facetten auf Kosten der kleineren Facetten angepasst werden, was zu einem höheren Trainingsfehler für Facette *d* führen kann. Bei Modellen besteht auch ein höheres Risiko, dass kleinere Datensätze zu stark angepasst werden, was zu größeren Testfehlern für Facette *d* führen kann. Denken Sie an das Beispiel, in dem ein Modell für Machine Learning hauptsächlich auf Daten von Personen mittleren Alters trainiert wird (Facette a). Es könnte weniger genau sein, wenn Vorhersagen getroffen werden, an denen jüngere und ältere Menschen beteiligt sind (Facette d).
Die Formel für das (normalisierte) Facetten-Ungleichgewichtsmaß:
CI = (na – nd)/(na \$1 nd)
Wobei na die Anzahl der Mitglieder der Facette *a* und nd die Zahl der Facette *d* ist. Ihre Werte liegen im Bereich des Intervalls [-1, 1].
+ Positive CI-Werte bedeuten, dass die Facette *a* mehr Trainingsstichproben im Datensatz enthält, und ein Wert von 1 gibt an, dass die Daten nur Mitglieder der Facette *a* enthalten.
+ CI-Werte nahe Null deuten auf eine gleichmäßigere Verteilung der Mitglieder zwischen den Facetten hin, und ein Wert von Null gibt eine vollkommen gleiche Verteilung zwischen den Facetten an und steht für eine ausgewogene Verteilung der Stichproben in den Trainingsdaten.
+ Negative CI-Werte bedeuten, dass die Facette *d* mehr Trainingsstichproben im Datensatz enthält, und ein Wert von -1 bedeutet, dass die Daten nur Mitglieder der Facette *d* enthalten.
+ CI-Werte, die sich in der Nähe eines der Extremwerte von -1 oder 1 befinden, sind sehr unausgewogen und bergen ein erhebliches Risiko, dass verzerrte Vorhersagen getroffen werden.
Wenn festgestellt wird, dass zwischen den Facetten ein erhebliches Facettenungleichgewicht besteht, sollten Sie die Stichprobe neu ausbalancieren, bevor Sie mit dem Schulen von Modellen auf ihr fortfahren.
# Unterschied in den Proportionen der Beschriftungen (DPL)
Der Unterschied in den Beschriftungsanteilen (DPL) vergleicht den Anteil der beobachteten Ergebnisse mit positiven Kennzeichnungen für Facette *d* mit dem Anteil der beobachteten Ergebnisse mit positiven Kennzeichnungen für Facette in *a* Trainingsdatensatz. Sie könnten es beispielsweise verwenden, um den Anteil von Personen mittleren Alters (Facette *a*) und anderen Altersgruppen (Facette *d*) zu vergleichen, denen Finanzkredite gewährt wurden. Modelle für Machine Learning versuchen, die Entscheidungen im Zusammenhang mit Trainingsdaten so genau wie möglich nachzuahmen. Ein Modell für Machine Learning, das auf einem Datensatz mit einem hohen DPL trainiert wurde, wird also wahrscheinlich dasselbe Ungleichgewicht in seinen future Prognosen widerspiegeln.
Die Formel für den Unterschied in den Proportionen der Beschriftungen lautet wie folgt:
DPL = (qa – qd)
Wobei Folgendes gilt:
+ qa = na(1)/na ist der Anteil der Facette *a*, die einen beobachteten Beschriftungswert von 1 haben. Zum Beispiel der Anteil der Bevölkerungsgruppe mittleren Alters, denen Kredite genehmigt werden. Dabei steht na(1) für die Anzahl der Mitglieder der Facette *a*, die ein positives Ergebnis erzielen und na für die Anzahl der Mitglieder der Facette *a*.
+ qd = nd(1)/nd ist der Anteil der Facette *d*, die einen beobachteten Beschriftungswert von 1 haben. Zum Beispiel der Anteil der Personen außerhalb der Bevölkerungsgruppe mittleren Alters, denen Kredite gewährt werden. Dabei steht nd(1) für die Anzahl der Mitglieder der Facette *d*, die ein positives Ergebnis erzielen, und nd für die Anzahl der Mitglieder der Facette *d*.
Wenn DPL nahe genug an 0 liegt, dann sagen wir, dass die *demografische Parität* erreicht wurde.
Bei binären und mehrkategorialen Facettenbeschriftungen bewegen sich die DPL-Werte über das Intervall (-1, 1). Für fortlaufende Beschriftungen legen wir einen Schwellenwert fest, um die Beschriftungen auf binäre Werte zu reduzieren.
+ Positive DPL-Werte weisen darauf hin, dass Facette *a* ist im Vergleich zu Facette *d* einen höheren Anteil an positiven Ergebnissen aufweist.
+ Werte von DPL nahe Null deuten auf einen gleichmäßigeren Anteil positiver Ergebnisse zwischen den Facetten hin, und ein Wert von Null weist auf eine perfekte demografische Parität hin.
+ Negative DPL-Werte deuten darauf hin, dass Facette *d* im Vergleich zu Facette *a* einen höheren Anteil an positiven Ergebnissen aufweist.
Ob ein hohes Ausmaß an DPL problematisch ist oder nicht, ist von Situation zu Situation unterschiedlich. In einem problematischen Fall könnte eine hohe DPL ein Hinweis auf zugrundeliegende Probleme in den Daten sein. Ein Datensatz mit einem hohen DPL könnte beispielsweise historische Vorurteile oder Vorurteile gegenüber altersbedingten demografischen Gruppen widerspiegeln, die für ein Modell nicht erwünscht wären, zu lernen.
# Kullback-Leibler-Divergenz (KL)
Die Kullback-Leibler-Divergenz (KL) misst, wie stark die beobachtete Kennzeichnungsverteilung der Facette *a*, Pa(y), von der Verteilung der Facette *d*, Pd(y) abweicht. Sie wird auch als relative Entropie von Pa(y) in Bezug auf Pd(y) bezeichnet und quantifiziert die Menge an Information, die beim Übergang von Pa(y) zu Pd(y) verloren geht.
Die Formel für die Kullback-Leibler-Divergenz lautet wie folgt:
KL(Pa \$1\$1 Pd) = ∑yPa(y)\$1log[Pa(y)/Pd(y)]
Es ist die Erwartung der logarithmischen Differenz zwischen den Wahrscheinlichkeiten Pa(y) und Pd(y), wobei die Erwartung mit den Wahrscheinlichkeiten Pa(y) gewichtet wird. Dies ist kein echter Abstand zwischen den Verteilungen, da er asymmetrisch ist und die Dreiecksungleichung nicht erfüllt. Die Implementierung verwendet natürliche Logarithmen und gibt KL in Einheiten von Nats an. Die Verwendung verschiedener logarithmischer Basen führt zu proportionalen Ergebnissen, jedoch in unterschiedlichen Einheiten. Wenn Sie beispielsweise die Basis 2 verwenden, erhalten Sie KL in Biteinheiten.
Nehmen wir beispielsweise an, dass eine Gruppe von Kreditantragstellern eine Bewilligungsquote von 30% (Facette *d*) hat und dass die Genehmigungsquote für andere Antragsteller (Facette *a*) bei 80% liegt. Die Kullback-Leibler-Formel gibt Ihnen die Abweichung der Labelverteilung zwischen Facette *a* und Facette *d* wie folgt:
KL = 0,8\$1ln (0,8/0,3) \$1 0,2\$1ln (0,2/0,7) = 0,53
Die Formel enthält hier zwei Begriffe, da Beschriftungen in diesem Beispiel binär sind. Diese Maßnahme kann zusätzlich zu binären auch auf mehrere Beschriftungen angewendet werden. Gehen Sie beispielsweise in einem Szenario mit Hochschulzulassungen davon aus, dass einem Bewerber eine von drei Kategorien zugewiesen wird: y i = \$1y0, y1, y2\$1 = \$1abgelehnt, auf der Warteliste, akzeptiert\$1.
Der Wertebereich für die KL-Metrik für binäre, mehrkategoriale und kontinuierliche Ergebnisse ist [0, \$1∞).
+ Werte nahe Null bedeuten, dass die Ergebnisse für die verschiedenen Facetten ähnlich verteilt sind.
+ Positive Werte bedeuten, dass die Labelverteilungen divergieren. Je positiver, desto größer die Divergenz.
# Jensen-Shannon-Divergenz (JS)
Die Jensen-Shannon-Divergenz (JS) misst, wie stark die Beschriftungsverteilungen verschiedener Facetten entropisch voneinander abweichen. Sie basiert auf der Kullback-Leibler-Divergenz, ist aber symmetrisch.
Die Formel für die Jensen-Shannon-Divergenz lautet wie folgt:
JS = ½ \$1 [KL (Pa \$1\$1 P) \$1 KL (P \$1\$1 Pd)]
Dabei ist P = ½ (Pa \$1 Pd), die durchschnittliche Labelverteilung über die Facetten *a* und *d*.
Der Bereich der JS-Werte für binäre, kontinuierliche Ergebnisse mit mehreren Kategorien ist [0, ln (2)).
+ Werte nahe Null bedeuten, dass die Beschriftungen ähnlich verteilt sind.
+ Positive Werte bedeuten, dass die Labelverteilungen divergieren. Je positiver, desto größer die Divergenz.
Diese Metrik gibt an, ob bei einem der Beschriftungen in Bezug auf die Facetten eine große Divergenz besteht.
# Lp-Norm (LP)
Die Lp-Norm (LP) misst den P-Norm-Abstand zwischen den Facettenverteilungen der beobachteten Markierungen in einem Trainingsdatensatz. Diese Metrik ist nicht negativ und kann daher keine umgekehrte Verzerrung erkennen.
Die Formel für die Lp-Norm lautet wie folgt:
Lp(Pa, Pd) = ( ∑y\$1\$1Pa – Pd\$1\$1p)1/p
Wobei der P-Norm-Abstand zwischen den Punkten x und y wie folgt definiert ist:
Lp(x, y) = (\$1x1-y1\$1p \$1 \$1x2-y2\$1p \$1 … \$1\$1xn-yn\$1p)1/p
Die 2-Norm ist die euklidische Norm. Nehmen wir an, Sie haben eine Ergebnisverteilung mit drei Kategorien, z. B. yi = \$1y0, y1, y2\$1 = \$1akzeptiert, auf die Warteliste gesetzt, abgelehnt\$1 in einem Szenario mit mehreren Kategorien für Hochschulzulassungen. Sie nehmen die Summe der Quadrate der Differenzen zwischen den Ergebniszahlen für die Facetten *a* und *d*. Die resultierende euklidische Entfernung wird wie folgt berechnet:
L2(Pa, Pd) = [(na(0) – nd(0))2 \$1 (na(1) – nd(1))2 \$1 (na(2) – nd(2))2]1/2
Wobei Folgendes gilt:
+ na(i) ist die Zahl der Ergebnisse der Kategorie i in Facet *a*: zum Beispiel ist n a(0) die Anzahl der Akzeptanzzahlen in Facet *a*.
+ nd(i) ist die Anzahl der Ergebnisse der Kategorie i in Facet *d*: n d(2) ist beispielsweise die Anzahl der Ablehnungen in der Facet *d*.
Der Bereich der LP-Werte für binäre, mehrkategoriale und kontinuierliche Ergebnisse ist [0, √2), wobei:
+ Werte nahe Null bedeuten, dass die Beschriftungen ähnlich verteilt sind.
+ Positive Werte bedeuten, dass die Beschriftungsverteilungen divergieren. Je positiver, desto größer die Divergenz.
# Gesamtvariationsdistanz (TVD)
Die Metrik „Total Variation Distance Data Bias“ (TVD) entspricht der Hälfte der L1-Norm. Der TVD ist der größtmögliche Unterschied zwischen den Wahrscheinlichkeitsverteilungen für Beschriftungsergebnisse der Facetn *a* und *d*. Die L1-Norm ist die Hamming-Distanz, eine Metrik, die verwendet wird, um zwei binäre Datenketten zu vergleichen, indem sie bestimmt, wie viele Ersetzungen mindestens erforderlich sind, um eine Zeichenfolge in eine andere umzuwandeln. Wenn es sich bei den Zeichenketten um Kopien voneinander handeln sollte, bestimmt sie die Anzahl der Fehler, die beim Kopieren aufgetreten sind. Im Kontext der Erkennung von Verzerrungen quantifiziert TVD, wie viele Ergebnisse in Facet *a* geändert werden müssten, damit sie den Ergebnissen in Facet *d* entsprechen.
Die Formel für die gesamte Streuungsdistanz lautet wie folgt:
TVD = ½\$1L1(Pa, Pd)
Nehmen wir beispielsweise an, Sie haben eine Ergebnisverteilung mit drei Kategorien, yi = \$1y0, y1, y2\$1 = \$1akzeptiert, auf die Warteliste gesetzt, abgelehnt\$1, in einem Szenario mit mehreren Kategorien für Hochschulzulassungen. Sie verwenden die Differenzen zwischen der Anzahl der Facetn *a* und *d* für jedes Ergebnis, um den TVD zu berechnen. Das Ergebnis ist wie folgt:
L1(Pa, Pd) = \$1na(0) – nd(0)\$1 \$1 \$1na(1) – nd(1)\$1 \$1 \$1na(2) – nd(2)\$1
Wobei Folgendes gilt:
+ na(i) ist die Zahl der Ergebnisse der Kategorie i in Facet *a*: zum Beispiel ist n a(0) die Anzahl der Akzeptanzzahlen in Facet *a*.
+ nd(i) ist die Anzahl der Ergebnisse der Kategorie i in Facet d: n d (2) ist beispielsweise die Anzahl der Ablehnungen in der Facet *d*.
Der Bereich der TVD-Werte für binäre, mehrkategoriale und kontinuierliche Ergebnisse ist [0, 1), wobei:
+ Werte nahe Null bedeuten, dass die Beschriftungen ähnlich verteilt sind.
+ Positive Werte bedeuten, dass die Beschriftungsverteilungen divergieren. Je positiver, desto größer die Divergenz.
# Kolmogorow-Smirnow (KS)
Die Kolmogorov-Smirnov-Bias-Metrik (KS) entspricht der maximalen Divergenz zwischen Beschriftungen in den Verteilungen für die Facetn *a* und *d* eines Datensatzes. Der von SageMaker Clarify durchgeführte KS-Test mit zwei Stichproben ergänzt die anderen Messgrößen für das Ungleichgewicht auf dem Etikett, indem er das unausgewogenste Etikett ermittelt.
Die Formel für die Kolmogorov-Smirnov-Metrik lautet wie folgt:
KS = max(\$1Pa(y) – Pd(y)\$1)
Nehmen wir zum Beispiel an, dass eine Gruppe von Bewerbern (Facet *a*) für ein College mit 40%, 40% bzw. 20% abgelehnt, auf die Warteliste gesetzt oder angenommen wurde, und dass diese Quoten für andere Bewerber (Facet *d*) bei 20%, 10%, 70% liegen. Dann lautet der Metrikwert des Kolmogorov-Smirnov-Bias wie folgt:
KS = max (\$10,4-0,2\$1, \$10,4-0,1\$1, \$10,2-0,7\$1) = 0,5
Dies sagt uns, dass die maximale Divergenz zwischen den Facetnverteilungen 0,5 beträgt und sich auf die Akzeptanzraten auswirkt. Die Gleichung enthält drei Begriffe, da es sich bei den Bezeichnungen um mehrere Klassen mit Kardinalität drei handelt.
Der Bereich der LP-Werte für binäre, mehrkategoriale und kontinuierliche Ergebnisse ist [0, \$11], wobei:
+ Werte nahe Null deuten darauf hin, dass die Beschriftungen in allen Ergebniskategorien gleichmäßig auf die Facetn verteilt waren. Beispielsweise erhielten beide Facetn, bei denen ein Kredit beantragt wurde, jeweils 50% der Zusagen und 50% der Ablehnungen.
+ Werte in der Nähe von eins deuten darauf hin, dass sich die Bezeichnungen für ein Ergebnis alle in einer Facet befanden. Beispielsweise erhielt Facet *a* 100% der Akzeptanzwerte und Facet *d* keine.
+ Intermittierende Werte geben den relativen Grad des maximalen Ungleichgewichts bei der Kennzeichnung an.
# Bedingte demografische Disparität (CDD)
Die Metrik zur demografischen Disparität (DD) bestimmt, ob bei einer Facet ein größerer Anteil der abgelehnten Ergebnisse im Datensatz als bei den akzeptierten Ergebnissen besteht. Im binären Fall, in dem zwei Facetn, beispielsweise Männer und Frauen, den Datensatz bilden, wird die benachteiligte als Facet *d* und die bevorzugte als Facet *a* bezeichnet. Wenn beispielsweise im Fall von Hochschulzulassungen 46% der abgelehnten Bewerberinnen und nur 32% der zugelassenen Bewerber weibliche Bewerber ausmachten, sagen wir, dass es *demografische Unterschiede* gibt, weil die Rate, mit der Frauen abgelehnt wurden, die Rate, mit der sie aufgenommen wurden, übersteigt. Bewerberinnen werden in diesem Fall als Facet *a* bezeichnet. Wenn die männlichen Bewerber 54% der abgelehnten und 68% der zugelassenen Bewerber ausmachten, dann besteht in dieser Hinsicht kein demografischer Unterschied, da die Ablehnungsquote geringer ist als die Zulassungsquote. Männliche Bewerber werden in diesem Fall als Facet *a* bezeichnet.
Die Formel für die demografische Disparität in Bezug auf die benachteiligte Facet *d* lautet wie folgt:
DDd = nd(0)/n(0) – nd(1)/n(1) = PdR(y0) – PdA(y1)
Wobei Folgendes gilt:
+ n(0) = na(0) \$1 nd(0) ist die Gesamtzahl der abgelehnten Ergebnisse im Datensatz für die bevorzugte Facet *a* und die benachteiligte Facet *d*.
+ n(1) = na(1) \$1 nd(1) ist die Gesamtzahl der akzeptierten Ergebnisse im Datensatz für die bevorzugte Facet *a* und die benachteiligte Facet *d*.
+ PdR(y0) ist der Anteil der abgelehnten Ergebnisse (mit dem Wert 0) in Facet *d*.
+ PdA(y1) ist der Anteil der akzeptierten Ergebnisse (Wert 1) in Facet *d*.
Für das Beispiel der Hochschulzulassung beträgt die demografische Disparität für Frauen DDd = 0.46 – 0.32 = 0.14. Für Männer DDa = 0.54 – 0.68 = – 0.14.
Um das Simpson-Paradoxon auszuschließen, ist eine CDD-Metrik (bedingte demografische Disparität) erforderlich, die DD anhand von Attributen konditioniert, die eine Schicht von Untergruppen im Datensatz definieren. Die Umgruppierung kann Aufschluss über die Ursache offensichtlicher demografischer Disparitäten bei benachteiligten Facetn geben. Der klassische Fall trat bei den Zulassungen in Berkeley auf, wo Männer insgesamt häufiger aufgenommen wurden als Frauen. Die Statistiken für diesen Fall wurden in den Beispielberechnungen von DD verwendet. Bei der Untersuchung der Untergruppen der einzelnen Abteilungen wurde jedoch gezeigt, dass Frauen höhere Zulassungsquoten aufwiesen als Männer, wenn sie nach Fachbereichen unterschieden werden. Die Erklärung dafür war, dass sich Frauen in Abteilungen mit niedrigeren Zulassungsquoten beworben hatten als Männer. Die Untersuchung der Annahmequoten nach Untergruppen ergab, dass Frauen in den Abteilungen mit niedrigeren Annahmequoten tatsächlich häufiger aufgenommen wurden als Männer.
Die CDD-Metrik liefert ein einziges Maß für alle Disparitäten, die in den durch ein Attribut eines Datensatzes definierten Untergruppen gefunden wurden, indem deren Durchschnitt gebildet wird. Sie ist definiert als gewichteter Durchschnitt der demografischen Disparitäten (DDi) für jede der Untergruppen, wobei die Disparität jeder Untergruppe proportional zur Anzahl der darin enthaltenen Beobachtungen gewichtet wird. Die Formel für die bedingte demografische Disparität lautet wie folgt:
CDD = (1/n)\$1∑ini \$1DDi
Wobei Folgendes gilt:
+ ∑ini = n ist die Gesamtzahl der Beobachtungen und n i ist die Anzahl der Beobachtungen für jede Untergruppe.
+ DD i = n i (0) /n (0) – n i (1) /n (1) = P i R (y 0) – P i A (y 1) ist die demografische Disparität für die i-te Untergruppe.
Die demografische Disparität für eine Untergruppe (DDi) ist der Unterschied zwischen dem Anteil der abgelehnten Ergebnisse und dem Anteil der akzeptierten Ergebnisse für jede Untergruppe.
Der Bereich der DD-Werte für binäre Ergebnisse für den vollständigen Datensatz DDd oder für seine konditionalisierten Untergruppen DDi ist [-1, \$11].
+ \$11: wenn es keine Ablehnungen in Facet *a* oder Untergruppe und keine Akzeptanz in Facet *d* oder Untergruppe gibt
+ Positive Werte deuten auf eine demografische Disparität hin, da Facet *d* oder Untergruppe einen größeren Anteil der abgelehnten Ergebnisse im Datensatz als der akzeptierten Ergebnisse aufweist. Je höher der Wert, desto weniger beliebt ist die Facet und desto größer ist die Disparität.
+ Negative Werte deuten darauf hin, dass kein demografischer Unterschied besteht, da die Facet *d* oder die Untergruppe einen größeren Anteil der akzeptierten Ergebnisse im Datensatz als der abgelehnten Ergebnisse aufweist. Je niedriger der Wert, desto bevorzugter ist die Facet.
+ -1: wenn es keine Ablehnungen in Facet *d* oder Untergruppe und keine Akzeptanz in Facet *a* oder Untergruppe gibt
Wenn Sie an nichts geknüpft sind, ist CDD genau dann Null, wenn DPL Null ist.
Diese Kennzahl ist nützlich, um die Konzepte der direkten und indirekten Diskriminierung sowie der objektiven Rechtfertigung in den Antidiskriminierungsgesetzen und der Rechtsprechung der EU und des Vereinigten Königreichs zu untersuchen. Weitere Informationen finden Sie unter [Warum Fairness nicht automatisiert werden kann](https://arxiv.org/abs/2005.05906). Dieses paper enthält auch die relevanten Daten und Analysen des Zulassungsfalls in Berkeley, aus dem hervorgeht, wie die Konditionierung auf Untergruppen der Zulassungsquoten der Abteilungen das Simpson-Paradoxon veranschaulicht.
# Generieren Sie in Studio Berichte über Verzerrungen bei Daten vor dem Training SageMaker
SageMaker Clarify ist in Amazon SageMaker Data Wrangler integriert, sodass Sie Verzerrungen bei der Datenvorbereitung erkennen können, ohne Ihren eigenen Code schreiben zu müssen. Data Wrangler bietet eine end-to-end Lösung zum Importieren, Vorbereiten, Transformieren, Funktionalisieren und Analysieren von Daten mit Amazon Studio. SageMaker Eine Übersicht über den Data Wrangler-Workflow zur Datenvorbereitung finden Sie unter [Vorbereiten von ML-Daten mit Amazon SageMaker Data Wrangler](data-wrangler.md).
Sie geben interessante Attribute wie Geschlecht oder Alter an, und SageMaker Clarify führt eine Reihe von Algorithmen aus, um das Vorhandensein von Verzerrungen in diesen Attributen zu erkennen. Nach der Ausführung des Algorithmus erstellt SageMaker Clarify einen visuellen Bericht mit einer Beschreibung der Ursachen und des Schweregrads möglicher Verzerrungen, sodass Sie Maßnahmen zur Minderung planen können. In einem Finanzdatensatz, der nur wenige Beispiele für Geschäftskredite an eine Altersgruppe im Vergleich zu anderen enthält, kennzeichnet SageMaker KI das Ungleichgewicht, sodass Sie ein Modell vermeiden können, das diese Altersgruppe benachteiligt.
**Um Datenverzerrungen zu analysieren und darüber zu berichten**
Informationen zum Einstieg in Data Wrangler finden Sie unter [Erste Schritte mit Data Wrangler](data-wrangler-getting-started.md).
1. Navigieren Sie in Amazon SageMaker Studio Classic im Menü **Home** (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/studio/icons/house.png)) im linken Bereich zum Knoten **Data** und wählen Sie dann **Data Wrangler**. Dadurch wird die **Data-Wrangler-Landingpage** in Studio Classic geöffnet.
1. Wählen Sie die Schaltfläche **\$1 Daten importieren**, um einen neuen Flow zu erstellen.
1. Wählen Sie auf Ihrer Flow-Seite auf der Registerkarte **Import** Amazon S3 aus, navigieren Sie zu Ihrem Amazon-S3-Bucket, suchen Sie Ihren Datensatz und wählen Sie dann **Import** aus.
1. Nachdem Sie Ihre Daten importiert haben, wählen Sie im Flussdiagramm auf der Registerkarte **Datenfluss** das **\$1** rechts neben dem Knoten **Datentypen** aus.
1. Wählen Sie **Analyse hinzufügen**.
1. Wählen Sie auf der Seite **Analyse erstellen** die Option **Bias Report** als **Analysetyp** aus.
1. Konfigurieren Sie den Verzerrungsbericht, indem Sie einen **Berichtsnamen**, die Spalte, die vorhergesagt werden soll, angeben, ob es sich um einen Wert oder einen Schwellenwert handelt, die Spalte, die auf Verzerrungen analysiert werden soll (die Facet) und ob es sich um einen Wert oder einen Schwellenwert handelt.
1. Fahren Sie mit der Konfiguration des Biasberichts fort, indem Sie die Bias-Metriken auswählen.
![\[Wählen Sie die Bias-Metrik aus.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/clarify-data-wrangler-configure-bias-metrics.png)
1. Wählen Sie **Auf Verzerrungen prüfen** aus, um den Bias-Bericht zu erstellen und anzuzeigen. Scrollen Sie nach unten, um alle Berichte zu sehen.
![\[Generieren Sie den Bericht über Verzerrungen und zeigen Sie ihn an.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/clarify-data-wrangler-create-bias-report.png)
1. Klicken Sie auf den Mauszeiger rechts neben der Beschreibung der Messwerte für systematische Abweichungen, um die Dokumentation aufzurufen, die Ihnen bei der Interpretation der Signifikanz der Metrikwerte helfen kann.
1. Um eine tabellarische Zusammenfassung der Bias-Metrikwerte anzuzeigen, wählen Sie den Schalter **Tabelle**. Zum Speichern des Berichts wählen Sie in der unteren rechten Ecke der Seite **Speichern** aus. Sie können den Bericht im Flussdiagramm auf der Registerkarte **Datenfluss** sehen. Klicken Sie doppelt auf den Bericht, um ihn zu öffnen.
# Daten nach dem Training und Modellverzerrungen
Die Verzerrungsanalyse nach dem Training kann helfen, Verzerrungen aufzudecken, die möglicherweise auf Verzerrungen in den Daten oder auf Verzerrungen zurückzuführen sind, die durch die Klassifizierungs- und Vorhersagealgorithmen verursacht wurden. Bei diesen Analysen werden die Daten, einschließlich der Kennzeichnungen, und die Vorhersagen eines Modells berücksichtigt. Sie bewerten die Leistung, indem Sie vorhergesagte Kennzeichnungen analysieren oder die Vorhersagen mit den beobachteten Zielwerten in den Daten in Bezug auf Gruppen mit unterschiedlichen Attributen vergleichen. Es gibt unterschiedliche Vorstellungen von Fairness, für deren Messung jeweils unterschiedliche Messwerte zur Verzerrung erforderlich sind.
Es gibt rechtliche Konzepte von Fairness, die möglicherweise nicht einfach zu erfassen sind, weil sie schwer zu erkennen sind. Zum Beispiel das US-Konzept der ungleichen Auswirkungen, das entsteht, wenn eine Gruppe, die als weniger begünstigte Facet *d* bezeichnet wird, negative Auswirkungen hat, auch wenn der gewählte Ansatz fair zu sein scheint. Diese Art von Verzerrung ist möglicherweise nicht auf ein Modell des maschinellen Lernens zurückzuführen, könnte aber durch eine Verzerrungsanalyse nach dem Training dennoch nachweisbar sein.
Amazon SageMaker Clarify versucht, eine einheitliche Verwendung der Terminologie sicherzustellen. Eine Liste der Begriffe und ihrer Definitionen finden Sie unter [Amazon SageMaker klärt die Bedingungen für Voreingenommenheit und Fairness](clarify-detect-data-bias.md#clarify-bias-and-fairness-terms).
Weitere Informationen zu Kennzahlen zu Verzerrungen nach dem Training finden [Sie unter Erfahren Sie, wie Amazon SageMaker Clarify hilft, Vorurteile und [Fairnessmaßnahmen für Machine Learning im](https://pages.awscloud.com/rs/112-TZM-766/images/Fairness.Measures.for.Machine.Learning.in.Finance.pdf) Finanzwesen zu erkennen](https://aws.amazon.com/blogs/machine-learning/learn-how-amazon-sagemaker-clarify-helps-detect-bias/). .
# Daten nach dem Training und Modellverzerrungenmetriken
Amazon SageMaker Clarify bietet elf Daten und Modellverzerrungsmetriken nach dem Training, um verschiedene Konzepte von Fairness zu quantifizieren. Diese Konzepte können nicht alle gleichzeitig erfüllt werden, und die Auswahl hängt von den Besonderheiten der Fälle ab, in denen potenzielle Verzerrungen analysiert werden. Bei den meisten dieser Kennzahlen handelt es sich um eine Kombination der Zahlen, die den Konfusionsmatrizen der binären Klassifikation für die verschiedenen demografischen Gruppen entnommen wurden. Da Fairness und Voreingenommenheit durch eine Vielzahl von Kennzahlen definiert werden können, ist menschliches Urteilsvermögen erforderlich, um zu verstehen, welche Kennzahlen für den jeweiligen Anwendungsfall relevant sind, und Kunden sollten sich mit den entsprechenden Interessengruppen beraten, um das angemessene Maß an Fairness für ihre Anwendung festzulegen.
Wir verwenden die folgende Notation, um die Bias-Metriken zu erörtern. Das hier beschriebene konzeptionelle Modell dient der binären Klassifikation, bei der Ereignisse in ihrem Stichprobenraum so gekennzeichnet werden, dass sie nur zwei mögliche Ergebnisse haben, die als positiv (mit dem Wert 1) und negativ (mit dem Wert 0) bezeichnet werden. Dieser Rahmen lässt sich in der Regel auf einfache Weise auf eine Klassifizierung nach mehreren Kategorien oder bei Bedarf auf Fälle mit kontinuierlich bewerteten Ergebnissen ausdehnen. Bei der binären Klassifikation werden Ergebnissen, die in einem Rohdatensatz für eine bevorzugte Facet *a* und für eine benachteiligte Facet *d* aufgezeichnet wurden, positive und negative Markierungen zugewiesen. Diese Kennzeichnungen y werden als *beobachtete Beschriftungen* bezeichnet, um sie von den *vorhergesagten Beschriftungen* y' zu unterscheiden, die von einem Modell für Machine Learning während der Trainings- oder Inferenzphase des ML-Lebenszyklus zugewiesen werden. Diese Bezeichnungen werden verwendet, um die Wahrscheinlichkeitsverteilungen Pa(y) and Pd(y) für ihre jeweiligen Facetnergebnisse zu definieren.
+ Beschriftungen:
+ y steht für die n beobachteten Beschriftungen für Ereignisergebnisse in einem Trainingsdatensatz.
+ y' steht für die von einem trainierten Modell vorhergesagten Markierungen für die n beobachteten Markierungen im Datensatz.
+ Ergebnisse:
+ Ein positives Ergebnis (mit dem Wert 1) für eine Stichprobe, z. B. eine Annahme eines Antrags.
+ n(1) ist die Anzahl der beobachteten Markierungen für positive Ergebnisse (Zulassungen).
+ n'(1) ist die Anzahl der vorhergesagten Kennzeichnungen für positive Ergebnisse (Akzeptanz).
+ Ein negatives Ergebnis (mit dem Wert 0) für eine Stichprobe, z. B. eine Ablehnung eines Antrags.
+ n(0) ist die Anzahl der beobachteten Markierungen für negative Ergebnisse (Ablehnungen).
+ n'(0) ist die Anzahl der vorhergesagten Markierungen für negative Ergebnisse (Ablehnungen).
+ Facetnwerte:
+ Facet *a* – Der Merkmalswert, der eine demografische Gruppe definiert, die von Vorurteilen bevorzugt wird.
+ na ist die Anzahl der beobachteten Beschriftungen für den bevorzugten Facetnwert: na = na(1) \$1 na(0) die Summe der positiven und negativen beobachteten Beschriftungen für den Wert Facet *a*.
+ n' a ist die Anzahl der vorhergesagten Beschriftungen für den bevorzugten Facetnwert: n'a = n'a(1) \$1 n'a(0) ist die Summe der positiven und negativen Kennzeichnungen für das vorhergesagte Ergebnis für den Facetnwert *a*. Beachten Sie n'a = na.
+ facet *d* – Der Merkmalswert, der eine demografische Gruppe definiert, die tendenziell benachteiligt ist.
+ nd ist die Anzahl der beobachteten Kennzeichnungen für den Facetnwert mit negativer Wirkung: nd = nd(1) \$1 nd(0) ist die Summe der beobachteten positiven und negativen Kennzeichnungen für den Facetnwert *d*.
+ n'd ist die Anzahl der vorhergesagten Markierungen für den Wert der negativen Facet: n'd = n'd(1) \$1 n'd(0) die Summe der positiven und negativen vorhergesagten Markierungen für den Facetnwert *d*. Beachten Sie n'd = nd.
+ Wahrscheinlichkeitsverteilungen für die Ergebnisse der markierten Facetndaten:
+ Pa(y) ist die Wahrscheinlichkeitsverteilung der beobachteten Markierungen für Facet *a*. Bei binär markierten Daten ergibt sich diese Verteilung aus dem Verhältnis der Anzahl der Stichproben in Facet *a* mit positiven Ergebnissen zur Gesamtzahl, Pa(y1) = na(1)/ na, und dem Verhältnis der Anzahl der Proben mit negativen Ergebnissen zur Gesamtzahl, Pa(y0) = na(0)/ na.
+ P d(y) ist die Wahrscheinlichkeitsverteilung der beobachteten Markierungen für Facet *d*. Bei binär markierten Daten ergibt sich diese Verteilung aus der Anzahl der mit positiven Ergebnissen markierten Stichproben in der Facet *d* zur Gesamtzahl, Pd(y1) = nd(1)/ nd, und dem Verhältnis der Anzahl der Proben mit negativen Ergebnissen zur Gesamtzahl, Pd(y0) = nd(0)/ nd.
Die folgende Tabelle enthält einen Spickzettel zur schnellen Orientierung und Links zu den Messwerten für Verzerrungen nach dem Training.
Kennzahlen zu Verzerrungen nach dem Training
| Kennzahl für Verzerrungen nach dem Training | Description | Beispiel für eine Frage | Interpretieren von metrischen Werten |
| --- | --- | --- | --- |
| [Unterschied zwischen positiven Anteilen bei prognostizierten Kennzeichnungen (DPPL)](clarify-post-training-bias-metric-dppl.md) | Misst den Unterschied im Anteil positiver Prognosen zwischen der bevorzugten Facet a und der ungünstigen Facet d. | Gab es bei den prognostizierten positiven Ergebnissen zwischen den demografischen Gruppen ein Ungleichgewicht, das auf eine Verzerrung hindeuten könnte? | Bereich für normalisierte binäre und mehrkategoriale Facetnbezeichnungen: `[-1,+1]` Bereich für fortlaufende Beschriftungen: (-∞, \$1∞) Interpretation: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/clarify-measure-post-training-bias.html) |
| [Disparate Impact (DI)](clarify-post-training-bias-metric-di.md) | Misst das Verhältnis der Anteile der vorhergesagten Markierungen für die bevorzugte Facet a und die benachteiligte Facet d. | Gab es bei den prognostizierten positiven Ergebnissen zwischen den demografischen Gruppen ein Ungleichgewicht, das auf eine Verzerrung hindeuten könnte? | Bereich für normalisierte binäre Bezeichnungen, Bezeichnungen mit mehrkategorialen Facetn und fortlaufenden Bezeichnungen: [0, ∞) Interpretation: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/clarify-measure-post-training-bias.html) |
| [Bedingte demografische Disparität bei prognostizierten Beschriftungen (CDDPL)](clarify-post-training-bias-metric-cddpl.md) | Misst die Disparität der vorhergesagten Kennzeichnungen zwischen den Facetn insgesamt, aber auch nach Untergruppen. | Ist bei einigen Bevölkerungsgruppen der Anteil der Ablehnungen von Kreditanträgen höher als der Anteil der Kreditanträge? | Der CDDPL-Wertebereich für binäre, mehrkategoriale und kontinuierliche Ergebnisse: `[-1, +1]` [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/clarify-measure-post-training-bias.html) |
| [Kontrafaktischer Fliptest (FT)](clarify-post-training-bias-metric-ft.md) | Untersucht jedes Mitglied der Facet d und bewertet, ob ähnliche Mitglieder von Facet a unterschiedliche Modellvorhersagen haben. | Entspricht eine Gruppe einer bestimmten Altersgruppe in allen Merkmalen sehr gut einer anderen Altersgruppe, wird aber im Durchschnitt besser bezahlt? | Der Bereich für binäre und mehrkategoriale Facetnbezeichnungen [-1, \$11] beträgt. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/clarify-measure-post-training-bias.html) |
| [Genauigkeitsunterschied (AD)](clarify-post-training-bias-metric-ad.md) | Misst den Unterschied zwischen der Vorhersagegenauigkeit für die bevorzugte und die ungünstige Facet. | Prognostiziert das Modell Beschriftungen für Anwendungen in allen demografischen Gruppen genauso genau? | Der Bereich für binäre und mehrkategoriale Facetnbezeichnungen [-1, \$11] beträgt.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/clarify-measure-post-training-bias.html) |
| [Unterschied zurückrufen (RD)](clarify-post-training-bias-metric-rd.md) | Vergleicht die Erinnerung an das Modell in Bezug auf die bevorzugten und die ungünstigen Facetn. | Liegt bei der Kreditvergabe eine altersbedingte Verzerrung vor, die darauf zurückzuführen ist, dass ein Modell für eine Altersgruppe eine höhere Erinnerungsrate aufweist als für eine andere? | Bereich für binäre und mehrkategoriale Klassifikation: `[-1, +1]`. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/clarify-measure-post-training-bias.html) |
| [Unterschied bei der bedingten Akzeptanz () DCAcc](clarify-post-training-bias-metric-dcacc.md) | Vergleicht die beobachteten Markierungen mit den von einem Modell vorhergesagten Markierungen. Prüft, ob dies bei vorhergesagten positiven Ergebnissen (Akzeptanzzahlen) in allen Facetn gleich ist. | Werden Kredite beim Vergleich einer Altersgruppe mit einer anderen häufiger oder seltener als prognostiziert (je nach Qualifikation) angenommen? | Der Bereich für binäre, mehrkategoriale Facetnbezeichnungen und fortlaufende Bezeichnungen: (-∞, \$1∞). [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/clarify-measure-post-training-bias.html) |
| [Unterschied in den Akzeptanzraten (DAR)](clarify-post-training-bias-metric-dar.md) | Misst den Unterschied zwischen den beobachteten positiven Ergebnissen (TP) und den prognostizierten positiven Ergebnissen (TP \$1 FP) zwischen den bevorzugten und negativen Facetn. | Ist das Modell bei der Vorhersage von Kreditannahmen für qualifizierte Antragsteller aller Altersgruppen gleich genau? | Der Bereich für binäre, mehrkategoriale Facetnbezeichnungen und fortlaufende Beschriftungen beträgt [-1, \$11].[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/clarify-measure-post-training-bias.html) |
| [Spezifitätsunterschied (SD)](clarify-post-training-bias-metric-sd.md) | Vergleicht die Spezifität des Modells zwischen bevorzugten und ungünstigen Facetn. | Liegt eine altersbedingte Verzerrung bei der Kreditvergabe vor, weil das Modell für eine Altersgruppe eine höhere Spezifität voraussagt als für eine andere? | Bereich für binäre und mehrkategoriale Klassifikation: `[-1, +1]`. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/clarify-measure-post-training-bias.html) |
| [Unterschied bei der bedingten Ablehnung (DCR)](clarify-post-training-bias-metric-dcr.md) | Vergleicht die beobachteten Markierungen mit den von einem Modell vorhergesagten Kennzeichnungen und bewertet, ob diese Werte bei negativen Ergebnissen (Ablehnungen) für alle Facetn gleich sind. | Werden Kreditanträge für eine Altersgruppe mehr oder weniger abgelehnt als für eine andere Altersgruppe aufgrund ihrer Qualifikationen prognostiziert? | Der Bereich für binäre, mehrkategoriale Facetnbezeichnungen und fortlaufende Bezeichnungen: (-∞, \$1∞).[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/clarify-measure-post-training-bias.html) |
| [Unterschied bei den Ablehnungsraten (DRR)](clarify-post-training-bias-metric-drr.md) | Misst den Unterschied im Verhältnis zwischen den beobachteten negativen Ergebnissen (TN) und den vorhergesagten negativen Ergebnissen (TN \$1 FN) zwischen den benachteiligten und den bevorzugten Facetn. | Ist das Modell bei der Vorhersage von Kreditablehnungen für unqualifizierte Antragsteller in allen Altersgruppen gleich genau? | Der Bereich für binäre, mehrkategoriale Facetnbezeichnungen und fortlaufende Beschriftungen beträgt [-1, \$11].[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/clarify-measure-post-training-bias.html) |
| [Gleichbehandlung (TE)](clarify-post-training-bias-metric-te.md) | Misst den Unterschied im Verhältnis von falsch positiven zu falsch negativen Ergebnissen zwischen den bevorzugten und negativen Facetn. | Ist bei Kreditanträgen das relative Verhältnis von falsch positiven zu falsch negativen Ergebnissen in allen Altersklassen gleich? | Der Bereich für binäre und mehrkategoriale Facetnbezeichnungen: (-∞, \$1∞).[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/clarify-measure-post-training-bias.html) |
| [Generalisierte Entropie (GE)](clarify-post-training-bias-metric-ge.md) | Misst die Ungleichheit der b-Vorteile, die jedem Input durch die Modellvorhersagen zugewiesen werden. | Führt eines der beiden für die Klassifizierung von Kreditanträgen in Frage kommenden Modelle zu einer ungleichmäßigeren Verteilung der gewünschten Ergebnisse als das andere? | Der Bereich für binäre und mehrkategoriale Beschriftungen: (0, 0,5). GE ist undefiniert, wenn das Modell nur falsch negative Werte vorhersagt.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/clarify-measure-post-training-bias.html) |
Weitere Informationen zu Messgrößen für Verzerrungen nach dem Training finden Sie unter [Eine Familie von Fairness-Maßnahmen für Machine Learning im Finanzwesen](https://pages.awscloud.com/rs/112-TZM-766/images/Fairness.Measures.for.Machine.Learning.in.Finance.pdf).
**Topics**
+ [Unterschied zwischen positiven Anteilen bei prognostizierten Kennzeichnungen (DPPL)](clarify-post-training-bias-metric-dppl.md)
+ [Disparate Impact (DI)](clarify-post-training-bias-metric-di.md)
+ [Unterschied bei der bedingten Akzeptanz () DCAcc](clarify-post-training-bias-metric-dcacc.md)
+ [Unterschied bei der bedingten Ablehnung (DCR)](clarify-post-training-bias-metric-dcr.md)
+ [Spezifitätsunterschied (SD)](clarify-post-training-bias-metric-sd.md)
+ [Unterschied zurückrufen (RD)](clarify-post-training-bias-metric-rd.md)
+ [Unterschied in den Akzeptanzraten (DAR)](clarify-post-training-bias-metric-dar.md)
+ [Unterschied bei den Ablehnungsraten (DRR)](clarify-post-training-bias-metric-drr.md)
+ [Genauigkeitsunterschied (AD)](clarify-post-training-bias-metric-ad.md)
+ [Gleichbehandlung (TE)](clarify-post-training-bias-metric-te.md)
+ [Bedingte demografische Disparität bei prognostizierten Beschriftungen (CDDPL)](clarify-post-training-bias-metric-cddpl.md)
+ [Kontrafaktischer Fliptest (FT)](clarify-post-training-bias-metric-ft.md)
+ [Generalisierte Entropie (GE)](clarify-post-training-bias-metric-ge.md)
# Unterschied zwischen positiven Anteilen bei prognostizierten Kennzeichnungen (DPPL)
Der Unterschied zwischen den positiven Anteilen in der Metrik für vorhergesagte Kennzeichnungen (DPPL) bestimmt, ob das Modell die Ergebnisse für jede Facet unterschiedlich vorhersagt. Sie ist definiert als die Differenz zwischen dem Anteil positiver Vorhersagen (y' = 1) für Facet *a* und dem Anteil positiver Vorhersagen (y' = 1) für Facet *d*. Wenn die Modellprognosen beispielsweise Kredite für 60% einer Gruppe mittleren Alters (Facet *a*) und 50% für andere Altersgruppen (Facet *d*) gewähren, könnte dies gegenüber Facet *d* voreingenommen sein. In diesem Beispiel müssen Sie ermitteln, ob der Unterschied von 10% wesentlich für eine Verzerrung ist.
Durch einen Vergleich des Unterschieds in Proportionen von Labels (DPL), einem Maß für den Bias vor dem Training, mit DPPL, einem Maß für den Bias nach dem Training, wird bewertet, ob sich der Bias in positiven Proportionen, die ursprünglich im Datensatz vorhanden waren, nach dem Training ändert. Wenn der DPPL größer als der DPL ist, nimmt der positive Bias nach dem Training zu. Wenn DPPL kleiner als DPL ist, erhöhte das Modell die Verzerrung nach dem Training nicht positiv. Der Vergleich von DPL mit DPPL garantiert nicht, dass das Modell Verzerrungen in allen Dimensionen reduziert. Beispielsweise kann das Modell immer noch verzerrt sein, wenn andere Kennzahlen wie oder berücksichtigt werden. [Kontrafaktischer Fliptest (FT)](clarify-post-training-bias-metric-ft.md) [Genauigkeitsunterschied (AD)](clarify-post-training-bias-metric-ad.md) Weitere Informationen zur Erkennung von Verzerrungen finden Sie im Blogbeitrag [Erfahren Sie, wie Amazon SageMaker Clarify bei der Erkennung von Verzerrungen hilft](https://aws.amazon.com/blogs/machine-learning/learn-how-amazon-sagemaker-clarify-helps-detect-bias/). Weitere Informationen zu DPL finden Sie unter [Unterschied in den Proportionen der Beschriftungen (DPL)](clarify-data-bias-metric-true-label-imbalance.md).
Die Formel für die DPPL lautet wie folgt:
DPPL = q'a – q'd
Wobei Folgendes gilt:
+ q'a = n'a(1)/na ist der vorhergesagte Anteil der Facet *a*, die ein positives Ergebnis mit dem Wert 1 erzielen. In unserem Beispiel ist dies der Anteil der Personen mittleren Alters, für die prognostiziert wurde, dass ihnen ein Kredit gewährt wird. Hier steht n'a(1) für die Anzahl der Mitglieder der Facet *a*, die ein positives vorhergesagtes Ergebnis mit dem Wert 1 erzielen, und n a für die Anzahl der Mitglieder der Facet *a*.
+ q'd = n'd(1)/nd ist der vorhergesagte Anteil der Facet *d*, die ein positives Ergebnis mit dem Wert 1 erzielen. In unserem Beispiel wurde für eine Facet älterer und jüngerer Menschen prognostiziert, dass ihnen ein Kredit gewährt wird. Hier steht n'd(1) für die Anzahl der Mitglieder der Facet *d*, die ein positives prognostiziertes Ergebnis erzielen, und nd für die Anzahl der Mitglieder der Facet *d*.
Wenn DPPL nahe genug an 0 liegt, bedeutet dies, dass die *demografische Parität* nach der Ausbildung erreicht wurde.
Bei binären und mehrkategorialen Facetnbezeichnungen bewegen sich die normalisierten DPL-Werte über das Intervall [-1, 1]. Bei kontinuierlichen Beschriftungen variieren die Werte über das Intervall (-∞, \$1∞).
+ Positive DPPL-Werte weisen darauf hin, dass Facet *a* im Vergleich zu Facet *d* einen höheren Anteil an prognostizierten positiven Ergebnissen aufweist.
Dies wird als *positive Verzerrung* bezeichnet.
+ DPPL-Werte nahe Null deuten auf einen gleichmäßigeren Anteil der vorhergesagten positiven Ergebnisse zwischen den Facetn *a* und *d* hin, und ein Wert von Null weist auf eine perfekte demografische Parität hin.
+ Negative DPPL-Werte deuten darauf hin, dass Facet *d* im Vergleich zu Facet *a* einen höheren Anteil an prognostizierten positiven Ergebnissen aufweist. Dies wird als *negativer Bias* bezeichnet.
# Disparate Impact (DI)
Der Unterschied zwischen den positiven Proportionen in der Metrik für prognostizierte Kennzeichnungen kann in Form eines Verhältnisses bewertet werden.
Der Vergleich positiver Anteile in der Metrik für vorhergesagte Kennzeichnungen kann in Form eines Verhältnisses und nicht als Unterschied bewertet werden, wie dies bei der [Unterschied zwischen positiven Anteilen bei prognostizierten Kennzeichnungen (DPPL)](clarify-post-training-bias-metric-dppl.md) der Fall ist. Die Kennzahl für unterschiedliche Auswirkungen (DI) ist definiert als das Verhältnis des Anteils positiver Vorhersagen (y' = 1) für Facet *d* zum Anteil positiver Vorhersagen (y' = 1) für Facet *a*. Wenn die Modellprognosen beispielsweise Kredite für 60% einer Gruppe mittleren Alters (Facet *a*) und 50% für andere Altersgruppen (Facet *d*) gewähren, dann ist DI = .5/.6 = 0.8, was auf eine positive Tendenz und negative Auswirkungen auf die andere Altersgruppe, die durch Facet *d* repräsentiert wird, hindeutet.
Die Formel für das Verhältnis der Anteile der vorhergesagten Kennzeichnungen lautet wie folgt:
DI = q'd/q'a
Wobei Folgendes gilt:
+ q'a = n'a(1)/na ist der vorhergesagte Anteil der Facet *a*, die ein positives Ergebnis mit dem Wert 1 erzielen. In unserem Beispiel ist dies der Anteil der Personen mittleren Alters, für die prognostiziert wurde, dass ihnen ein Kredit gewährt wird. Dabei steht n'a(1) für die Anzahl der Mitglieder der Facet *a*, die ein positives prognostiziertes Ergebnis erzielen, und na für die Anzahl der Mitglieder der Facet *a*.
+ q'd = n'd(1)/nd ist der vorhergesagte Anteil der Facet *d* a, die ein positives Ergebnis mit dem Wert 1 erzielen. In unserem Beispiel wird für eine Facet älterer und jüngerer Menschen prognostiziert, dass ihnen ein Kredit gewährt wird. Hier steht n' d (1) für die Anzahl der Mitglieder der Facet *d*, die ein positives prognostiziertes Ergebnis erzielen, und n für d die Anzahl der Mitglieder der Facet *d*.
Bei binären, mehrkategorialen Facetnbezeichnungen und kontinuierlichen Beschriftungen liegen die DI-Werte im Bereich des Intervalls [0, ∞).
+ Werte unter 1 weisen darauf hin, dass die Facet *a* einen höheren Anteil an prognostizierten positiven Ergebnissen aufweist als die Facet *d*. Dies wird als *positive Verzerrung* bezeichnet.
+ Ein Wert von 1 steht für demografische Parität.
+ Werte über 1 weisen darauf hin, dass Facet *d* einen höheren Anteil an prognostizierten positiven Ergebnissen aufweist als Facet *a*. Dies wird als *negative Verzerrung* bezeichnet.
# Unterschied bei der bedingten Akzeptanz () DCAcc
Diese Metrik vergleicht die beobachteten Kennzeichnungen mit den vom Modell vorhergesagten Kennzeichnungen und bewertet, ob diese Werte bei vorhergesagten positiven Ergebnissen für alle Facetn gleich sind. Diese Metrik ahmt menschliche Verzerrungen insofern sehr nach, als sie quantifiziert, wie viele positive Ergebnisse ein Modell für eine bestimmte Facet vorhergesagt hat (mit 'y' bezeichnet), verglichen mit den Ergebnissen, die im Trainingsdatensatz beobachtet wurden (Bezeichnungen y). Wenn beispielsweise im Trainingsdatensatz für Kreditanträge für eine Gruppe mittleren Alters (Facet *a*) mehr Akzeptanz festgestellt wurde (ein positives Ergebnis) als von dem auf Qualifikationen basierenden Modell vorhergesagt wurde als in der Facet, die andere Altersgruppen umfasst (Facet *d*), könnte dies auf mögliche Verzerrungen bei der Kreditvergabe zugunsten der Gruppe mittleren Alters hindeuten.
Die Formel für den Unterschied in der bedingten Akzeptanz lautet wie folgt:
DCAcc = c a — c d
Wobei Folgendes gilt:
+ ca = na(1)/ n'a(1) ist das Verhältnis der beobachteten Anzahl positiver Ergebnisse mit dem Wert 1 (Akzeptanz) von Facet *a* zur vorhergesagten Anzahl positiver Ergebnisse (Akzeptanz) für Facet *a*.
+ cd = nd(1)/ n'd(1) ist das Verhältnis der beobachteten Anzahl positiver Ergebnisse mit dem Wert 1 (Akzeptanz) der Facet *d* zur prognostizierten Anzahl der vorhergesagten positiven Ergebnisse (Akzeptanz) für Facet *d*.
Mit der DCAcc Kennzahl können sowohl positive als auch negative Verzerrungen erfasst werden, die auf eine bevorzugte Behandlung aufgrund von Qualifikationen schließen lassen. Betrachten Sie die folgenden Fälle altersbedingter Vorurteile bei der Annahme von Krediten.
**Beispiel 1: Positive Verzerrung**
Nehmen wir an, wir haben einen Datensatz mit 100 Personen mittleren Alters (Facet *a*) und 50 Personen aus anderen Altersgruppen (Facet *d*), die Kredite beantragt haben, wobei das Modell empfahl, 60 Personen aus Facet *a* und 30 aus Facet *d* Kredite zu vergeben. Die prognostizierten Anteile sind also in Bezug auf die DPPL-Metrik unvoreingenommen, aber die beobachteten Angaben zeigen, dass 70 aus der Facet *a* und 20 aus der Facet *d* Kredite gewährt wurden. Mit anderen Worten, das Modell gewährte Kredite an 17% weniger Personen im mittleren Alter, als es die beobachteten Angaben in den Trainingsdaten nahelegen (70/60 = 1,17), und es wurden 33% mehr Personen aus anderen Altersgruppen Kredite gewährt, als es die beobachteten Beschriftungen vermuten ließen (20/30 = 0,67). Die Berechnung des DCAcc Werts ergibt Folgendes:
DCAcc = 70/60 - 20/30 = 1/2
Der positive Wert weist darauf hin, dass ein potenzieller Bias gegenüber der Facet *a* mittleren Alters mit einer niedrigeren Akzeptanzrate als der anderen Facet *d* besteht, als es die beobachteten Daten (als unvoreingenommen betrachtet) vermuten lassen.
**Beispiel 2: Negativer Bias**
Nehmen wir an, wir haben einen Datensatz mit 100 Personen mittleren Alters (Facet *a*) und 50 Personen aus anderen Altersgruppen (Facet *d*), die Kredite beantragt haben, wobei das Modell empfahl, 60 Personen aus Facet *a* und 30 aus Facet d *Kredite* zu vergeben. Die prognostizierten Anteile sind also in Bezug auf die DPPL-Metrik unvoreingenommen, aber die beobachteten Angaben zeigen, dass 50 aus der Facet *a* und 40 aus der Facet *d* Kredite gewährt wurden. Mit anderen Worten, das Modell gewährte Kredite an 17% weniger Personen im mittleren Alter, als die beobachteten Bezeichnungen in den Trainingsdaten vermuten ließen (50/60 = 0,83), und an 33% mehr Kredite aus anderen Altersgruppen als die beobachteten Beschriftungen vermuten ließen (40/30 = 1,33). Die Berechnung des DCAcc Wertes ergibt Folgendes:
DCAcc = 50/60 - 40/30 = -1/2
Der negative Wert weist darauf hin, dass ein potenzieller Bias gegenüber der Facet *d* mit einer niedrigeren Akzeptanzrate als bei der Facet *a* mittleren Alters vorliegt, als es die beobachteten Daten (als unvoreingenommen betrachtet) vermuten lassen.
Beachten Sie, dass Sie es verwenden können, DCAcc um mögliche (unbeabsichtigte) Verzerrungen zu erkennen, die durch Menschen verursacht werden, die die Modellvorhersagen in einer Umgebung überwachen. human-in-the-loop Nehmen wir zum Beispiel an, dass die Vorhersagen y' durch das Modell unvoreingenommen waren, aber die letztendliche Entscheidung wird von einem Menschen getroffen (möglicherweise mit Zugriff auf zusätzliche Funktionen), der die Modellvorhersagen ändern kann, um eine neue und endgültige Version von y zu generieren. Die zusätzliche Verarbeitung durch den Menschen kann dazu führen, dass Kredite an eine unverhältnismäßige Anzahl unbeabsichtigt aufgrund einer Facette abgelehnt werden. DCAcckann helfen, solche potenziellen Vorurteile aufzudecken.
Der Wertebereich für Unterschiede in der bedingten Akzeptanz für binäre, mehrkategoriale Facetnbezeichnungen und kontinuierliche Beschriftungen ist (-∞, \$1∞).
+ Positive Werte liegen vor, wenn das Verhältnis der beobachteten Anzahl von Annahmen zu den vorhergesagten Annahmen für Facet *a* höher ist als das gleiche Verhältnis für Facet *d*. Diese Werte deuten auf eine mögliche Voreingenommenheit gegenüber den qualifizierten Bewerbern aus Facet *a* hin. Je größer der Unterschied zwischen den Verhältnissen ist, desto extremer ist die scheinbare Verzerrung.
+ Werte nahe Null liegen vor, wenn das Verhältnis der beobachteten Anzahl von Annahmen zu den vorhergesagten Annahmen für Facet *a* dem Verhältnis für Facet *d* entspricht. Diese Werte deuten darauf hin, dass die prognostizierten Annahmequoten mit den beobachteten Werten in den gekennzeichneten Daten übereinstimmen und dass qualifizierte Bewerber aus beiden Facetn auf ähnliche Weise aufgenommen werden.
+ Negative Werte liegen vor, wenn das Verhältnis der beobachteten Anzahl von Annahmen zu den prognostizierten Annahmen für Facet *a* geringer ist als das Verhältnis für Facet *d*. Diese Werte deuten auf eine mögliche Voreingenommenheit gegenüber den qualifizierten Bewerbern aus Facet *d* hin. Je negativer der Unterschied in den Verhältnissen ist, desto extremer ist die offensichtliche Verzerrung.
# Unterschied bei der bedingten Ablehnung (DCR)
Diese Kennzahl vergleicht die beobachteten Kennzeichnungen mit den vom Modell vorhergesagten Kennzeichnungen und bewertet, ob dies bei negativen Ergebnissen (Ablehnungen) in allen Facetn gleich ist. Diese Metrik ahmt menschliche Voreingenommenheit insofern sehr nach, als sie quantifiziert, wie viele negative Ergebnisse ein Modell für eine bestimmte Facet mehr negative Ergebnisse erzielt hat (vorhergesagte Kennzeichnungen y') als das, was die Beschriftungen im Trainingsdatensatz nahelegen (beobachtete Markierungen y). Wenn beispielsweise mehr Ablehnungen (negatives Ergebnis) bei Kreditanträgen für eine Gruppe mittleren Alters (Facet *a*) beobachtet wurden als von dem auf Qualifikationen basierenden Modell vorhergesagt als bei der Facet, die andere Altersgruppen umfasst (Facet *d*), könnte dies auf eine mögliche Verzerrung bei der Ablehnung von Krediten hindeuten, die die Gruppe mittleren Alters gegenüber anderen Gruppen begünstigen.
Die Formel für den Unterschied in der bedingten Akzeptanz lautet wie folgt:
DCR = rd – ra
Wobei Folgendes gilt:
+ rd = nd(0)/ n'd(0) ist das Verhältnis der beobachteten Anzahl negativer Ergebnisse mit dem Wert 0 (Ablehnungen) der Facet *d* zur prognostizierten Anzahl negativer Ergebnisse (Ablehnungen) für Facet *d*.
+ ra = na(0)/ n'a(0) ist das Verhältnis der beobachteten Anzahl negativer Ergebnisse mit Wert 0 (Ablehnungen) von Facet *a* zur prognostizierten Anzahl negativer Ergebnisse mit Wert 0 (Ablehnungen) für Facet *a*.
Die DCR-Metrik kann sowohl positive als auch negative Verzerrungen erfassen, die auf eine bevorzugte Behandlung aufgrund von Qualifikationen schließen lassen. Betrachten Sie die folgenden Fälle von altersbedingter Voreingenommenheit bei Kreditablehnungen.
**Beispiel 1: Positive Voreingenommenheit**
Nehmen wir an, wir haben einen Datensatz mit 100 Personen mittleren Alters (Facet *a*) und 50 Personen aus anderen Altersgruppen (Facet *d*), die Kredite beantragt haben, wobei das Modell empfahl, 60 Personen aus Facet *a* und 30 aus Facet *d* zurückzuweisen. Die vorhergesagten Anteile sind also unabhängig von der DPPL-Metrik, aber die beobachteten Kennzeichnungen zeigen, dass 50 von Facet *a* und 40 von Facet *d* abgelehnt wurden. Mit anderen Worten, das Modell lehnte 17% mehr Kredite im mittleren Alter ab, als die beobachteten Angaben in den Trainingsdaten vermuten ließen (50/60 = 0,83), und es wurden 33% weniger Kredite aus anderen Altersgruppen abgelehnt, als die beobachteten Kennzeichnungen vermuten ließen (40/30 = 1,33). Der DCR-Wert quantifiziert diesen Unterschied im Verhältnis zwischen beobachteten und prognostizierten Ablehnungsraten zwischen den einzelnen Facetn. Der positive Wert weist darauf hin, dass eine potenzielle Verzerrung zugunsten der Gruppe mittleren Alters mit niedrigeren Ablehnungsraten im Vergleich zu anderen Gruppen besteht, als es die beobachteten Daten (als unvoreingenommen betrachtet) vermuten lassen.
DCR = 40/30 – 50/60 = 1/2
**Beispiel 2: Negativer Bias**
Nehmen wir an, wir haben einen Datensatz mit 100 Personen mittleren Alters (Facet *a*) und 50 Personen aus anderen Altersgruppen (Facet *d*), die Kredite beantragt haben, wobei das Modell empfahl, 60 Personen aus Facet *a* und 30 aus Facet *d* zurückzuweisen. Die vorhergesagten Anteile sind also unabhängig von der DPPL-Metrik, aber die beobachteten Kennzeichnungen zeigen, dass 70 von Facet *a* und 20 von Facet *d* abgelehnt wurden. Mit anderen Worten, das Modell lehnte 17% weniger Kredite aus dem mittleren Alter ab, als die beobachteten Angaben in den Trainingsdaten vermuten ließen (70/60 = 1,17), und es wurden 33% mehr Kredite aus anderen Altersgruppen abgelehnt, als die beobachteten Kennzeichnungen vermuten ließen (20/30 = 0,67). Der negative Wert weist darauf hin, dass ein potenzieller Bias zugunsten der Facet *a* mit niedrigeren Ablehnungsraten im Vergleich zur Facet *a* mittleren Alters vorliegt, als es die beobachteten Daten (als unvoreingenommen betrachtet) vermuten lassen.
DCR = 20/30 – 70/60 = -1/2
Der Wertebereich für Unterschiede bei der bedingten Ablehnung bei binären, mehrkategorialen Facetnbeschriftungen und kontinuierlichen Beschriftungen ist (-∞, \$1∞).
+ *Positive Werte liegen vor, wenn das Verhältnis der beobachteten Anzahl von Zurückweisungen zu den vorhergesagten Ablehnungen für Facet *d* größer ist als das Verhältnis für Facet a*. Diese Werte deuten auf eine mögliche Voreingenommenheit gegenüber den qualifizierten Bewerbern aus Facet *a* hin. Je größer der Wert der DCR-Metrik ist, desto extremer ist die scheinbare Verzerrung.
+ Werte nahe Null liegen vor, wenn das Verhältnis der beobachteten Anzahl von Ablehnungen zu den prognostizierten Akzeptanzzahlen für Facet *a* dem Verhältnis für Facet *d* entspricht. Diese Werte deuten darauf hin, dass die prognostizierten Ablehnungsraten mit den beobachteten Werten in den gekennzeichneten Daten übereinstimmen und dass qualifizierte Bewerber aus beiden Facetn auf ähnliche Weise abgelehnt werden.
+ Negative Werte liegen vor, wenn das Verhältnis der beobachteten Anzahl von Ablehnungen zu den prognostizierten Ablehnungen für Facet *d* geringer ist als das Verhältnis Facet *a*. Diese Werte deuten auf eine mögliche Voreingenommenheit gegenüber den qualifizierten Bewerbern aus Facet *d* hin. Je größer die negative DCR-Metrik ist, desto extremer ist die scheinbare Verzerrung.
# Spezifitätsunterschied (SD)
Der Spezifitätsunterschied (SD) ist der Unterschied in der Spezifität zwischen der bevorzugten Facet *a* und der ungünstigen Facet *d*. Die Spezifität misst, wie oft das Modell ein negatives Ergebnis korrekt vorhersagt (y'=0). Jeder Unterschied in diesen Spezifitäten ist eine mögliche Form von Verzerrung.
Die Spezifität ist für eine Facet perfekt, wenn alle y=0-Fälle für diese Facet korrekt vorhergesagt wurden. Die Spezifität ist größer, wenn das Modell falsch positive Ergebnisse minimiert, was als Fehler vom Typ I bezeichnet wird. Beispielsweise ist der Unterschied zwischen einer niedrigen Spezifität für die Kreditvergabe an Facet *a* und einerhohen Spezifität für die Kreditvergabe an Facet *d* ein Maß für die Verzerrung gegenüber Facet *d*.
Die folgende Formel bezieht sich auf den Unterschied in der Spezifität für die Facetn *a* und *d*.
SD = TNd/(TNd \$1 FPd) – TNa/(TNa \$1 FPa) = TNRd – TNRa
Die folgenden Variablen, die zur Berechnung von SD verwendet wurden, sind wie folgt definiert:
+ TNd sind die wahren negativen Werte, die für Facet *d* vorhergesagt wurden.
+ FPd sind die falsch positiven Ergebnisse, die für Facet *d* vorhergesagt wurden.
+ TNd sind die wahren negativen Werte, die für Facet *a* vorhergesagt wurden.
+ FPd sind die falsch positiven Ergebnisse, die für Facet *a* vorhergesagt wurden.
+ TNRa = TNa/(TNa \$1 FPa) ist die tatsächliche negative Rate, auch bekannt als Spezifität, für Facet *a*.
+ TNR d = TNd/(TN d \$1 FPd) ist die tatsächliche negative Rate, auch bekannt als Spezifität, für Facet *d*.
Betrachten Sie zum Beispiel die folgenden Konfusionsmatrizen für die Facetn *a* und *d*.
Konfusionsmatrix für die bevorzugte Facet `a`
| Vorhersagen der Klasse A | Tatsächliches Ergebnis 0 | Tatsächliches Ergebnis 1 | Gesamt |
| --- | --- | --- | --- |
| 0 | 20 | 5 | 25 |
| 1 | 10 | 65 | 75 |
| Gesamt | 30 | 70 | 100 |
Konfusionsmatrix für die benachteiligte Facet `d`
| Vorhersagen der Klasse D | Tatsächliches Ergebnis 0 | Tatsächliches Ergebnis 1 | Gesamt |
| --- | --- | --- | --- |
| 0 | 18 | 7 | 25 |
| 1 | 5 | 20 | 25 |
| Gesamt | 23 | 27 | 50 |
Der Wert des Spezifitätsunterschieds ist `SD = 18/(18+5) - 20/(20+10) = 0.7826 - 0.6667 = 0.1159`, was auf eine Verzerrung gegenüber Facet *d* hinweist.
Der Wertebereich für den Spezifitätsunterschied zwischen den Facetn *a* und *d* für die binäre und mehrkategoriale Klassifikation ist `[-1, +1]`. Diese Metrik ist nicht für kontinuierliche Etiketten verfügbar. Die verschiedenen SD-Werte bedeuten Folgendes:
+ Positive Werte werden erhalten, wenn die Spezifität für die Facet *d* höher ist als für die Facet *a*. Dies deutet darauf hin, dass das Modell für Facet *d* weniger falsch positive Ergebnisse findet als für Facet *a*. Ein positiver Wert weist auf eine systematische Abweichung gegenüber Facet *d* hin.
+ Werte nahe Null deuten darauf hin, dass die Spezifität der verglichenen Facetn ähnlich ist. Dies deutet darauf hin, dass das Modell in beiden Facetn eine ähnliche Anzahl falsch positiver Ergebnisse feststellt und nicht verzerrt ist.
+ Negative Werte ergeben sich, wenn die Spezifität für Facet *a* höher ist als für Facet *d*. Dies deutet darauf hin, dass das Modell mehr falsch positive Ergebnisse für Facet *a* als für Facet *d* findet. Ein negativer Wert weist auf eine systematische Abweichung gegenüber Facet *a* hin.
# Unterschied zurückrufen (RD)
Die Kennzahl der Erinnerungsdifferenz (RD) ist der Unterschied beim Erinnerungsvermögen des Modells zwischen der bevorzugten Facet *a* und der ungünstigen Facet *d*. Jeder Unterschied zwischen diesen Rückrufen ist eine mögliche Form von Verzerrung. Bei der Rückrufrate handelt es sich um die True-Positive-Rate (TPR), mit der gemessen wird, wie oft das Modell die Fälle korrekt vorhersagt, die zu einem positiven Ergebnis führen sollten. Die Rückrufaktion ist für eine Facet perfekt, wenn alle Fälle mit y=1 für diese Facet korrekt mit y'=1 vorhergesagt wurden. Der Erinnerungsvermögen ist größer, wenn das Modell falsch negative Ergebnisse minimiert, die als Fehler vom Typ II bezeichnet werden. Wie viele Personen in zwei verschiedenen Gruppen (Facetn *a* und *d*), die für Kredite in Frage kommen sollten, werden beispielsweise vom Modell korrekt erkannt? Wenn die Rückrufrate bei der Kreditvergabe an die Facet *a* hoch, bei der Kreditvergabe an die Facet *d* jedoch niedrig ist, ist die Differenz ein Maß für diese Verzerrung gegenüber der Gruppe, die zu Facet *d* gehört.
Die Formel für den Unterschied zwischen den Rückrufraten für die Facetn *a* und *d*:
RD = TPa/(TPa \$1 FNa) – TPd/(TPd \$1 FNd) = TPRa – TPRd
Wobei Folgendes gilt:
+ TP a sind die wahren positiven Ergebnisse, die für Facet *a* vorhergesagt wurden.
+ FN a sind die falsch negativen Werte, die für Facet *a* vorhergesagt wurden.
+ TP d sind die wahren positiven Ergebnisse, die für Facet *d* vorhergesagt wurden.
+ FNd sind die falsch negativen Werte, die für Facet *d* vorhergesagt wurden.
+ TPRa = TPa/(TPa \$1 FNa) ist der Recall für Facet *a* oder ihre tatsächliche positive Rate.
+ TPRd TPd/(TPd \$1 FNd) ist der Rückruf für Facet *d* oder ihre tatsächliche positive Rate.
Betrachten Sie zum Beispiel die folgenden Konfusionsmatrizen für die Facetn *a* und *d*.
Konfusionsmatrix für die bevorzugte Facet a
| Vorhersagen der Klasse A | Tatsächliches Ergebnis 0 | Tatsächliches Ergebnis 1 | Gesamt |
| --- | --- | --- | --- |
| 0 | 20 | 5 | 25 |
| 1 | 10 | 65 | 75 |
| Gesamt | 30 | 70 | 100 |
Konfusionsmatrix für die benachteiligte Facet d
| Vorhersagen der Klasse D | Tatsächliches Ergebnis 0 | Tatsächliches Ergebnis 1 | Gesamt |
| --- | --- | --- | --- |
| 0 | 18 | 7 | 25 |
| 1 | 5 | 20 | 25 |
| Gesamt | 23 | 27 | 50 |
Der Wert der Erinnerungsdifferenz ist RD = 65/70 – 20/27 = 0,93 – 0,74 = 0,19, was auf einen Bias gegenüber Facet *d* hindeutet.
Der Wertebereich für die Erinnerungsdifferenz zwischen den Facetn *a* und *d* für die binäre und mehrkategoriale Klassifikation ist [-1, \$11]. Diese Metrik ist nicht für kontinuierliche Etiketten verfügbar.
+ Positive Werte ergeben sich, wenn für Facet *a* ein höherer Erinnerungswert als für Facet *d* vorhanden ist. Dies deutet darauf hin, dass das Modell mehr echte positive Ergebnisse für Facet *a* als für Facet *d* findet, was eine Form von Verzerrung ist.
+ Werte nahe Null deuten darauf hin, dass der Erinnerungswert für die verglichenen Facetn ähnlich ist. Dies deutet darauf hin, dass das Modell in diesen beiden Facetn etwa die gleiche Anzahl an echten positiven Ergebnissen findet und nicht verzerrt ist.
+ Negative Werte ergeben sich, wenn für Facet *d* ein höherer Erinnerungswert als für Facet *a* vorhanden ist. Dies deutet darauf hin, dass das Modell für Facet *d* mehr echte positive Ergebnisse findet als für Facet *a*, was eine Form von Verzerrung ist.
# Unterschied in den Akzeptanzraten (DAR)
Die Kennzahl für die Differenz der Akzeptanzraten (DAR) ist die Differenz zwischen den tatsächlichen positiven (TP) Vorhersagen und den beobachteten positiven (TP \$1 FP) für die Facetn *a* und *d*. Mit dieser Metrik wird der Unterschied in der Genauigkeit des Modells zur Vorhersage der Akzeptanz anhand dieser beiden Facetn gemessen. Mit der Genauigkeit wird der Anteil qualifizierter Kandidaten aus dem Pool qualifizierter Kandidaten gemessen, die vom Modell als solche identifiziert werden. Wenn die Modellgenauigkeit für die Vorhersage qualifizierter Bewerber in den einzelnen Facetn unterschiedlich ist, handelt es sich um eine Verzerrung, deren Ausmaß mit dem DAR gemessen wird.
Die Formel für den Unterschied in den Akzeptanzquoten zwischen den Facetn *a* und *d*:
DAR = TPa/(TPa \$1 FPa) – TPd/(TPd \$1 FPd)
Wobei Folgendes gilt:
+ TPa sind die wahren positiven Ergebnisse, die für Facet *a* vorhergesagt wurden.
+ FPa sind die falsch positiven Ergebnisse, die für Facet *a* vorhergesagt wurden.
+ TPd sind die wahren positiven Ergebnisse, die für Facet *d* vorhergesagt wurden.
+ FPd sind die falsch positiven Ergebnisse, die für Facet *d* vorhergesagt wurden.
Nehmen wir zum Beispiel an, das Modell akzeptiert 70 Antragsteller mittleren Alters (Facet *a*) für einen Kredit (vorhergesagte positive Beschriftungen), von denen nur 35 tatsächlich akzeptiert werden (beobachtete positive Beschriftungen). Nehmen wir außerdem an, das Modell akzeptiert 100 Antragsteller aus anderen Bevölkerungsgruppen (Facet *d*) für einen Kredit (prognostizierte positive Beschriftungen), von denen nur 40 tatsächlich akzeptiert werden (beobachtete positive Beschriftungen). Dann ist DAR = 35/70 – 40/100 = 0,10, was auf eine potenzielle Voreingenommenheit gegenüber qualifizierten Personen der zweiten Altersgruppe hindeutet (Facet *d*).
Der Wertebereich für DAR für binäre, mehrkategoriale Facetnbeschriftungen und fortlaufende Beschriftungen ist [-1, \$11].
+ Positive Werte liegen vor, wenn das Verhältnis der prognostizierten positiven Ergebnisse (Zusagen) zu den beobachteten positiven Ergebnissen (qualifizierte Bewerber) für Facet *a* größer ist als das gleiche Verhältnis für Facet *d.* Diese Werte deuten auf eine mögliche Verzerrung gegenüber der ungünstigen Facet *d* hin, die durch das Auftreten von relativ mehr falsch positiven Ergebnissen in Facet *d* verursacht wird. Je größer der Unterschied zwischen den Verhältnissen ist, desto extremer ist die scheinbare Verzerrung.
+ Werte nahe Null liegen vor, wenn das Verhältnis der prognostizierten positiven Ergebnisse (Akzeptanz) zu den beobachteten positiven Ergebnissen (qualifizierte Bewerber) für die Facetn *a* und *d* ähnliche Werte aufweist, was darauf hindeutet, dass die beobachteten Kennzeichnungen für positive Ergebnisse vom Modell mit gleicher Genauigkeit vorhergesagt werden.
+ Negative Werte liegen vor, wenn das Verhältnis der prognostizierten positiven Ergebnisse (Akzeptanz) zu den beobachteten positiven Ergebnissen (qualifizierte Bewerber) für Facet *d* größer ist als das Verhältnis Facet *a*. Diese Werte deuten auf eine mögliche Verzerrung gegenüber der bevorzugten Facet *a* hin, die durch das Auftreten von relativ mehr falsch positiven Ergebnissen in Facet *a* verursacht wird. Je negativer der Unterschied in den Verhältnissen ist, desto extremer ist die scheinbare Verzerrung.
# Unterschied bei den Ablehnungsraten (DRR)
Die Kennzahl Differenz der Ablehnungsraten (DRR) ist der Unterschied in den Verhältnissen zwischen den wahrhaft negativen (TN) Vorhersagen und den beobachteten negativen Vorhersagen (TN \$1 FN) für die Facetn *a* und *d*. Diese Metrik misst den Unterschied in der Genauigkeit des Modells zur Vorhersage von Ablehnungen anhand dieser beiden Facetn. Mit der Genauigkeit wird der Anteil unqualifizierter Kandidaten aus dem Pool unqualifizierter Kandidaten gemessen, die vom Modell als solche identifiziert werden. Wenn die Modellgenauigkeit für die Vorhersage unqualifizierter Bewerber in den einzelnen Facetn unterschiedlich ist, handelt es sich um eine Verzerrung, deren Ausmaß anhand der DRR gemessen wird.
Die Formel für den Unterschied in den Ablehnungsquoten zwischen den Facetn *a* und *d*:
DRR = TNd/(TNd \$1 FNd) – TNa/(TNa \$1 FNa)
Die Komponenten der vorherigen DRR-Gleichung lauten wie folgt.
+ TNd sind die wahren negativen Werte, die für Facet *d* vorhergesagt wurden.
+ FNd sind die falsch negativen Werte, die für Facet *d* vorhergesagt wurden.
+ TPa sind die wahren negativen Werte, die für Facet *a* vorhergesagt wurden.
+ FNa sind die falsch negativen Werte, die für Facet *a* vorhergesagt wurden.
Nehmen wir zum Beispiel an, das Modell lehnt 100 Antragsteller mittleren Alters (Facet *a*) für einen Kredit ab (vorhergesagte negative Beschriftungen), von denen 80 tatsächlich nicht qualifiziert sind (beobachtete negative Beschriftungen). Nehmen wir außerdem an, das Modell lehnt 50 Antragsteller aus anderen Bevölkerungsgruppen (Facet *d*) für einen Kredit ab (prognostizierte negative Bewertungen), von denen nur 40 tatsächlich unqualifiziert sind (beobachtete negative Beschriftungen). Dann ist DRR = 40/50 – 80/100 = 0, sodass keine Verzerrung vorliegt.
Der Wertebereich für DRR für binäre, mehrkategoriale Facetnbeschriftungen und kontinuierliche Beschriftungen ist [-1, \$11].
+ Positive Werte liegen vor, wenn das Verhältnis der prognostizierten negativen Ergebnisse (Ablehnungen) zu den beobachteten negativen Ergebnissen (unqualifizierte Bewerber) für Facet *d* größer ist als das gleiche Verhältnis für Facet *a*. Diese Werte deuten auf eine mögliche Verzerrung gegenüber der bevorzugten Facet *a* hin, die durch das Auftreten von relativ mehr falsch negativen Ergebnissen in Facet *a* verursacht wird. Je größer der Unterschied zwischen den Verhältnissen ist, desto extremer ist die scheinbare Verzerrung.
+ Werte nahe Null liegen vor, wenn das Verhältnis der prognostizierten negativen Ergebnisse (Ablehnungen) zu den beobachteten negativen Ergebnissen (unqualifizierte Bewerber) für die Facetn *a* und *d* ähnliche Werte aufweist, was darauf hindeutet, dass die beobachteten Markierungen für negative Ergebnisse vom Modell mit gleicher Genauigkeit vorhergesagt werden.
+ Negative Werte liegen vor, wenn das Verhältnis der prognostizierten negativen Ergebnisse (Ablehnungen) zu den beobachteten negativen Ergebnissen (unqualifizierte Bewerber) für Facet *a* größer ist als das Verhältnis Facet *d*. Diese Werte deuten auf eine mögliche Verzerrung gegenüber der ungünstigen Facet *d* hin, die durch das Auftreten von relativ mehr falsch positiven Ergebnissen in Facet *d* verursacht wird. Je negativer der Unterschied in den Verhältnissen ist, desto extremer ist die scheinbare Verzerrung.
# Genauigkeitsunterschied (AD)
Die Kennzahl Genauigkeitsdifferenz (AD) ist die Differenz zwischen der Vorhersagegenauigkeit für verschiedene Facetn. Diese Metrik bestimmt, ob die Klassifizierung durch das Modell für eine Facet genauer ist als für die andere. AD gibt an, ob bei einer Facet ein größerer Anteil an Fehlern vom Typ I und Typ II auftritt. Es kann jedoch nicht zwischen Fehlern vom Typ I und Typ II unterschieden werden. Beispielsweise kann das Modell für verschiedene Altersdemographien die gleiche Genauigkeit aufweisen, aber die Fehler können für eine Altersgruppe hauptsächlich falsch positive Ergebnisse (Fehler vom Typ I) und für die andere hauptsächlich falsch negative Ergebnisse (Fehler vom Typ II) sein.
Wenn Kreditgenehmigungen für eine Bevölkerungsgruppe mittleren Alters (Facet *a*) mit viel höherer Genauigkeit erteilt werden als für eine andere Altersgruppe (Facet *d*), wird entweder einem größeren Anteil qualifizierter Antragsteller in der zweiten Gruppe ein Kredit verweigert (FN) oder ein größerer Anteil unqualifizierter Antragsteller aus dieser Gruppe erhält einen Kredit (FP) oder beides. Dies kann innerhalb der Gruppe zu ungerechtfertigter Behandlung der zweiten Gruppe führen, auch wenn der Anteil der gewährten Kredite für beide Altersgruppen nahezu gleich ist, was durch einen DPPL-Wert nahe Null angezeigt wird.
Die Formel für die AD-Metrik ist die Differenz zwischen der Vorhersagegenauigkeit für Facet *a*, ACCa, minus der Genauigkeit für Facet *d* , ACC:d
AD = ACCa – ACCd
Wobei Folgendes gilt:
+ ACCa = (TPa \$1 TNa)/(TPa \$1 TNa \$1 FPa \$1 FNa)
+ TPa sind die wahren positiven Ergebnisse, die für Facet *a* vorhergesagt wurden
+ TNa sind die wahren negativen Werte, die für Facet *a* vorhergesagt wurden
+ FPa sind die falsch positiven Ergebnisse, die für Facet *a* vorhergesagt wurden
+ FNa sind die falsch negativen Werte, die für Facet *a* vorhergesagt wurden
+ ACCd = (TPd \$1 TNd)/(TPd \$1 TNd \$1 FPd \$1 FNd)
+ TPd sind die wahren positiven Ergebnisse, die für Facet *d* vorhergesagt wurden
+ TNd sind die wahren negativen Werte, die für Facet *d* vorhergesagt wurden
+ FPd sind die falsch positiven Ergebnisse, die für Facet *d* vorhergesagt wurden
+ FNd sind die falsch negativen Ergebnisse, die für Facet *D* vorhergesagt wurden
Nehmen wir zum Beispiel an, ein Modell genehmigt Kredite an 70 Antragsteller von Facet *a* von 100 und lehnt die anderen 30 ab. 10 hätte das Darlehen nicht angeboten werden dürfen (FPa) und 60 wurden genehmigt, die hätten sein sollen (TPa). 20 der Ablehnungen hätten genehmigt werden müssen (FNa) und 10 wurden korrekt abgelehnt (TNa). Die Genauigkeit für Facet *a* ist wie folgt:
ACCa = (60 \$1 10)/(60 \$1 10 \$1 20 \$1 10) = 0,7
Nehmen wir als Nächstes an, ein Modell genehmigt Kredite an 50 Antragsteller aus Facet *d* von 100 und lehnt die anderen 50 ab. 10 hätten das Darlehen nicht angeboten werden sollen (FPa) und 40 wurden genehmigt, die hätten sein sollen (TPa). 40 der Ablehnungen hätten genehmigt werden müssen (FNa) und 10 wurden korrekt abgelehnt (TNa). Die Genauigkeit für Facet *a* wird wie folgt bestimmt:
ACCd= (40 \$1 10)/(40 \$1 10 \$1 40 \$1 10) = 0.5
Der Genauigkeitsunterschied ist somit AD = ACCa – ACCd = 0.7 – 0.5 = 0.2. Dies deutet darauf hin, dass eine Verzerrung gegenüber der Facet *d* vorliegt, da die Metrik positiv ist.
Der Wertebereich für AD für binäre und mehrkategoriale Facetnbeschriftungen ist [-1, \$11].
+ Positive Werte treten auf, wenn die Vorhersagegenauigkeit für Facet *a* größer ist als die für Facet *d*. Das bedeutet, dass Facet *d* stärker unter einer Kombination von falsch positiven Ergebnissen (Fehler vom Typ I) oder falsch negativen Ergebnissen (Fehler vom Typ II) leidet. Das bedeutet, dass ein potenzieller Bias gegenüber der benachteiligten Facet *d* besteht.
+ Werte nahe Null treten auf, wenn die Vorhersagegenauigkeit für Facet *a* der für Facet *d* ähnlich ist.
+ Negative Werte treten auf, wenn die Vorhersagegenauigkeit für Facet *d* größer ist als die für Facet *a* t. Das bedeutet, dass Facet *a* stärker unter einer Kombination von falsch positiven Ergebnissen (Fehler vom Typ I) oder falsch negativen Ergebnissen (Fehler vom Typ II) leidet. Das bedeutet, dass es sich um einen Bias gegenüber der bevorzugten Facet *a* handelt.
# Gleichbehandlung (TE)
Die Gleichbehandlung (TE) ist der Unterschied im Verhältnis von falsch negativen zu falsch positiven Ergebnissen zwischen den Facetn *a* und *d*. Die Hauptidee dieser Kennzahl besteht darin, zu beurteilen, ob Fehler, auch wenn die Genauigkeit zwischen den Gruppen gleich ist, für eine Gruppe schädlicher sind als für eine andere? Die Fehlerquote ergibt sich aus der Summe der falsch positiven und falsch negativen Ergebnisse, aber die Aufschlüsselung dieser beiden kann je nach Facet sehr unterschiedlich sein. TE misst, ob Fehler in allen Facetn auf ähnliche oder unterschiedliche Weise kompensiert werden.
Die Formel für die Gleichbehandlung lautet wie folgt:
TE = FNd/FPd – FNa/FPa
Wobei Folgendes gilt:
+ FNd sind die falsch negativen Werte, die für Facet *d* vorhergesagt wurden.
+ FPd sind die falsch positiven Ergebnisse, die für Facet *d* vorhergesagt wurden.
+ FNa sind die falsch negativen Ergebnisse, die für Facet *a* vorhergesagt wurden.
+ FPa sind die falsch positiven Ergebnisse, die für Facet *a* vorhergesagt wurden.
Beachten Sie, dass die Metrik unbegrenzt ist, wenn FPa oder FPd Null ist.
Nehmen wir zum Beispiel an, es gibt 100 Kreditantragsteller aus Facet *a* und 50 aus Facet *d*. Für Facet *a* wurde 8 fälschlicherweise ein Darlehen verweigert (FNa) und weitere 6 wurden fälschlicherweise genehmigt (FPa). Die übrigen Vorhersagen waren wahr, also TPa \$1 TNa = 86. Für Facet *d* wurden 5 fälschlicherweise abgelehnt (FNd) und 2 fälschlicherweise genehmigt (FPd). Die übrigen Vorhersagen waren wahr, also TPd \$1 TNd = 43. Das Verhältnis von falsch negativen zu falsch positiven Ergebnissen beträgt 8/6 = 1,33 für Facet *a* und 5/2 = 2,5 für Facet *d*. Somit ist TE = 2,5 – 1,33 = 1,167, obwohl beide Facetn dieselbe Genauigkeit aufweisen:
ACCa = (86)/(86\$1 8 \$1 6) = 0.86
ACCd = (43)/(43 \$1 5 \$1 2) = 0.86
Der Wertebereich für Unterschiede bei der bedingten Ablehnung bei binären und mehrkategorialen Facetnbeschriftungen ist (-∞, \$1∞). Die TE-Metrik ist nicht für kontinuierliche Beschriftungen definiert. Die Interpretation dieser Metrik hängt von der relativen Bedeutung falsch positiver Ergebnisse (Fehler Typ I) und falsch negativer Werte (Fehler Typ II) ab.
+ Positive Werte liegen vor, wenn das Verhältnis von falsch negativen zu falsch positiven Ergebnissen für Facet *d* größer ist als für Facet *a*.
+ Werte nahe Null liegen vor, wenn das Verhältnis von falsch negativen zu falsch positiven Ergebnissen für Facet *a* dem für Facet *d* ähnlich ist.
+ Negative Werte liegen vor, wenn das Verhältnis von falsch negativen zu falsch positiven Ergebnissen für Facet *d* geringer ist als das für Facet *a*.
**Anmerkung**
In einer früheren Version wurde angegeben, dass die Metrik „Behandlungsgleichheit“ als FPa / FNa – FPd / FNd statt als FNd / FPd – FNa / FPa berechnet wird. Dabei kann jede der Versionen verwendet werden. Weitere Informationen finden Sie unter [https://pages.awscloud.com/rs/112-TZM-766/images/Fairness.Measures.for.Machine.Learning.in.Finance.pdf](https://pages.awscloud.com/rs/112-TZM-766/images/Fairness.Measures.for.Machine.Learning.in.Finance.pdf).
# Bedingte demografische Disparität bei prognostizierten Beschriftungen (CDDPL)
Die demografische Disparitätsmetrik (DDPL) bestimmt, ob die Facet *d* einen größeren Anteil an den vorhergesagten abgelehnten Beschriftungen als an den vorhergesagten akzeptierten Beschriftungen hat. Sie ermöglicht einen Vergleich der Unterschiede zwischen dem prognostizierten Ablehnungsanteil und dem prognostizierten Akzeptanzanteil zwischen den einzelnen Facetn. Diese Metrik entspricht exakt der CDD-Metrik vor dem Training, mit der Ausnahme, dass sie anhand der vorhergesagten und nicht anhand der beobachteten Werte berechnet wird. Diese Metrik liegt im Bereich (-1, \$11).
Die Formel für die Prognosen zur demografischen Disparität für Beschriftungen der Facet ** lautet wie folgt:
DDPLd = n'd(0)/n'(0) – n'd(1)/n'(1) = PdR(y'0) – PdA(y'1)
Wobei Folgendes gilt:
+ n'(0) = n'a(0) \$1 n'd(0) ist die Anzahl der vorhergesagten zurückgewiesenen Beschriftungen für die Facetn *a* und *d*.
+ n'(1) = n'a(1) \$1 n'd(1) ist die Anzahl der vorhergesagten akzeptierten Beschriftungen für die Facetn *a* und *d*.
+ PdR(y'0) ist der Anteil der vorhergesagten zurückgewiesenen Beschriftungen (Wert 0) in Facet *d*.
+ PdA(y'1) ist der Anteil der vorhergesagten akzeptierten Beschriftungen (Wert 1) in Facet *d*.
Um das Simpson-Paradoxon auszuschließen, ist eine CDDPL-Metrik (Vorhersehbare demografische Ungleichheit bei den vorhergesagten Beschriftungen) erforderlich, die DDPL anhand von Attributen konditioniert, die eine Schicht von Untergruppen im Datensatz definieren. Die Umgruppierung kann Aufschluss über die Ursache offensichtlicher demografischer Disparitäten bei benachteiligten Facetn geben. Der klassische Fall trat bei den Zulassungen in Berkeley auf, wo Männer insgesamt häufiger aufgenommen wurden als Frauen. Bei der Untersuchung der Untergruppen der einzelnen Abteilungen wurde jedoch festgestellt, dass Frauen nach Abteilungen höhere Zulassungsquoten aufwiesen als Männer. Die Erklärung dafür war, dass sich Frauen in Abteilungen mit niedrigeren Zulassungsquoten beworben hatten als Männer. Die Untersuchung der Akzeptanzquoten der Untergruppen ergab, dass Frauen in den Abteilungen mit niedrigeren Annahmequoten tatsächlich häufiger aufgenommen wurden als Männer.
Die CDDPL-Metrik liefert eine einzige Messgröße für alle Disparitäten, die in den durch ein Attribut eines Datensatzes definierten Untergruppen gefunden wurden, indem sie gemittelt werden. Sie ist definiert als gewichteter Durchschnitt der demografischen Disparitäten in vorhergesagten Kennzeichnungen (DDPLi) für jede der Untergruppen, wobei jede Untergruppendisparität proportional zur Anzahl der darin enthaltenen Beobachtungen gewichtet wird. Die Formel für die bedingte demografische Disparität in den Kategorien vorhergesagter Prognosen lautet wie folgt:
CDDPL = (1/n)\$1∑ini \$1DDPLi
Wobei Folgendes gilt:
+ ∑ini = n ist die Gesamtzahl der Beobachtungen und niist die Anzahl der Beobachtungen für jede Untergruppe.
+ DDPLi = n'i(0)/n(0) – n'i(1)/n(1) = PiR(y'0) – PiA(y'1) ist die demografische Disparität der vorhergesagten Beschriftungen für die Untergruppe.
Die demografische Disparität für eine Untergruppe in vorhergesagten Kennzeichnungen (DDPLi) ist also die Differenz zwischen dem Anteil der vorhergesagten abgelehnten Kennzeichnungen und dem Anteil der vorhergesagten akzeptierten Kennzeichnungen für jede Untergruppe.
Der Bereich der DDPL-Werte für binäre, mehrkategoriale und kontinuierliche Ergebnisse ist [-1, \$11].
+ \$11: wenn es keine vorhergesagten Ablehnungskennzeichnungen für Facet *a* oder Untergruppe und keine vorhergesagten Annahmen für Facet *d* oder Untergruppe gibt.
+ Positive Werte deuten auf demografische Unterschiede bei den vorhergesagten Beschriftungen hin, da Facet *d* oder Untergruppe einen größeren Anteil der vorhergesagten abgelehnten Beschriftungen als der vorhergesagten akzeptierten Beschriftungen hat. Je höher der Wert, desto größer die Disparität.
+ Werte nahe Null deuten darauf hin, dass im Durchschnitt keine demografische Disparität besteht.
+ Negative Werte deuten auf demografische Unterschiede bei den vorhergesagten Kennzeichnungen hin, da Facet *a* oder Untergruppe einen größeren Anteil der prognostizierten abgelehnten Kennzeichnungen als der vorhergesagten akzeptierten Kennzeichnungen hat. Je niedriger der Wert, desto größer die Disparität.
+ -1: wenn es für Facet *d* oder Untergruppe keine prognostizierten Abstoßungsreffer und für Facet *a* oder Untergruppe keine vorhergesagten Akzeptanzwerte gibt.
# Kontrafaktischer Fliptest (FT)
Der Fliptest ist ein Ansatz, bei dem jedes Mitglied der Facette *d* betrachtet und bewertet wird, ob ähnliche Mitglieder von Facette *a* unterschiedliche Modellvorhersagen haben. Die Mitglieder der Facette *a* werden so ausgewählt, dass sie die k-nächsten Nachbarn der Beobachtung aus Facette *d* sind. Wir beurteilen, wie viele der nächsten Nachbarn der gegenüberliegenden Gruppe eine andere Vorhersage erhalten, wobei die umgekehrte Vorhersage von positiv zu negativ und umgekehrt gehen kann.
Die Formel für den kontrafaktischen Fliptest ist der Unterschied in der Kardinalität zweier Sätze geteilt durch die Anzahl der Mitglieder der Facette *d*:
FT = (F\$1 – F-)/nd
Wobei Folgendes gilt:
+ F\$1 = ist die Anzahl der Mitglieder mit einem ungünstigen Ergebnis in der bevorzugten Facette *d*, deren nächste Nachbarn in der bevorzugten Facette *a* ein günstiges Ergebnis erzielt haben.
+ F- = ist die Anzahl der Mitglieder mit einem günstigen Ergebnis, deren nächste Nachbarn in *der* bevorzugten Facette *a* ein ungünstiges Ergebnis erzielt haben.
+ nd ist der Stichprobenumfang von Facette *d*.
Der Wertebereich für den kontrafaktischen Fliptest für binäre und mehrkategoriale Facettenbeschriftungen ist [-1, \$11]. Für kontinuierliche Beschriftungen legen wir einen Schwellenwert fest, um die Beschriftungen auf binäre Werte zu reduzieren.
+ Positive Werte liegen vor, wenn die Anzahl der ungünstigen kontrafaktischen Fliptest-Entscheidungen für die benachteiligte Facette *d* größer ist als die Anzahl der günstigen.
+ Werte nahe Null liegen vor, wenn sich die Anzahl der ungünstigen und der günstigen kontrafaktischen Fliptest-Entscheidungen ausgleicht.
+ Negative Werte liegen vor, wenn die Anzahl der ungünstigen kontrafaktischen Fliptest-Entscheidungen für die benachteiligte Facette *d* geringer ist als die Anzahl der günstigen.
# Generalisierte Entropie (GE)
Der generalisierte Entropieindex (GE) misst die Ungleichheit des Nutzens für das vorhergesagte Etikett im `b` Vergleich zum beobachteten Etikett. Ein Vorteil liegt vor, wenn ein falsch positiver Wert vorhergesagt wird. Ein falsch positives Ergebnis liegt vor, wenn aus einer negativen Beobachtung (y=0) eine positive Prognose (y'=1) resultiert. Ein Vorteil ergibt sich auch, wenn die beobachteten und vorhergesagten Markierungen identisch sind, was auch als richtig positiv und richtig negativ bezeichnet wird. Es entsteht kein Nutzen, wenn ein falsch negatives Ergebnis vorhergesagt wird. Ein falsch negatives Ergebnis liegt vor, wenn für eine positive Beobachtung (y=1) ein negatives Ergebnis prognostiziert wird (y'=0). Der Vorteil `b` ist wie folgt definiert.
```
b = y' - y + 1
```
Nach dieser Definition erhält ein falsch positives Ergebnis einen Vorteil `b` von `2` und ein falsch negatives Ergebnis einen Vorteil von `0`. Sowohl ein wirklich positives als auch ein echtes Negativ erhalten einen Vorteil von `1`.
Die GE-Metrik wird anhand des [Generalisierten Entropie-Index](https://en.wikipedia.org/wiki/Generalized_entropy_index) (GE) berechnet, wobei die Gewichtung `alpha` auf `2` eingestellt ist. Dieses Gewicht steuert die Sensitivität gegenüber unterschiedlichen Nutzenwerten. Ein kleinerer `alpha` bedeutet eine erhöhte Sensitivität gegenüber kleineren Werten.
![\[Gleichung, die den generalisierten Entropieindex definiert, wobei der Alpha-Parameter auf 2 gesetzt ist.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/clarify-post-training-bias-metric-ge.png)
Die folgenden Variablen, die zur Berechnung von GE verwendet werden, sind wie folgt definiert:
+ b i ist der Vorteil, den der `ith` Datenpunkt erhält.
+ b' ist der Mittelwert aller Leistungen.
GE kann im Bereich von 0 bis 0,5 liegen, wobei Werte von Null bedeuten, dass keine Ungleichheit der Leistungen über alle Datenpunkte hinweg besteht. Dies ist entweder der Fall, wenn alle Eingaben korrekt vorhergesagt wurden oder wenn alle Prognosen falsch positiv sind. GE ist undefiniert, wenn alle Vorhersagen falsch negativ sind.
**Anmerkung**
Die Metrik GE hängt nicht davon ab, ob ein Facettenwert entweder bevorzugt oder negativ bewertet wird.
# Erklärbarkeit des Modells
Amazon SageMaker Clarify bietet Tools, mit denen erklärt werden kann, wie Modelle für maschinelles Lernen (ML) Vorhersagen treffen. Diese Tools können ML-Modellierern und -Entwicklern sowie anderen internen Stakeholdern helfen, die Modellmerkmale vor der Bereitstellung als Ganzes zu verstehen und Vorhersagen zu debuggen, die das Modell nach der Bereitstellung liefert.
+ Erläuterungen zu Ihren Datensätzen und Modellen finden Sie unter [Fairness, Erklärbarkeit von Modellen und Erkennung von Verzerrungen mit Clarify SageMaker](clarify-configure-processing-jobs.md).
+ Informationen zum Abrufen von Erklärungen in Echtzeit von einem SageMaker KI-Endpunkt finden Sie unter[Online-Erklärbarkeit mit Clarify SageMaker](clarify-online-explainability.md).
Transparenz darüber, wie ML-Modelle zu ihren Prognosen gelangen, ist auch für Verbraucher und Aufsichtsbehörden von entscheidender Bedeutung. Sie müssen den Modellvorhersagen vertrauen können, wenn sie die auf ihnen basierenden Entscheidungen akzeptieren wollen. SageMaker Clarify verwendet einen modellunabhängigen Ansatz zur Zuordnung von Merkmalen. Sie können dies verwenden, um zu verstehen, warum ein Modell nach dem Training eine Vorhersage getroffen hat, und um während der Inferenz eine Erklärung pro Instance zu geben. Die Implementierung beinhaltet eine skalierbare und effiziente Implementierung von [SHAP](https://papers.nips.cc/paper/2017/file/8a20a8621978632d76c43dfd28b67767-Paper.pdf). Dies basiert auf dem Konzept eines Shapley-Werts aus dem Bereich der kooperativen Spieltheorie, der jedem Merkmal einen Wichtigkeitswert für eine bestimmte Vorhersage zuweist.
Clarify erstellt partielle Abhängigkeitsdiagramme (PDPs), die die marginalen Auswirkungen von Merkmalen auf das vorhergesagte Ergebnis eines Modells für maschinelles Lernen zeigen. Die partielle Abhängigkeit hilft bei der Erklärung der Zielreaktion anhand einer Reihe von Eingabemerkmalen. Sie unterstützt auch die Erklärbarkeit von Computer Vision (CV) und natürliche Sprachverarbeitung (NLP) unter Verwendung desselben Shapley-Wertealgorithmus (SHAP), der auch für tabellarische Datenerklärungen verwendet wird.
Was ist die Funktion einer Erklärung im Kontext des maschinellen Lernens? Eine Erklärung kann man sich als Antwort auf eine *Warum-Frage vorstellen*, die Menschen hilft, die Ursache einer Vorhersage zu verstehen. Im Kontext eines ML-Modells könnten Sie an der Beantwortung von Fragen wie den folgenden interessiert sein:
+ Warum hat das Modell für einen bestimmten Antragsteller ein negatives Ergebnis vorhergesagt, z. B. eine Ablehnung eines Kredits?
+ Wie macht das Modell Vorhersagen?
+ Warum hat das Modell eine falsche Vorhersage getroffen?
+ Welche Merkmale haben den größten Einfluss auf das Verhalten des Modells?
Mithilfe von Erläuterungen können Sie regulatorische Anforderungen prüfen und erfüllen, Vertrauen in das Modell aufbauen und menschliche Entscheidungen unterstützen sowie die Modellleistung debuggen und verbessern.
Entscheidend für die Art der Erklärung ist die Notwendigkeit, den Anforderungen an menschliches Verständnis über die Art und die Ergebnisse der ML-Inferenz gerecht zu werden. Forschungen aus philosophischen und kognitionswissenschaftlichen Disziplinen haben gezeigt, dass Menschen sich besonders für kontrastive Erklärungen interessieren, also Erklärungen, warum ein Ereignis X eingetreten ist, anstatt für ein anderes Ereignis Y, das nicht eingetreten ist. Hier könnte X ein unerwartetes oder überraschendes Ereignis sein, das eingetreten ist, und Y entspricht einer Erwartung, die auf ihrem bestehenden mentalen Modell basiert und als *Basislinie* bezeichnet wird. Beachten Sie, dass für dasselbe Ereignis X verschiedene Personen je nach ihrer Sichtweise oder ihrem mentalen Modell Y unterschiedliche Erklärungen suchen können. Im Zusammenhang mit erklärbarer KI können Sie sich X als das Beispiel vorstellen, das erklärt wird, und Y als Basislinie, die normalerweise ausgewählt wird, um ein nicht informatives oder durchschnittliches Beispiel im Datensatz darzustellen. Manchmal, zum Beispiel bei der ML-Modellierung von Bildern, kann die Basislinie implizit sein, wobei ein Bild, dessen Pixel alle dieselbe Farbe haben, als Basislinie dienen kann.
## Beispiel-Notebooks
Amazon SageMaker Clarify stellt zur besseren Erläuterung des Modells das folgende Musternotizbuch zur Verfügung:
+ [Amazon SageMaker Clarify Processing](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-clarify/index.html#sagemaker-clarify-processing) — Verwenden Sie SageMaker Clarify, um einen Verarbeitungsjob für die Erkennung von Verzerrungen und die Erklärung von Modellvorhersagen mit Feature-Attributionen zu erstellen. Beispiele hierfür sind die Verwendung der Datenformate CSV und JSON Lines, das Verwenden eines eigenen Containers und das Ausführen von Verarbeitungsaufträgen mit Spark.
+ [Erläuterung der Bildklassifizierung mit SageMaker SageMaker Clarify](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-clarify/computer_vision/image_classification/explainability_image_classification.ipynb) — Clarify bietet Ihnen Einblicke, wie Ihre Computer-Vision-Modelle Bilder klassifizieren.
+ [Erläuterung von Objekterkennungsmodellen mit SageMaker Clarify](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-clarify/computer_vision/object_detection/object_detection_clarify.ipynb) — SageMaker Clarify bietet Ihnen Einblicke in die Art und Weise, wie Ihre Computer-Vision-Modelle Objekte erkennen.
Es wurde verifiziert, dass dieses Notizbuch nur in Amazon SageMaker Studio ausgeführt werden kann. Anweisungen zum Öffnen eines Notizbuchs in Amazon SageMaker Studio finden Sie unter[Erstellen oder öffnen Sie ein Amazon SageMaker Studio Classic-Notizbuch](notebooks-create-open.md). Wenn Sie aufgefordert werden, einen Kernel auszuwählen, wählen Sie **Python 3 (Data Science)**.
**Topics**
+ [Beispiel-Notebooks](#clarify-model-explainability-sample-notebooks)
+ [Feature-Attributionen, die Shapley-Werte verwenden](clarify-shapley-values.md)
+ [Asymmetrische Shapley-Werte](clarify-feature-attribute-shap-asymm.md)
+ [SHAP-Baselines zur Erläuterbarkeit](clarify-feature-attribute-shap-baselines.md)
# Feature-Attributionen, die Shapley-Werte verwenden
SageMaker Clarify stellt Funktionszuweisungen bereit, die auf dem Konzept des [Shapley-Werts](https://en.wikipedia.org/wiki/Shapley_value) basieren. Sie können Shapley-Werte verwenden, um den Beitrag zu ermitteln, den jedes Merkmal zu Modellvorhersagen geleistet hat. Diese Zuschreibungen können für spezifische Vorhersagen und auf globaler Ebene für das gesamte Modell bereitgestellt werden. Wenn Sie beispielsweise ein ML-Modell für Hochschulzulassungen verwenden, können Sie anhand der Erläuterungen ermitteln, ob der Notendurchschnitt oder der SAT-Wert das Merkmal war, das am stärksten für die Vorhersagen des Modells verantwortlich war. Anschließend können Sie feststellen, wie verantwortlich jedes Merkmal für die Entscheidung über die Zulassung eines bestimmten Studenten war.
SageMaker Clarify hat das Konzept der Shapley-Werte aus der Spieltheorie übernommen und in einem Kontext für maschinelles Lernen eingesetzt. Der Shapley-Wert bietet eine Möglichkeit, den Beitrag jedes Spielers zu einem Spiel zu quantifizieren und somit die Möglichkeit, den durch ein Spiel generierten Gesamtgewinn auf der Grundlage ihrer Beiträge an die Spieler zu verteilen. In diesem Kontext des maschinellen Lernens behandelt SageMaker Clarify die Vorhersage des Modells auf einer bestimmten Instanz als das *Spiel* und die im Modell enthaltenen Funktionen als die *Spieler*. In einer ersten Annäherung könnte man versucht sein, den marginalen Beitrag oder Effekt jedes Merkmals zu bestimmen, indem man das Ergebnis des *Entfernens* dieses Merkmals aus dem Modell oder des *Entfernens* aller anderen Merkmale aus dem Modell quantifiziert. Bei diesem Ansatz wird jedoch nicht berücksichtigt, dass die in einem Modell enthaltenen Merkmale häufig nicht unabhängig voneinander sind. Wenn beispielsweise zwei Merkmale stark korreliert sind, kann es sein, dass die Modellvorhersage nicht wesentlich verändert wird, wenn eines der Merkmale weggelassen wird.
Um diesen potenziellen Abhängigkeiten Rechnung zu tragen, erfordert der Shapley-Wert, dass das Ergebnis jeder möglichen Kombination (oder Koalition) von Merkmalen berücksichtigt werden muss, um die Bedeutung der einzelnen Merkmale zu bestimmen. Bei gegebenen *d* Merkmalen gibt es 2 d solcher möglichen Merkmalskombinationen, von denen jede einem potenziellen Modell entspricht. Um die Zuordnung für ein bestimmtes Merkmal *f* zu bestimmen, berücksichtigen Sie den marginalen Beitrag, den die Einbeziehung von *f* in alle Merkmalskombinationen (und zugehörigen Modelle), die *f* nicht enthalten, mit einbezieht, und nehmen Sie den Durchschnitt. Es kann gezeigt werden, dass der Shapley-Wert die einzigartige Methode ist, den Beitrag oder die Wichtigkeit jedes Merkmals zuzuweisen, das bestimmte wünschenswerte Eigenschaften erfüllt. Insbesondere entspricht die Summe der Shapley-Werte jedes Merkmals der Differenz zwischen den Vorhersagen des Modells und einem Scheinmodell ohne Merkmale. Aber selbst für vernünftige Werte von *d*, sagen wir 50 Merkmale, ist es rechnerisch unerschwinglich und nicht praktikabel, mögliche 2d-Modelle zu trainieren. Aus diesem Grund muss SageMaker Clarify verschiedene Näherungstechniken verwenden. Zu diesem Zweck verwendet SageMaker Clarify Shapley Additive Explanations (SHAP), das solche Näherungen berücksichtigt und durch zusätzliche Optimierungen eine skalierbare und effiziente Implementierung des Kernel-SHAP-Algorithmus entwickelt hat.
Weitere Informationen zu Shapley-Werten finden Sie unter [Ein einheitlicher Ansatz zur Interpretation von Modellvorhersagen.](https://papers.nips.cc/paper/2017/file/8a20a8621978632d76c43dfd28b67767-Paper.pdf)
# Asymmetrische Shapley-Werte
Die SageMaker Clarify-Lösung zur Erklärung von Zeitreihenprognosemodellen ist eine Methode zur Zuordnung von Merkmalen, die auf der [kooperativen Spieltheorie basiert und im Geiste SHAP ähnelt](https://en.wikipedia.org/wiki/Cooperative_game_theory). Insbesondere verwendet Clarify [Gruppenwerte in zufälliger Reihenfolge](http://www.library.fa.ru/files/Roth2.pdf#page=121), die beim maschinellen Lernen und bei der Erklärbarkeit auch als [asymmetrische Shapley-Werte](https://proceedings.neurips.cc/paper/2020/file/0d770c496aa3da6d2c3f2bd19e7b9d6b-Paper.pdf) bezeichnet werden.
## Hintergrund
*Ziel ist es, Zuordnungen von Eingabe-Features zu einem bestimmten Prognosemodell f zu berechnen.* Das Prognosemodell verwendet die folgenden Eingaben:
+ Vergangene Zeitreihen *(Ziel TS)*. *Dabei könnte es sich beispielsweise um ehemalige tägliche Zugpassagiere auf der Strecke Paris-Berlin handeln, die mit x gekennzeichnet ist. t*
+ (Optional) Eine kovariate Zeitreihe. Dies könnten beispielsweise Feierlichkeiten und Wetterdaten sein, die mit *z t* ∈ R S bezeichnet werden. Bei Verwendung könnte die Kovariate TS nur für die vergangenen Zeitschritte oder auch für die future Zeitschritte (im Festkalender enthalten) verfügbar sein.
+ (Optional) Statische Kovariaten, z. B. Servicequalität (wie 1. oder 2. Klasse), bezeichnet mit *u* ∈ R E.
Statische Kovariaten, dynamische Kovariaten oder beides können je nach Anwendungsszenario weggelassen werden. Bei einem Prognosehorizont K ≥ 0 (z. B. K=30 Tage) kann die Modellvorhersage durch die Formel charakterisiert werden: *f (x[1:T], z[1:T\$1K], u*) = x. [T\$11:T \$1K\$11]
Das folgende Diagramm zeigt eine Abhängigkeitsstruktur für ein typisches Prognosemodell. Die Vorhersage zum Zeitpunkt *t\$11* hängt von den drei zuvor genannten Eingangstypen ab.
![\[Abhängigkeitsstruktur für ein typisches Prognosemodell.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/clarify/clarify-forecast-dependency.png)
## Methode
Erklärungen werden berechnet, indem das Zeitreihenmodell *f* anhand einer Reihe von Punkten abgefragt wird, die aus der ursprünglichen Eingabe abgeleitet wurden. Anhand spieltheoretischer Konstruktionen werden die Durchschnittswerte der Unterschiede zwischen den Vorhersagen geklärt, wobei Teile der Eingaben iterativ verschleiert (d. h. auf einen Basiswert festgelegt) werden. Durch die zeitliche Struktur kann in chronologischer oder antichronologischer Reihenfolge oder in beidem navigiert werden. Chronologische Erklärungen werden erstellt, indem iterativ Informationen aus dem ersten Zeitschritt hinzugefügt werden, während Informationen aus dem letzten Schritt antichronologisch hinzugefügt werden. Letzteres Modell ist möglicherweise besser geeignet, wenn es um Verzerrungen in jüngster Zeit geht, z. B. bei der Prognose von Aktienkursen. Eine wichtige Eigenschaft der berechneten Erklärungen besteht darin, dass sie in ihrer Summe den Output des ursprünglichen Modells ergeben, wenn das Modell deterministische Ergebnisse liefert.
## Daraus resultierende Zuschreibungen
Bei den resultierenden Attributionen handelt es sich um Punktzahlen, die einzelne Beiträge bestimmter Zeitintervalle oder Eingabe-Features zur endgültigen Prognose in jedem prognostizierten Zeitschritt kennzeichnen. Clarify bietet zur Erläuterung die folgenden zwei Granularitäten an:
+ Zeitliche Erklärungen sind kostengünstig und geben nur Auskunft über bestimmte Zeitschritte, z. B. wie viel die Informationen des 19. Tages in der Vergangenheit zur Prognose des ersten Tages in der future beigetragen haben. Diese Zuschreibungen erklären keine individuellen statischen Kovariaten und aggregierten Erklärungen von Ziel- und kovariaten Zeitreihen. *Bei den Attributionen handelt es sich um eine Matrix *A*, wobei jedes *A tk* die Zuordnung des Zeitschritts *t zur Prognose des Zeitschritts T\$1k* darstellt.* *Beachten Sie, dass t größer als *T* sein kann, wenn das Modell future Kovariaten akzeptiert.*
+ Präzise Erklärungen sind rechenintensiver und bieten eine vollständige Aufschlüsselung aller Attributionen der Eingabevariablen.
**Anmerkung**
Feinkörnige Erklärungen unterstützen nur die chronologische Reihenfolge.
Die sich daraus ergebenden Zuschreibungen sind ein Triplett, das sich wie folgt zusammensetzt:
+ *Matrix *A x* ∈ R T×K bezogen auf die Eingabezeitreihe, wobei *A tk x die Zuordnung von *x t** zum Prognoseschritt T\$1k ist*
+ *Tensor *A z* ∈ *R T\$1K×S×K* bezieht sich auf die kovariate Zeitreihe, wobei *A tsk z die Zuordnung von *z ts** (d. h. der ersten Kovariate TS) zum Prognoseschritt T\$1k ist*
+ *Matrix *A u* ∈ R E×K bezieht sich auf die statischen Kovariaten, wobei *A ek u die Zuordnung von *u e** (der zehnten statischen Kovariate) zum Prognoseschritt T\$1k ist*
Unabhängig von der Granularität enthält die Erklärung auch einen Offsetvektor *B* ∈ *R K*, der das „grundlegende Verhalten“ des Modells darstellt, wenn alle Daten verschleiert sind.
# SHAP-Baselines zur Erläuterbarkeit
Die Erklärungen sind in der Regel kontrastiv (d. h. sie berücksichtigen Abweichungen von einer Ausgangsbasis). Daher können Sie für dieselbe Modellvorhersage davon ausgehen, dass Sie unterschiedliche Erklärungen in Bezug auf unterschiedliche Ausgangswerte erhalten. Daher ist die Wahl einer Basislinie von entscheidender Bedeutung. In einem ML-Kontext entspricht die Baseline einer hypothetischen Instance, die entweder *nicht informativ* oder *informativ* sein kann. Während der Berechnung von Shapley-Werten generiert SageMaker Clarify mehrere neue Instanzen zwischen der Basislinie und der jeweiligen Instanz, in denen das Fehlen eines Merkmals modelliert wird, indem der Merkmalswert auf den Wert der Basislinie gesetzt wird, und das Vorhandensein eines Merkmals wird modelliert, indem der Merkmalswert auf den Wert der jeweiligen Instanz gesetzt wird. Somit entspricht das Fehlen aller Features der Basislinie und das Vorhandensein aller Features entspricht der gegebenen Instance.
Wie kann man gute Baselines wählen? Oft ist es wünschenswert, eine Ausgangsbasis mit sehr geringem Informationsgehalt zu wählen. Sie können beispielsweise aus dem Trainingsdatensatz eine Durchschnitts-Instance erstellen, indem Sie entweder den Median oder den Durchschnitt für numerische Merkmale und den Modus für kategoriale Merkmale verwenden. Für das Beispiel mit den Hochschulzulassungen könnte es für Sie von Interesse sein, zu erklären, warum ein bestimmter Bewerber zugelassen wurde, im Vergleich zu den Basiszulassungen, die auf einem durchschnittlichen Bewerber basieren. Falls nicht angegeben, wird eine Basislinie automatisch von SageMaker Clarify unter Verwendung von K-Means oder K-Prototypen im Eingabedatensatz berechnet.
Alternativ können Sie Erklärungen zu informativen Basislinien erstellen. Für das Zulassungsszenario an Hochschulen möchten Sie vielleicht erläutern, warum ein bestimmter Bewerber im Vergleich zu anderen Bewerbern mit ähnlichem demografischem Hintergrund abgelehnt wurde. In diesem Fall können Sie eine Ausgangsbasis wählen, die die Bewerber repräsentiert, die für Sie von Interesse sind, d. h. Bewerber mit einem ähnlichen demografischen Hintergrund. Auf diese Weise können Sie aussagekräftige Basiswerte verwenden, um die Analyse auf die spezifischen Aspekte einer bestimmten Modellvorhersage zu konzentrieren. Sie können die Merkmale für die Bewertung isolieren, indem Sie demografische Merkmale und andere Merkmale, auf die Sie nicht reagieren können, auf denselben Wert wie in der jeweiligen Instance festlegen.
# SageMaker Klären Sie die Erklärbarkeit mit AI Autopilot SageMaker
Autopilot verwendet von Amazon SageMaker Clarify bereitgestellte Tools, um Einblicke in die Art und Weise zu geben, wie Modelle für maschinelles Lernen (ML) Vorhersagen treffen. Diese Tools können ML-Ingenieuren, Produktmanagern und anderen internen Stakeholdern helfen, Modellmerkmale zu verstehen. Um Entscheidungen, die auf Modellprognosen basieren, vertrauen und interpretieren zu können, sind sowohl Verbraucher als auch Regulierungsbehörden auf Transparenz im Bereich von Machine Learning angewiesen.
Die Erklärungsfunktion des Autopiloten verwendet einen modellunabhängigen Ansatz zur Zuordnung von Merkmalen. Dieser Ansatz bestimmt den Beitrag einzelner Merkmale oder Eingaben zur Ausgabe des Modells und bietet so Einblicke in die Relevanz verschiedener Merkmale. Sie können ihn verwenden, um zu verstehen, warum ein Modell nach dem Training eine Vorhersage getroffen hat, oder Sie können ihn verwenden, um während der Inferenz eine Erklärung pro Instance zu liefern. Die Implementierung beinhaltet eine skalierbare Implementierung von [SHAP](https://papers.nips.cc/paper/2017/file/8a20a8621978632d76c43dfd28b67767-Paper.pdf) (Shapley Additive Explanations). Dies basiert auf dem Konzept eines Shapley-Werts aus dem Bereich der kooperativen Spieltheorie, der jedem Feature einen Wichtigkeitswert für eine bestimmte Vorhersage zuweist.
Sie können diese SHAP-Erklärungen verwenden, um regulatorische Anforderungen zu prüfen und zu erfüllen, Vertrauen in das Modell aufzubauen, menschliche Entscheidungen zu unterstützen oder die Modellleistung zu debuggen und zu verbessern.
Weitere Informationen zu Shapely-Werten und -Baselines finden Sie unter [SHAP-Baselines für Erklärbarkeit](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-feature-attribute-shap-baselines.html).
Eine Anleitung zur Amazon SageMaker Clarifesty-Dokumentation finden Sie unter [Leitfaden zur SageMaker Clarify-Dokumentation](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html#clarify-fairness-and-explainability-toc).