Cette page a été traduite par l'API Cloud Translation.

Exporter des modèles tabulaires AutoML

Cette page explique comment utiliser Vertex AI pour exporter votre modèle tabulaire AutoML vers Cloud Storage, télécharger le modèle sur un serveur sur site ou un serveur hébergé par un autre fournisseur cloud, puis utiliser Docker pour rendre le modèle disponible pour les prédictions.

Pour en savoir plus sur l'exportation de modèles Edge d'images et vidéo, consultez Exporter des modèles AutoML Edge.

Après avoir exporté votre modèle tabulaire, si vous souhaitez le réimporter dans Vertex AI, consultez Importer des modèles dans Vertex AI.

Limites

L'exportation de modèles tabulaires AutoML présente les limites suivantes :

Vous ne pouvez exporter que les modèles de classification et de régression tabulaires AutoML. L'exportation de modèles de prévision tabulaires AutoML n'est pas acceptée.
Vertex Explainable AI n'est pas disponible avec les modèles tabulaires exportés. Si vous devez utiliser Vertex Explainable AI, vous devez livrer des prédictions à partir d'un modèle hébergé par Vertex AI.
Le modèle tabulaire exporté ne peut s'exécuter que sur les processeurs d'architecture x86 compatibles avec les ensembles d'instructions AVX (Advanced Vector Extensions).

Processus d'exportation

Voici la procédure à suivre pour exporter votre modèle :

Configurez votre environnement.
Exportez le modèle.
Extrayez et exécutez le serveur de modèles.
Demandez des prédictions.

Avant de commencer

Avant de pouvoir effectuer cette tâche, vous devez avoir réalisé les opérations suivantes :

Configurez votre projet comme décrit dans Configurer un projet et un environnement de développement.
Entraînez le modèle que vous souhaitez télécharger.
Installez et initialisez la Google Cloud CLI sur le serveur que vous utiliserez pour exécuter le modèle exporté.
Installez Docker sur votre serveur.

Exporter le modèle

Console

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

Accéder à la page "Modèles"
Cliquez sur le modèle tabulaire que vous souhaitez exporter pour ouvrir sa page d'informations.
Cliquez sur Exporter dans la barre de boutons pour exporter votre modèle.
Sélectionnez ou créez un dossier Cloud Storage à l'emplacement souhaité.

Le bucket doit répondre aux exigences concernant les buckets.

Vous ne pouvez pas exporter un modèle vers un bucket de niveau supérieur. Vous devez utiliser au moins un niveau de dossier.

Pour de meilleurs résultats, créez un dossier vide. Vous copierez l'intégralité du contenu du dossier à une étape ultérieure.
Cliquez sur Exporter.

Vous allez télécharger le modèle exporté sur votre serveur dans la section suivante.

REST

Vous utilisez la méthode models.export pour exporter un modèle vers Cloud Storage.

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

LOCATION : votre région.
PROJECT : ID de votre projet.
MODEL_ID : ID du modèle que vous souhaitez exporter.
GCS_DESTINATION : dossier de destination dans Cloud Storage. Par exemple : gs://export-bucket/exports.
Vous ne pouvez pas exporter un modèle vers un bucket de niveau supérieur. Vous devez utiliser au moins un niveau de dossier.

Ce dossier doit respecter les exigences concernant les buckets.

Pour de meilleurs résultats, créez un dossier. Vous copierez l'intégralité du contenu du dossier lors d'une prochaine étape.

Méthode HTTP et URL :

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID:export

Corps JSON de la requête :

{
  "outputConfig": {
    "exportFormatId": "tf-saved-model",
    "artifactDestination": {
      "outputUriPrefix": "GCS_DESTINATION"
    }
  }
}

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 print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID:export"

PowerShell

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

