Addestramento di un modello di machine learning
TUTORIAL
Panoramica
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 minimo richiesto 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
27 marzo 2023
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.
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.
Lo stack inoltre presuppone che sia presente un VPC pubblico predefinito configurato nell'account. Se non disponi di un VPC pubblico, consulta VPC con una singola sottorete pubblica per scoprire come creare un VPC pubblico.
Seleziona Sono consapevole che AWS CloudFormation può creare le risorse IAM, quindi scegli Crea stack.
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).
2.1 Digita SageMaker Studio nella barra di ricerca della console, quindi scegli SageMaker Studio.
2.2 Scegli Stati Uniti orientali (Virginia settentrionale) dall'elenco a discesa Regione nell'angolo in alto a destra della console SageMaker. Per avviare l'app, seleziona Studio dal riquadro di navigazione a sinistra. Seleziona studio-user come profilo utente e scegli il pulsante Apri Studio.
2.3 Verrà visualizzata la schermata di creazione dell'applicazione all'interno di SageMaker Studio. Il caricamento dell'applicazione richiede qualche minuto.
2.4 Apri l'interfaccia di SageMaker Studio. Sulla barra di navigazione, scegli File, Nuovo, Notebook.
2.5 Nella finestra di dialogo Configura ambiente notebook, in Immagine, seleziona Data Science 3. Il kernel Python 3 viene selezionato automaticamente. Per Tipo di istanza , scegli ml.t3.medium. Scegli Seleziona.
2.6 Il kernel nell'angolo in alto a destra del notebook dovrebbe visualizzare Python 3 (Data Science).
2.7 In una nuova cella di codice nel notebook Jupyter, copia e incolla il codice seguente ed esegui la cella. Ciò assicurerà che tu stia utilizzando la versione corrente di SageMaker.
%pip install sagemaker --upgrade --quiet 2.8 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.52.9 Devi 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"2.10 Tieni presente che il nome del bucket di scrittura deriva dall'oggetto di sessione di SageMaker. Il nome del bucket predefinito è sagemaker-<your-Region>-<your-account-id>. 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 utilizzi per aumentare verticalmente l'addestramento del modello.
2.11 Copia e incolla il seguente blocco di codice 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.
3.1 Il primo livello di modalità script è la capacità di definire il proprio processo di addestramento in uno script Python autonomo e personalizzato, per poi 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.
3.2 Dopo aver preparato il tuo script di addestramento, 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
)3.3. Quando selezioni 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.
3.4 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)
}3.5 Copia e incolla il seguente blocco di codice per configurare l'ottimizzatore di iperparametri. SageMaker esegue routine di ottimizzazione bayesiane 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)3.6 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()3.7 I processi di ottimizzazione avviati sono visibili dalla console SageMaker in 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 della differenza dei timestamp.
3.8 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 prestazione.
# 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 In 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
4.1 Prima che SageMaker Clarify possa eseguire il rilevamento degli errori del modello, il servizio richiede un modello SageMaker che SageMaker Clarify implementa 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 derivato 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.")4.2 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],
)4.3 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.name4.4. Gli 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.pdf4.5 Nel report in 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.
4.6 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
)4.7 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.pdf4.8. Il 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à customer_gender_male giochi il ruolo più importante nella generazione delle previsioni, seguita a ruota dalla funzionalità num-injuries. 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.
4.9 I risultati dell'analisi di errore e spiegabilità possono essere visualizzati anche in SageMaker Studio nella sezione SageMaker Home ed Esperimenti.
4.10 Scegli Esecuzioni non assegnate. Seleziona il report sulla spiegabilità denominato clarify-explainability-<datetimestamp>.
4.11 Nella scheda Spiegabilità, puoi visualizzare il grafico di importanza delle funzionalità. Puoi scaricare il report anche selezionando Esporta report PDF report.
4.12 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)
);4.13 Per l'esempio scelto (primo campione nel set di test), alla previsione hanno contribuito maggiormente l'importo del sinistro, il genere e il numero di incidenti al giorno.
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.
5.1 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}")5.2 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 ed eseguire previsioni come mostrato nella sezione successiva.
5.3 È possibile controllare l'endpoint implementato dall'interfaccia di SageMaker Studio selezionando l'icona SageMaker Home e selezionando Implementazioni e quindi Endpoint.
5.4 Puoi ispezionare gli endpoint anche tramite la console SageMaker in Inferenza, Endpoint.
5.5 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]}")5.6 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 dal modello come non frode.
Fase 6: Eliminazione delle risorse
Per evitare di ricevere addebiti non desiderati, una best practice consigliata consiste nell'eliminare le risorse non più utilizzate.
6.1 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)6.2 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-<your-Region>-<your-id-account> eseguendo di nuovo la stessa procedura.
Per eliminare le app SageMaker Studio, procedi come segue: nella console SageMaker, scegli Domini, quindi scegli StudioDomain. Dall'elenco Profili utente, seleziona studio-user, quindi elimina tutte le app elencate in App. scegliendo Elimina app. Per eliminare il JupyterServer, scegli Azione, quindi Elimina. Attendi finché lo Stato non diventa Eliminato.
6.4 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.
6.5 Per aprire la console CloudFormation, digita CloudFormation nella barra di ricerca della console AWS, quindi scegli CloudFormation dai risultati della ricerca.
6.6 Aprire la console CloudFormation. Nel riquadro CloudFormation , scegli Stack. Dall'elenco a discesa degli stati, seleziona Attivo. In Nome stack, scegli CFN-SM-IM-Lambda-catalog per aprire la pagina dei dettagli dello stack.
6.7 Nella pagina dei dettagli dello stack CFN-SM-IM-Lambda-Catalog, scegli Elimina per cancellare lo stack insieme alle risorse create nella fase 1.
Conclusioni
Creazione automatica di un modello di ML
Implementazione di un modello addestrato
Trova altri tutorial pratici