EKI06 - Computer Vision

Wie Computer aus Bildern (Pixeln) Bedeutung gewinnen: von künstlichen Neuronen über Backpropagation und Deep Learning bis zu Convolutional Neural Networks, gezeigt am MNIST-Ziffernerkennungs-Beispiel mit Keras/TensorFlow.

Überblick

Computer Vision (CV) ist das Teilgebiet der KI, das Maschinen befähigt, aus Bildern Informationen zu extrahieren. Auf der KI-Landkarte (nach B. Humm) gehört Computer Vision zum Bereich Perceiving (Wahrnehmung) und damit zur nicht-symbolischen KI / Machine Learning (zusammen mit Sensortechnik). Es ist Teil des "Applying intelligence" und stützt sich auf erlernte Modelle (Acquiring intelligence).

Der Foliensatz gliedert sich in:

Überblick
CV-Anwendungen
Neuronale Netze (künstliches Neuron, ANN, Fehler/Kostenfunktion, Gradientenabstieg, Backpropagation)
Deep Learning mit CNN (Faltungs-, Pooling- und vollverbundene Schichten)
Herausforderung: Ziffernerkennung (MNIST, Keras/TensorFlow-Workflow)
Mini-Test

Der rote Faden: Ein Bild ist zunächst nur eine Zahlenmatrix. Neuronale Netze lernen daraus schrittweise immer komplexere Merkmale (low level -> medium level -> high level), und CNNs nutzen die räumliche Nachbarschaft der Pixel gezielt aus.

CV-Anwendungen

Die Folien präsentieren Computer Vision anhand von Anwendungsdomänen, jeweils als Eingabe -> Ausgabe-Beziehung.

Hinweis: Der Foliensatz gliedert Computer Vision nach Anwendungsfeldern (OCR, Gesichtserkennung, Medizin, ...), nicht nach einer formalen Taxonomie von CV-Aufgaben (z. B. Klassifikation, Objekterkennung, Segmentierung). Eine solche Aufgabenliste kommt im Deck nicht vor. Implizit erkennbar sind aber die Aufgaben Klassifikation (Ziffer erkennen), Detektion + Lokalisierung + Identifikation (Gesichtserkennung: "ob Gesichter da sind, Gesichts-Position und Identifikation") und Anomalieerkennung (Medizin).

Anwendung	Eingabe	Ausgabe / Aufgabe	Beispiel-Anwendungsfälle
Optische Zeichenerkennung (OCR)	Bild von hand- oder maschinengeschriebenem Text	Textdokument	Archivierung/Zugriff auf alte Dokumente, Adressen auf Briefen scannen
Gesichtserkennung	Bild	Ob Gesichter vorhanden sind, Gesichts-Position, Identifikation	Autotagging von Kamerabildern, Bilder im Internet finden, Menschen erkennen (z. B. am Flughafen)
Medizin	Bild (CT / PET / MRI / Ultraschall)	Anomalien erkennen	Diagnoseunterstützung
Industrie / Landwirtschaft	Bild	Klassifikation / Steuerung	Früchte sortieren, QM in Fertigungsprozessen, Roboter in Fertigungsprozessen
Militär / Luftfahrt	Bild	Erkennung / Steuerung	Erkennen feindlicher Soldaten und Fahrzeuge, Raketenlenkung, autonome Fahrzeuge, Drohnen
Automobil	Bild	Warnung / Steuerung	Kollisionswarnung, Parkhilfe / automatisches Parken, Verkehrsschild-Erkennung, autonome Fahrzeuge
Film	Bild / Marker	Szene / Bewegung	Erzeugen von Szenen in Filmen, Motion Capturing

OCR wird später (MNIST) als konkretes Fallbeispiel wieder aufgegriffen: Die Ziffernerkennung ist eine spezielle OCR-Aufgabe.

Bildrepräsentation (Pixel und Kanäle)

Bevor ein Netz ein Bild verarbeiten kann, muss es als Zahlen dargestellt werden.

