Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# 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 der 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 Format > SageMaker AI JSON Lines Dense 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 Beispiel-Notizbuch 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 vom SageMaker Clariy-Prozessor gesendeten Nutzdaten steuern. 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\_template 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 {'predictions [\*] .mean [:2] '}} `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` damit 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.