Esta versão legada do AI Platform Training está descontinuada e não estará mais disponível no Google Cloud após 31 de janeiro de 2025. Migre seus recursos para o treinamento personalizado da Vertex AI a fim de acessar novos recursos de machine learning que estão indisponíveis no AI Platform.

Treinar um modelo de ML com scikit-learn e XGBoost

O serviço de treinamento do AI Platform gerencia recursos de computação na nuvem para treinar modelos. Nesta página, você verá o processo de treinamento de um modelo com scikit-learn e XGBoost usando o AI Platform Training.

Visão geral

Neste tutorial, você treinará um modelo simples para prever as espécies de flores usando o conjunto de dados Iris. Primeiro, você ajustará o código de treinamento de modelo para fazer o download de dados do Cloud Storage e fazer o upload do arquivo de modelo salvo para o Cloud Storage. Depois, você criará um pacote de aplicativo de treinamento que será usado para executar o treinamento no AI Platform Training.

Como treinar seu modelo no AI Platform Training

Depois de concluir o processo de configuração inicial, treine seu modelo no AI Platform Training em três etapas:

Crie seu módulo de treinamento em Python
- Adicionar o código para fazer o download dos dados do Cloud Storage para que o AI Platform Training possa usá-los
- Adicione código para exportar e salvar o modelo no Cloud Storage depois que o AI Platform Training terminar de treinar o modelo.
Prepare um pacote de aplicativo de treinamento.
Enviar o job de treinamento

O processo de configuração inicial inclui a criação de um projeto do Google Cloud Platform, a ativação de faturamento e APIs, a configuração de um bucket do Cloud Storage para usar com o AI Platform Training e a instalação local do scikit-learn ou do XGBoost. Se você já concluiu todas as tarefas de configuração e instalação, vá direto para Como criar o código do treinamento de modelo.

Antes de começar

Conclua as etapas a seguir para configurar uma conta do GCP, ativar a API AI Platform Training e instalar e ativar o SDK do Cloud.

Configurar o projeto GCP

Faça login na sua conta do Google Cloud. Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.

No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

Acessar o seletor de projetos

Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

Ative as APIs AI Platform Training & Prediction and Compute Engine.

Ative as APIs

Instale a CLI do Google Cloud.

Para inicializar a CLI gcloud, execute o seguinte comando:

gcloud init

No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

Acessar o seletor de projetos

Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

Ative as APIs AI Platform Training & Prediction and Compute Engine.

Ative as APIs

Instale a CLI do Google Cloud.

Para inicializar a CLI gcloud, execute o seguinte comando:

gcloud init

Configurar o ambiente

Escolha uma das opções abaixo para configurar o ambiente localmente no macOS ou em um ambiente remoto no Cloud Shell.

Para usuários do macOS, recomendamos a configuração do ambiente usando a guia MACOS abaixo. O Cloud Shell, mostrado na guia CLOUD SHELL, está disponível para macOS, Linux e Windows. Com ele, você testa rapidamente o AI Platform Training. No entanto, ele não é adequado para trabalhos de desenvolvimento contínuos.

macOS

Verificar a instalação do Python
Verifique se o Python (em inglês) está instalado e, se necessário, instale-o.
```
python -V
```
Verificar a pip instalação do
pip é o gerenciador de pacote do Python, incluído nas versões atuais do Python. Execute pip --version para verificar se o pip já está instalado. Caso contrário, veja como instalar o pip (em inglês).

É possível fazer upgrade do pip usando o comando a seguir:
```
pip install -U pip
```
Consulte a documentação do pip para mais detalhes.
Instalar virtualenv
virtualenv é uma ferramenta para criar ambientes Python isolados. Execute virtualenv --version para verificar se a virtualenv já está instalada. Caso contrário, instale virtualenv (em inglês):
```
pip install --user --upgrade virtualenv
```
Para criar um ambiente de desenvolvimento isolado para este guia, crie um novo ambiente virtual em virtualenv. Por exemplo, com o comando a seguir, você ativa um ambiente chamado aip-env:
```
virtualenv aip-env
source aip-env/bin/activate
```
Neste tutorial, execute o restante dos comandos no ambiente virtual.
Veja mais informações sobre o uso da virtualenv (em inglês). Para sair da virtualenv, execute deactivate.

