Schlagwort-Archive: perzeptron

Maschinelles Lernen mit Python 2a

zurück zu HeliHuBot Planung und Umsetzung


Training ML-Lernalgorithmen für die Klassifizierung

Mit Schwerpunkten auf:

  • kurze Vorstellung eines Perceptrons und adaptive linearer Neuronen
  • erster Einblick in ML-Algorithmen

Vom Neuron zum Perzeptron

Ein biologisches Neuron (Nervenzelle) ist schematisch im folgenden grob umrissen:

Wer sich für Details interessiert, findet welche im Kapitel I, meiner Physiologie für Biologen und Mediziner. Besonders 1) Das Ruhemembranpotential, 2) Entstehung und Fortleitung eines Aktionspotentials und 5) Synapsen kann ich als Einstieg empfehlen.

Hier werden wir nicht auf neurophysiologische Details oder auf die Vernetzung (Konnektom) eingehen, sondern wir brauchen an dieser Stelle eigentlich nur zu wissen, dass an den Dendriten Synapsen von anderen Axonenden zu finden sind (stellt den Input dar), die hemmen oder erregen können und somit das Ruhemembranpotential (RM) der Membran (Umgibt den Körper der Nervenzelle) beeinflusst. Das RM summiert sich auf und nur wenn eine bestimmte Schwelle erreicht wird (Alles oder Nichts Prinzip), entsteht ein Aktionspotential am Axonhügel (dort wo das Axon vom Körper abgeht) und breitet sich über das Axon zu den Enden aus, wo sich wieder Synapsen befinden, welche auf die nächsten Dentriten hemmend oder erregend wirken können (unser Output).

Natürlich kann ich an dieser Stelle nicht umhin, W.S. McCulloch und W. Pitts, sowie Frank Rosenblatt zu erwähnen, die Pionierarbeit auf dem Gebiet der KI leisteten, sodass 1958 das Perzeptron, das erste, sehr vereinfachte neuronales Netz, basierend auf dem McCulloch-Pitts neuron, vorgestellt werden konnte. Mit den Perzepron-Regeln konnte Rosenblatt eine Algo entwickeln, der automatisch die optimalen Gewichungskoeffizienten lernte, die dann mit den Input-Features verknüpft entschieden, ob ein Neuron feuerte (die Schwelle erreicht wurde), oder nicht. Im Kontext von supervised learning und der Klassifikation bedeutet das, dass der Algo benutzt werden konnte, um eine Zuordnung zu einer Klasse zu erreichen.
Formal können wir dieses Problem als binäre Klassifikationsaufgabe darstellen, wobei wir zur Vereinfachung unsere beiden Klassen als 1 und -1 bezeichnen. Dann können wir eine Aktivierungsfunktion definieren \theta(z), welche eine lineare Kombination bestimmter Eingabewerte \vec{x} und eines entsprechenden Gewichtsvektors \vec{w} erfordert, wobei z der sogenannte net input ist z = (w1x1 + …. + wmxm):

\vec{w} =  \begin{bmatrix} w\textsubscript{1}	\\ \vdots	 \\ w\textsubscript{m}	 \end{bmatrix} , \vec{x} =  \begin{bmatrix} x\textsubscript{1}	\\ \vdots	 \\ x\textsubscript{m}	 \end{bmatrix}
Wenn die Aktivierung eines bestimmten Beispiels x(i), also die Ausgabe von \theta(z), größer ist als ein definierter Schwellenwert \phi, sagen wir Klasse 1 oder andernfalls Klasse -1 voraus.

