Implantar um modelo em um endpoint

Implante um modelo em um endpoint antes de ele ser usado para exibir previsões on-line. A implantação de um modelo associa recursos físicos ao modelo para que ele possa exibir previsões on-line com baixa latência.

Para ser implantado, o modelo precisa estar visível no Vertex AI Model Registry. Para saber mais sobre o Model Registry, incluindo como importar artefatos de modelo ou criá-los diretamente no Model Registry, consulte Introdução ao Vertex AI Model Registry.

É possível implantar vários modelos em um endpoint ou o mesmo modelo em vários endpoints. Para mais informações sobre opções e casos de uso para implantar modelos, consulte Motivos para implantar mais de um modelo no mesmo endpoint.

Implantar um modelo em um endpoint

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

Console do Google Cloud

  1. No Console do Google Cloud, na seção da Vertex AI, acesse a página de Modelos.

    Acessar a página de modelos

  2. Clique no nome e no código da versão do modelo que você quer implantar para abrir a página de detalhes.

  3. Selecione a guia Implantar e testar.

    Caso seu modelo já esteja implantado em um endpoint, o endpoint estará listado na seção Implantar seu modelo.

  4. Clique em Implantar no endpoint.

  5. Para implantar o modelo em um novo endpoint, selecione Criar novo endpoint e dê um nome a ele. Para implantar o modelo em um endpoint atual, selecione Adicionar a um endpoint atual e escolha o endpoint na lista suspensa.

    É possível implantar vários modelos em um endpoint ou implantar o mesmo modelo em vários endpoints.

  6. Se você implantar o modelo em um endpoint atual que tem um ou mais modelos implantados, é necessário atualizar a porcentagem de divisão de tráfego do modelo que você está implantando, bem como a dos modelos já implantados para que todas as porcentagens totalizem 100%.

  7. Se você estiver implantando seu modelo em um novo endpoint, aceite 100 para a divisão de tráfego. Caso contrário, ajuste os valores de divisão de tráfego para todos os modelos no endpoint para que totalizem 100.

  8. Insira o número mínimo de nós de computação que você quer fornecer ao modelo.

    Esse é o número de nós que precisam estar disponíveis para o modelo o tempo todo.

    Você é cobrado pelos nós usados, seja para processar a carga de previsão ou por nós de espera (mínimo), mesmo sem tráfego de previsão. Consulte a página de preços.

    O número de nós de computação pode aumentar se for necessário para processar o tráfego de previsão, mas nunca ultrapassa o número máximo de nós.

  9. Para usar o escalonamento automático, insira o número máximo de nós de computação que você quer que a Vertex AI escalone verticalmente.

  10. Selecione o Tipo de máquina.

    Recursos maiores de máquina aumentarão o desempenho da previsão e os custos. Compare os tipos de máquina disponíveis.

  11. Selecione um Tipo de acelerador e uma Contagem de aceleradores.

    Se você ativou o uso do acelerador ao importar ou criar o modelo, essa opção será exibida.

    Para ver a contagem de aceleradores, consulte a tabela de GPUs para verificar se há números válidos de GPUs que você pode usar com cada tipo de máquina de CPU. A contagem de aceleradores se refere ao número de aceleradores por nó, e não ao número total de aceleradores na sua implantação.

  12. Se você quiser usar uma conta de serviço personalizada na implantação, selecione uma conta de serviço no menu suspenso Conta de serviço.

  13. Saiba como alterar as configurações padrão para a geração de registros de previsão.

  14. Clique em Concluído no modelo. Quando todas as porcentagens de Divisão de tráfego estiverem corretas, clique em Continuar.

    A região onde seu modelo é implantado é exibida. Precisa ser a região em que você criou o modelo.

  15. Clique em Implantar para implantar o modelo no endpoint.

API

Ao implantar um modelo usando a API Vertex AI, siga estas etapas:

  1. Create um endpoint, se necessário.
  2. Get o ID do endpoint.
  3. Deploy o modelo para o endpoint.

Crie um endpoint

Se você estiver implantando um modelo em um endpoint existente, pule esta etapa e acesse Pegar o ID do endpoint. Para testar a visualização do endpoint dedicado, pule para Criar um endpoint dedicado.

gcloud

O exemplo a seguir usa o comando gcloud ai endpoints create:

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

Substitua:

  • LOCATION_ID: a região em que você está usando a Vertex AI.
  • ENDPOINT_NAME: o nome de exibição do endpoint.

