esegui il deployment di un modello in un endpoint

Devi eseguire il deployment di un modello in un endpoint prima che questo modello possa essere utilizzato per fornire previsioni online. Il deployment di un modello associa le risorse fisiche al modello in modo che possa fornire previsioni online con bassa latenza.

Puoi eseguire il deployment di più modelli in un endpoint e puoi eseguire il deployment di un modello in più di un endpoint. Per ulteriori informazioni sulle opzioni e sui casi d'uso per il deployment dei modelli, vedi Motivi per eseguire il deployment di più modelli nello stesso endpoint di seguito.

esegui il deployment di un modello in un endpoint

Utilizza uno dei seguenti metodi per eseguire il deployment di un modello:

Console Google Cloud

  1. Nella sezione Vertex AI della console Google Cloud, vai alla pagina Modelli.

    Vai alla pagina Modelli

  2. Fai clic sul nome e sull'ID versione del modello di cui vuoi eseguire il deployment per aprire la relativa pagina dei dettagli.

  3. Seleziona la scheda Deployment e test.

    Se il deployment del modello è già stato eseguito in eventuali endpoint, questi saranno elencati nella sezione Esegui il deployment del modello.

  4. Fai clic su Deployment su endpoint.

  5. Per eseguire il deployment del modello su un nuovo endpoint, seleziona Crea nuovo endpoint e specifica un nome per il nuovo endpoint. Per eseguire il deployment del modello su un endpoint esistente, seleziona Aggiungi a endpoint esistente, quindi seleziona l'endpoint dall'elenco a discesa.

    Puoi aggiungere più di un modello a un endpoint, nonché un modello a più di un endpoint.

  6. Se esegui il deployment del modello su un endpoint esistente in cui è stato eseguito il deployment di uno o più modelli, devi aggiornare la percentuale di suddivisione del traffico per il modello di cui stai eseguendo il deployment e per i modelli già distribuiti, in modo che la somma di tutte le percentuali corrisponda al 100%.

  7. Se esegui il deployment del modello in un nuovo endpoint, accetta 100 per la suddivisione del traffico. In caso contrario, regola i valori di suddivisione del traffico per tutti i modelli sull'endpoint in modo che la somma sia fino a 100.

  8. Inserisci il Numero minimo di nodi di computing da fornire per il modello.

    Si tratta del numero di nodi sempre disponibili per il modello.

    Ti viene addebitato il costo dei nodi utilizzati, che sia per gestire il carico di previsione o per i nodi in standby (minimo), anche senza traffico di previsione. Consulta la pagina dei prezzi.

    Il numero di nodi di computing può aumentare se necessario per gestire il traffico di previsione, ma non supererà mai il numero massimo di nodi.

  9. Per utilizzare la scalabilità automatica, inserisci il Numero massimo di nodi di computing a cui vuoi che Vertex AI faccia lo scale up.

  10. Seleziona il Tipo di macchina.

    Risorse macchina più grandi aumentano le prestazioni delle previsioni e aumentano i costi. Confronta i tipi di macchine disponibili.

  11. Seleziona un Tipo di acceleratore e un Conteggio acceleratore.

    Se hai abilitato l'utilizzo dell'acceleratore quando hai importato o creato il modello, viene visualizzata questa opzione.

    Per il conteggio degli acceleratori, consulta la tabella delle GPU per verificare il numero valido di GPU che puoi utilizzare con ogni tipo di macchina di CPU. Il conteggio degli acceleratori si riferisce al numero di acceleratori per nodo, non al numero totale di acceleratori nel deployment.

  12. Se vuoi utilizzare un account di servizio personalizzato per il deployment, selezionane uno nella casella a discesa Account di servizio.

  13. Scopri come modificare le impostazioni predefinite per il logging delle previsioni.

  14. Fai clic su Fine per il modello e quando tutte le percentuali di Suddivisione del traffico sono corrette, fai clic su Continua.

    Viene visualizzata la regione in cui viene eseguito il deployment del modello. Deve essere la regione in cui hai creato il modello.

  15. Fai clic su Esegui il deployment per eseguire il deployment del modello nell'endpoint.

API

Quando esegui il deployment di un modello utilizzando l'API Vertex AI, devi completare i seguenti passaggi:

  1. Create un endpoint, se necessario.
  2. Get l'ID endpoint.
  3. Deploy il modello all'endpoint.

Creazione di un endpoint

Se esegui il deployment di un modello in un endpoint esistente, puoi saltare questo passaggio.

gcloud

Nell'esempio seguente viene utilizzato il comando gcloud ai endpoints create:

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

