Fare previsioni con i modelli PyTorch in formato ONNX
Panoramica
Open Neural Network Exchange (ONNX) fornisce un formato uniforme progettato per rappresentare qualsiasi framework di machine learning. Il supporto di BigQuery ML per ONNX ti consente di:
- Addestra un modello utilizzando il tuo framework preferito.
- Converti il modello nel formato ONNX. Per ulteriori informazioni, consulta la pagina relativa alla conversione in formato ONNX.
- Importa il modello ONNX in BigQuery ed esegui previsioni utilizzando BigQuery ML.
Questo tutorial mostra come importare i modelli ONNX addestrati con PyTorch in un set di dati BigQuery e utilizzarli per effettuare previsioni da una query SQL. Puoi importare i modelli ONNX utilizzando queste interfacce:
- Nella console Google Cloud
- Il comando
bq query
nello strumento a riga di comando bq - L'API BigQuery
Per ulteriori informazioni sull'importazione dei modelli ONNX in BigQuery, inclusi i requisiti di formato e archiviazione, consulta l'istruzione CREATE
MODEL
per l'importazione dei modelli ONNX.
Obiettivi
In questo tutorial, imparerai a:
- Creare e addestrare modelli con PyTorch.
- Converti i modelli in formato ONNX utilizzando torch.onnx.
- Importa i modelli ONNX in BigQuery ed esegui previsioni.
Creare un modello di visione artificiale PyTorch per la classificazione delle immagini
Importa un file resnet18 preaddestrato PyTorch che accetti i dati delle immagini decodificati restituiti dalle funzioni BigQuery ML ML.DECODE_IMAGE
e ML.RESIZE_IMAGE
.
import torch
import torch.nn as nn
# Define model input format to match the output format of
# ML.DECODE_IMAGE function: [height, width, channels]
dummy_input = torch.randn(1, 224, 224, 3, device="cpu")
# Load a pretrained pytorch model for image classification
model = torch.hub.load('pytorch/vision:v0.10.0', 'resnet18', pretrained=True)
# Reshape input format from [batch_size, height, width, channels]
# to [batch_size, channels, height, width]
class ReshapeLayer(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
x = x.permute(0, 3, 1, 2) # reorder dimensions
return x
class ArgMaxLayer(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
return torch.argmax(x, dim=1)
final_model = nn.Sequential(
ReshapeLayer(),
model,
nn.Softmax(),
ArgMaxLayer()
)
Converti il modello in formato ONNX e salva
Utilizza torch.onnx
per esportare il modello di visione di PyTorch in un file ONNX denominato resnet18.onnx
.
torch.onnx.export(final_model, # model being run
dummy_input, # model input
"resnet18.onnx", # where to save the model
opset_version=10, # the ONNX version to export the model to
input_names = ['input'], # the model's input names
output_names = ['class_label']) # the model's output names
Carica il modello ONNX su Cloud Storage
Crea un bucket Cloud Storage per archiviare il file del modello ONNX, quindi carica il file del modello ONNX salvato nel tuo bucket Cloud Storage. Per ulteriori informazioni, vedi Caricare oggetti da un file system.
Importa il modello ONNX in BigQuery
Questo passaggio presuppone che tu abbia caricato il modello ONNX nel tuo bucket Cloud Storage. Un modello di esempio è archiviato in gs://cloud-samples-data/bigquery/ml/onnx/resnet18.onnx
.
Console
Nella console Google Cloud, vai alla pagina BigQuery.
Nell'editor query, inserisci un'istruzione
CREATE MODEL
come la seguente.CREATE OR REPLACE MODEL `mydataset.mymodel` OPTIONS (MODEL_TYPE='ONNX', MODEL_PATH='gs://bucket/path/to/onnx_model/*')
Ad esempio:
CREATE OR REPLACE MODEL `example_dataset.imported_onnx_model` OPTIONS (MODEL_TYPE='ONNX', MODEL_PATH='gs://cloud-samples-data/bigquery/ml/onnx/resnet18.onnx')
La query precedente importa il modello ONNX che si trova in
gs://cloud-samples-data/bigquery/ml/onnx/resnet18.onnx
come modello BigQuery denominatoimported_onnx_model
.Il nuovo modello dovrebbe apparire nel riquadro Risorse. Man mano che espandi ciascuno dei set di dati in un progetto, i modelli vengono elencati insieme alle altre risorse BigQuery nei set di dati. I modelli sono indicati dall'icona del modello: .
Se selezioni il nuovo modello nel riquadro Risorse, le informazioni sul modello vengono visualizzate sotto l'Editor query.
bq
Per importare un modello ONNX da Cloud Storage, esegui una query batch inserendo un comando come questo:
bq query \
--use_legacy_sql=false \
"CREATE MODEL
`mydataset.mymodel`
OPTIONS
(MODEL_TYPE='ONNX',
MODEL_PATH='gs://bucket/path/to/onnx_model/*')"
Ad esempio:
bq query --use_legacy_sql=false \
"CREATE OR REPLACE MODEL
`example_dataset.imported_onnx_model`
OPTIONS
(MODEL_TYPE='ONNX',
MODEL_PATH='gs://cloud-samples-data/bigquery/ml/onnx/resnet18.onnx')"
Dopo aver importato il modello, questo dovrebbe apparire nell'output di bq ls [dataset_name]
:
$ bq ls example_dataset
tableId Type Labels Time Partitioning
--------------------- ------- -------- -------------------
imported_onnx_model MODEL
API
Inserisci un nuovo job e compila la proprietà jobs#configuration.query come nel seguente corpo della richiesta:
{
"query": "CREATE MODEL `project_id:mydataset.mymodel` OPTIONS(MODEL_TYPE='ONNX' MODEL_PATH='gs://bucket/path/to/onnx_model/*')"
}
Crea una tabella degli oggetti in BigQuery per accedere ai dati immagine
Per accedere ai dati non strutturati in BigQuery, devi creare una tabella degli oggetti. Per istruzioni dettagliate, consulta Creare tabelle degli oggetti.
Crea una tabella di oggetti denominata goldfish_image_table
su un'immagine di pesce rosso archiviata in gs://mybucket/goldfish.jpg
.
CREATE EXTERNAL TABLE `example_dataset.goldfish_image_table`
WITH CONNECTION `us.my-connection`
OPTIONS(
object_metadata = 'SIMPLE',
uris = ['gs://mybucket/goldfish.jpg'],
max_staleness = INTERVAL 1 DAY,
metadata_cache_mode = 'AUTOMATIC');
Eseguire previsioni con il modello ONNX importato
Console
Nella console Google Cloud, vai alla pagina BigQuery.
Nell'Editor query, inserisci una query utilizzando
ML.PREDICT
come indicato di seguito.SELECT class_label FROM ML.PREDICT(MODEL
example_dataset.imported_onnx_model
, ( SELECT ML.RESIZE_IMAGE(ML.DECODE_IMAGE(DATA), 224, 224, FALSE) AS input FROM example_dataset.goldfish_image_table) )La query precedente utilizza il modello denominato
imported_onnx_model
nel set di datiexample_dataset
del progetto attuale per fare previsioni dai dati di immagine nella tabella dell'oggetto di inputgoldfish_image_table
. La funzioneML.DECODE_IMAGE
è necessaria per decodificare i dati immagine in modo che possano essere interpretati daML.PREDICT
. Inoltre, la funzioneML.RESIZE_IMAGE
viene chiamata per ridimensionare l'immagine in base alle dimensioni dell'input del modello (224 x 224). Per ulteriori informazioni sull'esecuzione dell'inferenza sulle tabelle degli oggetti immagine, consulta Eseguire l'inferenza sulle tabelle degli oggetti immagine.Questa query restituisce l'etichetta della classe prevista dell'immagine di input in base al dizionario delle etichette ImageNet.
bq
Per eseguire previsioni dai dati di input nella tabella input_data
, inserisci un comando come il seguente, utilizzando il modello ONNX importato my_model
:
bq query \
--use_legacy_sql=false \
'SELECT *
FROM ML.PREDICT(
MODEL `my_project.my_dataset.my_model`,
(SELECT * FROM input_data))'
API
Inserisci un nuovo job e compila la proprietà jobs#configuration.query come nel seguente corpo della richiesta:
{
"query": "SELECT * FROM ML.PREDICT(MODEL `my_project.my_dataset.my_model`, (SELECT * FROM input_data))"
}
Passaggi successivi
- Per saperne di più sull'importazione dei modelli ONNX, consulta l'istruzione
CREATE MODEL
per i modelli ONNX. - Per ulteriori informazioni sui convertitori e sui tutorial ONNX disponibili, consulta la sezione Conversione al formato ONNX.
- Per una panoramica di BigQuery ML, consulta Introduzione a BigQuery ML.
- Per iniziare a utilizzare BigQuery ML, consulta Creare modelli di machine learning in BigQuery ML.
- Per saperne di più sull'utilizzo dei modelli, consulta queste risorse: