Esta página foi traduzida pela API Cloud Translation.

Receba inferências e explicações online

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

Uma inferência online é um pedido síncrono, ao contrário de uma inferência em lote, que é um pedido assíncrono. Use inferências online quando fizer pedidos em resposta à entrada de aplicações ou noutras situações em que precise de inferências oportunas.

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.

Os tópicos abordados são:

Implemente um modelo num ponto final
Obtenha uma inferência online com o modelo implementado
Receba uma explicação online através do modelo implementado

Antes de começar

Antes de poder obter inferências online, tem primeiro de preparar um modelo de classificação ou regressão.

Implemente um modelo num ponto final

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

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

Aceda à página Modelos
Clique no nome do modelo que quer implementar para abrir a respetiva página de detalhes.
Selecione o separador 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.
Clique em Implementar no ponto final.
Na página Defina o seu ponto final, configure da seguinte forma:
1. Pode optar por implementar o modelo num novo ponto final ou num ponto final existente.
  - Para implementar o modelo num novo ponto final, selecione Criar novo ponto final e indique um nome para o novo ponto final.
  - Para implementar o modelo num ponto final existente, selecione Adicionar ao ponto final existente e selecione o ponto final na lista pendente.
  - Pode adicionar mais do que um modelo a um ponto final e pode adicionar um modelo a mais do que um ponto final. Saiba mais.
2. Clique em Continuar.
Na página Definições do modelo, 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. Se estiver a implementar o seu modelo num ponto final existente que tenha um ou mais modelos implementados, tem de atualizar a percentagem de divisão do tráfego para o modelo que está a implementar e os modelos já implementados, de modo que todas as percentagens totalizem 100%.
2. Introduza o número mínimo de nós de computação que quer fornecer para o seu modelo.
  
  Este é o número de nós disponíveis para este modelo em todos os momentos. São-lhe cobrados os nós usados, quer para processar a carga de inferência, quer para nós em espera (mínimo), mesmo sem tráfego de inferência. Consulte a página de preços.
3. Selecione o Tipo de máquina.
  
  Os recursos de máquina maiores aumentam o desempenho da inferência e os custos.
4. Saiba como alterar as definições predefinidas para o registo de inferências.
5. Clique em Continuar.
Na página Monitorização de modelos, clique em Continuar.
Na página Objetivos de monitorização, configure da seguinte forma:
1. Introduza a localização dos seus dados de preparação.
2. Introduza o nome da coluna de destino.
Clique em Implementar para implementar o modelo no ponto final.

API

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

Crie um ponto final, se necessário.
Obtenha o ID do ponto final.
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

Aceda ao 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)

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)

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 usar GPUs para acelerar a publicação de previsões e 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.
MACHINE_TYPE: opcional. Os recursos da máquina usados para cada nó desta implementação. A predefinição é n1-standard-2. Saiba mais sobre os tipos de máquinas.
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. Este valor tem de ser igual ou superior a 1. Se o sinalizador --min-replica-count for omitido, o valor predefinido é 1.
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

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

Windows (PowerShell)

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

Windows (cmd.exe)

gcloud ai endpoints deploy-model ENDPOINT_ID^
  --region=LOCATION_ID ^
  --model=MODEL_ID ^
  --display-name=DEPLOYED_MODEL_NAME ^
  --machine-type=MACHINE_TYPE ^
  --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

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

Windows (PowerShell)

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

Windows (cmd.exe)

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

REST

Usa o método endpoints.predict para pedir uma inferência online.

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.
MACHINE_TYPE: opcional. Os recursos da máquina usados para cada nó desta implementação. A predefinição é n1-standard-2. Saiba mais sobre os tipos de máquinas.
ACCELERATOR_TYPE: o tipo de acelerador a anexar à máquina. Opcional se ACCELERATOR_COUNT não for especificado ou for zero. Não recomendado para modelos do AutoML ou modelos preparados personalizados que estejam a usar imagens sem GPU. Saiba mais.
ACCELERATOR_COUNT: o número de aceleradores que cada réplica deve usar. Opcional. Deve ser zero ou não especificado para modelos AutoML ou modelos preparados personalizados que estão a usar imagens não GPU.
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. Este valor tem de ser igual ou superior a 1.
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.
REQUIRED_REPLICA_COUNT: opcional. O número necessário de nós para que esta implementação seja marcada como bem-sucedida. Tem de ser igual ou superior a 1 e inferior ou igual ao número mínimo de nós. Se não for especificado, o valor predefinido é o 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/locations/us-central1/models/MODEL_ID",
    "displayName": "DEPLOYED_MODEL_NAME",
    "dedicatedResources": {
       "machineSpec": {
         "machineType": "MACHINE_TYPE",
         "acceleratorType": "ACCELERATOR_TYPE",
         "acceleratorCount": "ACCELERATOR_COUNT"
       },
       "minReplicaCount": MIN_REPLICA_COUNT,
       "maxReplicaCount": MAX_REPLICA_COUNT,
       "requiredReplicaCount": REQUIRED_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)

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)

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/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

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.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 java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutionException;

