Accelerare l’addestramento dei modelli di deep learning fino al 35% con l’utilizzo di Amazon SageMaker e il suo smart sifting

Aumenta del 35% la velocità di addestramento dei modelli di deep learning utilizzando Amazon SageMaker e la sua selezione intelligente

Nel paesaggio in rapida evoluzione dell’intelligenza artificiale, i modelli di deep learning si sono trovati all’avanguardia dell’innovazione, con applicazioni che spaziano dalla computer vision (CV) all’elaborazione del linguaggio naturale (NLP) e ai sistemi di raccomandazione. Tuttavia, il crescente costo associato all’addestramento e al perfezionamento di questi modelli rappresenta una sfida per le aziende. Questo costo è principalmente determinato dal volume di dati utilizzati nell’addestramento dei modelli di deep learning. Oggi, i modelli più grandi vengono spesso addestrati su terabyte di dati e possono richiedere settimane per essere addestrati, anche con potenti GPU o hardware basato su AWS Trainium. Di solito, i clienti si affidano a tecniche e ottimizzazioni che migliorano l’efficienza del ciclo di addestramento di un modello, come i kernel o i layer ottimizzati, l’addestramento a precisione mista o funzionalità come le librerie di addestramento distribuito di Amazon SageMaker. Tuttavia, oggi si presta meno attenzione all’efficienza dei dati di addestramento in sé. Non tutti i dati contribuiscono allo stesso modo al processo di apprendimento durante l’addestramento del modello: una parte significativa delle risorse di calcolo può essere impiegata nel processare esempi semplici che non contribuiscono in modo sostanziale alla precisione complessiva del modello.

I clienti si sono tradizionalmente basati su tecniche di preprocessing come l’upsampling o il downsampling e la deduplicazione per raffinare e migliorare la qualità delle informazioni dei loro dati. Queste tecniche possono essere utili, ma spesso richiedono molto tempo, esperienza specialistica in scienze dei dati e talvolta sono più un’arte che una scienza. I clienti spesso si affidano anche a set di dati curati, come RefinedWeb, per migliorare le prestazioni dei loro modelli; tuttavia, questi set di dati non sono sempre completamente open source e spesso sono più generici e non correlati al tuo caso d’uso specifico.

In che altro modo puoi superare questa inefficienza legata a campioni di dati a bassa informazione durante l’addestramento del modello?

Siamo lieti di annunciare una preview pubblica di smart sifting, una nuova funzionalità di SageMaker che può ridurre del 35% i costi di addestramento dei modelli di deep learning. Smart sifting è una nuova tecnica di efficienza dei dati che analizza attivamente i campioni di dati durante l’addestramento e filtra i campioni meno informativi per il modello. Addestrandosi su un sottoinsieme di dati più piccolo contenente solo i campioni che contribuiscono di più alla convergenza del modello, l’addestramento e i costi totali diminuiscono con un impatto minimo o nullo sulla precisione. Inoltre, poiché la funzionalità opera online durante l’addestramento del modello, smart sifting non richiede modifiche ai dati di origine o alla pipeline di addestramento successiva.

• Pika 1.0 Un nuovo modello AI per la creazione di video
• I ricercatori di Apple presentano Parallel Speculative Sampling (PaSS) un salto nella efficienza e scalabilità dei modelli di linguaggio.
• Quanto tempo ci vuole per imparare la scienza dei dati?

In questo post, discuteremo i seguenti argomenti:

• La nuova funzionalità smart sifting in SageMaker e come funziona
• Come utilizzare smart sifting con carichi di lavoro di addestramento PyTorch

Puoi anche consultare la nostra documentazione e i quaderni di esempio per ulteriori risorse su come iniziare con smart sifting.

Come funziona SageMaker smart sifting

Iniziamo questo post con una panoramica su come la funzionalità smart sifting può accelerare l’addestramento del tuo modello su SageMaker.

Il compito di smart sifting è di esaminare i tuoi dati di addestramento durante il processo di addestramento e alimentare solo i campioni più informativi al modello. Durante un tipico addestramento con PyTorch, i dati vengono inviati in batch in modo iterativo al ciclo di addestramento e ai dispositivi acceleratori (ad esempio, GPU o chip Trainium) tramite il PyTorch DataLoader. Smart sifting è implementato in questa fase di caricamento dei dati e quindi è indipendente da qualsiasi preprocessing dei dati a monte nella tua pipeline di addestramento.

Smart sifting utilizza il tuo modello e una funzione di loss specificata dall’utente per effettuare un passaggio in avanti valutativo per ogni campione di dati durante il caricamento. I campioni con una loss elevata influenzeranno in modo significativo l’addestramento del modello e quindi verranno utilizzati nell’addestramento; i campioni di dati relativamente a bassa loss vengono messi da parte ed esclusi dall’addestramento.

