Experimentos do Amazon SageMaker de próxima geração – organize, rastreie e compare seus treinamentos de machine learning em escala

Hoje, temos o prazer de anunciar atualizações em nosso Experimentos Amazon SageMaker capacidade de Amazon Sage Maker que permite organizar, rastrear, comparar e avaliar experimentos de aprendizado de máquina (ML) e versões de modelo de qualquer ambiente de desenvolvimento integrado (IDE) usando o SageMaker Python SDK ou boto3, incluindo Jupyter Notebooks locais.

O aprendizado de máquina (ML) é um processo iterativo. Ao resolver um novo caso de uso, cientistas de dados e engenheiros de ML iteram por meio de vários parâmetros para encontrar as melhores configurações de modelo (também conhecidas como hiperparâmetros) que podem ser usadas na produção para resolver o desafio de negócios identificado. Com o tempo, depois de experimentar vários modelos e hiperparâmetros, torna-se difícil para as equipes de ML gerenciar com eficiência as execuções do modelo para encontrar o ideal sem uma ferramenta para acompanhar os diferentes experimentos. Os sistemas de rastreamento de experimentos simplificam os processos para comparar diferentes iterações e ajudam a simplificar a colaboração e a comunicação em uma equipe, aumentando assim a produtividade e economizando tempo. Isso é obtido organizando e gerenciando experimentos de ML sem esforço para tirar conclusões deles, por exemplo, encontrar a execução do treinamento com a melhor precisão.

Para resolver esse desafio, o SageMaker oferece o SageMaker Experiments, um recurso totalmente integrado do SageMaker. Ele oferece a flexibilidade de registrar as métricas, parâmetros, arquivos, artefatos do modelo, plotar gráficos de diferentes métricas, capturar vários metadados, pesquisá-los e oferecer suporte à reprodutibilidade do modelo. Os cientistas de dados podem comparar rapidamente o desempenho e os hiperparâmetros para avaliação do modelo por meio de gráficos e tabelas visuais. Eles também podem usar o SageMaker Experiments para fazer o download dos gráficos criados e compartilhar a avaliação do modelo com as partes interessadas.

Com as novas atualizações do SageMaker Experiments, ele agora faz parte do SageMaker SDK, simplificando o trabalho do cientista de dados e eliminando a necessidade de instalar uma biblioteca extra para gerenciar várias execuções de modelo. Estamos introduzindo os seguintes novos conceitos principais:

• Experiência: uma coleção de execuções agrupadas. Um experimento inclui execuções para vários tipos que podem ser iniciados de qualquer lugar usando o SageMaker Python SDK.
• Execute: Cada etapa de execução de um processo de treinamento de modelo. Uma execução consiste em todas as entradas, parâmetros, configurações e resultados para uma iteração do treinamento do modelo. Parâmetros e métricas personalizados podem ser registrados usando o log_parameter, log_parameters e log_metric funções. A entrada e a saída personalizadas podem ser registradas usando o log_file função.

Os conceitos que são implementados como parte de um Run class são disponibilizados a partir de qualquer IDE em que o SageMaker Python SDK esteja instalado. Para treinamento, processamento e

Transform Jobs, o SageMaker Experiment Run é passado automaticamente para o trabalho se o trabalho for invocado em um contexto de execução. Você pode recuperar o objeto de execução usando load_run() do seu trabalho. Por fim, com a integração das novas funcionalidades, os cientistas de dados também podem registrar automaticamente uma matriz de confusão, gráficos de precisão e recuperação e uma curva ROC para casos de uso de classificação usando o run.log_confusion_matrix, run.log_precision_recall e run.log_roc_curve funções, respectivamente.

Nesta postagem de blog, forneceremos exemplos de como usar as novas funcionalidades do SageMaker Experiments em um notebook Jupyter por meio do SageMaker SDK. Vamos demonstrar esses recursos usando um PyTorch exemplo para treinar um exemplo de classificação de dígitos manuscritos MNIST. O experimento será organizado da seguinte forma:

1. Criando execuções de experimentos e parâmetros de registro: primeiro criaremos um novo experimento, iniciaremos uma nova execução para este experimento e registraremos parâmetros para ele.
2. Métricas de desempenho do modelo de registro:Vamos registrar as métricas de desempenho do modelo e traçar gráficos de métricas.
3. Comparando execuções de modelo:Vamos comparar diferentes execuções de modelo de acordo com os hiperparâmetros do modelo. Discutiremos como comparar essas execuções e como usar o SageMaker Experiments para selecionar o melhor modelo.
4. Executando experimentos de trabalhos do SageMaker: também forneceremos um exemplo de como compartilhar automaticamente o contexto de seu experimento com um trabalho de processamento, treinamento ou transformação em lote do SageMaker. Isso permite que você recupere automaticamente seu contexto de execução com o load_run função dentro do seu trabalho.
5. Integrando relatórios do SageMaker Clarify: Vamos demonstrar como agora podemos integrar SageMaker Esclarecer viés e relatórios de explicabilidade para uma única exibição com seu relatório de modelo treinado.

