La GTX 745 y la instalación de tensorflow – gpu en Windows

Autora: Eleonora Bernasconi

 

Especificaciones de la tarjeta de gráficos NVIDIA GeForce GTX 745

Especificaciones: https://www.geforce.com/hardware/desktop-gpus/geforce-gtx-745-oem/specifications

Núcleos CUDA: 384

Base Clock (MHz): 1033

Velocidad de la memoria ( Gbps ): 1.8 Gbps

Cantidad de memoria: 4 GB

Interfaz de memoria: DDR3

Ancho de banda máx (GB/sec): 28.8

 

Figura 01 – nvidia-smi para el monitoreo de GPU

Abra el símbolo del sistema e ingrese:

cd C:\Program Files\NVIDIA Corporation\NVSMI

nvidia-smi

N.B. El porcentaje de uso de la GPU oscila entre 92% y 94%, en el Administrador de tareas de Windows permanece en 70%.

 

Instalación de Tensorflow con GPU para Windows 10

Requisitos

Python 3.5

Nvidia CUDA GPU. Verifique que la GPU sea compatible con CUDA.

Configurando la tarjeta GPU Nvidia

Instala Cuda Toolkit 8.0 e cuDNN v5.1.

Descarga e instalación de CUDA Toolkit

Toolkit 8.0 https://developer.nvidia.com/cuda-downloads

Ejemplo de directorio de instalación: C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v8.0

Descarga e instalación de cuDNN

Installa cuDNN versione 5.1 per Windows 10: https://developer.nvidia.com/cudnn

Extraiga los archivos cuDNN e ingréselos en el directorio Toolkit.

Variables de entorno

Después de instalar CUDA toolkit, asegúrese de que CUDA_HOME esté configurado en las variables de entorno; de lo contrario, agréguelo manualmente.

Figura 02 – Variables de entorno CUDA_HOME parte 01

 

Figura 03 – Variables de entorno CUDA_HOME parte 02

Instala Anaconda

Descarga : https://www.anaconda.com/download/

Cree un nuevo entorno con el nombre tensorflow-gpu y la versión 3.5.2 de python

conda create -n tensorflow-gpu python=3.5.2

N.B. En caso de que se encuentre con versiones incompatibles entre sí, simplemente active estos comandos para resolver el problema:

conda install -c conda-forge tensorflow-gpu

Anaconda instalará automáticamente las versiones requeridas de cuda, cudNN y otros paquetes.

Figura 04 – conda install -c conda-forge tensorflow-gpu

activate tensorflow-gpu

Figura 05 – activate tensorflow-gpu

 

Instala tensorFlow

pip install tensorflow-gpu

Figura 06 – pip install tensorflow-gpu

i Ahora ha terminado y tiene instalado con éxito tensorflow con la GPU !

i Recuerde activar el comando:activate tensorflow-gpu para entrar en modo GPU!

Prueba de GPU

python

import tensorflow as tf

sess = tf.Session(config=tf.ConfigProto(log_device_placement=True))

 

Figura 07 – prueba de GPU

 

Prueba en CIFAR-10 con 10 épocas

Tiempo promedio por época:150 sec

Tiempo total: 25 min

Figura 08 – Prueba en CIFAR-10 con 10 épocas 

Spark y Machine Learning (MLlib)

Autor: Antonio Berti

En este tutorial vamos a aprender el uso de la libreria de Apache Foundation para el Machine Learning llamada MLlib.

MLIB forma parte de las API de Spark y es interoperable con NumPy de Python así como las librerias de R. implementado con Spark es posible utilizar cualquier tipo de datos de cualquier origen o de la plataforma Hadoop como por ejemplo HDFS, HBase, las fuentes  datos provenientes de database relacionadas o fuentes de datos locales, como documentos de texto.

Spark sobresale en los procesos de cálculos iterativo permitiendo que los procesos escritos en las librerias MLlib se ejecuten rápidamente permitiendo su uso y tambien  sobre todo a nivel industrial.

