Sie hat ihren Ursprung in der Antike und ihr Gedanke treibt bis heute revolutionäre Erfindungen an. Was lange Zeit nur in Mythen und fiktionalen Werken anzutreffen war, hat seit einigen Jahrzehnten einen festen Platz an vorderster Front der Wissenschaft. In dystopischen Weltentwürfen reißt sie die gesamte Kontrolle über den Planeten an sich und dennoch ist sie in der Lage, unser Leben in nahezu allen Bereichen zu optimieren: künstliche Intelligenz.

In unserem aktuellen Blogbeitrag untersuchen unsere Xperten eine besondere Ausprägung dieses Teilgebiets innerhalb der Informatik: Machine Learning. Diese Subdisziplin befasst sich mit der Lernfähigkeit von Maschinen – der artifiziellen Hervorbringung von Wissen. Anhand eines kompakten Beispiels mit Python zeigen unsere Xperten, wie ein Modell mithilfe von Machine-Learning-Algorithmen Zahlen erkennen kann. Zu Beginn möchten wir jedoch einige Begriffe und Konzepte zum besseren Verständnis klären.

Künstliche Intelligenz

Unter künstlicher Intelligenz werden alle Verfahren verstanden, die einen Computeralgorithmus nutzen, um ein Modell zu trainieren. Das Wort künstlich legt erst einmal fest, dass es sich dabei um etwas handelt, das nicht in der Natur vorkommt. Intelligenz wird hier als die Fähigkeit, Handlungen auf Zielerreichung auszurichten definiert – Aufgaben, bei denen Maschinen menschenähnlich arbeiten sollen.

Das trainierte Modell kann zur Umweltwahrnehmung und Entscheidungsfindung angewandt werden. Hierbei ist es notwendig, dass Eingangsdaten für dieses Modell vorhanden sind. Die künstliche Intelligenz ist daher auf eine realitätsnahe Darstellung von bspw. Sensordaten oder anderen Eingangsgrößen angewiesen. Die Methode zum Trainieren dieser Modelle nennt sich Machine Learning.

Machine Learning

Mithilfe von Machine-Learning-Algorithmen sind Maschinen in der Lage, aus Daten zu lernen und Muster zu erkennen. Auf dieser Basis können sie menschenähnliche Handlungen wie bspw. Vorhersagen oder Entscheidungen treffen.

Um ein Modell zu trainieren, kommen im Machine Learning vordefinierte Features zum Einsatz, die vom Modell berücksichtigt werden. Bei der Auswahl dieser Features hat der Mensch durch vielseitige Vorverarbeitungen im Erstellungsprozess einen signifikanten Einfluss. Dieser Aktionsradius erleichtert eine Feature Extraction am fertigen Modell.

Die Feature Extraction bezeichnet eine Methode im Machine Learning, mit der die aussagekräftigsten Eingangsgrößen ermittelt werden können. So kann bspw. bei Bildklassifizierungsaufgaben ausgegeben werden, welche Pixel am wahrscheinlichsten welchem Objekt zuzuordnen sind.

Geht man im Machine Learning eine Stufe weiter bzw. tiefer, gelangt man in die Gefilde des Deep Learning. Anders als beim Machine Learning konzentriert sich dieser Teilbereich auf die versteckten Ebenen, die Hidden Layer, eines Modells. Zum Trainieren des Modells werden die Features hierbei nicht mehr vom Menschen festgelegt. Da hier nun einige Arbeitsschritte vor dem Training wegfallen, ist die Kontrolle über das Ergebnis geringer als bei traditionellen Machine-Learning-Methoden. Die ersten Trainingsschritte – das Warm-up – sind ein zufälliges Zusammenwürfeln der Features. Mithilfe der Hidden Layer entscheidet das Modell dann während des Trainingsprozesses, welche Features die aussagekräftigsten sind.

Da diese spezielle Form der künstlichen Intelligenz enorme Mengen an Trainingsdaten sowie Rechenleistung benötigt und somit auch einen hohen Kostenaufwand darstellt, eignet sich Deep Learning nicht für den breiten Anwendungsfall. Könnte beim Machine Learning noch alles mit der Hand nachgerechnet werden, ist dies bei Deep Learning nicht mehr möglich. Die Komplexität der Berechnungen ist für den Menschen im Einzelfall nicht mehr nachvollziehbar.

Unabhängig davon, ob es sich nun um Machine Learning oder Deep Learning handelt, den Kern beider bilden sogenannte künstliche neuronale Netze.

Künstliche Neuronale Netze

