Tutorial: modelar o desenvolvimento em uma estação de trabalho em nuvem

Saiba como desenvolver um script de treinamento com um notebook em uma estação de trabalho em nuvem do Azure Machine Learning. Este tutorial aborda as noções básicas de que você precisa para começar:

Pré-requisitos

Para usar o Azure Machine Learning, primeiro você precisará de um workspace. Se você não tiver um, conclua Criar recursos necessários para começar para criar um workspace e saber mais sobre como usá-lo.

Começar com a computação

A seção Computação em seu workspace permite que você crie recursos de computação. Uma instância de computação é uma estação de trabalho baseada em nuvem totalmente gerenciada pelo Azure Machine Learning. Esta série de tutoriais usa uma instância de computação. Você também pode usá-la para executar seu próprio código e desenvolver e testar modelos.

1. Entre no Estúdio do Azure Machine Learning.
2. Selecione o workspace, se ele ainda não estiver aberto.
3. À esquerda, selecione Computação.
4. Se você não tiver uma instância de computação, verá Nova no meio da tela. Selecione Nova e preencha o formulário. Você pode usar todos os padrões.
5. Se você tiver uma instância de computação, selecione-a na lista. Se ela for interrompida, selecione Iniciar.

Abrir o Visual Studio Code (VS Code)

Depois de ter uma instância de computação em execução, você poderá acessá-la de várias maneiras. Este tutorial mostra como usar a instância de computação do VS Code. O VS Code oferece um ambiente de desenvolvimento integrado (IDE) completo com o poder dos recursos do Azure Machine Learning.

Na lista de instâncias de computação, selecione o link VS Code (Web) ou VS Code (Desktop) para a instância de computação que você deseja usar. Se você escolher VS Code (Área de Trabalho), você poderá ver um pop-up perguntando se deseja abrir o aplicativo.

Esta instância do VS Code é anexada à instância de computação e ao sistema de arquivos do workspace. Mesmo se você abri-lo em sua área de trabalho, os arquivos que você vê são arquivos em seu workspace.

Configurar um novo ambiente para prototipagem (opcional)

Para que o script seja executado, você precisa estar trabalhando em um ambiente configurado com as dependências e bibliotecas que o código espera. Esta seção ajuda você a criar um ambiente adaptado ao seu código. Para criar o novo kernel do Jupyter ao qual seu notebook se conecta, você usará um arquivo YAML que define as dependências.

• Carregar um arquivo.

  Os arquivos carregados são armazenados em um compartilhamento de arquivos do Azure e esses arquivos são montados em cada instância de computação e compartilhados dentro do workspace.

  1. Baixe este arquivo de ambiente conda, workstation_env.yml para seu computador usando o botão Baixar arquivo bruto no canto superior direito.

  2. Arraste o arquivo do computador para a janela do VS Code. O arquivo é carregado no workspace.

  3. Mova o arquivo em sua pasta de nome de usuário.

     

  4. Selecione esse arquivo para visualizar e veja quais dependências ele especifica. Você verá conteúdos como este:

  name: workstation_env
  # This file serves as an example - you can update packages or versions to fit your use case
  dependencies:
    - python=3.8
    - pip=21.2.4
    - scikit-learn=0.24.2
    - scipy=1.7.1
    - pandas>=1.1,<1.2
    - pip:
      - mlflow-skinny 
      - azureml-mlflow
      - psutil>=5.8,<5.9
      - ipykernel~=6.0
      - matplotlib
  

• Crie um kernel.

  Agora, use o terminal para criar um novo kernel Jupyter, com base no arquivo workstation_env.yml.

  1. Na barra de menus superior, selecione Terminal > Novo terminal.

     

  2. Exiba seus ambientes atuais do Conda. O ambiente ativo é marcado com um *.

     conda env list
     

  3. cd para a pasta em que você carregou o arquivo workstation_env.yml. Por exemplo, se você carregou na pasta do usuário:

     cd Users/myusername
     

  4. Certifique-se de que o arquivo workstation_env.yml esteja nessa pasta.

     ls
     

  5. Crie o ambiente com base no arquivo conda fornecido. Leva alguns minutos para criar esse ambiente.

     conda env create -f workstation_env.yml
     

  6. Ative o novo ambiente.

     conda activate workstation_env
     

     Observação

     Se você vir um CommandNotFoundError, siga as instruções para executar conda init bash, feche o terminal e abra um novo. Em seguida, repita o comando conda activate workstation_env.

  7. Valide se o ambiente correto está ativo, novamente procurando o ambiente marcado com um *.

     conda env list
     

  8. Crie um novo kernel do Jupyter com base em seu ambiente ativo.

     python -m ipykernel install --user --name workstation_env --display-name "Tutorial Workstation Env" 
     

  9. Feche a janela do terminal.

