theanoIniziare con theano


Osservazioni

Theano è una libreria python che gestisce la definizione e la valutazione di espressioni simboliche su variabili tensoriali. Ha varie applicazioni, ma il più popolare è l'apprendimento profondo.

Installazione o configurazione

Istruzioni dettagliate su come installare o installare Theano.

Installazione di Theano e configurazione della GPU su Ubuntu 14.04

È possibile utilizzare le seguenti istruzioni per installare Theano e configurare la GPU (si presume che Ubuntu 14.04 sia installato di recente:

# Install Theano
sudo apt-get install python-numpy python-scipy python-dev python-pip python-nose g++ libopenblas-dev git
sudo pip install Theano

# Install Nvidia drivers, CUDA and CUDA toolkit, following some instructions from http://docs.nvidia.com/cuda/cuda-installation-guide-linux/index.html
wget http://developer.download.nvidia.com/compute/cuda/7.5/Prod/local_installers/cuda-repo-ubuntu1404-7-5-local_7.5-18_amd64.deb # Got the link at https://developer.nvidia.com/cuda-downloads
sudo dpkg -i cuda-repo-ubuntu1404-7-5-local_7.5-18_amd64.deb
sudo apt-get update
sudo apt-get install cuda

sudo reboot
 

A quel punto, l'esecuzione di nvidia-smi dovrebbe funzionare, ma l'esecuzione di nvcc non funzionerà.

# Execute in console, or (add in ~/.bash_profile then run "source ~/.bash_profile"):
export PATH=/usr/local/cuda-7.5/bin:$PATH
export LD_LIBRARY_PATH=/usr/local/cuda-7.5/lib64:$LD_LIBRARY_PATH
 

A quel punto, dovrebbero funzionare sia nvidia-smi che nvcc .

Per verificare se Theano è in grado di utilizzare la GPU:

Copia-incolla quanto segue in gpu_test.py :

# Start gpu_test.py
# From http://deeplearning.net/software/theano/tutorial/using_gpu.html#using-gpu
from theano import function, config, shared, sandbox
import theano.tensor as T
import numpy
import time

vlen = 10 * 30 * 768  # 10 x #cores x # threads per core
iters = 1000

rng = numpy.random.RandomState(22)
x = shared(numpy.asarray(rng.rand(vlen), config.floatX))
f = function([], T.exp(x))
print(f.maker.fgraph.toposort())
t0 = time.time()
for i in xrange(iters):
    r = f()
t1 = time.time()
print("Looping %d times took %f seconds" % (iters, t1 - t0))
print("Result is %s" % (r,))
if numpy.any([isinstance(x.op, T.Elemwise) for x in f.maker.fgraph.toposort()]):
    print('Used the cpu')
else:
    print('Used the gpu')
# End gpu_test.py
 

ed eseguilo:

THEANO_FLAGS='mode=FAST_RUN,device=gpu,floatX=float32' python gpu_test.py
 

che dovrebbe restituire:

f@f-Aurora-R4:~$ THEANO_FLAGS='mode=FAST_RUN,device=gpu,floatX=float32' python gpu_test.py
Using gpu device 0: GeForce GTX 690
[GpuElemwise{exp,no_inplace}(<CudaNdarrayType(float32, vector)>), HostFromGpu(GpuElemwise{exp,no_inplace}.0)]
Looping 1000 times took 0.658292 seconds
Result is [ 1.23178029  1.61879349  1.52278066 ...,  2.20771813  2.29967761
  1.62323296]
Used the gpu
 

Per conoscere la tua versione CUDA:

​nvcc -V
 

Esempio:

username@server:~$ nvcc -V
nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2015 NVIDIA Corporation
Built on Tue_Aug_11_14:27:32_CDT_2015
Cuda compilation tools, release 7.5, V7.5.17
 

Aggiunta di cuDNN

Per aggiungere cuDNN (istruzioni da http://deeplearning.net/software/theano/library/sandbox/cuda/dnn.html) :

  1. Scarica cuDNN da https://developer.nvidia.com/rdp/cudnn-download (è necessaria la registrazione, che è gratuita)
  2. tar -xvf cudnn-7.0-linux-x64-v3.0-prod.tgz
  3. Effettuare una delle seguenti operazioni

Opzione 1: copia i *.h in CUDA_ROOT/include e i file *.so* in CUDA_ROOT/lib64 (per impostazione predefinita, CUDA_ROOT è /usr/local/cuda su Linux).

sudo cp cuda/lib64/* /usr/local/cuda/lib64/
sudo cp cuda/include/cudnn.h /usr/local/cuda/include/
 

Opzione 2:

export LD_LIBRARY_PATH=/home/user/path_to_CUDNN_folder/lib64:$LD_LIBRARY_PATH
export CPATH=/home/user/path_to_CUDNN_folder/include:$CPATH
export LIBRARY_PATH=/home/user/path_to_CUDNN_folder/lib64:$LD_LIBRARY_PATH
 

Per impostazione predefinita, Theano rileva se può utilizzare cuDNN. Se è così, lo userà. Altrimenti, le ottimizzazioni di Theano non introdurranno le operazioni cuDNN. Quindi Theano funzionerà ancora se l'utente non li ha introdotti manualmente.

Per ottenere un errore se Theano non può usare cuDNN, usa questo flag di Theano: optimizer_including=cudnn .

Esempio:

THEANO_FLAGS='mode=FAST_RUN,device=gpu,floatX=float32,optimizer_including=cudnn' python gpu_test.py
 

Per conoscere la tua versione cuDNN:

cat /usr/local/cuda/include/cudnn.h | grep CUDNN_MAJOR -A 2
 

Aggiunta di CNMeM

La libreria CNMeM è una "libreria semplice per aiutare i framework Deep Learning a gestire la memoria CUDA".

# Build CNMeM without the unit tests
git clone https://github.com/NVIDIA/cnmem.git cnmem
cd cnmem
mkdir build
cd build
sudo apt-get install -y cmake
cmake ..
make

# Copy files to proper location
sudo cp ../include/cnmem.h /usr/local/cuda/include
sudo cp *.so /usr/local/cuda/lib64/
cd ../..
 

Per usarlo con Theano, è necessario aggiungere il flag lib.cnmem . Esempio:

THEANO_FLAGS='mode=FAST_RUN,device=gpu,floatX=float32,lib.cnmem=0.8,optimizer_including=cudnn' python gpu_test.py
 

Il primo output dello script dovrebbe essere:

Using gpu device 0: GeForce GTX TITAN X (CNMeM is enabled with initial size: 80.0% of memory, cuDNN 5005)
 

lib.cnmem=0.8 significa che può utilizzare fino all'80% della GPU.

È stato segnalato che CNMeM offre alcuni interessanti miglioramenti della velocità ed è supportato da Theano, Torch e Caffee.

Theano - fonte 1 :

La velocità dipende da molti fattori, come le forme e il modello stesso. La velocità aumenta da 0 a 2x più veloce.

Theano - source 2 :

Se non cambi il flag di Theano allow_gc, puoi aspettarti un aumento del 20% della GPU. In alcuni casi (modelli piccoli), abbiamo rilevato un aumento del 50%.


Problemi comuni:

Esecuzione di Theano su più core CPU

È possibile eseguire Theano su più core CPU con il OMP_NUM_THREADS=[number_of_cpu_cores] .

Esempio:

OMP_NUM_THREADS=4 python gpu_test.py 
 

Lo script theano/misc/check_blas.py informazioni su quale BLAS è utilizzato:

cd [theano_git_directory]
OMP_NUM_THREADS=4 python theano/misc/check_blas.py
 

Il tuo primo programma theano

In questo esempio, compileremo funzioni che calcolano somma e differenza in base a due numeri reali.

from __future__ import print_function
import theano
import theano.tensor as T

#define two symbolic scalar
s_x = T.fscalar()
s_y = T.fscalar()

#compute something
s_sum = s_x + s_y
s_diff = s_x - s_y

#compile a function that adds two number
#theano will call system compiler at here
fn_add = theano.function(inputs=[s_x, s_y], outputs=s_sum)
fn_diff = theano.function(inputs=[s_x, s_y], outputs=s_diff)

#call the compiled functions
print(fn_add(2., 2.)) #4.
print(fn_diff(2., 2.)) #0.