esegui il deployment di un modello in un endpoint

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

Per poter eseguire il deployment, il modello deve essere visibile in Vertex AI Model Registry. Per informazioni su Model Registry, incluse informazioni su importare gli artefatti del modello o crearli direttamente Registry di Vertex, consulta Introduzione a Vertex AI Model Registry.

Puoi eseguire il deployment di più modelli su un endpoint oppure dello stesso modello più endpoint. Per ulteriori informazioni sulle opzioni e sui casi d'uso per sul deployment di modelli, consulta Motivi per eseguire il deployment di più modelli nello stesso endpoint.

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 console Google Cloud, nella sezione Vertex AI, 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 casella di controllo Deploy & Scheda Test.

    Se il modello è già stato distribuito in altri endpoint, questi vengono elencati nella Sezione Deployment del modello.

  4. Fai clic su Esegui il deployment nell'endpoint.

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

    Puoi eseguire il deployment di più modelli in un endpoint oppure puoi eseguire il deployment dello stesso modello in più endpoint.

  6. Se esegui il deployment del modello su un endpoint esistente che ha uno o più di cui è stato eseguito il deployment, devi aggiornare la percentuale di suddivisione del traffico per il modello di cui si esegue il deployment e per i modelli di cui è già stato eseguito il deployment, percentuale sommata fino al 100%.

  7. Se esegui il deployment del modello in un nuovo endpoint, accetta 100 per la Suddivisione del traffico. In caso contrario, modifica i valori di suddivisione del traffico per tutti i modelli nell'endpoint in modo che sommino 100.

  8. Inserisci il numero minimo di nodi di calcolo che vuoi fornire per il tuo modello.

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

    Ti vengono addebitati i nodi utilizzati, sia per gestire il carico delle previsioni che per nodi in standby (minimo), anche senza traffico di previsione. Vedi i prezzi .

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

  9. Per utilizzare la scalabilità automatica, inserisci il Numero massimo di nodi di calcolo fino al quale vuoi che Vertex AI esegua la scalabilità.

  10. Seleziona il tipo di macchina.

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

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

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

    Per il conteggio degli acceleratori, consulta la sezione GPU tabella per verificare la presenza di numeri validi di GPU utilizzabili con ogni tipo di macchina CPU. Il conteggio degli acceleratori fa riferimento al numero di acceleratori per nodo, non al numero totale di acceleratori nel tuo deployment.

  12. Se vuoi utilizzare un servizio personalizzato Google Cloud per il deployment, un account di servizio 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 traffico sono corrette, fai clic su Continua.

    Viene visualizzata la regione in cui viene eseguito il deployment del modello. Questo 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, completi seguenti passaggi:

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

Creazione di un endpoint

Se stai eseguendo il deployment di un modello in un endpoint esistente, puoi saltare questo passaggio e andare a Ottenere l'ID endpoint. Per provare l'anteprima dell'endpoint dedicato, vai a Creare un endpoint dedicato.

gcloud

L'esempio seguente utilizza la classe gcloud ai endpoints create comando:

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 delle seguenti 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 lo stato dell'operazione finché 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 Java riportate nella guida rapida all'utilizzo delle librerie client di Vertex AI. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Java di Vertex AI.

Per eseguire l'autenticazione su Vertex AI, configura 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 Node.js riportate nella guida rapida all'utilizzo delle librerie client di Vertex AI. Per ulteriori informazioni, consulta API Node.js Vertex AI documentazione di riferimento.

Per eseguire l'autenticazione su Vertex AI, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 ulteriori informazioni, consulta 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

Crea un endpoint dedicato

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

Un endpoint dedicato è un endpoint più veloce e stabile che supporta dimensioni del payload più grandi e timeout delle richieste più lunghi.

Per usare un endpoint dedicato durante l'anteprima, devi abilitarlo in modo esplicito.

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

Sostituisci quanto segue:

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

Python 

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

