O blog da AWS
Introdução ao SageMaker Studio
Por Sergio Beltrán, AI/ML Specialist SA, MCO
O Amazon SageMaker Studio, que nos referiremos a partir de agora como Studio, é o primeiro ambiente de desenvolvimento integrado (IDE) para Machine Learning (ML) que permite alterar a instância de computação facilmente. Esse artigo é um guia básico mostrando como configurar um domínio, clonar um repositório do Github, testar algumas das funcionalidades incluídas, particularmente de modelagem, implementação e monitoramento e, finalmente, como encerrar recursos (evitando cobranças desnecessárias).
Criando um domínio do Studio
Ao abrir a Console da AWS, clique em Serviços e abra o Amazon SageMaker. Uma vez dentro, verifique se você está em uma das regiões onde o Studio está disponível (veja a lista aqui).
Na seção Introdução, há duas opções: Início rápido ou Configuração Padrão. No início rápido, você pode escolher o nome de usuário e a função de execução, que controlará o acesso a outros serviços da AWS a partir de instâncias de notebook Studio. Na configuração padrão, você deve escolher o método de autenticação (AWS SSO ou AWS IAM), permissões e outros detalhes. Depois de ter escolhido tudo isso, você precisará aguardar alguns minutos para o provisionamento.
1. Clonagem de um repositório GitHub no Studio
Passo 1: Clique em Abrir o Studio para abrir a IDE
Passo 2: Abrir um terminal dentro do Studio (File > New >Terminal)
Passo 3: Para clonar o repositório, execute o seguinte comando no terminal.
git clone https://github.com/awslabs/amazon-sagemaker-examples.git
Passo 4: Use o gerenciador de arquivos do Studio para localizar e abrir o notebook dentro da pasta getting_started.
2. Notebook de previsão de Churn
O notebook utiliza dados de uma empresa de telecomunicações para automatizar a identificação de clientes insatisfeitos e, assim, ser capaz de oferecer incentivos antes que eles deixem de consumir os serviços/produtos da empresa (churn).
Este notebook abrange vários recursos importantes do Studio, como os Jobs de Treinamento do SageMaker (XGBoost no modo algoritmo e modo framework), Experimentos (Trials), debugging de modelos, implantação, como invocar Endpoint (inferência), monitoramento de modelos e exploração de gráficos.
Os dados usados neste tutorial estão no repositório e uma prévia seria:
3. Amazon SageMaker Experiements
Um experimento dentro do Amazon SageMaker Experiments é uma coleção de ensaios (trials), ou seja, um grupo de trabalhos (jobs) relacionados para resolver o mesmo problema. O Studio tem a capacidade de gerenciar vários trials, possibilitando uma experimentação com vários hiperparâmetros. Com os resultados desses experimentos, métricas relevantes podem ser apresentadas em gráficos para selecionar o melhor modelo.
Um ensaio (trial) é um conjunto de etapas envolvidas no mesmo trabalho (job). As etapas de treinamento geralmente incluem pré-processamento, treinamento do modelo, avaliação, etc. Um ensaio também é enriquecido com metadados de entrada (por exemplo, algoritmos escolhidos, hiperparâmetros, conjuntos de dados utilizados) e saídas (por exemplo, modelos e métricas).
O objetivo do SageMaker Experiments é tornar o mais simples possível a criação de experimentos, inserção dados e execução de análises em ensaios e experimentos. Para fazer isso, há um novo SDK para Python que contém uma API de log e análise.
Para executar trabalhos de treinamento no SageMaker ou no SageMaker Autopilot, tudo o que você precisa fazer é passar um parâmetro adicional para o estimador, definindo o nome do experimento ao qual este teste deve ser anexado. Todas as entradas e saídas serão gravadas automaticamente.
Depois de executar seus trabalhos de treinamento, o SDK de experimentos do SageMaker permite que você carregue os dados de experimentação em um dataframe do Pandas ou visualize-os dentro do Studio e, com isso, faça todos os tipos de análises. Você pode executar consultas complexas e exibir tabelas de classificação de modelos e gráficos de métricas em tempo real.
No treinamento deste exercício foram feitos 2 Trials:
Trial 1: XGBOOST Modo algoritmo
Para nosso primeiro teste, usaremos o algoritmo XGBoost integrado para treinar um modelo sem fornecer nenhum código adicional. Dessa forma, podemos usar o XGBoost para treinar e implementar um modelo como faríamos com outros algoritmos integrados do Amazon SageMaker.
trial = Trial.create(trial_name="algorithm-mode-trial-{}".format(strftime("%Y-%m-%d-%H-%M-%S", gmtime())),
experiment_name=customer_churn_experiment.experiment_name,
sagemaker_boto_client=boto3.client('sagemaker'))
xgb = sagemaker.estimator.Estimator(image_name=docker_image_name,
role=role,
hyperparameters=hyperparams,
train_instance_count=1,
train_instance_type='ml.m4.xlarge',
output_path='s3://{}/{}/output'.format(bucket, prefix),
base_job_name="demo-xgboost-customer-churn",
sagemaker_session=sess)
xgb.fit({'train': s3_input_train,
'validation': s3_input_validation},
experiment_config={
"ExperimentName": customer_churn_experiment.experiment_name,
"TrialName": trial.trial_name,
"TrialComponentDisplayName": "Training",
}
)
Criamos um novo objeto da classe Trial e associamos o teste ao experimento que criamos anteriormente. Para treinar o modelo, criamos um estimator e especificamos alguns parâmetros, como o tipo da instância de treinamento que gostaríamos de usar e quantas, e onde os artefatos do modelo treinado devem ser armazenados.
Nós também associaremos o trabalho de treinamento com o teste do experimento que acabamos de criar quando chamamos o método fit do estimador.
4. Amazon SageMaker Debugger
O Amazon SageMaker Studio Debugger permite que você obtenha visibilidade sobre o que acontece durante o treinamento do modelo. Permite registrar e analisar métricas relevantes durante o treinamento de modelos de Machine Learning e Deep Learning (DL), como pesos, gradientes e erros. Toda essa coleção de métricas é constantemente atualizada durante as fases de backpropagation e otimização dos modelos DL.
Especificar as regras do SageMaker Debugger
Para permitir a detecção automatizada de problemas comuns durante o treinamento, o Amazon SageMaker Debugger também permite anexar uma lista de regras para avaliar o trabalho de treinamento.
Algumas regras que se aplicam ao XGBoost são: AllZero, ClassImbalance, Confusion, LossNotDecreasing, Overfit, Overtraining, SimilarAcrossRuns, TensorVariance, UnchangedTensor, e TreeDepth.
Usamos as regras de LossNotDecreasing (que é ativada se o valor da função de perda não diminuir em nenhum momento do treinamento), Overtraining e Overfit. Para criar as regras:
debug_rules = [Rule.sagemaker(rule_configs.loss_not_decreasing()), Rule.sagemaker(rule_configs.overtraining()), Rule.sagemaker(rule_configs.overfit())
Trial 2 – XGBOOST modo framework
Para este teste, um modelo semelhante foi treinado, mas o XGBoost foi usado no modo framework. Se você já trabalhou com o XGBoost de código aberto, usar o XgBoost dessa forma será familiar para você. O uso do XGBoost como framework fornece mais flexibilidade do que usá-lo como um algoritmo integrado, pois permite cenários mais avançados, como incorporar scripts de pré-processamento, treinamento e pós-processamento. Especificamente, poderemos definir uma lista de regras que queremos que o Amazon SageMaker Debugger avalie no nosso treinamento.
entry_point_script = "xgboost_customer_churn.py"
trial = Trial.create(trial_name="framework-mode-trial-{}".format(strftime("%Y-%m-%d-%H-%M-%S", gmtime())),
experiment_name=customer_churn_experiment.experiment_name,
sagemaker_boto_client=boto3.client('sagemaker'))
framework_xgb = sagemaker.xgboost.XGBoost(image_name=docker_image_name,
entry_point=entry_point_script,
role=role,
framework_version="0.90-2",
py_version="py3",
hyperparameters=hyperparams,
train_instance_count=1,
train_instance_type='ml.m4.xlarge',
output_path='s3://{}/{}/output'.format(bucket, prefix),
base_job_name="demo-xgboost-customer-churn",
sagemaker_session=sess,
rules=debug_rules
)
framework_xgb.fit({'train': s3_input_train,
'validation': s3_input_validation},
experiment_config={
"ExperimentName": customer_churn_experiment.experiment_name,
"TrialName": trial.trial_name,
"TrialComponentDisplayName": "Training",
})
5. Hospedagem de modelos
O Amazon SageMaker fornece serviços de hospedagem de modelos para sua implementação como microsserviços. Conforme mostrado no diagrama abaixo, quando implementados modelos para resposta em tempo real, o Amazon SageMaker fornece um endpoint HTTPS em que seu modelo de ML fica disponível para receber requisições e retornar inferências.
xgb_predictor = xgb.deploy(initial_instance_count=1,
instance_type='ml.m4.xlarge',
endpoint_name=endpoint_name,
data_capture_config=DataCaptureConfig(enable_capture=True,
sampling_percentage=100,
destination_s3_uri='s3://{}/{}'.format(bucket, data_capture_prefix)
)
)
6. SageMaker Model Monitor
O Amazon SageMaker Model Monitor monitora automaticamente modelos ML em produção e relata problemas com a qualidade dos dados. Isso pode acontecer porque os modelos em produção realizam inferências sobre dados da vida real que não são cuidadosamente selecionados como a maioria dos conjuntos de dados de treinamento. Se a natureza estatística dos dados que seu modelo recebe durante a produção se afastar da natureza dos dados do baseline com os quais ele foi treinado, o modelo começa a perder a precisão em suas predições. Isso é conhecido como concept drift.
Para habilitar o monitoramento do modelo, siga os passos abaixo:
Passo 1: Criar um baseline
Crie um baseline a partir do conjunto de dados que foi usado para treinar o modelo.
baseline_prefix = prefix + '/baselining'
baseline_data_prefix = baseline_prefix + '/data'
baseline_results_prefix = baseline_prefix + '/results'
baseline_data_uri = 's3://{}/{}'.format(bucket,baseline_data_prefix)
baseline_results_uri = 's3://{}/{}'.format(bucket, baseline_results_prefix)
print('Baseline data uri: {}'.format(baseline_data_uri))
print('Baseline results uri: {}'.format(baseline_results_uri))
baseline_data_path = S3Uploader.upload("data/training-dataset-with-header.csv", baseline_data_uri)
Paso 2: Agendar um trabalho de monitoramento
Crie um trabalho de monitoramento que especifique quais dados coletar, com que frequência coletá-los, como analisá-los e quais relatórios produzir.
my_default_monitor = DefaultModelMonitor(role=role, instance_count=1, instance_type='ml.m5.xlarge', volume_size_in_gb=20, max_runtime_in_seconds=3600, ) baseline_job = my_default_monitor.suggest_baseline(baseline_dataset=baseline_data_path, dataset_format=DatasetFormat.csv(header=True), output_s3_uri=baseline_results_uri, wait=True )
Passo 3: Interpretar os resultados
Inspecione os relatórios, que comparam os dados mais recentes com o baseline, e observe as violações relatadas e métricas e notificações do Amazon CloudWatch.
Limpeza e exclusão de recursos
Como uma boa prática, você pode usar o código a seguir para desprovisionar memória, excluir endpoints e outros recursos criados:
try:
sess.delete_monitoring_schedule(mon_schedule_name)
except:
pass
while True:
try:
print("Waiting for schedule to be deleted")
sess.describe_monitoring_schedule(mon_schedule_name)
sleep(15)
except:
print("Schedule deleted")
break
sess.delete_endpoint(xgb_predictor.endpoint)
def cleanup(experiment):
'''Clean up everything in the given experiment object'''
for trial_summary in experiment.list_trials():
trial = Trial.load(trial_name=trial_summary.trial_name)
for trial_comp_summary in trial.list_trial_components():
trial_step=TrialComponent.load(trial_component_name=trial_comp_summary.trial_component_name)
print('Starting to delete TrialComponent..' + trial_step.trial_component_name)
sm.disassociate_trial_component(TrialComponentName=trial_step.trial_component_name, TrialName=trial.trial_name)
trial_step.delete()
time.sleep(1)
trial.delete()
experiment.delete()
cleanup(customer_churn_experiment)
No primeiro passo, quando você cria um domínio do Amazon Sagemaker Studio usando autenticação com o AWS IAM, o Studio cria uma lista de usuários autorizados, definições de configuração e um sistema de arquivos do Amazon Elastic File System (Amazon EFS) que contém dados para todos os usuários, incluindo notebooks. Isso significa que temos que desligar todos os aplicativos primeiro para ser capaz de excluir um usuário e, repetir, excluindo todos os usuários para depois ser capaz de excluir o domínio e efetivamente desprovisionar o EFS.
Conclusão
O Amazon Sagemaker Studio é a primeira IDE projetada especificamente para ML e incorpora vários dos recursos do SageMaker. Ele também oferece funcionalidades com as quais desenvolvedores de software sem tanto conhecimento de ML podem desenvolver modelos e incluí-los em suas arquiteturas para assim melhorar seus produtos.
Este artigo foi traduzido do Blog da AWS em Espanhol.
Sobre o autor
Sergio Beltrán é um arquiteto de soluções da AWS especialista AI/ML na AWS. Em sua função, ele apoia os clientes a encontrar a melhor solução e arquitetura para suas necessidades e aproveitar os serviços de AI/ML para gerar inovação e melhorar a produtividade. Antes da AWS, ele trabalhou como cientista de dados e gerente de desenvolvimento de negócios no setor de telecomunicações.
Sobre o revisor
Marcelo Cunha é um arquiteto de soluções da AWS especialista em AI/ML. Em sua função, ele ajuda os clientes a criar soluções de ML para resolver os seus desafíos de negócio utilizando a plataforma AWS. De uma familia de médicos e profissionais da saúde, ele também tem interesse em aplicações de ML nesse setor.