Übersicht
In diesem Tutorial lernen Sie, wie Sie ein Machine Learning (ML)-Modell mithilfe von Amazon SageMaker Studio und Amazon SageMaker Clarify trainieren, abstimmen und auswerten.
Amazon SageMaker Studio ist eine integrierte Entwicklungsumgebung (IDE) für ML, welche eine vollständig verwaltete Jupyter-Notebook-Schnittstelle bietet, in der Sie den gesamten ML-Lebenszyklus durchführen können. Mit SageMaker Studio können Sie Datensätze erstellen und untersuchen, Trainingsdaten vorbereiten, Modelle erstellen, trainieren und abstimmen und trainierte Modelle für Inferenzen bereitstellen – alles an einem Ort. Mit Amazon SageMaker Clarify haben Sie einen besseren Einblick in Ihre Trainingsdaten und Modelle, sodass Sie Verzerrungen erkennen und einschränken und Vorhersagen erklären können.
In diesem Tutorial verwenden Sie einen synthetisch generierten Datensatz für Kfz-Versicherungsansprüchen. Die Eingaben sind die Trainings-, Validierungs- und Testdatensätze, die jeweils Details und extrahierte Merkmale zu Ansprüchen und Kunden sowie eine Betrugsspalte enthalten, die angibt, ob ein Anspruch betrügerisch war oder nicht. Sie werden das Open-Source-Framework XGBoost verwenden, um ein binäres Klassifizierungsmodell auf diesem synthetischen Datensatz zu erstellen, um die Wahrscheinlichkeit einer betrügerischen Forderung vorherzusagen. Außerdem werden Sie das trainierte Modell auswerten, indem Sie Berichte über Verzerrungen und die Merkmalsbedeutung ausführen, das Modell zum Testen bereitstellen und Stichprobeninferenzen ausführen, um die Modellleistung zu bewerten und Vorhersagen zu erklären.
Was Sie erreichen werden
In diesem Leitfaden werden Sie:
- ein Modell im Skriptmodus erstellen, trainieren und optimieren;
- Verzerrungen in ML-Modellen erkennen und Modellprognosen verstehen;
- das trainierte Modell an einem Echtzeit-Inferenz-Endpunkt zum Testen bereitstellen;
- das Modell durch die Generierung von Probevorhersagen auswerten und die Auswirkungen von Merkmalen verstehen.
Voraussetzungen
Bevor Sie mit diesem Leitfaden beginnen, benötigen Sie:
- Ein AWS-Konto: Wenn Sie noch kein Konto haben, folgen Sie dem Leitfaden für die ersten Schritte zum Einrichten Ihrer Umgebung, um einen schnellen Überblick zu erhalten.
Erfahrung mit AWS
Einsteiger
Benötigte Zeit
2 Stunden
Veranschlagte Kosten
Siehe SageMaker-Preise, um die Kosten für dieses Tutorial abzuschätzen.
Erfordert
Sie müssen bei einem AWS-Konto angemeldet sein.
Verwendete Services
Amazon SageMaker Studio, Amazon SageMaker Clarify
Letzte Aktualisierung
03. Mai 2022
Implementierung
Schritt 1: Einrichten Ihrer Amazon-SageMaker-Studio-Domäne
Mit Amazon SageMaker können Sie ein Modell visuell über die Konsole oder programmgesteuert mithilfe von SageMaker Studio oder SageMaker-Notebooks bereitstellen. In diesem Tutorial stellen Sie das Modell programmgesteuert mithilfe eines SageMaker-Studio-Notebooks bereit, wofür eine SageMaker-Studio-Domäne erforderlich ist.
Ein AWS-Konto kann nur eine SageMaker-Studio-Domäne pro Region haben. Wenn Sie bereits eine SageMaker Studio-Domäne in der Region USA Ost (Nord-Virginia) haben, folgen Sie dem Einrichtungsleitfaden zu SageMaker Studio, um die erforderlichen AWS-IAM-Richtlinien mit Ihrem SageMaker-Studio-Konto zu verknüpfen, überspringen Sie dann Schritt 1 und fahren Sie direkt mit Schritt 2 fort.
Wenn Sie keine bestehende SageMaker-Studio-Domäne haben, fahren Sie mit Schritt 1 fort, um eine AWS-CloudFormation-Vorlage auszuführen, die eine SageMaker-Studio-Domäne erstellt und die für den Rest dieses Tutorials erforderlichen Berechtigungen hinzufügt.
Wählen Sie den Link AWS-CloudFormation-Stack. Dieser Link öffnet die AWS-CloudFormation-Konsole und erstellt Ihre SageMaker-Studio-Domäne und einen Benutzer mit dem Namen studio-user. Er fügt auch die erforderlichen Berechtigungen zu Ihrem SageMaker-Studio-Konto hinzu. Bestätigen Sie in der CloudFormation-Konsole, dass USA Ost (Nord-Virginia) die Region ist, die in der oberen rechten Ecke angezeigt wird. Der Stack-Name sollte CFN-SM-IM-Lambda-catalog lauten und sollte nicht geändert werden. Dieser Stack benötigt etwa 10 Minuten, um alle Ressourcen zu erstellen.
Dieser Stack geht davon aus, dass Sie bereits eine öffentliche VPC in Ihrem Konto eingerichtet haben. Wenn Sie keine öffentliche VPC haben, lesen Sie VPC mit einem einzigen öffentlichen Subnetz, um zu erfahren, wie Sie eine öffentliche VPC erstellen können.
Wählen Sie Ich bestätige, dass AWS CloudFormation möglicherweise IAM-Ressourcen erstellt und wählen Sie dann Stack erstellen aus.
Wählen Sie im Bereich CloudFormation die Option Stacks. Es dauert etwa 10 Minuten, bis der Stack erstellt ist. Wenn der Stack erstellt wird, ändert sich der Status des Stacks von CREATE_IN_PROGRESS zu CREATE_COMPLETE.
Schritt 2: Einrichten eines SageMaker Studio-Notebooks
In diesem Schritt starten Sie ein neues SageMaker-Studio-Notebook, installieren die erforderlichen Open-Source-Bibliotheken und richten die SageMaker-Variablen ein, die für die Interaktion mit anderen Services erforderlich sind, einschließlich Amazon Simple Storage Service (Amazon S3).
Geben Sie SageMaker Studio in die Suchleiste der Konsole ein und wählen Sie dann SageMaker Studio.
Wählen Sie USA Ost (Nord-Virginia) aus der Dropdown-Liste Region in der oberen rechten Ecke der SageMaker-Konsole. Wählen Sie für App starten die Option Studio, um SageMaker Studio mit dem studio-user-Profil zu öffnen.
Öffnen Sie die Oberfläche von SageMaker Studio. Wählen Sie in der Navigationsleiste Datei, Neu, Notebook.
Wählen Sie im Dialogfeld Notebook-Umgebung einrichten unter Image die Option Data Science. Der Python 3-Kernel wird automatisch ausgewählt. Wählen Sie Auswählen.
Der Kernel in der oberen rechten Ecke des Notebooks sollte nun Python 3 (Data Science) anzeigen.
Um bestimmte Versionen der Open-Source-Bibliotheken XGBoost und Pandas zu installieren, kopieren Sie den folgenden Codeausschnitt, fügen Sie ihn in eine Zelle im Notebook ein und drücken Sie die Kombination Umschalt+Eingabe, um die aktuelle Zelle auszuführen. Ignorieren Sie alle Warnungen zum Neustart des Kernels oder Abhängigkeitskonflikte.
%pip install -q xgboost==1.3.1 pandas==1.0.5Sie müssen auch das S3-Client-Objekt und die Speicherorte in Ihrem Standard-S3-Bucket einrichten, in die Inhalte wie Metriken und Modellartefakte hochgeladen werden. Kopieren Sie dazu das folgende Codebeispiel, fügen Sie es in eine Zelle im Notebook ein und führen Sie es aus.
import pandas as pd
import boto3
import sagemaker
import json
import joblib
from sagemaker.xgboost.estimator import XGBoost
from sagemaker.tuner import (
IntegerParameter,
ContinuousParameter,
HyperparameterTuner
)
from sagemaker.inputs import TrainingInput
from sagemaker.image_uris import retrieve
from sagemaker.serializers import CSVSerializer
from sagemaker.deserializers import CSVDeserializer
# Setting SageMaker variables
sess = sagemaker.Session()
write_bucket = sess.default_bucket()
write_prefix = "fraud-detect-demo"
region = sess.boto_region_name
s3_client = boto3.client("s3", region_name=region)
sagemaker_role = sagemaker.get_execution_role()
sagemaker_client = boto3.client("sagemaker")
read_bucket = "sagemaker-sample-files"
read_prefix = "datasets/tabular/synthetic_automobile_claims"
# Setting S3 location for read and write operations
train_data_key = f"{read_prefix}/train.csv"
test_data_key = f"{read_prefix}/test.csv"
validation_data_key = f"{read_prefix}/validation.csv"
model_key = f"{write_prefix}/model"
output_key = f"{write_prefix}/output"
train_data_uri = f"s3://{read_bucket}/{train_data_key}"
test_data_uri = f"s3://{read_bucket}/{test_data_key}"
validation_data_uri = f"s3://{read_bucket}/{validation_data_key}"
model_uri = f"s3://{write_bucket}/{model_key}"
output_uri = f"s3://{write_bucket}/{output_key}"
estimator_output_uri = f"s3://{write_bucket}/{write_prefix}/training_jobs"
bias_report_output_uri = f"s3://{write_bucket}/{write_prefix}/clarify-output/bias"
explainability_report_output_uri = f"s3://{write_bucket}/{write_prefix}/clarify-output/explainability"Beachten Sie, dass der Schreib-Bucket-Name vom SageMaker-Sitzungsobjekt abgeleitet wird. Ihr Standard-Bucket hat den Namen sagemaker-<your-Region>-<your-account-id>. In diesen Bucket werden alle Trainingsartefakte hochgeladen. Die Datensätze, die Sie für das Training verwenden, befinden sich in einem öffentlichen S3-Bucket mit dem Namen sagemaker-sample-files, der als Lese-Bucket festgelegt wurde. Beachten Sie, dass das importierte SageMaker-XGBoost-Framework nicht das Open-Source-Framework ist, das Sie im vorherigen Schritt installiert haben. Dies ist das integrierte Framework mit einem Docker-Container-Image, das Sie zum Hochskalieren des Modelltrainings verwenden.
Kopieren Sie den folgenden Code-Block und fügen Sie ihn ein, um den Modellnamen und die Konfigurationen und Anzahl der Trainings- und Inferenz-Instances festzulegen. Mit diesen Einstellungen können Sie die Trainings- und Inferenzprozesse verwalten, indem Sie den entsprechenden Instance-Typ und die entsprechende Anzahl verwenden.
tuning_job_name_prefix = "xgbtune"
training_job_name_prefix = "xgbtrain"
xgb_model_name = "fraud-detect-xgb-model"
endpoint_name_prefix = "xgb-fraud-model-dev"
train_instance_count = 1
train_instance_type = "ml.m4.xlarge"
predictor_instance_count = 1
predictor_instance_type = "ml.m4.xlarge"
clarify_instance_count = 1
clarify_instance_type = "ml.m4.xlarge"Schritt 3: Starten von Hyperparameter-Optimierungsaufträgen im Skriptmodus
Mit SageMaker Studio können Sie Ihre eigene Logik in Python-Skripte einbringen, um sie für das Training zu verwenden. Indem Sie die Trainingslogik in ein Skript kapseln, können Sie benutzerdefinierte Trainingsroutinen und Modellkonfigurationen integrieren und gleichzeitig die von AWS verwalteten gängigen ML-Framework-Container verwenden. In diesem Tutorial bereiten Sie ein Trainingsskript vor, das das Open-Source-Framework XGBoost verwendet, das vom von AWS bereitgestellten XGBoost-Container unterstützt wird, und starten Hyperparameter-Optimierungsaufträgen im großen Maßstab. Um das Modell zu trainieren, verwenden Sie die Spalte Betrug als Zielspalte.
Die erste Ebene des Skriptmodus ist die Möglichkeit, Ihren eigenen Trainingsprozess in einem eigenständigen, angepassten Python-Skript zu definieren und dieses Skript als Einstiegspunkt bei der Definition Ihres SageMaker-Schätzers zu verwenden. Kopieren Sie den folgenden Code-Block und fügen Sie ihn ein, um ein Python-Skript zu schreiben, das die Trainingslogik des Modells kapselt.
%%writefile xgboost_train.py
import argparse
import os
import joblib
import json
import pandas as pd
import xgboost as xgb
from sklearn.metrics import roc_auc_score
if __name__ == "__main__":
parser = argparse.ArgumentParser()
# Hyperparameters and algorithm parameters are described here
parser.add_argument("--num_round", type=int, default=100)
parser.add_argument("--max_depth", type=int, default=3)
parser.add_argument("--eta", type=float, default=0.2)
parser.add_argument("--subsample", type=float, default=0.9)
parser.add_argument("--colsample_bytree", type=float, default=0.8)
parser.add_argument("--objective", type=str, default="binary:logistic")
parser.add_argument("--eval_metric", type=str, default="auc")
parser.add_argument("--nfold", type=int, default=3)
parser.add_argument("--early_stopping_rounds", type=int, default=3)
# SageMaker specific arguments. Defaults are set in the environment variables
# Location of input training data
parser.add_argument("--train_data_dir", type=str, default=os.environ.get("SM_CHANNEL_TRAIN"))
# Location of input validation data
parser.add_argument("--validation_data_dir", type=str, default=os.environ.get("SM_CHANNEL_VALIDATION"))
# Location where trained model will be stored. Default set by SageMaker, /opt/ml/model
parser.add_argument("--model_dir", type=str, default=os.environ.get("SM_MODEL_DIR"))
# Location where model artifacts will be stored. Default set by SageMaker, /opt/ml/output/data
parser.add_argument("--output_data_dir", type=str, default=os.environ.get("SM_OUTPUT_DATA_DIR"))
args = parser.parse_args()
data_train = pd.read_csv(f"{args.train_data_dir}/train.csv")
train = data_train.drop("fraud", axis=1)
label_train = pd.DataFrame(data_train["fraud"])
dtrain = xgb.DMatrix(train, label=label_train)
data_validation = pd.read_csv(f"{args.validation_data_dir}/validation.csv")
validation = data_validation.drop("fraud", axis=1)
label_validation = pd.DataFrame(data_validation["fraud"])
dvalidation = xgb.DMatrix(validation, label=label_validation)
params = {"max_depth": args.max_depth,
"eta": args.eta,
"objective": args.objective,
"subsample" : args.subsample,
"colsample_bytree":args.colsample_bytree
}
num_boost_round = args.num_round
nfold = args.nfold
early_stopping_rounds = args.early_stopping_rounds
cv_results = xgb.cv(
params=params,
dtrain=dtrain,
num_boost_round=num_boost_round,
nfold=nfold,
early_stopping_rounds=early_stopping_rounds,
metrics=["auc"],
seed=42,
)
model = xgb.train(params=params, dtrain=dtrain, num_boost_round=len(cv_results))
train_pred = model.predict(dtrain)
validation_pred = model.predict(dvalidation)
train_auc = roc_auc_score(label_train, train_pred)
validation_auc = roc_auc_score(label_validation, validation_pred)
print(f"[0]#011train-auc:{train_auc:.2f}")
print(f"[0]#011validation-auc:{validation_auc:.2f}")
metrics_data = {"hyperparameters" : params,
"binary_classification_metrics": {"validation:auc": {"value": validation_auc},
"train:auc": {"value": train_auc}
}
}
# Save the evaluation metrics to the location specified by output_data_dir
metrics_location = args.output_data_dir + "/metrics.json"
# Save the model to the location specified by model_dir
model_location = args.model_dir + "/xgboost-model"
with open(metrics_location, "w") as f:
json.dump(metrics_data, f)
with open(model_location, "wb") as f:
joblib.dump(model, f)
Beachten Sie, wie das Skript die zuvor installierte Open-Source-XGBoost-Bibliothek importiert.
SageMaker führt das Einstiegspunktskript aus und liefert alle Eingabeparameter wie Modellkonfigurationsdetails und Eingabe- und Ausgabepfade als Befehlszeilenargumente. Das Skript verwendet die Python-Bibliothek „argparse“, um die bereitgestellten Argumente zu erfassen.
Ihr Trainingsskript wird in einem Docker-Container ausgeführt und SageMaker lädt automatisch Trainings- und Validierungsdatensätze von Amazon S3 in lokale Pfade innerhalb des Containers herunter. Auf diese Speicherorte kann über Umgebungsvariablen zugegriffen werden. Eine vollständige Liste der SageMaker-Umgebungsvariablen finden Sie unter Umgebungsvariablen.
Nachdem Sie Ihr Trainingsskript vorbereitet haben, können Sie einen SageMaker-Schätzer einrichten. Sie verwenden den von AWS verwalteten XGBoost-Schätzer, da er den XGBoost-Container verwaltet, der Ihr benutzerdefiniertes Skript ausführen kann. Um den XGBoost-Schätzer einzurichten, kopieren Sie den folgenden Code und fügen ihn ein.
# SageMaker estimator
# Set static hyperparameters that will not be tuned
static_hyperparams = {
"eval_metric" : "auc",
"objective": "binary:logistic",
"num_round": "5"
}
xgb_estimator = XGBoost(
entry_point="xgboost_train.py",
output_path=estimator_output_uri,
code_location=estimator_output_uri,
hyperparameters=static_hyperparams,
role=sagemaker_role,
instance_count=train_instance_count,
instance_type=train_instance_type,
framework_version="1.3-1",
base_job_name=training_job_name_prefix
)Sie können die statischen Konfigurationsparameter bei der Angabe des Schätzers angeben. In diesem Tutorial verwenden Sie die Receiver Operating Characteristics Area Under the Curve (ROC-AUC) als Bewertungsmetrik. Um die Dauer der Ausführung zu kontrollieren, wurde die Anzahl der Runden auf 5 festgelegt.
Das benutzerdefinierte Skript und die Konfigurationen der Trainings-Instance werden als Argumente an das Schätzer-Objekt übergeben. Die XGBoost-Version wird so ausgewählt, dass sie mit der zuvor installierten Version übereinstimmt.
In diesem Tutorial optimieren Sie vier XGBoost-Hyperparameter:
- eta: Schrumpfung der Schrittgröße, die bei Aktualisierungen verwendet wird, um eine Überanpassung zu verhindern. Nach jedem Boosting-Schritt können Sie direkt die Gewichtung neuer Funktionen abrufen. Der eta-Parameter verkleinert tatsächlich die Merkmal-Gewichte, um den Boosting-Prozess konservativer zu gestalten.
- subsample: Teilprobenverhältnis der Trainings-Instances. Die Einstellung auf 0,5 bedeutet, dass XGBoost die Hälfte der Trainingsdaten zufällig abtastet, bevor Datenbäume erstellt werden. Die Verwendung unterschiedlicher Teilmengen für jede Boosting-Iteration hilft, eine Überanpassung zu vermeiden.
- colsample_bytree: Bruchteil der Merkmale, die verwendet werden, um jeden Datenbaum des Boosting-Prozesses zu generieren. Die Verwendung einer Teilmenge von Merkmalen zum Erstellen jedes Datenbaums führt zu mehr Zufälligkeit im Modellierungsprozess und verbessert die Verallgemeinerbarkeit.
- max_depth: Maximale Tiefe eines Datenbaums. Eine Erhöhung dieses Wertes macht das Modell komplexer und es ist wahrscheinlicher, dass es überangepasst wird.
Kopieren Sie den folgenden Code-Block und fügen Sie ihn ein, um den Bereich der vorhergehenden Hyperparameter für die Suche einzurichten.
# Setting ranges of hyperparameters to be tuned
hyperparameter_ranges = {
"eta": ContinuousParameter(0, 1),
"subsample": ContinuousParameter(0.7, 0.95),
"colsample_bytree": ContinuousParameter(0.7, 0.95),
"max_depth": IntegerParameter(1, 5)
}Kopieren Sie den folgenden Code-Block und fügen Sie ihn ein, um den Hyperparameter-Tuner einzurichten. SageMaker führt standardmäßig Bayes'sche Optimierungsroutinen für den Suchprozess aus. In diesem Tutorial verwenden Sie den Ansatz der Zufallssuche, um die Laufzeit zu reduzieren. Die Parameter werden basierend auf der AUC-Leistung des Modells auf dem Validierungsdatensatz abgestimmt.
objective_metric_name = "validation:auc"
# Setting up tuner object
tuner_config_dict = {
"estimator" : xgb_estimator,
"max_jobs" : 5,
"max_parallel_jobs" : 2,
"objective_metric_name" : objective_metric_name,
"hyperparameter_ranges" : hyperparameter_ranges,
"base_tuning_job_name" : tuning_job_name_prefix,
"strategy" : "Random"
}
tuner = HyperparameterTuner(**tuner_config_dict)Sie können die fit() -Methode auf dem Optimierungsobjekt aufrufen, um Hyperparameter-Optimierungsaufträge zu starten. Für die Anpassung des Tuners können Sie die verschiedenen Eingangskanäle festlegen. Dieses Tutorial stellt Trainings- und Validierungskanäle bereit. Kopieren Sie den folgenden Code-Block und fügen Sie ihn ein, um Hyperparameter-Optimierungsaufträge zu starten. Die Ausführung dauert etwa 13 Minuten.
# Setting the input channels for tuning job
s3_input_train = TrainingInput(s3_data="s3://{}/{}".format(read_bucket, train_data_key), content_type="csv", s3_data_type="S3Prefix")
s3_input_validation = (TrainingInput(s3_data="s3://{}/{}".format(read_bucket, validation_data_key),
content_type="csv", s3_data_type="S3Prefix")
)
tuner.fit(inputs={"train": s3_input_train, "validation": s3_input_validation}, include_cls_metadata=False)
tuner.wait()Die gestarteten Optimierungsaufträge sind in der SageMaker-Konsole unter Hyperparameter-Optimierungsaufträge sichtbar (beachten Sie, dass die Namen der Optimierungsaufträge, wie in den angefügten Images gezeigt, aufgrund unterschiedlicher Zeitstempel nicht mit dem übereinstimmen, was Sie sehen).
Sobald die Optimierung abgeschlossen ist, können Sie auf eine Zusammenfassung der Ergebnisse zugreifen. Kopieren Sie den folgenden Code-Block und fügen Sie ihn ein, um die Ergebnisse des Optimierungsauftrags in einem Pandas-Datenrahmen abzurufen, der in absteigender Reihenfolge der Leistung angeordnet ist.
# Summary of tuning results ordered in descending order of performance
df_tuner = sagemaker.HyperparameterTuningJobAnalytics(tuner.latest_tuning_job.job_name).dataframe()
df_tuner = df_tuner[df_tuner["FinalObjectiveValue"]>-float('inf')].sort_values("FinalObjectiveValue", ascending=False)
df_tunerSie können die Kombination von Hyperparametern prüfen, die die beste Leistung erbracht hat.
Schritt 4: Überprüfung des Modells auf Verzerrungen und Erläuterung der Modellvorhersagen mithilfe von SageMaker Clarify
Sobald Sie ein trainiertes Modell haben, ist es wichtig, vor dem Bereitstellen zu verstehen, ob das Modell oder die Daten eine inhärente Verzerrung aufweisen. Modellvorhersagen können eine Quelle von Verzerrungen sein (z. B. wenn sie Vorhersagen treffen, die für eine Gruppe häufiger zu einem negativen Ergebnis führen als für eine andere). SageMaker Clarify hilft zu erklären, wie ein trainiertes Modell Vorhersagen macht, indem es einen Merkmalszuordnungsansatz verwendet. In diesem Tutorial liegt der Schwerpunkt auf der Verzerrungsmetrik nach dem Training und den SHAP-Werten für die Erklärbarkeit des Modells. Insbesondere werden die folgenden allgemeinen Aufgaben behandelt:
- Erkennung von Daten- und Modellverzerrungen
- Modell-Erklärbarkeit anhand von Werten zur Merkmalsbedeutung
- Auswirkungen von Merkmalen und lokale Erklärungen für einzelne Datenproben
Bevor SageMaker Clarify eine Modellverzerrungserkennung durchführen kann, ist ein SageMaker-Modell erforderlich, das SageMaker Clarify als Teil der Analysen auf einem kurzlebigen Endpunkt bereitstellt. Der Endpunkt wird dann gelöscht, sobald SageMaker-Clarify-Analysen abgeschlossen sind. Kopieren Sie den folgenden Code-Block und fügen Sie ihn ein, um ein SageMaker-Modell aus dem besten Trainingsauftrag zu erstellen, der durch den Optimierungsauftrag ermittelt wurde.
tuner_job_info = sagemaker_client.describe_hyper_parameter_tuning_job(HyperParameterTuningJobName=tuner.latest_tuning_job.job_name)
model_matches = sagemaker_client.list_models(NameContains=xgb_model_name)["Models"]
if not model_matches:
_ = sess.create_model_from_job(
name=xgb_model_name,
training_job_name=tuner_job_info['BestTrainingJob']["TrainingJobName"],
role=sagemaker_role,
image_uri=tuner_job_info['TrainingJobDefinition']["AlgorithmSpecification"]["TrainingImage"]
)
else:
print(f"Model {xgb_model_name} already exists.")Um die Verzerrungserkennung auszuführen, erwartet SageMaker Clarify, dass mehrere Komponentenkonfigurationen eingerichtet werden. Weitere Einzelheiten finden Sie unter Amazon SageMaker Clarify. In diesem Tutorial richten Sie neben den Standardkonfigurationen SageMaker Clarify so ein, dass es erkennt, ob die Daten statistisch Frauen gegenüber voreingenommen sind, indem es prüft, ob das Ziel auf einen Wert ausgerichtet ist, der auf dem Geschlecht des Kunden basiert. Kopieren Sie den folgenden Code und fügen Sie ihn ein, um die SageMaker-Clarify-Konfiguration einzurichten.
train_df = pd.read_csv(train_data_uri)
train_df_cols = train_df.columns.to_list()
clarify_processor = sagemaker.clarify.SageMakerClarifyProcessor(
role=sagemaker_role,
instance_count=clarify_instance_count,
instance_type=clarify_instance_type,
sagemaker_session=sess,
)
# Data config
bias_data_config = sagemaker.clarify.DataConfig(
s3_data_input_path=train_data_uri,
s3_output_path=bias_report_output_uri,
label="fraud",
headers=train_df_cols,
dataset_type="text/csv",
)
# Model config
model_config = sagemaker.clarify.ModelConfig(
model_name=xgb_model_name,
instance_type=train_instance_type,
instance_count=1,
accept_type="text/csv",
)
# Model predictions config to get binary labels from probabilities
predictions_config = sagemaker.clarify.ModelPredictedLabelConfig(probability_threshold=0.5)
# Bias config
bias_config = sagemaker.clarify.BiasConfig(
label_values_or_threshold=[0],
facet_name="customer_gender_female",
facet_values_or_threshold=[1],
)
# Run Clarify job
clarify_processor.run_bias(
data_config=bias_data_config,
bias_config=bias_config,
model_config=model_config,
model_predicted_label_config=predictions_config,
pre_training_methods=["CI"],
post_training_methods=["DPPL"])
clarify_bias_job_name = clarify_processor.latest_job.name
In SageMaker Clarify zeigen Metriken vor dem Training bereits vorhandene Verzerrungen in den Daten, während Metriken nach dem Training Verzerrungen in den Vorhersagen des Modells zeigen. Mit dem SageMaker SDK können Sie angeben, für welche Gruppen Sie Verzerrungen überprüfen möchten und welche Verzerrungsmetriken berücksichtigt werden sollen. Für die Zwecke dieses Tutorials verwenden Sie Klassenungleichgewicht (Class Imbalance, CI) und Differenz der positiven Proportionen in vorhergesagten Bezeichnungen (Difference in Positive Proportions in Predicted Labels, DPPL) als Beispiele für Verzerrungsstatistiken vor und nach dem Training. Einzelheiten zu anderen Verzerrungsmetriken finden Sie unter Messen von Verzerrungen vor dem Training und Daten- und Modellverzerrungen nach dem Training. Kopieren Sie den folgenden Code-Block und fügen Sie ihn ein, um SageMaker Clarify auszuführen und Verzerrungsberichte zu generieren. Die gewählten Verzerrungsmetriken werden als Argumente an die Methode run_bias übergeben. Die Ausführung dieses Codes dauert etwa 12 Minuten.
clarify_processor.run_bias(
data_config=bias_data_config,
bias_config=bias_config,
model_config=model_config,
model_predicted_label_config=predictions_config,
pre_training_methods=["CI"],
post_training_methods=["DPPL"]
)
clarify_bias_job_name = clarify_processor.latest_job.nameDie Ausgaben von SageMaker Clarify werden in Ihrem standardmäßigen S3-Bucket gespeichert. Kopieren Sie den folgenden Code und fügen Sie ihn ein, um den SageMaker-Clarify-Bericht im PDF-Format von Amazon S3 in Ihr lokales Verzeichnis in SageMaker Studio herunterzuladen.
# Copy bias report and view locally
!aws s3 cp s3://{write_bucket}/{write_prefix}/clarify-output/bias/report.pdf ./clarify_bias_output.pdfIm PDF-Bericht scheint der Datensatz basierend auf den Metriken für Voreingenommenheit vor und nach dem Training ein Klassenungleichgewicht in Bezug auf das Geschlechtsmerkmal des Kunden aufzuweisen. Solche Ungleichgewichte können durch die Anwendung von Techniken wie SMOTE korrigiert werden, um den Trainingsdatensatz neu zu erstellen. Sie können auch SageMaker Data Wrangler verwenden und eine der zahlreichen Optionen angeben, einschließlich SMOTE, die innerhalb des Services verfügbar sind, um Trainingsdatensätze auszugleichen. Weitere Einzelheiten finden Sie unter Data-Wrangler-Balance-Daten. Aus Platzgründen ist dieser Schritt in diesem Tutorial nicht enthalten.
Zusätzlich zu den Datenverzerrungen kann SageMaker Clarify auch das trainierte Modell analysieren und einen Bericht über die Erklärbarkeit des Modells auf der Grundlage der Merkmalsbedeutung erstellen. SageMaker Clarify verwendet SHAP-Werte, um den Beitrag zu erklären, den jedes Eingabemerkmal zur endgültigen Vorhersage leistet. Kopieren Sie den folgenden Code-Block und fügen Sie ihn ein, um eine Analyse der Erklärbarkeit von Modellen zu konfigurieren und auszuführen. Die Ausführung dieses Code-Blocks dauert etwa 14 Minuten.
explainability_data_config = sagemaker.clarify.DataConfig(
s3_data_input_path=train_data_uri,
s3_output_path=explainability_report_output_uri,
label="fraud",
headers=train_df_cols,
dataset_type="text/csv",
)
# Use mean of train dataset as baseline data point
shap_baseline = [list(train_df.drop(["fraud"], axis=1).mean())]
shap_config = sagemaker.clarify.SHAPConfig(
baseline=shap_baseline,
num_samples=500,
agg_method="mean_abs",
save_local_shap_values=True,
)
clarify_processor.run_explainability(
data_config=explainability_data_config,
model_config=model_config,
explainability_config=shap_config
)Kopieren Sie den folgenden Code und fügen Sie ihn ein, um den Erklärbarkeitsbericht von SageMaker Clarify im PDF-Format von Amazon S3 in Ihr lokales Verzeichnis in SageMaker Studio herunterzuladen.
# Copy explainability report and view
!aws s3 cp s3://{write_bucket}/{write_prefix}/clarify-output/explainability/report.pdf ./clarify_explainability_output.pdfDer Bericht enthält Diagramme zur Merkmalsbedeutung, die zeigen, wie die eingegebenen Merkmale zu den Modellvorhersagen beitragen. Für das in diesem Tutorial trainierte Modell scheint das Merkmal num-injuries die wichtigste Rolle bei der Generierung von Vorhersagen zu spielen, dicht gefolgt von dem Merkmal customer_gender_male. Solche Merkmalsklassifizierungen liefern wichtige Einblicke in den Vorhersagemechanismus und treiben die Modellverfeinerung und -entwicklung mit einer fairen und erklärbaren Verwendung von ML voran.
Die Ergebnisse der Verzerrungs- und Erklärbarkeitsanalyse können auch in SageMaker Studio unter der Option SageMaker-Ressourcen und Experimente und Versuche in der Dropdown-Liste angezeigt werden. Wählen Sie Nicht zugeordnete Versuchskomponenten.
Wählen Sie den Erklärbarkeitsbericht mit dem Namen clarify-explainability-<datetimestamp> aus.
Auf der Registerkarte Erklärbarkeit können Sie das Merkmalsbedeutungsdiagramm visualisieren. Sie können den Bericht auch herunterladen, indem Sie PDF-Bericht exportieren wählen.
Der von SageMaker Clarify generierte Erklärbarkeitsbericht stellt auch eine Datei namens out.csv bereit, die lokale SHAP-Werte für einzelne Proben enthält. Kopieren Sie den folgenden Code-Block und fügen Sie ihn ein, um diese Datei zu verwenden, um die Erklärung (die Auswirkung, die jedes Merkmal auf die Vorhersage Ihres Modells hat) für jedes einzelne Beispiel zu visualisieren.
import matplotlib.pyplot as plt
import matplotlib
%matplotlib inline
local_explanations_out = pd.read_csv(explainability_report_output_uri + "/explanations_shap/out.csv")
feature_names = [str.replace(c, "_label0", "") for c in
local_explanations_out.columns.to_series()]
local_explanations_out.columns = feature_names
selected_example = 100
print("Example number:", selected_example)
local_explanations_out.iloc[selected_example].plot(
kind="bar", title="Local explanation for the example number " + str(selected_example), rot=60, figsize=(20, 8)
);Für das gewählte Beispiel (erste Stichprobe in der Testreihe) trugen die Gesamtschadenshöhe, das Geschlecht und die Anzahl der Verletzungen am meisten zur Vorhersage bei.
Schritt 5: Bereitstellen des Modells für einen Echtzeit-Inferenz-Endpunkt
In diesem Schritt stellen Sie das beste Modell, das Sie aus dem Hyperparameter-Optimierungsauftrag erhalten haben, an einem Echtzeit-Inferenzendpunkt bereit und verwenden dann den Endpunkt, um Vorhersagen zu generieren. Es gibt mehrere Methoden zum Bereitstellen eines trainierten Modells, z. B. SageMaker SDK, AWS SDK – Boto3 und die SageMaker-Konsole. Weitere Informationen finden Sie unter Bereitstellen von Modellen für Inferenz in der Amazon-SageMaker-Dokumentation. In diesem Beispiel stellen Sie das Modell mithilfe des SageMaker SDK auf einem Echtzeitendpunkt bereit.
Kopieren Sie den folgenden Code-Block und fügen Sie ihn ein, um das beste Modell bereitzustellen.
best_train_job_name = tuner.best_training_job()
model_path = estimator_output_uri + '/' + best_train_job_name + '/output/model.tar.gz'
training_image = retrieve(framework="xgboost", region=region, version="1.3-1")
create_model_config = {"model_data":model_path,
"role":sagemaker_role,
"image_uri":training_image,
"name":endpoint_name_prefix,
"predictor_cls":sagemaker.predictor.Predictor
}
# Create a SageMaker model
model = sagemaker.model.Model(**create_model_config)
# Deploy the best model and get access to a SageMaker Predictor
predictor = model.deploy(initial_instance_count=predictor_instance_count,
instance_type=predictor_instance_type,
serializer=CSVSerializer(),
deserializer=CSVDeserializer())
print(f"\nModel deployed at endpoint : {model.endpoint_name}")Der Code verwendet den besten Trainingsauftragsnamen, um das Modell aus Amazon S3 abzurufen. XGBoost kann Eingabedaten entweder im Text/libsvm- oder im Text/csv-Format akzeptieren. Die in diesem Tutorial verwendeten Eingabedatensätze liegen im CSV-Format vor, und daher enthält die Bereitstellungskonfiguration einen CSVSerializer, der CSV-Eingaben in Bytestreams konvertiert, und einen CSVDeserializer, der die native Modellausgabe in Bytestreams zurück in das CSV-Format für unsere Verwendung konvertiert. Nach Abschluss gibt der Code-Block den Namen des Endpunkts zurück, auf dem das Modell bereitgestellt wurde. Die Bereitstellung gibt auch einen SageMaker Predictor zurück, der verwendet werden kann, um den Endpunkt zum Ausführen von Prognosen aufzurufen, wie im nächsten Abschnitt gezeigt wird.
Sie können den bereitgestellten Endpunkt über die SageMaker-Studio-Oberfläche überprüfen, indem Sie auf das Symbol SageMaker-Ressourcen klicken und Endpunkte aus der Dropdown-Liste auswählen.
Sie können Endpunkte auch über die SageMaker-Konsole untersuchen unter Inferenz, Endpunkte.
Nachdem das Modell an einem Endpunkt bereitgestellt wurde, können Sie es durch direkten Aufruf der REST-API (nicht in diesem Tutorial beschrieben), über das AWS SDK, über eine grafische Oberfläche in SageMaker Studio oder mithilfe des SageMaker Python SDK aufrufen. In diesem Tutorial verwenden Sie den SageMaker Predictor, der durch den Bereitstellungsschritt verfügbar gemacht wird, um Modellvorhersagen in Echtzeit für ein oder mehrere Testmuster zu erhalten. Kopieren Sie den folgenden Code-Block und fügen Sie ihn ein, um den Endpunkt aufzurufen und eine einzelne Probe von Testdaten zu senden.
# Sample test data
test_df = pd.read_csv(test_data_uri)
payload = test_df.drop(["fraud"], axis=1).iloc[0].to_list()
print(f"Model predicted score : {float(predictor.predict(payload)[0][0]):.3f}, True label : {test_df['fraud'].iloc[0]}")Die Ausgabe der Zelle zeigt die wahre Bezeichnung und die vorhergesagte Punktzahl, wie sie vom Modellendpunkt zurückgesendet werden. Da die vorhergesagte Wahrscheinlichkeit sehr gering ist, wurde die Testprobe vom Modell korrekt als kein Betrug eingestuft.
Schritt 6: Bereinigen der Ressourcen
Es ist eine bewährte Methode, Ressourcen, die Sie nicht mehr verwenden, zu löschen, damit Ihnen keine unerwünschten Gebühren entstehen.
Um das Modell und den Endpunkt zu löschen, kopieren Sie den folgenden Code und fügen Sie ihn in das Notebook ein.
# Delete model
try:
sess.delete_model(xgb_model_name)
except:
pass
sess.delete_model(model.name)
# Delete inference endpoint config
sess.delete_endpoint_config(endpoint_config_name=predictor._get_endpoint_config_name())
# Delete inference endpoint
sess.delete_endpoint(endpoint_name=model.endpoint_name)Gehen Sie wie folgt vor, um den S3-Bucket zu löschen:
- Öffnen Sie die Amazon-S3-Konsole. Wählen Sie in der Navigationsleiste Buckets, sagemaker-<your-Region>-<your-account-id> und aktivieren Sie dann das Kontrollkästchen neben fraud-detect-demo. Wählen Sie dann Löschen.
- Vergewissern Sie sich im Dialogfeld Objekte löschen, dass Sie das richtige Objekt zum Löschen ausgewählt haben, und geben Sie dauerhaft löschen im Bestätigungsfeld Objekte dauerhaft löschen ein.
- Sobald dies abgeschlossen und der Bucket leer ist, können Sie den Bucket sagemaker-<your-Region>-<your-account-id> löschen, indem Sie dasselbe Verfahren erneut ausführen.
Der Data-Science-Kernel, der zum Ausführen des Notebook-Images in diesem Tutorial verwendet wird, sammelt Gebühren an, bis Sie entweder den Kernel anhalten oder die folgenden Schritte ausführen, um die Anwendungen zu löschen. Weitere Informationen finden Sie unter Herunterfahren von Ressourcen im Entwicklerhandbuch zu Amazon SageMaker.
Gehen Sie wie folgt vor, um die SageMaker-Studio-Apps zu löschen: Wählen Sie in der SageMaker-Studio-Konsole studio-user und löschen Sie dann alle unter Apps aufgelisteten Apps, indem Sie Apps löschen auswählen. Warten Sie, bis sich der Status in Gelöscht ändert.
Wenn Sie in Schritt 1 eine vorhandene SageMaker-Studio-Domäne verwendet haben, überspringen Sie den Rest von Schritt 6 und fahren Sie direkt mit dem Abschlussabschnitt fort.
Wenn Sie die CloudFormation-Vorlage in Schritt 1 ausgeführt haben, um eine neue SageMaker-Studio-Domäne zu erstellen, fahren Sie mit den folgenden Schritten fort, um die Domäne, den Benutzer und die von der CloudFormation-Vorlage erstellten Ressourcen zu löschen.
Um die CloudFormation-Konsole zu öffnen, geben Sie CloudFormation in die Suchleiste der AWS-Konsole ein, und wählen Sie CloudFormation aus den Suchergebnissen aus.
Wählen Sie im Bereich CloudFormation die Option Stacks. Wählen Sie in der Status-Dropdown-Liste Aktiv aus. Wählen Sie unter Stack-Name die Option CFN-SM-IM-Lambda-catalog, um die Stack-Details-Seite zu öffnen.
Wählen Sie auf der Stack-Details-Seite CFN-SM-IM-Lambda-catalog die Option Löschen, um den Stack zusammen mit den in Schritt 1 erstellten Ressourcen zu löschen.
Zusammenfassung
Herzlichen Glückwunsch! Sie haben das Tutorial Train a Machine Learning Model abgeschlossen.
In diesem Tutorial haben Sie Amazon SageMaker Studio verwendet, um ein binäres Klassifizierungsmodell im Skriptmodus zu trainieren. Sie haben die Open-Source-XGBoost-Bibliothek mit dem von AWS verwalteten XGBoost-Container verwendet, um das Modell mithilfe von SageMaker-Hyperparameter-Optimierungsaufträgen zu trainieren und zu optimieren. Außerdem haben Sie die Verzerrungen und die Erklärbarkeit der Modelle mit SageMaker Clarify analysiert und die Berichte verwendet, um die Auswirkungen der Merkmale auf einzelne Vorhersagen auszuwerten. Abschließend haben Sie das SageMaker-SDK verwendet, um das Modell an einem Echtzeit-Inferenz-Endpunkt bereitzustellen und es mit einer Beispiel-Nutzlast zu testen.
Sie können Ihren Weg als Datenwissenschaftler mit Amazon SageMaker fortsetzen, indem Sie den nachfolgenden Abschnitt über die nächsten Schritte befolgen.
Automatisches Erstellen eines ML-Modells
Bereitstellen eines trainierten Modells
Weitere praktische Tutorials suchen