Chapter 2: 智能体发展史 (Part 2: 动手实现 ELIZA 聊天机器人)

最新推荐文章于 2026-01-09 14:32:16 发布

原创最新推荐文章于 2026-01-09 14:32:16 发布 · 561 阅读

12 ·

CC 4.0 BY-SA版权

文章标签：

#机器人 #agent #LLM

在 Part 1 中，我们探讨了符号主义的宏伟蓝图。虽然物理符号系统假说为 AI 提供了理论依据，但理论终究需要通过实践来验证。本篇我们将通过复现 1966 年诞生的 ELIZA，来看看那个时代的“黑科技”究竟是如何工作的。

2.2 构建基于规则的聊天机器人

在探讨了符号主义的理论挑战后，本节我们将通过一个具体的编程实践，来直观地感受基于规则的系统是如何工作的。我们将尝试复现人工智能历史上一个极具影响力的早期聊天机器人 ELIZA 。

2.2.1 ELIZA 的设计思想

ELIZA 是由麻省理工学院的计算机科学家约瑟夫·魏泽鲍姆 (Joseph Weizenbaum) 于 1966 年发布的一个计算机程序，是早期自然语言处理领域的著名尝试之一。

身份设定：ELIZA 并非一个单一的程序，而是一个可以执行不同“脚本”的框架。其中最广为人知的脚本是“DOCTOR”，它模仿了一位罗杰斯学派的非指导性心理治疗师。
工作方式：它从不正面回答问题或提供信息，而是通过识别用户输入中的关键词，然后应用一套预设的转换规则，将用户的陈述转化为一个开放式的提问。
例子：用户说“我为我的男朋友感到难过” -> ELIZA 识别关键词“我为…感到难过” -> 生成回应“你为什么会为你的男朋友感到难过？” 。

💡 深度解析：ELIZA 效应
魏泽鲍姆的设计初衷并非要创造一个真正能够“理解”人类情感的智能体。恰恰相反，他想证明：通过简单句式转换技巧，机器可以在完全不理解对话内容的情况下，营造出“智能”和“共情”的假象 。
但出乎意料的是，许多与 ELIZA 交互过的人（包括他的秘书）都对其产生了情感依赖，深信它能理解自己。

2.2.2 模式匹配与文本替换

ELIZA 的算法流程基于 模式匹配 (Pattern Matching) 与 文本替换 (Text Substitution)，可被清晰地分解为以下四个步骤：

关键词识别与排序：规则库为每个关键词（如 mother, dreamed, depressed）设定优先级。程序选择优先级最高的关键词规则处理。
分解规则 (Decomposition)：使用带通配符 (*) 的规则捕获句子部分。

规则：* my *
输入："My mother is afraid of me"
捕获结果：["", "mother is afraid of me"]

重组规则 (Reassembly)：从关联的重组规则中选择一条生成回应，并填入上一步捕获的内容。

规则："Tell me more about your family."
输出："Tell me more about your family."

代词转换：在重组前，进行简单的代词转换（如 I → you, my → your），以维持对话连贯性。

核心算法伪代码

整个工作流程可以用以下伪代码表示：

FUNCTION generate_response(user_input):
    # 1. 将用户输入拆分成单词
    words = SPLIT(user_input)

    # 2. 寻找优先级最高的关键词规则
    best_rule = FIND_BEST_RULE(words)
    IF best_rule is NULL:
        RETURN a_generic_response()  # 例如: "Please go on."

    # 3. 使用规则分解用户输入
    decomposed_parts = DECOMPOSE(user_input, best_rule.decomposition_pattern)
    IF decomposition_failed:
        RETURN a_generic_response()

    # 4. 对分解出的部分进行代词转换
    transformed_parts = TRANSFORM_PRONOUNS(decomposed_parts)

    # 5. 使用重组规则生成回应
    response = REASSEMBLE(transformed_parts, best_rule.reassembly_patterns)
    
    RETURN response

通过这套机制，ELIZA 成功地将复杂的自然语言理解问题，简化为了一个可操作的、基于规则的模式匹配游戏。

2.2.3 核心逻辑的实现 (Python 版)

现在，我们将上述原理转化为一个可运行的 Python 代码。这个迷你版 ELIZA 包含一小部分规则，但足以展示核心机制。

