Obtenha inferências a partir de um modelo de classificação de imagens

Esta página mostra como obter inferências online (em tempo real) e inferências em lote dos seus modelos de classificação de imagens através da Google Cloud consola ou da API Vertex AI.

Diferença entre inferências online e em lote

As inferências online são pedidos síncronos feitos a um ponto final do modelo. Use inferências online quando estiver a fazer pedidos em resposta à entrada da aplicação ou em situações que requerem inferência atempada.

As inferências em lote são pedidos assíncronos. Pede inferências em lote diretamente do recurso do modelo sem ter de implementar o modelo num ponto final. Para dados de imagens, use inferências em lote quando não precisar de uma resposta imediata e quiser processar dados acumulados através de um único pedido.

Obtenha inferências online

Implemente um modelo num ponto final

Tem de implementar um modelo num ponto final antes de poder usar esse modelo para publicar inferências online. A implementação de um modelo associa recursos físicos ao modelo para que possa publicar inferências online com baixa latência.

Pode implementar mais do que um modelo num ponto final e pode implementar um modelo em mais do que um ponto final. Para mais informações sobre opções e exemplos de utilização para a implementação de modelos, consulte o artigo Acerca da implementação de modelos.

Use um dos seguintes métodos para implementar um modelo:

Google Cloud consola

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

   Aceda à página Modelos

2. Clique no nome do modelo que quer implementar para abrir a respetiva página Descrição do modelo.

3. Na coluna ID da versão, clique no ID da versão do modelo que quer implementar

4. Clique em Implementar e testar.

   Se o seu modelo já estiver implementado em quaisquer pontos finais, estes são apresentados na secção Implemente o seu modelo.

5. Clique em Implementar no ponto final.

6. Para implementar o modelo num novo ponto final, clique em Criar novo ponto final e introduza um nome para o novo ponto final. Para implementar o modelo num ponto final existente, clique em Adicionar ao ponto final existente e selecione o ponto final Nome do ponto final.

   Pode adicionar mais do que um modelo a um ponto final e pode adicionar um modelo a vários pontos finais. Saiba mais.

   Se implementar num novo ponto final, escolha como o seu ponto final pode ser acedido:

   • Clique em Padrão para que o ponto final esteja disponível para inferência através de uma API REST.

   • Clique em Privado para que o ponto final use uma ligação privada.

   Se fizer a implementação num ponto final existente que tenha um ou mais modelos implementados, atualize a percentagem de Divisão de tráfego para o modelo que está a implementar e os modelos já implementados, de modo que as respetivas percentagens totalizem 100%.

7. Selecione AutoML Image e configure da seguinte forma:

   1. Se estiver a implementar o seu modelo num novo ponto final, aceite 100 para a divisão de tráfego. Caso contrário, ajuste os valores de divisão do tráfego para todos os modelos no ponto final de modo que totalizem 100.

   2. Introduza o número de nós de computação que quer disponibilizar para o seu modelo.

      Este é o número de nós disponíveis para este modelo em todos os momentos. Os nós são-lhe cobrados, mesmo sem tráfego de inferência. Consulte a página de preços.

   3. Saiba como alterar as definições predefinidas para o registo de inferências.

   4. Apenas modelos de classificação (opcional): na secção Opções de explicabilidade, selecione Ativar atribuições de funcionalidades para este modelo para ativar a IA explicável do Vertex. Aceite as definições de visualização existentes ou escolha novos valores e clique em Concluído.

      A implementação de modelos de classificação de imagens do AutoML com a Vertex Explainable AI configurada e a realização de inferências com explicações é opcional. A ativação da IA explicável do Vertex no momento da implementação incorre em custos adicionais com base na contagem de nós implementados e no tempo de implementação. Consulte Preços para mais informações.

   5. Clique em Concluído para o seu modelo e, quando todas as percentagens de Divisão de tráfego estiverem corretas, clique em Continuar.

      É apresentada a região onde o seu modelo é implementado. Esta tem de ser a região onde criou o modelo.

   6. Clique em Implementar para implementar o modelo no ponto final.

API

Quando implementa um modelo através da API Vertex AI, conclui os seguintes passos:

1. Crie um ponto final, se necessário.
2. Obtenha o ID do ponto final.
3. Implemente o modelo no ponto final.

Crie um ponto final

Se estiver a implementar um modelo num ponto final existente, pode ignorar este passo.

gcloud

O exemplo seguinte usa o comando gcloud ai endpoints create:

gcloud ai endpoints create \
  --region=LOCATION \
  --display-name=ENDPOINT_NAME

Substitua o seguinte:

• LOCATION_ID: a região onde está a usar o Vertex AI.
• ENDPOINT_NAME: o nome a apresentar do ponto final.

A ferramenta Google Cloud CLI pode demorar alguns segundos a criar o ponto final.

REST

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

• LOCATION_ID: a sua região.
• PROJECT_ID: o seu ID do projeto.
• ENDPOINT_NAME: o nome a apresentar do ponto final.

Método HTTP e URL:

POST https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints

Corpo JSON do pedido:

{
  "display_name": "ENDPOINT_NAME"
}

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

curl (Linux, macOS ou Cloud Shell)

Nota: O comando seguinte pressupõe que tem sessão iniciada na CLI gcloud com a sua conta de utilizador executando gcloud init ou gcloud auth login, ou usando o Cloud Shell, que inicia automaticamente sessão na CLI gcloud. Pode verificar a conta atualmente ativa executando o comando gcloud auth list.

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_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints"

PowerShell (Windows)

Nota: O comando seguinte pressupõe que iniciou sessão na CLI do Google Cloud com a sua conta de utilizador executando gcloud init ou gcloud auth login .gcloud Pode verificar a conta atualmente ativa executando o comando gcloud auth list.

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_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints" | Select-Object -Expand Content

Deve receber uma resposta JSON semelhante à seguinte:

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION_ID/endpoints/ENDPOINT_ID/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.v1.CreateEndpointOperationMetadata",
    "genericMetadata": {
      "createTime": "2020-11-05T17:45:42.812656Z",
      "updateTime": "2020-11-05T17:45:42.812656Z"
    }
  }
}

Pode sondar o estado da operação até a resposta incluir "done": true.

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.CreateEndpointOperationMetadata;
import com.google.cloud.aiplatform.v1.Endpoint;
import com.google.cloud.aiplatform.v1.EndpointServiceClient;
import com.google.cloud.aiplatform.v1.EndpointServiceSettings;
import com.google.cloud.aiplatform.v1.LocationName;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateEndpointSample {

  public static void main(String[] args)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "YOUR_PROJECT_ID";
    String endpointDisplayName = "YOUR_ENDPOINT_DISPLAY_NAME";
    createEndpointSample(project, endpointDisplayName);
  }

  static void createEndpointSample(String project, String endpointDisplayName)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    EndpointServiceSettings endpointServiceSettings =
        EndpointServiceSettings.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 (EndpointServiceClient endpointServiceClient =
        EndpointServiceClient.create(endpointServiceSettings)) {
      String location = "us-central1";
      LocationName locationName = LocationName.of(project, location);
      Endpoint endpoint = Endpoint.newBuilder().setDisplayName(endpointDisplayName).build();

      OperationFuture<Endpoint, CreateEndpointOperationMetadata> endpointFuture =
          endpointServiceClient.createEndpointAsync(locationName, endpoint);
      System.out.format("Operation name: %s\n", endpointFuture.getInitialFuture().get().getName());
      System.out.println("Waiting for operation to finish...");
      Endpoint endpointResponse = endpointFuture.get(300, TimeUnit.SECONDS);

      System.out.println("Create Endpoint Response");
      System.out.format("Name: %s\n", endpointResponse.getName());
      System.out.format("Display Name: %s\n", endpointResponse.getDisplayName());
      System.out.format("Description: %s\n", endpointResponse.getDescription());
      System.out.format("Labels: %s\n", endpointResponse.getLabelsMap());
      System.out.format("Create Time: %s\n", endpointResponse.getCreateTime());
      System.out.format("Update Time: %s\n", endpointResponse.getUpdateTime());
    }
  }
}

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 endpointDisplayName = 'YOUR_ENDPOINT_DISPLAY_NAME';
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';

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

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

// Instantiates a client
const endpointServiceClient = new EndpointServiceClient(clientOptions);

async function createEndpoint() {
  // Configure the parent resource
  const parent = `projects/${project}/locations/${location}`;
  const endpoint = {
    displayName: endpointDisplayName,
  };
  const request = {
    parent,
    endpoint,
  };

  // Get and print out a list of all the endpoints for this resource
  const [response] = await endpointServiceClient.createEndpoint(request);
  console.log(`Long running operation : ${response.name}`);

  // Wait for operation to complete
  await response.promise();
  const result = response.result;

  console.log('Create endpoint response');
  console.log(`\tName : ${result.name}`);
  console.log(`\tDisplay name : ${result.displayName}`);
  console.log(`\tDescription : ${result.description}`);
  console.log(`\tLabels : ${JSON.stringify(result.labels)}`);
  console.log(`\tCreate time : ${JSON.stringify(result.createTime)}`);
  console.log(`\tUpdate time : ${JSON.stringify(result.updateTime)}`);
}
createEndpoint();

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.

def create_endpoint_sample(
    project: str,
    display_name: str,
    location: str,
):
    aiplatform.init(project=project, location=location)

    endpoint = aiplatform.Endpoint.create(
        display_name=display_name,
        project=project,
        location=location,
    )

    print(endpoint.display_name)
    print(endpoint.resource_name)
    return endpoint

Obtenha o ID do ponto final

Precisa do ID do ponto final para implementar o modelo.

gcloud

O exemplo seguinte usa o comando gcloud ai endpoints list:

gcloud ai endpoints list \
  --region=LOCATION \
  --filter=display_name=ENDPOINT_NAME

Substitua o seguinte:

