Learning Deep Learning: 2017

zondag 29 oktober 2017

Weer lekker ... 4

Op deze site staan wat data - augmentation voorbeelden. De meesten blijken echter niet zinvol voor de MNIST dataset omdat de data al 'optimaal' geprepareerd is. (Horizontaal / centered / gelijke grootte)

https://machinelearningmastery.com/image-augmentation-deep-learning-keras/

Wat wel misschien zinvol is is de zca_whitening. Om de keras data augmentation te testen probeer ik dat uit op het model.

Dat lijkt alleen maar slechter te werken. Ik test toch ook wat verrijkingen door kleine verschuivingen en draaiingen toe te passen. Dat lijkt weinig effect te hebben maar het gaat iig niet (veel) omlaag. En in principe zou het netwerk hiermee robuuster moeten worden.

train_datagen = ImageDataGenerator(zca_whitening=False,

rotation_range=5,

width_shift_range=0.1,

height_shift_range=0.1,

shear_range=0.1,

zoom_range=0.1,

horizontal_flip=False,

fill_mode='nearest')

Een ander idee is om de onjuist geclassificeerde nummers dubbel of meerdere malen aan te bieden. Daardoor leert het model wellicht iets beter ook afwijkende varianten te beoordelen. Ik voeg hier elke epoch (na de eerste) alle foutief geclassificeerde nummers opnieuw toe. Uiteindelijk worden er zo 3432 extra toegevoegd. Met 20 epochs is dit het resultaat:

Een maximale score van 0.9956! (Bij epoch 15). Dat lijkt ietsjes beter.

Na toevoegen van shuflelen gaat het nog iets beter: 0.9959 bij epoch 14

Weer lekker testen met deep learning. 3

De laatst gevonden, beste waarde is deze: Van .9903 naar .9926 door een extra convolutional layer.

Learn = 0.001 (not 1)

Playing with the learning rate. The original optimizer in this model was Adadelta. There Keras advices not to 'fool around' with the default pararmeters. For another populair optimizer 'Adam' it can help to finetune this. First lets try the learning rate. I find there is some variation in the results due to different initialisations. The proper way to deal with that is 'quasi randomness'. I will try to add that in future tests.

keras.optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0)

Learn = 3e-05 Test loss: 0.0690871921693 Test accuracy: 0.9801

Learn = 0.0001 Test loss: 0.0280504023324 Test accuracy: 0.9915

Learn = 0.0003 Test loss: 0.0197399869517 Test accuracy: 0.9936

Learn = 0.001 Test loss: 0.0218230394037 Test accuracy: 0.9942

Learn = 0.003 Test loss: 0.0266497306848 Test accuracy: 0.9933

Learn = 0.01 Test loss: 7.57344366913 Test accuracy: 0.5143

With the default 0.001 we seem to be close to the optimum.

Learn = 0.0008 Test loss: 0.0185411315141 Test accuracy: 0.9943

Learn = 0.001 Test loss: 0.0218230394037 Test accuracy: 0.9942

Learn = 0.002 Test loss: 0.0207599511368 Test accuracy: 0.9944

Learn = 0.003 Test loss: 0.0214822151026 Test accuracy: 0.994

There seems little difference around .001 for the accuracy. However the loss is a little lower going to a learning rate of 0.0008. Let see if I can repeat that. I added now pseudo randomness so the results should now be repeatable.

Learn = 0.0008 Test loss: 0.0182288939081 Test accuracy: 0.9944

Van de parameters ook maar even getest met de decay wat niet veel lijkt op te leveren. Het kleiner maken van de epsilon van 1e-08 naar 1e-09 lijkt iets te helpen. Wel lastig om t ekijkn of iest echt beter is als je dichter bij het optimum komt. De stapjes zijn per definitie veel kleiner.

Learn = 0.0008 Test loss: 0.0185519629256 Test accuracy: 0.9945

Een Batchnormalisation layer lijkt weinig toe te voegen . Deze is na de Flatten layer voor de eerste Dense layer. Maar ook bij na de eerste conv layer gaan de prestaties achteruit.

Nog even wat installatie issues.

Mijn PATH variabelen blijven niet 'permanent'. D.w.z. dat ik ze elke keer eerst opnieuw moet aanbieden. Hier lees ik echter dat ze in het bashprofile kan plaatsen (met vi). En dat lijkt te lukken.

