Künstliche Intelligenz programmieren: Lasse deine KI Ziffern auf Bildern erkennen

Ihr wollt endlich eure eigene Künstliche Intelligenz programmieren und handgeschriebene Ziffern/Zahlen auf Bildern mittels der KI erkennen? 

Künstliche Intelligenz programmieren: Meine Anleitung für deine KI-Ziffernerkennung in Python

Perfekt, dann seid ihr in diesem Tutorial auf meinem Blog genau richtig!

In diesem Künstliche Intelligenz programmieren Tutorial zeige ich euch, wie ihr in 6 einfachen Schritten in Python eure erste Künstliche Intelligenz programmiert und anschließend mit der KI handgeschriebene Ziffern erkennt. Unser neuronales Netz empfängt als Input 70 000 Bilder mit handgeschriebenen Ziffern.

Ihr lernt, wie ihr euer KI-Modell mit 60 000 dieser Bilder trainiert und anschließend auf neuen, dem Modell unbekannten Bildern handgeschriebene Ziffern mit eurer Künstlichen Intelligenz erkennt!!!

Die Bilder mit den Ziffern, die später von der KI erkannt bzw. prognostiziert werden sollen, stammen aus dem MNIST Datensatz (bereits in Keras enthalten) und sehen folgendermaßen aus:

Das Geniale dabei ist: In weniger als 10 Minuten seid ihr mit den Anweisungen in der Lage, eine Genauigkeit von über 97% zu erreichen. Alles klar – worauf warten wir dann noch?

Künstliche Intelligenz programmieren: Die 6 Schritte in der Übersicht

1. Importieren der benötigten Module und Bibliotheken
2. Laden des Datensatzes mit Bildern der handgeschriebenen Ziffern aus Keras
3. Splitten des Datensatzes in Trainings- und Testdaten
4. Weiteres Preprocessing für neuronales Netz
5. Erstellung und Training des Künstlichen Neuronalen Netzes
6. Testen der Genauigkeit unseres Neuronalen Netzes und Validierung der Ergebnisse in Matplotlib

Nachdem ihr jetzt einen Überblick habt, was euch erwartet, starten wir direkt in den Code und beginnen mit Schritt 1:

Schritt 1: Importieren der benötigten Module und Bibliotheken

Ich nehme an, dass ihr Python (die Programmiersprache, nicht die Schlange :)) auf eurem Rechner bereits installiert habt. Falls das nicht der Fall ist, könnt ihr euch Python auf dieser Webseite https://www.python.org/ downloaden und installieren. Auf der Homepage findet ihr alle Informationen für euer jeweiliges Betriebssystemen (wie z. B. Windows,  Mac OS x und Linux/Unix). Ihr könnt prüfen, ob die Installation erfolgreich war, indem ihr python in die Kommandozeile eingebt. Bei Windows müsst ihr dafür einfach nur in der Windowssuche „cmd“ eingeben und es öffnet sich das Terminal. Bei Mac OS x reicht die Suche nach Terminal. Sobald ihr in der Kommandozeile python eingegeben habt, sollte euch eure installierte Python-Version (z. B. 3.7.) angezeigt werden.

Ich nutze für dieses Tutorial ein Jupyter Notebook aus dem Anaconda-Navigator. Den Download der Anaconda-Distribution findet ihr hier. Ihr dürft aber auch selbstverständlich jeden anderen Python-Editor (z. B. Spyder, VS Code, Eclipse,..) verwenden.

———————————————————————————————————-

Falls du noch wenige oder fast keine Vorkenntnisse in der Programmiersprache Python hast, empfehle ich dir die beiden Bücher und Programmierkurse*:  Python: 3 Programmieren für Einsteiger, Python: Der Grundkurs, und meiner Meinung nach der beste englischsprachige Pyton-Programmierkurs auf Udemy von Derek Banas:

https://click.linksynergy.com/deeplink?id=py8UhVESZa0&mid=39197&u1=PYTHON&murl=https%3A%2F%2Fwww.udemy.com%2Fcourse%2Fultimate-python-tutorial%2F.

———————————————————————————————————-