Pré-requisitos

Para esta postagem no blog, usaremos Estúdio Amazon SageMaker para mostrar como registrar métricas de um bloco de anotações do Studio usando as funcionalidades atualizadas do SageMaker Experiments. Para executar os comandos apresentados em nosso exemplo, você precisa dos seguintes pré-requisitos:

• Domínio SageMaker Studio
• Perfil de usuário do SageMaker Studio com acesso total ao SageMaker
• Um notebook SageMaker Studio com pelo menos um ml.t3.medium tipo de instância

Se você não tiver um domínio SageMaker e um perfil de usuário disponível, poderá criar um usando este guia de configuração rápida.

Parâmetros de registro

Para este exercício, usaremos visão da tocha, um pacote PyTorch que fornece conjuntos de dados populares, arquiteturas de modelo e transformações de imagem comuns para visão computacional. O SageMaker Studio fornece um conjunto de Imagens do Docker para casos de uso comuns de ciência de dados disponibilizados no Amazon ECR. Para PyTorch, você tem a opção de selecionar imagens otimizadas para treinamento de CPU ou GPU. Para este exemplo, vamos selecionar a imagem PyTorch 1.12 Python 3.8 CPU Optimized e os votos de Python 3 núcleo. Os exemplos descritos abaixo se concentrarão nas funcionalidades do SageMaker Experiments e não são códigos completos.

Vamos baixar os dados com o torchvision empacotar e rastrear o número de amostras de dados para os conjuntos de dados de treinamento e teste como parâmetros com o SageMaker Experiments. Para este exemplo, vamos supor train_set e test_set como já baixou torchvision conjuntos de dados.

from sagemaker.session import Session
from sagemaker.experiments.run import Run
import os

# create an experiment and start a new run
experiment_name = "local-experiment-example"
run_name = "experiment-run"

with Run(experiment_name=experiment_name, sagemaker_session=Session(), run_name=run_name) as run:
    run.log_parameters({
        "num_train_samples": len(train_set.data),
        "num_test_samples": len(test_set.data)
    })
    for f in os.listdir(train_set.raw_folder):
        print("Logging", train_set.raw_folder+"/"+f)
        run.log_file(train_set.raw_folder+"/"+f, name=f, is_output=False)

Neste exemplo, usamos o run.log_parameters para registrar o número de amostras de dados de treinamento e teste e run.log_file para carregar os conjuntos de dados brutos no Amazon S3 e registrá-los como entradas para nosso experimento.

Como treinar um modelo e registrar as métricas do modelo

Agora que baixamos nosso conjunto de dados MNIST, vamos treinar um Modelo CNN para reconhecer os dígitos. Ao treinar o modelo, queremos carregar nossa execução de experimento existente, registrar novos parâmetros nele e acompanhar o desempenho do modelo registrando as métricas do modelo.

Nós podemos usar o load_run função para carregar nossa execução anterior e usá-la para registrar nosso treinamento de modelo

with load_run(experiment_name=experiment_name, run_name=run_name, sagemaker_session=Session()) as run:
    train_model(
        run=run,
        train_set=train_set,
        test_set=test_set,
        epochs=10,
        hidden_channels=5,
        optimizer="adam"
    )

Podemos então usar run.log_parameter e run.log_parameters para registrar um ou vários parâmetros de modelo em nossa execução.

# log the parameters of your model
run.log_parameter("device", "cpu")
run.log_parameters({
    "data_dir": data_dir,
    "optimizer": optimizer,
    "epochs": epochs,
    "hidden_channels": hidden_channels
})

E podemos usar run.log_metric para registrar métricas de desempenho em nosso experimento.

run.log_metric(name=metric_type+":loss", value=loss, step=epoch)
run.log_metric(name=metric_type+":accuracy", value=accuracy, step=epoch)

Para modelos de classificação, você também pode usar run.log_confusion_matrix, run.log_precision_recall e run.log_roc_curve, para plotar automaticamente a matriz de confusão, o gráfico de recuperação de precisão e a curva ROC do seu modelo. Como nosso modelo resolve um problema de classificação multiclasse, vamos registrar apenas a matriz de confusão para ele.

# log confusion matrix
with torch.no_grad():
    for data, target in test_loader:
        data, target = data.to(device), target.to(device)
        output = model(data)
        pred = output.max(1, keepdim=True)[1] 
        run.log_confusion_matrix(target, pred, "Confusion-Matrix-Test-Data")

