History, Evolution &
AI Revolution

The story of artificial intelligence is not a straight line — it is a dramatic tale of soaring ambitions, crushing disappointments, quiet perseverance, and explosive breakthroughs. To understand where AI is today, and where it is going, we must understand where it has been.

This chapter takes you on a journey spanning nearly two centuries, from Charles Babbage's mechanical calculating engine in the 1830s to the large language models that can write poetry, code, and scientific papers in 2024. Along the way, you will meet the brilliant minds who dared to ask: "Can machines think?"

You will learn that AI's path was far from smooth. It suffered through two devastating "AI Winters" — periods when funding dried up, researchers left the field, and skeptics declared intelligent machines a fantasy. Yet each time, AI came back stronger, fueled by new ideas, better hardware, and bigger data.

We will also explore how different nations have approached AI development. While Silicon Valley and China often dominate headlines, India's AI story — from early IIT research labs to the ₹10,000 crore IndiaAI Mission — is one of the most exciting emerging narratives in global AI.

The dream of creating intelligent machines is ancient. Greek mythology speaks of Talos, a bronze automaton that guarded the island of Crete. The medieval Arabic polymath Al-Jazari (1136–1206) built programmable automata including a boat with four mechanical musicians. In 1770, Wolfgang von Kempelen constructed "The Turk," a chess-playing automaton that amazed European courts (though it was later revealed to hide a human chess master inside).

These early efforts, while not truly "intelligent," reveal a persistent human desire to create thinking machines — a desire that would crystallize into a scientific discipline only in the 20th century.

Charles Babbage & Ada Lovelace (1837–1843)

Charles Babbage (1791–1871) is often called the "Father of the Computer." In 1837, he designed the Analytical Engine — a mechanical general-purpose computer that could be programmed using punched cards. Though never fully built in his lifetime, the Analytical Engine contained all the essential elements of a modern computer: an arithmetic logic unit (the "mill"), memory (the "store"), input/output mechanisms, and conditional branching.

Ada Lovelace (1815–1852), daughter of the poet Lord Byron, wrote what is widely considered the first computer program — a set of instructions for the Analytical Engine to compute Bernoulli numbers. More remarkably, Lovelace foresaw that machines could go beyond mere calculation:

"The Analytical Engine weaves algebraic patterns just as the Jacquard loom weaves flowers and leaves." — Ada Lovelace, Notes on the Analytical Engine, 1843

George Boole & Boolean Logic (1854)

George Boole published "An Investigation of the Laws of Thought" in 1854, formalizing logic into algebra. Boolean algebra — with its AND, OR, NOT operations — would become the mathematical foundation of all digital computing and, by extension, artificial intelligence. Every modern CPU executes billions of Boolean operations per second.

Alan Turing & the Turing Machine (1936)

Alan Turing (1912–1954) is arguably the most important figure in the history of computing and AI. In his 1936 paper "On Computable Numbers," Turing described a theoretical machine — the Turing Machine — that could compute anything that is computable, given enough time and memory. This concept established the fundamental limits and possibilities of computation.

In 1950, Turing published the landmark paper "Computing Machinery and Intelligence" in the journal Mind, asking the question: "Can machines think?" He proposed the Turing Test (originally called the "Imitation Game"): if a human judge cannot reliably distinguish a machine's responses from a human's in a text-based conversation, the machine can be said to exhibit intelligent behavior.

Claude Shannon & Information Theory (1948)

Claude Shannon (1916–2001), in his 1948 paper "A Mathematical Theory of Communication," founded information theory. He defined the concept of entropy as a measure of information content and uncertainty — a concept that became foundational to machine learning (used in decision trees, cross-entropy loss, etc.).

Shannon also wrote a 1950 paper on programming a computer to play chess, making him a pioneer in both information theory and AI.

McCulloch-Pitts Neuron (1943)

