Utilizzo di Keras e Tensorflow con GPU AMD

Blog

Utilizzo di Keras e Tensorflow con GPU AMD

AMD sta sviluppando una nuova piattaforma HPC, chiamata ROCm. La sua ambizione è quella di creare un ambiente comune, open-source, in grado di interfacciarsi sia con Nvidia (usando CUDA) che con GPU AMD ( ulteriori informazioni ).



Questo tutorial spiegherà come configurare un ambiente di rete neurale, utilizzando le GPU AMD in una o più configurazioni.

Lato software: potremo eseguire Tensorflow v1.12.0 come backend per Keras sopra il kernel ROCm, usando Docker.



Questo è il titolo dell'immagine

Per installare e distribuire ROCm sono necessarie particolari configurazioni hardware/software.



Requisiti hardware

La documentazione ufficiale (ROCm v2.1) suggerisce quanto segue soluzioni hardware .

CPU supportate

Le attuali CPU che supportano PCIe Gen3 + PCIe Atomics sono:

  • CPU AMD Ryzen;
  • Le CPU delle APU AMD Ryzen;
  • CPU AMD Ryzen Threadripper
  • CPU AMD EPYC;
  • Intel Xeon E7 v3 o CPU più recenti;
  • Intel Xeon E5 v3 o CPU più recenti;
  • Intel Xeon E3 v3 o CPU più recenti;
  • Intel Core i7 v4 (i7–4xxx), Core i5 v4 (i5–4xxx), Core i3 v4 (i3–4xxx) o CPU più recenti (ad es. famiglia Haswell o più recenti).
  • Alcuni sistemi Ivy Bridge-E

GPU supportate

ROCm supporta ufficialmente le GPU AMD che utilizzano i seguenti chip:

  • GPU GFX8
  • Chip Fiji, come su AMD Radeon R9 Fury X e Radeon Instinct MI8
  • Chip Polaris 10, come su AMD Radeon RX 480/580 e Radeon Instinct MI6
  • Chip Polaris 11, come su AMD Radeon RX 470/570 e Radeon Pro WX 4100
  • Chip Polaris 12, come su AMD Radeon RX 550 e Radeon RX 540
  • GPU GFX9
  • Chip Vega 10, come su AMD Radeon RX Vega 64 e Radeon Instinct MI25
  • Chip Vega 7nm (Radeon Instinct MI50, Radeon VII)

Requisiti software

Lato software, l'attuale versione di ROCm (v2.1), è supportata solo nei sistemi basati su Linux.

La piattaforma ROCm 2.1.x supporta i seguenti sistemi operativi:

Ubuntu 16.04.x ​​e 18.04.x ​​(versione 16.04.3 e successive o kernel 4.13 e successive)

CentOS 7.4, 7.5 e 7.6 (utilizzando il supporto runtime devtoolset-7)

RHEL 7.4, 7.5 e 7.6 (utilizzando il supporto runtime devtoolset-7)

Configurazione di prova

La seguente configurazione hardware/software è stata utilizzata, dall'autore, per testare e convalidare l'ambiente:

HARDWARE

  • CPU: Intel Xeon E5–2630L
  • RAM: 2 x 8 GB
  • Scheda madre: MSI X99A Krait Edition
  • GPU: 2 x RX480 da 8 GB + 1 x RX580 da 4 GB
  • SSD: Samsung 850 Evo (256 GB)
  • HDD: WDC 1 TB

SOFTWARE

  • Sistema operativo: Ubuntu 18.04 LTS

Installazione ROCm

Per far funzionare tutto correttamente, si consiglia di avviare il processo di installazione, all'interno di un sistema operativo appena installato. Il seguenti passaggi si riferiscono al sistema operativo Ubuntu 18.04 LTS, per altri sistemi operativi fare riferimento a documentazione ufficiale .

Il primo passo è installare il kernel ROCm e le dipendenze:

Aggiorna il tuo sistema

Apri un nuovo terminale |_+_|

