Modelle exportieren

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
• TRANSFORM_ONLY

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
TRANSFORM_ONLY
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. Bevor Daten für die Vorhersage übergeben werden, ist keine explizite Vorverarbeitung erforderlich. Die Eingabe sollte im Allgemeinen mit der für BigQuery ML ML.PREDICT verwendeten Eingabe übereinstimmen. Alle numerischen Werte in den exportierten Modellsignaturen werden in den 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

Wenn das Modell mit der TRANSFORM-Anweisung 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. Sie können ein mit der TRANSFORM-Anweisung trainiertes Modell sowohl in Vertex AI als auch lokal bereitstellen. Weitere Informationen finden Sie unter Modellbereitstellung.

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 zum Feature Engineering, das während des Trainings außerhalb der TRANSFORM-Klausel ausgeführt wird. Beispiel: Alles in der SELECT-Anweisung. Sie müssen also die Eingabedaten manuell konvertieren, bevor Sie sie in das Vorverarbeitungsmodell einspeisen.

Unterstützte Datentypen

Beim Exportieren von Modellen, die mit der TRANSFORM-Klausel trainiert wurden, werden die folgenden Datentypen für die Einspeisung in die TRANSFORM-Anweisung unterstützt.

Eingabetyp TRANSFORM	Eingabebeispiele TRANSFORM	Eingabebeispiele für exportierte Vorverarbeitungsmodellen
INT64	10, 11	tf.constant(   [10, 11],   dtype=tf.int64)
NUMERIC	NUMERIC 10, NUMERIC 11	tf.constant(   [10, 11],   dtype=tf.float64)
BIGNUMERIC	BIGNUMERIC 10, BIGNUMERIC 11	tf.constant(   [10, 11],   dtype=tf.float64)
FLOAT64	10.0, 11.0	tf.constant(   [10, 11],   dtype=tf.float64)
BOOL	TRUE, FALSE	tf.constant(   [True, False],   dtype=tf.bool)
STRING	'abc', 'def'	tf.constant(   ['abc', 'def'],   dtype=tf.string)
BYTES	b'abc', b'def'	tf.constant(   ['abc', 'def'],   dtype=tf.string)
DATE	DATE '2020-09-27', DATE '2020-09-28'	tf.constant(   [     '2020-09-27',     '2020-09-28'   ],   dtype=tf.string) "%F" format
DATETIME	DATETIME '2023-02-02 02:02:01.152903', DATETIME '2023-02-03 02:02:01.152903'	tf.constant(   [     '2023-02-02 02:02:01.152903',     '2023-02-03 02:02:01.152903'   ],   dtype=tf.string) "%F %H:%M:%E6S" format
TIME	TIME '16:32:36.152903', TIME '17:32:36.152903'	tf.constant(   [     '16:32:36.152903',     '17:32:36.152903'   ],   dtype=tf.string) "%H:%M:%E6S" format
TIMESTAMP	TIMESTAMP '2017-02-28 12:30:30.45-08', TIMESTAMP '2018-02-28 12:30:30.45-08'	tf.constant(   [     '2017-02-28 20:30:30.4 +0000',     '2018-02-28 20:30:30.4 +0000'   ],   dtype=tf.string) "%F %H:%M:%E1S %z" format
ARRAY	['a', 'b'], ['c', 'd']	tf.constant(   [['a', 'b'], ['c', 'd']],   dtype=tf.string)
ARRAY< STRUCT< INT64, FLOAT64>>	[(1, 1.0), (2, 1.0)], [(2, 1.0), (3, 1.0)]	tf.sparse.from_dense(   tf.constant(     [       [0, 1.0, 1.0, 0],       [0, 0, 1.0, 1.0]     ],     dtype=tf.float64))
NULL	NULL, NULL	tf.constant(   [123456789.0e10, 123456789.0e10],   dtype=tf.float64) tf.constant(   [1234567890000000000, 1234567890000000000],   dtype=tf.int64) tf.constant(   [' __MISSING__ ', ' __MISSING__ '],   dtype=tf.string)

Unterstützte SQL-Funktionen

Beim Exportieren von Modellen, die mit der TRANSFORM-Anweisung trainiert wurden, können Sie die folgenden SQL-Funktionen in der TRANSFORM-Anweisung verwenden.

• Operatoren
  • +, -, *, /, =, <, >, <=, >=, !=, <>, [NOT] BETWEEN, [NOT] IN, IS [NOT] NULL, IS [NOT] TRUE, IS [NOT] FALSE, NOT, AND, OR.
• Bedingte Ausdrücke
  • CASE expr, CASE, COALESCE, IF, IFNULL, NULLIF.
• Mathematische Funktionen
  • ABS, ACOS, ACOSH, ASINH, ATAN, ATAN2, ATANH, CBRT, CEIL, CEILING, COS, COSH, COT, COTH, CSC, CSCH, EXP, FLOOR, IS_INF, IS_NAN, LN, LOG, LOG10, MOD, POW, POWER, SEC, SECH, SIGN, SIN, SINH, SQRT, TAN, TANH.