Ein Einzelbild wird als Vektor dargestellt. Bei MNIST: ein 28x28-Graustufenbild = 28 x 28 = 784 Zahlen.
Jeder Pixel ist ein Grauwert (im Beispiel Werte zwischen 0 und 255; im Deck als kleine Dezimalzahlen bzw. 0/1-Matrix skizziert). Der Hintergrund ist 0, die Ziffer besteht aus positiven Werten.
Ein ganzer Trainingsdatensatz ist eine Matrix der Form [55000, 784]: 55000 Bilder, je 784 Pixel.
Im Kaggle-CSV-Format hat der Datensatz 785 Spalten: eine label-Spalte plus pixel0 bis pixel783.
Für ein CNN wird der Vektor wieder in seine räumliche Form mit Kanaldimension gebracht: Höhe = 28 px, Breite = 28 px, Kanal (canal) = 1 (Graustufen), also die Form (28, 28, 1).

Skizze der Pixelmatrix (Ausschnitt, Ziffer als Grauwerte, 0 = Hintergrund):

0 0 0 0 0 0 0 0 ...
0 0 0 0 0 .6 .8 0 ...
0 0 0 0 0 .3 .1 0 ...   <- Vektor der Länge 784
0 0 0 0 0 .5 .1 .4 ...
...

Hinweis: Die Folie 6.39 kommentiert die Kanaldimension als canal = 1 (Anglizismus/Tippfehler für "channel" bzw. deutsch "Kanal"). Gemeint ist der eine Graustufen-Kanal.

Neuronale Netze

Biologisches Vorbild: das Neuron

Das künstliche Neuron ist dem biologischen nachempfunden:

Dendriten -> Eingänge
Synapsen -> Gewichte (Stärke der Verbindung)
Zellkörper -> Summierung/Aktivierung
Axon -> Ausgabe (Signal)

Künstliches Neuron (artificial neuron)

Ein künstliches Neuron bildet die gewichtete Summe seiner Eingänge und schickt sie durch eine Aktivierungsfunktion.

Die Gewichte $w_i$ entsprechen der Stärke der jeweiligen synaptischen Verbindung.
Der Eingang $in_0 = 1$ mit Gewicht $w_0 = bias$ realisiert den Bias (Schwellenwert).
Die Ausgabe $out$ entspricht dem Signal auf dem Axon.

Gewichtete Summe:

sum = \sum_i in_i \cdot w_i

Aktivierung mit der Sigmoid-Funktion:

out = \frac{1}{1 + e^{-sum}}

Die Sigmoid-Funktion und ihre Ableitung (wichtig für Backpropagation):

f(x) = \frac{1}{1 + e^{-x}} \qquad f'(x) = f(x)\,\bigl(1 - f(x)\bigr)

Die Sigmoid-Kurve verläuft S-förmig von 0 (bei $x \to -\infty$ ) über 0,5 (bei $x = 0$ ) nach 1 (bei $x \to +\infty$ ).

Künstliche neuronale Netzwerke (ANN)

Ein ANN (artificial neural network) besteht aus Schichten von Neuronen:

Eingabeschicht (input layer)
Zwischenschicht(en) (intermediate / hidden layer)
Ausgabeschicht (output layer)

Zwei Grundtypen:

feed-forward network - Ausgaben der einen Schicht sind die Eingaben der nächsten Schicht.
recurrent network - Ausgaben werden zu Eingängen einer früheren Schicht zurückgeleitet.

flowchart LR
  subgraph IN["Eingabeschicht"]
    i1(( )); i2(( )); i3(( ))
  end
  subgraph HID["Zwischenschicht"]
    h1(( )); h2(( )); h3(( )); h4(( ))
  end
  subgraph OUT["Ausgabeschicht"]
    o1(( )); o2(( ))
  end
  i1 --> h1; i1 --> h2; i2 --> h2; i2 --> h3; i3 --> h3; i3 --> h4
  h1 --> o1; h2 --> o1; h3 --> o2; h4 --> o2

Fehler und Kostenfunktion (cost function)

Um zu lernen, misst das Netz seinen Fehler: den Unterschied zwischen der tatsächlichen Ausgabe ( $out$ ) und der gewünschten Ausgabe ( $target$ ). Die Kostenfunktion ist die Summe der quadrierten Abweichungen:

Fehler = Cost(W;\cdot) = \sum_i (target - out)^2

