感知机

# 你的大脑在做这样的计算：
价格 = -50      # 太贵了，减分！
款式 = +30      # 很喜欢，加分！
质量 = +40      # 质量很好，加分！
需要程度 = +20  # 确实需要，加分！

总分 = (-50) + 30 + 40 + 20 = 40

# 如果总分 > 0，就买！
# 如果总分 ≤ 0，就不买！

def should_go_out(weather, mood, energy, plans):
    """
    感知机决策：要不要出门？
    """
    # 每个因素的权重（重要程度）
    weather_weight = 0.4    # 天气很重要
    mood_weight = 0.3       # 心情比较重要  
    energy_weight = 0.2     # 精力一般重要
    plans_weight = 0.1      # 计划不太重要
    
    # 偏置项（你本身就喜欢宅在家）
    bias = -0.2
    
    # 加权求和
    total_score = (weather * weather_weight + 
                   mood * mood_weight + 
                   energy * energy_weight + 
                   plans * plans_weight + 
                   bias)
    
    # 激活函数：做最终决定
    if total_score > 0:
        return "出门！"
    else:
        return "宅在家"

# 测试一下
weather = 0.8   # 天气很好 (0-1之间)
mood = 0.6      # 心情不错
energy = 0.4    # 有点累
plans = 0.9     # 有重要计划

decision = should_go_out(weather, mood, energy, plans)
print(f"决定：{decision}")

import numpy as np
import matplotlib.pyplot as plt

# 比如判断一个学生能否通过考试
inputs = {
    '上课出勤率': 0.8,    # x1
    '作业完成度': 0.6,    # x2  
    '复习时间': 0.7,      # x3
    '之前成绩': 0.5       # x4
}

print("考虑的因素：")
for factor, value in inputs.items():
    print(f"  {factor}: {value}")

# 权重表示每个因素有多重要
weights = {
    '上课出勤率': 0.3,    # w1 - 比较重要
    '作业完成度': 0.4,    # w2 - 很重要！
    '复习时间': 0.5,      # w3 - 最重要！
    '之前成绩': 0.2       # w4 - 参考作用
}

print("\n每个因素的重要程度：")
for factor, weight in weights.items():
    importance = "⭐" * int(weight * 10)
    print(f"  {factor}: {importance}")

def step_function(x):
    """
    阶跃函数：最简单的激活函数
    就像开关一样，要么开，要么关
    """
    if x >= 0:
        return 1  # 通过考试
    else:
        return 0  # 不通过考试

def plot_step_function():
    """可视化阶跃函数"""
    x = np.linspace(-2, 2, 100)
    y = [step_function(xi) for xi in x]
    
    plt.figure(figsize=(8, 5))
    plt.plot(x, y, 'b-', linewidth=3, label='阶跃函数')
    plt.axhline(y=0.5, color='r', linestyle='--', alpha=0.7, label='决策边界')
    plt.axvline(x=0, color='r', linestyle='--', alpha=0.7)
    
    plt.xlabel('输入总分')
    plt.ylabel('输出结果')
    plt.title('感知机的激活函数 - 就像开关')
    plt.legend()
    plt.grid(True, alpha=0.3)
    
    # 添加注释
    plt.annotate('不通过', xy=(-1, 0), xytext=(-1.5, 0.2),
                arrowprops=dict(arrowstyle='->', color='red'),
                fontsize=12, color='red')
    plt.annotate('通过', xy=(1, 1), xytext=(1.5, 0.8),
                arrowprops=dict(arrowstyle='->', color='green'),
                fontsize=12, color='green')
    
    plt.show()

plot_step_function()

class SimplePerceptron:
    """简单易懂的感知机实现"""
    
    def __init__(self, input_size, learning_rate=0.1):
        """
        初始化感知机
        input_size: 输入特征的数量
        learning_rate: 学习速度
        """
        # 随机初始化权重（就像婴儿大脑的随机连接）
        self.weights = np.random.random(input_size) * 0.1
        self.bias = 0.0  # 偏置项
        self.learning_rate = learning_rate
        
        print(f"🧠 感知机诞生了！有 {input_size} 个输入")
        print(f"初始权重: {self.weights}")
    
    def predict(self, inputs):
        """
        进行预测（做决定）
        """
        # 第一步：计算加权和
        weighted_sum = np.dot(inputs, self.weights) + self.bias
        
        # 第二步：通过激活函数得出结果
        if weighted_sum >= 0:
            return 1
        else:
            return 0
    
    def train_step(self, inputs, target):
        """
        训练一步（从错误中学习）
        """
        # 先预测
        prediction = self.predict(inputs)
        
        # 计算错误
        error = target - prediction
        
        # 如果预测错了，就调整权重
        if error != 0:
            # 调整权重（这就是学习！）
            self.weights += self.learning_rate * error * inputs
            self.bias += self.learning_rate * error
            
            print(f"😅 预测错了！调整权重...")
            print(f"新权重: {self.weights}")
            return True  # 发生了学习
        else:
            print("✅ 预测正确！")
            return False  # 没有学习

