Modelle exportieren

Überblick

Auf dieser Seite wird gezeigt, wie Sie BigQuery ML-Modelle exportieren. Sie können BigQuery ML-Modelle nach Cloud Storage exportieren und dann für Onlinevorhersagen verwenden oder in Python bearbeiten. So exportieren Sie ein BigQuery ML-Modell:

• Google Cloud Console verwenden
• Anweisung EXPORT MODEL verwenden
• Mit dem Befehl bq extract im bq-Befehlszeilentool
• Durch Senden eines extract-Jobs über die API oder die Clientbibliotheken

Sie können die folgenden Modelltypen exportieren:

• AUTOENCODER
• AUTOML_CLASSIFIER
• AUTOML_REGRESSOR
• BOOSTED_TREE_CLASSIFIER
• BOOSTED_TREE_REGRESSOR
• DNN_CLASSIFIER
• DNN_REGRESSOR
• DNN_LINEAR_COMBINED_CLASSIFIER
• DNN_LINEAR_COMBINED_REGRESSOR
• KMEANS
• LINEAR_REG
• LOGISTIC_REG
• MATRIX_FACTORIZATION
• RANDOM_FOREST_CLASSIFIER
• RANDOM_FOREST_REGRESSOR
• TENSORFLOW (importierte TensorFlow-Modelle)
• PCA

Exportmodellformate und Beispiele

Die folgende Tabelle enthält die Exportzielformate für die verschiedenen BigQuery ML-Modelltypen sowie ein Beispiel für Dateien, die in den Cloud Storage-Bucket geschrieben werden.

Modelltyp	Exportmodellformat	Beispiel für exportierte Dateien
AUTOML_CLASSIFIER	TensorFlow SavedModel (TF 2.1.0)	gcs_bucket/   assets/     f1.txt     f2.txt   saved_model.pb   variables/     variables.data-00-of-01     variables.index
AUTOML_REGRESSOR
AUTOENCODER	TensorFlow SavedModel (TF 1.15 oder höher)
DNN_CLASSIFIER
DNN_REGRESSOR
DNN_LINEAR_COMBINED_CLASSIFIER
DNN_LINEAR_COMBINED_REGRESSOR
KMEANS
LINEAR_REGRESSOR
LOGISTIC_REG
MATRIX_FACTORIZATION
PCA
BOOSTED_TREE_CLASSIFIER	Booster (XGBoost 0.82)	gcs_bucket/   assets/     0.txt     1.txt     model_metadata.json   main.py   model.bst   xgboost_predictor-0.1.tar.gz     ....      predictor.py     .... main.py dient der lokalen Ausführung. Weitere Informationen finden Sie unter Modellbereitstellung.
BOOSTED_TREE_REGRESSOR
RANDOM_FOREST_REGRESSOR
RANDOM_FOREST_REGRESSOR
TENSORFLOW (importiert)	TensorFlow SavedModel	Exakt die gleichen Dateien, die beim Importieren des Modells vorhanden waren

Hinweis: Die automatischen Datenvorverarbeitungen, die während der Modellerstellung durchgeführt werden, z. B. Standardisierung und Labelcodierung, werden in den exportierten Dateien als Teil der Grafik für TensorFlow SavedModel und in den externen Dateien für Booster gespeichert. Eine explizite Vorverarbeitung ist nicht erforderlich, bevor Daten für die Vorhersage übergeben werden. Die Eingabe sollte im Allgemeinen mit der Eingabe für BigQuery ML ML.PREDICT übereinstimmen. Alle numerischen Werte in den exportierten Modellsignaturen werden als Datentyp FLOAT64 umgewandelt . Außerdem müssen alle STRUCT-Felder in separate Felder erweitert werden. Beispielsweise sollte das Feld f1 in STRUCT f2 in f2_f1 umbenannt und als separate Spalte übergeben werden.

Mit TRANSFORM trainiertes Modell exportieren

Vorschau

