Tabellarische Modelle von AutoML exportieren

Auf dieser Seite wird beschrieben, wie Sie mithilfe von Vertex AI Ihr tabellarisches AutoML-Modell in Cloud Storage exportieren, das Modell auf einen lokalen Server oder einen Server herunterladen, der von einem anderen Cloud-Anbieter gehostet wird, und wie Sie dann mit Docker das Modell für Vorhersagen verfügbar machen.

Informationen zum Exportieren von Bild- und Video-Edge-Modellen finden Sie unter AutoML Edge-Modelle exportieren.

Nachdem Sie Ihr tabellarisches Modell exportiert haben, wenn Sie es wieder in Vertex AI zu importieren möchten, lesen Sie Modelle in Vertex AI importieren.

Beschränkungen

Für den Export von tabellarischen AutoML-Modellen gelten die folgenden Einschränkungen:

  • Sie können nur tabellarische AutoML-Klassifizierungs- und Regressionsmodelle exportieren. Das Exportieren von tabellarischen AutoML-Prognosemodellen wird nicht unterstützt.

  • Vertex Explainable AI ist bei exportierten Tabellenmodellen nicht verfügbar. Wenn Sie Vertex Explainable AI verwenden müssen, müssen Sie Vorhersagen von einem Modell bereitstellen, das von Vertex AI gehostet wird.

  • Das exportierte Tabellenmodell kann nur auf x86-Architektur-CPUs ausgeführt werden, die Befehlssätze für Advanced Vector Extensions (AVX) unterstützen.

Export

Gehen Sie folgendermaßen vor, um Ihr Modell zu exportieren:

  1. Richten Sie die Umgebung ein.
  2. Modell exportieren.
  3. Modellserver ausführen.
  4. Vorhersagen anfordern.

Vorbereitung

Bevor Sie diese Aufgabe durchführen können, müssen Sie die folgenden Aufgaben ausgeführt haben:

  • Richten Sie Ihr Projekt wie in Cloud-Umgebung einrichten beschrieben ein.
  • Das Modell trainieren, das Sie herunterladen möchten.
  • Installieren und initialisieren Sie Cloud SDK auf dem Server, auf dem Sie das exportierte Modell ausführen möchten.
  • Installieren Sie Docker auf Ihrem Server.
  • Rufen Sie per Pull das Modellserver-Docker-Image von Vertex AI ab:

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

    Ersetzen Sie MULTI_REGION durch us, europe oder asia, um das Docker-Repository auszuwählen, aus dem Sie das Docker-Image abrufen möchten. Jedes Repository stellt dasselbe Docker-Image bereit. Es kann jedoch die Latenz verringern, die Multi-Region der Artifact Registry auszuwählen, die der Maschine am nächsten ist, auf der Sie Docker ausführen.

Modell exportieren

Console

  1. Rufen Sie in der Cloud Console unter „Vertex AI“ die Seite Modelle auf.

    Zur Seite "Modelle"

  2. Klicken Sie auf das Tabellenmodell, das Sie exportieren möchten, um die zugehörige Detailseite aufzurufen.

  3. Klicken Sie in der Symbolleiste auf Exportieren, um das Modell zu exportieren.

  4. Wählen Sie einen Cloud Storage-Ordner am gewünschten Standort aus oder erstellen Sie ihn.

    Der Bucket muss die Bucket-Anforderungen erfüllen.

    Sie können ein Modell nicht in einen Bucket der obersten Ebene exportieren. Es muss mindestens eine Ordnerebene vorhanden sein.

    Die besten Ergebnisse erzielen Sie, wenn Sie einen neuen, leeren Ordner erstellen. Sie kopieren den gesamten Inhalt des Ordners in einem späteren Schritt.

  5. Klicken Sie auf Exportieren.

    Im nächsten Abschnitt laden Sie das exportierte Modell auf Ihren Server herunter.

REST UND BEFEHLSZEILE

Sie verwenden die Methode models.export, um ein Modell in Cloud Storage zu exportieren.

Ersetzen Sie dabei folgende Werte für die Anfragedaten:

  • LOCATION: Ihre Region.
  • PROJECT: Ihre Projekt-ID oder Projektnummer
  • MODEL_ID: Die ID des Modells, das Sie exportieren möchten
  • GCS_DESTINATION : Ihr Zielordner in Cloud Storage. Beispiel: gs://export-bucket/exports

    Sie können ein Modell nicht in einen Bucket der obersten Ebene exportieren. Es muss mindestens eine Ordnerebene vorhanden sein.

    Der Ordner muss den Bucket-Anforderungen entsprechen.

    Die besten Ergebnisse erzielen Sie, wenn Sie einen neuen Ordner erstellen. Sie kopieren den gesamten Inhalt des Ordners in einem späteren Schritt.

HTTP-Methode und URL:

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

JSON-Text der Anfrage:

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

Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

curl

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus:

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/locations/LOCATION/models/MODEL_ID:export"

PowerShell

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus:

$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/locations/LOCATION/models/MODEL_ID:export" | Select-Object -Expand Content

Sie sollten in etwa folgende JSON-Antwort erhalten:

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


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

