theanoKomma igång med theano


Anmärkningar

Theano är ett pythonbibliotek, som hanterar att definiera och utvärdera symboliska uttryck över tensorvariabler. Har olika tillämpningar, men mest populärt är djup inlärning.

Installation eller installation

Detaljerade anvisningar om hur du installerar eller installerar theano.

Installera Theano och konfigurera GPU på Ubuntu 14.04

Du kan använda följande instruktioner för att installera Theano och konfigurera GPU (anta en nyinstallerad Ubuntu 14.04):

# 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
 

Vid den nvidia-smi bör köra nvidia-smi fungera, men att köra nvcc fungerar inte.

# 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
 

Vid den nvcc bör både nvidia-smi och nvcc fungera.

För att testa om Theano kan använda GPU:

Kopiera och klistra in följande i 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
 

och kör det:

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

som borde återvända:

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
 

Så här känner du till din CUDA-version:

​nvcc -V
 

Exempel:

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
 

Lägger till cuDNN

Så här lägger du till cuDNN (instruktioner från http://deeplearning.net/software/theano/library/sandbox/cuda/dnn.html) :

  1. Ladda ner cuDNN från https://developer.nvidia.com/rdp/cudnn-download (behöver registrering, vilket är gratis)
  2. tar -xvf cudnn-7.0-linux-x64-v3.0-prod.tgz
  3. Gör en av följande

Alternativ 1: Kopiera *.h filerna till CUDA_ROOT/include och *.so* CUDA_ROOT/lib64 till CUDA_ROOT/lib64 (som standard är CUDA_ROOT /usr/local/cuda på Linux).

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

Alternativ 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
 

Som standard kommer Theano att upptäcka om det kan använda cuDNN. I så fall kommer den att använda den. Om inte kommer Theano-optimeringar inte att introducera cuDNN-ops. Så Theano kommer fortfarande att fungera om användaren inte introducerade dem manuellt.

För att få ett fel om Theano inte kan använda cuDNN, använd denna Theano-flagga: optimizer_including=cudnn .

Exempel:

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

Så här känner du till din cuDNN-version:

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

Lägger till CNMeM

CNMeM-biblioteket är ett "Enkelt bibliotek för att hjälpa Deep Learning-ramarna att hantera CUDA-minne."

# 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 ../..
 

För att kunna använda Theano måste du lägga till lib.cnmem flaggan. Exempel:

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

Den första utgången från skriptet ska vara:

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

lib.cnmem=0.8 betyder att den kan använda upp till 80% av GPU.

CNMeM har rapporterats ge några intressanta hastighetsförbättringar och stöds av Theano, Torch och Caffee.

Theano - källa 1 :

Uppstarten beror på många faktorer, som formerna och själva modellen. Farten upp går från 0 till 2x snabbare.

Theano - källa 2 :

Om du inte ändrar Theano-flaggan allow_gc, kan du förvänta dig 20% snabbare hastighet på GPU. I vissa fall (små modeller) såg vi en hastighet på 50%.


Vanliga problem:

Kör Theano på flera CPU-kärnor

Du kan köra Theano på flera CPU-kärnor med OMP_NUM_THREADS=[number_of_cpu_cores] .

Exempel:

OMP_NUM_THREADS=4 python gpu_test.py 
 

Skriptet theano/misc/check_blas.py matar ut information om vilken BLAS som används:

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

Ditt första theano-program

I det här exemplet kommer vi att sammanställa funktioner som beräknar summa och skillnad med två riktiga nummer.

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.