Esportazione di modelli

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Panoramica

Questa pagina mostra come esportare i modelli BigQuery ML. Puoi esportare i modelli BigQuery ML in Cloud Storage e utilizzarli per la previsione online oppure modificarli in Python. Puoi esportare un modello BigQuery ML in base a:

  • Utilizzando la Google Cloud Console.
  • Utilizzare l'istruzione EXPORT MODEL.
  • usando il comando bq extract nello strumento a riga di comando bq.
  • Invio di un job extract tramite l'API o le librerie client.

Puoi esportare i seguenti tipi di modello:

  • 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
  • TENSORFLOW (modelli TensorFlow importati)
  • PCA

Esporta formati e campioni di modelli

La tabella seguente mostra i formati della destinazione di esportazione per ciascun tipo di modello di BigQuery ML e fornisce un esempio di file che vengono scritti nel bucket Cloud Storage.

Tipo di modello Esporta formato modello Esempio di file esportati
CLASSE_AUTOML TensorFlow SavedModel (TF 2.1.0) gcs_bucket/
  assets/
    f1.txt
    f2.txt
  saved_model.pb
  variables/
    variables.data-00-of-01
    variables.index
REGOLATORE_AUTOML
CODICE AUTOMATICO TensorFlow SavedModel (TF 1.15 o versioni successive)
DNN_CLASSIFICATORE
DNN_REGRESSOR
DNN_LINEAR_COMBINED_CLASSIFIER
DNN_LINEAR_COMBINED_REGRESSOR
KMEAN
REGOLATORE_LINEARIO
REGISTIC_REG
MATRIX_FACTORIZAZIONE
PCA
BOOSTED_TREE_CLASSIFIER Richiamo (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 è per l'esecuzione locale. Per ulteriori dettagli, consulta la sezione Deployment di modelli.
BOOSTED_TREE_REGRESSOR
TENSORFLOW (importato) TensorFlow SavedModel Esattamente gli stessi file che erano presenti durante l'importazione del modello

Il modello non contiene le informazioni sulla progettazione della funzionalità eseguite nell'istruzione SELECT durante l'addestramento, quindi dovresti convertire manualmente i dati di input prima di inserirli nel modello esportato.

Limitazioni

Quando esporti i modelli si applicano le seguenti limitazioni:

  • L'esportazione del modello non è supportata se durante l'addestramento è stata utilizzata una delle seguenti funzionalità:

  • I modelli esportati per i tipi di modelli AUTOML_REGRESSOR e AUTOML_CLASSIFIER non supportano il deployment di AI Platform per la previsione online.

  • Il limite per le dimensioni del modello è di 1 GB per l'esportazione dei modelli di fattorizzazione matrice. La dimensione del modello è circa proporzionale a num_factors, quindi puoi ridurre num_factors durante l'addestramento per ridurre le dimensioni del modello se raggiungi il limite.

  • Le funzionalità relative alle chiavi di crittografia gestite dal cliente non sono supportate per l'esportazione dei modelli.

Esportazione di modelli di ML ML

Per esportare un modello:

console

  1. Apri la pagina BigQuery in Google Cloud Console.

    Vai alla pagina BigQuery

  2. Nella sezione Risorse del pannello di navigazione, espandi il progetto e fai clic sul set di dati per espanderlo. Individua e fai clic sul modello che stai esportando.

  3. Sul lato destro della finestra, fai clic su Esporta modello.

    Esporta modello

  4. Nella finestra di dialogo Esporta modello in Cloud Storage:

    • In Seleziona località Cloud Storage, cerca il bucket o la posizione della cartella in cui vuoi esportare il modello.
    • Fai clic su Esporta per esportare il modello.

Per verificare l'avanzamento del job, guarda nella parte superiore della barra di navigazione Cronologia del job per un job di esportazione.

SQL

L'istruzione EXPORT MODEL consente di esportare i modelli BigQuery ML in Cloud Storage utilizzando la sintassi delle query SQL standard.

Per esportare un modello BigQuery ML nella console Google Cloud utilizzando l'istruzione EXPORT MODEL, segui questi passaggi:

  1. In Google Cloud Console, apri la pagina BigQuery.

    Vai a BigQuery

  2. Fai clic su Crea nuova query.

  3. Nel campo Editor query, digita l'istruzione EXPORT MODEL.

    La query seguente esporta un modello denominato myproject.mydataset.mymodel in un bucket Cloud Storage con URI gs://bucket/path/to/saved_model/.

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

  4. Fai clic su Esegui. Una volta completata la query, nel riquadro Risultati delle query viene visualizzato quanto segue: Successfully exported model.

bq

Utilizza il comando bq extract con il flag --model.

(Facoltativo) Fornisci il flag --destination_format e scegli il formato del modello esportato. (Facoltativo) Fornisci il flag --location e imposta il valore sulla tua posizione.

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

Dove:

  • location è il nome della tua località. Il flag --location è facoltativo. Ad esempio, se utilizzi BigQuery nella regione di Tokyo, puoi impostare il valore del flag su asia-northeast1. Puoi impostare un valore predefinito per la località utilizzando il file .bigqueryrc.
  • destination_format è il formato del modello esportato: ML_TF_SAVED_MODEL (predefinito) o ML_XGBOOST_BOOSTER.
  • project_id è l'ID progetto.
  • dataset è il nome del set di dati di origine.
  • model è il modello che stai esportando.
  • bucket è il nome del bucket Cloud Storage in cui stai esportando i dati. Il set di dati BigQuery e il bucket Cloud Storage devono essere nella stessa località.
  • model_folder è il nome della cartella in cui verranno scritti i file del modello esportati.

Esempi:

Ad esempio, il comando seguente esporta mydataset.mymodel in TensorFlow SavedModel in un bucket Cloud Storage denominato mymodel_folder.

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

Il valore predefinito di destination_format è ML_TF_SAVED_MODEL.

Il comando seguente esporta mydataset.mymodel in formato XGBoost Booster in un bucket Cloud Storage denominato mymodel_folder.

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

Server

Per esportare il modello, crea un job extract e completa la configurazione del job.

(Facoltativo) Specifica la tua località nella proprietà location nella sezione jobReference della risorsa del lavoro.

  1. Crea un job di estrazione che punti al modello BigQuery ML e alla destinazione di Cloud Storage.

  2. Specifica il modello di origine utilizzando l'oggetto di configurazione sourceModel che contiene l'ID progetto, l'ID del set di dati e l'ID modello.

  3. La proprietà destination URI(s) deve essere completa e nel formato gs://bucket/model_folder.

  4. Specifica il formato di destinazione impostando la proprietà configuration.extract.destinationFormat. Ad esempio, per esportare un modello di albero potenziato, imposta questa proprietà sul valore ML_XGBOOST_BOOSTER.

  5. Per controllare lo stato del job, chiama jobs.get(job_id) fornendo l'ID del job restituito dalla richiesta iniziale.

    • Se status.state = DONE, il job è stato completato correttamente.
    • Se la proprietà status.errorResult è presente, la richiesta non è andata a buon fine e l'oggetto includerà informazioni che descrivono ciò che è andato storto.
    • Se status.errorResult non è presente, il job è stato completato correttamente, ma potrebbero esserci errori non irreversibili. Gli errori non irreversibili sono elencati nella proprietà status.errors dell'oggetto job restituito.

Note API:

  • Come best practice, genera un ID univoco e trasmettilo come jobReference.jobId quando chiami jobs.insert per creare un job. Questo approccio è più robusto rispetto agli errori di rete, perché il client può eseguire il polling o riprovare sull'ID job noto.

  • Chiamare jobs.insert per un determinato ID job è idempotente; in altre parole, puoi riprovare tutte le volte che vuoi con lo stesso ID job e al massimo una di queste operazioni avrà esito positivo.

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());
    }
  }
}