• LOCATION_ID: a região onde está a usar o Vertex AI.
• ENDPOINT_NAME: o nome a apresentar do ponto final.

Tenha em atenção o número apresentado na coluna ENDPOINT_ID. Use este ID no passo seguinte.

REST

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

• LOCATION_ID: a região onde está a usar o Vertex AI.
• PROJECT_ID: .
• ENDPOINT_NAME: o nome a apresentar do ponto final.

Método HTTP e URL:

GET https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints?filter=display_name=ENDPOINT_NAME

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

curl (Linux, macOS ou Cloud Shell)

Nota: O comando seguinte pressupõe que tem sessão iniciada na CLI gcloud com a sua conta de utilizador executando gcloud init ou gcloud auth login, ou usando o Cloud Shell, que inicia automaticamente sessão na CLI gcloud. Pode verificar a conta atualmente ativa executando o comando gcloud auth list.

Execute o seguinte comando:

curl -X GET \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints?filter=display_name=ENDPOINT_NAME"

PowerShell (Windows)

Nota: O comando seguinte pressupõe que iniciou sessão na CLI do Google Cloud com a sua conta de utilizador executando gcloud init ou gcloud auth login .gcloud Pode verificar a conta atualmente ativa executando o comando gcloud auth list.

Execute o seguinte comando:

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

Invoke-WebRequest `
    -Method GET `
    -Headers $headers `
    -Uri "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints?filter=display_name=ENDPOINT_NAME" | Select-Object -Expand Content

Deve receber uma resposta JSON semelhante à seguinte:

{
  "endpoints": [
    {
      "name": "projects/PROJECT_NUMBER/locations/LOCATION_ID/endpoints/ENDPOINT_ID",
      "displayName": "ENDPOINT_NAME",
      "etag": "AMEw9yPz5pf4PwBHbRWOGh0PcAxUdjbdX2Jm3QO_amguy3DbZGP5Oi_YUKRywIE-BtLx",
      "createTime": "2020-04-17T18:31:11.585169Z",
      "updateTime": "2020-04-17T18:35:08.568959Z"
    }
  ]
}

Tenha em atenção o ENDPOINT_ID.

Implemente o modelo

Selecione o separador abaixo para o seu idioma ou ambiente:

gcloud

Os exemplos seguintes usam o comando gcloud ai endpoints deploy-model.

O exemplo seguinte implementa um Model num Endpoint sem dividir o tráfego entre vários recursos DeployedModel:

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

• ENDPOINT_ID: o ID do ponto final.
• LOCATION_ID: a região onde está a usar o Vertex AI.
• MODEL_ID: o ID do modelo a implementar.
• DEPLOYED_MODEL_NAME: um nome para o DeployedModel. Também pode usar o nome a apresentar do Model para o DeployedModel.
• MIN_REPLICA_COUNT: o número mínimo de nós para esta implementação. O número de nós pode ser aumentado ou diminuído conforme necessário pela carga de inferência, até ao número máximo de nós e nunca inferior a este número de nós.
• MAX_REPLICA_COUNT: o número máximo de nós para esta implementação. O número de nós pode ser aumentado ou diminuído conforme necessário pela carga de inferência, até este número de nós e nunca inferior ao número mínimo de nós. Se omitir a flag --max-replica-count, o número máximo de nós é definido para o valor de --min-replica-count.

Execute o comando gcloud ai endpoints deploy-model:

Linux, macOS ou Cloud Shell

Nota: Certifique-se de que inicializou a CLI Google Cloud com autenticação e um projeto executando gcloud init; ou gcloud auth login e gcloud config set project.

gcloud ai endpoints deploy-model ENDPOINT_ID\
  --region=LOCATION_ID \
  --model=MODEL_ID \
  --display-name=DEPLOYED_MODEL_NAME \
  --min-replica-count=MIN_REPLICA_COUNT \
  --max-replica-count=MAX_REPLICA_COUNT \
  --traffic-split=0=100

Windows (PowerShell)

Nota: Certifique-se de que inicializou a CLI Google Cloud com autenticação e um projeto executando gcloud init; ou gcloud auth login e gcloud config set project.

gcloud ai endpoints deploy-model ENDPOINT_ID`
  --region=LOCATION_ID `
  --model=MODEL_ID `
  --display-name=DEPLOYED_MODEL_NAME `
  --min-replica-count=MIN_REPLICA_COUNT `
  --max-replica-count=MAX_REPLICA_COUNT `
  --traffic-split=0=100

Windows (cmd.exe)

Nota: Certifique-se de que inicializou a CLI Google Cloud com autenticação e um projeto executando gcloud init; ou gcloud auth login e gcloud config set project.

gcloud ai endpoints deploy-model ENDPOINT_ID^
  --region=LOCATION_ID ^
  --model=MODEL_ID ^
  --display-name=DEPLOYED_MODEL_NAME ^
  --min-replica-count=MIN_REPLICA_COUNT ^
  --max-replica-count=MAX_REPLICA_COUNT ^
  --traffic-split=0=100

 

Dividir tráfego

A flag --traffic-split=0=100 nos exemplos anteriores envia 100% do tráfego de previsão que o Endpoint recebe para o novo DeployedModel, que é representado pelo ID temporário 0. Se o seu Endpoint já tiver outros DeployedModel recursos, pode dividir o tráfego entre os novos DeployedModel e os antigos. Por exemplo, para enviar 20% do tráfego para a nova versão DeployedModel e 80% para uma versão mais antiga, execute o seguinte comando.

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

• OLD_DEPLOYED_MODEL_ID: o ID do DeployedModel existente.

Execute o comando gcloud ai endpoints deploy-model:

Linux, macOS ou Cloud Shell

Nota: Certifique-se de que inicializou a CLI Google Cloud com autenticação e um projeto executando gcloud init; ou gcloud auth login e gcloud config set project.

gcloud ai endpoints deploy-model ENDPOINT_ID\
  --region=LOCATION_ID \
  --model=MODEL_ID \
  --display-name=DEPLOYED_MODEL_NAME \ 
  --min-replica-count=MIN_REPLICA_COUNT \
  --max-replica-count=MAX_REPLICA_COUNT \
  --traffic-split=0=20,OLD_DEPLOYED_MODEL_ID=80

Windows (PowerShell)

Nota: Certifique-se de que inicializou a CLI Google Cloud com autenticação e um projeto executando gcloud init; ou gcloud auth login e gcloud config set project.

gcloud ai endpoints deploy-model ENDPOINT_ID`
  --region=LOCATION_ID `
  --model=MODEL_ID `
  --display-name=DEPLOYED_MODEL_NAME \ 
  --min-replica-count=MIN_REPLICA_COUNT `
  --max-replica-count=MAX_REPLICA_COUNT `
  --traffic-split=0=20,OLD_DEPLOYED_MODEL_ID=80

