Déployer un modèle sur un point de terminaison

Vous devez déployer un modèle sur un point de terminaison avant de pouvoir utiliser ce modèle pour diffuser des prédictions en ligne. Le déploiement d'un modèle associe des ressources physiques au modèle afin qu'il puisse diffuser des prédictions en ligne avec une faible latence.

Pour être déployable, le modèle doit être visible dans Vertex AI Model Registry. Pour en savoir plus sur Model Registry, y compris sur la manière d'importer des artefacts de modèles ou de les créer directement dans Model Registry, consultez la page Présentation de Vertex AI Model Registry.

Vous pouvez déployer plusieurs modèles sur un point de terminaison ou le même modèle sur plusieurs points de terminaison. Pour en savoir plus sur les options et les cas d'utilisation de déploiement de modèles, consultez la section Motifs de déploiement de plusieurs modèles sur le même point de terminaison ci-dessous.

Déployer un modèle sur un point de terminaison

Utilisez l'une des méthodes suivantes pour déployer un modèle :

Console Google Cloud

  1. Dans la section Vertex AI de la console Google Cloud, accédez à la page Modèles.

    Accéder à la page des modèles

  2. Cliquez sur le nom et l'ID de version du modèle que vous souhaitez déployer pour ouvrir sa page d'informations.

  3. Sélectionnez l'onglet Déployer et tester.

    Si votre modèle est déjà déployé sur des points de terminaison, ils sont répertoriés dans la section Déployer votre modèle.

  4. Cliquez sur Déployer sur un point de terminaison.

  5. Pour déployer votre modèle sur un nouveau point de terminaison, sélectionnez Créer un point de terminaison et nommez le nouveau point de terminaison. Pour déployer votre modèle sur un point de terminaison existant, sélectionnez Ajouter à un point de terminaison existant, puis sélectionnez le point de terminaison dans la liste déroulante.

    Vous pouvez déployer plusieurs modèles sur un point de terminaison ou déployer le même modèle sur plusieurs points de terminaison.

  6. Si vous déployez votre modèle sur un point de terminaison existant qui contient un ou plusieurs modèles déployés, vous devez mettre à jour le pourcentage de répartition du trafic du modèle que vous déployez et des modèles déjà déployés afin que le pourcentage cumulé de tous les pourcentages soit égal à 100 %.

  7. Si vous déployez votre modèle sur un nouveau point de terminaison, acceptez la valeur 100 pour la répartition du trafic. Sinon, ajustez les valeurs de répartition du trafic pour tous les modèles sur le point de terminaison afin d'atteindre 100.

  8. Saisissez le nombre de nœuds de calcul que vous souhaitez fournir pour votre modèle.

    Il s'agit du nombre de nœuds qui doivent être disponibles pour le modèle à tout moment.

    Les nœuds utilisés vous sont facturés, que ce soit pour gérer la charge de prédiction ou pour les nœuds de secours (minimum), même sans le trafic de prédiction. Consultez la page des tarifs.

    Le nombre de nœuds de calcul peut augmenter en cas de nécessité pour gérer le trafic de prédiction, mais celui-ci ne dépassera jamais le nombre maximal de nœuds.

  9. Pour utiliser l'autoscaling, saisissez le nombre maximal de nœuds de calcul que vous souhaitez que Vertex AI puisse effectuer.

  10. Sélectionnez un type de machine.

    Des ressources de plus grande capacité améliorent les performances des prédictions et augmentent les coûts. Comparez les types de machines disponibles.

  11. Sélectionnez un Type d'accélérateur et un Nombre d'accélérateurs.

    Si vous avez activé l'utilisation de l'accélérateur lorsque vous avez importé ou créé le modèle, cette option s'affiche.

    Pour connaître le nombre d'accélérateurs, consultez la table GPU pour vérifier le nombre de GPU valides que vous pouvez utiliser avec chaque type de machine. Le nombre d'accélérateurs fait référence au nombre d'accélérateurs par nœud, et non au nombre total d'accélérateurs dans votre déploiement.

  12. Si vous souhaitez utiliser un compte de service personnalisé pour le déploiement, sélectionnez un compte de service dans la boîte déroulante Compte de service.

  13. Découvrez comment modifier les paramètres par défaut pour la journalisation des prédictions.

  14. Cliquez sur OK pour votre modèle, et lorsque tous les pourcentages de répartition du trafic sont corrects, cliquez sur Continuer.

    La région dans laquelle le modèle est déployé s'affiche. Il doit s'agir de la région dans laquelle vous avez créé votre modèle.

  15. Cliquez sur Déployer pour déployer votre modèle sur le point de terminaison.

