[Python] Ein Schüler der Mittelstufe implementierte Perceptron und versuchte, Iris zu klassifizieren.

Einführung

Beim Schreiben dieses Artikels habe ich auf Python Machine Learning Programming-GitHub verwiesen. Ich bin dir wirklich dankbar.

Über Neuronen

Die Zellen, aus denen der Nerv besteht, die stimuliert und angeregt werden und den Reiz auf andere Zellen übertragen. Nervenzelle.

Das Neuron ist ein Bild wie das folgende.

[Nikkei Cross Tech](https://www.google.com/url? 1593296223820000 & source = images & cd = vfe & ved = 0CAMQjB1qFwoTCJDi3o_BoOoCFQAAAAAdAAAAABAQ)

Es gibt ungefähr 200 Milliarden Neuronen in Ihrem Gehirn. Dann wird jedes Neuron wie in der Abbildung unten gezeigt verbunden.

[Earth Semina 36-3](https://www.google.com/url?sa=i&url=http%3A%2F%2Fblog.livedoor.jp%2Fnara_suimeishi%2Farchives%2F51595095.html&psig=AOvVaw2KqsANc_yt4x9xvlxfjf9xcvl9f9f9f9x9 vfe & ved = 0CAMQjB1qFwoTCMD-84vDoOoCFQAAAAAdAAAAABAD)

Die Gelenke werden Synapsen genannt.

Mechanismus der Informationsübertragung durch Neuronen

Der Zellteil wird stimuliert
Der Nervenimpuls "feuert"
Informationsspike-Züge werden über Axone an Synapsen geliefert
Es gelangt zu den nachgeschalteten Nervenzellen.

Formulieren Sie Neuronen

Ein einfaches Diagramm eines Neurons ist unten gezeigt.

Es gibt viele Eingabewerte bis zu $ x_1 ... x_m $, aber der Ausgabewert ist immer entweder "Feuer" oder "Nicht feuern". Diesmal ist der Ausgabewert bei "Zünden" 1 und der Ausgabewert bei "Zünden" -1. (Der Ausgabewert ist beliebig) $ W $ ist übrigens ein Akronym für Gewicht, das die Wichtigkeit des Eingabewerts bestimmt. $ y $ repräsentiert den Ausgabewert.

Wenn dies quantifiziert wird, wird es so.

z = x_1w_1 + ... + x_mw_m = \sum_{x=1}^{m} x_iw_i

Das neue $ z $ wird hier als Gesamteingabe und in Englisch als Nettoeingabe bezeichnet.

Und $ \ theta $, wie im obigen Bild gezeigt, wird als Schwelle (Schwelle) bezeichnet, und wenn es $ z \ geq \ theta $ ist, wird "Feuer" 1 ausgegeben. Wenn andererseits $ z <\ theta $ ist, wird -1 ausgegeben, weil es sich nicht entzündet.

f(z) = \left\{
\begin{array}{ll}
1 & (z \geq 0) \\
0 & (z \lt 0)
\end{array}
\right.

Zu diesem Zeitpunkt ist $ f (z) $ eine ** Entscheidungsfunktion **, die "1" ausgibt, wenn sie 0 oder mehr wird, und "0", wenn sie 0 oder weniger wird.

Einheitsschrittfunktion

Wie Sie in diesem Diagramm sehen können, wird z ausgelöst, wenn z 0 oder mehr wird, und 1 wird ausgegeben.

Auf diese Weise wird die Funktion, die plötzlich zu einem bestimmten Zeitpunkt ausgelöst wird, als ** schwere Seitentreppenfunktion ** bezeichnet.

Über einfaches Perceptron

Bisher haben wir über einfache Neuronen gesprochen, die als formale Neuronen bezeichnet werden. Als nächstes werde ich einen Algorithmus namens Perceptron erklären.

Das 1958 eingeführte Simple Perceptron basiert auf einem sehr einfachen Algorithmus.

1.Initialisieren Sie Gewichte auf 0 oder eine beliebige Zahl
2.Berechnen Sie den Ausgabewert für jeden Eingabewert und aktualisieren Sie das Gewicht

Das ist es.

Die Formel zum Aktualisieren des Gewichts lautet wie folgt.

W_j := W_j + \Delta W_j

Jedes Gewicht auf der linken Seite, $ W_j $, wird mit $ \ Delta W_j $ aktualisiert.

$ \ Delta W_j $ ist

\Delta W_j = \eta\:(\:y^{(i)}-\hat{y}^{(i)}\:)\: x_{j}^{(i)}

Kann geschrieben werden als.

$ y ^ {(i)} $ repräsentiert die wahre Klassenbezeichnung (korrekte Klassifizierung) und $ \ hat {y} ^ {(i)} $ repräsentiert den Ausgabewert (Klassifizierungsergebnis). Und $ \ eta $ zeigt die Lernrate und $ x_ {j} ^ {(i)} $ zeigt den Eingabewert.

Wenden wir bestimmte Zahlen an

Nachdem Sie die generierte Formel verstanden haben, versuchen wir es mit einer konkreten Zahl.

Betrachten Sie beispielsweise ein Muster, das falsch klassifiziert wurde.

\Delta W_j = \eta\:(\:1-(-1)\:)\: x_{j}^{(i)} = \eta\:(2)\:x_{j}^{(i)}

Wenn $ \ eta $ 1 ist, $ x_ {j} ^ {(i)} $ 0,5 ist, wird das Gewicht auf 1 aktualisiert.

Dies führt zu einer größeren Anzahl von Gesamteingaben ($ x_ {j} ^ {(i)} W_j $), was weniger wahrscheinlich falsch ist.

Und es ist ** Simple Perceptron **, das dies die ganze Zeit tut, bis es keine Fehler mehr gibt.

Nachteile von Simple Perceptron

Simple Perceptron kann nicht zwei Klassen trennen, die linear untrennbar sind.

PLAN-B

Auch ein XOR-Betrieb ist nicht möglich, da eine lineare Trennung nicht möglich ist. (Was ist eine XOR-Operation?) Betrachten Sie die Eingabewerte $ x_1 $, $ x_2 $.

x_1	x_2	x_1 XOR x_2
0	0	0
0	1	1
1	1	0
1	0	1

Zu diesem Zeitpunkt sieht das Plotten jeweils so aus.

Maschinelles Lernen, das auch Abiturienten verstehen können

Wie Sie sehen können, ist dies linear untrennbar miteinander verbunden.

Um die XOR-Operation zu lösen, ist es notwendig, ein mehrschichtiges Perzeptron zu implementieren.

Lassen Sie uns Perceptron implementieren !!

Entwicklungsumgebung: Chrome 83 Google Colab Mac OS High Sierra

1. Modularisierung von Perceptron

import numpy as np

class Perceptron(object):
    def __init__(self, eta=0.01, n_iter=50, random_state=1):
        self.eta = eta
        self.n_iter = n_iter
        self.random_state = random_state

    def fit(self, X, y):
        rgen = np.random.RandomState(self.random_state)
        self.w_ = rgen.normal(loc=0.0, scale=0.01, size=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):
        return np.dot(X, self.w_[1:]) + self.w_[0]

    def predict(self, X):
        return np.where(self.net_input(X) >= 0.0, 1, -1)

Originalcode: GitHub

2. Überprüfen Sie den Iris-Datensatz

#Daten lesen und prüfen, X,Spezifikation von y
import matplotlib.pyplot as plt
import pandas as pd 
df = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data', header=None)
df.head()

y = df.iloc[0:100, 4].values
y = np.where(y == 'Iris-setosa', -1, 1)

X = df.iloc[0:100, [0, 2]].values

Originalcode: GitHub

3. Funktionen zum Plotten

from matplotlib.colors import ListedColormap

def plot_decision_regions(X, y, classifier, resolution=0.02):

    # setup marker generator and color map
    markers = ('s', 'x', 'o', '^', 'v')
    colors = ('red', 'blue', 'lightgreen', 'gray', 'cyan')
    cmap = ListedColormap(colors[:len(np.unique(y))])

    # plot the decision surface
    x1_min, x1_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    x2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max() + 1
    xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, resolution),
                           np.arange(x2_min, x2_max, resolution))
    Z = classifier.predict(np.array([xx1.ravel(), xx2.ravel()]).T)
    Z = Z.reshape(xx1.shape)
    plt.contourf(xx1, xx2, Z, alpha=0.3, cmap=cmap)
    plt.xlim(xx1.min(), xx1.max())
    plt.ylim(xx2.min(), xx2.max())

    # plot class samples
    for idx, cl in enumerate(np.unique(y)):
        plt.scatter(x=X[y == cl, 0], 
                    y=X[y == cl, 1],
                    alpha=0.8, 
                    c=colors[idx],
                    marker=markers[idx], 
                    label=cl, 
                    edgecolor='black')

Originalcode: GitHub

4. Handlung

plot_decision_regions(X, y, classifier=ppn)
plt.xlabel('sepal length [cm]')
plt.ylabel('petal length [cm]')
plt.legend(loc='upper left')


# plt.savefig('images/02_08.png', dpi=300)
plt.show()

Originalcode: GitHub

5. So.

Schließlich

Als nächstes möchte ich die Implementierung des mehrschichtigen Perceptron ausprobieren.