Importer des modèles dans Vertex AI

Ce guide explique comment importer des modèles existants que vous avez entraînés en dehors de l'IA Vertex, ou que vous avez entraînés à l'aide de Vertex AI et exportés. Après avoir importé votre modèle, vous obtenez un modèle dans Vertex AI, que vous pouvez déployer sur un point de terminaison, puis utiliser pour demander des prédictions.

Conteneurs prédéfinis ou personnalisés

Lorsque vous importez un modèle, vous l'associez à un conteneur permettant à Vertex AI d'exécuter des requêtes de prédiction. Vous pouvez utiliser des conteneurs prédéfinis fournis par Vertex AI, ou utiliser vos propres conteneurs personnalisés que vous créez et transférez vers Container Registry ou Artifact Registry

Vous pouvez utiliser un conteneur prédéfini si votre modèle répond aux exigences suivantes :

Si vous importez un modèle AutoML tabulaire que vous avez précédemment exporté, vous devez utiliser un conteneur personnalisé spécifique fourni par Vertex AI.

Sinon, créez un conteneur personnalisé ou utilisez un conteneur personnalisé existant que vous avez dans Container Registry ou Artifact Registry.

Importer des artefacts de modèle dans Cloud Storage

Vous devez stocker vos artefacts de modèle dans un bucket Cloud Storage, où la région du bucket correspond au point de terminaison régional que vous utilisez. La taille totale du fichier contenant les artefacts du modèle doit être inférieure ou égale à 10 Go.

Si votre bucket Cloud Storage se trouve dans un autre projet Google Cloud, vous devez accorder l'accès à Vertex AI pour lire les artefacts de votre modèle.

Si vous utilisez un conteneur prédéfini, assurez-vous que le nom de vos artefacts de modèles correspond exactement aux exemples suivants :

  • Modèle SavedModel TensorFlow : saved_model.pb
  • scikit-learn : model.joblib ou model.pkl
  • XGBoost : model.bst

Découvrez comment exporter des artefacts de modèle pour la prédiction.

Importer un modèle à l'aide de Cloud Console

Pour importer un modèle à l'aide de Cloud Console, procédez comme suit :

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

    Accéder à la page des modèles

  2. Cliquez sur Import (Importer).

  3. Nom et région : saisissez le nom du modèle. Sélectionnez la région qui correspond à la région de votre bucket et au point de terminaison régional Vertex AI que vous utilisez. Cliquez sur Continue (Continuer).

  4. En développant Options avancées, vous pouvez éventuellement décider d'ajouter une clé de chiffrement gérée par le client.

Selon le type de conteneur que vous utilisez, sélectionnez l'onglet approprié ci-dessous.

Conteneur prédéfini

  1. Sélectionnez Importer des artefacts de modèle dans un nouveau conteneur prédéfini.

  2. Sélectionnez le framework de modèle et la version du framework de modèle que vous avez utilisés pour entraîner le modèle.

  3. Si vous souhaitez utiliser des GPU pour diffuser des prédictions, définissez le type d'accélérateur sur GPU.

    Vous sélectionnerez le type de GPU ultérieurement, lorsque vous déploierez le modèle sur un point de terminaison.

  4. Indiquez le chemin d'accès Cloud Storage au répertoire contenant les artefacts de votre modèle.

    Exemple : gs://BUCKET_NAME/models/

  5. Laissez le champ Predict schemata (Schémas de prédiction) vide.

  6. Pour importer votre modèle sans paramètres Vertex Explainable IA, cliquez sur Importer.

    Une fois l'importation terminée, votre modèle s'affiche sur la page Modèles.

    Sinon, poursuivez la configuration du modèle en saisissant vos paramètres d'explicabilité dans l'onglet Explicabilité. En savoir plus sur les paramètres d'explicabilité.

