Esportazione modelli

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:

• Utilizzando la console Google Cloud.
• Utilizzo dell'istruzione EXPORT MODEL.
• Utilizzo del 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 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

Esportare formati e esempi di modelli

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

Tipo di modello	Formato del modello di esportazione	Esempio di file esportati
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 o versioni successive)
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 ulteriori dettagli, consulta Deployment dei modelli.
BOOSTED_TREE_REGRESSOR
RANDOM_FOREST_REGRESSOR
RANDOM_FOREST_REGRESSOR
TENSORFLOW (importato)	SavedModel di TensorFlow	Esattamente gli stessi file presenti al momento dell'importazione del modello

Nota: la preelaborazione automatica dei dati effettuata durante la creazione del modello, ad esempio la standardizzazione e la codifica delle etichette, viene salvata nei file esportati come parte del grafo per TensorFlow SavedModel e nei file esterni per Booster. La pre-elaborazione esplicita non è necessaria prima di trasmettere i dati per la previsione. In genere, l'input deve corrispondere a quello utilizzato per ML.PREDICT BigQuery ML. Tutti i valori numerici nelle firme del modello esportate vengono trasmessi come tipo di dati FLOAT64 . Inoltre, tutti i campi STRUCT devono essere espansi in campi separati. Ad esempio, il campo f1 in STRUCT f2 deve essere rinominato f2_f1 e passato come colonna distinta.

Esportare il modello addestrato con TRANSFORM

Se il modello viene addestrato con la clausola TRANSFORM, un modello di preelaborazione aggiuntivo esegue la stessa logica nella clausola TRANSFORM e viene salvato nel formato SavedModel di TensorFlow nella sottodirectory transform. Puoi eseguire il deployment di un modello addestrato con la clausola TRANSFORM su Vertex AI e localmente. Per ulteriori informazioni, consulta la sezione Deployment dei modelli.

Formato del modello di esportazione	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 versioni successive)	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 le informazioni sull'ingegneria delle funzionalità eseguita al di fuori della clausola TRANSFORM durante l'addestramento. Ad esempio, qualsiasi elemento nell'istruzione SELECT . Dovrai quindi convertire manualmente i dati di input prima di inserirli nel modello di preelaborazione.

Tipi di dati supportati

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

Tipo di input TRANSFORM	Campioni di input TRANSFORM	Esempi di input del modello di preelaborazione esportati
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)
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.

• 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, 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, 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 di stringa
  • CONCAT, LEFT, LENGTH, LOWER, REGEXP_REPLACE, RIGHT, SPLIT, SUBSTR, SUBSTRING, TRIM, UPPER.
• Funzioni data
  • Date, DATE_ADD, DATE_SUB, DATE_DIFF, DATE_TRUNC, EXTRACT, FORMAT_DATE, PARSE_DATE, SAFE.PARSE_DATE.
• Funzioni di data/ora
  • DATETIME, DATETIME_ADD, DATETIME_SUB, DATETIME_DIFF, DATETIME_TRUNC, EXTRACT, PARSE_DATETIME, SAFE.PARSE_DATETIME.
• Funzioni relative al tempo
  • TIME, TIME_ADD, TIME_SUB, TIME_DIFF, TIME_TRUNC, EXTRACT, FORMAT_TIME, PARSE_TIME, SAFE.PARSE_TIME.
• Funzioni di timestamp
  • 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.
• 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

Quando esporti i modelli, si applicano le seguenti limitazioni:

• L'esportazione del modello non è supportata se durante l'addestramento sono state utilizzate una o più delle seguenti funzionalità:

  • Nei dati di input erano presenti tipi di elementi ARRAY, TIMESTAMP o GEOGRAPHY.

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

• Il limite di dimensioni del modello è 1 GB per l'esportazione del modello di fattorizzazione matriciale. Le dimensioni del modello sono approssimativamente proporzionali a num_factors, quindi puoi ridurre num_factors durante l'addestramento per ridurre le dimensioni del modello se raggiungi il limite.

• Per i modelli addestrati con la clausola TRANSFORM di BigQuery ML per la preelaborazione manuale delle funzionalità, consulta i tipi di dati e le funzioni supportati per l'esportazione.

• I modelli addestrati con la clausola TRANSFORM di BigQuery ML prima del 18 settembre 2023 devono essere riattizzati prima di poter essere implementati tramite il Registry dei modelli per la previsione online.

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

Esportare i modelli BigQuery ML

Per esportare un modello:

Console

1. Apri la pagina BigQuery nella console Google Cloud.
   

   Vai alla pagina BigQuery

2. Nel pannello di navigazione, nella sezione Risorse, 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.

   

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

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

Per controllare l'avanzamento del job, cerca Esportazione nella Cronologia dei job nella parte superiore della barra di navigazione.

SQL

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

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

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 l'istruzione EXPORT MODEL.

   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, nel riquadro Risultati query viene visualizzato quanto segue: Successfully exported model.

bq

Nota: per esportare un modello utilizzando lo strumento a riga di comando bq, devi disporre dello strumento bq nella versione 2.0.56 o successiva, incluso nell'interfaccia alla gcloud CLI nella versione 287.0.0 e successive. Per visualizzare la versione dello strumento bq installata, utilizza 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 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 sede. 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 posizione 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 trovarsi nella stessa località.
• model_folder è il nome della cartella in cui verranno scritti i file del modello esportati.

Esempi:

Ad esempio, il seguente comando esporta mydataset.mymodel nel formato SavedModel di TensorFlow 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 relativa configurazione.

(Facoltativo) Specifica la tua posizione nella proprietà location nella sezione jobReference della risorsa job.

1. Crea un job di estrazione che punti al modello BigQuery ML e alla 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 completa, nel formato gs://bucket/model_folder.

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

