Entraînement d'un modèle de machine learning
DIDACTICIEL
Présentation
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
Délai minimum d'exécution
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
27 mars 2023
Mise en œuvre
É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 tutoriel, 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.
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 IAM AWS 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 tutoriel.
Cette pile repose sur l'hypothèse que vous avez déjà configuré un VPC public par défaut dans votre compte. Si vous ne disposez pas d'un VPC public, veuillez consulter la rubrique VPC avec un seul sous-réseau public pour apprendre à créer un VPC public.
Sélectionnez je reconnais qu’AWS CloudFormation peut créer des ressources IAM, puis choisissez Créer la pile.
É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).
2.1 Saisissez SageMaker Studio dans la barre de recherche de la console, puis choisissez SageMaker Studio.
2.2 Choisissez USA Est (Virginie du Nord) dans la liste déroulante des Régions située dans le coin supérieur droit de la console SageMaker. Pour lancer l'application, sélectionnez Studio dans le volet de navigation de gauche. Sélectionnez utilisateur-studio comme profil utilisateur et cliquez sur le bouton Ouvrir Studio.
2.3 L'écran de création de l'application dans SageMaker Studio s'affichera. L'application prend quelques minutes pour se charger.
2.4 Ouvrez l'interface SageMaker Studio. Dans la barre de navigation, choisissez Fichier, Nouveau, Bloc-notes.
2.5 Dans la boîte de dialogue Configuration de l’environnement du bloc-notes, sous Image, sélectionnez Science des données 3. Le noyau Python 3 est sélectionné automatiquement. Sous type d'instance, choisissez ml.t3.medium. Choisissez Sélectionner.
2.6 Le noyau dans le coin supérieur droit du bloc-notes devrait maintenant afficher Python 3 (science des données).
2.7 Dans une nouvelle cellule de code du bloc-notes Jupyter, copiez et collez le code suivant et exécutez la cellule. Cela garantira que vous utilisez la version actuelle de SageMaker.
%pip install sagemaker --upgrade --quiet 2.8 Pour installer des versions spécifiques des bibliothèques open source XGBoost et Pandas, copiez et collez l’extrait de code suivant dans une cellule du bloc-notes, puis appuyez sur Maj+Entréepour 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.52.9 Vous 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-la.
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 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 de formation sont chargés. Les jeux de données que vous utilisez pour l’entraînement existent dans un compartiment S3 public nommé sagemaker-sample-files, qui a été spécifié comme étant 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.
2.11 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 tutoriel, 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 hyper-paramètres à grande échelle. Pour entraîner le modèle, vous utilisez la colonne fraudecomme colonne cible.
3.1 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 Variables d’environnement.
3.2 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
)3.3 Vous pouvez spécifier les paramètres de configuration statique lorsque vous spécifiez l'estimateur. Dans ce tutoriel, vous utilisez l'aire sous la courbe des caractéristiques d'exploitation du récepteur (ROC-AUC) comme mesure d'évaluation. 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.
3.4 Vous ajustez quatre hyper-paramètres XGBoost dans ce tutoriel :
- eta : réduction de la taille du pas utilisé dans les mises à jour pour éviter le surajustement. 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 hyper-paramè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)
}3.5 Copiez et collez le bloc de code suivant pour configurer l'ajusteur des hyper-paramè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)3.6 Vous pouvez appeler la méthode fit() sur l'objet ajusteur pour lancer les tâches d'ajustement des hyper-paramè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()3.7 Les tâches d’ajustement lancées sont visibles dans la console SageMaker sous Tâches d’ajustement des hyper-paramè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).
3.8 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_tuner3.9 Vous pouvez inspecter la combinaison d'hyper-paramètres qui a obtenu les meilleures performances.
Étape 4 : vérification de l'absence de biais dans le 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
4.1 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 dans 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.")4.2 Pour exécuter la détection de biais, SageMaker Clarify s'attend à ce que plusieurs configurations de composants soient définies. Vous trouverez plus d’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],
)4.3 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 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.name4.4 Les 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.pdf4.5 Dans 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 tutoriel.
4.6 En plus du 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
)4.7 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.pdf4.8. Le 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 tutoriel, il semble que la caractéristique client_genre_masculin joue le rôle le plus important, suivie de près par la caractéristique nom_lésions 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.
4.9 Les résultats des analyses de biais et d'explicabilité peuvent également être consultés dans SageMaker Studio dans la section Accueil SageMaker puisExpériences.
4.10 Choisissez Exécutions non attribuées. Sélectionnez le rapport d'explicabilité nommé clarify-explainability-<datetimestamp>.
4.11 Dans l'onglet Explicabilité, vous pouvez visualiser le graphique de l'importance des caractéristiques. Vous pouvez également télécharger le rapport en sélectionnant Exporter le rapport PDF.
4.12 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)
);4.13 Pour l'exemple choisi (premier échantillon de l'ensemble de test), le montant du sinistre, le sexe, les incidents par jour 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 SDK de SageMaker.
5.1 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}")5.2 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 text/libsvm ou text/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 Predictor SageMaker qui peut être utilisé pour invoquer le point de terminaison afin d'exécuter des prédictions, comme indiqué dans la section suivante.
5.3 Vous pouvez consulter le point de terminaison déployé depuis l'interface de SageMaker Studio en sélectionnant l'icône Accueil SageMaker puis en sélectionnant Déploiements et Points de terminaison.
5.4 Vous pouvez également inspecter les points de terminaison dans la console SageMaker sous Inférence, Points de terminaison.
5.5 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 tutoriel), via le SDK AWS, via une interface graphique dans SageMaker Studio ou en utilisant le SDK Python de SageMaker. Dans ce tutoriel, 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 invoquer 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]}")5.6 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.
6.1 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)6.2 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 cette opération terminée et le compartiment vide, vous pouvez supprimer le compartiment sagemaker-<votre-région>-<votre-identifiant-de-compte> en suivant à nouveau la même procédure.
Pour supprimer les applications SageMaker Studio, procédez comme suit : Sur la console SageMaker, choisissez Domaines puis StudioDomain. Dans la liste des profils utilisateur, sélectionnez utilisateur-studio, puis supprimez toutes les applications répertoriées sous Applications en choisissant Supprimer l'application. Pour supprimer le JupyterServer, choisissez Action, puis Supprimer. Attendez que leStatut passe à Supprimé.
6.4 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.
6.5 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.
6.6 Ouvrez la console CloudFormation. Dans le volet CloudFormation, choisissez Piles. Dans la liste déroulante du statut, sélectionnez Actif. Sous Nom de la pile, choisissez CFN-SM-IM-Lambda-Catalogpour ouvrir la page des détails de la pile.
6.7 Sur la page de détails de la pile CFN-SM-IM-Lambda-catalog, choisissez Supprimer pour supprimer la pile ainsi que les ressources qu'elle a créées à l'étape 1.
