Receba previsões de ML com modelos do scikit-learn ou do XGBoost

macOS

1. Verificar a instalação do Python
   Verifique se o Python (em inglês) está instalado e, se necessário, instale-o.

   python -V

2. 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.

3. 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

4. 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

1. Abra o console do Google Cloud.

   Console do Google Cloud

2. 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.

3. 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.

macOS

Em seu ambiente virtual, execute o seguinte comando 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 Prediction:

(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. Assim, você evita comportamentos inesperados quando o código for executado no AI Platform Prediction.

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

• Instruções de instalação do scikit-learn
• Instruções de instalação do XGBoost (em inglês)
• Instruções de instalação do pandas

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:

• Instruções de instalação do scikit-learn
• Instruções de instalação do XGBoost (em inglês)
• Instruções de instalação do pandas

scikit-learn

Seguindo o exemplo do scikit-learn sobre persistência de modelos, você pode treinar e exportar um modelo como mostrado abaixo:

from sklearn.externals import joblib
from sklearn import datasets
from sklearn import svm

# Load the Iris dataset
iris = datasets.load_iris()

# Train a classifier
classifier = svm.SVC()
classifier.fit(iris.data, iris.target)

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

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.

Para os propósitos deste tutorial, o scikit-learn é usado com o XGBoost apenas para importar o conjunto de dados Iris.

from sklearn import datasets
import xgboost as xgb

# Load the Iris dataset
iris = datasets.load_iris()

# 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
bst.save_model('./model.bst')

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)

scikit-learn

XGBoost

gcloud

Crie um arquivo input.json com cada instância de entrada em uma linha separada:

[6.8,  2.8,  4.8,  1.4]
[6.0,  3.4,  4.5,  1.6]

O formato das instâncias de entrada precisa ser compatível com o modelo. Neste exemplo, como o modelo Iris requer quatro recursos, sua entrada precisa ser uma matriz de forma (num_instances, 4).

API REST

Crie um arquivo input.json formatado como uma lista simples de flutuantes, com cada instância de entrada em uma linha separada:

{
  "instances": [

    [6.8,  2.8,  4.8,  1.4],
    [6.0,  3.4,  4.5,  1.6]

  ]
}

O formato das instâncias de entrada precisa ser compatível com o modelo. Neste exemplo, como o modelo Iris requer quatro recursos, sua entrada precisa ser uma matriz de forma (num_instances, 4).

Console

1. Abra a página Modelos do AI Platform Prediction no console do Google Cloud:

   Acessar a página de modelos

2. Clique no botão Novo modelo, na parte superior da página Modelos. Você será direcionado para a página Criar modelo.

3. Insira um nome exclusivo para o modelo no campo Nome do modelo.

4. Quando a caixa de seleção Usar endpoint regional está marcada, o AI Platform Prediction usa um endpoint regional. Para usar o endpoint global, desmarque a caixa de seleção Usar endpoint regional.

5. Na lista suspensa Região, selecione um local para os nós de previsão. As regiões disponíveis diferem dependendo do uso de um endpoint regional ou global.

6. Clique em Criar.

7. Verifique se você voltou à página Modelos e se o novo modelo é exibido na lista.

gcloud

gcloud ai-platform models create MODEL_NAME \
  --region=REGION

gcloud ai-platform models create MODEL_NAME \
  --regions=REGION

API REST

Console

1. Abra a página Modelos do AI Platform Prediction no console do Google Cloud:

   Acessar a página de modelos

2. Na página Modelos, selecione o nome do recurso do modelo que quiser usar para criar a versão. Você será direcionado para a página Detalhes do modelo.

3. Clique no botão Nova versão, na parte superior da página Detalhes do modelo. Você será direcionado para a página Criar versão.

4. Digite o nome da versão no campo Nome. Se quiser, insira uma descrição para a versão no campo Descrição.

5. Digite as seguintes informações sobre o treinamento do modelo nas caixas suspensas correspondentes:

   • Selecione a versão do Python usada para treinar o modelo.
   • Selecione o framework e a versão dele.
   • Selecione a Versão do ambiente de execução de ML. Saiba mais sobre as versões de ambiente de execução do AI Platform Prediction.

6. Se quiser, selecione um tipo de máquina para executar a previsão on-line.

7. No campo URI do modelo, insira o local do bucket do Cloud Storage em que você fez o upload do arquivo de modelo. Use o botão Procurar para encontrar o caminho correto.

   Especifique o caminho para o diretório em que está o arquivo, não o caminho para o arquivo do modelo em si. Por exemplo, use gs://your_bucket_name/model-dir/ em vez de gs://your_bucket_name/model-dir/saved_model.pb ou gs://your_bucket_name/model-dir/model.pkl.

8. Selecione uma opção de escalonamento para implantação de previsão on-line:

   • Se você selecionar "Escalonamento automático", o campo opcional Número mínimo de nós será exibido. Insira o número mínimo de nós a serem mantidos sempre em execução quando o serviço for reduzido.

   • Se você selecionar "Escalonamento manual", digite o número de nós que quer manter em execução.

   Saiba como as opções de escalonamento variam de acordo com o tipo de máquina.

   Saiba mais sobre os custos de previsão.

9. Clique em Salvar para criar a versão do modelo.

gcloud

1. Defina variáveis de ambiente para armazenar o caminho do diretório do Cloud Storage em que o binário do modelo está localizado, o nome do modelo, o nome da versão e a opção de framework.

   Ao criar uma versão com a gcloud CLI, é possível inserir o nome do framework em letras maiúsculas com sublinhados (por exemplo, SCIKIT_LEARN) ou em letras minúsculas com hífens (por exemplo, scikit-learn). Ambas as opções produzem um comportamento idêntico.

   Substitua [VALUES_IN_BRACKETS] pelos valores apropriados:

   MODEL_DIR="gs://your_bucket_name/"
   VERSION_NAME="[YOUR-VERSION-NAME]"
   MODEL_NAME="[YOUR-MODEL-NAME]"
   FRAMEWORK="[YOUR-FRAMEWORK_NAME]"
   

2. Crie a versão:

   gcloud ai-platform versions create $VERSION_NAME \
     --model=$MODEL_NAME \
     --origin=$MODEL_DIR \
     --runtime-version=2.11 \
     --framework=$FRAMEWORK \
     --python-version=3.7 \
     --region=REGION \
     --machine-type=MACHINE_TYPE
   

   Substitua:

   • REGION: a região do endpoint regional em que você criou o modelo. Se você criou o modelo no endpoint global, omita a sinalização --region.

   • MACHINE_TYPE: um tipo de máquina que determina os recursos de computação disponíveis para os nós de previsão.

   A criação da versão leva alguns minutos. Quando ela estiver pronta, você verá a resposta abaixo:

   Creating version (this might take a few minutes)......done.

3. Veja informações sobre a nova versão:

   gcloud ai-platform versions describe $VERSION_NAME \
     --model=$MODEL_NAME
   

   A resposta será parecida com esta:

   createTime: '2018-02-28T16:30:45Z'
   deploymentUri: gs://your_bucket_name
   framework: [YOUR-FRAMEWORK-NAME]
   machineType: mls1-c1-m2
   name: projects/[YOUR-PROJECT-ID]/models/[YOUR-MODEL-NAME]/versions/[YOUR-VERSION-NAME]
   pythonVersion: '3.7'
   runtimeVersion: '2.11'
   state: READY

API REST

1. Formate o corpo da solicitação para conter o objeto da versão. Neste exemplo, são especificadas as versões name, deploymentUri, runtimeVersion, framework e machineType. Substitua [VALUES_IN_BRACKETS] pelos valores apropriados:

   {
     "name": "[YOUR-VERSION-NAME]",
     "deploymentUri": "gs://your_bucket_name/",
     "runtimeVersion": "2.11",
     "framework": "[YOUR_FRAMEWORK_NAME]",
     "pythonVersion": "3.7",
     "machineType": "[YOUR_MACHINE_TYPE]"
   }
   