\phi(z) = \biggl\{  \frac{1 if z \geq \theta}{-1 sonst}
Was die Notation betrifft, greife ich hier inkonsequent auf die grundlegende und oft übliche, kurze Schreibweise zurück, wie sie hier zu finden ist

Bemerkenswert ist hier, dass somit statt \sum\nolimits_{j=0}^m einfach xjwj = wTx geschrieben werden kann.

Die folgende Skizze zeigt, wie der Net-Input einen binären Output ergibt und wie die Aktivierugsfunktion benutzt werden kann, um zwischen zwei linear unterscheidbaren Klassen zu unterscheiden.

Wie oben schon angemerkt, ist die Tatsache, dass ein Neuron ab einen bestimmten Schwellwert feuert im MCP-Neuron einfach umgesetzt. Rosenblatt’s Initialisierungsregel für das Perzeptron ist daher einfach zu umschreiben:
1.) Initialisiere die Gewichtung mit 0 oder kleinen zufälligen Zahlen
2.) für jedes Training, Beispiel x(i) sind die folgenden Schritte durchzuführen
a.) berechene den Ourtput-Wert ŷ
b.) aktualisiere die Gewichtung
Der Output-Wert ist hier das vorausgesagte Class-Label mittels besprochener Heaviside step function und der gleichzeitigen Aktualisierung der Gewichtung des Gewichtungsvektor wi also wi := wi + \Deltawi
\Deltawi mit dem wi aktualisiert wird, wird mit der Perceptron Lernregel berechnet \Deltawi = \eta (y(i) – (ŷ(i))xj(i)
In dieser Lernregel ist \eta die Lernrate (zwischen 0,0 und 1,0)
yi ist das Klass-Label und
ŷi ist das vorausgesagte Klass-Label.
Es müssen alle Gewichtungen aktualisiert werden, bevor ŷi neu berechnet wird.
\Deltaw0 = \eta (y(i) – (output(i))
\Deltaw1 = \eta (y(i) – (output(i))x1(i)
\Deltaw2 = \eta (y(i) – (output(i))x2(i) ….
Wenn das Klass-Label richtig vorausgesagt wird, bleibt die Gewichtung unverändert.

Weblinks:
https://www.cs.cmu.edu/~zkolter/course/linalg/linalg_notes.pdf von Linear Algebra Review
Weitere Quellen
Künstliche Intelligenz von Stuart Russell und Peter Norvig; ISBN 978-3-86894-098-5
Python Machine Learning von Sebastian Raschka; ISBN 978-1-78355-513-0
Neuronale Netze von Günter Daniel Rey und Karl F. Wender; ISBN 978-3-456-54881-5

(71)

Ein Lernalgorithmus in Python für ein Perzeptron

Was man sich vorher ansehen sollte.
NumPy: Quickstart tutorial bzw. NumPy v1.12.dev0 Manual oder Tentative NumPy Tutorial bzw. auf GitHub scipy-tentative-numpy-tutorials. Wer ein älteres pdf bevorzugt findet es hier doc_numpy-pdf_1

Pandas: http://pandas.pydata.org/pandas-docs/stable/tutorials.html
Matplotlib: http://matplotlib.org/users/beginner.html

Von Python sollte eine 3er Version installiert sein. python -V sagt mir, dass ich Python 3.5.2 installiert habe, womit ich zufrieden bin.
Auf Python 3.5.2 documentation findet man die Doku zu Python und um pip braucht man sich seit der 3.4 Version auch nicht mehr kümmern, da der Paketmanager für PyPI schon automatisch mitinstalliert wird.
Wir verwenden also NumPy, pandas und matplotlib zum Einlesen, Verarbeiten und Visualisieren der Daten und wir werden einen einfachen Algorithmus zur linearen Klassifikation implementieren.
Zuerst schaue ich einmal, ob ich die neueste Version von pip habe und komme mit „pip install –upgrade pip“ auf pip-9.0.1 und schon habe ich falsch gedacht. Ich muss ja pip für Python 3.x installieren mit sudo apt install python3-pip Dann wieder ein –upgrade und ein sudo pip3 install numpy

 

 

 

 

 

Zum Code:

import numpy as np
class Perceptron(object):
"""Perceptron classifier.

Parameters
------------
eta : float
Learning rate (between 0.0 and 1.0)
n_iter : int
Passes over the training dataset.

Attributes
-----------
w_ : 1d-array
Weights after fitting.
errors_ : list
Number of misclassifications in every epoch.

"""
def __init__(self, eta=0.01, n_iter=10):
self.eta = eta
self.n_iter = n_iter

def fit(self, X, y):
"""Fit training data.

Parameters
----------
X : {array-like}, shape = [n_samples, n_features]
Training vectors, where n_samples is the number of samples and
n_features is the number of features.
y : array-like, shape = [n_samples]
Target values.

Returns
-------
self : object

"""
self.w_ = np.zeros(1 + X.shape[1])
self.errors_ = []

for _ in range(self.n_iter):
errors = 0
for xi, target in zip(X, y):
update = self.eta * (target - self.predict(xi))
self.w_[1:] += update * xi
self.w_[0] += update
errors += int(update != 0.0)
self.errors_.append(errors)
return self

def net_input(self, X):
"""Calculate net input"""
return np.dot(X, self.w_[1:]) + self.w_[0]

def predict(self, X):
"""Return class label after unit step"""
return np.where(self.net_input(X) >= 0.0, 1, -1)

 

 
So, soweit funktioniert es und nächstes mal werde ich das Perzeptron-Modell mit den Iris Datensätzen trainieren.


Quelle: Python Machine Learning von Sebastian Raschka; Published 2015-09-23
Weblinks:
https://github.com/arnaudbenard/python-machine-learning
http://stackoverflow.com/questions/36532585/passing-an-array-to-numpy-dot-in-python-implementation-of-perceptron-learning
https://github.com/rasbt/python-machine-learning-book/blob/master/code/optional-py-scripts/ch02.py
http://natureofcode.com/book/chapter-10-neural-networks/
http://stackoverflow.com/questions/36532585/passing-an-array-to-numpy-dot-in-python-implementation-of-perceptron-learning

(54)

Perzeptron: Lernregeln

Hier werden nur drei Lernregeln für das Perzeptron vorgestellt:
.) die Hebb-Regel
.) die Perzeptronregel und
.) die Deltaregel
Mit anderen Worten, ich möchte nur näher auf, einfache, lange bekannte Mechanismen des automatisierten, überwachten Lernens näher eingehen.
Lernen bedeutet, beim einfachen künstlichen Neuron, Perzeptron, dass der Gewichtsvektor w und der Schwellwert an die Klassifikationsaufgabe angepasst wird. Wir modifizieren die Vorverarbeitung zur Vereinfachung, wie folgt:

(281)

Das Perzeptron – Einführung in neuronale Netze und KI

Das Perzeptron ist ein vereinfachtes künstliches neuronales Netz (Frank Rosenblatt 1958). Rosenblatt hat es so einfach realisiert, dass man es mathematisch mit einer dreistufigen Verarbeitung von Matritzen erfassen konnte. Aber auch weil die Parameter der zweiten Stufe mit verschiedenen Lernregeln gelernt werden können ist dieses „einfache“ Modell bedeutsam für die Einführung in neuronale Netze und künstliche Intelligenz.
Es kann auch ganz einfach in fast jeder Programmiersprache leicht umgesetzt werden.

Es besteht in seiner einfachsten Variante aus einer einzelnen Schicht künstlicher Neurone mit anpassbaren Gewichtungen und einem Schwellenwert. Es ist eine vereinfachte Nachbildung eines biologischen Neurons. Unter Verwendung eines Graphen (Skizze stellt solche Graphen dar) können die Neuronen als Knoten und ihre Verbindungen als Kanten dargestellt werden. Die Eingaben werden oft wie Neuronen als Knoten behandelt, dann spricht man folglich bei einem Netz mit einer Eingabe- und einer Neuronenschicht von einem zweischichtigen Netz.
Das einstufige Perzeptron besteht in diesen Fall also, aus zwei Schichten (layer). Die erste Schicht ist die Eingabeschicht (Netzhaut), welche aus McCulloch-Pitts Neuronen besteht. Von der ersten Schicht gibt es
gewichtete Verbindungen zum nächsten Neuron (Ausgabeneuron). Das ist der prinzipielle
Unterschied zu einfacheren Neuron. Man hat die Möglichkeit die Eingaben, die n-mal
vorkommen anhand der Gewichtung darstellen. Durch Änderung der Gewichte und
Schwellenwerte kann das Perzeptron lernen. Die eingehenden Signale gehen erste durch die
erste Schicht, wo sie vorgefiltert werden. Im Ausgabeneuron werden vorsortierte gewichtete
Signale aufsummiert. Wenn die Summe den Schwellenwert überschreitet, feuert das
Perzeptron. Abhängig von der Anzahl gewichteten Schichten werden Perzeptrone ein-, zwei-, dreistufig etc. genannt.
Ein Beispiel dazu aus der Bildverarbeitung (nicht unbedingt zum chapcha knaken) bei dem die Frage beantwortet werden soll, ob ein Bild einen bestimmten Gegenstand darstellt und dann soll das Perzeptron mit verschiedenen Lernregeln getestet werden.
Das Bild wird dazu mit einem Muster verglichen und Übereinstimmung bzw. Abweichung soll festgestellt werden. Dabei kann geprüft werden ob das Bild zu einer Gruppe von Mustern mit einer bestimmten Eigenschaft passt.. Rosenberg unterscheidet bei der Bildverarbeitung drei Stufen:
die Merkmalextraktion, die Merkmalbeurteilung und die Entscheidung, die Stufen 2 und 3 bilden den eigentlichen Kern des Perzeptrons.

Stufe 1: Vorverarbeitung oder Merkmalextraktion

Unabhängig davon, welcher Bildtyp erkannt werden soll, wird eine Menge charakteristischer Kenngrößen des Bildes extrahiert (beim menschlichen Sehen und Erkennen findet dies auf der Netzhaut des Auges statt).
Auf einer Menge von Eingaben, z.B. die Pixel (eij) eines Bildes werden Prädikate pk(eij) ∈ {0,1} berechnet. Beim Perzeptron wird die Vorverarbeitung durch Lernvorgänge nicht verändert, aber je nach Fähigkeiten der Stufe 1 kann in mehrere Gruppen eingeteilt werden (Anzahl der Eingaben, Durchmesserbeschränkungen).
Die Prädikate sollen sich einfach aus den Pixeln berechnen lassen.

Stufe 2: Beurteilung der Bildmerkmale

Die Ergebnisse aus Stufe 1 werden so aufbereitet, das eine Entscheidung möglich wird, ob das bild mit seinen Eigenschaften zu den vorgegebenen Mustern passt. Die Parameter dafür können entweder vorher eingestellt, oder mittels Beispielen gelernt werden. (Beim Menschen sird eine solche vom Gedächtnis abhängige Verarbeitung in den Sehfeldern des Gehirns vorgenommen; bei Ausfall dieser kommt es zur Rindenblindheit, auch wenn das Auge völlig intakt ist).
Die Stufe 2 ist eine lineare Abbildung (Aktivierung, Polynom vom Grad 1 in p1 …pn). Die Prädikate werden zu einer gewichteten Summe aufaddiert und der Schwellwert wird abgezogen. Es wird die folgende lineare Funktion a, auch Aktivierungsfunktion genannt, berechnet
a(p1 …pn) = ∑iwipi – θ (θ steht für thresold, Schwellwert).
Die Gewichte sind positiv, wenn die Prädikate für die Eigenschaft typisch und negativ, wenn sie untypisch sind. Gewicht 0 hat keinen Einfluss. Die Gewichte und der Schwellwert sind problemspezifisch und können eingestellt bzw. maschinell gelernt werden.

Stufe 3: Entscheidung

Der Klassifikator entscheidet auf grund der Beurteilung, ob das Bild den gesuchten Eigenschaften entspricht. (beim Menschen entspricht das dem Erkennen des Gegenstands).
Je nachdem, ob a(p1 …pn) ≥ 0 oder ≤ ist, wir die Eingabe angenommen (Wert 1), oder abgelehnt (Wert 0) aher ist σ(a(p))= 1 für a(p)≥ 0 und σ(a(p)) = 0 für a(p) > 0.

Quellenverzeichnis:
Praktikum Neuronaler Netze von Heinrich Braun, Johajjes Feulner und Rainer Malaka
Principles of Neurodynamics von F. Rosenblatt
Parallel Distributed Processing von D.E. Rumelhart und J.L. McClelland

(539)