Esportazione modelli

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

• Utilizzando la console Google Cloud.
• Utilizzo dell'istruzione EXPORT MODEL.
• Utilizzo del comando bq extract nello strumento a riga di comando bq.
• L'invio di un Job extract tramite l'API o le librerie client.

Puoi esportare i seguenti tipi di modelli:

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

Esporta formati ed esempi di modelli

La tabella seguente mostra i formati di destinazione di esportazione per ogni il tipo di modello 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
AUTOML_CLASSIFIER	SavedModel di TensorFlow (TF 2.1.0)	gcs_bucket/   assets/     f1.txt     f2.txt   saved_model.pb   variables/     variables.data-00-of-01     variables.index
AUTOML_REGRESSOR
CODIFICATORE AUTOMATICO	SavedModel di TensorFlow (TF 1.15 o superiore)
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 è per l'esecuzione locale. Per maggiori dettagli, consulta Deployment del modello.
BOOSTED_TREE_REGRESSOR
RANDOM_FOREST_REGRESSOR
RANDOM_FOREST_REGRESSOR
TENSORFLOW (importato)	SavedModel di TensorFlow	Esattamente gli stessi file presenti durante l'importazione del modello

Nota: la pre-elaborazione automatica dei dati eseguite durante la creazione del modello, come la standardizzazione e la codifica delle etichette, viene salvato nei file esportati come parte del grafico per SavedModel di TensorFlow, e nei file esterni per Booster. Non è necessaria la pre-elaborazione esplicita prima del giorno per la trasmissione dei dati per la previsione. L'input deve generalmente corrispondere a quello utilizzato per BigQuery ML ML.PREDICT. Tutti i valori numerici nelle firme del modello esportato vengono trasmessi come tipo di dati FLOAT64 . Inoltre, tutti i campi di STRUCT devono essere espansi in campi separati. Ad esempio: campo f1 in STRUCT f2 deve essere rinominato come f2_f1 e passato come un campo colonna.

Esporta modello addestrato con TRANSFORM

Se il modello viene addestrato con clausola TRANSFORM, un modello di pre-elaborazione aggiuntivo esegue la stessa logica clausole TRANSFORM e viene salvata nella Formato di TensorFlow SavedModel nella sottodirectory transform. Puoi eseguire il deployment di un modello addestrato con la clausola TRANSFORM a Vertex AI e in locale. Per ulteriori informazioni, vedi il deployment del modello.

Esporta formato modello	Esempio di file esportati
Modello di previsione: TensorFlow SavedModel o Booster (XGBoost 0.82). Modello di pre-elaborazione per la clausola TRANSFORM: TensorFlow SavedModel (TF 2.5 o superiore)	gcs_bucket/   ....(model files)   transform/     assets/         f1.txt/         f2.txt/     saved_model.pb     variables/         variables.data-00-of-01         variables.index

Il modello non contiene informazioni sul feature engineering eseguita al di fuori della clausola TRANSFORM durante l'addestramento. Ad esempio, qualsiasi elemento nell'istruzione SELECT . Quindi dovreste devono convertire manualmente i dati di input prima di inserirli nella fase di pre-elaborazione un modello di machine learning.

Tipi di dati supportati

Quando esporti i modelli addestrati con la clausola TRANSFORM, sono supportati i seguenti tipi di dati per l'inserimento nel clausola TRANSFORM.

Tipo di input TRANSFORM	Campioni di input TRANSFORM	Campioni di input del modello di pre-elaborazione esportati
INT64	10, 11	tf.constant(   [10, 11],   dtype=tf.int64)
NUMERICO	NUMERIC 10, NUMERIC 11	tf.constant(   [10, 11],   dtype=tf.float64)
BIGNUMERICO	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)
STRINGA	'abc', 'def'	tf.constant(   ['abc', 'def'],   dtype=tf.string)
BYTES	b'abc', b'def'	tf.constant(   ['abc', 'def'],   dtype=tf.string)
DATA	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
TEMPO	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)

Funzioni SQL supportate

Quando esporti i modelli addestrati con la clausola TRANSFORM, puoi utilizzare le seguenti funzioni SQL all'interno della clausola TRANSFORM di Google.

• Operatori
  • +, -, *, /, =, <, >, <=, >=, !=, <>, [NOT] BETWEEN, [NOT] IN, IS [NOT] NULL, IS [NOT] TRUE, IS [NOT] FALSE, NOT, AND, OR.
