import numpy as np

class DeepNeuralNetwork:
    """
    Deep Neural Network — any number of layers!
    Example: DeepNeuralNetwork([784, 128, 64, 10])
             → 784 input, 128 hidden, 64 hidden, 10 output
    """
    def __init__(self, layer_sizes):
        self.L = len(layer_sizes) - 1  # number of layers (excl. input)
        self.sizes = layer_sizes
        self.params = {}

        # Initialize weights (He initialization for ReLU)
        for l in range(1, self.L + 1):
            self.params[f'W{l}'] = np.random.randn(
                layer_sizes[l-1], layer_sizes[l]
            ) * np.sqrt(2.0 / layer_sizes[l-1])
            self.params[f'b{l}'] = np.zeros((1, layer_sizes[l]))

    def relu(self, z):
        return np.maximum(0, z)

    def relu_deriv(self, z):
        return (z > 0).astype(float)

    def softmax(self, z):
        """Numerically stable softmax"""
        exp_z = np.exp(z - np.max(z, axis=1, keepdims=True))
        return exp_z / np.sum(exp_z, axis=1, keepdims=True)

    def forward(self, X):
        """Forward pass through ALL layers"""
        self.cache = {'a0': X}

        for l in range(1, self.L + 1):
            z = self.cache[f'a{l-1}'] @ self.params[f'W{l}'] + self.params[f'b{l}']
            self.cache[f'z{l}'] = z

            if l == self.L:
                # Last layer: softmax (multi-class)
                self.cache[f'a{l}'] = self.softmax(z)
            else:
                # Hidden layers: ReLU
                self.cache[f'a{l}'] = self.relu(z)

        return self.cache[f'a{self.L}']

    def backward(self, y_onehot, lr=0.01):
        """Backprop through ALL layers"""
        m = y_onehot.shape[0]

        # Output layer: softmax + cross-entropy shortcut
        dz = self.cache[f'a{self.L}'] - y_onehot  # elegant!

        for l in range(self.L, 0, -1):
            dW = (1/m) * self.cache[f'a{l-1}'].T @ dz
            db = (1/m) * np.sum(dz, axis=0, keepdims=True)

            if l > 1:
                da = dz @ self.params[f'W{l}'].T
                dz = da * self.relu_deriv(self.cache[f'z{l-1}'])

            # Update
            self.params[f'W{l}'] -= lr * dW
            self.params[f'b{l}'] -= lr * db

    def predict(self, X):
        probs = self.forward(X)
        return np.argmax(probs, axis=1)

    def accuracy(self, X, y):
        return np.mean(self.predict(X) == y) * 100

import numpy as np

# ===========================
# Softmax — turns scores into probabilities
# ===========================
def softmax(z):
    exp_z = np.exp(z - np.max(z, axis=1, keepdims=True))
    return exp_z / np.sum(exp_z, axis=1, keepdims=True)

# Example: raw scores from output layer
scores = np.array([[2.0, 1.0, 0.1]])  # 3 classes
probs = softmax(scores)
print(probs)
# [[0.659, 0.242, 0.099]] ← probabilities! Sum = 1.0
print(f"Predicted class: {np.argmax(probs)}")  # 0

# ===========================
# Cross-Entropy Loss
# Better than MSE for classification!
# ===========================
def cross_entropy_loss(y_pred, y_true_onehot):
    """
    y_pred: softmax output (probabilities)
    y_true_onehot: one-hot encoded labels
    """
    m = y_pred.shape[0]
    # Clip to avoid log(0)
    y_pred = np.clip(y_pred, 1e-12, 1 - 1e-12)
    loss = -np.sum(y_true_onehot * np.log(y_pred)) / m
    return loss

# Example
y_true = np.array([[1, 0, 0]])  # true: class 0
y_pred = np.array([[0.7, 0.2, 0.1]])  # predicted probs
print(f"Loss: {cross_entropy_loss(y_pred, y_true):.4f}")  # 0.3567

# ===========================
# One-Hot Encoding helper
# ===========================
def one_hot(labels, num_classes):
    """Convert [0, 2, 1] → [[1,0,0], [0,0,1], [0,1,0]]"""
    m = labels.shape[0]
    encoded = np.zeros((m, num_classes))
    encoded[np.arange(m), labels] = 1
    return encoded

print(one_hot(np.array([0, 2, 1]), 3))
# [[1. 0. 0.]   ← class 0
#  [0. 0. 1.]   ← class 2
#  [0. 1. 0.]]  ← class 1

import numpy as np

# ===========================
# 1. Min-Max Normalization → scale to [0, 1]
# ===========================
def normalize(X):
    X_min = X.min(axis=0)
    X_max = X.max(axis=0)
    return (X - X_min) / (X_max - X_min + 1e-8)

# ===========================
# 2. Z-Score Standardization → mean=0, std=1
# ===========================
def standardize(X):
    mean = X.mean(axis=0)
    std = X.std(axis=0)
    return (X - mean) / (std + 1e-8)

# ===========================
# 3. Train/Test Split
# ===========================
def train_test_split(X, y, test_ratio=0.2, seed=42):
    np.random.seed(seed)
    indices = np.random.permutation(len(X))
    split = int(len(X) * (1 - test_ratio))
    train_idx, test_idx = indices[:split], indices[split:]
    return X[train_idx], X[test_idx], y[train_idx], y[test_idx]

# Example
data = np.array([[150, 0.5], [200, 0.8], [100, 0.2]])
print("Before:", data[0])         # [150, 0.5]
print("After: ", normalize(data)[0]) # [0.5, 0.5] ← same scale!

import numpy as np

