Simple Science

Scienza all'avanguardia spiegata semplicemente

# Informatica# Informatica distribuita, parallela e in cluster# Intelligenza artificiale

Un Nuovo Approccio al Deep Learning e alla Programmazione HPC

Presentiamo un framework per semplificare lo sviluppo di kernel DL e HPC per vari sistemi CPU.

― 5 leggere min


Framework di DeepFramework di DeepLearning semplificatoefficiente per applicazioni DL e HPC.Una soluzione di programmazione
Indice

Negli ultimi anni, i campi del Deep Learning (DL) e del High Performance Computing (HPC) hanno fatto grandi progressi. Tuttavia, i metodi di programmazione di questi sistemi non si sono aggiornati di pari passo. Molti sviluppatori si affidano ancora a vecchie librerie progettate per piattaforme specifiche. Questa dipendenza può portare a problemi, poiché queste librerie potrebbero funzionare bene solo per alcuni compiti, mentre potrebbero essere scarse in altri. Questo articolo presenta un nuovo framework che punta a risolvere questi problemi, rendendo più facile per i programmatori creare kernel DL e HPC efficienti e flessibili per i moderni sistemi CPU.

Comprendere il Problema

C'è stata una convergenza tra deep learning e high-performance computing, il che significa che condividono molte attività computazionali comuni. Tuttavia, i metodi di programmazione usati in questi due settori spesso rimangono indietro. Molti programmatori sono bloccati nell'uso di librerie rigide e specifiche per il fornitore che offrono ottime prestazioni su piattaforme specifiche. Questo spesso porta a un codice che non può essere facilmente spostato o adattato a diversi compiti o sistemi. Di conseguenza, lo sviluppo di applicazioni può diventare costoso e dispendioso in termini di tempo.

Queste librerie specifiche per il fornitore possono funzionare male in molti casi, risultando in un'incapacità di creare codice flessibile o di uso generale. Inoltre, man mano che l'architettura delle CPU continua a progredire, queste librerie spesso non riescono a sfruttare pienamente le nuove funzionalità. Questo rende difficile sviluppare applicazioni efficienti che possano funzionare bene su vari design di CPU.

Presentazione del Nuovo Framework

Il nuovo framework cerca di migliorare il modo in cui si sviluppa il codice DL e HPC. Si concentra su due passaggi principali:

  1. Utilizzo dei Tensor Processing Primitives (TPP): I TPP sono un insieme di operazioni tensoriali 2D semplificate che possono essere usate per costruire compiti più complessi.
  2. Astrazioni di Loop ad Alto Livello: Questo passaggio consente ai programmatori di dichiarare loop logici in modo più semplice senza doversi immergere in dettagli complicati come l'ordinamento dei dati o l'ordine delle operazioni.

Spezzando lo sviluppo del kernel in questi due passaggi, il framework consente ai programmatori di concentrarsi sul quadro generale anziché perdersi nei dettagli del codice per diverse piattaforme.

I Vantaggi del Framework

Uno dei principali vantaggi di questo framework è che consente un codice più portatile. Poiché il nucleo dei calcoli è espresso utilizzando i TPP, il codice può essere adattato per diversi sistemi senza necessità di riscritture importanti. Questo significa che gli sviluppatori non devono ripartire da zero ogni volta che vogliono eseguire il proprio codice su un'architettura CPU diversa.

Inoltre, usare astrazioni ad alto livello per i loop rende più facile controllare come vengono eseguiti i compiti. I programmatori possono specificare le proprietà che vogliono per i loro loop senza dover scrivere manualmente codice complicato. Questo porta a un codice più chiaro e più manutentivo, rendendo più semplice l'adattamento in futuro.

Come Funziona il Framework

Il framework funziona tramite uno strumento chiamato PARLOOPER, che semplifica la creazione di loop attorno ai TPP.

Passo 1: Dichiarare i TPP

Il primo passo nell'usare PARLOOPER è definire il nucleo computazionale di un kernel utilizzando i TPP. Questo significa che i programmatori esprimono i loro calcoli fondamentali in termini delle operazioni di base offerte dalla libreria TPP. Questo può essere fatto in modo semplice, rendendo più facile per gli sviluppatori concentrarsi sulla logica reale del loro codice.

Passo 2: Specificare i Loop con PARLOOPER

Una volta definiti i calcoli fondamentali, i programmatori possono quindi dichiarare i loop logici che circonderanno i TPP. Questo passaggio è reso più semplice grazie a PARLOOPER, che consente agli utenti di specificare i vincoli e le proprietà dei loro loop senza dover scrivere manualmente tutta la struttura.