MLlib proporciona muchos tipos de algoritmos, así como numerosas funciones de utilidad. ML incluye algoritmos de clasificación, regresión, árboles de decisión, algoritmos de recomendación, agrupamiento. Entre las utilidades más utilizados puede incluir las características de las transformaciones, la estandarización y normalización, funciones estadísticas y álgebra lineal.

 

Primero que todo cargamos la base de datos

val data =MLUtils.loadLibSVMFile(sc, "data/mllib/sample_libsvm_data.txt")

 

El conjunto de datos se divide en una parte utilizada para entrenar el modelo (60%) y otra parte para las prueba (40%).

 

val splits = data.randomSplit(Array(0.6, 0.4), seed=11L)

val training = splits(0).cache()

val test = splits(1)

Se ejecuta el modelo en la base de datos de prueba.

val model = new LogisticRegressionWithLBFGS()
.setNumClasses(10)&nbsp
.run(training)

Se entrena el algoritmo y se costruye el modelo

val predictionAndLabels = test.map {case LabeledPoint(label, features) =>

 val prediction = model.predict(features)

  (prediction, label)}

De esta forma, se obtiene la métrica del modelo y la precisión del pronóstico.

val metrics = new MulticlassMetrics(predictionAndLabels)

val accuracy = metrics.accuracy

println("Accuracy = $accuracy")

Es posible guardar el modelo recién entrenado y volver a cargarlo en la memoria para su uso posterior.

model.save(sc, "target/tmp/scalaLogisticRegressionWithLBFGSModel")

val sameModel = LogisticRegressionModel.load(sc,

               "target/tmp/scalaLogisticRegressionWithLBFGSModel")

 

Referencias

documentación spark – http://spark.apache.org

documentación mllib – http://spark.apache.org/docs/latest/ml-guide.html

dataset de ejemplos mllib – https://github.com/apache/spark/tree/master/data/mllib

codigo de ejemplo  – https://github.com/apache/spark/tree/master/examples/src/main/scala/org/apache/spark/examples

 

Creación de un Tensor en Pytorch

Autor: Andrea Mercuri

Al igual que los otros Framework  para el deep learning, también en PyTorch son absolutamente esenciales los tensores. Cuando representamos los cálculos que son efectuados por una red neuronal  como operaciones  tensoriales obtenemos dos ventajas: utilizamos un  código matemático  compacto  y permitimos que la CPU haga cálculos paralelos.
Los tensores pueden residir en la RAM principal de la computadora y ser procesados por la CPU o RAM de una tarjeta de video y procesados por una GPU. Estos últimos se identifican por una series de diferencias de los primeros. A continuación veremos una lista de todos los tipos de tensores presentes en PyTorch.

Tipo Tensores CPU Tensores GPU
32-bit coma flotante torch.FloatTensor torch.cuda.FloatTensor
64-bit coma flotante torch.DoubleTensor torch.cuda.DoubleTensor
16-bit coma flotante torch.HalfTensor torch.cuda.HalfTensor
8-bit entero (sin signo) torch.ByteTensor torch.cuda.ByteTensor
8-bit entero (con signo) torch.CharTensor torch.cuda.CharTensor
16-bit entero (con signo) torch.ShortTensor torch.cuda.ShortTensor
32-bit entero (con signo) torch.IntTensor torch.cuda.IntTensor
64-bit entero (con signo) torch.LongTensor torch.cuda.LongTensor

En primer lugar importamos PyTorch.

import torch

Podemos crear un tensor  estos siempre  siempre tienen que inicializarlos llamando al constructor de uno de los tipos enumerados anteriormente.

x = torch.FloatTensor(3, 2)
print(x)
1.00000e-25 *
&nbsp&nbsp9.9872  0.0000
&nbsp&nbsp9.9872  0.0000
&nbsp&nbsp0.0000  0.0000
&nbsp&nbsp[torch.FloatTensor of size 3x2]

En este caso, el tensor se crea en la RAM principal. Si queremos crear un tensor en la GPU corriente, tenemos que usar uno de los tipos CUDA.