def create_minibatches(X, y, batch_size=32):
    """Split data into mini-batches"""
    m = X.shape[0]
    indices = np.random.permutation(m)
    X_shuffled = X[indices]
    y_shuffled = y[indices]

    batches = []
    for i in range(0, m, batch_size):
        X_batch = X_shuffled[i:i+batch_size]
        y_batch = y_shuffled[i:i+batch_size]
        batches.append((X_batch, y_batch))
    return batches

# ===========================
# Training with mini-batches
# ===========================
def train_minibatch(model, X, y_onehot, epochs=20, lr=0.1, batch_size=32):
    for epoch in range(epochs):
        batches = create_minibatches(X, y_onehot, batch_size)
        epoch_loss = 0

        for X_batch, y_batch in batches:
            # Forward
            pred = model.forward(X_batch)

            # Loss
            pred_clipped = np.clip(pred, 1e-12, 1-1e-12)
            batch_loss = -np.sum(y_batch * np.log(pred_clipped)) / len(X_batch)
            epoch_loss += batch_loss

            # Backward + Update
            model.backward(y_batch, lr)

        if (epoch+1) % 5 == 0:
            avg_loss = epoch_loss / len(batches)
            print(f"  Epoch {epoch+1:>3} │ Loss: {avg_loss:.4f}")

import numpy as np
from sklearn.datasets import load_iris  # just for loading data

# ===========================
# 1. Load & Prepare Data
# ===========================
iris = load_iris()
X = iris.data.astype(np.float64)     # (150, 4)
y = iris.target                       # (150,) → values: 0, 1, 2

# Normalize
X = (X - X.mean(axis=0)) / (X.std(axis=0) + 1e-8)

# One-hot encode labels
def one_hot(labels, num_classes):
    enc = np.zeros((len(labels), num_classes))
    enc[np.arange(len(labels)), labels] = 1
    return enc

y_oh = one_hot(y, 3)  # (150, 3)

# Train/test split
np.random.seed(42)
idx = np.random.permutation(150)
X_train, X_test = X[idx[:120]], X[idx[120:]]
y_train, y_test = y_oh[idx[:120]], y_oh[idx[120:]]
y_test_labels = y[idx[120:]]

# ===========================
# 2. Create & Train Network
# ===========================
# Architecture: 4 input → 16 hidden → 8 hidden → 3 output
model = DeepNeuralNetwork([4, 16, 8, 3])

print("🌸 Training on Iris dataset...")
for epoch in range(200):
    pred = model.forward(X_train)
    model.backward(y_train, lr=0.1)

    if (epoch+1) % 50 == 0:
        loss = -np.sum(y_train * np.log(np.clip(pred,1e-12,1))) / len(X_train)
        acc = model.accuracy(X_test, y_test_labels)
        print(f"  Epoch {epoch+1:>3} │ Loss: {loss:.4f} │ Test Acc: {acc:.1f}%")

# ===========================
# 3. Final Results
# ===========================
print(f"\n✅ Final Test Accuracy: {model.accuracy(X_test, y_test_labels):.1f}%")
# Output: ✅ Final Test Accuracy: 96.7%+ 🎉

import numpy as np
from sklearn.datasets import fetch_openml

# =====================================================
# 1. LOAD MNIST DATA
# =====================================================
print("📥 Loading MNIST dataset...")
mnist = fetch_openml('mnist_784', version=1, as_frame=False)
X, y = mnist.data.astype(np.float64), mnist.target.astype(int)

# Normalize pixels: [0, 255] → [0, 1]
X = X / 255.0

# Split: 60k train, 10k test
X_train, X_test = X[:60000], X[60000:]
y_train, y_test = y[:60000], y[60000:]

# One-hot encode
def one_hot(labels, nc):
    enc = np.zeros((len(labels), nc))
    enc[np.arange(len(labels)), labels] = 1
    return enc

y_train_oh = one_hot(y_train, 10)

print(f"Train: {X_train.shape}, Test: {X_test.shape}")
# Train: (60000, 784), Test: (10000, 784)

# =====================================================
# 2. CREATE DEEP NETWORK
# Architecture: 784 → 128 → 64 → 10
# =====================================================
model = DeepNeuralNetwork([784, 128, 64, 10])
print("🧠 Network: [784] → [128] → [64] → [10]")

# =====================================================
# 3. TRAIN WITH MINI-BATCHES
# =====================================================
epochs = 20
batch_size = 64
lr = 0.1

print(f"\n🔥 Training for {epochs} epochs (batch={batch_size}, lr={lr})")
print("─" * 50)

for epoch in range(epochs):
    # Shuffle
    idx = np.random.permutation(60000)
    X_shuf = X_train[idx]
    y_shuf = y_train_oh[idx]

    # Mini-batch loop
    for i in range(0, 60000, batch_size):
        Xb = X_shuf[i:i+batch_size]
        yb = y_shuf[i:i+batch_size]
        model.forward(Xb)
        model.backward(yb, lr)

    # Evaluate every 5 epochs
    if (epoch+1) % 5 == 0:
        train_acc = model.accuracy(X_train[:5000], y_train[:5000])
        test_acc = model.accuracy(X_test, y_test)
        print(f"  Epoch {epoch+1:>2} │ Train: {train_acc:.1f}% │ Test: {test_acc:.1f}%")

# =====================================================
# 4. FINAL RESULTS
# =====================================================
final_acc = model.accuracy(X_test, y_test)
print(f"\n🎯 Final Test Accuracy: {final_acc:.1f}%")
# Output: 🎯 Final Test Accuracy: 97.2%+ 🎉

# =====================================================
# 5. DEMO: Predict single digit
# =====================================================
sample_idx = 42
pred = model.predict(X_test[sample_idx:sample_idx+1])
print(f"\nSample #{sample_idx}: Predicted={pred[0]}, Actual={y_test[sample_idx]}")