• Espressioni condizionali
  • CASE expr, CASE, COALESCE, IF, IFNULL e NULLIF.
• Funzioni matematiche
  • 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 e TANH.
• Funzioni di conversione
  • CAST AS INT64, CAST AS FLOAT64, CAST AS NUMERIC CAST AS BIGNUMERIC, CAST AS STRING, SAFE_CAST AS INT64 SAFE_CAST AS FLOAT64
• Funzioni stringa
  • CONCAT, LEFT, LENGTH, LOWER, REGEXP_REPLACE, RIGHT, SPLIT, SUBSTR, SUBSTRING, TRIM e UPPER.
• Funzioni di data
  • Date, DATE_ADD, DATE_SUB, DATE_DIFF, DATE_TRUNC, EXTRACT, FORMAT_DATE, PARSE_DATE e SAFE.PARSE_DATE.
• Funzioni data/ora
  • DATETIME, DATETIME_ADD, DATETIME_SUB e DATETIME_DIFF DATETIME_TRUNC, EXTRACT, PARSE_DATETIME e SAFE.PARSE_DATETIME.
• Funzioni temporali
  • TIME, TIME_ADD, TIME_SUB, TIME_DIFF, TIME_TRUNC, EXTRACT, FORMAT_TIME, PARSE_TIME e SAFE.PARSE_TIME.
• Funzioni timestamp
  • TIMESTAMP, TIMESTAMP_ADD, TIMESTAMP_SUB e 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.
• Funzioni di pre-elaborazione manuale
  • 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.

Limitazioni

Durante l'esportazione dei modelli si applicano le seguenti limitazioni:

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

  • ARRAY, TIMESTAMP o GEOGRAPHY erano presenti nell'elemento i dati di input.

• Modelli esportati per i tipi di modello AUTOML_REGRESSOR e AUTOML_CLASSIFIER non supportano il deployment di Vertex AI per la previsione online.

• Il limite per le dimensioni del modello è 1 GB per l'esportazione del modello di fattorizzazione matriciale. Le dimensioni del modello sono più o meno proporzionali a num_factors, quindi puoi ridurre num_factors durante l'addestramento per ridurre le dimensioni del modello se viene raggiunto il limite.

• Per i modelli addestrati con Clausola TRANSFORM di BigQuery ML per la pre-elaborazione manuale delle funzionalità, consulta i tipi di dati e funzioni supportati per l'esportazione.

• Modelli addestrati con la clausola TRANSFORM di BigQuery ML prima del 18 settembre 2023 devono essere riaddestrati prima di poter distribuito mediante Model Registry per la previsione online.

• Durante l'esportazione del modello, ARRAY<STRUCT<INT64, FLOAT64>>, ARRAY e TIMESTAMP sono supportati come dati pretrasformati, ma non come dati dati post-trasformati.

Esporta modelli BigQuery ML

Per esportare un modello:

Console

1. Apri la pagina BigQuery nella console Google Cloud.
   

   Vai alla pagina di BigQuery

2. Nel pannello di navigazione, nella sezione Risorse, espandi le progetto e fai clic sul set di dati per espanderlo. Trova e fai clic sul modello. che stai esportando.

3. Fai clic su Esporta modello sul lato destro della finestra.

   

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

   • In Seleziona la località di 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 controllare l'avanzamento del job, guarda vicino alla parte superiore della barra di navigazione alla Cronologia dei job per un job di esportazione.

SQL

L'istruzione EXPORT MODEL consente di esportare i modelli BigQuery ML in Cloud Storage usando GoogleSQL la sintassi della query.

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

1. Nella console Google Cloud, apri la pagina BigQuery.

   Vai a BigQuery

2. Fai clic su Crea nuova query.

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

   La seguente query 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. Al termine della query, nella sezione Riquadro Risultati query: Successfully exported model.

bq

Nota: per esportare un modello utilizzando lo strumento a riga di comando bq, è necessario disporre dello strumento bq versione 2.0.56 o successiva, inclusa in gcloud CLI versione 287.0.0 e successive. Per visualizzare la versione dello strumento bq installato, usa bq version e, se necessario, aggiorna gcloud CLI utilizzando gcloud components update.

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 su la tua posizione.

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

Dove:

• location è il nome della tua sede. Il flag --location è facoltativo. Ad esempio, se utilizzi BigQuery Regione di Tokyo, puoi impostare il valore del flag su asia-northeast1. Puoi imposta un valore predefinito per la località utilizzando file.bigqueryrc.
• destination_format è il formato del modello esportato: ML_TF_SAVED_MODEL (valore 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 da da cui stai esportando i dati. Il set di dati BigQuery e Il bucket Cloud Storage deve trovarsi nello stesso location.
• model_folder è il nome della cartella in cui sono stati esportati i file verranno scritti file di modello.

Esempi:

Ad esempio, il seguente comando 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 seguente comando 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

API

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

(Facoltativo) Specifica la tua località nella proprietà location del jobReference del risorse di lavoro.

1. Creare un job di estrazione che punti al modello BigQuery ML la destinazione Cloud Storage.

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

3. La proprietà destination URI(s) deve essere completamente idonea, nel formato gs://bucket/model_folder.

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

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

   • Se status.state = DONE, il job è stato completato correttamente.
   • Se è presente la proprietà status.errorResult, la richiesta non è riuscita. e l'oggetto includerà informazioni che descrivono cosa non ha funzionato.
   • Se il campo status.errorResult non è presente, il job è stato completato correttamente. anche se potrebbero essersi verificati alcuni errori non irreversibili. Non irreversibile gli errori sono elencati nel campo status.errors dell'oggetto job restituito proprietà.

Note API:

• Come best practice, genera un ID univoco e passalo come jobReference.jobId quando chiami jobs.insert per creare un job. Questo è più efficace per gli errori di rete perché il client può eseguire oppure riprova sull'ID job noto.

• Chiamare jobs.insert su 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 riuscirà.

Java

Prima di provare questo esempio, segui le istruzioni per la configurazione di Java nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Java BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

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 su Vertex AI e localmente. Se la clausola TRANSFORM del modello contiene Date funzioni, funzioni Datetime, funzioni Time o Timestamp, è necessario usa la libreria BigQuery-ml-utils nel container. L'eccezione è se esegui il deployment tramite Model Registry, che non richiede modelli esportati o container di pubblicazione.

Deployment di Vertex AI

Esporta formato modello	Deployment
SavedModel di TensorFlow (modelli non AutoML)	Esegui il deployment di un SavedModel di TensorFlow (versione runtime 1.15 o successiva)
SavedModel di TensorFlow (modelli AutoML)	Non supportata
Booster XGBoost	Routine di previsione personalizzata (versione runtime 1.15) Nota: poiché sono presenti informazioni di pre-elaborazione e post-elaborazione salvati nei file esportati, devi utilizzare Personalizzato routine di previsione per eseguire il deployment del modello con i file esportati in eccesso.

Deployment locale

Esporta formato modello	Deployment
SavedModel di TensorFlow (modelli non AutoML)	SavedModel è un formato standard e puoi eseguirne il deployment in Container DockerFlow Serving. Puoi anche sfruttare l'esecuzione locale della previsione online di Vertex AI.
SavedModel di TensorFlow (modelli AutoML)	Esegui il container AutoML.
Booster XGBoost	Per eseguire i modelli XGBooster in locale, puoi utilizzare l'istruzione main.py esportata file: Scarica tutti i file da Cloud Storage nella directory locale. Decomprimi il file predictor.py da xgboost_predictor-0.1.tar.gz in nella directory locale. 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 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 ciascuna i seguenti esempi di formati di output.

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

AUTOML_CLASSIFIER

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

AUTOML_REGRESSOR

Formato di output della previsione	Esempio di output
+-----------------+ | predictions | +-----------------+ | [FLOAT] | +-----------------+	+-----------------+ | predictions | +-----------------+ | [1.8, 2.46] | +-----------------+

BOOSTED_TREE_CLASSIFIER e RANDOM_FOREST_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 E RANDOM_FOREST_REGRESSOR

Formato di output della previsione	Esempio di output
+-----------------+ | predicted_label | +-----------------+ | FLOAT | +-----------------+	+-----------------+ | predicted_label | +-----------------+ | [1.8] | +-----------------+ | [2.46] | +-----------------+

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

KMEANS

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

LINEAR_REG

Formato di output della previsione	Esempio di output
+-----------------+ | PREDICTED_LABEL | +-----------------+ | FLOAT | +-----------------+	+-----------------+ | PREDICTED_LABEL | +-----------------+ | [1.8] | +-----------------+ | [2.46] | +-----------------+

LOGISTIC_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_FACTORIZATION

Nota: al momento supportiamo solo la selezione di un utente di input e le prime 50 coppie (predicted_rating, predicted_item) ordinate in base a predicted_rating 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
Come il 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] | +-------------------------+---------------------------------+