Sostituisci quanto segue:

  • LOCATION_ID: la regione in cui utilizzi Vertex AI.
  • ENDPOINT_NAME: il nome visualizzato dell'endpoint.

Lo strumento Google Cloud CLI potrebbe richiedere alcuni secondi per creare l'endpoint.

REST

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

  • LOCATION_ID: la tua regione.
  • PROJECT_ID: il tuo ID progetto.
  • ENDPOINT_NAME: il nome visualizzato dell'endpoint.

Metodo HTTP e URL: 

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

Corpo JSON della richiesta: 

{
  "display_name": "ENDPOINT_NAME"
}

Per inviare la richiesta, espandi una di queste opzioni:

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "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"
    }
  }
}
Puoi eseguire il polling per verificare lo stato dell'operazione fino a quando la risposta non include "done": true.

Terraform

L'esempio seguente utilizza la risorsa Terraform google_vertex_ai_endpoint per creare un endpoint.

Per scoprire come applicare o rimuovere una configurazione Terraform, consulta Comandi Terraform di base.

# 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

Prima di provare questo esempio, segui le istruzioni di configurazione di Java riportate nella guida rapida di Vertex AI sull'utilizzo delle librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Java Vertex AI.

Per eseguire l'autenticazione in Vertex AI, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 


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

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js riportate nella guida rapida di Vertex AI sull'utilizzo delle librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Node.js Vertex AI.

Per eseguire l'autenticazione in Vertex AI, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

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

Per scoprire come installare o aggiornare l'SDK Vertex AI per Python, consulta Installare l'SDK Vertex AI per Python. Per saperne di più, consulta la documentazione di riferimento dell'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

Recupera l'ID endpoint

È necessario l'ID endpoint per eseguire il deployment del modello.

gcloud

Nell'esempio seguente viene utilizzato il comando gcloud ai endpoints list:

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

Sostituisci quanto segue:

  • LOCATION_ID: la regione in cui utilizzi Vertex AI.
  • ENDPOINT_NAME: il nome visualizzato dell'endpoint.

Prendi nota del numero riportato nella colonna ENDPOINT_ID. Utilizza questo ID nel passaggio seguente.

REST

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

  • LOCATION_ID: la regione in cui utilizzi Vertex AI.
  • PROJECT_ID: il tuo ID progetto.
  • ENDPOINT_NAME: il nome visualizzato dell'endpoint.

Metodo HTTP e URL: 

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

Per inviare la richiesta, espandi una di queste opzioni:

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "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"
    }
  ]
}
Prendi nota di ENDPOINT_ID.

Esegui il deployment del modello

Seleziona la scheda seguente per la tua lingua o il tuo ambiente:

gcloud

Negli esempi seguenti viene utilizzato il comando gcloud ai endpoints deploy-model.

L'esempio seguente esegue il deployment di un oggetto Model in un Endpoint senza utilizzare GPU per accelerare la fornitura delle previsioni e senza suddividere il traffico tra più risorse DeployedModel:

Prima di utilizzare uno qualsiasi dei dati di comando riportati di seguito, effettua le seguenti sostituzioni:

  • ENDPOINT_ID: l'ID dell'endpoint.
  • LOCATION_ID: la regione in cui utilizzi Vertex AI.
  • MODEL_ID: l'ID del modello di cui eseguire il deployment.
  • DEPLOYED_MODEL_NAME: un nome per DeployedModel. Puoi utilizzare anche il nome visualizzato di Model per DeployedModel.
  • MIN_REPLICA_COUNT: il numero minimo di nodi per questo deployment. Il numero di nodi può essere aumentato o diminuito in base alle esigenze del carico della previsione, fino al numero massimo di nodi e mai meno di questo numero.
  • MAX_REPLICA_COUNT: il numero massimo di nodi per questo deployment. Il numero di nodi può essere aumentato o diminuito in base al carico di previsione, fino a questo numero di nodi e mai inferiore al numero minimo di nodi. Se ometti il flag --max-replica-count, il numero massimo di nodi è impostato sul valore di --min-replica-count.

Esegui il comando gcloud ai endpoints deploy-model:

Linux, macOS o 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
 

Suddivisione del traffico

Il flag --traffic-split=0=100 negli esempi precedenti invia il 100% del traffico di previsione ricevuto da Endpoint al nuovo DeployedModel, rappresentato dall'ID temporaneo 0. Se il tuo Endpoint ha già altre risorse DeployedModel, puoi suddividere il traffico tra la nuova DeployedModel e quella precedente. Ad esempio, per inviare il 20% del traffico al nuovo DeployedModel e l'80% a uno meno recente, esegui questo comando.