CTRL + ALT + T

Aggiungi il repository apt di ROCm

Per scaricare e installare lo stack ROCm è necessario aggiungere i relativi repository:

sudo apt update sudo apt dist-upgrade sudo apt install libnuma-dev sudo reboot

Installa ROCm

Ora è necessario aggiornare l'elenco dei repository apt e installare |_+_| meta-pacchetto:

wget -qO - http://repo.radeon.com/rocm/apt/debian/rocm.gpg.key | sudo apt-key add - echo 'deb [arch=amd64] http://repo.radeon.com/rocm/apt/debian/ xenial main' | sudo tee /etc/apt/sources.list.d/rocm.list

Imposta i permessi

La documentazione ufficiale suggerisce di creare un nuovo |_+_| gruppo per avere accesso alle risorse GPU, utilizzando l'utente corrente.

Innanzitutto, controlla i gruppi nel tuo sistema, emettendo:

rocm-dkms

Quindi aggiungiti al gruppo di video:

sudo apt update sudo apt install rocm-dkms

Potresti voler assicurarti che tutti gli utenti futuri che aggiungi al tuo sistema vengano inseriti nel gruppo video per impostazione predefinita. Per farlo, puoi eseguire i seguenti comandi:

video

Quindi riavviare il sistema:

groups

Test dello stack ROCm

Si suggerisce ora di testare l'installazione di ROCm emettendo i seguenti comandi.

Apri un nuovo terminale |_+_| , impartisci i seguenti comandi:

sudo usermod -a -G video $LOGNAME

l'output dovrebbe essere il seguente: collegamento

Quindi ricontrolla l'emissione:

echo 'ADD_EXTRA_GROUPS=1' | sudo tee -a /etc/adduser.conf echo 'EXTRA_GROUPS=video' | sudo tee -a /etc/adduser.conf

L'output dovrebbe essere simile a questo: collegamento

La documentazione ufficiale suggerisce infine di aggiungere i binari ROCm a PATH:

reboot

Congratulazioni! ROCm è installato correttamente nel tuo sistema e il comando:

CTRL + ALT + T

dovrebbe visualizzare le informazioni e le statistiche sull'hardware:

Questo è il titolo dell'immagine
output del comando rocm-smi

Docker Tensorflow

Il metodo più rapido e affidabile per far funzionare il backend ROCm + Tensorflow consiste nell'utilizzare l'immagine docker fornita dagli sviluppatori AMD.

Installa Docker CE

Innanzitutto, è necessario installare Docker. Per farlo, segui le istruzioni per i sistemi Ubuntu:

Ottieni Docker Engine

Consiglio : Per evitare di inserire |_+_| invece di |_+_| è utile fornire l'accesso agli utenti non root: Gestisci Docker come utente non root .

Tira l'immagine ROCm Tensorflow

È ora di tirare il Finestra mobile Tensorflow fornito dagli sviluppatori AMD.

Apri un nuovo terminale |_+_| ed emettere:

/opt/rocm/bin/rocminfo

dopo pochi minuti, l'immagine sarà installata nel tuo sistema, pronta per l'uso.

Crea uno spazio persistente

A causa della natura effimera dei contenitori Docker, una volta chiusa una sessione docker, tutte le modifiche e i file archiviati verranno eliminati con il contenitore.

Per questo motivo è utile creare uno spazio persistente nell'unità fisica per l'archiviazione di file e notebook Jupyter. Il metodo più semplice consiste nel creare una cartella da inizializzare con un contenitore docker. Per farlo emettere il comando:

/opt/rocm/opencl/bin/x86_64/clinfo

Questo comando creerà una cartella denominata |_+_| utile per archiviare e rivedere i dati creati all'interno della finestra mobile.

Avvio di Docker

Ora, esegui l'immagine in una nuova sessione del contenitore. Invia semplicemente il seguente comando:

echo 'export PATH=$PATH:/opt/rocm/bin:/opt/rocm/profiler/bin:/opt/rocm/opencl/bin/x86_64' | sudo tee -a /etc/profile.d/rocm.sh

La finestra mobile è in esecuzione nella directory |_+_| e dovresti vedere qualcosa di simile a:

Questo è il titolo dell'immagine

significa che ora stai operando all'interno del sistema virtuale Tensorflow-ROCm.

Installazione di Jupyter

Jupyter è uno strumento molto utile, per lo sviluppo, il debug e il test di reti neurali. Sfortunatamente, non è attualmente installato, come impostazione predefinita, sull'immagine Tensorflow-ROCm, Docker, pubblicata dal team ROCm. È quindi necessario installare manualmente Jupyter.

Per fare ciò, all'interno del prompt del sistema virtuale Tensorflow-ROCm,

1. Emettere il seguente comando:

rocm-smi

Installerà il pacchetto Jupyter nel sistema virtuale. Lascia aperto questo terminale.

2. Apri un nuovo terminale |_+_| .

Trova il |_+_| impartendo il comando:

sudo docker

Dovrebbe apparire una tabella simile alla seguente:

Questo è il titolo dell'immagine
ID contenitore a sinistra

La prima colonna rappresenta il ID contenitore del contenitore eseguito. Copialo perché è necessario per il passaggio successivo.

3. È ora di commettere , per scrivere permanentemente le modifiche dell'immagine. Dallo stesso terminale eseguire:

docker

dove |_+_| value è un nome arbitrario, ad esempio |_+_| .

4. Per ricontrollare che l'immagine sia stata generata correttamente, dallo stesso terminale, impartire il comando:

CTRL + ALT + T

che dovrebbe risultare genera una tabella simile alla seguente:

Questo è il titolo dell'immagine

È importante notare che faremo riferimento a questa immagine appena generata per il resto del tutorial.

Il nuovo |_+_| comando, da usare, sarà simile a:

docker pull rocm/tensorflow

dove ancora una volta, |_+_| il valore è arbitrario, ad esempio |_+_| .

Entrare nell'ambiente del notebook Jupyter

Possiamo finalmente entrare nell'ambiente Jupyter. Al suo interno creeremo la prima rete neurale utilizzando Tensorflow v1.12 come backend e Keras come frontend.

Pulizia

Per prima cosa chiudi tutti i contenitori Docker in esecuzione in precedenza.

  1. Controlla i contenitori già aperti:
mkdir /home/$LOGNAME/tf_docker_share

2. Chiudere tutti i contenitori/contenitori Docker:

tf_docker_share

3. Chiudere tutti i terminali già aperti.

Esecuzione di Jupyter

Apriamo un nuovo terminale |_+_| :

  1. Esegui un nuovo contenitore Docker (il tag |_+_| verrà utilizzato come predefinito):
docker run -i -t --network=host --device=/dev/kfd --device=/dev/dri --group-add video --cap-add=SYS_PTRACE --security-opt seccomp=unconfined --workdir=/tf_docker_share -v $HOME/tf_docker_share:/tf_docker_share rocm/tensorflow:latest /bin/bash

Dovresti essere connesso al prompt del contenitore docker Tensorflow-ROCm.

Questo è il titolo dell'immagine

Accesso al container docker

2. Eseguire il notebook Jupyter:

/tf_docker_share

dovrebbe apparire una nuova finestra del browser, simile alla seguente:

Questo è il titolo dell'immagine
Directory principale di Jupyter

Se la nuova scheda non compare automaticamente, sul browser, torna al terminale dove |_+_| comando è stato eseguito. In basso, c'è un collegamento da seguire (premi: |_+_| su di esso), quindi una nuova scheda nel tuo browser ti reindirizza alla directory principale di Jupyter.

Questo è il titolo dell'immagine
Tipico output di notebook Jupyter. Il collegamento di esempio è in basso

Addestra una rete neurale con Keras

