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

Este artigo descreve como desenvolver um script de treinamento usando um notebook em uma estação de trabalho de nuvem do Azure Machine Learning. O tutorial aborda as etapas básicas que você precisa para começar:

• Prepare e configure a estação de trabalho na nuvem. Sua estação de trabalho de nuvem é alimentada por uma instância de computação do Azure Machine Learning, que é pré-configurada com ambientes para dar suporte às suas necessidades de desenvolvimento de modelo.
• Use ambientes de desenvolvimento baseados em nuvem.
• Use o MLflow para acompanhar as métricas do modelo.

Pré-requisitos

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

Importante

Se o seu espaço de trabalho do Azure Machine Learning estiver configurado com uma rede virtual gerenciada, talvez você precise adicionar regras de saída para permitir o acesso aos repositórios públicos de pacotes do Python. Para obter mais informações, confira Cenário: Acessar pacotes públicos de aprendizado de máquina.

Criar ou iniciar computação

Você pode criar recursos de computação na seção Computação em seu workspace. 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 seu workspace, se ele ainda não estiver aberto.
3. No painel esquerdo, selecione Computação.
4. Se você não tiver uma instância de computação, verá Novo no meio da página. 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 descreve como usar a instância de computação do Visual Studio Code. O Visual Studio Code fornece um IDE (ambiente de desenvolvimento integrado) completo para criar instâncias de computação.

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 (Desktop), poderá ver uma mensagem perguntando se deseja abrir o aplicativo.

Essa instância do Visual Studio Code está anexada à sua instância de computação e ao sistema de arquivos da sua área de trabalho. 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 criação de protótipos

Para que o script seja executado, você precisa estar trabalhando em um ambiente configurado com as dependências e bibliotecas esperadas pelo código. Esta seção ajuda você a criar um ambiente adaptado ao seu código. Para criar o novo kernel jupyter ao qual seu notebook se conecta, você usa 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. Acesse azureml-examples/tutorials/get-started-notebooks/workstation_env.yml.

  2. Baixe o arquivo de ambiente do Conda workstation_env.yml no seu computador selecionando o botão de reticências (...) no canto superior direito da página e selecionando Baixar.

  3. Arraste o arquivo do computador para a janela do Visual Studio Code. O arquivo é carregado no workspace.

  4. Mova o arquivo para sua pasta de nome de usuário.

     

  5. Selecione o arquivo para visualizar. Examine as dependências que ele especifica. Você deve ver algo assim:

  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 baseado no arquivo workstation_env.yml .

  1. No menu na parte superior do Visual Studio Code, selecione Terminal > Novo Terminal.

  

  1. Exiba os seus ambientes Conda atuais. O ambiente ativo é marcado com um asterisco (*).

     conda env list
     

  2. Use cd para navegar até a pasta em que você carregou o arquivo workstation_env.yml . Por exemplo, se você carregou o arquivo para a pasta do usuário, use o seguinte comando:

     cd Users/myusername
     

  3. Verifique se workstation_env.yml está na pasta.

     ls
     

  4. Crie o ambiente com base no arquivo Conda fornecido. Leva alguns minutos para criar o ambiente.

     conda env create -f workstation_env.yml
     

  5. Ative o novo ambiente.

     conda activate workstation_env
     

     Observação

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

  6. Verifique se o ambiente correto está ativo, novamente procurando o ambiente marcado com um *.

     conda env list
     

  7. Crie um novo kernel Jupyter baseado no seu ambiente ativo.

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

  8. 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. No menu na parte superior do Visual Studio Code, selecione Arquivo > Novo Arquivo.
2. Nomeie seu novo arquivo develop-tutorial.ipynb (ou use outro nome). Certifique-se de usar a extensão .ipynb.

Definir o kernel

1. No canto superior direito do novo arquivo, 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 Workstation Env. Se você não vir o kernel, selecione o botão de atualizar acima da lista.

Desenvolver um script de treinamento

Nesta seção, você desenvolverá um script de treinamento em Python que prevê a inadimplência de pagamentos de cartão de crédito 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 métricas de 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 do 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 código para iniciar o registro automático com o MLflow para que você possa acompanhar as métricas e os resultados. Com a natureza iterativa do desenvolvimento de modelos, o MLflow ajuda você a registrar os parâmetros e os resultados do modelo. Consulte diferentes 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 do MLflow. Os resultados que você precisa ainda serão rastreados.

6. Selecione Executar Tudo acima do código.

ITERAR

Agora que você tem resultados de modelo, altere algo e execute o modelo novamente. Por exemplo, tente uma técnica de classificação 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()

Observação

Você pode ignorar os avisos do MLflow. Os resultados que você precisa ainda serão rastreados.

Selecione Executar Tudo para executar o modelo.

Examinar os resultados

Agora que você tentou dois modelos diferentes, use os resultados acompanhados pelo MLFfow para decidir qual modelo é melhor. Você pode referenciar métricas como precisão ou outros indicadores que mais importam para seus cenários. Você pode examinar esses resultados com mais detalhes examinando os trabalhos criados pelo MLflow.

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

2. No painel esquerdo, selecione Trabalhos.

   

3. Selecione Tutorial Desenvolver na Nuvem.

4. Há dois trabalhos mostrados, um para cada um dos modelos que você tentou. Os nomes são gerados automaticamente. Se você quiser renomear o trabalho, passe o mouse sobre o nome e selecione o botão lápis ao lado dele.

5. Selecione o link para o primeiro trabalho. O nome aparece na parte superior da página. Você também pode renomeá-lo aqui usando o botão 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. (Seus resultados serão diferentes porque você tem um conjunto de treinamento diferente.)

   

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

   

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

Executar um script do Python

Agora você criará um script Python do bloco de anotações para treinamento de modelo.

1. No Visual Studio Code, clique com o botão direito do mouse no nome do arquivo do notebook e selecione Importar Bloco de Anotações para Script.

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

3. Examine o 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 você deseja usar e exclua o código para o modelo que você não deseja usar.

   • 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 você pode dar 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 do trabalho inclui o nome do experimento.
   • Quando você treina um único modelo, as linhas para iniciar e encerrar uma execução (mlflow.start_run() e mlflow.end_run()) não são necessárias (elas não têm efeito), mas você pode deixá-las dentro.

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 mostra como executar um script de treinamento de maneira mais escaloná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 bloco de anotações, você verá o nome do ambiente. Selecione-o e depois selecione o ambiente no topo do Visual Studio Code.

   

2. Execute o script Python selecionando o botão Executar Tudo acima do código.

   

Observação

Você pode ignorar os avisos do MLflow. Você ainda obterá todas as métricas e imagens do registro automático.

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 continuar em outros tutoriais, vá 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, no painel esquerdo, selecione Computação.
2. Na parte superior da página, selecione Instâncias de Computação.
3. Na lista, selecione a instância de computação.
4. Na parte superior da página, selecione Parar.

Excluir todos os recursos

Importante

Os recursos que você criou podem ser usados como pré-requisitos em outros tutoriais e artigos de instruções do Azure Machine Learning.

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

1. No portal do Azure, na caixa de pesquisa, insira Grupos de recursos e selecione-o nos resultados.

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

3. Na página Visão geral, selecione Excluir grupo de recursos.

   

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

Próximas etapas

Consulte estes recursos para saber mais:

• Artefatos e 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 mostra as primeiras etapas da 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:

Treinar um modelo