Apache Scala e Machine Learning (MLlib)

Autore: Antonio Berti

In questo tutorial verrà illustrato l’uso della libreria di Apache Foundation per il Machine Learning chiamata MLlib.

MLib fa parte delle API di Spark ed è interoperabile con NumPy di Python oltre che con le librerie di R. Implementato con Spark è possibile utilizzare ogni tipo di origine dati della piattaforma Hadoop come per esempio HDFS, HBase,  fonti dati provenienti da database relazionali o sorgenti dati locali come documenti di testo.

Spark eccelle nella computazione iterativa consentendo ai processi scritti con le librerie di MLlib di essere eseguite molto velocemente consentendone l’utilizzo anche e soprattutto a livello industriale.

MLlib fornisce molti tipi di algoritmi oltre che numerose funzioni di utilità. ML include algoritmi di classificazione, regressione, alberi decisionali, algoritmi di raccomandazione, clustering. Fra le utilità più utilizzate si possono annoverare le trasformazioni delle caratteristiche, standardizzazione e normalizzazione, funzioni statistiche e di algebra lineare.

Nel codice seguente verrà illustrato come implementare un semplice modello di regressione logistica con MLlb.

 

Innanzitutto viene caricato il dataset.

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

Il dataset viene diviso in una parte utilizzata per addestrare il modello (60%) e in un’altra per il test (40%).

val splits = data.randomSplit(Array(0.6, 0.4), seed=11L)
val training = splits(0).cache()
val test = splits(1)

 

Si addestra l’algoritmo e si costruisce il modello.

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

Si esegue il modello sul dataset di test.

val predictionAndLabels = test.map {case LabeledPoint(label, features) => 
 val prediction = model.predict(features)
  (prediction, label)}

In questo modo si ottiene la metrica del modello e l’accuratezza della previsione.

val metrics = new MulticlassMetrics(predictionAndLabels)
val accuracy = metrics.accuracy
println("Accuracy = $accuracy")

E’ possibile salvare il modello appena addestrato e ricaricarlo nuovamente in memoria per un ulteriore uso.

model.save(sc, "target/tmp/scalaLogisticRegressionWithLBFGSModel") 
val sameModel = LogisticRegressionModel.load(sc, 
               "target/tmp/scalaLogisticRegressionWithLBFGSModel")

 

Riferimenti:

documentazine spark – http://spark.apache.org

documentazione mllib – http://spark.apache.org/docs/latest/ml-guide.html

codice d’esempio – https://github.com/apache/spark/tree/master/examples/src/main/scala/org/apache/spark/examples

dataset d’esempio mllib – https://github.com/apache/spark/tree/master/data/mllib

Installazione di Keras/Tensorflow-Theano su Windows

Autore: Francesco Pugliese & Matteo Testi

 

In questo post vediamo come affrontare l’annoso problema dell’installazione su Windows del noto framework per Deep Learning “Keras” e di tutto lo stack di backend “Tensorflow / Theano“.

L’installazione parte con la necessità di scaricare il pacchetto relativo a Python 3. Scegliamo Miniconda al seguente link: https://conda.io/miniconda.html che farà apparire la seguente schermata:

 

 

Selezionare Python 3.6 e la versione di Windows a 64-bit o 32-bit. Cliccare sul pacchetto scaricato ed effetturare l’installazione lasciando tutto predefinito. Alla fine dell’installazione accettare il riavvio della macchina.

Una volta riavviato il PC, dalla box di ricerca di Windows, digitare cmd.exe e lanciare il prompt. Poi eseguire lo script c:\Users\-utente-\Miniconda3\Scripts\activate.bat che lancerà il prompt di Anaconda (sostituire -utente- con il nome dell’account specifico).

A questo punto digitare: conda install numpy scipy mkl-service m2w64-toolchain per installare:

  1. la libreria “numpy” di Python molto utile per la gestione delle matrici e degli array in generale.
  2. la libreria per il calcolo scientifico in python “scipy“.
  3. la libreria “mkl-service” di ottimizzazione, con routine matematiche vettoriali per accelerare funzioni e applicazioni mathematiche.
  4. la libreria “libpython” per Python 3 con codice per Machine Learning e per sviluppare codice efficiente. 
  5. la libreria “m2w64-toolchain” che fornisce una versione compatibile di GCC e quindi è fortemente consigliata.

Opzionali librerie sono:

  1. la libreria “nose” per il testing dei programmi Python.
  2. la libreria “nose-parameterized” per il testing parametrico.
  3. la libreria “sphinx” per creare della documentazione elegante del programma in vari formati (HTML, PDF, ePyub, ecc.).
  4. la libreria “pydot-ng” interfaccia al linguaggio di rendering grafico Graphviz’s Dot.