Conteneur personnalisé

  1. Sélectionnez Importer un conteneur personnalisé existant.

  2. Définissez l'URI de l'image de conteneur.

  3. Si vous souhaitez fournir des artefacts de modèle en plus d'une image de conteneur, spécifiez le chemin d'accès Cloud Storage au répertoire contenant les artefacts de votre modèle.

    Par exemple, gs://BUCKET_NAME/models/.

  4. Spécifiez les valeurs de tous les autres champs.

    Pour en savoir plus sur ces champs facultatifs, cliquez ici.

  5. Pour importer votre modèle sans paramètres Vertex Explainable IA, cliquez sur Importer.

    Une fois l'importation terminée, votre modèle s'affiche sur la page Modèles.

    Sinon, poursuivez la configuration du modèle en saisissant vos paramètres d'explicabilité dans l'onglet Explicabilité. En savoir plus sur les paramètres d'explicabilité.

Conteneur tabulaire AutoML

  1. Sélectionnez Importer un conteneur personnalisé existant.

  2. Dans le champ Image du conteneur, saisissez MULTI_REGION-docker.pkg.dev/vertex-ai/automl-tabular/prediction-server-v1:latest.

    Remplacez MULTI_REGION par us, europe ou asia pour sélectionner le dépôt Docker à partir duquel vous souhaitez extraire l'image Docker. Chaque dépôt fournit la même image Docker, mais le choix de l'emplacement multirégional de Artifact Registry le plus proche de la machine sur laquelle vous exécutez Docker est susceptible de réduire la latence.

  3. Dans le champ Emplacement du package, spécifiez le chemin d'accès Cloud Storage vers le répertoire contenant les artefacts de votre modèle.

    Le chemin d'accès ressemble à l'exemple suivant:

    gs://BUCKET_NAME/models-MODEL_ID/tf-saved-model/TIMESTAMP/

  4. Laissez tous les autres champs vides.

  5. Cliquez sur Import (Importer).

    Une fois l'importation terminée, votre modèle s'affiche sur la page Modèles. Vous pouvez utiliser ce modèle de la même manière que d'autres modèles tabulaires AutoML, à l'exception des modèles tabulaires AutoML importés n'étant pas compatibles avec Explainable AI.

Importer un modèle de manière automatisée

Les exemples suivants montrent comment importer un modèle à l'aide de divers outils :

gcloud

L'exemple suivant utilise la commande gcloud beta ai models upload :

gcloud beta ai models upload \
  --region=LOCATION \
  --display-name=MODEL_NAME \
  --container-image-uri=IMAGE_URI \
  --artifact-uri=PATH_TO_MODEL_ARTIFACT_DIRECTORY