5. Per controllare lo stato del job, chiama jobs.get(job_id) con 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 è riuscita e l'oggetto includerà informazioni che descrivono il problema.
   • Se status.errorResult non è presente, il job è stato completato correttamente, anche se potrebbero essere stati rilevati alcuni errori non fatali. Gli errori non fatali sono elencati nella proprietà status.errors dell'oggetto job restituito.

Note sull'API:

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

• La chiamata a 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 andrà a buon fine.

Java

Prima di provare questo esempio, segui le istruzioni di configurazione Java riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Java.

Per autenticarti in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare 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 funzioni Data, Datetime, Ora o Timestamp, devi utilizzare la libreria bigquery-ml-utils nel contenitore. Fanno eccezione i deployment tramite Model Registry, che non richiedono modelli esportati o container di pubblicazione.

Deployment di Vertex AI

Formato del modello di esportazione	Deployment
SavedModel TensorFlow (modelli non AutoML)	Esegui il deployment di un SavedModel di TensorFlow. Devi creare il file SavedModel utilizzando una versione supportata di TensorFlow.
SavedModel di TensorFlow (modelli AutoML)	Non supportati.
XGBoost Booster	Utilizza una routine di previsione personalizzata. Per i modelli XGBoost Booster, le informazioni di preelaborazione e postelaborazione vengono salvate nei file esportati e una routine di previsione personalizzata consente di implementare il modello con i file extra esportati. Devi creare i file del modello utilizzando una versione supportata di XGBoost.

Deployment locale

Formato del modello di esportazione	Deployment
SavedModel TensorFlow (modelli non AutoML)	SavedModel è un formato standard e puoi eseguirne il deployment nel container Docker di TensorFlow Serving. Puoi anche sfruttare l'esecuzione locale della previsione online di Vertex AI.
SavedModel TensorFlow (modelli AutoML)	Esegui il containerizzazione ed esegui il modello.
XGBoost Booster	Per eseguire localmente i modelli XGBoost Booster, puoi utilizzare il file main.py esportato: Scarica tutti i file da Cloud Storage nella directory locale. Decomprimi il file predictor.py da xgboost_predictor-0.1.tar.gz nella directory locale. Esegui main.py (vedi le istruzioni in main.py).

Formato di output della previsione

Questa sezione fornisce il formato dell'output di previsione dei modelli esportati per ciascun tipo di modello. Tutti i modelli esportati supportano le previsioni batch e possono gestire più righe di input alla volta. Ad esempio, in ciascuno dei seguenti esempi di formato di output sono presenti due righe di input.

AUTOENCODER

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 l'input di un utente e l'output delle 50 coppie migliori (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
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] | +-------------------------+---------------------------------+

TRANSFORM_ONLY

Formato di output della previsione
Le stesse colonne specificate nella clausola TRANSFORM del modello

Visualizzazione del modello XGBoost

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

1. Esporta il modello ad albero migliorato 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 il seguente codice nel notebook:

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

Nota: utilizziamo l'encoder di etichette per codificare le funzionalità categoriche, in modo da poter ottenere la categoria corrispondente per un valore di suddivisione dal file del vocabolario nella directory "assets/" all'interno del bucket Cloud Storage di esportazione del modello. Ad esempio, quando vedi "f0 < 2.95" in un nodo, puoi trovare la corrispondente categoria nel file del vocabolario cercando il terzo elemento.

Al momento non salviamo i nomi delle funzionalità nel modello, quindi vedrai nomi come "f0", "f1" e così via. Puoi trovare i nomi delle funzionalità corrispondenti nel assets/model_metadata.json file esportato 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, per eseguire un job di esportazione e per scrivere i dati nel bucket Cloud Storage.

Autorizzazioni BigQuery

• Per esportare il modello, devi disporre almeno delle autorizzazioni bigquery.models.export. I seguenti ruoli IAM (Identity and Access Management) predefiniti vengono concessi alle autorizzazionibigquery.models.export:

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

• Per eseguire un job di esportazione, devi almeno 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 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 su ruoli e autorizzazioni IAM in BigQuery ML, consulta Controllo dell'accesso.

Considerazioni sulla località

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

Colloca i bucket Cloud Storage per l'esportazione dei dati:
• Se il set di dati BigQuery si trova nella regione multipla EU, il bucket Cloud Storage contenente i dati esportati deve trovarsi nella stessa regione multipla o in una posizione contenuta nella regione multipla. Ad esempio, se il set di dati BigQuery si trova nella regione multiregionale EU, il bucket Cloud Storage può trovarsi nella regione europe-west1 del Belgio, che fa parte dell'UE.

  Se il set di dati si trova nell'area geografica multipla US, puoi esportare i dati in un bucket Cloud Storage in qualsiasi posizione.

• Se il set di dati si trova in una regione, il bucket Cloud Storage deve trovarsi nella stessa regione. Ad esempio, se il set di dati si trova nella regione asia-northeast1 di Tokyo, il bucket Cloud Storage non può trovarsi nella regione multipla ASIA.
Sviluppare un piano di gestione dei dati:
• Se scegli una risorsa di archiviazione regionale, come un set di dati BigQuery 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.

Spostare i dati BigQuery tra posizioni

Non puoi modificare la posizione 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, consulta Job di esportazione nella pagina Quote e limiti.

Prezzi

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

Una volta esportati, ti vengono addebitati i costi per l'archiviazione dei dati in Cloud Storage. Per ulteriori informazioni sui prezzi di Cloud Storage, consulta la pagina Prezzi di Cloud Storage.

Passaggi successivi

• Segui il tutorial Esporta un modello BigQuery ML per la previsione online.