人工智能六十年沧桑巨变——从达特茅斯会议到大模型时代

class DartmouthAttendee:
    def __init__(self, name, expertise, bold_prediction):
        self.name = name
        self.expertise = expertise
        self.prediction = bold_prediction
    
    def speak(self):
        return f"{self.name}（{self.expertise}）：{self.prediction}"

attendees = [
    DartmouthAttendee("麦卡锡", "数学逻辑", "我们将创造能真正推理的机器！"),
    DartmouthAttendee("明斯基", "神经网络", "大脑就是一串电信号，机器一定能模拟它！"),
    DartmouthAttendee("香农", "信息论", "机器也可以有创造力！"),
    DartmouthAttendee("西蒙", "经济学", "十年内计算机将成为国际象棋冠军！")
]

for attendee in attendees:
    print(attendee.speak())
# 输出：
# 麦卡锡（数学逻辑）：我们将创造能真正推理的机器！
# 明斯基（神经网络）：大脑就是一串电信号，机器一定能模拟它！
# 香农（信息论）：机器也可以有创造力！
# 西蒙（经济学）：十年内计算机将成为国际象棋冠军！

import numpy as np

class Perceptron:
    """1958年罗森布拉特提出的感知机"""
    def __init__(self, input_size, lr=0.1):
        self.weights = np.random.randn(input_size) * 0.1
        self.bias = 0
        self.lr = lr
    
    def predict(self, x):
        return 1 if np.dot(x, self.weights) + self.bias > 0 else 0
    
    def train(self, X, y, epochs=10):
        for epoch in range(epochs):
            errors = 0
            for xi, target in zip(X, y):
                prediction = self.predict(xi)
                error = target - prediction
                if error != 0:
                    self.weights += self.lr * error * xi
                    self.bias += self.lr * error
                    errors += 1
            print(f"Epoch {epoch+1}, errors: {errors}")

# 训练一个简单的AND门
X = np.array([[0,0], [0,1], [1,0], [1,1]])
y = np.array([0, 0, 0, 1])  # AND gate

p = Perceptron(2)
p.train(X, y, epochs=5)

for xi in X:
    print(f"Input: {xi}, Output: {p.predict(xi)}")

# 单层感知机无法解决XOR问题
X_xor = np.array([[0,0], [0,1], [1,0], [1,1]])
y_xor = np.array([0, 1, 1, 0])  # XOR

p2 = Perceptron(2)
p2.train(X_xor, y_xor, epochs=20)
print("\nXOR问题结果：")
for xi in X_xor:
    print(f"Input: {xi}, Output: {p2.predict(xi)}")
# 错误率永远大于0，这就是AI寒冬的直接导火索

class ExpertSystem:
    """基于规则的简单专家系统"""
    def __init__(self):
        self.rules = []
        self.facts = set()
    
    def add_rule(self, conditions, conclusion):
        self.rules.append({
            'conditions': conditions,
            'conclusion': conclusion
        })
    
    def add_fact(self, fact):
        self.facts.add(fact)
    
    def diagnose(self):
        for rule in self.rules:
            if all(cond in self.facts for cond in rule['conditions']):
                return rule['conclusion']
        return "无法确诊，请咨询专业医生"

# 构建感冒诊断系统
medical_expert = ExpertSystem()
medical_expert.add_rule(['发烧', '咳嗽', '流鼻涕'], '普通感冒')
medical_expert.add_rule(['发烧', '喉咙痛', '淋巴结肿大'], '扁桃体炎')
medical_expert.add_rule(['高烧', '头痛', '皮疹'], '麻疹')

# 模拟病人症状
medical_expert.add_fact('发烧')
medical_expert.add_fact('咳嗽')
medical_expert.add_fact('流鼻涕')

print("诊断结果：", medical_expert.diagnose())  # 普通感冒

历史局限：专家系统需要人工提取规则，无法自主学习，维护成本极高。

4、1987-1993：第二次寒冬

导火索：日本第五代计算机项目失败，专家系统泡沫破裂

教训：纯符号主义路径存在天花板

import random