Durante l'esecuzione, gli utenti possono fornire un singolo parametro che dice a PARLOOPER come impostare i loop. Questo consente ai loop di adattarsi in base alle esigenze del calcolo specifico e alle capacità dell'hardware sottostante. Questo processo in due fasi offre grande flessibilità pur mantenendo elevate prestazioni.

Prestazioni e Flessibilità

L'efficienza del nuovo framework è stata testata su vari sistemi CPU, dimostrando la sua capacità di superare soluzioni esistenti. Utilizzando i TPP insieme a PARLOOPER, gli sviluppatori possono raggiungere elevati livelli di prestazioni in una gamma di applicazioni.

Il framework non offre solo velocità; rende anche più facile adattarsi a nuove tecnologie man mano che diventano disponibili. Questo è fondamentale nel mondo frenetico della tecnologia, dove nuovi design e capacità delle CPU emergono costantemente. Avere la possibilità di scrivere codice flessibile con il minimo sforzo è un vantaggio significativo.

Applicazioni Pratiche

Questo framework è stato utilizzato per sviluppare diversi tipi di applicazioni, tra cui:

  1. Moltiplicazione di Matrici Generale (GEMM): Questa è un'operazione comune nel DL che comporta la moltiplicazione di due matrici. Il framework rende più facile implementare questa operazione in modo efficiente, indipendentemente dall'hardware specifico.

  2. Perceptroni Multi-Livello (MLP): Il framework consente la creazione di reti neurali complesse che possono sfruttare le ultime capacità hardware, semplificando il processo di programmazione.

  3. Reti Neurali Convoluzionali (CNN): Queste sono ampiamente utilizzate nei compiti di elaborazione delle immagini, e il framework ha mostrato grande potenziale nel velocizzarne l'implementazione.

  4. Operazioni su Matrici Sparse: Il framework supporta anche operazioni avanzate che coinvolgono matrici sparse, riducendo i requisiti di memoria e migliorando le prestazioni in varie applicazioni.

Conclusione

La necessità di metodi di programmazione flessibili ed efficienti in DL e HPC è chiara. Il nuovo framework offre una soluzione proponendo un modo per sviluppare codice portatile che può adattarsi a una varietà di architetture CPU. Con il suo focus sui TPP e sulle astrazioni di loop ad alto livello, questo framework non solo semplifica il processo di sviluppo, ma migliora anche le prestazioni delle applicazioni.

Man mano che la tecnologia continua a progredire, questo approccio aiuterà gli sviluppatori a tenere il passo con le sfide emergenti e ad approfittare appieno del nuovo hardware. In generale, il framework rappresenta un passo avanti nel rendere la programmazione DL e HPC più accessibile ed efficiente per tutti gli sviluppatori.

Fonte originale

Titolo: Harnessing Deep Learning and HPC Kernels via High-Level Loop and Tensor Abstractions on CPU Architectures

Estratto: During the past decade, Deep Learning (DL) algorithms, programming systems and hardware have converged with the High Performance Computing (HPC) counterparts. Nevertheless, the programming methodology of DL and HPC systems is stagnant, relying on highly-optimized, yet platform-specific and inflexible vendor-optimized libraries. Such libraries provide close-to-peak performance on specific platforms, kernels and shapes thereof that vendors have dedicated optimizations efforts, while they underperform in the remaining use-cases, yielding non-portable codes with performance glass-jaws. This work introduces a framework to develop efficient, portable DL and HPC kernels for modern CPU architectures. We decompose the kernel development in two steps: 1) Expressing the computational core using Tensor Processing Primitives (TPPs): a compact, versatile set of 2D-tensor operators, 2) Expressing the logical loops around TPPs in a high-level, declarative fashion whereas the exact instantiation (ordering, tiling, parallelization) is determined via simple knobs. We demonstrate the efficacy of our approach using standalone kernels and end-to-end workloads that outperform state-of-the-art implementations on diverse CPU platforms.

Autori: Evangelos Georganas, Dhiraj Kalamkar, Kirill Voronin, Abhisek Kundu, Antonio Noack, Hans Pabst, Alexander Breuer, Alexander Heinecke

Ultimo aggiornamento: 2024-03-15 00:00:00

Lingua: English

URL di origine: https://arxiv.org/abs/2304.12576

Fonte PDF: https://arxiv.org/pdf/2304.12576

Licenza: https://creativecommons.org/licenses/by/4.0/

Modifiche: Questa sintesi è stata creata con l'assistenza di AI e potrebbe presentare delle imprecisioni. Per informazioni accurate, consultare i documenti originali collegati qui.

Si ringrazia arxiv per l'utilizzo della sua interoperabilità ad accesso aperto.

Altro dagli autori

Articoli simili