Maison > Article > développement back-end > 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 !
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 :
Mathématiquement, cela ressemble à ceci :
f(x) = w1*x1 w2*x2 ... wn*xn b
Où :
Si f(x) est supérieur ou égal à un seuil, la sortie est de classe 1 ; sinon, c'est la classe 0.
Nous utiliserons ici uniquement NumPy pour les opérations matricielles afin de garder les choses légères.
import numpy as np
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 :
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
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
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.
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.
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.
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!