Deployment del modello

Puoi eseguire il deployment del modello esportato in Google Cloud AI Platform e localmente.

Deployment di AI Platform

Esporta formato modello Deployment
Tensorflow SavedModel (modelli non AutoML) Esegui il deployment di un modello Tensorflow salvato (versione di runtime 1.15 o successiva)
Tensorflow SavedModel (modelli AutoML) Funzionalità non supportata
Booster XGBoost Routine di previsione personalizzata (versione 1,15 del runtime)

Nota: poiché nelle informazioni salvate sono presenti informazioni di pre-elaborazione e post-elaborazione, devi utilizzare una routine di previsione personalizzata per eseguire il deployment del modello con i file esportati aggiuntivi.

Deployment locale

Esporta formato modello Deployment
Tensorflow SavedModel (modelli non AutoML) SavedModel è un formato standard e puoi eseguirne il deployment nel container docker Tensorflow.

Puoi anche utilizzare l'esecuzione locale della previsione online di AI Platform.
Tensorflow SavedModel (modelli AutoML) Esegui il contenitore AutoML.
Booster XGBoost Per eseguire i modelli XGBoost Booster a livello locale, puoi utilizzare il file main.py esportato:
  1. Scarica tutti i file da Cloud Storage nella directory locale.
  2. Decomprimi il file predictor.py da xgboost_predictor-0.1.tar.gz nella directory locale.
  3. Esegui main.py (vedi le istruzioni in main.py).