Prima di utilizzare uno qualsiasi dei dati di comando riportati di seguito, effettua le seguenti sostituzioni:

  • OLD_DEPLOYED_MODEL_ID: l'ID dell'elemento DeployedModel esistente.

Esegui il comando gcloud ai endpoints deploy-model:

Linux, macOS o 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

Esegui il deployment del modello.

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

  • LOCATION_ID: la regione in cui utilizzi Vertex AI.
  • PROJECT_ID: il tuo ID progetto.
  • ENDPOINT_ID: l'ID dell'endpoint.
  • MODEL_ID: l'ID del modello di cui eseguire il deployment.
  • DEPLOYED_MODEL_NAME: un nome per DeployedModel. Puoi utilizzare anche il nome visualizzato di Model per DeployedModel.
  • MACHINE_TYPE: facoltativo. Le risorse macchina utilizzate per ogni nodo di questo deployment. La sua impostazione predefinita è n1-standard-2. Scopri di più sui tipi di macchina.
  • ACCELERATOR_TYPE: il tipo di acceleratore da collegare alla macchina. Facoltativo se ACCELERATOR_COUNT non è specificato o è pari a zero. Opzione non consigliata per i modelli AutoML o per i modelli con addestramento personalizzato che utilizzano immagini non GPU. Scopri di più.
  • ACCELERATOR_COUNT: il numero di acceleratori da utilizzare per ogni replica. Facoltativo. Il valore deve essere zero o non specificato per i modelli AutoML o per i modelli addestrati personalizzati che utilizzano immagini non GPU.
  • MIN_REPLICA_COUNT: il numero minimo di nodi per questo deployment. Il numero di nodi può essere aumentato o diminuito in base alle esigenze del carico della previsione, fino al numero massimo di nodi e mai meno di questo numero. Questo valore deve essere maggiore o uguale a 1.
  • MAX_REPLICA_COUNT: il numero massimo di nodi per questo deployment. Il numero di nodi può essere aumentato o diminuito in base al carico di previsione, fino a questo numero di nodi e mai inferiore al numero minimo di nodi.
  • TRAFFIC_SPLIT_THIS_MODEL: la percentuale del traffico di previsione verso questo endpoint da instradare al modello di cui viene eseguito il deployment con questa operazione. Il valore predefinito è 100. La somma di tutte le percentuali di traffico deve essere pari a 100. Scopri di più sulle suddivisioni del traffico.
  • DEPLOYED_MODEL_ID_N: facoltativo. Se viene eseguito il deployment di altri modelli in questo endpoint, devi aggiornare le percentuali di suddivisione del traffico in modo che la somma delle percentuali corrisponda a 100.
  • TRAFFIC_SPLIT_MODEL_N: il valore percentuale di suddivisione del traffico per la chiave ID modello di cui è stato eseguito il deployment.
  • PROJECT_NUMBER: il numero di progetto generato automaticamente per il tuo progetto

Metodo HTTP e URL: 

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

Corpo JSON della richiesta: 

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

Per inviare la richiesta, espandi una di queste opzioni:

Dovresti ricevere una risposta JSON simile alla seguente:

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

Prima di provare questo esempio, segui le istruzioni di configurazione di Java riportate nella guida rapida di Vertex AI sull'utilizzo delle librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Java Vertex AI.

Per eseguire l'autenticazione in Vertex AI, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

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

Per scoprire come installare o aggiornare l'SDK Vertex AI per Python, consulta Installare l'SDK Vertex AI per Python. Per saperne di più, consulta la documentazione di riferimento dell'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

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js riportate nella guida rapida di Vertex AI sull'utilizzo delle librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Node.js Vertex AI.

Per eseguire l'autenticazione in Vertex AI, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

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);
  });

Scopri come modificare le impostazioni predefinite per il logging delle previsioni.

Ottieni stato operazione

Alcune richieste avviano operazioni a lunga esecuzione il cui completamento richiede tempo. Queste richieste restituiscono un nome operazione, che puoi utilizzare per visualizzare lo stato dell'operazione o per annullarla. Vertex AI fornisce metodi helper per effettuare chiamate a operazioni a lunga esecuzione. Per maggiori informazioni, consulta Operazioni a lunga esecuzione.

Limitazioni

  • Se hai abilitato i Controlli di servizio VPC, il container del modello di cui hai eseguito il deployment non avrà accesso a internet.

Configura il deployment dei modelli

Durante il deployment del modello, prendi le seguenti decisioni importanti su come eseguire la previsione online:

Risorsa creata Impostazione specificata al momento della creazione della risorsa
Endpoint Località in cui eseguire le previsioni
Modello Contenitore da utilizzare (ModelContainerSpec)
DeployedModel Macchine da utilizzare per la previsione online

Non puoi aggiornare le impostazioni elencate sopra dopo la creazione iniziale del modello o dell'endpoint e non puoi eseguirne l'override nella richiesta di previsione online. Se devi modificare queste impostazioni, devi eseguire nuovamente il deployment del modello.

Cosa succede quando esegui il deployment di un modello

Quando esegui il deployment di un modello su un endpoint, associ le risorse fisiche (macchina) al modello in modo che possa fornire previsioni online. Le previsioni online hanno requisiti di bassa latenza. Fornire in anticipo risorse al modello riduce la latenza.

Il tipo di addestramento del modello (AutoML o personalizzato) e il tipo di dati (AutoML) determinano i tipi di risorse fisiche disponibili per il modello. Dopo il deployment del modello, puoi mutate alcune di queste risorse senza creare un nuovo deployment.

La risorsa endpoint fornisce l'endpoint di servizio (URL) utilizzato per richiedere la previsione. Ad esempio:

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

Motivi per eseguire il deployment di più modelli nello stesso endpoint

Il deployment di due modelli nello stesso endpoint consente di sostituire gradualmente un modello con l'altro. Ad esempio, supponi di utilizzare un modello e di trovare un modo per aumentare l'accuratezza del modello con nuovi dati di addestramento. Tuttavia, non vuoi aggiornare l'applicazione in modo che punti a un nuovo URL dell'endpoint e non creare cambiamenti improvvisi nell'applicazione. Puoi aggiungere il nuovo modello allo stesso endpoint, gestendo una piccola percentuale di traffico, e aumentare gradualmente la suddivisione del traffico fino a quando non gestisce il 100% del traffico.

Poiché le risorse sono associate al modello anziché all'endpoint, potresti eseguire il deployment di modelli di tipi diversi nello stesso endpoint. Tuttavia, la best practice prevede il deployment di modelli di un tipo specifico (ad esempio testo AutoML, tabella AutoML, addestramento personalizzato) su un endpoint. Questa configurazione è più facile da gestire.

Motivi per eseguire il deployment di un modello su più endpoint

Puoi eseguire il deployment dei tuoi modelli con risorse diverse per ambienti applicativi diversi, ad esempio test e produzione. Potresti anche voler supportare SLO diversi per le tue richieste di previsione. Forse una delle tue applicazioni ha esigenze di prestazioni molto più elevate rispetto alle altre. In questo caso, puoi eseguire il deployment del modello in un endpoint con prestazioni più elevate e più risorse macchina. Per ottimizzare i costi, puoi anche eseguire il deployment del modello in un endpoint con prestazioni inferiori e meno risorse macchina.

Comportamento di scalabilità

Quando esegui il deployment di un Model per la previsione online come DeployedModel, puoi configurare i nodi di previsione per la scalabilità automatica. Per farlo, imposta dedicatedResources.maxReplicaCount su un valore maggiore di dedicatedResources.minReplicaCount.

Quando configuri DeployedModel, devi impostare dedicatedResources.minReplicaCount su almeno 1. In altre parole, non puoi configurare DeployedModel per la scalabilità ai nodi di previsione 0 quando non è utilizzato.

Utilizzo e configurazione target

Per impostazione predefinita, se esegui il deployment di un modello senza risorse GPU dedicate, Vertex AI aumenta o diminuisce automaticamente il numero di repliche in modo che l'utilizzo della CPU corrisponda al valore target predefinito del 60%.

Per impostazione predefinita, se esegui il deployment di un modello con risorse GPU dedicate (se machineSpec.accelerator_count è superiore a 0), Vertex AI scalerà automaticamente il numero di repliche in modo che l'utilizzo di CPU o GPU, a seconda di quale sia il valore più alto, corrisponda al valore target predefinito del 60%. Pertanto, se la velocità effettiva di previsione causa un elevato utilizzo della GPU, ma non un utilizzo elevato della CPU, Vertex AI farà lo scale up e l'utilizzo della CPU sarà molto basso, visibile nel monitoraggio. Al contrario, se il container personalizzato sottoutilizza la GPU, ma ha un processo non correlato che porta l'utilizzo della CPU superiore al 60%, Vertex AI effettuerà lo scale up, anche se potrebbe non essere stato necessario per raggiungere i target di QPS e latenza.

Puoi eseguire l'override della metrica di soglia e del target predefiniti specificando autoscalingMetricSpecs. Tieni presente che, se il deployment è configurato per la scalabilità in base solo all'utilizzo della CPU, non verrà fatto lo scale up anche se l'utilizzo della GPU è elevato.