x = torch.cuda.FloatTensor(3, 2)
print(x)
nan nan
nan nan
nan nan
[torch.cuda.FloatTensor of size 3x2 (GPU 0)]

En este caso, nos enteramos  que el tensor se encuentra en la primera GPU. Las GPU que están presentes en la máquina están enumeradas con números  enteros a partir de 0.
Podemos crear tensores a partir de  las listas de Python

torch.FloatTensor([[1,2,3],[4,5,6]])
1  2  3
4  5  6
[torch.FloatTensor of size 2x3]

o de array numpy.

x_np = np.array([1,2,3,4], dtype=np.float32)
x = torch.FloatTensor(x_np)

Obtenemos el mismo resultado con el método  from_numpy.

x = torch.from_numpy(x_np)

Notemos que el array numpy y el tensor PyTorch comparten los datos. Si cambiamos uno de los dos, el otro sufre los mismos cambios.

x[0] = 0
print(x_np)
[ 0.,  2.,  3.,  4.]
print(x)
0
2
3
4
[torch.FloatTensor of size 4]

Podemos crear tensores desde otros tensores.

y = torch.FloatTensor(x)
print(y)
0
2
3
4
[torch.FloatTensor of size 4]

Incluso en este caso, el tensor creado comparte los datos con el tensor original.
Podemos crear tensores desde cero.

torch.zeros(3,2)
0  0
0  0
0  0
[torch.FloatTensor of size 3x2]

Podemos crear tensores de números aleatorios extraídos de una determinada distribución, por ejemplo, espaciadas dentro el intervalo [0,1].

torch.rand(2, 3)
0.1256  0.0406  0.2072
0.2479  0.0515  0.093
[torch.FloatTensor of size 2x3]

Cada tensor vive en la memoria principal o en una tarjeta de video. Dos tensores pueden ser operandos de la misma operación solo si residen en la misma memoria ( en este caso el resultado aún reside en la misma memoria). Si tratamos de combinar (por ejemplo, sumando) un tensor que reside en la RAM principal y uno que está en una tarjeta de video (o dos tensores en dos tarjetas de video diferentes) será una excepción.

xcpu = torch.FloatTensor(3,2)
xgpu = torch.cuda.FloatTensor(3,2)
xcpu + xgpu
TypeError             Traceback (most recent call last)
in ()
----> 1 xcpu + xgpu
…

Si queremos obtener una copia de un tensor x en la primera GPU, podemos usar el método cuda.

y = x.cuda(device=0)

Si el tensor ya está en la primera GPU regresa el tensor original .En lugar de obtener una copia de un tensor x en la RAM principal, usamos el método cpu.

y = x.cpu()

Podemos convertir un tensor a otro tipo diferente  pasando del método de type al tipo de destinacion.

y = x.type(torch.ByteTensor)

Obtenemos el mismo resultado al inserir un método específico de conversión.

y = x.byte()

Si además de cambiar el tipo  queremos copiar el tensor en la GPU ,tenemos que pasar del método type a un tipo cuda.

y = x.type(torch.cuda.ByteTensor)

o escribir

y = x.byte().cuda()

Para usar la segunda GPU usamos set_device.

torch.cuda.set_device(1)

Si ahora escribimos

torch.cuda.current_device()

obtenemos 1 como valor de retorno. Esto significa que ahora la GPU actual es la segunda y no la primera y, por ejemplo, cuando usamos el método cuda en un tensor creamos una copia en la segunda GPU en lugar de la primera.
También se puede usar un context manager para cambiar temporalmente la GPU actual.
Por ejemplo, escribiendo

with torch.cuda.device(1):
&nbsp&nbspx1 = torch.cuda.FloatTensor(2,3)
x2 = torch.cuda.FloatTensor(2,3)