Diese Funktion unterliegt den „Nutzungsbedingungen für Pre-GA-Angebote“ im Abschnitt „Allgemeine Nutzungsbedingungen“ der dienstspezifischen Nutzungsbedingungen. Pre-GA-Funktionen sind „wie besehen“ verfügbar und werden möglicherweise nur eingeschränkt unterstützt. Weitere Informationen finden Sie in den Beschreibungen der Startphase.

Wenn das Modell mit der TRANSFORM-Klausel trainiert wird, führt ein zusätzliches Vorverarbeitungsmodell die gleiche Logik in der TRANSFORM-Klausel aus und wird im TensorFlow-SavedModel-Format im Unterverzeichnis transform gespeichert.

Exportmodellformat	Beispiel für exportierte Dateien
Vorhersagemodell: TensorFlow SavedModel oder Booster (XGBoost 0.82). Vorverarbeitungsmodell für TRANSFORM-Klausel: TensorFlow SavedModel (TF 2.5 oder höher)	gcs_bucket/   ....(model files)   transform/     assets/         f1.txt/         f2.txt/     saved_model.pb     variables/         variables.data-00-of-01         variables.index

Das Modell enthält nicht die Informationen zu dem Feature Engineering, das während des Trainings in der SELECT-Anweisung ausgeführt wird. Deshalb müssen Sie die Eingabedaten manuell konvertieren, bevor Sie sie in das exportierte Modell einspeisen.

Beschränkungen

Beim Exportieren von Modellen gelten folgende Beschränkungen:

• Der Modellexport wird nicht unterstützt, wenn für das Training eines der folgenden Features verwendet wurde:

  • Die Eingabedatentypen ARRAY, TIMESTAMP oder GEOGRAPHY waren in den Eingabedaten vorhanden.

• Die exportierten Modelle für die Modelltypen AUTOML_REGRESSOR und AUTOML_CLASSIFIER unterstützen keine AI Platform-Bereitstellung für Onlinevorhersagen.

• Der Modellgrößenlimit beträgt 1 GB für das Exportieren des Matrixfaktorisierungsmodells. Die Modellgröße ist ungefähr proportional zu num_factors. Sie können also num_factors während des Trainings reduzieren, um die Modellgröße zu verkleinern, wenn Sie das Limit erreichen.

• Eingeschränkte Funktionen werden für den Modellexport unterstützt, wenn für das Feature Engineering die BigQuery ML-TRANSFORM-Klausel verwendet wurde. Unterstützte Funktionen sind:

  • Alle Funktionen mit NUMERICAL-Eingaben. Beispiele: ML.BUCKETIZE, ML.MIN_MAX_SCALER
  • Eingeschränkte Funktionen mit STRING-Eingaben: UPPER, LOWER, CONCAT, ML.HASH_BUCKETIZE.
  • Eingeschränkte Funktionen mit ARRAY-Eingaben: ML.NGRAMS.

BigQuery ML-Modelle exportieren

So exportieren Sie ein Modell:

Console

1. Öffnen Sie in der Google Cloud Console die Seite "BigQuery".
   

   Zur Seite "BigQuery"

2. Maximieren Sie im Navigationsbereich im Abschnitt Ressourcen Ihr Projekt und klicken Sie dann zum Maximieren auf Ihr Dataset. Ermitteln Sie das Modell, das Sie exportieren möchten, und klicken Sie darauf.

3. Klicken Sie rechts im Fenster auf Modell exportieren.

   

4. Gehen Sie im Dialogfeld Modell nach Cloud Storage exportieren so vor:

   • Ermitteln Sie unter Cloud Storage-Speicherort auswählen den Bucket- oder Ordnerstandort, in den Sie das Modell exportieren möchten.
   • Klicken Sie auf Exportieren, um das Modell zu exportieren.

Für einen Exportjob können Sie unter Jobverlauf oben in der Navigation den Status des Jobs prüfen.

SQL

Mit der EXPORT MODEL-Anweisung können Sie BigQuery ML-Modelle über die GoogleSQL-Abfragesyntax nach Cloud Storage exportieren.

So exportieren Sie ein BigQuery ML-Modell mithilfe der Anweisung EXPORT MODEL in die Cloud Console:

1. Öffnen Sie in der Google Cloud Console die Seite „BigQuery“.

   BigQuery aufrufen

2. Klicken Sie auf Neue Abfrage erstellen.

3. Geben Sie im Feld Abfrageeditor die Anweisung EXPORT MODEL ein.

   Die folgende Abfrage exportiert ein Modell mit dem Namen myproject.mydataset.mymodel in einen Cloud Storage-Bucket mit URI gs://bucket/path/to/saved_model/.

    EXPORT MODEL `myproject.mydataset.mymodel`
    OPTIONS(URI = 'gs://bucket/path/to/saved_model/')
    

4. Klicken Sie auf Ausführen. Wenn die Abfrage abgeschlossen ist, wird Folgendes im Bereich Abfrageergebnisse angezeigt: Successfully exported model.

bq

Hinweis: Zum Exportieren eines Modells mit dem bq-Befehlszeilentool benötigen Sie die bq-Version 2.0.56 oder höher, die im gcloud CLI Version 287.0.0 und höher enthalten ist. Verwenden Sie bq version, um die installierte Version des bq-Tools aufzurufen. Aktualisieren Sie dann gegebenenfalls die gcloud CLI mit gcloud components update.

Führen Sie den Befehl bq extract mit dem Flag --model aus.

(Optional) Geben Sie das Flag --destination_format an und wählen Sie das Format des exportierten Modells aus. (Optional) Geben Sie das Flag --location an und legen Sie als Wert Ihren Standort fest.

bq --location=location extract \
--destination_format format \
--model project_id:dataset.model \
gs://bucket/model_folder

Wobei:

• location ist der Name Ihres Standorts. Das Flag --location ist optional. Wenn Sie BigQuery z. B. in der Region Tokio verwenden, können Sie für das Flag den Wert asia-northeast1 festlegen. Mit der Datei .bigqueryrc können Sie einen Standardwert für den Standort festlegen.
• destination_format ist das Format für das exportierte Modell: ML_TF_SAVED_MODEL (Standard) oder ML_XGBOOST_BOOSTER.
• project_id ist die Projekt-ID.
• dataset ist der Name des Quell-Datasets.
• model ist das Modell, das Sie exportieren.
• bucket ist der Name des Cloud Storage-Buckets, in den Sie Daten exportieren. Das BigQuery-Dataset und der Cloud Storage-Bucket müssen sich am selben Standort befinden.
• model_folder ist der Name des Ordners, in den die exportierten Modelldateien geschrieben werden.

Beispiele:

Der folgende Befehl exportiert mydataset.mymodel im SavedModel-Format von TensorFlow in einen Cloud Storage-Bucket mit dem Namen mymodel_folder.

bq extract --model \
'mydataset.mymodel' \
gs://example-bucket/mymodel_folder

Der Standardwert von destination_format ist ML_TF_SAVED_MODEL.

Der folgende Befehl exportiert mydataset.mymodel im Booster-Format von XGBoost in einen Cloud Storage-Bucket namens mymodel_folder.

bq extract --model \
--destination_format ML_XGBOOST_BOOSTER \
'mydataset.mytable' \
gs://example-bucket/mymodel_folder

API

Zum Exportieren eines Modells erstellen Sie einen extract-Job und legen dafür die Jobkonfiguration fest.

Optional: Geben Sie im Attribut location im Abschnitt jobReference der Jobressource Ihren Standort an.

1. Erstellen Sie einen Extrahierungsjob, der auf das BigQuery ML-Modell und auf das Cloud Storage-Ziel verweist.

2. Geben Sie das Quellmodell mithilfe des Konfigurationsobjekts sourceModel an, das die Projekt-ID, die Dataset-ID und die Modell-ID enthält.

3. Das Attribut destination URI(s) muss voll qualifiziert sein und das Format gs://bucket/model_folder haben.

4. Geben Sie das Zielformat an, indem Sie das Attribut configuration.extract.destinationFormat festlegen. Wenn Sie beispielsweise ein Boosted Tree-Modell exportieren möchten, legen Sie dieses Attribut auf den Wert ML_XGBOOST_BOOSTER fest.