Ao observar os detalhes da execução, agora podemos ver as métricas geradas, conforme mostrado na captura de tela abaixo:

A página de detalhes da execução fornece mais informações sobre as métricas.

E os novos parâmetros do modelo são rastreados na página de visão geral dos parâmetros.

Você também pode analisar o desempenho do seu modelo por classe usando a matriz de confusão plotada automaticamente, que também pode ser baixada e usada para diferentes relatórios. E você pode plotar gráficos extras para analisar o desempenho do seu modelo com base nas métricas registradas.

Comparando vários parâmetros de modelo

Como cientista de dados, você deseja encontrar o melhor modelo possível. Isso inclui treinar um modelo várias vezes com diferentes hiperparâmetros e comparar o desempenho do modelo com esses hiperparâmetros. Para fazer isso, o SageMaker Experiments nos permite criar várias execuções no mesmo experimento. Vamos explorar esse conceito treinando nosso modelo com diferentes num_hidden_channels e optimizers.

# define the list of parameters to train the model with
num_hidden_channel_param = [5, 10, 20]
optimizer_param = ["adam", "sgd"]
run_id = 0
# train the model using SageMaker Experiments to track the model parameters, 
# metrics and performance
sm_session = Session()
for i, num_hidden_channel in enumerate(num_hidden_channel_param):
    for k, optimizer in enumerate(optimizer_param):
        run_id += 1
        run_name = "experiment-run-"+str(run_id)
        print(run_name)
        print(f"Training model with: {num_hidden_channel} hidden channels and {optimizer} as optimizer")
        # Defining an experiment run for each model training run
        with Run(experiment_name=experiment_name, run_name=run_name, sagemaker_session=sm_session) as run:
            train_model(
                run=run, 
                train_set=train_set,
                test_set=test_set,
                epochs=10, 
                hidden_channels=num_hidden_channel,
                optimizer=optimizer
            )

Agora estamos criando seis novas execuções para nosso experimento. Cada um registrará os parâmetros, métricas e matriz de confusão do modelo. Podemos então comparar as execuções para selecionar o modelo de melhor desempenho para o problema. Ao analisar as corridas, podemos plotar os gráficos métricos para as diferentes corridas como um único gráfico, comparando o desempenho das corridas nas diferentes etapas (ou épocas) de treinamento.

Usando experimentos do SageMaker com treinamento, processamento e trabalhos de transformação em lote do SageMaker

No exemplo acima, usamos o SageMaker Experiments para registrar o desempenho do modelo de um notebook SageMaker Studio em que o modelo foi treinado localmente no notebook. Podemos fazer o mesmo para registrar o desempenho do modelo dos trabalhos de processamento, treinamento e transformação em lote do SageMaker. Com os novos recursos de transmissão automática de contexto, não precisamos compartilhar especificamente a configuração do experimento com o trabalho do SageMaker, pois ela será capturada automaticamente.

O exemplo abaixo se concentrará nas funcionalidades do SageMaker Experiments e não é um código completo.

from sagemaker.pytorch import PyTorch
from sagemaker.experiments.run import Run
from sagemaker.session import Session
from sagemaker import get_execution_role
role = get_execution_role()

# set new experiment configuration
exp_name = "training-job-experiment-example"
run_name = "experiment-run-example"

# Start training job with experiment setting
with Run(experiment_name=exp_name, run_name=run_name, sagemaker_session=Session()) as run:
    est = PyTorch(
        entry_point="",
        dependencies=[""],
        role=role,
        model_dir=False,
        framework_version="1.12",
        py_version="py38",
        instance_type='ml.c5.xlarge',
        instance_count=1,
            hyperparameters={
            "epochs": 10,
            "hidden_channels":5,
            "optimizer": "adam",
        },
        keep_alive_period_in_seconds=3600
    )
    
    est.fit()

Em nosso arquivo de script de modelo, podemos obter o contexto de execução usando load_run(). Nos trabalhos de treinamento e processamento do SageMaker, não precisamos fornecer a configuração do experimento para carregar a configuração. Para trabalhos de transformação em lote, precisamos fornecer experiment_name e run_name para carregar a configuração do experimento.

with load_run() as run:
    run.log_parameters({...})
    train_model(run, ...)

Além das informações que obtemos ao executar o SageMaker Experiments a partir de um script de notebook, a execução de um trabalho do SageMaker preencherá automaticamente os parâmetros e saídas do trabalho.

O novo SageMaker Experiments SDK também garante compatibilidade com versões anteriores usando os conceitos de testes e componentes de teste. Qualquer experimento acionado usando a versão anterior do SageMaker Experiments será disponibilizado automaticamente na nova interface do usuário para análise dos experimentos.

Integração do SageMaker Clarify e modelos de relatórios de treinamento