Before AI had a name, Warren McCulloch (neurophysiologist) and Walter Pitts (logician) published "A Logical Calculus of Ideas Immanent in Nervous Activity" in 1943. They proposed a simplified mathematical model of a biological neuron — the McCulloch-Pitts (MCP) neuron.

The MCP neuron takes binary inputs (0 or 1), applies weights, sums them, and produces a binary output based on a threshold. This model showed that networks of simple logical units could, in principle, compute any logical function — a foundational insight for neural networks.

    x₁ ──[w₁]──┐
                │
    x₂ ──[w₂]──┤──► Σ (weighted sum) ──► θ (threshold) ──► y (output)
                │
    x₃ ──[w₃]──┘

    If  Σ(wᵢ·xᵢ) ≥ θ  →  y = 1
    If  Σ(wᵢ·xᵢ) < θ  →  y = 0
    

Hebb's Learning Rule (1949)

Donald Hebb proposed in "The Organization of Behavior" that when two neurons fire together repeatedly, the connection between them strengthens. This "Hebbian learning" rule — often paraphrased as "neurons that fire together, wire together" — became the basis for neural network learning algorithms.

The Dartmouth Conference (Summer 1956)

The field of Artificial Intelligence was officially born at the Dartmouth Summer Research Project on Artificial Intelligence, a workshop held at Dartmouth College, New Hampshire, in the summer of 1956. The proposal was written by:

• John McCarthy (Dartmouth) — coined the term "Artificial Intelligence"
• Marvin Minsky (Harvard/MIT) — pioneer of neural networks and AI theory
• Nathaniel Rochester (IBM) — designer of the IBM 701
• Claude Shannon (Bell Labs) — father of information theory

The proposal stated their ambitious hypothesis: "Every aspect of learning or any other feature of intelligence can in principle be so precisely described that a machine can be made to simulate it."

Frank Rosenblatt's Perceptron (1958)

Frank Rosenblatt at Cornell built the Mark I Perceptron — the first machine that could "learn" from data. Unlike the McCulloch-Pitts neuron (which had fixed weights), the Perceptron could automatically adjust its weights using a learning algorithm. The New York Times wrote in 1958 that the Navy had built a computer that "will be able to walk, talk, see, write, reproduce itself, and be conscious of its existence."

The decade following Dartmouth was a period of extraordinary optimism. Researchers built systems that seemed to demonstrate genuine intelligence, and bold predictions flew freely.

By the early 1970s, the initial excitement had given way to deep disappointment. AI systems had failed to scale beyond toy problems, and critics were becoming vocal.

The Lighthill Report (1973)

Sir James Lighthill, a distinguished British mathematician, was commissioned by the UK Science Research Council to evaluate AI research. His 1973 report was devastating: he concluded that AI had failed to achieve its "grandiose objectives" and that most AI research had produced nothing of value. The report led to the near-total collapse of AI funding in the UK.

Minsky & Papert's "Perceptrons" (1969)

Marvin Minsky and Seymour Papert published "Perceptrons" in 1969, mathematically proving that single-layer perceptrons cannot solve the XOR problem — they can only learn linearly separable functions. While they acknowledged that multi-layer networks might overcome this limitation, their book was widely interpreted as proving that neural networks were fundamentally limited. Funding for neural network research dried up for over a decade.

         x₂
          │
     1  ──●──────────●──  (0,1)=1    (1,1)=0
          │          │
          │  Cannot draw a single
          │  straight line to separate
          │  0s from 1s!
          │          │
     0  ──●──────────●──  (0,0)=0    (1,0)=1
          │          │
          0          1         x₁

    XOR Truth Table:
    ┌────┬────┬─────────┐
    │ x₁ │ x₂ │ x₁ ⊕ x₂│
    ├────┼────┼─────────┤
    │  0 │  0 │    0    │
    │  0 │  1 │    1    │
    │  1 │  0 │    1    │
    │  1 │  1 │    0    │
    └────┴────┴─────────┘
    