Nell'ultima sezione, di questo tutorial, addestreremo una semplice rete neurale sul Set di dati MNIST . Per prima cosa costruiremo una rete neurale completamente connessa.

Rete neurale completamente connessa

Creiamo un nuovo taccuino, selezionando Python3 dal menu in alto a destra nella directory principale di Jupyter.

Il menu in alto a destra in Jupyter explorer

Il menu in alto a destra in Jupyter explorer

Un nuovo taccuino Jupiter dovrebbe apparire in una nuova scheda del browser. Rinominalo in|_+_| cliccando |_+_| nell'angolo in alto a sinistra della finestra.

Questo è il titolo dell'immagine

Rinominare il taccuino

Controlliamo il backend di Tensorflow. Sulla prima cella inserire:

pip3 install jupyter

quindi premere |_+_| eseguire. L'output dovrebbe essere simile a:

Questo è il titolo dell'immagine
Tensorflow V1.12.0

Stiamo utilizzando Tensorflow v1.12.0.

Importiamo alcune funzioni utili, da utilizzare in seguito:

CTRL + ALT + T

Impostiamo la dimensione del batch, le epoche e il numero di classi.

CONTAINER ID

Ora scaricheremo e preprocesseremo gli input, caricandoli nella memoria di sistema.

docker ps

È il momento di definire l'architettura della rete neurale:

docker commit rocm/tensorflow:

Useremo una rete molto semplice, a due strati completamente connessa, con 512 neuroni per strato. È inclusa anche una probabilità di caduta del 20% sulle connessioni neuronali, al fine di prevenire il sovradattamento.

Stampiamo alcune informazioni sull'architettura di rete:

tag

Questo è il titolo dell'immagine
Architettura di rete

Nonostante la semplicità del problema, abbiamo un numero considerevole di parametri da addestrare (quasi ~700.000), ciò significa anche un notevole consumo di potenza computazionale. Le reti neurali convoluzionali risolveranno il problema riducendo la complessità computazionale.

Ora compila il modello:

personal

e inizia ad allenarti:

docker images

Questo è il titolo dell'immagine
Processo di formazione

ufc 260 live streaming reddit

La rete neurale è stata addestrata su un singolo RX 480 con un rispettabile 47us/step. Per fare un confronto, una Nvidia Tesla K80 raggiunge i 43 us/step ma è 10 volte più costosa.

Formazione multi-GPU

Come ulteriore passaggio, se il tuo sistema dispone di più GPU, è possibile sfruttare le funzionalità di Keras, al fine di ridurre i tempi di training, suddividendo il batch tra diverse GPU.

Per fare ciò, prima è necessario specificare il numero di GPU da utilizzare per l'addestramento, dichiarando una variabile ambientale (metti il ​​seguente comando su una singola cella ed esegui):

docker run

I numeri da 0 a … definiscono quale GPU utilizzare per l'addestramento. Nel caso in cui desideri disabilitare semplicemente l'accelerazione GPU:

docker run -i -t --network=host --device=/dev/kfd --device=/dev/dri --group-add video --cap-add=SYS_PTRACE --security-opt seccomp=unconfined --workdir=/tf_docker_share -v $HOME/tf_docker_share:/tf_docker_share rocm/tensorflow: /bin/bash

È inoltre necessario aggiungere |_+_| funzione.

Ad esempio, se hai 3 GPU, il codice precedente lo farà modificare di conseguenza .

Conclusioni

Questo conclude questo tutorial. Il prossimo passo sarà testare una rete neurale convoluzionale sul set di dati MNIST. Confronto delle prestazioni sia in singola che in multi-GPU.

Ciò che è rilevante qui è che le GPU AMD funzionano abbastanza bene sotto carico computazionale a una frazione del prezzo. Il mercato delle GPU sta cambiando rapidamente e ROCm ha fornito a ricercatori, ingegneri e startup strumenti open source molto potenti da adottare, riducendo i costi iniziali delle apparecchiature hardware.

#tensorflow #keras