Worked example aus der Folie (Ampel-Beispiel, 3 Ausgabeneuronen):

Neuron	output	target	$(target - out)^2$
1	0.92	1.0	$(1.0 - 0.92)^2 = 0.0064$
2	0.17	0	$(0 - 0.17)^2 = 0.0289$
3	0.35	0	$(0 - 0.35)^2 = 0.1225$

Cost = (1.0-0.92)^2 + (0-0.17)^2 + (0-0.35)^2 = 0.1578

Gradientenabstieg (gradient descent)

Das Lernen minimiert die Kostenfunktion, indem die Gewichte in Richtung des negativen Gradienten der Kosten angepasst werden. Der Aktualisierungsschritt ist proportional zu

- \eta \cdot \nabla Cost(\dots)

wobei $\eta$ die Lernrate ist. Die Folie visualisiert dies als Kugel, die auf der (mehrdimensionalen, hier als Kurve dargestellten) Kostenlandschaft bergab rollt, bis sie ein Minimum erreicht.

Training mit Backpropagation

Das Training von ANNs erfolgt per Backpropagation (D. E. Rumelhart, G. E. Hinton, R. J. Williams). Die 5 Schritte:

Schritt 1 - Leite die Trainingsdaten vorwärts durch das Netzwerk.
Schritt 2 - Berechne den Unterschied (d. h. Fehler) zwischen den tatsächlichen und den gewünschten Ausgaben in der letzten Schicht.
Schritt 3 - Berechne für jedes Neuron in der letzten Schicht seinen Korrekturwert ( $\Delta$ ).
Schritt 4 - Iteriere rückwärts von der vorletzten Schicht bis zur Eingabeschicht und berechne für jedes Neuron seinen Korrekturwert unter Berücksichtigung der bereits berechneten Korrekturwerte aus der nächsten Schicht.
Schritt 5 - Korrigiere jedes Gewicht mit Hilfe des Korrekturwerts, der zu dem jeweiligen Neuron gehört.

Schritt 1 - Vorwärtspropagierung. Für jedes Neuron $i$ in Schicht $k$ :

sum_i = \sum_j in_j \cdot w_{j,i} \qquad out_i = \frac{1}{1 + e^{-sum_i}}

public void forward(double [] input) {
    output[0] = input;
    for (int k=1; k<numLayers; k++) {
        for (int i=0; i<layerSize[k]; i++) {
            double sum = weight[k][i][layerSize[k-1]]; // bias
            for (int j=0; j<layerSize[k-1]; j++) {
                sum += output[k-1][j] * weight[k][i][j];
            }
            output[k][i] = 1.0 / (1.0 + Math.exp(-sum));
        }
    } // next layer k
}

Schritte 2 und 3 - Fehler und Korrekturwert der letzten Schicht.

e = \sum_i (target_i - out_i)^2 \qquad \Delta_i = f'(sum_i)\cdot(target_i - out_i)