O SageMaker Clarify ajuda a melhorar nossos modelos de ML detectando viés potencial e ajudando обяснявам como esses modelos fazem previsões. O Clarify fornece contêineres pré-construídos que são executados como tarefas de processamento do SageMaker após o treinamento do modelo, usando informações sobre seus dados (configuração de dados), modelo (configuração do modelo) e as colunas de dados confidenciais que queremos analisar quanto a possível viés (viés configuração). Até agora, o SageMaker Experiments exibia nosso treinamento de modelo e os relatórios do Clarify como componentes de teste individuais que eram conectados por meio de um teste.

Com os novos experimentos do SageMaker, também podemos integrar os relatórios do SageMaker Clarify com nosso treinamento de modelo, tendo uma fonte de verdade que nos permite entender melhor nosso modelo. Para um relatório integrado, tudo o que precisamos fazer é ter o mesmo nome de execução para nossos trabalhos de treinamento e esclarecimento. O exemplo a seguir demonstra como podemos integrar os relatórios usando um modelo XGBoost para prever a renda de adultos nos Estados Unidos. O modelo usa o Conjunto de dados UCI Adulto. Para este exercício, assumimos que o modelo já foi treinado e que já calculamos os dados, o modelo e as configurações de viés.

with Run(
    experiment_name='clarify-experiment',
    run_name="joint-run",
    sagemaker_session=sagemaker_session,
) as run:
    xgb.fit({"train": train_input}, logs=False)
    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="all",
        post_training_methods="all",
    )
    clarify_processor.run_explainability(
        data_config=explainability_data_config,
        model_config=model_config,
        explainability_config=shap_config,
    )

Com essa configuração, obtemos uma exibição combinada que inclui as métricas do modelo, entradas e saídas conjuntas e os relatórios do Clarify para viés estatístico e explicabilidade do modelo.

Conclusão

Nesta postagem, exploramos a nova geração do SageMaker Experiments, uma parte integrada do SageMaker SDK. Demonstramos como registrar seus fluxos de trabalho de ML de qualquer lugar com a nova classe Run. Apresentamos a nova interface do usuário de experimentos que permite rastrear seus experimentos e plotar gráficos para uma única métrica de execução, bem como comparar várias execuções com o novo recurso de análise. Fornecemos exemplos de experimentos de registro de um bloco de anotações do SageMaker Studio e de um trabalho de treinamento do SageMaker Studio. Por fim, mostramos como integrar o treinamento de modelo e os relatórios do SageMaker Clarify em uma exibição unificada, permitindo que você entenda melhor seu modelo.

Incentivamos você a experimentar as novas funcionalidades de Experimentos e conectar-se com o Comunidade de aprendizado de máquina e IA se você tiver alguma dúvida ou feedback!

Sobre os autores

Tanque Maira Ladeira é especialista em Machine Learning da AWS. Com formação em ciência de dados, ela tem 9 anos de experiência na arquitetura e construção de aplicativos de ML com clientes de vários setores. Como líder técnica, ela ajuda os clientes a acelerar a obtenção de valor comercial por meio de tecnologias emergentes e soluções inovadoras. Em seu tempo livre, Maira gosta de viajar e passar o tempo com sua família em um lugar aconchegante.

Mani Khanuja é Especialista em Inteligência Artificial e Aprendizado de Máquina SA na Amazon Web Services (AWS). Ela ajuda os clientes que usam aprendizado de máquina a resolver seus desafios de negócios usando a AWS. Ela passa a maior parte do tempo se aprofundando e ensinando os clientes em projetos de IA/ML relacionados à visão computacional, processamento de linguagem natural, previsão, ML na borda e muito mais. Ela é apaixonada por ML no limite, por isso criou seu próprio laboratório com kit autônomo e linha de produção de protótipos, onde passa grande parte de seu tempo livre.

Dewen Qi é um engenheiro de desenvolvimento de software na AWS. Ela atualmente participa da criação de uma coleção de serviços e ferramentas de plataforma no AWS SageMaker para ajudar o cliente a tornar seus projetos de ML bem-sucedidos. Ela também é apaixonada por trazer o conceito de MLOps para um público mais amplo. Fora do trabalho, Dewen gosta de praticar violoncelo.

Abhishek Agarwal é gerente de produto sênior do Amazon SageMaker. Ele é apaixonado por trabalhar com clientes e tornar o aprendizado de máquina mais acessível. Em seu tempo livre, Abhishek gosta de pintar, andar de bicicleta e aprender sobre tecnologias inovadoras.

Dana Benson é um engenheiro de software que trabalha na equipe de experimentos, linhagem e pesquisa do Amazon SageMaker. Antes de ingressar na AWS, Dana passou um tempo habilitando a funcionalidade de casa inteligente no Alexa e pedidos móveis na Starbucks.