# 创建一个感知机来学习逻辑"与"运算
print("=== 教感知机学会逻辑'与'运算 ===")
perceptron = SimplePerceptron(input_size=2)

# 训练数据：逻辑与的真值表
training_data = [
    ([0, 0], 0),  # 0 AND 0 = 0
    ([0, 1], 0),  # 0 AND 1 = 0  
    ([1, 0], 0),  # 1 AND 0 = 0
    ([1, 1], 1),  # 1 AND 1 = 1
]

print("\n训练数据（逻辑与运算）：")
for inputs, output in training_data:
    print(f"  {inputs[0]} AND {inputs[1]} = {output}")

# 开始训练
print("\n🎓 开始训练...")
max_epochs = 10
for epoch in range(max_epochs):
    print(f"\n--- 第 {epoch + 1} 轮训练 ---")
    learned_something = False
    
    for inputs, target in training_data:
        print(f"\n输入: {inputs}, 期望输出: {target}")
        if perceptron.train_step(inputs, target):
            learned_something = True
    
    # 如果这一轮没有调整权重，说明学会了
    if not learned_something:
        print(f"\n🎉 太棒了！感知机在第 {epoch + 1} 轮就学会了！")
        break

# 测试学习结果
print("\n=== 测试学习结果 ===")
for inputs, expected in training_data:
    prediction = perceptron.predict(inputs)
    result = "✅" if prediction == expected else "❌"
    print(f"{inputs[0]} AND {inputs[1]} = {prediction} {result}")

def demonstrate_xor_limitation():
    """演示感知机不能解决XOR问题"""
    
    print("=== 挑战：让感知机学习'异或'运算 ===")
    
    # XOR（异或）的真值表
    xor_data = [
        ([0, 0], 0),  # 0 XOR 0 = 0
        ([0, 1], 1),  # 0 XOR 1 = 1
        ([1, 0], 1),  # 1 XOR 0 = 1  
        ([1, 1], 0),  # 1 XOR 1 = 0
    ]
    
    print("XOR运算真值表：")
    for inputs, output in xor_data:
        print(f"  {inputs[0]} XOR {inputs[1]} = {output}")
    
    # 可视化XOR问题
    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))
    
    # AND问题（线性可分）
    ax1.scatter([0, 0, 1], [0, 1, 0], c='red', s=100, label='输出=0')
    ax1.scatter([1], [1], c='blue', s=100, label='输出=1')
    ax1.plot([0.5, 0.5], [0, 1], 'g--', linewidth=2, label='决策边界')
    ax1.set_title('AND运算 - 可以用一条直线分开')
    ax1.set_xlabel('输入1')
    ax1.set_ylabel('输入2')
    ax1.legend()
    ax1.grid(True, alpha=0.3)
    
    # XOR问题（线性不可分）
    ax2.scatter([0, 1], [0, 1], c='red', s=100, label='输出=0')
    ax2.scatter([0, 1], [1, 0], c='blue', s=100, label='输出=1')
    ax2.set_title('XOR运算 - 无法用一条直线分开！')
    ax2.set_xlabel('输入1')
    ax2.set_ylabel('输入2')
    ax2.legend()
    ax2.grid(True, alpha=0.3)
    
    # 画几条试图分离的直线
    x = np.linspace(-0.2, 1.2, 100)
    ax2.plot(x, 0.5*np.ones_like(x), 'r--', alpha=0.5, label='尝试1')
    ax2.plot(0.5*np.ones_like(x), x, 'g--', alpha=0.5, label='尝试2')
    ax2.plot(x, x, 'm--', alpha=0.5, label='尝试3')
    
    plt.tight_layout()
    plt.show()
    
    print("\n💡 这就是为什么我们需要多层神经网络！")

demonstrate_xor_limitation()

