Il moderno machine learning applicato al trading quantitativo e sistematico tramite il deep learning necessita di un ambiente di ricerca all’avanguarida. In questa lezione descriviamo l’installazione di TensorFlow, che rappresenta la base per tutte le nostre ricerche future.
Installazione di TensorFlow
Per sviluppare un ambiente di ricerca avanzato nel trading quantitativo con il machine learning, adottiamo un framework solido che ci consente di astrarre le specifiche del modello dalla sua implementazione. A tal fine utilizziamo TensorFlow, una libreria creata e distribuita da Google. Le prime versioni di TensorFlow offrivano già questa astrazione, evitandoci di scrivere modelli ottimizzati in C, C++ o FORTRAN, oppure utilizzando direttamente il modello di programmazione GPU CUDA fornito da Nvidia.
Da allora abbiamo assistito a ulteriori miglioramenti. Keras, una nota libreria per la definizione di modelli di deep learning, è stata integrata direttamente in TensorFlow attraverso l’API tf.keras, una comoda interfaccia ad alto livello. Questo ci permette di definire i modelli in modo ancora più semplice all’interno dell’ambiente TensorFlow.
Possiamo installare TensorFlow in molti modi, in base al sistema operativo e all’hardware disponibili. Ad esempio, possiamo eseguire codice TensorFlow tramite immagini preconfigurate su macchine virtuali con GPU ospitate nel cloud.
Tuttavia, in alcuni casi preferiamo addestrare ed eseguire modelli di deep learning direttamente in locale su una workstation personalizzata. In questa lezione spieghiamo come installare TensorFlow su una macchina con sistema operativo Ubuntu 18.04.
Ora esploriamo i prerequisiti Python necessari, i passaggi per completare l’installazione di TensorFlow con supporto CPU e le istruzioni per configurare CUDA e utilizzare la GPU.
Prerequisiti dell’ambiente Python
Dobbiamo disporre di un ambiente virtuale Python3 funzionante per eseguire TensorFlow. Per semplificare la configurazione dell’ambiente di ricerca, consigliamo di scaricare l’ultima distribuzione Anaconda, Individual. Al momento della redazione di questa lezione, la versione più recente include Python 3.7.
Possiamo scaricare lo script di installazione Linux per Python 3.7 da questo link. Per maggiori dettagli sull’installazione in ambiente Linux, facciamo riferimento alla documentazione ufficiale di Anaconda.
Una volta completata l’installazione di Anaconda, creiamo un ambiente virtuale separato per isolare l’installazione di TensorFlow. In questa lezione chiamiamo l’ambiente virtuale tf. Per configurarlo, digitiamo il seguente comando nel terminale:
conda create -n tf
conda activate tf
In questo modo creiamo un nuovo ambiente virtuale Conda chiamato tfe lo attiviamo.
Installazione di TensorFlow per l’utilizzo della CPU
Se non è disponibile una GPU compatibile con Nvidia CUDA, è possibile installare TensorFlow per essere usato solo con una CPU. L’allenamento sarà significativamente più lento su una CPU rispetto a una GPU. Nonostante ciò un’installazione sulla CPU può rivelarsi utile per i modelli più piccoli e per scopi di studio da auto-didatta
Per installare TensorFlow è sufficiente digitare quanto segue in un terminale con un ambiente Conda attivato:
pip install tensorflow
Con questo comando installiamo TensorFlow e tutte le dipendenze necessarie. Una volta completato, proseguiamo con il paragrafo Convalida dell’installazione di TensorFlow.
Installazione di TensorFlow per l’utilizzo della GPU
Installare TensorFlow su una GPU Nvidia richiede un certo livello di esperienza. Dobbiamo spesso utilizzare comandi da terminale per individuare e risolvere eventuali problemi.
In DataTrader abbiamo già completato questa procedura su diverse GPU Nvidia, partendo da vecchi modelli GeForce GTX 780 Ti fino ad arrivare alla più recente GeForce GTX 1080 Ti.
Durante il processo abbiamo affrontato alcune difficoltà comuni, soprattutto legate all’avvio sicuro UEFI (vedi sotto) e alla configurazione del driver Nvidia. Oggi però possiamo seguire una procedura molto più semplice rispetto al passato.
Le GPU Nvidia di fascia consumer più aggiornate al momento della scrittura di questa lezione appartengono alla serie 20xx RTX. Le consigliamo perché offrono ottime prestazioni con i moderni modelli di deep learning e mantengono un costo accessibile.
Panoramica
Per installare TensorFlow 2.2 con supporto CUDA, iniziamo verificando la compatibilità dell’hardware e del software sulla nostra workstation.
Dopo aver completato i controlli, seguiamo le istruzioni ufficiali per l’installazione di TensorFlow con supporto GPU. Procediamo quindi installando CUDA, cuDNN, TensorRT e il driver Nvidia più adatto.
Quando abbiamo installato tutti i pacchetti, testiamo il corretto funzionamento di TensorFlow con la GPU importando la libreria ed eseguendo un’operazione base sui tensori.
Avvio UEFI sicuro
Durante l’installazione dei driver Nvidia su Linux incontriamo spesso un ostacolo causato da un’impostazione della scheda madre chiamata Secure UEFI Boot. Per completare l’installazione del driver con successo, dobbiamo disattivarla sulla maggior parte delle schede madri.
Ogni scheda madre ha un metodo diverso per questa operazione, quindi non possiamo fornire istruzioni universali per tutti i sistemi.
In generale, accediamo al BIOS all’avvio premendo il tasto Canc o F10. Una volta dentro, navighiamo fino alle impostazioni di avvio. Per disabilitare Secure UEFI Boot, in alcuni casi eseguiamo un backup e rimuoviamo determinate chiavi, mentre in altri casi modifichiamo un semplice parametro booleano.
Se non disattiviamo questa funzione, incontriamo quasi certamente problemi dopo l’installazione del driver Nvidia. Questi problemi possono impedire l’avvio corretto di Ubuntu, rendendo difficile caricare l’interfaccia grafica!
Verifiche di installazione pre-CUDA
Prima di installare CUDA, conviene eseguire alcune verifiche per prevenire possibili problemi:
- Verifichiamo che la nostra GPU sia compatibile con CUDA
- Verifichiamo che la versione di Ubuntu sia supportata
- Verifichiamo che GNU Compiler Collection (gcc) sia installato
- Verifichiamo la disponibilità dei pacchetti di sviluppo e delle intestazioni del kernel
- Verifichiamo se sono presenti driver Nvidia preinstallati che potrebbero causare conflitti con CUDA
Verificare che la GPU sia compatibile con CUDA
Il comando lspci mostra dettagli sui bus PCI e sui dispositivi della workstation. Usiamolo per identificare il modello di GPU Nvidia disponibile. Digitiamo il seguente comando nel terminale:
lspci | grep -i nvidia
Dovremmo ottenere un output simile al seguente:
01:00.0 VGA compatible controller: NVIDIA Corporation GK110B [GeForce GTX 780 Ti] (rev a1)
01:00.1 Audio device: NVIDIA Corporation GK110 HDMI Audio (rev a1)
02:00.0 VGA compatible controller: NVIDIA Corporation GK110B [GeForce GTX 780 Ti] (rev a1)
02:00.1 Audio device: NVIDIA Corporation GK110 HDMI Audio (rev a1)
Vediamo che nella workstation sono installate due schede GeForce GTX 780 Ti. Nvidia fornisce un elenco di GPU compatibili con CUDA qui . Controlla la tua scheda rispetto a questo elenco per assicurarti che fornisca la capacità CUDA necessaria.
Verificare che la versione di Ubuntu sia supportata
Il comando unix name uname restituisce il nome, la versione e ulteriori dettagli sulla macchina e sul sistema operativo. Digitiamo quanto segue in un terminale per determinare l’architettura dell’hardware della macchina:
uname -m
Dovremmo ottenere il seguente output:
x86_64
Ciò mostra che è disponibile una CPU compatibile con x86 a 64 bit.
Per determinare la versione di Ubuntu installata, digitiamo quanto segue:
cat /etc/lsb-release
Otteniamo un output simile al seguente, supponendo che sia installato Ubuntu 18.04 LTS :
DISTRIB_ID=Ubuntu
DISTRIB_RELEASE=18.04
DISTRIB_CODENAME=bionic
DISTRIB_DESCRIPTION="Ubuntu 18.04.4 LTS"
Ciò conferma la compatibilità dell’hardware della macchina e del sistema operativo.
Verificare che gcc sia installato
Per installare CUDA è necessario avere installato un compilatore C++. A tale scopo Ubuntu fornisce la GNU Compiler Collection (gcc). Se non è stato installato in precedenza, di solito è necessario eseguire il seguente comando di installazione:
sudo apt-get install build-essential
Possiamo verificare la versione di gcc con il seguente comando:
gcc --version
L’output è simile al seguente:
gcc (Ubuntu 7.5.0-3ubuntu1~18.04) 7.5.0
Copyright (C) 2017 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
In questo caso la versione di gcc è 7.5.0, che è sufficiente ai fini dell’installazione di CUDA.
Controllare i pacchetti di sviluppo e le intestazioni appropriati
Per determinare quale kernel Linux è disponibile, digitiamo quanto segue in un terminale:
uname -r
L’output è simile al seguente:
5.3.0-62-generic
Dopo aver determinato il nome del kernel, dobbiamo installare gli specifici headers del kernel e i pacchetti di sviluppo tramite il comando seguente. Assicuriamoci di sostituire la versione del kernel con l’output di cui sopra:
sudo apt-get install linux-headers-5.3.0-62-generic
L’output (estratto) è simile al seguente:
Reading package lists... Done
Building dependency tree
Reading state information... Done
linux-headers-5.3.0-62-generic is already the newest version (5.3.0-62.56~18.04.1).
linux-headers-5.3.0-62-generic set to manually installed.
The following packages were automatically installed and are no longer required:
..
..
Use 'sudo apt autoremove' to remove them.
0 to upgrade, 0 to newly install, 0 to remove and 78 not to upgrade.
Quanto sopra conferma che gli headers erano già installate sulla workstation.
Controllare gli attuali driver Nvidia
Se il driver Nvidia è già installato, è possibile determinare la versione digitando quanto segue nel terminale:
nvidia-smi
L’output è simile al seguente:
Wed Jul 15 14:27:36 2020
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 440.100 Driver Version: 440.100 CUDA Version: 10.2 |
|-------------------------------+----------------------+----------------------+
| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |
| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |
|===============================+======================+======================|
| 0 GeForce GTX 780 Ti Off | 00000000:01:00.0 N/A | N/A |
| 37% 55C P2 N/A / N/A | 1244MiB / 3018MiB | N/A Default |
+-------------------------------+----------------------+----------------------+
| 1 GeForce GTX 780 Ti Off | 00000000:02:00.0 N/A | N/A |
| 17% 36C P8 N/A / N/A | 1MiB / 3022MiB | N/A Default |
+-------------------------------+----------------------+----------------------+
+-----------------------------------------------------------------------------+
| Processes: GPU Memory |
| GPU PID Type Process name Usage |
|=============================================================================|
| 0 Not Supported |
| 1 Not Supported |
+-----------------------------------------------------------------------------+
In questo caso il driver Nvidia installato è alla versione 440.100.
Siamo ora pronti per procedere con l’installazione di CUDA, cuDNN e TensorRT.
Installazione di CUDA Framework
I seguenti passaggi sono tratti dalla documentazione di installazione della GPU TensorFlow e sono stati testati su una workstation locale.
Immettiamo i seguenti comandi nel terminale per installare CUDA 10.1 (non 10.2) sul sistema:
wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64/cuda-repo-ubuntu1804_10.1.243-1_amd64.deb
sudo apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64/7fa2af80.pub
sudo dpkg -i cuda-repo-ubuntu1804_10.1.243-1_amd64.deb
sudo apt-get update
wget http://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64/nvidia-machine-learning-repo-ubuntu1804_1.0.0-1_amd64.deb
sudo apt install ./nvidia-machine-learning-repo-ubuntu1804_1.0.0-1_amd64.deb
sudo apt-get update
Con i comandi precedenti scarichiamo il repository CUDA per Ubuntu 18.04 come pacchetto Debian. Otteniamo quindi le chiavi. Usiamo il comando dpkg per installare il pacchetto CUDA di Debian. Aggiorniamo quindi i repository apt e scarichiamo ed installiamo gli altri repository (nvidia-machine-learning-repo-***). Infine aggiorniamo ancora una volta i repository apt.
A questo punto possiamo installare il driver Nvidia alla versione 450:
sudo apt-get install --no-install-recommends nvidia-driver-450
Una volta completato, dobbiamo riavviare il sistema per assicurarci che il driver Nvidia sia stato caricato correttamente. Dopo il riavvio possiamo usare nvidia-smi per garantire che le GPU siano ancora visibili dal sistema:
nvidia-smi
L’output è simile al seguente:
Wed Jul 15 14:49:41 2020
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 450.51.05 Driver Version: 450.51.05 CUDA Version: 11.0 |
|-------------------------------+----------------------+----------------------+
| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |
| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |
| | | MIG M. |
|===============================+======================+======================|
| 0 GeForce GTX 780 Ti On | 00000000:01:00.0 N/A | N/A |
| 37% 57C P0 N/A / N/A | 1057MiB / 3018MiB | N/A Default |
| | | N/A |
+-------------------------------+----------------------+----------------------+
| 1 GeForce GTX 780 Ti On | 00000000:02:00.0 N/A | N/A |
| 17% 37C P8 N/A / N/A | 3MiB / 3022MiB | N/A Default |
| | | N/A |
+-------------------------------+----------------------+----------------------+
+-----------------------------------------------------------------------------+
| Processes: |
| GPU GI CI PID Type Process name GPU Memory |
| ID ID Usage |
|=============================================================================|
| No running processes found |
+-----------------------------------------------------------------------------+
A questo punto dobbiamo scaricare le librerie di runtime CUDA 10.1 e cuDNN 7.6. La dimensione totale del file dei pacchetti è di circa 5 GB. A seconda della connessione questo richiederà probabilmente del tempo sia per il download che per l’installazione. Digitiamo quanto segue per installare i pacchetti:
sudo apt-get install --no-install-recommends cuda-10-1 libcudnn7=7.6.4.38-1+cuda10.1 libcudnn7-dev=7.6.4.38-1+cuda10.1
Facoltativamente, possiamo installare TensorRT, progettato per “migliorare la latenza e il throughput per l’inferenza su alcuni modelli”, come menzionato nella documentazione della GPU TensorFlow. Per eseguire questa operazione, digitiamo quanto segue in un terminale:
sudo apt-get install -y --no-install-recommends libnvinfer6=6.0.1-1+cuda10.1 libnvinfer-dev=6.0.1-1+cuda10.1 libnvinfer-plugin6=6.0.1-1+cuda10.1
Ora abbiamo installato tutte le librerie e i pacchetti necessari.
Allo stesso modo precedente, possiamo ora installare TensorFlow per la CPU. Assicuriamoci che l’ambiente virtuale Conda sia attivato e digitiamo quanto segue per installare TensorFlow:
pip install tensorflow
Il passaggio finale consiste nel verificare che l’installazione sia andata a buon fine e che TensorFlow venga eseguito sulla GPU.
Convalida dell’installazione di TensorFlow
Per convalidare l’installazione di TensorFlow su una GPU, apriamo una console Python interattiva digitando quanto segue nel terminale:
python
Eseguiamo i seguenti comandi nella shell Python per importare TensorFlow e verificare che sia compilato su CUDA:
import tensorflow as tf
tf.test.is_built_with_cuda()
In caso di successo, l’output dovrebbe semplicemente indicare True:
Python 3.6.9 (default, Apr 18 2020, 01:56:04)
[GCC 8.4.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import tensorflow as tf
>>> tf.test.is_built_with_cuda()
True
Se stiamo utilizzando la versione CPU di TensorFlow, questo comando restituisce False.
Per determinare quali GPU sono state rilevate da TensorFlow, possiamo eseguire il seguente comando in una console Python dopo aver importato TensorFlow:
tf.config.list_physical_devices('GPU')
L’output (estratto) è simile al seguente:
[PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU'), PhysicalDevice(name='/physical_device:GPU:1', device_type='GPU')]
In questo caso sono state rilevate entrambe le due GPU 780 Ti, citate in precedenza nell’articolo.
Come verifica finale (sia per versione CPU che GPU) possiamo effettuare un calcolo base di TensorFlow direttamente dalla riga di comando. Questo significa che quanto segue non viene eseguito all’interno di una console Python. Invece il comando viene eseguito in un normale terminale Ubuntu:
python -c "import tensorflow as tf;print(tf.reduce_sum(tf.random.normal([1000, 1000])))"
L’output (estratto) è simile al seguente:
..
..
..
2020-07-15 15:20:15.379624: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:981] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2020-07-15 15:20:15.379944: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:981] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2020-07-15 15:20:15.380279: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:981] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2020-07-15 15:20:15.380570: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1247] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 1703 MB memory) -> physical GPU (device: 0, name: GeForce GTX 780 Ti, pci bus id: 0000:01:00.0, compute capability: 3.5)
2020-07-15 15:20:15.380931: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:981] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2020-07-15 15:20:15.381252: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1247] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:1 with 2652 MB memory) -> physical GPU (device: 1, name: GeForce GTX 780 Ti, pci bus id: 0000:02:00.0, compute capability: 3.5)
tf.Tensor(554.52527, shape=(), dtype=float32)
L’ultima riga contiene il risultato del calcolo reduce_sum. Poicheé una distribuzione normale casuale viene campionata all’interno di questo calcolo, è possibile che il tensore risultante abbia un valore diverso rispetto a quello precedente.
Questo verifica che TensorFlow sia stato installato correttamente sulla GPU.
Conclusione
Abbiamo descritto i passi e le modalità per l’installazione di TensorFlow 2.2 con Ubuntu 18.04 e una GPU Nvidia. Possiamo ora iniziare a creare alcune architetture di machine learning per risolvere semplici problemi di classificazione. Infine possiamo costruire architetture di reti neurali profonde implementate con TensorFlow.