# Ziffernerkennung mit Hilfe einer Support Vector Machine (SVM)
%% Cell type:markdown id: tags:
## Einleitung
In diesem Notebook lernst du
+ wie man mit Hilfe eines Machine Learning Modells handschriftlich geschriebene Ziffern erkennen kann.
+ wie man einen Datensatz vorbereitet.
+ wie man die Effektivität eines Modells evaluieren kann
+ wie man einen Hyperparmater optimiert.
Das Notebook bildet exemplarisch den Prozess vom Einlesen der Daten bis zur Evaluation des Modells ab. Die Erläuterungen dienen in erster Linie dazu, den Prozess nachvollziehbar zu machen.
%% Cell type:markdown id: tags:
## Bibliotheken importieren
%% Cell type:code id: tags:
``` python
fromsklearn.datasetsimportload_digits
fromsklearnimportsvm
fromsklearn.model_selectionimporttrain_test_split
fromsklearnimportmetrics
importmatplotlib.pyplotasplt
importcv2
importnumpyasnp
fromipycanvasimportCanvas
importipywidgetsaswidgets
```
%% Cell type:markdown id: tags:
## Datensatz einlesen
Wir beginnen damit einen Datensatz aus der sklearn-Bibliothek zu laden.
Der Datensatz enthält 1797 Bilder. Auf den Bildern ist jeweils eine handschriftlich geschriebene Ziffer zu erkennen. In der Liste `target` wurde annotiert, welche Ziffer jeweils zu sehen ist. Dem Datensatz liegt außerdem eine Beschreibung bei (DESCR).
The data set contains images of hand-written digits: 10 classes where
each class refers to a digit.
Preprocessing programs made available by NIST were used to extract
normalized bitmaps of handwritten digits from a preprinted form. From a
total of 43 people, 30 contributed to the training set and different 13
to the test set. 32x32 bitmaps are divided into nonoverlapping blocks of
4x4 and the number of on pixels are counted in each block. This generates
an input matrix of 8x8 where each element is an integer in the range
0..16. This reduces dimensionality and gives invariance to small
distortions.
For info on NIST preprocessing routines, see M. D. Garris, J. L. Blue, G.
T. Candela, D. L. Dimmick, J. Geist, P. J. Grother, S. A. Janet, and C.
L. Wilson, NIST Form-Based Handprint Recognition System, NISTIR 5469,
1994.
.. topic:: References
- C. Kaynak (1995) Methods of Combining Multiple Classifiers and Their
Applications to Handwritten Digit Recognition, MSc Thesis, Institute of
Graduate Studies in Science and Engineering, Bogazici University.
- E. Alpaydin, C. Kaynak (1998) Cascading Classifiers, Kybernetika.
- Ken Tang and Ponnuthurai N. Suganthan and Xi Yao and A. Kai Qin.
Linear dimensionalityreduction using relevance weighted LDA. School of
Electrical and Electronic Engineering Nanyang Technological University.
2005.
- Claudio Gentile. A New Approximate Maximal Margin Classification
Algorithm. NIPS. 2000.
%% Cell type:markdown id: tags:
Aus der Beschreibung geht hervor, dass die Bilder jeweils eine Auflösung von 8 mal 8 Pixel haben. Die Bilder wurden bereits vorverarbeitet. Ein Bild wird durch eine 8x8 Matrix repräsentiert. Jeder Pixel entspricht einer Zahl zwischen 0 (schwarz) und 16 (weiß).
%% Cell type:code id: tags:
``` python
images[0]
```
%% Output
array([[ 0., 0., 5., 13., 9., 1., 0., 0.],
[ 0., 0., 13., 15., 10., 15., 5., 0.],
[ 0., 3., 15., 2., 0., 11., 8., 0.],
[ 0., 4., 12., 0., 0., 8., 8., 0.],
[ 0., 5., 8., 0., 0., 9., 8., 0.],
[ 0., 4., 11., 0., 1., 12., 7., 0.],
[ 0., 2., 14., 5., 10., 12., 0., 0.],
[ 0., 0., 6., 13., 10., 0., 0., 0.]])
%% Cell type:markdown id: tags:
## Daten visualisieren
Mit Hilfe der Funktion `imshow` können wir die Matrixdarstellung in ein Bild umwandeln. Wir betrachten das erste Bild des Datensatzes.
%% Cell type:code id: tags:
``` python
plt.gray()
plt.axis('off')
plt.imshow(images[0])
```
%% Output
<matplotlib.image.AxesImage at 0x1c09107ea48>
<matplotlib.image.AxesImage at 0x254e2953f48>
%% Cell type:markdown id: tags:
## Daten vorbereiten
%% Cell type:markdown id: tags:
### Daten vektorisieren
Bislang liegen die Daten in Form einer 8x8 Matrix vor. Wir müssen die Daten für das Modell zunächst in ein anderes Format bringen. Dazu ordnen wir die Daten hintereinander in einem langen Vektor (64 Elemente) an. Solch ein Vektor wird auch Featurevektor genannt.
%% Cell type:code id: tags:
``` python
images[0]
```
%% Output
array([[ 0., 0., 5., 13., 9., 1., 0., 0.],
[ 0., 0., 13., 15., 10., 15., 5., 0.],
[ 0., 3., 15., 2., 0., 11., 8., 0.],
[ 0., 4., 12., 0., 0., 8., 8., 0.],
[ 0., 5., 8., 0., 0., 9., 8., 0.],
[ 0., 4., 11., 0., 1., 12., 7., 0.],
[ 0., 2., 14., 5., 10., 12., 0., 0.],
[ 0., 0., 6., 13., 10., 0., 0., 0.]])
%% Cell type:code id: tags:
``` python
images=images.reshape(n,-1)
images.shape
```
%% Output
(1797, 64)
%% Cell type:code id: tags:
``` python
images
```
%% Output
array([[ 0., 0., 5., ..., 0., 0., 0.],
[ 0., 0., 0., ..., 10., 0., 0.],
[ 0., 0., 0., ..., 16., 9., 0.],
...,
[ 0., 0., 1., ..., 6., 0., 0.],
[ 0., 0., 2., ..., 12., 0., 0.],
[ 0., 0., 10., ..., 12., 1., 0.]])
%% Cell type:markdown id: tags:
### Daten normalisieren
Wir skalieren den Vektor so, dass alle Werte zwischen 0 und 1 liegen. Dazu teilen wir durch den größten Wert, der auftreten kann (16). Dieser Schritt ist optional. Die Skalierung hat jedoch Auswirkungen auf die Wahl des Hyperparameters (siehe Abschnitt 11).
%% Cell type:code id: tags:
``` python
images/=16.0
```
%% Cell type:markdown id: tags:
## Trainingsdaten und Testdaten
Wir teilen die Daten in Trainings und Testdaten auf. Die Trainingsdaten werden für das Trainieren des Modells benötigt. Die Testdaten dienen zur Optimierung des Hyperparameters und zur Evaluierung des Modells.
Für die Klassifikation der Bilder verwenden wir eine Support Vector Machine (SVM). Die genaue Funktionsweise ist nicht Teil dieses Tutorials. Für weitere Erläuterungen siehe beispielsweise: https://monkeylearn.com/blog/introduction-to-support-vector-machines-svm/
Der Parameter $\gamma$ ist ein sogenannter Hyperparameter. Dieser hat Auswirkungen auf den Trainingsprozess und damit auf die Effektivität des Modells. Für den Anfang setzen wir diesen auf den Wert 1. Später ermitteln wir die optimale Belegung.
%% Cell type:code id: tags:
``` python
classify=svm.SVC(gamma=1)
```
%% Cell type:markdown id: tags:
## Modell trainieren
Die Methode `fit` passt das Modell an die Daten an. Das bedeutet, dass das Modell lernt anhand der Merkmale (Pixel) zwischen den verschiedenen Klassen (Ziffern) zu unterscheiden.
Das Modell sieht dabei lediglich Reihen von Zahlen (Featurevektoren) und die dazugehörige Annotationen. Das Modell sucht - vereinfacht ausgedrückt - nach statistischen Mustern zwischen den Zahlenreihen und den Annotationen. Ob es sich bei den Zahlenreihen um Bilder oder Wetterdaten handelt spielt für das Modell dabei keine Rolle.
Das trainierte Modell können wir nun dazu verwenden, neue Daten zu klassifizieren. Wir geben dem Modell die Bilder aus den Testdaten und lassen es mit Hilfe des Gelernten die dazugehörigen Annotationen vorhersagen. Anschließend vergleichen wir die Vorhersagen mit den tatsächlichen Annotationen, um die Effektivität des Modells zu bestimmen.
Die Effektivität des Modells ist auch ohne Optimierung des Hyperparameter $\gamma$ bereits sehr gut. Die Treffergenauigkeit (accuracy) gibt den Anteil der richtig klassifizierten Bilder an. Eine Genauigkeit von 0,96 bedeutet demnach, dass 96% aller Vorhersagen zutreffend waren.
Für die Optimierung des Hyperparameters $\gamma$ betrachten wir den F1-Score (makro). Dabei handelt es sich um ein das harmonische mittel zwischen Genauigkeit (precision) und Trefferquote (recall).
Die Wahl von $\gamma$ einen großen Einfluss auf den Trainingsprozess und damit auf die Effektivität des Modells hat. Um die Belegung von $\gamma$ zu finden gehen wir wie folgt vor:
1. Wir definieren eine Funktion `score`. Diese erhält einen Parameter $\gamma$. die uns für gegebenes $\gamma$ den erzielten F1-Score zurürckgibt
2. Wir legen fest, welche Werte wir für $\gamma$ einsetzen möchten. Es ist meist sinnvoll zunächst verschiedene Größenordnungen (magnitudes) zu untersuchen.
3. Wir wählen denjenigen Wert aus, der den höchsten F1-Score erzielt.
Wir beobachten: Im Intervall $[10^{-2};10^0]$ erhalten wir eine zufriedenstellende Effektivität. Von den untersuchten Werte hat der Wert $\gamma=2^{-2}=0.25$ den höchsten F1-Score erzielt.
%% Cell type:markdown id: tags:
## Eigene Handschrift erkennen
%% Cell type:markdown id: tags:
Nun können wir das Modell an unserer eigenen Handschrift testen.
**Probiere es aus! Zeichne in das schwarze Feld eine Ziffer und bestätige deine Eingabe indem du den Button anklickst!**
Das Bild wird anschließend ausgelesen, verarbeitet und mit Hilfe unseres Modells klassifiziert. Die Vorhersage wird unterhalb des Bildes ausgegeben.
