Programmierung für OttoNormalVerbraucher

October 15, 2019/in Business Analytics, Mathematics/by klausbenecke

Facebook und Co. arbeiten daran Nachrichten so aufzubereiten, dass sie emotional noch mehr ansprechen, als ob die gesellschaftliche Situation nicht schon aufgeheizt genug ist. Wir arbeiten daran dem Endnutzer Werkzeuge bereitzustellen um seine rationale Urteilskraft mit Hilfe des Computers zu stärken. Dafür benötigt man möglichst einfache aber dennoch leistungsstarke Programmiersprachen und umfangreiche, vertrauenswürdige, öffentlich zugängliche Informationen in Form von vielgestaltigen großen Tabellen und Dokumenten ähnlich der Wikipedia.

Auch wenn die entwickelte Sprache so einfach wie möglich ist, wird sie im Gegensatz zum Facebookansatz einen gewissen Lernaufwand erfordern.

Eine solche Programmiersprache in Kombination mit vertrauensvollen Daten könnte ein großer Schritt in Richtung einer weiteren Demokratisierung der Gesellschaft werden. Viele Falschnachrichten könnten leicht von jedermann durch entsprechende Fakten oder statistischen Auswertungen paralysiert werden.

Vielleicht kann man die Schaffung einer solchen Programmiersprache mit der Schaffung des ersten Alphabets durch die Phönizier oder der Schaffung des ersten Alphabets mit Vokalen durch die Griechen vergleichen. Hätten diese Völker solche Leistungen vollbringen können ohne diese Voraussetzungen. Ich vermute ohne dieses Alphabet hätte es keine griechische Wissenschaft und Kultur gegeben; vielleicht auch keine griechische Demokratie.

Entwurfskriterien für eine solche Sprache:

Eine mathematische Fundierung ist erforderlich.
Methodisch-didaktische und pragmatische Fragen stehen zunächst vor Effizienzproblemen.
Kurze, lesbare Programme; die wichtigsten Schlüsselworte sollten kurz sein
Einfache, unstrukturierte Programme; Schleifen und allgemeine Rekursionen führen häufig zu schwer lesbaren und schwer änderbaren Programmen;
Universelle Anwendbarkeit; sie muss nicht nur für Relationen (flache einfache Tabellen) sondern auch für strukturierte Tabellen und Dokumente nutzbar sein; sie muss nicht nur für Anfragen an die wichtigsten Systeme sondern auch für vielfältige Berechnungen geeignet sein
Um im Schulunterricht einsetzbar zu sein, muss sie die verschiedenen mathematische Teilgebiete unterstützen, sowie Nutzen für die anderen Fächer bieten
Sie sollte so mächtig sein, dass sie andere Systeme und Sprachen wie Tabellenkalkulation und SQL ersetzen kann.
Aus Endnutzersicht darf es nur ein einheitliches System mit einheitlicher Syntax (Schreibweise) für die Verarbeitung von Massendaten geben, genau wie die Operationen der Einzeldatenverarbeitung (+ – * : sin) standardisiert sind.

Einführung in o++o:

A. Merkel „Jeder Schüler soll neben lesen, rechnen und schreiben auch programmieren können.“

o++o (ausführlich ottoPS) ist eine tabellenorientierte Programmiersprache mit funktionalen Möglichkeiten, die auf Schleifen verzichtet. Dennoch ist o++o sehr ausdrucksstark und man kann mit ihr nicht nur kompakte Anfragen sondern auch vielfältige Berechnungen für strukturierte Tabellen und strukturierte Dokumente bewerkstelligen.

o++o benutzt viele mathematische Konzepte, daher sehen wir die Hauptvorteile der Vermittlung im Mathematikunterricht, genau wie die wesentlichen Fähigkeiten für die Nutzung des Taschenrechners in Mathematik vermittelt werden. o++o verwendet insbesondere folgende Konzepte: Kollektion (Menge, Multimenge, Liste); Gleichheit und Inklusionsbeziehungen dieser; Tupel; leistungsfähige Operationen zum Selektieren; Berechnen; Restrukturieren; Sortieren und Aggregieren (Summe; Durchschnitt; …),… .

Tabellenkalkulationsprogramme wie EXCEL und die Datenbankstandardabfragesprache SQL kennen keine strukturierten Schemen und Tabellen. Erste Tests mit Vorschulkindern lassen vermuten, dass man mit strukturierten Tabellen leichter rechnen kann als mit Dezimalzahlen. Wir wollen einige o++o-Beispielprogramme anfügen:

1. Berechne den Wert eines einfachen Terms.

2*3+4

* und + haben jeweils 2 Inputwerte. Zunächst wird 2*3 (6) berechnet. Die 6 ist erster Inputwert von +, so dass sich insgesamt 24 ergibt. Hier wird also einfach von links nach rechts gerechnet.

2. Schreibe den Term cos³(sin²(3.14159)) in o++o.

pi sin hoch 2 cos hoch 3

Unserer Meinung nach ist der Ausgangsterm für Otto Normalverbraucher schwer zu lesen. Man beginnt mit pi geht nach links bis zum sin dann nach rechts zum hoch 2 jetzt bewegt man sich wieder nach links zum cos und abschließend nach rechts zum hoch 3. Diese Schreibweise wurde sicher eingeführt um Klammern zu sparen. Eigentlich müsste der Ausgangsterm um unmissverständlich zu sein, folgendes Aussehen haben:

(cos((sin(3.14159))²))³

Das ist sicher noch schwerer zu lesen und man bewegt sich noch mehr von links nach rechts und umgekehrt.

3. Schreibe den Term sin²(x)+cos³(y) in o++o.

X sin hoch 2 + (Y cos hoch 3)

oder

X sin hoch 2

+ Y cos hoch 3

Man könnte alle Terme in o++o ohne Klammern schreiben, allerdings müssten dann bestimmte Terme mehrzeilig geschrieben werden.

4. Wie berechnet man den Term 2+3:4*5 ?

2+(3:(4*5))=2 3/20

2+((3:4)*5)=5 ¾

o++o: ((2+3):4)*5=6 1/4

Man erkennt, dass man mit der Schulweisheit Punktrechnung geht vor Strichrechnung noch nicht auskommt. Man benötigt die Regel „von links nach rechts“ zusätzlich.

5. Berechne den Durchschnitt mehrerer Noten.

1 2 3 1 2 ++:

Vom methodischen Standpunkt kann man dieses Programm noch verbessern, indem man die Klammern für Listen hinzufügt: [1 2 3 1 2] ++:

Man erkennt jetzt, dass die Durchschnittsoperation ++: einen Inputwert, nämlich eine Liste besitzt und dass ++: diesem einen Inputwert nachgestellt wird. Da die Nutzer in der Regel nicht viel tippen wollen, gehen wir davon aus, dass die erste Notation in Praxis häufiger benutzt werden wird.

6. Berechne die Durchschnitte einer strukturierten Tabelle noten.tab für jedes Fach.

noten.tab

DUR:=NOTEl ++:

noten.tab könnte so aussehen:

FACH,NOTEl l
Ma 1 2 1 3 1 2
Phy 4 3 2 2 1

…

Hierbei kürzt l Liste ab. D.h., noten.tab ist eine einfache strukturierte Tabelle (Liste), die zu jedem Fach eine Liste von Noten enthält. Um Platz zu sparen, wählen wir auch hier die methodisch nicht optimale Darstellung. Wie FACH ist auch NOTE ein Spaltenname, so dass noten.tab eigentlich so dargestellt werden müsste:

FACH,NOTEl l

Ma 1 2 1 3 1 2
Phy 4 3 2 2 1

Das Ergebnis der Anfrage wieder im „tab-Format“:

FACH, DUR, NOTEl l
Ma 1.66666666667 1 2 1 3 1 2
Phy 2.4 4 3 2 2 1

7. Bilde die Summe der Zahlen von 1 bis 100 (Aufgabe von Gauß Klasse 5).

1 .. 100 ++

Wie die Addition und die Multiplikation besitzt .. zwei Inputwerte (1 und 100). Als Zwischenergebnis entsteht die Liste

ZAHLl
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43
44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83
84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100

,deren Zahlen dann aufsummiert werden, so dass sich 5050 ergibt.

8. Berechne näherungsweise das Maximum der Sinus-Funktion im Intervall [1 2].

1 … 2!0.001 sin max

… benötigt 3 Inputwerte: 1. den Anfangswert 1, den Endwert 2 und die Schrittweite 0.001. Es entstehen hierbei die Zahlen 1 1.001 1.002 1.003 …1.999 2.

Auf jede der Zahlen wird die Sinusfunktion angewandt, sodass wieder 1001 Zahlen entstehen. Auf diese Liste wird dann die Funktion max (Maximum) angewandt. Obwohl es sich hierbei um ein Näherungsverfahren handelt, kommt der exakte Wert 1 heraus, wenn die Schrittweite weiter verfeinert wird. sin und max haben jeweils einen Inputwert (hier eine Liste) aber der Outputwert von sin ist wieder eine Liste und max erzeugt lediglich eine Zahl, da es sich hier um eine Aggregationsfunktion handelt. Der zweite und der dritte Inputwert einer dreistelligen Operation (oben …) wird jeweils durch ein „!“ getrennt. Das ist in o++o nötig, da das Komma für die Paarbildung bereits vergeben ist und das Leerzeichen bereits Listenelemente trennt.

9. Berechne näherungsweise das Minimum des Polynoms X³ + 4 X² -3 X+2 im Intervall [0 2] mit zugehörigem X-Wert.

[X! 0 … 2!0.001]

Y:= X polynom [1 4 -3 2]

MINI:= Yl min

avec Y = MINI

avec ist französisch und bezeichnet eine Selektion. Ein konkretes Polynom von einer Variablen X hat stets nur einen Inputwert, der für X eingesetzt wird. polynom in Zeile 2 ist dagegen allgemeiner und hat 2 Inputwerte:

Den Inputwert für X, der hier alle Zahlen, die in der ersten Zeile generiert wurden, annimmt.
Eine Liste von Zahlen, die den Koeffizienten des konkreten Polynoms entspricht.

Durch die ersten Zeile entsteht eine Liste von Zahlen, die alle den Namen X bekommen haben. Das erkennt man am besten in der xml bzw. ment-Repräsentation:

Gesamtergebnis:
MINI, (X, Y l)

1.481482037 0.333 1.481482037

10. Berechne eine Nullstelle der Cosinus Funktion im Intervall [1 2] näherungsweise.

[X! 1 … 2!0.0001]

avec X cos < 0

avec X pos = 1

Hier verbleiben nach der ersten Selektion nur die X-Werte mit Funktionswert kleiner 0. Von diesen wird im zweiten Schritt der erste Wert ausgewählt. Da wir wissen, dass cos nur eine Nullstelle im betrachteten Intervall besitzt, wird diese durch das Ergebnis angenähert. pos kürzt Position ab, so dass das erste Paar der verbliebenen Paare selektiert wird.

11. Berechne das Gesamtwachstum, wenn 5 Jahreswachstumszahlen gegeben sind. Runde das Ergebnis auf eine Stelle nach dem Komma.

[W! 0 1.5 2.1 1.3 0.4 1.2]

ACCU:= first 100. next ACCU pred *(W:100+1) at W

rnd 1

Die Ergebnistabelle:

[W! 0 1.5 2.1 1.3 0.4 1.2]
ACCU:= first 100. next ACCU pred *(W:100+1) at W
rnd 1
Die Ergebnistabelle:
W, ACCU l
0. 100.
1.5 101.5
2.1 103.6
1.3 105.
0.4 105.4
1.2 106.7

Der erste ACCU-Wert ergibt sich durch den Ausdruck hinter first (100.). Für den zweiten Wert wird für ACCU pred der Wert 100. eingesetzt und der Term nach next bewertet. Es ergibt sich 101.5. Diese Zahl wird wieder in ACCU pred eingesetzt und der next-Term erneut berechnet (rund 103.6),… bis der letzte W-Wert erreicht ist. pred ist der predecessor (Vorgänger).

12. Berechne die Fläche unter der Sinuskurve im Intervall [0, pi] näherungsweise.

0 … pi!0.0001 sin * 0.0001 ++

Hierbei werden nacheinander alle Zahlen zwischen 0 und pi generiert, dann von jeder Zahl der Sinus berechnet und anschließend jede Zahl mit 0.0001 multipliziert. Es entstehen 31415 Rechteckflächen, die abschließend addiert werden.

13. Berechne den DurchschnittsBMI pro Alter und den BMI pro Person und Alter für alle Personen über 20.

<TAB!
NAME, LAENGE, (ALTER, GEWICHT l) l
Klaus        1.68 18 61 30 65 56 80
Rolf       1.78 40 72
Kathi         1.70 18 55 40 70
Walleri     1.00 3 16
Viktoria   1.61 13 51
Bert          1.72 18 66 30 70
!TAB>

avec NAME! 20<ALTER
BMI:= GEWICHT : LAENGE : LAENGE
gib ALTER,BMIAVG,(NAME,BMI m) m BMIAVG:= BMI ! ++:
rnd 2 #rundet alle Zahlen der Tabelle auf 2 Stellen nach dem Punkt

Die TAB-Klammern deuten an, dass die eingeschlossenen Daten der TAB-Darstellung entsprechen.

Die obige Bedingung selektiert Personen-Sätze, d.h. NAME,LAENGE,(ALTER,GEWICHT l) Tupel (strukturierte Tupel bzw. Strupel). Da eine Personen mehrere ALTER-Angaben besitzt, muss quantifiziert werden. NAME! 20 <ALTER selektiert demnach alle Personen, die einen entsprechenden Alterseintrag besitzen. D.h., der Existenzquantor wird nicht geschrieben, gehört aber zu jeder Bedingung. In diesem kleinen Beispiel könnte man die Selektion natürlich auch per Hand realisieren.

Resultat:

ALTER, BMIAVG, (NAME, BMI m) m

18 20.98 Bert 22.31

Kathi 19.03

Klaus 21.61

30 23.35 Bert 23.66

Klaus 23.03

40 23.47 Kathi 24.22

Rolf 22.72

56 28.34 Klaus 28.34

Das Endergebnis kann beispielsweise durch einfaches Klicken als Säulendiagramm dargestellt werden. Das Beispiel zeigt, dass man eine Hierarchie einfach durch Angabe des gewünschten Schemas umkehren kann. Im Ergebnis ist der Name dem Alter untergeordnet.

Es wird insbesondere deutlich, dass die Aufgaben ohne Kenntnisse der Differential- und Integral-rechnung gelöst werden können. Mit o++o kann der Mathematikunterricht in vielfältiger Weise unterstützt werden. Das reicht von Klasse 7 oder tiefer bis zur Klassenstufe 12. Es betrifft: Rechnen mit natürlichen Zahlen, Dezimalzahlen, näherungsweise Berechnung von Nullstellen beliebiger Funktionen, Ableitung, Flächen unter Kurven, Extremwerte (kann wahrscheinlich bereits in der Sekundarschule gelehrt werden), Wahrscheinlichkeitsrechnung, … . Mit o++o können Dinge in einfacher Weise berechnet werden, die sonst nur theoretisch abgehandelt werden. Dadurch kann das Verständnis der Konzepte wesentlich verbessert, erweitert und vertieft werden. Weitere Informationen zu o++o finden Sie unter ottops.de (Z.B. „o++o auf 8 Seiten“ ist eine kurze Einführung).

Wir glauben, dass o++o besondere Vorteile für den Mathematik- und Informatikunterricht bietet aber auch in den anderen Fächern sinnvoll genutzt werden kann.

Fehler-Rückführung mit der Backpropagation

January 29, 2019/in Artificial Intelligence, Deep Learning, Machine Learning, Main Category, Mathematics, Predictive Analytics/by Benjamin Aunkofer

Dies ist Artikel 4 von 6 der Artikelserie –Einstieg in Deep Learning.

Das Gradienten(abstiegs)verfahren ist der Schlüssel zum Training einzelner Neuronen bzw. deren Gewichtungen zu den Neuronen der vorherigen Schicht. Wer dieses Prinzip verstanden hat, hat bereits die halbe Miete zum Verständnis des Trainings von künstlichen neuronalen Netzen.

