Implémentation d'un Perceptron à partir de zéro en Python

Salut les développeurs,

Le Perceptron est l'un des concepts les plus simples et les plus fondamentaux de l'apprentissage automatique. Il s’agit d’un classificateur linéaire binaire qui constitue la base des réseaux de neurones. Dans cet article, je vais parcourir les étapes pour comprendre et implémenter un Perceptron à partir de zéro en Python.

Plongeons-nous !

---

Qu'est-ce qu'un Perceptron ?

Un Perceptron est un algorithme de base pour l'apprentissage supervisé des classificateurs binaires. Compte tenu des fonctionnalités d'entrée, le Perceptron apprend des poids qui aident à séparer les classes en fonction d'une simple fonction de seuil. Voici comment cela fonctionne en termes simples :

1. Entrée : un vecteur de fonctionnalités (par exemple, [x1, x2]).
2. Poids : chaque fonctionnalité d'entrée a un poids, que le modèle ajuste en fonction de ses performances.
3. Fonction d'activation : calcule la somme pondérée des caractéristiques d'entrée et applique un seuil pour décider si le résultat appartient à une classe ou à l'autre.

Mathématiquement, cela ressemble à ceci :

f(x) = w1*x1 w2*x2 ... wn*xn b

Où :

• f(x) est la sortie,
• w représente les poids,
• x représente les entités d'entrée, et
• b est le terme de biais.

Si f(x) est supérieur ou égal à un seuil, la sortie est de classe 1 ; sinon, c'est la classe 0.

---

Étape 1 : Importer des bibliothèques

Nous utiliserons ici uniquement NumPy pour les opérations matricielles afin de garder les choses légères.

import numpy as np

---

Étape 2 : Définir la classe Perceptron

Nous allons construire le Perceptron comme une classe pour que tout reste organisé. Le cours comprendra des méthodes d'entraînement et de prédiction.

class Perceptron:
    def __init__(self, learning_rate=0.01, epochs=1000):
        self.learning_rate = learning_rate
        self.epochs = epochs
        self.weights = None
        self.bias = None

    def fit(self, X, y):
        # Number of samples and features
        n_samples, n_features = X.shape

        # Initialize weights and bias
        self.weights = np.zeros(n_features)
        self.bias = 0

        # Training
        for _ in range(self.epochs):
            for idx, x_i in enumerate(X):
                # Calculate linear output
                linear_output = np.dot(x_i, self.weights) + self.bias
                # Apply step function
                y_predicted = self._step_function(linear_output)

                # Update weights and bias if there is a misclassification
                if y[idx] != y_predicted:
                    update = self.learning_rate * (y[idx] - y_predicted)
                    self.weights += update * x_i
                    self.bias += update

    def predict(self, X):
        # Calculate linear output and apply step function
        linear_output = np.dot(X, self.weights) + self.bias
        y_predicted = self._step_function(linear_output)
        return y_predicted

    def _step_function(self, x):
        return np.where(x >= 0, 1, 0)

Dans le code ci-dessus :

• ajustement : cette méthode entraîne le modèle en ajustant les poids et les biais chaque fois qu'il classe mal un point.
• prédire : cette méthode calcule des prédictions sur de nouvelles données.
• _step_function : Cette fonction applique un seuil pour déterminer la classe de sortie.

---

Étape 3 : Préparer un ensemble de données simple

Nous utiliserons un petit ensemble de données pour faciliter la visualisation du résultat. Voici un simple ensemble de données de porte ET :

# AND gate dataset
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([0, 0, 0, 1])  # Labels for AND gate

---

Étape 4 : Entraîner et tester le Perceptron

Maintenant, entraînons le Perceptron et testons ses prédictions.

# Initialize Perceptron
p = Perceptron(learning_rate=0.1, epochs=10)

# Train the model
p.fit(X, y)

# Test the model
print("Predictions:", p.predict(X))

Sortie attendue pour la porte ET :

import numpy as np

---

Explication du processus d'apprentissage du Perceptron

1. Initialiser les poids et les biais : Au début, les poids sont définis sur zéro, ce qui permet au modèle de commencer à apprendre à partir de zéro.
2. Calculer la sortie linéaire : Pour chaque point de données, le Perceptron calcule la somme pondérée des entrées plus le biais.
3. Activation (Fonction Étape) : Si la sortie linéaire est supérieure ou égale à zéro, elle attribue la classe 1 ; sinon, il attribue la classe 0.
4. Mettre à jour la règle : si la prédiction est incorrecte, le modèle ajuste les pondérations et les biais dans le sens qui réduit l'erreur. La règle de mise à jour est donnée par : poids = learning_rate * (y_true - y_pred) * x

Cela permet à Perceptron de se mettre à jour uniquement pour les points mal classés, rapprochant progressivement le modèle de la limite de décision correcte.

---

Visualiser les limites de décision

Visualisez la limite de décision après la formation. Ceci est particulièrement utile si vous travaillez avec des ensembles de données plus complexes. Pour l’instant, nous allons garder les choses simples avec la porte ET.

---

Extension aux perceptrons multicouches (MLP)

Bien que le Perceptron soit limité à des problèmes linéairement séparables, il constitue le fondement de réseaux neuronaux plus complexes comme les perceptrons multicouches (MLP). Avec les MLP, nous ajoutons des couches cachées et des fonctions d'activation (comme ReLU ou Sigmoid) pour résoudre des problèmes non linéaires.

---

Résumé

Le Perceptron est un algorithme d'apprentissage automatique simple mais fondamental. En comprenant son fonctionnement et en le mettant en œuvre à partir de zéro, nous obtenons un aperçu des bases de l'apprentissage automatique et des réseaux de neurones. La beauté du Perceptron réside dans sa simplicité, ce qui en fait un point de départ idéal pour toute personne intéressée par l'IA.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!