TRANSFORM_ONLY

Formato di output della previsione
Uguale alle colonne specificate nella colonna TRANSFORM del modello clausola

Visualizzazione del modello XGBoost

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

1. Esporta il modello di albero migliorato in un bucket Cloud Storage.
2. Scarica il file model.bst dal bucket Cloud Storage.
3. In un noteboook di Colab, carica il file model.bst su 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 traccia più alberi (un albero per iterazione):

Nota: utilizziamo il codificatore delle etichette per codificare le caratteristiche categoriche, in modo che tu possa ottenere la categoria corrispondente per un valore split dal file vocabolario nel 'assets/' all'interno del bucket Cloud Storage di esportazione del modello. Per Ad esempio, se vedi "f0 < 2,95" in un nodo, puoi trovare le informazioni categoria nel file di vocabolario, cercando il terzo elemento.

Al momento, non salviamo i nomi delle caratteristiche nel modello, quindi vedrai i nomi ad esempio "f0", "f1" e così via. Puoi trovare i nomi delle caratteristiche corrispondenti in il 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 necessarie accedere al modello ML di BigQuery, alle autorizzazioni per eseguire un job di esportazione e autorizzazioni per scrivere i dati nel bucket Cloud Storage.

Autorizzazioni BigQuery

• Come minimo, per esportare il modello devi disporre di bigquery.models.export autorizzazioni aggiuntive. Sono stati concessi i seguenti ruoli predefiniti di Identity and Access Management (IAM) bigquery.models.export autorizzazioni:

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

• Come minimo, per eseguire un job di esportazione, devi ricevere le autorizzazioni bigquery.jobs.create. Le seguenti impostazioni predefinite Ai ruoli IAM sono concesse bigquery.jobs.create autorizzazioni:

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

Autorizzazioni per Cloud Storage

• Per scrivere i dati in un bucket Cloud Storage esistente, devi avere autorizzazioni concesse a storage.objects.create. Le seguenti impostazioni predefinite Ai ruoli IAM sono concesse storage.objects.create autorizzazioni:

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

Per saperne di più su ruoli e autorizzazioni IAM in BigQuery ML, consulta Controllo dell'accesso.

Considerazioni sulla località

Quando scegli una località per i tuoi dati, considera quanto segue:

Assegna i bucket Cloud Storage per l'esportazione dei dati:
• Se il set di dati BigQuery si trova nella località multiregionale EU, il bucket Cloud Storage contenenti i dati che esporti devono trovarsi nella stessa località multiregionale o in una località è contenuto all'interno di più regioni. Ad esempio, se il set di dati BigQuery è nella località multiregionale EU, il bucket Cloud Storage può trovarsi nella zona europe-west1 Regione del Belgio all'interno dell'UE.

  Se il set di dati si trova nella località multiregionale US, puoi esportare i dati in un bucket Cloud Storage in qualsiasi località.

• Se il set di dati si trova in una regione, il bucket Cloud Storage deve trovarsi nella stessa regione. Per Ad esempio, se il set di dati si trova nella regione asia-northeast1 di Tokyo, i dati di Cloud Storage il bucket non può trovarsi nella località multiregionale ASIA.
Sviluppa un piano di gestione dei dati:
• Se scegli una risorsa di archiviazione regionale, ad esempio un set di dati BigQuery un bucket Cloud Storage, sviluppa un piano la gestione geografica dei tuoi dati.

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

Spostare i dati BigQuery tra località

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

Criteri per le quote

Per informazioni sulle quote dei job di esportazione, consulta Esporta i job nella pagina Quote e limiti.

Prezzi

Non è previsto alcun costo per l'esportazione dei modelli BigQuery ML, ma sono soggette alle norme di BigQuery, Quote e limiti. Per ulteriori informazioni su BigQuery consulta la pagina Prezzi.

Una volta esportati i dati, ti viene addebitato il costo per l'archiviazione di archiviazione ideale in Cloud Storage. Per ulteriori informazioni sui prezzi di Cloud Storage, consulta Prezzi di Cloud Storage.

Passaggi successivi

• Scopri come esportare un modello BigQuery ML per la previsione online. durante il tutorial.