Perfeziona e distribuisci un modello di riepilogo utilizzando i contenitori Amazon SageMaker di Hugging Face che portano il tuo script

Ci sono stati molti progressi recenti nel dominio della PNL. I modelli pre-addestrati ei servizi NLP completamente gestiti hanno democratizzato l'accesso e l'adozione della PNL. Amazon Comprehend è un servizio completamente gestito in grado di eseguire attività NLP come riconoscimento di entità personalizzate, modellazione di argomenti, analisi del sentiment e altro per estrarre informazioni dettagliate dai dati senza la necessità di alcuna precedente esperienza di machine learning.

L'anno scorso, AWS ha annunciato a associazione con Abbracciare il viso per aiutare a portare più rapidamente in produzione i modelli di elaborazione del linguaggio naturale (NLP). Hugging Face è una comunità di intelligenza artificiale open source, incentrata sulla PNL. La loro libreria basata su Python (Trasformatori) fornisce strumenti per utilizzare facilmente le popolari architetture Transformer all'avanguardia come BERT, RoBERTa e GPT. È possibile applicare questi modelli a una varietà di attività NLP, come la classificazione del testo, l'estrazione di informazioni e la risposta a domande, tra cui altri.

Amazon Sage Maker è un servizio completamente gestito che offre a sviluppatori e data scientist la possibilità di creare, addestrare e distribuire rapidamente modelli di machine learning (ML). SageMaker elimina il lavoro pesante da ogni fase del processo ML, facilitando lo sviluppo di modelli di alta qualità. SageMaker Python SDK fornisce API e contenitori open source per addestrare e distribuire modelli su SageMaker, utilizzando diversi framework ML e deep learning.

L'integrazione di Hugging Face con SageMaker ti consente di creare modelli di Hugging Face su larga scala in base ai casi d'uso specifici del tuo dominio.

In questo post, ti guideremo attraverso un esempio di come creare e distribuire un riassunto del testo personalizzato Hugging Face su SageMaker. Usiamo Pegasus [1] per questo scopo, il primo modello basato su Transformer specificamente pre-addestrato su un obiettivo su misura per la sintesi astratta del testo. BERT è pre-addestrato a mascherare parole casuali in una frase; al contrario, durante il pre-allenamento di Pegasus, le frasi sono mascherate da un documento di input. Il modello genera quindi le frasi mancanti come un'unica sequenza di output utilizzando tutte le frasi non mascherate come contesto, creando di conseguenza un riepilogo esecutivo del documento.

Grazie alla flessibilità della libreria HuggingFace, puoi facilmente adattare il codice mostrato in questo post per altri tipi di modelli di trasformatori, come t5, BART e altri.

Carica il tuo set di dati per mettere a punto un modello Hugging Face

Per caricare un set di dati personalizzato da un file CSV, utilizziamo il file load_dataset metodo dal pacchetto Transformers. Possiamo applicare la tokenizzazione al set di dati caricato utilizzando il file datasets.Dataset.map funzione. Il map la funzione esegue un'iterazione sul set di dati caricato e applica la funzione tokenize a ciascun esempio. Il set di dati tokenizzato può quindi essere passato al trainer per la messa a punto del modello. Vedere il codice seguente:

# Python
def tokenize(batch):
    tokenized_input = tokenizer(batch[args.input_column], padding='max_length', truncation=True, max_length=args.max_source)
    tokenized_target = tokenizer(batch[args.target_column], padding='max_length', truncation=True, max_length=args.max_target)
    tokenized_input['target'] = tokenized_target['input_ids']

    return tokenized_input
    

def load_and_tokenize_dataset(data_dir):
    for file in os.listdir(data_dir):
        dataset = load_dataset("csv", data_files=os.path.join(data_dir, file), split='train')
    tokenized_dataset = dataset.map(lambda batch: tokenize(batch), batched=True, batch_size=512)
    tokenized_dataset.set_format('numpy', columns=['input_ids', 'attention_mask', 'labels'])
    
    return tokenized_dataset