Cloud Shell

Abra o console do Google Cloud.

Console do Google Cloud
Clique no botão Ativar o Cloud Shell na parte superior da janela do console.

Uma sessão do Cloud Shell é aberta em um novo frame na parte inferior do console e um prompt de linha de comando é exibido. A inicialização da sessão do shell pode levar alguns segundos.

A sessão do Cloud Shell está pronta para ser usada.
Configure a ferramenta de linha de comando gcloud para usar o projeto selecionado.
```
gcloud config set project [selected-project-id]
```
em que [selected-project-id] é o ID do projeto. Retire os colchetes incluídos.

Instalar frameworks

macOS

No ambiente virtual, execute o comando a seguir para instalar as versões do scikit-learn, do XGBoost e do pandas que foram usadas na versão 2.11 do ambiente de execução do AI Platform Training:

(aip-env)$ pip install scikit-learn==1.0.2 xgboost==1.6.2 pandas==1.3.5

Ao fornecer os números de versão no comando anterior, você garante que as dependências em seu ambiente virtual correspondam às dependências na versão do ambiente de execução. Isso ajuda a evitar comportamentos inesperados quando o código é executado no AI Platform Training.

Para mais detalhes, opções de instalação e solução de problemas, consulte as instruções de instalação de cada framework:

Cloud Shell

Execute o seguinte comando para instalar o scikit-learn, o XGBoost e o pandas:

pip install --user scikit-learn xgboost pandas

Para mais detalhes, opções de instalação e informações sobre solução de problemas, consulte as instruções de instalação de cada framework:

Configurar o bucket do Cloud Storage

Você precisará de um bucket do Cloud Storage para armazenar o código de treinamento e as dependências. Para este tutorial, é mais fácil usar um bucket dedicado do Cloud Storage no mesmo projeto que você está utilizando no AI Platform Training.

Se você estiver usando um bucket em outro projeto, precisará garantir que sua conta de serviço do AI Platform Training acesse seu código de treinamento e dependências no Cloud Storage. Sem as permissões apropriadas, o job de treinamento falhará. Saiba como conceder permissões para armazenamento.

Use ou configure um bucket na mesma região que está sendo usada para executar os jobs de treinamento. Veja as regiões disponíveis para os serviços do AI Platform Training.

Nesta seção, você aprende a criar um novo bucket. É possível usar um bucket atual, mas ele precisa estar na mesma região em que você planeja executar os jobs do AI Platform. Além disso, se ele não fizer parte do projeto que você está usando para executar o AI Platform Training, conceda acesso explícito às contas de serviço do AI Platform Training.

Especifique um nome para o novo bucket. Ele precisa ser único em todos os buckets no Cloud Storage.
```
BUCKET_NAME="YOUR_BUCKET_NAME"
```
Por exemplo, use o nome do projeto com -aiplatform anexado:
```
PROJECT_ID=$(gcloud config list project --format "value(core.project)")
BUCKET_NAME=${PROJECT_ID}-aiplatform
```
Verifique o nome do bucket que você criou.
```
echo $BUCKET_NAME
```
Selecione a região do bucket e defina a variável de ambiente REGION.

Use a mesma região em que você planeja executar jobs do AI Platform Training. Veja as regiões disponíveis para os serviços do AI Platform Training.

Por exemplo, o código a seguir cria REGION e a define como us-central1:
```
REGION=us-central1
```
Crie o novo bucket:
```
gsutil mb -l $REGION gs://$BUCKET_NAME
```

Crie seu módulo de treinamento em Python

Crie um arquivo iris_training.py, que contém o código para treinar seu modelo. Nesta seção, explicamos a função de cada parte do código de treinamento:

Configurar e fazer importações
Fazer o download de dados do Cloud Storage
Carregar dados no pandas
Treinar e salvar o modelo
Fazer upload do arquivo de modelo salvo para o Cloud Storage