Formato di output della previsione

Questa sezione fornisce il formato di output della previsione dei modelli esportati per ogni tipo di modello. Tutti i modelli esportati supportano la previsione batch; possono gestire più righe di input alla volta. Ad esempio, ci sono due righe di input in ciascuno dei seguenti esempi di formati di output.

CODICE AUTOMATICO

Formato di output della previsione Esempio di output

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

CLASSE_AUTOML

Formato di output della previsione Esempio di output

+------------------------------------------+
| predictions                              |
+------------------------------------------+
| [{"scores":[FLOAT], "classes":[STRING]}] |
+------------------------------------------+
        

+---------------------------------------------+
| predictions                                 |
+---------------------------------------------+
| [{"scores":[1, 2], "classes":['a', 'b']},   |
|  {"scores":[3, 0.2], "classes":['a', 'b']}] |
+---------------------------------------------+
        

REGOLATORE_AUTOML

Formato di output della previsione Esempio di output

+-----------------+
| predictions     |
+-----------------+
| [FLOAT]         |
+-----------------+
        

+-----------------+
| predictions     |
+-----------------+
| [1.8, 2.46]     |
+-----------------+
        

BOOSTED_TREE_CLASSIFIER

Formato di output della previsione Esempio di output

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

Formato di output della previsione Esempio di output

+-----------------+
| predicted_label |
+-----------------+
| FLOAT           |
+-----------------+
        

+-----------------+
| predicted_label |
+-----------------+
| [1.8]           |
+-----------------+
| [2.46]          |
+-----------------+
        

DNN_CLASSIFICATORE

Formato di output della previsione Esempio di output

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

Formato di output della previsione Esempio di output

+-----------------+
| PREDICTED_LABEL |
+-----------------+
| FLOAT           |
+-----------------+
        

+-----------------+
| PREDICTED_LABEL |
+-----------------+
| [1.8]           |
+-----------------+
| [2.46]          |
+-----------------+
        

DNN_LINEAR_COMBINED_CLASSIFIER

Formato di output della previsione Esempio di output

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

Formato di output della previsione Esempio di output

+-----------------+
| PREDICTED_LABEL |
+-----------------+
| FLOAT           |
+-----------------+
        

+-----------------+
| PREDICTED_LABEL |
+-----------------+
| [1.8]           |
+-----------------+
| [2.46]          |
+-----------------+
        

KMEAN

Formato di output della previsione Esempio di output

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

REG_LINEAR

Formato di output della previsione Esempio di output

+-----------------+
| PREDICTED_LABEL |
+-----------------+
| FLOAT           |
+-----------------+
        

+-----------------+
| PREDICTED_LABEL |
+-----------------+
| [1.8]           |
+-----------------+
| [2.46]          |
+-----------------+
       

REGISTIC_REG

Formato di output della previsione Esempio di output

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

Nota: al momento supportiamo solo l'utilizzo di un utente di input e delle prime 50 coppie (previsto_classificazione, previsione_articolo) ordinate per previsione_classificazione in ordine decrescente.

Formato di output della previsione Esempio di output

+--------------------+--------------+
| PREDICTED_RATING | PREDICTED_ITEM |
+------------------+----------------+
| [FLOAT]          | [STRING]       |
+------------------+----------------+
        

+--------------------+--------------+
| PREDICTED_RATING | PREDICTED_ITEM |
+------------------+----------------+
| [5.5, 1.7]       | ['A', 'B']     |
+------------------+----------------+
| [7.2, 2.7]       | ['B', 'A']     |
+------------------+----------------+
        

TENSORFLOW (importato)

Formato di output della previsione
Uguale al modello importato

PCA

Formato di output della previsione Esempio di output

+-------------------------+---------------------------------+
| PRINCIPAL_COMPONENT_IDS | PRINCIPAL_COMPONENT_PROJECTIONS |
+-------------------------+---------------------------------+
|       [INT64]           |             [FLOAT]             |
+-------------------------+---------------------------------+
        

+-------------------------+---------------------------------+
| PRINCIPAL_COMPONENT_IDS | PRINCIPAL_COMPONENT_PROJECTIONS |
+-------------------------+---------------------------------+
|       [1, 2]            |             [1.2, 5.0]          |
+-------------------------+---------------------------------+
        