Der Gradientenabstieg wird häufig fälschlicherweise mit der Backpropagation gleichgesetzt, jedoch ist das nicht ganz richtig, denn die Backpropagation ist mehr als die Anwendung des Gradientenabstiegs.

Bevor wir die Backpropagation erläutern, nochmal kurz zurück zur Forward-Propagation, die die eigentliche Prädiktion über ein künstliches neuronales Netz darstellt:

Forward-Propagation

Abbildung 1: Ein simples kleines künstliches neuronales Netz mit zwei Schichten (+ Eingabeschicht) und zwei Neuronen pro Schicht.

In einem kleinen künstlichen neuronalen Netz, wie es in der Abbildung 1 dargestellt ist, und das alle Neuronen über die Sigmoid-Funktion aktiviert, wird jedes Neuron eine Nettoeingabe $z$ berechnen…

$z = w^{T} \cdot x$

… und diese Nettoeingabe in die Sigmoid-Funktion einspeisen…

$\phi(z) = sigmoid(z) = \frac{1}{1 + e^{-z}}$

… die dann das einzelne Neuron aktiviert. Die Aktivierung erfolgt also in der mittleren Schicht (N-Schicht) wie folgt:

$N_{j} = \frac{1}{1 + e^{- \sum (w_{ij} \cdot x_{i}) }}$

Die beiden Aktivierungsausgaben $N$ werden dann als Berechnungsgrundlage für die Ausgaben der Ausgabeschicht $o$ verwendet. Auch die Ausgabe-Neuronen berechnen ihre jeweilige Nettoeingabe $z$ und aktivieren über Sigmoid( $z$ ).

Ausgabe eines Ausgabeknotens als Funktion der Eingänge und der Verknüpfungsgewichte für ein dreischichtiges neuronales Netz, mit nur zwei Knoten je Schicht, kann also wie folgt zusammen gefasst werden:

$O_{k} = \frac{1}{1 + e^{- \sum (w_{jk} \cdot \frac{1}{1 + e^{- \sum (w_{ij} \cdot x_{i}) }}) }}$

Abbildung 2: Forward-Propagation. Aktivierung via Sigmoid-Funktion.

Sollte dies die erste Forward-Propagation gewesen sein, wird der Output noch nicht auf den Input abgestimmt sein. Diese Abstimmung erfolgt in Form der Gewichtsanpassung im Training des neuronalen Netzes, über die zuvor erwähnte Gradientenmethode. Die Gradientenmethode ist jedoch von einem Fehler abhängig. Diesen Fehler zu bestimmen und durch das Netz zurück zu führen, das ist die Backpropagation.

Back-Propagation

Um die Gewichte entgegen des Fehlers anpassen zu können, benötigen wir einen möglichst exakten Fehler als Eingabe. Der Fehler berechnet sich an der Ausgabeschicht über eine Fehlerfunktion (Loss Function), beispielsweise über den MSE (Mean Squared Error) oder über die sogenannte Kreuzentropie (Cross Entropy). Lassen wir es in diesem Beispiel einfach bei einem simplen Vergleich zwischen dem realen Wert (Sollwert $o_{real}$ ) und der Prädiktion (Ausgabe $o$ ) bleiben:

$e_{o} = o_{real} - o$

Der Fehler $e$ ist also einfach der Unterschied zwischen dem Ziel-Wert und der Prädiktion. Jedes Training ist eine Wiederholung von Prädiktion (Forward) und Gewichtsanpassung (Back). Im ersten Schritt werden üblicherweise die Gewichtungen zufällig gesetzt, jede Gewichtung unterschiedlich nach Zufallszahl. So ist die Wahrscheinlichkeit, gleich zu Beginn die “richtigen” Gewichtungen gefunden zu haben auch bei kleinen neuronalen Netzen verschwindend gering. Der Fehler wird also groß sein und kann über den Gradientenabstieg durch Gewichtsanpassung verkleinert werden.

In diesem Beispiel berechnen wir die Fehler $e_{1}$ und $e_{2}$ und passen danach die Gewichte $w_{j,k}$ ( $w_{1,1}$ & $w_{2,1}$ und $w_{1,2}$ & $w_{2,2}$ ) der Schicht zwischen dem Hidden-Layer $N$ und dem Output-Layer $o$ an.

Abbildung 3: Anpassung der Gewichtungen basierend auf dem Fehler in der Ausgabe-Schicht.

Die Frage ist nun, wie die Gewichte zwischen dem Input-Layer $X$ und dem Hidden-Layer $N$ anzupassen sind. Es stellt sich die Frage, welchen Einfluss diese auf die Fehler in der Ausgabe-Schicht haben?

Um diese Gewichtungen anpassen zu können, benötigen wir den Fehler-Anteil der beiden Neuronen $N_{1}$ und $N_{2}$ . Dieser Anteil am Fehler der jeweiligen Neuronen ergibt sich direkt aus den Gewichtungen $w_{j,k}$ zum Output-Layer:

$e_{N_{1}} = e_{o1} \cdot \frac{w_{1,1}}{w_{1,1} + w_{1,2}} + e_{o2} \cdot \frac{w_{1,2}}{w_{1,1} + w_{1,2}}$

$e_{N_{2}} = e_{o1} \cdot \frac{w_{2,1}}{w_{2,1} + w_{2,2}} + e_{o2} \cdot \frac{w_{2,2}}{w_{2,1} + w_{2,2}}$

Wenn man das nun generalisiert:

$e_{N} = \left(\begin{array}{rr} \frac{w_{1,1}}{w_{1,1} + w_{1,2}} & \frac{w_{1,2}}{w_{1,1} + w_{1,2}} \\ \frac{w_{2,1}}{w_{2,1} + w_{2,2}} & \frac{w_{2,2}}{w_{2,1} + w_{2,2}} \end{array}\right) \cdot \left(\begin{array}{c} e_{1} \\ e_{2} \end{array}\right) \qquad$

Dabei ist es recht aufwändig, die Gewichtungen stets ins Verhältnis zu setzen. Diese Berechnung können wir verkürzen, indem ganz einfach direkt nur die Gewichtungen ohne Relativierung zur Kalkulation des Fehleranteils benutzt werden. Die Relationen bleiben dabei erhalten!

$e_{N} = \left(\begin{array}{rr} w_{1,1} & w_{1,2} \\ w_{2,1} & w_{2,2} \end{array}\right) \cdot \left(\begin{array}{c} e_{1} \\ e_{2} \end{array}\right) \qquad$

Oder folglich in Kurzform: $e_{N} = w^{T} \cdot e_{o}$

Abbildung 4: Vollständige Gewichtsanpassung auf Basis der Fehler in der Ausgabeschicht und der Fehleranteile in der verborgenden Schicht.

Und nun können, basierend auf den Fehleranteilen der verborgenden Schicht $N$ , die Gewichtungen $w_{i,j}$ zwischen der Eingabe-Schicht $I$ und der verborgenden Schicht $N$ angepasst werden, entgegen dieser Fehler $e_{N}$ .

Die Backpropagation besteht demnach aus zwei Schritten:

Fehler-Berechnung durch Abgleich der Soll-Werte mit den Prädiktionen in der Ausgabeschicht und durch Fehler-Rückführung zu den Neuronen der verborgenden Schichten (Hidden-Layer)
Anpassung der Gewichte entgegen des Gradientenanstiegs der Fehlerfunktion (Loss Function)

Buchempfehlungen

Die folgenden zwei Bücher haben mir sehr beim Verständnis und beim Verständlichmachen der Backpropagation in künstlichen neuronalen Netzen geholfen.


Neuronale Netze selbst programmieren: Ein verständlicher Einstieg mit Python	Deep Learning. Das umfassende Handbuch: Grundlagen, aktuelle Verfahren und Algorithmen, neue Forschungsansätze (mitp Professional)

Training eines Neurons mit dem Gradientenverfahren

January 13, 2019/in Artificial Intelligence, Data Science, Data Science Hack, Deep Learning, Machine Learning, Main Category, Mathematics, optimization, Predictive Analytics, Python/by Benjamin Aunkofer

Dies ist Artikel 3 von 6 der Artikelserie –Einstieg in Deep Learning.

Das Training von neuronalen Netzen erfolgt nach der Forward-Propagation über zwei Schritte:

Fehler-Rückführung über aller aktiver Neuronen aller Netz-Schichten, so dass jedes Neuron “seinen” Einfluss auf den Ausgabefehler kennt.
Anpassung der Gewichte entgegen den Gradienten der Fehlerfunktion

Beide Schritte werden in der Regel zusammen als Backpropagation bezeichnet. Machen wir erstmal einen Schritt vor und betrachten wir, wie ein Neuron seine Gewichtsverbindungen zu seinen Vorgängern anpasst.

Gradientenabstiegsverfahren

Der Gradientenabstieg ist ein generalisierbarer Algorithmus zur Optimierung, der in vielen Verfahren des maschinellen Lernens zur Anwendung kommt, jedoch ganz besonders als sogenannte Backpropagation im Deep Learning den Erfolg der künstlichen neuronalen Netze erst möglich machen konnte.

Der Gradientenabstieg lässt sich vom Prinzip her leicht erklären: Angenommen, man stünde im Gebirge im dichten Nebel. Das Tal, und somit der Weg nach Hause, ist vom Nebel verdeckt. Wohin laufen wir? Wir können das Ziel zwar nicht sehen, tasten uns jedoch so heran, dass unser Gehirn den Gradienten (den Unterschied der Höhen beider Füße) berechnet, somit die Steigung des Bodens kennt und sich entgegen dieser Steigung unser Weg fortsetzt.

Konkret funktioniert der Gradientenabstieg so: Wir starten bei einem zufälligen Theta $\theta$ (Random Initialization). Wir berechnen die Ausgabe (Forwardpropogation) und vergleichen sie über eine Verlustfunktion (z. B. über die Funktion Mean Squared Error) mit dem tatsächlich korrekten Wert. Auf Grund der zufälligen Initialisierung haben wir eine nahe zu garantierte Falschheit der Ergebnisse und somit einen Verlust. Für die Verlustfunktion berechnen wir den Gradienten für gegebene Eingabewerte. Voraussetzung dafür ist, dass die Funktion ableitbar ist. Wir bewegen uns entgegen des Gradienten in Richtung Minimum der Verlustfunktion. Ist dieses Minimum (fast) gefunden, spricht man auch davon, dass der Lernalgorithmus konvergiert.

Das Gradientenabstiegsverfahren ist eine Möglichkeit der Gradientenverfahren, denn wollten wir maximieren, würden wir uns entlang des Gradienten bewegen, was in anderen Anwendungen sinnvoll ist.

Ob als “Cost Function” oder als “Loss Function” bezeichnet, in jedem Fall ist es eine “Error Function”, aber auf die Benennung kommen wir später zu sprechen. Jedenfalls versuchen wir die Fehlerrate zu senken! Leider sind diese Funktionen in der Praxis selten so einfach konvex (zwei Berge mit einem Tal dazwischen).

Aber Achtung: Denn befinden wir uns nur zwischen zwei Bergen, finden wir das Tal mit Sicherheit über den Gradienten. Befinden wir uns jedoch in einem richtigen Gebirge mit vielen Bergen und Tälern, gilt es, das richtige Tal zu finden. Bei der Optimierung der Gewichtungen von künstlichen neuronalen Netzen wollen wir die besten Gewichtungen finden, die uns zu den geringsten Ausgaben der Verlustfunktion führen. Wir suchen also das globale Minimum unter den vielen (lokalen) Minima.

Programmier-Beispiel in Python

Nachfolgend ein Beispiel des Gradientenverfahrens zur Berechnung einer Regression. Wir importieren numpy und matplotlib.pyplot und erzeugen uns künstliche Datenpunkte:

import numpy as np
import matplotlib.pyplot as plt


X = 2 * np.random.rand(1000, 1)
y = 5 + 2 * X + np.random.randn(1000, 1)

plt.figure(figsize = (15, 15))
plt.plot(X, y, "b.")
plt.axis([0, 2, 0, 15])
plt.show()

Nun wollen wir einen Lernalgorithmus über das Gradientenverfahren erstellen. Im Grunde haben wir hier es bereits mit einem linear aktivierten Neuron zutun:

Bei der linearen Regression, die wir durchführen wollen, nehmen wir zwei-dimensionale Daten (wobei wir die Regression prinzipiell auch mit x-Dimensionen durchführen können, dann hätte unser Neuron weitere Eingänge). Wir empfangen einen Bias ( $w_0$ ) der stets mit einer Eingangskonstante multipliziert und somit als Wert erhalten bleibt. Der Bias ist das Alpha $\alpha$ in einer Schulmathe-tauglichen Formel wie $y = \beta \cdot x + \alpha$ .

Beta $\beta$ ist die Steigung, der Gradient, der Funktion.

Sowohl $\alpha$ als auch $\beta$ sind uns unbekannt, versuchen wir jedoch über die Betrachtung unserer Prädiktion durch Berechnung der Formel $\^y = \beta \cdot x + \alpha$ und den darauffolgenden Abgleich mit dem tatsächlichen $y$ herauszufinden. Anfangs behaupten wir beispielsweise einfach, sowohl $\beta$ als auch $\alpha$ seien $0.00$ . Folglich wird $\^y = \beta \cdot x + \alpha$ ebenfalls gleich 0.00 sein und die Fehlerfunktion (Loss Function) wird maximal sein. Dies war der erste Durchlauf des Trainings, die sogenannte erste Epoche!

Die Epochen (Durchläufe) und dazugehörige Fehlergrößen. Wenn die Fehler sinken und mit weiteren Epochen nicht mehr wesentlich besser werden, heißt es, das der Lernalogorithmus konvergiert.

Als Fehlerfunktion verwenden wir bei der Regression die MSE-Funktion (Mean Squared Error):

$MSE = \sum(\^y_i - y_i)^2$

Um diese Funktion wird sich nun alles drehen, denn diese beschreibt den Fehler und gibt uns auch die Auskunft darüber, ob wie stark und in welche Richtung sie ansteigt, so dass wir uns entgegen der Steigung bewegen können. Wer die Regeln der Ableitung im Kopf hat, weiß, dass die Ableitung der Formel leichter wird, wenn wir sie vorher auf halbe Werte runterskalieren. Da die Proportionen dabei erhalten bleiben und uns quadrierte Fehlerwerte unserem menschlichen Verstand sowieso nicht so viel sagen (unser Gehirn denkt nunmal nicht exponential), stört das nicht:

$MSE = \frac{\frac{1}{2} \cdot \sum(\^y_i - y_i)^2}{n}$

$MSE = \frac{\frac{1}{2} \cdot \sum(w^T \cdot x_i - y_i)^2}{n}$

Wenn die Mathematik der partiellen Ableitung (Ableitung einer Funktion nach jedem Gradienten) abhanden gekommen ist, bitte nochmal folgende Regeln nachschlagen, um die nachfolgende Ableitung verstehen zu können:

Allgemeine partielle Ableitung
Kettenregel

Ableitung der MSD-Funktion nach dem einen Gewicht $w$ bzw. partiell nach jedem vorhandenen $w_j$ :

$\frac{\partial}{\partial w_j}MSE = \frac{\partial}{\partial w} \frac{1}{2} \cdot \sum(\^y - y_i)^2$

$\frac{\partial}{\partial w_j}MSE = \frac{\partial}{\partial w} \frac{1}{2} \cdot \sum(w^T \cdot x_i - y_i)^2$

$\frac{\partial}{\partial w_j}MSE = \frac{2}{n} \cdot \sum(w^T \cdot x_i - y_i) \cdot x_{ij}$

Woher wir das $x_{ij}$ am Ende her haben? Das ergibt sie aus der Kettenregel: Die äußere Funktion wurde abgeleitet, so wurde aus $\frac{1}{2} \cdot \sum(w^T \cdot x_i - y_i)^2$ dann $\frac{2}{n} \cdot \sum(w^T \cdot x_i - y_i)$ . Jedoch muss im Sinne eben dieser Kettenregel auch die innere Funktion abgeleitet werden. Da wir nach $w_j$ ableiten, bleibt nur $x_ij$ erhalten.