Agora você tem um novo kernel. Em seguida, você abrirá um notebook e usará esse kernel.

Criar um notebook

1. Na barra de menus superior, selecione Arquivo > Novo arquivo.
2. Nomeie o seu novo arquivo develop-tutorial.ipynb (ou insira o nome que desejar). Use a extensão .ipynb.

Definir o kernel

1. No canto superior direito, selecione Selecionar kernel.
2. Selecione a Instância de Computação do Machine Learning do Azure (computeinstance-name).
3. Selecione o kernel que você criou, Tutorial Estação de Tabalho Env. Se você não o vir, selecione a ferramenta Atualizar na parte superior direita.

Desenvolver um script de treinamento

Nesta seção, você desenvolverá um script de treinamento do Python que prevê pagamentos de cartão de crédito como padrão, usando os conjuntos de dados de teste e treinamento preparados do conjunto de dados da UCI.

Esse código usa sklearn para treinamento e MLflow para registrar as métricas em log.

1. Comece com o código que importa os pacotes e bibliotecas que você usará no script de treinamento.

   import os
   import argparse
   import pandas as pd
   import mlflow
   import mlflow.sklearn
   from sklearn.ensemble import GradientBoostingClassifier
   from sklearn.metrics import classification_report
   from sklearn.model_selection import train_test_split

2. Em seguida, carregue e processe os dados para este experimento. Neste tutorial, você irá ler os dados de um arquivo na Internet.

   # load the data
   credit_df = pd.read_csv(
       "https://azuremlexamples.blob.core.windows.net/datasets/credit_card/default_of_credit_card_clients.csv",
       header=1,
       index_col=0,
   )
   
   train_df, test_df = train_test_split(
       credit_df,
       test_size=0.25,
   )

3. Prepare os dados para treinamento:

   # Extracting the label column
   y_train = train_df.pop("default payment next month")
   
   # convert the dataframe values to array
   X_train = train_df.values
   
   # Extracting the label column
   y_test = test_df.pop("default payment next month")
   
   # convert the dataframe values to array
   X_test = test_df.values

4. Adicione o código para iniciar o registro automático com MLflow, para que você possa acompanhar as métricas e os resultados. Com a natureza iterativa do desenvolvimento de modelos, MLflow ajuda você a registrar os parâmetros e os resultados do modelo de log. Veja essas execuções para comparar e entender o desempenho do modelo. Os logs também fornecem contexto para quando você estiver pronto para passar da fase de desenvolvimento para a fase de treinamento de seus fluxos de trabalho no Azure Machine Learning.

   # set name for logging
   mlflow.set_experiment("Develop on cloud tutorial")
   # enable autologging with MLflow
   mlflow.sklearn.autolog()

5. Treinar um modelo.

   # Train Gradient Boosting Classifier
   print(f"Training with data of shape {X_train.shape}")
   
   mlflow.start_run()
   clf = GradientBoostingClassifier(n_estimators=100, learning_rate=0.1)
   clf.fit(X_train, y_train)
   
   y_pred = clf.predict(X_test)
   
   print(classification_report(y_test, y_pred))
   # Stop logging for this model
   mlflow.end_run()

   Observação

   Você pode ignorar os avisos de mlflow. Você ainda obterá todos os resultados necessários.

ITERAR

Agora que você tem resultados de modelo, talvez queira alterar algo e tentar novamente. Por exemplo, experimente uma técnica de classificador diferente:

# Train  AdaBoost Classifier
from sklearn.ensemble import AdaBoostClassifier

print(f"Training with data of shape {X_train.shape}")

mlflow.start_run()
ada = AdaBoostClassifier()

ada.fit(X_train, y_train)

y_pred = ada.predict(X_test)

print(classification_report(y_test, y_pred))
# Stop logging for this model
mlflow.end_run()

Examinar resultados

Agora que você tentou dois modelos diferentes, use os resultados rastreados por MLFfow para decidir qual modelo é melhor. Você pode fazer referência a métricas como precisão ou outros indicadores que são mais relevantes para seus cenários. Obtenha informações mais detalhadas sobre esses resultados examinando os trabalhos criados por MLflow.

1. Retorne ao workspace no Estúdio do Azure Machine Learning.

2. Na navegação à esquerda, selecione Trabalhos.

   