Zudem benötigen wir speziell für dieses Tutorial die beiden gängigen ML-Bibliotheken Keras und Tensorflow. Zunächst müsst ihr diese installieren: Dies könnt ihr entweder in der Shell via einem pip-Install-Aufruf (z. B. pip install keras) oder in eurem Anaconda Navigator unter Environments (sucht bei den Packages in Anaconda nach keras, keras applications, tensorflow) tun.

Warum brauchen wir KERAS und TENSORFLOW? Keras ist eine leicht zu bedienende Bibliothek, welche im Machine Learning zur Erstellung und zum Trainieren von künstlichen Neuronalen Netzwerken verwendet wird. Bei Tensorflow wurde von Google entwickelt und ist ebenfalls im Machine Learning (speziell im Deep Learning) eine Standardbibliothek.

Nach der Installation importieren wir im Jupyter Notebook (oder in eurem Python-Editor) die genannten Bibliotheken. Die Importbefehle sehen dann wie folgt im Code aus:

import tensorflow as tf
import keras
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import Adam
from keras.utils import to_categorical

Dense bezieht sich übrigens darauf, dass wir ein Neuronales Netz erstellen, in dem alle Neuronen miteinander verbunden sind. Im Englischen spricht man dann von FULLY CONNECTED LAYERS. Die Architektur unseres Neuronalen Netzes findet ihr im Schritt 5 bei der Erstellung des NN.

Schritt 2: Laden des Datensatzes mit Bildern der handgeschriebenen Ziffern aus Keras

Laden wir jetzt unseren Datensatz und lesen die Bilder ein. Dafür müsst ihr keine Bilder downloaden, denn der Datensatz kommt bereits kostenlos mitgeliefert in der Bibliothek von Keras. Der Import geht dann sehr bequem mit wenig Code:

mnist = keras.datasets.mnist 

Falls ihr euch fragt, welche Bilder wir hochladen, dann möchte ich euch die Bilder zeigen:

Wie ihr sehen könnt, handelt es sich handgeschriebene Bilder mit den Zahlen zwischen 0 und 9. Davon lesen wir 70 000 Bilder ein, die jeweils eine Größe von 28×28 Pixel aufweisen. Das bedeutet, jedes alle Bilder haben die gleichen Abmaße. Das ist wichtig für das Einlesen unseres Datensatzes durch die Künstliche Intelligenz.

Schritt 3: Splitten des Datensatzes in Trainings- und Testdaten

Jetzt kommen wir zu einem zentralen Schritt: Wir trennen unsere Bilder in Trainings- und Testbilder im sogenannten Splitting. Was? Wieso ist das denn wichtig? Das ist wichtig beim ML, weil wir ein Overfitting vermeiden wollen. Overfitting würde dann vorliegen, wenn unsere KI (also unser Modell des neuronalen Netzes) zu stark durch die Trainingsdaten beeinflusst ist und sich diese Konzentration auf die Trainingsdaten negativ auf die Leistung (also z. B. Vorhersagegenauigkeit) des Modells auf andere Daten auswirkt. Um dies vorzubeugen, machen wir das Folgende:

Wir teilen unsere Gesamtdaten (also die 70 000 Bilder) auf und trennen die Daten in die beiden Töpfe Training und Testen. In Python ausgedrückt splitten wir also den MNIST-Datensatz in die zwei Variablen x_train und x_test mit den zugehörigen y_Daten. Denn wir wollen zunächst unsere KI mit Trainingsdaten trainieren, sodass es Zusammenhänge lernt und versteht, wie z. B. eine 5 oder die Ziffer 9 aussieht. Anschließend, nach dem Training, testen wir unsere KI auf Herz und Nieren.

Wie wir das tun? Wir prüfen die Vorhersage unseres trainierten Modells im Schritt 6, in dem wir der KI Testdaten geben. Diese Testdaten hat die KI vorher noch nie gesehen und spätetens da wird sich zeigen, ob wir ein gutes NN-Modell aufgebaut haben. Zurück zum Splitten der Daten. Dies wird in Python mit der Funktion load_data() bewerkstelligt:

(x_train, y_train), (x_test, y_test) = mnist.load_data()

Was durch diese Zeile Code passiert ist, ist, dass wir jetzt 60 000 Bilder als Trainingsdaten deklariert und 10 000 als Testdaten definiert haben. Die Trainings- bzw. Testbilder haben wir den beiden Variablen x_train und x_test zugewiesen.  Wisst ihr, was es mit den y_Daten auf sich hat? Das sind die sogenannten Labels, also die Ergebnisse unserer Bilder.

In unserem Fall steht dann z. B. in den Labels, dass f(x_train[0]) = 5. Das bedeutet, dass im ersten Bild (Python Listen starten bei Index 0!) des Trainingsdatensatzes die Zahl 5 als Ergebnis steht. Diese Zuordnung klingt banal, ist aber für den Lernprozess unseres Neuronalen Netzes entscheidend und wichtig. 

Natürlich müssen wir auch prüfen, ob wir die Bilder (x_Daten) und die zugehörigen Labels (= Beschriftungen der Bilder = y_Daten) korrekt eingelesen haben.

Machen wir dazu einen Schnelltest: Welche Ziffer befindet sich denn im Bild Nummer 1 (also Index 0) der Trainingsbilder? Das machen wir kurz und schmerzlos mithilfe der sehr nützlichen Matplotlib Bibliothek (Wenn ihr mehr über Diagramme mit Matplotlib in Python lernen möchtet, lest doch gerne meine Artikel zu den Matplotlibs): Matplotlib sollte ebenfalls bereits installiert sein. Falls nicht, könnt ihr das mit dem Befehl pip install matplotlib nachholen:

from matplotlib import pyplot as plt

plt.imshow(x_train[0])

Jetzt haben wir zwar den grafischen Output, aber wir müssen auch prüfen, ob die Labels der y_train-Variable ebenfalls den Wert 5 ausgeben. Um das zu tun, müssen wir den Inhalt vom ersten Label des y_train abfragen:

print(y_train[0])

Die Ausgabe gibt eine 5 aus. Soweit, so gut!

Schritt 4: Weiteres Preprocessing für neuronales Netz

Der nächste Schritt ist bei einem Machine Learning Projekt nicht wegzudenken: Das weitere Preprocessing – hier eine Normalisierung – unserer Daten zur einfacheren Handhabung für den Dateninput an das Neuronale Netz. Warum brauchen wir eine Normalisierung überhaupt? 

Das Problem ist, dass die x_Variablen (welche unsere Bilder repräsentieren) bisher sogenannte numpy arrays mit Werten zwischen 0 und 255 sind. Ihr glaubt mir nicht, was? Dann schauen wir uns die Daten doch mal an:

print(x_train)

Hatte ich recht und ihr erkennt ein mehrdimesionales Array mit Werten zwischen 0 und 255? Warum sehen unsere Rohdaten so aus? Der Grund ist, dass wir der Variablen RGB-Werte der Bilder übergeben haben. Diese nehmen Werte zwischen 0 und 255 an, sodass jedes Bild aus Matrizen dieser RGB-Werte besteht.

Das wäre an sich noch kein Problem, aber die Daten variieren sehr stark, was zu Problemen bei den Berechnungen der KI (genauer: des Deep Learning Netzes) führen kann. Deshalb umgehen wir etwaige Probleme und normalisieren die Daten mit der Funktion utils.normalize. Das Ziel ist, x_Werte zwischen 0 und 1 zu erhalten. Ich zeige euch, wie die Normalisierung durchgeführt wird:

x_train  = keras.utils.normalize(x_train, axis=1)

x_test  = keras.utils.normalize(x_test, axis=1)

Nach der Normalisierung sehen unsere Daten folgendermaßen aus:

Schritt 5: Erstellung und Training des künstlichen neuronalen Netzes

Super, jetzt sind wir schon weit vorgedrungen und kommen zum Pudels Kern – der Modellierung, der Erstellung und dem Training unseres künstlichen neuronalen Netzes. 

