1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

import numpy as np
import matplotlib.pyplot as plt

class Perceptron:
    def __init__(self, learning_rate=1.0, max_iter=1000):
        self.lr = learning_rate
        self.max_iter = max_iter
        self.w = None
        self.b = None
        
    def fit(self, X, y):
        n_samples, n_features = X.shape
        
        # Initialize weights and bias
        self.w = np.zeros(n_features)
        self.b = 0
        
        for _ in range(self.max_iter):
            misclassified = False
            
            for xi, yi in zip(X, y):
                # Check if point is misclassified
                if yi * (np.dot(self.w, xi) + self.b) <= 0:
                    # Update weights and bias
                    self.w += self.lr * yi * xi
                    self.b += self.lr * yi
                    misclassified = True
            
            # Stop if no misclassifications
            if not misclassified:
                break
                
        return self
    
    def predict(self, X):
        linear_output = np.dot(X, self.w) + self.b
        return np.sign(linear_output)
    
    def score(self, X, y):
        predictions = self.predict(X)
        return np.mean(predictions == y)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# Generate linearly separable data
np.random.seed(42)
X_pos = np.random.randn(20, 2) + np.array([2, 2])
X_neg = np.random.randn(20, 2) + np.array([-2, -2])
X = np.vstack([X_pos, X_neg])
y = np.array([1] * 20 + [-1] * 20)

# Train perceptron
clf = Perceptron()
clf.fit(X, y)

print(f"Weights: {clf.w}")
print(f"Bias: {clf.b}")
print(f"Accuracy: {clf.score(X, y):.2%}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

def plot_decision_boundary(clf, X, y, title="Decision Boundary"):
    plt.figure(figsize=(8, 6))
    
    # Plot data points
    plt.scatter(X[y == 1][:, 0], X[y == 1][:, 1], 
                c='#4CAF50', marker='o', label='Class +1', edgecolors='k')
    plt.scatter(X[y == -1][:, 0], X[y == -1][:, 1], 
                c='#EF5350', marker='x', label='Class -1', s=100)
    
    # Plot decision boundary
    x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    x_line = np.linspace(x_min, x_max, 100)
    
    # Decision boundary: w1*x1 + w2*x2 + b = 0
    # => x2 = -(w1*x1 + b) / w2
    if clf.w[1] != 0:
        y_line = -(clf.w[0] * x_line + clf.b) / clf.w[1]
        plt.plot(x_line, y_line, 'k-', linewidth=2, label='Decision Boundary')
    
    plt.xlabel('$x_1$', fontsize=12)
    plt.ylabel('$x_2$', fontsize=12)
    plt.title(title)
    plt.legend()
    plt.grid(True, alpha=0.3)
    plt.savefig('assets/decision_boundary.png', dpi=150)
    plt.show()

plot_decision_boundary(clf, X, y, "Perceptron Decision Boundary")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# Add some noise to make data non-separable
X_noisy = X.copy()
y_noisy = y.copy()
# Flip some labels
y_noisy[0] = -1
y_noisy[21] = 1

# Train perceptron
clf_noisy = Perceptron(max_iter=100)
clf_noisy.fit(X_noisy, y_noisy)

print(f"Accuracy on noisy data: {clf_noisy.score(X_noisy, y_noisy):.2%}")

plot_decision_boundary(clf_noisy, X_noisy, y_noisy, 
                       "Perceptron on Non-Separable Data")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

from sklearn.linear_model import Perceptron as SkPerceptron
from sklearn.preprocessing import StandardScaler

# Standardize features (recommended for perceptron)
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Train sklearn perceptron
sk_clf = SkPerceptron(max_iter=1000, random_state=42)
sk_clf.fit(X_scaled, y)

print(f"sklearn Perceptron Accuracy: {sk_clf.score(X_scaled, y):.2%}")