Der Aufbau und die Funktion von künstlichen neuronalen Netzen sind dem menschlichen Gehirn nachempfunden. Sie eignen sich hervorragend für die Automatisierung von Aufgaben, um Muster oder Zusammenhänge in großen Datenmengen zu erkennen. Das Fundament eines jeden künstlichen neuronalen Netzes wird von vielen untereinander vernetzten Recheneinheiten gebildet – den künstlichen Neuronen.

Ein künstliches Neuron setzt sich aus mehreren Eingängen, die jeweils ein Signal empfangen, und einem Ausgang, der das Signal ausgibt, zusammen. Jedem Eingangswert wird eine sogenannte Wichtung zugeordnet, die den Beitrag dieses Eingangs zum Gesamtausgang des Neurons reguliert. Anschließend werden die gewichteten Eingangswerte addiert und an die Aktivierungsfunktion zur Ausgabe übermittelt.

In einem künstlichen neuronalen Netz ist jedes dieser künstlichen Neuronen miteinander verbunden und beim Deep Learning sogar über mehrere Schichten (Layer) hinweg.

Leistungskennzahlen

Ein wichtiges Hilfsmittel, um die Leistung von Machine-Learning-Modellen zu ermitteln, sind Leistungskennzahlen. Es handelt sich dabei um Evaluationsmetriken und je nach Anwendungsfall eignet sich die eine besser als die andere. Im Folgenden möchten wir nun einen kurzen Überblick über die geläufigsten dieser Operationen geben.

Genauigkeit (Accuracy): Die Genauigkeit ermittelt, wie oft das Modell richtig vorhersagt. Sie wird berechnet, indem die Anzahl der korrekten Vorhersagen durch die Gesamtzahl der Vorhersagen geteilt wird.

$\raisebox{1ex}{$\mathrm{tp\; +\; tn}$}\!\left/ \!\raisebox{-1ex}{$\mathrm{tp\; +\; tn\; +\; fp\; +\; fn}$}\right.$

Präzision (Precision): Die Präzision ermittelt, wie oft das Modell richtig positive Vorhersagen macht. Sie wird berechnet, indem die Anzahl der korrekten positiven Vorhersagen durch die Gesamtzahl der positiven Vorhersagen geteilt wird.

$\raisebox{1ex}{$\mathrm{tp}$}\!\left/ \!\raisebox{-1ex}{$\mathrm{tp\; +\; fp}$}\right.$

Recall (Sensitivity): Mit dem Recall wird ermittelt, wie oft das Modell alle tatsächlichen positiven Fälle identifiziert hat. Er wird berechnet, indem die Anzahl der korrekt identifizierten positiven Fälle durch die Gesamtzahl der tatsächlichen positiven Fälle geteilt wird.

$\raisebox{1ex}{$\mathrm{tp}$}\!\left/ \!\raisebox{-1ex}{$\mathrm{tp\; +\; fn}$}\right.$

F1-Score: Der F1-Score ist das harmonische Mittel aus Präzision und Recall. Hierdurch ist der F1-Score weniger anfällig auf irreführende Genauigkeitswerte und hat sich als Standard für die Genauigkeitsbewertung etabliert.

$2*\frac{\mathrm{precision}*\mathrm{recall}}{\mathrm{precision}+\mathrm{recall}}$

Anhand dieser Metriken lässt sich ganz gut erkennen, ob ein System zu stark auf einer Seite ausschlägt. Um das gewünschte Ergebnis zu erreichen, können die Parameter gegebenenfalls angepasst werden, indem am Ende bspw. ein neuer Bias hinzugefügt wird.

Hardwareanforderungen

Grundsätzlich reichen, um Machine Learning zu betreiben, nahezu alle gängigen PCs oder Laptops. Selbst für komplexe Anwendungen ist die Rechenleistung dieser Geräte ausreichend. Bspw. können auch Einplatinencomputer wie bspw. der Raspberry Pi zum Einstieg ins Machine Learning genutzt werden. Beim Deep Learning gestalten sich die Hardwareanforderungen allerdings schon erheblich schwieriger. Aufgrund der künstlichen neuronalen Netze mit mehreren Schichten sowie den komplexen Berechnungen kann es ganze Rechenzentren zur Durchführung benötigen. Je größer und komplexer das Modell ist, desto schneller steigen auch die Anforderungen an die benötigte Hardware.

Anwendung

Da nun die grundlegenden Begriffe und Konzepte geklärt sind, möchten wir nun in unser Praxisbeispiel mit Python gehen. Hierfür bearbeiten wir eine pixelbasierte Zahlenerkennung mit einer logistischen Regression. Es handelt sich dabei um eine mathematische Funktion zur Abbildung des zu trainierenden Modells.