Causes of the First AI Winter

• Overpromising: Researchers made grand predictions that failed to materialize
• Combinatorial explosion: AI methods couldn't scale — search spaces grew exponentially
• Limited computing power: 1970s computers had kilobytes of memory, not gigabytes
• Lack of data: No internet, no large datasets to train systems on
• Narrow successes, broad claims: Toy demos were presented as general solutions

AI's first comeback was driven not by neural networks but by rule-based expert systems — programs that encoded human expert knowledge as IF-THEN rules.

The Japanese Fifth Generation Project (1982)

Japan's Ministry of International Trade and Industry (MITI) launched the Fifth Generation Computer Systems (FGCS) project in 1982 with a budget of ¥57 billion (~$850 million). The goal was to build computers that could perform logic-based reasoning, natural language processing, and knowledge management. This triggered a global AI arms race — the US launched the Strategic Computing Initiative, and the UK funded the Alvey Programme.

The expert systems bubble burst in the late 1980s, leading to the second — and more severe — AI Winter.

Why Expert Systems Failed

• Knowledge Bottleneck: Extracting rules from human experts was slow, expensive, and error-prone. A large expert system needed thousands of rules, each hand-crafted.
• Brittleness: Expert systems couldn't handle situations outside their rule set. They had no common sense, no ability to learn, and no graceful degradation.
• Maintenance Nightmare: As rules accumulated, they became contradictory and impossible to maintain. R1/XCON grew to 17,500 rules and became nearly unmaintainable.
• LISP Machine Collapse: Specialized LISP machines (from Symbolics, LMI, TI) became obsolete as general-purpose workstations from Sun and DEC surpassed them at lower cost.
• Japanese Fifth Generation Failure: The FGCS project was officially wound down in 1992, having failed to achieve most of its goals.

While the label "AI" was toxic, researchers rebranded their work as "machine learning," "data mining," "pattern recognition," and "computational intelligence." This quiet period produced many of the algorithms still in use today.

Backpropagation Rediscovery (1986)

David Rumelhart, Geoffrey Hinton, and Ronald Williams published the definitive paper on backpropagation in 1986, showing that multi-layer neural networks could be trained using gradient descent. This solved the XOR problem that had killed neural networks in 1969. Though backprop had been discovered earlier (by Paul Werbos in 1974), the 1986 paper made it practical and widely known.

Support Vector Machines (1995)

Vladimir Vapnik and colleagues developed Support Vector Machines (SVMs) with strong theoretical foundations in statistical learning theory. SVMs could find optimal decision boundaries and handle non-linear classification using the "kernel trick." For over a decade, SVMs were the dominant ML algorithm.

Random Forests (2001)

Leo Breiman introduced Random Forests — ensemble methods that build many decision trees and aggregate their predictions. Random Forests are robust, require minimal tuning, and handle both classification and regression. They remain among the most popular algorithms for structured/tabular data.

Key Milestones of the Renaissance

AlexNet & ImageNet 2012: The Big Bang

In October 2012, Alex Krizhevsky, Ilya Sutskever, and Geoffrey Hinton from the University of Toronto entered the ImageNet Large Scale Visual Recognition Challenge (ILSVRC) with a deep convolutional neural network called AlexNet. AlexNet achieved a top-5 error rate of 15.3%, compared to the runner-up's 26.2% — a staggering improvement of nearly 11 percentage points.

This wasn't just an incremental improvement; it was a paradigm shift. AlexNet used several key innovations:

• GPU Training: Used two NVIDIA GTX 580 GPUs (3GB each) for parallel training
• ReLU Activation: Replaced sigmoid/tanh with ReLU, solving vanishing gradients
• Dropout: Regularization technique to prevent overfitting
• Data Augmentation: Image flipping, cropping, and color jittering
• 5 convolutional + 3 fully connected layers — 60 million parameters

