Exporte modelos tabulares do AutoML

Esta página descreve como usar a Vertex AI para exportar o seu modelo tabular do AutoML para o Cloud Storage, transferir o modelo para um servidor no local ou um servidor alojado por outro fornecedor de nuvem e, em seguida, usar o Docker para disponibilizar o modelo para previsões.

Para obter informações sobre a exportação de modelos do Edge de imagem e vídeo, consulte o artigo Exporte modelos do AutoML Edge.

Depois de exportar o modelo tabular, se quiser importá-lo novamente para o Vertex AI, consulte o artigo Importe modelos para o Vertex AI.

Limitações

A exportação de modelos tabulares do AutoML tem as seguintes limitações:

• Só pode exportar modelos de classificação tabular e regressão do AutoML. A exportação de modelos de previsão tabular do AutoML não é suportada.

• O Vertex Explainable AI não está disponível com modelos tabulares exportados. Se precisar de usar a Vertex AI Explainable AI, tem de apresentar previsões a partir de um modelo alojado pela Vertex AI.

• O modelo tabular exportado só pode ser executado em CPUs de arquitetura x86 que suportem conjuntos de instruções de extensões vetoriais avançadas (AVX).

Processo de exportação

Os passos para exportar o modelo são:

1. Configure o seu ambiente.
2. Exporte o modelo.
3. Extraia e execute o servidor de modelos.
4. Pedir previsões.

Antes de começar

Antes de poder concluir esta tarefa, tem de ter concluído as seguintes tarefas:

• Configure o seu projeto conforme descrito em Configure um projeto e um ambiente de desenvolvimento.
• Prepare o modelo que quer transferir.
• Instale e inicialize a CLI Google Cloud no servidor que vai usar para executar o modelo exportado.
• Instale o Docker no seu servidor.

Exporte o modelo

Consola

1. Na Google Cloud consola, na secção Vertex AI, aceda à página Modelos.

   Aceda à página Modelos

2. Clique no modelo tabular que quer exportar para abrir a respetiva página de detalhes.

3. Clique em Exportar na barra de botões para exportar o modelo.

4. Selecione ou crie uma pasta do Cloud Storage na localização desejada.

   O contentor tem de cumprir os requisitos do contentor.

   Não pode exportar um modelo para um contentor de nível superior. Tem de usar, pelo menos, um nível de pasta.

   Para obter os melhores resultados, crie uma nova pasta vazia. Vai copiar todo o conteúdo da pasta num passo posterior.

5. Clique em Exportar.

   Na secção seguinte, vai transferir o modelo exportado para o seu servidor.

REST

Use o método models.export para exportar um modelo para o Cloud Storage.

Antes de usar qualquer um dos dados do pedido, faça as seguintes substituições:

• LOCATION: a sua região.
• PROJECT: o seu ID do projeto.
• MODEL_ID: o ID do modelo que quer exportar.
• GCS_DESTINATION : a pasta de destino no Cloud Storage. Por exemplo, gs://export-bucket/exports.

  Não pode exportar um modelo para um contentor de nível superior. Tem de usar, pelo menos, um nível de pasta.

  A pasta tem de estar em conformidade com os requisitos do contentor.

  Para os melhores resultados, crie uma nova pasta. Vai copiar todo o conteúdo da pasta num passo posterior.

Método HTTP e URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID:export

Corpo JSON do pedido:

{
  "outputConfig": {
    "exportFormatId": "tf-saved-model",
    "artifactDestination": {
      "outputUriPrefix": "GCS_DESTINATION"
    }
  }
}

Para enviar o seu pedido, escolha uma destas opções:

curl

Guarde o corpo do pedido num ficheiro com o nome request.json, e execute o seguinte comando:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID:export"

PowerShell

Guarde o corpo do pedido num ficheiro com o nome request.json, e execute o seguinte comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID:export" | Select-Object -Expand Content

Deve receber uma resposta JSON semelhante à seguinte:

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION/models/MODEL_ID/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.v1.ExportModelOperationMetadata",
    "genericMetadata": {
      "createTime": "2020-10-12T20:53:40.130785Z",
      "updateTime": "2020-10-12T20:53:40.130785Z"
    },
    "outputInfo": {
      "artifactOutputUri": "gs://OUTPUT_BUCKET/model-MODEL_ID/EXPORT_FORMAT/YYYY-MM-DDThh:mm:ss.sssZ"
    }
  }
}