Un elemento chiave per smart sifting è la proporzione di dati da escludere: ad esempio, impostando la proporzione al 33% (beta_value=0.5), i campioni approssimativamente nell’ultimo terzo di loss di ogni batch verranno esclusi dall’addestramento. Quando sono stati identificati abbastanza campioni ad alta loss per completare un batch, i dati vengono inviati attraverso l’intero ciclo di addestramento e il modello impara e si allena normalmente. Non è necessario apportare alcuna modifica al tuo ciclo di addestramento quando smart sifting è abilitato.

Il seguente diagramma illustra questo flusso di lavoro.

Includendo solo un sottoinsieme dei tuoi dati di addestramento, la selezione intelligente riduce il tempo e il calcolo necessari per addestrare il modello. Nei nostri test, abbiamo ottenuto fino a una riduzione di quasi il 40% del tempo e del costo totale di addestramento. Con la selezione intelligente dei dati, può esserci un impatto minimo o nullo sull’accuratezza del modello perché i campioni esclusi erano relativamente a bassa perdita per il modello. Nella tabella seguente, includiamo un insieme di risultati sperimentali che dimostrano il miglioramento delle prestazioni possibili con SageMaker selezione intelligente.

Nella tabella, la colonna % Accettati indica la proporzione di dati inclusi e utilizzati nel ciclo di addestramento. Aumentare questo parametro modificabile riduce il costo (come dimostrato nella colonna % Risparmi di IMR), ma può anche influire sull’accuratezza. La configurazione appropriata per % Accettati dipende dal tuo set di dati e dal modello; dovresti sperimentare e regolare questo parametro per ottenere il miglior equilibrio tra costo ridotto e impatto sull’accuratezza.

Panoramica della soluzione

Nelle sezioni seguenti, attraverseremo un esempio pratico di abilitazione della selezione intelligente con un lavoro di addestramento PyTorch su SageMaker. Se vuoi iniziare rapidamente, puoi passare agli esempi di PyTorch o PyTorch Lightning.

Prerequisiti

Assumiamo che tu sappia già come addestrare un modello utilizzando PyTorch o PyTorch Lightning utilizzando il SDK Python di SageMaker e la classe Estimator utilizzando SageMaker Deep Learning Containers per l’addestramento. In caso contrario, consulta Utilizzo del SDK Python di SageMaker prima di continuare.

Inizia con SageMaker selezione intelligente

In un tipico lavoro di addestramento PyTorch, inizializzi il PyTorch training DataLoader con il tuo set di dati e altri parametri richiesti, che fornisce batch di input durante l’addestramento. Per abilitare la selezione intelligente dei tuoi dati di addestramento, utilizzerai una nuova classe DataLoader: smart_sifting.dataloader.sift_dataloader.SiftingDataloader. Questa classe viene utilizzata come wrapper sopra il tuo PyTorch DataLoader esistente e il processo di addestramento utilizzerà invece SiftingDataloader per ottenere i batch di input. SiftingDataLoader prende il batch di input dal tuo PyTorch DataLoader originale, valuta l’importanza dei campioni nel batch e costruisce un batch filtrato con campioni ad alta perdita, che vengono quindi passati allo step di addestramento. Il wrapper si presenta come il seguente codice:

from smart_sifting.dataloader.sift_dataloader import SiftingDataloadertrain_dataloader =  SiftingDataloader(    sift_config = sift_config,    orig_dataloader=DataLoader(self.train, self.batch_size, shuffle=True),    loss_impl=BertLoss(),    model=self.model)

Il SiftingDataloader richiede alcuni parametri aggiuntivi per analizzare i tuoi dati di addestramento, che puoi specificare tramite il parametro sift_config. Prima, crea un oggetto smart_sifting.sift_config.sift_configs.RelativeProbabilisticSiftConfig. Questo oggetto contiene la configurazione configurabile e richiesta beta_value e loss_history_length, che definiscono rispettivamente la proporzione di campioni da conservare e la finestra di campioni da includere durante la valutazione della perdita relativa. Nota che, poiché la selezione intelligente utilizza il tuo modello per definire l’importanza del campione, possono esserci implicazioni negative se viene utilizzato un modello con pesi completamente casuali. Invece, puoi utilizzare loss_based_sift_config e un sift_delay per ritardare il processo di selezione finché i pesi dei parametri nel modello non vengono aggiornati oltre i valori casuali. (Per ulteriori dettagli, consulta Applica la selezione intelligente al tuo script di addestramento.) Nel codice seguente, definiamo sift_config e specifichiamo beta_value e loss_history_length, oltre a ritardare l’avvio della selezione utilizzando loss_based_sift_config:

from smart_sifting.sift_config.sift_configs import RelativeProbabilisticSiftConfig, LossConfig, SiftingBaseConfigsift_config = RelativeProbabilisticSiftConfig(    beta_value=3,    loss_history_length=500,    loss_based_sift_config=LossConfig(         sift_config=SiftingBaseConfig(sift_delay=10)    ))

In seguito, devi anche includere un parametro loss_impl nell’oggetto SiftingDataloader. Il sift intelligente funziona a livello di singolo campione ed è fondamentale avere accesso a un metodo di calcolo della perdita per determinare l’importanza del campione. Dovresti implementare un metodo di perdita di sift che restituisca un tensore nx1, che contiene i valori di perdita di n campioni. Tipicamente, si specifica lo stesso metodo di perdita utilizzato dal tuo modello durante l’addestramento. Infine, includi un riferimento al tuo modello nell’oggetto SiftingDataloader, che viene utilizzato per valutare i campioni prima che vengano inclusi nell’addestramento. Vedi il seguente codice:

from smart_sifting.sift_config.sift_configs import RelativeProbabilisticSiftConfig, LossConfig, SiftingBaseConfig## Definizione della perdita di siftclass SiftBertLoss(Loss):    # Dovresti aggiungere la seguente funzione di inizializzazione     # per calcolare la perdita per campione, non per batch.    def __init__(self):        self.celoss = torch.nn.CrossEntropyLoss(reduction='none')    def loss(            self,            model: torch.nn.Module,            transformed_batch: SiftingBatch,            original_batch: Any = None,    ) -> torch.Tensor:            device = next(model.parameters()).device        batch = [t.to(device) for t in original_batch]        # calcolo della perdita        outputs = model(batch)        return self.celoss(outputs.logits, batch[2])........train_dataloader =  SiftingDataloader(    sift_config = sift_config,    orig_dataloader=DataLoader(self.train, self.batch_size, shuffle=True),    loss_impl=SiftBertLoss(),    model=self.model)

Il seguente codice mostra un esempio completo di abilitazione del sift intelligente con un lavoro di addestramento BERT esistente:

from smart_sifting.dataloader.sift_dataloader import SiftingDataloaderfrom smart_sifting.loss.abstract_sift_loss_module import Lossfrom smart_sifting.sift_config.sift_configs import RelativeProbabilisticSiftConfig, LossConfig, SiftingBaseConfig.........## Definizione della perdita di siftclass SiftBertLoss(Loss):    # Dovresti aggiungere la seguente funzione di inizializzazione     # per calcolare la perdita per campione, non per batch.    def __init__(self):        self.celoss = torch.nn.CrossEntropyLoss(reduction='none')    def loss(            self,            model: torch.nn.Module,            transformed_batch: SiftingBatch,            original_batch: Any = None,    ) -> torch.Tensor:            device = next(model.parameters()).device        batch = [t.to(device) for t in original_batch]        # calcolo della perdita        outputs = model(batch)        return self.celoss(outputs.logits, batch[2])              .... .... ....  sift_config = RelativeProbabilisticSiftConfig(    beta_value=3,    loss_history_length=500,    loss_based_sift_config=LossConfig(        sift_config=SiftingBaseConfig(sift_delay=10)    ))train_dataloader =  SiftingDataloader(    sift_config = sift_config,    orig_dataloader=DataLoader(self.train, self.batch_size, shuffle=True),    loss_impl=SiftBertLoss(),    model=self.model)......# utilizza train_dataloader nella logica di addestramento restante.

Conclusione

In questo post, abbiamo esplorato l’anteprima pubblica del sift intelligente, una nuova funzionalità di SageMaker che può ridurre i costi di addestramento dei modelli di deep learning fino al 35%. Questa caratteristica migliora l’efficienza dei dati durante l’addestramento filtrando i campioni di dati meno informativi. Includendo solo i dati più impattanti per la convergenza del modello, è possibile ridurre significativamente il tempo e le spese di addestramento, mantenendo allo stesso tempo l’accuratezza. Inoltre, si integra senza soluzione di continuità nei processi esistenti senza richiedere modifiche ai dati o al flusso di addestramento.

Per approfondire il sift intelligente di SageMaker, esplorare come funziona e implementarlo con i carichi di lavoro di addestramento PyTorch, consultare la nostra documentazione e i quaderni di esempio e iniziare con questa nuova funzionalità.