public void backpropagate(double [] target) {
    // compute the delta values for the neurons in the last layer
    // and compute the training error
    int lastLayer = numLayers - 1;
    for (int i=0; i < layerSize[lastLayer]; i++) {
        double out = output[lastLayer][i];
        error += (target[i] - out) * (target[i] - out);
        delta[lastLayer][i] = out * (1.0 - out) * (target[i] - out);
    }
    //...

Beachte: Der Code verwendet out * (1.0 - out), was genau $f'(sum_i) = f(sum_i)\,(1-f(sum_i))$ für die Sigmoid-Aktivierung ist.

Schritt 4 - Korrekturwerte der vorgelagerten Schichten. Für Neuron $i$ in Schicht $k$ unter Verwendung der Deltas der nachfolgenden Schicht $k+1$ :

\Delta_i = f'(sum_i)\cdot \sum_j w_{i,j}\cdot \Delta_j

// compute the delta values for the upstream layers
for (int k=lastLayer-1; k>0; k--) {
    for (int i=0; i<layerSize[k]; i++) {
        double sum = 0;
        for (int j=0; j<layerSize[k+1]; j++) {
            sum += weight[k+1][j][i] * delta[k+1][j];
        } // next neuron j in layer k+1
        delta[k][i] = output[k][i] * (1.0 - output[k][i]) * sum;
    } // next neuron i in layer k
} // next layer k

Schritt 5 - Gewichtsanpassung. Mit Lernrate $\eta$ :

w_{j,i} = w_{j,i} + \eta \cdot \Delta_i \cdot out_j

// requires that backpropagate computed the delta values
public void adjust(double eta) {
    for (int k=numLayers-1; k>0; k--) {
        for (int i=0; i<layerSize[k]; i++) {
            for (int j=0; j<layerSize[k-1]; j++) {
                weight[k][i][j] += eta * delta[k][i] * output[k-1][j];
            }
            // adjust the weight of the bias
            weight[k][i][layerSize[k-1]] += eta * delta[k][i] * 1.0;
        } // next neuron i in layer k
    } // next layer k
}

Trainingsverlauf - Beispiel

Die Folie zeigt einen realen Trainingsverlauf über 20 Epochen. Auszug:

Epoche	Trainingsfehler	Lernrate	Validationsfehler	Anzahl Treffer	Genauigkeit
0	45661.53	0.060	4146.35	8006	80.06%
1	13995.44	0.057	1503.75	9049	90.49%
5	6935.89	0.045	1156.09	9293	92.93%
10	5570.45	0.030	917.38	9435	94.35%
13	4935.88	0.021	807.96	9502	95.02%
14	4747.00	0.018	862.51	9470	94.70%
19	4249.72	0.003	699.82	9568	95.68%

Beobachtungen aus der Tabelle:

Der Trainingsfehler sinkt monoton (45661 -> 4250).
Die Lernrate wird pro Epoche verkleinert (0.060 -> 0.003, "learning rate decay").
Die Genauigkeit steigt von 80.06% auf 95.68% (Anzahl Treffer bei offenbar 10000 Testbildern).
Der Verlauf ist nicht streng monoton: In Epoche 14 steigt der Validationsfehler wieder (807.96 -> 862.51) und die Genauigkeit fällt kurz (95.02% -> 94.70%, in der Folie rot markiert).

Hinweis: Die letzte Spalte ist in der Folie mit "Fehlergenauigkeit" überschrieben. Die Werte entsprechen aber der Treffer-/Klassifikationsgenauigkeit (Anzahl Treffer / 10000, z. B. 8006 -> 80.06%). "Fehlergenauigkeit" ist hier missverständlich; gemeint ist die Genauigkeit (accuracy).

Deep Learning mit CNN

Deep Learning

Deep Learning ist ein ANN mit einer Kaskade aus vielen Zwischenschichten:

Regulärer Aufbau: Jede Schicht nutzt die Ausgabe der vorherigen Schicht als Eingabe.
Erkennung zunehmend komplexerer Elemente: von low level (Pixel) über medium level (Formen) hin zu high level (Klassen).

Die Folie illustriert dies: Aus Pixeln werden Kanten/Striche, daraus Teilformen, daraus ganze Objekte, die schließlich einer Klasse (z. B. Penguin, Elephant, Kangaroo) zugeordnet werden.

Convolutional Neural Networks (CNN)

Ein CNN ist die typische Deep-Learning-Architektur für Bilder. Pipeline:

flowchart LR
  A["Input Layer (Low level, Pixel)"] --> B["Convolutional Layer"]
  B --> C["Pooling Layer"]
  C --> D["Fully Connected Layer"]
  D --> E["Output Layer (High level, Klassen)"]

Zuordnung der Phasen (laut Folie):

Eingabe: Low level (Pixel)
Features erlernen: Medium level (Convolutional- und Pooling-Schichten)
Klassifikation: Fully Connected Layer
Ausgabe: High level (Klassen)

Convolutional- und Pooling-Schichten können sich wiederholen (im MNIST-Beispiel: 2 Convolutional- + 2 Pooling-Schichten), bevor die vollverbundenen Schichten klassifizieren.

Convolutional Layers (Faltung)

Kernidee:

Pixel werden nur im Zusammenhang mit unmittelbar benachbarten und nahestehenden Pixeln betrachtet. Dadurch bleiben die Beziehungen zwischen den verschiedenen Teilen eines Bildes erhalten.
Convolution (Faltung): Filtern des Bildes mit einem kleineren Pixel-Filter (Kernel). Das verkleinert die Bildgröße, ohne die Beziehung zwischen den Pixeln zu verlieren.

Worked Example (Folie 6.27): Ein 5x5-Bild wird mit einem 3x3-Filter gefaltet; das Ergebnis ist eine 3x3-Merkmalskarte (feature map).

Eingabebild (5x5):

Filter / Kernel (3x3):

1 0 0
0 1 1
1 0 1

Ergebnis (3x3 feature map):

5 1 3
2 3 2
2 2 4

Rechnung für die obere linke Position (Filter auf den 3x3-Ausschnitt oben links legen, elementweise multiplizieren, aufsummieren):

\begin{aligned} &(1\cdot1)+(0\cdot0)+(0\cdot0) \\ +\;&(0\cdot0)+(1\cdot1)+(1\cdot1) \\ +\;&(1\cdot1)+(0\cdot0)+(1\cdot1) = 5 \end{aligned}

Der Filter "wandert" mit Schrittweite 1 über das Bild; jede Position liefert einen Wert der feature map. Aus dem Beispiel liest man die Größenreduktion ab: aus 5x5 wird 3x3.

Hinweis: Eine allgemeine Formel für die Ausgabegröße steht nicht auf den Folien. Sie lässt sich aber aus dem Beispiel herleiten: Bei Eingabegröße $N$ , Filtergröße $F$ und Schrittweite (stride) $S = 1$ ohne Randauffüllung gilt $O = N - F + 1$ . Hier: $O = 5 - 3 + 1 = 3$ . (Diese Formel ist ergänzend, nicht Teil des Decks.)

Pooling Layers

Pooling fasst Bildregionen zusammen und reduziert so die Auflösung/Komplexität:

Es selektiert einen Bereich von Pixeln und berechnet daraus das Maximum, den Durchschnitt oder die Summe.
Beispiel: Max-Pooling mit einem 2x2-Bereich.
Das Einfügen eines Pooling-Layers nach jedem Convolution-Layer reduziert die Komplexität.

Worked Example (Folie 6.28): 4x4-Eingabe -> 2x2-Ausgabe per 2x2-Max-Pooling (jeweils das Maximum jedes 2x2-Blocks).

Eingabe (4x4)          Ausgabe (2x2, Max je Block)
5 1 | 3 6              max(5,1,2,3)=5   max(3,6,2,2)=6
2 3 | 2 2       ->     max(2,2,5,1)=5   max(4,2,3,1)=4
----+----
2 2 | 4 2                 5 6
5 1 | 3 1                 5 4

Fully Connected Layers (vollverbundene Schichten)

In einem Fully Connected Layer ist jedes Neuron mit allen anderen Neuronen (der Nachbarschichten) verbunden.
Wird bei der Klassifikation von Bildern benutzt: Die Anzahl der Ausgabe-Neuronen entspricht der Anzahl der Klassen.

Diese Schichten stehen am Ende des CNN und wandeln die gelernten Merkmale in eine Klassenzuordnung um.

Herausforderung: Ziffernerkennung (MNIST)

Aufgabe und Datensatz

Kaggle-Wettbewerb "Digit Recognizer": Computer-Vision-Grundlagen mit dem berühmten MNIST-Datensatz lernen.
MNIST-Datenbank (handgeschriebene Ziffern, Yann LeCun). Aufgabe: Identifiziere eine Ziffer in einem Bild (OCR). Eingabe: Bilder von Ziffern; Ausgabe: z. B. 5 0 4 1.
Repräsentation: siehe Abschnitt Bildrepräsentation - 28x28 = 784 Werte pro Bild, Trainingsmatrix [55000, 784], Kaggle-CSV mit 785 Spalten (label + pixel0..pixel783).

One-Hot-Kodierung

Die Klassenlabels (Ziffern 0-9) werden One-Hot-kodiert: Aus einer Ziffer wird ein 10-stelliger Vektor mit genau einer 1 an der Position der Ziffer.

Label	0	1	3	5	9
3	0	0	1	0	0
5	0	0	0	1	0
9	0	0	0	0	1
1	0	1	0	0	0
0	1	0	0	0	0

Werkzeuge: TensorFlow und Keras

TensorFlow ist die Machine-Learning-Bibliothek von Google - eine End-to-End-Plattform (Daten vorbereiten, Modelle bauen, deployen, betreiben).
Keras ist die High-Level Deep-Learning-API ("Simple. Flexible. Powerful."), die auf TensorFlow aufsetzt und den Aufbau/Training von Netzen vereinfacht.

Workflow (Keras/TensorFlow)

1) Daten laden (mit pandas):