API

Pour déployer un modèle à l'aide de l'API Vertex AI, vous devez effectuer les étapes suivantes :

  1. Create un point de terminaison si nécessaire.
  2. Get l'ID du point de terminaison.
  3. Deploy le modèle sur le point de terminaison.

Créer un point de terminaison

Si vous déployez un modèle sur un point de terminaison existant, vous pouvez ignorer cette étape.

gcloud

L'exemple suivant utilise la commande gcloud ai endpoints create :

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

Remplacez l'élément suivant :

  • LOCATION_ID : région dans laquelle vous utilisez l'IA Vertex.
  • ENDPOINT_NAME : nom du point de terminaison à afficher.

La création du point de terminaison par l'outil Google Cloud CLI peut prendre quelques secondes.

REST

Avant d'utiliser les données de requête, effectuez les remplacements suivants :

  • LOCATION_ID : votre région.
  • PROJECT_ID : l'ID de votre projet.
  • ENDPOINT_NAME : nom du point de terminaison à afficher.

Méthode HTTP et URL : 

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

Corps JSON de la requête :

{
  "display_name": "ENDPOINT_NAME"
}

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

{
  "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"
    }
  }
}
Vous pouvez interroger l'état de l'opération jusqu'à ce que la réponse indique "done": true.

Terraform

L'exemple suivant utilise la ressource Terraform google_vertex_ai_endpoint pour créer un point de terminaison.

Pour savoir comment appliquer ou supprimer une configuration Terraform, consultez la page Commandes Terraform de 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

Avant d'essayer cet exemple, suivez les instructions de configuration pour Java décrites dans le guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI Java.

Pour vous authentifier auprès de Vertex AI, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement 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

Avant d'essayer cet exemple, suivez les instructions de configuration pour Node.js décrites dans le guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI Node.js.

Pour vous authentifier auprès de Vertex AI, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement 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

Pour savoir comment installer ou mettre à jour le SDK Vertex AI pour Python, consultez la section Installer le SDK Vertex AI pour Python. Pour en savoir plus, consultez la documentation de référence de l'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

Récupérer l'ID du point de terminaison

Vous avez besoin de l'ID de point de terminaison pour déployer le modèle.

gcloud

L'exemple suivant utilise la commande gcloud ai endpoints list :

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

Remplacez l'élément suivant :

  • LOCATION_ID : région dans laquelle vous utilisez l'IA Vertex.
  • ENDPOINT_NAME : nom du point de terminaison à afficher.

Notez le nombre qui s'affiche dans la colonne ENDPOINT_ID. Utilisez cet ID à l'étape suivante.

REST

Avant d'utiliser les données de requête, effectuez les remplacements suivants :

  • LOCATION_ID : région dans laquelle vous utilisez Vertex AI.
  • PROJECT_ID : l'ID de votre projet.
  • ENDPOINT_NAME : nom du point de terminaison à afficher.

Méthode HTTP et URL : 

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

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

{
  "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"
    }
  ]
}
Notez l'élément ENDPOINT_ID.

Déployer le modèle

Sélectionnez l'onglet correspondant à votre langage ou à votre environnement :

gcloud

Les exemples suivants utilisent la commande gcloud ai endpoints deploy-model.

L'exemple suivant déploie un Model sur un Endpoint sans utiliser de GPU pour accélérer la diffusion des prédictions et répartir le trafic entre plusieurs ressources DeployedModel :

