Heim > Artikel > Backend-Entwicklung > Implementierung eines Perzeptrons von Grund auf in Python
Hallo Entwickler,
Das Perzeptron ist eines der einfachsten und grundlegendsten Konzepte des maschinellen Lernens. Es handelt sich um einen binären linearen Klassifikator, der die Grundlage neuronaler Netze bildet. In diesem Beitrag werde ich die Schritte durchgehen, um ein Perceptron von Grund auf in Python zu verstehen und zu implementieren.
Lass uns eintauchen!
Ein Perceptron ist ein grundlegender Algorithmus für das überwachte Lernen binärer Klassifikatoren. Bei gegebenen Eingabemerkmalen lernt das Perceptron Gewichtungen, die dabei helfen, Klassen auf der Grundlage einer einfachen Schwellenwertfunktion zu trennen. So funktioniert es in einfachen Worten:
Mathematisch gesehen sieht es so aus:
f(x) = w1*x1 w2*x2 ... wn*xn b
Wo:
Wenn f(x) größer oder gleich einem Schwellenwert ist, ist die Ausgabe Klasse 1; andernfalls ist es Klasse 0.
Wir werden hier nur NumPy für Matrixoperationen verwenden, um die Dinge übersichtlich zu halten.
import numpy as np
Wir werden das Perceptron als Klasse aufbauen, um alles organisiert zu halten. Der Kurs umfasst Methoden zum Training und zur Vorhersage.
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)
Im Code oben:
Wir verwenden einen kleinen Datensatz, um die Visualisierung der Ausgabe zu erleichtern. Hier ist ein einfacher UND-Gatter-Datensatz:
# 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
Jetzt trainieren wir das Perzeptron und testen seine Vorhersagen.
# 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))
Erwartete Ausgabe für UND-Gatter:
import numpy as np
Dadurch erfolgt die Perceptron-Aktualisierung nur für falsch klassifizierte Punkte, wodurch das Modell schrittweise näher an die korrekte Entscheidungsgrenze herangeführt wird.
Visualisierung der Entscheidungsgrenze nach dem Training. Dies ist besonders hilfreich, wenn Sie mit komplexeren Datensätzen arbeiten. Im Moment halten wir es einfach mit dem UND-Gatter.
Während das Perceptron auf linear trennbare Probleme beschränkt ist, ist es die Grundlage komplexerer neuronaler Netze wie Multi-Layer Perceptrons (MLPs). Mit MLPs fügen wir versteckte Ebenen und Aktivierungsfunktionen (wie ReLU oder Sigmoid) hinzu, um nichtlineare Probleme zu lösen.
Das Perceptron ist ein unkomplizierter, aber grundlegender Algorithmus für maschinelles Lernen. Indem wir die Funktionsweise verstehen und von Grund auf implementieren, erhalten wir Einblicke in die Grundlagen des maschinellen Lernens und neuronaler Netze. Die Schönheit des Perceptron liegt in seiner Einfachheit, was es zu einem perfekten Ausgangspunkt für alle macht, die sich für KI interessieren.
Das obige ist der detaillierte Inhalt vonImplementierung eines Perzeptrons von Grund auf in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!