J'ai essayé d'implémenter le perceptron artificiel avec python

Le livre que j'ai lu

"[2e édition] Python Machine Learning Programming Expert Data Scientist Theory and Practice (impress top gear)"

↑ Je joue avec différentes données, mais en gros, je viens de faire le chapitre 2 de ce livre.

2. Formation aux problèmes de classification d'algorithmes d'apprentissage automatique simples

Règles d'apprentissage précoce de Perceptron

1. Initialisez le poids $ \ mathbf {w} $ avec 0 ou un petit nombre aléatoire

2. Pour chaque exemple d'apprentissage $ \ mathbf {x} ^ {(i)} $, procédez comme suit:

3. Calculez la valeur de sortie $ \ hat {y} $

4. Mettez à jour le poids

$ \ eta $ est le taux d'apprentissage (généralement une constante supérieure à 0,0 et inférieure à 1,0) $ y ^ {(i)} $ est le vrai label de classe du i-ème échantillon d'apprentissage, $ \ hat {y} ^ {(i)} $ est l'étiquette de classe prédite.

La valeur prédite $ \ hat {y} ^ {(i)} $ est

et

Est déterminé par.

Perceptron est linéairement séparable et la convergence n'est garantie que lorsque le taux d'apprentissage est suffisamment faible.

2.2 Implémenter l'algorithme d'apprentissage de Perceptron en Python

2.2.1 API Perceptron orientée objet

import numpy as np
class Perceptron(object):
    """Classificateur Perceptron
    
Paramètres
    -----------
    eta : float
Taux d'apprentissage(0.Supérieur à 0 1.Valeur inférieure ou égale à 0)
    n_iter : int
Nombre de formations dans les données de formation
    random_state : int
Graine aléatoire pour l'initialisation du poids
attribut
    -----------
    w_ :Tableau à 1 dimension
Poids après conformité
    errors_ :liste
Nombre d'erreurs de classification (mises à jour) à chaque époque
    """
    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):
        """S'adapte aux données d'entraînement
        
Paramètres
        ------------
        X : {Structure de données de type tableau}, shape = [n_samples, n_features]
Données d'entraînement
            n_samples est le nombre d'échantillons, n_fonctionnalités est le nombre de fonctionnalités
        y :Structure de données de type tableau, shape = [n_samples]
Variable objective
            
Valeur de retour
        ------------
        self : object
        """
        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): #Répétez les données d'entraînement pour le nombre de formations
            errors = 0
            for xi, target in zip(X, y): #Mettre à jour les poids dans chaque échantillon
                #Poids w_1, ..., w_m mise à jour
                # Δw_j = η (y^(i)vraie valeur- y^(i)Prévoir) x_j (j = 1, ..., m)
                update = self.eta * (target - self.predict(xi))
                self.w_[1:] += update * xi
                #Poids w_Mettre à jour 0 Δw_0 = η (y^(i)vraie valeur- y^(i)Prévoir)
                self.w_[0] += update
                #Si la mise à jour du poids n'est pas 0, elle est considérée comme une erreur de classification.
                errors += int(update != 0.0)
            #Erreur de stockage pour chaque itération
            self.errors_.append(errors)
        return self

    def net_input(self, X):
        """Calculer l'entrée totale"""
        return np.dot(X, self.w_[1:]) + self.w_[0]
    
    def predict(self, X):
        """Renvoie le libellé de la classe après une étape"""
        return np.where(self.net_input(X) >= 0.0, 1, -1)

2.3 Formation du modèle Perceptron avec le jeu de données Iris

from sklearn.datasets import load_iris
import pandas as pd
iris = load_iris()
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['target'] = iris.target
# df.loc[df['target'] == 0, 'target'] = "setosa"
# df.loc[df['target'] == 1, 'target'] = "versicolor"
# df.loc[df['target'] == 2, 'target'] = "virginica"
df.head()

import seaborn as sns
sns.pairplot(df, hue='target')

Puisqu'il s'agit d'une classification binaire, nous nous limiterons à deux types qui peuvent être séparés linéairement.

De plus, les caractéristiques sont réalisées en deux dimensions afin qu'elles puissent être vues visuellement.

Les étiquettes 0 et 2 doivent être appropriées et peuvent être grossièrement séparées. (Je veux utiliser quelque chose de différent du livre)

import numpy as np
import matplotlib.pyplot as plt
df2 = df.query("target != 1").copy() #Exclure l'étiquette 1
df2["target"] -= 1 #Étiquette 1-Aligner sur 1