Avant d'utiliser les données de la commande ci-dessous, effectuez les remplacements suivants :

  • ENDPOINT_ID : ID du point de terminaison.
  • LOCATION_ID : région dans laquelle vous utilisez Vertex AI.
  • MODEL_ID : ID du modèle à déployer.
  • DEPLOYED_MODEL_NAME : nom de l'élément DeployedModel. Vous pouvez également utiliser le nom à afficher du Model pour le DeployedModel.
  • MIN_REPLICA_COUNT : nombre minimal de nœuds pour ce déploiement. Le nombre de nœuds peut être augmenté ou réduit selon les besoins de la charge de prédiction, dans la limite du nombre maximal de nœuds et jamais moins que ce nombre de nœuds.
  • MAX_REPLICA_COUNT : nombre maximal de nœuds pour ce déploiement. Le nombre de nœuds peut être augmenté ou diminué selon les besoins de la charge de prédiction, jusqu'à atteindre ce nombre de nœuds mais jamais moins que le nombre minimal de nœuds. Si vous omettez l'option --max-replica-count, le nombre maximal de nœuds est défini sur la valeur de --min-replica-count.

Exécutez la commande 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
 

Répartir le trafic

L'option --traffic-split=0=100 des exemples précédents envoie 100 % du trafic de prédiction que Endpoint reçoit à la nouvelle ressource DeployedModel, correspondant à l'ID temporaire 0. Si votre Endpoint dispose déjà d'autres ressources DeployedModel, vous pouvez répartir le trafic entre le nouveau DeployedModel et les anciens. Par exemple, pour envoyer 20 % du trafic vers le nouveau DeployedModel et 80 % vers une ressource plus ancienne, exécutez la commande suivante.

Avant d'utiliser les données de la commande ci-dessous, effectuez les remplacements suivants :

  • OLD_DEPLOYED_MODEL_ID : ID de la ressource DeployedModel existante.

Exécutez la commande 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

déployer le modèle ;

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • LOCATION_ID : région dans laquelle vous utilisez Vertex AI.
  • PROJECT_ID : l'ID de votre projet.
  • ENDPOINT_ID : ID du point de terminaison.
  • MODEL_ID : ID du modèle à déployer.
  • DEPLOYED_MODEL_NAME : nom de l'élément DeployedModel. Vous pouvez également utiliser le nom à afficher du Model pour le DeployedModel.
  • MACHINE_TYPE : facultatif. Ressources machine utilisées pour chaque nœud de ce déploiement. Le paramètre par défaut est n1-standard-2. En savoir plus sur les types de machines.
  • ACCELERATOR_TYPE : type d'accélérateur à associer à la machine. Facultatif si ACCELERATOR_COUNT n'est pas spécifié ou est égal à zéro. Il n'est pas recommandé pour les modèles AutoML ni les modèles personnalisés qui utilisent des images non GPU. En savoir plus
  • ACCELERATOR_COUNT : nombre d'accélérateurs pour chaque instance dupliquée à utiliser. Facultatif. Doit être égal à zéro ou non spécifié pour les modèles AutoML ou les modèles personnalisés qui utilisent des images non GPU.
  • MIN_REPLICA_COUNT : nombre minimal de nœuds pour ce déploiement. Le nombre de nœuds peut être augmenté ou réduit selon les besoins de la charge de prédiction, dans la limite du nombre maximal de nœuds et jamais moins que ce nombre de nœuds. Cette valeur doit être supérieure ou égale à 1.
  • MAX_REPLICA_COUNT : nombre maximal de nœuds pour ce déploiement. Le nombre de nœuds peut être augmenté ou diminué selon les besoins de la charge de prédiction, jusqu'à atteindre ce nombre de nœuds mais jamais moins que le nombre minimal de nœuds.
  • TRAFFIC_SPLIT_THIS_MODEL : pourcentage du trafic de prédiction vers ce point de terminaison à acheminer vers le modèle déployé avec cette opération. La valeur par défaut est 100. La somme des pourcentages de trafic doit être égale à 100. En savoir plus sur la répartition du trafic.
  • DEPLOYED_MODEL_ID_N : facultatif. Si d'autres modèles sont déployés sur ce point de terminaison, vous devez mettre à jour les pourcentages de répartition du trafic pour que le pourcentage cumulé de tous les pourcentages soit égal à 100.
  • TRAFFIC_SPLIT_MODEL_N : valeur en pourcentage de la répartition du trafic pour la clé de l'ID de modèle déployé.
  • PROJECT_NUMBER : numéro de projet généré automatiquement pour votre projet

