Führen Sie SageMaker Clarify Processing Jobs für Verzerrungsanalyse und Erklärbarkeit aus

Die folgenden Beispiele zeigen, wie Sie die Verzerrungsanalyse und die Erklärbarkeitsanalyse für einen tabellarischen Datensatz im Format konfigurieren. CSV 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 URI aus einer Datensatzdatei oder einem Amazon S3 URI S3-Präfix stammen. Wenn Sie ein URI S3-Präfix angeben, sammelt der SageMaker Clarify-Verarbeitungsauftrag rekursiv alle Amazon S3 S3-Dateien, die sich unter dem Präfix befinden. Der Wert für s3_output_path sollte ein URI S3-Präfix sein, das die Analyseergebnisse enthält. SageMaker verwendet das s3_output_path während der Kompilierung und kann keinen Wert eines SageMaker Pipeline-Parameters, einer Eigenschaft, eines Ausdrucks oder annehmenExecutionVariable, die zur Laufzeit verwendet werden. 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 Messwerte für Verzerrungen vor dem Training für einen Datensatz CSV

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 vor dem Training vorgenommenen Bias-Metriken 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 und den Unterschied in den Proportionen von Labels zu berechnen.

Wie berechnet man alle Messwerte für Verzerrungen nach dem Training für einen Datensatz CSV

Sie können vor dem Training Messwerte für Verzerrungen vor dem Training berechnen. Um Messwerte für Verzerrungen nach dem Training 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 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 Parametersdataset_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 und ungleichen Auswirkungen zu berechnen.

Wie berechnet man alle Messwerte für Verzerrungen für einen Datensatz CSV

Das folgende Konfigurationsbeispiel zeigt, wie alle Verzerrungsmetriken 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 with Clarify. SageMaker

Wie berechnet man SHAP Werte für einen CSV Datensatz

SageMaker Clarify stellt Feature-Attributionen mithilfe des SHAPKernel-Algorithmus bereit. SHAP Die Analyse erfordert den Wahrscheinlichkeitswert oder die Punktzahl anstelle des vorhergesagten Labels, sodass dieses ModelPredictedLabelConfig Objekt über einen Wahrscheinlichkeitsindex 1 verfügt. 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 Objekt bietet SHAPConfig SHAP Analyseparameter. In diesem Beispiel ist der SHAP baselineDer Parameter wird weggelassen und der Wert des num_clusters Parameters ist1. Dadurch wird der SageMaker Clarify Processor angewiesen, einen zu berechnen SHAP Ausgangsstichprobe, die auf der Clusterbildung des Eingabedatensatzes basiert. Informationen zur Auswahl des Basisdatensatzes finden Sie unter SHAP Baselines für die Erklärbarkeit.

shap_config = clarify.SHAPConfig(
    num_clusters=1,
)

Im folgenden Codebeispiel wird ein SageMaker Clarif-Verarbeitungsauftrag zur Berechnung gestartet SHAP Werte.

clarify_processor.run_explainability(
    data_config=data_config,
    model_config=model_config,
    model_scores=probability_config,
    explainability_config=shap_config,
)

Für ein Beispiel-Notizbuch mit Anweisungen zum Ausführen eines SageMaker Clarif-Verarbeitungsauftrags in SageMaker Studio Classic zur Berechnung SHAP Werte finden Sie unter Fairness und Erklärbarkeit mit Clarify. SageMaker

Wie berechnet man partielle Abhängigkeitsdiagramme (PDPs) für einen CSV Datensatz

PDPs zeigt die Abhängigkeit der vorhergesagten Zielreaktion von einem oder mehreren interessierenden Eingabemerkmalen, während alle anderen Merkmale konstant gehalten werden. Eine nach oben geneigte Linie oder Kurve in der gibt anPDP, 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 Verarbeitungsauftrag SageMaker Clarify anzuweisen, die Wichtigkeit des Features 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 SageMaker Clarify-Verarbeitungsauftrag wird generiert PDPs zur 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 gestartet PDPs.

clarify_processor.run_explainability(
    data_config=data_config,
    model_config=model_config,
    model_scores=probability_config,
    explainability_config=pdp_config,
)