$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-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID:export" | Select-Object -Expand Content

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

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION/models/MODEL_ID/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.v1.ExportModelOperationMetadata",
    "genericMetadata": {
      "createTime": "2020-10-12T20:53:40.130785Z",
      "updateTime": "2020-10-12T20:53:40.130785Z"
    },
    "outputInfo": {
      "artifactOutputUri": "gs://OUTPUT_BUCKET/model-MODEL_ID/EXPORT_FORMAT/YYYY-MM-DDThh:mm:ss.sssZ"
    }
  }
}

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.ExportModelOperationMetadata;
import com.google.cloud.aiplatform.v1.ExportModelRequest;
import com.google.cloud.aiplatform.v1.ExportModelResponse;
import com.google.cloud.aiplatform.v1.GcsDestination;
import com.google.cloud.aiplatform.v1.ModelName;
import com.google.cloud.aiplatform.v1.ModelServiceClient;
import com.google.cloud.aiplatform.v1.ModelServiceSettings;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class ExportModelTabularClassificationSample {
  public static void main(String[] args)
      throws InterruptedException, ExecutionException, TimeoutException, IOException {
    // TODO(developer): Replace these variables before running the sample.
    String gcsDestinationOutputUriPrefix = "gs://your-gcs-bucket/destination_path";
    String project = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    exportModelTableClassification(gcsDestinationOutputUriPrefix, project, modelId);
  }

  static void exportModelTableClassification(
      String gcsDestinationOutputUriPrefix, String project, String modelId)
      throws IOException, ExecutionException, InterruptedException, 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";
      ModelName modelName = ModelName.of(project, location, modelId);

      GcsDestination.Builder gcsDestination = GcsDestination.newBuilder();
      gcsDestination.setOutputUriPrefix(gcsDestinationOutputUriPrefix);
      ExportModelRequest.OutputConfig outputConfig =
          ExportModelRequest.OutputConfig.newBuilder()
              .setExportFormatId("tf-saved-model")
              .setArtifactDestination(gcsDestination)
              .build();

      OperationFuture<ExportModelResponse, ExportModelOperationMetadata> exportModelResponseFuture =
          modelServiceClient.exportModelAsync(modelName, outputConfig);
      System.out.format(
          "Operation name: %s\n", exportModelResponseFuture.getInitialFuture().get().getName());
      System.out.println("Waiting for operation to finish...");
      ExportModelResponse exportModelResponse =
          exportModelResponseFuture.get(300, TimeUnit.SECONDS);
      System.out.format(
          "Export Model Tabular Classification Response: %s", exportModelResponse.toString());
    }
  }
}

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 sur l'utilisation des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI Node.js.

/**
 * TODO(developer): Uncomment these variables before running the sample.\
 * (Not necessary if passing values as arguments)
 */

// const gcsDestinationOutputUriPrefix ='YOUR_GCS_DESTINATION_\
// OUTPUT_URI_PREFIX'; eg. "gs://<your-gcs-bucket>/destination_path"
// const modelId = 'YOUR_MODEL_ID';
// 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 exportModelTabularClassification() {
  // Configure the name resources
  const name = `projects/${project}/locations/${location}/models/${modelId}`;
  // Configure the outputConfig resources
  const outputConfig = {
    exportFormatId: 'tf-saved-model',
    artifactDestination: {
      outputUriPrefix: gcsDestinationOutputUriPrefix,
    },
  };
  const request = {
    name,
    outputConfig,
  };

  // Export Model request
  const [response] = await modelServiceClient.exportModel(request);
  console.log(`Long running operation : ${response.name}`);

  // Wait for operation to complete
  await response.promise();
  console.log(`Export model response : ${JSON.stringify(response.result)}`);
}
exportModelTabularClassification();

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.

from google.cloud import aiplatform_v1beta1


def export_model_tabular_classification_sample(
    project: str,
    model_id: str,
    gcs_destination_output_uri_prefix: str,
    location: str = "us-central1",
    api_endpoint: str = "us-central1-aiplatform.googleapis.com",
    timeout: int = 300,
):
    # The AI Platform services require regional API endpoints.
    client_options = {"api_endpoint": api_endpoint}
    # Initialize client that will be used to create and send requests.
    # This client only needs to be created once, and can be reused for multiple requests.
    client = aiplatform_v1beta1.ModelServiceClient(client_options=client_options)
    gcs_destination = {"output_uri_prefix": gcs_destination_output_uri_prefix}
    output_config = {
        "artifact_destination": gcs_destination,
        "export_format_id": "tf-saved-model",
    }
    name = client.model_path(project=project, location=location, model=model_id)
    response = client.export_model(name=name, output_config=output_config)
    print("Long running operation:", response.operation.name)
    print("output_info:", response.metadata.output_info)
    export_model_response = response.result(timeout=timeout)
    print("export_model_response:", export_model_response)

Obtenir l'état de l'opération d'exportation

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 Travailler avec des opérations de longue durée.

Extraire et exécuter le serveur de modèle

Dans cette tâche, vous allez télécharger le modèle exporté à partir de Cloud Storage et démarrer le conteneur Docker pour que votre modèle soit prêt à recevoir des requêtes de prédiction.

Pour extraire et exécuter le serveur de modèles :

Sur la machine sur laquelle vous allez exécuter le modèle, accédez au répertoire dans lequel vous souhaitez enregistrer le modèle exporté.
Téléchargez le modèle exporté :
```
gcloud storage cp <var>gcs-destination</var> . --recursive
```
Où gcs-destination est le chemin d'accès à l'emplacement du modèle exporté dans Cloud Storage.

Le modèle est copié dans votre répertoire actuel, sous le chemin d'accès suivant :

./model-<model-id>/tf-saved-model/<export-timestamp>

Le chemin d'accès peut contenir tf-saved-model ou custom-trained.
Renommez le répertoire afin que le code temporel soit supprimé.
```
mv model-<model-id>/tf-saved-model/<export-timestamp> model-<model-id>/tf-saved-model/<new-dir-name>
```
Le code temporel rend le répertoire non valide pour Docker.
Extraire l'image Docker du serveur de modèles
```
sudo docker pull MODEL_SERVER_IMAGE
```
L'image du serveur de modèles à extraire se trouve dans le fichier environment.json du répertoire du modèle exporté. Il doit comporter le chemin suivant :