class SimpleChessAI:
    """模拟深蓝的决策过程"""
    def __init__(self, name):
        self.name = name
    
    def evaluate_board(self, board_state):
        """评估棋盘局势（简化版）"""
        piece_values = {'queen': 9, 'rook': 5, 'bishop': 3, 'knight': 3, 'pawn': 1}
        score = 0
        for piece in board_state:
            score += piece_values.get(piece, 0)
        return score
    
    def minimax(self, depth, maximizing):
        """极小化极大算法（简化）"""
        if depth == 0:
            return random.randint(-10, 10)  # 简化评估
        if maximizing:
            return max([self.minimax(depth-1, False) for _ in range(3)])
        else:
            return min([self.minimax(depth-1, True) for _ in range(3)])

ai = SimpleChessAI("Deep Blue Jr.")
print(f"{ai.name} 思考深度4层的评分: {ai.minimax(4, True)}")

class ImageNetCompetitor:
    def __init__(self, name, error_rate, year):
        self.name = name
        self.error_rate = error_rate  # 错误率
        self.year = year
    
    def __str__(self):
        return f"{self.name} ({self.year}): 错误率 {self.error_rate}%"

competitors = [
    ImageNetCompetitor("传统计算机视觉", 28.2, 2010),
    ImageNetCompetitor("AlexNet (深度学习)", 16.4, 2012),
    ImageNetCompetitor("VGG", 7.3, 2014),
    ImageNetCompetitor("ResNet", 3.6, 2015),
    ImageNetCompetitor("SENet", 2.3, 2017),
]

print("ImageNet图像分类竞赛历史：")
for c in competitors:
    print(c)
    if c.error_rate < 5:
        print("  超越人类水平（约5%）！")

1、符号主义（1956-1990s统治期）

核心主张：

• 人类认知 = 符号操作

• 智能 = 规则 + 逻辑推理

• 代表成果：LISP语言、专家系统、知识图谱

案例：符号推理的经典问题——猴子与香蕉

class MonkeyBananaProblem:
    """符号主义经典问题：猴子怎么拿到香蕉？"""
    
    def __init__(self):
        self.state = {
            'monkey_position': 'door',
            'monkey_height': 'ground',
            'box_position': 'corner',
            'has_banana': False
        }
    
    def move_monkey(self, new_pos):
        self.state['monkey_position'] = new_pos
        print(f"猴子移动到 {new_pos}")
        return True
    
    def move_box(self, new_pos):
        if self.state['monkey_position'] == self.state['box_position']:
            self.state['box_position'] = new_pos
            print(f"箱子被移动到 {new_pos}")
            return True
        print("猴子不在箱子旁边，无法移动箱子")
        return False
    
    def climb_box(self):
        if (self.state['monkey_position'] == self.state['box_position'] 
            and self.state['monkey_height'] == 'ground'):
            self.state['monkey_height'] = 'box'
            print("猴子爬上箱子")
            return True
        print("无法爬箱子")
        return False
    
    def take_banana(self):
        if (self.state['monkey_height'] == 'box' 
            and self.state['monkey_position'] == 'under_banana'):
            self.state['has_banana'] = True
            print(" 猴子成功拿到香蕉！")
            return True
        print("猴子拿不到香蕉")
        return False
    
    def solve(self):
        print("开始解决问题...")
        self.move_monkey('corner')      # 先到箱子位置
        self.move_box('under_banana')   # 把箱子推到香蕉下
        self.climb_box()                # 爬上箱子
        self.take_banana()              # 拿到香蕉

problem = MonkeyBananaProblem()
problem.solve()

符号主义的贡献：为AI奠定了理论基础，开创了知识表示与推理的研究方向。

符号主义的局限：无法处理模糊性、不确定性，难以应对现实世界的复杂性。

2、连接主义（1980s复兴，2010s至今主导）

import math

