Ricerca degli iperparametri con Transformers e Ray Tune

'Hyperparameter optimization with Transformers and Ray Tune'

Un post di blog ospite di Richard Liaw dal team Anyscale

Con implementazioni di ricerca all’avanguardia e migliaia di modelli addestrati facilmente accessibili, la libreria Hugging Face transformers è diventata fondamentale per il successo e la crescita dell’elaborazione del linguaggio naturale oggi.

Perché un qualsiasi modello di apprendimento automatico possa ottenere buone prestazioni, gli utenti spesso devono implementare una forma di accordatura dei parametri. Tuttavia, quasi tutti ( 1 , 2 ) finiscono per ignorare l’accordatura degli iperparametri o optano per una ricerca a griglia semplice con uno spazio di ricerca limitato.

Tuttavia, semplici esperimenti sono in grado di mostrare i vantaggi dell’utilizzo di una tecnica di accordatura avanzata. Di seguito è riportato un recente esperimento eseguito su un modello BERT di Hugging Face transformers sul dataset RTE . Le tecniche di ottimizzazione genetiche come PBT possono fornire miglioramenti delle prestazioni considerevoli rispetto alle tecniche standard di ottimizzazione degli iperparametri.

Algoritmo	Miglior Acc. Val.	Miglior Acc. Test	Totale minuti GPU	Totale costo $
Ricerca a griglia	74%	65.4%	45 min	$2.30
Ottimizzazione Bayesiana + Stop anticipato	77%	66.9%	104 min	$5.30
Training basato sulla popolazione	78%	70.5%	48 min	$2.45

Se stai utilizzando Transformers , vorrai avere un modo per accedere facilmente a soluzioni di accordatura degli iperparametri potenti senza rinunciare alla personalizzabilità del framework Transformers.

• Portare il sistema di traduzione fairseq wmt19 su transformers
• Sfruttare i checkpoint dei modelli di lingua preaddestrati per i modelli codificatore-decodificatore
• Come abbiamo accelerato l’elaborazione di inferenza del transformer di 100 volte per i clienti di 🤗 API

Nella versione 3.1 di Transformers, Hugging Face Transformers e Ray Tune si sono uniti per fornire un’integrazione semplice ma potente. Ray Tune è una popolare libreria Python per l’accordatura degli iperparametri che fornisce molti algoritmi all’avanguardia già pronti per l’uso, insieme a integrazioni con strumenti di prima classe, come Weights and Biases e tensorboard.

Per dimostrare questa nuova integrazione di Hugging Face + Ray Tune, sfruttiamo la libreria Hugging Face Datasets per l’affinamento di BERT su MRPC .

Per eseguire questo esempio, esegui prima:

pip install "ray[tune]" transformers datasets scipy sklearn torch

È sufficiente collegare uno degli algoritmi di accordatura standard di Ray aggiungendo solo poche righe di codice.

from datasets import load_dataset, load_metric
from transformers import (AutoModelForSequenceClassification, AutoTokenizer,
                          Trainer, TrainingArguments)

tokenizer = AutoTokenizer.from_pretrained('distilbert-base-uncased')
dataset = load_dataset('glue', 'mrpc')
metric = load_metric('glue', 'mrpc')

def encode(examples):
    outputs = tokenizer(
        examples['sentence1'], examples['sentence2'], truncation=True)
    return outputs

encoded_dataset = dataset.map(encode, batched=True)

def model_init():
    return AutoModelForSequenceClassification.from_pretrained(
        'distilbert-base-uncased', return_dict=True)

def compute_metrics(eval_pred):
    predictions, labels = eval_pred
    predictions = predictions.argmax(axis=-1)
    return metric.compute(predictions=predictions, references=labels)

# Valuta durante l'addestramento e un po' più spesso
# rispetto al valore predefinito per poter eliminare rapidamente i tentativi fallimentari.
# Disabilitare tqdm è una questione di preferenza.
training_args = TrainingArguments(
    "test", evaluation_strategy="steps", eval_steps=500, disable_tqdm=True)
trainer = Trainer(
    args=training_args,
    tokenizer=tokenizer,
    train_dataset=encoded_dataset["train"],
    eval_dataset=encoded_dataset["validation"],
    model_init=model_init,
    compute_metrics=compute_metrics,
)

# L'obiettivo predefinito è la somma di tutte le metriche
# quando vengono fornite, quindi dobbiamo massimizzarla.
trainer.hyperparameter_search(
    direction="maximize", 
    backend="ray", 
    n_trials=10 # numero di tentativi
)

Per impostazione predefinita, ogni prova utilizzerà 1 CPU e facoltativamente 1 GPU se disponibile. Puoi sfruttare più GPU per una ricerca parallela degli iperparametri passando un argomento resources_per_trial.

Puoi anche facilmente scambiare diversi algoritmi di ottimizzazione dei parametri come HyperBand, Bayesian Optimization, Population-Based Training:

Per eseguire questo esempio, esegui prima: pip install hyperopt

from ray.tune.suggest.hyperopt import HyperOptSearch
from ray.tune.schedulers import ASHAScheduler

trainer = Trainer(
    args=training_args,
    tokenizer=tokenizer,
    train_dataset=encoded_dataset["train"],
    eval_dataset=encoded_dataset["validation"],
    model_init=model_init,
    compute_metrics=compute_metrics,
)

best_trial = trainer.hyperparameter_search(
    direction="massimizza",
    backend="ray",
    # Scegli tra molte librerie:
    # https://docs.ray.io/en/latest/tune/api_docs/suggestion.html
    search_alg=HyperOptSearch(metric="obiettivo", mode="massimizza"),
    # Scegli tra gli schedulers:
    # https://docs.ray.io/en/latest/tune/api_docs/schedulers.html
    scheduler=ASHAScheduler(metric="obiettivo", mode="massimizza"))

Funziona anche con Weights and Biases out of the box!

Provalo oggi:

• pip install -U ray
• pip install -U transformers datasets
• Consulta la documentazione di Hugging Face e il thread di discussione
• Esempio completo di utilizzo della ricerca degli iperparametri di Hugging Face per la classificazione del testo

Se hai apprezzato questo post sul blog, assicurati di dare un’occhiata anche a:

• Esempio Transformers + GLUE + Ray Tune
• Il nostro rapporto Weights and Biases sull’ottimizzazione degli iperparametri per Transformers
• Il modo più semplice per servire il tuo modello NLP da zero