$ echo $CPATH

//Developer/NVIDIA/CUDA-8.0/include:

$LIBRARY_PATH

//home/Developer/NVIDIA/CUDA-8.0/lib:

vi ~/.bash_profile

export LD_LIBRARY_PATH=//Developer/NVIDIA/CUDA-8.0/lib:$LD_LIBRARY_PATH

export CPATH=//Developer/NVIDIA/CUDA-8.0/include:$CPATH

export LIBRARY_PATH=//home/Developer/NVIDIA/CUDA-8.0/lib:$LIBRARY_PATH

zaterdag 28 oktober 2017

Weer lekker testen met deep learning 2

Na de activaties ook maar eens kijken wat er gebeurd na meer Epochs. Bij linear activatie lijkt er sneller overfitting plaats te vinden. De test accuracy blijft achter. Geen wonder dat er vaak voor relu wordt gekozen bij convolutional net werken. (in een eerder bericht heb ik de relu functie laten zien).

Twee extra Dense layers geven in eerste instantie slechtere resultaten:( was test 0.9739)

Ook na 20 epochs ziet het er nog niet goede uit:

Met een extra convolutional layer (128) ziet het er zo uit:

Dat lijkt een aardige verbetering van 0.9739 naar 0.9816! Kijken of we er nog een kunnen toevoegen. De tijd is nog steeds 2 seconden per epoch. Lang leve de GPU versnelling.

We gaan terug in performance helaas. Snel er weer vanaf. Of ook even de Dense layer aanpassen naar 256?

Dat lijkt wel te werken maar ik heb toch een beter gevoel om 1 conv layer terug te gaan. Zou het ook helpen om dropout bij de conv layers te introduceren? Hij gaat nu wel naar 3 seconden per Epoch! De 3 extra dropout layers zijn blijkbaar rekenintensief.

We gaan weer achteruit. Op zich logisch. Wellicht moeten we nu wat langer trainen? Hmm, wel een verhoging naar 0.9836. Maar is het echte winst? We zaten op 0.9903 met de volledige set.

We hebben iig iets gewonnen van 0.9903 naar 0.9925. En er lijken nog groeimogelijkheden in het aantal epochs.

Toch nog even kijken of de dropout bij de convolutional layers niet teveel roet in het eten gooit: (deze is dus zonder extra dropouts - title vergeten aan te passen) Het lijkt beter zonder de dropouts maar wellicht vlakt het ook meer af. Misschien hebben de dropouts toch meer potentie.

Met doorleren (20 epochs) krijgen we met extra dropouts het volgende resultaat:

Dat geeft toch nauwelijks verbetering maar wel veel meet processing (17 sec per epoch ipv 13) . Weg weer met de dropouts! Morgen verder. Misschien met wat data-verrijking?!

Toch nog even de vergeten maxpooling eruit gehaald: Vreemd dat hij er nu 22 seconden (van 14) per epoch over doet?!

act = 'relu'

model = Sequential()

model.add(Conv2D(32, kernel_size=(3, 3),

activation=act,

input_shape=input_shape))

model.add(Conv2D(64, (3, 3), activation=act))

#model.add(MaxPooling2D(pool_size=(2, 2)))

model.add(Conv2D(128, (3, 3), activation=act))

model.add(Dropout(0.25))

model.add(MaxPooling2D(pool_size=(2, 2)))

model.add(Dropout(0.25))

model.add(Flatten())

model.add(Dense(128, activation=act))

model.add(Dropout(0.5))

model.add(Dense(128, activation=act))

model.add(Dropout(0.5))

Maxpooling werkt enorm versnellend. Een extra layer brengt het naar 8 seconden: Maar helaas geen verbetering:

Weer lekker testen met deep learning.

Na op Coursera de beroemde (in deeplearning kringen dan toch) cursus van Andrew Ng gevolgd te hebben (met certificaat !!!!) nu weer eens even lekker zelf experimenteren.

'Eenvoudig' weer beginnen met een klein convolutional netwerk op de MNIST getallen dataset. Zo'n 60K aan geclassificeerde, handgeschreven getallen. Mijn eerste doel is om beter de resultaten van een DL experiment te kunnen beoordelen. Ik neem daarom een Keras voorbeeld en draai de volgende grafieken (ik heb voor het gemak ook maar de maximale gevonden waardes erbij gezet). Het lijkt vreemd dat de test set hoger uitkomt dan de train set. Op de Keras site lees ik al snel waarom. Bij de de test set worden de 'Dropout layers', die dienen om overfitting tegen te gaan en dus meer generalisatie op moeten leveren, uitgezet. Leuk om dat eens te testen. Tevens kijk ik wel effect een kleinere trainset met zich meebrengt (10.000 ipv 60.000):

Conclusie is idd dat als de dropout layers eruit worden gehaald de accuracy van de test set idd lager is. Tevens is er een veel grilliger verloop, vermoedelijk door overfitting. De verkleining van de trainset geeft een versnelling van 11 naar 2 seconden per Epoch en toch een behoorlijk verklarend resultaat. D.w.z. dat het erop lijkt dat er eerst met een kleinere set getest kan worden om de modellen en parameters optimaal te krijgen en vervolgens de uitgebreidere training gedaan kan worden.

Ik meende dat sigmoid ook gebruikt kon worden als activatie in plaats van relu maar niet dus:

Conclusie blijkt dat idd relu het beste lijkt met een goede runner-up voor linear. Bij beiden lijken er nog groei mogelijkheden in het aantal epochs te zitten.

Installatie perikelen

Wat een drama! Mijn GPU accelerator in Theano blijkt weer inactief. Zowel Cuda als CuDNN. Na vele nieuwe installaties met o.a. miniconda, Xcode 9 en zo bleef ik een foutmelding krijgen:

The nvidia driver version installed with this OS does not give good results for reduction.

Navragen op het nvidia of theano forum levert helaas niets op. Uiteindelijk na vele omzwervingen heb ik Xcode 7.3.1 en Cuda version : Cuda compilation tools, release 8.0, V8.0.61 en CuDNN cudnn-8.0-osx-x64-v5.1 er weer op gekregen en na onderstaande pad aanpassingen gelukkig nu weer de oude melding terug:

WARNING (theano.sandbox.cuda): The cuda backend is deprecated and will be removed in the next release (v0.10). Please switch to the gpuarray backend. You can get more information about how to switch at this URL:

https://github.com/Theano/Theano/wiki/Converting-to-the-new-gpu-back-end%28gpuarray%29

Using gpu device 0: GeForce GTX 1080 Ti (CNMeM is disabled, cuDNN 5110)

export LD_LIBRARY_PATH=//Developer/NVIDIA/CUDA-8.0/lib:$LD_LIBRARY_PATH

export CPATH=//Developer/NVIDIA/CUDA-8.0/include:$CPATH

export LIBRARY_PATH=//home/Developer/NVIDIA/CUDA-8.0/lib:$LIBRARY_PATH

maandag 4 september 2017

Installatie nieuwe grafische kaart met Cuda en CuDNN

Nieuw pc-tje, nieuwe grafische kaart dus ook hernieuwde installatie perikelen.
Maar ... het is weer gelukt geloof ik.

- Wat heb ik gedaan?

Een tijdje geleden heb ik al python en theano geinstalleerd. Theano geeft keurig aan als het de GPU gebruikt en CuDNN maar helaas dus. Geen van beide. Gelukkig lukt het me nu vrij snel om e.e.a. weer op de rit te krijgen.

Eerst de theanorc maar weer aangepast. Die moet op de $HOME directory geplaatst worden.

vi ~/.theanorc

De inhoud zoek ik op van een eerder bericht op deze blog.

[global]

floatX=float32

device=gpu

#force_device = True

#allow_gc = False

#optimizer_including=cudnn

[cuda]

#root=/Developer/NVIDIA/CUDA-7.0/lib

#cxxflags = -L/Developer/NVIDIA/CUDA-7.0/lib

[lib]

#cnmem=.75

(Alleen de eerste 3 regels zijn niet 'afgehashed' dus relevant.)
Kijk nu geef hij al:

>>> import theano

https://github.com/Theano/Theano/wiki/Converting-to-the-new-gpu-back-end%28gpuarray%29

Using gpu device 0: GeForce GTX 1080 Ti (CNMeM is disabled, cuDNN None)

Using GPU device !!!! Mooi !!! Maar nog geen CuDNN
Ook dat vind ik terug in een eerder bericht:

Voor CuDNN heb ik de handmatige installatie gedaan. Eerst versie 8.0 gedownload van de NVIDEA site. Daarna de bestanden naar de actieve cuda directory gekopieerd. Het gaat om deze bestanden:

Het eerste bestand gaat naar de

/Developer/NVIDIA/CUDA-8.0/include

de andere naar de /Developer/NVIDIA/CUDA-8.0/lib

et voila. Het werkt!

Helaas deze keer nog niet. Maar ik zie dat ik de juiste directories nog niet heb toegevoegd aan wat padnamen:

export LD_LIBRARY_PATH=//Developer/NVIDIA/CUDA-8.0/lib:$LD_LIBRARY_PATH

export CPATH=//Developer/NVIDIA/CUDA-8.0/include:$CPATH

export LIBRARY_PATH=//home/Developer/NVIDIA/CUDA-8.0/lib:$LIBRARY_PATH

En kijk:

Using gpu device 0: GeForce GTX 1080 Ti (CNMeM is disabled, cuDNN 5110)

CuDNN 5110 !!!!! Helemaal goed!!! Ik moet alleen nog even kijken hoe ik deze padnamen ook alweer standaard aangeroepen krijg. Ik zie dat ze na herstarten weer vergeten zijn. Ook dat heb ik een keer eerder opgelost. Ga ik een andere keer nog eens naar kijken.

dinsdag 25 april 2017

Autoencoders 1

Een autoencoder is een neuraal netwerk met een compressie en een decompressie gedeelte. Toepassing is bijvoorbeeld een de-noiser waarbij 'de ruis' uit afbeeldingen kan worden gehaald. Om een autoencoder te trainen geef je in principe dezelfde input als de output. Het netwerk leert dan deze gegevens in een heel gecomprimeerde vorm weer te geven.
Leuk om eens mee te experimenteren. Ik vind hier een aardige voorbeeld site en besluit daarop geïnspireerd ook maar weer eens de mnist-dataset te gebruiken. De mnist-dataset bestaat uit een 60K geclassificeerde, zeer wisselend geschreven cijfers van 0 tot 9. De 'afbeeldingen zijn behoorlijk compact (28x28 pixels) waardoor er relatief makkelijk mee te werken is. Bovendien biedt Keras, mijn favorite DL framework, de dataset standaard aan om mee te testen. (Lekker lui :-)

Ik gebruik het convolutional model uit bovenstaande site. Keras heeft de mogelijkheid om met een Theano backend of met een (Google) Tensorflow backend te werken. Hoewel in principe beide voor mij zou kunnen krijg ik Tensorflow zo snel niet werkend op de GPU. Dan maar op Theano.

Ik wil proberen of met autoencoders op een of andere wijze de 'essentie' van afbeeldingen kunnen worden getraind. Zoiets van 'dat op de afbeelding wat van belang is voor een classificatie'. En de rest negeren. Onze hersenen zijn daar juist zeer goed in. Al heel snel vind je meestal de locatie van iets kenmerkends voor de afbeelding.

Ik besluit eerst eens te kijken of ik een autoencoder kan gebruiken om de wisselend geschreven letters om te zetten naar 'model letters'. Daartoe kies ik een tiental mooi geschreven voorbeelden en biedt die aan de autoencoder. Dit is het resultaat:

De bovenste regel geeft de gekozen model getallen weer. De 2e enkele willekeurige testgetallen en de derde regel geef het resultaat na 150 epochs trainen. Hij lijkt het redelijk te doen. Hier het verloop van de trainingsresultaten:

zaterdag 22 april 2017

Opnieuw installatie issues

Mijn Macpro is helaas wat aan het verouderen. Momenteel start hij niet meer betrouwbaar op. Vaak stopt die gewoon na een paar seconden en begint de ventilator hard te blazen. Na een aantal keren opstarten wordt die wel stabiel en kan ik er gelukkig goed mee werken. Vermoedelijk door wat ongeduld bij het herstarten is echter mijn opstart SSD ook defect geraakt. Ik heb een nieuwe SSD gekocht en ben nu alles weer 'recht aan het breien'.

Dat wil ook zeggen dat alle Python programma's en toebehoren weer geïnstalleerd moeten worden. Zojuist bezig geweest met de GPU en CuDNN ondersteuning voor deep learning projecten. Dat was vorige keer een flinke klus en hoewel het nu iets sneller gaat zitten er toch een hoop haken en ogen aan. Maar weer even vastleggen.

Python had ik al wat eerder geïnstalleerd. Ook Theano werkt wel maar dus zonder de GPU ondersteuning.

Ik start met deze pagina:

http://deeplearning.net/software/theano/tutorial/using_gpu.html

Och ja, ik moet de .theanorc file aanmaken op de root (/usr/local) en aanpassen. Dat ging met de tekst editor 'vi'.
Het blijft lastig om de commando's te herinneren als je hem weinig gebruikt. Met 'i' kom je in de insert mode. Met escape --> ':wq' Schrijf je de aanpassingen weg.

[global]
device = cuda

floatX = float32

Het werkt nog niet. (ImportError: No module named pygpu) Ik probeer tevergeefs 'device = cpu0'. Hmm ... pygpu ... Ik zie dat er een nieuwe manier is om de GPU aan te spreken.

Dat staat hier beschreven:

https://github.com/Theano/Theano/wiki/Converting-to-the-new-gpu-back-end%28gpuarray%29

Als eerste wordt verwezen naar

http://deeplearning.net/software/libgpuarray/installation.html#step-by-step-install-system-library-as-admin

Daar moet eerst cmake 3.8.0 geïnstalleerd worden (cmake.org) Ik installeer de laatste versie. Vervolgens haal ik de laatste CUDA versie (8.0.61) op van de nvidea site. OpenCL zoek ik ook maar dat wordt in de drivers van de grafische kaart al bijgeleverd.

De download van libgpuarray met 'git' gaat goed. De volgende stappen geven wat issues. Met name cmake kent hij niet als commando in de terminal. Ik herinner mij dat ik dat vorige keer ook via het cmake userwindow heb uitgevoerd.

Na de selectie van de directories en configure en generate weer terug naar het script. Daar moet de make en de make install worden uitgevoerd. Hij geeft helaas aan dat hij de library 'cython' niet kan vinden wat ik gelukkig met 'pip install cython' kan verhelpen.

De 'python setup.py build' en 'pyhton setup.py install' lijken zonder problemen te werken.

Helaas geeft Theano nog steeds een foutmelding:

"clang: warning: treating 'c-header' input as 'c++-header' when in C++ mode, this behavior is deprecated"

Het lukt mij niet om de melding weg te krijgen. Ergens in de installatie heb ik blijkbaar iets fout gedaan.

Ik probeer het op de 'oude manier'. Schakelen tussen nieuw en oud gaat zo (in .theanorc): Use device=cuda or cuda0, ... instead of gpu. Yes !!! Dat lijkt gelukkig te lukken.

Ik haal nu ook Cudnn 8.0 v 5.1 op van de nvidea site. Door weer de cudnn files naar de juiste folders in cuda te zetten (zie eerder bericht) lukt het om ook cuDNN actief te krijgen. Wel moet ik weer de paden aangeven die gebruikt moeten worden.

Ik gebruik de info vanuit hier:
https://coolestguidesontheplanet.com/add-shell-path-osx/
en creëer met vi een .bash_profile om de paden fixed te laten opstarten.

export PATH="/usr/local/cuda/bin/:$PATH"

export LD_LIBRARY_PATH="/usr/local/cuda/lib64:$LD_LIBRARY_PATH"

En het werkt!!!! :

https://github.com/Theano/Theano/wiki/Converting-to-the-new-gpu-back-end%28gpuarray%29

Using gpu device 0: GeForce GTX 980 (CNMeM is disabled, cuDNN 5110)

Wel is de warning wat zorgelijk. Misschien later toch nog eens die @@#$% gpuarray aan de praat zien te krijgen.

zaterdag 11 februari 2017

Even spelen met DL

Siraj heeft een prachtige serie, door zijn snelheid haast onnavolgbare, tutorials over deel learning. Een daarvan gaat over 'de AI artist'. Gaaf om eens even mee bezig te gaan. Het blijkt vrij makkelijk om aan het werk te krijgen alleen werkt deze met (veel) 'runtime attributen', dus even precies nagaan hoe dat ook alweer moet werken. Gelukkig zijn de meeste optioneel.

Door het combineren van kunstenaarsstijl en een bestaande foto kunnen prachtige kunstwerken worden gerealiseerd. Hier wat voorbeelden. In de derde kolom staat uiteraard het resultaat meesterwerk.