fix in chapter2,3,4

docs/chapter2/第二章 智能体发展史.md

@@ -396,11 +396,13 @@ ELIZA的实践清晰地揭示了符号主义方法的核心矛盾：系统看似
 
 <strong>从特定任务到通用模型</strong>
 
-在预训练范式出现之前，传统的自然语言处理模型通常是为单一特定任务（如情感分析、机器翻译）在专门标注的中小规模数据集上从零开始独立训练的。这种模式导致了几个问题：模型的知识面狭窄，难以将在一个任务中学到的知识泛化到另一个任务，并且每一个新任务都需要耗费大量的人力去标注数据。预训练与微调（Pre-training, Fine-tuning）范式的提出彻底改变了这一现状。其核心思想分为两步，如图2.8所示：
+在预训练范式出现之前，传统的自然语言处理模型通常是为单一特定任务（如情感分析、机器翻译）在专门标注的中小规模数据集上从零开始独立训练的。这种模式导致了几个问题：模型的知识面狭窄，难以将在一个任务中学到的知识泛化到另一个任务，并且每一个新任务都需要耗费大量的人力去标注数据。预训练与微调（Pre-training, Fine-tuning）范式的提出彻底改变了这一现状。其核心思想分为两步：
 
 1. <strong>预训练阶段</strong>：首先在一个包含互联网级别海量文本数据的通用语料库上，通过<strong>自监督学习（Self-supervised Learning）</strong>的方式训练一个超大规模的神经网络模型。这个阶段的目标不是完成任何特定任务，而是学习语言本身内在的规律、语法结构、事实知识以及上下文逻辑。最常见的目标是“预测下一个词”。
 2. <strong>微调阶段</strong>：完成预训练后，这个模型就已经学习到了和数据集有关的丰富知识。之后，针对特定的下游任务，只需使用少量该任务的标注数据对模型进行微调，即可让模型适应对应任务。
 
+如图2.8所示，直观地展示了这一预训练与微调的完整流程：通用文本数据经过自监督学习形成基础模型，随后通过特定任务数据进行微调，最终适应各项下游任务。
+
 <div align="center">
   <img src="https://raw.githubusercontent.com/datawhalechina/Hello-Agents/main/docs/images/2-figures/1757246501849-7.png" alt="图片描述" width="90%"/>
   <p>图 2.8 “预训练-微调”范式示意图</p>
@@ -428,14 +430,19 @@ ELIZA的实践清晰地揭示了符号主义方法的核心矛盾：系统看似
 
 如第一章所述，智能体与环境的交互可以被抽象为一个核心循环。LLM驱动的智能体通过一个由多个模块协同工作的、持续迭代的闭环流程来完成任务。该流程遵循图2.9所示的架构，具体步骤如下：
 
