Nieuwsgierig naar de foutjes

Door de parameters aan te passen in de SVM.SVC (Support Vector Machines / Support Vector Classification) functie namenlijk gamma  en C (gamma = Kernel coefficient for ‘rbf’, ‘poly’ and ‘sigmoid’. en C = Penalty parameter C of the error term - even doen alsof ik het begrijp :-) kan de gevoeligheid worden afgestemd op de betreffende invoer.

In eerste instantie maar eens alleen met de gamma spelen. Rond de 0.025 en 0.03 lijkt een betrouwbaarheid piek te zitten (97.02% bij 10.000 oefencijfers). Waarom is er geen DL-algoritme om dat optimum te bepalen? :-) Ik neem aan dat dat ook wel ergens zal zijn bedacht.

Ook is het interessant welke cijfers nou fout worden ingeschat. Na wat experimenteren met de code lukt het mij om ook daar voorbeelden van te tonen. De fouten lijken aannemelijk. Het zijn de complexere afbeeldingen. Vooral de laatste 2 rechtsonder zijn wel verrassend. Het lijkt zo beschouwd een wonder dat het convolutional netwerk uit oefening 5 in de buurt van de 99.5% komt:

('Prediction:', array([2]), 3)

('Prediction:', array([2]), 3)

('Prediction:', array([6]), 1)

('Prediction:', array([8]), 1

('Prediction:', array([5]), 1)

('Prediction:', array([6]), 5)

('Prediction:', array([4]), 7)

('Prediction:', array([9]), 2) ??

('Prediction:', array([8]), 9)

('Prediction:', array([4]), 9) ??

De gebruikte programmacode:

import matplotlib.pyplot as plt

import numpy as np

import time

from sklearn import svm

from load import mnist

trX, teX, trY, teY = mnist(onehot=True)

t0 = time.time()

ga = 0.027

size = 10000

clf = svm.SVC(gamma=ga, C=100)

clf.fit(trX[:size],np.argmax(trY[:size], axis=1))

print "reliability: ", np.mean(np.argmax(teY,axis=1) == clf.predict(teX)), time.time() - t0, "seconds, gamma: ", ga, " size :", size

t = 0

i = 0

while (t < 5 and i < 10000):

    if (np.argmax(teY[i],axis=0) != clf.predict(teX[i])):

        t += 1

        print ('Prediction:', clf.predict(teX[i]), np.argmax(teY[i],axis=0), "i - " , i)

        im=teX[i]

        im.shape=28,28

        plt.imshow(im, cmap=plt.cm.gray_r, interpolation="nearest")

        plt.show()

    i += 1

Sklearn testen met de mnist dataset.

Tja, de titel lijkt aan te geven dat ik er wat van begin te begrijpen :-)
Dat valt best wel tegen. Maar in de gevolgde cursus over deep learning met Python is gebruik gemaakt van de mnist dataset: Een verzameling van 60.000 handgeschreven cijfers en hun juiste uitkomsten.
Onlangs ben ik mij wat gaan verdiepen in sklearn: Een open deeplearning bibliotheek. Ook daar werd een voorbeeld met handgeschreven tekens gegeven. Nu ben ik deze maar eens gaan combineren. De mnist dataset zijn karakters van 28x28 terwijl die van sklearn 8 x 8 zijn. Zou het gebruikte sklearn algoritme ook werken met deze grotere dataset?
Het oorspronkelijke voorbeeld met sklearn data:

import matplotlib.pyplot as plt

from sklearn import datasets

from sklearn import svm

from load import mnist

digits = datasets.load_digits()

clf = svm.SVC(gamma=0.0001, C=100)

x,y = digits.data[:-1], digits.target[:-1]

clf.fit(x,y)

t=-5

print ('Prediction:', clf.predict(digits.data[t]))

plt.imshow(digits.images[t], cmap=plt.cm.gray_r, interpolation="nearest")

plt.show() 

geeft :

('Prediction:', array([9]))

