Crea un’architettura personalizzata

Una AutoClass deduce automaticamente il modello dell’architettura e scarica la configurazione e i pesi pre-allenati. Generalmente, noi consigliamo di usare un AutoClass per produrre un codice indipendente dal checkpoint. Ma gli utenti che desiderano un controllo maggiore su parametri specifici del modello possono creare un modello 🤗 Transformers personalizzato da poche classi base. Questo potrebbe essere particolarmente utile per qualunque persona sia interessata nel studiare, allenare o sperimentare con un modello 🤗 Transformers. In questa guida, approfondisci la creazione di un modello personalizzato senza AutoClass. Impara come:

• Caricare e personalizzare una configurazione del modello.
• Creare un’architettura modello.
• Creare un tokenizer lento e veloce per il testo.
• Creare un estrattore di caratteristiche per attività riguardanti audio o immagini.
• Creare un processore per attività multimodali.

Configurazione

Una configurazione si riferisce agli attributi specifici di un modello. Ogni configurazione del modello ha attributi diversi; per esempio, tutti i modelli npl hanno questi attributi in comune hidden_size, num_attention_heads, num_hidden_layers e vocab_size. Questi attributi specificano il numero di attention heads o strati nascosti con cui costruire un modello.

Dai un’occhiata più da vicino a DistilBERT accedendo a DistilBertConfig per ispezionare i suoi attributi:

>>> from transformers import DistilBertConfig

>>> config = DistilBertConfig()
>>> print(config)
DistilBertConfig {
  "activation": "gelu",
  "attention_dropout": 0.1,
  "dim": 768,
  "dropout": 0.1,
  "hidden_dim": 3072,
  "initializer_range": 0.02,
  "max_position_embeddings": 512,
  "model_type": "distilbert",
  "n_heads": 12,
  "n_layers": 6,
  "pad_token_id": 0,
  "qa_dropout": 0.1,
  "seq_classif_dropout": 0.2,
  "sinusoidal_pos_embds": false,
  "transformers_version": "4.16.2",
  "vocab_size": 30522
}

DistilBertConfig mostra tutti gli attributi predefiniti usati per costruire una base DistilBertModel. Tutti gli attributi sono personalizzabili, creando uno spazio per sperimentare. Per esempio, puoi configurare un modello predefinito per:

• Provare un funzione di attivazione diversa con il parametro activation.
• Utilizzare tasso di drop out più elevato per le probalità di attention con il parametro attention_dropout.

>>> my_config = DistilBertConfig(activation="relu", attention_dropout=0.4)
>>> print(my_config)
DistilBertConfig {
  "activation": "relu",
  "attention_dropout": 0.4,
  "dim": 768,
  "dropout": 0.1,
  "hidden_dim": 3072,
  "initializer_range": 0.02,
  "max_position_embeddings": 512,
  "model_type": "distilbert",
  "n_heads": 12,
  "n_layers": 6,
  "pad_token_id": 0,
  "qa_dropout": 0.1,
  "seq_classif_dropout": 0.2,
  "sinusoidal_pos_embds": false,
  "transformers_version": "4.16.2",
  "vocab_size": 30522
}

Nella funzione from_pretrained() possono essere modificati gli attributi del modello pre-allenato:

>>> my_config = DistilBertConfig.from_pretrained("distilbert-base-uncased", activation="relu", attention_dropout=0.4)

Quando la configurazione del modello ti soddisfa, la puoi salvare con save_pretrained(). Il file della tua configurazione è memorizzato come file JSON nella save directory specificata:

>>> my_config.save_pretrained(save_directory="./your_model_save_path")

Per riutilizzare la configurazione del file, caricalo con from_pretrained():

>>> my_config = DistilBertConfig.from_pretrained("./your_model_save_path/my_config.json")

Modello

