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]))