Visualizzazione del modello XGBoost

Puoi visualizzare gli alberi potenziati utilizzando l'API plot_tree dopo l'esportazione del modello. Ad esempio, puoi utilizzare Colab senza installare le dipendenze:

  1. Esporta il modello ad albero potenziato in un bucket Cloud Storage.
  2. Scarica il file model.bst dal bucket Cloud Storage.
  3. In un blocco note di Colab, carica il file model.bst in Files.
  4. Esegui questo codice nel blocco note:

    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
    

Questo esempio illustra più alberi (un albero per iterazione):

Esporta modello

Al momento, i nomi delle funzionalità non vengono salvati nel modello, quindi vengono mostrati nomi quali "quot;f0", "f1" e così via. Puoi trovare i nomi delle funzionalità corrispondenti nel file esportato assets/model_metadata.json utilizzando questi nomi (ad esempio "f0") come indici.

Autorizzazioni obbligatorie

Per esportare un modello BigQuery ML in Cloud Storage, devi disporre delle autorizzazioni per accedere al modello BigQuery ML, delle autorizzazioni per eseguire un job di esportazione e delle autorizzazioni per scrivere i dati nel bucket Cloud Storage.

Autorizzazioni BigQuery

  • Come minimo, per esportare il modello, devi disporre delle autorizzazioni bigquery.models.export. Vengono concesse le seguenti autorizzazioni IAM predefinite: bigquery.models.export:

    • bigquery.dataViewer
    • bigquery.dataOwner
    • bigquery.dataEditor
    • bigquery.admin
  • Come minimo, per eseguire un job di esportazione, devi disporre delle autorizzazioni bigquery.jobs.create. Ai seguenti ruoli IAM predefiniti vengono concesse le autorizzazioni bigquery.jobs.create:

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

Autorizzazioni di Cloud Storage

  • Per scrivere i dati in un bucket Cloud Storage esistente, devi disporre delle autorizzazioni storage.objects.create. Ai seguenti ruoli IAM predefiniti vengono concesse le autorizzazioni storage.objects.create:

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

Per ulteriori informazioni sui ruoli IAM e sulle autorizzazioni in BigQuery ML, consulta la pagina Controllo dell'accesso. Per ulteriori informazioni sui ruoli a livello di set di dati, consulta Ruoli di base per i set di dati nella documentazione di BigQuery.

Considerazioni sulla località

Quando scegli una posizione per i tuoi dati, tieni presente quanto segue:

  • Coordina i bucket Cloud Storage per esportare i dati.
    • Se il set di dati BigQuery si trova in più aree geografiche, il bucket Cloud Storage che contiene i dati che stai esportando deve trovarsi nella stessa area geografica o in una località che si trova all'interno di quest'ultima. Ad esempio, se il set di dati BigQuery si trova nella regione a più regioni "UE", il bucket Cloud Storage può trovarsi nella regione Belgio "europe-west1", che si trova all'interno dell'UE.
    • Se il set di dati si trova in una regione, il bucket Cloud Storage deve essere nella stessa regione. Ad esempio, se il set di dati si trova nell'area geografica di Tokyo "asia-northeast1", il tuo bucket Cloud Storage non può trovarsi nell'area geografica "ASIA".
    • Eccezione: se il set di dati si trova nella località con più regioni "US", puoi esportare i dati in un bucket Cloud Storage in qualsiasi località.
  • Sviluppare un piano di gestione dei dati.
    • Se scegli una risorsa di archiviazione a livello di area geografica, ad esempio un set di dati BigQuery ML o un bucket Cloud Storage, sviluppa un piano per la gestione geografica dei dati.

Per ulteriori informazioni sulle località di Cloud Storage, consulta Località dei bucket nella documentazione di Cloud Storage.

Spostamento di dati BigQuery tra località

Non puoi modificare la località di un set di dati dopo averlo creato, ma puoi crearne una copia.

Criteri per le quote

Per informazioni sulle quote dei job di esportazione, vedi Esportazione dei job nella pagina Quote e limiti.

Prezzi

L'esportazione dei modelli di BigQuery ML non prevede alcun costo, ma le esportazioni sono soggette alle quote e ai limiti di BigQuery. Per ulteriori informazioni sui prezzi di BigQuery, consulta la pagina Prezzi.

Dopo l'esportazione dei dati, ti viene addebitato il costo di archiviazione dei dati in Cloud Storage. Per ulteriori informazioni sui prezzi di Cloud Storage, consulta la pagina Prezzi di Cloud Storage.

Passaggi successivi