[Python] Un lycéen a implémenté Perceptron et a essayé de classer les iris.
introduction
En écrivant cet article, j'ai fait référence à Python Machine Learning Programming -GitHub. Je vous en suis vraiment reconnaissant.
À propos des neurones
Les cellules qui composent le nerf, qui sont stimulées et excitées, et transmettent le stimulus à d'autres cellules. Cellule nerveuse.
Le neurone est une image comme celle ci-dessous.
[Nikkei Cross Tech](https://www.google.com/url?sa=i&url=https%3A%2F%2Fxtech.nikkei.com%2Fdm%2Fatcl%2Ffeature%2F15%2F032300023%2F00003%2F&psig=vVaw3ekhXBOUT 1593296223820000 & source = images & cd = vfe & ved = 0CAMQjB1qFwoTCJDi3o_BoOoCFQAAAAAdAAAAABAQ)
Il y a environ 200 milliards de neurones dans votre cerveau. Ensuite, chaque neurone est connecté comme indiqué dans l'image ci-dessous.
[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_yt4xjFv8gl vfe & ved = 0CAMQjB1qFwoTCMD-84vDoOoCFQAAAAAdAAAAABAD)
Les articulations sont appelées synapses.
Mécanisme de transmission de l'information par les neurones
- La partie cellulaire est stimulée
- L'influx nerveux "se déclenche"
- Des trains de pointes d'information sont livrés aux synapses via des axones
- Il progresse vers les cellules nerveuses en aval.
Formuler des neurones
Un schéma simple d'un neurone est présenté ci-dessous.
Il existe de nombreuses valeurs d'entrée allant jusqu'à $ x_1 ... x_m $, mais la valeur de sortie est toujours un choix entre "fire" et "do not fire". Cette fois, la valeur de sortie lorsque «s'enflamme» est 1 et la valeur de sortie lorsque «ne s'allume pas» est -1. (La valeur de sortie est arbitraire) À propos, $ w $ est un acronyme pour poids, qui détermine l'importance de la valeur d'entrée. $ y $ représente la valeur de sortie.
Quand cela est quantifié, cela devient comme ça.
z = x_1w_1 + ... + x_mw_m = \sum_{x=1}^{m} x_iw_i
Le nouveau $ z $ ici est appelé entrée totale et est appelé entrée nette en anglais.
Et, $ \ theta $ montré dans l'image ci-dessus est appelé le seuil (seuil), et quand il est $ z \ geq \ theta $, "fire" 1 est sorti. En revanche, si $ z <\ theta $, -1 est émis car il ne s'enflamme pas.
f(z) = \left\{
\begin{array}{ll}
1 & (z \geq 0) \\
0 & (z \lt 0)
\end{array}
\right.
A ce moment, $ f (z) $ est une ** fonction de décision ** qui produit "1" quand il devient 0 ou plus et "0" quand il devient 0 ou moins.
Fonction d'étape d'unité
Comme vous pouvez le voir sur ce graphique, lorsque z devient 0 ou plus, il se déclenche et 1 est émis.
De cette façon, la fonction qui se déclenche soudainement à un certain moment est appelée la ** fonction d'escalier latéral lourd **.
À propos de Simple Perceptron
Jusqu'à présent, nous avons parlé de neurones simples appelés neurones formels. Ensuite, j'expliquerai un algorithme appelé Perceptron.
Introduit en 1958, le Simple Perceptron fonctionne sur un algorithme très simple.
1.Initialiser les poids à 0 ou à n'importe quel nombre
2.Calculez la valeur de sortie pour chaque valeur d'entrée et mettez à jour le poids
C'est tout.
La formule de mise à jour du poids est la suivante.
W_j := W_j + \Delta W_j
Chaque poids à gauche, $ W_j $, est mis à jour avec $ \ Delta W_j $.
$ \ Delta W_j $ est
\Delta W_j = \eta\:(\:y^{(i)}-\hat{y}^{(i)}\:)\: x_{j}^{(i)}
Peut être écrit comme.
$ y ^ {(i)} $ représente la vraie étiquette de classe (classification correcte) et $ \ hat {y} ^ {(i)} $ représente la valeur de sortie (résultat de la classification). Et $ \ eta $ montre le taux d'apprentissage et $ x_ {j} ^ {(i)} $ montre la valeur d'entrée.
Appliquons des nombres spécifiques
Maintenant que vous comprenez la formule générée, essayons un nombre concret.
Par exemple, considérons un modèle qui a été mal classé.
\Delta W_j = \eta\:(\:1-(-1)\:)\: x_{j}^{(i)} = \eta\:(2)\:x_{j}^{(i)}
Si $ \ eta $ vaut 1, $ x_ {j} ^ {(i)} $ vaut 0,5, le poids est mis à jour à 1.
Cela entraînera un plus grand nombre d'entrées totales ($ x_ {j} ^ {(i)} W_j $), ce qui est moins susceptible de se tromper.
Et c'est ** Simple Perceptron ** qui continue à faire cela tout le temps jusqu'à ce qu'il n'y ait plus d'erreurs.
Inconvénients de Simple Perceptron
Simple Perceptron ne peut pas séparer deux classes linéairement inséparables.
De plus, le fonctionnement XOR n'est pas possible car la séparation linéaire n'est pas possible. (Qu'est-ce que l'opération XOR?) Considérez les valeurs d'entrée $ x_1 $, $ x_2 $.
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 1 | 0 |
| 1 | 0 | 1 |
À ce stade, le tracé de chacun ressemblera à ceci.
Apprentissage automatique que même les diplômés du secondaire peuvent comprendre
Comme vous pouvez le voir, c'est linéairement inséparable.
Afin de résoudre l'opération XOR, il est nécessaire de mettre en œuvre un perceptron multicouche.
Implémentons Perceptron !!
Environnement de développement: Chrome 83 Google Colab Mac OS High Sierra
1. Modularisation de 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)
Code d'origine: GitHub
2. Vérifiez le jeu de données iris
#Lecture et vérification des données, X,spécification de 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
Code d'origine: GitHub
3. Fonctions de traçage
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')
Code d'origine: GitHub
4. Tracé
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()
Code d'origine: GitHub
5. Comme ça
finalement
Ensuite, je voudrais essayer la mise en œuvre du Perceptron multicouche.
Recommended Posts