Treinar um modelo de machine learning
TUTORIAL
Visão geral
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 mínimo para 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
27 de março de 2023
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 caderno do SageMaker Studio, que requer um domínio do SageMaker Studio.
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 a 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.
A pilha pressupõe que você já tenha uma VPC pública configurada em sua conta. Se você não tiver uma VPC pública, consulte VPC com uma única sub-rede pública para aprender a criar uma VPC pública.
Selecione Estou ciente de que o AWS CloudFormation pode criar recursos do IAM e escolha Criar pilha.
Etapa 2: configurar um caderno do SageMaker Studio
Nesta etapa, você iniciará um novo caderno 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, incluindo o Amazon Simple Storage Service (Amazon S3).
2.1 Insira SageMaker Studio na barra de pesquisa do console e escolha SageMaker Studio.
2.2 Escolha Leste dos EUA (Norte da Virgínia) na lista suspensa Região no canto superior direito do console do SageMaker. Para iniciar a aplicação, selecione Studio no painel de navegação esquerdo. Selecione studio-user como perfil de usuário e escolha o botão Abrir Studio.
2.3 A tela de criação da aplicação no SageMaker Studio será exibida. A aplicação levará alguns minutos para carregar.
2.4 Abra a interface do SageMaker Studio. Na barra de navegação, escolha Arquivo, Novo, Caderno.
2.5 Na caixa de diálogo Configurar ambiente de caderno, em Imagem, selecione Ciência de dados 3. O kernel do Python 3 será selecionado automaticamente. No tipo Instância, escolha ml.t3.medium. Escolha Selecionar.
2.6 O kernel no canto superior direito do caderno agora deverá exibir Python 3 (Data Science).
2.7 No caderno Jupyter, em uma nova célula de código, copie e cole o código a seguir e execute a célula. Isso garantirá que você esteja usando a versão atual do SageMaker.
%pip install sagemaker --upgrade --quiet 2.8 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 caderno 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.52.9 També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 caderno 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"2.10 Observe que o nome do bucket de gravação é derivado do objeto de sessão do SageMaker. O nome de seu bucket padrão é sagemaker-<sua-Região>-<id-sua-conta>. 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. Observe que 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.
2.11 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âncias 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 iniciar trabalhos de ajuste de hiperparâmetros em escala. Para treinar o modelo, use a coluna fraude como coluna de destino.
3.1 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 completa das variáveis de ambiente do SageMaker, consulte Variáveis de ambiente.
3.2 Depois de preparar o script de treinamento, você poderá 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
)3.3 Você pode especificar os parâmetros de configuração estáticos 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. A versão do XGBoost que corresponde à anteriormente instalada é escolhida.
3.4 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)
}3.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)3.6 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()3.7 Os trabalhos de ajuste iniciados são exibidos no console do SageMaker em Trabalhos de ajuste de hiperparâmetros (observe que os nomes dos trabalhos de ajuste, conforme mostrados nas imagens anexas, não corresponderão ao que você vê por causa dos diferentes carimbos de data/hora).
3.8 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_tuner3.9 É possível inspecionar a combinação de hiperparâmetros que teve a melhor performance.
Etapa 4: verificar se há desvios e explicar 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
4.1 Antes que o SageMaker Clarify possa executar a detecção de desvio de modelo, ele necessitará de um modelo do SageMaker que o SageMaker Clarify implantará em um endpoint efêmero como parte das análises. O endpoint será então excluído quando as análises do SageMaker Clarify forem 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.")4.2 Para executar a detecção de desvio, o SageMaker Clarify espera que várias configurações de componentes sejam definidas. Mais detalhes estão disponíveis no 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],
)4.3 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 SageMaker SDK, você pode especificar em quais grupos deseja verificar o desvio e quais métricas de desvio devem ser consideradas. 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.name4.4 As 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 formato 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.pdf4.5 No 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 desbalanceamentos 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.
4.6 Além do desvio de 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
)4.7 Copie e cole o código a seguir para baixar o relatório de explicabilidade do SageMaker Clarify em formato 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.pdf4.8. O 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 customer_gender_male tem o papel mais importante, seguido de perto pelo recurso num-injuries 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.
4.9 Os resultados da análise de desvio e explicabilidade também podem ser visualizados no SageMaker Studio na seção Início e Experimentos do SageMaker.
4.10 Escolha Corridas não atribuídas. Selecione o relatório de explicabilidade chamado clarify-explainability-<carimbodatahora>.
4.11 Na guia Explicabilidade, você pode visualizar o gráfico de importância do recurso. Também é possível baixar o relatório escolhendo Exportar relatório em PDF.
4.12 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) para 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)
);4.13 Para o exemplo escolhido (primeira amostra no conjunto de teste), o valor da solicitação do veículo, o sexo, incidentes por dia, 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 SageMaker SDK.
5.1 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}")5.2 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.
5.3 Você pode conferir o endpoint implantado na interface do SageMaker Studio selecionando o ícone Início do SageMaker e selecionando Implantações e, em seguida, Endpoints.
5.4 Também é possível inspecionar endpoints pelo console do SageMaker em Inferência, Endpoints.
5.5 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 SageMaker Python SDK. 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]}")5.6 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.
Etapa 6: limpar recursos
Recomenda-se excluir recursos que você não está mais usando.
6.1 Para excluir o modelo e o endpoint, copie e cole o código a seguir no caderno.
# 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 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-<sua-Região>-<id-sua-conta> realizando o mesmo procedimento novamente.
Para excluir as aplicações do SageMaker Studio, faça o seguinte: no console do SageMaker, escolha Domínios e, em seguida, StudioDomain. Na lista Perfis de usuário, selecione studio-user, exclua todas as aplicações listadas em Aplicações escolhendo Excluir aplicação. Para excluir o JupyterServer, escolha Ação e Excluir. Aguarde até o Status ser alterado para Excluído.
6.4 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.
6.5 Para abrir o console do CloudFormation, insira CloudFormation na barra de pesquisa do console da AWS e escolha CloudFormation nos resultados da pesquisa.
6.6 Abra o console do CloudFromation. No painel do CloudFormation, escolha Pilhas. Na lista suspensa de status, selecione Ativo. Em Nome da pilha, escolha CFN-SM-IM-Lambda-catalog para abrir a página de detalhes da pilha.
6.7 Na página de detalhes da pilha CFN-SM-IM-Lambda-catalog, escolha Excluir para excluir a pilha junto com os recursos que ela criou na Etapa 1.
Conclusão
Criar um modelo de machine learning automaticamente
Implantar um modelo treinado
Encontre mais tutoriais práticos