Zum Lernen eignet sich bspw. Jupyter Notebooks (.ipynb) bestens, da der Code in einzeln ausführbare Blöcke heruntergebrochen werden kann. Jupyter ist als Standalone-Version, aber auch als Plug-in für beliebte Code-Editoren verfügbar.

Anfangs müssen erst einmal die benötigten Bibliotheken in Python importiert werden.

import numpy as np
import sklearn
import matplotlib.pyplot as plt
import pandas as pd
%matplotlib inline

Der MNIST-Datensatz des National Institute of Standards and Technology ist frei verfügbar und beinhaltet eine Vielzahl von Trainings- und Testdaten. Dieser kann mit folgendem Code heruntergeladen und in Python eingelesen werden:

from six.moves import urllib
from scipy.io import loadmat
mnist_url = "https://github.com/amplab/datascience-sp14/raw/master/lab7/mldata/mnist-original.mat"
mnist_path = "./mnist-original2.mat"
response = urllib.request.urlopen(mnist_url)
with open(mnist_path, "wb") as f:
    content = response.read()
    f.write(content)
mnist_raw = loadmat(mnist_path)
mnist = {
    "data": mnist_raw["data"].T,
    "target": mnist_raw["label"][0],
    "COL_NAMES": ["label", "data"],
    "DESCR": "mldata.org dataset: mnist-original",
}

Die nun deklarierte "mnist"-Variable muss noch in Trainings- und Testdaten aufgeteilt werden. Für unser Beispiel verwenden wir 60.000 Trainings- und 10.000 Testdaten.

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(mnist['data'], mnist['target'],train_size=6/7, test_size=1/7,random_state=101)

Datenerkundung und Vorverarbeitung

Die im MNIST-Datensatz enthaltenen Daten sind Bilder mit einer Auflösung von 28x28 Pixeln.

Mit dem Befehl plt.imshow(X_test[0].reshape(28,28)) lässt sich das erste Bild im Testdatensatz anzeigen.

Um das Training des Machine-Learning-Modells zu starten, muss es zunächst mit from sklearn.linear_model import LogisticRegression importiert und als model=LogisticRegression() definiert werden.

Wie oft das Modell durch den Trainingsdatensatz iterieren soll, wird mit model.max_iter=4 definiert. Die Wahl der Iterationen ist im Machine Learning von großer Bedeutung. Wird ein Modell untertrainiert, kann es möglicherweise die zu erkennenden „Features“ nicht verallgemeinern. Ein übertrainierts Modell hingegen ist möglicherweise sehr genau, wenn man es gegen den Trainingsdatensatz prüft, würde aber bedeutend schlechter gegen neue Testdatensätze abschneiden.

Schließlich kann mittels model.fit(X=X_train, y=y_train) das Training gestartet werden.

Durch die geringe Anzahl der Iterationen, Trainingsdaten und zu verarbeitenden Pixel pro Bild ist dieses Modell innerhalb von wenigen Sekunden vollständig trainiert. Eine Gegebenheit, die auch der Rechenleistung heutiger Hardware geschuldet ist.

Um die Genauigkeit des Modells bestimmen zu können, werden die Genauigkeitswerte benötigt. Diese können von sklearn mit folgendem Code berechnet werden:

from sklearn.metrics import classification_report, confusion_matrix
y_train_pred_first = model.predict(X_train)
y_pred = model.predict(X_test)
plt.matshow(confusion_matrix(y_test, y_pred))

y_train_pred = model.predict(X_train)
y_test_pred = model.predict(X_test)
print(classification_report(y_test, y_pred))

Die hierbei entstehende Confusion-Matrix beschreibt, welche Zahlen das Modell korrekt erkennt.

In dieser Grafik ist die 5 wenig ausgeprägt sowie mit deutlichen Abweichungen in den Zahlen 3 und 8. Dies bedeutet, dass die 5 besonders schlecht als solche vom Modell erkannt und häufig als 3 oder 8 fehlerkannt wird.

Das trainierte Modell

Mit dem Befehl plt.imshow(model.coef_[8].reshape(28,28)) können die Koeffizienten eines Modells (hier der Zahl 8) veranschaulicht werden. Die hellen, gelben Bereiche stellen dabei jene Pixel dar, die das Modell klar mit der Zahl 8 verbindet. Befindet sich ein Pixel jedoch in einem dunkelblauen Bereich, spricht dies gegen eine Klassifizierung als 8.

Für jede zu erkennende Zahl wird am Ende der Verarbeitungskette am Ausgangsneuron eine Wahrscheinlichkeit für die möglichen Zahlen 0 bis 9 ausgegeben. Die Zahl mit der höchsten Wahrscheinlichkeit wird am Ende als erkannte Zahl verwendet.