-1. <strong>感知 (Perception)</strong> ：流程始于感知模块。该模块从<strong>外部环境 (Environment)</strong> 中接收输入，即<strong>观察 (Observation)</strong> 。这些观察信息（如用户指令或环境状态变化）被处理后，传递给规划模块。
-2. <strong>规划 (Planning)</strong> ：规划模块接收到观察信息后，对其进行分析和高级策略制定。此阶段包含<strong>反思 (Reflection)</strong> 和<strong>自我批判 (Self-criticism)</strong> 等关键机制，旨在将高层级目标分解为更具体的、结构化的行动计划。该计划随后被发送至系统的认知核心——大型语言模型。
-3. <strong>核心处理 (LLM Processing)</strong> ：作为中枢的<strong>大型语言模型 (LLM)</strong> 接收来自规划模块的指令。它会与<strong>记忆模块 (Memory)</strong> 进行交互，整合历史信息和上下文，进行深度推理，并最终决策出下一步的具体操作。这个操作通常表现为一个<strong>工具调用 (Tool Call)</strong> 。
-4. <strong>行动 (Action)</strong> ：LLM生成的工具调用指令被发送到<strong>执行模块 (Execution Module)</strong> 。该模块解析指令，选择并使用<strong>工具箱 (Tool Use)</strong> 中相应的工具（如代码执行器、搜索引擎等）来执行任务。执行后，工具返回一个<strong>工具结果 (Tool Result)</strong> 给LLM，同时对环境产生一个实际的<strong>行动 (Action)</strong> 。
-5. <strong>反馈与更新 (Feedback & Update)</strong> ：LLM接收到返回的<strong>工具结果</strong>，评估该步骤的执行效果。基于此结果，LLM会对记忆模块进行<strong>更新 (Memory Update)</strong> ，例如记录本次行动的成功、失败或关键产出。同时，环境因智能体的行动而发生改变，产生新的<strong>观察 (Observation)</strong> ，该信息被感知模块捕获，从而启动下一轮循环。
+1. <strong>感知 (Perception)</strong> ：流程始于<strong>感知模块 (Perception Module)</strong>。它通过传感器从<strong>外部环境 (Environment)</strong> 接收原始输入，形成<strong>观察 (Observation)</strong>。这些观察信息（如用户指令、API返回的数据或环境状态的变化）是智能体决策的起点，处理后将被传递给思考阶段。
+2. <strong>思考 (Thought)</strong> ：这是智能体的认知核心，对应图中的<strong>规划模块 (Planning Module)</strong> 和<strong>大型语言模型 (LLM)</strong> 的协同工作。
+   - <strong>规划与分解</strong>：首先，规划模块接收观察信息，进行高级策略制定。它通过<strong>反思 (Reflection)</strong> 和<strong>自我批判 (Self-criticism)</strong> 等机制，将宏观目标分解为更具体、可执行的步骤。
+   - <strong>推理与决策</strong>：随后，作为中枢的<strong>LLM</strong> 接收来自规划模块的指令，并与<strong>记忆模块 (Memory)</strong> 交互以整合历史信息。LLM进行深度推理，最终决策出下一步要执行的具体操作，这通常表现为一个<strong>工具调用 (Tool Call)</strong>。
+3. <strong>行动 (Action)</strong> ：决策完成后，便进入行动阶段，由<strong>执行模块 (Execution Module)</strong> 负责。LLM生成的工具调用指令被发送到执行模块。该模块解析指令，从<strong>工具箱 (Tool Use)</strong> 中选择并调用合适的工具（如代码执行器、搜索引擎、API等）来与环境交互或执行任务。这个与环境的实际交互就是智能体的<strong>行动 (Action)</strong>。
+4. <strong>观察 (Observation)</strong> 与循环 ：行动会改变环境的状态，并产生结果。
+   - 工具执行后会返回一个<strong>工具结果 (Tool Result)</strong> 给LLM，这构成了对行动效果的直接反馈。同时，智能体的行动改变了环境，从而产生了一个全新的<strong>环境状态</strong>。
+   - 这个“工具结果”和“新的环境状态”共同构成了一轮全新的<strong>观察 (Observation)</strong>。这个新的观察会被感知模块再次捕获，同时LLM会根据行动结果<strong>更新记忆 (Memory Update)</strong>，从而启动下一轮“感知-思考-行动”的循环。
 
 这种模块化的协同机制与持续的迭代循环，构成了LLM驱动智能体解决复杂问题的核心工作流。
 
+
+
 ### 2.4.5 智能体发展关键节点概览
 
 人工智能体的发展史并非一条笔直的单行道，而是几大核心思想流派长达半个多世纪交织、竞争与融合的历程。理解这一历程，有助于我们洞察当前智能体架构范式形成的深刻根源。

docs/chapter3/第三章 大模型基础.md

@@ -1,6 +1,6 @@
 # 第三章 大语言模型基础
 