Het gebruik van de mnist dataset in plaats van de sklearn blijkt relatief eenvoudig. Wel is er een verschil in de vorm die fouten geeft waar ik eerst niets van snap. Uiteindelijk blijkt dat 'het target array' bij sklearn gewoon uit de getallen 0 t/m 9 bestaat terwijl dat bij mnist arrays zijn van 10 waarden bijv. [0 , 0 , 0, 1, 0, 0, 0, 0, 0, 0] om een 3 aan te geven. Uit een van de voorbeeld netwerken 'vis' ik de numpy functie 'argmax' en, hoepla, het werkt! Alleen de grafische weergave moet ook wat worden aangepast maar dat had ik al eens eerder uitgezocht. Tevens maak ik een reeks testvoorbeelden aan in plaats van steeds maar 1. En ook nog een betrouwbaarheidsmeting (1 regel) vanuit de mnist cursus toegevoegd. 

De nieuwe code is zo:  

import matplotlib.pyplot as plt

import numpy as np

from sklearn import svm                                     # support vector machines

from load import mnist                                        # inladen 60000 leer en 10000 test getallen.

trX, teX, trY, teY = mnist(onehot=True)

clf = svm.SVC(gamma=0.0001, C=100)             # Instellen van de 'gevoeligheden' van het netwerk

clf.fit(trX[:5000],np.argmax(trY[:5000], axis=1))  # Leren 

print np.mean(np.argmax(teY,axis=1) == clf.predict(teX))  # Meten behaalde betrouwbaarheid

for t in range(-50,-40):                                                         # Weergeven van enke testvoorbeelden

    print ('Prediction:', clf.predict(teX[t]))

    im=teX[t]

    im.shape=28,28

    plt.imshow(im, cmap=plt.cm.gray_r, interpolation="nearest")

    plt.show()

Hij doet er (uiteraard) iets langer over om te trainen maar het resultaat mag er zijn. Met 5.000 trainingsvoorbeelden al een betrouwbaarheid van  92.32%. Met 10.000 gaat hij in 96 seconden naar de 93.09%. Met 30.000 neemt 'hij' 383 seconden om naar de 94.34% te kruipen. Door de gamma te vergroten (naar 0.01) groeit de betrouwbaarheid bij 10.000 voorbeelden al naar 96.58%. De gamma geeft de stapgrootte aan richting het optimum. Maak je die te groot dan 'stap je' over het optimum heen. De 'C' parameter is de Radius Basis Function (RBF). Uitleg over de parameters staat hier. We zijn nog ver van 'de commerciële norm' van 99.5% maar toch, voor die paar regeltjes code...

Voorbeelden:

('Prediction:', array([2]))

('Prediction:', array([6]))

Grafische kaart niet op gang te krijgen.

De afgelopen dagen vele uren bezig geweest met het in en uitbouwen van de grafische kaarten. Welke tip ik van de forums ook uitprobeer, het resultaat blijft een leeg, zwart scherm. Ook een proef met een Windows installatie op de Mac en een test in de game pc van Mick geeft hetzelfde resultaat. Zwart, heel erg zwart!
Je leert wel alle 'donkere' ;-) uithoeken van je computer kennen. Ingewikkelde "command-prompt" commando's. (De terminal commando's - Doet weer een beetje aan de DOS tijd denken)  Command - Option (Alt) R+P ook bijvoorbeeld om het NVRAM van de mac opnieuw in te stellen. Ook dat een W7 installatie op een macpro soms niet lukt totdat de bootdisc van de mac verwijderd wordt. (Of had het toch iets met Tuxura, mijn NTFS ondersteuningsprogramma te maken?)

Gelukkig heb ik mijn kaart bij CoolBlue gekocht waar de service tot nu toe heel goed is gebleken. Ik hoop dat ik snel een werkende kaart terug krijg want de betere deeplearning testjes blijven op zich wachten. Gelukkig biedt internet nog veel meer informatie waar ik dan wel weer beter aan toe kom.

Zo blijkt Indico, het bedrijf waar de ceo de "deeplearning met Pyhton" cursus van verzorgde, gratis eenvoudig toepasbare dl-software te bieden. Er zijn wat leuke voorbeelden op de site.

Zelf experimenteren 3

Bij het vergelijken van het effect/bijdrage van een functie in een model moet wel rekening worden gehouden met de variatie. Doordat er steeds van random waarden wordt uitgegaan (de start waarden en de de dropout) levert elke loop een nieuw resultaat op. Dit is niet per definitie beter dan het voorgaande. Ik vergelijk steeds het resultaat van de 100e leer-loop maar zoals aangegeven zit er dus best wel variatie in.