Exkurs Datenvorverarbeitung

Im Machine Learning ist eine Vorverarbeitung der Daten essenziell, um bessere Ergebnisse zu erzielen. Der MNIST-Datensatz ist bereits von vielen Fehlerquellen bereinigt.

Mögliche Vorverarbeitungen im Falle einer Zahlenerkennung sind u. a. das Reduzieren von Helligkeitsinformationen, eine Kantenhervorhebung oder das Neuausrichten der Zahlen zur Bildmitte. Es kann sich durchaus lohnen, diese Methoden auszuprobieren und im Anschluss die Genauigkeitswerte zu vergleichen. Hierfür müssen lediglich die Werte von X_train und X_test ersetzt werden.

Informationsreduktion

Im Fall des MNIST-Datensatzes sind Helligkeitswerte von 0 bis 255 vorhanden (8 Bit). Die Helligkeitswerte können mittels X_train.min() und X_train.max() ermittelt werden. Diese Informationen können bspw. auf 1 Bit reduziert werden, indem ein Schwellenwert bestimmt wird, unter welchem alle Werte als 0 und über welchem alle Werte als 1 definiert werden.

from sklearn.preprocessing import minmax_scale, binarize
X_train_binarized = minmax_scale(X_train)
X_test_binarized = binarize(X_test, threshold=96)

Mit dieser Methode wurden die Eingangsdaten für das Machine-Learning-Modell um ein 128-faches reduziert. Die Genauigkeit sinkt durch diese Vorverarbeitung jedoch um 1 % im F1-Score. Das Beispiel zeigt deutlich, dass im Machine Learning häufig Modelle für schwächere Hardware oder eingeschränkte Datenübertragungswege herunterskaliert werden können, ohne einen großen Genauigkeitsverlust hinnehmen zu müssen.

Kantenerkennung

Eine weitere Möglichkeit der Datenvorverarbeitung ist das Anlegen von Bildern mithilfe von Kantenerkennung. Bildmanipulationen können mit der Python Image Library PIL durchgeführt werden. Nachdem diese importiert wurde, müssen die Pixel der Trainingsdaten als Bilder eingelesen werden. Anschließend kann auf diese eine Kantendetektion angewandt werden. Um die Bilder später als Trainingsdaten verwenden zu können, müssen sie wieder als einzelne Pixel in ein Array geschrieben werden. Dieser Prozess wird mit dem Testdatensatz wiederholt. Das hierbei entstehende Array hat drei Dimensionen, unser Modell kann jedoch mit maximal zwei Dimensionen trainiert werden. Die Dimensionen lassen sich mit np.concatenate reduzieren.

from PIL import Image, ImageFilter
X_train_pil = [Image.fromarray(x.reshape(28, 28)) for x in X_train]
X_train_pil_edges = [x.filter(ImageFilter.FIND_EDGES) for x in X_train_pil]
X_train_edges = np.array([np.array(x).reshape(-1, 784) for x in X_train_pil_edges])
X_test_pil = [Image.fromarray(x.reshape(28, 28)) for x in X_test]
X_test_pil_edges = [x.filter(ImageFilter.FIND_EDGES) for x in X_test_pil]
X_test_edges = np.array([np.array(x).reshape(-1, 784) for x in X_test_pil_edges])
X_data_train = np.concatenate([X_train, X_train_edges[:, 0, :]], axis=1)
X_data_test = np.concatenate([X_test, X_test_edges[:, 0, :]], axis=1)

Diese Datenvorverarbeitung bringt mit einem Genauigkeitsverlust von 2 % ebenfalls leider keinen Genauigkeitsgewinn im F1-Score. Die Bilder im MNIST-Datensatz sind bereits gut für die Weiterverarbeitung vorverarbeitet. Unser kleines Experiment zeigt aber, dass zahlreiche Optionen existieren, einem Machine-Learning-Modell Daten zuzuführen.

Wie wir arbeiten

Die Einsatzmöglichkeiten von Machine Learning sind vielfältig. In der Umsetzung von Predictive-Maintenance-Anwendungen leistet Machine Learning einen wertvollen Beitrag in unseren Projekten. Auf einem künstlichen neuronalen Netz basierend, haben wir bspw. eine Anwendung entwickelt, die selbstständig zu wartende Geräte erkennt.

In Zukunft werden sich die Branchen, in denen Machine Learning ein wichtiger Faktor sein wird, zunehmend ausweiten, nicht zuletzt durch die kontinuierlich steigende Hardwareleistung. Aufgrund seiner Leichtgewichtigkeit wird Machine Learning auch neben Deep Learning im Vorantreiben des technologischen Wandels noch lange Bestand haben.