Generare embedding con modelli Transformer in formato ONNX

Questo tutorial mostra come esportare un modello Transformer nel formato Open Neural Network Exchange (ONNX), importare il modello ONNX in un set di dati BigQuery e quindi utilizzarlo per generare incorporamenti da una query SQL.

Questo tutorial utilizza il modello sentence-transformers/all-MiniLM-L6-v2. Questo modello di trasformazione delle frasi è noto per le sue prestazioni rapide ed efficaci nella generazione di incorporamenti di frasi. L'incorporamento di frasi consente attività come la ricerca semantica, il clustering e la somiglianza di frasi acquisendo il significato sottostante del testo.

ONNX fornisce un formato uniforme progettato per rappresentare qualsiasi framework di machine learning (ML). Il supporto di BigQuery ML per ONNX ti consente di:

  • Addestra un modello utilizzando il tuo framework preferito.
  • Converti il modello nel formato ONNX.
  • Importa il modello ONNX in BigQuery ed esegui previsioni utilizzando BigQuery ML.

Converti i file del modello Transformer in ONNX

Se vuoi, puoi seguire i passaggi descritti in questa sezione per convertire manualmente il modello sentence-transformers/all-MiniLM-L6-v2 e il tokenizer in ONNX. In alternativa, puoi utilizzare i file di esempio del bucket Cloud Storage pubblico gs://cloud-samples-data che sono già stati convertiti.

Se scegli di convertire manualmente i file, devi disporre di un ambiente a riga di comando locale con Python installato. Per saperne di più sull'installazione di Python, consulta la pagina Download di Python.

Esporta il modello Transformer in ONNX

Utilizza l'interfaccia a riga di comando Hugging Face Optimum per esportare il modello sentence-transformers/all-MiniLM-L6-v2 in ONNX. Per saperne di più sull'esportazione di modelli con la CLI Optimum, consulta Esportare un modello in ONNX con optimum.exporters.onnx.

Per esportare il modello, apri un ambiente a riga di comando e segui questi passaggi:

  1. Installa l'interfaccia a riga di comando Optimum:

    pip install optimum[onnx]

  2. Esporta il modello. L'argomento --model specifica l'ID modello Hugging Face. L'argomento --opset specifica la versione della libreria ONNXRuntime ed è impostato su 17 per mantenere la compatibilità con la libreria ONNXRuntime supportata da BigQuery.

    optimum-cli export onnx \
  --model sentence-transformers/all-MiniLM-L6-v2 \
  --task sentence-similarity \
  --opset 17 all-MiniLM-L6-v2/

Il file del modello viene esportato nella directory all-MiniLM-L6-v2 come model.onnx.

Applica la quantizzazione al modello Transformer

Utilizza Optimum CLI per applicare la quantizzazione al modello transformer esportato per ridurre le dimensioni del modello e velocizzare l'inferenza. Per ulteriori informazioni, vedi Quantizzazione.

Per applicare la quantizzazione al modello, esegui questo comando nella riga di comando:

optimum-cli onnxruntime quantize \
  --onnx_model all-MiniLM-L6-v2/ \
  --avx512_vnni -o all-MiniLM-L6-v2_quantized

Il file del modello quantizzato viene esportato nella directory all-MiniLM-L6-v2_quantized come model_quantized.onnx.

Converti il tokenizer in ONNX

Per generare incorporamenti utilizzando un modello Transformer in formato ONNX, in genere utilizzi un tokenizer per produrre due input per il modello, input_ids e attention_mask.

Per produrre questi input, converti il tokenizer per il modello sentence-transformers/all-MiniLM-L6-v2 in formato ONNX utilizzando la libreria onnxruntime-extensions. Dopo aver convertito il tokenizer, puoi eseguire la tokenizzazione direttamente sugli input di testo non elaborato per generare previsioni ONNX.