Windows (cmd.exe)

Nota: Certifique-se de que inicializou a CLI Google Cloud com autenticação e um projeto executando gcloud init; ou gcloud auth login e gcloud config set project.

gcloud ai endpoints deploy-model ENDPOINT_ID^
  --region=LOCATION_ID ^
  --model=MODEL_ID ^
  --display-name=DEPLOYED_MODEL_NAME \ 
  --min-replica-count=MIN_REPLICA_COUNT ^
  --max-replica-count=MAX_REPLICA_COUNT ^
  --traffic-split=0=20,OLD_DEPLOYED_MODEL_ID=80

 

REST

Implemente o modelo.

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

• LOCATION_ID: a região onde está a usar o Vertex AI.
• PROJECT_ID: .
• ENDPOINT_ID: o ID do ponto final.
• MODEL_ID: o ID do modelo a implementar.
• DEPLOYED_MODEL_NAME: um nome para o DeployedModel. Também pode usar o nome a apresentar do Model para o DeployedModel.
• MIN_REPLICA_COUNT: o número mínimo de nós para esta implementação. O número de nós pode ser aumentado ou diminuído conforme necessário pela carga de inferência, até ao número máximo de nós e nunca inferior a este número de nós.
• MAX_REPLICA_COUNT: o número máximo de nós para esta implementação. O número de nós pode ser aumentado ou diminuído conforme necessário pela carga de inferência, até este número de nós e nunca inferior ao número mínimo de nós.
• TRAFFIC_SPLIT_THIS_MODEL: A percentagem do tráfego de previsão para este ponto final a encaminhar para o modelo implementado com esta operação. A predefinição é 100. Todas as percentagens de tráfego têm de totalizar 100. Saiba mais acerca das divisões de tráfego.
• DEPLOYED_MODEL_ID_N: opcional. Se outros modelos forem implementados neste ponto final, tem de atualizar as respetivas percentagens de divisão de tráfego para que todas as percentagens totalizem 100.
• TRAFFIC_SPLIT_MODEL_N: o valor da percentagem da divisão de tráfego para a chave do ID do modelo implementado.
• PROJECT_NUMBER: o número do projeto gerado automaticamente do seu projeto

Método HTTP e URL:

POST https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints/ENDPOINT_ID:deployModel

Corpo JSON do pedido:

{
  "deployedModel": {
    "model": "projects/PROJECT_ID/locations/LOCATION_ID/models/MODEL_ID",
    "displayName": "DEPLOYED_MODEL_NAME",
    "automaticResources": {
       "minReplicaCount": MIN_REPLICA_COUNT,
       "maxReplicaCount": MAX_REPLICA_COUNT
     }
  },
  "trafficSplit": {
    "0": TRAFFIC_SPLIT_THIS_MODEL,
    "DEPLOYED_MODEL_ID_1": TRAFFIC_SPLIT_MODEL_1,
    "DEPLOYED_MODEL_ID_2": TRAFFIC_SPLIT_MODEL_2
  },
}

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

curl (Linux, macOS ou Cloud Shell)

Nota: O comando seguinte pressupõe que tem sessão iniciada na CLI gcloud com a sua conta de utilizador executando gcloud init ou gcloud auth login, ou usando o Cloud Shell, que inicia automaticamente sessão na CLI gcloud. Pode verificar a conta atualmente ativa executando o comando gcloud auth list.

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_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints/ENDPOINT_ID:deployModel"

PowerShell (Windows)

Nota: O comando seguinte pressupõe que iniciou sessão na CLI do Google Cloud com a sua conta de utilizador executando gcloud init ou gcloud auth login .gcloud Pode verificar a conta atualmente ativa executando o comando gcloud auth list.

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_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints/ENDPOINT_ID:deployModel" | Select-Object -Expand Content

Deve receber uma resposta JSON semelhante à seguinte:

{
  "name": "projects/PROJECT_ID/locations/LOCATION_ID/endpoints/ENDPOINT_ID/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.v1.DeployModelOperationMetadata",
    "genericMetadata": {
      "createTime": "2020-10-19T17:53:16.502088Z",
      "updateTime": "2020-10-19T17:53:16.502088Z"
    }
  }
}

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.api.gax.longrunning.OperationTimedPollAlgorithm;
import com.google.api.gax.retrying.RetrySettings;
import com.google.cloud.aiplatform.v1.AutomaticResources;
import com.google.cloud.aiplatform.v1.DedicatedResources;
import com.google.cloud.aiplatform.v1.DeployModelOperationMetadata;
import com.google.cloud.aiplatform.v1.DeployModelResponse;
import com.google.cloud.aiplatform.v1.DeployedModel;
import com.google.cloud.aiplatform.v1.EndpointName;
import com.google.cloud.aiplatform.v1.EndpointServiceClient;
import com.google.cloud.aiplatform.v1.EndpointServiceSettings;
import com.google.cloud.aiplatform.v1.MachineSpec;
import com.google.cloud.aiplatform.v1.ModelName;
import com.google.cloud.aiplatform.v1.stub.EndpointServiceStubSettings;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.threeten.bp.Duration;

public class DeployModelSample {

  public static void main(String[] args)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "YOUR_PROJECT_ID";
    String deployedModelDisplayName = "YOUR_DEPLOYED_MODEL_DISPLAY_NAME";
    String endpointId = "YOUR_ENDPOINT_NAME";
    String modelId = "YOUR_MODEL_ID";
    int timeout = 900;
    deployModelSample(project, deployedModelDisplayName, endpointId, modelId, timeout);
  }

  static void deployModelSample(
      String project,
      String deployedModelDisplayName,
      String endpointId,
      String modelId,
      int timeout)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {

    // Set long-running operations (LROs) timeout
    final OperationTimedPollAlgorithm operationTimedPollAlgorithm =
        OperationTimedPollAlgorithm.create(
            RetrySettings.newBuilder()
                .setInitialRetryDelay(Duration.ofMillis(5000L))
                .setRetryDelayMultiplier(1.5)
                .setMaxRetryDelay(Duration.ofMillis(45000L))
                .setInitialRpcTimeout(Duration.ZERO)
                .setRpcTimeoutMultiplier(1.0)
                .setMaxRpcTimeout(Duration.ZERO)
                .setTotalTimeout(Duration.ofSeconds(timeout))
                .build());

    EndpointServiceStubSettings.Builder endpointServiceStubSettingsBuilder =
        EndpointServiceStubSettings.newBuilder();
    endpointServiceStubSettingsBuilder
        .deployModelOperationSettings()
        .setPollingAlgorithm(operationTimedPollAlgorithm);
    EndpointServiceStubSettings endpointStubSettings = endpointServiceStubSettingsBuilder.build();
    EndpointServiceSettings endpointServiceSettings =
        EndpointServiceSettings.create(endpointStubSettings);
    endpointServiceSettings =
        endpointServiceSettings.toBuilder()
            .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 (EndpointServiceClient endpointServiceClient =
        EndpointServiceClient.create(endpointServiceSettings)) {
      String location = "us-central1";
      EndpointName endpointName = EndpointName.of(project, location, endpointId);
      // key '0' assigns traffic for the newly deployed model
      // Traffic percentage values must add up to 100
      // Leave dictionary empty if endpoint should not accept any traffic
      Map<String, Integer> trafficSplit = new HashMap<>();
      trafficSplit.put("0", 100);
      ModelName modelName = ModelName.of(project, location, modelId);
      AutomaticResources automaticResourcesInput =
          AutomaticResources.newBuilder().setMinReplicaCount(1).setMaxReplicaCount(1).build();
      DeployedModel deployedModelInput =
          DeployedModel.newBuilder()
              .setModel(modelName.toString())
              .setDisplayName(deployedModelDisplayName)
              .setAutomaticResources(automaticResourcesInput)
              .build();

      OperationFuture<DeployModelResponse, DeployModelOperationMetadata> deployModelResponseFuture =
          endpointServiceClient.deployModelAsync(endpointName, deployedModelInput, trafficSplit);
      System.out.format(
          "Operation name: %s\n", deployModelResponseFuture.getInitialFuture().get().getName());
      System.out.println("Waiting for operation to finish...");
      DeployModelResponse deployModelResponse = deployModelResponseFuture.get(20, TimeUnit.MINUTES);

      System.out.println("Deploy Model Response");
      DeployedModel deployedModel = deployModelResponse.getDeployedModel();
      System.out.println("\tDeployed Model");
      System.out.format("\t\tid: %s\n", deployedModel.getId());
      System.out.format("\t\tmodel: %s\n", deployedModel.getModel());
      System.out.format("\t\tDisplay Name: %s\n", deployedModel.getDisplayName());
      System.out.format("\t\tCreate Time: %s\n", deployedModel.getCreateTime());

      DedicatedResources dedicatedResources = deployedModel.getDedicatedResources();
      System.out.println("\t\tDedicated Resources");
      System.out.format("\t\t\tMin Replica Count: %s\n", dedicatedResources.getMinReplicaCount());

      MachineSpec machineSpec = dedicatedResources.getMachineSpec();
      System.out.println("\t\t\tMachine Spec");
      System.out.format("\t\t\t\tMachine Type: %s\n", machineSpec.getMachineType());
      System.out.format("\t\t\t\tAccelerator Type: %s\n", machineSpec.getAcceleratorType());
      System.out.format("\t\t\t\tAccelerator Count: %s\n", machineSpec.getAcceleratorCount());

      AutomaticResources automaticResources = deployedModel.getAutomaticResources();
      System.out.println("\t\tAutomatic Resources");
      System.out.format("\t\t\tMin Replica Count: %s\n", automaticResources.getMinReplicaCount());
      System.out.format("\t\t\tMax Replica Count: %s\n", automaticResources.getMaxReplicaCount());
    }
  }
}

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 modelId = "YOUR_MODEL_ID";
// const endpointId = 'YOUR_ENDPOINT_ID';
// const deployedModelDisplayName = 'YOUR_DEPLOYED_MODEL_DISPLAY_NAME';
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';