5. Rufen Sie zur Prüfung des Jobstatus jobs.get(job_id) mit der ID des Jobs auf, die von der ursprünglichen Anfrage zurückgegeben wurde.

   • Wenn status.state = DONE zurückgegeben wird, wurde der Job erfolgreich abgeschlossen.
   • Wenn das Attribut status.errorResult zurückgegeben wird, ist die Anfrage fehlgeschlagen. Das Objekt enthält in diesem Fall Angaben zur Fehlerursache.
   • Wenn status.errorResult nicht zurückgegeben wird, wurde der Job erfolgreich abgeschlossen, obwohl einige nicht schwerwiegende Fehler aufgetreten sein können. Nicht schwerwiegende Fehler werden im Attribut status.errors des Objekts für den zurückgegebenen Job aufgeführt.

API-Hinweise:

• Als Best Practice generieren Sie eine eindeutige ID und übergeben Sie diese als jobReference.jobId, wenn Sie jobs.insert zum Erstellen eines Ladejobs aufrufen. Diese Vorgehensweise ist weniger anfällig für Netzwerkfehler, da der Client anhand der bekannten Job-ID einen Abruf oder einen neuen Versuch ausführen kann.

• Das Aufrufen von jobs.insert für eine bestimmte Job-ID ist idempotent. Das bedeutet, dass Sie den Aufruf für eine bestimmte Job-ID beliebig oft wiederholen können. Maximal einer dieser Vorgänge wird erfolgreich sein.

Java

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Java in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Java API.

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

Auf GitHub ansehen Feedback

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.ExtractJobConfiguration;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.ModelId;

// Sample to extract model to GCS bucket
public class ExtractModel {

  public static void main(String[] args) throws InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    String projectName = "bigquery-public-data";
    String datasetName = "samples";
    String modelName = "model";
    String bucketName = "MY-BUCKET-NAME";
    String destinationUri = "gs://" + bucketName + "/path/to/file";
    extractModel(projectName, datasetName, modelName, destinationUri);
  }

  public static void extractModel(
      String projectName, String datasetName, String modelName, String destinationUri)
      throws InterruptedException {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      ModelId modelId = ModelId.of(projectName, datasetName, modelName);

      ExtractJobConfiguration extractConfig =
          ExtractJobConfiguration.newBuilder(modelId, destinationUri).build();

      Job job = bigquery.create(JobInfo.of(extractConfig));

      // Blocks until this job completes its execution, either failing or succeeding.
      Job completedJob = job.waitFor();
      if (completedJob == null) {
        System.out.println("Job not executed since it no longer exists.");
        return;
      } else if (completedJob.getStatus().getError() != null) {
        System.out.println(
            "BigQuery was unable to extract due to an error: \n" + job.getStatus().getError());
        return;
      }
      System.out.println("Model extract successful");
    } catch (BigQueryException ex) {
      System.out.println("Model extraction job was interrupted. \n" + ex.toString());
    }
  }
}

Modellbereitstellung

Sie können das exportierte Modell sowohl auf der AI Platform als auch lokal bereitstellen.

AI Platform-Bereitstellung

Exportmodellformat	Bereitstellung
TensorFlow SavedModel (Nicht-AutoML-Modelle)	TensorFlow SavedModel bereitstellen (Laufzeitversion 1.15 oder höher)
TensorFlow SavedModel (AutoML-Modelle)	Nicht unterstützt
XGBoost-Booster	Benutzerdefinierte Vorhersageroutine (Laufzeitversion 1.15) Hinweis: In den exportierten Dateien sind Informationen zur Vorverarbeitung und Nachverarbeitung gespeichert. Sie müssen daher eine benutzerdefinierte Vorhersageroutine verwenden, um das Modell mit den zusätzlichen exportierten Dateien bereitzustellen.

Lokale Bereitstellung