Sostituisci quanto segue:

  • ENDPOINT_NAME: il nome visualizzato dell'endpoint.

recupera l'ID endpoint

Per eseguire il deployment del modello, devi disporre dell'ID endpoint.

gcloud

L'esempio seguente utilizza la classe gcloud ai endpoints list comando:

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 visualizzato nella colonna ENDPOINT_ID. Utilizza questo ID nel passaggio successivo.

REST

Prima di utilizzare i dati della richiesta, apporta 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 di seguito la scheda per la tua lingua o il tuo ambiente:

gcloud

I seguenti esempi utilizzano il comando gcloud ai endpoints deploy-model.

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

Prima di utilizzare i dati dei comandi 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 il DeployedModel. Puoi utilizzare il nome visualizzato Model anche per DeployedModel.
  • MIN_REPLICA_COUNT: numero minimo di nodi per questo deployment. Il numero di nodi può essere aumentato o diminuito in base al 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 conteggio dei nodi può essere aumentato o diminuito in base al carico della previsione. fino a questo numero di nodi e mai meno del numero minimo di nodi. Se il flag --max-replica-count viene omesso, il numero massimo di nodi viene 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% della previsione il traffico ricevuto dal Endpoint al nuovo DeployedModel, che rappresentato dall'ID temporaneo 0. Se il tuo Endpoint ha già altri DeployedModel risorse, quindi puoi suddividere il traffico tra le nuove risorse DeployedModel e quelli precedenti. Ad esempio, per inviare il 20% del traffico al nuovo DeployedModel e l'80% a quello precedente, esegui questo comando.

Prima di utilizzare i dati dei comandi riportati di seguito, effettua le seguenti sostituzioni:

  • OLD_DEPLOYED_MODEL_ID: l'ID del 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 da implementare.
  • DEPLOYED_MODEL_NAME: un nome per DeployedModel. Puoi utilizzare il nome visualizzato del Model anche per DeployedModel.
  • MACHINE_TYPE: facoltativo. Le risorse della macchina utilizzate per ogni nodo di questo deployment. L'impostazione predefinita è n1-standard-2. Scopri di più sui tipi di macchina.
  • ACCELERATOR_TYPE: tipo di acceleratore da associare alla macchina. Facoltativo se ACCELERATOR_COUNT non è specificato o è pari a zero. Non consigliato per i modelli AutoML o con addestramento personalizzato che utilizzano immagini non GPU. Scopri di più.
  • ACCELERATOR_COUNT: il numero di acceleratori da utilizzare per ogni replica. Facoltativo. Deve essere zero o non specificato per i modelli AutoML o i modelli con addestramento personalizzato che utilizzano immagini non GPU.
  • MIN_REPLICA_COUNT: numero minimo di nodi per questo deployment. Il conteggio dei nodi può essere aumentato o diminuito in base al 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 della 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 per questo endpoint da inoltrare al modello di cui viene eseguito il deployment con questa operazione. Il valore predefinito è 100. Tutto il traffico la somma delle percentuali deve essere 100. Scopri di più sulle suddivisioni del traffico.
  • DEPLOYED_MODEL_ID_N: facoltativo. Se in questo endpoint sono di cui è stato eseguito il deployment di altri modelli, devi aggiornare le relative percentuali di suddivisione del traffico in modo che tutte le percentuali sommate diano 100.
  • TRAFFIC_SPLIT_MODEL_N: il valore percentuale di suddivisione del traffico per l'ID del modello di cui è stato eseguito il deployment chiave.
  • PROJECT_NUMBER: il numero di progetto generato automaticamente del 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 delle seguenti 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 per la configurazione di Java nel Guida rapida di Vertex AI con librerie client. Per ulteriori informazioni, consulta API Java Vertex AI documentazione di riferimento.

Per autenticarti in Vertex AI, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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, vedi 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 per la configurazione di Node.js nel Guida rapida di Vertex AI con librerie client. Per ulteriori informazioni, consulta API Node.js Vertex AI documentazione di riferimento.