Para sua conveniência, o código completo de iris_training.py está hospedado no GitHub para que você possa usá-lo neste tutorial:

Configuração

Importe as bibliotecas do Python a seguir para o scikit-learn ou o XGBoost. Defina uma variável para o nome do seu bucket do Cloud Storage.

scikit-learn

import datetime
import os
import subprocess
import sys
import pandas as pd
from sklearn import svm
from sklearn.externals import joblib

# Fill in your Cloud Storage bucket name
BUCKET_NAME = '<YOUR_BUCKET_NAME>'

XGBoost

import datetime
import os
import subprocess
import sys
import pandas as pd
import xgboost as xgb

# Fill in your Cloud Storage bucket name
BUCKET_NAME = '<YOUR_BUCKET_NAME>'

Fazer o download de dados do Cloud Storage

Durante o processo de desenvolvimento típico, você faz o upload de seus próprios dados para o Cloud Storage para que o AI Platform Training possa acessá-los. Os dados deste tutorial estão hospedados em um bucket público do Cloud Storage: gs://cloud-samples-data/ai-platform/iris/

O código a seguir faz o download dos dados usando o gsutil e, em seguida, os dados são direcionados do gsutil para stdout:

scikit-learn

iris_data_filename = 'iris_data.csv'
iris_target_filename = 'iris_target.csv'
data_dir = 'gs://cloud-samples-data/ml-engine/iris'

# gsutil outputs everything to stderr so we need to divert it to stdout.
subprocess.check_call(['gsutil', 'cp', os.path.join(data_dir,
                                                    iris_data_filename),
                       iris_data_filename], stderr=sys.stdout)
subprocess.check_call(['gsutil', 'cp', os.path.join(data_dir,
                                                    iris_target_filename),
                       iris_target_filename], stderr=sys.stdout)

XGBoost

iris_data_filename = 'iris_data.csv'
iris_target_filename = 'iris_target.csv'
data_dir = 'gs://cloud-samples-data/ai-platform/iris'

# gsutil outputs everything to stderr so we need to divert it to stdout.
subprocess.check_call(['gsutil', 'cp', os.path.join(data_dir,
                                                    iris_data_filename),
                       iris_data_filename], stderr=sys.stdout)
subprocess.check_call(['gsutil', 'cp', os.path.join(data_dir,
                                                    iris_target_filename),
                       iris_target_filename], stderr=sys.stdout)

Carregar dados no pandas

Use o pandas para carregar seus dados em matrizes NumPy para treinamento com scikit-learn ou XGBoost.

scikit-learn

# Load data into pandas, then use `.values` to get NumPy arrays
iris_data = pd.read_csv(iris_data_filename).values
iris_target = pd.read_csv(iris_target_filename).values

# Convert one-column 2D array into 1D array for use with scikit-learn
iris_target = iris_target.reshape((iris_target.size,))

XGBoost

# Load data into pandas, then use `.values` to get NumPy arrays
iris_data = pd.read_csv(iris_data_filename).values
iris_target = pd.read_csv(iris_target_filename).values

# Convert one-column 2D array into 1D array for use with XGBoost
iris_target = iris_target.reshape((iris_target.size,))

Treinar e salvar um modelo

Crie um módulo de treinamento para ser executado pelo AI Platform Training. Neste exemplo, o módulo treina um modelo com os dados de treinamento do Iris (iris_data e iris_target) e o salva como um arquivo exportado. Se você quiser usar o AI Platform Prediction para ter previsões on-line após o treinamento, nomeie o arquivo de modelo de acordo com a biblioteca usada para exportá-lo. Saiba mais sobre os requisitos de nomenclatura do arquivo de modelo.

scikit-learn

Siga as instruções do exemplo de persistência de modelo do scikit-learn para treinar e exportar um modelo como mostrado abaixo:

# Train the model
classifier = svm.SVC(gamma='auto', verbose=True)
classifier.fit(iris_data, iris_target)

# Export the classifier to a file
model_filename = 'model.joblib'
joblib.dump(classifier, model_filename)

Para exportar o modelo, você também tem a opção de usar a biblioteca pickle da seguinte maneira:

import pickle
with open('model.pkl', 'wb') as model_file:
  pickle.dump(classifier, model_file)

XGBoost

Você pode exportar o modelo usando o método "save_model" do objeto Booster.

# Load data into DMatrix object
dtrain = xgb.DMatrix(iris_data, label=iris_target)

# Train XGBoost model
bst = xgb.train({}, dtrain, 20)

# Export the classifier to a file
model_filename = 'model.bst'
bst.save_model(model_filename)

Para exportar o modelo, você também tem a opção de usar a biblioteca pickle da seguinte maneira:

import pickle
with open('model.pkl', 'wb') as model_file:
  pickle.dump(bst, model_file)

Requisitos de nomenclatura do arquivo de modelo

Para previsão on-line, o arquivo de modelo salvo enviado ao Cloud Storage precisa ser nomeado como: model.pkl, model.joblib, ou model.bst, dependendo da biblioteca que você usou. Essa restrição garante que o AI Platform Prediction use o mesmo padrão para reconstruir o modelo na importação e na exportação.

Se você criar uma rotina de predição personalizada (Beta), esse modelo não se aplicará.

scikit-learn

Biblioteca usada para exportar o modelo	Nome correto do modelo
`pickle`	`model.pkl`
`sklearn.externals.joblib`	`model.joblib`

XGBoost

Biblioteca usada para exportar o modelo	Nome correto do modelo
`pickle`	`model.pkl`
`joblib`	`model.joblib`
`xgboost.Booster`	`model.bst`

Para iterações futuras do modelo, organize seu bucket do Cloud Storage para que cada modelo novo tenha um diretório dedicado.

Fazer upload do modelo salvo para o Cloud Storage

Se você usa um bucket do Cloud Storage fora do projeto do Google Cloud que está usando para executar o AI Platform Training, verifique se o AI Platform Training tem acesso ao seu bucket.

scikit-learn

# Upload the saved model file to Cloud Storage
gcs_model_path = os.path.join('gs://', BUCKET_NAME,
    datetime.datetime.now().strftime('iris_%Y%m%d_%H%M%S'), model_filename)
subprocess.check_call(['gsutil', 'cp', model_filename, gcs_model_path],
    stderr=sys.stdout)

XGBoost

# Upload the saved model file to Cloud Storage
gcs_model_path = os.path.join('gs://', BUCKET_NAME,
    datetime.datetime.now().strftime('iris_%Y%m%d_%H%M%S'), model_filename)
subprocess.check_call(['gsutil', 'cp', model_filename, gcs_model_path],
    stderr=sys.stdout)

Criar pacote de aplicativo de treinamento

Com o iris_training.py criado a partir dos snippets acima, crie um pacote de aplicativo de treinamento que inclua o iris_training.py como seu módulo principal.

A maneira mais fácil e recomendada de criar um pacote de aplicativo de treinamento usa o gcloud para empacotar e fazer o envio do aplicativo quando você enviar seu job de treinamento. Esse método requer a criação de uma estrutura de arquivos muito simples com dois arquivos.

scikit-learn

Para este tutorial, a estrutura de arquivos do seu pacote de aplicativo de treinamento precisa ser similar a esta:

iris_sklearn_trainer/
    __init__.py
    iris_training.py

Na linha de comando, crie um diretório localmente:
```
mkdir iris_sklearn_trainer
```
Crie um arquivo vazio chamado __init__.py:
```
touch iris_sklearn_trainer/__init__.py
```
Salve o código de treinamento como iris_training.py e salve esse arquivo no diretório iris_sklearn_trainer. Como alternativa, use cURL para fazer o download e salvar o arquivo do GitHub:
```
curl https://raw.githubusercontent.com/GoogleCloudPlatform/cloudml-samples/master/sklearn/iris_training.py > iris_sklearn_trainer/iris_training.py
```
Veja o código-fonte completo no GitHub.
Confirme se o pacote de aplicativo de treinamento está configurado corretamente:
```
ls ./iris_sklearn_trainer
  __init__.py  iris_training.py
```

XGBoost

