Perceptron

The Perceptron is one of the earliest and simplest types of artificial neural networks. It was introduced by Frank Rosenblatt in 1958 and is primarily used for binary classification tasks.

A perceptron consists of one or more inputs, a processor (weighted sum), an activation function, and a single output. It learns a linear decision boundary to classify inputs into two distinct classes.

The components of a perceptron include:

• Input features (x₁, x₂, ..., xₙ)
• Weights for each input (w₁, w₂, ..., wₙ)
• Bias term (b)
• Activation function (usually step or sign function)

Visualization of a single-layer perceptron model

Here's a basic implementation of a single-layer perceptron in Python using NumPy:

import numpy as np

# Activation Function
def step_function(x):
    return 1 if x >= 0 else 0

# Perceptron Training
def train_perceptron(X, y, lr=0.1, epochs=10):
    n_samples, n_features = X.shape
    weights = np.zeros(n_features)
    bias = 0

    for _ in range(epochs):
        for idx, x_i in enumerate(X):
            linear_output = np.dot(x_i, weights) + bias
            y_pred = step_function(linear_output)
            error = y[idx] - y_pred
            weights += lr * error * x_i
            bias += lr * error
            
    return weights, bias

# Example Data (AND gate)
X = np.array([[0,0], [0,1], [1,0], [1,1]])
y = np.array([0, 0, 0, 1])

w, b = train_perceptron(X, y)
print("Trained weights:", w)
print("Trained bias:", b)

This perceptron is trained to learn the logic of an AND gate using a step activation function.