Crea il tuo script di allenamento per lo stimatore Hugging Face SageMaker

Come spiegato nel post AWS e Hugging Face collaborano per semplificare e accelerare l'adozione dei modelli di elaborazione del linguaggio naturale, addestrare un modello Hugging Face su SageMaker non è mai stato così facile. Possiamo farlo usando lo stimatore Hugging Face del SDK di SageMaker.

Il seguente frammento di codice perfeziona Pegasus sul nostro set di dati. Puoi anche trovarne molti quaderni di esempio che ti guidano attraverso la messa a punto di diversi tipi di modelli, disponibili direttamente nel repository GitHub di Transformers. Per abilitare la formazione distribuita, possiamo utilizzare il Libreria di parallelismo dei dati in SageMaker, che è stato integrato nell'API di HuggingFace Trainer. Per abilitare il parallelismo dei dati, dobbiamo definire il distribution parametro nel nostro stimatore Hugging Face.

# Python
from sagemaker.huggingface import HuggingFace
# configuration for running training on smdistributed Data Parallel
distribution = {'smdistributed':{'dataparallel':{ 'enabled': True }}}
huggingface_estimator = HuggingFace(entry_point='train.py',
                                    source_dir='code',
                                    base_job_name='huggingface-pegasus',
                                    instance_type= 'ml.g4dn.16xlarge',
                                    instance_count=1,
                                    transformers_version='4.6',
                                    pytorch_version='1.7',
                                    py_version='py36',
                                    output_path=output_path,
                                    role=role,
                                    hyperparameters = {
                                        'model_name': 'google/pegasus-xsum',
                                        'epoch': 10,
                                        'per_device_train_batch_size': 2
                                    },
                                    distribution=distribution)
huggingface_estimator.fit({'train': training_input_path, 'validation': validation_input_path, 'test': test_input_path})

La dimensione massima del batch di addestramento che puoi configurare dipende dalle dimensioni del modello e dalla memoria GPU dell'istanza utilizzata. Se la formazione distribuita SageMaker è abilitata, la dimensione totale del batch è la somma di ogni batch distribuito su ciascun dispositivo/GPU. Se utilizziamo un ml.g4dn.16xlarge con training distribuito invece di un'istanza ml.g4dn.xlarge, abbiamo una memoria otto volte superiore (8 GPU) rispetto a un'istanza ml.g4dn.xlarge (1 GPU). La dimensione del batch per dispositivo rimane la stessa, ma otto dispositivi vengono addestrati in parallelo.

Come al solito con SageMaker, creiamo a train.py script da utilizzare con la modalità script e passare gli iperparametri per l'addestramento. Il frammento di codice seguente per Pegasus carica il modello e lo addestra utilizzando Transformers Trainer classe:

# Python
from transformers import (
    AutoModelForSeq2SeqLM,
    AutoTokenizer,
    Seq2SeqTrainer,
    Seq2seqTrainingArguments
)

model = AutoModelForSeq2SeqLM.from_pretrained(model_name).to(device)
    
training_args = Seq2seqTrainingArguments(
    output_dir=args.model_dir,
    num_train_epochs=args.epoch,
    per_device_train_batch_size=args.train_batch_size,
    per_device_eval_batch_size=args.eval_batch_size,
    warmup_steps=args.warmup_steps,
    weight_decay=args.weight_decay,
    logging_dir=f"{args.output_data_dir}/logs",
    logging_strategy='epoch',
    evaluation_strategy='epoch',
    saving_strategy='epoch',
    adafactor=True,
    do_train=True,
    do_eval=True,
    do_predict=True,
    save_total_limit = 3,
    load_best_model_at_end=True,
    metric_for_best_model='eval_loss'
    # With the goal to deploy the best checkpoint to production
    # it is important to set load_best_model_at_end=True,
    # this makes sure that the last model is saved at the root
    # of the model_dir” directory
)
    
trainer = Seq2SeqTrainer(
    model=model,
    args=training_args,
    train_dataset=dataset['train'],
    eval_dataset=dataset['validation']
)

trainer.train()
trainer.save_model()

# Get rid of unused checkpoints inside the container to limit the model.tar.gz size
os.system(f"rm -rf {args.model_dir}/checkpoint-*/")

Il codice completo è disponibile su GitHub.

Distribuisci il modello Hugging Face addestrato su SageMaker

I nostri amici di Hugging Face hanno reso l'inferenza sui modelli SageMaker per Transformers più semplice che mai grazie al SageMaker Kit di strumenti per l'inferenza del viso che abbraccia. È possibile distribuire direttamente il modello addestrato in precedenza semplicemente impostando la variabile di ambiente "HF_TASK":"summarization" (per istruzioni, cfr Modelli Pegasus), scegliendo Schierare, e quindi scegliere Amazon Sage Maker, senza dover scrivere uno script di inferenza.

Tuttavia, se hai bisogno di un modo specifico per generare o postelaborare previsioni, ad esempio generando diversi suggerimenti di riepilogo basati su un elenco di diversi parametri di generazione del testo, scrivere il tuo script di inferenza può essere utile e relativamente semplice:

# Python
# inference.py script

import os
import json
import torch
from transformers import AutoModelForSeq2SeqLM, AutoTokenizer

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

def model_fn(model_dir):
    # Create the model and tokenizer and load weights
    # from the previous training Job, passed here through "model_dir"
    # that is reflected in HuggingFaceModel "model_data"
    tokenizer = AutoTokenizer.from_pretrained(model_dir)
    model = AutoModelForSeq2SeqLM.from_pretrained(model_dir).to(device).eval()
    
    model_dict = {'model':model, 'tokenizer':tokenizer}
    
    return model_dict
        

def predict_fn(input_data, model_dict):
    # Return predictions/generated summaries
    # using the loaded model and tokenizer on input_data
    text = input_data.pop('inputs')
    parameters_list = input_data.pop('parameters_list', None)
    
    tokenizer = model_dict['tokenizer']
    model = model_dict['model']

    # Parameters may or may not be passed    
    input_ids = tokenizer(text, truncation=True, padding='longest', return_tensors="pt").input_ids.to(device)
    
    if parameters_list:
        predictions = []
        for parameters in parameters_list:
            output = model.generate(input_ids, **parameters)
            predictions.append(tokenizer.batch_decode(output, skip_special_tokens=True))
    else:
        output = model.generate(input_ids)
        predictions = tokenizer.batch_decode(output, skip_special_tokens=True)
    
    return predictions
    
    
def input_fn(request_body, request_content_type):
    # Transform the input request to a dictionary
    request = json.loads(request_body)
    return request

Come mostrato nel codice precedente, uno script di inferenza di questo tipo per HuggingFace su SageMaker richiede solo le seguenti funzioni modello:

• modello_fn() – Legge all'interno il contenuto di ciò che è stato salvato al termine del lavoro di formazione SM_MODEL_DIRo da una directory dei pesi del modello esistente salvata come file tar.gz in Servizio di archiviazione semplice Amazon (Amazon S3). Viene utilizzato per caricare il modello addestrato e il tokenizer associato.
• input_fn () – Formatta i dati ricevuti da una richiesta effettuata all'endpoint.
• predict_fn () – Richiama l'uscita di model_fn() (il modello e il tokenizer) per eseguire l'inferenza sull'output di input_fn() (i dati formattati).

Facoltativamente, puoi creare un output_fn() funzione per la formattazione dell'inferenza, utilizzando l'output di predict_fn(), che non abbiamo dimostrato in questo post.

Possiamo quindi distribuire il modello Hugging Face addestrato con il suo script di inferenza associato a SageMaker utilizzando il file Modello SageMaker con il viso che abbraccia classe:

# Python
from sagemaker.huggingface import HuggingFaceModel

model = HuggingFaceModel(model_data=huggingface_estimator.model_data,
                     role=role,
                     framework_version='1.7',
                     py_version='py36',
                     entry_point='inference.py',
                     source_dir='code')
                     
predictor = model.deploy(initial_instance_count=1,
                         instance_type='ml.g4dn.xlarge'
                         )

Testare il modello distribuito

Per questa demo, abbiamo addestrato il modello su Set di dati di recensioni di abbigliamento e-commerce da donna, che contiene recensioni di articoli di abbigliamento (che consideriamo come testo di input) e i relativi titoli (che consideriamo riepiloghi). Dopo aver rimosso gli articoli con i titoli mancanti, il set di dati contiene 19,675 recensioni. La messa a punto del modello Pegasus su un training set contenente il 70% di quegli articoli per cinque epoche ha richiesto circa 3.5 ore su un'istanza ml.p3.16xlarge.

Possiamo quindi distribuire il modello e testarlo con alcuni dati di esempio dal set di test. Quello che segue è un esempio di recensione che descrive un maglione:

# Python
Review Text
"I ordered this sweater in green in petite large. The color and knit is beautiful and the shoulders and body fit comfortably; however, the sleeves were very long for a petite. I roll them, and it looks okay but would have rather had a normal petite length sleeve."

Original Title
"Long sleeves"

Rating
3

Grazie al nostro script di inferenza personalizzato ospitato in un endpoint SageMaker, possiamo generare diversi riepiloghi per questa recensione con diversi parametri di generazione del testo. Ad esempio, possiamo chiedere all'endpoint di generare un intervallo di riepiloghi da molto brevi a moderatamente lunghi specificando penalità di lunghezza diverse (minore è la penalità di lunghezza, minore è il riepilogo generato). Di seguito sono riportati alcuni esempi di input di parametri e i successivi riepiloghi generati dalla macchina:

# Python
inputs = {
    "inputs":[
"I ordered this sweater in green in petite large. The color and knit is   beautiful and the shoulders and body fit comfortably; however, the sleeves were very long for a petite. I roll them, and it looks okay but would have rather had a normal petite length sleeve."
    ],

    "parameters_list":[
        {
            "length_penalty":2
        },
	{
            "length_penalty":1
        },
	{
            "length_penalty":0.6
        },
        {
            "length_penalty":0.4
        }
    ]

result = predictor.predict(inputs)
print(result)

[
    ["Beautiful color and knit but sleeves are very long for a petite"],
    ["Beautiful sweater, but sleeves are too long for a petite"],
    ["Cute, but sleeves are long"],
    ["Very long sleeves"]
]

Quale riassunto preferisci? Il primo titolo generato cattura tutti i fatti importanti sulla recensione, con un quarto del numero di parole. Al contrario, l'ultimo usa solo tre parole (meno di 1/10 della lunghezza della recensione originale) per concentrarsi sulla caratteristica più importante del maglione.

Conclusione

Puoi mettere a punto un riepilogo di testo sul tuo set di dati personalizzato e distribuirlo alla produzione su SageMaker con questo semplice esempio disponibile su GitHub. addizionale quaderni di esempio per addestrare e distribuire modelli Hugging Face su SageMaker sono disponibili anche.

Come sempre, AWS è lieto di ricevere feedback. Si prega di inviare commenti o domande.

Riferimenti

[1] PEGASUS: Pre-formazione con frasi di gap estratte per la sintesi astratta

Circa gli autori

Viktor Malesevic è un ingegnere di machine learning con AWS Professional Services, appassionato di elaborazione del linguaggio naturale e MLOps. Collabora con i clienti per sviluppare e mettere in produzione modelli di deep learning impegnativi su AWS. Nel tempo libero si diverte a condividere un bicchiere di vino rosso e del formaggio con gli amici.

Amna Najmi è un Data Scientist con AWS Professional Services. È appassionata di aiutare i clienti a innovare con le tecnologie Big Data e Intelligenza Artificiale per sfruttare il valore aziendale e le informazioni dettagliate dai dati. Nel tempo libero le piace fare giardinaggio e viaggiare in posti nuovi.