Para este tutorial, a estrutura de arquivos do seu pacote de aplicativo de treinamento precisa ser similar a esta:

iris_xgboost_trainer/
    __init__.py
    iris_training.py

Na linha de comando, crie um diretório localmente:
```
mkdir iris_xgboost_trainer
```
Crie um arquivo vazio chamado __init__.py:
```
touch iris_xgboost_trainer/__init__.py
```
Salve o código de treinamento como iris_training.py e salve esse arquivo no diretório iris_xgboost_trainer. Como alternativa, use cURL para fazer o download e salvar o arquivo do GitHub:
```
curl https://raw.githubusercontent.com/GoogleCloudPlatform/cloudml-samples/master/xgboost/iris_training.py > iris_xgboost_trainer/iris_training.py
```
Veja o código-fonte completo no GitHub.
Confirme se o pacote de aplicativo de treinamento está configurado corretamente:
```
ls ./iris_xgboost_trainer
  __init__.py  iris_training.py
```

Saiba mais sobre como empacotar um aplicativo de treinamento.

Executar o treinador localmente

É possível testar seu aplicativo de treinamento localmente usando o comando gcloud ai-platform local train. Essa etapa é opcional, mas é útil para fins de depuração.

scikit-learn

Na linha de comando, defina as seguintes variáveis de ambiente, substituindo [VALUES-IN-BRACKETS] pelos valores apropriados:

TRAINING_PACKAGE_PATH="./iris_sklearn_trainer/"
MAIN_TRAINER_MODULE="iris_sklearn_trainer.iris_training"

Teste o job de treinamento localmente:

gcloud ai-platform local train \
  --package-path $TRAINING_PACKAGE_PATH \
  --module-name $MAIN_TRAINER_MODULE

XGBoost

Na linha de comando, defina as seguintes variáveis de ambiente, substituindo [VALUES-IN-BRACKETS] pelos valores apropriados:

TRAINING_PACKAGE_PATH="./iris_xgboost_trainer/"
MAIN_TRAINER_MODULE="iris_xgboost_trainer.iris_training"

Teste o job de treinamento localmente:

gcloud ai-platform local train \
  --package-path $TRAINING_PACKAGE_PATH \
  --module-name $MAIN_TRAINER_MODULE

Enviar o job de treinamento

Nesta seção, você usa gcloud ai-platform jobs submit training para enviar o job de treinamento.

Especificar os parâmetros do job de treinamento

Defina as variáveis de ambiente a seguir para cada parâmetro na solicitação de job de treinamento:

BUCKET_NAME: nome do bucket do Cloud Storage.
JOB_NAME: o nome que será usado para o job. Use apenas letras maiúsculas e minúsculas, números e sublinhados, começando com uma letra. Por exemplo, iris_scikit_learn_$(date +"%Y%m%d_%H%M%S") ou iris_xgboost_$(date +"%Y%m%d_%H%M%S").
JOB_DIR: o caminho para o local do Cloud Storage a ser usado para os arquivos de saída do job de treinamento. Por exemplo, gs://$BUCKET_NAME/scikit_learn_job_dir ou gs://$BUCKET_NAME/xgboost_job_dir.
TRAINING_PACKAGE_PATH: o caminho local do diretório raiz do aplicativo de treinamento. Por exemplo, ./iris_sklearn_trainer/ ou ./iris_xgboost_trainer/.
MAIN_TRAINER_MODULE: especifica qual arquivo o serviço de treinamento do AI Platform Training executará. Ele tem o formato [YOUR_FOLDER_NAME.YOUR_PYTHON_FILE_NAME]. Por exemplo, iris_sklearn_trainer.iris_training ou iris_xgboost_trainer.iris_training.
REGION: o nome da região usada para executar o job de treinamento. Use uma das regiões disponíveis para o serviço de treinamento do AI Platform Training. Verifique se o bucket do Cloud Storage está na mesma região.
RUNTIME_VERSION: é necessário especificar uma versão de ambiente de execução do AI Platform Training que seja compatível com o scikit-learn. Neste exemplo, 2.11.
PYTHON_VERSION: a versão do Python a ser usada para o job. Para este tutorial, especifique o Python 3.7.
SCALE_TIER: uma especificação de cluster predefinida de máquinas para executar o job de treinamento. Nesse caso, BASIC. Também é possível usar níveis de dimensionamento personalizados para definir a própria configuração de clusters para o treinamento.