const modelName = `projects/${project}/locations/${location}/models/${modelId}`;
const endpoint = `projects/${project}/locations/${location}/endpoints/${endpointId}`;
// Imports the Google Cloud Endpoint Service Client library
const {EndpointServiceClient} = require('@google-cloud/aiplatform');

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

// Instantiates a client
const endpointServiceClient = new EndpointServiceClient(clientOptions);

async function deployModel() {
  // Configure the parent resource
  // key '0' assigns traffic for the newly deployed model
  // Traffic percentage values must add up to 100
  // Leave dictionary empty if endpoint should not accept any traffic
  const trafficSplit = {0: 100};
  const deployedModel = {
    // format: 'projects/{project}/locations/{location}/models/{model}'
    model: modelName,
    displayName: deployedModelDisplayName,
    automaticResources: {minReplicaCount: 1, maxReplicaCount: 1},
  };
  const request = {
    endpoint,
    deployedModel,
    trafficSplit,
  };

  // Get and print out a list of all the endpoints for this resource
  const [response] = await endpointServiceClient.deployModel(request);
  console.log(`Long running operation : ${response.name}`);

  // Wait for operation to complete
  await response.promise();
  const result = response.result;

  console.log('Deploy model response');
  const modelDeployed = result.deployedModel;
  console.log('\tDeployed model');
  if (!modelDeployed) {
    console.log('\t\tId : {}');
    console.log('\t\tModel : {}');
    console.log('\t\tDisplay name : {}');
    console.log('\t\tCreate time : {}');

    console.log('\t\tDedicated resources');
    console.log('\t\t\tMin replica count : {}');
    console.log('\t\t\tMachine spec {}');
    console.log('\t\t\t\tMachine type : {}');
    console.log('\t\t\t\tAccelerator type : {}');
    console.log('\t\t\t\tAccelerator count : {}');

    console.log('\t\tAutomatic resources');
    console.log('\t\t\tMin replica count : {}');
    console.log('\t\t\tMax replica count : {}');
  } else {
    console.log(`\t\tId : ${modelDeployed.id}`);
    console.log(`\t\tModel : ${modelDeployed.model}`);
    console.log(`\t\tDisplay name : ${modelDeployed.displayName}`);
    console.log(`\t\tCreate time : ${modelDeployed.createTime}`);

    const dedicatedResources = modelDeployed.dedicatedResources;
    console.log('\t\tDedicated resources');
    if (!dedicatedResources) {
      console.log('\t\t\tMin replica count : {}');
      console.log('\t\t\tMachine spec {}');
      console.log('\t\t\t\tMachine type : {}');
      console.log('\t\t\t\tAccelerator type : {}');
      console.log('\t\t\t\tAccelerator count : {}');
    } else {
      console.log(
        `\t\t\tMin replica count : \
          ${dedicatedResources.minReplicaCount}`
      );
      const machineSpec = dedicatedResources.machineSpec;
      console.log('\t\t\tMachine spec');
      console.log(`\t\t\t\tMachine type : ${machineSpec.machineType}`);
      console.log(
        `\t\t\t\tAccelerator type : ${machineSpec.acceleratorType}`
      );
      console.log(
        `\t\t\t\tAccelerator count : ${machineSpec.acceleratorCount}`
      );
    }

    const automaticResources = modelDeployed.automaticResources;
    console.log('\t\tAutomatic resources');
    if (!automaticResources) {
      console.log('\t\t\tMin replica count : {}');
      console.log('\t\t\tMax replica count : {}');
    } else {
      console.log(
        `\t\t\tMin replica count : \
          ${automaticResources.minReplicaCount}`
      );
      console.log(
        `\t\t\tMax replica count : \
          ${automaticResources.maxReplicaCount}`
      );
    }
  }
}
deployModel();

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.

