History and Evolution of Artificial Intelligence

# Simple ELIZA-style chatbot (1966 approach)
# Uses pattern matching - no actual "understanding"

import re

def eliza_response(user_input):
    """Simulate ELIZA's pattern matching approach"""
    user_input = user_input.lower().strip()
    
    # Pattern-response pairs (like 1966 ELIZA)
    patterns = [
        (r"i am (.*)", "Why do you say you are {0}?"),
        (r"i feel (.*)", "Tell me more about feeling {0}."),
        (r"my (.*) is (.*)", "Why do you think your {0} is {1}?"),
        (r"i think (.*)", "Why do you think {0}?"),
        (r"because (.*)", "Is that the real reason?"),
        (r"(.*) sorry (.*)", "Please don't apologize."),
        (r"hello|hi|hey", "Hello! How are you feeling today?"),
        (r"(.*)", "Can you elaborate on that?"),  # Default
    ]
    
    for pattern, response in patterns:
        match = re.match(pattern, user_input)
        if match:
            # Fill in captured groups
            return response.format(*match.groups())
    
    return "Please go on."

# Example conversation
print("ELIZA: Hello! I'm a simple therapist bot.")
print("ELIZA:", eliza_response("I am feeling sad"))
print("ELIZA:", eliza_response("because my job is stressful"))
print("ELIZA:", eliza_response("I think nobody understands me"))

# Simple Expert System (1980s approach)
# Uses IF-THEN rules - no learning capability

class MedicalExpertSystem:
    """Simple diagnostic expert system like MYCIN"""
    
    def __init__(self):
        # Knowledge base: rules encoded by human experts
        self.rules = [
            {
                "conditions": {"fever": True, "cough": True, "fatigue": True},
                "diagnosis": "Possible flu",
                "confidence": 0.8
            },
            {
                "conditions": {"fever": True, "rash": True},
                "diagnosis": "Possible allergic reaction",
                "confidence": 0.7
            },
            {
                "conditions": {"headache": True, "stiff_neck": True, "fever": True},
                "diagnosis": "Seek immediate medical attention",
                "confidence": 0.9
            },
            {
                "conditions": {"cough": True, "runny_nose": True},
                "diagnosis": "Possible common cold",
                "confidence": 0.75
            }
        ]
    
    def diagnose(self, symptoms):
        """Apply rules to symptoms (forward chaining)"""
        matches = []
        
        for rule in self.rules:
            # Check if all conditions are met
            if all(symptoms.get(cond, False) == val 
                   for cond, val in rule["conditions"].items()):
                matches.append({
                    "diagnosis": rule["diagnosis"],
                    "confidence": rule["confidence"]
                })
        
        return sorted(matches, key=lambda x: -x["confidence"])

# Example usage
expert = MedicalExpertSystem()
patient_symptoms = {
    "fever": True,
    "cough": True,
    "fatigue": True,
    "runny_nose": False
}

results = expert.diagnose(patient_symptoms)
print("Expert System Diagnosis:")
for r in results:
    print(f"  {r['diagnosis']} (confidence: {r['confidence']:.0%})")

# The Perceptron - First trainable neural network (1958)
# Frank Rosenblatt's invention that sparked neural network research

import numpy as np

class Perceptron:
    """Simple perceptron classifier - learns from data!"""
    
    def __init__(self, learning_rate=0.1, n_iterations=100):
        self.lr = learning_rate
        self.n_iter = n_iterations
        self.weights = None
        self.bias = None
    
    def fit(self, X, y):
        """Train perceptron on examples"""
        n_samples, n_features = X.shape
        self.weights = np.zeros(n_features)
        self.bias = 0
        
        # Learning: adjust weights based on errors
        for _ in range(self.n_iter):
            for xi, yi in zip(X, y):
                prediction = self.predict_single(xi)
                # Perceptron learning rule
                update = self.lr * (yi - prediction)
                self.weights += update * xi
                self.bias += update
    
    def predict_single(self, x):
        """Activation: step function"""
        linear_output = np.dot(x, self.weights) + self.bias
        return 1 if linear_output >= 0 else 0
    
    def predict(self, X):
        return np.array([self.predict_single(x) for x in X])

# Example: Learning logical AND
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([0, 0, 0, 1])  # AND truth table

perceptron = Perceptron()
perceptron.fit(X, y)

print("Perceptron learned AND gate:")
for xi, yi in zip(X, y):
    pred = perceptron.predict_single(xi)
    print(f"  {xi} → {pred} (expected: {yi})")

# Modern Machine Learning (2012+ approach)
# Let the model learn patterns from data

from sklearn.neural_network import MLPClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Load real data (not hand-crafted rules!)
iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(
    iris.data, iris.target, test_size=0.2, random_state=42
)

# Modern neural network - learns from examples
model = MLPClassifier(
    hidden_layer_sizes=(10, 10),  # 2 hidden layers
    activation='relu',            # Modern activation
    max_iter=1000,
    random_state=42
)

# Train: model discovers patterns automatically
model.fit(X_train, y_train)

# Evaluate
predictions = model.predict(X_test)
accuracy = accuracy_score(y_test, predictions)

print(f"Modern ML Accuracy: {accuracy:.1%}")
print(f"Learned from {len(X_train)} examples")
print("No hand-crafted rules needed!")

# AI Evolution: From Rules to Learning
# Comparing different eras of AI

def classify_email_1980s(email_text):
    """1980s Expert System approach: Hand-coded rules"""
    spam_keywords = ["free", "winner", "click here", "limited time"]
    
    for keyword in spam_keywords:
        if keyword in email_text.lower():
            return "SPAM (rule-based)"
    return "NOT SPAM (rule-based)"

def classify_email_2020s(email_text, model):
    """2020s ML approach: Learned patterns"""
    # Model was trained on millions of examples
    # It discovered patterns humans never coded
    prediction = model.predict([email_text])[0]
    return "SPAM (ML)" if prediction == 1 else "NOT SPAM (ML)"

# Example
test_email = "Congratulations! You've been selected for a prize!"

print("1980s approach:", classify_email_1980s(test_email))
# Would need: model trained on labeled spam data
# print("2020s approach:", classify_email_2020s(test_email, trained_model))

print("\nKey difference:")
print("  1980s: Engineers write rules based on intuition")
print("  2020s: Algorithms discover rules from data")