plt.scatter(df2.iloc[:50, 3], df2.iloc[:50, 1], color='blue', marker='o', label='setosa')
plt.scatter(df2.iloc[50:, 3], df2.iloc[50:, 1], color='green', marker='o', label='virginica')
plt.xlabel('petal width [cm]')
plt.ylabel('sepal width [cm]')
plt.legend(loc='upper left')
plt.show()

Le diagramme de paires ci-dessus a été extrait et tracé de la même manière que le premier à partir de la droite et le second à partir du haut.

Ces données sont utilisées pour entraîner l'algorithme de Perceptron.

X = df2[['petal width (cm)', 'sepal width (cm)']].values
Y = df2['target'].values

ppn = Perceptron(eta=0.1, n_iter=10)
ppn.fit(X, Y)
plt.plot(range(1, len(ppn.errors_) + 1), ppn.errors_, marker='o')
plt.xlabel('Epochs')
plt.ylabel('Number of update')
plt.show()

On voit que le Perceptron a convergé à la 6e époque.

Implémentez une fonction simple et pratique pour visualiser les limites de décision.

from matplotlib.colors import ListedColormap

def plot_decision_regions(X, y, classifier, resolution=0.02):
    
    #Préparation des marqueurs et des cartes de couleurs
    markers = ('s', 'x', 'o', '^', 'v')
    colors = ('red', 'blue', 'lightgreen', 'gray', 'cyan')
    cmap = ListedColormap(colors[:len(np.unique(y))])
    
    #Diagramme de la zone de décision
    x1_min, x1_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    x2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max() + 1
    #Générer des points de grille
    xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, resolution),
                           np.arange(x2_min, x2_max, resolution))
    #Prédire en convertissant chaque entité en un tableau unidimensionnel
    Z = classifier.predict(np.array([xx1.ravel(), xx2.ravel()]).T)
    #Conversion des résultats de prédiction en taille de données de point de grille d'origine
    Z = Z.reshape(xx1.shape)
    #Tracé de contour de point de grille
    plt.contourf(xx1, xx2, Z, alpha=0.3, cmap=cmap)
    #Réglage de la plage d'axe
    plt.xlim(xx1.min(), xx1.max())
    plt.ylim(xx2.min(), xx2.max())
    
    #Tracer des échantillons par classe
    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')

#Diagramme de la zone de décision
plot_decision_regions(X, Y, classifier=ppn)
plt.xlabel('petal width [cm]')
plt.ylabel('sepal width [cm]')
plt.legend(loc='upper left')
plt.show()

Si vous ne pouvez pas le diviser, essayez-le.

Prédiction: Elle ne converge pas et s'arrête à la limite du nombre d'époques. l'erreur sera probablement meilleure.

import numpy as np
import matplotlib.pyplot as plt
df3 = df.query("target != 0").copy() #Exclure l'étiquette 0
y = df3.iloc[:, 4].values
y = np.where(y == 1, -1, 1) #étiquette 1-Définissez les autres (étiquette 2) sur 1

plt.scatter(df3.iloc[:50, 1], df3.iloc[:50, 0], color='orange', marker='o', label='versicolor')
plt.scatter(df3.iloc[50:, 1], df3.iloc[50:, 0], color='green', marker='o', label='virginica')
plt.xlabel('sepal width [cm]')
plt.ylabel('sepal length [cm]')
plt.legend(loc='upper left')
plt.show()

Le troisième en partant de la droite et le premier en partant du haut du diagramme de paires ci-dessus ont été extraits et tracés de la même manière.

X2 = df3[['sepal width (cm)', 'sepal length (cm)']].values

ppn = Perceptron(eta=0.1, n_iter=100)
ppn.fit(X2, y)
plt.plot(range(1, len(ppn.errors_) + 1), ppn.errors_, marker='o')
plt.xlabel('Epochs')
plt.ylabel('Number of update')
plt.show()

#Diagramme de la zone de décision
plot_decision_regions(X2, y, classifier=ppn)
plt.xlabel('sepal width [cm]')
plt.ylabel('sepal length [cm]')
plt.legend(loc='upper left')
plt.show()

Pas du tout classé. Visuellement, plus y est grand, plus l'étiquette 1 est, donc j'ai pensé qu'elle serait séparée correctement lorsque y = 6, mais il semble que ce ne soit pas le cas.

J'ai une note sur Gist.

Ensuite, je ferai ADALINE.