By 2015, deep learning surpassed human-level performance on ImageNet image classification. This was a watershed moment — machines could now "see" better than humans, at least on standardized benchmarks.

Other Key Deep Learning Milestones

Attention Is All You Need (2017)

In June 2017, Vaswani et al. at Google Brain published "Attention Is All You Need," introducing the Transformer architecture. Unlike RNNs that process sequences step-by-step, Transformers use self-attention to process all positions in parallel, enabling massively faster training. The Transformer is the architecture behind BERT, GPT, T5, PaLM, and virtually every modern language model.

                         ┌─────────────────┐
                         │   Output Probs   │
                         │  (Softmax Layer)  │
                         └────────┬──────────┘
                                  │
                         ┌────────▼──────────┐
                         │  Feed-Forward Net  │
                         │   (FFN Layer)      │
                         └────────┬──────────┘
                                  │
                         ┌────────▼──────────┐
                         │  Multi-Head        │
                         │  Self-Attention    │
                         │  Q·K^T / √d_k     │
                         └────────┬──────────┘
                                  │
                         ┌────────▼──────────┐
                         │  Positional        │
                         │  Encoding + Embed  │
                         └────────┬──────────┘
                                  │
                         ┌────────▼──────────┐
                         │   Input Tokens     │
                         │  "The cat sat..."  │
                         └────────────────────┘
    

The GPT Journey: From GPT-1 to GPT-4o

Other Modern Milestones

• BERT (2018): Google's bidirectional transformer, revolutionized search and NLP benchmarks
• AlphaFold (2020): DeepMind solved the 50-year protein folding problem, predicting 3D structures of 200M+ proteins
• DALL-E & Stable Diffusion (2021-22): AI generates photorealistic images from text descriptions
• GitHub Copilot (2021): AI pair programmer trained on billions of lines of code
• Gemini (2023-24): Google's multimodal model family, competing with GPT-4
• Sora (2024): OpenAI's video generation model, creating minute-long photorealistic videos from text

AI's history is deeply intertwined with mathematics. Here are the key mathematical frameworks that emerged at each historical stage:

1. Boolean Algebra (1854) — The Logic of Machines

2. Information Entropy (1948) — Measuring Knowledge

3. Perceptron Convergence (1962)

4. Backpropagation — The Chain Rule Applied (1986)

5. Self-Attention (2017)

Derivation 1: Perceptron Learning Rule

Goal: Find weights w such that the perceptron correctly classifies all training examples.

Step 1: Define the perceptron output:

Step 2: Define the error — a misclassification occurs when y ≠ ŷ. For a misclassified point, y·(w·x + b) < 0.

Step 3: Define the loss function (sum over misclassified points M):

Step 4: Compute gradients:

Step 5: Update rule (stochastic — one misclassified point at a time):

Derivation 2: Shannon Entropy from Maximum Uncertainty Principle

Goal: Find the unique function H(p₁, p₂, ..., pₙ) that measures uncertainty and satisfies three axioms.

Axiom 1: H is continuous in pᵢ.

Axiom 2: For uniform distribution (all pᵢ = 1/n), H increases with n (more outcomes = more uncertainty).

Axiom 3: H is additive for independent events: H(X,Y) = H(X) + H(Y).

Result: Shannon proved (1948) that the ONLY function satisfying all three axioms is:

Derivation 3: Softmax Attention Scaling Factor √d_k

Why divide by √d_k?

Step 1: Assume Q and K have components drawn independently from N(0, 1).

Step 2: The dot product q·k = Σ_i=1^d_k q_i·k_i. Each q_i·k_i has mean 0 and variance 1.

Step 3: By independence, Var(q·k) = d_k·1 = d_k.

Step 4: So q·k has standard deviation √d_k. For large d_k (e.g., 512), dot products can be very large.