• Umrechnungsfunktionen
  • CAST AS INT64, CAST AS FLOAT64, CAST AS NUMERIC, CAST AS BIGNUMERIC, CAST AS STRING, SAFE_CAST AS INT64, SAFE_CAST AS FLOAT64
• Stringfunktionen
  • CONCAT, LEFT, LENGTH, LOWER, REGEXP_REPLACE, RIGHT, SPLIT, SUBSTR, SUBSTRING, TRIM, UPPER.
• Datumsfunktionen
  • Date, DATE_ADD, DATE_SUB, DATE_DIFF, DATE_TRUNC, EXTRACT, FORMAT_DATE, PARSE_DATE, SAFE.PARSE_DATE.
• Datums-/Zeitfunktionen
  • DATETIME, DATETIME_ADD, DATETIME_SUB, DATETIME_DIFF, DATETIME_TRUNC, EXTRACT, PARSE_DATETIME, SAFE.PARSE_DATETIME.
• Zeitfunktionen
  • TIME, TIME_ADD, TIME_SUB, TIME_DIFF, TIME_TRUNC, EXTRACT, FORMAT_TIME, PARSE_TIME, SAFE.PARSE_TIME.
• Zeitstempelfunktionen
  • TIMESTAMP, TIMESTAMP_ADD, TIMESTAMP_SUB, TIMESTAMP_DIFF, TIMESTAMP_TRUNC, FORMAT_TIMESTAMP, PARSE_TIMESTAMP, SAFE.PARSE_TIMESTAMP, TIMESTAMP_MICROS, TIMESTAMP_MILLIS, TIMESTAMP_SECONDS, EXTRACT, STRING, UNIX_MICROS, UNIX_MILLIS, UNIX_SECONDS.
• Manuelle Vorverarbeitungsfunktionen
  • ML.IMPUTER, ML.HASH_BUCKETIZE, ML.LABEL_ENCODER, ML.MULTI_HOT_ENCODER, ML.NGRAMS, ML.ONE_HOT_ENCODER, ML.BUCKETIZE, ML.MAX_ABS_SCALER, ML.MIN_MAX_SCALER, ML.NORMALIZER, ML.QUANTILE_BUCKETIZE, ML.ROBUST_SCALER, ML.STANDARD_SCALER.

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 Vertex AI-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.

• Für Modelle, die mit der BigQuery ML TRANSFORM-Klausel für die Manuelle Vorverarbeitung von Features trainiert wurden, beachten Sie die für den Export unterstützten Datentypen und Funktionen.

• Modelle, die vor dem 18. September 2023 mit der BigQuery TRANSFORM-Klausel trainiert wurden, müssen neu trainiert werden, bevor sie für Online-Vorhersagen über Model Registry bereitgestellt werden können.

• Beim Modellexport werden ARRAY<STRUCT<INT64, FLOAT64>> ARRAY und TIMESTAMP als vor-transformierte Daten unterstützt, aber nicht als nach-transformierte Daten.

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

Dabei gilt:

• 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 Clientbibliotheken einrichten.

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 in Vertex AI als auch lokal bereitstellen. Wenn die TRANSFORM-Klausel des Modells Datumsfunktionen, Datums-/Uhrzeitfunktionen, Uhrzeitfunktionen und Zeitstempelfunktionen enthält, müssen Sie die Bibliothek bigquery-ml-utils im Container verwenden. Davon ausgenommen sind Bereitstellungen über Model Registry, für die keine exportierten Modelle oder Bereitstellungscontainer erforderlich sind.

Vertex AI-Bereitstellung

Exportmodellformat	Bereitstellung
TensorFlow SavedModel (Nicht-AutoML-Modelle)	TensorFlow SavedModel bereitstellen. Sie müssen die SavedModel-Datei mit einer unterstützten Version von TensorFlow erstellen.
TensorFlow SavedModel (AutoML-Modelle)	Nicht unterstützt.
XGBoost-Booster	Verwenden Sie eine benutzerdefinierte Vorhersageroutine. Bei XGBoost-Booster-Modellen werden Informationen zur Vor- und Nachverarbeitung in den exportierten Dateien gespeichert. Mit einer benutzerdefinierten Vorhersageroutine können Sie das Modell mit den zusätzlichen exportierten Dateien bereitstellen. Sie müssen die Modelldateien mit einer unterstützten Version von XGBoost erstellen.

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 Vertex AI-Onlinevorhersagen nutzen.
TensorFlow SavedModel (AutoML-Modelle)	Modell containerisieren und ausführen
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] | +-------------------------+---------------------------------+

TRANSFORM_ONLY

Ausgabeformat der Vorhersage
Entspricht den Spalten, die in der TRANSFORM-Anweisung des Modells angegeben sind

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) enthalten Berechtigungen vom Typ 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

Bei der Auswahl eines Speicherorts für Ihre Daten sollten Sie Folgendes beachten:

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