Resultaat zonder 2e rectify

  Het weglaten van functies uit het 'moderne netwerk' (oefening 4) geeft de volgende resultaten:

• 98.77 Origineel - 3437 sec
• 98.68 input noise (dropout op X) - 3368 sec
• 98.70 output noise (dropout op h2) - 3088 sec
• 98.79 middle noise (dropout op h) - 3112 sec.
• 98.47 geen noise - 2838 sec
• 97.98 Eerste rectify - 3128 sec
• 98.52 Tweede rectify - 3208 sec

Conclusies.

• De eerste rectify lijkt in ieder geval heel relevant. De tweede helpt toch ook wel.
• Noise lijkt wel noodzakelijk maar het maakt niet veel uit in welke laag die geproduceerd wordt.
• Het weglaten van de middle noise geeft 225 seconden tijdswinst (6.5%) en schijnbaar geen teruggang in resultaten. Blijft dat de variatie in het resultaat de conclusies kunnen beïnvloeden. Tevens hangt de tijdwinst uiteraard ook af van andere processen op de computer.

Resultaat bij geen 'middle noise'.

Vijde deel in "Deep Learning met Python" cursus: Convolutional network

Eindelijk zijn we dan bij de 'heilige graal' aangekomen. Het convolutional network. Een netwerk architectuur die onze betrouwbaarheid naar het niveau van 99.5% moet gaan tillen. Het ontwerp gaat ervan uit dat er meer gekeken wordt naar eigenschappen (features) van de geschreven getallen dan naar de getallen als geheel. Een logische gedachte als je bedenkt dat bijvoorbeeld exact dezelfde 4 op verschillende plaatsen en met verschillende schalen en / of rotaties opgeschreven kan zijn.

Er wordt uitgegaan van kleine matrixes van 3x3 om de basiskenmerken vast te leggen van delen van de afbeeldingen. Deze werken als een soort mini-lensjes. Daarna worden die via 'downsampling' overgezet naar een 2x zo grote, volgende verborgen laag. (Ik doe nu net even of ik het snap :-)

... beschrijving code wordt vervolgd ....  

Ook deze code blijkt bij mij in eerste instantie niet te werken. Na diep spitten door alle foutmeldingen blijkt mijn installatie niet het type T.ftensor4() te kennen. Gelukkig ontdek ik dat T.dtensor4() een alias is voor hetzelfde datatype.

Nu blijkt wel heel sterk de behoefte aan rekenkracht. Een enkele leer-loop duurt meer dan 50 minuten. En ik heb er 100 te gaan! Daar kan ik niet op wachten. Gelukkig zijn de eerste betrouwbaarheids-resultaten veel belovend. Na een nachtje doorrekenen zit het al een heel eind richting de beloofde 99.5% Uit een test programmaatje blijkt dat ik dus geen gebruik maak van de GPU, de grafische processor. Tja, dat maakt experimenteren met convolutional netwerken wel erg lastig. Helaas heb ik mijn nieuwe kaart nog steeds niet aan de praat kunnen krijgen.

import theano

from theano import tensor as T

from theano.sandbox.rng_mrg import MRG_RandomStreams as RandomStreams

import numpy as np

from load import mnist

from theano.tensor.nnet.conv import conv2d

from theano.tensor.signal.downsample import max_pool_2d

import time

srng = RandomStreams()

def floatX(X):

    return np.asarray(X, dtype=theano.config.floatX)

def init_weights(shape):

    return theano.shared(floatX(np.random.randn(*shape) * 0.01))

def rectify(X):

    return T.maximum(X, 0.)

def softmax(X):

    e_x = T.exp(X - X.max(axis=1).dimshuffle(0, 'x'))

    return e_x / e_x.sum(axis=1).dimshuffle(0, 'x')

def dropout(X, p=0.):

    if p > 0:

        retain_prob = 1 - p

        X *= srng.binomial(X.shape, p=retain_prob, dtype=theano.config.floatX)

        X /= retain_prob

    return X