A ferramenta CLI do Google Cloud pode levar alguns segundos para criar o endpoint.

REST

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • LOCATION_ID: sua região.
  • PROJECT_ID: o ID do projeto.
  • ENDPOINT_NAME: o nome de exibição do endpoint.

Método HTTP e URL: 

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

Corpo JSON da solicitação:

{
  "display_name": "ENDPOINT_NAME"
}

Para enviar a solicitação, expanda uma destas opções:

Você receberá uma resposta JSON semelhante a esta:

{
  "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"
    }
  }
}
Pesquise o status da operação até que a resposta inclua "done": true.

Terraform

O exemplo a seguir usa o recurso google_vertex_ai_endpoint do Terraform para criar um endpoint.

Para saber como aplicar ou remover uma configuração do Terraform, consulte Comandos básicos do Terraform.

# Endpoint name must be unique for the project
resource "random_id" "endpoint_id" {
  byte_length = 4
}

resource "google_vertex_ai_endpoint" "default" {
  name         = substr(random_id.endpoint_id.dec, 0, 10)
  display_name = "sample-endpoint"
  description  = "A sample Vertex AI endpoint"
  location     = "us-central1"
  labels = {
    label-one = "value-one"
  }
}

Java

Antes de testar esse exemplo, siga as instruções de configuração para Java no Guia de início rápido da Vertex AI sobre como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para Java.

Para autenticar na Vertex AI, configure o Application Default Credentials. Para mais informações, consulte Configurar 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 testar esse exemplo, siga as instruções de configuração para Node.js no Guia de início rápido da Vertex AI sobre como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para Node.js.

Para autenticar na Vertex AI, configure o Application Default Credentials. Para mais informações, consulte Configurar 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 o SDK da Vertex AI para Python, consulte Instalar o SDK da Vertex AI para Python. Para mais informações, consulte a documentação de referência da API Python. 

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

Criar um endpoint dedicado

Pule a etapa abaixo se você estiver implantando um modelo em um endpoint existente.

Um endpoint dedicado é mais rápido e estável, com suporte para tamanhos de payload maiores e tempos limite de solicitação mais longos.

Para usar um endpoint dedicado durante a visualização, é necessário ativá-lo explicitamente.

REST 

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
-d '{"display_name": "ENDPOINT_NAME", "dedicatedEndpointEnabled": true}' \
https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints

Substitua:

  • ENDPOINT_NAME: o nome de exibição do endpoint.
  • LOCATION_ID: a região em que você está usando a Vertex AI.
  • PROJECT_ID: o ID do projeto do seu projeto do Google Cloud.

Python 

endpoint = aiplatform.Endpoint.create(
  display_name="ENDPOINT_NAME",
  dedicated_endpoint_enabled=True,
)

Substitua:

  • ENDPOINT_NAME: o nome de exibição do endpoint.

Receber o ID do endpoint

Você precisa do ID do endpoint para implantar o modelo.

gcloud

O exemplo a seguir usa o comando gcloud ai endpoints list:

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

Substitua:

  • LOCATION_ID: a região em que você está usando a Vertex AI.
  • ENDPOINT_NAME: o nome de exibição do endpoint.

Anote o número que aparece na coluna ENDPOINT_ID. Use esse ID na etapa a seguir.

REST

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • LOCATION_ID: a região em que você está usando a Vertex AI.
  • PROJECT_ID: o ID do projeto.
  • ENDPOINT_NAME: o nome de exibição do endpoint.

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 a solicitação, expanda uma destas opções:

Você receberá uma resposta JSON semelhante a esta:

{
  "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"
    }
  ]
}
Observe o ENDPOINT_ID.

Implantar o modelo

Selecione a guia abaixo para seu idioma ou ambiente:

gcloud

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

O exemplo a seguir implanta um Model em um Endpoint sem usar GPUs para acelerar a exibição da previsão e sem dividir o tráfego entre vários recursos DeployedModel:

Antes de usar os dados do comando abaixo, faça estas substituições:

  • ENDPOINT_ID: o ID do endpoint.
  • LOCATION_ID: a região em que você está usando a Vertex AI.
  • MODEL_ID: o ID do modelo a ser implantado.
  • DEPLOYED_MODEL_NAME: um nome para DeployedModel. Também é possível usar o nome de exibição do Model para o DeployedModel.
  • MIN_REPLICA_COUNT: o número mínimo de nós para esta implantação. A contagem de nós pode ser aumentada ou reduzida conforme necessário pela carga de previsão, até o número máximo de nós e nunca menos que esse número.
  • MAX_REPLICA_COUNT: o número máximo de nós para esta implantação. A contagem de nós pode ser aumentada ou reduzida conforme necessário pela carga de previsão, até esse número de nós e nunca menos que o número mínimo de nós. Se você omitir a sinalização --max-replica-count, o número máximo de nós será definido como 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 \
  --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 `
  --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 ^
  --min-replica-count=MIN_REPLICA_COUNT ^
  --max-replica-count=MAX_REPLICA_COUNT ^
  --traffic-split=0=100
  

Divisão de tráfego

A sinalização --traffic-split=0=100 nos exemplos anteriores envia 100% do tráfego de previsão que Endpoint recebe para o novo DeployedModel, que é representado pelo ID temporário 0. Se a Endpoint já tiver outros recursos DeployedModel, será possível dividir o tráfego entre o novo DeployedModel e os antigos. Por exemplo, para enviar 20% do tráfego para o novo DeployedModel e 80% para um mais antigo, execute o seguinte comando.

Antes de usar os dados do comando abaixo, faça estas 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 \ 
  --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 \ 
  --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 \ 
  --min-replica-count=MIN_REPLICA_COUNT ^
  --max-replica-count=MAX_REPLICA_COUNT ^
  --traffic-split=0=20,OLD_DEPLOYED_MODEL_ID=80
  

REST

Implantar o modelo.

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • LOCATION_ID: a região em que você está usando a Vertex AI.
  • PROJECT_ID: o ID do projeto.
  • ENDPOINT_ID: o ID do endpoint.
  • MODEL_ID: o ID do modelo a ser implantado.
  • DEPLOYED_MODEL_NAME: um nome para DeployedModel. Também é possível usar o nome de exibição do Model para o DeployedModel.
  • MACHINE_TYPE: opcional. Os recursos de máquina usados para cada nó desta implantação. A configuração padrão é n1-standard-2. Saiba mais sobre tipos de máquinas.
  • ACCELERATOR_TYPE: o tipo de acelerador a ser anexado à máquina. Opcional se ACCELERATOR_COUNT não for especificado ou for zero. Não recomendado para modelos AutoML ou modelos treinados personalizados que usem imagens que não sejam de GPU. Saiba mais.
  • ACCELERATOR_COUNT: o número de aceleradores a serem usados por cada réplica. Opcional. Deve ser zero ou não especificado para modelos do AutoML ou modelos treinados personalizados que usam imagens que não sejam de GPU.
  • MIN_REPLICA_COUNT: o número mínimo de nós para esta implantação. A contagem de nós pode ser aumentada ou reduzida conforme necessário pela carga de previsão, até o número máximo de nós e nunca menos que esse número. O valor precisa ser maior ou igual a 1.
  • MAX_REPLICA_COUNT: o número máximo de nós para esta implantação. A contagem de nós pode ser aumentada ou reduzida conforme necessário pela carga de previsão, até esse número de nós e nunca menos que o número mínimo de nós.
  • TRAFFIC_SPLIT_THIS_MODEL: a porcentagem do tráfego de previsão para esse endpoint que será roteada para o modelo que está sendo implantado com esta operação. O padrão é 100. A soma de todas as porcentagens de tráfego precisam totalizar 100. Saiba mais sobre as divisões de tráfego.
  • DEPLOYED_MODEL_ID_N: opcional. Se outros modelos forem implantados nesse endpoint, será necessário atualizar as porcentagens de divisão de tráfego para que todas as porcentagens somem 100.
  • TRAFFIC_SPLIT_MODEL_N: o valor da porcentagem da divisão de tráfego para a chave de ID do modelo implantado.
  • PROJECT_NUMBER: o número do projeto gerado automaticamente

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 da solicitação:

{
  "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
     },
  },
  "trafficSplit": {
    "0": TRAFFIC_SPLIT_THIS_MODEL,
    "DEPLOYED_MODEL_ID_1": TRAFFIC_SPLIT_MODEL_1,
    "DEPLOYED_MODEL_ID_2": TRAFFIC_SPLIT_MODEL_2
  },
}

Para enviar a solicitação, expanda uma destas opções:

Você receberá uma resposta JSON semelhante a esta:

{
  "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

Antes de testar esse exemplo, siga as instruções de configuração para Java no Guia de início rápido da Vertex AI sobre como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para Java.

Para autenticar na Vertex AI, configure o Application Default Credentials. Para mais informações, consulte Configurar 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

Para saber como instalar o SDK da Vertex AI para Python, consulte Instalar o SDK da Vertex AI para Python. Para mais informações, consulte a documentação de referência da API 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

Antes de testar esse exemplo, siga as instruções de configuração para Node.js no Guia de início rápido da Vertex AI sobre como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para Node.js.

Para autenticar na Vertex AI, configure o Application Default Credentials. Para mais informações, consulte Configurar 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 configurações padrão para a geração de registros de previsão.

Receber status da operação

Algumas solicitações iniciam operações de longa duração que exigem tempo para serem concluídas. Essas solicitações retornam um nome de operação, que pode ser usado para ver o status da operação ou cancelá-la. A Vertex AI oferece métodos auxiliares para realizar chamadas em operações de longa duração. Para mais informações, consulte Como trabalhar com operações de longa duração.

Limitações

  • Se o VPC Service Controls estiver ativado, o contêiner do modelo implantado não terá acesso à Internet.

Configurar a implantação do modelo

Durante a implantação do modelo, você toma as seguintes decisões importantes sobre como executar a previsão on-line:

Recurso criado Configuração especificada na criação de recursos
Endpoint Local onde executar predições
Modelo Contêiner a ser usado (ModelContainerSpec)
DeployedModel Máquinas para usar na previsão on-line

Não é possível atualizar essas configurações listadas após a criação inicial do modelo ou do endpoint. Não é possível modificá-las na solicitação de previsão on-line. Se você precisar alterar essas configurações, é necessário reimplantar o modelo.

O que acontece quando você implanta um modelo

Ao implantar um modelo em um endpoint, você associa os recursos físicos (máquina) ao modelo para que ele possa exibir previsões on-line. As previsões on-line têm requisitos de baixa latência. Fornecer recursos ao modelo com antecedência reduz a latência.

O tipo de treinamento (AutoML ou personalizado) e dados (AutoML) do modelo determinam os tipos de recursos físicos disponíveis nele. Após a implantação do modelo, é possível mutate alguns desses recursos sem criar uma nova implantação.

O recurso de endpoint fornece o endpoint de serviço (URL) que você usa para solicitar a previsão. Exemplo:

https://us-central1-aiplatform.googleapis.com/v1/projects/{project}/locations/{location}/endpoints/{endpoint}:predict

Motivos para implantar mais de um modelo no mesmo endpoint

A implantação de dois modelos no mesmo endpoint permite substituir gradualmente um modelo por outro. Por exemplo, suponha que você esteja usando um modelo e encontre uma maneira de aumentar a precisão dele com novos dados de treinamento. No entanto, não convém atualizar o aplicativo para apontar para um novo URL de endpoint e você não quer criar alterações repentinas no aplicativo. Você pode adicionar o novo modelo ao mesmo endpoint, exibindo uma pequena porcentagem do tráfego e aumentar gradualmente a divisão de tráfego do novo modelo até que ele exiba 100% do tráfego.

Como os recursos são associados ao modelo em vez do endpoint, é possível implantar modelos de tipos diferentes no mesmo endpoint. No entanto, a prática recomendada é implantar modelos de um tipo específico, como um AutoML tabular, treinamento personalizado, em um endpoint. Essa configuração é mais fácil de gerenciar.

Motivos para implantar um modelo em mais de um endpoint

Pode ser útil implantar os modelos com diferentes recursos para diferentes ambientes de aplicativos, como testes e produção. Você também pode querer oferecer suporte a diferentes SLOs para suas solicitações de previsão. Talvez um dos seus aplicativos tenha necessidades de desempenho muito mais altas do que outros. Nesse caso, é possível implantar esse modelo em um endpoint de desempenho superior com mais recursos de máquina. Para otimizar os custos, também é possível implantar o modelo em um endpoint de desempenho inferior com menos recursos da máquina.

Comportamento de escalonamento

Ao implantar um modelo para previsão on-line como um DeployedModel, é possível configurar nós de previsão para serem escalonados automaticamente. Para isso, defina dedicatedResources.maxReplicaCount com um valor maior que dedicatedResources.minReplicaCount.

Ao configurar um DeployedModel, você precisa definir dedicatedResources.minReplicaCount como pelo menos 1. Em outras palavras, não é possível configurar o DeployedModel para escalonar para 0 nós de previsão quando ele não é usado.

Utilização e configuração de valor desejado

Por padrão, se você implantar um modelo sem recursos de GPU dedicados, a Vertex AI fará o escalonamento vertical ou horizontal automático do número de réplicas para que o uso da CPU corresponda ao valor desejado padrão de 60%.

Por padrão, se você implantar um modelo com recursos de GPU dedicados (se machineSpec.accelerator_count for maior que 0), a Vertex AI vai escalonar automaticamente o número de réplicas para que o uso da CPU ou GPU, o que for maior, corresponda ao valor desejado padrão de 60%. Portanto, se a capacidade de processamento estiver causando alto uso da GPU, mas não alto uso da CPU, a Vertex AI será escalonada verticalmente, e a utilização da CPU será muito baixa, o que vai ficar visível no monitoramento. Por outro lado, se o contêiner personalizado estiver subutilizando a GPU, mas tiver um processo não relacionado que aumente a utilização da CPU para mais de 60%, a Vertex AI vai ser escalonar verticalmente, mesmo que isso não seja necessário para atingir as metas de QPS e latência.

É possível substituir o valor desejado e a métrica de limite padrão especificando autoscalingMetricSpecs. Se a implantação for configurada para escalonar com base apenas no uso da CPU, ela não será escalonar verticalmente mesmo que o uso da GPU seja alto.

Gerenciar o uso de recursos

É possível monitorar seu endpoint para rastrear métricas como o uso da CPU e do acelerador, o número de solicitações, a latência e o número atual e pretendido de réplicas. Essas informações podem ajudar você a entender o uso de recursos e o comportamento de escalonamento do endpoint.

Lembre-se de que cada réplica executa apenas um contêiner. Isso significa que, se um contêiner de previsão não puder usar totalmente o recurso de computação selecionado, como um código de linha de execução única para uma máquina com vários núcleos ou um modelo personalizado que chame outro serviço como parte da previsão, talvez seus nós não sejam escalonar verticalmente verticalmente.

Por exemplo, se você estiver usando o FastAPI ou qualquer servidor de modelo com um número configurável de workers ou linhas de execução, poderá haver muitos casos em que ter um só worker aumentará a utilização de recursos, o melhorando a capacidade do serviço de escalonar automaticamente o número de réplicas.

Geralmente, recomendamos começar com um só worker ou linha de execução por núcleo. Se você perceber que a utilização da CPU está baixa, especialmente sob carga alta, ou se o modelo não estiver escalonando verticalmente porque a utilização da CPU está baixa, aumente o número de workers. Por outro lado, se você perceber que a utilização está muito alta e suas latências aumentam mais do que o esperado sob carga, tente usar menos workers. Se você já estiver usando apenas um worker, tente usar um tipo de máquina menor.

Comportamento de escalonamento e atraso

A Vertex AI ajusta o número de réplicas a cada 15 segundos usando dados da janela anterior de 5 minutos. Para cada ciclo de 15 segundos, o sistema mede a utilização do servidor e gera um número pretendido de réplicas com base na seguinte fórmula:

target # of replicas = Ceil(current # of replicas * (current utilization / target utilization))

Por exemplo, se você tem duas réplicas que estão sendo usadas em 100%, o valor desejado é 4:

4 = Ceil(3.33) = Ceil(2 * (100% / 60%))

Outro exemplo: se você tiver 10 réplicas e a utilização cair para 1%, o valor desejado é 1:

1 = Ceil(.167) = Ceil(10 * (1% / 60%))

No final de cada ciclo de 15 segundos, o sistema ajusta o número de réplicas para corresponder ao maior valor desejado da janela de cinco minutos anterior. Como o maior valor desejado é escolhido, seu endpoint não vai reduzir escala vertical vertical se houver um pico de utilização durante essa janela de cinco minutos, mesmo que a utilização geral seja muito baixa. Por outro lado, se o sistema precisar ser escalonado verticalmente, ele fará isso em até 15 segundos, já que o valor de destino mais alto é escolhido em vez da média.

Lembre-se de que, mesmo depois que a Vertex AI ajusta o número de réplicas, leva tempo para iniciar ou desativar as réplicas. Portanto, haverá um atraso maior até o endpoint se ajustar ao tráfego. Os principais fatores que contribuem para esse tempo incluem:

  • o tempo para provisionar e iniciar as VMs do Compute Engine
  • o tempo para fazer o download do contêiner do registro
  • o tempo para carregar o modelo do armazenamento

A melhor maneira de entender o comportamento de escalonamento real do seu modelo é executar um teste de carga e otimizar as características importantes para o modelo e o caso de uso. Se o escalonador automático não estiver sendo rápido o suficiente para escalonar verticalmente o aplicativo, provisione min_replicas suficientes para lidar com o tráfego de referência esperado.

Atualizar a configuração de escalonamento

Se você tiver especificado DedicatedResources ou AutomaticResources ao implantar o modelo, poderá atualizar a configuração de escalonamento sem reimplantar o modelo chamando mutateDeployedModel.

Por exemplo, a solicitação a seguir atualiza max_replica, autoscaling_metric_specs e desativa o registro de contêiner.

{
  "deployedModel": {
    "id": "2464520679043629056",
    "dedicatedResources": {
      "maxReplicaCount": 9,
      "autoscalingMetricSpecs": [
        {
          "metricName": "aiplatform.googleapis.com/prediction/online/cpu/utilization",
          "target": 50
        }
      ]
    },
    "disableContainerLogging": true
  },
  "update_mask": {
    "paths": [
      "dedicated_resources.max_replica_count",
      "dedicated_resources.autoscaling_metric_specs",
      "disable_container_logging"
    ]
  }
}

Observações sobre o uso:

  • Não é possível mudar o tipo de máquina ou alternar de DedicatedResources para AutomaticResources ou vice-versa. Os únicos campos de configuração de escalonamento que podem ser alterados são: min_replica, max_replica e AutoscalingMetricSpec (somente DedicatedResources).
  • É necessário listar todos os campos que você precisa atualizar em updateMask. Os campos não listados são ignorados.
  • O DeployedModel precisa estar no estado DEPLOYED. Pode haver no máximo uma operação mutate ativa por modelo implantado.
  • O mutateDeployedModel também permite ativar ou desativar a geração de registros de contêineres. Para mais informações, consulte Geração de registros de previsão on-line.

Cancelar a implantação de um modelo e excluir o endpoint

Use um dos métodos a seguir para desimplantar um modelo e excluir o endpoint.

Console do Google Cloud

  1. Desimplante o modelo da seguinte maneira:

    1. No console do Google Cloud, na seção da Vertex AI, acesse a página Endpoints.

      Acessar a página do Endpoints

    2. Clique no nome e no ID da versão do modelo que você quer desimplantar para abrir a página de detalhes.

    3. Na linha do modelo, clique em Ações e em Cancelar a implantação do modelo no endpoint.

    4. Na caixa de diálogo Cancelar a implantação do modelo do endpoint, clique em Cancelar a implantação.

    5. Para excluir outros modelos, repita as etapas anteriores.

  2. Opcional: exclua o endpoint de previsão on-line da seguinte maneira:

    1. No console do Google Cloud, na seção Vertex AI, acesse a página Previsão on-line.

      Acessar a previsão on-line

    2. Selecione o endpoint.

    3. Para excluir o endpoint, clique em Ações e, em seguida, clique em Excluir endpoint.

gcloud

  1. Liste os IDs de todos os endpoints no seu projeto:

    gcloud ai endpoints list \
    --project=PROJECT_ID \
    --region=LOCATION_ID

    Substitua PROJECT_ID pelo nome do projeto e LOCATION_ID pela região em que você está usando a Vertex AI.

  2. Liste os IDs dos modelos implantados em um endpoint:

    gcloud ai endpoints describe ENDPOINT_ID \
    --project=PROJECT_ID \
    --region=LOCATION_ID

    Substitua ENDPOINT_ID pelo ID do endpoint.

  3. Desimplante um modelo do endpoint:

    gcloud ai endpoints undeploy-model ENDPOINT_ID \
    --project=PROJECT_ID \
    --region=LOCATION_ID \
    --deployed-model-id=DEPLOYED_MODEL_ID

    Substitua DEPLOYED_MODEL_ID pelo ID do modelo.

  4. Opcional: exclua o endpoint de previsão on-line:

    gcloud ai endpoints delete ENDPOINT_ID \
    --project=PROJECT_ID \
    --region=LOCATION_ID

A seguir