Step 5: Large values push softmax into regions with tiny gradients (saturation). Dividing by √d_k normalizes the variance back to 1, keeping gradients healthy.

Example 1: Shannon Entropy Calculation

Example 2: Perceptron Learning — Step by Step

Example 3: Attention Score Computation

1. AI History Timeline Visualization

import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
import numpy as np

# ─── AI History Timeline Data ─────────────────────────────
events = [
    (1843, "Ada Lovelace\nFirst Program", "#8b5cf6"),
    (1936, "Turing Machine", "#8b5cf6"),
    (1943, "McCulloch-Pitts\nNeuron", "#3b82f6"),
    (1950, "Turing Test", "#3b82f6"),
    (1956, "Dartmouth\nConference", "#059669"),
    (1958, "Perceptron", "#059669"),
    (1966, "ELIZA\nChatbot", "#059669"),
    (1969, "Perceptrons\n(Minsky)", "#f43f5e"),
    (1973, "Lighthill\nReport", "#f43f5e"),
    (1980, "MYCIN/XCON\nExpert Systems", "#f59e0b"),
    (1986, "Backprop\n(Hinton)", "#059669"),
    (1997, "Deep Blue\nBeats Kasparov", "#3b82f6"),
    (2012, "AlexNet\nImageNet", "#059669"),
    (2016, "AlphaGo\nBeats Lee Sedol", "#059669"),
    (2017, "Transformer\nArchitecture", "#0891b2"),
    (2022, "ChatGPT\nLaunched", "#0891b2"),
    (2024, "GPT-4o\nMultimodal", "#0891b2"),
]

# ─── AI Winters ────────────────────────────────────────────
winters = [
    (1974, 1980, "1st AI Winter"),
    (1987, 1993, "2nd AI Winter"),
]

fig, ax = plt.subplots(figsize=(18, 8))
fig.patch.set_facecolor('#0f172a')
ax.set_facecolor('#0f172a')

# Draw AI Winter bands
for start, end, label in winters:
    ax.axvspan(start, end, alpha=0.15, color='#f43f5e', zorder=0)
    ax.text((start + end) / 2, 1.05, label,
            ha='center', fontsize=9, color='#f43f5e',
            fontweight='bold', transform=ax.get_xaxis_transform())

# Draw timeline spine
years = [e[0] for e in events]
ax.plot([min(years)-5, max(years)+5], [0, 0],
        color='#334155', linewidth=2, zorder=1)

# Plot events alternating above/below
for i, (year, label, color) in enumerate(events):
    direction = 1 if i % 2 == 0 else -1
    height = direction * (0.3 + (i % 3) * 0.15)

    ax.plot(year, 0, 'o', markersize=10, color=color,
            zorder=3, markeredgecolor='white', markeredgewidth=1.5)
    ax.vlines(year, 0, height, colors=color, linewidth=1.5,
              linestyles='--', alpha=0.6)
    ax.text(year, height + direction * 0.05, label,
            ha='center', va='bottom' if direction > 0 else 'top',
            fontsize=7.5, color='#e2e8f0', fontweight='bold',
            bbox=dict(boxstyle='round,pad=0.3', facecolor='#1e293b',
                      edgecolor=color, alpha=0.9))

ax.set_xlim(1835, 2030)
ax.set_ylim(-1.0, 1.2)
ax.set_xlabel('Year', fontsize=12, color='#94a3b8')
ax.set_title('The Complete History of Artificial Intelligence',
             fontsize=16, fontweight='bold', color='#e2e8f0', pad=20)
ax.tick_params(colors='#94a3b8')
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.spines['left'].set_visible(False)
ax.spines['bottom'].set_color('#334155')
ax.yaxis.set_visible(False)

plt.tight_layout()
plt.savefig('ai_history_timeline.png', dpi=150, bbox_inches='tight',
            facecolor='#0f172a')
plt.show()
print("✅ Timeline saved as ai_history_timeline.png")
    