./model-<model-id>/tf-saved-model/<new-dir-name>/environment.json

Si aucun fichier environment.json n'est présent, utilisez :

MULTI_REGION-docker.pkg.dev/vertex-ai/automl-tabular/prediction-server-v1

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.

Démarrez le conteneur Docker en utilisant le nom de répertoire que vous venez de créer :

docker run -v `pwd`/model-<model-id>/tf-saved-model/<new-dir-name>:/models/default -p 8080:8080 -it MODEL_SERVER_IMAGE

Vous pouvez arrêter le serveur de modèle à tout moment à l'aide de Ctrl-C.

Mettre à jour le conteneur Docker du serveur de modèle

Étant donné que vous téléchargez le conteneur Docker du serveur de modèle lors de l'exportation du modèle, vous devez explicitement mettre à jour le serveur de modèle pour obtenir des mises à niveau et des corrections de bugs. Vous devez mettre à jour le serveur de modèle régulièrement à l'aide de la commande suivante :

docker pull MODEL_SERVER_IMAGE

Assurez-vous que l'URI de l'image Docker correspond à l'URI de l'image Docker que vous avez extraite précédemment.

Obtenir des prédictions du modèle exporté

Le serveur de modèle du conteneur d'images Vertex AI traite les requêtes de prédiction et renvoie les résultats des prédictions.

Les prédictions par lots ne sont pas disponibles pour les modèles exportés.

Format des données de prédiction

Vous renseignez le champ de données payload pour votre requête de prédiction au format JSON suivant :

{ "instances": [ { "column_name_1": value, "column_name_2": value, … } , … ] }

L'exemple suivant montre une requête comportant trois colonnes : une colonne catégorielle, un tableau numérique et un struct. La requête contient deux lignes.

{
  "instances": [
    {
      "categorical_col": "mouse",
      "num_array_col": [
        1,
        2,
        3
      ],
      "struct_col": {
        "foo": "piano",
        "bar": "2019-05-17T23:56:09.05Z"
      }
    },
    {
      "categorical_col": "dog",
      "num_array_col": [
        5,
        6,
        7
      ],
      "struct_col": {
        "foo": "guitar",
        "bar": "2019-06-17T23:56:09.05Z"
      }
    }
  ]
}

Envoyer la requête de prédiction

Copiez les données de votre requête dans un fichier texte, par exemple tmp/request.json.

Le nombre de lignes de données dans la requête de prédiction, dénommé taille de mini-lot, a une incidence sur la latence et le débit de la prédiction. Plus la taille du mini-lot est élevée, plus la latence et le débit augmentent. Pour réduire la latence, diminuez la taille de mini-lot. Pour augmenter le débit, augmentez la taille de mini-lot. Les tailles de mini-lot les plus couramment utilisées sont 1, 32, 64, 128, 256, 512 et 1024.

Demandez la prédiction :

curl -X POST --data @/tmp/request.json http://localhost:8080/predict

Format des résultats de la prédiction

Le format des résultats dépend de l'objectif de votre modèle.

Résultats d'un modèle de classification

Les résultats de la prédiction pour les modèles de classification (binaires et multiclasses) affichent un score de probabilité pour chaque valeur potentielle de la colonne cible. Vous devez déterminer comment vous souhaitez utiliser les scores. Par exemple, pour obtenir une classification binaire à partir des scores fournis, vous devez identifier une valeur de seuil. S'il existe deux classes, A et B, vous devez classer l'exemple dans A si le score de A est supérieur au seuil choisi, et dans B dans le cas contraire. Pour les ensembles de données déséquilibrées, le seuil peut atteindre 100 % ou 0 %.

La charge utile des résultats d'un modèle de classification ressemble à ce qui suit :

{
  "predictions": [
    {
      "scores": [
        0.539999994635582,
        0.2599999845027924,
        0.2000000208627896
      ],
      "classes": [
        "apple",
        "orange",
        "grape"
      ]
    },
    {
      "scores": [
        0.23999999463558197,
        0.35999998450279236,
        0.40000002086278963
      ],
      "classes": [
        "apple",
        "orange",
        "grape"
      ]
    }
  ]
}

Résultats d'un modèle de régression

Une valeur prédite s'affiche pour chaque ligne valide de la requête de prédiction. Les intervalles de prédiction ne s'affichent pas pour les modèles exportés.

La charge utile des résultats d'un modèle de régression ressemble à ce qui suit :

{
  "predictions": [
    {
      "value": -304.3663330078125,
      "lower_bound": -56.32196807861328,
      "upper_bound": 126.51904296875
    },
    {
      "value": -112.3663330078125,
      "lower_bound": 16.32196807861328,
      "upper_bound": 255.51904296875
    }
  ]
}

Étape suivante

Découvrez comment réimporter votre modèle tabulaire exporté dans Vertex AI.