Présentation
Dans ce didacticiel, vous apprenez à entraîner, ajuster et évaluer un modèle de machine learning (ML) avec Amazon SageMaker Studio et Amazon SageMaker Clarify.
Amazon SageMaker Studio est un environnement de développement intégré (IDE) pour le ML qui fournit une interface de bloc-notes Jupyter entièrement gérée dans laquelle vous pouvez effectuer des tâches de bout en bout du cycle de vie du ML. SageMaker Studio vous permet de créer et d'explorer des jeux de données, de préparer des données d'entraînement, de créer, d'entraîner et d'ajuster des modèles, et de déployer des modèles entraînés pour l'inférence, le tout en un seul endroit. Avec Amazon SageMaker Clarify, vous bénéficiez d'une meilleure visibilité sur vos données d'entraînement et vos modèles afin de pouvoir identifier et limiter les biais et expliquer les prédictions.
Pour ce didacticiel, vous utilisez un jeu de données de synthèse de sinistres d'assurance automobile. Les données d'entrée sont les jeux de données d'entraînement et de test, chacun contenant des détails et des caractéristiques extraites concernant des sinistres et des clients, ainsi qu'une colonne fraud (fraude) indiquant si un sinistre est frauduleux ou non. Vous utilisez le cadre open source XGBoost pour prototyper un modèle de classification binaire sur ce jeu de données de synthèse afin de prédire la probabilité qu'un sinistre soit frauduleux. Vous évaluez également le modèle entraîné en exécutant des rapports sur le biais et l'importance des caractéristiques, vous déployez le modèle pour le tester et exécutez une inférence d'échantillon pour évaluer les performances du modèle et expliquer les prédictions.
Qu'allez-vous accomplir ?
Avec ce guide, vous allez :
- Créer, entraîner et ajuster un modèle en utilisant le mode script
- Détecter les biais dans les modèles de ML et comprendre les prédictions de modèles
- Déployer le modèle entraîné vers un point de terminaison d'inférence en temps réel pour le tester
- Évaluer le modèle en générant des échantillons de prédictions et en comprenant l'impact des caractéristiques
Prérequis
Pour pouvoir démarrer ce guide, vous avez besoin de ce qui suit :
- Un compte AWS : si vous n'en avez pas encore, suivez les instructions du guide de mise en route Configuration de votre environnement AWS pour une présentation rapide.
Expérience AWS
Débutant
Durée
2 heures
Coût de réalisation
Consultez la tarification de SageMaker pour estimer le coût de ce didacticiel.
Éléments requis
Vous devez être connecté à un compte AWS.
Services utilisés
Amazon SageMaker Studio, Amazon SageMaker Clarify
Date de la dernière mise à jour
3 mai 2022
Implémentation
Étape 1 : configuration de votre domaine Amazon SageMaker Studio
Avec Amazon SageMaker, vous pouvez déployer un modèle visuellement à l'aide de la console ou par programmation à l'aide de SageMaker Studio ou des blocs-notes SageMaker. Dans ce didacticiel, vous déployez le modèle de manière programmatique à l'aide d'un bloc-notes SageMaker Studio, ce qui nécessite un domaine SageMaker Studio.
Un compte AWS ne peut avoir qu'un seul domaine SageMaker Studio par région. Si vous possédez déjà un domaine SageMaker Studio dans la région USA Est (Virginie du Nord), suivez le Guide de configuration de SageMaker Studio pour joindre les politiques AWS IAM requises à votre compte SageMaker Studio, puis sautez l'étape 1 et passez directement à l'étape 2.
Si vous ne disposez pas d'un domaine SageMaker Studio existant, poursuivez avec l'étape 1 pour exécuter un modèle AWS CloudFormation qui crée un domaine SageMaker Studio et ajoute les autorisations requises pour la suite de ce didacticiel.
Choisissez le lien de la pile AWS CloudFormation. Ce lien ouvre la console AWS CloudFormation et crée votre domaine SageMaker Studio ainsi qu'un utilisateur nommé studio-user. Il ajoute également les autorisations requises à votre compte SageMaker Studio. Dans la console CloudFormation, confirmez que USA Est (Virginie du Nord) est la région affichée dans le coin supérieur droit. Le nom de la pile doit être CFN-SM-IM-Lambda-Catalog, et ne doit pas être modifié. Cette pile prend environ 10 minutes pour créer toutes les ressources.
Cette pile repose sur l'hypothèse que vous avez déjà configuré un VPC public dans votre compte. Si vous ne disposez pas d'un VPC public, veuillez consulter la rubrique VPC with a single public subnet (VPC avec un seul sous-réseau public) pour savoir comment créer un VPC public.
Sélectionnez I acknowledge that AWS CloudFormation might create IAM resources (J'accepte qu'AWS CloudFormation puisse créer des ressources IAM), puis choisissez Create stack (Créer la pile).
Dans le volet CloudFormation, choisissez Stacks (Piles). Il faut environ 10 minutes pour que la pile soit créée. Lorsque la pile est créée, son statut passe de CREATE_IN_PROGRESS (Création en cours) à CREATE_COMPLETE (Création terminée).
Étape 2 : configuration d'un bloc-notes SageMaker Studio
Au cours de cette étape, vous lancez un nouveau bloc-notes SageMaker Studio, installez les bibliothèques open source nécessaires et configurez les variables SageMaker requises pour interagir avec d'autres services, notamment Amazon Simple Storage Service (Amazon S3).
Saisissez SageMaker Studio dans la barre de recherche de la console, puis choisissez SageMaker Studio.
Choisissez USA Est (Virginie du Nord) dans la liste déroulante Region (Région) située dans le coin supérieur droit de la console SageMaker. Pour Launch app (Lancer l'application), sélectionnez Studio pour ouvrir SageMaker Studio à l'aide du profil studio-user.
Ouvrez l'interface SageMaker Studio. Dans la barre de navigation, choisissez File (Fichier), New (Nouveau), Notebook (Bloc-notes).
Dans la boîte de dialogue Set up notebook environment (Configuration de l'environnement du bloc-notes), sous Image, sélectionnez Data Science (Science des données). Le noyau Python 3 est sélectionné automatiquement. Choisissez Select (Sélectionner).
Le kernel (noyau) dans le coin supérieur droit du bloc-notes devrait maintenant afficher Python 3 (Data Science) (Python 3 [Science des données]).
Pour installer des versions spécifiques des bibliothèques open source XGBoost et Pandas, copiez et collez le bout de code suivant dans une cellule du bloc-notes, puis appuyez sur Shift+Enter (Maj+Entrée) pour exécuter la cellule en cours. Ignorez tout avertissement de redémarrage noyau ou toute erreur de conflit de dépendance.
%pip install -q xgboost==1.3.1 pandas==1.0.5Vous devez également instancier l'objet client S3 et les emplacements dans votre compartiment S3 par défaut où sont chargés les contenus tels que les métriques et les artefacts de modèle. Pour ce faire, copiez et collez l'exemple de code suivant dans une cellule du bloc-notes et exécutez-le.
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"Remarquez que le nom du compartiment d'écriture est dérivé de l'objet de session SageMaker. Votre compartiment par défaut porte le nom sagemaker-<votre-région>-<votre-identifiant-de-compte>. Ce compartiment est l'emplacement où tous les artefacts d'entraînement sont chargés. Les jeux de données que vous utilisez pour vous entraîner existent dans un compartiment S3 public nommé sagemaker-sample-files, qui a été spécifié comme le compartiment de lecture. Notez que le cadre SageMaker XGBoost importé n'est pas le cadre open-source que vous avez installé à l'étape précédente. Il s'agit du cadre intégré avec une image de conteneur Docker que vous utilisez pour améliorer l'entraînement du modèle.
Copiez et collez le bloc de code suivant pour définir le nom du modèle ainsi que les configurations et le nombre d'instances d'entraînement et d'inférence. Ces paramètres vous permettent de gérer les processus d'entraînement et d'inférence en utilisant le type et le nombre d'instances appropriés.
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"Étape 3 : lancement des tâches de réglage des hyperparamètres en mode script
Avec SageMaker Studio, vous pouvez intégrer votre propre logique dans des scripts Python à utiliser pour l'entraînement. En encapsulant la logique d'entraînement dans un script, vous pouvez incorporer des routines d'entraînement personnalisées et des configurations de modèle, tout en utilisant les conteneurs de cadre de ML communs gérés par AWS. Dans ce didacticiel, vous préparez un script d'entraînement qui utilise le cadre open source XGBoost, pris en charge par le conteneur XGBoost fourni par AWS, et lance des tâches de réglage des hyperparamètres à grande échelle. Pour entraîner le modèle, vous utilisez la colonne fraud (fraude) comme colonne cible.
Le premier niveau du mode script est la possibilité de définir votre propre processus d'entraînement dans un script Python autonome et personnalisé et d'utiliser ce script comme point d'entrée pour définir votre estimateur SageMaker. Copiez et collez le bloc de code suivant pour écrire un script Python encapsulant la logique d'entraînement du modèle.
%%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)
Remarquez comment le script importe la bibliothèque open source XGBoost que vous avez installée précédemment.
SageMaker exécute le script de point d'entrée et fournit tous les paramètres d'entrée tels que les détails de configuration du modèle et les chemins d'entrée et de sortie en tant qu'arguments de ligne de commande. Le script utilise la bibliothèque Python « argparse » pour capturer les arguments fournis.
Votre script d'entraînement s'exécute à l'intérieur d'un conteneur Docker et SageMaker télécharge automatiquement les jeux de données d'entraînement et de validation depuis Amazon S3 vers des chemins locaux à l'intérieur du conteneur. Ces emplacements sont accessibles au moyen de variables d'environnement. Pour une liste exhaustive des variables d'environnement de SageMaker, veuillez consulter la rubrique Environment variables (Variables d'environnement, en anglais uniquement).
Une fois que vous avez préparé votre script d'entraînement, vous pouvez instancier un estimateur SageMaker. Vous utilisez l'estimateur XGBoost géré par AWS, car il gère le conteneur XGBoost qui peut exécuter votre script personnalisé. Pour instancier l'estimateur XGBoost, copiez et collez le code suivant.
# 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
)Vous pouvez spécifier les paramètres de configuration statique lorsque vous spécifiez l'estimateur. Dans ce didacticiel, la métrique d'évaluation utilisée est l'aire sous la courbe de la caractéristique d'exploitation du récepteur (ROC-AUC, Receiver Operating Characteristic Area Under the Curve). Pour contrôler le temps d'exécution, le nombre de cycles a été fixé à 5.
Le script personnalisé et les configurations de l'instance d'entraînement sont passés à l'objet estimateur en tant qu'arguments. La version de XGBoost est choisie pour correspondre à celle que vous avez installée précédemment.
Vous ajustez quatre hyperparamètres XGBoost dans ce didacticiel :
- eta : rétrécissement de la taille du pas utilisé dans les mises à jour pour éviter le surajustement (overfitting). Après chaque étape de boosting, vous pouvez obtenir directement les pondérations des nouvelles caractéristiques. Le paramètre eta réduit effectivement les pondérations des caractéristiques pour rendre le processus de boosting plus conservateur.
- subsample : proportion de sous-échantillon des instances d'entraînement. En le fixant à 0,5, XGBoost échantillonne de manière aléatoire la moitié des données d'entraînement avant de faire croître les arbres. L'utilisation de sous-ensembles différents pour chaque itération de boosting permet d'éviter le surajustement.
- colsample_bytree : part des caractéristiques utilisées pour générer chaque arbre du processus de boosting. L'utilisation d'un sous-ensemble de caractéristiques pour créer chaque arbre introduit plus d'aléatoire dans le processus de modélisation, ce qui améliore la capacité de généralisation.
- max_depth : profondeur maximale d'un arbre. L'augmentation de cette valeur rend le modèle plus complexe et susceptible d'être surajusté.
Copiez et collez le bloc de code suivant pour configurer la plage des hyperparamètres précédents dans laquelle effectuer la recherche.
# 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)
}Copiez et collez le bloc de code suivant pour configurer l'ajusteur d'hyperparamètres. SageMaker exécute par défaut des routines d'optimisation bayésienne pour le processus de recherche. Dans ce didacticiel, vous utilisez l'approche de la recherche aléatoire pour réduire le temps d'exécution. Les paramètres sont ajustés en fonction de la performance AUC du modèle sur le jeu de données de validation.
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)Vous pouvez appeler la méthode fit() sur l'objet ajusteur pour lancer les tâches d'ajustement des hyperparamètres. Pour adapter l'ajusteur, vous pouvez spécifier les différents canaux d'entrée. Ce didacticiel fournit des canaux d'entraînement et de validation. Copiez et collez le bloc de code suivant pour lancer les tâches d'ajustement des hyperparamètres. Cette opération dure environ 13 minutes.
# 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()Les tâches de réglage lancées sont visibles dans la console SageMaker sous Hyperparameter tuning jobs (Tâches d'ajustement des hyperparamètres). Notez que les noms des tâches d'ajustement, tels qu'ils apparaissent dans les images ci-jointes, ne correspondent pas à ce que vous voyez en raison des différents horodatages.
Une fois l'ajustement terminé, vous pouvez accéder à un résumé des résultats. Copiez et collez le bloc de code suivant pour récupérer les résultats de la tâche d'ajustement dans un cadre de données pandas, classés par ordre décroissant de performance.
# 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_tunerVous pouvez inspecter la combinaison d'hyperparamètres qui a obtenu les meilleures performances.
Étape 4 : vérification des biais du modèle et explication des prédictions du modèle à l'aide de SageMaker Clarify
Une fois que vous avez un modèle entraîné, il est important d'établir s'il existe un biais inhérent au modèle ou aux données avant le déploiement. Les prédictions des modèles peuvent être une source de biais (par exemple, s'ils font des prédictions qui produisent plus fréquemment un résultat négatif pour un groupe que pour un autre). SageMaker Clarify permet d'expliquer comment un modèle entraîné fait des prédictions en utilisant une approche d'attribution des caractéristiques. Dans ce didacticiel, l'accent est mis sur la métrique du biais post-entraînement et les valeurs SHAP pour l'explicabilité du modèle. Plus précisément, les tâches courantes suivantes sont couvertes :
- Détection des biais dans les données et les modèles
- Modélisation de l'explicabilité à l'aide des valeurs d'importance des caractéristiques
- Impact des caractéristiques et des explications locales pour les échantillons de données uniques
Avant que SageMaker Clarify puisse effectuer la détection des biais de modèle, il a besoin d'un modèle SageMaker que SageMaker Clarify déploie vers un point de terminaison éphémère dans le cadre des analyses. Le point de terminaison est supprimé une fois les analyses de SageMaker Clarify terminées. Copiez et collez le bloc de code suivant pour créer un modèle SageMaker à partir de la meilleure tâche d'entraînement identifiée à partir de la tâche d'ajustement.
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.")Pour exécuter la détection de biais, SageMaker Clarify s'attend à ce que plusieurs configurations de composants soient définies. Vous trouverez de plus amples informations sur la page Amazon SageMaker Clarify. Pour ce didacticiel, en dehors des configurations standard, vous configurez SageMaker Clarify pour détecter si les données sont statistiquement biaisées au détriment des femmes en vérifiant si la cible est faussée vers une valeur basée sur le sexe du client. Copiez et collez le code suivant pour définir la configuration de SageMaker Clarify.
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
Dans SageMaker Clarify, les métriques de pré-entraînement montrent les biais préexistants dans les données, tandis que les métriques de post-entraînement montrent les biais dans les prédictions du modèle. À l'aide du kit SDK de SageMaker, vous pouvez spécifier les groupes sur lesquels vous souhaitez vérifier le biais et les métriques de biais à prendre en compte. Pour les besoins de ce didacticiel, vous utilisez Class Imbalance (CI, Déséquilibre de classe) et Difference in Positive Proportions in Predicted Labels (DPPL, Différence de proportions positives dans les étiquettes prédites) comme exemples de statistiques de biais avant et après entraînement, respectivement. Vous trouverez des détails sur d'autres métriques de biais à Measure Pretraining Bias (Mesure du biais de pré-entraînement) et Posttraining Data and Model Bias (Biais des données et du modèle de post-entraînement). Copiez et collez le bloc de code suivant pour exécuter SageMaker Clarify et générer des rapports sur les biais. Les métriques de biais choisies sont transmises comme arguments à la méthode run_bias. L'exécution de ce code prend environ 12 minutes.
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.nameLes résultats de SageMaker Clarify sont enregistrés dans votre compartiment S3 par défaut. Copiez et collez le code suivant pour télécharger le rapport SageMaker Clarify au format PDF depuis Amazon S3 vers votre répertoire local dans SageMaker Studio.
# Copy bias report and view locally
!aws s3 cp s3://{write_bucket}/{write_prefix}/clarify-output/bias/report.pdf ./clarify_bias_output.pdfDans le rapport PDF, sur la base des métriques de biais avant et après entraînement, le jeu de données semble présenter un déséquilibre de classe en ce qui concerne la caractéristique du sexe du client. Ces déséquilibres peuvent être corrigés en appliquant des techniques telles que SMOTE pour recréer le jeu de données d'entraînement. Vous pouvez également utiliser SageMaker Data Wrangler et spécifier l'une des multiples options disponibles dans le service, y compris SMOTE, pour équilibrer les jeux de données d'entraînement. Pour plus de détails, veuillez consulter la rubrique Data Wrangler Balance Data (Équilibre des données de Data Wrangler). Par souci de concision, cette étape n'est pas incluse dans le didacticiel.
Outre le biais des données, SageMaker Clarify peut également analyser le modèle entraîné et créer un rapport d'explicabilité du modèle basé sur l'importance des caractéristiques. SageMaker Clarify utilise les valeurs SHAP pour expliquer la contribution de chaque caractéristique d'entrée à la prédiction finale. Copiez et collez le bloc de code suivant pour configurer et exécuter une analyse d'explicabilité de modèle. L'exécution de ce bloc de code prend environ 14 minutes.
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
)Copiez et collez le code suivant pour télécharger le rapport d'explicabilité SageMaker Clarify au format PDF depuis Amazon S3 vers votre répertoire local dans SageMaker Studio.
# Copy explainability report and view
!aws s3 cp s3://{write_bucket}/{write_prefix}/clarify-output/explainability/report.pdf ./clarify_explainability_output.pdfLe rapport contient des graphiques d'importance des caractéristiques qui montrent comment les caractéristiques d'entrée contribuent aux prédictions du modèle. Pour le modèle entraîné dans ce didacticiel, il semble que la caractéristique num-injuries joue le rôle le plus important, suivie de près par la caractéristique customer_gender_male dans la génération des prédictions. Ces classements de caractéristiques fournissent des informations importantes sur le mécanisme de prédiction et permettent d'affiner et de développer des modèles en utilisant le ML de manière équitable et explicable.
Les résultats de l'analyse des biais et de l'explicabilité peuvent également être consultés dans SageMaker Studio via les options SageMaker Resources (Ressources SageMaker) et Experiments and trials (Expériences et essais) dans la liste déroulante. Choisissez Unassigned trial components (composants d'essai non attribués).
Sélectionnez le rapport d'explicabilité nommé clarify-explainability-<horodatagedateheure>.
Dans l'onglet Explainability (Explicabilité), vous pouvez visualiser le graphique de l'importance des caractéristiques. Vous pouvez également télécharger le rapport en sélectionnant Export PDF report (Exporter le rapport PDF).
Le rapport d'explicabilité généré par SageMaker Clarify fournit également un fichier appelé out.csv contenant les valeurs SHAP locales pour les échantillons individuels. Copiez et collez le bloc de code suivant pour utiliser ce fichier afin de visualiser l'explication (l'impact que chaque caractéristique a sur la prédiction de votre modèle) pour n'importe quel exemple unique.
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)
);Pour l'exemple choisi (premier échantillon de l'ensemble de test), le montant total du sinistre, le sexe et le nombre de blessures ont le plus contribué à la prédiction.
Étape 5 : déploiement du modèle vers un point de terminaison d'inférence en temps réel
Au cours de cette étape, vous déployez le meilleur modèle obtenu à partir de la tâche d'ajustement des hyperparamètres vers un point de terminaison d'inférence en temps réel, puis vous utilisez ce point de terminaison pour générer des prédictions. Il existe plusieurs méthodes pour déployer un modèle entraîné, notamment le kit SDK SageMaker, le kit SDK AWS – Boto3, et la console SageMaker. Pour en savoir plus, consultez la page Deploy Models for Inference (Déployer des modèles pour inférence) de la documentation d'Amazon SageMaker. Dans cet exemple, vous déployez le modèle vers un point de terminaison en temps réel à l'aide du kit SDK de SageMaker.
Copiez et collez le bloc de code suivant pour déployer le meilleur modèle.
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}")Le code utilise le nom de la meilleure tâche d'entraînement pour récupérer le modèle depuis Amazon S3. XGBoost peut accepter des données d'entrée aux formats texte/libsvm ou texte/csv. Les jeux de données d'entrée utilisés dans ce didacticiel sont au format CSV. La configuration du déploiement comprend donc un CSVSerializer qui convertit les entrées CSV en flux d'octets et un CSVDeserializer qui reconvertit la sortie du modèle natif en flux d'octets au format CSV pour notre consommation. Une fois terminé, le bloc de code renvoie le nom du point de terminaison vers lequel le modèle a été déployé. Le déploiement renvoie également un prédicteur SageMaker qui peut être utilisé pour appeler le point de terminaison afin d'exécuter des prédictions, comme indiqué dans la section suivante.
Vous pouvez vérifier le point de terminaison déployé à partir de l'interface SageMaker Studio en cliquant sur l'icône SageMaker Resources (Ressources SageMaker) et en sélectionnant Endpoints (Points de terminaison) dans la liste déroulante.
Vous pouvez également inspecter les points de terminaison dans la console SageMaker sous Inference, Endpoints (Points de terminaison).
Maintenant que le modèle a été déployé vers un point de terminaison, vous pouvez l'invoquer en appelant directement l'API REST (non décrite dans ce didacticiel), via le kit SDK AWS, via une interface graphique dans SageMaker Studio, ou en utilisant le SDK Python de SageMaker. Dans ce didacticiel, vous utilisez le prédicteur SageMaker mis à disposition par l'étape de déploiement pour obtenir des prédictions de modèle en temps réel sur un ou plusieurs échantillons de test. Copiez et collez le bloc de code suivant pour appeler le point de terminaison et envoyer un seul échantillon de données de test.
# 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]}")Le résultat de la cellule montre l'étiquette réelle et le score prédit tels qu'ils ont été renvoyés par le point de terminaison du modèle. Comme la probabilité prédite est très faible, l'échantillon test a été correctement étiqueté comme non frauduleux par le modèle.
Étape 6 : nettoyage des ressources
Une bonne pratique consiste à supprimer les ressources que vous n'utilisez plus afin de ne pas encourir de frais imprévus.
Pour supprimer le modèle et le point de terminaison, copiez et collez le code suivant dans le bloc-notes.
# 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)Pour supprimer le compartiment S3, procédez comme suit :
- Ouvrez la console Amazon S3. Sur la barre de navigation, choisissez Buckets (Compartiments), sagemaker-<votre-région>-<votre-identifiant-de-compte>, puis cochez la case à côté de fraud-detect-demo. Puis choisissez Delete (Supprimer).
- Dans la boîte de dialogue Delete objects (Supprimer des objets), vérifiez que vous avez sélectionné le bon objet à supprimer et saisissez permanently delete (supprimer définitivement) dans la case de confirmation des Permanently delete objects (Supprimer définitivement des objets).
- Une fois que cette opération est terminée et que le compartiment est vide, vous pouvez supprimer le compartiment sagemaker-<votre-région>-<votre-identifiant-de-compte> en suivant à nouveau la même procédure.
Le noyau de Science des données utilisé pour exécuter l'image du bloc-notes dans ce didacticiel accumule les charges jusqu'à ce que vous arrêtiez le noyau ou que vous effectuiez les étapes suivantes pour supprimer les applications. Pour en savoir plus, veuillez consulter la rubrique Shut Down Resources (Arrêt des ressources) dans le Guide du développeur Amazon SageMaker.
Pour supprimer les applications SageMaker Studio, procédez comme suit : dans la console SageMaker Studio, choisissez studio-user, puis supprimez toutes les applications répertoriées sous Apps (Applications) en choisissant Delete app (Supprimer l'application). Attendez que le Status (Statut) de l'état passe à Deleted (Supprimé).
Si vous avez utilisé un domaine SageMaker Studio existant à l'étape 1, ignorez le reste de l'étape 6 et passez directement à la section de conclusion.
Si vous avez exécuté le modèle CloudFormation à l'étape 1 pour créer un domaine SageMaker Studio, poursuivez les étapes suivantes pour supprimer le domaine, l'utilisateur et les ressources créés par le modèle CloudFormation.
Pour ouvrir la console CloudFormation, saisissez CloudFormation dans la barre de recherche de la console AWS, puis choisissez CloudFormation dans les résultats de la recherche.
Dans le volet CloudFormation, choisissez Stacks (Piles). Dans la liste déroulante Status (Statut), sélectionnez Active (Actif). Sous Stack name (Nom de la pile), choisissez CFN-SM-IM-Lambda-Catalog pour ouvrir la page des détails de la pile.
Sur la page de détails de la pile CFN-SM-IM-Lambda-Catalog, choisissez Delete (Supprimer) pour supprimer la pile ainsi que les ressources qu'elle a créées à l'étape 1.
Conclusion
Félicitations ! Vous avez terminé le didacticiel Entraînement d'un modèle de machine learning.
Dans ce didacticiel, vous avez utilisé Amazon SageMaker Studio pour entraîner un modèle de classification binaire en mode script. Vous avez utilisé la bibliothèque open source XGBoost avec le conteneur XGBoost géré par AWS pour entraîner et ajuster le modèle à l'aide des tâches d'ajustement des hyperparamètres de SageMaker. Vous avez également analysé le biais et l'explicabilité des modèles à l'aide de SageMaker Clarify et utilisé les rapports pour évaluer l'impact des caractéristiques sur les prédictions individuelles. Enfin, vous avez utilisé le kit SDK de SageMaker pour déployer le modèle vers un point de terminaison d'inférence en temps réel et l'avez testé avec un échantillon de charge utile.
Vous pouvez poursuivre votre parcours de scientifique des données avec Amazon SageMaker en suivant la section des prochaines étapes ci-dessous.