Per eseguire l'autenticazione su Vertex AI, configura 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 la registrazione delle previsioni.

Ottieni stato dell'operazione

Alcune richieste avviano operazioni a lunga esecuzione il cui completamento richiede tempo. Questi restituiscono il nome di un'operazione, che puoi utilizzare per visualizzare o annullare l'operazione. Vertex AI fornisce metodi di assistenza per effettuare chiamate a operazioni di lunga durata. Per ulteriori informazioni, consulta la sezione Utilizzo di modelli operazioni.

Limitazioni

  • Se hai attivato i Controlli di servizio VPC, il contenitore del modello di cui è stato eseguito il deployment non avrà accesso a internet.

Configura il deployment del modello

Durante il deployment del modello, devi prendere 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 queste impostazioni elencate dopo la creazione iniziale dell'elemento modello o 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 in un endpoint, devi associare fisica (macchina) le risorse con il modello, in modo che possa fornire previsioni online. Previsioni online hanno requisiti di bassa latenza. Fornire risorse al modello in anticipo riduce la latenza.

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

La risorsa endpoint fornisce l'endpoint (URL) del servizio che utilizzi 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 ti consente di sostituire gradualmente un modello con l'altro. Ad esempio, supponiamo che tu stia usando un modello e che trovi un modo aumentare l'accuratezza del modello con nuovi dati di addestramento. Tuttavia, non aggiornare l'applicazione in modo che punti a un nuovo URL dell'endpoint e vuoi creare cambiamenti improvvisi nella tua applicazione. Puoi aggiungere il nuovo modello lo stesso endpoint, gestendo una piccola percentuale di traffico e aumentando gradualmente la suddivisione del traffico per il nuovo modello finché non gestisce il 100% del traffico.

Poiché le risorse sono associate al modello anziché all'endpoint, puoi eseguire il deployment di modelli di tipi diversi nello stesso endpoint. Tuttavia, la migliore prassi è eseguire il deployment di modelli di un tipo specifico (ad esempio tabulari AutoML, con addestramento personalizzato) in un endpoint. Questa configurazione è più facile da gestire.

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

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

Comportamento di scalabilità

Quando esegui il deployment di un modello per la previsione online come DeployedModel, puoi configurare nodi di previsione per scalare automaticamente. A questo scopo, imposta dedicatedResources.maxReplicaCount a un maggiore di dedicatedResources.minReplicaCount.

Quando configuri un valore DeployedModel, devi impostare da dedicatedResources.minReplicaCount ad almeno 1. In altre parole, non puoi configurare DeployedModel per scalare fino a 0 nodi di previsione 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 è maggiore di 0), Vertex AI scalerà automaticamente il numero di repliche o inferiore in modo che l'utilizzo di CPU o GPU, a seconda di quale sia il valore più alto, corrisponda al valore predefinito 60% del valore target. Di conseguenza, se la velocità effettiva di previsione causa un'elevata GPU ma non un utilizzo elevato della CPU, lo scale up di Vertex AI sarà molto ridotto e sarà visibile durante il monitoraggio. Al contrario, se il container personalizzato sta sottoutilizzando la GPU, ma ha un processo non correlato che aumentano l'utilizzo della CPU di oltre il 60%, Vertex AI farà lo scale up, nel caso in cui ciò non fosse stato necessario per raggiungere gli obiettivi di QPS e latenza.

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

Gestisci l'utilizzo delle risorse

Puoi monitorare endpoint per monitorare metriche come utilizzo di CPU e Accelerator, numero di richieste, latenza e il numero di repliche attuale e di destinazione. Queste informazioni possono aiutarti a comprendere il comportamento di scalabilità e utilizzo delle risorse dell'endpoint.

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