Exportmodellformat	Bereitstellung
TensorFlow SavedModel (Nicht-AutoML-Modelle)	"SavedModel" ist ein Standardformat, das sich in Tensorflow Serving-Docker-Containern bereitstellen lässt. Sie können auch die lokale Ausführung von AI Platform-Onlinevorhersagen nutzen.
TensorFlow SavedModel (AutoML-Modelle)	Führen Sie den AutoML-Container aus.
XGBoost-Booster	Zum lokalen Ausführen von XGBoost-Booster-Modellen können Sie die exportierte main.py-Datei verwenden: Laden Sie alle Dateien aus Cloud Storage in das lokale Verzeichnis herunter. Entpacken Sie die predictor.py-Datei aus xgboost_predictor-0.1.tar.gz in das lokale Verzeichnis. Führen Sie main.py aus (siehe Anleitung in main.py).

Ausgabeformat der Vorhersage

In diesem Abschnitt wird das Ausgabeformat für die Vorhersage der exportierten Modelle für jeden Modelltyp dargestellt. Alle exportierten Modelle unterstützen Batchvorhersagen und können mehrere Eingabezeilen gleichzeitig verarbeiten. Beispielsweise gibt es in jedem der folgenden Beispiele für die Ausgabeformate zwei Eingabezeilen.

AUTOENCODER

Ausgabeformat der Vorhersage	Ausgabebeispiel
+------------------------+------------------------+------------------------+ | LATENT_COL_1 | LATENT_COL_2 | ... | +------------------------+------------------------+------------------------+ | [FLOAT] | [FLOAT] | ... | +------------------------+------------------------+------------------------+	+------------------+------------------+------------------+------------------+ | LATENT_COL_1 | LATENT_COL_2 | LATENT_COL_3 | LATENT_COL_4 | +------------------------+------------+------------------+------------------+ | 0.21384512 | 0.93457112 | 0.64978097 | 0.00480489 | +------------------+------------------+------------------+------------------+

AUTOML_CLASSIFIER

Ausgabeformat der Vorhersage	Ausgabebeispiel
+------------------------------------------+ | predictions | +------------------------------------------+ | [{"scores":[FLOAT], "classes":[STRING]}] | +------------------------------------------+	+---------------------------------------------+ | predictions | +---------------------------------------------+ | [{"scores":[1, 2], "classes":['a', 'b']}, | | {"scores":[3, 0.2], "classes":['a', 'b']}] | +---------------------------------------------+

AUTOML_REGRESSOR

Ausgabeformat der Vorhersage	Ausgabebeispiel
+-----------------+ | predictions | +-----------------+ | [FLOAT] | +-----------------+	+-----------------+ | predictions | +-----------------+ | [1.8, 2.46] | +-----------------+

BOOSTED_TREE_CLASSIFIER und RANDOM_FOREST_CLASSIFIER

Ausgabeformat der Vorhersage	Ausgabebeispiel
+-------------+--------------+-----------------+ | LABEL_PROBS | LABEL_VALUES | PREDICTED_LABEL | +-------------+--------------+-----------------+ | [FLOAT] | [STRING] | STRING | +-------------+--------------+-----------------+	+-------------+--------------+-----------------+ | LABEL_PROBS | LABEL_VALUES | PREDICTED_LABEL | +-------------+--------------+-----------------+ | [0.1, 0.9] | ['a', 'b'] | ['b'] | +-------------+--------------+-----------------+ | [0.8, 0.2] | ['a', 'b'] | ['a'] | +-------------+--------------+-----------------+

BOOSTED_TREE_REGRESSOR UND RANDOM_FOREST_REGRESSOR

Ausgabeformat der Vorhersage	Ausgabebeispiel
+-----------------+ | predicted_label | +-----------------+ | FLOAT | +-----------------+	+-----------------+ | predicted_label | +-----------------+ | [1.8] | +-----------------+ | [2.46] | +-----------------+

DNN_CLASSIFIER

Ausgabeformat der Vorhersage

Ausgabebeispiel

+---------------+-------------+-----------+---------+------------------------+--------+---------------+ | ALL_CLASS_IDS | ALL_CLASSES | CLASS_IDS | CLASSES | LOGISTIC (binary only) | LOGITS | PROBABILITIES | +---------------+-------------+-----------+---------+------------------------+--------+---------------+ | [INT64] | [STRING] | INT64 | STRING | FLOAT | [FLOAT]| [FLOAT] | +---------------+-------------+-----------+---------+------------------------+--------+---------------+