Una volta settato l’ambiente Python, a questo punto scaricare i driver Cuda dal seguente link:

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

Si aprirà la seguente schermata con le varie opzioni del sistema operativo e delle versioni richieste:

 

 

Scaricare la versione locale (consigliato) del file installante e procedere con l’installazione dei driver Cuda che sono le librerie di programmazione parallela della GPU Nvidia (Graphic Processing Unit) presente nella scheda grafica. Eventualmente, se necessario, accettare anche l’installazione del driver della scheda video qualora non fosse aggiornato o correttamente funzionante.

Terminata l’installazione dei driver Cuda (e degli eventuali driver della scheda video) procedere all’installazione di Theano e della libreria di supporto “libgpuarray” che è libreria per manipolare i tensori su GPU con il comando:

conda install theano pygpu

NOTA 1 Theano: Per l’installazione di Theano si raccomanda sempre l’installazione di almeno 1 punto di versione precedente di Cuda. Questo è dovuto al fatto che Theano non viene aggiornata rapidamente e questo comporta che si ottengono spesso errori di compilazione una volta terminata l’installazione di Theano con la versione più recente di Cuda. Per esempio, al tempo corrente la versione più stabile di Theano è la 0.9.0, per cui si raccomanda l’installazione di Cuda 8.0 anzichè Cuda 9.0. Esistono online degli espedienti per far funzionare perfettamente Cuda 9 con Theano 0.9 ma sono un pò tricky e portano via tempo, e il gioco alla fine non vale la candela. Si consiglia di avere una configurazione Cuda-Theano stabile come quella fornita dalle versioni raccomandate.

A questo punto è necessario installare Visual Studio che fornisce il compilatore C++ per Windows a Theano (infatti il GCC precedentemente installato si riferisce al solo compilatore C). Per fare questo scaricare Visual Studio Community dal seguente link: https://www.visualstudio.com/it/downloads/ e seguire tutti  i passaggi richiesti, cercando di installare solo i componenti essenziali per il C++.

NOTA 2 Theano: Apparentemente dopo la prossima release, Theano andrà in pensione, è spiegato dallo stesso Bengio in questo post: link Le ragioni sono tante, crediamo essenzialmente dovute alla concorrenza massiccia degli altri framework per Deep Learning (mxnet, tensorflow, deeplearning4j, gluon, solo per citarne alcuni) che sono più manutenuti. Come abbiamo mostrato Theano soffre di problemi di aggiornamento costante da parte del Team. Tuttavia riteniamo sia ancora una pietra miliare per il Deep Learning, il primo che ha introdotto la differenziazione automatica e la parallelizzazione efficiente e trasparente delle operazioni matriciali su GPU che hanno dato il là alla diffusione delle deep neural networks su GPU. Quindi riteniamo bisogni darne il giusto onore a questo eccezionale framework, e del resto fornisce ancora i suoi vantaggi in termini di versatilità e velocità se usato come backend di Keras.

NOTA Visual Studio: Anche Visual Studio risente dei problemi di compatibilità di Theano. In particolare Visual Studio 2017 genererà un’eccezione in fase di importazioine di Theano sia che si usa Cuda 9 che Cuda 8. Pertanto si consiglia di installare una verione precedente stabile come Visual Studio 2013.

Una volta installato Visual Studio è necessario compilare il file .theanorc, di configurazione di Theano, che si trova con Miniconda3 al percorso: c:\Users\-utente-\.theanorc

Compilare il .theanorc nel seguente modo, supponendo di avere installato Cuda 8 e 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

Soffermiamoci un attimo su questi parametri: la sezione “device” di [global] serve ad inpostare se si desidera utilizzare la CPU o la GPU, la sezione “root” di [cuda] è necessario per definire il percorso delle librerie Cuda, mentre “compiler_bindir” di [nvcc] serve a definire il percorso del compilatore C++ di Visual Studio necessario alla compilazione dei programmi Theano. Il parametro CNMeM invece si riferisce ad una libreria (built-in di Theano) che permette di definire (attraverso un valore compreso tra 0 e 1) il modo in cui il framework di Deep Learning può gestire la memoria della GPU, ed è un modo per velocizzare la computazione delle reti neurali deep su Theano. Ad esempio, per schede video condivise con lo schermo si consiglia un paramentro intorno a 0.8, mentre per schede video stand-alone, ossia dedicate solo al Deep Learning, si consiglia un cnmem pari ad 1.