public class DeployModelCustomTrainedModelSample {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "PROJECT";
    String endpointId = "ENDPOINT_ID";
    String modelName = "MODEL_NAME";
    String deployedModelDisplayName = "DEPLOYED_MODEL_DISPLAY_NAME";
    deployModelCustomTrainedModelSample(project, endpointId, modelName, deployedModelDisplayName);
  }

  static void deployModelCustomTrainedModelSample(
      String project, String endpointId, String model, String deployedModelDisplayName)
      throws IOException, ExecutionException, InterruptedException {
    EndpointServiceSettings settings =
        EndpointServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();
    String location = "us-central1";

    // 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 client = EndpointServiceClient.create(settings)) {
      MachineSpec machineSpec = MachineSpec.newBuilder().setMachineType("n1-standard-2").build();
      DedicatedResources dedicatedResources =
          DedicatedResources.newBuilder().setMinReplicaCount(1).setMachineSpec(machineSpec).build();

      String modelName = ModelName.of(project, location, model).toString();
      DeployedModel deployedModel =
          DeployedModel.newBuilder()
              .setModel(modelName)
              .setDisplayName(deployedModelDisplayName)
              // `dedicated_resources` must be used for non-AutoML models
              .setDedicatedResources(dedicatedResources)
              .build();
      // 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);
      EndpointName endpoint = EndpointName.of(project, location, endpointId);
      OperationFuture<DeployModelResponse, DeployModelOperationMetadata> response =
          client.deployModelAsync(endpoint, deployedModel, trafficSplit);

      // You can use OperationFuture.getInitialFuture to get a future representing the initial
      // response to the request, which contains information while the operation is in progress.
      System.out.format("Operation name: %s\n", response.getInitialFuture().get().getName());

      // OperationFuture.get() will block until the operation is finished.
      DeployModelResponse deployModelResponse = response.get();
      System.out.format("deployModelResponse: %s\n", deployModelResponse);
    }
  }
}

Python

def deploy_model_with_dedicated_resources_sample(
    project,
    location,
    model_name: str,
    machine_type: 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,
    accelerator_type: Optional[str] = None,
    accelerator_count: Optional[int] = None,
    explanation_metadata: Optional[explain.ExplanationMetadata] = None,
    explanation_parameters: Optional[explain.ExplanationParameters] = None,
    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)

    # The explanation_metadata and explanation_parameters should only be
    # provided for a custom trained model and not an AutoML model.
    model.deploy(
        endpoint=endpoint,
        deployed_model_display_name=deployed_model_display_name,
        traffic_percentage=traffic_percentage,
        traffic_split=traffic_split,
        machine_type=machine_type,
        min_replica_count=min_replica_count,
        max_replica_count=max_replica_count,
        accelerator_type=accelerator_type,
        accelerator_count=accelerator_count,
        explanation_metadata=explanation_metadata,
        explanation_parameters=explanation_parameters,
        metadata=metadata,
        sync=sync,
    )

    model.wait()

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

Node.js

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.

const automl = require('@google-cloud/automl');
const client = new automl.v1beta1.AutoMlClient();

/**
 * Demonstrates using the AutoML client to create a model.
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = '[PROJECT_ID]' e.g., "my-gcloud-project";
// const computeRegion = '[REGION_NAME]' e.g., "us-central1";
// const datasetId = '[DATASET_ID]' e.g., "TBL2246891593778855936";
// const tableId = '[TABLE_ID]' e.g., "1991013247762825216";
// const columnId = '[COLUMN_ID]' e.g., "773141392279994368";
// const modelName = '[MODEL_NAME]' e.g., "testModel";
// const trainBudget = '[TRAIN_BUDGET]' e.g., "1000",
// `Train budget in milli node hours`;

// A resource that represents Google Cloud Platform location.
const projectLocation = client.locationPath(projectId, computeRegion);

// Get the full path of the column.
const columnSpecId = client.columnSpecPath(
  projectId,
  computeRegion,
  datasetId,
  tableId,
  columnId
);

// Set target column to train the model.
const targetColumnSpec = {name: columnSpecId};

// Set tables model metadata.
const tablesModelMetadata = {
  targetColumnSpec: targetColumnSpec,
  trainBudgetMilliNodeHours: trainBudget,
};

// Set datasetId, model name and model metadata for the dataset.
const myModel = {
  datasetId: datasetId,
  displayName: modelName,
  tablesModelMetadata: tablesModelMetadata,
};

// Create a model with the model metadata in the region.
client
  .createModel({parent: projectLocation, model: myModel})
  .then(responses => {
    const initialApiResponse = responses[1];
    console.log(`Training operation name: ${initialApiResponse.name}`);
    console.log('Training started...');
  })
  .catch(err => {
    console.error(err);
  });

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.

Obtenha 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. O modelo devolve resultados baseados no objetivo do modelo. Use a Google Cloud consola ou a API Vertex AI para pedir uma inferência online.

Google Cloud consola

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

Aceda à página Modelos
Na lista de modelos, clique no nome do modelo a partir do qual quer pedir inferências.
Selecione o separador Implementar e testar.
Na secção Teste o seu modelo, adicione itens de teste para pedir uma inferência. Os dados de inferência de base são preenchidos automaticamente. Em alternativa, pode introduzir os seus próprios dados de inferência e clicar em Prever.

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

API: Classification

gcloud

Crie um ficheiro denominado request.json com o seguinte conteúdo:
```
      {
  "instances": [
    {
      PREDICTION_DATA_ROW
    }
  ]
}
    
```
Substitua o seguinte:
- PREDICTION_DATA_ROW: um objeto JSON com chaves como os nomes das funcionalidades e valores como os valores das funcionalidades correspondentes. Por exemplo, para um conjunto de dados com um número, uma matriz de strings e uma categoria, a linha de dados pode ter o seguinte aspeto:
```
"length":3.6,
"material":"cotton",
"tag_array": ["abc","def"]
```
  Tem de ser fornecido um valor para cada funcionalidade incluída na preparação. O formato dos dados usados para a previsão tem de corresponder ao formato usado para a preparação. Consulte o artigo Formato de dados para previsões para ver detalhes.
Execute o seguinte comando:
```
gcloud ai endpoints predict ENDPOINT_ID \
  --region=LOCATION_ID \
  --json-request=request.json
```
Substitua o seguinte:
- ENDPOINT_ID: o ID do ponto final.
- LOCATION_ID: a região onde está a usar o Vertex AI.

REST

Usa o método endpoints.predict para pedir uma inferência online.

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

LOCATION_ID: região onde o ponto final está localizado. Por exemplo, us-central1.
PROJECT_ID: o seu ID do projeto.
ENDPOINT_ID: o ID do ponto final.
PREDICTION_DATA_ROW: um objeto JSON com chaves como os nomes das funcionalidades e valores como os valores das funcionalidades correspondentes. Por exemplo, para um conjunto de dados com um número, uma matriz de strings e uma categoria, a linha de dados pode ter o seguinte aspeto:
```
"length":3.6,
"material":"cotton",
"tag_array": ["abc","def"]
```
Tem de ser fornecido um valor para cada funcionalidade incluída na preparação. O formato dos dados usados para a previsão tem de corresponder ao formato usado para a preparação. Consulte o artigo Formato de dados para previsões para ver detalhes.
DEPLOYED_MODEL_ID: saída pelo método predict e aceite como entrada pelo método explain. O ID do modelo usado para gerar a inferência. Se precisar de pedir explicações para uma inferência pedida anteriormente, e tiver mais do que um modelo implementado, pode usar este ID para garantir que as explicações são devolvidas para o mesmo modelo que forneceu a inferência anterior.

Método HTTP e URL:

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

Corpo JSON do pedido:

{
  "instances": [
    {
      PREDICTION_DATA_ROW
    }
  ]
}

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

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

Deve receber uma resposta JSON semelhante à seguinte:

   {
     "predictions": [
      {
         "scores": [
           0.96771615743637085,
           0.032283786684274673
         ],
         "classes": [
           "0",
           "1"
         ]
      }
     ]
     "deployedModelId": "2429510197"
   }

Java

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.cloud.aiplatform.util.ValueConverter;
import com.google.cloud.aiplatform.v1.EndpointName;
import com.google.cloud.aiplatform.v1.PredictResponse;
import com.google.cloud.aiplatform.v1.PredictionServiceClient;
import com.google.cloud.aiplatform.v1.PredictionServiceSettings;
import com.google.cloud.aiplatform.v1.schema.predict.prediction.TabularClassificationPredictionResult;
import com.google.protobuf.ListValue;
import com.google.protobuf.Value;
import com.google.protobuf.util.JsonFormat;
import java.io.IOException;
import java.util.List;

public class PredictTabularClassificationSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "YOUR_PROJECT_ID";
    String instance = "[{ “feature_column_a”: “value”, “feature_column_b”: “value”}]";
    String endpointId = "YOUR_ENDPOINT_ID";
    predictTabularClassification(instance, project, endpointId);
  }

  static void predictTabularClassification(String instance, String project, String endpointId)
      throws IOException {
    PredictionServicPredictionServiceSettingsceSettings =
        PredictionServicPredictionServiceSettings          .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 (PredictionServicPredictionServiceClientceClient =
        PredictionServicPredictionServiceClientonServiceSettings)) {
      String location = "us-central1";
      EndpointName endEndpointNameEndpointName.of(EndpointNameation, endpointId);

      ListValue.BuildeListValueue = ListValue.newBuiListValue     JsonFormat.parseJsonFormatinstance, listValue);
      List<Value> instanListValuelistValue.getValuesList();

      Value parametersValuelue.newBuilderValuetListValue(listValue).build();
      PredictResponse PredictResponse =
          predictionServiceClient.predict(endpointName, instanceList, parameters);
      System.out.println("Predict Tabular Classification Response");
      System.out.format("\tDeployed Model Id: %s\n", predictResponse.predictResponse.getDeployedModelId().out.println("Predictions");
      for (Value predictionValueedictResponse.predictResponse.getPredictionsList()larClassificTabularClassificationPredictionResultuilder =
            TabularClassificTabularClassificationPredictionResult       TabularClassificTabularClassificationPredictionResult      (TabularClassificTabularClassificationPredictionResult  ValueConverter.fValueConvertertBuilder, prediction);

        for (int i = 0; i < result.getClasseresult.getClassesCount()   System.out.printf("\tClass: %s", result.getClasseresult.getClasses(i)tem.out.printf("\tScore: %f", result.getScoresresult.getScores(i)   }
    }
  }
}

Node.js

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 endpointId = 'YOUR_ENDPOINT_ID';
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';
const aiplatform = require('@google-cloud/aiplatform');
const {prediction} =
  aiplatform.protos.google.cloud.aiplatform.v1.schema.predict;

// Imports the Google Cloud Prediction service client
const {PredictionServiceClient} = aiplatform.v1;

// Import the helper module for converting arbitrary protobuf.Value objects.
const {helpers} = aiplatform;

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

// Instantiates a client
const predictionServiceClient = new PredictionServiceClient(clientOptions);

async function predictTablesClassification() {
  // Configure the endpoint resource
  const endpoint = `projects/${project}/locations/${location}/endpoints/${endpointId}`;
  const parameters = helpers.toValue({});

  const instance = helpers.toValue({
    petal_length: '1.4',
    petal_width: '1.3',
    sepal_length: '5.1',
    sepal_width: '2.8',
  });

  const instances = [instance];
  const request = {
    endpoint,
    instances,
    parameters,
  };

  // Predict request
  const [response] = await predictionServiceClient.predict(request);

  console.log('Predict tabular classification response');
  console.log(`\tDeployed model id : ${response.deployedModelId}\n`);
  const predictions = response.predictions;
  console.log('Predictions :');
  for (const predictionResultVal of predictions) {
    const predictionResultObj =
      prediction.TabularClassificationPredictionResult.fromValue(
        predictionResultVal
      );
    for (const [i, class_] of predictionResultObj.classes.entries()) {
      console.log(`\tClass: ${class_}`);
      console.log(`\tScore: ${predictionResultObj.scores[i]}\n\n`);
    }
  }
}
predictTablesClassification();

Python

def predict_tabular_classification_sample(
    project: str,
    location: str,
    endpoint_name: str,
    instances: List[Dict],
):
    """
    Args
        project: Your project ID or project number.
        location: Region where Endpoint is located. For example, 'us-central1'.
        endpoint_name: A fully qualified endpoint name or endpoint ID. Example: "projects/123/locations/us-central1/endpoints/456" or
               "456" when project and location are initialized or passed.
        instances: A list of one or more instances (examples) to return a prediction for.
    """
    aiplatform.init(project=project, location=location)

    endpoint = aiplatform.Endpoint(endpoint_name)

    response = endpoint.predict(instances=instances)

    for prediction_ in response.predictions:
        print(prediction_)

API: regressão

gcloud

Crie um ficheiro denominado `request.json` com o seguinte conteúdo:
```
      {
  "instances": [
    {
      PREDICTION_DATA_ROW
    }
  ]
}
    
```
Substitua o seguinte:
- PREDICTION_DATA_ROW: um objeto JSON com chaves como os nomes das funcionalidades e valores como os valores das funcionalidades correspondentes. Por exemplo, para um conjunto de dados com um número, uma matriz de números e uma categoria, a linha de dados pode ter o seguinte aspeto:
```
"age":3.6,
"sq_ft":5392,
"code": "90331"
```
  Tem de ser fornecido um valor para cada funcionalidade incluída na preparação. O formato dos dados usados para a previsão tem de corresponder ao formato usado para a preparação. Consulte o artigo Formato de dados para previsões para ver detalhes.
Execute o seguinte comando:
```
gcloud ai endpoints predict ENDPOINT_ID \
  --region=LOCATION_ID \
  --json-request=request.json
```
Substitua o seguinte:
- ENDPOINT_ID: o ID do ponto final.
- LOCATION_ID: a região onde está a usar o Vertex AI.

REST

Usa o método endpoints.predict para pedir uma inferência online.

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

LOCATION_ID: região onde o ponto final está localizado. Por exemplo, us-central1.
PROJECT_ID: .
ENDPOINT_ID: o ID do ponto final.
PREDICTION_DATA_ROW: um objeto JSON com chaves como os nomes das funcionalidades e valores como os valores das funcionalidades correspondentes. Por exemplo, para um conjunto de dados com um número, uma matriz de números e uma categoria, a linha de dados pode ter o seguinte aspeto:
```
"age":3.6,
"sq_ft":5392,
"code": "90331"
```
Tem de ser fornecido um valor para cada funcionalidade incluída na preparação. O formato dos dados usados para a previsão tem de corresponder ao formato usado para a preparação. Consulte o artigo Formato de dados para previsões para ver detalhes.
DEPLOYED_MODEL_ID: saída pelo método predict e aceite como entrada pelo método explain. O ID do modelo usado para gerar a inferência. Se precisar de pedir explicações para uma inferência pedida anteriormente, e tiver mais do que um modelo implementado, pode usar este ID para garantir que as explicações são devolvidas para o mesmo modelo que forneceu a inferência anterior.

Método HTTP e URL:

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

Corpo JSON do pedido:

{
  "instances": [
    {
      PREDICTION_DATA_ROW
    }
  ]
}

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

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

Deve receber uma resposta JSON semelhante à seguinte:


{
  "predictions": [
    [
      {
        "value": 65.14233
      }
    ]
  ],
  "deployedModelId": "DEPLOYED_MODEL_ID"
}

Java

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.cloud.aiplatform.util.ValueConverter;
import com.google.cloud.aiplatform.v1.EndpointName;
import com.google.cloud.aiplatform.v1.PredictResponse;
import com.google.cloud.aiplatform.v1.PredictionServiceClient;
import com.google.cloud.aiplatform.v1.PredictionServiceSettings;
import com.google.cloud.aiplatform.v1.schema.predict.prediction.TabularRegressionPredictionResult;
import com.google.protobuf.ListValue;
import com.google.protobuf.Value;
import com.google.protobuf.util.JsonFormat;
import java.io.IOException;
import java.util.List;

public class PredictTabularRegressionSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "YOUR_PROJECT_ID";
    String instance = "[{ “feature_column_a”: “value”, “feature_column_b”: “value”}]";
    String endpointId = "YOUR_ENDPOINT_ID";
    predictTabularRegression(instance, project, endpointId);
  }

  static void predictTabularRegression(String instance, String project, String endpointId)
      throws IOException {
    PredictionServicPredictionServiceSettingsceSettings =
        PredictionServicPredictionServiceSettings          .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 (PredictionServicPredictionServiceClientceClient =
        PredictionServicPredictionServiceClientonServiceSettings)) {
      String location = "us-central1";
      EndpointName endEndpointNameEndpointName.of(EndpointNameation, endpointId);

      ListValue.BuildeListValueue = ListValue.newBuiListValue     JsonFormat.parseJsonFormatinstance, listValue);
      List<Value> instanListValuelistValue.getValuesList();

      Value parametersValuelue.newBuilderValuetListValue(listValue).build();
      PredictResponse PredictResponse =
          predictionServiceClient.predict(endpointName, instanceList, parameters);
      System.out.println("Predict Tabular Regression Response");
      System.out.format("\tDisplay Model Id: %s\n", predictResponse.predictResponse.getDeployedModelId().out.println("Predictions");
      for (Value predictionValueedictResponse.predictResponse.getPredictionsList()larRegressioTabularRegressionPredictionResultuilder =
            TabularRegressioTabularRegressionPredictionResult        TabularRegressioTabularRegressionPredictionResult      (TabularRegressioTabularRegressionPredictionResult.fValueConvertertBuilder, prediction);

        System.out.printf("\tUpper bound: %f\n", result.getUpperBresult.getUpperBound()m.out.printf("\tLower bound: %f\n", result.getLowerBresult.getLowerBound()m.out.printf("\tValue: %f\n", result.getValue(result.getValue()
  }
}

Node.js

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 endpointId = 'YOUR_ENDPOINT_ID';
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';
const aiplatform = require('@google-cloud/aiplatform');
const {prediction} =
  aiplatform.protos.google.cloud.aiplatform.v1.schema.predict;

// Imports the Google Cloud Prediction service client
const {PredictionServiceClient} = aiplatform.v1;

// Import the helper module for converting arbitrary protobuf.Value objects.
const {helpers} = aiplatform;

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

// Instantiates a client
const predictionServiceClient = new PredictionServiceClient(clientOptions);

async function predictTablesRegression() {
  // Configure the endpoint resource
  const endpoint = `projects/${project}/locations/${location}/endpoints/${endpointId}`;
  const parameters = helpers.toValue({});

  // TODO (erschmid): Make this less painful
  const instance = helpers.toValue({
    BOOLEAN_2unique_NULLABLE: false,
    DATETIME_1unique_NULLABLE: '2019-01-01 00:00:00',
    DATE_1unique_NULLABLE: '2019-01-01',
    FLOAT_5000unique_NULLABLE: 1611,
    FLOAT_5000unique_REPEATED: [2320, 1192],
    INTEGER_5000unique_NULLABLE: '8',
    NUMERIC_5000unique_NULLABLE: 16,
    STRING_5000unique_NULLABLE: 'str-2',
    STRUCT_NULLABLE: {
      BOOLEAN_2unique_NULLABLE: false,
      DATE_1unique_NULLABLE: '2019-01-01',
      DATETIME_1unique_NULLABLE: '2019-01-01 00:00:00',
      FLOAT_5000unique_NULLABLE: 1308,
      FLOAT_5000unique_REPEATED: [2323, 1178],
      FLOAT_5000unique_REQUIRED: 3089,
      INTEGER_5000unique_NULLABLE: '1777',
      NUMERIC_5000unique_NULLABLE: 3323,
      TIME_1unique_NULLABLE: '23:59:59.999999',
      STRING_5000unique_NULLABLE: 'str-49',
      TIMESTAMP_1unique_NULLABLE: '1546387199999999',
    },
    TIMESTAMP_1unique_NULLABLE: '1546387199999999',
    TIME_1unique_NULLABLE: '23:59:59.999999',
  });

  const instances = [instance];
  const request = {
    endpoint,
    instances,
    parameters,
  };

  // Predict request
  const [response] = await predictionServiceClient.predict(request);

  console.log('Predict tabular regression response');
  console.log(`\tDeployed model id : ${response.deployedModelId}`);
  const predictions = response.predictions;
  console.log('\tPredictions :');
  for (const predictionResultVal of predictions) {
    const predictionResultObj =
      prediction.TabularRegressionPredictionResult.fromValue(
        predictionResultVal
      );
    console.log(`\tUpper bound: ${predictionResultObj.upper_bound}`);
    console.log(`\tLower bound: ${predictionResultObj.lower_bound}`);
    console.log(`\tLower bound: ${predictionResultObj.value}`);
  }
}
predictTablesRegression();

Python

def predict_tabular_regression_sample(
    project: str,
    location: str,
    endpoint_name: str,
    instances: List[Dict],
):
    aiplatform.init(project=project, location=location)

    endpoint = aiplatform.Endpoint(endpoint_name)

    response = endpoint.predict(instances=instances)

    for prediction_ in response.predictions:
        print(prediction_)

Interprete os resultados da previsão

Classificação

Os modelos de classificação devolvem uma pontuação de confiança.

A pontuação de confiança comunica a intensidade com que o modelo associa cada classe ou etiqueta a um item de teste. Quanto mais elevado for o número, maior é a confiança do modelo de que a etiqueta deve ser aplicada a esse item. Decide qual o nível de confiança que a pontuação tem de ter para aceitar os resultados do modelo.

Regressão

Os modelos de regressão devolvem um valor de inferência.

Se o seu modelo usar a inferência probabilística, o campo value contém o minimizador do objetivo de otimização. Por exemplo, se o objetivo de otimização for minimize-rmse, o campo value contém o valor médio. Se for minimize-mae, o campo value contém o valor mediano.

Se o seu modelo usar inferência probabilística com quantis, o Vertex AI fornece valores de quantis e inferências, além do minimizador do objetivo de otimização. Os valores dos quantis são definidos durante a preparação do modelo. As inferências de quantil são os valores de inferência associados aos valores de quantil.

Obtenha uma explicação online com o modelo implementado

Pode pedir uma inferência com explicações (também denominadas atribuições de funcionalidades) para ver como o modelo chegou a uma inferência. Os valores de importância das funcionalidades locais indicam a contribuição de cada funcionalidade para o resultado da inferência. As atribuições de funcionalidades estão incluídas nas inferências do Vertex AI através do Vertex Explainable AI.

Consola

Quando usa a Google Cloud consola para pedir uma inferência online, os valores de importância das funcionalidades locais são devolvidos automaticamente.

Se usou os valores de previsão pré-preenchidos, os valores de importância das caraterísticas locais são todos zero. Isto deve-se ao facto de os valores pré-preenchidos serem os dados de previsão de base, pelo que a previsão devolvida é o valor de previsão de base.

gcloud

Crie um ficheiro denominado request.json com o seguinte conteúdo:
```
{
  "instances": [
    {
      PREDICTION_DATA_ROW
    }
  ]
}
```
Substitua o seguinte:
- PREDICTION_DATA_ROW: um objeto JSON com chaves como os nomes das funcionalidades e valores como os valores das funcionalidades correspondentes. Por exemplo, para um conjunto de dados com um número, uma matriz de strings e uma categoria, a linha de dados pode ter o seguinte aspeto:
```
"length":3.6,
"material":"cotton",
"tag_array": ["abc","def"]
```
  Tem de ser fornecido um valor para cada funcionalidade incluída na preparação. O formato dos dados usados para a previsão tem de corresponder ao formato usado para a preparação. Consulte o artigo Formato de dados para previsões para ver detalhes.
Execute o seguinte comando:
```
gcloud ai endpoints explain ENDPOINT_ID \
  --region=LOCATION_ID \
  --json-request=request.json
```
Substitua o seguinte:
- ENDPOINT_ID: o ID do ponto final.
- LOCATION_ID: a região onde está a usar o Vertex AI.
Opcionalmente, se quiser enviar um pedido de explicação a um DeployedModel específico no Endpoint, pode especificar a flag --deployed-model-id:
```
gcloud ai endpoints explain ENDPOINT_ID \
  --region=LOCATION \
  --deployed-model-id=DEPLOYED_MODEL_ID \
  --json-request=request.json
```
Além dos marcadores de posição descritos anteriormente, substitua o seguinte:
- DEPLOYED_MODEL_ID Opcional: o ID do modelo implementado para o qual quer obter explicações. O ID está incluído na resposta do método predict. Se precisar de pedir explicações para um modelo específico e tiver mais do que um modelo implementado no mesmo ponto final, pode usar este ID para garantir que as explicações são devolvidas para esse modelo específico.

REST

O exemplo seguinte mostra um pedido de inferência online para um modelo de classificação tabular com atribuições de caraterísticas locais. O formato do pedido é o mesmo para os modelos de regressão.

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

LOCATION: região onde o ponto final está localizado. Por exemplo, us-central1.
PROJECT: .
ENDPOINT_ID: o ID do ponto final.
PREDICTION_DATA_ROW: um objeto JSON com chaves como os nomes das funcionalidades e valores como os valores das funcionalidades correspondentes. Por exemplo, para um conjunto de dados com um número, uma matriz de strings e uma categoria, a linha de dados pode ter o seguinte aspeto:
```
"length":3.6,
"material":"cotton",
"tag_array": ["abc","def"]
```
Tem de ser fornecido um valor para cada funcionalidade incluída na preparação. O formato dos dados usados para a previsão tem de corresponder ao formato usado para a preparação. Consulte o artigo Formato de dados para previsões para ver detalhes.
DEPLOYED_MODEL_ID (opcional): o ID do modelo implementado para o qual quer obter explicações. O ID está incluído na resposta do método predict. Se precisar de pedir explicações para um modelo específico e tiver mais do que um modelo implementado no mesmo ponto final, pode usar este ID para garantir que as explicações são devolvidas para esse modelo específico.

Método HTTP e URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/endpoints/ENDPOINT_ID:explain

Corpo JSON do pedido:

{
  "instances": [
    {
      PREDICTION_DATA_ROW
    }
  ],
  "deployedModelId": "DEPLOYED_MODEL_ID"
}

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/endpoints/ENDPOINT_ID:explain"

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/endpoints/ENDPOINT_ID:explain" | Select-Object -Expand Content

Python

def explain_sample(project: str, location: str, endpoint_id: str, instance_dict: Dict):

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

    endpoint = aiplatform.Endpoint(endpoint_id)

    response = endpoint.explain(instances=[instance_dict], parameters={})

    for explanation in response.explanations:
        print(" explanation")
        # Feature attributions.
        attributions = explanation.attributions
        for attribution in attributions:
            print("  attribution")
            print("   baseline_output_value:", attribution.baseline_output_value)
            print("   instance_output_value:", attribution.instance_output_value)
            print("   output_display_name:", attribution.output_display_name)
            print("   approximation_error:", attribution.approximation_error)
            print("   output_name:", attribution.output_name)
            output_index = attribution.output_index
            for output_index in output_index:
                print("   output_index:", output_index)

    for prediction in response.predictions:
        print(prediction)

Receba explicações para uma previsão devolvida anteriormente

Uma vez que as explicações aumentam a utilização de recursos, é recomendável reservar o pedido de explicações para situações em que as necessita especificamente. Por vezes, pode ser útil pedir explicações para um resultado de inferência que já recebeu, talvez porque a inferência foi um valor atípico ou não fez sentido.

Se todas as suas inferências provêm do mesmo modelo, pode simplesmente reenviar os dados do pedido, com as explicações pedidas desta vez. No entanto, se tiver vários modelos a devolver inferências, tem de se certificar de que envia o pedido de explicação para o modelo correto. Pode ver explicações para um modelo específico incluindo o ID do modelo implementado deployedModelID no seu pedido, que está incluído na resposta do pedido de inferência original. Tenha em atenção que o ID do modelo implementado é diferente do ID do modelo.

Interprete os resultados da explicação

Para calcular a importância das caraterísticas locais, primeiro é calculado o resultado da inferência de base. Os valores de base são calculados a partir dos dados de preparação, usando o valor mediano para caraterísticas numéricas e o modo para caraterísticas categóricas. A inferência gerada a partir dos valores de referência é a pontuação de inferência de referência. Os valores de base são calculados uma vez para um modelo e não mudam.

Para uma inferência específica, a importância da caraterística local para cada caraterística indica o quanto essa caraterística adicionou ou subtraiu ao resultado em comparação com a pontuação de inferência de referência. A soma de todos os valores de importância das funcionalidades é igual à diferença entre a pontuação de inferência de referência e o resultado da inferência.

Para modelos de classificação, a pontuação está sempre entre 0,0 e 1,0, inclusive. Por conseguinte, os valores de importância das caraterísticas locais para modelos de classificação estão sempre entre -1,0 e 1,0 (inclusive).

Para ver exemplos de consultas de atribuição de funcionalidades e saber mais, consulte o artigo Atribuições de funcionalidades para classificação e regressão.

Exemplo de saída para inferências e explicações

Classificação

O payload de retorno para uma inferência online de um modelo de classificação tabular com importância das caraterísticas é semelhante ao exemplo seguinte.

O instanceOutputValue de 0.928652400970459 é a pontuação de confiança da classe com a pontuação mais alta, neste caso, class_a. O campo baselineOutputValue contém a pontuação de inferência de base, 0.808652400970459. A funcionalidade que mais contribuiu para este resultado foi feature_3.

{
"predictions": [
  {
    "scores": [
      0.928652400970459,
      0.071347599029541
    ],
    "classes": [
      "class_a",
      "class_b"
    ]
  }
]
"explanations": [
  {
    "attributions": [
      {
        "baselineOutputValue": 0.808652400970459,
        "instanceOutputValue": 0.928652400970459,
        "approximationError":  0.0058915703929231,
        "featureAttributions": {
          "feature_1": 0.012394922231235,
          "feature_2": 0.050212341234556,
          "feature_3": 0.057392736534209,
        },
        "outputIndex": [
          0
        ],
        "outputName": "scores"
      }
    ],
  }
]
"deployedModelId": "234567"
}

Regressão

O payload de retorno para uma inferência online com importância das funcionalidades de um modelo de regressão tabular é semelhante ao seguinte exemplo.

O instanceOutputValue de 1795.1246466281819 é o valor previsto. O campo baselineOutputValue contém a pontuação de inferência de base, 1788.7423095703125. A funcionalidade que mais contribuiu para este resultado foi feature_3.

{
"predictions": [
  {
    "value": 1795.1246466281819
  }
]
"explanations": [
  {
    "attributions": [
      {
        "baselineOutputValue": 1788.7423095703125,
        "instanceOutputValue": 1795.1246466281819,
        "approximationError": 0.0038215703911553,
        "featureAttributions": {
          "feature_1": 0.123949222312359,
          "feature_2": 0.802123412345569,
          "feature_3": 5.456264423211472,
        },
        "outputIndex": [
          -1
        ]
      }
    ]
  }
],
"deployedModelId": "345678"
}

O que se segue?

Saiba como exportar o seu modelo.
Saiba mais acerca dos preços para inferências online.

Receba inferências e explicações online Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Antes de começar

Implemente um modelo num ponto final

Google Cloud consola

API

Crie um ponto final

gcloud

REST

curl (Linux, macOS ou Cloud Shell)

PowerShell (Windows)

Java

Node.js

Python

Aceda ao ID do ponto final

gcloud

REST

curl (Linux, macOS ou Cloud Shell)

PowerShell (Windows)

Implemente o modelo

gcloud

Linux, macOS ou Cloud Shell

Windows (PowerShell)

Windows (cmd.exe)

Dividir tráfego

Linux, macOS ou Cloud Shell

Windows (PowerShell)

Windows (cmd.exe)

REST

curl (Linux, macOS ou Cloud Shell)

PowerShell (Windows)

Java

Python

Node.js

Obtenha o estado da operação

Obtenha uma inferência online com o modelo implementado

Google Cloud consola

API: Classification

gcloud

REST

curl

PowerShell

Java

Node.js

Python

API: regressão

gcloud

REST

curl

PowerShell

Java

Node.js

Python

Interprete os resultados da previsão

Classificação

Regressão

Obtenha uma explicação online com o modelo implementado

Consola

gcloud

REST

curl

PowerShell

Python

Interprete os resultados da explicação

Exemplo de saída para inferências e explicações

Classificação

Regressão

O que se segue?

Receba inferências e explicações online