+---------------+-------------+-----------+---------+------------------------+--------+---------------+ | ALL_CLASS_IDS | ALL_CLASSES | CLASS_IDS | CLASSES | LOGISTIC (binary only) | LOGITS | PROBABILITIES | +---------------+-------------+-----------+---------+------------------------+--------+---------------+ | [0, 1] | ['a', 'b'] | [0] | ['a'] | [0.36] | [-0.53]| [0.64, 0.36] | +---------------+-------------+-----------+---------+------------------------+--------+---------------+ | [0, 1] | ['a', 'b'] | [0] | ['a'] | [0.2] | [-1.38]| [0.8, 0.2] | +---------------+-------------+-----------+---------+------------------------+--------+---------------+

DNN_REGRESSOR

Ausgabeformat der Vorhersage	Ausgabebeispiel
+-----------------+ | PREDICTED_LABEL | +-----------------+ | FLOAT | +-----------------+	+-----------------+ | PREDICTED_LABEL | +-----------------+ | [1.8] | +-----------------+ | [2.46] | +-----------------+

DNN_LINEAR_COMBINED_CLASSIFIER

Ausgabeformat der Vorhersage

Ausgabebeispiel

+---------------+-------------+-----------+---------+------------------------+--------+---------------+ | ALL_CLASS_IDS | ALL_CLASSES | CLASS_IDS | CLASSES | LOGISTIC (binary only) | LOGITS | PROBABILITIES | +---------------+-------------+-----------+---------+------------------------+--------+---------------+ | [INT64] | [STRING] | INT64 | STRING | FLOAT | [FLOAT]| [FLOAT] | +---------------+-------------+-----------+---------+------------------------+--------+---------------+

+---------------+-------------+-----------+---------+------------------------+--------+---------------+ | ALL_CLASS_IDS | ALL_CLASSES | CLASS_IDS | CLASSES | LOGISTIC (binary only) | LOGITS | PROBABILITIES | +---------------+-------------+-----------+---------+------------------------+--------+---------------+ | [0, 1] | ['a', 'b'] | [0] | ['a'] | [0.36] | [-0.53]| [0.64, 0.36] | +---------------+-------------+-----------+---------+------------------------+--------+---------------+ | [0, 1] | ['a', 'b'] | [0] | ['a'] | [0.2] | [-1.38]| [0.8, 0.2] | +---------------+-------------+-----------+---------+------------------------+--------+---------------+

DNN_LINEAR_COMBINED_REGRESSOR

Ausgabeformat der Vorhersage	Ausgabebeispiel
+-----------------+ | PREDICTED_LABEL | +-----------------+ | FLOAT | +-----------------+	+-----------------+ | PREDICTED_LABEL | +-----------------+ | [1.8] | +-----------------+ | [2.46] | +-----------------+

KMEANS

Ausgabeformat der Vorhersage	Ausgabebeispiel
+--------------------+--------------+---------------------+ | CENTROID_DISTANCES | CENTROID_IDS | NEAREST_CENTROID_ID | +--------------------+--------------+---------------------+ | [FLOAT] | [INT64] | INT64 | +--------------------+--------------+---------------------+	+--------------------+--------------+---------------------+ | CENTROID_DISTANCES | CENTROID_IDS | NEAREST_CENTROID_ID | +--------------------+--------------+---------------------+ | [1.2, 1.3] | [1, 2] | [1] | +--------------------+--------------+---------------------+ | [0.4, 0.1] | [1, 2] | [2] | +--------------------+--------------+---------------------+

LINEAR_REG

Ausgabeformat der Vorhersage	Ausgabebeispiel
+-----------------+ | PREDICTED_LABEL | +-----------------+ | FLOAT | +-----------------+	+-----------------+ | PREDICTED_LABEL | +-----------------+ | [1.8] | +-----------------+ | [2.46] | +-----------------+

