Fare previsioni con i modelli PyTorch in formato ONNX

Panoramica

Open Neural Network Exchange (ONNX) offre un'architettura 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 del modello ONNX. Per ulteriori informazioni, vedi Conversione in formato ONNX.
  • Importa il modello ONNX in BigQuery ed effettua previsioni utilizzando in BigQuery ML.

Questo tutorial mostra come importare modelli ONNX addestrati con PyTorch. in un set di dati BigQuery e utilizzarle per fare previsioni query SQL. Puoi importare modelli ONNX utilizzando queste interfacce:

Per saperne di più sull'importazione dei modelli ONNX in BigQuery, inclusi i requisiti di formato e di archiviazione, vedi 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 effettua previsioni.

Creare un modello di visione artificiale PyTorch per la classificazione delle immagini

Importare un resnet18 preaddestrato PyTorch che accetta dati di immagini decodificati restituiti da BigQuery ML ML.DECODE_IMAGE e le funzioni di 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

Usa 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 in cui archiviare il file del modello ONNX, quindi carica il file del modello ONNX salvato nel 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 in Cloud Storage di sincronizzare la directory di una VM con un bucket. Un modello di esempio viene archiviato gs://cloud-samples-data/bigquery/ml/onnx/resnet18.onnx.

Console

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

    Vai alla pagina di BigQuery

  2. Nell'editor query, inserisci 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 nella gs://cloud-samples-data/bigquery/ml/onnx/resnet18.onnx come Modello BigQuery denominato imported_onnx_model.

  3. A questo punto, il nuovo modello dovrebbe apparire nel riquadro Risorse. Man mano che espandere ciascun set di dati in un progetto, i modelli sono elencati con le altre risorse BigQuery nei set di dati. I modelli sono indicato dall'icona del modello: icona modello .

  4. Se selezioni il nuovo modello nel riquadro Risorse, vengono visualizzate le informazioni sul modello viene visualizzata sotto Editor di query.

    informazioni sul modello onnx

bq

Per importare un modello ONNX da Cloud Storage, esegui un inserendo un comando simile al 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')"

Una volta importato, il modello dovrebbe apparire nell'output di bq ls [dataset_name]:

$ bq ls example_dataset

       tableId          Type    Labels   Time Partitioning
 --------------------- ------- -------- -------------------
  imported_onnx_model   MODEL

API

Inserire un nuovo job e completa la 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 dell'immagine

Per accedere ai dati non strutturati in BigQuery, devi creare una tabella degli oggetti. Consulta Crea tabelle di oggetti per istruzioni dettagliate.

Crea una tabella di oggetto denominata goldfish_image_table su un'immagine di un pesce rosso archiviato alle ore 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');

Effettuare previsioni con il modello ONNX importato

Console

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

    Vai alla pagina di BigQuery

  2. Nell'editor query, inserisci una query utilizzando ML.PREDICT. come mostrato 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 dati example_dataset del progetto attuale per previsioni dai dati di immagine nella tabella dell'oggetto di input goldfish_image_table. ML.DECODE_IMAGE per decodificare i dati immagine in modo che possano essere interpretati da ML.PREDICT. Inoltre, viene chiamata la funzione ML.RESIZE_IMAGE per ridimensionare l'immagine in modo che si adatti alle dimensioni dell'input del modello (224 x 224). Per maggiori informazioni sull'esecuzione dell'inferenza nelle tabelle di oggetti immagine, consulta Esegui l'inferenza sulle tabelle di oggetti immagine.

    Questa query restituisce l'etichetta di classe prevista dell'immagine di input in base a le etichette ImageNet dizionario.

    Risultati delle query

bq

Per eseguire previsioni in base ai dati di input nella tabella input_data, inserisci un 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

Inserire un nuovo job e completa la 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