Remplacez l'élément suivant :

  • LOCATION : région dans laquelle vous utilisez Vertex AI.
  • MODEL_NAME : nom à afficher pour l'objet Model.
  • IMAGE_URI : URI de l'image de conteneur à utiliser pour diffuser les prédictions. Exemple : us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.2-1:latest. Utilisez un conteneur prédéfini ou un conteneur personnalisé.
  • PATH_TO_MODEL_ARTIFACT_DIRECTORY : URI Cloud Storage (commençant par gs://) d'un répertoire Cloud Storage contenant les artefacts de modèle.

L'exemple précédent montre toutes les options nécessaires pour importer la plupart des modèles. Si vous n'utilisez pas de conteneur prédéfini pour la prédiction, vous devrez probablement spécifier des options facultatives supplémentaires afin de permettre à AI Platform d'utiliser votre image de conteneur. Ces options, qui commencent par --container-, correspondent aux champs du containerSpec de votre Model.

API REST et ligne de commande

Utilisez l'exemple de code suivant pour importer un modèle à l'aide de la méthode upload de la ressource model.

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

  • LOCATION : région dans laquelle vous utilisez Vertex AI.
  • PROJECT_ID: ID de votre projet ou numéro de projet.
  • MODEL_NAME : nom à afficher pour l'objet Model.
  • MODEL_DESCRIPTION : facultatif. Description du modèle.
  • IMAGE_URI : URI de l'image de conteneur à utiliser pour diffuser les prédictions. Exemple : us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.2-1:latest. Utilisez un conteneur prédéfini ou un conteneur personnalisé.
  • PATH_TO_MODEL_ARTIFACT_DIRECTORY : URI Cloud Storage (commençant par gs://) d'un répertoire Cloud Storage contenant les artefacts de modèle. Cette variable et le champ artifactUri sont facultatifs si vous utilisez un conteneur personnalisé.
  • labels : facultatif. Ensemble de paires clé/valeur pour organiser vos modèles. Exemple :
    • "env" : "prod"
    • "tier" : "backend"
  • Spécifiez les éléments LABEL_NAME et LABEL_VALUE pour toutes les étiquettes que vous souhaitez appliquer à ce pipeline d'entraînement.

Méthode HTTP et URL :

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/models:upload

Corps JSON de la requête :

{
  "model": {
    "displayName": "MODEL_NAME",
    "predictSchemata": {},
    "containerSpec": {
      "imageUri": "IMAGE_URI"
    },
    "artifactUri": "PATH_TO_MODEL_ARTIFACT_DIRECTORY",
    "labels": {
      "LABEL_NAME_1": "LABEL_VALUE_1",
      "LABEL_NAME_2": "LABEL_VALUE_2"
    }
  }
}

Pour envoyer votre requête, choisissez l'une des options suivantes :

curl

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

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

PowerShell

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$cred = gcloud auth application-default 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-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/models:upload" | Select-Object -Expand Content

Java


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.aiplatform.v1.LocationName;
import com.google.cloud.aiplatform.v1.Model;
import com.google.cloud.aiplatform.v1.ModelContainerSpec;
import com.google.cloud.aiplatform.v1.ModelServiceClient;
import com.google.cloud.aiplatform.v1.ModelServiceSettings;
import com.google.cloud.aiplatform.v1.UploadModelOperationMetadata;
import com.google.cloud.aiplatform.v1.UploadModelResponse;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class UploadModelSample {
  public static void main(String[] args)
      throws InterruptedException, ExecutionException, TimeoutException, IOException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "YOUR_PROJECT_ID";
    String modelDisplayName = "YOUR_MODEL_DISPLAY_NAME";
    String metadataSchemaUri =
        "gs://google-cloud-aiplatform/schema/trainingjob/definition/custom_task_1.0.0.yaml";
    String imageUri = "YOUR_IMAGE_URI";
    String artifactUri = "gs://your-gcs-bucket/artifact_path";
    uploadModel(project, modelDisplayName, metadataSchemaUri, imageUri, artifactUri);
  }

  static void uploadModel(
      String project,
      String modelDisplayName,
      String metadataSchemaUri,
      String imageUri,
      String artifactUri)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    ModelServiceSettings modelServiceSettings =
        ModelServiceSettings.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 (ModelServiceClient modelServiceClient = ModelServiceClient.create(modelServiceSettings)) {
      String location = "us-central1";
      LocationName locationName = LocationName.of(project, location);

      ModelContainerSpec modelContainerSpec =
          ModelContainerSpec.newBuilder().setImageUri(imageUri).build();

      Model model =
          Model.newBuilder()
              .setDisplayName(modelDisplayName)
              .setMetadataSchemaUri(metadataSchemaUri)
              .setArtifactUri(artifactUri)
              .setContainerSpec(modelContainerSpec)
              .build();

      OperationFuture<UploadModelResponse, UploadModelOperationMetadata> uploadModelResponseFuture =
          modelServiceClient.uploadModelAsync(locationName, model);
      System.out.format(
          "Operation name: %s\n", uploadModelResponseFuture.getInitialFuture().get().getName());
      System.out.println("Waiting for operation to finish...");
      UploadModelResponse uploadModelResponse = uploadModelResponseFuture.get(5, TimeUnit.MINUTES);

      System.out.println("Upload Model Response");
      System.out.format("Model: %s\n", uploadModelResponse.getModel());
    }
  }
}

Node.js

/**
 * TODO(developer): Uncomment these variables before running the sample.\
 */

// const modelDisplayName = 'YOUR_MODEL_DISPLAY_NAME';
// const metadataSchemaUri = 'YOUR_METADATA_SCHEMA_URI';
// const imageUri = 'YOUR_IMAGE_URI';
// const artifactUri = 'YOUR_ARTIFACT_URI';
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';

// Imports the Google Cloud Model Service Client library
const {ModelServiceClient} = require('@google-cloud/aiplatform');

// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: 'us-central1-aiplatform.googleapis.com',
};

// Instantiates a client
const modelServiceClient = new ModelServiceClient(clientOptions);

async function uploadModel() {
  // Configure the parent resources
  const parent = `projects/${project}/locations/${location}`;
  // Configure the model resources
  const model = {
    displayName: modelDisplayName,
    metadataSchemaUri: '',
    artifactUri: artifactUri,
    containerSpec: {
      imageUri: imageUri,
      command: [],
      args: [],
      env: [],
      ports: [],
      predictRoute: '',
      healthRoute: '',
    },
  };
  const request = {
    parent,
    model,
  };

  console.log('PARENT AND MODEL');
  console.log(parent, model);
  // Upload Model request
  const [response] = await modelServiceClient.uploadModel(request);
  console.log(`Long running operation : ${response.name}`);

  // Wait for operation to complete
  await response.promise();
  const result = response.result;

  console.log('Upload model response ');
  console.log(`\tModel : ${result.model}`);
}
uploadModel();

Python

Cet exemple utilise le SDK Vertex pour Python. Avant d'exécuter l'exemple de code suivant, vous devez configurer l'authentification.

def upload_model_sample(
    project: str,
    location: str,
    display_name: str,
    serving_container_image_uri: str,
    artifact_uri: Optional[str] = None,
    serving_container_predict_route: Optional[str] = None,
    serving_container_health_route: Optional[str] = None,
    description: Optional[str] = None,
    serving_container_command: Optional[Sequence[str]] = None,
    serving_container_args: Optional[Sequence[str]] = None,
    serving_container_environment_variables: Optional[Dict[str, str]] = None,
    serving_container_ports: Optional[Sequence[int]] = None,
    instance_schema_uri: Optional[str] = None,
    parameters_schema_uri: Optional[str] = None,
    prediction_schema_uri: Optional[str] = None,
    explanation_metadata: Optional[explain.ExplanationMetadata] = None,
    explanation_parameters: Optional[explain.ExplanationParameters] = None,
    sync: bool = True,
):

    aiplatform.init(project=project, location=location)

    model = aiplatform.Model.upload(
        display_name=display_name,
        artifact_uri=artifact_uri,
        serving_container_image_uri=serving_container_image_uri,
        serving_container_predict_route=serving_container_predict_route,
        serving_container_health_route=serving_container_health_route,
        instance_schema_uri=instance_schema_uri,
        parameters_schema_uri=parameters_schema_uri,
        prediction_schema_uri=prediction_schema_uri,
        description=description,
        serving_container_command=serving_container_command,
        serving_container_args=serving_container_args,
        serving_container_environment_variables=serving_container_environment_variables,
        serving_container_ports=serving_container_ports,
        explanation_metadata=explanation_metadata,
        explanation_parameters=explanation_parameters,
        sync=sync,
    )

    model.wait()

    print(model.display_name)
    print(model.resource_name)
    return model

Pour importer un modèle avec les paramètres Explainable AI activés, reportez-vous aux exemples d'importation de modèles Explainable AI.

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. L'IA Vertex 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.

Étape suivante