LOGISTIC_REG

Ausgabeformat der Vorhersage	Ausgabebeispiel
+-------------+--------------+-----------------+ | LABEL_PROBS | LABEL_VALUES | PREDICTED_LABEL | +-------------+--------------+-----------------+ | [FLOAT] | [STRING] | STRING | +-------------+--------------+-----------------+	+-------------+--------------+-----------------+ | LABEL_PROBS | LABEL_VALUES | PREDICTED_LABEL | +-------------+--------------+-----------------+ | [0.1, 0.9] | ['a', 'b'] | ['b'] | +-------------+--------------+-----------------+ | [0.8, 0.2] | ['a', 'b'] | ['a'] | +-------------+--------------+-----------------+

MATRIX_FACTORIZATION

Hinweis: Derzeit wird nur ein Eingabenutzer unterstützt und die 50 besten Paare (predicted_rating, predicted_item) werden nach predicted_rating in absteigender Reihenfolge sortiert ausgegeben.

Ausgabeformat der Vorhersage	Ausgabebeispiel
+--------------------+--------------+ | PREDICTED_RATING | PREDICTED_ITEM | +------------------+----------------+ | [FLOAT] | [STRING] | +------------------+----------------+	+--------------------+--------------+ | PREDICTED_RATING | PREDICTED_ITEM | +------------------+----------------+ | [5.5, 1.7] | ['A', 'B'] | +------------------+----------------+ | [7.2, 2.7] | ['B', 'A'] | +------------------+----------------+

TENSORFLOW (importiert)

Ausgabeformat der Vorhersage
Entspricht dem importierten Modell

PCA

Ausgabeformat der Vorhersage	Ausgabebeispiel
+-------------------------+---------------------------------+ | PRINCIPAL_COMPONENT_IDS | PRINCIPAL_COMPONENT_PROJECTIONS | +-------------------------+---------------------------------+ | [INT64] | [FLOAT] | +-------------------------+---------------------------------+	+-------------------------+---------------------------------+ | PRINCIPAL_COMPONENT_IDS | PRINCIPAL_COMPONENT_PROJECTIONS | +-------------------------+---------------------------------+ | [1, 2] | [1.2, 5.0] | +-------------------------+---------------------------------+

XGBoost-Modellvisualisierung

Sie können die hochgeladenen Boosted Trees nach dem Modellexport mit der Python API plot_tree visualisieren. Beispielsweise können Sie Colab nutzen, ohne die Abhängigkeiten zu installieren:

1. Exportieren Sie das Boosted Tree-Modell in einen Cloud Storage-Bucket.
2. Laden Sie die Datei model.bst aus dem Cloud Storage-Bucket herunter.
3. Laden Sie die Datei model.bst in ein Colab-Notebook in Files hoch.

4. Führen Sie den folgenden Code im Notebook aus:

   import xgboost as xgb
   import matplotlib.pyplot as plt
   
   model = xgb.Booster(model_file="model.bst")
   num_iterations = <iteration_number>
   for tree_num in range(num_iterations):
     xgb.plot_tree(model, num_trees=tree_num)
   plt.show
   

In diesem Beispiel werden mehrere Bäume dargestellt (ein Baum pro Iteration):

Hinweis: Wir verwenden den Label-Encoder, um kategoriale Features zu codieren, sodass Sie die entsprechende Kategorie für einen aufgeteilten Wert aus der Vokabeldatei im Verzeichnis "assets/" abrufen können, das sich im Cloud Storage-Bucket für den Modellexport befindet. Wird beispielsweise in einem Knoten "f0 < 2.95" angezeigt, finden Sie die entsprechende Kategorie in der Vokabeldatei, indem Sie nach dem dritten Element suchen.

Derzeit speichern wir keine Featurenamen im Modell, sodass Sie Namen wie "f0", "f1" usw. sehen. Die entsprechenden Featurenamen finden Sie in der exportierten Datei assets/model_metadata.json mithilfe dieser Namen (z. B. "f0") als Indexe.

Erforderliche Berechtigungen