cuando en la GPU el índice es 0,x1 viene creado en la segunda GPU  un (índice 1), x2 y en la primera (índice 0).
Todas las funciones relativas a las creaciónes de tensores están incluidas en los package torchtorch.cuda  y en la clase torch.Tensor. En los próximos tutoriales continuaremos aprendiendo de los tensores.
Referencias

Instalación de Keras/Tensorflow-Theano en Windows

Autores: Francesco Pugliese & Matteo Testi

En este post, veremos cómo abordar el abrumador problema de la instalación de Windows en el marco de framework para Deep Learning “Keras” y tambien veremos el stack de backend “Tensorflow / Theano”.
La instalación parte descargando  paquete de Python 3. Elegimos la opcion Miniconda en el siguiente enlace: https://conda.io/miniconda.html   aparecerá la siguiente pantalla:

 

Seleccione Python 3.6 y la versión de Windows de 64 bits o 32 bits. Haga clic en el paquete descargado y ejecute la instalación dejando todo predeterminado. Al final de la instalación, acepte el reinicio de la máquina.

Después de reiniciar su PC, desde el cuadro de búsqueda de Windows, escriba cmd.exe y ejecute el prompt. A continuación, ejecute el script c:\Users\-utente-\Miniconda3\Scripts\activate.bat donde iniciará el prompt de Anaconda(replace-user- con el nombre de cuenta específico).

En este punto escriba: conda install numpy scipy mkl-service m2w64-toolchain para instalar:

  1. La libreria “numpy” de Python es muy útil para gestionar matrices y array en general.
  2. la libreria para el cálculo científico en python “scipy”.
  3. la libreria para “mkl-service” es para optomizar, las rutinas de vectores matemáticos para acelerar las funciones y aplicaciones matemáticas.
  4. la libreria “libpython” para Python 3 con código para Machine Learning y para desarrollar código eficiente.
  5. la biblioteca “m2w64-toolchain” que proporciona una versión compatible con GCC, por lo tanto, es muy recomendable.

Las librerias opcionales son:

  1. la libreria “nose” para el testing de los programas  Python.
  2. la libreria “nose-parameterized” para el testing paramétrico.
  3. la libreria “sphinx” para crear documentación elegante del programa en varios formatos (HTML, PDF, ePyub, etc.).
  4. la libreria “pydot-ng” es la interfaz al lenguaje de representación gráfica de Graphviz’s Dot.

Una vez hecho el set up de Pyton,descargue los controladores de Cuda desde el siguiente enlace:

https://developer.nvidia.com/cuda-downloads

 

Se abrirá la siguiente pantalla con distintas opciones del sistema operativo y las versiones requeridas:

 

 

 

Descargar la versión local (recomendada) del archivo instalado y proceda con la instalación de los driver Cuda, que son las librerias de programación pararela de la GPU Nvidia (Graphic Processing Unit) que esta presente en la tarjeta grafica. Si es necesario, también acepte la instalación del driver de la tarjeta de video si en el caso este no estuviera actualizado o no funcionara correctamente.

Después de haber terminado instalacion de los driver Cuda (y de los driver de la tarjeta de video), el siguiente paso es instalar Theano y la libreria de soporte “libgpuarray”, que es una libreria para manipular los tensores en la GPUcon el comando:

conda install theano pygpu

NOTA 1 Theano: para la instalación de Theano siempre se recomienda la instalación la versión anterior de Cuda. Esto se debe a que Theano no viene actualizado a menudo esto comporta que te puedes encontrar con  errores de compilación esto  sucede cuando has instalado una version  de Theano con la última versión de Cuda. Por ejemplo, en este momento la versión más estable de Theano es 0.9.0, por lo que recomendamos instalar Cuda 8.0 en lugar de Cuda 9.0. Existen tutoriales en intenet que te dicen que te dan consejos como funcionaria perfectamente Cuda 9 con Theano 0,9, segun mi opinion considero que son complicados y quitan tiempo. Es aconsejable tener una configuración estable de Cuda-Theano por esto les aconsejo elegir las versiones que les he recomendado.