Zum Beispiel ein Notizbuch mit Anweisungen zum Ausführen eines SageMaker Clarif-Verarbeitungsauftrags in SageMaker Studio Classic zur Berechnung PDPs, siehe Erklärbarkeit mit SageMaker Clarify — Partielle Abhängigkeitsdiagramme () PDP.

Wie berechnet man beide SHAP Werte und PDPs für einen CSV Datensatz

Sie können beide berechnen SHAP Werte und PDPs in einem einzigen SageMaker Clarif-Verarbeitungsauftrag. Im folgenden Konfigurationsbeispiel ist der top_k_features Parameter eines neuen PDPConfig Objekts auf 2 gesetzt. Dadurch wird der SageMaker Clarify-Verarbeitungsauftrag angewiesen, folgende Berechnungen durchzuführen PDPs für die 2 Funktionen, die weltweit den größten Wert haben SHAP Werte.

shap_pdp_config = clarify.PDPConfig(
    top_k_features=2,
    grid_resolution=10,
)

Im folgenden Codebeispiel wird ein SageMaker Clarif-Verarbeitungsauftrag gestartet, um beide zu berechnen SHAP Werte und PDPs.

clarify_processor.run_explainability(
    data_config=data_config,
    model_config=model_config,
    model_scores=probability_config,
    explainability_config=[shap_config, shap_pdp_config],
)

Die folgenden Beispiele zeigen, wie die Verzerrungsanalyse und die Erklärbarkeitsanalyse für einen tabellarischen Datensatz im Format > SageMaker JSON Liniendichte konfiguriert werden. Weitere Informationen finden Sie unter JSONLINESFormat der Anfrage. In diesen Beispielen enthält der eingehende Datensatz dieselben Daten wie im vorherigen Abschnitt, jedoch im JSON Format Linien. 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 JMESPathAusdruck 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. Bei dem s3_data_input_path Parameter kann es sich entweder um eine URI Datensatzdatei oder um ein Amazon S3 URI S3-Präfix handeln. Wenn Sie ein URI S3-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 URI S3-Präfix sein, das die Analyseergebnisse enthält. SageMaker verwendet das s3_output_path während der Kompilierung und kann keinen Wert eines SageMaker Pipeline-Parameters, einer Eigenschaft, eines Ausdrucks oder annehmenExecutionVariable, die zur Laufzeit verwendet werden.

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 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 wirdprobability. Dadurch wird die Punktzahl aus der Modellausgabe extrahiert.

probability_config = clarify.ModelPredictedLabelConfig(
    probability='probability',
)

Verwenden Sie dieselben Run-Anweisungen und Konfigurationsobjekte wie im JSON vorherigen Abschnitt für Datensätze, um Messwerte für systematische Abweichungen und die Bedeutung von Merkmalen für CSV Datensätze zu berechnen. Sie können in SageMaker Studio Classic einen SageMaker Clarif-Verarbeitungsauftrag ausführen, um Abweichungen zu erkennen und die Wichtigkeit von Merkmalen zu berechnen. Eine Anleitung und ein Beispiel-Notizbuch finden Sie unter Fairness and Explainability with SageMaker Clarify (JSONLines Format).

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 NLP Explainability 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. NLPDie Erklärbarkeit multimodaler Datensätze kann Ihnen helfen zu verstehen, wie wichtig jedes Feature 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ürNLP. 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 Eingabe-Dataset im CSV Format und im Ausgabedatenpfad angegeben wird.

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 es sich bei dem s3_data_input_path Parameter entweder um eine URI Datensatzdatei oder um ein Amazon S3 URI S3-Präfix handeln. Wenn Sie ein URI S3-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 URI S3-Präfix sein, das die Analyseergebnisse enthält. SageMaker verwendet das s3_output_path während der Kompilierung und kann keinen Wert eines SageMaker Pipeline-Parameters, einer Eigenschaft, eines Ausdrucks oder annehmenExecutionVariable, die zur Laufzeit verwendet werden.

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 Modells konfiguriert wird. In diesem Beispiel stellt ein kurzlebiger Endpunkt das Modell bereit. Dieser Endpunkt verwendet eine ml.g4dn.xlarge InferenzinstanzGPU, die mit a für beschleunigte Inferenzen ausgestattet ist.

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,
)

