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!

Was ist ein Perzeptron?

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:

1. Eingabe: Ein Vektor von Features (z. B. [x1, x2]).
2. Gewichte: Jede Eingabefunktion hat eine Gewichtung, die das Modell basierend auf der Leistung des Modells anpasst.
3. Aktivierungsfunktion: Berechnet die gewichtete Summe der Eingabemerkmale und wendet einen Schwellenwert an, um zu entscheiden, ob das Ergebnis zu der einen oder anderen Klasse gehört.

Mathematisch gesehen sieht es so aus:

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

Wo:

• f(x) ist die Ausgabe,
• w steht für Gewichte,
• x stellt Eingabefunktionen dar und
• b ist der Bias-Begriff.

Wenn f(x) größer oder gleich einem Schwellenwert ist, ist die Ausgabe Klasse 1; andernfalls ist es Klasse 0.

Schritt 1: Bibliotheken importieren

Wir werden hier nur NumPy für Matrixoperationen verwenden, um die Dinge übersichtlich zu halten.

import numpy as np

Schritt 2: Definieren Sie die Perceptron-Klasse

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:

• fit: Diese Methode trainiert das Modell, indem sie Gewichte und Bias anpasst, wenn ein Punkt falsch klassifiziert wird.
• vorhersagen: Diese Methode berechnet Vorhersagen für neue Daten.
• _step_function: Diese Funktion wendet einen Schwellenwert an, um die Ausgabeklasse zu bestimmen.

Schritt 3: Bereiten Sie einen einfachen Datensatz vor

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

Schritt 4: Trainieren und testen Sie das Perzeptron

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

Erklärung des Perceptron-Lernprozesses

1. Gewichte und Bias initialisieren: Zu Beginn werden die Gewichte auf Null gesetzt, sodass das Modell von Grund auf mit dem Lernen beginnen kann.
2. Lineare Ausgabe berechnen: Für jeden Datenpunkt berechnet das Perceptron die gewichtete Summe der Eingaben plus den Bias.
3. Aktivierung (Schrittfunktion): Wenn die lineare Ausgabe größer oder gleich Null ist, wird Klasse 1 zugewiesen; andernfalls wird Klasse 0 zugewiesen.
4. Aktualisierungsregel: Wenn die Vorhersage falsch ist, passt das Modell Gewichte und Bias in die Richtung an, die den Fehler verringert. Die Aktualisierungsregel ist gegeben durch: Gewichte = learning_rate * (y_true - y_pred) * x

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 von Entscheidungsgrenzen

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.

Erweiterung auf Multi-Layer-Perceptrons (MLPs)

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.

Zusammenfassung

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!