def RMSprop(cost, params, lr=0.001, rho=0.9, epsilon=1e-6):

    grads = T.grad(cost=cost, wrt=params)

    updates = []

    for p, g in zip(params, grads):

        acc = theano.shared(p.get_value() * 0.)

        acc_new = rho * acc + (1 - rho) * g ** 2

        gradient_scaling = T.sqrt(acc_new + epsilon)

        g = g / gradient_scaling

        updates.append((acc, acc_new))

        updates.append((p, p - lr * g))

    return updates

def model(X, w, w2, w3, w4, p_drop_conv, p_drop_hidden):

    l1a = rectify(conv2d(X, w, border_mode='full'))

    l1 = max_pool_2d(l1a, (2, 2))

    l1 = dropout(l1, p_drop_conv)

    l2a = rectify(conv2d(l1, w2))

    l2 = max_pool_2d(l2a, (2, 2))

    l2 = dropout(l2, p_drop_conv)

    l3a = rectify(conv2d(l2, w3))

    l3b = max_pool_2d(l3a, (2, 2))

    l3 = T.flatten(l3b, outdim=2)

    l3 = dropout(l3, p_drop_conv)

    l4 = rectify(T.dot(l3, w4))

    l4 = dropout(l4, p_drop_hidden)

    pyx = softmax(T.dot(l4, w_o))

    return l1, l2, l3, l4, pyx

trX, teX, trY, teY = mnist(onehot=True)

trX = trX.reshape(-1, 1, 28, 28)

teX = teX.reshape(-1, 1, 28, 28)

X = T.dtensor4()    # Aangepast!!! was T.ftensor4()

Y = T.fmatrix()

w = init_weights((32, 1, 3, 3))

w2 = init_weights((64, 32, 3, 3))

w3 = init_weights((128, 64, 3, 3))

w4 = init_weights((128 * 3 * 3, 625))

w_o = init_weights((625, 10))

noise_l1, noise_l2, noise_l3, noise_l4, noise_py_x = model(X, w, w2, w3, w4, 0.2, 0.5)

l1, l2, l3, l4, py_x = model(X, w, w2, w3, w4, 0., 0.)

y_x = T.argmax(py_x, axis=1)

cost = T.mean(T.nnet.categorical_crossentropy(noise_py_x, Y))

params = [w, w2, w3, w4, w_o]

updates = RMSprop(cost, params, lr=0.001)

train = theano.function(inputs=[X, Y], outputs=cost, updates=updates, allow_input_downcast=True)

predict = theano.function(inputs=[X], outputs=y_x, allow_input_downcast=True)

t0 = time.time()

for i in range(100):

    for start, end in zip(range(0, len(trX), 128), range(128, len(trX), 128)):

        cost = train(trX[start:end], trY[start:end])

    print np.mean(np.argmax(teY, axis=1) == predict(teX))

    print time.time() - t0, "seconds"

    t0 = time.time()

Zelf experimenteren 2

