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 

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