Schlagwort-Archive: perzeptron

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

(24)

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:

(277)

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

(414)