Vielleicht fragst du dich, was ist denn überhaupt ein künstliches neuronales Netz? Dann bin ich sicher, dass dir das folgende Buch* „Neuronale Netze selbst programmieren: Ein verständlicher Einstieg mit Python„ enorm weiterhelfen wird!

Wie wir bereits angekündigt haben, wählen wir der Einfachheit halber ein vollständig verbundenes Netz (Fully connected und dense). Dieses ist sequentiell aufgebaut, und soll aus 2 Hidden Layers (versteckte Schichten) und einem Output-Layer (Ausgabeschicht) bestehen.

Die Hidden Layers besitzen jeweils 128 Neuronen und werden nach der Multiplikation der Inputs mit den Gewichen durch die relu-Aktivierungsfunktion aktiviert. Falls ihr euch fragt, was die Output-Schicht macht: Diese Schicht gibt unsere Ergebnisse aus. In unserem Fall geben wir auf der linken Seite des Neuronalen Netzes 60 000 Trainigsbilder ein ein, durchlaufen mehrere Schichten mittels Forward Propagation und erhalten als Ausgabe 10 Wahrscheinlichkeiten auf der rechten Seite.

Warum sind es 10 Wahrscheinlichkeiten? Ganz einfach: Unsere KI (also das neuronale Netz) soll uns für ein handgeschriebenes Bild eine Vorhersage liefern, was wohl auf dem Bild zu erkennen ist. Da auf den Bildern jeweils die Ziffern zwischen 0 und 9 geschrieben wurden, gibt es ergo 10 Möglichkeiten und damit 10 verschiedene Ausgabe in der Outputschicht. Das bedeutet, dass die KI uns folgende Prognose liefert:

• p(0) = 10% (= mit 10%-iger Wahrscheinlichkeit befindet sich auf dem übergebenen Bild die Ziffer 0)
• p(1) = 20% (= mit 20%-iger Wahrscheinlichkeit befindet sich auf dem übergebenen Bild die Ziffer 1)
• p(2) = 60% (= mit 60%-iger Wahrscheinlichkeit befindet sich auf dem übergebenen Bild die Ziffer 2)
• …

Unserer Neuronales Netz bauen wir folgendermaßen auf:

model = Sequential()

model.add(Dense(128, activation='relu')) # Hidden Layer 1

model.add(Dense(128, activation='relu')) # Hidden Layer 2

model.add(Dense(10, activation='softmax')) # Output Layer

Prima. Jetzt müssen wir in der Funktion compile() weitere wichtige Parameter für das Training (wie z. B. den Optimizer, und die Berechnungsverfahren für den Loss, was gemessen werden soll als Metrik) festlegen:

model.compile(optimizer='adams', loss='sparse_categorical_crossentropy', metrics=['accuracy']

Erst jetzt können wir unser Modell mit den bekannten Trainingsdaten trainieren. Wie tun wir das? Na klar, wir ‚füttern‘ unser Neuronales Netz mit den X_Werten als Input (=Trainingsdaten) und sagen der KI, was sich auf den Bildern befindet. Das tun wir, in der fit-Funktion(), indem wir der KI die Labels mit den Ergebnissen der Ziffern übergeben.

model.fit(x_train.reshape(60000, 784), y_train, epochs=3)

Die Zahl 60000 bezieht sich auf die Anzahl der Trainingsdaten, die unsere KI für’s Training erhält. 784 ergibt sich aus der Multiplikation der 28×28 Pixel pro Bild. Ich habe 3 Epochen für das Training gewählt. Ich empfehle euch jedoch, mit den Parametern zu ’spielen‘ und zu versuchen, eurer NN-Modell zu tunen.

Je nach eurer Prozessorleistung dauert der Trainingsvorgang wenige Sekunden bis hin zu einigen Minuten. Nachdem das Training erfolgreich war, erhaltet ihr die folgende Ausgabe auf der Konsole mit Aussagen zur Genauigkeit (Accuracy) und zum Verlust (Loss):

Schritt 6: Testen der Genauigkeit unseres Neuronalen Netzes und Validierung der Ergebnisse in Matplotlib

Jetzt ist es soweit gekommen: TESTEN WIR UNSERE KÜNSTLICHE INTELLIGENZ und wenden unser Modell auf unbekannte Bilder an. Das heißt, wir lassen unser trainiertes Neuronales Netz eine Vorhersage und Abschätzung machen, welche Ziffern sich auf den unbekannten Testbildern befindet: Zunächst wollen wir wissen, wie genau (im Code val_acc) die Vorhersagen unserer KI auf dem Testdatensatz sind:

val_loss, val_acc = model.evaluate(x_test.reshape(-1, 784), y_test)

Das bedeutet, dass wir unserem trainierten Neuronalen Netz (model) die x_test-Daten (Parameter -1 bedeutet alle Testdaten – also 10 000 Bilder – , jeweils mit einer Größe von 28×28 Pixel) sowie die zugehörigen Antworten (die Zahlenlabels der Bilder = y_test) übergeben.  Das Ergebnis der evaluate-funktion in den beiden Variablen val_loss und val_acc gespeichert wird.

Wenn wir jetzt unser val_acc ausgeben, seht ihr die tatsächliche Genauigkeit unserer Vorhersage der Ziffern:

print(val_acc)

Klasse, jetzt solltet ihr mindestens eine Genauigkeit von 0.97 erreicht haben. Was bedeutet das konkret? Das bedeutet, dass unser Neuronales Netz ihm unbekannte 10 000 handgeschriebene Ziffern mit einer Genauigkeit von 97% richtig erkannt hat! Phänomenal, oder?

Ihr seid noch misstrauisch und zweifelt, ob die KI wirklich die Ziffern richtig erkennen kann? Kein Problem, ich zeige es euch graphisch:

Liebe KI, bitte sage mir, WELCHE ZIFFER BEFINDET SICH AUF BILD NR.21 (Index 20) DER TESTDATEN?

Hierfür müssen wir numpy via pip install numpy installieren und mit einem Importbefehl importieren. Anschließend wollen wir eine Vorhersage (engl.: Prediction, deshalb predict()) unseres Modells für das Bild Nummer 20 erhalten!

import numpy as np

predictions = model.predict(x_test.reshape(-1, 784))

Wie ihr erkennen könnt, übergeben wir dieses Mal keine y_Daten bzw. Labels. Der Grund ist, dass wir die KI testen wollen und ihm nicht mitteilen möchten, was sich auf dem Testbild befindet. Es soll schließlich seine ‚Künstliche Intelligenz‘ unter Beweis stellen!:) Schauen wir uns die Ausgabe auf der Konsole an:

print(predictions[20])

Hmm, ein  Array mit zehn Zahlen. Komisch, oder? 

Nein, das ist nicht überraschend, auch wenn es auf dem ersten Blick verwirrend erscheint. Das neuronale Netz hat nämlich brav seine Aufgabe erfüllt und die KI gibt uns als Ausgabe die 10 Wahrscheinlichkeiten der 10 Ziffern aus.

Da diese Darstellung aber sehr unschön daherkommt und wenig anschaulich ist, schlage ich vor, dass wir uns nur die Ausgabe mit der höchsten Wahrscheinlichkeit ausgeben lassen. Das hat den Vorteil, dass wir dann sofort sehen können, welche Ziffer die KI meint auf dem Bild Nr. 20 der Testdaten erkannt zu haben. Soweit, so klar? Gut. Dann implementieren wir das ganze und holen uns den argmax-value des arrays

pred_20 = prediction[20]

max_20 = np.argmax(pred_20)

print(max_20)

Okay, cool. Die KI meint also, auf dem Bild Nummer 20 handelt es sich mit einer Wahrscheinlichkeit von über 99% um die Ziffer 9. Da ist aber jemand zuversichtlich … 🙂 Um diese Vorhersage zu prüfen, plotten wir doch das Bild der Ziffer mittels matplotlib:

Yeah, jetzt habt ihr es geschafft!

Herzlichen Glückwunsch. Ihr habt jetzt ein voll funktionsfähiges KI-Modell aufgebaut, das Ziffern zwischen 0 und 9 auf unbekannten handgeschriebenen Bildern des MNIST-Testdatensatzes sehr zuverlässig richtig erkennt!!!