Il prossimo passo e di creare modello. Il modello - vagamente riferito anche come architettura - definisce cosa ogni strato deve fare e quali operazioni stanno succedendo. Attributi come num_hidden_layers provenienti dalla configurazione sono usati per definire l’architettura. Ogni modello condivide la classe base PreTrainedModel e alcuni metodi comuni come il ridimensionamento degli input embeddings e la soppressione delle self-attention heads . Inoltre, tutti i modelli sono la sottoclasse di torch.nn.Module, tf.keras.Model o flax.linen.Module. Cio significa che i modelli sono compatibili con l’uso di ciascun di framework.

>>> from transformers import DistilBertModel

>>> my_config = DistilBertConfig.from_pretrained("./your_model_save_path/my_config.json")
>>> model = DistilBertModel(my_config)

>>> model = DistilBertModel.from_pretrained("distilbert-base-uncased")

>>> model = DistilBertModel.from_pretrained("distilbert-base-uncased", config=my_config)

>>> from transformers import TFDistilBertModel

>>> my_config = DistilBertConfig.from_pretrained("./your_model_save_path/my_config.json")
>>> tf_model = TFDistilBertModel(my_config)

>>> tf_model = TFDistilBertModel.from_pretrained("distilbert-base-uncased")

>>> tf_model = TFDistilBertModel.from_pretrained("distilbert-base-uncased", config=my_config)

Model head

A questo punto, hai un modello DistilBERT base i cui output sono gli hidden states (in italiano stati nascosti). Gli stati nascosti sono passati come input a un model head per produrre l’output finale. 🤗 Transformers fornisce un model head diverso per ogni attività fintanto che il modello supporta l’attività (i.e., non puoi usare DistilBERT per un attività sequence-to-sequence come la traduzione).

>>> from transformers import DistilBertForSequenceClassification

>>> model = DistilBertForSequenceClassification.from_pretrained("distilbert-base-uncased")

>>> from transformers import DistilBertForQuestionAnswering

>>> model = DistilBertForQuestionAnswering.from_pretrained("distilbert-base-uncased")

>>> from transformers import TFDistilBertForSequenceClassification

>>> tf_model = TFDistilBertForSequenceClassification.from_pretrained("distilbert-base-uncased")

>>> from transformers import TFDistilBertForQuestionAnswering

>>> tf_model = TFDistilBertForQuestionAnswering.from_pretrained("distilbert-base-uncased")

Tokenizer

L’ultima classe base di cui hai bisogno prima di utilizzare un modello per i dati testuali è un tokenizer per convertire il testo grezzo in tensori. Ci sono due tipi di tokenizer che puoi usare con 🤗 Transformers:

• PreTrainedTokenizer: un’implementazione Python di un tokenizer.
• PreTrainedTokenizerFast: un tokenizer dalla nostra libreria 🤗 Tokenizer basata su Rust. Questo tipo di tokenizer è significativamente più veloce, specialmente durante la batch tokenization, grazie alla sua implementazione Rust. Il tokenizer veloce offre anche metodi aggiuntivi come offset mapping che associa i token alle loro parole o caratteri originali.

Entrambi i tokenizer supportano metodi comuni come la codifica e la decodifica, l’aggiunta di nuovi token e la gestione di token speciali.

Se hai addestrato il tuo tokenizer, puoi crearne uno dal tuo file vocabolario:

>>> from transformers import DistilBertTokenizer

>>> my_tokenizer = DistilBertTokenizer(vocab_file="my_vocab_file.txt", do_lower_case=False, padding_side="left")

È importante ricordare che il vocabolario di un tokenizer personalizzato sarà diverso dal vocabolario generato dal tokenizer di un modello preallenato. È necessario utilizzare il vocabolario di un modello preallenato se si utilizza un modello preallenato, altrimenti gli input non avranno senso. Crea un tokenizer con il vocabolario di un modello preallenato con la classe DistilBertTokenizer:

>>> from transformers import DistilBertTokenizer

>>> slow_tokenizer = DistilBertTokenizer.from_pretrained("distilbert-base-uncased")

Crea un tokenizer veloce con la classe DistilBertTokenizerFast:

>>> from transformers import DistilBertTokenizerFast

>>> fast_tokenizer = DistilBertTokenizerFast.from_pretrained("distilbert-base-uncased")