Méthode HTTP et URL : 

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

Corps JSON de la requête :

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

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

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

Avant d'essayer cet exemple, suivez les instructions de configuration pour Java décrites dans le guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI Java.

Pour vous authentifier auprès de Vertex AI, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement 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

Pour savoir comment installer ou mettre à jour le SDK Vertex AI pour Python, consultez la section Installer le SDK Vertex AI pour Python. Pour en savoir plus, consultez la documentation de référence de l'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

Avant d'essayer cet exemple, suivez les instructions de configuration pour Node.js décrites dans le guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI Node.js.

Pour vous authentifier auprès de Vertex AI, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement 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);
  });

Découvrez comment modifier les paramètres par défaut pour la journalisation des prédictions.

Obtenir l'état de l'opération

Certaines requêtes démarrent des opérations de longue durée qui nécessitent du temps. Ces requêtes renvoient un nom d'opération, que vous pouvez utiliser pour afficher l'état de l'opération ou pour annuler l'opération. Vertex AI propose des méthodes d'assistance pour appeler les opérations de longue durée. Pour en savoir plus, consultez la section Travailler avec des opérations de longue durée.

Limites

  • Si vous avez activé VPC Service Controls, le conteneur de votre modèle déployé n'aura pas accès à Internet.

Configurer le déploiement du modèle

Lors du déploiement du modèle, vous prenez les décisions importantes suivantes concernant l'exécution de la prédiction en ligne :

Ressource créée Paramètre spécifié lors de la création de la ressource
Point de terminaison Emplacement dans lequel exécuter les prédictions
Modèle Conteneur à utiliser (ModelContainerSpec)
DeployedModel Machines à utiliser pour la prédiction en ligne

Vous ne pouvez pas mettre à jour ces paramètres répertoriés après la création initiale du modèle ou du point de terminaison, et vous ne pouvez pas les remplacer dans la requête de prédiction en ligne. Pour modifier ces paramètres, vous devez redéployer votre modèle.

Déroulement du déploiement d'un modèle

Lorsque vous déployez un modèle sur un point de terminaison, vous associez des ressources physiques (machine) au modèle afin qu'il puisse diffuser les prédictions en ligne. Les prédictions en ligne présentent des exigences de latence faible. Fournir des ressources au modèle à l'avance réduit la latence.

Le type d'entraînement (AutoML ou personnalisé) et le type de données (AutoML) du modèle déterminent les types de ressources physiques disponibles pour le modèle. Après le déploiement du modèle, vous pouvez mutate certaines de ces ressources sans créer de déploiement.

La ressource de point de terminaison fournit le point de terminaison (URL) du service que vous utilisez pour demander la prédiction. Exemple :

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

Motifs de déploiement de plusieurs modèles sur le même point de terminaison

Le déploiement de deux modèles sur le même point de terminaison vous permet de remplacer progressivement un modèle par l'autre. Par exemple, supposons que vous utilisiez un modèle et que vous cherchiez un moyen d'améliorer la précision de ce modèle avec de nouvelles données d'entraînement. Toutefois, vous ne souhaitez pas mettre à jour votre application pour qu'elle pointe vers une nouvelle URL de point de terminaison et vous ne souhaitez pas modifier soudainement l'application. Vous pouvez ajouter le nouveau modèle au même point de terminaison, diffuser un petit pourcentage de trafic, puis augmenter progressivement la répartition du trafic pour le nouveau modèle jusqu'à ce qu'il diffuse 100% du trafic.

Étant donné que les ressources sont associées au modèle plutôt qu'au point de terminaison, vous pouvez déployer des modèles de différents types sur le même point de terminaison. Toutefois, la bonne pratique consiste à déployer des modèles d'un type spécifique (par exemple tabulaire AutoML, entraînement personnalisé) sur un point de terminaison. Cette configuration est plus facile à gérer.

Motifs de déploiement d'un modèle sur plusieurs points de terminaison

Vous souhaitez peut-être déployer vos modèles avec différentes ressources pour divers environnements d'application, tels que les tests et la production. Vous pouvez également être compatible avec différents SLO pour vos requêtes de prédiction. Il est possible que l'une de vos applications présente des besoins de performances bien plus élevés que les autres. Dans ce cas, vous avez la possibilité de déployer ce modèle sur un point de terminaison plus performant avec davantage de ressources de machine. Pour optimiser les coûts, vous pouvez également déployer le modèle sur un point de terminaison à faible performances avec moins de ressources de machine.

Comportement du scaling

Lorsque vous déployez un modèle pour la prédiction en ligne en tant que DeployedModel, vous pouvez configurer les nœuds de prédiction pour qu'ils assurent le scaling automatique. Pour ce faire, définissez dedicatedResources.maxReplicaCount sur une valeur supérieure à dedicatedResources.minReplicaCount.

Lorsque vous configurez un DeployedModel, vous devez définir dedicatedResources.minReplicaCount sur une valeur d'au moins 1. En d'autres termes, vous ne pouvez pas configurer le modèle DeployedModel pour qu'il soit réduit à 0 nœud de prédiction lorsqu'il n'est pas utilisé.

Utilisation cible et configuration

Par défaut, si vous déployez un modèle sans ressources GPU dédiées, Vertex AI ajuste automatiquement le nombre d'instances dupliquées afin que l'utilisation du processeur corresponde à la valeur par défaut de 60 %.

Par défaut, si vous déployez un modèle avec des ressources GPU dédiées (si machineSpec.accelerator_count est supérieur à 0), Vertex AI effectuera automatiquement un scaling à la hausse ou à la baisse du nombre d'instances répliquées jusqu'à ce que l'utilisation du CPU ou du GPU (selon la valeur la plus élevée) corresponde à la valeur cible par défaut de 60 %. Par conséquent, si votre débit de prédiction entraîne une utilisation élevée des GPU, mais pas une utilisation élevée du processeur, Vertex AI effectue un scaling à la hausse, et l'utilisation du processeur sera très faible, ce qui est visible dans la surveillance. Si votre conteneur personnalisé sous-utilise les GPU, mais dispose d'un processus sans lien qui entraîne une utilisation du CPU supérieure à 60 %, Vertex AI effectue un scaling à la hausse, même si cela n'était peut-être pas nécessaire pour atteindre les objectifs de RPS et de latence.

Vous pouvez remplacer la métrique de seuil et la cible par défaut en spécifiant autoscalingMetricSpecs. Notez que si votre déploiement est configuré pour évoluer uniquement en fonction de l'utilisation du processeur, il ne peut pas évoluer à la hausse, même si l'utilisation du GPU est élevée.

Gérer l'utilisation des ressources

Vous pouvez surveiller votre point de terminaison pour effectuer le suivi de métriques telles que l'utilisation du processeur et de l'accélérateur, le nombre de requêtes, la latence, ainsi que le nombre actuel et cible d'instances dupliquées. Ces informations peuvent vous aider à comprendre le comportement des ressources et leur utilisation des points de terminaison.

N'oubliez pas que chaque instance dupliquée n'exécute qu'un seul conteneur. Cela signifie que si un conteneur de prédiction ne peut pas utiliser pleinement la ressource de calcul sélectionnée, telle que du code à thread unique pour une machine multicœur ou un modèle personnalisé qui appelle un autre service dans le cadre de la prédiction, il est possible que le scaling à la hausse de vos nœuds ne soit pas effectué.

