Visão geral
Neste tutorial, você aprenderá a treinar, ajustar e avaliar um modelo de machine learning (ML) usando o Amazon SageMaker Studio e o Amazon SageMaker Clarify.
O Amazon SageMaker Studio é um ambiente de desenvolvimento integrado (IDE) para ML que fornece uma interface de caderno Jupyter totalmente gerenciada em que é possível executar tarefas completas do ciclo de vida de ML. Usando o SageMaker Studio, é possível: criar e explorar conjuntos de dados; preparar dados de treinamento; desenvolver, treinar e ajustar modelos; e implementar modelos treinados para inferência. Você pode fazer tudo isso em um só lugar. Com o Amazon SageMaker Clarify, obtenha maior visibilidade de seus dados e modelos de treinamento para poder identificar e limitar tendências, além de explicar as previsões.
Para este tutorial, você usará um conjunto de dados de declarações de indenizações próprio que foi gerado sinteticamente. As entradas são os conjuntos de dados de treinamento, validação e teste. Cada um desses conjuntos contém detalhes e recursos extraídos sobre solicitações e clientes, com uma coluna fraud (fraude) indicando se a reclamação foi fraudulenta ou não. Você usará o framework XGBoost de código aberto para desenvolver um modelo de classificação binária nesse conjunto de dados sintético e prever a probabilidade de uma solicitação ser fraudulenta. Também avaliará o modelo treinado executando relatórios de desvio e importância do recurso, implantará o modelo para testes e executará inferência de amostra para avaliar a performance do modelo e explicar as previsões.
O que você aprenderá
Neste guia, você vai:
- Desenvolver, treinar e ajustar um modelo usando o modo de script
- Detectar tendências em modelos de ML e entender as previsões do modelo
- Implantar o modelo treinado em um endpoint de inferência em tempo real para testes
- Avaliar o modelo gerando previsões de amostra e entendendo o impacto do recurso
Pré-requisitos
Antes de iniciar este guia, você precisará de:
- Uma conta da AWS: caso ainda não tenha uma conta, siga o guia de conceitos básicos Setting Up Your AWS Environment (Configurar seu ambiente da AWS) para obter uma breve visão geral.
AWS Experience
Iniciante
Tempo para a conclusão
2 horas
Custo para a conclusão
Consulte os preços do SageMaker para estimar o custo deste tutorial.
Requisitos
É necessário se conectar a uma conta da AWS.
Serviços usados
Amazon SageMaker Studio, Amazon SageMaker Clarify
Data da última atualização
3 de maio de 2022
Implementação
Etapa 1: configurar o domínio do Amazon SageMaker Studio
Com o Amazon SageMaker, é possível implantar um modelo visualmente pelo console ou de maneira programática com o SageMaker Studio ou blocos de anotações do SageMaker. Neste tutorial, implante o modelo de maneira programática usando um bloco de anotações do SageMaker Studio, que requer um domínio do SageMaker Studio.
Uma conta da AWS pode ter apenas um domínio do SageMaker Studio por região. Caso já tenha um domínio do SageMaker Studio na região Leste dos EUA (Norte da Virgínia), siga o guia de configuração do SageMaker Studio para anexar as políticas do AWS IAM necessárias à conta do SageMaker Studio, ignore a Etapa 1 e vá diretamente para a Etapa 2.
Caso não tenha um domínio SageMaker Studio, continue com os passos da Etapa 1 para executar um modelo do AWS CloudFormation que cria um domínio do SageMaker Studio e adiciona as permissões necessárias para finalizar este tutorial.
Escolha o link da pilha do AWS CloudFormation. Esse link abre o console do AWS CloudFormation e cria seu domínio do SageMaker Studio e um usuário chamado studio-user. Também adiciona as permissões necessárias a sua conta do SageMaker Studio. No console do CloudFormation, confirme se US East (N. Virginia) (Leste dos EUA [Norte da Virgínia]) é a Region (Região) exibida no canto superior direito. O Stack name (Nome da pilha) deve ser CFN-SM-IM-Lambda-Catalog e não poderá ser alterado. Essa pilha leva cerca de dez minutos para criar todos os recursos.
A pilha pressupõe que você já tenha uma VPC pública configurada na conta. Se você não tiver uma VPC pública, consulte VPC com uma única sub-rede pública para aprender como criar uma VPC pública.
Selecione I acknowledge that AWS CloudFormation might create IAM resources (Estou ciente de que o AWS CloudFormation pode criar recursos do IAM) e escolha Create stack (Criar pilha).
No painel CloudFormation, selecione Stacks (Pilhas). A pilha leva dez minutos para ser criada. Quando a pilha é criada, o status da pilha é alterado de CREATE_IN_PROGRESS para CREATE_COMPLETE.
Etapa 2: configurar um bloco de anotações do SageMaker Studio
Nesta etapa, você executará um novo bloco de anotações do SageMaker Studio, instalará as bibliotecas de código aberto necessárias e configurará as variáveis do SageMaker necessárias para interagir com outros serviços, como o Amazon Simple Storage Service (Amazon S3).
Digite SageMaker Studio na barra de pesquisa do console e escolha SageMaker Studio.
Escolha US East (N. Virginia) (Leste dos EUA [Norte da Virgínia]) na lista suspensa Region (Região) no canto superior direito do console do SageMaker. Em Launch app (Iniciar aplicação), selecione Studio para abrir o SageMaker Studio usando o perfil studio-user.
Abra a interface do SageMaker Studio. Na barra de navegação, escolha File (Arquivo), New (Novo), Notebook (Bloco de anotações).
Na caixa de diálogo Set up notebook environment (Configurar ambiente de bloco de anotações), em Image (Imagem), selecione Data Science (Ciência de dados). O kernel Python 3 é selecionado automaticamente. Escolha Select .
O kernel no canto superior direito do bloco de anotações agora deverá exibir Python 3 (Data Science) (Ciência de dados).
Para instalar versões específicas das bibliotecas de código aberto XGBoost e Pandas, copie e cole o trecho de código a seguir em uma célula no bloco de anotações e pressione Shift+Enter para executar a célula atual. Ignore avisos para reiniciar o kernel ou qualquer erro de conflito de dependência.
%pip install -q xgboost==1.3.1 pandas==1.0.5Também é necessário criar uma instância do objeto de cliente do S3 e definir os locais do bucket do S3 padrão em que conteúdos como métricas e artefatos de modelo serão carregados. Para isso, copie e cole o exemplo de código a seguir em uma célula do bloco de anotações e execute-o.
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"O nome do bucket de gravação é derivado do objeto de sessão do SageMaker. O nome de seu bucket padrão é sagemaker-<your-Region>-<your-account-id>. Esse é o bucket em que todos os artefatos de treinamento são carregados. Os conjuntos de dados que você usa para treinamento estão localizados em um bucket público do S3 chamado sagemaker-sample-files, que foi especificado como o bucket de leitura. O framework XGBoost do SageMaker que está sendo importado não é o framework de código aberto que você instalou na etapa anterior. Esse é o framework interno com uma imagem de contêiner do Docker usado para aumentar a escala verticalmente do treinamento do modelo.
Copie e cole o bloco de código a seguir para definir o nome do modelo e as configurações e contagens de instâncias de treinamento e inferência. Essas configurações permitem gerenciar os processos de treinamento e inferência usando o tipo e a contagem de instância corretos.
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"Etapa 3: iniciar trabalhos de ajuste de hiperparâmetros no modo de script
Com o SageMaker Studio, você pode trazer sua própria lógica dentro dos scripts do Python a ser usada no treinamento. Ao encapsular a lógica de treinamento em um script, é possível incorporar rotinas de treinamento personalizadas e configurações de modelo enquanto você ainda usa contêineres de framework de ML comuns mantidos pela AWS. Neste tutorial, você vai preparar um script de treinamento que usa o framework XGBoost de código aberto compatível com o contêiner XGBoost fornecido pela AWS e inicia trabalhos de ajuste de hiperparâmetro em escala. Para treinar o modelo, use a coluna fraud fraude como coluna de destino.
O primeiro nível do modo de script é a capacidade de definir seu próprio processo de treinamento em um script do Python personalizado e independente e usar esse script como ponto de entrada ao definir o estimador do SageMaker. Copie e cole o bloco de código a seguir para escrever um script do Python encapsulando a lógica de treinamento do 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)
Veja como o script importa a biblioteca de código aberto XGBoost que você instalou anteriormente.
O SageMaker executa o script de ponto de entrada e fornece todos os parâmetros de entrada, como detalhes de configuração do modelo e caminhos de entrada e saída como argumentos de linha de comando. O script usa a biblioteca Python “argparse” para capturar os argumentos fornecidos.
O script de treinamento é executado em um contêiner do Docker, e o SageMaker baixa automaticamente conjuntos de dados de treinamento e validação do Amazon S3 para caminhos locais dentro do contêiner. Esses locais podem ser acessados por variáveis de ambiente. Para obter uma lista exaustiva das variáveis de ambiente do SageMaker, consulte Environment variables (Variáveis de ambiente).
Depois de preparar o script de treinamento, você pode criar uma instância de um estimador do SageMaker. Use o estimador do XGBoost gerenciado pela AWS, pois ele gerencia o contêiner XGBoost que poderá executar seu script personalizado. Para criar uma instância do estimador do XGBoost, copie e cole o código a seguir.
# 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
)Você pode especificar os parâmetros de configuração estática ao especificar o estimador. Neste tutorial, você vai usar a área sob a curva de característica de operação do receptor (ROC-AUC) como a métrica de avaliação. Para controlar o tempo de execução, o número de rodadas foi definido como 5.
O script personalizado e as configurações da instância de treinamento são transmitidos para o objeto de estimador como argumentos. Escolhe-se a versão do XGBoost para corresponder à instalada anteriormente.
Neste tutorial, você ajustará quatro hiperparâmetros do XGBoost:
- eta: redução do tamanho da etapa usada em atualizações para evitar sobreajuste. Após cada etapa de aumento, é possível obter diretamente os pesos dos novos recursos. O parâmetro eta de fato reduz os pesos dos recurso, deixando o processo de aumento mais conservador.
- subsample: proporção de subamostra das instâncias de treinamento. Defini-la como 0.5 significa que o XGBoost fará amostras aleatórias de metade dos dados de treinamento antes de criar árvores. Usar diferentes subconjuntos para cada iteração de aumento ajuda a evitar o sobreajuste.
- colsample_bytree: fração de recursos usados para gerar cada árvore do processo de aumento. Usar um subconjunto de recursos para criar cada árvore introduz mais aleatoriedade ao processo de modelagem, melhorando a generalizabilidade.
- max_depth: profundidade máxima de uma árvore. Aumentar esse valor torna o modelo mais complexo e propenso a sobreajustes.
Copie e cole o bloco de código a seguir para configurar o intervalo dos hiperparâmetros anteriores de onde pesquisar.
# 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 e cole o bloco de código a seguir para configurar o sintonizador de hiperparâmetros. O SageMaker executa rotinas de otimização bayesiana como padrão para o processo de pesquisa. Neste tutorial, usará a metodologia de pesquisa aleatória para reduzir o tempo de execução. Os parâmetros são ajustados com base na performance de AUC do modelo no conjunto de dados de validação.
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)Você pode chamar o método fit() no objeto do sintonizador para iniciar trabalhos de ajuste de hiperparâmetros. Para ajustar o sintonizador, é possível especificar os diferentes canais de entrada. Este tutorial fornece canais de treinamento e de validação. Copie e cole o bloco de código a seguir para iniciar trabalhos de hiperparâmetros. Isso levará aproximadamente 13 minutos para ser concluído.
# 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()Os trabalhos de ajuste iniciados são exibidos no console do SageMaker em Hyperparameter tuning jobs (Trabalhos de ajuste de hiperparâmetros). Os nomes dos trabalhos de ajuste, conforme mostrado nas imagens anexas, não corresponderão ao que você vê por causa dos diferentes carimbos de data/hora.
Quando o ajuste estiver concluído, você terá acesso a um resumo dos resultados. Copie e cole o bloco de código a seguir para recuperar os resultados do trabalho de ajuste em uma estrutura de dados do pandas organizada em ordem decrescente de performance.
# Summary of tuning results ordered in descending order of performance
df_tuner = sagemaker.HyperparameterTuningJobAnalytics(tuner.latest_tuning_job.job_name).dataframe()
df_tuner = df_tuner[df_tuner["FinalObjectiveValue"]>-float('inf')].sort_values("FinalObjectiveValue", ascending=False)
df_tunerÉ possível inspecionar a combinação de hiperparâmetros que teve a melhor performance.
Etapa 4: verificar se há desvios no modelo e explique as previsões do modelo com o SageMaker Clarify
Depois de obter um modelo treinado, é importante entender se há algum desvio inerente no modelo ou nos dados antes da implantação. As previsões do modelo podem ser uma fonte de desvio (por exemplo, se fizerem previsões que produzam um resultado negativo com mais frequência para um grupo do que para outro). O SageMaker Clarify ajuda a explicar como um modelo treinado faz previsões usando uma metodologia de atribuição de recursos. Neste tutorial, o foco está na métrica de desvio pós-treinamento e nos valores de SHAP para explicabilidade do modelo. Especificamente, abrangem-se as seguintes tarefas comuns:
- Detecção de desvio de dados e de modelos
- Explicabilidade do modelo usando valores de importância do recurso
- Impacto dos recursos e explicações locais para amostras de dados individuais
Para que possa realizar a detecção de desvio de modelo, o SageMaker Clarify necessita de um modelo do SageMaker que o SageMaker Clarify implanta em um endpoint efêmero como parte das análises. O endpoint é excluído assim que as análises do SageMaker Clarify são concluídas. Copie e cole o bloco de código a seguir para criar um modelo do SageMaker com base no melhor trabalho de treinamento identificado no trabalho 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 executar a detecção de desvio, o SageMaker Clarify espera que várias configurações de componentes sejam definidas. Você encontra mais detalhes em Amazon SageMaker Clarify. Neste tutorial, além das configurações padrão, você configurará o SageMaker Clarify para detectar se os dados são estatisticamente enviesados em relação ao sexo feminino, verificando se o destino é desviado para um valor com base no sexo do cliente. Copie e cole o código a seguir para definir a configuração do 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
No SageMaker Clarify, as métricas de pré-treinamento mostram desvio pré-existente nos dados, enquanto as métricas de pós-treinamento mostram desvio nas previsões do modelo. Com o SDK do SageMaker, você pode especificar em quais grupos deseja verificar o desvio e quais métricas de desvio quer considerar. Para os fins deste tutorial, utilize desbalanceamento de classe (CI) e diferença nas proporções positivas em rótulos previstos (DPPL) como exemplos de estatísticas de desvio pré e pós-treinamento, respectivamente. Você encontra detalhes sobre outras métricas de desvio em Measure Pretraining Bias (Medir desvio pré-treinamento) e Posttraining Data and Model Bias (Desvio de dados e modelos pós-treinamento. Copie e cole o bloco de código a seguir para executar o SageMaker Clarify e gerar relatórios de desvio. As métricas de desvio escolhidas são transmitidas como argumentos ao método run_bias. Esse código levará aproximadamente 12 minutos para ser concluído.
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.nameAs saídas do SageMaker Clarify são salvas em seu bucket do S3 padrão. Copie e cole o código a seguir para baixar o relatório do SageMaker Clarify em PDF do Amazon S3 para o diretório local no SageMaker Studio.
# Copy bias report and view locally
!aws s3 cp s3://{write_bucket}/{write_prefix}/clarify-output/bias/report.pdf ./clarify_bias_output.pdfNo relatório em PDF, com base nas métricas de desvio de pré e pós-treinamento, o conjunto de dados parece ter um desbalanceamento de classe em relação ao recurso de gênero do cliente. É possível corrigir esses desbalanceamento aplicando técnicas como SMOTE para recriar o conjunto de dados de treinamento. Você também pode usar o SageMaker Data Wrangler e especificar uma das várias opções, inclusive o SMOTE, que estão disponíveis no serviço para balancear conjuntos de dados de treinamento. Para obter mais detalhes, consulte Data Wrangler Balance Data (Dados de balanceamento do Data Wrangler). Por questões de brevidade, não incluímos essa etapa neste tutorial.
Além do desvio dos dados, o SageMaker Clarify também pode analisar o modelo treinado e criar um relatório de explicabilidade do modelo com base na importância do recurso. O SageMaker Clarify usa valores SHAP para explicar a contribuição de cada recurso de entrada para a previsão final. Copie e cole o bloco de código a seguir para configurar e executar uma análise de explicabilidade de modelo. Esse bloco de código levará aproximadamente 14 minutos para ser concluído.
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 e cole o código a seguir para baixar o relatório de explicabilidade do SageMaker Clarify em PDF do Amazon S3 para o diretório local no SageMaker Studio.
# Copy explainability report and view
!aws s3 cp s3://{write_bucket}/{write_prefix}/clarify-output/explainability/report.pdf ./clarify_explainability_output.pdfO relatório contém gráficos de importância de recursos que mostram como os recursos de entrada contribuem para as previsões do modelo. Para o modelo treinado neste tutorial, aparentemente o recurso num-injuries tem o papel mais importante, seguido de perto pelo recurso customer_gender_male ao gerar previsões. Essas classificações de recursos fornecem informações importantes sobre o mecanismo de previsão e impulsionam o refinamento e o desenvolvimento do modelo com o uso justo e explicável de ML.
Também é possível visualizar os resultados da análise de desvio e explicabilidade no SageMaker Studio na opção SageMaker Resources (Recursos do SageMaker ) e Experiments and trials (Experimentos e testes) na lista suspensa. Escolha Unassigned trial components (Componentes de teste não atribuídos).
Selecione o relatório de explicabilidade chamado clarify-explainability-<datetimestamp>.
Na guia Explainability, você pode visualizar o gráfico de importância do recurso. Também é possível baixar o relatório escolhendo Export PDF report (Exportar relatório em PDF).
O relatório de explicabilidade gerado pelo SageMaker Clarify também fornece um arquivo chamado out.csv contendo valores de SHAP locais para amostras individuais. Copie e cole o bloco de código a seguir para usar este arquivo para visualizar a explicação (o impacto que cada recurso tem na previsão do modelo) em qualquer exemplo 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)
);Para o exemplo escolhido (primeira amostra no conjunto de teste), o valor total da solicitação, o sexo e o número de lesões contribuíram mais para a previsão.
Etapa 5: implantar o modelo em um endpoint de inferência em tempo real
Nesta etapa, você implantará o melhor modelo obtido do trabalho de ajuste de hiperparâmetros em um endpoint de inferência em tempo real e usará o endpoint para gerar previsões. Há vários métodos para implantar um modelo treinado, como o SDK do SageMaker, o AWS SDK Boto3 e o console do SageMaker. Para obter mais informações, consulte Deploy Models for Inference(Implantar modelos para inferência) na documentação do Amazon SageMaker. Neste exemplo, você implantará o modelo em um endpoint em tempo real usando o SDK do SageMaker.
Copie e cole o bloco de código a seguir para implantar o melhor 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}")O código usa o melhor nome de trabalho de treinamento para recuperar o modelo do Amazon S3. O XGBoost aceita dados de entrada nos formatos text/libsvm ou text/csv. Os conjuntos de dados de entrada usados neste tutorial estão no formato CSV. Portanto, a configuração de implantação inclui um CSVSerializer que converte entradas CSV em fluxos de bytes e um CSVDeserializer que converte a saída do modelo nativo em fluxos de bytes ao formato CSV para nosso consumo. Após a conclusão, o bloco de código retorna o nome do endpoint em que o modelo foi implantado. A implantação também retorna um SageMaker Predictor, que pode ser usado para invocar o endpoint para executar previsões, como demonstrado na próxima seção.
Você pode verificar o endpoint implantado na interface do SageMaker Studio clicando no ícone SageMaker Resources (Recursos do SageMaker ) e selecionando Endpoints na lista suspensa.
Também é possível inspecionar endpoints pelo console do SageMaker em Inference (Inferência), Endpoints.
Agora que o modelo foi implantado em um endpoint, é possível invocar chamando a API REST diretamente (não descrita neste tutorial), pelo AWS SDK, por uma interface gráfica no SageMaker Studio ou usando o SDK do SageMaker Python. Neste tutorial, você usará o SageMaker Predictor disponibilizado na etapa de implantação para obter previsões de modelo em tempo real em uma ou mais amostras de teste. Copie e cole o bloco de código a seguir para invocar o endpoint e enviar uma única amostra de dados de teste.
# 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]}")A saída da célula mostra o rótulo verdadeiro e a pontuação prevista conforme retornado pelo endpoint do modelo. Como a probabilidade prevista é muito baixa, o modelo rotulou corretamente a amostra de teste como not fraud (não fraude).
Etapa 6: limpar recursos
Para evitar cobranças não intencionais, é uma prática recomendada excluir recursos que você não está mais usando.
Para excluir o modelo e o endpoint, copie e cole o código a seguir no bloco de anotações.
# 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 excluir o bucket do S3, faça o seguinte:
- Abra o console do Amazon S3. Na barra de navegação, escolha Buckets, sagemaker-<your-Region>-<your-account-id>, e marque a caixa de seleção ao lado de fraud-detect-demo. Selecione Delete (Excluir).
- Na caixa de diálogo Delete objects (Excluir objetos), verifique se você selecionou o objeto correto para excluir e digite permanently delete (excluir permanentemente) na caixa de confirmação Permanently delete objects (Excluir objetos permanentemente).
- Quando esse passo for concluído e o bucket estiver vazio, você poderá excluir o bucket sagemaker-<your-Region>-<your-account-id> realizando o mesmo procedimento novamente.
O kernel Data Science usado para executar a imagem do bloco de anotações neste tutorial acumulará cobranças até você interromper o kernel ou executar as etapas a seguir para excluir as aplicações. Para obter mais informações, consulte Shut Down Resources (Desativar recursos) no Guia do desenvolvedor do Amazon SageMaker.
Para excluir as aplicações do SageMaker Studio, faça o seguinte: no console do SageMaker Studio, escolha studio-user e exclua todas as aplicações listadas em Apps (Aplicações) escolhendo Delete app (Excluir aplicação). Aguarde até o Status ser alterado para Deleted (Excluído).
Se você usou um domínio existente do SageMaker Studio na Etapa 1, ignore o restante da Etapa 6 e vá diretamente para a seção de conclusão.
Se você executou o modelo do CloudFormation na Etapa 1 para criar um novo domínio do SageMaker Studio, prossiga com as etapas a seguir para excluir o domínio, o usuário e os recursos criados pelo modelo do CloudFormation.
Para abrir o console do CloudFormation, insira CloudFormation na barra de pesquisa do Console da AWS e escolha CloudFormation nos resultados da pesquisa.
No painel do CloudFormation, escolha Stacks (Pilhas). Na lista suspensa de status, selecione Active (Ativo). Em Stack name (Nome da pilha), escolha CFN-SM-IM-Lambda-catalog para abrir a página de detalhes da pilha.
Na página de detalhes da pilha CFN-SM-IM-Lambda-catalog, escolha Delete (Excluir) para excluir a pilha junto com os recursos que ela criou na Etapa 1.
Conclusão
Parabéns! Você concluiu o tutorial Treinar um modelo de machine learning.
Neste tutorial, você usou o Amazon SageMaker Studio para treinar um modelo de classificação binária no modo de script. Utilizou a biblioteca XGBoost de código aberto com o contêiner XGBoost gerenciado pela AWS para treinar e ajustar o modelo usando trabalhos de ajuste de hiperparâmetros do SageMaker. Também analisou o desvio e a explicabilidade do modelo usando o SageMaker Clarify e usou os relatórios para avaliar o impacto do recurso em previsões individuais. Por fim, utilizou o SDK do SageMaker para implantar o modelo em um endpoint de inferência em tempo real e testou-o com uma carga útil de exemplo.
Continue sua jornada como cientista de dados com o Amazon SageMaker seguindo a seção de próximas etapas abaixo.
Criar um modelo de machine learning automaticamente
Implantar um modelo treinado
Encontre mais tutoriais práticos