class Neuron:
    """生物神经元模型（简化版）"""
    def __init__(self, name):
        self.name = name
        self.synapses = []  # 突触连接
        self.weights = []   # 突触权重
        self.threshold = 0.5
        self.potential = 0
    
    def add_synapse(self, target_neuron, weight):
        self.synapses.append(target_neuron)
        self.weights.append(weight)
    
    def receive_signal(self, signal_strength):
        """接收信号，累积电位"""
        self.potential += signal_strength
    
    def fire(self):
        """是否激活"""
        return self.potential >= self.threshold
    
    def transmit(self):
        """向连接的神经元传递信号"""
        if self.fire():
            print(f" {self.name} 神经元被激活！")
            for target, weight in zip(self.synapses, self.weights):
                target.receive_signal(weight)
            self.potential = 0  # 重置电位
            return True
        return False

# 构建一个简单神经网络
sensory = Neuron("感觉神经元")
inter = Neuron("中间神经元")
motor = Neuron("运动神经元")
sensory.add_synapse(inter, 0.8)
inter.add_synapse(motor, 1.2)

# 模拟刺激
sensory.receive_signal(0.6)
print("轻微刺激：")
sensory.transmit()
inter.transmit()
motor.transmit()

print("\n强烈刺激：")
sensory.receive_signal(1.0)
sensory.transmit()
inter.transmit()
motor.transmit()

import numpy as np
import random

class MazeQLearning:
    """行为主义强化学习经典算法"""
    def __init__(self, maze, alpha=0.1, gamma=0.9, epsilon=0.1):
        self.maze = maze
        self.alpha = alpha      # 学习率
        self.gamma = gamma      # 折扣因子
        self.epsilon = epsilon  # 探索率
        self.q_table = {}       # Q值表
        
        # 初始化Q表
        for i in range(len(maze)):
            for j in range(len(maze[0])):
                if maze[i][j] != 1:  # 不是墙
                    self.q_table[(i, j)] = {'up': 0, 'down': 0, 'left': 0, 'right': 0}
    
    def get_action(self, state):
        """ε-贪心策略选择动作"""
        if random.random() < self.epsilon:
            return random.choice(['up', 'down', 'left', 'right'])  # 探索
        else:
            # 选择Q值最大的动作
            return max(self.q_table[state], key=self.q_table[state].get)
    
    def move(self, state, action):
        """执行动作，返回新状态和奖励"""
        x, y = state
        if action == 'up':
            new_x, new_y = x - 1, y
        elif action == 'down':
            new_x, new_y = x + 1, y
        elif action == 'left':
            new_x, new_y = x, y - 1
        else:
            new_x, new_y = x, y + 1
        # 检查边界和墙壁
        if (new_x < 0 or new_x >= len(self.maze) or 
            new_y < 0 or new_y >= len(self.maze[0]) or
            self.maze[new_x][new_y] == 1):
            return state, -1  # 撞墙，负奖励
        if self.maze[new_x][new_y] == 2:
            return (new_x, new_y), 100  # 找到终点，巨大奖励
        return (new_x, new_y), -0.1  # 正常移动，小额负奖励
    
    def train(self, start, episodes=500):
        """训练智能体"""
        print("开始训练智能体...")
        for episode in range(episodes):
            state = start
            total_reward = 0
            steps = 0
            while self.maze[state[0]][state[1]] != 2 and steps < 100:
                action = self.get_action(state)
                new_state, reward = self.move(state, action)
                total_reward += reward
                # Q值更新公式
                old_q = self.q_table[state][action]
                next_max_q = max(self.q_table[new_state].values())
                new_q = old_q + self.alpha * (reward + self.gamma * next_max_q - old_q)
                self.q_table[state][action] = new_q
                state = new_state
                steps += 1
            if (episode + 1) % 100 == 0:
                print(f"Episode {episode+1}, 总奖励: {total_reward:.2f}")
        print("训练完成！")

# 迷宫：0=路，1=墙，2=终点
maze = [
    [0, 0, 0, 1],
    [1, 0, 1, 0],
    [0, 0, 0, 0],
    [0, 1, 0, 2]
]

agent = MazeQLearning(maze)
agent.train(start=(0, 0), episodes=500)

未来趋势：三个学派正在走向融合，大模型就是连接主义+符号推理的典型代表。