Für alle Video-Fans: Ich habe zum Artikel ein kompaktes Erklärungsvideo (Tutorial) auf YouTube (LINK zum YouTube-Video ) hochgeladen, das ich euch wärmstens ans Herz lege. Klickt aufs Bild und gelangt so direkt zum YouTube-Video:

Bitte dieses Feld leer lassen

Vorname

E-Mail *

Prüfe deinen Posteingang oder Spam-Ordner, um dein Abonnement zu bestätigen.

Lasst mir gerne bei der Gelegenheit auf diesem Blog und YouTube-Kanal ein Abo (hier geht’s zum Newsletter) da, um keine spannenden (KI) Programmiervideos mehr zu verpassen.

---

Meine Empfehlung: Falls ihr noch keinerlei Kenntnisse in der Python-Programmierung habt und unbedingt Python lernen möchtet: Startet durch mit dem Online-Kurs Python Programming Bootcamp von Derek Banas. Ich habe den Kurs auch besucht und durchgearbeitet. Ich kann euch diesen Kurs wirklich ans Herz legen, weil er meiner Meinung nach der beste und einer der umfangreichsten Python-Kurse bei Udemy ist. Der Kurs dauert über 20 Stunden und bietet einen qualitativ hochwertigen Einstieg in die (objektorientierte) Programmierung mit Python. Derek hat seine Videos so gestaltet, dass er ohne lange Umschweife die wichtigsten Inhalte präzise an Hand von Codebeispielen erklärt. Er bettet viele, interaktive Übungsaufgaben ein, sodass ihr euren Fortschritt regelmäßig überprüfen könnt.

Neben Grundlagen wie Funktionen, Klassen, Schleifen, usw. werdet ihr ebenfalls lernen, wie SQLite funktioniert und wie ihr grafische Benutzeroberflächen (GUIs) programmiert. Außerdem lernt ihr das Webframework Django kennen.

Also nichts wie los, das ist eure Chance bei Python so richtig durchzustarten! Ich bin mir sicher, dass ihr nicht enttäuscht werdet und eure Lernfortschritte durch die Decke gehen werden! Klickt direkt auf das Bild, das euch zum Kurs bringt und sichert euch den tollen Udemy-Kurs*:

————————————————————————————————————————————

Tolle Bücher und Kurse* zum Python lernen (speziell für Programmier-Einsteiger)

Meine Empfehlung: Falls ihr noch keinerlei Kenntnisse in der Python-Programmierung habt oder aber von einer anderen Programmiersprache umsteigen möchtet: Startet durch mit dem Online-Kurs Python Programming Bootcamp von Derek Banas. Ich habe den Kurs auch besucht und durchgearbeitet. Ich kann euch diesen Kurs wirklich ans Herz legen, weil er meiner Meinung nach der beste und einer der umfangreichsten Python-Kurse bei Udemy ist. Der Kurs dauert über 20 Stunden und bietet einen qualitativ hochwertigen Einstieg in die (objektorientierte) Programmierung mit Python. Derek hat seine Videos so gestaltet, dass er ohne lange Umschweife die wichtigsten Inhalte präzise an Hand von Codebeispielen erklärt. Er bettet viele, interaktive Übungsaufgaben ein, sodass ihr euren Fortschritt regelmäßig überprüfen könnt.

Neben Grundlagen wie Funktionen, Klassen, Schleifen, usw. werdet ihr ebenfalls lernen, wie SQLite funktioniert und wie ihr grafische Benutzeroberflächen (GUIs) programmiert. Außerdem lernt ihr das Webframework Django kennen.

Also nichts wie los, das ist eure Chance bei Python so richtig durchzustarten! Ich bin mir sicher, dass ihr nicht enttäuscht werdet und eure Lernfortschritte durch die Decke gehen werden! Klickt direkt auf das Bild, das euch zum Kurs bringt und sichert euch den tollen Udemy-Kurs*:

 

————————————————————————————————————————————

Vielen Dank für euer Interesse. Bis zum nächsten Artikel auf

Euer Maximilian.

Alle mit * gekennzeichneten Links sind Affiliate-Links.