Zoals verwacht levert elke eerste verbeterstap het meeste op in betrouwbaarheid. Als ik de RMSprop functie (De 'versnelde gradient) bijvoorbeeld alleen aan het '3e algoritme' ('gewoon netwerk') toevoeg dan stijgt de score naar 98.17% Vrijwel evenveel als het alleen toevoegen van de rectify functie. (98.19%) Nu nog kijken of de verlaging na de input noise stap (van 98.19 naar 97.96) wel iets is om rekening mee te houden. Ik ga deze in het 'moderne netwerk algoritme' eens afzetten.

Zelf experimenteren ...

Zo nu wordt het interessant! (vind ik dan toch :-)
De verbeteringen in het vierde algoritme hebben een toename van de betrouwbaarheid laten zien van 95,71% naar 98,77%. (Van 'net' naar 'modern net') Maar welke aanpassing levert nu wat op?
Om dat te testen besluit ik het eenvoudiger netwerk uit de 3e oefening stap voor stap met de verbeterde functies uit te breiden. Geeft ook de mogelijkheid om eens wat met de modellen te experimenteren. Ik krijg het volgende resultaat:

• 95.71% - Origineel
• 98.19% - De rectify functie (wow!)
  

• 97.96% - Dropout op input
• 98.38% - Dropout op weights
• 98.41% - Nieuwe softmax functie
• 98.65% - Gebruik van de RMSprop functie.

Hoewel de rectify functie het meest lijkt bij te dragen is het wellicht nog eens interessant om andere volgordes uit te proberen. Het blijkt (logischerwijs) dat de stappen richting de 100% steeds moeilijker worden dus wellicht geeft deze volgorde een vertekend beeld. Ook is het interessant om te kijken of de dropout op de input wel ingezet zou moeten worden. Op dit moment lijkt het de score juist te verlagen. Ik heb het nog niet uitgeprobeerd.

OpenCV - Voor beeldbewerking

Een groepje van 4 studenten hebben een bril gemaakt die merk-afbeeldingen vervaagt. Dat lijkt toch aardige 'intelligent'. Het lukte ze volledig in 2 dagen tijd! Ook hiervoor werd Python gebruikt in combinatie met OpenCV, een open source bilbliotheek met allemaal slimme beeldbewerkingsalgoritmen.

Ze gebruikten hiervoor het zogenaamde sift algoritme (Scale-invariant feature transform)

Vierde deel in "Deep Learning met Python" cursus - Modern netwerk

De gradient-functie (sgd) nadert maar langzaam zijn optimum.

In het vierde deel wordt de netwerk opzet verbeterd:

• Een 'rectify' functie die in principe alle negatieve waarden naar nul terugbrengt waardoor er steeds met 'schone' waardes wordt gewerkt.
• Een aangepaste softmax functie. Dit heeft meer een technische reden. De ingebouwde softmax blijkt niet altijd goed te voldoen.
• De RMSprop functie. Een mooie grafiek (zie hierboven) laat zien dat de eerder gebruikte 'gradient-functie' bij het 'leren' steeds langzamer naar het gewenste optimum toe gaat. De hier gedefinieerde RMSprop functie doet dit veel sneller. Er zijn dus minder leer-loops noodzakelijk om bij het gewenste punt uit te komen.          
• De dropout functie. Deze wordt gebruikt om bewust, random 'vervuiling' in de invoer en in de verborgen lagen aan te brengen. Hierdoor wordt het leren iets flexibeler. 
• De tussenlaag is 784x625 en de output laag is 625x10. Het is mij nog niet helemaal duidelijk hoe deze formaten zijn gekozen. Alleen de 784 (28*28) is gelijk aan de input en de 10 is gelijk aan het aantal mogelijke uitkomsten. Het formaat daartussen (625 = 25*25) begrijp ik niet helemaal.

Hier is de betreffende code. Na 100 leerloops wordt er een betrouwbaarheid mee bereikt van 98,77%
Alweer een stapje dichter bij het noodzakelijke niveau van  99,5%. Straks kijken wat een 'convolutional network' gaat brengen!

import theano

from theano import tensor as T

from theano.sandbox.rng_mrg import MRG_RandomStreams as RandomStreams

import numpy as np

import time

from load import mnist

srng = RandomStreams()

def floatX(X):

    return np.asarray(X, dtype=theano.config.floatX)

def init_weights(shape):

    return theano.shared(floatX(np.random.randn(*shape) * 0.01))

def rectify(X):

    return T.maximum(X, 0.)

def softmax(X):

    e_x = T.exp(X - X.max(axis=1).dimshuffle(0, 'x'))

    return e_x / e_x.sum(axis=1).dimshuffle(0, 'x')

def RMSprop(cost, params, lr=0.001, rho=0.9, epsilon=1e-6):

    grads = T.grad(cost=cost, wrt=params)

    updates = []

    for p, g in zip(params, grads):

        acc = theano.shared(p.get_value() * 0.)

        acc_new = rho * acc + (1 - rho) * g ** 2

        gradient_scaling = T.sqrt(acc_new + epsilon)

        g = g / gradient_scaling

        updates.append((acc, acc_new))

        updates.append((p, p - lr * g))

    return updates

def dropout(X, p=0.):

    if p > 0:

        retain_prob = 1 - p

        X *= srng.binomial(X.shape, p=retain_prob, dtype=theano.config.floatX)

        X /= retain_prob

    return X

def model(X, w_h, w_h2, w_o, p_drop_input, p_drop_hidden):

    X = dropout(X, p_drop_input)

    h = rectify(T.dot(X, w_h))

    h = dropout(h, p_drop_hidden)

    h2 = rectify(T.dot(h, w_h2))

    h2 = dropout(h2, p_drop_hidden)

    py_x = softmax(T.dot(h2, w_o))

    return h, h2, py_x

trX, teX, trY, teY = mnist(onehot=True)

X = T.fmatrix()

Y = T.fmatrix()

w_h = init_weights((784, 625))

w_h2 = init_weights((625, 625))

w_o = init_weights((625, 10))

noise_h, noise_h2, noise_py_x = model(X, w_h, w_h2, w_o, 0.2, 0.5)

h, h2, py_x = model(X, w_h, w_h2, w_o, 0., 0.)

y_x = T.argmax(py_x, axis=1)

cost = T.mean(T.nnet.categorical_crossentropy(noise_py_x, Y))

params = [w_h, w_h2, w_o]

updates = RMSprop(cost, params, lr=0.001)

train = theano.function(inputs=[X, Y], outputs=cost, updates=updates, allow_input_downcast=True)

predict = theano.function(inputs=[X], outputs=y_x, allow_input_downcast=True)

t0 = time.time()

for i in range(100):

    for start, end in zip(range(0, len(trX), 128), range(128, len(trX), 128)):

        cost = train(trX[start:end], trY[start:end])

    print np.mean(np.argmax(teY, axis=1) == predict(teX))

print time.time() - t0, "seconds"

Snoertje binnen!

Bij Amazon in Duitsland een extra voedingsnoertje weten te bestellen voor de nieuwe grafische kaart (GTX 980) . Om geen verzendkosten te hebben maar een USB3.0 kaartje erbij gekocht. Kom je net boven de 30 euro. Gelukkig blijkt het snoertje te passen. Helaas levert dat na het plaatsen nog geen beeld op. Wel lijkt er geen echte 'dump' meer te ontstaan want ik hoor een Youtube filmpje starten nadat ik 'blind' het toegangspassword heb ingevuld. Maar ja, wat nu? Zelfs het youtube filmpje over de gevaren van deep learning is minder interessant zonder beeld :-)