-本章将完全聚焦于大语言模型本身。我们将从语言模型的基本定义出发，通过对这些原理的学习，理解LLM如何获得强大的知识储备与推理能力打下坚实的基础。
+前两章分别介绍了智能体的定义和发展历史，本章将完全聚焦于大语言模型本身解答一个关键问题：现代智能体是如何工作的？我们将从语言模型的基本定义出发，通过对这些原理的学习，为理解LLM如何获得强大的知识储备与推理能力打下坚实的基础。
 
 ## 3.1 语言模型与 Transformer 架构
 

docs/chapter4/第四章 智能体经典范式构建.md

@@ -889,47 +889,53 @@ $$
 Reflection 的核心在于迭代，而迭代的前提是能够记住之前的尝试和获得的反馈。因此，一个“短期记忆”模块是实现该范式的必需品。这个记忆模块将负责存储每一次“执行-反思”循环的完整轨迹。
 
 ```python
-from typing import List, Dict, Any
+from typing import List, Dict, Any, Optional
 
 class Memory:
-"""
-一个简单的短期记忆模块，用于存储智能体的行动与反思轨迹。
-"""
-def __init__(self):
-# 初始化一个空列表来存储所有记录
-self.records: List[Dict[str, Any]] = []
+    """
+    一个简单的短期记忆模块，用于存储智能体的行动与反思轨迹。
+    """
 
-def add_record(self, record_type: str, content: str):
-"""
-向记忆中添加一条新记录。
+    def __init__(self):
+        """
+        初始化一个空列表来存储所有记录。
+        """
+        self.records: List[Dict[str, Any]] = []
 
-参数:
-- record_type (str): 记录的类型 ('execution' 或 'reflection')。
-- content (str): 记录的具体内容 (例如，生成的代码或反思的反馈)。
-"""
-self.records.append({"type": record_type, "content": content})
-print(f"📝 记忆已更新，新增一条 '{record_type}' 记录。")
+    def add_record(self, record_type: str, content: str):
+        """
+        向记忆中添加一条新记录。
 
-def get_trajectory(self) -> str:
-"""
-将所有记忆记录格式化为一个连贯的字符串文本，用于构建提示词。
-"""
-trajectory = ""
-for record in self.records:
-if record['type'] == 'execution':
-trajectory += f"--- 上一轮尝试 (代码) ---\n{record['content']}\n\n"
-elif record['type'] == 'reflection':
-trajectory += f"--- 评审员反馈 ---\n{record['content']}\n\n"
-return trajectory.strip()
-
-def get_last_execution(self) -> str:
-"""
-获取最近一次的执行结果 (例如，最新生成的代码)。
-"""
-for record in reversed(self.records):
-if record['type'] == 'execution':
-return record['content']
-return None
+        参数:
+        - record_type (str): 记录的类型 ('execution' 或 'reflection')。
+        - content (str): 记录的具体内容 (例如，生成的代码或反思的反馈)。
+        """
+        record = {"type": record_type, "content": content}
+        self.records.append(record)
+        print(f"📝 记忆已更新，新增一条 '{record_type}' 记录。")
+
+    def get_trajectory(self) -> str:
+        """
+        将所有记忆记录格式化为一个连贯的字符串文本，用于构建提示词。
+        """
+        trajectory_parts = []
+        for record in self.records:
+            if record['type'] == 'execution':
+                trajectory_parts.append(f"--- 上一轮尝试 (代码) ---\n{record['content']}")
+            elif record['type'] == 'reflection':
+                trajectory_parts.append(f"--- 评审员反馈 ---\n{record['content']}")
+        
+        return "\n\n".join(trajectory_parts)
+
+    def get_last_execution(self) -> Optional[str]:
+        """
+        获取最近一次的执行结果 (例如，最新生成的代码)。
+        如果不存在，则返回 None。
+        """
+        for record in reversed(self.records):
+            if record['type'] == 'execution':
+                return record['content']
+        return None
 ```
 
 这个 `Memory` 类的设计比较简洁，主体是这样的：