💡 注解：
下方的代码使用了 Python 的 re (正则表达式) 模块来实现模式匹配，这是处理文本规则最经典的工具。

import re
import random

# 定义规则库: 模式(正则表达式) -> 响应模板列表
rules = {
    r'I need (.*)': [
        "Why do you need {0}?",
        "Would it really help you to get {0}?",
        "Are you sure you need {0}?"
    ],
    r'Why don\'t you (.*)\?': [
        "Do you really think I don't {0}?",
        "Perhaps eventually I will {0}.",
        "Do you really want me to {0}?"
    ],
    r'Why can\'t I (.*)\?': [
        "Do you think you should be able to {0}?",
        "If you could {0}, what would you do?",
        "I don't know -- why can't you {0}?"
    ],
    r'I am (.*)': [
        "Did you come to me because you are {0}?",
        "How long have you been {0}?",
        "How do you feel about being {0}?"
    ],
    r'.*mother.*': [
        "Tell me more about your mother.",
        "What was your relationship with your mother like?",
        "How do you feel about your mother?"
    ],
    r'.*father.*': [
        "Tell me more about your father.",
        "How did your father make you feel?",
        "What has your father taught you?"
    ],
    r'.*': [  # 默认兜底规则
        "Please tell me more.",
        "Let's change focus a bit... Tell me about your family.",
        "Can you elaborate on that?"
    ]
}

# 定义代词转换规则
pronoun_swap = {
    "i": "you", "you": "i", "me": "you", "my": "your",
    "am": "are", "are": "am", "was": "were", "i'd": "you would",
    "i've": "you have", "i'll": "you will", "yours": "mine",
    "mine": "yours"
}

def swap_pronouns(phrase):
    """对输入短语中的代词进行第一/第二人称转换"""
    words = phrase.lower().split()
    # 简单的逐词查找替换
    swapped_words = [pronoun_swap.get(word, word) for word in words]
    return " ".join(swapped_words)

def respond(user_input):
    """根据规则库生成响应"""
    for pattern, responses in rules.items():
        # 尝试匹配正则表达式
        match = re.search(pattern, user_input, re.IGNORECASE)
        if match:
            # 捕获匹配到的部分 (即正则表达式中的括号内容)
            captured_group = match.group(1) if match.groups() else ''
            
            # 进行代词转换
            swapped_group = swap_pronouns(captured_group)
            
            # 从模板中随机选择一个并格式化
            response = random.choice(responses).format(swapped_group)
            return response
            
    # 如果没有匹配任何特定规则 (理论上 r'.*' 会捕获所有)，使用兜底
    return random.choice(rules[r'.*'])

# 主聊天循环
if __name__ == '__main__':
    print("Therapist: Hello! How can I help you today?")
    while True:
        user_input = input("You: ")
        if user_input.lower() in ["quit", "exit", "bye"]:
            print("Therapist: Goodbye. It was nice talking to you.")
            break
        
        response = respond(user_input)
        print(f"Therapist: {response}")

运行示例

Therapist: Hello! How can I help you today?
You: I am feeling sad today.
Therapist: How long have you been feeling sad today?

You: I need some help with my project.
Therapist: Are you sure you need some help with your project?

You: My mother is not happy with my work.
Therapist: Tell me more about your mother.

You: quit
Therapist: Goodbye. It was nice talking to you.

2.2.4 局限性总结：基于规则系统的天花板

通过上述的编程实践，我们可以直观地总结出规则驱动系统的根本局限性，这些局限正是对符号主义理论挑战的直接印证：

缺乏语义理解：系统不理解词义。例如，面对 I am not happy 的输入，它仍会机械地匹配 I am (.*) 规则，可能生成“How long have you been not happy?” 这样语义略显生硬的回应，因为它无法理解否定词 not 的作用。
无上下文记忆 (Stateless)：系统是无状态的，每次回应仅基于当前单句输入，无法进行连贯的多轮对话。
规则的扩展性问题：尝试增加更多规则会导致规则库规模爆炸式增长，规则间的冲突与优先级管理将变得极其复杂，最终导致系统难以维护。

ELIZA 的实践清晰地揭示了符号主义方法的核心矛盾：系统看似智能的表现，完全依赖于设计者预先编码的规则。面对真实世界语言的无限可能性，这种穷举式的方法注定不可扩展。系统没有真正的理解，只是在执行符号操作，这正是其脆弱性的根源。