2. Perceptron Implementation from Scratch

import numpy as np

class Perceptron:
    """
    Rosenblatt's Perceptron (1958) — Implemented from first principles.
    This is the algorithm that started neural network research.
    """

    def __init__(self, learning_rate=0.1, n_epochs=100):
        self.lr = learning_rate
        self.n_epochs = n_epochs
        self.weights = None
        self.bias = None
        self.errors_per_epoch = []

    def step_function(self, x):
        """Heaviside step activation — the original 1958 activation"""
        return np.where(x >= 0, 1, 0)

    def fit(self, X, y):
        n_samples, n_features = X.shape
        self.weights = np.zeros(n_features)
        self.bias = 0
        self.errors_per_epoch = []

        for epoch in range(self.n_epochs):
            errors = 0
            for xi, yi in zip(X, y):
                # Forward pass
                z = np.dot(xi, self.weights) + self.bias
                y_pred = self.step_function(z)

                # Update rule: w += η * (y - ŷ) * x
                error = yi - y_pred
                self.weights += self.lr * error * xi
                self.bias += self.lr * error
                errors += int(error != 0)

            self.errors_per_epoch.append(errors)
            if errors == 0:
                print(f"✅ Converged at epoch {epoch + 1}")
                break

    def predict(self, X):
        z = np.dot(X, self.weights) + self.bias
        return self.step_function(z)

# ─── Train on AND gate ────────────────────────────────────
X = np.array([[0,0], [0,1], [1,0], [1,1]])
y_and = np.array([0, 0, 0, 1])
y_or  = np.array([0, 1, 1, 1])
y_xor = np.array([0, 1, 1, 0])

print("═══ AND Gate ═══")
p_and = Perceptron(learning_rate=0.1, n_epochs=20)
p_and.fit(X, y_and)
print(f"Weights: {p_and.weights}, Bias: {p_and.bias}")
print(f"Predictions: {p_and.predict(X)}")

print("\n═══ OR Gate ═══")
p_or = Perceptron(learning_rate=0.1, n_epochs=20)
p_or.fit(X, y_or)
print(f"Predictions: {p_or.predict(X)}")

print("\n═══ XOR Gate (will FAIL — not linearly separable!) ═══")
p_xor = Perceptron(learning_rate=0.1, n_epochs=20)
p_xor.fit(X, y_xor)
print(f"Predictions: {p_xor.predict(X)} ← Cannot learn XOR!")
    

3. Shannon Entropy Calculator

import numpy as np

def shannon_entropy(probabilities):
    """
    Compute Shannon entropy H(X) = -Σ p(x) * log2(p(x))
    Derived from Shannon's 1948 paper.
    """
    probs = np.array(probabilities, dtype=np.float64)
    assert np.isclose(probs.sum(), 1.0), "Probabilities must sum to 1"
    # Avoid log(0) by filtering zero probabilities
    nonzero = probs[probs > 0]
    return -np.sum(nonzero * np.log2(nonzero))

# ─── Examples ──────────────────────────────────────────────
print("Shannon Entropy Calculator")
print("=" * 40)

# Fair coin
h_coin = shannon_entropy([0.5, 0.5])
print(f"Fair coin:           H = {h_coin:.4f} bits")

# Biased coin
h_biased = shannon_entropy([0.9, 0.1])
print(f"Biased coin (90/10): H = {h_biased:.4f} bits")

# Fair die
h_die = shannon_entropy([1/6]*6)
print(f"Fair 6-sided die:    H = {h_die:.4f} bits")

# Weather example from worked example
h_weather = shannon_entropy([0.40, 0.35, 0.25])
print(f"Weather (40/35/25):  H = {h_weather:.4f} bits")

# Certain event
h_certain = shannon_entropy([1.0, 0.0])
print(f"Certain event:       H = {h_certain:.4f} bits")

