Expérience d'apprentissage Perceptron apprise avec Python

1. Règles d'apprentissage de Perceptron

La règle d'apprentissage de Perceptron est une méthode pour trouver le poids d'une fonction discriminante linéaire par apprentissage. Le motif est représenté par un point unique sur l'espace des fonctions. Par exemple, lorsqu'on considère deux classes, est-il possible de séparer les points distribués dans l'espace des caractéristiques en deux par le superplan généré par la fonction discriminante linéaire? Afin de le séparer en deux, le poids de la fonction discriminante linéaire doit être ajusté. L'ajustement devient apprentissage. En d'autres termes, un superplan pour se séparer en deux est créé par apprentissage. Tout d'abord, soit la classe Ci (i = 1 ... c), x le motif d'entrée et le nombre de dimensions d. La fonction discriminante linéaire gi (x) de classe Ci est

g_i(x) = ω₀+\sum_{j=1}^{d} ω_jx_j

Cette fois, par souci de simplicité, nous allons considérer deux classes, et laisser les classes être C₁ et C₂. De plus, lorsque gi (x) est le maximum, on suppose que la classe à laquelle appartient x est Ci. fait). A ce moment, lorsque le motif d'entrée est de classe C₁, g₁ (x)> g₂ (x). Et lorsque le motif d'entrée est de classe C₂, g₁ (x) <g₂ (x). Par conséquent, la fonction d'identification gi (x) est combinée en une seule.

g(x) = g_1(x)-g_2(x)
     =ω'₀+\sum_{j=1}^{d} ω'_jx'_j

• Lorsque g (x)> 0, x∊C₁. Lorsque g (x) <0, x∊C₂ Et. Le ω dans ce g (x) est le poids, et le but de l'apprentissage est de faire de ce poids la valeur optimale. Le poids est calculé selon la procédure suivante. Exprimez (ω'₀, ω'₁, ..., ω'd) comme vecteur de poids W. ① Tout d'abord, réglez le poids de manière appropriée ② Sélectionnez un modèle d'apprentissage. (Un modèle d'apprentissage est un ensemble de vecteurs de caractéristiques x et de classe Ci auxquels x appartient) (3) Lorsque x∊C₁ est g (x) <0, ajoutez le vecteur de poids W multiplié par le modèle d'apprentissage x (vecteur de caractéristiques) et le coefficient d'apprentissage p. Lorsque x∊C₂ est g (x)> 0, la valeur obtenue en multipliant le vecteur de poids W par le motif d'apprentissage x (vecteur de caractéristique) par le coefficient d'apprentissage p est soustraite. (4) Exécutez les étapes (2) et (3) pour tous les modèles d'apprentissage. ⑤ Terminez lorsque des résultats d'identification corrects sont obtenus pour tous les modèles d'apprentissage. S'il y a même une erreur, revenez à l'étape ②.

De cette manière, le vecteur poids W est obtenu. La fonction discriminante linéaire, qui le remplace par g (x), sépare l'espace des caractéristiques de chaque classe par un superplan. Cependant, il est limité aux distributions linéairement séparables, car les règles d'apprentissage de Perceptron convergent lorsqu'elles sont linéairement séparables (Théorème de convergence de Perceptron).

2. Implémenté en Python

Premièrement, le vecteur de caractéristiques du modèle d'apprentissage pourrait être utilisé comme entrée du côté exécution, mais il a été défini à l'avance car les règles d'apprentissage de Perceptron ne peuvent être appliquées que si la distribution est linéairement identifiable. C'est comme suit. Classe C₁: x₁ = (1,1,1,1), x₂ = (1,0,1,1), x₃ = (1,1,0,1), x₄ = (1,1,1,0) Classe C₂: x₅ = (1,0,0,0), x₆ = (1,1,0,0), x₇ = (1,0,1,0), x₈ = (1,0,0,1) Le 0e élément de chaque vecteur de caractéristique est tout 1, qui est la valeur multipliée par ω₀ de la fonction discriminante linéaire g (x). En réalité, les trois éléments après le premier élément sont les vecteurs de caractéristiques, et l'espace des caractéristiques est également tridimensionnel (à proprement parler, le vecteur à quatre dimensions comprenant le premier élément est appelé le vecteur de caractéristiques étendu. À l'origine, le vecteur de caractéristiques ( (Sans extension) signifie le premier au dth vecteurs). Puisqu'il s'agit d'un espace d'entités tridimensionnel, il réussit si les deux classes sont séparées par un superplan bidimensionnel. Le coefficient d'apprentissage dans la règle d'apprentissage a été fixé à 1. Tout d'abord, les vecteurs de caractéristiques du modèle d'apprentissage sont répartis dans l'espace de caractéristiques comme suit. (Rouge: Classe C₁, Bleu: Classe C₂) J'ai implémenté les règles d'apprentissage en Python. Le code est comme suit.

perceptron_learning.py

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

#Vecteur de fonction de modèle d'apprentissage
x = np.array([[1, 1, 1, 1], [1, 0, 1, 1], [1, 1, 0, 1], [1, 1, 1, 0], [1, 0, 0, 0], [1, 1, 0, 0], [1, 0, 1, 0], [1, 0, 0, 1]])

#Vecteur de poids
w = np.array([-5, 1, 1, 1])

#Règles d'apprentissage Perceptron
while True:
	judge = 0
	count = 1;
	for data in x:
		print(w)
		if count <= x.shape[0]/2:
			if np.dot(data, w)<=0:
				w += data
				judge = 1
		else:
			if np.dot(data, w)>=0:
				w -= data
				judge = 1
		count += 1
	print()
	if judge == 0:
		break


#Fonction discriminante linéaire
def f(x1, x2):
    return (w[1]*x1+w[2]*x2+w[0])/(-w[3])

x1, x2 = np.mgrid[-1:2:0.1, -1:2:0.1]
x3 = f(x1, x2)

#Paramètres de l'espace des fonctionnalités
fig = plt.figure()
ax = fig.add_subplot(111, projection="3d", facecolor="w")
ax.set_xlabel('x1')
ax.set_ylabel('x2')
ax.set_zlabel('x3')
ax.set_title("feature space")

#Dessiner une fonction discriminante linéaire
ax.plot_surface(x1, x2, x3, cmap='BuGn')

i = 1

#Dessiner des modèles d'apprentissage
for point in x:
	if i<=x.shape[0]/2:
		ax.scatter(point[1], point[2], point[3], c='red')
	else:
		ax.scatter(point[1], point[2], point[3], c='blue')
	i += 1

#Afficher l'espace des fonctionnalités
plt.show()

À la suite de l'exécution, l'espace des fonctionnalités est le suivant. Comme le montre la figure ci-dessus, les points rouge et bleu sont séparés par la surface verte (superplan). Par conséquent, on peut voir que le poids a été obtenu par la règle d'apprentissage.

3. Références

[1] Kenichiro Ishii, Nobuyoshi Ueda, Eisaku Maeda, Hiroshi Murase. "Reconnaissance de modèle facile à comprendre 2ème édition". Ohm, 2019.