Ad esempio, se utilizzi FastAPI o qualsiasi server di modelli con un numero configurabile di worker o thread, in molti casi avere più di un 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 è basso, in particolare in caso di carico elevato, o se il tuo modello non viene eseguito in modalità di scalabilità automatica perché l'utilizzo della CPU è basso, aumenta il numero di worker. Se invece noti che l'utilizzo è troppo elevato e la tua le latenze aumentano più del previsto sotto carico, prova a utilizzare meno worker. Se utilizzi già un solo worker, prova a usare un tipo di macchina più piccolo.

Comportamento di scalabilità e tempo di latenza

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

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

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

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

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

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

Al termine 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. Nota che poiché viene scelto il valore target più alto, lo fare lo scale down dell'endpoint non verrà eseguito c'è un picco di utilizzo durante questo periodo di 5 minuti, anche se nel complesso è molto basso. D'altra parte, se il sistema deve essere scalato, lo farà entro 15 secondi poiché viene scelto il valore target più alto anziché la media.

Tieni presente che anche dopo che Vertex AI ha modificato il numero di repliche, è necessario del tempo per avviarle o ridurle. Di conseguenza, si verifica un ulteriore ritardo prima che l'endpoint possa adeguarsi al traffico. I fattori principali che contribuiscono a questo periodo includono quanto segue:

  • il tempo necessario per eseguire il provisioning e avviare le VM di Compute Engine
  • il tempo per scaricare il contenitore dal registry
  • il tempo necessario per caricare il modello

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 rapidamente per esegui il provisioning di un numero sufficiente di min_replicas per gestire la base di riferimento prevista per via del traffico.

Aggiorna la configurazione della scalabilità

Se hai specificato DedicatedResources o AutomaticResources quando hai eseguito il deployment 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 modificare il tipo di macchina o passare da DedicatedResources a AutomaticResources o viceversa. Gli unici campi di configurazione della scalabilità che puoi modificare sono: min_replica, max_replica e AutoscalingMetricSpec (solo DedicatedResources).
  • Devi elencare tutti i campi da aggiornare in updateMask. Non elencato vengono ignorati.
  • Il metodo DeployedModel deve essere nello stato DEPLOYED. Può essere attiva al massimo un'operazione di mutazione per modello di cui è stato eseguito il deployment.
  • mutateDeployedModel consente anche di abilitare o disabilitare il logging dei container. Per maggiori informazioni per informazioni, consulta Previsione online il logging.

Annullare il deployment di un modello ed eliminare l'endpoint

Utilizza uno dei seguenti metodi per annullare il deployment di un modello ed eliminare l'endpoint.

Console Google Cloud

  1. Annulla il deployment del modello nel seguente modo:

    1. Nella console Google Cloud, nella sezione Vertex AI, vai alla pagina Endpoint.

      Vai alla pagina Endpoint

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

    3. Nella riga relativa al modello, fai clic su . Azioni, quindi fai clic su Annulla il deployment del modello nell'endpoint.

    4. Nella finestra di dialogo Annulla il deployment del modello nell'endpoint, fai clic su Annulla deployment.

    5. Per eliminare altri modelli, ripeti i passaggi precedenti.

  2. (Facoltativo) Elimina l'endpoint di previsione online nel seguente modo:

    1. Nella console Google Cloud, nella sezione Vertex AI, vai alla pagina Previsione online.

      Vai a Previsione online

    2. Seleziona l'endpoint.

    3. Per eliminare l'endpoint, fai clic su Azioni e poi su Elimina endpoint.

gcloud

  1. Elenca gli ID endpoint per tutti gli endpoint nel tuo progetto:

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

    Sostituisci PROJECT_ID con il nome del progetto e LOCATION_ID con la regione in cui utilizzi Vertex AI.

  2. Elenca gli ID dei modelli di cui è stato eseguito il deployment in un endpoint:

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

    Sostituisci ENDPOINT_ID con l'ID endpoint.

  3. Annulla il deployment di un modello nell'endpoint:

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

    Sostituisci DEPLOYED_MODEL_ID con l'ID modello.

  4. (Facoltativo) Elimina l'endpoint di previsione online:

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

Passaggi successivi