Damit können wir arbeiten! So kompliziert ist die Formel nun auch wieder nicht: $\frac{2}{n} \cdot \sum(w^T \cdot x_i - y_i) \cdot x_{ij}$

Mit dieser Formel können wir unsere Gewichte an den Fehler anpassen: ( $f\nabla$ ist der Gradient der Funktion!)

$w_j = w_j - \nabla MSE(w_j)$

Initialisieren der Gewichtungen

Die Gewichtungen $\alpha$ und $\beta$ müssen anfänglich mit Werten initialisiert werden. In der Regression bietet es sich an, die Gewichte anfänglich mit $0.00$ zu initialisieren.

Bei vielen neuronalen Netzen, mit nicht-linearen Aktivierungsfunktionen, ist das jedoch eher ungünstig und zufällige Werte sind initial besser. Gut erprobt sind normal-verteilte Zufallswerte.

Lernrate

Nur eine Kleinigkeit haben wir bisher vergessen: Wir brauchen einen Faktor, mit dem wir anpassen. Hier wäre der Faktor 1. Das ist in der Regel viel zu groß. Dieser Faktor wird geläufig als Lernrate (Learning Rate) $\eta$ (eta) bezeichnet:

$w_j = w_j - \eta \cdot \nabla MSE(w_j)$

Die Lernrate $\eta$ ist ein Knackpunkt und der erste Parameter des Lernalgorithmus, den es anzupassen gilt, wenn das Training nicht konvergiert.

Die Lernrate $\eta$ darf nicht zu groß klein gewählt werden, da das Training sonst zu viele Epochen benötigt. Ungeduldige erhöhen die Lernrate möglicherweise aber so sehr, dass der Lernalgorithmus im Minimum der Fehlerfunktion vorbeiläuft und diesen stets überspringt. Hier würde der Algorithmus also sozusagen konvergieren, weil nicht mehr besser werden, aber das resultierende Modell wäre weit vom Optimum entfernt.

Beginnen wir mit der Implementierung als Python-Klasse:

class LinearRegressionGD(object):
    
    def __init__(self, eta = 0.0001, n_iter = 50):
        
        self.eta = eta                  # Lernrate
        self.n_iter = n_iter            # Epochen
        
    def fit(self, X, y):
        
        self.w_ = np.zeros(1 + X.shape[1]) # <- 1 für den Bias + alle weiteren Columns für die Steigungen
                                           # In diesem Beispiel self.w_ = [0.0, 0.] = [Alpha, Beta]
                                           # Dabei initialisieren wir Alpha und Beta mit 0.00-Werten
        
        self.cost_ = []                    # Cost Function (der Verlauf der Loss Function MSE)
        
        for i in range(self.n_iter):       # Für jede Epoche...
            
            output = self.predict(X)       # Die Funktion x * Beta + Alpha ausrechnen  
                                           # Batch-Verfahren, denn wir trainieren jede Epoche mit allen X-Werten

            errors = y.flatten() - output  # y_predicted - y_real

            mse = ((errors ** 2).sum() / 2.0) / len(X)  # Loss Function MSE
            
            self.cost_.append(mse)                      # Loss Function wird Teil der Cost Function
            
            self.w_[1:] += self.eta * X.T.dot(errors)   # Anpassen des Gewichts Beta (und falls es sie gäbe: aller weiteren Gewichte)
            self.w_[0] += self.eta * errors.sum()      # Anpassen des Gewichts Alpha
            
            
            #print(output)
            #print(errors)
            #print("Beta  -> ", self.w_[1:])
            #print("Alpha -> ", self.w_[0])                   
            
        return self
        
    def predict(self, X):
        return np.dot(X, self.w_[1:]) + self.w_[0]      # y = x * Beta + Alpha

Die Klasse sollte so funktionieren, bevor wir sie verwenden, sollten wir die Input-Werte standardisieren:

x_std = (X - X.mean()) / X.std()
y_std = (y - y.mean()) / y.std()

Bei diesem Beispiel mit künstlich erzeugten Werten ist das Standardisieren bzw. das Fehlen des Standardisierens zwar nicht kritisch, aber man sollte es sich zur Gewohnheit machen. Testweise es einfach mal weglassen 🙂

Kommen wir nun zum Einsatz der Klasse, die die Regression via Gradientenabstieg absolvieren soll:

lrGD = LinearRegressionGD()  # Instanziieren
lrGD.fit(x_std, y_std)       # Trainieren (das ".fit()" entspricht dem Wording von scikit-learn, ".train()" wäre mir sonst lieber :-)

Was tut diese Instanz der Klasse LinearRegressionGD nun eigentlich?

Bildlich gesprochen, legt sie eine Gerade auf den Boden des Koordinatensystems, denn die Gewichtungen werden mit 0.00 initialisiert, $y$ ist also gleich 0.00, egal welche Werte in $x$ enthalten sind. Der Fehler ist dann aber sehr groß (sollte maximal sein, im Vergleich zu zukünftigen Epochen). Die Gewichte werden also angepasst, die Gerade somit besser in die Punktwolke platziert. Mit jeder Epoche wird die Gerade erneut in die Punktwolke gelegt, der Gesamtfehler (über alle $x$ , da wir es hier mit dem Batch-Verfahren zutun haben) berechnet, die Werte angepasst… bis die vorgegebene Zahl an Epochen abgelaufen ist.

Schauen wir uns das Ergebnis des Trainings an:

plt.figure(figsize = (15, 15))
plt.plot(x_std, y_std, "b.")                                # Scatter, wie zuvor!
plt.plot(x_std, lrGD.predict(x_std), "r-", linewidth = 5)   # Regressionsgerade als Linie
plt.show()

Die Linie sieht passend aus, oder? Da wir hier nicht zu sehr in die Theorie der Regressionsanalyse abdriften möchten, lassen wir das testen und prüfen der Akkuratesse mal aus, hier möchte ich auf meinen Artikel Regressionsanalyse in Python mit Scikit-Learn verweisen.

Prüfen sollten wir hingegen mal, wie schnell der Lernalgorithmus mit der vorgegebenen Lernrate $eta$ konvergiert:

plt.figure(figsize = (15, 15))
plt.plot(range(1, lrGD.n_iter + 1), lrGD.cost_)
plt.xlabel('Epochen')
plt.ylabel('Summe quadrierter Abweichungen')
plt.show()

Hier die Verlaufskurve der Cost Function:

Die Kurve zeigt uns, dass spätestens nach 40 Epochen kaum noch Verbesserung (im Sinne der Gesamtfehler-Minimierung) erreicht wird.

Wichtige Hinweise

Natürlich war das nun nur ein erster kleiner Einstieg und wer es verstanden hat, hat viel gewonnen. Denn erst dann kann man sich vorstellen, wie ein einzelnen Neuron eines künstlichen neuronalen Netzes grundsätzlich trainiert werden kann.

Folgendes sollte noch beachtet werden:

Lernrate $\eta$ :
Die Lernrate ist ein wichtiger Parameter. Wer das Programmier-Beispiel bei sich zum Laufen gebracht hat, einfach mal die Lernrate auf Werte zwischen 10.00 und 0.00000001 setzen, schauen was passiert 🙂
Globale Minima vs lokale Minima:
Diese lineare zwei-dimensionale Regression ist ziemlich einfach. Neuronale Netze sind hingegen komplexer und haben nicht einfach nur eine simple konvexe Fehlerfunktion. Hier gibt es mehrere Hügel und Täler in der Fehlerfunktion und die Gefahr ist groß, in einem lokalen, nicht aber in einem globalen Minimum zu landen.
Stochastisches Gradientenverfahren:
Wir haben hier das sogenannte Batch-Verfahren verwendet. Dieses ist grundsätzlich besser als die stochastische Methode. Denn beim Batch verwenden wir den gesamten Stapel an $x$ -Werten für die Fehlerbestimmung. Allerdings ist dies bei großen Daten zu rechen- und speicherintensiv. Dann werden kleinere Unter-Stapel (Sub-Batches) zufällig aus den $x$ -Werten ausgewählt, der Fehler daraus bestimmt (was nicht ganz so akkurat ist, wie als würden wir den Fehler über alle $x$ berechnen) und der Gradient bestimmt. Dies ist schon Rechen- und Speicherkapazität, erfordert aber meistens mehr Epochen.

Buchempfehlung

Die folgenden zwei Bücher haben mir bei der Erstellung dieses Beispiels geholfen und kann ich als hilfreiche und deutlich weiterführende Lektüre empfehlen:


Machine Learning mit Python und Scikit-Learn und TensorFlow: Das umfassende Praxis-Handbuch für Data Science, Predictive Analytics und Deep Learning (mitp Professional)	Hands-On Machine Learning with Scikit-Learn and TensorFlow: Concepts, Tools, and Techniques for Building Intelligent Systems

Funktionsweise künstlicher neuronaler Netze

August 31, 2018/in Artificial Intelligence, Business Analytics, Data Science, Deep Learning, Machine Learning, Main Category, Mathematics/by Benjamin Aunkofer

Künstliche neuronale Netze sind ein Spezialbereich des maschinellen Lernens, der sogar einen eigenen Trendbegriff hat: Deep Learning.
Doch wie funktioniert ein künstliches neuronales Netz überhaupt? Und wie wird es in Python realisiert? Dies ist Artikel 2 von 6 der Artikelserie –Einstieg in Deep Learning.

Gleich vorweg, wir beschränken uns hier auf die künstlichen neuronalen Netze des überwachten maschinellen Lernens. Dafür ist es wichtig, dass das Prinzip des Trainings und Testens von überwachten Verfahren verstanden ist. Künstliche neuronale Netze können aber auch zur unüberwachten Dimensionsreduktion und zum Clustering eingesetzt werden. Das bekannteste Verfahren ist das AE-Net (Auto Encoder Network), das hier aus der Betrachtung herausgenommen wird.

Beginnen wir mit einfach künstlichen neuronalen Netzen, die alle auf dem Perzeptron als Kernidee beruhen. Das Vorbild für künstliche neuronale Netze sind natürliche neuronale Netze, wie Sie im menschlichen Gehirn zu finden sind.

Perzeptron

Das Perzeptron (engl. Perceptron) ist ein „Klassiker“ unter den künstlichen neuronalen Netzen. Wenn von einem neuronalen Netz gesprochen wird, ist meistens ein Perzeptron oder eine Variation davon gemeint. Perzeptrons sind mehrschichtige Netze ohne Rückkopplung, mit festen Eingabe- und Ausgabeschichten. Es gibt keine absolut einheitliche Definition eines Perzeptrons, in der Regel ist es jedoch ein reines FeedForward-Netz mit einer Input-Schicht (auch Abtast-Schicht oder Retina genannt) mit statisch oder dynamisch gewichteten Verbindungen zur Ausgabe-Schicht, die (als Single-Layer-Perceptron) aus einem einzigen Neuron besteht. Das eine Neuron setzt sich aus zwei mathematischen Funktionen zusammen: Einer Berechnung der Nettoeingabe und einer Aktivierungsfunktion, die darüber entscheidet, ob die berechnete Nettoeingabe im Brutto nun “feuert” oder nicht. Es ist in seiner Ausgabe folglich binär: Man kann es sich auch als kleines Lämpchen vorstellen, so dass abhängig von den Eingabewerten und den Gewichtungen eine Nettoeingabe (Summe) bildet und eine Sprungfunktion darüber entscheidet, ob am Ende das Lämpchen leuchtet oder nicht. Dieses Konzept der Ausgabeerzeugung wird Forward-Propagation genannt.

Single-Layer-Perceptron

Auch wenn “Netz” für ein einzelnes Perzeptron mit seinem einen Neuron etwas übertrieben wirken mag, ist es doch die Grundlage für viele größere und mehrschichtige Netze.

Betrachten wir nun die Mathematik der Forward-Propagation.

Wir haben eine Menge an Eingabewerten $x_0, x_1 \dots x_n$ . Wobei für $x_0$ als Bias-Input stets gilt: $x_0 = 1,0$ . Der Bias-Input ist nur ein Platzhalter für das wichtige Bias-Gewicht.

$x = \begin{bmatrix} x_0\\ x_1\\ x_2\\ x_3\\ \vdots\\ x_n \end{bmatrix}$

Für jede Eingabevariable wird eine Gewichtsvariable benötigt: $w_0, w_1 \dots w_n$

$w = \begin{bmatrix} w_0\\ w_1\\ w_2\\ w_3\\ \vdots\\ w_n \end{bmatrix}$

Jedes Produkt aus Eingabewert und Gewichtung soll in Summe die Nettoeingabe $z$ bilden. Hier zeigt sich $z$ als lineare mathematische Funktion, die zwei-dimensional leicht als $z = w_0 + w_1 \cdot x_1$ mit $w_0$ als Y-Achsenschnitt wenn $x_1 = 0$ .

$z = w_0 \cdot x_0 + w_1 \cdot x_1 + \dots + w_n \cdot x_n$

Die lineare Funktion wird nur durch die Sprungfunktion als sogenannte Aktivierungsfunktion zu einer binären Klasseneinteilung (siehe hierzu: Machine Learning – Regression vs Klassifikation), denn wenn $z$ einen festzulegenden Schwellwert $\theta$ überschreitet, liefert die Sprungfunktion $\phi$ mit der Eingabe $z$ einen anderen Wert als wenn dieser Schwellwert nicht überschritten wird.

(1) $\begin{equation*} \phi(z) = \begin{cases} 1 & \text{wenn } z \le \theta \\ -1 & \text{wenn } z < \theta \\ \end{cases} \end{equation*}$

Die Definition dieser Aktivierungsfunktion ist der Kern der Klassifikation und viele erweiterte künstliche neuronale Netze unterscheiden sich im Wesentlichen vom Perzeptron dadurch, dass die Aktivierungsfunktion komplexer ist, als eine reine Sprungfunktion, beispielsweise als Sigmoid-Funktion (basierend auf der logistischen Funktion) oder die Tangens hyperbolicus (tanh) -Funktion. Mehr darüber dann im nächsten Artikel dieser Artikelserie, bleiben wir also bei der einfachen Sprungfunktion.

Künstliche neuronale Netze sind im Grunde nichts anderes als viel-dimensionale, mathematische Funktionen, die durch Schaltung als Neuronen nebeneinander (Neuronen einer Schicht) und hintereinander (mehrere Schichten) eine enorme Komplexität erfassen können. Die Gewichtungen sind dabei die Stellschraube, die die Form der mathematischen Funktion gestaltet, aus Geraden und Kurven, um eine Punktwolke zu beschreiben (Regression) oder um Klassengrenzen zu identifizieren (Klassifikation).

Eine andere Sichtweise auf künstliche neuronale ist die des Filters: Ein künstliches neuronales Netz nimmt alle Eingabe-Variablen entgegen (z. B. alle Pixel eines Bildes) und über ein Training werden die Gewichtungen (die Form des Filters) so gestaltet, dass der Filter immer zu richtigen Klasse (im Kontext der Bildklassifikation: die Objektklasse) führt.

Kommen wir nochmal kurz zurück zu der Berechnung der Nettoeingabe $z$ . Da diese Schreibweise…

$z = w_0 \cdot x_0 + w_1 \cdot x_1 + \dots + w_n \cdot x_n$

… recht anstrengend ist, schreiben Fortgeschrittene der linearen Algebra lieber $z = w^T \cdot x$ .

$z = w^T \cdot x$

Das hochgestellte $T$ steht dabei für transponieren. Transponieren bedeutet, dass Spalten zu Zeilen werden – oder umgekehrt.

Beispielsweise befüllen wir zwei Vektoren $x$ und $w$ mit beispielhaften Inhalten:

Eingabewerte:

$x = \begin{bmatrix} 5\\ 12\\ 30\\ 2 \end{bmatrix}$

Gewichtungen:

$w = \begin{bmatrix} 1\\ 2\\ 5\\ 12 \end{bmatrix}$