def visualize_learning_process():
    """可视化感知机的学习过程"""
    
    # 生成简单的二分类数据
    np.random.seed(42)
    
    # 类别1：考试通过的学生
    class1 = np.random.normal([0.7, 0.8], 0.1, (20, 2))
    
    # 类别2：考试不通过的学生  
    class2 = np.random.normal([0.3, 0.2], 0.1, (20, 2))
    
    # 合并数据
    X = np.vstack([class1, class2])
    y = np.hstack([np.ones(20), np.zeros(20)])
    
    # 创建感知机
    perceptron = SimplePerceptron(input_size=2, learning_rate=0.1)
    
    # 记录学习过程
    history = []
    
    plt.figure(figsize=(15, 5))
    
    for epoch in range(3):
        plt.subplot(1, 3, epoch + 1)
        
        # 绘制数据点
        plt.scatter(class1[:, 0], class1[:, 1], c='green', s=50, 
                   alpha=0.7, label='通过考试 ✅')
        plt.scatter(class2[:, 0], class2[:, 1], c='red', s=50, 
                   alpha=0.7, label='不通过考试 ❌')
        
        # 绘制当前的决策边界
        if abs(perceptron.weights[1]) > 1e-6:  # 避免除零
            x_line = np.linspace(0, 1, 100)
            # w1*x1 + w2*x2 + bias = 0
            # x2 = -(w1*x1 + bias) / w2
            y_line = -(perceptron.weights[0] * x_line + perceptron.bias) / perceptron.weights[1]
            
            # 只显示在图形范围内的部分
            mask = (y_line >= 0) & (y_line <= 1)
            plt.plot(x_line[mask], y_line[mask], 'b-', linewidth=2, 
                    label=f'决策边界 (第{epoch+1}轮)')
        
        plt.xlim(0, 1)
        plt.ylim(0, 1)
        plt.xlabel('学习努力程度')
        plt.ylabel('基础能力')
        plt.title(f'第 {epoch + 1} 轮训练后')
        plt.legend()
        plt.grid(True, alpha=0.3)
        
        # 训练一轮
        for i in range(len(X)):
            perceptron.train_step(X[i], y[i])
    
    plt.tight_layout()
    plt.show()
    
    print("📈 可以看到决策边界在不断调整，直到正确分类所有数据点！")

visualize_learning_process()

class SpamDetector:
    """垃圾邮件检测器 - 感知机的实际应用"""
    
    def __init__(self):
        self.perceptron = SimplePerceptron(input_size=5)
        self.feature_names = [
            '包含"免费"', 
            '包含"赚钱"', 
            '全大写字母', 
            '多个感叹号',
            '可疑链接'
        ]
    
    def extract_features(self, email_text):
        """从邮件中提取特征"""
        features = []
        
        # 检查是否包含"免费"
        features.append(1 if '免费' in email_text else 0)
        
        # 检查是否包含"赚钱"
        features.append(1 if '赚钱' in email_text else 0)
        
        # 检查是否有很多大写字母
        uppercase_ratio = sum(1 for c in email_text if c.isupper()) / len(email_text)
        features.append(1 if uppercase_ratio > 0.5 else 0)
        
        # 检查是否有多个感叹号
        features.append(1 if email_text.count('!') > 2 else 0)
        
        # 检查是否有可疑链接
        features.append(1 if 'http://' in email_text and '可疑' in email_text else 0)
        
        return np.array(features)
    
    def train(self, emails, labels):
        """训练垃圾邮件检测器"""
        print("🎓 训练垃圾邮件检测器...")
        
        for epoch in range(5):
            print(f"\n第 {epoch + 1} 轮训练：")
            for email, label in zip(emails, labels):
                features = self.extract_features(email)
                self.perceptron.train_step(features, label)
    
    def predict(self, email_text):
        """预测邮件是否为垃圾邮件"""
        features = self.extract_features(email_text)
        result = self.perceptron.predict(features)
        
        print(f"\n邮件内容: '{email_text}'")
        print("特征分析:")
        for name, value in zip(self.feature_names, features):
            status = "✓" if value else "✗"
            print(f"  {name}: {status}")
        
        if result == 1:
            print("🚨 判定: 垃圾邮件")
        else:
            print("✅ 判定: 正常邮件")
        
        return result

# 训练数据
training_emails = [
    "免费赚钱机会！！！点击这里", # 垃圾邮件
    "您好，这是工作邮件", # 正常邮件  
    "恭喜您中奖了！免费领取！！！", # 垃圾邮件
    "明天开会，请准备资料", # 正常邮件
    "赚钱秘籍！！！立即行动", # 垃圾邮件
]