Para sua comodidade, as variáveis de ambiente deste tutorial estão listadas abaixo.

scikit-learn

Substitua [VALUES-IN-BRACKETS] pelos valores apropriados:

    BUCKET_NAME=[YOUR-BUCKET-NAME]
    JOB_NAME="iris_scikit_learn_$(date +"%Y%m%d_%H%M%S")"
    JOB_DIR=gs://$BUCKET_NAME/scikit_learn_job_dir
    TRAINING_PACKAGE_PATH="./iris_sklearn_trainer/"
    MAIN_TRAINER_MODULE="iris_sklearn_trainer.iris_training"
    REGION=us-central1
    RUNTIME_VERSION=2.11
    PYTHON_VERSION=3.7
    SCALE_TIER=BASIC

XGBoost

Substitua [VALUES-IN-BRACKETS] pelos valores apropriados:

    BUCKET_NAME=[YOUR-BUCKET-NAME]
    JOB_NAME="iris_xgboost_$(date +"%Y%m%d_%H%M%S")"
    JOB_DIR=gs://$BUCKET_NAME/xgboost_job_dir
    TRAINING_PACKAGE_PATH="./iris_xgboost_trainer/"
    MAIN_TRAINER_MODULE="iris_xgboost_trainer.iris_training"
    REGION=us-central1
    RUNTIME_VERSION=2.11
    PYTHON_VERSION=3.7
    SCALE_TIER=BASIC

Envie a solicitação de job de treinamento:

gcloud ai-platform jobs submit training $JOB_NAME \
  --job-dir $JOB_DIR \
  --package-path $TRAINING_PACKAGE_PATH \
  --module-name $MAIN_TRAINER_MODULE \
  --region $REGION \
  --runtime-version=$RUNTIME_VERSION \
  --python-version=$PYTHON_VERSION \
  --scale-tier $SCALE_TIER

O resultado será semelhante a:

Job [iris_scikit_learn_[DATE]_[TIME]] submitted successfully.
Your job is still active. You may view the status of your job with the command

  $ gcloud ai-platform jobs describe iris_scikit_learn_[DATE]_[TIME]

or continue streaming the logs with the command

  $ gcloud ai-platform jobs stream-logs iris_scikit_learn_[DATE]_[TIME]

jobId: iris_scikit_learn_[DATE]_[TIME]
state: QUEUED

Como visualizar os registros de treinamento (opcional)

O AI Platform Training captura todos os streams stdout e stderr e as instruções de geração de registros. Esses registros são armazenados no Logging e permanecem visíveis durante e após a execução.

Para ver os registros do job de treinamento:

Console

Abra a página Jobs do AI Platform Training.

Abrir jobs no Console do Google Cloud
Selecione o nome do job de treinamento a ser inspecionado. Você será direcionado à página Detalhes do job correspondente ao job de treinamento selecionado.
Nos detalhes do job, selecione o link Ver registros. Você será direcionado à página “Registros”, em que é possível pesquisar e filtrar os registros do job de treinamento selecionado.

gcloud

Veja os registros no terminal com gcloud ai-platform jobs stream-logs.

gcloud ai-platform jobs stream-logs $JOB_NAME

Verificar o arquivo de modelo no Cloud Storage

Visualize o conteúdo da pasta de destino do modelo para verificar se foi feito upload do arquivo salvo no Cloud Storage.

gsutil ls gs://$BUCKET_NAME/iris_*

Exemplo de resposta:

gs://bucket-name/iris_20180518_123815/:
gs://bucket-name/iris_20180518_123815/model.joblib

A seguir

Consiga previsões on-line com o scikit-learn no AI Platform Training.
Saiba como usar níveis de escalonamento personalizados para definir a própria configuração de clusters para o treinamento.