Panoramica
In questo tutorial, imparerai ad addestrare, ottimizzare e valutare un modello di machine learning (ML) utilizzando Amazon SageMaker Studio ed Amazon SageMaker Clarify.
Amazon SageMaker Studio è un ambiente di sviluppo integrato (IDE) per il ML che fornisce un'interfaccia notebook Jupyter completamente gestita in cui è possibile eseguire attività end-to-end del ciclo di vita del ML. Con SageMaker Studio puoi creare ed esplorare set di dati, preparare i dati di addestramento, costruire, addestrare e mettere a punto modelli e implementare i modelli addestrati per l'inferenza, tutto in un unico posto. Amazon SageMaker Clarify fornisce una maggiore visibilità sui dati e i modelli di addestramento in modo da poter identificare e limitare gli errori e spiegare le previsioni.
Per questo tutorial utilizzerai un set di dati sui sinistri di assicurazione auto generato artificialmente. Gli input sono i set di dati di addestramento, convalida e test, ciascuno contenente dettagli e funzionalità estratte su sinistri e clienti insieme a una colonna frode che indica se un incidente era fraudolento o meno. Utilizzerai il framework XGBoost open source per creare un modello di classificazione binaria su questo set di dati artificiale per prevedere la probabilità che un incidente sia fraudolento. Valuterai anche il modello addestrato eseguendo rapporti di errori e importanza delle funzionalità, distribuirai il modello per il test ed eseguirai l'inferenza del campione per valutare le prestazioni del modello e spiegare le previsioni.
Obiettivi
Con questa guida, imparerai a:
- Creare, addestrare e ottimizzare un modello utilizzando una modalità script
- Rilevare gli errori nei modelli di ML e comprendere le previsioni del modello
- Implementare il modello addestrato su un endpoint di inferenza in tempo reale per il test
- Valutare il modello generando previsioni dei campioni e scoprendo l'impatto sulle funzionalità
Prerequisiti
Prima di iniziare questa guida, avrai bisogno di:
- Un account AWS: se non ne sei ancora in possesso, segui la guida introduttiva Configurazione del tuo ambiente AWS per una rapida panoramica.
Esperienza AWS
Principiante
Tempo per il completamento
2 ore
Costo richiesto per il completamento
Per una stima dei costi di questo tutorial, consulta Prezzi di SageMaker.
Requisiti
Devi aver effettuato l'accesso con un account AWS.
Servizi utilizzati
Amazon SageMaker Studio, Amazon SageMaker Clarify
Ultimo aggiornamento
3 maggio 2022
Implementazione
Fase 1: Configurazione del dominio di Amazon SageMaker Studio
Con Amazon SageMaker puoi implementare un modello visivamente utilizzando la console o in maniera programmatica utilizzando SageMaker Studio o i notebook SageMaker. In questo tutorial, il modello viene implementato in maniera programmatica tramite un notebook SageMaker Studio, che richiede un dominio di SageMaker Studio.
Un account AWS può avere solo un dominio SageMaker Studio per regione. Se hai già un dominio SageMaker Studio nella regione Stati Uniti orientali (Virginia settentrionale), consulta la Guida alla configurazione di SageMaker Studio per collegare le policy AWS IAM richieste all'account SageMaker Studio, quindi salta la fase 1 e passa direttamente alla fase 2.
Se invece non disponi di un dominio SageMaker Studio, continua con la fase 1 per eseguire un modello AWS CloudFormation che crea un dominio SageMaker Studio e aggiunge le autorizzazioni necessarie per il resto di questo tutorial.
Scegli il link dello stack AWS CloudFormation. Questo link apre la console AWS CloudFormation e crea il dominio SageMaker e un utente denominato studio-user. Inoltre aggiunge le autorizzazioni richieste al tuo account SageMaker Studio. Nella console CloudFormation, conferma che Stati Uniti orientali (Virginia settentrionale) sia la regione visualizzata nell'angolo in alto a destra. Il nome dello stack deve essere CFN-SM-IM-Lambda-catalog e non può essere modificato. Questo stack richiede circa 10 minuti per creare tutte le risorse.
Assume inoltre che sia presente un VPC pubblico configurato nell'account. Se non hai un VPC pubblico, consulta VPC con una singola sottorete pubblica per scoprire come creare un VPC pubblico.
Seleziona I acknowledge that AWS CloudFormation might create IAM resources (Sono consapevole che AWS CloudFormation può creare le risorse IAM), quindi scegli Create stack (Crea stack).
Nel riquadro CloudFormation, scegli Stack. La creazione dello stack richiede circa 10 minuti. Una volta creato lo stack, il suo stato passerà da CREATE_IN_PROGRESS a CREATE_COMPLETE.
Fase 2: Configurazione di un notebook SageMaker Studio
In questa fase, avvierai un nuovo notebook SageMaker Studio, installerai le librerie open source necessarie e configurerai le variabili SageMaker necessarie per interagire con altri servizi, tra cui Amazon Simple Storage Service (Amazon S3).
Digita SageMaker Studio nella barra di ricerca della console, quindi scegli SageMaker Studio.
Scegli US East (N. Virginia) (Stati Uniti orientali [Virginia settentrionale]) dall'elenco a discesa Region (Regione) nell'angolo in alto a destra della console SageMaker. In Launch app (Avvia app), seleziona Studio per aprire SageMaker Studio utilizzando il profilo studio-user.
Apri l'interfaccia di SageMaker Studio. Sulla barra di navigazione, scegli File, New (Nuovo), Notebook.
Nella finestra di dialogo Set up notebook environment (Configura ambiente notebook), in Image (Immagine), seleziona Data Science (Data science). Il kernel Python 3 viene selezionato automaticamente. Scegli Select (Seleziona).
Il kernel nell'angolo in alto a destra del notebook dovrebbe visualizzare Python 3 (Data Science) (Python 3 [data science]).
Per installare versioni specifiche delle librerie XGBoost e Pandas open source, copia e incolla il seguente frammento di codice in una cella nel notebook, quindi premi Maius+Invio per eseguire la cella corrente. Ignora le eventuali avvertenze per riavviare il kernel o gli errori di conflitto delle dipendenze.
%pip install -q xgboost==1.3.1 pandas==1.0.5Devi inoltre creare un'istanza dell'oggetto client S3 e delle posizioni all'interno del bucket S3 predefinito in cui sono caricati contenuti quali parametri e artefatti del modello. Per far ciò, copia e incolla il seguente codice di esempio in una cella nel notebook ed eseguilo.
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"Tieni presente che il nome del bucket di scrittura deriva dall'oggetto di sessione di SageMaker. Il nome del bucket predefinito è sagemaker-<regione>-<id-account>. Questo bucket è dove vengono caricati tutti gli artefatti di addestramento. I set di dati che utilizzi per l'addestramento sono presenti in un bucket S3 pubblico denominato sagemaker-sample-files, che è stato specificato come bucket di lettura. Tieni presente che il framework XGBoost di SageMaker che viene importato non è il framework open source installato nel passo precedente. Questo è il framework integrato con un'immagine del container Docker che usi per aumentare l'addestramento del modello.
Copia e incolla il blocco di codice seguente per impostare il nome del modello e le configurazioni e i conteggi delle istanze di addestramento e inferenza. Queste impostazioni consentono di gestire i processi di addestramento e di inferenza utilizzando il tipo e il conteggio di istanza appropriati.
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"Fase 3: Avvio dei processi di ottimizzazione degli iperparametri in modalità script
Con SageMaker Studio puoi portare la tua logica all'interno degli script Python da utilizzare per l'addestramento. Incapsulando la logica di addestramento in uno script, puoi incorporare routine di addestramento personalizzate e configurazioni di modelli, pur continuando a utilizzare i comuni container del framework ML gestiti da AWS. In questo tutorial, preparerai uno script di addestramento che utilizza il framework XGBoost open source supportato dal container XGBoost fornito da AWS e avvii processi di ottimizzazione degli iperparametri su larga scala. Per addestrare il modello, verrà utilizzata la colonna frode come colonna di destinazione.
Il primo livello di modalità script è la capacità di definire il proprio processo di addestramento in uno script Python autonomo e personalizzato e di utilizzare quello script come punto di ingresso quando si definisce il proprio stimatore SageMaker. Copia e incolla il blocco di codice seguente per scrivere uno script Python che incapsula la logica di addestramento del modello.
%%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)
Nota come lo script importa la libreria XGBoost open source che hai installato in precedenza.
SageMaker esegue lo script del punto di ingresso e fornisce tutti i parametri di input come i dettagli di configurazione del modello e i percorsi di input e output come argomenti della riga di comando. Lo script utilizza la libreria Python ‘argparse' per acquisire gli argomenti forniti.
Lo script di addestramento viene eseguito all'interno di un container Docker e SageMaker scarica automaticamente i set di dati di addestramento e convalida da Amazon S3 ai percorsi locali all'interno del container. Puoi accedere a queste posizioni tramite variabili di ambiente. Per un elenco completo delle variabili d'ambiente di SageMaker, consulta Variabili d'ambiente.
Dopo aver preparato il tuo script di formazione, potrai creare uno stimatore SageMaker. Utilizzi lo stimatore XGBoost gestito da AWS, poiché gestisce il container XGBoost che può eseguire il tuo script personalizzato. Per creare un'istanza dello stimatore XGBoost, copia e incolla il codice seguente.
# 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
)Quando specifici lo stimatore puoi specificare i parametri di configurazione statica. In questo tutorial, utilizzerai il Receiver Operating Characteristics Area Under the Curve (ROC-AUC) come parametro di valutazione. Per controllare il tempo necessario per l'esecuzione, il numero di fasi è stato impostato su 5.
Lo script personalizzato e le configurazioni dell'istanza di addestramento vengono passati all'oggetto stimatore come argomenti. La versione XGBoost viene scelta in modo da corrispondere a quella installata in precedenza.
In questo tutorial potrai ottimizzare quattro iperparametri XGBoost:
- eta: riduzione della dimensione della fase utilizzato negli aggiornamenti per prevenire l'overfitting. Dopo ogni fase di potenziamento, puoi ottenere direttamente il peso delle nuove funzionalità. Il parametro eta riduce effettivamente i pesi delle funzionalità per rendere il processo di potenziamento più conservativo.
- subsample: rapporto sottocampione delle istanze di addestramento. Impostarlo su 0,5 significa che XGBoost campiona in modo casuale metà dei dati di addestramento prima di far crescere le strutture. L'uso di sottoinsiemi diversi per ogni iterazione di potenziamento aiuta a prevenire l'overfitting.
- colsample_bytree: frazione delle funzionalità utilizzate per generare ciascuna struttura del processo di potenziamento. L'utilizzo di un sottoinsieme di funzionalità per creare ogni struttura introduce più casualità nel processo di modellazione, migliorando la generalizzabilità.
- max_depth: la profondità massima di una struttura. L'aumento di questo valore rende il modello più complesso e suscettibile di un overfitting.
Copia e incolla il blocco di codice seguente per impostare l'intervallo degli iperparametri precedenti da cui eseguire la ricerca.
# 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)
}Copia e incolla il seguente blocco di codice per configurare l'ottimizzatore di iperparametri. SageMaker esegue routine di ottimizzazione bayesiana come impostazione predefinita per il processo di ricerca. In questo tutorial utilizzerai l'approccio della ricerca casuale per ridurre il tempo di esecuzione. I parametri sono ottimizzati in base alle prestazioni AUC del modello sul set di dati di convalida.
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)Puoi chiamare il metodo fit() sull'oggetto ottimizzatore per avviare i processi di ottimizzazione degli iperparametri. Per adattare l'ottimizzatore, è possibile specificare i diversi canali di ingresso. Questo tutorial fornisce i canali di formazione e di convalida. Copia e incolla il seguente blocco di codice per avviare i processi di ottimizzazione degli iperparametri. Il completamento di questa operazione richiede circa 13 minuti.
# 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()I processi di ottimizzazione avviati sono visibili dalla console SageMaker in Hyperparameter tuning jobs (Processi di ottimizzazione degli iperparametri); tieni presente che i nomi dei processi di ottimizzazione come mostrati nelle immagini allegate non corrisponderanno a cosa è realmente visualizzato a causa di diversi timestamp.
Una volta completata l'ottimizzazione, potrai accedere a un riepilogo dei risultati. Copia e incolla il blocco di codice seguente per recuperare i risultati del processo di ottimizzazione in un dataframe Pandas in ordine decrescente di prestazioni.
# 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_tunerIn questo modo potrai esaminare la combinazione di iperparametri con le prestazioni migliori.
Fase 4: Verifica della presenza di errori nel modello e spiegazione delle previsioni del modello tramite SageMaker Clarify
Una volta che hai un modello addestrato, prima dell'implementazione è importante capire se c'è qualche errore intrinseco nel modello o nei dati. Le previsioni del modello possono essere una fonte di errore (ad esempio, se si fanno previsioni che producono più frequentemente un risultato negativo per un gruppo rispetto a un altro). SageMaker Clarify aiuta a spiegare come un modello addestrato effettua previsioni utilizzando un approccio di attribuzione delle funzionalità. In questo tutorial l'attenzione si concentra sul parametro di errore post-addestramento e sui valori SHAP per la spiegabilità del modello. Nello specifico, sono coperte le seguenti attività comuni:
- Rilevamento di errori di dati e modello
- Spiegabilità del modello utilizzando i valori di importanza delle funzionalità
- Impatto delle funzionalità e delle spiegazioni locali per singoli campioni di dati
Prima che SageMaker Clarify possa eseguire il rilevamento degli errori del modello, richiede un modello SageMaker che SageMaker Clarify distribuisce su un endpoint temporaneo come parte delle analisi. Questo endpoint sarà quindi eliminato una volta completate le analisi di SageMaker Clarify. Copia e incolla il seguente blocco di codice per creare un modello SageMaker dal miglior processo di addestramento identificato dal processo di ottimizzazione.
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.")Per eseguire il rilevamento degli errori, SageMaker Clarify prevede l'impostazione delle configurazioni di più componenti. Per maggiori dettagli, visita la pagina di Amazon SageMaker Clarify. Per questo tutorial, a parte le configurazioni standard, configuri SageMaker Clarify in modo che rilevi se i dati sono statisticamente distorti rispetto alle donne controllando se la destinazione è sbilanciata verso un valore basato sul genere del cliente. Copia e incolla il codice seguente per impostare la configurazione di 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
All'interno di SageMaker Clarify, i parametri di pre-addestramento mostrano errori preesistenti nei dati, mentre i parametri di post-addestramento mostrano errori nelle previsioni dal modello. Utilizzando l'SDK SageMaker, puoi specificare in quali gruppi controllare gli errori e quali parametri di errore considerare. Ai fini di questo tutorial, usi Class Imbalance (CI) e Difference in Positive Proportions in Predicted Labels (DPPL) come esempi di statistiche sugli errori pre-addestramento e post-addestramento, rispettivamente. Maggiori dettagli su altri parametri di errore sono disponibili in Misurazione degli errori pre-addestramento e Errori di dati e modello post-addestramento. Copia e incolla il seguente blocco di codice per eseguire SageMaker Clarify e generare report di errore. I parametri di errore scelti vengono inviati come argomenti al metodo run_bias. Il completamento di questo codice richiede circa 12 minuti.
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.nameGli output di SageMaker Clarify vengono salvati nel bucket S3 predefinito. Copia e incolla il codice seguente per scaricare il report di SageMaker Clarify in formato PDF da Amazon S3 nella directory locale in SageMaker Studio.
# Copy bias report and view locally
!aws s3 cp s3://{write_bucket}/{write_prefix}/clarify-output/bias/report.pdf ./clarify_bias_output.pdfNel report PDF, basato sui parametri di errore pre-addestramento e post-addestramento, il set di dati sembra avere uno squilibrio di classe rispetto alla caratteristica del genere del cliente. Tali squilibri possono essere corretti applicando tecniche come SMOTE per creare nuovamente il set di dati di addestramento. Puoi inoltre utilizzare SageMaker Data Wrangler e specificare una delle tante opzioni, incluso SMOTE, disponibili all'interno del servizio per bilanciare i set di dati di addestramento. Per maggiori dettagli, consulta Dati di bilanciamento di Data Wrangler. Per brevità, questo passaggio non è incluso in questo tutorial.
Oltre agli errori di distorsione dei dati, SageMaker Clarify può anche analizzare il modello addestrato e creare un report sulla spiegabilità del modello basato sull'importanza delle funzionalità. SageMaker Clarify utilizza i valori SHAP per spiegare il contributo dato da ogni funzionalità alla previsione finale. Copia e incolla il blocco di codice seguente per configurare ed eseguire un'analisi della spiegazione del modello. Il completamento di questo blocco di codice richiede circa 14 minuti.
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
)Copia e incolla il codice seguente per scaricare il report sulla spiegabilità di SageMaker Clarify in formato PDF da Amazon S3 nella directory locale in SageMaker Studio.
# Copy explainability report and view
!aws s3 cp s3://{write_bucket}/{write_prefix}/clarify-output/explainability/report.pdf ./clarify_explainability_output.pdfIl report contiene grafici di importanza delle funzionalità che mostrano come le funzionalità di input contribuiscono alle previsioni del modello. Per il modello addestrato in questo tutorial, sembra che la funzionalità num-injuries giochi il ruolo più importante nella generazione delle previsioni, seguita a ruota dalla funzionalità customer_gender_male. Tali classificazioni delle funzionalità forniscono informazioni importanti sul meccanismo di previsione e guidano il perfezionamento e lo sviluppo del modello con un uso equo e spiegabile del ML.
I risultati dell'analisi di errori e spiegabilità possono essere visualizzati in SageMaker Studio in SageMaker Resources (Risorse SageMaker) selezionando l'opzione Experiments and trials (Esperimenti e prove) nell'elenco a discesa. Scegli Unassigned trial components (Componenti di prova non assegnati).
Seleziona il report sulla spiegabilità denominato clarify-explainability-<dataora>.
Nella scheda Explainability (Spiegabilità), puoi visualizzare il grafico di importanza delle funzionalità. Puoi scaricare il report anche selezionando Export PDF report (Esporta report PDF).
Il report sulla spiegabilità generato da SageMaker Clarify fornisce anche un file chiamato out.csv contenente i valori SHAP locali per i singoli campioni. Copia e incolla il seguente blocco di codice per utilizzare questo file per visualizzare la spiegazione (l'impatto che ogni funzionalità ha sulla previsione del tuo modello) per ogni singolo campione.
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)
);Per l'esempio scelto (primo campione nel set di test), alla previsione hanno contribuito maggiormente l'importo totale del sinistro, il genere e il numero di infortuni.
Fase 5: Implementazione del modello su un endpoint di inferenza in tempo reale
In questa fase, implementerai il miglior modello ottenuto dal processo di ottimizzazione degli iperparametri su un endpoint di inferenza in tempo reale e quindi utilizzerai l'endpoint per generare le previsioni. Esistono diversi metodi per implementare un modello addestrato, ovvero l'SDK SageMaker, l'SDK AWS - Boto3 e la console SageMaker. Per ulteriori informazioni, consulta Deploy Models for Inference (Implementazione di modelli per l'inferenza) nella documentazione di Amazon SageMaker. In questo esempio, il modello verrà implementato su un endpoint in tempo reale tramite l'SDK SageMaker.
Per implementare il miglior modello, copia e incolla il seguente blocco di codice.
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}")Il codice utilizza il nome del miglior processo di addestramento per recuperare il modello da Amazon S3. XGBoost può accettare i dati di input sia in formato text/libsvm che in formato text/csv. I set di dati di input utilizzati in questo tutorial sono in formato CSV e pertanto la configurazione dell'implementazione include a CSVSerializer che converte gli input CSV in flussi di byte e un CSVDeserializer che converte l'output del modello nativo in flussi di byte di nuovo nel formato CSV in modo da poter essere utilizzato. Al termine, il blocco di codice restituisce il nome dell'endpoint su cui è stato implementato il modello. L'implementazione restituisce anche un SageMaker Predictor che può essere utilizzato per richiamare l'endpoint per eseguire previsioni come mostrato nella sezione successiva.
È possibile controllare l'endpoint distribuito dall'interfaccia di SageMaker Studio facendo clic sull'icona SageMaker Resources (Risorse SageMaker) e selezionando Endpoints (Endpoint) dall'elenco a discesa.
Puoi ispezionare gli endpoint anche tramite la console SageMaker in Inference (Inferenza), Endpoints (Endpoint).
Ora che il modello è stato implementato su un endpoint, puoi richiamarlo chiamando direttamente la REST API (non descritta in questo tutorial), tramite l'SDK AWS, tramite un'interfaccia grafica in SageMaker Studio o utilizzando l'SDK Python di SageMaker. In questo tutorial, utilizzerai SageMaker Predictor reso disponibile durante la fase di implementazione per ottenere previsioni del modello in tempo reale su uno o più campioni di prova. Copia e incolla il seguente blocco di codice per richiamare l'endpoint e inviare un singolo campione di dati di 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]}")L'output della cella mostra l'etichetta true e il punteggio previsto restituito dall'endpoint del modello. Poiché la probabilità prevista è molto bassa, il campione di prova è stato correttamente etichettato come non frode dal modello.
Fase 6: Eliminazione delle risorse
Per evitare di ricevere addebiti non desiderati, una best practice consigliata consiste nell'eliminare le risorse non più utilizzate.
Per eliminare il modello e l'endpoint, copia e incolla il codice seguente nel notebook.
# 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)Per eliminare il bucket S3, completa le seguenti operazioni:
- Apri la console Amazon S3. Sulla barra di navigazione, scegli Buckets (Bucket), sagemaker-<regione>-<id-account>, quindi seleziona la casella di controllo accanto a fraud-detect-demo. Quindi, seleziona Elimina.
- Nella finestra di dialogo Delete objects (Elimina oggetti), verifica di aver selezionato l'oggetto corretto da eliminare, quindi digita permanently delete nella casella di conferma Permanently delete objects (Elimina definitivamente gli oggetti).
- Una volta completato e il bucket è vuoto, potrai eliminare il bucket sagemaker-<regione>-<id-account> eseguendo di nuovo la stessa procedura.
Il kernel Data science utilizzato per eseguire l'immagine del notebook in questo tutorial accumulerà costi fino a quando non lo interromperai o eseguirai i passaggi riportati di seguito per eliminare le app. Per ulteriori informazioni, consulta Risorse di arresto nella guida per gli sviluppatori di Amazon SageMaker.
Per eliminare le app SageMaker Studio, completa la seguente procedura: nella console SageMaker Studio, scegli studio-user, quindi elimina tutte le app riportate in Apps (App) selezionando Delete app (Elimina app). Attendi fino a che Status (Stato) diventa Deleted (Eliminato).
Se nella fase 1 hai utilizzato un dominio SageMaker Studio esistente, salta il resto della fase 6 e procedi direttamente alla sezione conclusiva.
Se hai eseguito il modello CloudFormation nella fase 1 per creare un nuovo dominio SageMaker Studio, continua con le fasi seguenti per eliminare il dominio, l'utente e le risorse create dal modello CloudFormation.
Per aprire la console CloudFormation, immetti CloudFormation nella barra di ricerca della console AWS, quindi scegli CloudFormation dai risultati della ricerca.
Nel riquadro CloudFormation, scegli Stacks (Stack). Dall'elenco a discesa degli stati, seleziona Active (Attivo). In Stack name (Nome stack), scegli CFN-SM-IM-Lambda-catalog per aprire la pagina dei dettagli dello stack.
Nella pagina dei dettagli dello stack CFN-SM-IM-Lambda-catalog, scegli Delete (Elimina) per eliminare lo stack insieme alle risorse create nella fase 1.
Conclusioni
Complimenti! Hai terminato il tutorial Addestramento di un modello di machine learning.
In questo tutorial, hai utilizzato Amazon SageMaker Studio per addestrare un modello di classificazione binaria in modalità script. Hai utilizzato la libreria XGBoost open source con il container XGBoost gestito da AWS per addestrare e ottimizzare il modello utilizzando i processi di ottimizzazione degli iperparametri di SageMaker. Hai anche analizzato gli errori di distorsione e la spiegabilità del modello utilizzando SageMaker Clarify e hai utilizzato i report per valutare l'impatto delle funzionalità sulle singole previsioni. Infine, hai utilizzato l'SDK SageMaker per implementare il modello in un endpoint di inferenza in tempo reale e lo hai testato con un payload campione.
Puoi continuare il tuo percorso da data scientist con Amazon SageMaker completando le fasi successive riportate di seguito.
Creazione automatica di un modello di ML
Implementazione di un modello addestrato
Trova altri tutorial pratici