Modelle exportieren

Übersicht

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:

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

  • AUTOML_CLASSIFIER
  • AUTOML_REGRESSOR
  • BOOSTED_TREE_CLASSIFIER
  • BOOSTED_TREE_REGRESSOR
  • DNN_CLASSIFIER
  • DNN_REGRESSOR
  • KMEANS
  • LINEAR_REG
  • LOGISTIC_REG
  • MATRIX_FACTORIZATION
  • TENSORFLOW (importierte TensorFlow-Modelle)
  • XGBOOST (importierte XGBoost-Modelle)

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
DNN_CLASSIFIER TensorFlow SavedModel (TF 1.15 oder höher)
DNN_REGRESSOR
KMEANS
LINEAR_REGRESSOR
LOGISTIC_REG
MATRIX_FACTORIZATION
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
TENSORFLOW (importiert) TensorFlow SavedModel Exakt die gleichen Dateien, die beim Importieren des Modells vorhanden waren

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

  • 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 BigQuery ML Transform-Klausel wurde für das Feature Engineering verwendet.
  • 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.

BigQuery ML-Modelle exportieren

So exportieren Sie ein Modell:

Console

  1. Öffnen Sie in der 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.

    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 Anweisung EXPORT MODEL können Sie BigQuery ML-Modelle mithilfe der Standard-SQL-Abfragesyntax in Cloud Storage exportieren.

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

  1. Öffnen Sie in der 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

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

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 Google Cloud 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:
  1. Laden Sie alle Dateien aus Cloud Storage in das lokale Verzeichnis herunter.
  2. Entpacken Sie die predictor.py-Datei aus xgboost_predictor-0.1.tar.gz in das lokale Verzeichnis.
  3. 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.

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

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

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]          |
+-----------------+
        

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

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):

Screenshot: Modell exportieren

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 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. Weitere Informationen zu Rollen auf Dataset-Ebene finden Sie in der BigQuery-Dokumentation unter Einfache Rollen für Datasets.

Ü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 Sie Daten exportieren, muss sich der regionale oder multiregionale Cloud Storage-Bucket am selben Standort wie das BigQuery ML-Dataset befinden. Wenn Ihr BigQuery ML-Dataset zum Beispiel im multiregionalen Standort "EU" liegt, muss sich der Cloud Storage-Bucket mit den Daten, die Sie exportieren, an einem regionalen oder multiregionalen Standort in der EU befinden.
    • Wenn Ihr Dataset an einem regionalen Standort gespeichert ist, muss der Cloud Storage-Bucket ein regionaler Bucket am selben Standort sein. Wenn sich Ihr Dataset zum Beispiel in der Region "Tokio" befindet, muss der Cloud Storage-Bucket ein regionaler Bucket in Tokio sein.
    • Ausnahme: Wenn sich Ihr Dataset am multiregionalen Standort "US" befindet, können Sie Daten in einen Cloud Storage-Bucket exportieren, der sich an einem beliebigen regionalen oder multiregionalen Standort befindet.
  • Entwickeln Sie einen Plan zur Datenverwaltung:
    • Wenn Sie eine regionale Speicherressource wie ein BigQuery ML-Dataset oder einen Cloud Storage-Bucket auswählen, müssen Sie einen Plan für die geografische Verwaltung Ihrer Daten erstellen.

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