Un altro parametro molto importante per velocizzare la computazione, soprattutto per quanto riguarda la convoluzione, è il parametro “enabled” di [dnn] che permette di abilitare o disabilitare le librerie Nvidia CuDNN. E’ in pratica una libreria che fornisce primitive ottimizzate per le deep neural networks, permettendo di velocizzare il training, il testing ed anche ridurre il consumo di memoria. Per installare le CuDNN è necessario andare a questo link: https://developer.nvidia.com/cudnn e cliccare sul tasto download e procedere allo scarico (potrebbe essere necessaria la registrazione alla membership di Nvidia), dovrebbe aprirsi la seguente schermata:

 

 

NOTA cuDNN: anche qui come nei casi precedenti si consiglia di non scaricare l’ultima versione di cuDNN ma una o due precedenti in quanto rischia di non essere “vista” ne da Cuda 8 e ne da Theano 0.9, in tal caso si consiglia la versione cuDNN 6.0. E con Theano 0.9 si potrebbe comunque avere un warning indicante il fatto che la versione di cuDNN è molto recente e potrebbe creare eventuali problemi. Abbiamo verificato anche problemi di incompatibilità tra l’ultima versione di cuDNN e TensorFlow.

Scompattando il file scaricato, si otterranno 3 cartelle: bin, lib e include. Tutto quello che bisogna fare è copiare il contenuto delle cartelle nelle omonime cartelle dentro la directory di Cuda, ossia dentro: C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v8.0

Dunque copiare cudnn64_6.dll dentro la bin del path Cuda, copiare cudnn.h dentro include e infine copiare cudnn.lib dentro lib.

Una volta installato cuDNN, procedere con l’installazione di Keras attraverso pip:

pip install keras

L’istruzione installerà tutte le dipendenze ed anche l’ultima versione (attualmente Keras 2.0.9). Per settare Theano come backend di Keras, andare dentro la cartella: c:\users\-utente-\.keras ed editare il file keras.json nel seguente modo, ovvero impostando “theano” alla voce “backend”.

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

Per testare che tutto vada bene, avviare il prompt di anaconda, e lanciare python. Dentro il prompt di python digitare: import keras. Se tutto è andato per il verso giusto dovrebbe comparire la seguente schermata:

 

 

Notare il warning prima menzionato a proposito delle cuDNN e comunicato da Theano stesso: se si dovessero incontrare i problemi citati  effettuare il downgrade delle cuDNN alla versione 5.1 come raccomandato dallo stesso team. L’uscita della versione stabile di Theano 0.10 dovrebbe risolvere tutti questi problemi di compatibilità.

In ogni caso ci risulta che l’ambiente configurato con Keras e Theano in questo modo funziona perfettamente su una varietà di modelli che abbiamo addestrato e testato. Utilizziamo Theano perchè si presenta spesso più veloce di TensorFlow su alcuni addestramenti di Computer Vision.

In ogni caso se si volesse utilizzare TensorFlow come backend è necessario installarlo. Per installare tensorflow per GPU è necessario il seguente comando:

pip install –upgrade tensorflow-gpu

Questo installerà l’ultima versione (1.4.0) di Tensorflow-gpu. Per provarlo con Keras sostituire “theano” con la stringa “tensorflow” nel file keras.json, riavviare il prompt di anaconda e rifare import keras.

NOTA TensorFlow: non è supportato su piattaforme a 32 bit, la procedura di installazione vi scaricherà solo il wheel relativo al framework a 64 bit. Inoltre per scaricare la versione per cpu, dovrete solo specificare: pip install –upgrade tensorflow.

Se tutto è andato per il verso giusto, questa volta dovrebbe comparire TensorFlow come backend di keras:

 

Altri pacchetti utili, che consigliamo per lavorare con Keras sono:

  1. scikit-image: Una libreria molto utile di image processing in python, che permette tra le altre cose di salvare matrici e tensori in un immagine jpeg o tanti altri formati supportati. Installabile con: conda install scikit-image.
  2. gensim: La libreria per i word embeddings che implementa tra le altre cose l’algoritmo word2vec. Installabile con: conda install gensim.
  3. h5py: La libreria interfaccia al formato di salvataggio HDF5 di Pythonic, necessaria per salvare i modelli addestrati su disco in Keras. Installabile con pip install h5py.

A questo punto l’ambiente Keras/Tf-Th su Windows è pronto all’uso, per testare il vostro codice e i vostri modelli sfruttando nativamente la GPU.

Buon lavoro!

Al prossimo tutorial.

Un saluto da Deep Learning Italia.

 

Per info e chiarimenti ecco le nostre email:

Francesco Pugliese – f.pugliese@deeplearningitalia.com

Matteo Testi – m.testi@deeplearningitalia.com