import pandas as pd
# loading data
train = pd.read_csv('data/train.csv')
test  = pd.read_csv('data/test.csv')

2) Vorverarbeitung der Daten:

# Split features and labels in training set
X = train.drop(labels = ['label'], axis = 1)
y = train['label']
# One hot encode labels
Y = to_categorical(y, num_classes = 10)
# Normalize pixel data
X = X/255.0
# Reshape image in 3 dimensions (height = 28px, width = 28px, canal = 1)
X = X.values.reshape(-1, 28, 28, 1)

Schritte: Merkmale (Pixel) von Label trennen, Label One-Hot-kodieren (10 Klassen), Pixel auf [0,1] normalisieren (Division durch 255), Vektor in die räumliche Form (28, 28, 1) reshapen (mit Kanaldimension).

3) Definition des Modells (Sequential-Topologie, 2 Convolutional + 2 Pooling + 2 Fully Connected):

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense
from tensorflow.keras.optimizers import RMSprop

model = Sequential([
    Conv2D(32, (3,3), activation='relu', input_shape=(28,28,1)),
    MaxPooling2D(2, 2),
    Conv2D(64, (3,3), activation='relu'),
    MaxPooling2D(2,2),
    Flatten(),
    Dense(512, activation='relu'),
    Dense(10, activation='softmax')
])

