Train a Machine Learning Model
TUTORIAL
Übersicht
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 dieser Anleitung 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
Anfänger
Minimale Zeit für die Fertigstellung
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
27. März 2023
Implementierung
Schritt 1: Einrichtung Ihrer Amazon SageMaker Studio-Domäne
Mit Amazon SageMaker können Sie ein Modell visuell über die Konsole oder programmgesteuert mit 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-Domain erforderlich ist.
Wenn Sie bereits über eine SageMaker-Studio-Domain in der Region USA Ost (Nord-Virginia) verfügen, befolgen Sie die Anleitung zur Einrichtung von SageMaker Studio, um die erforderlichen AWS-IAM-Richtlinien mit Ihrem Konto von SageMaker Studio zu verknüpfen, überspringen Sie dann Schritt 1 und fahren Sie direkt mit Schritt 2 fort.
Wenn Sie keine bestehende SageMaker-Studio-Domain haben, fahren Sie mit Schritt 1 fort, um eine AWS-CloudFormation-Vorlage auszuführen, die eine SageMaker-Studio-Domain erstellt und die für den Rest dieses Tutorials erforderlichen Berechtigungen hinzufügt.
Dieser Stack geht davon aus, dass Sie bereits eine öffentliche Standard-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.
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, einschließlich Amazon Simple Storage Service (Amazon S3), erforderlich sind.
2.1 Geben Sie SageMaker Studio in die Suchleiste der Konsole ein und wählen Sie dann SageMaker Studio.
2.2 Wählen Sie USA Ost (Nord-Virginia) aus der Dropdown-Liste mit Regionen in der oberen rechten Ecke der SageMaker-Konsole. Um die Anwendung zu starten, wählen Sie im linken Navigationsbereich Studio aus. Wählen Sie studio-user als Benutzerprofil und wählen Sie dann die Schaltfläche Studio öffnen.
2.3 Der Bildschirm zum Erstellen einer Anwendung in SageMaker Studio wird angezeigt. Es dauert einige Minuten, bis die Anwendung geladen ist.
2.4 Öffnen Sie die Oberfläche von SageMaker Studio. Wählen Sie in der Navigationsleiste Datei, Neu, Notebook.
2.5 Wählen Sie im Dialogfeld Einrichtung der Notebook-Umgebung unter Image die Option Datenwissenschaft 3. Der Python-3-Kernel wird automatisch ausgewählt. Wählen Sie unter Instance-Typ ml.t3.medium. Wählen Sie Auswählen.
2.6 Der Kernel in der oberen rechten Ecke des Notebooks sollte nun Python 3 (Datenwissenschaft) anzeigen.
2.7 Kopieren Sie den folgenden Code in eine neue Codezelle in Ihr Jupyter-Notebook und führen Sie die Zelle aus. Dadurch wird sichergestellt, dass Sie die aktuelle Version von SageMaker verwenden.
%pip install sagemaker --upgrade --quiet 2.8 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, den Kernel neu zu starten, und alle Fehlermeldungen zu Abhängigkeitskonflikten.
%pip install -q xgboost==1.3.1 pandas==1.0.52.9 Sie 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"2.10 Beachten Sie, dass der Name des Schreib-Buckets aus dem SageMaker-Sitzungsobjekt abgeleitet ist. Ihr Standard-Bucket hat den Namen sagemaker-<Ihre-Region>-<Ihre-Konto-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 namens sagemaker-sample-files, welcher 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.
2.11 Kopieren Sie den folgenden Codeblock 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 von dem von AWS bereitgestellten XGBoost-Container unterstützt wird, und starten Hyperparameter-Optimierungsaufträge im großen Maßstab. Um das Modell zu trainieren, verwenden Sie die Spalte Betrug als Zielspalte.
3.1 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.
3.2 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
)3.3 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.
3.4 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)
}3.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)3.6 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()3.7 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).
3.8 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_tuner3.9 Sie können die Kombination von Hyperparametern prüfen, die die beste Leistung erbracht hat.
Schritt 4: Überprüfen des Modells auf Verzerrungen und Erläutern 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
4.1 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.")4.2 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],
)4.3 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.name4.4 Die 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.pdf4.5 Im PDF-Bericht scheint der Datensatz basierend auf den Metriken für Voreingenommenheit vor und nach dem Training ein Klassenungleichgewicht in Bezug auf das Geschlechts-Feature 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.
4.6 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 Eingabe-Feature 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
)4.7 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.pdf4.8. Der Bericht enthält Diagramme zur Bedeutung von Features, die zeigen, wie die Eingabe-Features zu den Modellvorhersagen beitragen. Für das in diesem Tutorial trainierte Modell scheint das Feature customer_gender_male die wichtigste Rolle bei der Generierung von Vorhersagen zu spielen, dicht gefolgt von dem Feature num_injuries. Solche Feature-Klassifizierungen liefern wichtige Erkenntnisse in den Vorhersagemechanismus und treiben die Modellverfeinerung und -entwicklung mit einer fairen und erklärbaren Verwendung von ML voran.
4.9 Die Ergebnisse der Verzerrungs- und Erklärbarkeitsanalyse können auch in SageMaker Studio im Abschnitt SageMaker Home und Experiments eingesehen werden.
4.10 Wählen Sie Nicht zugewiesene Ausführungen. Wählen Sie den Erklärbarkeitsbericht mit dem Namen clarify-explainability-<datetimestamp> aus.
4.11 Auf der Registerkarte Erklärbarkeit können Sie das Feature-Bedeutungsdiagramm visualisieren. Sie können den Bericht auch herunterladen, indem Sie PDF-Bericht exportieren wählen.
4.12 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)
);4.13 Für das gewählte Beispiel (erste Probe im Testsatz) trugen die Höhe des Fahrzeugschadens, das Geschlecht, die Vorfälle pro Tag und die Anzahl der Verletzungen am stärksten 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 Echtzeit-Endpunkt bereit.
5.1 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}")5.2 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.
5.3 Sie können den bereitgestellten Endpunkt von der SageMaker-Studio-Oberfläche aus anzeigen, indem Sie das SageMaker-Startsymbol und dann Bereitstellungen und Endpunkte auswählen.
5.4 Sie können Endpunkte unter Inferenz, Endpunkte auch über die SageMaker-Konsole untersuchen.
5.5 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]}")5.6 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 zu löschen, die Sie nicht mehr verwenden, um unerwünschte Gebühren zu vermeiden.
6.1 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)6.2 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.
- Im Dialogfeld Objekte löschen vergewissern Sie sich, 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-<Ihre-Region>-<Ihre-Konto-ID> löschen, indem Sie dasselbe Verfahren erneut ausführen.
Gehen Sie wie folgt vor, um die SageMaker-Studio-Anwendungen zu löschen: Wählen Sie auf der SageMaker-Konsole Domains und dann StudioDomain. Wählen Sie in der Liste der Benutzerprofile die Option studio-user aus und löschen Sie dann alle Anwendungen, die unter Anwendungen aufgeführt sind, indem Sie Anwendung löschen auswählen. Um den JupyterServer zu löschen, wählen Sie Aktion und dann Löschen. Warten Sie, bis sich der Status in Gelöscht ändert.
6.4 Wenn Sie in Schritt 1 eine vorhandene SageMaker-Studio-Domain verwendet haben, überspringen Sie den Rest von Schritt 6 und fahren Sie direkt mit dem letzten Abschnitt fort.
Wenn Sie die CloudFormation-Vorlage in Schritt 1 ausgeführt haben, um eine neue SageMaker-Studio-Domain zu erstellen, fahren Sie mit den folgenden Schritten fort, um die Domain, den Benutzer und die von der CloudFormation-Vorlage erstellten Ressourcen zu löschen.
6.5 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.
6.6 Öffnen Sie die CloudFormation-Konsole. Wählen Sie im Bereich CloudFormation die Option Stacks aus. Wählen Sie in der Status-Dropdown-Liste Aktiv aus. Wählen Sie unter Stack-Name die Option CFN-SM-IM-Lambda-catalog aus, um die Stack-Detailseite zu öffnen.
6.7 Wählen Sie auf der Stack-Detailseite des CFN-SM-IM-Lambda-catalog die Option Löschen aus, um den Stack zusammen mit den in Schritt 1 erstellten Ressourcen zu löschen.
Zusammenfassung
Automatisches Erstellen eines ML-Modells
Bereitstellen eines trainierten Modells
Weitere praktische Tutorials finden