Zum Exportieren eines BigQuery ML-Modells nach Cloud Storage benötigen Sie Berechtigungen für den Zugriff auf das BigQuery ML-Modell, für das Ausführen eines Exportjobs und für das Schreiben der Daten in den Cloud Storage-Bucket.

BigQuery-Berechtigungen

• Zum Exportieren des Modells sind mindestens Berechtigungen vom Typ bigquery.models.export erforderlich. Die folgenden vordefinierten IAM-Rollen (Identity and Access Management) erhalten Berechtigungen des Typs bigquery.models.export:

  • bigquery.dataViewer
  • bigquery.dataOwner
  • bigquery.dataEditor
  • bigquery.admin

• Zum Ausführen eines Exportjobs benötigen Sie Berechtigungen vom Typ bigquery.jobs.create. Die folgenden vordefinierten IAM-Rollen enthalten Berechtigungen vom Typ bigquery.jobs.create:

  • bigquery.user
  • bigquery.jobUser
  • bigquery.admin

Cloud Storage-Berechtigungen

• Zum Schreiben von Daten in einen vorhandenen Cloud Storage-Bucket benötigen Sie Berechtigungen vom Typ storage.objects.create. Die folgenden vordefinierten IAM-Rollen enthalten Berechtigungen vom Typ storage.objects.create:

  • storage.objectCreator
  • storage.objectAdmin
  • storage.admin

Unter Zugriffssteuerung erfahren Sie mehr über IAM-Rollen und -Berechtigungen in BigQuery ML.

Überlegungen zum Standort

Beachten Sie Folgendes, wenn Sie einen Standort für Ihre Daten auswählen:

Platzieren Sie die Cloud Storage-Buckets zum Exportieren von Daten am selben Standort.
• Wenn sich Ihr BigQuery-Dataset in der Multi-Region EU befindet, muss sich der Cloud Storage-Bucket mit den zu exportierenden Daten am selben Standort oder an einem Standort in derselben Multi-Region Region befinden. Wenn sich Ihr BigQuery-Dataset zum Beispiel in der Multi-Region EU befindet, kann sich der Cloud Storage-Bucket in der Region europe-west1 innerhalb der EU befinden.

  Wenn sich Ihr Dataset in der Multi-Region US befindet, können Sie Daten in einen Cloud Storage-Bucket an einem beliebigen Standort exportieren.

• Wenn sich Ihr Dataset in einer Region befindet, muss sich der Cloud Storage-Bucket in derselben Region befinden. Wenn sich Ihr Dataset zum Beispiel in der Region asia-northeast1 Tokio befindet, darf sich der Cloud Storage-Bucket nicht am multiregionalen Standort ASIA befinden.
Entwickeln Sie einen Plan zur Datenverwaltung:
• Wenn Sie eine regionale Speicherressource wie ein BigQuery-Dataset oder einen Cloud Storage-Bucket auswählen, sollten Sie einen Plan für die geografische Verwaltung Ihrer Daten entwickeln.

Weitere Informationen zu Cloud Storage-Standorten finden Sie unter Bucket-Standorte in der Cloud Storage-Dokumentation.

BigQuery-Daten zwischen Standorten verschieben

Der Standort eines Datasets lässt sich nach seiner Erstellung nicht mehr ändern. Sie können aber eine Kopie des Datasets anlegen.

Kontingentrichtlinie

Weitere Informationen zum Exportieren von Jobkontingenten finden Sie auf der Seite "Kontingente und Limits" unter Exportjobs.

Preise

Für das Exportieren von BigQuery ML-Modellen fallen keine Kosten an. Exporte unterliegen aber den Kontingenten und Limits von BigQuery. Weitere Informationen zu den Preisen von BigQuery finden Sie auf der Seite BigQuery-Preise.

Nachdem die Daten exportiert wurden, wird das Speichern der Daten in Cloud Storage in Rechnung gestellt. Weitere Informationen zu den Preisen von Cloud Storage erhalten Sie auf der Seite Cloud Storage – Preise.

Nächste Schritte

• BigQuery ML-Modell für Onlinevorhersagen exportieren