Erläuterungen der Folie:

Sequential([...]) = ANN-Topologie: Sequenz von Schichten (layers).
2 Convolutional + 2 Pooling layers extrahieren die Merkmale; Conv2D(32, (3,3)) bzw. Conv2D(64, (3,3)) verwenden 32 bzw. 64 Filter der Größe 3x3.
activation='relu' = Aktivierungsfunktion, die die Ausgabe einzelner Neuronen berechnet.
Flatten() = Flatten in einen Vektor (macht aus der 2D-Merkmalskarte einen einzigen Feature-Vektor).
2 Fully Connected layers (Dense(512, relu) und Dense(10, softmax)): Die letzte Schicht hat 10 Ausgabe-Neuronen (= Anzahl Klassen) mit softmax für Wahrscheinlichkeiten.

Architektur des MNIST-CNN:

flowchart TB
  A["Eingabe: 28x28x1"] --> B["Conv2D 32 Filter 3x3 (ReLU)"]
  B --> C["MaxPooling2D 2x2"]
  C --> D["Conv2D 64 Filter 3x3 (ReLU)"]
  D --> E["MaxPooling2D 2x2"]
  E --> F["Flatten"]
  F --> G["Dense 512 (ReLU)"]
  G --> H["Dense 10 (Softmax) - 10 Klassen"]

4) Trainieren des Modells:

# Compiling model
model.compile(optimizer=RMSprop(), loss='categorical_crossentropy', metrics=['accuracy'])
# Fitting model
history = model.fit(X, Y, batch_size=100, epochs = 1)

Erläuterungen der Folie:

Optimizer (RMSprop) wird für die Optimierung der Metrik benutzt (gradient descent).
Loss function (categorical_crossentropy) berechnet den Fehler, d. h. den Unterschied zwischen der aktuellen und der vorhergesagten Ausgabe.
Metrik (accuracy) = was optimiert/gemessen werden soll.
Batch size = Anzahl der Trainingsdaten, die in einer Iteration des Optimierungsprozesses benutzt wird (hier 100).
Anzahl der Epochen = wie oft der ganze Trainingsdatensatz für die Optimierung benutzt wird. Größere Werte verbessern die Treffergenauigkeit, erhöhen aber auch die Laufzeit (hier 1).

