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/
|
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/
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
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/
|
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,
|
tf.constant(
|
NUMERICO |
NUMERIC 10,
|
tf.constant(
|
BIGNUMERICO |
BIGNUMERIC 10,
|
tf.constant(
|
FLOAT64 |
10.0,
|
tf.constant(
|
BOOL |
TRUE,
|
tf.constant(
|
STRINGA |
'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
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
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
,LOG10
,MOD
,POW
,POWER
,SEC
,SECH
,SIGN
,SIN
,SINH
,SQRT
,TAN
eTANH
.
- 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
eSAFE.PARSE_DATE
.
- Funzioni data/ora
DATETIME
,DATETIME_ADD
,DATETIME_SUB
eDATETIME_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
eSAFE.PARSE_TIME
.
- Funzioni timestamp
TIMESTAMP
,TIMESTAMP_ADD
,TIMESTAMP_SUB
eTIMESTAMP_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
oGEOGRAPHY
erano presenti nell'elemento i dati di input.
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 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
eTIMESTAMP
sono supportati come dati pretrasformati, ma non come dati 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 le progetto e fai clic sul set di dati per espanderlo. Trova 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 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:
Nella console Google Cloud, apri la pagina BigQuery.
Fai clic su Crea nuova query.
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 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, nella sezione Riquadro Risultati query:
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 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 suasia-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) 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 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.
Creare un job di estrazione che punti al modello BigQuery ML la destinazione Cloud Storage.
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.La proprietà
destination URI(s)
deve essere completamente idonea, nel formato gs://bucket/model_folder.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 valoreML_XGBOOST_BOOSTER
.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 campostatus.errors
dell'oggetto job restituito proprietà.
- Se
Note API:
Come best practice, genera un ID univoco e passalo come
jobReference.jobId
quando chiamijobs.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.
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:
|
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:
- Esporta il modello di albero migliorato in un bucket Cloud Storage.
- Scarica il file
model.bst
dal bucket Cloud Storage. - In un noteboook di Colab,
carica il file
model.bst
suFiles
. 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 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 concessebigquery.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 concessestorage.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à multiregionaleEU
, il bucket Cloud Storage può trovarsi nella zonaeurope-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à multiregionaleASIA
. - 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.