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. Per esportare un modello BigQuery ML:
- Utilizzando la console Google Cloud.
- Utilizzando l'istruzione
EXPORT MODEL
. - Utilizzo del comando
bq extract
nello strumento a riga di comando bq. - Inviare 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 dei modelli
La seguente tabella mostra i formati di destinazione dell'esportazione per ciascun tipo di modello BigQuery ML e fornisce un esempio di file scritti nel bucket Cloud Storage.
Tipo di modello | Esporta formato modello | Esempio di file esportati |
---|---|---|
AUTOML_CLASSIFIER | TensorFlow SavingModel (TF 2.1.0) | gcs_bucket/
|
AUTOML_REGRESSOR | ||
CODIFICATORE AUTOMATICO | TensorFlow SaveModel (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/
main.py è per l'esecuzione locale. Per ulteriori dettagli, consulta Deployment di modelli.
|
BOOSTED_TREE_REGRESSOR | ||
RANDOM_FOREST_REGRESSOR | ||
RANDOM_FOREST_REGRESSOR | ||
TENSORFLOW (importato) | SaveModel di TensorFlow | Esattamente gli stessi file presenti al momento dell'importazione del modello |
Esporta modello addestrato con TRANSFORM
Se il modello viene addestrato con la
clausola TRANSFORM
,
un ulteriore modello di pre-elaborazione esegue la stessa logica nella
clausola TRANSFORM
e viene salvato nel formato
SalvatoModel di TensorFlow nella sottodirectory transform
.
Puoi eseguire il deployment di un modello addestrato con la clausola TRANSFORM
su Vertex AI e localmente. Per maggiori informazioni, consulta la pagina relativa al deployment dei modelli.
Esporta formato modello | Esempio di file esportati |
---|---|
Modello di previsione: TensorFlow SavingModel o Booster (XGBoost 0.82).
Modello di pre-elaborazione per la clausola TRANSFORM: TensorFlow SavingModel (TF 2.5 o versioni successive) |
gcs_bucket/
|
Il modello non contiene le informazioni sul feature engineering eseguito al di fuori della clausola TRANSFORM
durante l'addestramento. Ad esempio, qualsiasi cosa nell'istruzione SELECT
. Dovresti quindi
convertire manualmente i dati di input prima di inserirli nel modello di
pre-elaborazione.
Tipi di dati supportati
Quando esporti modelli addestrati con la clausola TRANSFORM
,
sono supportati i seguenti tipi di dati per l'inserimento nella
clausola TRANSFORM
.
Tipo di input TRASFORMARE | TRASFORMARE campioni di input | Campioni di input dei modelli esportati di pre-elaborazione |
---|---|---|
INT64 |
10,
|
tf.constant(
|
NUMERIC |
NUMERIC 10,
|
tf.constant(
|
GRANDE NUMERO |
BIGNUMERIC 10,
|
tf.constant(
|
FLOAT64 |
10.0,
|
tf.constant(
|
BOOL |
TRUE,
|
tf.constant(
|
STRING |
'abc',
|
tf.constant(
|
BYTES |
b'abc',
|
tf.constant(
|
DATA |
DATE '2020-09-27',
|
tf.constant(
|
DATETIME |
DATETIME '2023-02-02 02:02:01.152903',
|
tf.constant(
|
TEMPO |
TIME '16:32:36.152903',
|
tf.constant(
|
TIMESTAMP |
TIMESTAMP '2017-02-28 12:30:30.45-08',
|
tf.constant(
|
ARRAY |
['a', 'b'],
|
tf.constant(
|
ARRAY< STRUCT< INT64, FLOAT64>> |
[(1, 1.0), (2, 1.0)],
|
tf.sparse.from_dense(
|
NULLA |
NULL,
|
tf.constant(
|
Funzioni SQL supportate
Quando esporti 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
eOR
.
- 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
,ACOSH
,ACOSH
,ACOSH
,ACOSH
,ACOSH
,ACOSH
,ACOSH
,ACOSH
,ACOSH
,ACOSH
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 stringa
CONCAT
,LEFT
,LENGTH
,LOWER
,REGEXP_REPLACE
,RIGHT
,SPLIT
,SUBSTR
,SUBSTRING
,TRIM
eUPPER
.
- Funzioni di 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
eSAFE.PARSE_DATETIME
.
- Funzioni temporali
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
eUNIX_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
eML.STANDARD_SCALER
.
Limitazioni
Durante l'esportazione dei modelli si applicano le seguenti limitazioni:
L'esportazione del modello non è supportata se durante l'addestramento è stata utilizzata una delle seguenti funzionalità:
- Nei dati di input erano presenti i tipi di funzionalità
ARRAY
,TIMESTAMP
oGEOGRAPHY
.
- Nei dati di input erano presenti i tipi di funzionalità
I modelli esportati per i tipi di modello
AUTOML_REGRESSOR
eAUTOML_CLASSIFIER
non supportano il deployment di Vertex AI per le previsioni online.Il limite di dimensioni del modello è di 1 GB per l'esportazione del modello di fattorizzazione matriciale. Le dimensioni del modello sono approssimativamente proporzionali a
num_factors
, quindi puoi diminuirenum_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 pre-elaborazione 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 riaddestrati prima di poter essere implementato tramite Model Registry per la previsione online.Durante l'esportazione del modello,
ARRAY<STRUCT<INT64, FLOAT64>>
,ARRAY
eTIMESTAMP
sono supportati come dati pre-trasmessi, ma non come dati dopo la trasformazione.
Esporta i modelli BigQuery ML
Per esportare un modello:
Console
Apri la pagina BigQuery nella console Google Cloud.
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.
Sul lato destro della finestra, fai clic su Esporta modello.
Nella finestra di dialogo Esporta modello in Cloud Storage:
- In Seleziona località di Cloud Storage, cerca il percorso 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 nella parte superiore della barra di navigazione la Cronologia dei 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 di GoogleSQL.
Per esportare un modello BigQuery ML nella console Google Cloud utilizzando l'istruzione EXPORT MODEL
, segui questi passaggi:
Nella console Google Cloud, apri la pagina BigQuery.
Fai clic su Crea nuova query.
Nel campo Editor query, digita l'istruzione
EXPORT MODEL
.La seguente query esporta un modello denominato
myproject.mydataset.mymodel
in un bucket Cloud Storage con URIgs://bucket/path/to/saved_model/
.EXPORT MODEL `myproject.mydataset.mymodel` OPTIONS(URI = 'gs://bucket/path/to/saved_model/')
Fai clic su Esegui. Al completamento della query, nel riquadro Risultati 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 località.
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 suasia-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) oML_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 vengono esportati 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 comando seguente esporta mydataset.mymodel
in formato TensorFlow SavingModel
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
nella
sezione jobReference
della
risorsa job.
Creare un job di estrazione che punta al modello BigQuery ML e alla destinazione di Cloud Storage.
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.La proprietà
destination URI(s)
deve essere completa, nel formato gs://bucket/model_folder.Specifica il formato di destinazione impostando la proprietà
configuration.extract.destinationFormat
. Ad esempio, per esportare un modello di albero potenziato, imposta questa proprietà sul valoreML_XGBOOST_BOOSTER
.Per verificare 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 è presente la proprietà
status.errorResult
, la richiesta non è andata a buon fine e l'oggetto includerà informazioni che descrivono l'errore. - Se
status.errorResult
non è presente, il job è stato completato correttamente, anche se potrebbero essersi verificati alcuni errori non irreversibili. Gli errori non irreversibili sono elencati nella proprietàstatus.errors
dell'oggetto job restituito.
- Se
Note dell'API:
Come best practice, genera un ID univoco e passalo come
jobReference.jobId
quando chiamijobs.insert
per creare un job. Questo approccio è più solido per gli 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 sullo 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 di Java disponibili nella guida rapida di BigQuery sull'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Java.
Per eseguire l'autenticazione in BigQuery, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per le librerie client.
Deployment del modello
Puoi eseguire il deployment del modello esportato in Vertex AI e localmente. Se la clausola TRANSFORM
del modello contiene funzioni di data, funzioni di data/ora, funzioni di ora o funzioni di timestamp, devi utilizzare la libreria bigquery-ml-utils nel container. Fa eccezione il caso in cui tu stia eseguendo il deployment tramite Model Registry, che non ha bisogno di modelli esportati o di container di gestione.
Deployment di Vertex AI
Esporta formato modello | Deployment |
---|---|
TensorFlow SaveModel (modelli non AutoML) | Esegui il deployment di un SaveModel TensorFlow (versione del runtime 1.15 o successiva) |
TensorFlow SaveModel (modelli AutoML) | Funzionalità non supportata |
Booster XGBoost |
Routine di previsione personalizzata
(versione runtime 1.15)
Nota: nei file esportati sono presenti informazioni di pre-elaborazione e post-elaborazione, pertanto 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 SaveModel (modelli non AutoML) |
SaveModel è un formato standard e puoi eseguirne il deployment nel container Docker TensorFlow Serving. Puoi anche sfruttare l'esecuzione locale della previsione online di Vertex AI. |
TensorFlow SaveModel (modelli AutoML) | Esegui il container AutoML. |
Booster XGBoost |
Per eseguire i modelli XGBoost Booster localmente, puoi utilizzare il file main.py
esportato:
|
Formato di output della previsione
Questa sezione fornisce il formato di output della previsione dei modelli esportati per ciascun tipo di modello. Tutti i modelli esportati supportano la previsione batch; possono gestire più righe di input contemporaneamente. Ad esempio, ci sono due righe di input in ognuno dei 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 l'ordinamento di un utente di input e di output delle prime 50 coppie (predicted_rating, Forecast_item) in base alla valutazione prevista 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 |
---|
Uguali alle colonne specificate nella clausola TRANSFORM del modello
|
Visualizzazione del modello XGBoost
Puoi visualizzare gli alberi potenziati utilizzando l'API Python plot_tree dopo l'esportazione del modello. Ad esempio, puoi utilizzare Colab senza installare le dipendenze:
- Esporta il modello ad albero potenziato in un bucket Cloud Storage.
- Scarica il file
model.bst
dal bucket Cloud Storage. - In Colab noteboook,
carica il file
model.bst
inFiles
. 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 (uno per iterazione):
Al momento, non salviamo i nomi delle caratteristiche nel modello, pertanto vedrai nomi
come "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, per eseguire un job di esportazione e per scrivere i dati nel bucket Cloud Storage.
Autorizzazioni BigQuery
Come minimo, per esportare il modello devi disporre delle autorizzazioni
bigquery.models.export
. Ai seguenti ruoli predefiniti di Identity and Access Management (IAM) vengono concesse le autorizzazionibigquery.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 sono concesse le autorizzazionibigquery.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 sono concesse le autorizzazionistorage.objects.create
:storage.objectCreator
storage.objectAdmin
storage.admin
Per ulteriori informazioni sui ruoli e sulle autorizzazioni IAM in BigQuery ML, consulta Controllo dell'accesso.
Considerazioni sulla località
Quando scegli una località per i tuoi dati, considera quanto segue:
-
Colloca i tuoi bucket Cloud Storage per l'esportazione dei dati:
- Se il set di dati BigQuery si trova nella località multiregionale
EU
, il bucket Cloud Storage contenente i dati esportati deve trovarsi nella stessa località a più regioni o in una località all'interno di più regioni. Ad esempio, se il set di dati BigQuery si trova nella località multiregionaleEU
, il bucket Cloud Storage può trovarsi nella regioneeurope-west1
del Belgio, che si trova all'interno dell'UE.Se il tuo set di dati si trova in
US
(più regioni), 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. Ad
esempio, se il set di dati si trova nella regione di Tokyo
asia-northeast1
, il bucket Cloud Storage non può trovarsi nella regione multiregionaleASIA
. - Se scegli una risorsa di Regional Storage, come un set di dati BigQuery o un bucket Cloud Storage, sviluppa un piano per la gestione geografica dei tuoi dati.
Per ulteriori informazioni sulle località di Cloud Storage, consulta Località dei bucket nella documentazione di Cloud Storage.
Spostare i dati di BigQuery tra le località
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
Non è previsto alcun costo per l'esportazione dei modelli BigQuery ML, ma le esportazioni sono soggette alle quote e ai limiti di BigQuery. Per ulteriori informazioni sui prezzi di BigQuery, consulta la pagina dei 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
- Esplora il tutorial Esporta un modello BigQuery ML per la previsione online.