# Maximum entropy for n outcomes
for n in [2, 4, 8, 16, 256]:
    h_max = np.log2(n)
    print(f"Max entropy ({n:3d} outcomes): H = {h_max:.4f} bits")
    

Multi-Layer Perceptron Solving XOR (What Minsky Said Was Impossible)

import tensorflow as tf
import numpy as np

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

# ─── Build MLP — solving the problem from Minsky's book ──
model = tf.keras.Sequential([
    tf.keras.layers.Dense(4, activation='relu', input_shape=(2,),
                          name='hidden_layer'),
    tf.keras.layers.Dense(1, activation='sigmoid',
                          name='output_layer')
], name='XOR_Solver_MLP')

model.compile(
    optimizer=tf.keras.optimizers.Adam(learning_rate=0.1),
    loss='binary_crossentropy',
    metrics=['accuracy']
)

print(model.summary())

# ─── Train ────────────────────────────────────────────────
history = model.fit(X, y, epochs=500, verbose=0)

# ─── Results ──────────────────────────────────────────────
predictions = model.predict(X, verbose=0)
print("\n═══ XOR Results ═══")
for i in range(4):
    print(f"Input: {X[i]} → Predicted: {predictions[i][0]:.4f}"
          f" → Rounded: {round(predictions[i][0])}"
          f" (Expected: {int(y[i][0])})")

print(f"\n✅ Minsky's XOR 'impossibility' solved with just 1 hidden layer!")
print(f"Final loss: {history.history['loss'][-1]:.6f}")
    

Comparing Historical ML Algorithms (SVM, Random Forest, Perceptron)

from sklearn.linear_model import Perceptron
from sklearn.svm import SVC
from sklearn.ensemble import RandomForestClassifier
from sklearn.neural_network import MLPClassifier
from sklearn.datasets import make_moons, make_circles
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import numpy as np

# ─── Generate non-linear dataset ─────────────────────────
X, y = make_moons(n_samples=1000, noise=0.2, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# ─── Historical algorithms comparison ─────────────────────
algorithms = {
    "Perceptron (1958)":     Perceptron(max_iter=1000),
    "SVM-Linear (1963)":     SVC(kernel='linear'),
    "SVM-RBF (1995)":        SVC(kernel='rbf', gamma='scale'),
    "Random Forest (2001)":  RandomForestClassifier(
                                 n_estimators=100, random_state=42),
    "MLP (1986/Modern)":     MLPClassifier(
                                 hidden_layer_sizes=(64, 32),
                                 max_iter=1000, random_state=42),
}

print("═══ Historical ML Algorithms — Performance Comparison ═══")
print(f"{'':<25} {'Train Acc':>10} {'Test Acc':>10} {'Year':>6}")
print("─" * 55)

for name, clf in algorithms.items():
    clf.fit(X_train, y_train)
    train_acc = accuracy_score(y_train, clf.predict(X_train))
    test_acc = accuracy_score(y_test, clf.predict(X_test))
    year = name.split("(")[1].rstrip(")")
    print(f"{name:<25} {train_acc:>10.4f} {test_acc:>10.4f} {year:>6}")

print("\n📊 Notice: Perceptron fails on non-linear data (moon shapes).")
print("   SVM-RBF, RF, and MLP handle non-linearity well.")
print("   This explains why AI progressed beyond simple linear models!")
    

AGI Timeline Predictions

AI Regulation Landscape

• EU AI Act (2024): World's first comprehensive AI law. Risk-based classification: unacceptable risk (banned), high risk (regulated), limited risk (transparency required), minimal risk (no regulation).
• US Executive Order (Oct 2023): Requires safety testing for powerful AI models, establishes AI safety standards.
• China AI Regulations: Generative AI regulations (2023), deepfake laws, algorithmic recommendation transparency requirements.
• India's Approach: Currently favoring "innovation-first" with light-touch regulation. Digital India Act (under development) expected to include AI governance provisions.