Estrattore Di Feature

Un estrattore di caratteristiche (feature in inglese) elabora input audio o immagini. Eredita dalla classe FeatureExtractionMixin base e può anche ereditare dalla classe ImageFeatureExtractionMixin per l’elaborazione delle caratteristiche dell’immagine o dalla classe SequenceFeatureExtractor per l’elaborazione degli input audio.

A seconda che tu stia lavorando a un’attività audio o visiva, crea un estrattore di caratteristiche associato al modello che stai utilizzando. Ad esempio, crea un ViTFeatureExtractor predefinito se stai usando ViT per la classificazione delle immagini:

>>> from transformers import ViTFeatureExtractor

>>> vit_extractor = ViTFeatureExtractor()
>>> print(vit_extractor)
ViTFeatureExtractor {
  "do_normalize": true,
  "do_resize": true,
  "feature_extractor_type": "ViTFeatureExtractor",
  "image_mean": [
    0.5,
    0.5,
    0.5
  ],
  "image_std": [
    0.5,
    0.5,
    0.5
  ],
  "resample": 2,
  "size": 224
}

Modifica uno qualsiasi dei parametri ViTFeatureExtractor per creare il tuo estrattore di caratteristiche personalizzato:

>>> from transformers import ViTFeatureExtractor

>>> my_vit_extractor = ViTFeatureExtractor(resample="PIL.Image.BOX", do_normalize=False, image_mean=[0.3, 0.3, 0.3])
>>> print(my_vit_extractor)
ViTFeatureExtractor {
  "do_normalize": false,
  "do_resize": true,
  "feature_extractor_type": "ViTFeatureExtractor",
  "image_mean": [
    0.3,
    0.3,
    0.3
  ],
  "image_std": [
    0.5,
    0.5,
    0.5
  ],
  "resample": "PIL.Image.BOX",
  "size": 224
}

Per gli input audio, puoi creare un Wav2Vec2FeatureExtractor e personalizzare i parametri in modo simile:

>>> from transformers import Wav2Vec2FeatureExtractor

>>> w2v2_extractor = Wav2Vec2FeatureExtractor()
>>> print(w2v2_extractor)
Wav2Vec2FeatureExtractor {
  "do_normalize": true,
  "feature_extractor_type": "Wav2Vec2FeatureExtractor",
  "feature_size": 1,
  "padding_side": "right",
  "padding_value": 0.0,
  "return_attention_mask": false,
  "sampling_rate": 16000
}

Processore

Per modelli che supportano attività multimodali, 🤗 Transformers offre una classe di processore che racchiude comodamente un estrattore di caratteristiche e un tokenizer in un unico oggetto. Ad esempio, utilizziamo Wav2Vec2Processor per un’attività di riconoscimento vocale automatico (ASR). ASR trascrive l’audio in testo, quindi avrai bisogno di un estrattore di caratteristiche e di un tokenizer.

Crea un estrattore di feature per gestire gli input audio:

>>> from transformers import Wav2Vec2FeatureExtractor

>>> feature_extractor = Wav2Vec2FeatureExtractor(padding_value=1.0, do_normalize=True)

Crea un tokenizer per gestire gli input di testo:

>>> from transformers import Wav2Vec2CTCTokenizer

>>> tokenizer = Wav2Vec2CTCTokenizer(vocab_file="my_vocab_file.txt")

Combinare l’estrattore di caratteristiche e il tokenizer in Wav2Vec2Processor:

>>> from transformers import Wav2Vec2Processor

>>> processor = Wav2Vec2Processor(feature_extractor=feature_extractor, tokenizer=tokenizer)

Con due classi di base - configurazione e modello - e una classe di preelaborazione aggiuntiva (tokenizer, estrattore di caratteristiche o processore), puoi creare qualsiasi modello supportato da 🤗 Transformers. Ognuna di queste classi base è configurabile, consentendoti di utilizzare gli attributi specifici che desideri. È possibile impostare facilmente un modello per l’addestramento o modificare un modello preallenato esistente per la messa a punto.