Gestisci l'utilizzo delle risorse

Puoi monitorare il tuo endpoint per tenere traccia di metriche come utilizzo della CPU e dell'acceleratore, numero di richieste, latenza e numero attuale e target di repliche. Queste informazioni possono aiutarti a comprendere l'utilizzo delle risorse e il comportamento di scalabilità dell'endpoint.

Tieni presente che ogni replica esegue un solo container. Ciò significa che se un container di previsione non può utilizzare completamente la risorsa di computing selezionata, ad esempio un codice con thread singolo per una macchina multi-core o un modello personalizzato che chiama un altro servizio nell'ambito della previsione, i nodi potrebbero non fare lo scale up.

Ad esempio, se utilizzi FastAPI o qualsiasi server del modello con un numero configurabile di worker o thread, in molti casi la presenza di più worker può aumentare l'utilizzo delle risorse, migliorando la capacità del servizio di scalare automaticamente il numero di repliche.

In genere consigliamo di iniziare con un worker o thread per core. Se noti che l'utilizzo della CPU è ridotto, in particolare sotto carico elevato, o se il tuo modello non esegue lo scale up perché l'utilizzo della CPU è ridotto, aumenta il numero di worker. Se invece noti che l'utilizzo è troppo elevato e le latenze aumentano di più del previsto sotto carico, prova a utilizzare meno worker. Se utilizzi già un solo worker, prova a utilizzare un tipo di macchina più piccolo.

Comportamento di scalabilità e ritardo

Vertex AI regola il numero di repliche ogni 15 secondi utilizzando i dati degli ultimi 5 minuti. Per ogni ciclo di 15 secondi, il sistema misura l'utilizzo del server e genera un numero target di repliche in base alla formula seguente:

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

Ad esempio, se al momento hai due repliche utilizzate al 100%, il target è 4:

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

Un altro esempio, se al momento hai 10 repliche e l'utilizzo cala all'1%, il target è 1:

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

Alla fine di ogni ciclo di 15 secondi, il sistema regola il numero di repliche in modo che corrisponda al valore target più alto della finestra dei 5 minuti precedenti. Tieni presente che, poiché viene scelto il valore target più alto, l'endpoint non farà fare lo scale down in caso di un picco di utilizzo durante il periodo di 5 minuti, anche se l'utilizzo complessivo è molto basso. Se invece è necessario fare lo scale up del sistema, lo scale up avverrà entro 15 secondi, poiché viene scelto il valore target più alto anziché la media.

Tieni presente che, anche dopo che Vertex AI ha regolato il numero di repliche, l'avvio o la disattivazione delle repliche richiede del tempo. C'è quindi un ulteriore ritardo prima che l'endpoint possa adattarsi al traffico. I fattori principali che contribuiscono a questo periodo sono i seguenti:

  • il tempo necessario per eseguire il provisioning e l'avvio delle VM di Compute Engine
  • il tempo necessario per scaricare il container dal registry.
  • il tempo per caricare il modello dallo spazio di archiviazione

Il modo migliore per comprendere il comportamento di scalabilità del modello nel mondo reale è eseguire un test di carico e ottimizzare le caratteristiche importanti per il modello e il caso d'uso. Se il gestore della scalabilità automatica non fa lo scale up abbastanza velocemente per la tua applicazione, esegui il provisioning di un valore di min_replicas sufficiente per gestire il traffico di riferimento previsto.

Aggiorna la configurazione di scalabilità

Se hai specificato DedicatedResources o AutomaticResources quando hai eseguito il deployment del modello, puoi aggiornare la configurazione di scalabilità senza eseguire nuovamente il deployment del modello chiamando mutateDeployedModel.

Ad esempio, la seguente richiesta aggiorna max_replica, autoscaling_metric_specs e disabilita il logging dei container.

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

Note sull'utilizzo:

  • Non puoi cambiare il tipo di macchina o passare da DedicatedResources a AutomaticResources e viceversa. Gli unici campi di configurazione della scalabilità che puoi modificare sono: min_replica, max_replica e AutoscalingMetricSpec (solo DedicatedResources).
  • Devi elencare ogni campo che vuoi aggiornare in updateMask. I campi non in elenco vengono ignorati.
  • Il modello DeployedModel deve essere in stato DEPLOYED. Può essere presente al massimo un'operazione di modifica attiva per modello di cui è stato eseguito il deployment.
  • mutateDeployedModel consente anche di abilitare o disabilitare il logging dei container. Per ulteriori informazioni, consulta la pagina relativa al logging delle previsioni online.

Passaggi successivi