Kann nun die Nettoeingabe $z$ berechnet werden, denn der Gewichtungsvektor wird vom Spaltenvektor zum Zeilenvektor. So kann – mathematisch korrekt dargestellt – jedes Element des einen Vektors mit dem zugehörigen Element des anderen Vektors multipliziert werden, die dabei entstehenden Ergebniswerte werden summiert.

$z = w^T \cdot x = \big[1\text{ }2\text{ }5\text{ }12\big] \cdot \begin{bmatrix} 5\\ 12\\ 30\\ 2 \end{bmatrix} = 1 \cdot 5 + 2 \cdot 12 + 5 \cdot 30 + 12 \cdot 2 = 203$

Zurück zur eigentlichen Aufgabe des künstlichen neuronalen Netzes: Klassifikation! (Regression, Clustering und Dimensionsreduktion blenden wir ja in diesem Artikel als Aufgabe aus 🙂

Das Perzeptron soll zwei Klassen trennen. Dafür sollen alle Eingaben richtig gewichtet werden, so dass die entstehende Nettoeingabe $z$ die Sprungfunktion dann aktiviert, wenn der Datensatz nicht für die eine, sondern für die andere Klasse ausweist.

Da wir es mit einer linearen Funktion $z$ zutun haben, ist die Konvergenz (= Passgenauigkeit des Models mit der Realität) eines Single-Layer-Perzeptrons nur für lineare Trennbarkeit möglich!

Training des Perzeptron-Netzes

Die Aufgabe ist nun, die richtigen Gewichte zu finden – und nicht nur irgendwelche richtigen, sondern genau die optimalen. Die Frage, die sich für jedes künstliche neuronale Netz stellt, ist die nach den richtigen Gewichtungen. Das Training eines Perzeptron ist vergleichsweise einfach, gerade weil es binär ist. Denn binär bedeutet auch, dass wenn eine falsche Antwort gegeben wurde, muss das jeweils andere mögliche Ergebnis korrekt sein.

Das Training eines Perzeptrons funktioniert wie folgt:

Setze alle Gewichtungen auf den Wert 0,00
Mit jedem Datensatz des Trainings
1. Berechne den Ausgabewert $\^{y}$
2. Vergleiche den Ausgabewert $\^{y}$ mit dem tatsächlichen Ergebnis $y$
3. Aktualisiere die Gewichtungen entgegen des Fehlers: $w_i = w_i + \Delta w_i$

Wobei die Gewichtsanpassung $\Delta w_i$ entgegen des Fehlers (bzw. hin zur jeweils anderen möglichen Antwort) geschieht:

$\Delta w_i = (\^{y}_j - y_j ) \cdot x_i$

Anmerkung für die Experten: Die Schrittweite $\eta$ blenden wir hier einfach mal aus. Bitte einfach von $\eta = 1.0$ ausgehen.

$\Delta w_i$ ist die Differenz aus der Prädiktion und dem tatsächlichen Ergebnis (Klasse). Alle Gewichtungen werden mit jedem Fehler gleichzeitig aktualisiert. Sind alle Gewichtungen aktualisiert, kommt der nächste Durchlauf (erneuter Vergleich zwischen $\^{y}$ und $y$ ), nicht zu vergessen ist dabei natürlich die Abhängigkeit von den Eingabewerten x:

$\Delta w_0 = (\^{y}_j - y_j ) \cdot x_0$

$\Delta w_2 = (\^{y}_j - y_j ) \cdot x_1$

$\Delta w_2 = (\^{y}_j - y_j) \cdot x_2$

$\Delta w_n = (\^{y}_j - y_j) \cdot x_n$

Training eines Perzeptrons

Das Training im überwachten Lernen basiert immer auf der Idee, den Ausgabe-Fehler (die Differenz zwischen Prädiktion und tatsächlich korrektem Ergebnis) zu betrachten und die Klassifikationslogik an den richtigen Stellschrauben (bei neuronalen Netzen sind das die Gewichtungen) entgegen des Fehlers anzupassen.

Richtige Klassifikations-Situationen können True-Positives und True-Negatives darstellen, die zu keiner Gewichtsanpassung führen sollen:

True-Positive -> Klassifikation: 1 | korrekte Klasse: 1

$\Delta w_i = (\^{y}_j - y_j) \cdot x_i = (1 - 1) \cdot x_i = 0$

True-Negative-> Klassifikation: -1 | korrekte Klasse: -1

$\Delta w_i = (\^{y}_j - y_j) \cdot x_i = (-1 - -1) \cdot x_i = 0$

Falsche Klassifikationen erzeugen einen Fehler, der zu einer Gewichtsanpassung entgegen des Fehlers führen soll:

False-Positive -> Klassifikation: 1 | korrekte Klasse: -1

$\Delta w_i = (\^{y}_j - y_j) \cdot x_i = (1 - -1) \cdot x_i = 2 \cdot x_i$

False-Negative -> Klassifikation: -1 | korrekte Klasse: 1

$\Delta w_i = (\^{y}_j - y_j) \cdot x_i = (-1 - 1) \cdot x_i = -2 \cdot x_i$

Imaginäres Trainingsbeispiel eines Single-Layer-Perzeptrons (SLP)

Nehmen wir an, dass $x_1 = 0,5$ ist und das SLP irrtümlicherweise die Klasse $\^{y_1} = -1$ ausgewiesen hat, obwohl die korrekte Klasse $y_1 = +1$ wäre. (Und die Schrittweite lassen wir bei $\eta = 1,0$ )

Dann passiert folgendes:

$\Delta w_1 = (\^{y}_1 - y_1) \cdot x_1 = (-1 - 1) \cdot 0,5 = -2,0 \cdot 0,5 = -1,0$

Die Gewichtung $w_1$ verringert sich entsprechend $w_1 = w_1 + \Delta w_1 = w_1 - 1,0$ und somit wird die Wahrscheinlichkeit größer, dass wenn bei der nächsten Iteration ( $j=1$ ) wieder die Klasse +1 korrekt sei, den Schwellwert $\phi(z)$ zu unterschreiten und auf eben diese korrekte Klasse zu stoßen.

Die Aktualisierung der Gewichtung $\Delta w_i$ ist proportional zu $x_i$ . So würde beispielsweise ein neues $x_1=2,0$ (bei Iteration $j=2$ ) zu einer irrtümlichen Klassifikation $\^(y_2) = -1$ ( $y_2 = +1$ ) führen, würde die Entscheidungsgrenze zur korrekten Prädiktion der Klasse beim nächsten Durchlauf ( $j = 3$ ) an $w_1$ noch weiter in die gleiche Richtung verschoben werden:

$\Delta w_1 = (\^{y}_2 - y_2) \cdot x_1 = (-1 - 1) \cdot 2,0 = -2,0 \cdot 2,0 = -4,0$

Mehr zum Training von künstlichen neuronalen Netzen ist im nächsten Artikel dieser Artikelserie zu erfahren.

Single-Layer-Perzeptrons (SLP) – Beispiel mit der boolischen Trennung

Verlassen wir nun das Training des Perzeptrons und gehen einfach mal davon aus, dass die idealen Gewichte schon gefunden wurden und schauen uns nun an, was ein Perzeptron alles (nicht) kann. Denn nicht vergessen, es soll eigentlich Klassen unterscheiden bzw. die dafür nötigen Entscheidungsgrenzen finden.

Boolische Operatoren unterscheiden Fälle nach boolischen Werten. Sie sind ein beliebtes “Hello World” für die Einarbeitung in die lineare Entscheidungslogik eines Perzeptrons. Es gibt drei grundlegende boolische Vergleichsoperatoren: AND, OR und XOR

x1	x2	AND	OR	XOR
0	0	0	0	0
0	1	0	1	1
1	0	0	1	1
1	1	1	1	0

Ein Perzeptron zur Lösung dieser Aufgabe bräuchte also zwei Dimensionen (+ Bias): $x_1$ und $x_2$
Und es müsste Gewichtungen haben, die dafür sorgen, dass die Vorhersage entsprechend der Logik AND, OR oder XOR mit $\^{y} = \phi(z) = \phi (w_0 \cdot 1 + w_1 \cdot x_1 + w_2 \cdot x_2)$ funktioniert.

Dabei ist es wichtig, dass wir auch phi $\phi$ als Sprungfunktion definieren. Sie könnte beispielsweise so aussehen, dass sie auf den Wert $\phi(z) = 1$ springt, wenn z > 0 ist, ansonsten aber $\phi(z) = 0$ bleibt.

Das Netz und die Gewichtungen (w-Setup) könnten für die AND- und die OR-Logik so aussehen:

Die Gewichtungen funktionieren beim SLP problemlos, denn wir haben es mit linear trennbaren Problemen zutun:

Kleiner Test gefällig? So nehmen wir uns erstmal die AND-Logik vor:

Wenn x1 = 0 und x2 = 0 ist, gilt: $z = -1,5 \cdot 1 + 1 \cdot 0 + 1 \cdot 0 = - 1,5$ ,
wie erhalten als Prädiktion $\phi(z) = \phi(-1,5) = 0$
Wenn x1 = 1 und x2 = 0 ist, gilt: $z = -1,5 \cdot 1 + 1 \cdot 1 + 1 \cdot 0 = - 0,5$ ,
wie erhalten als Prädiktion $\phi(z) = \phi(-0,5) = 0$
Wenn x1 = 1 und x2 = 1 ist, gilt: $z = -1,5 \cdot 1 + 1 \cdot 1 + 1 \cdot 1 = + 0,5$ ,
wie erhalten als Prädiktion $\phi(z) = \phi(0,5) = 1$

Scheint zu funktionieren!

Und dann die OR-Logik mit

Wenn x1 = 0 und x2 = 0 ist, gilt: $z = -0,5 \cdot 1 + 1 \cdot 0 + 1 \cdot 0 = - 0,5$ ,
wie erhalten als Prädiktion $\phi(z) = \phi(-0,5) = 0$
Wenn x1 = 1 und x2 = 0 ist, gilt: $z = -0,5 \cdot 1 + 1 \cdot 1 + 1 \cdot 0 = + 0,5$ ,
wie erhalten als Prädiktion $\phi(z) = \phi(0,5) = 1$
Wenn x1 = 1 und x2 = 1 ist, gilt: $z = -0,5 \cdot 1 + 1 \cdot 1 + 1 \cdot 1 = + 1,5$ ,
wie erhalten als Prädiktion $\phi(z) = \phi(1,5) = 1$

Super! Jedoch stellt sich nun die Frage, wie das XOR-Problem zu lösen ist, denn das bedingt sowohl die Grenzen von AND als auch jene des OR-Operators.

Multi-Layer-Perzeptron (MLP) bzw. (Deep) Feed Forward (FF) Net

Denn ein XOR kann mathematisch auch so korrekt beschrieben werden: $x_1 \text{ xor } x_2 = (x_1 \text{ and } \neg x_2) \text{ or } (\neg x_1 \text{ and } x_2)$

Testen wir es aus!

Wenn x1 = 0 und x2 = 0 ist, gilt:
$z_1 = w_{10} \cdot 1 + w_{11} \cdot x1 + w_{12} \cdot x2 = -0.5 \cdot 1 + 1,0 \cdot 0 - 1,0 \cdot 0 = -0,5$ und somit $\phi(z_1) = \phi(-0,5) = 0$
$z_2 = w_{20} \cdot 1 + w_{21} \cdot x1 + w_{22} \cdot x2 = -0.5 \cdot 1 - 1,0 \cdot 0 + 1,0 \cdot 0 = -0,5$ und somit $\phi(z_2) = \phi(-0,5) = 0$
$z_3 = w_{30} \cdot 1 + w_{31} \cdot \phi(z_1) + w_{32} \cdot \phi(z_2) = -0,5 \cdot 1 + 1,0 \cdot 0 + 1,0 \cdot 0 = -0,5$ und somit $\phi(z_3) = \phi(-0,5) = 0$
Wenn x1 = 1 und x2 = 0 ist, gilt:
$z_1 = w_{10} \cdot 1 + w_{11} \cdot x1 + w_{12} \cdot x2 = -0.5 \cdot 1 + 1,0 \cdot 1 - 1,0 \cdot 0 = 0,5$ und somit $\phi(z_1) = \phi(0,5) = 1$
$z_2 = w_{20} \cdot 1 + w_{21} \cdot x1 + w_{22} \cdot x2 = -0.5 \cdot 1 - 1,0 \cdot 1 + 1,0 \cdot 0 = -1,5$ und somit $\phi(z_2) = \phi(-1,5) = 0$
$z_3 = w_{30} \cdot 1 + w_{31} \cdot \phi(z_1) + w_{32} \cdot \phi(z_2) = -0,5 \cdot 1 + 1,0 \cdot 1 + 1,0 \cdot 0 = 0,5$ und somit $\phi(z_3) = \phi(0,5) = 1$
Wenn x1 = 0 und x2 = 1 ist, gilt:
$z_1 = w_{10} \cdot 1 + w_{11} \cdot x1 + w_{12} \cdot x2 = -0.5 \cdot 1 + 1,0 \cdot 0 - 1,0 \cdot 1 = -1,5$ und somit $\phi(z_1) = \phi(-1,5) = 0$
$z_2 = w_{20} \cdot 1 + w_{21} \cdot x1 + w_{22} \cdot x2 = -0.5 \cdot 1 - 1,0 \cdot 0 + 1,0 \cdot 1 = 0,5$ und somit $\phi(z_2) = \phi(0,5) = 1$
$z_3 = w_{30} \cdot 1 + w_{31} \cdot \phi(z_1) + w_{32} \cdot \phi(z_2) = -0,5 \cdot 1 + 1,0 \cdot 0 + 1,0 \cdot 1 = 0,5$ und somit $\phi(z_3) = \phi(0,5) = 1$
Wenn x1 = 1 und x2 = 1 ist, gilt:
$z_1 = w_{10} \cdot 1 + w_{11} \cdot x1 + w_{12} \cdot x2 = -0.5 \cdot 1 + 1,0 \cdot 1 - 1,0 \cdot 1 = -1,5$ und somit $\phi(z_1) = \phi(-0,5) = 0$
$z_2 = w_{20} \cdot 1 + w_{21} \cdot x1 + w_{22} \cdot x2 = -0.5 \cdot 1 - 1,0 \cdot 1 + 1,0 \cdot 1 = 0,5$ und somit $\phi(z_2) = \phi(-0,5) = 0$
$z_3 = w_{30} \cdot 1 + w_{31} \cdot \phi(z_1) + w_{32} \cdot \phi(z_2) = -0,5 \cdot 1 + 1,0 \cdot 0 + 1,0 \cdot 0 = -0,5$ und somit $\phi(z_3) = \phi(-0,5) = 0$

Es funktioniert!

Mehrfachklassifikation mit dem Perzeptron

Ein Perzeptron-Netz klassifiziert binär, die Ausgabe beschränkt sich auf 1 oder -1 bzw. 0 oder 1.

Jedoch wird in der Praxis oftmals eine One-vs-All (OvA) bzw. One-vs-Rest (OvR) Klassifikation implementiert. In diesem Fall steht die 1 für die Erkennung einer konkreten Klasse, während alle anderen übrigen Klassen als negativ betrachtet werden.

Um jede Klasse erkennen zu können, werden n Klassifizierer (= n Perzeptron-Netze) benötigt. Jedes Perzeptron-Netz ist auf die Erkennung einer bestimmten Klasse trainiert.

Adaline – Oder: die Limitation des Perzeptrons

Das Perzeptron wird nur über eine Sprungfunktion aktiviert. Das schränkt die Feinabstimmung des Trainings enorm ein. Besser sind Aktivierungen über stetige Funktionen, die dann nämlich differenzierbar (ableitbar) sind. Das ergibt eine konvexe Fehlerfunktion mit einem eindeutigen Minimum. Der Adaline-Algorithmus (ADAptive Linear NEuron) erweitert die Idee des Perzeptrons um genau diese Idee. Der wesentliche Fortschritt der Adaline-Regel gegenüber der des Perzeptrons ist demnach, dass die Aktualisierung der Gewichtungen nicht wie beim Perzeptron auf einer einfachen Sprungfunktion, sondern auf einer linearen, stetigen Aktivierungsfunktion beruht.

Single-Layer-Adaline

Wie ein künstliches neuronales Netz mit der Kategorie Adaline trainiert werden kann, wird im nächsten Artikel dieser Artikelserie erläutert.

Weiterführende Netz-Konzepte (CNN und RNN)

Wer bereits mit Frameworks wie TensorFlow in das Deep Learning eingestiegen ist, hat möglicherweise schon erweiterte Konzepte der künstlichen neuronalen Netze kennen gelernt. Die CNNs (Convolutional Neuronal Network) sind im Moment die Wahl für die Verarbeitung von hochdimensionalen Aufgaben, beispielsweise die Bilderkennung (Computer Vision) und Texterkennung (NLP). Das CNN erweitert die Möglichkeiten mit neuronalen Netzen deutlich, indem ein Netz zur Dimensionsreduktion vorgeschaltet wird, im Kern steckt jedoch weiterhin die Idee der MLPs. Beim Einsatz in der Bilderkennung funktionieren CNNs vereinfacht gesprochen so, dass der vorgeschaltete Netzbereich die Millionen Bildpixel sektorweise ausliest (Convolution, Faltung durch Auslesen über Sektoren, die sich gegenseitig überlappen), verdichtet (Pooling, beispielsweise über nicht-lineare Funktionen wie max()) und dann – nach diesem Prozedere – ähnlich eim MLP klassifiziert.

Eine andere erweiterte Form sind RNNs (Recurrent Neuronal Network), die ebenfalls auf der Idee des MLPs basieren, dieses Konzept jedoch dank Rückverbindungen (Neuronen senden an vorherige Schichten) und Selbstverbindungen (Neuronen senden an sich selbst) wiederum auf den Kopf stellen.

Dennoch ist es für das tiefere Verständnis von CNNs und RNNs essenziell, dass vorher das Konzept des MLPs verstanden ist. Es ist die einfachste Form der auch heute noch am meisten eingesetzten und sehr mächtigen Netz-Topologien.

Im Jahr 2016 hatte Fjodor van Veen von asimovinstitute.org hatte – dankenswerterweise – mal eine Zusammenstellung von Netz-Topologien erstellt, auf die ich heute noch immer mal wieder einen Blick werfe:

Künstliche neuronale Netze – Topologie-Übersicht von Fjodor van Veen

Buchempfehlungen

Die folgenden Bücher nutze ich für mein Selbststudium von Machine Learning und Deep Learning und sind teilweise Gedankenvorlagen auch für diesen Artikel gewesen:


Machine Learning mit Python und Scikit-Learn und TensorFlow: Das umfassende Praxis-Handbuch für Data Science, Predictive Analytics und Deep Learning (mitp Professional)	Deep Learning mit Python und Keras: Das Praxis-Handbuch vom Entwickler der Keras-Bibliothek(mitp Professional)

Wieviele Trainungsbeispiele benötigen Lernverfahren? (1/2)

April 16, 2018/in Data Mining, Data Science, Data Science Hack, Machine Learning, Mathematics/by Dr. Thomas Hoppe

Kurz nach der Jahrtausendwende begann das Zeitalter der digitalen Daten. Seitdem übertrifft die Menge der digitalen Daten die der Analogen [HL11] und dem Maschinellen Lernen stehen enorme Datenmengen zur Verfügung. Unter dem Buzzword „big data“ wird dabei meist nur das reine Volumen gesehen, andere Faktoren, wie die Frequenz mit der die Daten zu verarbeiten sind und die Variabilität der Formate werden oft vernachlässigt, obwohl auch solche Daten unter „big data“ zusammengefasst werden. Betrachtet man das Volumen dann spielen zwei Faktoren eine zentrale Rolle, die das „big“ von „big data“ ausmachen: die Anzahl der Beispieldatensätze und – und dies wird häufig übersehen – die Anzahl der Eigenschaften mit denen die Beispieldaten beschrieben werden.
Wenn von „big data“ gesprochen wird, wird dabei oft angenommen, dass genügend Datensätze vorhanden sind. Für bestimmte Anwendungen jedoch, müssen die Daten in unterschiedliche Gruppen unterschieden werden, um beim Lernen nicht Äpfel und Birnen in einen Topf zu werfen. In solchen Fällen kann es leicht passieren, dass pro Gruppe zu wenig Beispieldaten vorhanden sind und die Frage an Bedeutung gewinnt: „Reichen die Datensätze eigentlich aus, um ein Vorhersagemodel mit einer gewissen Mindestgüte zu lernen?“.
Leider gibt es bisher keine einfache Antwort auf diese Frage, da diese neben der Anzahl der Eigenschaften – der Dimensionalität – der Daten, von der Struktur des Datenraums, der Verteilung der Daten in diesem Raum, dem verwendeten Lernverfahren, der Ausdrucksfähigkeit seiner Hypothesenrepräsentation und seiner endgültigen Parametrisierung abhängt. In der “Computational Learning Theory” wurden jedoch Ansätze zur Abschätzungen von Untergrenzen erarbeitet, die, unter der Annahme idealer Lernverfahren, zu mindestens eine Aussage über die benötigte Mindestmenge an Trainingsdaten gestatten.
Ziel dieses Beitrags ist es auf möglichst anschauliche Art und Weise anhand eines praktischen Beispiels zu zeigen, welchen Einfluss die Dimensionalität der Daten auf die Abschätzung der Anzahl der benötigten Beispiele für das Erlernen von Vorhersagemodellen – genauer einfachen Klassifikationsmodellen[1] – hat und welche Methoden hierfür existieren. In diesem ersten Teil liegt das Hauptaugenmerk auf endlichen Daten- und Hypothesenräumen und wir werden sehen, dass selbst für eine kleine Anzahl von Eigenschaften – sprich Dimensionen – nützliche Aussagen nur für sehr einfache Hypothesenrepräsentationen möglich sind. Im zweiten Teil werden wir einen Abschätzungsansatz betrachten, der die „Unterscheidungsstärke“ unterschiedlicher Lernverfahren berücksichtigt und mit dem auch Abschätzungen für unendliche Daten- und Hypothesenräume möglich werden.

Anwendungsbeispiel

Betrachten wir das Beispiel eines Online-Shops, der Produkte über das Internet verkauft und dessen Produkte klassifiziert werden sollen. Wie die Produkte klassifiziert werden sollen ist für unsere Betrachtungen unerheblich, was wir aber im Kopf haben sollten: der Absatz unterschiedlicher Produkte folgt einer Potenzverteilung. Eine kleine Zahl von Produkten wird sehr häufig verkauft, so dass für sie viele Datensätze existieren (solche Produkte werden gewöhnlicher Weise in konventionellen Geschäften vertrieben, die nur begrenzte Lagerkapazitäten haben). Der Großteil der Produkte wird jedoch eher seltener umgesetzt (auch als „long tail“ bezeichnet), so dass die Anzahl ihrer Datensätze gering ist; u.U. so gering, dass für sie keine verlässlichen Vorhersagemodelle erlernbar sind.

Zur Illustration gehen wir davon aus, dass in dem Online-Shop Produkte von 500 Marken verkauft werden und diese Produkte neben ihrer Marke durch ihre Größe (10 mögliche Werte), ihre Farbe (20 mögliche Werte), die ersten drei Ebenen der Google Produktkategorien (auf der dritten Ebene 500 mögliche Werte) und ihren Preis (im Bereich 0,49 – 100 €) beschrieben werden.

In diesem Kontext besitzt die Antwort auf die Frage: „Wie viele Daten werden überhaupt für ein Lernverfahren benötigt?“ offensichtlich konkreten Nutzen,

da wir abschätzen können, ob für ein konkretes Produkt überhaupt ein sinnvolles Vorhersagemodell erlernbar ist,
da wir aus der Abschätzung auf die Dauer der Datensammlung schließen können und
um ggf. die Daten von selten verkauften Produkten inhaltlich oder zeitlich zu aggregieren.

Was uns vorweg klar sein sollte

Die Daten, die wir zum Erlernen von Vorhersagemodellen verwenden, werden durch Eigenschaften (normalerweise als Feature, in der Statistik auch als Variablen bezeichnet) beschrieben. Die Eigenschaften werden in beobachtete und abhängige Eigenschaften (im Maschinellen Lernen auch als Label bezeichnet) unterschieden. Die Wertebereiche der Eigenschaften können in endliche und unendliche Wertebereich unterschieden werden.

Wir können nicht erwarten, dass ein Lernverfahren ein 100%ig korrektes Modell erlernt. Lernverfahren versuchen durch einen induktiven Schluss aus Daten ein Vorhersagemodell zu ermitteln. Da die zur Verfügung stehende Datenmenge immer begrenzt sein wird und die Daten damit realistischer Weise unvollständig sein werden, Messfehler und Inkonsistenzen enthalten können, kann auch ein erlerntes Modell niemals 100%ig korrekt sein.

Viele unterschiedliche Modelle können konsistent mit den verfügbaren Daten sein. Ziel des Lernverfahrens ist es daher mit den verfügbaren Daten das bestmögliche Vorhersagemodell zu ermitteln.

Wir müssen in Kauf nehmen, dass unbekannte, zukünftige oder ungewöhnliche Daten zu fehlerhaften Vorhersagen führen. Zum Lernzeitpunkt ist nur ein Ausschnitt aller Daten verfügbar. Zukünftig erhobene Daten können Veränderungen unterliegen oder es können bisher noch nicht gesehene Fälle auftreten, auf die das erlernte Modell nicht mehr richtig passt.

Aus diesen Fakten ergibt sich die einzig realistische Annahme: ein gutes Lernverfahren soll mit großer Wahrscheinlichkeit eine gute Näherung des richtigen Vorhersagemodells erlernen.

Anzahl benötigter Trainingsfälle

Zur Abschätzung der Anzahl benötigter Trainingsfälle – als Beispielkomplexität (sample complexity) bezeichnet – wurden in der Computational Learning Theory unterschiedliche Ansätze entwickelt. Diese Ansätze beschreiben für idealisierte Lernverfahren unter welchen Bedingungen probabilistisch, approximativ, korrektes Lernen (PAC learning) effizient möglich ist. Grundlegend für die Einsetzbarkeit dieser Ansätze ist die Unterscheidung, ob das Lernen in einem endlichen oder unendlichen Hypothesenraum erfolgt, und ob das Lernverfahren konsistente Hypothesen oder nur näherungsweise Hypothesen, z.B. beim Vorliegen von Messfehlern, zu den Daten erlernen kann.

Endliche Datenräume

Sofern die Daten nur durch nominelle Eigenschaften mit endlichen Wertebereichen beschrieben werden[2], lässt sich die Größe des Datenraums relativ einfach bestimmen. Die folgende Tabelle beschreibt für die wichtigsten nominellen Eigenschaftstypen Größenfaktoren, die im Folgenden zur vereinheitlichten Darstellung verwendet werden:

Type $t$	Fehlende Werte (NA) ?	Größe des Wertebereichs $n$	Größenfaktor $g(t)$
Boolean	Nein	2	2
Boolean	Ja	2	3
Nominal (Menge)	Nein	$n_t$	$n_t$
Nominal (Menge)	Ja	$n_t$	$n_t+1$

Die Größe eines endlichen d-dimensionalen Datenraums $D$ kann allgemein mit folgender Formel bestimmt werden $|D| = \prod_{i=1}^d{g(t_i)}$ .

Das Lernproblem besteht darin: aus einer Teilmenge von Trainingsbeispielen $S$ aus dem Datenraum $D$ , i.e. $S \subset D$ , die ein Trainer dem Lernverfahren vorgibt, um Zielkonzept c zu erlernen, eine Hypothese aus dem Hypothesenraum $h \in H$ des Lernverfahrens zu ermitteln, welche (möglichst) alle positiven Beispiel $S_p$ umfasst und (möglichst) alle negativen Beispiele $S_n$ ausschließt.

Einfache Hypothesenrepräsentation

Die einfachste Hypothesenrepräsentation, in der Lernen, welches über einfaches Erinnern hinausgeht, sinnvoll ist, sind Disjunktionen von Bool’schen Eigenschaften. Eine Beispielanwendung für die diese Repräsentation Sinn macht, ist das Erkennen von Spam-Emails anhand des Vorliegens unterschiedlicher alternativer Eigenschaften, die Spam-Emails charakterisieren. Der Hypothesenraum dieser Sprache besitzt eine Größe von $|H| = 2^d$ [FoDS18]. Ein Beispiel für ein verbreitetes Lernverfahren, das eine Hypothesenrepräsentation dieses Typs nutzt, ist Naive Bayes.

Beliebige nominelle Eigenschaften können durch One-Hot- oder Dummy-Encoding als Bool’sche Variablen kodiert werden. Damit ergibt sich zum Erlernen von Disjunktionen kodierter, Bool’scher Eigenschaften die Größe des Hypothesenraums als $|H| = 2^{\sum_{i=1}^d{g(t_i)}}$ .

Um unser Produktbeispiel in dieser Sprache zu repräsentieren, müssen die Eigenschaften geeignet kodiert werden, z.B. durch One-Hot- oder Dummy-Encoding, bei dem jeder Wert einer Eigenschaft durch eine neue bool’sche Variable kodiert wird. Hieraus ergeben sich im Fall von One-Hot-Encoding $500+10+20+500+9941=10.971$ und im Fall von Dummy-Encoding $499+9+19+499+9940=10.966$ neue Bool’sche Eigenschaften.

Eigenschaftsvektoren (Feature-Vektoren, bzw. Konjunktionen von Eigenschaften) stellen die nächstkomplexere Repräsentationssprache dar, die, solange sie nicht um ein Konstrukt zur Verallgemeinerung erweitert wird, sehr unspektakulär ist, da Beispiele mit ihr lediglich erinnert werden. Erst wenn ein „don’t care“-Symbol, wie z.B. „?“, für beliebige Eigenschaftswerte hinzugefügt wird, wird die extremste Form von Generalisierung möglich, die von einzelnen Werten gleich auf alle Werte generalisiert [ML97]. Durch das „don’t care“-Symbol wird der Größenfaktor g um einen weiteren Wert erhöht. Für diese Repräsentation beträgt die Größe des Hypothesenraums über rein bool‘schen Eigenschaften (inkl. „don’t care“) $|H| = 3^d$ und für allgemeine endliche Eigenschaften $|H| = \prod_{i=1}^d{(g(t_i)+1)}$ . Diese Repräsentation ist sehr eingeschränkt und erlaubt es nur einzelne und keine kombinierten Konzepte zu erlernen. Sie ist daher eigentlich nur von theoretischem Interesse und wird – soweit bekannt – in keinem praktisch eingesetzten Lernverfahren genutzt.

Interessanter ist eine Verallgemeinerung dieser Repräsentationssprache, die k-CNF (konjunktive Normalform), die aus einer Konjunktion von Disjunktionen der Länge k besteht, die sowohl polynomielle Beispiel- als auch Zeitkomplexität besitzt [ML97] und für die ein effizienter Algorithmus existiert. Diese Repräsentation lässt sich auch auf einen d-dimensionalen Eigenschaftsvektor übertragen, in dem für jede Eigenschaft Generalisierungen über beliebige Teilmengen erlaubt werden. Die Größe des Hypothesenraums dieser Sprache beträgt $|H| = \prod_{i=1}^d{2^{g(t_i)}} = 2^{\sum_{i=1}^d{g(t_i)}}$ . Mit dieser Sprache können alle Eigenschaften zwar separat auf beliebige Teilmengen generalisiert werden, Korrelationen zwischen Eigenschaften werden jedoch nicht berücksichtigt.

Für Repräsentationssprachen, die keinerlei Einschränkungen machen, besitzt der Hypothesenraum für Daten mit d bool‘schen Eigenschaften eine Größe von $|H| = 2^{2^d}$ . Auf beliebige endliche Eigenschaften übertragen, kann diese Aussage zu $|H| = 2^{|D|} = 2^{\prod_{i=1}^d{g(t_i)}}$ verallgemeinert werden.

Wie aus diesen Abschätzungen ersichtlich wird, hat die Dimensionalität d der Daten einen direkten Einfluss auf die Größe des Hypothesenraums und damit auf die Anzahl der von einem Lernverfahren zu berücksichtigenden Konzepte.

Realistische Hypothesenrepräsentation

Bis auf einfache Disjunktionen bool’scher Eigenschaften, sind einfache Hypothesenrepräsentationen entweder zu ausdrucksschwach, so dass nützliche Konzepte kaum ausdrückbar sind, oder zu ausdrucksstark, so dass Lernen in vertretbarer nicht-exponentieller Zeit nicht möglich ist. Die gängigen Lernverfahren, wie k-Nearest Neighbors, Naive Bayes, Decision Trees, Random Forrests, AdaBoost, XGBoost, Logistic Regression, Support Vector Machines und Neuronale Netze, etc. beschränken durch spezifische Annahmen (inductive bias) den Hypothesenraum, um so nützliche Konzepte in vernünftiger Zeit zu erlernen.

Leider lassen sich nur für wenige der real eingesetzten Verfahren Abschätzungen für die Größe des Hypothesenraums finden.

Verfahren	\|H\|	Parameter
Boolean-coded Naive Bayes	$2^{\sum_{i=1}^d{g(t_i)}}$
Boolean-coded Decision Trees[3]	$2^{\sum_{i=1}^d{g(t_i)}}$
Boolean-coded Decision Trees with limited depth [4]	$2(2^k-1)(1+log_2{⁡\sum_{i=1}^d{g(t_i)}} ) +1$	k = Tiefenbegrenzung

Lernen eines zu allen Trainingsdaten konsistenten Konzepts (aka Overfitting)

Unter der Annahme eines idealen Lernalgorithmus, kann die Größe des Hypothesenraums dazu verwendet werden die Anzahl der Trainingsdaten $m$ die ein „konsistenter Lernalgorithmus“[5] benötigt, um ein beliebiges Konzept mit einem maximalen Fehler $\epsilon$ und einer Unsicherheit $\delta$ (bzw. einer Wahrscheinlichkeit von $1 - \delta$ ) zu erlernen, abgeschätzt werden mit[6]

$m \geq \frac{1}{\epsilon}(ln{(|H|)} + ln{(\frac{1}{\delta})})$

Nehmen wir für unser Beispielszenario an Produkt A wird stündlich im Durchschnitt 100 mal verkauft und Produkt B wird jeden Tag im Schnitt nur 10 mal verkauft. Zur Vereinfachung nehmen wir weiter an, die Produkte werden jeden Tag – egal ob Wochentag oder Wochenende – nur zwischen 6:00 und 20:00 Uhr verkauft. Pro Monat erhalten wir für Produkt A 42.000 Datensätze und für Produkt B 300 Datensätze.

Der Datenraum D hat eine Größe von $|D| = 500*10*20*500*9941 \approx 497$ Mrd. Punkten. Mit einer einfachen bool’schen Kodierung ergibt sich $d = 500+10+20+500+9951 = 10.971$ und $|H| = 2^{10.961}$ .

Wollten wir Datensätze dieser Produkte mit einem Fehler $\epsilon$ von maximal 10% und einer maximalen Unsicherheit $\delta = 5%$ – wie auch immer – klassifizieren, so würden wir für den Einsatz von Naive Bayes oder unbegrenzten DecisionTrees mindestens 76.145 Datensätze benötigen. Weder die monatlichen Daten von Produkt A noch Produkt B würden ausreichen.

Mit einem tiefenbeschränkten Entscheidungsbaum-Verfahren mit 5 Stufen, sind, ungeachtet der Qualität des Lernergebnisses, die Daten von Produkt A und B ausreichend, um die Anforderungen an $\epsilon$ und $\delta$ einzuhalten, da nur mindestens 91 Datensätze benötigt werden.

Ein, dieser Abschätzung zugrundeliegender, idealer Lernalgorithmus, ist jedoch für praktische Anwendungen unrealistisch, da er zwar für die Trainingsdaten ein konsistentes Konzept ermitteln würde, welches aber bei unbekannten, neuen Daten versagen kann. Der angenommene Lernalgorithmus unterliegt der „Überanpassung“ (overfitting).

Nichts desto trotz ist diese Abschätzungsformel hilfreich, da sie eine Aussage erlaubt, wie viele Trainingsbeispiele im besten Fall ausreichen, um mit einem idealen Lernverfahren ein Konzept mit einem maximalen Fehler von $\epsilon$ und einer Unsicherheit von höchstens $\delta$ zu erlernen, das in der genutzten Hypothesenrepräsentation ausdrückbar ist.

Agnostisches Lernen eines Konzeptes, das möglichst gut zu den Trainingsdaten passt

Überanpassung wollen wir in der Regel vermeiden, damit die erlernten Vorhersagemodelle auch auf unbekannte, fehlerbehaftete oder teilweise inkonsistente Daten anwendbar sind. Anders ausgedrückt: das zu erlernende Konzept $c$ kann etwas außerhalb des Hypothesenraums liegen, der durch das eingesetzte Lernverfahren erfasst wird. Dies bedeutet, dass wir im Hypothesenraum des Lernverfahrens nur eine Näherung $c'$ erlernen können, die möglichst gut sein sollte. Solch ein – als agnostisch bezeichnetes – Lernverfahren muss daher bestrebt sein den Fehler zwischen den Trainingsdaten und dem Fehler der sich durch das Erlernen der Näherung $c'$ ergibt möglichst klein zu halten.

Auch hierfür kann, unter der Annahme eines idealen Lernalgorithmus, die Größe des Hypothesenraums dazu verwendet werden die Anzahl der Trainingsdaten $m$ die ein „agnostisches Lernverfahren“ benötigt, um eine gute Näherung an das zu erlernende Konzept in einem endlichen Hypothesenraum mit einem maximalen Fehler $\epsilon$ und einer Unsicherheit $\delta$ (bzw. einer Wahrscheinlichkeit von $1 - \delta$ ) zu erlernen, abgeschätzt werden mit[6]

$m \geq \frac{1}{2\epsilon^2}(ln{(|H|)} + ln{(\frac{2}{\delta})})$

Auf das Beispiel angewendet müsste sich – unter der Annahme gleicher Rahmenbedingungen – die Mindestzahl von Trainingsbeispielen auf m = 490 belaufen. D.h. die Daten von Produkt A könnten zum Lernen der Klassifikation verwendet werden, die Datenmenge für Produkt B wäre jedoch nicht ausreichend.

Folgerung

Mit diesem ersten Beitrag haben wir anhand eines kleinen realen Beispiels gezeigt, wie sich für einen idealen Lernalgorithmus über die Betrachtung der Größe endlicher Hypothesenräume, die Mindestanzahl der benötigten Trainingsbeispiel abschätzen lässt.

Auch wenn es sich hierbei um eine idealisierte Betrachtung handelt, erlauben solche Abschätzungen Aussagen darüber, wann Lernverfahren nur mit einem größeren Fehler behaftet einsetzbar sind.

Diese Betrachtung erstreckte sich bisher nur über endliche Eigenschaften und berücksichtigt die Komplexität der Hypothesenrepräsentation – eine der wesentlichen Eigenschaften eines Lernverfahrens – noch nicht. Dies wird Thema des zweiten Teils sein, in dem wir sehen werden, wie sich Abschätzung auf der Basis der – sogenannten – Vapnik-Chervonenkis-Dimension (VC-Dimension) für viele gängige Klassen von Lernverfahren einsetzen lassen.

Fußnoten

[1] Wir betrachten hierbei nur rein binäre, binomiale resp. Bool’sche Klassifikationsprobleme, deren Aussagen sich jedoch auch auf multinomiale Klassifikation und reell-wertige Vorhersagemodelle übertragen lassen (siehe [ESL09], Seite 238).

[2] Unendlich, überabzählbare Eigenschaften lassen sich in Abhängigkeit vom Anwendungsproblem und der erforderlichen Genauigkeit oft diskretisieren und als ordinale Daten oder Intervalle ganzer Zahlen repräsentieren, wie z.B. Alter, Körpergröße, Längen, Temperatur, und Zeitintervalle usw., wenn es ausreichend ist diese mit einer Genauigkeit von Jahren, cm, mm, Zehntelgrad oder Sekunden zu erfassen.

[3] Vollausgebaute Decision Trees unterliegen der Gefahr der „Überanpassung“ (overfitting) und werden in der Regel gestutzt, um dies zu vermeiden. Die Abschätzung stellt daher die Obergrenze dar.

[4] http://www.cs.cmu.edu/~guestrin/Class/10701/slides/learningtheory-bigpicture.pdf und https://www.autonlab.org/_media/tutorials/pac05.pdf (Letzter Zugriff: 10.3.2018)

[5] Ein „konsistenter Lernalgorithmus“ erlernt Hypothesen, die – wann immer möglich – perfekt zu den Trainingsdaten passen [ML97].

[6] Details zur Ableitung der beschriebenen Untergrenzen finden sich u.a. in [ML97], [FoML12] oder [FoDS18].

Referenzen

[HL11] „The World’s Technological Capacity to Store, Communicate, and Compute Information“, M. Hilbert, P. López, Science 332, 60, 2011, http://www.uvm.edu/pdodds/files/papers/others/2011/hilbert2011a.pdf (letzter Zugriff: 14. März 2018)

[ESL09] “The Elements of Statistical Learning”, T. Hastie, R. Tibshirani, J. Friedman, 2^nd Edition, Springer, 2009.

[ML97] „Machine Learning“, T. Mitchell, McGraw-Hill, 1997.

[FoML12] „Foundations of Machine Learning“, M. Mohri, A. Rostamizadeh, A. Talwalkar, The MIT Press, 2012.

[FoDS18] „Foundations of Data Science“, A. Blum, J. Hopcroft, R. Kannan, Cornell University, https://www.cs.cornell.edu/jeh/book.pdf, Jan. 4^th, 2018 (letzter Zugriff: 14. März 2018)

Einstieg in Deep Learning – Artikelserie

March 1, 2018/in Artificial Intelligence, Books, Data Mining, Data Science, Deep Learning, Machine Learning, Mathematics/by Benjamin Aunkofer

Deep Learning gilt als ein Teilgebiet des maschinellen Lernens (Machine Learning), welches wiederum ein Teilgebiet der künstlichen Intelligenz (Artificial Intelligence) ist. Machine Learning umfasst alle (teilweise äußerst unterschiedliche) Methoden der Klassifikation oder Regression, die die Maschine über ein vom Menschen begleitetes Training selbst erlernt. Darüber hinaus umfasst Machine Learning auch unüberwachte Methoden zum Data Mining in besonders großen und vielfältigen Datenmengen.

Deep Learning ist eine Unterform des maschinellen Lernens und macht im Grunde nichts anderes: Es geht um antrainierte Klassifikation oder Regression. Seltener werden Deep Learning Algorithmen auch als unüberwachter Lernenmechanismus verwendet, zum Lernen von Rauschen zur Erkennung von Mustern (Data Mining). Deep Learning bezeichnet den Einsatz von künstlichen neuronalen Netzen, die gegenüber anderen Verfahren des maschinellen Lernens häufig überlegen sind und diesen gegenüber auch andere Vor- und Nachteile besitzen.

Im Rahmen dieser Artikelserie erscheinen im Laufe der kommenden Monate folgende Artikel:

Machine Learning vs Deep Learning – Wo liegt der Unterschied?
Funktionsweise künstlicher neuronaler Netze
Training eines Neurons mit dem Gradientenverfahren
Fehler-Rückführung mit der Backpropagation
Künstliches neuronales Netz in Python (erscheint demnächst)
Künstliches neuronales Netz mit dem TensorFlow-Framework (erscheint demnächst)

Buchempfehlungen

Seit 2016 arbeite ich mich in Deep Learning ein und biete auch Seminare und Workshops zu Machine Learning und Deep Learning an, dafür habe ich eine ausführliche Einarbeitung und ein immer wieder neu auflebendes Literaturstudium hinter mir. Unter Anderen habe ich folgende Bücher für mein Selbststudium verwendet und nutze ich auch Auszugsweise für meine Lehre:

Praxiseinstieg Machine Learning mit Scikit-Learn und TensorFlow: Konzepte, Tools und Techniken für intelligente Systeme (Animals)	Neuronale Netze selbst programmieren: Ein verständlicher Einstieg mit Python
Praxiseinstieg Deep Learning: Mit Python, Caffe, TensorFlow und Spark eigene Deep-Learning-Anwendungen erstellen	Machine Learning mit Python und Scikit-Learn und TensorFlow: Das umfassende Praxis-Handbuch für Data Science, Predictive Analytics und Deep Learning (mitp Professional)

Maschinelles Lernen: Klassifikation vs Regression

December 20, 2017/in Artificial Intelligence, Business Analytics, Data Mining, Data Science, Deep Learning, Machine Learning, Main Category, Mathematics, Predictive Analytics/by Benjamin Aunkofer

Das ist Artikel 2 von 4 aus der Artikelserie – Was ist eigentlich Machine Learning? Die Unterscheidung zwischen Klassifikation und Regression ist ein wichtiger Schritt für das Verständnis von Predictive Analytics. Nun möchte ich eine Erklärung liefern, die den Unterschied (hoffentlich) deutlich macht.

Regression – Die Vorhersage von stetigen Werten

Wir suchen bei der Regression demnach eine Funktion $y = \beta \cdot x + \alpha$ , die unsere Punktwolke – mit der wir uns zutrauen, Vorhersagen über die abhängige Variable vornehmen zu können – möglichst gut beschreibt. Dabei ist $y$ der Zielwert (abhängige Variable) und $x$ der Eingabewert. Wir arbeiten also in einer zwei-dimensionalen Welt. Variablen, die die Funktion mathematisch definieren, werden oft als griechische Buchstaben darsgestellt. Die Variable $\alpha$ (Alpha) ist der $y$ -Achsenschnitt bei $x = 0$ . Dieser wird als Bias, selten auch als Default-Wert, bezeichnet. Der Bias ist also der Wert, wenn die $x$ -Eingabe gleich Null ist. Eine weitere Variable $\beta$ (Beta) beschreibt die Steigung.

Ferner ist zu beachten, dass sich eine Punktwolke durch eine Gerade nie perfekt beschreiben lässt, und daher für jedes $x_{i}$ ein Fehler $\varepsilon_{i}$ existiert. Diesen Fehler wollen wir in diesem Artikel ignorieren.

In einem zwei-dimensionalen System (eine Eingabe und eine Ausgabe) sprechen wir von einer einfachen Regression. Generalisieren wir die Regressionsmethode auf ein multivariates System (mehr als eine Eingabe-Variable), werden die Variablen in der Regel nicht mehr als griechische Buchstaben (denn auch das griechische Alphabet ist endlich) dargestellt, sondern wir nehmen eines abstrahierende Darstellung über Gewichtungen (weights). Dies ist eine sehr treffende Symbolisierungen, denn sowohl der Bias ( $w_{0}$ statt $\alpha$ ) als auch die Steigungen ( $w_{1\ldots n}$ ) sind nichts anderes als Gewichtungen zwischen den Eingaben.

$y = w_{0} \cdot x_{0} + w_{1} \cdot x_{1} + \ldots + w_{n} \cdot x_{n}$

$y$ ist eine Summe aus den jeweiligen Produkten aus $x_{i}$ und $w_{i}$ . Verkürzt ausgedrückt:

$y = \sum_{i=0}^n w_{i} \cdot x_{i}$

Noch kürzer ausgedrückt:

$y = w^T \cdot x$

Anmerkung: Das hochgestellte T steht für Transponieren, eine Notation aus der linearen Algebra, die im Ergebnis nichts anderes bewirkt als $y = \sum_{i=0}^n w_{i} \cdot x_{i}$ .

Diese mathematische lineare Funktion kann wie folgt abgebildet werden:

Der Output ist gleich $y$ bzw. die Ausgabe der Nettoeingabe (Net Sum) $w^T \cdot x$ . Auf der linken Seite finden wir alle Eingabewerte, wobei der erste Wert statisch mit 1.0 belegt ist, nur für den Zweck, den Bias ( $w_{0}$ ) in der Nettoeingabe aufrecht zu erhalten. Im Falle einer einfachen linearen Regression hätten wir also eine Funktion mit zwei Gewichten: $y = 1 \cdot w_{0} + x \cdot w_{1}$

Das Modell beschreibt, wie aus einer Reihe von Eingabewerten (n = Anzahl an x-Dimensionen) und einer Reihe von Gewichtungen (n + 1) eine Funktion entsteht, die einen y-Wert berechnet. Diese Berechnung wird auch als Forward-Propagation bezeichnet.
Doch welche Werte brauchen wir für die Gewichtungen, damit bei gegebenen x-Werten ein (mehr oder weniger) korrekter y-Wert berechnet wird? Anders gefragt, wie schaffen wir es, dass die Forward-Propagation die richtigen Werte ausspuckt?

Mit einem Training via Backpropagation!

Einfache Erklärung der Backpropagation

Die Backpropagation ist ein Optimierungsverfahren, unter Einsatz der Gradientenmethode, den Fehler einer Forward-Propagation zu berechnen und die Gewichtungen in Gegenrichtung des Fehlers anzupassen. Optimiert wird in der Form, dass der Fehler minimiert wird. Es ist ein iteratives Verfahren, bei dem mit jedem Iterationsschritt wieder eine Forward-Propagation auf Basis von Trainingsdaten durchgeführt wird und die Prädiktionsergebnisse mit den vorgegebenen Ergebnissen (der gekennzeichneten Trainingsdaten) verglichen und damit die Fehler berechnet werden. Die resultierende Fehlerfunktion ist konvex, ableitbar und hat ein zentrales globales Minimum. Dieses Minimum finden wir durch diese iterative Vorgehensweise.

Die Backpropagation zu erklären, erfordert einen separaten Artikel. Merken wir uns einfach: Die Backpropagation nutzt eine Fehlerfunktion, um die Werte der Gewichtungen schrittweise entgegen des Fehlers (bei jeder Forward-Propagation) bis zu einem Punkt anzupassen, bis keine wesentliche Verbesserung (Reduzierung des Fehlers) mehr eintritt. Nach dem Vollzug der Backpropagation erhalten wir die “richtigen” Gewichtungen und haben eine Funktion zur Vorhersage von y-Werten bei Eingabe neuer x-Werte.

Klassifikation – Die Vorhersage von Gruppenzugehörigkeiten

Bei der Klassifikation möchten wir jedoch keine Gerade oder Kurve vorhersagen, die sich durch eine Punktwolke legt, sondern wie möchten Punktwolken voneinander als Klassen unterscheiden, um später hinzukommende Punkte ihren richtigen Klassen zuweisen zu können (Klassifikation). Wir können jedoch auf dem vorherigen Modell der Prädiktion von stetigen Werten aufbauen und auch die Backpropagation zum Training einsetzen, möchten das Training dann jedoch auf die Trennung der Punktwolken ausrichten.

Hinweis: Regressions- und Klassifikationsherausforderungen werden in den Dimensionen unterschiedlich dargestellt. Zur Veranschaulichung: Während wir bei der einfachen Regression eine x-Eingabe als unabhängige Variable und eine y-Ausgabe als abhängige Variable haben, haben wir bei einer zwei-dimensionalen Klassifikation zwei x-Dimensionen als Eingabe. Die Klassen sind die y-Ausgabe (hier als Farben visualisiert).

Ergänzen wir das Modell nun um eine Aktivierungsfunktion, dass die stetigen Werte der Nettosumme über eine Funktion in Klassen unterteilt, erhalten wir einen Klassifikator: Den Perceptron-Klassifikator. Das Perzeptron gilt als der einfachste Klassifikator und ist bereits die kleinste Form eines künstlichen neuronalen Netzes. Es funktioniert nur bei linearer Trennbarkeit der Klassen.

Was soll die Aktivierungsfunktion bewirken? Wir berechnen wieder eine Nettoeingabe $w^T \cdot x$ , die uns stetige Werte ausgiebt. Wir haben also immer noch unsere Gewichtungen, die wir trainieren können. Nun trainieren wir nur nicht auf eine “korrekte” stetige Ausgabe der Nettoeingabe hin, sondern auf eine korrekte Ausgabe der Aktivierungsfunktion $\phi$ (Phi), die uns die stetigen Werte der Nettoeingabe in einen binären Wert (z. B. 0 oder 1) umwandelt. Das Perzeptron ist die kleinste Form des künstlichen neuronalen Netzes und funktioniert wie der lineare Regressor, jedoch ergänzt um eine Aktivierungsfunktion die bewirken soll, dass ein Neuron (hier: der einzelne Output) “feuert” oder nicht “feuert”. Es ist ein binärer Klassifikator, der beispielsweise die Wertebereiche -1 oder +1 annehmen kann.

Das Perceptron verwendet die einfachste Form der Aktivierungsfunktion: Eine Sprungfunktion, die einer einfachen if… else… Anweisung gleich kommt.

$y = \phi(w^T \cdot x) = \left\{ \begin{array}{12} 1 & w^T \cdot x > 0\\ -1 & \text{otherwise} \end{array}$

Fazit – Unterschied zwischen Klassifikation und Regression

Mathematisch müssen sich Regression und Klassifikation gar nicht all zu sehr voneinander unterscheiden. Viele Verfahren der Klassifikation lassen sich mit nur wenig Anpassung auch zur Regression anwenden, oder umgekehrt. Künstliche neuronale Netze, k-nächste-Nachbarn und Entscheidungsbäume sind gute Beispiele, die in der Praxis sowohl für Klassifkation als auch für Regression eingesetzt werden, natürlich mit unterschiedlichen Stärken und Schwächen.

Unterschiedlich ist jedoch der Zweck der Anwendung: Bei der Regression möchten wir stetige Werte vorhersagen (z. B. Temperatur der Maschine), bei der Klassifikation hingegen Klassen unterscheiden (z. B. Maschine überhitzt oder überhitzt nicht).

Unterschiede zwischen linearer und nicht-linearer Klassifikation und linearer und nicht-linearer Regression. Für Einsteiger in diese Thematik ist beachten, dass jede maschinell erlernte Klassifikation und Regression einen gewissen Fehler hat, der unter Betrachtung der Trainings- und Testdaten zu minimieren ist, jedoch nie ganz verschwindet.

Und Clustering?

Clustering ist eine Disziplin des unüberwachten Lernens, um Gruppen von Klassen bzw. Grenzen dieser Klassen innerhalb von unbekannten Daten zu finden. Es ist im Prinzip eine untrainierte Klassifikation zum Zwecke des Data Minings. Clustering gehört auch zum maschinellen Lernen, ist aber kein Predictive Analytics. Da keine – mit dem gewünschten Ergebnis vorliegende – Trainingsdaten vorliegen, kann auch kein Training über eine Backpropagation erfolgen. Clustering ist folglich eine schwache Klassifikation, die mit den trainingsbasierten Klassifikationsverfahren nicht funktioniert.

Machine Learning mit Python – Minimalbeispiel

April 26, 2016/in Artificial Intelligence, Data Mining, Data Science Hack, Machine Learning, Mathematics, optimization, Predictive Analytics, Python, Tutorial, Visualization/by Benjamin Aunkofer

Maschinelles Lernen (Machine Learning) ist eine Gebiet der Künstlichen Intelligenz (KI, bzw. AI von Artificial Intelligence) und der größte Innovations- und Technologietreiber dieser Jahre. In allen Trendthemen – wie etwa Industrie 4.0 oder das vernetzte und selbstfahrende Auto – spielt die KI eine übergeordnete Rolle. Beispielsweise werden in Unternehmen viele Prozesse automatisiert und auch Entscheidungen auf operativer Ebene von einer KI getroffen, zum Beispiel in der Disposition (automatisierte Warenbestellungen) oder beim Festsetzen von Verkaufspreisen.

Aufsehen erregte Google mit seiner KI namens AlphaGo, einem Algortihmus, der den Weltmeister im Go-Spiel in vier von fünf Spielen besiegt hatte. Das Spiel Go entstand vor mehr als 2.500 Jahren in China und ist auch heute noch in China und anderen asiatischen Ländern ein alltägliches Gesellschaftsspiel. Es wird teilweise mit dem westlichen Schach verglichen, ist jedoch einfacher und komplexer zugleich (warum? das wird im Google Blog erläutert). Machine Learning kann mit einer Vielzahl von Methoden umgesetzt werden, werden diese Methoden sinnvoll miteinander kombiniert, können durchaus äußerst komplexe KIs erreicht werden. Der aktuell noch gängigste Anwendungsfall für Machine Learning ist im eCommerce zu finden und den meisten Menschen als die Produktvorschläge von Amazon.com bekannt: Empfehlungsdienste (Recommender System).

Klassifikation via K-Nearest Neighbour Algorithmus

Ein häufiger Zweck des maschinellen Lernens ist, technisch gesehen, die Klassifikation von Daten in Abhängigkeit von anderen Daten. Es gibt mehrere ML-Algorithmen, die eine Klassifikation ermöglichen, die wohl bekannteste Methode ist der k-Nearest-Neighbor-Algorithmus (Deutsch:„k-nächste-Nachbarn”), häufig mit “kNN” abgekürzt. Das von mir interviewte FinTech StartUp Number26 nutzt diese Methodik beispielsweise zur Klassifizierung von Finanztransaktionen.

Um den Algorithmus Schritt für Schritt aufbauen zu können, müssen wir uns

Natürlich gibt es in Python, R und anderen Programmiersprachen bereits fertige Bibliotheken, die kNN bereits anbieten, denen quasi nur Matrizen übergeben werden müssen. Am bekanntesten ist wohl die scikit-learn Bibliothek für Python, die mehrere Nächste-Nachbarn-Modelle umfasst. Mit diesem Minimalbeispiel wollen wir den grundlegenden Algorithmus von Grund auf erlernen. Wir wollen also nicht nur machen, sondern auch verstehen.

Vorab: Verwendete Bibliotheken

Um den nachstehenden Python-Code (Python 3.x, sollte allerdings auch mit Python 2.7 problemlos funktionieren) ausführen zu können, müssen folgende Bibliotheken eingebunden werden:

import numpy as numpy
import matplotlib.pyplot as pyplot
from mpl_toolkits.mplot3d import Axes3D #Erweiterung für die Matplotlib - siehe: http://matplotlib.org/mpl_toolkits/

Übrigens: Eine Auflistung der wohl wichtigsten Pyhton-Bibliotheken für Datenanalyse und Datenvisualisierung schrieb ich bereits hier.

Schritt 1 – Daten betrachten und Merkmale erkennen

Der erste Schritt ist tatsächlich der aller wichtigste, denn erst wenn der Data Scientist verstanden hat, mit welchen Daten er es zu tun hat, kann er die richtigen Entscheidungen treffen, wie ein Algorithmus richtig abgestimmt werden kann und ob er für diese Daten überhaupt der richtige ist.

In der Realität haben wir es oft mit vielen verteilten Daten zu tun, in diesem Minimalbeispiel haben wir es deutlich einfacher: Der Beispiel-Datensatz enthält Informationen über Immobilien über vier Spalten.

Quadratmeter: Größe der nutzbaren Fläche der Immobilie in der Einheit m²
Wandhoehe: Höhe zwischen Fußboden und Decke innerhalb der Immobilie in der Einheit m
IA_Ratio: Verhältnis zwischen Innen- und Außenflächen (z. B. Balkon, Garten)
Kategorie: Enthält eine Klassifizierung der Immobilie als “Haus”, “Wohnung” und “Büro”

[box]Hinweis für Python-Einsteiger: Die Numpy-Matrix ist speziell für Matrizen-Kalkulationen entwickelt. Kopfzeilen oder das Speichern von String-Werten sind für diese Datenstruktur nicht vorgesehen![/box]

def readDataSet(filename):

    fr = open(filename)                 # Datei-Stream vorbereiten

    numberOfLines = len(fr.readlines()) # Anzahl der Zeilen ermitteln

    returnMat = numpy.zeros((numberOfLines-1,3)) # Eine Numpy-Matrix in Höhe der Zeilenanzahl (minus Kopfzeile) und in Breite der drei Merkmal-Spalten

    classLabelVector = [] # Hier werden die tatsächlichen Kategorien (Haus, Wohnung, Büro) vermerkt
    classColorVector = [] # Hier werden die Kategorien über Farben vermerkt (zur späteren Unterscheidung im 3D-Plot!)
    
    #print(returnMat)   # Ggf. mal die noch die ausge-null-te Matrix anzeigen lassen (bei Python 2.7: die Klammern weglassen!)
    
    fr = open(filename) # Datei-Stream öffnen
    index = 0
    
    for line in fr.readlines():  # Zeile für Zeile der Datei lesen
        if index != 0:           # Kopfzeile überspringen
            line = line.strip()
            listFromLine = line.split('\t') # Jede Zeile wird zur temporären Liste (Tabulator als Trennzeichen)

            returnMat[index-1,:] = listFromLine[1:4] #Liste in die entsprechende Zeile der Matrix überführen
            
            classLabel = listFromLine[4]  # Kategorie (Haus, Wohnung, Büro) für diese Zeile merken
            
            if classLabel == "Buero":
                color = 'yellow'
            elif classLabel == "Wohnung":
                color = 'red'
            else:
                color = 'blue'
                        
            classLabelVector.append(classLabel) # Kategorie (Haus, Wohnung, Büro) als Text-Label speichern
            classColorVector.append(color)      # Kategorie als Farbe speichern (Büro = gelb, Wohnung = rot, Haus = Blau)
        
        index += 1


return returnMat,classLabelVector, classColorVector

Aufgerufen wird diese Funktion dann so:

dataSet, classLabelVector, classColorVector = readDataSet("K-Nearst_Neighbour-DataSet.txt")

Die Matrix mit den drei Spalten (Quadratmeter, Wandhohe, IA_Ratio) landen in der Variable “dataSet”.

Schritt 2 – Merkmale im Verhältnis zueinander perspektivisch betrachten

Für diesen Anwendungsfall soll eine Klassifizierung (und gewissermaßen die Vorhersage) erfolgen, zu welcher Immobilien-Kategorie ein einzelner Datensatz gehört. Im Beispieldatensatz befinden sich vier Merkmale: drei Metriken und eine Kategorie (Wohnung, Büro oder Haus). Es stellt sich zunächst die Frage, wie diese Merkmale zueinander stehen. Gute Ideen der Datenvisualisierung helfen hier fast immer weiter. Die gängigsten 2D-Visualisierungen in Python wurden von mir bereits hier zusammengefasst.

[box]Hinweis: In der Praxis sind es selten nur drei Dimensionen, mit denen Machine Learning betrieben wird. Das Feature-Engineering, also die Suche nach den richtigen Features in verteilten Datenquellen, macht einen wesentlichen Teil der Arbeit eines Data Scientists aus – wie auch beispielsweise Chief Data Scientist Klaas Bollhoefer (siehe Interview) bestätigt.[/box]

fig = pyplot.figure()
ax = fig.add_subplot(111)
ax.scatter(dataSet[:,0], dataSet[:,1], marker='o', color=classColorVector)
ax.set_xlabel("Raumflaeche in Quadratmeter")
ax.set_ylabel("Wandhohe")
ax.set_xlim(xmin=0)
ax.set_ylim(ymin=0)
pyplot.show()

fig = pyplot.figure()
ax = fig.add_subplot(111)
ax.scatter(dataSet[:,0], dataSet[:,2], marker='o', color=classColorVector)
ax.set_xlabel("Raumflaeche in Quadratmeter")
ax.set_ylabel("IA_Ratio")
ax.set_xlim(xmin=0)
ax.set_ylim(ymin=0)
pyplot.show()

Die beiden Scatter-Plots zeigen, das Häuser (blau) in allen Dimensionen die größte Varianz haben. Büros (gelb) können größer und höher ausfallen, als Wohnungen (rot), haben dafür jedoch tendenziell ein kleineres IA_Ratio. Könnten die Kategorien (blau, gelb, rot) durch das Verhältnis innerhalb von einem der beiden Dimensionspaaren in dem zwei dimensionalen Raum exakt voneinander abgegrenzt werden, könnten wir hier stoppen und bräuchten auch keinen kNN-Algorithmus mehr. Da wir jedoch einen großen Überschneidungsbereich in beiden Dimensionspaaren haben (und auch Wandfläche zu IA_Ratio sieht nicht besser aus),

Eine 3D-Visualisierung eignet sich besonders gut, einen Überblick über die Verhältnisse zwischen den drei Metriken zu erhalten: (die Werte wurden hier bereits normalisiert, liegen also zwischen 0,00 und 1,00)

fig = pyplot.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(dataSet[:,0], dataSet[:,2], dataSet[:,1], marker='o', color=classColorVector)
ax.set_xlabel("Raumflaeche in Quadratmeter")
ax.set_ylabel("IA_Ratio")
ax.set_zlabel("Wandhoehe in Meter")
ax.set_xlim(xmin=0)
ax.set_ylim(ymin=0)
ax.set_zlim(zmin=0)
pyplot.show()

Es zeigt sich gerade in der 3D-Ansicht recht deutlich, dass sich Büros und Wohnungen zum nicht unwesentlichen Teil überschneiden und hier jeder Algorithmus mit der Klassifikation in Probleme geraten wird, wenn uns wirklich nur diese drei Dimensionen zur Verfügung stehen.

Schritt 3 – Kalkulation der Distanzen zwischen den einzelnen Punkten

Bei der Berechnung der Distanz in einem Raum hilft uns der Satz des Pythagoras weiter. Die zu überbrückende Distanz, um von A nach B zu gelangen, lässt sich einfach berechnen, wenn man entlang der Raumdimensionen Katheten aufspannt.

$c = \sqrt{a^2+ b^2}$

Die Hypotenuse im Raum stellt die Distanz dar und berechnet sich aus der Wurzel aus der Summe der beiden Katheten im Quadrat. Die beiden Katheten bilden sich aus der Differenz der Punktwerte (q, p) in ihrer jeweiligen Dimension.Bei mehreren Dimensionen gilt der Satz entsprechend:

$Distanz = \sqrt{(q_1-p_1)^2+(q_2-p_2)^2+…+(q_n-p_n)^2}$

Um mit den unterschiedlichen Werte besser in ihrer Relation zu sehen, sollten sie einer Normalisierung unterzogen werden. Dabei werden alle Werte einer Dimension einem Bereich zwischen 0.00 und 1.00 zugeordnet, wobei 0.00 stets das Minimum und 1.00 das Maximum darstellt.

$NormWert = \frac{Wert - Min}{Wertspanne} = \frac{Wert - Min}{Max - Min}$

def normalizeDataSet(dataSet):
    
    dataSet_n = numpy.zeros(numpy.shape(dataSet))     #[[ 0. 0. 0.]
                                                      # [ 0. 0. 0.]
                                                      # [ 0. 0. 0.]
                                                      # ..., 
                                                      # [ 0. 0. 0.]
                                                      # [ 0. 0. 0.]
                                                      # [ 0. 0. 0.]]
    
    minValues = dataSet.min(0)                        # [ 10. 2.6 0.]
    ranges = dataSet.max(0) - dataSet.min(0)          # [ 1775. 2.4 68.]
    
    minValues = dataSet.min(0)                        # [ 10. 2.6 0.]
    maxValues = dataSet.max(0)                        # [ 1785. 5. 68.]
 
    ranges = maxValues - minValues                    # [ 1775. 2.4 68.]
 
    rowCount = dataSet.shape[0]                       # 1039 
    
    # numpy.tile() wiederholt Sequenzen (hier:  [[ 10. 2.6 0. ], ..., [ 10. 2.6 0. ]]

    dataSet_n = dataSet - numpy.tile(minValues, (rowCount, 1))  #[[ 2.56000000e+02 9.00000000e-01 1.80000000e+01]
                                                                # [ 6.60000000e+01 2.00000000e-01 5.40000000e+01]
                                                                # [ 3.32000000e+02 1.50000000e-01 1.00000000e+01]
                                                                # ..., 
                                                                # [ 1.58000000e+02 6.00000000e-01 0.00000000e+00]
                                                                # [ 5.70000000e+01 1.00000000e-01 5.20000000e+01]
                                                                # [ 1.68000000e+02 2.00000000e-01 0.00000000e+00]]

    dataSet_n = dataSet_n / numpy.tile(ranges, (rowCount, 1))   #[[ 0.14422535 0.375 0.26470588]
                                                                # [ 0.0371831 0.08333333 0.79411765]
                                                                # [ 0.18704225 0.0625 0.14705882]
                                                                # ..., 
                                                                # [ 0.08901408 0.25 0.]
                                                                # [ 0.03211268 0.04166667 0.76470588]
                                                                # [ 0.09464789 0.08333333 0.]]

    #print(dataSet_n)
        
    return dataSet_n, ranges, minValues

Die Funktion kann folgendermaßen aufgerufen werden:

dataSet_n, ranges, minValues = normalizeDataSet(dataSet)

Schritt 4 & 5 – Klassifikation durch Eingrenzung auf k-nächste Nachbarn

Die Klassifikation erfolgt durch die Kalkulation entsprechend der zuvor beschriebenen Formel für die Distanzen in einem mehrdimensionalen Raum, durch Eingrenzung über die Anzahl an k Nachbarn und Sortierung über die berechneten Distanzen.

def classify(inX, dataSet, labels, k):

    rowCount = dataSet.shape[0]              # Anzahl an Zeilen bestimmen

    diffMat = numpy.tile(inX, (rowCount,1)) - dataSet # Berechnung der Katheten 
                                                      # (über tile() wird der Eingangsdatensatz über die Zeilenanzahl des dataSet vervielfacht,
                                                      # der dataSet davon substrahiert)
 
    sqDiffMat = diffMat**2                   # Quadrat der Katheten
    sqDistances = sqDiffMat.sum(axis=1)      # Aufsummieren der Differenzpaare
    distances = sqDistances**0.5             # Quadratwurzel über alle Werte
    sortedDistIndicies = distances.argsort() # Aufsteigende Sortierung
    
    classCount = {}
    
    #print("inX = %s, k = %s" % (inX, k))
    #print(sortedDistIndicies)
    
    for i in range(k):                                        # Eingrenzung auf k-Werte in der sortierten Liste 
        closest = labels[sortedDistIndicies[i]]               # Label (Kategorie [Büro, Wohnung, Haus] entsprechend der Sortierung aufnehmen
        classCount[closest] = classCount.get(closest, 0) + 1  # Aufbau eines Dictionary über die 
    
    sortedClassCount = sorted(classCount, key = classCount.get, reverse=True) # Absteigende Sortierung der gesammelten Labels in k-Reichweite
                                                                              # wobei die Sortierung über den Count (Value) erfolgt
    
    #print(classCount)       
    #print(sortedClassCount[0])
    
    return sortedClassCount[0]   # Liefere das erste Label zurück 
                                 # also das Label mit der höchsten Anzahl innerhalb der k-Reichweite

Über folgenden Code rufen wir die Klassifikations-Funktion auf und legen die k-Eingrenzung fest, nebenbei werden Fehler gezählt und ausgewertet. Hier werden der Reihe nach die ersten 30 Zeilen verarbeitet:

 errorCount = 0
    
 k = 5                             # k-Eingrenzung (hier: auf 5 Nachbarn einschränken)

 rowCount = dataSet_n.shape[0]     # Anzahl der Zeilen im gesamten Datensatz
 
 numTestVectors = 30               # Datensätze 0 - 29 werden zum testen von k verwendet,
                                   # die Datensätze ab Zeile 30 werden zur Klassifikation verwendet
 
 for i in range(0, numTestVectors): # Aufruf des Klassifikators von 0 bis 29 
    
    result = classify(dataSet_n[i,:], dataSet_n[numTestVectors:rowCount,:], classLabelVector[numTestVectors:rowCount], k)
    
    print("%s - the classifier came back with: %s, the real answer is: %s" %(i, result, classLabelVector[i]))
 
    if (result != classLabelVector[i]):
       errorCount += 1.0

 print("Error Count: %d" % errorCount)

Nur 30 Testdatensätze auszuwählen ist eigentlich viel zu knapp bemessen und hier nur der Übersichtlichkeit geschuldet. Besser ist für dieses Beispiel die Auswahl von 100 bis 300 Datensätzen. Die Ergebnisse sind aber bereits recht ordentlich, allerdings fällt dem Algorithmus – wie erwartet – noch die Unterscheidung zwischen Wohnungen und Büros recht schwer.

0 – klassifiziert wurde: Buero, richtige Antwort: Buero
1 – klassifiziert wurde: Wohnung, richtige Antwort: Wohnung
2 – klassifiziert wurde: Buero, richtige Antwort: Buero
3 – klassifiziert wurde: Buero, richtige Antwort: Buero
4 – klassifiziert wurde: Wohnung, richtige Antwort: Wohnung
5 – klassifiziert wurde: Wohnung, richtige Antwort: Wohnung
6 – klassifiziert wurde: Wohnung, richtige Antwort: Wohnung
7 – klassifiziert wurde: Wohnung, richtige Antwort: Buero
8 – klassifiziert wurde: Wohnung, richtige Antwort: Wohnung
9 – klassifiziert wurde: Wohnung, richtige Antwort: Wohnung
10 – klassifiziert wurde: Wohnung, richtige Antwort: Wohnung
11 – klassifiziert wurde: Wohnung, richtige Antwort: Wohnung
12 – klassifiziert wurde: Buero, richtige Antwort: Buero
13 – klassifiziert wurde: Wohnung, richtige Antwort: Buero
14 – klassifiziert wurde: Wohnung, richtige Antwort: Wohnung
15 – klassifiziert wurde: Wohnung, richtige Antwort: Wohnung
16 – klassifiziert wurde: Buero, richtige Antwort: Buero
17 – klassifiziert wurde: Wohnung, richtige Antwort: Wohnung
18 – klassifiziert wurde: Haus, richtige Antwort: Haus
19 – klassifiziert wurde: Wohnung, richtige Antwort: Wohnung
20 – klassifiziert wurde: Wohnung, richtige Antwort: Wohnung
21 – klassifiziert wurde: Buero, richtige Antwort: Buero
22 – klassifiziert wurde: Buero, richtige Antwort: Buero
23 – klassifiziert wurde: Buero, richtige Antwort: Buero
24 – klassifiziert wurde: Wohnung, richtige Antwort: Wohnung
25 – klassifiziert wurde: Wohnung, richtige Antwort: Wohnung
26 – klassifiziert wurde: Wohnung, richtige Antwort: Wohnung
27 – klassifiziert wurde: Wohnung, richtige Antwort: Wohnung
28 – klassifiziert wurde: Wohnung, richtige Antwort: Wohnung
29 – klassifiziert wurde: Buero, richtige Antwort: Buero
Error Count: 2

Über weitere Tests wird deutlich, dass k nicht zu niedrig und auch nicht zu hoch gesetzt werden darf.

Datensätze	k	Fehler
150	1	25
150	3	23
150	5	21
150	20	26

Ein nächster Schritt wäre die Entwicklung eines Trainingprogramms, dass die optimale Konfiguration (k-Eingrenzung, Gewichtung usw.) ermittelt.

Fehlerraten herabsenken

Die Fehlerquote ist im Grunde niemals ganz auf Null herabsenkbar, sonst haben wir kein maschinelles Lernen mehr, sondern könnten auch feste Regeln ausmachen, die wir nur noch einprogrammieren (hard-coding) müssten. Wer lernt, macht auch Fehler! Dennoch ist eine Fehlerquote von 10% einfach zu viel für die meisten Anwendungsfälle. Was kann man hier tun?

Den Algorithmus verbessern (z. B. optimale k-Konfiguration und Gewichtung finden)
mehr Merkmale finden (= mehr Dimensionen)
mehr Daten hinzuziehen (gut möglich, dass alleine dadurch z. B. Wohnungen und Büros besser unterscheidbar werden)
einen anderen Algorithmus probieren (kNN ist längst nicht für alle Anwendungen ideal!)

Das Problem mit den Dimensionen

Theoretisch kann kNN mit undenklich vielen Dimensionen arbeiten, allerdings steigt der Rechenaufwand damit auch ins unermessliche. Der k-nächste-Nachbar-Algorithmus ist auf viele Daten und Dimensionen angewendet recht rechenintensiv.

In der Praxis hat nicht jedes Merkmal die gleiche Tragweite in ihrer Bedeutung für die Klassifikation und mit jeder weiteren Dimension steigt auch die Fehleranfälligkeit, insbesondere durch Datenfehler (Rauschen). Dies kann man sich bei wenigen Dimensionen noch leicht bildlich vorstellen, denn beispielsweise könnten zwei Punkte in zwei Dimensionen nahe beieinander liegen, in der dritten Dimension jedoch weit auseinander, was im Ergebnis dann eine lange Distanz verursacht. Wenn wir beispielsweise 101 Dimensionen berücksichtigen, könnten auch hier zwei Punkte in 100 Dimensionen eng beieinander liegen, läge jedoch in der 101. Dimension (vielleicht auch auf Grund eines Datenfehlers) eine lange Distanz vor, wäre die Gesamtdistanz groß. Mit Gewichtungen könnten jedoch als wichtiger einzustufenden Dimensionen bevorzugt werden und als unsicher geltende Dimensionen entsprechend entschärft werden.

Je mehr Dimensionen berücksichtigt werden sollen, desto mehr Raum steht zur Verfügung, so dass um wenige Datenpunkte viel Leerraum existiert, der dem Algorithmus nicht weiterhilft. Je mehr Dimensionen berücksichtigt werden, desto mehr Daten müssen zu Verfügung gestellt werden, im exponentiellen Anstieg – Wo wir wieder beim Thema Rechenleistung sind, die ebenfalls exponentiell ansteigen muss.

Weiterführende Literatur

Machine Learning in Action

Introduction to Machine Learning with Python

Einführung in Data Science: Grundprinzipien der Datenanalyse mit Python

Forward-Propagation

Back-Propagation

Buchempfehlungen

Gradientenabstiegsverfahren

Programmier-Beispiel in Python

Initialisieren der Gewichtungen

Lernrate

Wichtige Hinweise

Buchempfehlung

Perzeptron

Training des Perzeptron-Netzes

Training eines Perzeptrons

Imaginäres Trainingsbeispiel eines Single-Layer-Perzeptrons (SLP)

Single-Layer-Perzeptrons (SLP) – Beispiel mit der boolischen Trennung

Multi-Layer-Perzeptron (MLP) bzw. (Deep) Feed Forward (FF) Net

Mehrfachklassifikation mit dem Perzeptron

Adaline – Oder: die Limitation des Perzeptrons

Weiterführende Netz-Konzepte (CNN und RNN)

Buchempfehlungen

Anwendungsbeispiel

Was uns vorweg klar sein sollte

Anzahl benötigter Trainingsfälle

Endliche Datenräume

Einfache Hypothesenrepräsentation

Realistische Hypothesenrepräsentation

Lernen eines zu allen Trainingsdaten konsistenten Konzepts (aka Overfitting)

Agnostisches Lernen eines Konzeptes, das möglichst gut zu den Trainingsdaten passt

Folgerung

Fußnoten

Referenzen

Buchempfehlungen

Regression – Die Vorhersage von stetigen Werten

Klassifikation – Die Vorhersage von Gruppenzugehörigkeiten

Fazit – Unterschied zwischen Klassifikation und Regression

Und Clustering?

Klassifikation via K-Nearest Neighbour Algorithmus

Vorab: Verwendete Bibliotheken

Schritt 1 – Daten betrachten und Merkmale erkennen

Schritt 2 – Merkmale im Verhältnis zueinander perspektivisch betrachten

Schritt 3 – Kalkulation der Distanzen zwischen den einzelnen Punkten

Schritt 4 & 5 – Klassifikation durch Eingrenzung auf k-nächste Nachbarn

Fehlerraten herabsenken

Das Problem mit den Dimensionen

Weiterführende Literatur

Interesting links

Pages

Categories

Archive