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.
- 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
Esporta formati ed esempi di modelli
La tabella seguente mostra i formati di destinazione di esportazione per ciascun 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 | TensorFlow SavedModel (TF 2.1.0) | gcs_bucket/
|
AUTOML_REGRESSOR | ||
CODIFICATORE AUTOMATICO | TensorFlow SavedModel (TF 1.15 o versioni successive) | |
DNN_CLASSIFIER | ||
DNN_REGRESSOR | ||
DNN_LINEAR_COMBINED_CLASSIFIER | ||
DNN_LINEAR_COMBINED_REGRESSOR | ||
KMEAN | ||
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 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 |
Esporta modello addestrato con TRANSFORM
Se il modello viene addestrato con la clausola TRANSFORM
, un altro modello di pre-elaborazione 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
in Vertex AI e localmente. Per maggiori informazioni, consulta 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/
|
Il modello non contiene informazioni sul feature engineering
eseguito al di fuori della clausola TRANSFORM
durante l'addestramento. Ad esempio, qualsiasi elemento nell'istruzione SELECT
. Dovresti quindi
convertire manualmente i dati di input prima di inserirli nel modello
di pre-elaborazione.
Tipi di dati supportati
Quando si esportano modelli addestrati con la clausola TRANSFORM
,
sono supportati i seguenti tipi di dati che possono essere inseriti nella
clausola TRANSFORM
.
Tipo di input TRANSFORM | Campioni di input TRANSFORM | Campioni di input del modello di pre-elaborazione esportati |
---|---|---|
INT64 |
10,
|
tf.constant(
|
NUMERIC |
NUMERIC 10,
|
tf.constant(
|
BIGNUMERICO |
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(
|
NULL |
NULL,
|
tf.constant(
|
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
eNULLIF
.
- 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
/}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
,UPPER
.
- Funzioni di data
Date
,DATE_ADD
,DATE_SUB
,DATE_DIFF
,DATE_TRUNC
,EXTRACT
,FORMAT_DATE
,PARSE_DATE
eSAFE.PARSE_DATE
.
- Funzioni data/ora
DATETIME
,DATETIME_ADD
,DATETIME_SUB
,DATETIME_DIFF
,DATETIME_TRUNC
,EXTRACT
,PARSE_DATETIME
,SAFE.PARSE_DATETIME
.
- Funzioni temporali
TIME
,TIME_ADD
,TIME_SUB
,TIME_DIFF
,TIME_TRUNC
,EXTRACT
,FORMAT_TIME
,PARSE_TIME
eSAFE.PARSE_TIME
.
- Funzioni 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
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 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 ridurrenum_factors
durante l'addestramento per ridurle 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 implementati tramite il registro dei modelli per la previsione online.Durante l'esportazione del modello,
ARRAY<STRUCT<INT64, FLOAT64>>
,ARRAY
eTIMESTAMP
sono supportati come dati pre-trasformati, ma non come dati post-trasformati.
Esporta 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.
Fai clic su Esporta modello sul lato destro della finestra.
Nella finestra di dialogo Esporta il modello in Cloud Storage:
- In Seleziona la località di Cloud Storage, cerca il bucket o la 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 del riquadro 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
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 la tua 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 termine della query, nel riquadro Risultati delle query viene visualizzato quanto segue:
Successfully exported model
.
bq
Utilizza il comando bq extract
con il flag --model
.
(Facoltativo) Fornisci il flag --destination_format
e scegli il formato
del modello esportato.
(Facoltativo) Fornisci il flag --location
e imposta il valore sulla tua posizione.
bq --location=location extract \ --destination_format format \ --model project_id:dataset.model \ gs://bucket/model_folder
Dove:
- location è il nome della tua sede. Il flag
--location
è facoltativo. Ad esempio, se utilizzi BigQuery nell'area geografica 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 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
in 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 configurazione del job.
(Facoltativo) Specifica la tua località nella proprietà location
nella sezione
jobReference
della
risorsa job.
Creare un job di estrazione che punti al modello BigQuery ML e alla destinazione di Cloud Storage.
Specifica il modello di origine utilizzando l'oggetto di configurazione
sourceModel
contenente l'ID progetto, l'ID del set di dati e l'ID modello.La proprietà
destination URI(s)
deve essere completa e valida 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 migliorato, imposta questa proprietà sul valoreML_XGBOOST_BOOSTER
.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 è presente la proprietà
status.errorResult
, la richiesta non è andata a buon fine e l'oggetto includerà le 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 API:
Come best practice, genera un ID univoco e passalo come
jobReference.jobId
quando chiamijobs.insert
per creare un job. Questo approccio è più efficace per gli errori di rete perché il client può eseguire il polling o riprovare sull'ID job noto.Chiamare
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 avrà esito positivo.
Java
Prima di provare questo esempio, segui le istruzioni per la configurazione di Java nella guida rapida di BigQuery sull'utilizzo delle librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Java di BigQuery.
Per eseguire l'autenticazione su 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 su Vertex AI e localmente. Se la clausola TRANSFORM
del modello contiene funzioni Date, Datetime, Time o Timestamp, devi utilizzare la libreria BigQuery-ml-utils nel container. L'eccezione è se esegui il deployment tramite Model Registry,
che non ha bisogno di modelli esportati o container di gestione.
Deployment di Vertex AI
Esporta formato modello | Deployment |
---|---|
SavedModel di TensorFlow (modelli non AutoML) | Esegui il deployment di un SavedModel di TensorFlow (versione di runtime 1.15 o successiva) |
SavedModel di TensorFlow (modelli AutoML) | Funzionalità non supportata |
Booster XGBoost |
Routine di previsione personalizzata
(versione di runtime 1.15)
Nota: poiché nei file esportati sono presenti informazioni di pre-elaborazione e post-elaborazione, devi utilizzare una routine di previsione personalizzata per eseguire il deployment del modello con i file esportati aggiuntivi. |
Deployment locale
Esporta formato modello | Deployment |
---|---|
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 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 ciascuno 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] | +-----------------+ |
KMEAN
Formato di output della previsione | Esempio di output |
---|---|
+--------------------+--------------+---------------------+ | CENTROID_DISTANCES | CENTROID_IDS | NEAREST_CENTROID_ID | +--------------------+--------------+---------------------+ | [FLOAT] | [INT64] | INT64 | +--------------------+--------------+---------------------+ |
+--------------------+--------------+---------------------+ | CENTROID_DISTANCES | CENTROID_IDS | NEAREST_CENTROID_ID | +--------------------+--------------+---------------------+ | [1.2, 1.3] | [1, 2] | [1] | +--------------------+--------------+---------------------+ | [0.4, 0.1] | [1, 2] | [2] | +--------------------+--------------+---------------------+ |
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 |
---|
Come le 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 di albero migliorato in un bucket Cloud Storage.
- Scarica il file
model.bst
dal bucket Cloud Storage. - In un file Noteboook di Colab, 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 (un albero per iterazione):
Al momento, non salviamo i nomi delle caratteristiche nel modello, quindi vedrai nomi come "f0", "f1" e così via. Puoi trovare i nomi delle caratteristiche corrispondenti nel file esportato assets/model_metadata.json
utilizzando questi nomi (ad esempio "f0") come indici.
Autorizzazioni obbligatorie
Per esportare un modello BigQuery ML in Cloud Storage, devi disporre delle autorizzazioni per accedere al modello BigQuery ML, delle autorizzazioni per eseguire un job di esportazione e 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 per 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 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:
-
Colloca i tuoi bucket Cloud Storage per l'esportazione dei dati:
- Se il set di dati BigQuery si trova in
EU
(più regioni), il bucket Cloud Storage contenente i dati esportati deve trovarsi nella stessa località multiregionale o in una località contenuta all'interno di più regioni. Ad esempio, se il set di dati BigQuery si trova nell'area multiregionaleEU
, il bucket Cloud Storage può trovarsi nella regioneeurope-west1
Belgio, che si trova all'interno dell'UE.Se il 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
asia-northeast1
di Tokyo, il bucket Cloud Storage non può trovarsi nella località multiregionaleASIA
. - 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 tuoi dati.
Per ulteriori informazioni sulle località di Cloud Storage, consulta 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 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 prevede alcun costo, ma le esportazioni sono soggette alle quote e ai limiti di BigQuery. Per ulteriori informazioni sui prezzi di BigQuery, consulta la pagina Prezzi.
Dopo l'esportazione dei dati, ti viene addebitato il costo 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
- Scopri il tutorial Esportare un modello BigQuery ML per la previsione online.