Eseguire previsioni con i modelli scikit-learn 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 scikit-learn in un set di dati BigQuery e utilizzarli per fare predizioni 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 di modelli ONNX in BigQuery, inclusi i requisiti di formato e archiviazione, consulta L'istruzione CREATE MODEL per l'importazione di modelli ONNX.

Obiettivi

In questo tutorial, imparerai a:

• Crea e addestra modelli con scikit-learn.
• Converti i modelli in formato ONNX utilizzando sklearn-onnx.
• Importa i modelli ONNX in BigQuery ed esegui le previsioni.

Addestrare un modello di classificazione con scikit-learn

Crea e addestra una pipeline di scikit-learn sul set di dati Iris:

import numpy
from sklearn.datasets import load_iris
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier

data = load_iris()
X = data.data[:, :4]
y = data.target

ind = numpy.arange(X.shape[0])
numpy.random.shuffle(ind)
X = X[ind, :].copy()
y = y[ind].copy()

pipe = Pipeline([('scaler', StandardScaler()),
                ('clr', RandomForestClassifier())])
pipe.fit(X, y)

Nota: la pipeline scikit-learn supporta anche l'inclusione di modelli di altre librerie (LightGBM e XGBoost e così via), che possono essere convertiti in ONNX da sklearn-onnx. Per ulteriori informazioni, consulta Convertire una pipeline e Utilizzare i convertitori di altre librerie.

Converti il modello in formato ONNX e salvalo

Utilizza sklearn-onnx per convertire la pipeline di scikit-learn in un modello ONNX denominato pipeline_rf.onnx:

from skl2onnx import convert_sklearn
from skl2onnx.common.data_types import FloatTensorType

# Disable zipmap as it is not supported in BigQuery ML.
options = {id(pipe): {'zipmap': False}}

# Define input features. scikit-learn does not store information about the
# training dataset. It is not always possible to retrieve the number of features
# or their types. That's why the function needs another argument called initial_types.
initial_types = [
   ('sepal_length', FloatTensorType([None, 1])),
   ('sepal_width', FloatTensorType([None, 1])),
   ('petal_length', FloatTensorType([None, 1])),
   ('petal_width', FloatTensorType([None, 1])),
]

# Convert the model.
model_onnx = convert_sklearn(
   pipe, 'pipeline_rf', initial_types=initial_types, options=options
)

# And save.
with open('pipeline_rf.onnx', 'wb') as f:
 f.write(model_onnx.SerializeToString())

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/pipeline_rf.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/pipeline_rf.onnx')

   La query precedente importa il modello ONNX in gs://cloud-samples-data/bigquery/ml/onnx/pipeline_rf.onnx come modello BigQuery denominato imported_onnx_model.

3. Il nuovo modello dovrebbe ora essere visualizzato nel riquadro Risorse. Man mano che espandi ciascun 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: .

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

   

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/pipeline_rf.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/*')"
}

BigQuery DataFrames

Prima di provare questo esempio, segui le istruzioni di configurazione di BigQuery DataFrames riportate nella guida introduttiva di BigQuery che utilizza BigQuery DataFrames. Per ulteriori informazioni, consulta la documentazione di riferimento di BigQuery DataFrames.

Per autenticarti in BigQuery, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configurare l'autenticazione per un ambiente di sviluppo locale.

Importa il modello utilizzando l'oggetto ONNXModel.

import bigframes
from bigframes.ml.imported import ONNXModel

bigframes.options.bigquery.project = PROJECT_ID
# You can change the location to one of the valid locations: https://cloud.google.com/bigquery/docs/locations#supported_locations
bigframes.options.bigquery.location = "US"

imported_onnx_model = ONNXModel(
    model_path="gs://cloud-samples-data/bigquery/ml/onnx/pipeline_rf.onnx"
)

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 *
      FROM ML.PREDICT(MODEL example_dataset.imported_onnx_model,
        (
         SELECT * FROM bigquery-public-data.ml_datasets.iris
        )
    )
    

   La query precedente utilizza il modello denominato imported_onnx_model nel set di dati example_dataset nel progetto corrente per fare predizioni dai dati di input nella tabella pubblica iris del set di dati ml_datasets nel progetto bigquery-public-data. In questo caso, il modello ONNX si aspetta quattro input di tipo float: sepal_length, sepal_width, petal_length, petal_width che corrispondono a initial_types definito nel passaggio 2 , quindi la sottoquery SELECT l'intera tabella bigquery-public-data che contiene queste 4 colonne di input.

   Il modello genera le colonne label e probabilities, nonché le colonne della tabella di input.

   • label rappresenta l'etichetta della classe prevista.
   • probabilities è un array di probabilità che rappresentano le probabilità per ogni classe.

   Il risultato della query è simile al seguente:

   

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))'

Ad esempio:

bq query \
--use_legacy_sql=false \
'SELECT *
FROM ML.PREDICT(
  MODEL `example_dataset.imported_onnx_model`,
  (SELECT * FROM `bigquery-public-data.ml_datasets.iris`))'

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))"
}

BigQuery DataFrames

Prima di provare questo esempio, segui le istruzioni di configurazione di BigQuery DataFrames riportate nella guida introduttiva di BigQuery che utilizza BigQuery DataFrames. Per ulteriori informazioni, consulta la documentazione di riferimento di BigQuery DataFrames.

Per autenticarti in BigQuery, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configurare l'autenticazione per un ambiente di sviluppo locale.

Utilizza la funzione predict per eseguire il modello remoto:

import bigframes.pandas as bpd

df = bpd.read_gbq("bigquery-public-data.ml_datasets.iris")
predictions = imported_onnx_model.predict(df)
predictions.peek(5)

Il risultato è simile al seguente:

Passaggi successivi

• Per ulteriori informazioni 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 Conversione in 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 ulteriori informazioni sull'utilizzo dei modelli, consulta queste risorse:
  • Ottenere i metadati del modello
  • Aggiornare i metadati del modello
  • Gestire i modelli
  • Eliminare i modelli