Effettuare previsioni con modelli PyTorch in formato ONNX

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 in formato ONNX. Per ulteriori informazioni, consulta Conversione in formato ONNX.
  • Importa il modello ONNX in BigQuery ed esegui le previsioni utilizzando BigQuery ML.

Questo tutorial mostra come importare i modelli ONNX addestrati con PyTorch in un set di dati BigQuery e utilizzarli per fare 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:

  • Crea e addestra modelli con PyTorch.
  • Converti i modelli in formato ONNX utilizzando torch.onnx.
  • Importa i modelli ONNX in BigQuery ed esegui le previsioni.

Creare un modello di visione PyTorch per la classificazione delle immagini

Importa un modello resnet18 preaddestrato di PyTorch che accetta i dati delle immagini decodificati restituiti dalle funzioni ML.DECODE_IMAGE e ML.RESIZE_IMAGE di BigQuery ML.

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 salvalo

Utilizza torch.onnx per esportare il modello di visione 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 in Cloud Storage

Crea un bucket Cloud Storage per archiviare il file del modello ONNX, quindi carica il file del modello ONNX salvato nel bucket Cloud Storage. Per ulteriori informazioni, consulta 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

  1. Nella console Google Cloud, vai alla pagina BigQuery.

    Vai alla pagina BigQuery

  2. Nell'editor delle 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 in gs://cloud-samples-data/bigquery/ml/onnx/resnet18.onnx come modello BigQuery denominato imported_onnx_model.

  3. Il nuovo modello dovrebbe ora essere visualizzato nel riquadro Risorse. Man mano che espandi ciascuno dei set di dati di un progetto, i modelli vengono elencati insieme alle altre risorse BigQuery nei set di dati. I modelli sono indicati dall'icona del modello: icona del modello .

  4. Se selezioni il nuovo modello nel riquadro Risorse, le informazioni sul modello vengono visualizzate sotto l'editor di query.

    onnx model info

bq

Per importare un modello ONNX da Cloud Storage, esegui una query batch inserendo un comando come il seguente:

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 essere visualizzato 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 di oggetti in BigQuery per accedere ai dati delle immagini

Per accedere ai dati non strutturati in BigQuery, devi creare una tabella di oggetti. Per istruzioni dettagliate, consulta Creare tabelle di 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');

Fai previsioni con il modello ONNX importato

Console

  1. Nella console Google Cloud, vai alla pagina BigQuery.

    Vai alla pagina BigQuery

  2. Nell'editor delle query, inserisci una query utilizzando ML.PREDICT come segue.

     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 dati example_dataset nel progetto corrente per fare predizioni dai dati immagine nella tabella degli oggetti di input goldfish_image_table. La funzione ML.DECODE_IMAGE è necessaria per decodificare i dati dell'immagine in modo che possano essere interpretati da ML.PREDICT. Inoltre, viene chiamata la funzione ML.RESIZE_IMAGE 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 di classe prevista dell'immagine di input in base al dizionario delle etichette ImageNet.

    Risultati delle query

bq

Per fare 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