Toch maar weer eens kijken of alles wel geïnstalleerd is.  De Cuda software (Extra software voor de nvidea gpu te gebruiken) lijkt de GPU driver niet te herkennen.  Zo te zien moet ook nog de Cuda toolkit worden geïnstalleerd.  De instructies hiervoor zijn, voor een minder ervaren apple-terminal-gebruiker als ik, lastig te volgen. Uiteindelijk kom ik een heel eind. Het lijkt noodzakelijk om ook de bijgeleverde 'samples' te compileren. Na de juiste aanroep te hebben gevonden (net weer iets anders dan beschreven) is de computer nu al een uurtje bezig om alles te compileren. De meest ingewikkelde info raast door het terminal venster.  Ik ben benieuwd wanneer die klaar is - en ... of het dan wel gaat werken.

Klein voorbeeldje

/Developer/NVIDIA/CUDA-7.0/bin/nvcc -ccbin clang++   -m64  -Xcompiler -arch -Xcompiler x86_64  -Xlinker -rpath -Xlinker /Developer/NVIDIA/CUDA-7.0/lib  -gencode arch=compute_20,code=compute_20 -o jpegNPP jpegNPP.o  -L../common/FreeImage/lib -L../common/FreeImage/lib/darwin -L../common/FreeImage/lib/darwin/x86_64 -lnppi -lnppc -lfreeimage

ld: warning: directory not found for option '-L../common/FreeImage/lib/darwin/x86_64'

mkdir -p ../../bin/x86_64/darwin/release

cp jpegNPP ../../bin/x86_64/darwin/release

/Developer/NVIDIA/CUDA-7.0/bin/nvcc -ccbin clang++ -I../../common/inc  -m64  -Xcompiler -arch -Xcompiler x86_64  -gencode arch=compute_20,code=sm_20 -gencode arch=compute_30,code=sm_30 -gencode arch=compute_35,code=sm_35 -gencode arch=compute_37,code=sm_37 -gencode arch=compute_50,code=sm_50 -gencode arch=compute_52,code=sm_52 -gencode arch=compute_52,code=compute_52 -o main.o -c src/main.cpp

