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 per:
- Utilizzando la console Google Cloud.
- Utilizzo dell'istruzione
EXPORT MODEL
. - Utilizzo del comando
bq extract
nello strumento a riga di comando bq. - Invio di un job
extract
tramite l'API o le librerie client.
Puoi esportare i seguenti tipi di modelli:
AUTOENCODER
AUTOML_CLASSIFIER
AUTOML_REGRESSOR
BOOSTED_TREE_CLASSIFIER
BOOSTED_TREE_REGRESSOR
DNN_CLASSIFIER
DNN_REGRESSOR
DNN_LINEAR_COMBINED_CLASSIFIER
DNN_LINEAR_COMBINED_REGRESSOR
KMEANS
LINEAR_REG
LOGISTIC_REG
MATRIX_FACTORIZATION
RANDOM_FOREST_CLASSIFIER
RANDOM_FOREST_REGRESSOR
TENSORFLOW
(modelli TensorFlow importati)PCA
TRANSFORM_ONLY
Esportare formati e esempi di modelli
La tabella seguente mostra i formati di destinazione dell'esportazione per ogni tipo di modello BigQuery ML e fornisce un esempio di file che vengono scritti nel bucket Cloud Storage.
Tipo di modello | Esporta formato modello | Esempio di file esportati |
---|---|---|
AUTOML_CLASSIFIER | TensorFlow SavedModel (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 ulteriori dettagli, consulta Deployment dei modelli.
|
BOOSTED_TREE_REGRESSOR | ||
RANDOM_FOREST_REGRESSOR | ||
RANDOM_FOREST_REGRESSOR | ||
TENSORFLOW (importato) | SavedModel di TensorFlow | Esattamente gli stessi file presenti al momento dell'importazione del modello |
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 le informazioni sull'ingegneria delle funzionalità eseguita al di fuori della clausola TRANSFORM
durante l'addestramento. Ad esempio, qualsiasi elemento nell'istruzione SELECT
. Dovrai quindi
convertire manualmente i dati di input prima di inserirli nel
modello di preelaborazione.
Tipi di dati supportati
Quando esporti i modelli addestrati con la clausola TRANSFORM
,
i seguenti tipi di dati sono supportati per l'inserimento nella
clausola TRANSFORM
.
Tipo di input TRANSFORM | Campioni di input TRANSFORM | Esempi di input del modello di preelaborazione esportati |
---|---|---|
INT64 |
10,
|
tf.constant(
|
NUMERICO |
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
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
,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 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 relative al tempo
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
Durante l'esportazione dei 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
Modelli esportati per i tipi di modello
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 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 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 riquadro 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:
- Per Seleziona la posizione di Cloud Storage, cerca la posizione del bucket o della cartella in cui vuoi esportare il modello.
- Fai clic su Esporta per esportare il modello.
Per controllare l'avanzamento del job, cerca Esportazione nella Cronologia dei job nella parte superiore della barra di navigazione.
SQL
L'istruzione EXPORT MODEL
consente di esportare i modelli BigQuery ML
in Cloud Storage utilizzando la sintassi delle query GoogleSQL.
Per esportare un modello BigQuery ML nella console Google Cloud utilizzando l'istruzione EXPORT MODEL
:
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 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 stazione di ricarica. Il flag
--location
è facoltativo. Ad esempio, se utilizzi BigQuery Regione di Tokyo, puoi impostare il valore del flag suasia-northeast1
. Puoi impostare un valore predefinito per la posizione utilizzando il file .bigqueryrc. - destination_format è il formato del modello esportato:
ML_TF_SAVED_MODEL
(predefinito) 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 verranno scritti i file del modello esportati.
Esempi:
Ad esempio, il seguente comando esporta mydataset.mymodel
nel formato SavedModel di TensorFlow in un bucket Cloud Storage denominato mymodel_folder
.
bq extract --model \ 'mydataset.mymodel' \ gs://example-bucket/mymodel_folder
Il valore predefinito di destination_format è ML_TF_SAVED_MODEL
.
Il seguente comando esporta mydataset.mymodel
in formato XGBoost Booster
in un bucket Cloud Storage denominato mymodel_folder
.
bq extract --model \ --destination_format ML_XGBOOST_BOOSTER \ 'mydataset.mytable' \ gs://example-bucket/mymodel_folder
API
Per esportare il modello, crea un job extract
e compila la relativa configurazione.
(Facoltativo) Specifica la tua 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 completa, nel formato gs://bucket/model_folder.Specifica il formato di destinazione impostando il parametro
configuration.extract.destinationFormat
proprietà. Ad esempio, per esportare un modello ad albero con boosting, 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 la proprietà
status.errorResult
è presente, la richiesta non è riuscita e l'oggetto includerà informazioni che descrivono il problema. - Se
status.errorResult
non è presente, il job è stato completato correttamente, anche se potrebbero essere stati rilevati alcuni errori non fatali. Gli errori non fatali sono elencati nella proprietàstatus.errors
dell'oggetto job restituito.
- Se
Note sull'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.La chiamata a
jobs.insert
su un determinato ID job è idempotente; in altre parole, puoi riprovare tutte le volte che vuoi con lo stesso ID job e al massimo una di queste operazioni andrà a buon fine.
Java
Prima di provare questo esempio, segui le istruzioni di configurazione Java riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Java.
Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per saperne di più, 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 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
Esporta formato modello | Deployment |
---|---|
SavedModel di TensorFlow (modelli non AutoML) | Esegui il deployment di un SavedModel di TensorFlow. Devi creare il file SavedModel utilizzando una versione supportata di TensorFlow, |
SavedModel di TensorFlow (modelli AutoML) | Non supportati. |
XGBoost Booster |
Utilizza una routine di previsione personalizzata. Per i modelli XGBoost Booster, le informazioni di preelaborazione e postelaborazione vengono salvate nei file esportati e una routine di previsione personalizzata consente di implementare il modello con i file extra esportati.
Devi creare i file del modello utilizzando una versione supportata di XGBoost. |
Deployment locale
Esporta formato modello | Deployment |
---|---|
SavedModel TensorFlow (modelli non AutoML) |
SavedModel è un formato standard e puoi eseguirne il deployment nel container Docker di TensorFlow Serving. Puoi anche sfruttare l'esecuzione locale della previsione online di Vertex AI. |
SavedModel di TensorFlow (modelli AutoML) | Esegui il containerizzazione ed esegui il modello. |
XGBoost Booster |
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 dell'output di previsione dei modelli esportati per ciascun tipo di modello. Tutti i modelli esportati supportano le previsioni batch; possono gestire più righe di input alla volta. Ad esempio, in ciascuno dei seguenti esempi di formato di output sono presenti due righe di input.
AUTOENCODER
Formato di output della previsione | Esempio di output |
---|---|
+------------------------+------------------------+------------------------+ | LATENT_COL_1 | LATENT_COL_2 | ... | +------------------------+------------------------+------------------------+ | [FLOAT] | [FLOAT] | ... | +------------------------+------------------------+------------------------+ |
+------------------+------------------+------------------+------------------+ | LATENT_COL_1 | LATENT_COL_2 | LATENT_COL_3 | LATENT_COL_4 | +------------------------+------------+------------------+------------------+ | 0.21384512 | 0.93457112 | 0.64978097 | 0.00480489 | +------------------+------------------+------------------+------------------+ |
AUTOML_CLASSIFIER
Formato di output della previsione | Esempio di output |
---|---|
+------------------------------------------+ | predictions | +------------------------------------------+ | [{"scores":[FLOAT], "classes":[STRING]}] | +------------------------------------------+ |
+---------------------------------------------+ | predictions | +---------------------------------------------+ | [{"scores":[1, 2], "classes":['a', 'b']}, | | {"scores":[3, 0.2], "classes":['a', 'b']}] | +---------------------------------------------+ |
AUTOML_REGRESSOR
Formato di output della previsione | Esempio di output |
---|---|
+-----------------+ | predictions | +-----------------+ | [FLOAT] | +-----------------+ |
+-----------------+ | predictions | +-----------------+ | [1.8, 2.46] | +-----------------+ |
BOOSTED_TREE_CLASSIFIER e RANDOM_FOREST_CLASSIFIER
Formato di output della previsione | Esempio di output |
---|---|
+-------------+--------------+-----------------+ | LABEL_PROBS | LABEL_VALUES | PREDICTED_LABEL | +-------------+--------------+-----------------+ | [FLOAT] | [STRING] | STRING | +-------------+--------------+-----------------+ |
+-------------+--------------+-----------------+ | LABEL_PROBS | LABEL_VALUES | PREDICTED_LABEL | +-------------+--------------+-----------------+ | [0.1, 0.9] | ['a', 'b'] | ['b'] | +-------------+--------------+-----------------+ | [0.8, 0.2] | ['a', 'b'] | ['a'] | +-------------+--------------+-----------------+ |
BOOSTED_TREE_REGRESSOR E RANDOM_FOREST_REGRESSOR
Formato di output della previsione | Esempio di output |
---|---|
+-----------------+ | predicted_label | +-----------------+ | FLOAT | +-----------------+ |
+-----------------+ | predicted_label | +-----------------+ | [1.8] | +-----------------+ | [2.46] | +-----------------+ |
DNN_CLASSIFIER
Formato di output della previsione | Esempio di output |
---|---|
+---------------+-------------+-----------+---------+------------------------+--------+---------------+ | ALL_CLASS_IDS | ALL_CLASSES | CLASS_IDS | CLASSES | LOGISTIC (binary only) | LOGITS | PROBABILITIES | +---------------+-------------+-----------+---------+------------------------+--------+---------------+ | [INT64] | [STRING] | INT64 | STRING | FLOAT | [FLOAT]| [FLOAT] | +---------------+-------------+-----------+---------+------------------------+--------+---------------+ |
+---------------+-------------+-----------+---------+------------------------+--------+---------------+ | ALL_CLASS_IDS | ALL_CLASSES | CLASS_IDS | CLASSES | LOGISTIC (binary only) | LOGITS | PROBABILITIES | +---------------+-------------+-----------+---------+------------------------+--------+---------------+ | [0, 1] | ['a', 'b'] | [0] | ['a'] | [0.36] | [-0.53]| [0.64, 0.36] | +---------------+-------------+-----------+---------+------------------------+--------+---------------+ | [0, 1] | ['a', 'b'] | [0] | ['a'] | [0.2] | [-1.38]| [0.8, 0.2] | +---------------+-------------+-----------+---------+------------------------+--------+---------------+ |
DNN_REGRESSOR
Formato di output della previsione | Esempio di output |
---|---|
+-----------------+ | PREDICTED_LABEL | +-----------------+ | FLOAT | +-----------------+ |
+-----------------+ | PREDICTED_LABEL | +-----------------+ | [1.8] | +-----------------+ | [2.46] | +-----------------+ |
DNN_LINEAR_COMBINED_CLASSIFIER
Formato di output della previsione | Esempio di output |
---|---|
+---------------+-------------+-----------+---------+------------------------+--------+---------------+ | ALL_CLASS_IDS | ALL_CLASSES | CLASS_IDS | CLASSES | LOGISTIC (binary only) | LOGITS | PROBABILITIES | +---------------+-------------+-----------+---------+------------------------+--------+---------------+ | [INT64] | [STRING] | INT64 | STRING | FLOAT | [FLOAT]| [FLOAT] | +---------------+-------------+-----------+---------+------------------------+--------+---------------+ |
+---------------+-------------+-----------+---------+------------------------+--------+---------------+ | ALL_CLASS_IDS | ALL_CLASSES | CLASS_IDS | CLASSES | LOGISTIC (binary only) | LOGITS | PROBABILITIES | +---------------+-------------+-----------+---------+------------------------+--------+---------------+ | [0, 1] | ['a', 'b'] | [0] | ['a'] | [0.36] | [-0.53]| [0.64, 0.36] | +---------------+-------------+-----------+---------+------------------------+--------+---------------+ | [0, 1] | ['a', 'b'] | [0] | ['a'] | [0.2] | [-1.38]| [0.8, 0.2] | +---------------+-------------+-----------+---------+------------------------+--------+---------------+ |
DNN_LINEAR_COMBINED_REGRESSOR
Formato di output della previsione | Esempio di output |
---|---|
+-----------------+ | PREDICTED_LABEL | +-----------------+ | FLOAT | +-----------------+ |
+-----------------+ | PREDICTED_LABEL | +-----------------+ | [1.8] | +-----------------+ | [2.46] | +-----------------+ |
KMEANS
Formato di output della previsione | Esempio di output |
---|---|
+--------------------+--------------+---------------------+ | CENTROID_DISTANCES | CENTROID_IDS | NEAREST_CENTROID_ID | +--------------------+--------------+---------------------+ | [FLOAT] | [INT64] | INT64 | +--------------------+--------------+---------------------+ |
+--------------------+--------------+---------------------+ | CENTROID_DISTANCES | CENTROID_IDS | NEAREST_CENTROID_ID | +--------------------+--------------+---------------------+ | [1.2, 1.3] | [1, 2] | [1] | +--------------------+--------------+---------------------+ | [0.4, 0.1] | [1, 2] | [2] | +--------------------+--------------+---------------------+ |
LINEAR_REG
Formato di output della previsione | Esempio di output |
---|---|
+-----------------+ | PREDICTED_LABEL | +-----------------+ | FLOAT | +-----------------+ |
+-----------------+ | PREDICTED_LABEL | +-----------------+ | [1.8] | +-----------------+ | [2.46] | +-----------------+ |
LOGISTIC_REG
Formato di output della previsione | Esempio di output |
---|---|
+-------------+--------------+-----------------+ | LABEL_PROBS | LABEL_VALUES | PREDICTED_LABEL | +-------------+--------------+-----------------+ | [FLOAT] | [STRING] | STRING | +-------------+--------------+-----------------+ |
+-------------+--------------+-----------------+ | LABEL_PROBS | LABEL_VALUES | PREDICTED_LABEL | +-------------+--------------+-----------------+ | [0.1, 0.9] | ['a', 'b'] | ['b'] | +-------------+--------------+-----------------+ | [0.8, 0.2] | ['a', 'b'] | ['a'] | +-------------+--------------+-----------------+ |
MATRIX_FACTORIZATION
Nota: al momento supportiamo solo l'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 potenziati utilizzando lo plot_tree l'API Python 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 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 ogni 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 funzionalità corrispondenti nel
assets/model_metadata.json
file esportato utilizzando questi nomi (ad esempio "f0")
come indici.
Autorizzazioni obbligatorie
Per esportare un modello BigQuery ML in Cloud Storage, devi disporre delle autorizzazioni per accedere al modello BigQuery ML, per eseguire un job di esportazione e per scrivere i dati nel bucket Cloud Storage.
Autorizzazioni BigQuery
Come minimo, per esportare il modello devi disporre di
bigquery.models.export
autorizzazioni aggiuntive. I seguenti ruoli IAM (Identity and Access Management) predefiniti vengono concessi le autorizzazionibigquery.models.export
:bigquery.dataViewer
bigquery.dataOwner
bigquery.dataEditor
bigquery.admin
Come minimo, per eseguire un job di esportazione, devi ricevere le autorizzazioni
bigquery.jobs.create
. Ai seguenti ruoli IAM predefiniti vengono 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 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, tieni presente 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 nell'area geografica multipla
US
, puoi esportare i dati in un bucket Cloud Storage in qualsiasi posizione. - Se il set di dati si trova in una regione, il bucket Cloud Storage deve trovarsi nella stessa regione. Ad esempio, se il set di dati si trova nella regione
asia-northeast1
di Tokyo, il bucket Cloud Storage non può trovarsi nella regione 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, 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 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 sui prezzi di 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 la pagina Prezzi di Cloud Storage.
Passaggi successivi
- Segui il tutorial Esporta un modello BigQuery ML per la previsione online.