Input Layer (x₁, x₂, ..., xₙ)
      ↓ (W¹, b¹)
Hidden Layer 1 → a¹ = σ(W¹x + b¹)
      ↓ (W², b²)
Hidden Layer 2 a² = σ(W²a¹ + b²)
      ...
      ↓ (Wᴸ, bᴸ)
Output Layer ŷ = σ(Wᴸ aᴸ⁻¹ + bᴸ)

import numpy as np
import matplotlib.pyplot as plt

# XOR Dataset
X = np.array([[0,0], [0,1], [1,0], [1,1]])
y = np.array([[0], [1], [1], [0]])

class MLPFromScratch:
    def __init__(self, hidden_size=8, lr=0.1):
        self.lr = lr

        # Initialize weights properly (Xavier)
        self.W1 = np.random.randn(2, hidden_size) * np.sqrt(2/2)
        self.b1 = np.zeros((1, hidden_size))
        self.W2 = np.random.randn(hidden_size, 1) * np.sqrt(2/hidden_size)
        self.b2 = np.zeros((1, 1))

    def relu(self, z): return np.maximum(0, z)
    def relu_prime(self, z): return (z > 0).astype(float)
    def sigmoid(self, z): return 1/(1+np.exp(-z))

    def forward(self, X):
        self.z1 = X @ self.W1 + self.b1
        self.a1 = self.relu(self.z1)
        self.z2 = self.a1 @ self.W2 + self.b2
        self.a2 = self.sigmoid(self.z2)
        return self.a2

    def backward(self, X, y):
        ):
        m = X.shape[0]

        # Output layer
        dz2 = self.a2 - y
        dW2 = self.a1.T @ dz2 / m
        db2 = np.sum(dz2, axis=0, keepdims=True) / m

        # Hidden layer
        da1 = dz2 @ self.W2.T
        dz1 = da1 * self.relu_prime(self.z1)
        dW1 = X.T @ dz1 / m
        db1 = np.sum(dz1, axis=0, keepdims=True) / m

        # Update
        self.W2 -= self.lr * dW2
        self.b2 -= self.lr * db2
        self.W1 -= self.lr * dW1
        self.b1 -= self.lr * db1

    def train(self, X, y, epochs=10000):
        losses = []
        for i in range(epochs):
            pred = self.forward(X)
            loss = -np.mean(y*np.log(pred+1e-8) + (1-y)*np.log(1-pred+1e-8))
            losses.append(loss)
            self.backward(X, y)
            if i % 1000 == 0:
                print(f"Epoch {i}, Loss: {loss:.6f}")
        return losses

# Train
np.random.seed(42)
mlp = MLPFromScratch(hidden_size=10, lr=0.5)
losses = mlp.train(X, y)

print("\nFinal Predictions:")
print(np.round(mlp.forward(X)))

Epoch 0, Loss: 0.693147
Epoch 1000, Loss: 0.004123
...
Final Predictions:
[[0.]
 [1.]
 [1.]
 [0.]]
Perfect!

import torch
import torch.nn as nn
import torch.optim as optim

# Data
X = torch.tensor([[0,0],[0,1],[1,0],[1,1]], dtype=torch.float32)
y = torch.tensor([[0],[1],[1],[0]], dtype=torch.float32)

# Best MLP in 2025
class BestMLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(2, 64),
            nn.GELU(),              # Better than ReLU in 2025
            nn.Linear(64, 32),
            nn.GELU(),
            nn.Linear(32, 1),
            nn.Sigmoid()
        )
        # Proper weight init
        for layer in self.net:
            if isinstance(layer, nn.Linear):
                nn.init.xavier_normal_(layer.weight)

    def forward(self, x):
        return self.net(x)

model = BestMLP()
criterion = nn.BCELoss()
optimizer = optim.AdamW(model.parameters(), lr=0.01, weight_decay=1e-5)

# Training loop
for epoch in range(1000):
    optimizer.zero_grad()
    out = model(X)
    loss = criterion(out, y)
    loss.backward()
    optimizer.step()

    if epoch % 200 == 0:
        print(f"Epoch {epoch}, Loss: {loss.item():.6f}")

print("\nPyTorch Predictions:")
print((model(X) > 0.5).int())