3. Selecione o link para o Tutorial Desenvolver na nuvem.

4. Há dois trabalhos diferentes mostrados, um para cada um dos modelos que você experimentou. Esses nomes são gerados automaticamente. Ao passar o mouse sobre um nome, use a ferramenta de lápis ao lado do nome se quiser renomeá-lo.

5. Selecione o link para o primeiro trabalho. O nome aparece na parte superior. Você também pode renomeá-lo aqui com a ferramenta de lápis.

6. A página mostra detalhes do trabalho, como propriedades, saídas, marcas e parâmetros. Em Marcas, você verá o estimator_name, que descreve o tipo de modelo.

7. Selecione a guia Métricas para exibir as métricas registradas pelo MLflow. (Espere que seus resultados sejam diferentes, pois você tem um conjunto de treinamento diferente.)

   

8. Selecione a guia Imagens para exibir as imagens geradas por MLflow.

   

9. Voltar e examine as métricas e imagens do outro modelo.

Executar um script do Python

Agora, crie um script Python do notebook para treinamento de modelo.

1. Na janela do VS Code, clique com o botão direito do mouse no nome do arquivo do notebook e selecione Importar Notebook para Script.

2. Use o menu Arquivo > Salvar para salvar este novo arquivo de script. Nomeie-o train.py.

3. Examine esse arquivo e exclua o código que você não deseja no script de treinamento. Por exemplo, mantenha o código para o modelo que deseja usar e exclua o código para o modelo que não deseja.

   • Certifique-se de manter o código que inicia o registro automático (mlflow.sklearn.autolog()).
   • Ao executar o script Python interativamente (como você está fazendo aqui), você pode manter a linha que define o nome do experimento (mlflow.set_experiment("Develop on cloud tutorial")). Ou até mesmo dê a ele um nome diferente para vê-lo como uma entrada diferente na seção Trabalhos . Mas quando você prepara o script para um trabalho de treinamento, essa linha não se aplica e deve ser omitida – a definição de trabalho inclui o nome do experimento.
   • Ao treinar um único modelo, as linhas para iniciar e encerrar uma execução (mlflow.start_run() e mlflow.end_run()) também não são necessárias (não terão efeito), mas podem ser mantidas se desejar.

4. Ao terminar de editar, salve o arquivo.

Agora você tem um script Python para usar no treinamento do modelo de sua preferência.

Executar o script do Python

Por enquanto, você está executando este código em sua instância de computação, que é o seu ambiente de desenvolvimento do Azure Machine Learning. Tutorial: treinar um modelo que mostra como executar um script de treinamento de maneira mais escalável em recursos de computação mais poderosos.

1. Selecione o ambiente criado anteriormente neste tutorial como a sua versão do Python (workstations_env). No canto inferior direito do notebook, você verá o nome do ambiente. Selecione-o e selecione o ambiente no meio da tela.

   

2. Agora, execute o script do Python. Use a ferramenta Executar arquivo do Python na parte superior direita.

   

Examinar os resultados do script

Volte para Trabalhos em seu workspace no Estúdio do Azure Machine Learning para ver os resultados do script de treinamento. Lembre-se de que os dados de treinamento mudam a cada divisão, de modo que os resultados também diferem entre as execuções.

Limpar os recursos

Se você planeja prosseguir agora para outros tutorial, vá diretamente para as Próximas etapas.

Parar a instância de computação

Se não for usá-la agora, pare a instância de computação:

1. No estúdio, na área de navegação à esquerda, selecione Computação.
2. Nas guias superiores, selecione Instâncias de computação
3. Selecione a instância de computação na lista.
4. Na barra de ferramentas superior, selecione Parar.

Excluir todos os recursos

Se você não pretende usar nenhum dos recursos criados, exclua-os para não gerar custos:

1. No portal do Azure, selecione Grupos de recursos no canto esquerdo.

2. Selecione o grupo de recursos que você criou por meio da lista.

3. Selecione Excluir grupo de recursos.

   

4. Insira o nome do grupo de recursos. Em seguida, selecione Excluir.

Próximas etapas

Saiba mais sobre:

• De artefatos a modelos no MLflow
• Usando o Git com o Azure Machine Learning
• Executar notebooks do Jupyter em seu workspace
• Trabalhar com um terminal de instância de computação em seu workspace
• Gerenciar sessões de notebook e de terminal

Este tutorial mostrou as primeiras etapas de criação de um modelo, criando protótipos no mesmo computador em que o código reside. Para seu treinamento de produção, saiba como usar esse script de treinamento em recursos de computação remota mais avançados: