Información general
En este tutorial, aprenderá a entrenar, ajustar y evaluar un modelo de machine learning (ML) con Amazon SageMaker Studio y Amazon SageMaker Clarify.
Amazon SageMaker Studio es un entorno de desarrollo integrado (IDE) para ML que proporciona una interfaz de cuaderno de Jupyter totalmente administrada en la que puede realizar tareas de ciclo de vida de ML de extremo a extremo. Con SageMaker Studio, puede crear y explorar conjuntos de datos; preparar datos de entrenamiento; crear, entrenar y ajustar modelos; e implementar modelos entrenados para la inferencia, todo en un solo lugar. Mediante el uso de Amazon SageMaker Clarify, puede obtener una mayor visibilidad de los datos y modelos de entrenamiento para poder identificar y limitar los sesgos y explicar las predicciones.
Para este tutorial, utilizará un conjunto de datos de reclamaciones de seguros de automóviles generado de forma sintética. Las entradas son los conjuntos de datos de entrenamiento, validación y prueba, cada uno de los cuales contiene detalles y características extraídas sobre reclamaciones y clientes junto con una columna de fraude que clasifica las reclamaciones como fraudulentas o no. Utilizará el marco XGBoost de código abierto para crear un modelo de clasificación binaria en este conjunto de datos sintético a fin de predecir la probabilidad de que una reclamación sea fraudulenta. También evaluará el modelo entrenado mediante la ejecución de informes de importancia de sesgo y características, implementará el modelo para realizar pruebas y ejecutará inferencias de muestra a fin de evaluar el rendimiento del modelo y explicar las predicciones.
Lo que logrará
En esta guía, aprenderá a hacer lo siguiente:
- Crear, entrenar y ajustar un modelo mediante el modo de script.
- Detectar sesgos en modelos de ML y comprender las predicciones de los modelos.
- Implementar el modelo entrenado en un punto de conexión de inferencia en tiempo real para realizar pruebas.
- Evaluar el modelo al generar predicciones de muestra y comprender el impacto de las características.
Requisitos previos
Antes de comenzar esta guía, necesitará lo siguiente:
- Una cuenta de AWS: si aún no tiene una cuenta, siga la guía de introducción a la Configuración de su entorno de AWS para obtener una descripción general rápida.
Experiencia en AWS
Principiante
Tiempo de realización
2 horas
Costo de realización
Consulte los precios de SageMaker para estimar el costo de este tutorial.
Requisitos
Debe iniciar sesión en una cuenta de AWS.
Servicios utilizados
Amazon SageMaker Studio, Amazon SageMaker Clarify
Última actualización
3 de mayo de 2022
Implementación
Paso 1: configurar el dominio de Amazon SageMaker Studio
Con Amazon SageMaker, puede implementar un modelo de forma visual a través de la consola o mediante programación con el uso de SageMaker Studio o cuadernos de SageMaker. En este tutorial, implementará el modelo por programación mediante un cuaderno de SageMaker Studio, que requiere un dominio de SageMaker Studio.
Una cuenta de AWS solo puede tener un dominio de SageMaker Studio por región. Si ya tiene un dominio de SageMaker Studio en la región Este de EE. UU. (Norte de Virginia), siga la guía de configuración de SageMaker Studio para adjuntar las políticas de AWS IAM requeridas a su cuenta de SageMaker Studio; luego omita el paso 1 y continúe directamente con el paso 2.
Si no tiene un dominio de SageMaker Studio existente, continúe con el paso 1 a fin de ejecutar una plantilla de AWS CloudFormation que cree un dominio de SageMaker Studio y agregue los permisos necesarios para el resto de este tutorial.
Elija el enlace de la pila de AWS CloudFormation. Este enlace abre la consola de AWS CloudFormation y crea su dominio de SageMaker Studio y un usuario denominado studio-user. También agrega los permisos necesarios a su cuenta de SageMaker Studio. En la consola de CloudFormation, confirme que Este de EE. UU. (Norte de Virginia) sea la región que se muestra en la esquina superior derecha. El nombre de la pila debe ser CFN-SM-IM-Lambda-Catalog y no debe cambiarse. Esta pila tarda unos 10 minutos en crear todos los recursos.
Esta pila asume que ya tiene una VPC pública configurada en su cuenta. Si no tiene una VPC pública, consulte VPC con una única subred pública para obtener información sobre cómo crear una VPC pública.
Seleccione I acknowledge that AWS CloudFormation might create IAM resources (Acepto que AWS CloudFormation podría crear recursos de IAM) y luego elija Create stack (Crear pila).
En el panel de CloudFormation, elija Stacks (Pilas). La pila tarda unos 10 minutos en crearse. Cuando se crea la pila, su estado cambia de CREATE_IN_PROGRESS a CREATE_COMPLETE.
Paso 2: configurar un cuaderno de SageMaker Studio
En este paso, lanzará un nuevo cuaderno de SageMaker Studio, instalará las bibliotecas de código abierto necesarias y configurará las variables de SageMaker requeridas para interactuar con otros servicios, incluido Amazon Simple Storage Service (Amazon S3).
Ingrese SageMaker Studio en la barra de búsqueda de la consola y luego seleccione SageMaker Studio.
Elija US East (N. Virginia) (Este de EE. UU. [Norte de Virginia]) de la lista desplegable Region (Región) en la esquina superior derecha de la consola de SageMaker. En Launch app (Lanzar aplicación), seleccione Studio para abrir SageMaker Studio con el perfil studio-user.
Abra la interfaz de SageMaker Studio. En la barra de navegación, seleccione File (Archivo), New (Nuevo), Notebook (Cuaderno).
En el cuadro de diálogo Set up notebook environment (Configurar entorno de cuaderno), en Image (Imagen), seleccione Data Science (Ciencia de datos). El kernel de Python 3 se selecciona automáticamente. Elija Select (Seleccionar).
El kernel en la esquina superior derecha del cuaderno ahora debería mostrar Python 3 (Data Science) (Python 3 [Ciencia de datos]).
Para instalar versiones específicas de las bibliotecas XGBoost y Pandas de código abierto, copie y pegue el siguiente fragmento de código en una celda del cuaderno y presione Shift+Enter (Mayús+Intro) a fin de ejecutar la celda actual. Ignore cualquier advertencia para reiniciar el kernel o cualquier error de conflicto de dependencia.
%pip install -q xgboost==1.3.1 pandas==1.0.5También debe crear una instancia del objeto de cliente de S3 y definir las ubicaciones dentro de su bucket de S3 predeterminado donde se carga contenido, como métricas y artefactos del modelo. Para hacer esto, copie y pegue el siguiente ejemplo de código en una celda del cuaderno y ejecútelo.
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"Tenga en cuenta que el nombre del bucket de escritura se deriva del objeto de sesión de SageMaker. Su bucket predeterminado tiene el nombre sagemaker-<your-Region>-<your-account-id>. Este bucket es donde se cargan todos los artefactos de entrenamiento. Los conjuntos de datos que utiliza para el entrenamiento existen en un bucket público de S3 llamado sagemaker-sample-files, que se especificó como el bucket de lectura. Tenga en cuenta que el marco de SageMaker XGBoost que se está importando no es el marco de código abierto que instaló en el paso anterior. Este es el marco integrado con una imagen de contenedor de Docker que utiliza para escalar verticalmente el entrenamiento del modelo.
Copie y pegue el siguiente bloque de código para establecer el nombre del modelo y las configuraciones y recuentos de instancias de entrenamiento e inferencia. Esta configuración permite administrar los procesos de entrenamiento e inferencia mediante el uso del tipo de instancia y recuento adecuados.
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"Paso 3: lanzar trabajos de ajuste de hiperparámetros en el modo de script
Con SageMaker Studio, puede incorporar su propia lógica dentro de los scripts de Python para utilizarla en el entrenamiento. Al encapsular la lógica de entrenamiento en un script, puede incorporar rutinas de entrenamiento y configuraciones de modelos personalizadas sin dejar de utilizar contenedores de marco de ML comunes que mantiene AWS. En este tutorial, preparará un script de entrenamiento que utiliza el marco XGBoost de código abierto compatible con el contenedor de XGBoost que proporciona AWS y ejecutará trabajos de ajuste de hiperparámetros a escala. Para entrenar el modelo, utilice la columna fraud (fraude) como columna de destino.
El primer nivel del modo de script es la capacidad de definir su propio proceso de entrenamiento en un script de Python personalizado e independiente y utilizar ese script como punto de entrada al definir el estimador de SageMaker. Copie y pegue el siguiente bloque de código para escribir un script de Python que encapsule la lógica de entrenamiento del modelo.
%%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)
Observe cómo el script importa la biblioteca XGBoost de código abierto que instaló anteriormente.
SageMaker ejecuta el script del punto de entrada y proporciona todos los parámetros de entrada, como los detalles de configuración del modelo y las rutas de entrada y salida, como argumentos de la línea de comandos. El script utiliza la biblioteca de Python “argparse” para capturar los argumentos proporcionados.
Su script de entrenamiento se ejecuta dentro de un contenedor de Docker y SageMaker descarga de forma automática conjuntos de datos de entrenamiento y validación de Amazon S3 a rutas locales dentro del contenedor. Se puede acceder a estas ubicaciones a través de variables de entorno. Para obtener una lista exhaustiva de las variables de entorno de SageMaker, consulte Variables de entorno.
Una vez que haya preparado el script de entrenamiento, puede crear una instancia de estimador de SageMaker. Utilice el estimador de XGBoost que administra AWS, ya que administra el contenedor de XGBoost que puede ejecutar su script personalizado. Para crear una instancia del estimador de XGBoost, copie y pegue el siguiente código.
# 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
)Puede especificar los parámetros de configuración estáticos al especificar el estimador. En este tutorial, utilizará el área bajo la curva de características operativas del receptor (ROC-AUC) como la métrica de evaluación. Para controlar el tiempo que tarda en ejecutarse, la cantidad de rondas se ha establecido en 5.
El script personalizado y las configuraciones de la instancia de entrenamiento se pasan al objeto del estimador como argumentos. La versión de XGBoost se elige para que coincida con la que instaló anteriormente.
Ajustará cuatro hiperparámetros de XGBoost en este tutorial:
- eta: reducción del tamaño del paso que se utiliza en las actualizaciones para evitar el sobreajuste. Después de cada paso de impulso, puede obtener directamente los pesos de las características nuevas. El parámetro eta en realidad reduce los pesos de las características para que el proceso de impulso sea más conservador.
- submuestra: proporción de submuestra de las instancias de entrenamiento. Establecerlo en 0,5 significa que XGBoost muestrea al azar la mitad de los datos de entrenamiento antes de crear árboles. El uso de diferentes subconjuntos para cada iteración de impulso ayuda a evitar el sobreajuste.
- colsample_bytree: fracción de características que se utiliza para generar cada árbol del proceso de impulso. El uso de un subconjunto de características para crear cada árbol introduce más aleatoriedad en el proceso de modelado, lo que mejora la generalización.
- max_depth: profundidad máxima de un árbol. Aumentar este valor hace que el modelo sea más complejo y es probable que se sobreajuste.
Copie y pegue el siguiente bloque de código a fin de configurar el rango de los hiperparámetros anteriores a partir del cual se realizará la búsqueda.
# 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)
}Copie y pegue el siguiente bloque de código para configurar el sintonizador de hiperparámetros. SageMaker ejecuta rutinas de optimización bayesianas de forma predeterminada para el proceso de búsqueda. En este tutorial, utilizará el enfoque de búsqueda aleatoria para reducir el tiempo de ejecución. Los parámetros se ajustan en función del rendimiento del AUC del modelo en el conjunto de datos de validación.
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)Puede llamar al método fit() en el objeto del sintonizador para lanzar trabajos de ajuste de hiperparámetros. Para adaptar el sintonizador, puede especificar los diferentes canales de entrada. En este tutorial se proporcionan canales de entrenamiento y validación. Copie y pegue el siguiente bloque de código para lanzar trabajos de ajuste de hiperparámetros. Esto demora aproximadamente 13 minutos en completarse.
# 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()Los trabajos de ajuste iniciados se pueden ver en la consola de SageMaker en Hyperparameter tuning jobs (Trabajos de ajuste de hiperparámetros); tenga en cuenta que los nombres de los trabajos de ajuste que se muestran en las imágenes adjuntas no coincidirán con lo que ve debido a las diferentes marcas temporales.
Una vez que finalice el ajuste, puede acceder a un resumen de resultados. Copie y pegue el siguiente bloque de código para recuperar los resultados del trabajo de ajuste en un marco de datos de pandas organizado en orden descendente de rendimiento.
# 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_tunerPuede inspeccionar la combinación de hiperparámetros que tuvo el mejor rendimiento.
Paso 4: comprobar si hay sesgos en el modelo y explicar las predicciones del modelo con SageMaker Clarify
Una vez que tiene un modelo entrenado, es importante comprender si existe algún sesgo inherente en el modelo o en los datos antes de la implementación. Las predicciones del modelo pueden ser una fuente de sesgo (por ejemplo, si realiza predicciones que producen un resultado negativo con más frecuencia para un grupo que para otro). SageMaker Clarify ayuda a explicar la forma en que un modelo entrenado realiza predicciones con un enfoque de atribución de características. En este tutorial, el enfoque se encuentra en la métrica de sesgo posterior al entrenamiento y los valores SHAP para la explicabilidad del modelo. En concreto, se analizan las siguientes tareas comunes:
- Detección de sesgo de datos y modelos
- Explicabilidad del modelo mediante valores de importancia de las características
- Impacto de las características y explicaciones locales para muestras de datos individuales
Antes de que SageMaker Clarify pueda realizar la detección de sesgo del modelo, se requiere un modelo de SageMaker que SageMaker Clarify implemente en un punto de conexión efímero como parte de los análisis. Luego, el punto de conexión se elimina una vez que se completan los análisis de SageMaker Clarify. Copie y pegue el siguiente bloque de código para crear un modelo de SageMaker a partir del mejor trabajo de entrenamiento identificado en el trabajo de ajuste.
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.")Para ejecutar la detección de sesgo, SageMaker Clarify espera que se configuren varias configuraciones de componentes. Puede encontrar más detalles en Amazon SageMaker Clarify. En este tutorial, además de las configuraciones estándar, configurará SageMaker Clarify para detectar si los datos se encuentran estadísticamente sesgados contra las mujeres al comprobar si el destino está sesgado hacia un valor que se basa en el género del cliente. Copie y pegue el siguiente código para establecer la configuración de SageMaker Clarify.
train_df = pd.read_csv(train_data_uri)
train_df_cols = train_df.columns.to_list()
clarify_processor = sagemaker.clarify.SageMakerClarifyProcessor(
role=sagemaker_role,
instance_count=clarify_instance_count,
instance_type=clarify_instance_type,
sagemaker_session=sess,
)
# Data config
bias_data_config = sagemaker.clarify.DataConfig(
s3_data_input_path=train_data_uri,
s3_output_path=bias_report_output_uri,
label="fraud",
headers=train_df_cols,
dataset_type="text/csv",
)
# Model config
model_config = sagemaker.clarify.ModelConfig(
model_name=xgb_model_name,
instance_type=train_instance_type,
instance_count=1,
accept_type="text/csv",
)
# Model predictions config to get binary labels from probabilities
predictions_config = sagemaker.clarify.ModelPredictedLabelConfig(probability_threshold=0.5)
# Bias config
bias_config = sagemaker.clarify.BiasConfig(
label_values_or_threshold=[0],
facet_name="customer_gender_female",
facet_values_or_threshold=[1],
)
# Run Clarify job
clarify_processor.run_bias(
data_config=bias_data_config,
bias_config=bias_config,
model_config=model_config,
model_predicted_label_config=predictions_config,
pre_training_methods=["CI"],
post_training_methods=["DPPL"])
clarify_bias_job_name = clarify_processor.latest_job.name
Dentro de SageMaker Clarify, las métricas anteriores al entrenamiento muestran un sesgo preexistente en los datos, mientras que las métricas posteriores al entrenamiento muestran un sesgo en las predicciones del modelo. Con el SDK de SageMaker, puede especificar los grupos en los que desea comprobar el sesgo y las métricas de sesgo a considerar. A los efectos de este tutorial, utilizará el Desequilibrio de clases (CI) y la Diferencia en proporciones positivas en etiquetas previstas (DPPL) como ejemplos de estadísticas de sesgo anteriores y posteriores al entrenamiento, respectivamente. Puede encontrar detalles de otras métricas de sesgo en Medir sesgo anterior al entrenamiento y Datos posteriores al entrenamiento y sesgo del modelo. Copie y pegue el siguiente bloque de código para ejecutar SageMaker Clarify y generar informes de sesgo. Las métricas de sesgo elegidas se pasan como argumentos al método run_bias. Este código demora aproximadamente 12 minutos en completarse.
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.nameLos resultados de SageMaker Clarify se guardan en su bucket de S3 predeterminado. Copie y pegue el siguiente código para descargar el informe de SageMaker Clarify en formato PDF desde Amazon S3 a su directorio local en SageMaker Studio.
# Copy bias report and view locally
!aws s3 cp s3://{write_bucket}/{write_prefix}/clarify-output/bias/report.pdf ./clarify_bias_output.pdfEn el informe en PDF, que se basa en las métricas de sesgo anteriores y posteriores al entrenamiento, el conjunto de datos parece tener un desequilibrio de clase con respecto a la característica de género del cliente. Estos desequilibrios se pueden corregir al aplicar técnicas como SMOTE para recrear el conjunto de datos de entrenamiento. También puede utilizar SageMaker Data Wrangler y especificar una de las diferentes opciones, incluida la de SMOTE, que se encuentran disponibles en el servicio para equilibrar los conjuntos de datos de entrenamiento. Para obtener más detalles, consulte Datos de equilibrio de Data Wrangler. Para abreviar, este paso no se encuentra incluido en este tutorial.
Además del sesgo de datos, SageMaker Clarify también puede analizar el modelo entrenado y crear un informe de explicabilidad del modelo en función de la importancia de las características. SageMaker Clarify utiliza valores SHAP para explicar la contribución que realiza cada característica de entrada a la predicción final. Copie y pegue el siguiente bloque de código para configurar y ejecutar un análisis de explicabilidad del modelo. Este bloque de código demora aproximadamente 14 minutos en completarse.
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
)Copie y pegue el siguiente código para descargar el informe de explicabilidad de SageMaker Clarify en formato PDF desde Amazon S3 a su directorio local en SageMaker Studio.
# Copy explainability report and view
!aws s3 cp s3://{write_bucket}/{write_prefix}/clarify-output/explainability/report.pdf ./clarify_explainability_output.pdfEl informe contiene gráficos de importancia de las características que muestran cómo las características de entrada contribuyen a las predicciones del modelo. En el caso del modelo entrenado en este tutorial, parece que la característica num-injuries juega el papel más importante, seguida de cerca por la característica customer_gender_male en la generación de predicciones. Estas clasificaciones de características otorgan información importante sobre el mecanismo de predicción e impulsan el refinamiento y el desarrollo del modelo con un uso justo y explicable de ML.
Los resultados del análisis de sesgo y explicabilidad también se pueden ver en SageMaker Studio en la opción SageMaker Resources (Recursos de SageMaker) y Experiments and trials (Experimentos y pruebas) en la lista desplegable. Elija Unassigned trial components (Componentes de prueba no asignados).
Seleccione el informe de explicabilidad denominado clarify-explainability-<datetimestamp>.
En la pestaña Explainability (Explicabilidad), puede visualizar el gráfico de importancia de las características. También puede descargar el informe al elegir Export PDF report (Exportar informe en PDF).
El informe de explicabilidad que genera SageMaker Clarify también proporciona un archivo llamado out.csv que contiene valores SHAP locales para muestras individuales. Copie y pegue el siguiente bloque de código para utilizar este archivo a fin de visualizar la explicación (el impacto que tiene cada característica en la predicción de su modelo) para cualquier ejemplo individual.
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)
);En el caso del ejemplo elegido (primera muestra en el conjunto de prueba), el monto total de la reclamación, el género y la cantidad de lesiones contribuyeron más a la predicción.
Paso 5: implementar el modelo en un punto de conexión de inferencia en tiempo real
En este paso, implementará el mejor modelo obtenido del trabajo de ajuste de hiperparámetros en un punto de conexión de inferencia en tiempo real y luego utilizará el punto de conexión para generar predicciones. Existen varios métodos para implementar un modelo entrenado, como el SDK de SageMaker, AWS SDK: Boto3 y la consola de SageMaker. Para obtener más información, consulte Implementación de modelos para inferencia en la documentación de Amazon SageMaker. En este ejemplo, implementará el modelo en un punto de conexión en tiempo real mediante el SDK de SageMaker.
Copie y pegue el siguiente bloque de código para implementar el mejor modelo.
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}")El código utiliza el nombre del mejor trabajo de entrenamiento para recuperar el modelo de Amazon S3. XGBoost puede aceptar datos de entrada en formato texto/libsvm o texto/csv. Los conjuntos de datos de entrada que se utilizan en este tutorial se encuentran en el formato CSV y, por lo tanto, la configuración de implementación incluye un CSVSerializer que convierte las entradas de CSV en secuencias de bytes y un CSVDeserializer que convierte la salida del modelo nativo en secuencias de bytes al formato CSV para nuestro consumo. Al finalizar, el bloque de código devuelve el nombre del punto de conexión en el que se implementó el modelo. La implementación también devuelve un indicador de SageMaker que se puede utilizar para invocar el punto de conexión a fin de ejecutar predicciones como se muestra en la siguiente sección.
Puede consultar el punto de conexión implementado desde la interfaz de SageMaker Studio al hacer clic en el ícono de SageMaker Resources (Recursos de SageMaker) y seleccionar Endpoints (Puntos de conexión) en la lista desplegable.
También puede inspeccionar puntos de conexión a través de la consola de SageMaker en Inference (Inferencia), Endpoints (Puntos de conexión).
Ahora que el modelo se ha implementado en un punto de conexión, puede invocarlo al llamar directamente a la API de REST (no se describe en este tutorial), a través de AWS SDK, una interfaz gráfica en SageMaker Studio o con el SDK para Python de SageMaker. En este tutorial, utilizará el indicador de SageMaker disponible a través del paso de implementación para obtener predicciones de modelos en tiempo real en una o más muestras de prueba. Copie y pegue el siguiente bloque de código para invocar el punto de conexión y enviar una sola muestra de datos de prueba.
# 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]}")El resultado de la celda muestra la etiqueta verdadera y la puntuación pronosticada en la forma en que la envía el punto de conexión del modelo. Debido a que la probabilidad predicha es muy baja, el modelo etiquetó de forma correcta la muestra de prueba como no fraudulenta.
Paso 6: eliminar los recursos
Una práctica recomendada es eliminar los recursos que ya no se utilizan para no incurrir en cargos no deseados.
Para eliminar el modelo y el punto de conexión, copie y pegue el siguiente código en el cuaderno.
# 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)Para eliminar el bucket de S3, haga lo siguiente:
- Abra la consola de Amazon S3. En la barra de navegación, elija Buckets, sagemaker-<your-Region>-<your-account-id> y, a continuación, marque la casilla de verificación junto a fraud-detect-demo. Luego, seleccione Delete (Eliminar).
- En el cuadro de diálogo Delete objects (Eliminar objetos), verifique que haya seleccionado el objeto apropiado para eliminar e ingrese permanently delete (eliminar de forma permanente) en la casilla de confirmación Permanently delete objects (Eliminar objetos de forma permanente).
- Una vez que haya finalizado esto y el bucket esté vacío, puede eliminar el bucket sagemaker-<your-Region>-<your-account-id> siguiendo el mismo procedimiento nuevamente.
El kernel de ciencia de datos utilizado para ejecutar la imagen del cuaderno en este tutorial acumulará cargos hasta que lo detenga o realice los siguientes pasos para eliminar las aplicaciones. Para obtener más información, consulte Apagar recursos en la Guía para desarrolladores de Amazon SageMaker.
Para eliminar las aplicaciones de SageMaker Studio, haga lo siguiente: en la consola de SageMaker Studio, elija studio-user y, a continuación, elimine todas las aplicaciones que aparecen en Apps (Aplicaciones) al seleccionar Delete app (Eliminar aplicación). Espere hasta que el Status (Estado) cambie a Deleted (Eliminado).
Si usó un dominio existente de SageMaker Studio en el paso 1, omita el resto del paso 6 y vaya directamente a la sección de conclusión.
Si ejecutó la plantilla de CloudFormation en el paso 1 para crear un dominio de SageMaker Studio nuevo, continúe con los siguientes pasos a fin de eliminar el dominio, el usuario y los recursos creados por la plantilla de CloudFormation.
Para abrir la consola de CloudFormation, ingrese CloudFormation en la barra de búsqueda de la consola de AWS y elija CloudFormation en los resultados de búsqueda.
En el panel de CloudFormation, elija Stacks (Pilas). En la lista desplegable de estado, seleccione Active (Activo). En Stack name (Nombre de la pila), elija CFN-SM-IM-Lambda-catalog para abrir la página de detalles de la pila.
En la página de detalles de la pila CFN-SM-IM-Lambda-catalog, elija Delete (Eliminar) para eliminar la pila junto con los recursos que creó en el paso 1.
Conclusión
¡Felicitaciones! Ha finalizado el tutorial Entrenamiento de un modelo de machine learning.
En este tutorial, utilizó Amazon SageMaker Studio para entrenar un modelo de clasificación binaria en modo de script. Utilizó la biblioteca XGBoost de código abierto con el contenedor de XGBoost que administra AWS para entrenar y ajustar el modelo mediante trabajos de ajuste de hiperparámetros de SageMaker. También analizó el sesgo y la explicabilidad del modelo con SageMaker Clarify y utilizó los informes para evaluar el impacto de las características en las predicciones individuales. Por último, utilizó el SDK de SageMaker para implementar el modelo en un punto de conexión de inferencia en tiempo real y lo probó con una carga de muestra.
Puede continuar su viaje de científico de datos con Amazon SageMaker en la siguiente sección de pasos.
Crear un modelo de ML automáticamente
Implementar un modelo entrenado
Encontrar más tutoriales prácticos