Se devi implementare đ¤ modelli Transformers in ambienti di produzione, noi consigliamo di esportarli in un formato serializzato che può essere caricato ed eseguito su runtime e hardware specializzati. In questa guida ti mostreremo come farlo esporta đ¤ Modelli Transformers in due formati ampiamente utilizzati: ONNX e TorchScript.
Una volta esportato, un modello può essere ottimizato per lâinferenza tramite tecniche come la quantizzazione e soppressione. Se sei interessato a ottimizzare i tuoi modelli per lâesecuzione con la massima efficienza, dai unâocchiata a đ¤ Optimum library.
Il progetto ONNX (Open Neural Network eXchange) Il progetto onnx è un open standard che definisce un insieme comune di operatori e un formato di file comune a rappresentano modelli di deep learning in unâampia varietĂ di framework, tra cui PyTorch e TensorFlow. Quando un modello viene esportato nel formato ONNX, questi operatori sono usati per costruire un grafico computazionale (often called an intermediate representation) che rappresenta il flusso di dati attraverso la rete neurale.
Esponendo un grafico con operatori e tipi di dati standardizzati, ONNX rende piĂš facile passare da un framework allâaltro. Ad esempio, un modello allenato in PyTorch può essere esportato in formato ONNX e quindi importato in TensorFlow (e viceversa).
đ¤ Transformers fornisce un pacchetto transformers.onnx
che ti consente di
convertire i checkpoint del modello in un grafico ONNX sfruttando gli oggetti di configurazione.
Questi oggetti di configurazione sono giĂ pronti per una serie di architetture di modelli,
e sono progettati per essere facilmente estensibili ad altre architetture.
Le configurazioni pronte includono le seguenti architetture:
Nelle prossime due sezioni, ti mostreremo come:
transformers.onnx
.Per esportare un modello đ¤ Transformers in ONNX, dovrai prima installarne alcune dipendenze extra:
pip install transformers[onnx]
Il pacchetto transformers.onnx
può essere usato come modulo Python:
python -m transformers.onnx --help
usage: Hugging Face Transformers ONNX exporter [-h] -m MODEL [--feature {causal-lm, ...}] [--opset OPSET] [--atol ATOL] output
positional arguments:
output Path indicating where to store generated ONNX model.
optional arguments:
-h, --help show this help message and exit
-m MODEL, --model MODEL
Model ID on huggingface.co or path on disk to load model from.
--feature {causal-lm, ...}
The type of features to export the model with.
--opset OPSET ONNX opset version to export the model with.
--atol ATOL Absolute difference tolerence when validating the model.
Lâesportazione di un checkpoint utilizzando una configurazione giĂ pronta può essere eseguita come segue:
python -m transformers.onnx --model=distilbert-base-uncased onnx/
che dovrebbe mostrare i seguenti log:
Validating ONNX model...
-[â] ONNX model output names match reference model ({'last_hidden_state'})
- Validating ONNX Model output "last_hidden_state":
-[â] (2, 8, 768) matches (2, 8, 768)
-[â] all values close (atol: 1e-05)
All good, model saved at: onnx/model.onnx
Questo esporta un grafico ONNX del checkpoint definito dallâargomento --model
.
In questo esempio è distilbert-base-uncased
, ma può essere qualsiasi checkpoint
Hugging Face Hub o uno memorizzato localmente.
Il file risultante model.onnx
può quindi essere eseguito su uno dei tanti
acceleratori che supportano il
lo standard ONNX. Ad esempio, possiamo caricare ed eseguire il modello con ONNX
Runtime come segue:
>>> from transformers import AutoTokenizer
>>> from onnxruntime import InferenceSession
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")
>>> session = InferenceSession("onnx/model.onnx")
>>> # ONNX Runtime expects NumPy arrays as input
>>> inputs = tokenizer("Using DistilBERT with ONNX Runtime!", return_tensors="np")
>>> outputs = session.run(output_names=["last_hidden_state"], input_feed=dict(inputs))
I nomi di output richiesti (cioè ["last_hidden_state"]
) possono essere ottenuti
dando unâocchiata alla configurazione ONNX di ogni modello. Ad esempio, per
DistilBERT abbiamo:
>>> from transformers.models.distilbert import DistilBertConfig, DistilBertOnnxConfig
>>> config = DistilBertConfig()
>>> onnx_config = DistilBertOnnxConfig(config)
>>> print(list(onnx_config.outputs.keys()))
["last_hidden_state"]
Il processo è identico per i checkpoint TensorFlow sullâhub. Ad esempio, noi possiamo esportare un checkpoint TensorFlow puro da Keras organizzazione come segue:
python -m transformers.onnx --model=keras-io/transformers-qa onnx/
Per esportare un modello memorizzato localmente, devi disporre dei pesi del modello e file tokenizer memorizzati in una directory. Ad esempio, possiamo caricare e salvare un checkpoint come segue:
>>> from transformers import AutoTokenizer, AutoModelForSequenceClassification
>>> # Load tokenizer and PyTorch weights form the Hub
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")
>>> pt_model = AutoModelForSequenceClassification.from_pretrained("distilbert-base-uncased")
>>> # Save to disk
>>> tokenizer.save_pretrained("local-pt-checkpoint")
>>> pt_model.save_pretrained("local-pt-checkpoint")
Una volta salvato il checkpoint, possiamo esportarlo su ONNX puntando lâargomento --model
del pacchetto transformers.onnx
nella directory desiderata:
python -m transformers.onnx --model=local-pt-checkpoint onnx/
>>> from transformers import AutoTokenizer, TFAutoModelForSequenceClassification
>>> # Load tokenizer and TensorFlow weights from the Hub
>>> tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")
>>> tf_model = TFAutoModelForSequenceClassification.from_pretrained("distilbert-base-uncased")
>>> # Save to disk
>>> tokenizer.save_pretrained("local-tf-checkpoint")
>>> tf_model.save_pretrained("local-tf-checkpoint")
Once the checkpoint is saved, we can export it to ONNX by pointing the --model
argument of the transformers.onnx
package to the desired directory:
python -m transformers.onnx --model=local-tf-checkpoint onnx/
Ogni configurazione già pronta viene fornita con una serie di caratteristiche che ti consentono di esportare modelli per diversi tipi di topologie o attività . Come mostrato nella tabella di seguito, ogni caratteristica è associata a una diversa Auto Class:
Caratteristica | Auto Class |
---|---|
causal-lm , causal-lm-with-past |
AutoModelForCausalLM |
default , default-with-past |
AutoModel |
masked-lm |
AutoModelForMaskedLM |
question-answering |
AutoModelForQuestionAnswering |
seq2seq-lm , seq2seq-lm-with-past |
AutoModelForSeq2SeqLM |
sequence-classification |
AutoModelForSequenceClassification |
token-classification |
AutoModelForTokenClassification |
Per ciascuna configurazione, puoi trovare lâelenco delle funzionalitĂ supportate tramite il
FeaturesManager
. Ad esempio, per DistilBERT abbiamo:
>>> from transformers.onnx.features import FeaturesManager
>>> distilbert_features = list(FeaturesManager.get_supported_features_for_model_type("distilbert").keys())
>>> print(distilbert_features)
["default", "masked-lm", "causal-lm", "sequence-classification", "token-classification", "question-answering"]
Puoi quindi passare una di queste funzionalitĂ allâargomento --feature
nel
pacchetto transformers.onnx
. Ad esempio, per esportare un modello di classificazione del testo
possiamo scegliere un modello ottimizzato dallâHub ed eseguire:
python -m transformers.onnx --model=distilbert-base-uncased-finetuned-sst-2-english \ --feature=sequence-classification onnx/
che visualizzerĂ i seguenti registri:
Validating ONNX model...
-[â] ONNX model output names match reference model ({'logits'})
- Validating ONNX Model output "logits":
-[â] (2, 2) matches (2, 2)
-[â] all values close (atol: 1e-05)
All good, model saved at: onnx/model.onnx
Puoi notare che in questo caso, i nomi di output del modello ottimizzato sono
logits
invece di last_hidden_state
che abbiamo visto con il
checkpoint distilbert-base-uncased
precedente. Questo è previsto dal
modello ottimizato visto che ha una testa di e.
Le caratteristiche che hanno un suffisso wtih-past
(ad es. causal-lm-with-past
)
corrispondono a topologie di modello con stati nascosti precalcolati (chiave e valori
nei blocchi di attenzione) che possono essere utilizzati per la decodifica autoregressiva veloce.
Se desideri esportare un modello la cui architettura non è nativamente supportata dalla libreria, ci sono tre passaggi principali da seguire:
In questa sezione, vedremo come DistilBERT è stato implementato per mostrare cosa è coinvolto in ogni passaggio.
Iniziamo con lâoggetto di configurazione ONNX. Forniamo tre classi astratte da cui ereditare, a seconda del tipo di archittettura del modello che desideri esportare:
OnnxConfig
OnnxConfigWithPast
OnnxSeq2SeqConfigWithPast
Un buon modo per implementare una configurazione ONNX personalizzata è guardare lâimplementazione
esistente nel file configuration_<model_name>.py
di unâarchitettura simile.
PoichÊ DistilBERT è un modello basato su encoder, la sua configurazione eredita da
OnnxConfig
:
>>> from typing import Mapping, OrderedDict
>>> from transformers.onnx import OnnxConfig
>>> class DistilBertOnnxConfig(OnnxConfig):
... @property
... def inputs(self) -> Mapping[str, Mapping[int, str]]:
... return OrderedDict(
... [
... ("input_ids", {0: "batch", 1: "sequence"}),
... ("attention_mask", {0: "batch", 1: "sequence"}),
... ]
... )
Ogni oggetto di configurazione deve implementare la proprietĂ inputs
e restituire una
mappatura, dove ogni chiave corrisponde a un input previsto e ogni valore
indica lâasse di quellâinput. Per DistilBERT, possiamo vedere che sono richiesti
due input: input_ids
e attention_mask
. Questi inputs hanno la stessa forma di
(batch_size, sequence_length)
per questo motivo vediamo gli stessi assi usati nella
configurazione.
Puoi notare che la proprietĂ inputs
per DistilBertOnnxConfig
restituisce un
OrdinatoDict
. Ciò garantisce che gli input corrispondano alla loro posizione
relativa allâinterno del metodo PreTrainedModel.forward()
durante il tracciamento del grafico.
Raccomandiamo di usare un OrderedDict
per le proprietĂ inputs
e outputs
quando si implementano configurazioni ONNX personalizzate.
Dopo aver implementato una configurazione ONNX, è possibile istanziarla fornendo alla configurazione del modello base come segue:
>>> from transformers import AutoConfig
>>> config = AutoConfig.from_pretrained("distilbert-base-uncased")
>>> onnx_config = DistilBertOnnxConfig(config)
Lâoggetto risultante ha diverse proprietĂ utili. Ad esempio è possibile visualizzare il Set operatore ONNX che verrĂ utilizzato durante lâesportazione:
>>> print(onnx_config.default_onnx_opset)
11
Ă inoltre possibile visualizzare gli output associati al modello come segue:
>>> print(onnx_config.outputs)
OrderedDict([("last_hidden_state", {0: "batch", 1: "sequence"})])
Puoi notare che la proprietĂ degli output segue la stessa struttura degli input; esso
restituisce un OrderedDict
di output con nome e le loro forme. La struttura di output
è legato alla scelta della funzione con cui viene inizializzata la configurazione.
Per impostazione predefinita, la configurazione ONNX viene inizializzata con la funzione âpredefinitaâ
che corrisponde allâesportazione di un modello caricato con la classe AutoModel
. Se tu
desideri esportare una topologia di modello diversa, è sufficiente fornire una funzionalità diversa a
lâargomento task
quando inizializzi la configurazione ONNX. Ad esempio, se
volevamo esportare DistilBERT con una testa di classificazione per sequenze, potremmo
usare:
>>> from transformers import AutoConfig
>>> config = AutoConfig.from_pretrained("distilbert-base-uncased")
>>> onnx_config_for_seq_clf = DistilBertOnnxConfig(config, task="sequence-classification")
>>> print(onnx_config_for_seq_clf.outputs)
OrderedDict([('logits', {0: 'batch'})])
Tutte le proprietĂ e i metodi di base associati a OnnxConfig
e le
altre classi di configurazione possono essere sovrascritte se necessario. Guarda
BartOnnxConfig
per un esempio avanzato.
Una volta implementata la configurazione ONNX, il passaggio successivo consiste nellâesportare il
modello. Qui possiamo usare la funzione export()
fornita dal
pacchetto transformers.onnx
. Questa funzione prevede la configurazione ONNX, insieme
con il modello base e il tokenizer e il percorso per salvare il file esportato:
>>> from pathlib import Path
>>> from transformers.onnx import export
>>> from transformers import AutoTokenizer, AutoModel
>>> onnx_path = Path("model.onnx")
>>> model_ckpt = "distilbert-base-uncased"
>>> base_model = AutoModel.from_pretrained(model_ckpt)
>>> tokenizer = AutoTokenizer.from_pretrained(model_ckpt)
>>> onnx_inputs, onnx_outputs = export(tokenizer, base_model, onnx_config, onnx_config.default_onnx_opset, onnx_path)
Gli onnx_inputs
e onnx_outputs
restituiti dalla funzione export()
sono
liste di chiavi definite nelle proprietĂ di input
e output
della
configurazione. Una volta esportato il modello, puoi verificare che il modello sia ben
formato come segue:
>>> import onnx
>>> onnx_model = onnx.load("model.onnx")
>>> onnx.checker.check_model(onnx_model)
Se il tuo modello è piĂš largo di 2 GB, vedrai che molti file aggiuntivi sono creati durante lâesportazione. Questo è previsto perchĂŠ ONNX utilizza Protocol Buffer per memorizzare il modello e questi hanno un limite di dimensione 2 GB. Vedi la Documentazione ONNX per istruzioni su come caricare modelli con dati esterni.
Il passaggio finale consiste nel convalidare gli output dal modello di base e quello esportato
corrispondere entro una soglia di tolleranza assoluta. Qui possiamo usare la
Funzione validate_model_outputs()
fornita dal pacchetto transformers.onnx
come segue:
>>> from transformers.onnx import validate_model_outputs
>>> validate_model_outputs(
... onnx_config, tokenizer, base_model, onnx_path, onnx_outputs, onnx_config.atol_for_validation
... )
Questa funzione usa il metodo OnnxConfig.generate_dummy_inputs()
per generare
input per il modello di base e quello esportato e la tolleranza assoluta può essere
definita nella configurazione. Generalmente troviamo una corrispondenza numerica nellâintervallo da 1e-6
a 1e-4, anche se è probabile che qualsiasi cosa inferiore a 1e-3 vada bene.
Stiamo cercando di espandere lâinsieme di configurazioni giĂ pronte e di accettare contributi della community! Se vuoi contribuire con la tua aggiunta nella libreria, dovrai:
configuration file _<model_name>.py
~onnx.features.FeatureManager
test_onnx_v2.py
Scopri come stato contribuito la configurazione per [IBERT] (https://github.com/huggingface/transformers/pull/14868/files) per avere unâidea di cosa è coinvolto.
Questo è lâinizio dei nostri esperimenti con TorchScript e stiamo ancora esplorando le sue capacitĂ con modelli con variable-input-size. Ă una nostra prioritĂ e approfondiremo le nostre analisi nelle prossime versioni, con piĂš esempi di codici, unâimplementazione piĂš flessibile e benchmark che confrontano i codici basati su Python con quelli compilati con TorchScript.
Secondo la documentazione di Pytorch: âTorchScript è un modo per creare modelli serializzabili e ottimizzabili da codice Pytorchâ. I due moduli di Pytorch JIT e TRACE consentono allo sviluppatore di esportare il loro modello da riutilizzare in altri programmi, come i programmi C++ orientati allâefficienza.
Abbiamo fornito unâinterfaccia che consente lâesportazione di modelli đ¤ Transformers in TorchScript in modo che possano essere riutilizzati in un ambiente diverso rispetto a un programma Python basato su Pytorch. Qui spieghiamo come esportare e utilizzare i nostri modelli utilizzando TorchScript.
Esportare un modello richiede due cose:
torchscript
.Queste necessitĂ implicano diverse cose a cui gli sviluppatori dovrebbero prestare attenzione. Questi dettagli mostrati sotto.
Questo flag è necessario perchĂŠ la maggior parte dei modelli linguistici in questo repository hanno pesi legati tra il loro strato âEmbeddingâ e lo strato âDecodingâ. TorchScript non consente lâesportazione di modelli che hanno pesi legati, quindi è necessario prima slegare e clonare i pesi.
Ciò implica che i modelli istanziati con il flag torchscript
hanno il loro strato Embedding
e strato Decoding
separato, il che significa che non dovrebbero essere addestrati in futuro. Lâallenamento de-sincronizza i due
strati, portando a risultati inaspettati.
Questo non è il caso per i modelli che non hanno una testa del modello linguistico, poichÊ quelli non hanno pesi legati. Questi modelli
può essere esportato in sicurezza senza il flag torchscript
.
Gli input fittizzi sono usati per fare un modello passaggio in avanti . Mentre i valori degli input si propagano attraverso i strati, Pytorch tiene traccia delle diverse operazioni eseguite su ciascun tensore. Queste operazioni registrate vengono quindi utilizzate per creare la âtracciaâ del modello.
La traccia viene creata relativamente alle dimensioni degli input. Ă quindi vincolato dalle dimensioni dellâinput fittizio e non funzionerĂ per altre lunghezze di sequenza o dimensioni batch. Quando si proverĂ con una dimensione diversa, ci sarĂ errore come:
La dimensione espansa del tensore (3) deve corrispondere alla dimensione esistente (7) nella dimensione non singleton 2
will be raised. Si consiglia pertanto di tracciare il modello con una dimensione di input fittizia grande almeno quanto il piĂš grande input che verrĂ fornito al modello durante lâinferenza. Ă possibile eseguire il padding per riempire i valori mancanti. Il modello sarĂ tracciato con una grande dimensione di input, tuttavia, anche le dimensioni della diverse matrici saranno grandi, risultando in piĂš calcoli.
Si raccomanda di prestare attenzione al numero totale di operazioni eseguite su ciascun input e di seguire da vicino le prestazioni durante lâesportazione di modelli di sequenza-lunghezza variabili.
Di seguito è riportato un esempio, che mostra come salvare, caricare modelli e come utilizzare la traccia per lâinferenza.
Questo frammento di codice mostra come usare TorchScript per esportare un BertModel
. Qui il BertModel
è istanziato secondo
una classe BertConfig
e quindi salvato su disco con il nome del file traced_bert.pt
from transformers import BertModel, BertTokenizer, BertConfig
import torch
enc = BertTokenizer.from_pretrained("bert-base-uncased")
# Tokenizing input text
text = "[CLS] Who was Jim Henson ? [SEP] Jim Henson was a puppeteer [SEP]"
tokenized_text = enc.tokenize(text)
# Masking one of the input tokens
masked_index = 8
tokenized_text[masked_index] = "[MASK]"
indexed_tokens = enc.convert_tokens_to_ids(tokenized_text)
segments_ids = [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1]
# Creating a dummy input
tokens_tensor = torch.tensor([indexed_tokens])
segments_tensors = torch.tensor([segments_ids])
dummy_input = [tokens_tensor, segments_tensors]
# Initializing the model with the torchscript flag
# Flag set to True even though it is not necessary as this model does not have an LM Head.
config = BertConfig(
vocab_size_or_config_json_file=32000,
hidden_size=768,
num_hidden_layers=12,
num_attention_heads=12,
intermediate_size=3072,
torchscript=True,
)
# Instantiating the model
model = BertModel(config)
# The model needs to be in evaluation mode
model.eval()
# If you are instantiating the model with *from_pretrained* you can also easily set the TorchScript flag
model = BertModel.from_pretrained("bert-base-uncased", torchscript=True)
# Creating the trace
traced_model = torch.jit.trace(model, [tokens_tensor, segments_tensors])
torch.jit.save(traced_model, "traced_bert.pt")
Questo frammento di codice mostra come caricare il BertModel
che era stato precedentemente salvato su disco con il nome traced_bert.pt
.
Stiamo riutilizzando il dummy_input
precedentemente inizializzato.
loaded_model = torch.jit.load("traced_bert.pt")
loaded_model.eval()
all_encoder_layers, pooled_output = loaded_model(*dummy_input)
Usare il modello tracciato per lâinferenza è semplice come usare il suo metodo dunder __call__
:
traced_model(tokens_tensor, segments_tensors)
###Implementare modelli HuggingFace TorchScript su AWS utilizzando Neuron SDK
AWS ha introdotto Amazon EC2 Inf1 famiglia di istanze per lâinferenza di machine learning a basso costo e ad alte prestazioni nel cloud. Le istanze Inf1 sono alimentate dal chip AWS Inferentia, un acceleratore hardware personalizzato, specializzato in carichi di lavoro di inferenza di deep learning. AWS Neuron è lâSDK per Inferentia che supporta il tracciamento e lâottimizzazione dei modelli transformers per distribuzione su Inf1. LâSDK Neuron fornisce:
Modelli Transformers basati su architettura BERT (Bidirectional Encoder Representations from Transformers), o sue varianti come distilBERT e roBERTa funzioneranno meglio su Inf1 per attivitĂ non generative come la question answering estrattive, Classificazione della sequenza, Classificazione dei token. In alternativa, generazione di testo le attivitĂ possono essere adattate per essere eseguite su Inf1, secondo questo tutorial AWS Neuron MarianMT. Ulteriori informazioni sui modelli che possono essere convertiti fuori dagli schemi su Inferentia possono essere trovati nella sezione Model Architecture Fit della documentazione Neuron.
Lâutilizzo di AWS Neuron per convertire i modelli richiede le seguenti dipendenze e lâambiente:
Usando lo stesso script come in Usando TorchScipt in Python
per tracciare un âBertModelâ, importi lâestensione del framework torch.neuron
per accedere
i componenti di Neuron SDK tramite unâAPI Python.
from transformers import BertModel, BertTokenizer, BertConfig
import torch
import torch.neuron
E modificare solo la riga di codice di traccia
Da:
torch.jit.trace(model, [tokens_tensor, segments_tensors])
A:
torch.neuron.trace(model, [token_tensor, segments_tensors])
Questa modifica consente a Neuron SDK di tracciare il modello e ottimizzarlo per lâesecuzione nelle istanze Inf1.
Per ulteriori informazioni sulle funzionalitĂ , gli strumenti, i tutorial di esempi e gli ultimi aggiornamenti di AWS Neuron SDK, consultare la documentazione AWS NeuronSDK.