Java

Antes de experimentar este exemplo, siga as Javainstruções de configuração no início rápido do Vertex AI com bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Java Vertex AI.

Para se autenticar no Vertex AI, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.aiplatform.v1.ExportModelOperationMetadata;
import com.google.cloud.aiplatform.v1.ExportModelRequest;
import com.google.cloud.aiplatform.v1.ExportModelResponse;
import com.google.cloud.aiplatform.v1.GcsDestination;
import com.google.cloud.aiplatform.v1.ModelName;
import com.google.cloud.aiplatform.v1.ModelServiceClient;
import com.google.cloud.aiplatform.v1.ModelServiceSettings;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class ExportModelTabularClassificationSample {
  public static void main(String[] args)
      throws InterruptedException, ExecutionException, TimeoutException, IOException {
    // TODO(developer): Replace these variables before running the sample.
    String gcsDestinationOutputUriPrefix = "gs://your-gcs-bucket/destination_path";
    String project = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    exportModelTableClassification(gcsDestinationOutputUriPrefix, project, modelId);
  }

  static void exportModelTableClassification(
      String gcsDestinationOutputUriPrefix, String project, String modelId)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    ModelServiceSettings modelServiceSettings =
        ModelServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (ModelServiceClient modelServiceClient = ModelServiceClient.create(modelServiceSettings)) {
      String location = "us-central1";
      ModelName modelName = ModelName.of(project, location, modelId);

      GcsDestination.Builder gcsDestination = GcsDestination.newBuilder();
      gcsDestination.setOutputUriPrefix(gcsDestinationOutputUriPrefix);
      ExportModelRequest.OutputConfig outputConfig =
          ExportModelRequest.OutputConfig.newBuilder()
              .setExportFormatId("tf-saved-model")
              .setArtifactDestination(gcsDestination)
              .build();

      OperationFuture<ExportModelResponse, ExportModelOperationMetadata> exportModelResponseFuture =
          modelServiceClient.exportModelAsync(modelName, outputConfig);
      System.out.format(
          "Operation name: %s\n", exportModelResponseFuture.getInitialFuture().get().getName());
      System.out.println("Waiting for operation to finish...");
      ExportModelResponse exportModelResponse =
          exportModelResponseFuture.get(300, TimeUnit.SECONDS);
      System.out.format(
          "Export Model Tabular Classification Response: %s", exportModelResponse.toString());
    }
  }
}

Node.js

Antes de experimentar este exemplo, siga as Node.jsinstruções de configuração no início rápido do Vertex AI com bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Node.js Vertex AI.

Para se autenticar no Vertex AI, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

/**
 * TODO(developer): Uncomment these variables before running the sample.\
 * (Not necessary if passing values as arguments)
 */

// const gcsDestinationOutputUriPrefix ='YOUR_GCS_DESTINATION_\
// OUTPUT_URI_PREFIX'; eg. "gs://<your-gcs-bucket>/destination_path"
// const modelId = 'YOUR_MODEL_ID';
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';

// Imports the Google Cloud Model Service Client library
const {ModelServiceClient} = require('@google-cloud/aiplatform');

// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: 'us-central1-aiplatform.googleapis.com',
};

// Instantiates a client
const modelServiceClient = new ModelServiceClient(clientOptions);

async function exportModelTabularClassification() {
  // Configure the name resources
  const name = `projects/${project}/locations/${location}/models/${modelId}`;
  // Configure the outputConfig resources
  const outputConfig = {
    exportFormatId: 'tf-saved-model',
    artifactDestination: {
      outputUriPrefix: gcsDestinationOutputUriPrefix,
    },
  };
  const request = {
    name,
    outputConfig,
  };

  // Export Model request
  const [response] = await modelServiceClient.exportModel(request);
  console.log(`Long running operation : ${response.name}`);

  // Wait for operation to complete
  await response.promise();
  console.log(`Export model response : ${JSON.stringify(response.result)}`);
}
exportModelTabularClassification();