def deploy_model_with_automatic_resources_sample(
    project,
    location,
    model_name: str,
    endpoint: Optional[aiplatform.Endpoint] = None,
    deployed_model_display_name: Optional[str] = None,
    traffic_percentage: Optional[int] = 0,
    traffic_split: Optional[Dict[str, int]] = None,
    min_replica_count: int = 1,
    max_replica_count: int = 1,
    metadata: Optional[Sequence[Tuple[str, str]]] = (),
    sync: bool = True,
):
    """
    model_name: A fully-qualified model resource name or model ID.
          Example: "projects/123/locations/us-central1/models/456" or
          "456" when project and location are initialized or passed.
    """

    aiplatform.init(project=project, location=location)

    model = aiplatform.Model(model_name=model_name)

    model.deploy(
        endpoint=endpoint,
        deployed_model_display_name=deployed_model_display_name,
        traffic_percentage=traffic_percentage,
        traffic_split=traffic_split,
        min_replica_count=min_replica_count,
        max_replica_count=max_replica_count,
        metadata=metadata,
        sync=sync,
    )

    model.wait()

    print(model.display_name)
    print(model.resource_name)
    return model

Saiba como alterar as definições predefinidas para o registo de inferências.

Obtenha o estado da operaçã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.

Faça uma inferência online com o modelo implementado

Para fazer uma inferência online, envie um ou mais itens de teste a um modelo para análise, e o modelo devolve resultados baseados no objetivo do modelo. Para mais informações sobre os resultados da inferência, consulte a página Interpretar resultados.

Consola

Use a Google Cloud consola para pedir uma inferência online. O seu modelo tem de ser implementado num ponto final.

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

   Aceda à página Modelos

2. Na lista de modelos, clique no nome do modelo a partir do qual quer pedir inferências.

3. Selecione o separador Implementar e testar.

4. Na secção Teste o seu modelo, adicione itens de teste para pedir uma inferência.

   Os modelos do AutoML para objetivos de imagem requerem que carregue uma imagem para pedir uma inferência.

   Para obter informações sobre a importância das funcionalidades locais, consulte o artigo Receba explicações.

   Após a conclusão da inferência, o Vertex AI devolve os resultados na consola.

API

Use a API Vertex AI para pedir uma inferência online. O seu modelo tem de ser implementado num ponto final.

Obtenha inferências em lote

Para fazer um pedido de inferência em lote, especifica uma origem de entrada e um formato de saída onde o Vertex AI armazena os resultados da inferência. As inferências em lote para o tipo de modelo de imagem do AutoML requerem um ficheiro JSON Lines de entrada e o nome de um contentor do Cloud Storage para armazenar a saída.