training_labels = [1, 0, 1, 0, 1]  # 1=垃圾邮件, 0=正常邮件

# 创建并训练检测器
detector = SpamDetector()
detector.train(training_emails, training_labels)

# 测试
test_emails = [
    "免费午餐活动通知",
    "您好，请查收附件",  
    "赚钱机会！！！",
]

print("\n=== 测试垃圾邮件检测器 ===")
for email in test_emails:
    detector.predict(email)
    print("-" * 50)

def compare_biological_artificial():
    """比较生物神经元和人工感知机"""
    
    comparison = {
        "特征": ["输入", "处理", "输出", "学习", "速度"],
        "生物神经元": [
            "通过树突接收信号", 
            "在细胞体内整合信号",
            "通过轴突发送动作电位",
            "通过突触强度变化学习",
            "毫秒级响应"
        ],
        "人工感知机": [
            "数值输入向量",
            "加权求和 + 激活函数", 
            "0或1的数字输出",
            "通过调整权重学习",
            "微秒级计算"
        ]
    }
    
    print("🧠 生物神经元 vs 🤖 人工感知机")
    print("=" * 60)
    
    for i, feature in enumerate(comparison["特征"]):
        print(f"\n{feature}:")
        print(f"  🧠 生物: {comparison['生物神经元'][i]}")
        print(f"  🤖 人工: {comparison['人工感知机'][i]}")
    
    print("\n💡 相同点:")
    print("  - 都接收多个输入")
    print("  - 都进行某种'计算'")  
    print("  - 都产生输出信号")
    print("  - 都可以通过经验学习")
    
    print("\n🔄 不同点:")
    print("  - 生物神经元更复杂，有时间动态")
    print("  - 人工感知机更简单，便于数学分析")
    print("  - 生物神经元处理模拟信号")
    print("  - 人工感知机处理数字信号")

compare_biological_artificial()

def perceptron_history():
    """感知机的有趣历史"""
    
    timeline = {
        "1943年": "McCulloch和Pitts提出第一个数学神经元模型",
        "1957年": "Rosenblatt发明感知机，引起巨大轰动",
        "1958年": "第一台感知机硬件Mark I诞生",
        "1969年": "Minsky和Papert指出感知机的局限性",
        "1970s-1980s": "AI进入'寂静期'",  
        "1986年": "反向传播算法重燃神经网络希望",
        "2010s": "深度学习爆发，感知机成为基础"
    }
    
    print("📜 感知机的传奇历史")
    print("=" * 50)
    
    for year, event in timeline.items():
        print(f"{year}: {event}")
    
    print("\n🎯 有趣的事实:")
    print("  - Rosenblatt曾预言感知机将能'行走、说话、看见、写字'")
    print("  - 第一台感知机重达5吨！")
    print("  - 媒体称其为'会思考的机器'")
    print("  - XOR问题的发现几乎杀死了整个领域")
    print("  - 今天最复杂的AI仍然基于感知机的原理")

perceptron_history()

def evolution_to_modern_ai():
    """从感知机到现代AI的演化"""
    
    print("🚀 从感知机到现代AI的演化之路")
    print("=" * 50)
    
    stages = [
        {
            "阶段": "单个感知机",
            "能力": "线性分类",
            "局限": "无法处理XOR等问题",
            "例子": "简单的是/否判断"
        },
        {
            "阶段": "多层感知机", 
            "能力": "非线性分类",
            "局限": "训练困难",
            "例子": "复杂模式识别"
        },
        {
            "阶段": "反向传播神经网络",
            "能力": "可训练的多层网络", 
            "局限": "梯度消失问题",
            "例子": "手写数字识别"
        },
        {
            "阶段": "深度学习",
            "能力": "层次特征学习",
            "局限": "需要大量数据",
            "例子": "图像识别、语音识别"
        },
        {
            "阶段": "Transformer/GPT",
            "能力": "理解和生成文本",
            "局限": "计算资源要求高",
            "例子": "ChatGPT、文本生成"
        }
    ]
    
    for i, stage in enumerate(stages, 1):
        print(f"\n第{i}阶段: {stage['阶段']}")
        print(f"  💪 能力: {stage['能力']}")
        print(f"  ⚠️  局限: {stage['局限']}")
        print(f"  🔧 例子: {stage['例子']}")
    
    print("\n🌟 感知机的永恒价值:")
    print("  - 是理解AI的最佳起点")
    print("  - 今天所有神经网络的基础单元") 
    print("  - 简单但蕴含深刻原理")
    print("  - 连接了生物智能和人工智能")