Python

Para saber como instalar ou atualizar o SDK Vertex AI para Python, consulte o artigo Instale o SDK Vertex AI para Python. Para mais informações, consulte a Python documentação de referência da API.

from google.cloud import aiplatform_v1beta1


def export_model_tabular_classification_sample(
    project: str,
    model_id: str,
    gcs_destination_output_uri_prefix: str,
    location: str = "us-central1",
    api_endpoint: str = "us-central1-aiplatform.googleapis.com",
    timeout: int = 300,
):
    # The AI Platform services require regional API endpoints.
    client_options = {"api_endpoint": api_endpoint}
    # Initialize client that will be used to create and send requests.
    # This client only needs to be created once, and can be reused for multiple requests.
    client = aiplatform_v1beta1.ModelServiceClient(client_options=client_options)
    gcs_destination = {"output_uri_prefix": gcs_destination_output_uri_prefix}
    output_config = {
        "artifact_destination": gcs_destination,
        "export_format_id": "tf-saved-model",
    }
    name = client.model_path(project=project, location=location, model=model_id)
    response = client.export_model(name=name, output_config=output_config)
    print("Long running operation:", response.operation.name)
    print("output_info:", response.metadata.output_info)
    export_model_response = response.result(timeout=timeout)
    print("export_model_response:", export_model_response)

Obtenha o estado de uma operação de exportação

Alguns pedidos iniciam operações de longa duração que requerem tempo para serem concluídas. Estes pedidos devolvem um nome da operação, que pode usar para ver o estado da operação ou cancelar a operação. A Vertex AI fornece métodos auxiliares para fazer chamadas contra operações de longa duração. Para mais informações, consulte o artigo Trabalhar com operações de longa duração.

Extraia e execute o servidor de modelos

Nesta tarefa, vai transferir o modelo exportado do Cloud Storage e iniciar o contentor Docker para que o modelo esteja pronto para receber pedidos de previsão.

Para extrair e executar o servidor de modelos:

1. Na máquina onde vai executar o modelo, mude para o diretório onde quer guardar o modelo exportado.

2. Transfira o modelo exportado:

   gcloud storage cp <var>gcs-destination</var> . --recursive
   

   Onde gcs-destination é o caminho para a localização do modelo exportado no Cloud Storage.

   O modelo é copiado para o diretório atual, no seguinte caminho:

   ./model-<model-id>/tf-saved-model/<export-timestamp>

   O caminho pode conter tf-saved-model ou custom-trained.

3. Mude o nome do diretório para remover a indicação de tempo.

   mv model-<model-id>/tf-saved-model/<export-timestamp> model-<model-id>/tf-saved-model/<new-dir-name>
   

   A indicação de tempo torna o diretório inválido para o Docker.

4. Extraia a imagem do Docker do servidor de modelos.

   sudo docker pull MODEL_SERVER_IMAGE
   

   A imagem do servidor do modelo a extrair encontra-se no ficheiro environment.json no diretório do modelo exportado. Deve ter o seguinte caminho:

   ./model-<model-id>/tf-saved-model/<new-dir-name>/environment.json

   Se não existir nenhum ficheiro environment.json, use:

   MULTI_REGION-docker.pkg.dev/vertex-ai/automl-tabular/prediction-server-v1

   Substitua MULTI_REGION por us, europe ou asia para selecionar o repositório do Docker do qual quer extrair a imagem do Docker. Cada repositório fornece a mesma imagem do Docker, mas escolher o Artifact Registry multirregião mais próximo da máquina onde está a executar o Docker pode reduzir a latência.

5. Inicie o contentor Docker com o nome do diretório que acabou de criar:

   docker run -v `pwd`/model-<model-id>/tf-saved-model/<new-dir-name>:/models/default -p 8080:8080 -it MODEL_SERVER_IMAGE
   

Pode parar o servidor de modelos em qualquer altura através do comando Ctrl-C.

Atualize o contentor Docker do servidor de modelos

Uma vez que transfere o contentor Docker do servidor de modelos quando exporta o modelo, tem de atualizar explicitamente o servidor de modelos para receber atualizações e correções de erros. Deve atualizar o servidor do modelo periodicamente, usando o seguinte comando:

docker pull MODEL_SERVER_IMAGE

Certifique-se de que o URI da imagem de Docker corresponde ao URI da imagem de Docker que extraiu anteriormente.

Obtenha previsões do modelo exportado

O servidor de modelos no contentor de imagens do Vertex AI processa os pedidos de previsão e devolve os resultados da previsão.

A previsão em lote não está disponível para modelos exportados.

Formato de dados de previsão

Fornece os dados (campo payload) para o seu pedido de previsão no seguinte formato JSON:

{ "instances": [ { "column_name_1": value, "column_name_2": value, … } , … ] }

Nota: os modelos da Vertex AI exportados não validam o formato dos dados dos pedidos de previsão. Isto significa que um pedido de previsão bem formado, mas com colunas em falta, erros nos nomes das colunas ou até um pedido de um modelo completamente diferente, devolve uma previsão (com falhas ou potencialmente sem significado). Certifique-se de que os pedidos de previsão para modelos exportados estão corretos.

O exemplo seguinte mostra um pedido com três colunas: uma coluna categorial, uma matriz numérica e uma estrutura. O pedido inclui duas linhas.

{
  "instances": [
    {
      "categorical_col": "mouse",
      "num_array_col": [
        1,
        2,
        3
      ],
      "struct_col": {
        "foo": "piano",
        "bar": "2019-05-17T23:56:09.05Z"
      }
    },
    {
      "categorical_col": "dog",
      "num_array_col": [
        5,
        6,
        7
      ],
      "struct_col": {
        "foo": "guitar",
        "bar": "2019-06-17T23:56:09.05Z"
      }
    }
  ]
}

Faça o pedido de previsão

1. Coloque os dados do pedido num ficheiro de texto, por exemplo, tmp/request.json.

   O número de linhas de dados no pedido de previsão, denominado tamanho do minilote, afeta a latência e o débito da previsão. Quanto maior for o tamanho do mini lote, maior é a latência e o débito. Para reduzir a latência, use um tamanho de minilote mais pequeno. Para aumentar o débito, aumente o tamanho do mini lote. Os tamanhos de minilotes mais usados são 1, 32, 64, 128, 256, 512 e 1024.

2. Peça a previsão:

   curl -X POST --data @/tmp/request.json http://localhost:8080/predict
   

Formato dos resultados da previsão

O formato dos resultados depende do objetivo do modelo.

Resultados do modelo de classificação

Os resultados da previsão para modelos de classificação (binários e de várias classes) devolvem uma pontuação de probabilidade para cada valor potencial da coluna de destino. Tem de determinar como quer usar as pontuações. Por exemplo, para obter uma classificação binária a partir das pontuações fornecidas, identificaria um valor limite. Se existirem duas classes, "A" e "B", deve classificar o exemplo como "A" se a pontuação de "A" for superior ao limite escolhido e "B" caso contrário. Para conjuntos de dados desequilibrados, o limite pode aproximar-se de 100% ou 0%.

O payload de resultados de um modelo de classificação tem um aspeto semelhante ao deste exemplo:

{
  "predictions": [
    {
      "scores": [
        0.539999994635582,
        0.2599999845027924,
        0.2000000208627896
      ],
      "classes": [
        "apple",
        "orange",
        "grape"
      ]
    },
    {
      "scores": [
        0.23999999463558197,
        0.35999998450279236,
        0.40000002086278963
      ],
      "classes": [
        "apple",
        "orange",
        "grape"
      ]
    }
  ]
}

Resultados do modelo de regressão

É devolvido um valor previsto para cada linha válida do pedido de previsão. Os intervalos de previsão não são devolvidos para modelos exportados.

O payload de resultados de um modelo de regressão tem um aspeto semelhante ao deste exemplo:

{
  "predictions": [
    {
      "value": -304.3663330078125,
      "lower_bound": -56.32196807861328,
      "upper_bound": 126.51904296875
    },
    {
      "value": -112.3663330078125,
      "lower_bound": 16.32196807861328,
      "upper_bound": 255.51904296875
    }
  ]
}

O que se segue?

• Saiba como importar o modelo tabular exportado novamente para o Vertex AI.