Entonces, ahora es necesario  instalar Visual Studio que proporciona  el compilador  C ++ para Windows a Theano (de hecho, el CCG instalado anteriormente sólo se refiere al compilador de C). Para hacer esto se descarga Visual Studio Community en el siguiente enlace: https://www.visualstudio.com/it/downloads/ y despues tienes que seguir todos los pasos necesarios,  instalar sólo los componentes esenciales para el C++.

NOTA 2 Theano: Aparentemente después del próximo lanzamiento, Theano se retirará, explicado por el mismo Bengio en este post: link Las razones son tantas, creemos que se deben esencialmente a la competencia masiva de otros frameworks para Deep Learning (mxnet, tensorflow, deeplearning4j, gluon , por nombrar algunos) que vienen actualizados rapidamente. Como hemos demostrado, Theano sufre problemas constantes de actualización. Sin embargo, creemos que todavía es un hito para Deep Learning, Theano es el primero en introducir la diferenciación automática y la paralelización eficiente y transparente de las operaciones de la matriz GPU que han dado lugar a la difusion de las  deep neural networks en la GPU . Por lo tanto, creemos que es necesario darle un reconocimiento, a este excepcional framework, también tenemos reconocer, que todavía proporciona sus ventajas de versatilidad y velocidad cuando se utiliza como backend de Keras.

NOTA Visual Studio: también Visual Studio recientemente tiene problemas de compatibilidad con Theano. En particular, Visual Studio 2017 generará una excepción en la fase de importación de Theano, ya sea Cuda 9 que Cuda 8. Por lo tanto, recomendamos instalar una versión anterior estable como Visual Studio 2013

Una vez que haya instalado Visual Studio, es necesecario  completar el archivo  theanorc, de  la configuración de Theano,que se encuentra con Miniconda3 en la ruta de acceso: c: \ Users \ – user – \. Theanorc

Rellene  el .theanorc de la siguiente manera, suponiendo que haya instalado Cuda 8 y Visual Studio 2013:

[global]
device = gpu
floatX = float32

[cuda]
root = C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v8.0

[dnn]
enabled=False

[nvcc]
compiler_bindir = C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\bin

[lib]
cnmem = 0

Analizemos un momento estos parámetros: la sección “device” de [global] sirve para decidir si se desea usar la CPU o la GPU, la sección “root” de [cuda] es necesaria para definir la ruta de las librerias de Cuda, mientras que “compiler_bindir” ” de [nvcc] sirve para definir la ruta del compilador C ++ de Visual Studio que es necesaria para compilar los programas de Theano. El parámetro CNMeM es una libreria (built-in de Theano) que le permite definir (a través de un valor entre 0 y 1) el modo en el cual el framework de Deep Learning puede manejar la memoria de la GPU, y es una manera para acelerar la computación de las redes neuronales deep en Theano. Por ejemplo, las tarjetas de video compartidas con la pantalla se aconseja ajustar alrededor de 0.8, mientras que para las tarjetas de video stand-alone, osea que estan dedicadas solo a Deep Learning, recomendamos un cnmem igual a 1.

Otro parámetro muy importante para acelerar el cálculo, especialmente con respecto a la convolución, es el parámetro “enabled” de [dnn] que permite habilitar o deshabilitar las librerias Nvidia CuDNN. Básicamente es una libreria que  optimiza las deep neural networks, lo que le permite acelerar el traning, las pruebas e incluso reducir el consumo de memoria. Para instalar CuDNN se necesita ir a este enlace: https://developer.nvidia.com/cudnn y hacer click en el boton download e iniciar la descarga( talvez es necesario registrarse como membership de Nvidia) deberia abrirse la siguiente pantalla

developer.nvidia.com
The NVIDIA CUDA® Deep Neural Network library (cuDNN) is a GPU-accelerated library of primitives for deep neural networks. cuDNN provides highly tuned implementations …

 

 