Per convertire il tokenizer, segui questi passaggi dalla riga di comando:

  1. Installa l'interfaccia a riga di comando Optimum:

    pip install optimum[onnx]

  2. Utilizzando l'editor di testo che preferisci, crea un file denominato convert-tokenizer.py. L'esempio seguente utilizza l'editor di testo nano:

    nano convert-tokenizer.py

  3. Copia e incolla il seguente script Python nel file convert-tokenizer.py:

    from onnxruntime_extensions import gen_processing_models

# Load the Huggingface tokenizer
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")

# Export the tokenizer to ONNX using gen_processing_models
onnx_tokenizer_path = "tokenizer.onnx"

# Generate the tokenizer ONNX model, and set the maximum token length.
# Ensure 'max_length' is set to a value less than the model's maximum sequence length, failing to do so will result in error during inference.
tokenizer_onnx_model = gen_processing_models(tokenizer, pre_kwargs={'max_length': 256})[0]

# Modify the tokenizer ONNX model signature.
# This is because certain tokenizers don't support batch inference.
tokenizer_onnx_model.graph.input[0].type.tensor_type.shape.dim[0].dim_value = 1

# Save the tokenizer ONNX model
with open(onnx_tokenizer_path, "wb") as f:
  f.write(tokenizer_onnx_model.SerializeToString())

  4. Salva il file convert-tokenizer.py.

  5. Esegui lo script Python per convertire il tokenizer:

    python convert-tokenizer.py

Il tokenizer convertito viene esportato nella directory all-MiniLM-L6-v2_quantized come tokenizer.onnx.

Carica i file del modello convertito su Cloud Storage

Dopo aver convertito il modello Transformer e il tokenizer, procedi nel seguente modo:

Crea un set di dati

Crea un set di dati BigQuery per archiviare il tuo modello ML.

Console

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

    Vai alla pagina BigQuery

  2. Nel riquadro Explorer, fai clic sul nome del progetto.

  3. Fai clic su Visualizza azioni > Crea set di dati.

  4. Nella pagina Crea set di dati:

    • In ID set di dati, inserisci bqml_tutorial.

    • Per Tipo di località, seleziona Multi-regione e poi Stati Uniti (più regioni negli Stati Uniti).

    • Lascia invariate le restanti impostazioni predefinite e fai clic su Crea set di dati.

bq

Per creare un nuovo set di dati, utilizza il comando bq mk con il flag --location. Per un elenco completo dei possibili parametri, consulta la documentazione di riferimento del comando bq mk --dataset.

  1. Crea un set di dati denominato bqml_tutorial con la località dei dati impostata su US e una descrizione di BigQuery ML tutorial dataset:

    bq --location=US mk -d \
 --description "BigQuery ML tutorial dataset." \
 bqml_tutorial

    Anziché utilizzare il flag --dataset, il comando utilizza la scorciatoia -d. Se ometti -d e --dataset, il comando crea per impostazione predefinita un dataset.

  2. Verifica che il set di dati sia stato creato:

    bq ls

API

Chiama il metodo datasets.insert con una risorsa dataset definita.

{
  "datasetReference": {
     "datasetId": "bqml_tutorial"
  }
}

BigQuery DataFrames

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

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

import google.cloud.bigquery

bqclient = google.cloud.bigquery.Client()
bqclient.create_dataset("bqml_tutorial", exists_ok=True)

Importa i modelli ONNX in BigQuery

Importa i modelli di tokenizer e sentence transformer convertiti come modelli BigQuery ML.

Seleziona una delle seguenti opzioni:

Console

  1. Nella console Google Cloud , apri BigQuery Studio.

    Vai a BigQuery Studio

  2. Nell'editor di query, esegui la seguente istruzione CREATE MODEL per creare il modello tokenizer.

     CREATE OR REPLACE MODEL `bqml_tutorial.tokenizer`
  OPTIONS (MODEL_TYPE='ONNX',
   MODEL_PATH='TOKENIZER_BUCKET_PATH')

    Sostituisci TOKENIZER_BUCKET_PATH con il percorso del modello che hai caricato su Cloud Storage. Se utilizzi il modello di esempio, sostituisci TOKENIZER_BUCKET_PATH con il seguente valore: gs://cloud-samples-data/bigquery/ml/onnx/all-MiniLM-L6-v2/tokenizer.onnx.

    Al termine dell'operazione, viene visualizzato un messaggio simile al seguente: Successfully created model named tokenizer nel riquadro Risultati query.

  3. Fai clic su Vai al modello per aprire il riquadro Dettagli.

  4. Esamina la sezione Colonne di caratteristiche per visualizzare gli input del modello e la Colonna etichetta per visualizzare gli output del modello.

    Il riquadro **Dettagli** per il modello `tokenizer

  5. Nell'editor di query, esegui la seguente istruzione CREATE MODEL per creare il modello all-MiniLM-L6-v2.

     CREATE OR REPLACE MODEL `bqml_tutorial.all-MiniLM-L6-v2`
  OPTIONS (MODEL_TYPE='ONNX',
   MODEL_PATH='TRANSFORMER_BUCKET_PATH')

    Sostituisci TRANSFORMER_BUCKET_PATH con il percorso del modello che hai caricato su Cloud Storage. Se utilizzi il modello di esempio, sostituisci TRANSFORMER_BUCKET_PATH con il seguente valore: gs://cloud-samples-data/bigquery/ml/onnx/all-MiniLM-L6-v2/model_quantized.onnx.

    Al termine dell'operazione, viene visualizzato un messaggio simile al seguente: Successfully created model named all-MiniLM-L6-v2 nel riquadro Risultati query.

  6. Fai clic su Vai al modello per aprire il riquadro Dettagli.

  7. Esamina la sezione Colonne di caratteristiche per visualizzare gli input del modello e la Colonna etichetta per visualizzare gli output del modello.

    Il riquadro **Dettagli** per il modello `all-MiniLM-L6-v2`

bq

Utilizza lo strumento a riga di comando bq comando query per eseguire l'istruzione CREATE MODEL.

  1. Nella riga di comando, esegui questo comando per creare il modello tokenizer.

    bq query --use_legacy_sql=false \
"CREATE OR REPLACE MODEL
`bqml_tutorial.tokenizer`
OPTIONS
(MODEL_TYPE='ONNX',
MODEL_PATH='TOKENIZER_BUCKET_PATH')"

    Sostituisci TOKENIZER_BUCKET_PATH con il percorso del modello che hai caricato su Cloud Storage. Se utilizzi il modello di esempio, sostituisci TOKENIZER_BUCKET_PATH con il seguente valore: gs://cloud-samples-data/bigquery/ml/onnx/all-MiniLM-L6-v2/tokenizer.onnx.

    Al termine dell'operazione, viene visualizzato un messaggio simile al seguente: Successfully created model named tokenizer.

  2. Nella riga di comando, esegui questo comando per creare il modello all-MiniLM-L6-v2.

    bq query --use_legacy_sql=false \
"CREATE OR REPLACE MODEL
`bqml_tutorial.all-MiniLM-L6-v2`
OPTIONS
(MODEL_TYPE='ONNX',
  MODEL_PATH='TRANSFORMER_BUCKET_PATH')"

    Sostituisci TRANSFORMER_BUCKET_PATH con il percorso del modello che hai caricato su Cloud Storage. Se utilizzi il modello di esempio, sostituisci TRANSFORMER_BUCKET_PATH con il seguente valore: gs://cloud-samples-data/bigquery/ml/onnx/all-MiniLM-L6-v2/model_quantized.onnx.

    Al termine dell'operazione, viene visualizzato un messaggio simile al seguente: Successfully created model named all-MiniLM-L6-v2.

  3. Dopo aver importato i modelli, verifica che vengano visualizzati nel set di dati.

    bq ls -m bqml_tutorial

    L'output è simile al seguente:

    tableId            Type
------------------------
tokenizer          MODEL
all-MiniLM-L6-v2   MODEL

API

Utilizza il metodo jobs.insert per importare i modelli.Compila il parametro query della risorsa QueryRequest nel corpo della richiesta con l'istruzione CREATE MODEL.

  1. Utilizza il seguente valore parametro query per creare il modello tokenizer.

    {
"query": "CREATE MODEL `PROJECT_ID :bqml_tutorial.tokenizer` OPTIONS(MODEL_TYPE='ONNX' MODEL_PATH='TOKENIZER_BUCKET_PATH')"
}

    Sostituisci quanto segue:

    • PROJECT_ID con l'ID progetto.
    • TOKENIZER_BUCKET_PATH con il percorso del modello che hai caricato su Cloud Storage. Se utilizzi il modello di esempio, sostituisci TOKENIZER_BUCKET_PATH con il seguente valore: gs://cloud-samples-data/bigquery/ml/onnx/all-MiniLM-L6-v2/tokenizer.onnx.

  2. Utilizza il seguente valore parametro query per creare il modello all-MiniLM-L6-v2.

    {
"query": "CREATE MODEL `PROJECT_ID :bqml_tutorial.all-MiniLM-L6-v2` OPTIONS(MODEL_TYPE='ONNX' MODEL_PATH='TRANSFORMER_BUCKET_PATH')"
}

    Sostituisci quanto segue:

    • PROJECT_ID con l'ID progetto.
    • TRANSFORMER_BUCKET_PATH con il percorso del modello che hai caricato su Cloud Storage. Se utilizzi il modello di esempio, sostituisci TRANSFORMER_BUCKET_PATH con il seguente valore: gs://cloud-samples-data/bigquery/ml/onnx/all-MiniLM-L6-v2/model_quantized.onnx.

BigQuery DataFrames

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

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

Importa i modelli di tokenizer e sentence transformer utilizzando l'oggetto ONNXModel.

import bigframes
from bigframes.ml.imported import ONNXModel

bigframes.options.bigquery.project = PROJECT_ID

bigframes.options.bigquery.location = "US"

tokenizer = ONNXModel(
  model_path= "TOKENIZER_BUCKET_PATH"
)
imported_onnx_model = ONNXModel(
  model_path="TRANSFORMER_BUCKET_PATH"
)

Sostituisci quanto segue:

  • PROJECT_ID con l'ID progetto.
  • TOKENIZER_BUCKET_PATH con il percorso del modello che hai caricato su Cloud Storage. Se utilizzi il modello di esempio, sostituisci TOKENIZER_BUCKET_PATH con il seguente valore: gs://cloud-samples-data/bigquery/ml/onnx/all-MiniLM-L6-v2/tokenizer.onnx.
  • TRANSFORMER_BUCKET_PATH con il percorso del modello che hai caricato su Cloud Storage. Se utilizzi il modello di esempio, sostituisci TRANSFORMER_BUCKET_PATH con il seguente valore: gs://cloud-samples-data/bigquery/ml/onnx/all-MiniLM-L6-v2/model_quantized.onnx.

Generare embedding con i modelli ONNX importati

Utilizza i modelli di tokenizer e sentence transformer importati per generare incorporamenti basati sui dati del set di dati pubblico bigquery-public-data.imdb.reviews.

Seleziona una delle seguenti opzioni:

Console

Utilizza la funzione ML.PREDICT per generare embedding con i modelli.

La query utilizza una chiamata ML.PREDICT nidificata per elaborare il testo non elaborato direttamente tramite il tokenizer e il modello di embedding, come segue:

  • Tokenizzazione (query interna): la chiamata ML.PREDICT interna utilizza il modello bqml_tutorial.tokenizer. Prende la colonna title dal set di dati pubblico bigquery-public-data.imdb.reviews come input text. Il modello tokenizer converte le stringhe di testo non elaborate negli input di token numerici richiesti dal modello principale, inclusi gli input input_ids e attention_mask.
  • Generazione di incorporamenti (query esterna): la chiamata ML.PREDICT esterna utilizza il modello bqml_tutorial.all-MiniLM-L6-v2. La query prende le colonne input_ids e attention_mask dall'output della query interna come input.

L'istruzione SELECT recupera la colonna sentence_embedding, che è un array di valori FLOAT che rappresentano l'incorporamento semantico del testo.

  1. Nella console Google Cloud , apri BigQuery Studio.

    Vai a BigQuery Studio

  2. Nell'editor di query, esegui la query seguente.

    SELECT
sentence_embedding
FROM
ML.PREDICT (MODEL `bqml_tutorial.all-MiniLM-L6-v2`,
  (
  SELECT
    input_ids, attention_mask
  FROM
    ML.PREDICT(MODEL `bqml_tutorial.tokenizer`,
      (
      SELECT
        title AS text
      FROM
        `bigquery-public-data.imdb.reviews` limit 10))))

    Il risultato è simile al seguente:

    +-----------------------+
| sentence_embedding    |
+-----------------------+
| -0.02361682802438736  |
| 0.02025664784014225   |
| 0.005168713629245758  |
| -0.026361213997006416 |
| 0.0655381828546524    |
| ...                   |
+-----------------------+

bq

Utilizza lo strumento a riga di comando bq comando query per eseguire una query. La query utilizza la funzione ML.PREDICT per generare embedding con i modelli.

La query utilizza una chiamata ML.PREDICT nidificata per elaborare il testo non elaborato direttamente tramite il tokenizer e il modello di embedding, come segue:

  • Tokenizzazione (query interna): la chiamata ML.PREDICT interna utilizza il modello bqml_tutorial.tokenizer. Prende la colonna title dal set di dati pubblico bigquery-public-data.imdb.reviews come input text. Il modello tokenizer converte le stringhe di testo non elaborate negli input di token numerici richiesti dal modello principale, inclusi gli input input_ids e attention_mask.
  • Generazione di incorporamenti (query esterna): la chiamata ML.PREDICT esterna utilizza il modello bqml_tutorial.all-MiniLM-L6-v2. La query prende le colonne input_ids e attention_mask dall'output della query interna come input.

L'istruzione SELECT recupera la colonna sentence_embedding, che è un array di valori FLOAT che rappresentano l'incorporamento semantico del testo.

Nella riga di comando, esegui questo comando per eseguire la query.

bq query --use_legacy_sql=false \
'SELECT
sentence_embedding
FROM
ML.PREDICT (MODEL `bqml_tutorial.all-MiniLM-L6-v2`,
  (
  SELECT
    input_ids, attention_mask
  FROM
    ML.PREDICT(MODEL `bqml_tutorial.tokenizer`,
      (
      SELECT
        title AS text
      FROM
        `bigquery-public-data.imdb.reviews` limit 10))))'

Il risultato è simile al seguente:

+-----------------------+
| sentence_embedding    |
+-----------------------+
| -0.02361682802438736  |
| 0.02025664784014225   |
| 0.005168713629245758  |
| -0.026361213997006416 |
| 0.0655381828546524    |
| ...                   |
+-----------------------+

BigQuery DataFrames

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

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

Utilizza il metodo predict per generare embedding utilizzando i modelli ONNX.

import bigframes.pandas as bpd

df = bpd.read_gbq("bigquery-public-data.imdb.reviews", max_results=10)
df_pred = df.rename(columns={"title": "text"})
tokens = tokenizer.predict(df_pred)
predictions = imported_onnx_model.predict(tokens)
predictions.peek(5)

L'output è simile al seguente:

Output del modello Transformer.