Par exemple, si vous utilisez FastAPI ou tout serveur de modèles comportant un nombre configurable de nœuds de calcul ou de threads, il existe de nombreux cas où l'utilisation de plusieurs nœuds de calcul peut augmenter l'utilisation des ressources. Cela permet au service d'adapter automatiquement le nombre d'instances dupliquées.

Nous vous recommandons généralement de commencer par un nœud de calcul ou un thread par cœur. Si vous remarquez que l'utilisation du processeur est faible, en particulier en cas de charge élevée, ou que votre modèle n'effectue pas de scaling à la hausse, car l'utilisation du CPU est faible, augmentez le nombre de nœuds de calcul. En revanche, si vous remarquez que l'utilisation est trop élevée et que vos latences augmentent plus que prévu sous la charge, diminuez le nombre de nœuds de calcul. Si vous n'utilisez qu'un seul nœud de calcul, utilisez un type de machine plus petit.

Comportement et délai du scaling

Vertex AI ajuste le nombre d'instances dupliquées toutes les 15 secondes à l'aide des données de la fenêtre des 5 minutes précédentes. Pour chaque cycle de 15 secondes, le système mesure l'utilisation du serveur et génère un nombre cible d'instances dupliquées selon la formule suivante :

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

Par exemple, si deux instances répliquées sont actuellement utilisées à 100 %, la cible est de 4 :

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

Autre exemple, si vous avez actuellement 10 instances répliquées et que l'utilisation chute à 1 %, la cible est de 1 :

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

À la fin de chaque cycle de 15 secondes, le système ajuste le nombre d'instances dupliquées afin qu'elles correspondent à la valeur cible la plus élevée de la fenêtre des 5 minutes précédentes. Notez que comme la valeur choisie est la valeur cible la plus élevée, votre point de terminaison n'effectue pas de scaling à la baisse en cas de pic d'utilisation pendant cet intervalle de 5 minutes, même si l'utilisation globale est très faible. En revanche, si le système doit faire l'objet d'un scaling à la hausse, il le fera dans les 15 secondes, car la valeur cible la plus élevée est choisie plutôt que la moyenne.

Gardez à l'esprit que même après que Vertex AI ajuste le nombre d'instances dupliquées, le démarrage ou la désactivation des instances dupliquées prend un certain temps. Ainsi, il existe un délai supplémentaire avant que le point de terminaison puisse s'adapter au trafic. Les principaux facteurs qui contribuent à ce délai sont les suivants :

  • Temps de provisionnement et de démarrage des VM Compute Engine
  • Heure du téléchargement du conteneur à partir du registre
  • Temps de chargement du modèle depuis l'espace de stockage

La meilleure façon de comprendre le comportement de scaling réel de votre modèle consiste à exécuter un test de charge et à optimiser les caractéristiques importantes pour votre modèle et votre cas d'utilisation. Si l'autoscaler n'effectue pas un scaling assez rapide pour votre application, provisionnez suffisamment de min_replicas pour gérer le trafic de référence attendu.

Mettre à jour la configuration du scaling

Si vous avez spécifié une valeur pour DedicatedResources ou AutomaticResources lorsque vous avez déployé le modèle, vous pouvez mettre à jour la configuration du scaling sans redéployer le modèle en appelant mutateDeployedModel.

Par exemple, la requête suivante met à jour max_replica et autoscaling_metric_specs, et désactive la journalisation des conteneurs.

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

Consignes d'utilisation :

  • Vous ne pouvez pas modifier le type de machine ni passer de DedicatedResources à AutomaticResources, ou inversement. Les seuls champs de configuration de scaling que vous pouvez modifier sont : min_replica, max_replica et AutoscalingMetricSpec (DedicatedResources uniquement).
  • Vous devez répertorier tous les champs que vous souhaitez mettre à jour dans updateMask. Les champs non répertoriés sont ignorés.
  • L'état DeployedModel doit être à l'état DEPLOYED. Il peut y avoir au plus une opération de mutation active par modèle déployé.
  • mutateDeployedModel vous permet également d'activer ou de désactiver la journalisation des conteneurs. Pour en savoir plus, consultez la section Journalisation des prédictions en ligne.

Étapes suivantes