Das folgende Beispiel SHAP Die Konfiguration zeigt, wie anhand eines Tokens eine erklärbare Analyse anhand eines Modells und eines Eingabedatensatzes in englischer Sprache durchgefü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 Erklärbarkeitsanalyse. NLP 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 spaCyDokumentation zur Tokenisierung, die SageMaker Clarify für die Verarbeitung verwendet. NLP Das vorherige Beispiel zeigt auch, wie ein Durchschnittswert Rating von verwendet wird, 4 um einen direkten Wert festzulegen SHAP Basisinstanz. 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 gestartet SHAP Werte.

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 zur NLP Erklärbarkeitsanalyse finden Sie unter Erläuterung der Text-Sentimentanalyse mithilfe von Clarify. SageMaker

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 Amazon S3 URI S3-Präfix. Der Verarbeitungsauftrag SageMaker Clarify sammelt rekursiv alle Bilddateien, die sich unter dem Präfix befinden. Der s3_data_input_path Parameter kann entweder URI aus einer Datensatzdatei oder einem Amazon S3 URI S3-Präfix stammen. Wenn Sie ein URI S3-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 URI S3-Präfix sein, das die Analyseergebnisse enthält. SageMaker verwendet das s3_output_path während der Kompilierung und kann keinen Wert eines SageMaker Pipeline-Parameters, einer Eigenschaft, eines Ausdrucks oder annehmenExecutionVariable, die zur Laufzeit verwendet werden.

Wie erklärt man ein Modell zur Bildklassifizierung

Der Verarbeitungsjob SageMaker Clarify erklärt Bilder mithilfe des SHAP Kernel-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 SageMaker Bildklassifizierungsmodells konfiguriert wird. Weitere Informationen finden Sie unter Bildklassifizierung - MXNet.

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 Namenyour_cv_ic_model, darauf trainiert, die Tiere anhand von Eingabebildern zu klassifizieren. JPEG Das ModelConfig Objekt im vorherigen Beispiel weist den Verarbeitungsauftrag SageMaker Clarify an, das SageMaker Modell auf einem kurzlebigen Endpunkt bereitzustellen. Für beschleunigte Inferenzen verwendet der Endpunkt eine Inferenzinstanz, die mit einem ml.p2.xlarge ausgestattet ist. GPU

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.

Das folgende Beispiel SHAP Die Konfiguration 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) 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 ist lokal SHAP Werte werden für jedes Segment 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 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=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.

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:

Im folgenden Konfigurationsbeispiel your_cv_od_model wird ein SageMaker 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 Verarbeitungsauftrag SageMaker Clarify an, das SageMaker Modell auf einem kurzlebigen Endpunkt bereitzustellen. Für beschleunigte Bildgebung verwendet dieser Endpunkt eine ml.p2.xlarge Inferenzinstanz, die mit einem ausgestattet ist. GPU

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'],
)

Das folgende Beispiel SHAP Die Konfiguration 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 Konfigurationsdateien für die Analyse.

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 Clarify.

Die folgenden Beispiele zeigen, wie Daten in einem SageMaker JSON dichten Format konfiguriert werden, um ein Zeitreihenprognosemodell zu erläutern. Weitere Informationen zur JSON Formatierung finden Sie unterJSONAnforderungsformat.

[
    {
        "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 verwendetAsymmetricShapleyValueConfig, 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 die Merkmalsattributionen für jeweils ein Element berechnet werden. Die folgende Konfiguration zeigt eine Beispieldefinition 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 in methods with key an die Analysekonfiguration übergebenasymmetric_shapley_value.

Modellkonfiguration

Sie können die Struktur der Nutzdaten steuern, die vom SageMaker Clarify-Prozessor gesendet werden. 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, und interne Token sind $target_time_series$related_time_series, die verwendet $static_covariates 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 inTimeSeriesModelConfig, das mit dem Schlüssel an die Analysekonfiguration übergeben wirdtime_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] '}} lautet, wird der Prognosewert wie folgt analysiert: forecast

[[13.4, 3.6], [23.0, 4.7], [3.4, 5.6]]