/**
 * 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

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)

Status eines Exportvorgangs abrufen

Einige Anfragen starten lang andauernde Vorgänge, die viel Zeit in Anspruch nehmen. Diese Anfragen geben einen Vorgangsnamen zurück, mit dem Sie den Status des Vorgangs aufrufen oder den Vorgang abbrechen können. Vertex AI stellt Hilfsmethoden bereit, um Aufrufe für Vorgänge mit langer Laufzeit auszuführen. Weitere Informationen finden Sie unter Mit lang andauernden Vorgängen arbeiten.

Modellserver ausführen

In dieser Aufgabe laden Sie das exportierte Modell aus Cloud Storage herunter und starten den Docker-Container, damit Ihr Modell Vorhersageanfragen empfangen kann.

Ihr Modell muss in einem Docker-Container ausgeführt werden.

So führen Sie den Modellserver aus:

  1. Wechseln Sie auf dem Computer, auf dem Sie das Modell ausführen möchten, in das Verzeichnis, in dem Sie das exportierte Modell speichern möchten.

  2. Laden Sie das exportierte Modell herunter:

    gsutil cp -r <var>gcs-destination</var> .
    

    Dabei ist gcs-destination der Pfad zum Speicherort des exportierten Modells in Cloud Storage.

    Das Modell wird unter folgendem Pfad in Ihr aktuelles Verzeichnis kopiert:

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

  3. Benennen Sie das Verzeichnis um, damit der Zeitstempel entfernt wird.

    mv model-<model-id>/tf-saved-model/<export-timestamp> model-<model-id>/tf-saved-model/<new-dir-name>
    

    Der Zeitstempel macht das Verzeichnis für Docker ungültig.

  4. Starten Sie den Docker-Container mit dem gerade erstellten Verzeichnisnamen:

    docker run -v `pwd`/model-<model-id>/tf-saved-model/<new-dir-name>:/models/default -p 8080:8080 -it MULTI_REGION-docker.pkg.dev/vertex-ai/automl-tabular/prediction-server-v1
    

    Ersetzen Sie MULTI_REGION durch den Wert, den Sie im Abschnitt Vorbereitung dieser Anleitung (us, europe oder asia) verwendet haben, sodass der Docker-Image-URI mit dem URI des zuvor abgerufenen Docker-Images übereinstimmt.

Sie können den Modellserver jederzeit mit Ctrl-C stoppen.

Docker-Container des Modellservers aktualisieren

Da Sie den Docker-Container des Modellservers beim Export des Modells herunterladen, müssen Sie den Modellserver explizit aktualisieren, um Updates und Fehlerkorrekturen zu erhalten. Sie sollten den Modellserver mit dem folgenden Befehl regelmäßig aktualisieren:

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

Ersetzen Sie MULTI_REGION durch den Wert, den Sie im Abschnitt Vorbereitung dieses Leitfadens (us, europe oder asia) verwendet haben, sodass der Docker-Image-URI mit dem URI des Docker-Images übereinstimmt, das Sie zuvor abgerufen haben.

Vorhersagen aus dem exportierten Modell abrufen

Der Modellserver im Image-Container von Vertex AI verarbeitet Vorhersageanfragen und gibt Vorhersageergebnisse zurück.

Die Batchvorhersage ist für exportierte Modelle nicht verfügbar.

Datenformat für Vorhersagen

Sie geben die Daten (Feld payload) für Ihre Vorhersageanfrage im folgenden JSON-Format an:

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

Das folgende Beispiel zeigt eine Anfrage mit drei Spalten: eine kategoriale Spalte, ein numerisches Array und eine Struktur. Die Anfrage enthält zwei Zeilen.

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

Vorhersageanfrage stellen

  1. Fügen Sie Ihre Anfragedaten in eine Textdatei ein, z. B. tmp/request.json.

    Die Anzahl der Datenzeilen in der Vorhersageanfrage, die als Minibatch-Größe bezeichnet wird, wirkt sich auf die Latenz der Vorhersage und den Durchsatz aus. Je größer die Minibatch-Größe, desto höher die Latenz und der Durchsatz. Verwenden Sie für eine reduzierte Latenz eine kleinere Minibatch-Größe. Für einen höheren Durchsatz erhöhen Sie die Minibatch-Größe. Die am häufigsten verwendeten Minibatch-Größen sind 1, 32, 64, 128, 256, 512 und 1024.

  2. Fordern Sie die Vorhersage an:

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

Format der Vorhersageergebnisse

Das Format Ihrer Ergebnisse hängt vom Ziel Ihres Modells ab.

Ergebnisse des Klassifikationsmodells

Vorhersageergebnisse für Klassifizierungsmodelle (binär und mehrklassig) geben einen Wahrscheinlichkeitswert für jeden potenziellen Wert der Zielspalte zurück. Sie müssen festlegen, wie die Bewertungen verwendet werden sollen. Um beispielsweise eine binäre Klassifizierung aus den bereitgestellten Bewertungen zu erhalten, würden Sie einen Schwellenwert angeben. Wenn es die beiden Klassen „A“ und „B“ gibt, sollten Sie das Beispiel mit „A“ klassifizieren, wenn die Bewertung für „A“ größer als der ausgewählte Grenzwert ist. Andernfalls klassifizieren Sie „B“. Bei unausgewogenen Datasets kann der Grenzwert 100 % oder 0 % erreichen.

Die Ergebnisnutzlast für ein Klassifizierungsmodell sieht in etwa so aus:

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

Ergebnisse des Regressionsmodells

Für jede gültige Zeile der Vorhersageanfrage wird ein vorhergesagter Wert zurückgegeben. Prognoseintervalle werden für exportierte Modelle nicht zurückgegeben.

Die Nutzlast der Ergebnisse für ein Regressionsmodell sieht in etwa so aus:

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

Nächste Schritte