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 :

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

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

{
  "display_name": "ENDPOINT_NAME"
}

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints"

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints" | Select-Object -Expand Content

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

# 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"
  }
}

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

/**
 * 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();

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

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

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

curl -X GET \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints?filter=display_name=ENDPOINT_NAME"

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method GET `
    -Headers $headers `
    -Uri "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints?filter=display_name=ENDPOINT_NAME" | Select-Object -Expand Content

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

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

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

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

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

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

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

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

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

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints/ENDPOINT_ID:deployModel"

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints/ENDPOINT_ID:deployModel" | Select-Object -Expand Content

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

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

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

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

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 :

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

• Découvrez comment obtenir une prédiction en ligne.
• Obtenez des informations sur les points de terminaison privés.