2. Envie a chamada da API REST para o caminho a seguir, substituindo os [VALUES_IN_BRACKETS] pelos valores apropriados:

   POST https://REGION-ml.googleapis.com/v1/projects/[YOUR-PROJECT-ID]/models/[YOUR-MODEL-NAME]/versions
   

   Substitua REGION pela região do endpoint regional em que você criou seu modelo. Se você criou seu modelo no endpoint global, use ml.googleapis.com.

   Por exemplo, é possível fazer a solicitação a seguir usando o comando curl:

   curl -X POST -H "Content-Type: application/json" \
     -d '{"name": "[YOUR-VERSION-NAME]", "deploymentUri": "gs://your_bucket_name/", "runtimeVersion": "2.11", "framework": "[YOUR_FRAMEWORK_NAME]", "pythonVersion": "3.7", "machineType": "[YOUR_MACHINE_TYPE]"}' \
     -H "Authorization: Bearer `gcloud auth print-access-token`" \
     "https://REGION-ml.googleapis.com/v1/projects/[YOUR-PROJECT-ID]/models/[YOUR-MODEL-NAME]/versions"
   

   A criação da versão leva alguns minutos. Quando ela estiver pronta, você verá uma resposta parecida com esta:

   {
     "name": "projects/[YOUR-PROJECT-ID]/operations/create_[YOUR-MODEL-NAME]_[YOUR-VERSION-NAME]-[TIMESTAMP]",
     "metadata": {
       "@type": "type.googleapis.com/google.cloud.ml.v1.OperationMetadata",
       "createTime": "2018-07-07T02:51:50Z",
       "operationType": "CREATE_VERSION",
       "modelName": "projects/[YOUR-PROJECT-ID]/models/[YOUR-MODEL-NAME]",
       "version": {
         "name": "projects/[YOUR-PROJECT-ID]/models/[YOUR-MODEL-NAME]/versions/[YOUR-VERSION-NAME]",
         "deploymentUri": "gs://your_bucket_name",
         "createTime": "2018-07-07T02:51:49Z",
         "runtimeVersion": "2.11",
         "framework": "[YOUR_FRAMEWORK_NAME]",
         "machineType": "[YOUR_MACHINE_TYPE]",
         "pythonVersion": "3.7"
       }
     }
   }
   

gcloud

1. Configure variáveis de ambiente para os nomes do modelo, da versão e do arquivo de entrada:

   MODEL_NAME="iris"
   VERSION_NAME="v1"
   INPUT_FILE="input.json"
   

2. Envie a solicitação de predição:

   gcloud ai-platform predict --model $MODEL_NAME --version \
     $VERSION_NAME --json-instances $INPUT_FILE
   

Python

Nesta amostra, presume-se que você esteja familiarizado com a biblioteca de cliente do Google Cloud para Python. Caso não esteja, consulte Como usar a biblioteca cliente do Python.

import googleapiclient.discovery

def predict_json(project, model, instances, version=None):
    """Send json data to a deployed model for prediction.
    Args:
        project (str): project where the AI Platform Prediction Model is deployed.
        model (str): model name.
        instances ([[float]]): List of input instances, where each input
           instance is a list of floats.
        version: str, version of the model to target.
    Returns:
        Mapping[str: any]: dictionary of prediction results defined by the
            model.
    """
    # Create the AI Platform Prediction service object.
    # To authenticate set the environment variable
    # GOOGLE_APPLICATION_CREDENTIALS=<path_to_service_account_file>
    service = googleapiclient.discovery.build('ml', 'v1')
    name = 'projects/{}/models/{}'.format(project, model)

    if version is not None:
        name += '/versions/{}'.format(version)

    response = service.projects().predict(
        name=name,
        body={'instances': instances}
    ).execute()

    if 'error' in response:
        raise RuntimeError(response['error'])

    return response['predictions']