/Developer/NVIDIA/CUDA-7.0/bin/nvcc -ccbin clang++ -I../../common/inc  -m64  -Xcompiler -arch -Xcompiler x86_64  -gencode arch=compute_20,code=sm_20 -gencode arch=compute_30,code=sm_30 -gencode arch=compute_35,code=sm_35 -gencode arch=compute_37,code=sm_37 -gencode arch=compute_50,code=sm_50 -gencode arch=compute_52,code=sm_52 -gencode arch=compute_52,code=compute_52 -o piestimator.o -c src/piestimator.cu

Scikit - Prachtige site om DL te leren met Python

Gebrek aan bronnen kan je het in ieder geval niet noemen. Weer tegen ene hele mooie site aangelopen om deep learning te leren. Er zijn uitstekende beschrijvingen van verschillende modellen en data-pre processing mogelijkheden. Ook is er een goede 'roadmap' om te kiezen op welke wijze ene specifiek probleem het beste kan worden aangepakt:

Derde deel in "Deep Learning met Python" cursus

Sigmoid

De tien 28x28 weight matrixes, uit deel 2, blijken niet echt voldoende om tien getallen betrouwbaar 'te leren'. Dat lijkt ook logisch omdat er vele manieren zijn om getallen te schijven en dus het bijhouden van een gemiddelde verdeling per definitie de nodige fouten met zich mee zal brengen. De behaalde betrouwbaarheid was zo'n 92,5 %. Dat moet beter kunnen! Het derde deel gaat dan ook over een 'netwerk opzet' met ondermeer een 'verborgen' tussenlaag.

Hier is de betreffende code. Na 100 leer-loops wordt er een betrouwbaarheid mee bereikt van 98,4%
Nog lang niet genoeg voor een 'commerciële toepassing' volgens de spreker. Dat zou pas gaan meetellen vanaf 99,5%. Gelukkig gaan we daar later, via een modern net, met 'convolutional networks' in de buurt komen!

Er blijken 2 regels code in te zitten die niet werken maar gelukkig ook hier geen functie hebben. "foxhound utils" en "scipy". Deze #-en we dus maar even. Waarschijnlijk zijn ze oorspronkelijk gebruikt om grafieken te maken en om de gevonden leergegevens te kunnen opslaan.

De gradient funktie is aangepast (sgd) zodat die op beide weights (w_h en w_o) kan worden uitgevoerd.
Het model rekent met een sigmoid functie op de verborgen laag w_h, en met een softmax functie op w_o (output laag).
De keuze van de formaten van de weights matrixes is mij niet geheel duidelijk 748 is weer 28*28 (even groot als de invoer 'plaatjes') De output geeft weer de 10 getallen. De 625 daartussen blijft nog een beetje vaag.
Het netwerk haalt 95,66%. Een mindere score dan het eenvoudiger log_reg model uit het 2e deel.

	import theano from theano import tensor as T
	import numpy as np
	from load import mnist
	# from foxhound.utils.vis import grayscale_grid_vis, unit_scale
	# from scipy.misc import imsave
	def floatX(X):
	return np.asarray(X, dtype=theano.config.floatX)
	def init_weights(shape):
	return theano.shared(floatX(np.random.randn(*shape) * 0.01))
	def sgd(cost, params, lr=0.05):
	grads = T.grad(cost=cost, wrt=params)
	updates = []
	for p, g in zip(params, grads):
	updates.append([p, p - g * lr])
	return updates
	def model(X, w_h, w_o):
	h = T.nnet.sigmoid(T.dot(X, w_h))
	pyx = T.nnet.softmax(T.dot(h, w_o))
	return pyx
	trX, teX, trY, teY = mnist(onehot=True)
	X = T.fmatrix()
	Y = T.fmatrix()
	w_h = init_weights((784, 625))
	w_o = init_weights((625, 10))
	py_x = model(X, w_h, w_o)
	y_x = T.argmax(py_x, axis=1)
	cost = T.mean(T.nnet.categorical_crossentropy(py_x, Y))
	params = [w_h, w_o]
	updates = sgd(cost, params)
	train = theano.function(inputs=[X, Y], outputs=cost, updates=updates, allow_input_downcast=True)
	predict = theano.function(inputs=[X], outputs=y_x, allow_input_downcast=True)
	for i in range(100):
	for start, end in zip(range(0, len(trX), 128), range(128, len(trX), 128)):
	cost = train(trX[start:end], trY[start:end])
	print np.mean(np.argmax(teY, axis=1) == predict(teX))