NOTA cuDNN: también aquí, como en los casos anteriores, se recomienda no descargar la última versión de cuDNN, sino uno o dos precedentes, ya que Cuda 8 o Theano 0.9 no podran ser vistas, en este caso recomendamos versión cuDNN 6.0. Y con Theano 0.9 todavía puede tener una advertencia de que la versión cuDNN es muy reciente y podría causar problemas. También probamos problemas de incompatibilidad entre la última versión de cuDNN y TensorFlow.

Al descomprimir el archivo descargado, obtendrá 3 carpetas: bin, lib e include.  Lo que necesitas  hacer es copiar el contenido de las carpetas en las mismas carpetas dentro del directorio de Cuda, es decir, dentro de:

C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v8.0

Copie cudnn64_6.dll dentro de la bin del path Cuda, copie cudnn.h dentro include y luego copie cudnn.lib dentro lib.

Una vez que instalado cuDNN, proceda con la instalación de Keras a través de pip:

pip install keras

La declaración instalará todas las dependencias y también la última versión (actualmente Keras 2.0.9). Para configurar Theano como backend de Keras, entre a la carpeta: c: \ users \ -user – \. Keras y edite el archivo keras.json de la siguiente manera, o estableciendo “theano” en la entrada “backend”

{

“floatx”: “float32”,
“epsilon”: 1e-07,
“backend”: “theano”,
“image_data_format”: “channels_last”
}

Para probar que todo está bien, reinicie el prompt de anaconda y ejecute python. Dentro el prompt de Python escriba: import keras. Si todo esta en la dirección correcta, debería aparecer la siguiente pantalla:

 

Recuerdense del primer “warning” mencionado  sobre las cuDNN y comunicado por Theano mismo: si encuentra los problemas antes mencionados, efectuar el downgrade de las  cuDNN a la versión 5.1 según  como lo ha  recomendado por el mismo team. El lanzamiento de la versión estable de Theano 0.10 debería resolver todos estos problemas de compatibilidad.

De todos modos, encontramos que el entorno configurado con Keras y Theano de esta manera funciona perfectamente en una variedad de modelos que hemos entrenado y probado. Usamos Theano porque a menudo es más rápido que TensorFlow en algúnos training de Computer Vision.

Sin embargo, si desea utilizar TensorFlow como un backend, es necesario instalarlo. Para instalar tensorflow para la GPU, necesita el siguiente comando:

pip install –upgrade tensorflow-gpu

Este instalará la última versión (1.4.0) de Tensorflow-gpu. Para probarlo con Keras, reemplace “theano” con la cadena “tensorflow” en el archivo “keras.json”, reinicie el prompt de anaconda y haga nuevamente import keras.

NOTA TensorFlow: no esta admitido en plataformas de 32 bits, el procedimiento de instalación solo descargará en il wheel relativo al framework de 64 bits. También para descargar la versión de la CPU, solo necesitan especificar: pip install –upgrade tensorflow.

Si todo salió bien, esta vez deberia aparecer el  TensorFlow como backend de keras:

 

Otros paquetes útiles que recomendamos para trabajar con Keras son:

  1. scikit-image: Una libreria muy útil de image processing  en python, que permite, entre otras cosas, guardar matrices y tensores en una imagen JPEG u otros muchos formatos admitidos. Instalable con: conda install scikit-image.
  2. gensim: Una  libreria de word embeddings  que implementa, entre otras cosas, el algoritmo word2vec. Instalable con: conda install gensim.
  3. h5py: La  libreria como interfaz   conectada al formato de rescate HDF5 de Pythonic, necesario para guardar modelos  de entrenamientos en discos Keras. Instalado con pip install h5py.

A este punto, el entorno Keras / Tf-Th en Windows está listo para ser usado, y podran probar su código y sus modelos mediante el uso de la GPU.

Buen trabajo!

 

Nos vemos en el siguiente tutorial.

Un saludo de Deep Learning Italia.

Para información y aclaración, aquí están nuestros correos electrónicos:

Francesco Pugliese – f.pugliese@deeplearningitalia.com

Matteo Testi – m.testi@deeplearningitalia.com