Nota: tem de selecionar localizações de entrada e saída que estejam na mesma região que o seu modelo. Se usar a API para criar inferências em lote, envie pedidos para um ponto final de serviço (como https://us-central1-aiplatform.googleapis.com) que esteja na mesma região que as localizações de entrada e saída.

Requisitos de dados de entrada

A entrada para pedidos em lote especifica os itens a enviar ao seu modelo para inferência. Para modelos de classificação de imagens, pode usar um ficheiro JSON Lines para especificar uma lista de imagens sobre as quais fazer inferências e, em seguida, armazenar o ficheiro JSON Lines num contentor do Cloud Storage. O exemplo seguinte mostra uma única linha num ficheiro JSON Lines de entrada:

{"content": "gs://sourcebucket/datasets/images/source_image.jpg", "mimeType": "image/jpeg"}

Peça uma inferência em lote

Para pedidos de inferência em lote, pode usar a Google Cloud consola ou a API Vertex AI. Consoante o número de itens introduzidos que enviou, uma tarefa de inferência em lote pode demorar algum tempo a ser concluída.

Google Cloud consola

Use a Google Cloud consola para pedir uma inferência em lote.

1. Na Google Cloud consola, na secção Vertex AI, aceda à página Previsões em lote.

   Aceda à página Previsões em lote

2. Clique em Criar para abrir a janela Nova previsão em lote e conclua os seguintes passos:

   1. Introduza um nome para a inferência em lote.
   2. Para Nome do modelo, selecione o nome do modelo a usar para esta inferência em lote.
   3. Para Caminho de origem, especifique a localização do Cloud Storage onde se encontra o ficheiro de entrada JSON Lines.
   4. Para o Caminho de destino, especifique uma localização do Cloud Storage onde os resultados da inferência em lote são armazenados. O formato de saída é determinado pelo objetivo do seu modelo. Os modelos do AutoML para objetivos de imagens geram ficheiros JSON Lines.

API

Use a API Vertex AI para enviar pedidos de inferência em lote.

REST

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

• LOCATION_ID: região onde o modelo é armazenado e a tarefa de inferência em lote é executada. Por exemplo, us-central1.
• PROJECT_ID:
• BATCH_JOB_NAME: nome a apresentar para a tarefa em lote
• MODEL_ID: o ID do modelo a usar para fazer inferências
• THRESHOLD_VALUE (opcional): o Vertex AI devolve apenas inferências com pontuações de confiança com, pelo menos, este valor. A predefinição é 0.0.
• MAX_PREDICTIONS (opcional): o Vertex AI devolve até este número de inferências, começando pelas inferências com as pontuações de confiança mais elevadas. A predefinição é 10.
• URI: URI do Cloud Storage onde se encontra o ficheiro JSON Lines de entrada.
• BUCKET: o seu contentor do Cloud Storage
• PROJECT_NUMBER: o número do projeto gerado automaticamente do seu projeto

Método HTTP e URL:

POST https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/batchPredictionJobs

Corpo JSON do pedido:

{
    "displayName": "BATCH_JOB_NAME",
    "model": "projects/PROJECT/locations/LOCATION/models/MODEL_ID",
    "modelParameters": {
      "confidenceThreshold": THRESHOLD_VALUE,
      "maxPredictions": MAX_PREDICTIONS
    },
    "inputConfig": {
        "instancesFormat": "jsonl",
        "gcsSource": {
            "uris": ["URI"],
        },
    },
    "outputConfig": {
        "predictionsFormat": "jsonl",
        "gcsDestination": {
            "outputUriPrefix": "OUTPUT_BUCKET",
        },
    },
}

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

curl

Nota: O comando seguinte pressupõe que tem sessão iniciada na CLI gcloud com a sua conta de utilizador executando gcloud init ou gcloud auth login, ou usando o Cloud Shell, que inicia automaticamente sessão na CLI gcloud. Pode verificar a conta atualmente ativa executando o comando gcloud auth list.

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_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/batchPredictionJobs"

PowerShell

Nota: O comando seguinte pressupõe que iniciou sessão na CLI do Google Cloud com a sua conta de utilizador executando gcloud init ou gcloud auth login .gcloud Pode verificar a conta atualmente ativa executando o comando gcloud auth list.

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_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/batchPredictionJobs" | Select-Object -Expand Content

Deve receber uma resposta JSON semelhante à seguinte:

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION_ID/batchPredictionJobs/BATCH_JOB_ID",
  "displayName": "BATCH_JOB_NAME",
  "model": "projects/PROJECT_ID/locations/LOCATION_ID/models/MODEL_ID",
  "inputConfig": {
    "instancesFormat": "jsonl",
    "gcsSource": {
      "uris": [
        "CONTENT"
      ]
    }
  },
  "outputConfig": {
    "predictionsFormat": "jsonl",
    "gcsDestination": {
      "outputUriPrefix": "BUCKET"
    }
  },
  "state": "JOB_STATE_PENDING",
  "createTime": "2020-05-30T02:58:44.341643Z",
  "updateTime": "2020-05-30T02:58:44.341643Z",
  "modelDisplayName": "MODEL_NAME",
  "modelObjective": "MODEL_OBJECTIVE"
}

Pode sondar o estado da tarefa em lote através do BATCH_JOB_ID até que a tarefa state seja JOB_STATE_SUCCEEDED.

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.

def create_batch_prediction_job_sample(
    project: str,
    location: str,
    model_resource_name: str,
    job_display_name: str,
    gcs_source: Union[str, Sequence[str]],
    gcs_destination: str,
    sync: bool = True,
):
    aiplatform.init(project=project, location=location)

    my_model = aiplatform.Model(model_resource_name)

    batch_prediction_job = my_model.batch_predict(
        job_display_name=job_display_name,
        gcs_source=gcs_source,
        gcs_destination_prefix=gcs_destination,
        sync=sync,
    )

    batch_prediction_job.wait()

    print(batch_prediction_job.display_name)
    print(batch_prediction_job.resource_name)
    print(batch_prediction_job.state)
    return batch_prediction_job

Obtenha resultados da inferência em lote

O Vertex AI envia o resultado da inferência em lote para o destino especificado.

Quando uma tarefa de inferência em lote está concluída, o resultado da inferência é armazenado no contentor do Cloud Storage que especificou no seu pedido.

Exemplo de resultados da inferência em lote

Segue-se um exemplo de resultados de inferência em lote de um modelo de classificação de imagens.

{
  "instance": {"content": "gs://bucket/image.jpg", "mimeType": "image/jpeg"},
  "prediction": {
    "ids": [1, 2],
    "displayNames": ["cat", "dog"],
    "confidences": [0.7, 0.5]
  }
}