Hinweis: In der Folie 6.42 steht im Code metrics=['accuracy ]mit einem falschen schließenden Zeichen (Backtick statt Anführungszeichen) und die Annotation schreibt "gradient decent" statt "descent". Korrekt istmetrics=['accuracy']` bzw. "gradient descent". Oben ist die korrigierte Fassung gezeigt.

5) Evaluieren des Modells:

# Split the data in training and test set
X_train, X_test, Y_train, Y_test = train_test_split(X, Y)
# TODO: train and evaluate

Begründung der Folie: Das Trainieren eines ANN braucht lange; auch Kreuzvalidierung braucht viel Zeit. Alternative: train_test_split() erlaubt das einmalige Splitten der Daten in Trainings- und Testdatensatz (statt aufwändiger Kreuzvalidierung).

6) Erzeugen einer Submission-Datei (für Kaggle):

# Predict results
results = model.predict(test)
# One hot decoding: Select the index with the maximum probability
results = np.argmax(results, axis = 1)
# Add columns ImageID and Label
results = pd.Series(results, name="Label")
submission = pd.concat([pd.Series(range(1, len(results)+1), name = "ImageId"), results], axis = 1)
# Generate CSV file
submission.to_csv('data/submission.csv', index=False)

Wichtig (Folie): Die Testdaten müssen genauso vorverarbeitet worden sein wie die Trainingsdaten. Das One-Hot-Decoding wählt mit np.argmax den Index der höchsten Wahrscheinlichkeit (= vorhergesagte Ziffer). Ergebnis ist eine CSV mit den Spalten ImageId und Label.

Prüfungsrelevanz

CV-Anwendungen aufzählen können: OCR, Gesichtserkennung, Medizin (CT/PET/MRI/Ultraschall), Industrie/Landwirtschaft, Militär/Luftfahrt, Automobil, Film - jeweils mit Eingabe/Ausgabe.
Künstliches Neuron: gewichtete Summe $sum = \sum_i in_i w_i$ , Bias über $in_0=1, w_0$ , Sigmoid-Aktivierung $out = \frac{1}{1+e^{-sum}}$ und deren Ableitung $f'=f(1-f)$ .
ANN: Eingabe-/Zwischen-/Ausgabeschicht; Unterschied feed-forward vs. recurrent.
Kostenfunktion: $Cost = \sum_i (target-out)^2$ ; das Zahlenbeispiel (0.1578) nachrechnen können.
Gradientenabstieg: Gewichte in Richtung $-\eta\,\nabla Cost$ anpassen; Rolle der Lernrate $\eta$ .
Backpropagation: die 5 Schritte in richtiger Reihenfolge; Delta-Formeln letzte Schicht $\Delta_i = f'(sum_i)(target_i-out_i)$ und innere Schicht $\Delta_i = f'(sum_i)\sum_j w_{i,j}\Delta_j$ ; Gewichtsupdate $w_{j,i} = w_{j,i} + \eta \Delta_i out_j$ ; Urheber Rumelhart/Hinton/Williams.
Deep Learning: viele Zwischenschichten, Merkmale von low level (Pixel) über medium level (Formen) zu high level (Klassen).
CNN-Bausteine: Convolution (Filter/Kernel, erhält räumliche Beziehungen, verkleinert Bild), Pooling (Max/Durchschnitt/Summe, reduziert Komplexität), Fully Connected (Klassifikation, Ausgabeneuronen = Klassen). Faltungs- und Max-Pooling-Beispiel rechnen können.
MNIST-Repräsentation: 28x28 = 784 Werte, Datensatz [55000, 784], Kanal 1, Normalisierung /255, One-Hot der 10 Klassen.
Keras/TensorFlow-Workflow: laden -> vorverarbeiten -> Modell (Sequential, Conv2D/MaxPooling2D/Flatten/Dense) -> compile (optimizer, loss, metrics) -> fit (batch_size, epochs) -> evaluieren (train_test_split) -> vorhersagen/Submission (argmax). Bedeutung von batch_size und epochs erklären können.

Mini-Test

Nennen Sie Computer Vision Anwendungen
Was ist ein ANN?
Was ist back-propagation?
Was ist deep learning?
Was ist ein CNN?
Wie werden die Bilder in der MNIST Datenbank repräsentiert?
Was ist Keras und Tensorflow? Wie werden Sie benutzt?