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. - 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
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/
|
AUTOML_REGRESSOR | ||
CODIFICATORE AUTOMATICO | 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/
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 al momento dell'importazione del modello |
Esportare il 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, 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 superiore) |
gcs_bucket/
|
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
,
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(
|
NUMERIC |
NUMERIC 10,
|
tf.constant(
|
BIGNUMERIC |
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
,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
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 data
Date
,DATE_ADD
,DATE_SUB
,DATE_DIFF
,DATE_TRUNC
,EXTRACT
,FORMAT_DATE
,PARSE_DATE
,SAFE.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 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
oGEOGRAPHY
.
- Nei dati di input erano presenti tipi di elementi
I modelli esportati per i tipi di modelli
AUTOML_REGRESSOR
eAUTOML_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 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 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
eTIMESTAMP
sono supportati come dati pre-trasformati, ma non come dati post-trasformati.
Esportare 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 le progetto e fai clic sul set di dati per espanderlo. Trova e fai clic sul modello. che stai esportando.
Sul lato destro della finestra, fai clic su Esporta modello.
Nella finestra di dialogo Esporta il 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 usando GoogleSQL
la sintassi della query.
Per esportare un modello BigQuery ML nella console Google Cloud utilizzando l'istruzione EXPORT MODEL
:
Nella console Google Cloud, apri la pagina BigQuery.
Fai clic su Crea nuova query.
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 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 nella 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
(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 deve trovarsi nello stesso location.
- 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 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.
Crea un job di estrazione che punti al modello BigQuery ML e alla 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 la proprietà
configuration.extract.destinationFormat
. 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
status.errorResult
non è presente, il job è stato completato correttamente, anche se potrebbero essere stati rilevati alcuni errori non fatali. 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 approccio è più robusto in caso di errori di rete perché il client può eseguire il polling o riprovare con l'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 autenticarti a BigQuery, configura le 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
utilizza 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
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. |
Booster XGBoost |
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 utilizzare l'esecuzione locale della previsione online di Vertex AI. |
SavedModel TensorFlow (modelli AutoML) | Esegui il contenitore AutoML. |
XGBoost Booster |
Per eseguire localmente i modelli XGBoost Booster, 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 per ogni tipo di modello. Tutti i modelli esportati supportano le previsioni 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 l'ordinamento di un utente di input e delle 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 |
---|
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:
- 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 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 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 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
. 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 Cloud Storage
Per scrivere i dati in un bucket Cloud Storage esistente, devi avere autorizzazioni concesse a
storage.objects.create
. Ai seguenti ruoli IAM predefiniti vengono concesse le autorizzazionistorage.objects.create
: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:
-
Colloca 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 si trova nella regione multiregionaleEU
, il bucket Cloud Storage può trovarsi nella regioneeurope-west1
del Belgio, che fa parte 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. Ad esempio, se il set di dati si trova nella regione
asia-northeast1
di Tokyo, il bucket Cloud Storage non può trovarsi nella regione multiplaASIA
. - 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, vedi Località dei bucket nella documentazione di Cloud Storage.
Spostare i dati BigQuery tra posizioni
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
- Segui il tutorial Esporta un modello BigQuery ML per la previsione online.