evolution_to_modern_ai()

def digit_recognition_demo():
    """用感知机识别简化的数字"""
    
    # 简化的3x3像素数字
    digits = {
        0: [
            [1, 1, 1],
            [1, 0, 1], 
            [1, 1, 1]
        ],
        1: [
            [0, 1, 0],
            [0, 1, 0],
            [0, 1, 0]
        ]
    }
    
    def display_digit(digit_matrix, label):
        """显示数字"""
        print(f"\n数字 {label}:")
        for row in digit_matrix:
            line = ""
            for pixel in row:
                line += "█" if pixel else " "
            print(f"  {line}")
    
    # 显示数字
    for digit, matrix in digits.items():
        display_digit(matrix, digit)
    
    # 准备训练数据
    X_train = []
    y_train = []
    
    # 创建多个变种来增加训练数据
    for digit, matrix in digits.items():
        # 将3x3矩阵展平为9维向量
        flattened = np.array(matrix).flatten()
        X_train.append(flattened)
        y_train.append(digit)
        
        # 添加一些噪声版本
        for _ in range(3):
            noisy = flattened.copy()
            # 随机翻转一个像素
            flip_idx = np.random.randint(0, 9)
            noisy[flip_idx] = 1 - noisy[flip_idx]
            X_train.append(noisy)
            y_train.append(digit)
    
    X_train = np.array(X_train)
    y_train = np.array(y_train)
    
    print(f"\n🎓 训练数据: {len(X_train)} 个样本")
    
    # 创建感知机（输入9维，输出识别是否为数字1）
    perceptron = SimplePerceptron(input_size=9)
    
    # 将问题转换为二分类：是否为数字1
    binary_labels = (y_train == 1).astype(int)
    
    # 训练
    print("\n开始训练识别数字1...")
    for epoch in range(10):
        errors = 0
        for i in range(len(X_train)):
            if perceptron.train_step(X_train[i], binary_labels[i]):
                errors += 1
        
        if errors == 0:
            print(f"✅ 在第 {epoch + 1} 轮训练后完全学会了！")
            break
    
    # 测试
    print("\n🧪 测试识别能力:")
    test_digit_0 = np.array(digits[0]).flatten()
    test_digit_1 = np.array(digits[1]).flatten()
    
    result_0 = perceptron.predict(test_digit_0)
    result_1 = perceptron.predict(test_digit_1)
    
    print(f"输入数字0，预测结果: {'是数字1' if result_0 else '不是数字1'} {'✅' if result_0 == 0 else '❌'}")
    print(f"输入数字1，预测结果: {'是数字1' if result_1 else '不是数字1'} {'✅' if result_1 == 1 else '❌'}")

digit_recognition_demo()

def key_takeaways():
    """感知机的核心要点"""
    
    print("🎯 感知机的核心思想")
    print("=" * 40)
    
    principles = [
        {
            "原理": "模仿神经元",
            "解释": "像大脑神经元一样接收多个输入，产生一个输出",
            "比喻": "就像一个聪明的门卫，根据多个条件决定是否放行"
        },
        {
            "原理": "权重代表重要性", 
            "解释": "每个输入都有一个权重，权重越大越重要",
            "比喻": "就像投票时，专家的票比普通人的票更有分量"
        },
        {
            "原理": "学习就是调整权重",
            "解释": "通过不断试错，调整各个输入的重要性",
            "比喻": "就像学开车，不断调整对各种路况的反应"
        },
        {
            "原理": "线性分类器",
            "解释": "只能处理线性可分的问题",
            "比喻": "只能用一条直线把两类东西分开"
        }
    ]
    
    for i, principle in enumerate(principles, 1):
        print(f"\n{i}. {principle['原理']}")
        print(f"   📝 解释: {principle['解释']}")
        print(f"   🎭 比喻: {principle['比喻']}")
    
    print(f"\n🌟 为什么感知机重要？")
    print("  - 是理解AI的第一步")
    print("  - 所有神经网络的基础")
    print("  - 简单但包含核心思想")
    print("  - 连接生物和人工智能")
    
    print(f"\n🚀 下一步学什么？")
    print("  - 多层感知机（解决XOR问题）")
    print("  - 反向传播算法")
    print("  - 深度学习基础")
    print("  - 卷积神经网络")

key_takeaways()