From 66b64773625177042498b8d3b0a8ace1c2a99340 Mon Sep 17 00:00:00 2001 From: pengxiao Date: Sat, 25 Apr 2026 14:43:22 +0800 Subject: [PATCH] =?UTF-8?q?=E9=87=8D=E6=9E=84=E4=B8=8A=E7=AF=87=EF=BC=9A?= =?UTF-8?q?=E6=8C=89=E6=95=B0=E6=8D=AE=E6=A8=A1=E6=80=81=E7=BB=84=E7=BB=87?= =?UTF-8?q?=E4=B8=BA8=E7=AB=A0=EF=BC=8C=E5=BB=BA=E7=AB=8B=E5=B0=8F?= =?UTF-8?q?=E6=A8=A1=E5=9E=8B=E2=86=92=E5=A4=A7=E6=A8=A1=E5=9E=8B=E6=BC=94?= =?UTF-8?q?=E8=BF=9B=E8=84=89=E7=BB=9C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 第1章：导论（保留，微调标题） - 第2章：理论框架（新增环境-智能体-任务框架、数据模态全景） - 第3章：一维数据——序列与文本（RNN → LLM） - 第4章：二维数据——图像与视觉（CNN → 大视觉模型） - 第5章：三维数据——空间与3D（PointNet → 空间智能） - 第6章：强化学习——从决策到对齐（Q-Learning → RLHF） - 第7章：生成式AI——从创造到智能生成（VAE/GAN → Diffusion） - 第8章：AI Agent——从执行到自主（规则系统 → LLM Agent） - 删除旧目录（02-foundations, 03-computer-vision, 04-transformer, 05-generative-ai, 06-agent） - 更新目录.md反映新结构 Co-Authored-By: Claude Opus 4.7 --- 00-frontmatter/目录.md | 67 +- 01-introduction/01-introduction.md | 4 +- 02-foundations/02-foundations.md | 629 --------- 02-framework/02-framework.md | 897 ++++++++++++ 03-1d-sequence/03-1d-sequence.md | 1595 ++++++++++++++++++++++ 03-computer-vision/03-computer-vision.md | 464 ------- 04-2d-vision/04-2d-vision.md | 867 ++++++++++++ 04-transformer/04-transformer.md | 494 ------- 05-3d-spatial/05-3d-spatial.md | 1421 +++++++++++++++++++ 05-generative-ai/05-generative-ai.md | 344 ----- 06-agent/06-agent.md | 535 -------- 06-reinforcement/06-reinforcement.md | 896 ++++++++++++ 07-generative-ai/07-generative-ai.md | 496 +++++++ 08-agent/08-agent.md | 581 ++++++++ 14 files changed, 6781 insertions(+), 2509 deletions(-) delete mode 100644 02-foundations/02-foundations.md create mode 100644 02-framework/02-framework.md create mode 100644 03-1d-sequence/03-1d-sequence.md delete mode 100644 03-computer-vision/03-computer-vision.md create mode 100644 04-2d-vision/04-2d-vision.md delete mode 100644 04-transformer/04-transformer.md create mode 100644 05-3d-spatial/05-3d-spatial.md delete mode 100644 05-generative-ai/05-generative-ai.md delete mode 100644 06-agent/06-agent.md create mode 100644 06-reinforcement/06-reinforcement.md create mode 100644 07-generative-ai/07-generative-ai.md create mode 100644 08-agent/08-agent.md diff --git a/00-frontmatter/目录.md b/00-frontmatter/目录.md index 989371e..e925003 100644 --- a/00-frontmatter/目录.md +++ b/00-frontmatter/目录.md @@ -2,55 +2,41 @@ ## 上篇：原理与技术 -### 第一篇：导论 -- 第1章 AI发展历程 — 从Amazon Go到AI赋能 -- 第2章 AI范式演进 — 技术栈全景与发展趋势 +### 第一篇：导论与理论框架 +- 第1章 AI发展历程与范式演进 — 从Amazon Go到Scaling Law +- 第2章 设计人工智能的理论框架 — 函数式视角、模态全景与MLP基础 -### 第二篇：数学与编程基础 -- 第3章 函数式AI视角 — "Functions Describe the World" -- 第4章 多层感知机 — MLP结构与原理 -- 第5章 编程工具与Vibe Coding — Python环境与AI辅助编程 +### 第二篇：感知智能——从一维到三维 +- 第3章 一维数据——序列与文本 — 从RNN到大语言模型 +- 第4章 二维数据——图像与视觉 — 从CNN到大视觉模型 +- 第5章 三维数据——空间与3D — 从PointNet到空间智能 -### 第三篇：计算机视觉与空间图像 -- 第6章 CNN基础原理 — 卷积神经网络三大组件 -- 第7章 目标检测 — YOLO系列与应用 -- 第8章 语义分割与空间分析 — 图像分析层级 - -### 第四篇：Transformer与大模型 -- 第9章 注意力机制 — Self-Attention原理 -- 第10章 Transformer架构 — Encoder-Decoder结构 -- 第11章 大语言模型技术 — ChatGPT、RAG与Prompt工程 - -### 第五篇：生成式AI -- 第12章 生成模型演进 — 从VAE/GAN到Diffusion -- 第13章 AIGC设计工具链 — ControlNet、LoRA与ComfyUI - -### 第六篇：AI Agent与自主设计 -- 第14章 AI Agent架构 — LLM-based Agent与核心组件 -- 第15章 具身智能 — 数字孪生与物理世界交互 -- 第16章 协作与协议 — MCP协议与HITL协作 +### 第三篇：决策、生成与行动 +- 第6章 强化学习——从决策到对齐 — 从Q-Learning到RLHF +- 第7章 生成式AI——从创造到智能生成 — 从VAE/GAN到Diffusion +- 第8章 AI Agent——从执行到自主 — 从规则系统到LLM Agent ## 下篇：设计领域应用 -### 第七部分：数字媒体设计 -- 第17章 视觉设计与AIGC — 图像生成与风格迁移 -- 第18章 交互设计 — 用户界面生成与体验分析 +### 第四部分：数字媒体设计 +- 第9章 视觉设计与AIGC — 图像生成与风格迁移 +- 第10章 交互设计 — 用户界面生成与体验分析 -### 第八部分：环境设计 -- 第19章 室内设计 — 平面图生成与VR/AR预览 -- 第20章 景观设计 — 场地分析与生态效益模拟 +### 第五部分：环境设计 +- 第11章 室内设计 — 平面图生成与VR/AR预览 +- 第12章 景观设计 — 场地分析与生态效益模拟 -### 第九部分：工业设计 -- 第21章 产品造型设计 — 概念草图与三维建模 -- 第22章 设计优化与制造 — 拓扑优化与可制造性分析 +### 第六部分：工业设计 +- 第13章 产品造型设计 — 概念草图与三维建模 +- 第14章 设计优化与制造 — 拓扑优化与可制造性分析 -### 第十部分：城市设计 -- 第23章 城市空间分析 — 遥感影像与城市形态识别 -- 第24章 规划设计与评估 — 用地规划与交通优化 +### 第七部分：城市设计 +- 第15章 城市空间分析 — 遥感影像与城市形态识别 +- 第16章 规划设计与评估 — 用地规划与交通优化 -### 第十一部分：生态设计 -- 第25章 生态分析与评估 — 生态系统服务与生物多样性 -- 第26章 生态规划与修复 — 生态网络与修复方案优化 +### 第八部分：生态设计 +- 第17章 生态分析与评估 — 生态系统服务与生物多样性 +- 第18章 生态规划与修复 — 生态网络与修复方案优化 ## 附录 @@ -62,4 +48,3 @@ - 附录6：其他资源 - 附录7：参考文献 - 附录8：关键术语表 - diff --git a/01-introduction/01-introduction.md b/01-introduction/01-introduction.md index 9e5adec..06fa2d0 100644 --- a/01-introduction/01-introduction.md +++ b/01-introduction/01-introduction.md @@ -1,6 +1,6 @@ -# 第一篇：导论 +# 第1章：导论 -本篇作为全书的开篇，旨在帮助读者建立对人工智能的宏观认知框架。我们将从AI的发展历程出发，回顾从早期符号主义到深度学习、再到大模型时代的关键技术突破与转折节点；进而梳理AI的范式演进，从感知智能到生成式智能、从单一任务到通用智能的发展脉络，帮助读者理解AI技术的全貌和未来趋势。这一宏观视角的建立，将为后续各篇中AI与设计实践的结合提供必要的技术认知基础。 +本章建立读者对人工智能的宏观认知框架。从AI的发展历程出发，回顾从早期符号主义到深度学习、再到大模型时代的关键技术突破与转折节点；进而梳理AI的范式演进，从感知智能到生成式智能、从单一任务到通用智能的发展脉络，帮助读者理解AI技术的全貌和未来趋势。 ## 篇章导读 diff --git a/02-foundations/02-foundations.md b/02-foundations/02-foundations.md deleted file mode 100644 index 61cef75..0000000 --- a/02-foundations/02-foundations.md +++ /dev/null @@ -1,629 +0,0 @@ -# 第二篇：数学与编程基础 - -本篇从函数式视角理解AI，介绍神经网络的基本原理和Python编程工具，为后续学习打下基础。 - -## 篇章导读 - -理解AI不需要高深的数学背景。核心理念是：**神经网络就是由简单函数组合而成的复杂函数**。 - -从Excel的线性回归到深度神经网络，本质上是同样的思想：**用函数来描述和预测世界**。 - -本篇将： - 从函数式视角理解AI - 介绍多层感知机的基本原理 - 讲解Python编程工具和AI辅助编程 - ---- - -### 学习目标 - -理解"Functions Describe the World"的核心理念 - -掌握从Excel到神经网络的演进逻辑 - -理解函数组合与层级抽象的思想 - -### 核心理念：函数描述世界 - -#### 从物理定律说起 - -物理学用简洁的函数描述复杂现象： - - ---------------------------------- - 现象 函数 发现者 - ---------- -------------- -------- - 自由落体 h = ½gt² 伽利略 - - 万有引力 F = Gm₁m₂/r² 牛顿 - - 电磁感应 ε = -dΦ/dt 法拉第 - ---------------------------------- - -这些函数的共同特点：**用数学关系描述客观规律** - -#### AI的函数观 - -AI延续了这一传统：**用函数从数据中学习规律** - -`数据`` → ``函数`` → ``预测``/``决策`\ -` x → f(x) → y` - -从Excel到神经网络 - -线性回归：y = ax + b - -在Excel中，我们经常做线性拟合： - -`房价`` ≈ 0.015 × ``面积`` + 50``万`\ -` y = a × x + b` - -这就是一个最简单的"AI模型"：**单变量线性函数** - -多元回归：y = a₁x₁ + a₂x₂ + ... + b - -增加更多特征： - -`房价`` ≈ 0.01 × ``面积`` + 0.5 × ``卧室数`` + 0.3 × ``地段评分`` - 20``万` - -这就是**单层神经元**的数学形式！ - -函数组合：层级嵌套 - -现实世界的关系往往是非线性的，需要函数组合： - -`h₁ = f₁(x) # ``第一层：提取特征` - -`h₂ = f₂(h₁) # ``第二层：组合特征` - -`y = f₃(h₂) # ``第三层：输出结果` - -这就是**多层神经网络**的本质！ - -### 函数组合的威力 - -为什么需要多层？ - -**单层函数**只能学习简单的线性关系 - -**多层函数**可以学习任意复杂的非线性关系 - -直观例子：识别圆形 - -`输入：像素点灰度值`\ -` ↓`\ -`第一层：检测边缘（梯度变化）`\ -` ↓`\ -`第二层：组合边缘成弧线`\ -` ↓`\ -`第三层：判断是否闭合`` → ``圆形` - -每一层都是一个函数，层层组合形成复杂能力。 - -### 数据驱动 vs 规则驱动 - -#### 规则驱动 - -`# ``传统编程：人工编写规则`\ -`def`` ``is_circle``(image):`\ -` edges ``=`` ``detect_edges``(image)`\ -` ``if`` ``edges.is_closed``() ``and`` ``edges.is_round``():`\ -` ``return`` ``True`\ -` ``return`` ``False` - -**问题**：规则难以穷举，无法处理复杂情况 - -#### 数据驱动 - -`# AI``：从数据中学习函数`\ -`f ``=`` ``neural_network``()`\ -`train(f, ``thousands_of_examples``)`\ -`result ``=`` f(``new_image``) ``# ``自动判断` - -**优势**：自动发现规律，适应复杂情况 - -### 神经网络的函数本质 - -数学表示 - -一个L层神经网络： - -`y = ``f_L``(f_{L-``1}(``...f_₂(f₁(x))))` - -其中每一层： - -`h = ``σ(``Wx`` + b)` - -W：权重矩阵（可学习参数） - -b：偏置向量（可学习参数） - -σ：激活函数（引入非线性） - -#### 视觉理解 - -`输入层`` ``隐藏层`` ``输出层`\ -` x ``h₁,h₂,h``₃ y`\ -` ● ──────────→ ○ ──────────→ ●`\ -` │ ○ │`\ -` ● ──────────→ ○ ──────────→ ●`\ -` │ ○ │`\ -` ● ──────────→ ○ ──────────→ ●`\ -` ``权重``W₁ ``权重``W₂` - -箭头上的权重就是函数的参数，通过学习自动确定。 - -### 思考与练习 - -1.列举3个日常生活中"用函数描述世界"的例子 - -2.为什么单层函数无法学习异或（XOR）问题？ - -3.思考：设计中有哪些问题可以用"数据驱动函数"的思路解决？ - -### 关键术语 - - ------------------------------------------------------------ - 中文 英文 说明 - ---------- --------------------- --------------------------- - 线性回归 Linear Regression y = ax + b 形式的函数拟合 - - 多元回归 Multiple Regression 多输入变量的线性模型 - - 权重 Weight 神经网络中的可学习参数 - - 偏置 Bias 调整输出基准的参数 - - 非线性 Non-linearity 无法用直线表示的关系 - ------------------------------------------------------------ - -### 延伸阅读 - -[Neural Networks and Deep Learning](http://neuralnetworksanddeeplearning.com/) - 在线书籍 - ---- - -### 学习目标 - -理解MLP的基本结构 - -掌握前向传播的计算过程 - -了解激活函数的作用和类型 - -理解反向传播的基本思想 - -### MLP结构 - -#### 什么是MLP - -**MLP (Multi-Layer Perceptron)**：多层感知机，是最基础的神经网络结构。 - -网络架构 - -`输入层`` ``隐藏层`` ``输出层`\ -` ┌─────────┐ ┌─────────────┐ ┌─────────┐`\ -` │ x₁ │ │ h₁ │ │ y₁ │`\ -` │ x₂ │───→│ h₂ │───→│ y₂ │`\ -` │ x₃ │ │ h₃ │ │ y₃ │`\ -` │ ... │ │ ... │ │ ... │`\ -` │ xₙ │ │ hₘ │ │ yₖ │`\ -` └─────────┘ └─────────────┘ └─────────┘`\ -` │ │ │`\ -` └───────────────┴────────────────┘`\ -` ``全连接（每个神经元相连）` - -#### 层次说明 - - ---------------------------------------- - 层类型 作用 神经元数量 - -------- ---------------- -------------- - 输入层 接收原始数据 取决于特征数 - - 隐藏层 特征变换与组合 自由设计 - - 输出层 产生最终结果 取决于任务 - ---------------------------------------- - -### 前向传播 - -#### 单个神经元 - -`# ``线性部分`\ -`z ``=`` ``w₁x``₁ ``+`` ``w₂x``₂ ``+`` ... ``+`` ``wₙx``ₙ ``+`` b`\ -\ -`# ``激活函数`\ -`h ``=`` σ(z)` - -#### 完整网络 - -对于L层网络： - -`# ``第``1``层` - -`h₁ ``=`` σ``₁(``W₁x`` ``+`` b₁)` - -`# ``第``2``层` - -`h₂ ``=`` σ``₂(``W₂h``₁ ``+`` b₂)` - -`# ...` - -`# ``第``L``层` - - y = σₗ(Wₗh_{l-1} + bₗ) - -#### 数据流动 - -`输入向量`` x₀`\ -` │`\ -` ├─→ W₁, b₁ ──→ z₁ = ``W₁x``₀ + b₁`\ -` │ │`\ -` │ └─→ σ₁(z₁) = h₁`\ -` │ │`\ -` └──────────────────────────────├─→ W₂, b₂ ──→ z₂ = ``W₂h``₁ + b₂`\ -` │ │`\ -` └─→ σ₂(z₂) = h₂`\ -` │`\ -` └─→ ... → y` - -### 激活函数 - -#### 为什么需要激活函数？ - -没有激活函数，多层网络就等价于单层线性变换： - -`y = W₂(``W₁x``) = (W₂W``₁)x`` = ``W'x` - -激活函数引入**非线性**，使网络能够学习复杂模式。 - -#### 常用激活函数 - - -------------------------------------------------------------------- - 激活函数 公式 特点 应用场景 - ---------- ----------------------------- ------------ -------------- - Sigmoid σ(z) = 1/(1+e⁻ᶻ) 输出(0,1) 二分类输出层 - - ReLU ReLU(z) = max(0,z) 简单高效 隐藏层首选 - - Softmax softmax(zᵢ) = eᶻⁱ/Σeᶻʲ 输出和为1 多分类输出层 - - Tanh tanh(z) = (eᶻ-e⁻ᶻ)/(eᶻ+e⁻ᶻ) 输出(-1,1) 循环网络 - -------------------------------------------------------------------- - -#### 视觉对比 - -`ReLU``: Sigmoid: Tanh:`\ -` ↑ ___ ___`\ -` │ / ╲`\ -` │ / ╲`\ -` │____ / ╲___`\ -` │ ______ / │`\ -` └──────── / └──`\ -` -``∞ 0`` +∞ -∞ 0 +∞ -∞ 0 +∞` - -### 损失函数与优化 - -#### 损失函数 - -损失函数衡量模型预测与真实值的差距： - - --------------------------------------- - 任务 损失函数 公式 - -------- ---------- ------------------- - 回归 均方误差 MSE = Σ(ŷ-y)²/n - - 二分类 交叉熵 CE = -y·log(ŷ) - - 多分类 交叉熵 CE = -Σyᵢ·log(ŷᵢ) - --------------------------------------- - -#### 优化目标 - -`最小化损失函数：`\ -`min L(f(x; θ), y)`\ -\ -`其中`` θ = {W₁, b₁, W₂, b₂, ...} ``是所有可学习参数` - -#### 梯度下降 - -`重复直到收敛：`\ -` θ = θ - α·∇L(θ)`\ -\ -`其中：`\ -` θ``：参数`\ -` α``：学习率`\ -` ∇L(θ)``：损失函数的梯度` - -### 反向传播 - -核心思想 - -从输出层向输入层反向计算梯度： - -`输出层误差`` → ``隐藏层误差`` → ... → ``输入层误差` - -链式法则 - -`∂L/∂W₁ = (∂L/∂y) · (∂y/∂h₂) · (∂h₂/∂z₂) ·`\ -` `` (``∂z₂/∂h₁) · (∂h₁/∂z₁) · (∂z₁/∂W₁)` - -直观理解 - -1.**前向传播**：计算每个神经元的输出 - -2.**计算误差**：比较输出与真实值 - -3.**反向传播**：将误差反向传递 - -4.**更新权重**：根据误差调整参数 - -### MLP vs 传统模型 - - -------------------------------------- - 特性 MLP 传统机器学习 - ------------ ---------- -------------- - 特征工程 自动学习 人工设计 - - 非线性能力 强 中/弱 - - 数据需求 大量 中等 - - 可解释性 低 高 - - 训练时间 长 短 - -------------------------------------- - -### 思考与练习 - -1.为什么隐藏层越多，网络表达能力越强？ - -2.ReLU为什么比Sigmoid更适合隐藏层？ - -3.如果所有权重初始化为0，会发生什么？ - -### 关键术语 - - ---------------------------------------------------------- - 中文 英文 说明 - ---------- ------------------ ---------------------------- - 前向传播 Forward Pass 数据从输入到输出的计算过程 - - 反向传播 Backpropagation 计算梯度的算法 - - 损失函数 Loss Function 衡量预测误差的函数 - - 梯度下降 Gradient Descent 优化算法 - - 学习率 Learning Rate 参数更新的步长 - ---------------------------------------------------------- - -### 延伸阅读 - -[Neural Networks and Deep Learning - Chapter 1](http://neuralnetworksanddeeplearning.com/chap1.html) - -[Yes you should understand backprop](https://medium.com/@karpathy/yes-you-should-understand-backprop-e2f06eab496b) \# 01.3 编程工具与Vibe Coding - ---- - -## 学习目标 - -掌握Python AI开发环境配置 - -了解核心科学计算库 - -理解Vibe Coding的AI辅助编程新模式 - -### Python环境配置 - -#### Anaconda vs Miniconda - - ----------------------------------------------- - 工具 大小 特点 适用场景 - ----------- --------- ------------ ------------ - Anaconda \~500MB 预装常用库 初学者推荐 - - Miniconda \~50MB 仅含conda 精简安装 - ----------------------------------------------- - -#### 安装步骤 - -##### 1.下载安装 - -o访问 https://www.anaconda.com/download - -o选择Python 3.x版本 - -o按提示安装 - -##### 2.创建虚拟环境 - -`conda`` create ``-n`` ai-env python=3.10`\ -`conda`` activate ai-env` - -##### 3.安装核心库 - -`conda`` install ``numpy`` pandas ``scipy`\ -`pip`` install torch ``torchvision` - -### 核心科学计算库 - -#### NumPy：数值计算基础 - -`import`` ``numpy`` ``as`` np`\ -\ -`# ``创建数组`\ -`x ``=`` ``np.array``([``1``, ``2``, ``3``, ``4``])`\ -\ -`# ``矩阵运算`\ -`W ``=`` ``np.random.randn``(``4``, ``3``) ``# 4×3``权重矩阵`\ -`h ``=`` np.dot(x, W) ``# ``矩阵乘法`\ -\ -`# ``激活函数`\ -`relu`` ``=`` ``np.maximum``(``0``, h) ``# ``ReLU` - -#### Pandas：数据处理 - -`import`` pandas ``as`` pd`\ -\ -`# ``读取数据`\ -`df`` ``=`` ``pd.read_csv``(``'data.csv'``)`\ -\ -`# ``数据清洗`\ -`df`` ``=`` ``df.dropna``()`\ -`df`` ``=`` ``df`` normalized ``=`` (``df`` ``-`` ``df.mean``()) ``/`` ``df.std``()`\ -\ -`# ``统计分析`\ -`df.describe``()` - -#### SciPy：科学计算 - -`from`` ``scipy`` ``import`` optimize`\ -`from`` ``scipy.spatial`` ``import`` distance`\ -\ -`# ``优化问题`\ -`result ``=`` ``optimize.minimize``(``loss_func``, x0)`\ -\ -`# ``距离计算`\ -`dist`` ``=`` ``distance.euclidean``(point1, point2)` - -### 开发工具选择 - -#### VSCode - -**特点**： - 微软开源，免费 - 丰富的插件生态 - 轻量级，启动快 - -**AI开发常用插件**： - Python - Jupyter - Pylance - Copilot - -## Cursor - -**特点**： - AI原生IDE - 代码补全与生成 - 自然语言编程 - -**使用场景**： - 快速原型开发 - 代码重构 - 学习新API - -## Jupyter Notebook - -**特点**： - 交互式编程 - 可视化友好 - 文档即代码 - -**使用场景**： - 数据探索 - 算法实验 - 教学演示 - -# Vibe Coding：AI辅助编程 - -## 什么是Vibe Coding - -传统编程：**明确需求 → 设计算法 → 编写代码** - -Vibe Coding：**模糊想法 → AI辅助 → 迭代完善** - -## 工作流程 - -### 1. 描述意图（自然语言） - -`"``帮我创建一个简单的神经网络``"` - -### - -`2. AI``生成代码` - -### → 自动生成完整代码框架 - -`3. ``运行测试` - -`→ ``发现问题或需要调整` - -`4. ``迭代优化` - -`"``把隐藏层改成``128``个神经元``"` - -`→ AI``自动修改代码` - -`5. ``理解学习` - - → 阅读AI生成的代码，学习最佳实践 - -## 实践技巧 - - --------------------------------- - 技巧 说明 - ---------- ---------------------- - 明确需求 详细描述输入输出 - - 分步实现 复杂功能拆解为小任务 - - 验证结果 检查生成的代码 - - 学习思考 理解AI为什么这样写 - --------------------------------- - -## 工具推荐 - - -------------------------------------------- - 工具 特点 适用场景 - ---------------- ---------------- ---------- - GitHub Copilot 代码补全 日常开发 - - Cursor 对话式编程 快速原型 - - ChatGPT/Claude 代码生成与解释 学习咨询 - - Replit Agent 端到端开发 小型项目 - -------------------------------------------- - -## 开发工作流 - -项目结构 - -`project/`\ -`├── data/ # ``数据文件`\ -`├── notebooks/ # ``Jupyter``笔记本`\ -`├── ``src``/ # ``源代码`\ -`│ ├── models/ # ``模型定义`\ -`│ ├── utils/ # ``工具函数`\ -`│ └── train.py # ``训练脚本`\ -`├── requirements.txt # ``依赖列表`\ -`└── README.md # ``项目说明` - -### 典型工作流 - -`# 1. ``创建环境`\ -`conda`` create ``-n`` ``myproject`` python=3.10`\ -`conda`` activate ``myproject`\ -\ -`# 2. ``安装依赖`\ -`pip`` install ``-r`` requirements.txt`\ -\ -`# 3. ``开发迭代`\ -`# - ``在``notebook``中实验`\ -`# - ``整理到``src``/``目录`\ -`# - ``运行测试`\ -\ -`# 4. ``保存环境`\ -`conda`` env export ``>`` ``environment.yml` - -## 思考与练习 - -1.对比Anaconda和Miniconda，什么时候该用哪个？ - -2.尝试用Cursor/Copilot生成一个简单的神经网络代码 - -3.Vibe Coding如何改变传统的编程学习方式？ - -## 关键术语 - - ----------------------------------------------------------- - 中文 英文 说明 - ---------- ----------------------- ------------------------ - 虚拟环境 Virtual Environment 隔离的Python运行环境 - - 依赖管理 Dependency Management 管理项目所需的库 - - 代码补全 Code Completion 自动补全正在输入的代码 - - 原型开发 Prototyping 快速构建可运行版本 - - 迭代优化 Iterative Refinement 逐步改进代码 - ----------------------------------------------------------- - -## 延伸阅读 - -[Anaconda官方文档](https://docs.anaconda.com/) - -[NumPy快速入门](https://numpy.org/doc/stable/user/quickstart.html) - -[Cursor使用指南](https://cursor.com/docs) diff --git a/02-framework/02-framework.md b/02-framework/02-framework.md new file mode 100644 index 0000000..37dbbca --- /dev/null +++ b/02-framework/02-framework.md @@ -0,0 +1,897 @@ +# 第2章：设计人工智能的理论框架 + +本章建立全书的核心理论框架。我们从"函数描述世界"的理念出发，引入数据模态（Data Modality）作为理解AI技术的组织原则，梳理从小模型到大模型的统一演进规律，并以多层感知机（MLP）作为一切深度学习的基础模型进行系统讲解。 + +## 篇章导读 + +理解AI不需要逐一学习每种技术。核心理念是：**所有AI技术都是围绕不同类型的数据（模态）来学习函数**。 + +无论是处理文本、图像还是三维空间数据，AI的本质工作都是一样的——从数据中学习映射函数 $y = f(x; \theta)$。区别仅在于输入数据的形态不同，因此需要不同的网络结构来高效处理。 + +本章将： +- 从函数式视角理解AI的本质 +- 建立基于数据模态的全书知识地图 +- 揭示所有AI技术背后的统一演进规律 +- 深入讲解MLP这一最基础的神经网络 +- 建立"环境-智能体-任务"实践框架，降低上手门槛 + +--- + +## 2.1 函数式AI视角 + +### 学习目标 + +- 理解"Functions Describe the World"的核心理念 +- 掌握从Excel线性回归到神经网络的演进逻辑 +- 理解数据驱动与规则驱动的根本区别 + +### 2.1.1 物理定律：用函数描述世界 + +物理学是最早用数学函数描述世界的学科。人类科学家花费数百年时间，发现了许多简洁而优美的函数关系： + +| 现象 | 函数 | 发现者 | +|------|------|--------| +| 自由落体 | $h = \frac{1}{2}gt^2$ | 伽利略 | +| 万有引力 | $F = \frac{Gm_1m_2}{r^2}$ | 牛顿 | +| 电磁感应 | $\varepsilon = -\frac{d\Phi}{dt}$ | 法拉第 | +| 质能等价 | $E = mc^2$ | 爱因斯坦 | + +这些函数的共同特点是：**用简洁的数学关系描述复杂的自然规律**。科学家通过观察现象、收集数据、提出假设，最终找到精确的函数形式。 + +### 2.1.2 AI的函数观：从数据中学习函数 + +AI延续了这一传统，但方式截然不同——**不是由人类发现函数，而是让机器从数据中自动学习函数**。 + +``` +传统科学： 观察 → 假设 → 验证 → 发现函数 f(x) +AI方法： 数据 → 训练 → 学习函数 y = f(x; θ) +``` + +在AI中，函数的一般形式为： + +$$y = f(x; \theta)$$ + +其中： +- $x$ 是**输入**（如图像、文本、传感器数据） +- $y$ 是**输出**（如分类标签、预测值、生成内容） +- $\theta$ 是**可学习参数**（通过训练自动确定） +- $f$ 是**模型结构**（我们设计的函数框架） + +关键区别在于：物理定律中的函数形式是人为确定的（如 $F=ma$），而AI中的函数形式由神经网络自动学习，参数 $\theta$ 通过海量数据训练得到。 + +### 2.1.3 从Excel线性回归到神经网络 + +这个过程可以用一个渐进的例子来理解。 + +**第一步：简单线性回归（Excel就能做）** + +预测房价，只有一个输入变量——面积： + +$$房价 \approx 0.015 \times 面积 + 50万$$ + +这就是 $y = ax + b$，最简单的线性函数。在Excel中，我们可以用趋势线功能轻松完成。 + +**第二步：多元回归** + +增加更多特征： + +$$房价 \approx 0.01 \times 面积 + 0.5 \times 卧室数 + 0.3 \times 地段评分 - 20万$$ + +这就是 $y = a_1x_1 + a_2x_2 + a_3x_3 + b$。从数学上看，这已经是**单个神经元**的完整形式。 + +**第三步：多层函数组合** + +现实世界的关系往往不是简单的线性关系。我们需要将多个函数组合起来： + +``` +h₁ = σ(W₁x + b₁) # 第一层：提取基础特征 +h₂ = σ(W₂h₁ + b₂) # 第二层：组合高级特征 +y = σ(W₃h₂ + b₃) # 第三层：输出最终结果 +``` + +这就是**多层神经网络**。每一层都在做线性变换加非线性激活，层层嵌套形成复杂的能力。 + +**Python代码示例：简单线性回归** + +```python +import numpy as np +import matplotlib.pyplot as plt + +# 生成模拟数据：面积（平方米）与房价（万元） +np.random.seed(42) +areas = np.random.uniform(50, 200, 100) # 50-200平方米 +prices = 0.015 * areas + 50 + np.random.normal(0, 10, 100) # 加入噪声 + +# 使用最小二乘法拟合线性函数 y = ax + b +X = np.column_stack([areas, np.ones_like(areas)]) # 构造设计矩阵 +theta = np.linalg.lstsq(X, prices, rcond=None)[0] # 求解参数 + +a, b = theta +print(f"学到的函数: 房价 = {a:.4f} × 面积 + {b:.2f}") +print(f"真实函数: 房价 = 0.0150 × 面积 + 50.00") + +# 可视化 +plt.figure(figsize=(8, 5)) +plt.scatter(areas, prices, alpha=0.5, label='数据点') +plt.plot(areas, a * areas + b, 'r-', linewidth=2, label=f'拟合: y={a:.4f}x+{b:.1f}') +plt.xlabel('面积（平方米）') +plt.ylabel('房价（万元）') +plt.title('线性回归：从数据中学习函数') +plt.legend() +plt.grid(True, alpha=0.3) +plt.show() +``` + +这段代码展示了一个完整的"从数据中学习函数"的过程。虽然这只是最简单的线性回归，但它已经包含了AI的核心思想：**给定数据，自动确定函数参数**。 + +### 2.1.4 数据驱动 vs 规则驱动 + +这是理解AI最重要的思维转变。 + +**规则驱动（传统编程）** + +```python +# 传统方式：人工编写判断规则 +def classify_design_style(image): + if has_minimal_lines(image) and is_monochrome(image): + return "极简主义" + elif has_curved_forms(image) and is_colorful(image): + return "波普风格" + # ... 需要穷举所有情况 + return "未知风格" +``` + +问题： +- 规则难以穷举所有情况 +- 边界情况（edge case）无法覆盖 +- 无法处理模糊和不确定的情况 +- 维护成本随复杂度指数增长 + +**数据驱动（AI方法）** + +```python +# AI方式：从标注数据中自动学习 +model = NeuralNetwork() +model.train(thousands_of_labeled_images) # 从数据中学习规律 +result = model.predict(new_image) # 自动判断 +``` + +优势： +- 自动发现人类难以表达的规律 +- 数据越多，性能越好 +- 可以处理复杂的、非线性的关系 +- 适应性强，可迁移到新任务 + +> **设计思维的转变**：从"设计规则"到"设计数据"。在AI时代，设计师不仅要设计规则（设计语言、规范），还要设计和管理训练数据，因为数据决定了AI学到的函数。 + +--- + +## 2.2 数据模态全景 + +### 学习目标 + +- 理解数据模态（Data Modality）的概念 +- 建立全书各章节之间的知识地图 +- 理解为什么数据模态是组织AI知识的有效框架 + +### 2.2.1 什么是数据模态 + +**模态（Modality）** 是指信息的存在形式和感知方式。人类通过不同感官感知不同模态的信息：耳朵感知声音（一维时间序列），眼睛感知图像（二维像素矩阵），身体感知空间（三维坐标）。 + +AI同样需要针对不同模态的数据采用不同的处理方式。一种数据模态决定了： + +1. **数据的组织形式**：文本是符号序列，图像是像素矩阵，三维数据是点云或网格 +2. **适合的网络结构**：序列数据用RNN/Transformer，图像用CNN/ViT，空间数据用PointNet +3. **典型的应用场景**：翻译、分类、检测、生成等 +4. **评估标准**：不同任务的评估指标不同 + +因此，**数据模态是理解AI技术最自然的组织框架**。 + +### 2.2.2 六大数据模态 + +本书后续章节将围绕以下六大数据模态展开： + +| 模态 | 数据维度 | 数据类型 | 输入形式 | 代表模型（小→大） | 设计应用 | 对应章节 | +|------|---------|---------|---------|-------------------|---------|---------| +| **一维：文本与序列** | 1D | 文本、时间序列、音乐 | Token序列 | RNN → LSTM → BERT → GPT-4 | 设计文本生成、用户评论分析、设计趋势预测 | 第3章 | +| **二维：图像与视觉** | 2D | 图像、视觉设计稿 | 像素矩阵 | LeNet → ResNet → ViT → SAM | 图像分类、目标检测、风格迁移、设计评估 | 第4章 | +| **三维：空间与几何** | 3D | 点云、网格、体素 | 3D坐标集 | PointNet → DGCNN → Point Transformer | 三维重建、空间分析、建筑设计、数字孪生 | 第5章 | +| **决策序列** | 时序决策 | 状态-动作对 | 状态→动作映射 | Q-Learning → DQN → PPO → AlphaGo | 布局优化、参数调优、自适应设计 | 第6章 | +| **生成** | 创造性输出 | 图像、文本、音频 | 噪声/条件 | VAE → GAN → Diffusion → Sora | AIGC设计、概念生成、风格迁移、设计探索 | 第7章 | +| **行动序列** | 多步行动 | 任务-工具-行动链 | 目标→计划→执行 | ReAct → Toolformer → AutoGPT → GPT-4V | 智能设计助手、自动化工作流、多Agent协作 | 第8章 | + +### 2.2.3 模态之间的关系 + +这六种模态并非孤立存在，它们之间存在密切的内在联系： + +``` + ┌──────────────┐ + │ 一维：序列 │ + │ （第3章） │ + └──────┬───────┘ + │ 序列化的基础 + ┌──────┴───────┐ + │ 二维：视觉 │ + │ （第4章） │ + └──────┬───────┘ + │ 空间维度的扩展 + ┌──────┴───────┐ + │ 三维：空间 │ + │ （第5章） │ + └──────┬───────┘ + │ + ┌────────────┼────────────┐ + │ │ │ + ┌──────┴──────┐ ┌──┴───┐ ┌──────┴──────┐ + │ 决策序列 │ │ 生成 │ │ 行动序列 │ + │ （第6章） │ │(第7章)│ │ （第8章） │ + └─────────────┘ └──────┘ └─────────────┘ +``` + +**从感知到行动的逻辑链条**： +- **一维到三维**是感知智能的递进——从理解语言、识别图像到感知空间 +- **决策序列**将感知转化为行动策略——在环境中做出最优选择 +- **生成**突破感知的局限——不仅理解，还能创造新内容 +- **行动序列**整合所有能力——感知、规划、执行形成闭环 + +### 2.2.4 为什么模态是有用的组织原则 + +**第一，降低学习门槛。** 不需要一次性理解所有AI技术，只需要按数据类型逐一学习。理解了文本处理的方法后，很多概念可以直接迁移到图像处理。 + +**第二，揭示统一规律。** 虽然不同模态使用的网络结构不同，但背后遵循相同的学习范式——都是从小模型到大模型的演进（见2.3节）。 + +**第三，对应设计实践。** 设计师日常接触的信息天然是按模态划分的：文字（设计说明）、图像（效果图）、三维模型（空间设计）。按模态组织知识，便于直接找到所需技术。 + +**第四，预见技术趋势。** 理解了模态框架，就能更好地理解多模态（Multimodal）AI的发展方向——让AI同时处理多种模态的数据，正如人类同时用视觉、听觉和触觉感知世界。 + +--- + +## 2.3 小模型到大模型的演进规律 + +### 学习目标 + +- 理解AI技术发展的四个阶段 +- 认识到不同模态背后存在统一的演进规律 +- 建立对当前大模型时代的技术定位 + +### 2.3.1 四个发展阶段 + +纵观AI各个模态的发展历程，可以提炼出一个统一的四阶段演进模式： + +**第一阶段：手工特征时代（Hand-crafted Features）** + +人类专家根据领域知识，手工设计特征提取方法。例如，图像处理中的边缘检测算子（Sobel、Canny）、纹理特征（HOG、SIFT），自然语言处理中的词袋模型（Bag of Words）、TF-IDF等。 + +特点： +- 特征由人类专家精心设计 +- 每个特征都有明确的物理含义 +- 性能受限于人类的领域知识和表达能力 +- 适合数据量小、计算资源有限的场景 + +**第二阶段：自动学习时代（Deep Learning）** + +深度学习让模型自动从原始数据中学习特征。卷积神经网络（CNN）自动学习图像特征，循环神经网络（RNN）自动学习序列特征。 + +特点： +- 特征由网络自动学习，无需人工设计 +- 端到端（End-to-End）的训练方式 +- 需要大量标注数据 +- 性能大幅超越手工特征方法 + +**第三阶段：预训练时代（Pre-training）** + +通过在大规模无标注数据上的预训练，模型学习通用知识，再通过微调（Fine-tuning）适配具体任务。迁移学习使得少量标注数据也能获得优秀性能。 + +特点： +- 先预训练学通用知识，再微调适配任务 +- 大幅减少对标注数据的依赖 +- 模型开始具备迁移和泛化能力 +- "预训练+微调"成为标准范式 + +**第四阶段：大模型时代（Foundation Models）** + +参数规模达到十亿甚至万亿级别的模型，展现出"涌现能力"（Emergent Abilities）——模型规模大到一定程度后，突然具备了小模型没有的新能力。 + +特点： +- 单一模型处理多种任务（通用性） +- 涌现能力：规模带来质变 +- 少样本甚至零样本学习 +- Scaling Law：性能随规模持续提升 + +### 2.3.2 四阶段对比 + +| 维度 | 手工特征时代 | 自动学习时代 | 预训练时代 | 大模型时代 | +|------|------------|------------|-----------|-----------| +| **特征提取方式** | 人工设计 | 自动学习 | 预训练+微调 | 涌现学习 | +| **数据需求** | 少量标注数据 | 大量标注数据 | 大量无标注+少量标注 | 海量多模态数据 | +| **计算资源** | CPU即可 | 需要GPU | 需要多GPU | 需要大规模集群 | +| **模型特点** | 任务专用 | 任务专用但自动 | 可迁移 | 通用基础模型 | +| **典型模型** | SIFT、HOG、TF-IDF | AlexNet、LSTM | BERT、ResNet | GPT-4、SAM、Sora | +| **设计影响** | 基础图像处理 | 自动化设计分析 | 设计知识迁移 | 通用设计智能 | + +### 2.3.3 不同模态的演进路径 + +每种模态都经历了相同的四个阶段，只是时间线略有不同： + +**文本与序列（一维）** + +``` +手工特征 自动学习 预训练 大模型 +TF-IDF → Word2Vec → BERT (2018) → GPT-4 (2023) +词袋模型 LSTM/GRU ELMo Claude +N-gram Seq2Seq T5 Llama +``` + +**图像与视觉（二维）** + +``` +手工特征 自动学习 预训练 大模型 +SIFT → AlexNet → ResNet → SAM (2023) +HOG VGGNet EfficientNet DINOv2 +Canny边缘 YOLO CLIP GPT-4V +``` + +**三维空间（三维）** + +``` +手工特征 自动学习 预训练 大模型 +FPFH → PointNet → Point-BERT → Point-E +3D形状上下文 DGCNN Point-MAE Shape-E +体素特征 PointNet++ ULIP LRM +``` + +**生成模型** + +``` +手工特征 自动学习 预训练 大模型 +规则模板 → VAE/GAN → StyleGAN → Stable Diffusion +马尔可夫链 PixelCNN BigGAN DALL-E 3 +分形算法 CycleGAN Craiyon Sora +``` + +> **关键洞察**：无论哪种模态，发展路径都遵循相同的规律——从人工设计到自动学习，从专用到通用，从小规模到大规模。理解了这个规律，即使面对全新的AI技术，也能快速定位它所处的阶段和意义。 + +### 2.3.4 对设计师的启示 + +1. **不要被具体模型名称迷惑**。模型千变万化，但底层逻辑相同。重要的是理解它属于哪个阶段、处理什么模态的数据。 + +2. **关注趋势而非细节**。AI技术迭代极快，具体的模型可能很快过时，但从手工到自动、从小到大的趋势不会改变。 + +3. **预训练时代是设计师的最佳入口**。利用预训练模型，设计师不需要海量数据和强大算力，就能将AI应用到设计实践中。 + +4. **大模型时代带来"民主化"**。大模型通过自然语言交互降低了AI的使用门槛，设计师可以用自然语言指挥AI完成设计任务。 + +--- + +## 2.4 MLP：一切的基础 + +### 学习目标 + +- 理解多层感知机（MLP）的网络架构 +- 掌握前向传播的计算过程 +- 了解激活函数、损失函数和反向传播的基本原理 +- 建立对神经网络训练过程的完整认知 + +### 2.4.1 为什么MLP如此重要 + +多层感知机（Multi-Layer Perceptron, MLP）是最基础的神经网络结构。虽然现代AI使用CNN、Transformer等更复杂的架构，但它们的底层构件仍然是MLP中的基本操作：线性变换、非线性激活、损失计算和梯度更新。 + +**理解MLP是理解所有深度学习的起点。** + +``` +MLP（多层感知机） + │ + ├── CNN（卷积神经网络）= 局部连接的MLP + 权重共享 + │ + ├── RNN（循环神经网络）= 共享参数的MLP + 时间展开 + │ + └── Transformer = 注意力机制 + MLP +``` + +### 2.4.2 网络架构 + +MLP由三种类型的层组成： + +``` +输入层 隐藏层1 隐藏层2 输出层 +┌─────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────┐ +│ x₁ │ │ h₁ │ │ g₁ │ │ y₁ │ +│ x₂ │───→│ h₂ │──→│ g₂ │──→│ y₂ │ +│ x₃ │ │ h₃ │ │ g₃ │ │ y₃ │ +│ ... │ │ ... │ │ ... │ │ ... │ +│ xₙ │ │ hₘ │ │ gₖ │ │ yₚ │ +└─────────┘ └─────────────┘ └─────────────┘ └─────────┘ + │ │ │ │ + └───────────────┴─────────────────┴────────────────┘ + 全连接（Fully Connected）：每个神经元与上一层所有神经元相连 +``` + +各层的作用： + +| 层类型 | 作用 | 神经元数量 | +|--------|------|-----------| +| 输入层 | 接收原始数据，每个神经元对应一个特征 | 取决于数据特征数（如图像像素数） | +| 隐藏层 | 特征变换与组合，逐步提取高级特征 | 可自由设计（超参数） | +| 输出层 | 产生最终预测结果 | 取决于任务（分类数或回归值数） | + +**设计类比**：可以把MLP想象为设计方案的评审流程。输入层是原始需求，隐藏层是不同维度的评估（功能、美学、可行性），输出层是最终的评分或决策。每一层都在对信息进行加工和抽象。 + +### 2.4.3 前向传播 + +前向传播（Forward Propagation）是数据从输入层经过各隐藏层到达输出层的计算过程。 + +**单个神经元的计算** + +每个神经元执行两个操作： + +``` +步骤1：线性变换 z = W₁x₁ + W₂x₂ + ... + Wₙxₙ + b = Wx + b +步骤2：非线性激活 h = σ(z) +``` + +其中 $W$ 是权重（Weight），$b$ 是偏置（Bias），$\sigma$ 是激活函数（Activation Function）。 + +**完整网络的前向传播** + +对于L层网络，前向传播逐层计算： + +``` +# 第1层 +h₁ = σ₁(W₁ · x + b₁) + +# 第2层 +h₂ = σ₂(W₂ · h₁ + b₂) + +# ... 第l层 +hₗ = σₗ(Wₗ · hₗ₋₁ + bₗ) + +# 输出层 +y = hₗ +``` + +用更简洁的函数组合表示： + +$$y = f_L(f_{L-1}(\cdots f_2(f_1(x))\cdots))$$ + +**数据流动示意** + +``` +输入向量 x + │ + ├─→ 线性变换: z₁ = W₁x + b₁ + │ │ + │ └─→ 激活函数: h₁ = σ(z₁) + │ │ + │ └─→ 线性变换: z₂ = W₂h₁ + b₂ + │ │ + │ └─→ 激活函数: h₂ = σ(z₂) + │ │ + │ └─→ ... → y（输出） +``` + +**Python代码示例：手动实现前向传播** + +```python +import numpy as np + +def sigmoid(x): + """Sigmoid激活函数""" + return 1 / (1 + np.exp(-x)) + +def relu(x): + """ReLU激活函数""" + return np.maximum(0, x) + +# 定义一个简单的3层MLP +# 输入: 4维 → 隐藏层1: 8个神经元 → 隐藏层2: 4个神经元 → 输出: 2维 + +# 初始化权重和偏置（实际中由训练得到） +W1 = np.random.randn(8, 4) * 0.01 # (8, 4) +b1 = np.zeros((8, 1)) # (8, 1) +W2 = np.random.randn(4, 8) * 0.01 # (4, 8) +b2 = np.zeros((4, 1)) # (4, 1) +W3 = np.random.randn(2, 4) * 0.01 # (2, 4) +b3 = np.zeros((2, 1)) # (2, 1) + +# 输入数据（4个特征） +x = np.array([[0.5], [0.3], [0.8], [0.1]]) # (4, 1) + +# 前向传播 +z1 = np.dot(W1, x) + b1 # 线性变换 +h1 = relu(z1) # ReLU激活 +z2 = np.dot(W2, h1) + b2 # 线性变换 +h2 = relu(z2) # ReLU激活 +z3 = np.dot(W3, h2) + b3 # 线性变换 +y = sigmoid(z3) # Sigmoid激活（输出层） + +print(f"输入: {x.flatten()}") +print(f"隐藏层1输出: {h1.flatten()}") +print(f"隐藏层2输出: {h2.flatten()}") +print(f"最终输出: {y.flatten()}") +``` + +### 2.4.4 激活函数 + +激活函数（Activation Function）是神经网络的"灵魂"。没有激活函数，无论网络有多少层，都等价于一个单层线性变换： + +$$y = W_2(W_1x) = (W_2W_1)x = W'x$$ + +激活函数引入**非线性**，使网络能够拟合任意复杂的函数关系。 + +**常用激活函数对比** + +| 激活函数 | 公式 | 输出范围 | 特点 | 典型应用 | +|---------|------|---------|------|---------| +| Sigmoid | $\sigma(z) = \frac{1}{1+e^{-z}}$ | (0, 1) | 输出可解释为概率；两端梯度消失 | 二分类输出层 | +| ReLU | $\text{ReLU}(z) = \max(0, z)$ | [0, +∞) | 计算简单高效；缓解梯度消失 | **隐藏层首选** | +| Tanh | $\tanh(z) = \frac{e^z - e^{-z}}{e^z + e^{-z}}$ | (-1, 1) | 零中心化；两端梯度消失 | 循环网络隐藏层 | +| Softmax | $\text{softmax}(z_i) = \frac{e^{z_i}}{\sum_j e^{z_j}}$ | (0, 1)，和为1 | 输出为概率分布 | 多分类输出层 | +| LeakyReLU | $\text{LeakyReLU}(z) = \max(\alpha z, z)$ | (-∞, +∞) | 解决ReLU"死神经元"问题 | 深层网络隐藏层 | + +**视觉对比** + +``` +ReLU: Sigmoid: Tanh: + ↑ ___ ___ + │ / \ / \ + │ / \ / \ + │ ____ / \ ____ / \ ____ + │___________| │ │ │ │ + └───────────┼──→ └──────────┘ └────────────────────┘ + -∞ 0 +∞ -∞ 0 +∞ -∞ 0 +∞ + +特点：简单，计算快 特点：平滑，输出(0,1) 特点：零中心，输出(-1,1) +正区间梯度恒为1 两端梯度趋近于0 两端梯度趋近于0 +负区间输出为0 可能导致梯度消失 可能导致梯度消失 +``` + +> **设计类比**：激活函数就像是设计中的"非线性思维"。如果只有线性思维（没有激活函数），无论思考多少层，结论都是线性的——就像在一条直线上来回走。激活函数引入了"跳跃"和"拐弯"的能力，让网络能够表达复杂的设计关系。 + +### 2.4.5 损失函数 + +损失函数（Loss Function）衡量模型预测值与真实值之间的差距，是训练过程的"指南针"。 + +**常用损失函数** + +| 任务类型 | 损失函数 | 公式 | 直观含义 | +|---------|---------|------|---------| +| 回归 | 均方误差 (MSE) | $L = \frac{1}{n}\sum_{i=1}^{n}(\hat{y}_i - y_i)^2$ | 预测值与真实值差的平方平均 | +| 二分类 | 二元交叉熵 (BCE) | $L = -[y\log\hat{y} + (1-y)\log(1-\hat{y})]$ | 预测概率与真实标签的偏差 | +| 多分类 | 交叉熵 (CE) | $L = -\sum_{i=1}^{C}y_i\log\hat{y}_i$ | 预测分布与真实分布的差距 | + +其中 $\hat{y}$ 是模型预测值，$y$ 是真实值。 + +**损失函数的直观理解** + +``` +好的预测： 差的预测： +预测值: ■ 预测值: ■ +真实值: ■ 真实值: ■ +损失小: | 损失大: |---------| +→ 参数调整小 → 参数需要大幅调整 +``` + +### 2.4.6 反向传播与梯度下降 + +反向传播（Backpropagation）是训练神经网络的核心算法，它解决了"如何高效计算每个参数对损失的影响程度"这一问题。 + +**核心思想：梯度下降** + +训练目标是最小化损失函数。梯度下降的思想是：沿着损失函数梯度（下降最快的方向）的相反方向更新参数。 + +$$\theta = \theta - \alpha \nabla L(\theta)$$ + +其中： +- $\theta$：模型的所有可学习参数（权重 $W$ 和偏置 $b$） +- $\alpha$：学习率（Learning Rate），控制每次更新的步长 +- $\nabla L(\theta)$：损失函数对参数的梯度 + +**直观理解** + +想象你站在山上某处（当前参数值），目标是到达谷底（最小损失）。梯度下降就是： +- 观察脚下地面的坡度（计算梯度） +- 沿着最陡的下坡方向走一步（参数更新） +- 重复以上步骤直到到达谷底（收敛） + +``` +损失 L + │ ╲ + │ ╲ ╱╲ + │ ╲╱ ╲ ← 梯度下降的路径 + │ ╲ ╲ ╱ + │ ╲ ╲╱ + │ ╲ + └───────────────→ 参数 θ +``` + +**反向传播：高效计算梯度** + +反向传播利用**链式法则（Chain Rule）**，从输出层向输入层反向逐层计算梯度： + +``` +前向传播（计算输出）： + x → h₁ → h₂ → ... → y → L（损失） + +反向传播（计算梯度）： + ∂L/∂y → ∂L/∂h₂ → ∂L/∂h₁ → ∂L/∂x（每步用链式法则） +``` + +链式法则的具体形式： + +$$\frac{\partial L}{\partial W_1} = \frac{\partial L}{\partial y} \cdot \frac{\partial y}{\partial h_2} \cdot \frac{\partial h_2}{\partial h_1} \cdot \frac{\partial h_1}{\partial W_1}$$ + +**训练循环的四个步骤** + +``` +1. 前向传播：用当前参数计算预测值 y = f(x; θ) +2. 计算损失：比较预测值与真实值 L = loss(y, ŷ) +3. 反向传播：计算损失对所有参数的梯度 ∂L/∂θ +4. 参数更新：沿梯度反方向更新参数 θ = θ - α·∂L/∂θ + +重复以上步骤，直到损失不再显著下降（收敛） +``` + +**Python代码示例：完整的训练循环** + +```python +import numpy as np + +# ===== 1. 准备数据 ===== +# 模拟数据：用y = 2x₁ + 3x₂ + 1生成 +np.random.seed(42) +X = np.random.randn(100, 2) # 100个样本，2个特征 +y_true = 2 * X[:, 0:1] + 3 * X[:, 1:2] + 1 # 真实值 +y_true += np.random.normal(0, 0.1, y_true.shape) # 加入噪声 + +# ===== 2. 初始化参数 ===== +W = np.random.randn(2, 1) * 0.01 # 权重 (2, 1) +b = np.zeros((1, 1)) # 偏置 (1, 1) +learning_rate = 0.01 # 学习率 + +# ===== 3. 训练循环 ===== +for epoch in range(500): + # 前向传播 + y_pred = np.dot(X, W) + b # 线性变换: z = Wx + b + + # 计算损失（均方误差） + loss = np.mean((y_pred - y_true) ** 2) + + # 反向传播（计算梯度） + dL_dy = 2 * (y_pred - y_true) / len(X) # 损失对输出的梯度 + dL_dW = np.dot(X.T, dL_dy) # 损失对W的梯度 + dL_db = np.sum(dL_dy, axis=0, keepdims=True) # 损失对b的梯度 + + # 参数更新（梯度下降） + W = W - learning_rate * dL_dW + b = b - learning_rate * dL_db + + # 每100轮打印一次 + if (epoch + 1) % 100 == 0: + print(f"第 {epoch+1:3d} 轮 | 损失: {loss:.6f} " + f"| W: [{W[0,0]:.4f}, {W[1,0]:.4f}] | b: {b[0,0]:.4f}") + +print(f"\n学到的参数: W = {W.flatten()}, b = {b.flatten()}") +print(f"真实参数: W = [2.0, 3.0], b = [1.0]") +``` + +输出示例： +``` +第 100 轮 | 损失: 0.352148 | W: [1.5234, 2.3456] | b: 0.8765 +第 200 轮 | 损失: 0.053421 | W: [1.8765, 2.8234] | b: 0.9654 +第 300 轮 | 损失: 0.008756 | W: [1.9654, 2.9567] | b: 0.9932 +第 400 轮 | 损失: 0.001543 | W: [1.9923, 2.9891] | b: 0.9987 +第 500 轮 | 损失: 0.000287 | W: [1.9985, 2.9978] | b: 0.9997 + +学到的参数: W = [1.9985, 2.9978], b = [0.9997] +真实参数: W = [2.0, 3.0], b = [1.0] +``` + +可以看到，经过500轮训练，模型学到的参数已经非常接近真实值。 + +### 2.4.7 MLP的局限性 + +虽然MLP是理解神经网络的基础，但它也存在明显的局限性： + +1. **参数量爆炸**：处理高维输入（如高清图像）时，全连接导致参数量过大 +2. **忽略数据结构**：将图像展平成一维向量会丢失空间结构信息 +3. **缺乏平移不变性**：物体在图像中移动后，需要重新学习 +4. **难以处理序列数据**：没有处理时序依赖的机制 + +正是这些局限性，催生了后续的CNN（处理图像）、RNN（处理序列）、Transformer（处理通用序列）等更专业的架构。但它们的底层原理都与MLP一脉相承。 + +--- + +## 2.5 环境-智能体-任务：AI实践的三元框架 + +### 学习目标 + +- 理解"环境-智能体-任务"三元框架 +- 认识环境配置是AI实践中的关键瓶颈 +- 掌握降低环境门槛的实用策略 +- 了解推荐的学习资源与平台 + +### 2.5.1 三元框架的提出 + +学习AI技术可以抽象为一个三元交互模型：**环境（Environment）— 智能体（Agent）— 任务（Task）**。 + +``` +┌──────────────────────────────────────────────────┐ +│ │ +│ ┌──────────┐ 执行任务 ┌──────────┐ │ +│ │ 智能体 │ ──────────────→ │ 任务 │ │ +│ │ (Agent) │ ←────────────── │ (Task) │ │ +│ │ │ 返回结果 │ │ │ +│ └────┬─────┘ └──────────┘ │ +│ │ 感知 │ │ +│ ▼ │ │ +│ ┌──────────┐ │ │ +│ │ 环境 │ ◄───────────────────┘ │ +│ │(Environ.)│ 环境反馈 │ +│ └──────────┘ │ +│ │ +└──────────────────────────────────────────────────┘ +``` + +三个要素的含义： + +| 要素 | 含义 | AI学习中的具体体现 | +|------|------|-------------------| +| **环境** | 智能体所处的操作空间 | Python环境、GPU资源、数据集、网络连接 | +| **智能体** | 执行任务的学习者 | 设计专业学生、设计师、研究人员 | +| **任务** | 需要完成的目标 | 运行一个CNN分类器、训练一个生成模型、部署一个Agent | + +这个框架不仅适用于强化学习中的智能体（见第6章），也适用于**人类学习AI的过程**：学习者（智能体）需要在一个合适的环境（计算环境）中完成学习任务。 + +### 2.5.2 环境配置：被忽视的瓶颈 + +对于计算机专业的学生，搭建Python环境、安装PyTorch、下载预训练模型可能只是日常操作。但对于**设计专业学生**而言，环境配置往往成为学习AI的最大障碍： + +``` +设计学生尝试运行一个图像分类示例： + + 1. 安装Python → 版本冲突（3.8? 3.9? 3.11?） + 2. 安装pip包 → 权限报错 / 网络超时 + 3. pip install torch → 下载2GB，断线重连3次 + 4. 下载预训练权重 → 需要HuggingFace账号 / 网络限制 + 5. CUDA版本不匹配 → "torch.cuda.is_available() = False" + 6. import cv2报错 → 缺少系统依赖 + 7. 终于跑通 → 已经精疲力竭，失去了学习兴趣 +``` + +**典型痛点清单**： + +| 痛点 | 具体表现 | 严重程度 | +|------|---------|---------| +| Python版本管理 | 多版本共存导致路径混乱 | ★★★★ | +| 包依赖冲突 | numpy版本不兼容PyTorch | ★★★★ | +| GPU/CUDA配置 | 驱动版本与CUDA版本不匹配 | ★★★★★ | +| 数据下载 | 大型数据集下载慢、需要代理 | ★★★★ | +| 网络环境 | HuggingFace/Google Colab访问受限 | ★★★★ | +| 系统差异 | Windows/Mac/Linux命令不同 | ★★★ | +| 内存不足 | 本地机器无法运行大模型 | ★★★★ | + +> **核心观点**：环境问题不是"技术能力不足"的问题，而是**基础设施鸿沟**。正如设计师不需要理解CAD软件的底层渲染引擎才能画图，学习AI也不应该被环境配置阻挡在门外。 + +### 2.5.3 降低门槛的实践策略 + +针对以上痛点，推荐以下策略： + +**策略一：使用云端开发环境** + +| 平台 | 特点 | 适用场景 | 费用 | +|------|------|---------|------| +| Google Colab | 免费GPU、即开即用 | 快速实验、课程练习 | 免费/Pro版$10/月 | +| Kaggle Notebooks | 免费GPU、数据集内置 | 竞赛学习、数据分析 | 免费 | +| 阿里云天池 | 国内访问快、中文社区 | 国内课程、中文教程 | 免费额度 | +| AutoDL / 矩池云 | 国内GPU租用 | 训练大模型、长时间训练 | 按量计费 | + +**策略二：使用Vibe Coding工具链** + +本书附录2详细介绍了Vibe Coding（感觉驱动编程）的理念和工具链。核心思想是：**让AI辅助编程，降低代码编写的门槛**。 + +- **Claude Code**：用自然语言描述需求，AI自动生成代码 +- **Cursor / GitHub Copilot**：IDE内AI辅助编程 +- **Jupyter Notebook**：交互式编程，所见即所得 + +**策略三：使用容器化环境** + +```bash +# 一行命令启动预配置的AI开发环境（需安装Docker） +docker run -it -p 8888:8888 pytorch/pytorch:latest + +# 或使用 conda 快速创建隔离环境 +conda create -n ai-design python=3.10 +conda activate ai-design +conda install pytorch torchvision -c pytorch +``` + +容器化确保环境一致性——一次配置，到处运行。 + +**策略四：渐进式学习路径** + +``` +零门槛入门 进阶实践 深度开发 +───────────────────────────────────────────────────── +Google Colab → 本地Python环境 → GPU服务器 +自然语言编程 → Vibe Coding → 原生代码编写 +在线Notebook → Jupyter本地 → IDE (VSCode) +调用API → 加载预训练模型 → 微调训练 +小数据集实验 → 设计数据集构建 → 大规模训练 +``` + +> **建议**：初学阶段不必强求本地环境配置完整。先在云端环境跑通案例、建立直觉，再逐步搭建本地环境。 + +### 2.5.4 推荐学习资源 + +以下资源可以作为本章和后续章节的补充学习材料： + +**机器学习与深度学习系统课程** + +| 资源 | 特点 | 链接 | +|------|------|------| +| Datawhale Bishop DL | 基于Bishop《深度学习》的中文笔记，覆盖概率论、回归、分类、DNN、CNN、Transformer | [dive-into-bishop-dl](https://datawhalechina.github.io/dive-into-bishop-dl/) | +| Ai-learn | 完整的AI学习路线图，从数学基础到深度学习实战 | [Ai-learn](https://github.com/tangyudi/Ai-learn) | +| 3Blue1Brown 神经网络 | 顶级可视化讲解，建立直觉理解 | [YouTube](https://www.youtube.com/playlist?list=PLZHQObOWTQDNU6R1_67000Dx_ZCJB-3pi) | +| 李宏毅机器学习 | 中文讲解，理论与应用并重 | [YouTube](https://www.youtube.com/c/HungyiLeeNTU) | +| fast.ai | 顶向下教学，先实践后理论 | [course.fast.ai](https://course.fast.ai/) | +| d2l.ai（动手学深度学习） | 代码驱动，PyTorch/MXNet/TensorFlow多框架 | [d2l.ai](https://d2l.ai/) | + +**设计领域AI资源** + +| 资源 | 说明 | +|------|------| +| Hugging Face | 模型和数据集的"GitHub"，可在线体验 | +| Civitai | Stable Diffusion模型分享社区 | +| Papers With Code | 论文+代码+排行榜，追踪最新技术 | + +> **学习方法建议**：不要试图一次性学完所有资源。根据当前章节的学习进度，选择1-2个配套资源即可。例如，学习第3章（Transformer）时，可以对照 Datawhale Bishop DL 中对应的章节加深理解。 + +--- + +## 思考与练习 + +1. **函数思维练习**：请列举3个设计领域中的例子，说明它们可以用函数 $y = f(x; \theta)$ 来描述。思考输入 $x$、输出 $y$ 和需要学习的参数 $\theta$ 分别是什么。 + +2. **模态映射练习**：选择一个你熟悉的设计项目（如建筑设计、产品设计或平面设计），分析该项目涉及哪些数据模态（一维/二维/三维/决策/生成/行动），以及每种模态在该项目中的作用。 + +3. **演进规律思考**：回顾2.3节中介绍的四个发展阶段。在你关注的设计领域，AI技术目前处于哪个阶段？未来会如何演进？请给出你的分析和理由。 + +4. **环境-智能体-任务练习**：规划你的AI学习路径。评估你当前的计算环境（笔记本配置、网络条件），选择最适合你的入门策略（云端/本地/Vibe Coding），并设定一个本周可完成的小任务（如在Colab上运行一个图像分类示例）。 + +--- + +## 关键术语 + +| 中文 | 英文 | 说明 | +|------|------|------| +| 数据模态 | Data Modality | 信息的存在形式，如文本、图像、三维等 | +| 线性回归 | Linear Regression | $y = ax + b$ 形式的函数拟合 | +| 多元回归 | Multiple Regression | 多输入变量的线性模型 $y = \sum a_ix_i + b$ | +| 多层感知机 | Multi-Layer Perceptron (MLP) | 最基础的前馈神经网络结构 | +| 前向传播 | Forward Propagation | 数据从输入层到输出层的计算过程 | +| 激活函数 | Activation Function | 引入非线性的函数，如ReLU、Sigmoid | +| 损失函数 | Loss Function | 衡量预测值与真实值差距的函数 | +| 反向传播 | Backpropagation | 利用链式法则计算梯度的算法 | +| 梯度下降 | Gradient Descent | 沿梯度反方向更新参数的优化方法 | +| 学习率 | Learning Rate | 梯度下降中控制参数更新步长的超参数 | +| 权重 | Weight | 神经元之间连接的可学习参数 | +| 偏置 | Bias | 调整输出基准的可学习参数 | +| 特征工程 | Feature Engineering | 人工设计和提取数据特征的过程 | +| 迁移学习 | Transfer Learning | 将一个任务学到的知识迁移到新任务 | +| 基础模型 | Foundation Model | 在大规模数据上预训练的大型通用模型 | +| 涌现能力 | Emergent Abilities | 模型规模大到一定程度后出现的新能力 | +| 缩放定律 | Scaling Law | 模型性能与规模（数据量、参数量、计算量）之间的关系规律 | +| 环境-智能体-任务 | Environment-Agent-Task | AI实践的三元框架：环境提供操作空间，智能体执行任务，任务定义目标 | +| Vibe Coding | Vibe Coding | 感觉驱动编程，用自然语言描述需求让AI生成代码的编程范式 | +| 全连接层 | Fully Connected Layer | 每个神经元与上一层所有神经元相连的网络层 | +| 预训练 | Pre-training | 在大规模数据上的初始训练阶段 | +| 微调 | Fine-tuning | 在特定任务数据上对预训练模型进行适配训练 | + +--- + +## 延伸阅读 + +- [Neural Networks and Deep Learning](http://neuralnetworksanddeeplearning.com/) — Michael Nielsen 的在线教材，直观讲解神经网络原理 +- [Scaling Laws for Neural Language Models](https://arxiv.org/abs/2001.08361) — Kaplan et al., 2020，Scaling Law 的经典论文 +- [On the Opportunities and Risks of Foundation Models](https://arxiv.org/abs/2108.07258) — Stanford HAI 报告，全面介绍基础模型 +- [3Blue1Brown: But what is a Neural Network?](https://www.youtube.com/watch?v=aircAruvnKk) — 优秀的神经网络可视化讲解视频 diff --git a/03-1d-sequence/03-1d-sequence.md b/03-1d-sequence/03-1d-sequence.md new file mode 100644 index 0000000..9d3545f --- /dev/null +++ b/03-1d-sequence/03-1d-sequence.md @@ -0,0 +1,1595 @@ +# 第3章：一维数据——序列与文本 + +## 篇章导读 + +一维数据（1D Data）是人工智能处理的最基础、也是最重要的数据形态。你正在阅读的文字、你说出的一句话、股票市场的价格走势、建筑室内温度随时间的变化——这些都是一维序列数据。 + +与图像（二维）和三维模型（三维）不同，一维数据的核心特征是**有序性**：每一个元素的含义不仅取决于它本身，还取决于它在序列中的位置以及与前后元素的关系。"我吃饭了"和"饭我吃了"虽然包含相同的字，但含义截然不同——这就是序列的魅力与挑战。 + +本章将带你踏上一段激动人心的技术演进之旅：从早期的小型循环神经网络（RNN），到注意力机制的革命性突破，再到 Transformer 架构的横空出世，最终见证大语言模型（LLM）如何改变整个 AI 格局。这条从小模型到大模型的技术脉络，不仅是深度学习最精彩的故事之一，也直接关系到今天每一位设计师如何使用 AI 工具。 + +**核心线索**：序列数据的模型演进——RNN（小模型）→ 注意力机制 → Transformer → 大语言模型（LLM） + +--- + +## 学习目标 + +- 理解序列数据的特点与建模难点 +- 掌握 RNN、LSTM、GRU 的基本原理 +- 理解 Self-Attention 机制和 Transformer 架构 +- 了解大语言模型的发展历程与关键技术 +- 学会在设计场景中应用文本处理技术 + +--- + +# 3.1 序列建模 + +## 为什么序列数据如此重要？ + +在设计领域，序列数据无处不在： + +| 数据类型 | 示例 | 设计场景 | +|----------|------|----------| +| 文本序列 | 设计说明、用户评论 | 需求分析、情感分析 | +| 时间序列 | 温度、人流量、能耗 | 环境监测、建筑性能 | +| 操作序列 | 用户点击、浏览路径 | 交互设计优化 | +| 空间序列 | 路径规划、动线分析 | 室内导航设计 | + +### 序列数据的两大挑战 + +**挑战一：变长问题** + +图像的尺寸可以统一缩放，但文本的长度千变万化： + +``` +"好" → 长度 1 +"这个设计方案不错" → 长度 7 +"请将客厅的主色调调整为暖色系，并增加自然采光" → 长度 19 +``` + +传统的全连接网络（MLP）要求固定大小的输入，无法直接处理变长序列。 + +**挑战二：时序依赖** + +序列中元素的含义依赖上下文： + +``` +"这个设计 很好" → 正面评价 +"这个设计 很好笑" → 负面/调侃评价 + +"光线 不足" → 设计问题 +"光线 充足" → 设计优点 +``` + +模型需要"记住"之前看到的内容，才能理解当前内容。这正是**循环神经网络**要解决的核心问题。 + +--- + +## RNN：循环神经网络 + +### 核心思想 + +RNN（Recurrent Neural Network）通过**隐藏状态**（Hidden State）在时间步之间传递信息，实现"记忆"功能。 + +``` +时间展开视图： + + x₁ x₂ x₃ x₄ + │ │ │ │ + ▼ ▼ ▼ ▼ +┌───┐ ┌───┐ ┌───┐ ┌───┐ +│h₁ │──→│h₂ │──→│h₃ │──→│h₄ │ +└───┘ └───┘ └───┘ └───┘ + │ │ │ │ + ▼ ▼ ▼ ▼ + y₁ y₂ y₃ y₄ +``` + +### 数学表达 + +在每个时间步 t，RNN 执行以下计算： + +``` +隐藏状态更新： + h_t = tanh(W_hh · h_{t-1} + W_xh · x_t + b_h) + +输出计算： + y_t = W_hy · h_t + b_y +``` + +其中： +- `x_t`：时刻 t 的输入 +- `h_{t-1}`：上一时刻的隐藏状态（"记忆"） +- `h_t`：当前时刻的隐藏状态 +- `W_hh, W_xh, W_hy`：可学习的权重矩阵 + +### 直观理解 + +想象你在阅读一份设计说明书： + +``` +输入序列："客厅 采用 开放式 布局 以 增加 空间感" + +时间步1：看到"客厅" → h₁ = "在讨论一个房间" +时间步2：看到"采用" → h₂ = "在讨论客厅的某个选择" +时间步3：看到"开放式" → h₃ = "客厅选择了开放式布局" +时间步4：看到"布局" → h₄ = "确认：客厅开放式布局方案" +时间步5：看到"以" → h₅ = "接下来要说目的" +时间步6：看到"增加" → h₆ = "目的是增加某个属性" +时间步7：看到"空间感" → h₇ = "完整理解：客厅用开放式布局来增加空间感" +``` + +每一步，RNN 都在累积和更新对文本的理解。这就是"记忆"的力量。 + +### PyTorch 代码示例 + +```python +import torch +import torch.nn as nn + +# 定义一个简单的 RNN +class SimpleRNN(nn.Module): + def __init__(self, input_size, hidden_size, output_size): + super().__init__() + self.rnn = nn.RNN(input_size, hidden_size, batch_first=True) + self.fc = nn.Linear(hidden_size, output_size) + + def forward(self, x): + # x 形状: (batch, seq_len, input_size) + out, h_n = self.rnn(x) # out: 所有时间步的输出 + out = self.fc(out[:, -1, :]) # 取最后一个时间步 + return out + +# 创建模型 +model = SimpleRNN(input_size=100, hidden_size=64, output_size=2) +# 用于文本分类（如：正面/负面评价） +``` + +--- + +## RNN 的致命问题：梯度消失与梯度爆炸 + +### 问题根源 + +RNN 需要通过反向传播跨越多个时间步来更新参数。当序列较长时，梯度要经过多次乘法运算： + +``` +梯度回传路径（以4步为例）： + +∂L/∂W = (∂L/∂h₄) · (∂h₄/∂h₃) · (∂h₃/∂h₂) · (∂h₂/∂h₁) · (∂h₁/∂W) + └───────── 多次连乘 ──────────┘ +``` + +- 如果每步的梯度 < 1 → 连乘后趋近于 0 → **梯度消失**（学不到远距离依赖） +- 如果每步的梯度 > 1 → 连乘后趋近于 ∞ → **梯度爆炸**（训练不稳定） + +### 直观类比 + +``` +传话游戏： + +第1个人："把客厅漆成温暖的米黄色" +第2个人："把客厅漆成温暖的米……什么？" ← 信息开始丢失 +第3个人："客厅……漆成……？" ← 大量信息丢失 +第4个人："什么客厅？" ← 几乎全忘了 + +RNN 处理长序列时遇到同样的问题！ +``` + +在实际应用中，标准 RNN 通常只能"记住"5-10步之前的信息。对于"这个设计方案虽然外观简洁大方，功能分区合理，但是整体造价偏高"这样跨越多个分句的评价，RNN 可能会遗忘前半部分的内容。 + +--- + +## LSTM：长短期记忆网络 + +### 设计哲学 + +LSTM（Long Short-Term Memory）由 Hochreiter 和 Schmidhuber 于1997年提出，核心创新是引入**细胞状态**（Cell State）——一条贯穿整个序列的"信息高速公路"，让信息可以长距离传递而不被稀释。 + +``` +LSTM 单元内部结构： + + ┌──────────────────────────────────────┐ + │ LSTM 单元 │ + │ │ + c_{t-1} ───────→ │ ─── 遗忘门 ──→ ── 输入门 ──→ ──────→ │ ──→ c_t + │ ↓ ↓ ↓ │ (细胞状态) + h_{t-1} ──┐ │ σ σ+σ̃ tanh │ + │ │ ↓ ↓ ↓ │ + x_t ──────┤ │ f_t i_t c̃_t │ + │ │ ↓ │ + │ │ c_t = f_t⊙c_{t-1} + i_t⊙c̃_t + │ │ ↓ │ + └─────→│ ────────────── 输出门 ──────→│ │ + │ σ → o_t ↓ │ + │ h_t = o_t ⊙ tanh(c_t) │ + └──────────────────────────────────────┘ +``` + +### 三道门：遗忘、输入、输出 + +LSTM 通过三个"门"（Gate）来精确控制信息的流动： + +**1. 遗忘门（Forget Gate）**：决定从细胞状态中丢弃什么信息 + +``` +f_t = σ(W_f · [h_{t-1}, x_t] + b_f) + +输出范围 (0, 1)：0 = 全部遗忘，1 = 全部保留 +``` + +**2. 输入门（Input Gate）**：决定将什么新信息存入细胞状态 + +``` +i_t = σ(W_i · [h_{t-1}, x_t] + b_i) # 哪些信息需要更新 +c̃_t = tanh(W_c · [h_{t-1}, x_t] + b_c) # 新的候选值 +``` + +**3. 输出门（Output Gate）**：决定输出什么信息 + +``` +o_t = σ(W_o · [h_{t-1}, x_t] + b_o) +h_t = o_t ⊙ tanh(c_t) +``` + +### 细胞状态更新 + +``` +c_t = f_t ⊙ c_{t-1} + i_t ⊙ c̃_t + └────────┘ └────────┘ + 保留旧信息 加入新信息 +``` + +### 设计类比 + +``` +LSTM 就像一位优秀的设计项目管理者： + + 遗忘门 → "之前的方案中哪些思路已经过时了？" + 输入门 → "客户提出了什么新需求？" + 细胞状态 → "项目的核心理念和关键约束"（长期记忆） + 隐藏状态 → "当前正在讨论的具体话题"（短期记忆） + 输出门 → "现在应该向团队传达什么信息？" +``` + +### 代码示例 + +```python +import torch +import torch.nn as nn + +class TextClassifier(nn.Module): + """基于 LSTM 的文本分类模型""" + def __init__(self, vocab_size, embed_dim, hidden_dim, num_classes): + super().__init__() + self.embedding = nn.Embedding(vocab_size, embed_dim) + self.lstm = nn.LSTM(embed_dim, hidden_dim, batch_first=True) + self.fc = nn.Linear(hidden_dim, num_classes) + + def forward(self, x): + # x: (batch, seq_len) 整数索引 + embedded = self.embedding(x) # (batch, seq_len, embed_dim) + output, (h_n, c_n) = self.lstm(embedded) + logits = self.fc(h_n.squeeze(0)) # 取最后隐藏状态 + return logits + +# 使用示例 +model = TextClassifier(vocab_size=10000, embed_dim=128, + hidden_dim=256, num_classes=3) +# 3分类：正面/中性/负面（设计评论情感分析） +``` + +--- + +## GRU：简化版 LSTM + +GRU（Gated Recurrent Unit）由 Cho 等人于2014年提出，将遗忘门和输入门合并为**更新门**，参数更少，训练更快。 + +``` +GRU 结构： + + h_{t-1} ──→ ┌─────────────────┐ ──→ h_t + │ 重置门 r_t │ + x_t ──────→ │ 更新门 z_t │ + │ h̃_t = tanh(...) │ + │ h_t = (1-z_t)⊙h_{t-1} + z_t⊙h̃_t + └─────────────────┘ +``` + +### LSTM vs GRU 对比 + +| 特性 | LSTM | GRU | +|------|------|-----| +| 门数量 | 3个（遗忘、输入、输出） | 2个（重置、更新） | +| 细胞状态 | 有独立的细胞状态 c_t | 无，直接用隐藏状态 | +| 参数量 | 较多 | 较少（约少1/3） | +| 训练速度 | 较慢 | 较快 | +| 适用场景 | 复杂长序列 | 中等长度序列 | + +### 如何选择？ + +``` +经验法则： +├── 数据量充足、序列很长 → LSTM（更强的表达能力） +├── 数据量有限、序列中等 → GRU（更快收敛，不易过拟合） +└── 都试试，看验证集表现 → 实践出真知 +``` + +--- + +## 设计应用：文本分类与时间序列预测 + +### 应用一：设计文档自动分类 + +```python +import torch +import torch.nn as nn + +class DesignDocClassifier(nn.Module): + """将设计文档自动分类为：建筑设计/景观设计/室内设计/平面设计""" + def __init__(self, vocab_size=20000, embed_dim=128, hidden_dim=256): + super().__init__() + self.embedding = nn.Embedding(vocab_size, embed_dim) + self.lstm = nn.LSTM(embed_dim, hidden_dim, + num_layers=2, # 2层 LSTM + bidirectional=True, # 双向：同时看前后文 + dropout=0.3, + batch_first=True) + self.fc = nn.Linear(hidden_dim * 2, 4) # 4个设计类别 + + def forward(self, x): + embedded = self.embedding(x) + output, _ = self.lstm(embedded) + # 取正反向最后隐藏状态拼接 + logits = self.fc(output[:, -1, :]) + return logits +``` + +### 应用二：建筑能耗时间序列预测 + +```python +import torch +import torch.nn as nn + +class EnergyPredictor(nn.Module): + """基于 LSTM 的建筑能耗预测模型""" + def __init__(self, input_dim=6, hidden_dim=64, pred_steps=24): + super().__init__() + # input_dim: 温度、湿度、光照、人流量、时间(时)、星期几 + self.lstm = nn.LSTM(input_dim, hidden_dim, num_layers=2, + dropout=0.2, batch_first=True) + self.fc = nn.Linear(hidden_dim, pred_steps) # 预测未来24小时 + + def forward(self, x): + # x: (batch, past_hours, features) 过去若干小时的数据 + _, (h_n, _) = self.lstm(x) + prediction = self.fc(h_n[-1]) # 最后一层的隐藏状态 + return prediction +``` + +--- + +# 3.2 注意力革命 + +## RNN 的瓶颈：串行计算的困境 + +尽管 LSTM 和 GRU 缓解了梯度消失问题，但 RNN 的根本架构限制依然存在： + +``` +RNN 的串行瓶颈： + +时间步： t=1 t=2 t=3 t=4 t=5 + │ │ │ │ │ + ▼ ▼ ▼ ▼ ▼ + ┌───┐ ┌───┐ ┌───┐ ┌───┐ ┌───┐ + x₁ → │h₁│→ │h₂│→ │h₃│→ │h₃│→ │h₅│ → 输出 + └───┘ └───┘ └───┘ └───┘ └───┘ + +问题1：必须等 t=1 算完才能算 t=2，无法并行！ +问题2：h₅ 能充分了解 x₁ 的信息吗？（远距离依赖） +``` + +| RNN 的局限 | 具体影响 | +|------------|---------| +| 串行计算 | 训练速度慢，无法利用 GPU 并行能力 | +| 长距离依赖衰减 | 即使是 LSTM，50步以上的依赖也会衰减 | +| 固定的信息压缩 | 无论序列多长，都压缩到一个固定大小的 h_t | +| 单向信息流 | 后面的信息无法影响前面的理解（除非用双向） | + +2017年，一篇名为《Attention Is All You Need》的论文彻底改变了这一局面。 + +--- + +## Self-Attention：自注意力机制 + +### 核心思想 + +自注意力让序列中的每个位置都能**直接**与所有其他位置"交流"，一步到位地获取全局信息。 + +``` +传统 RNN（串行传递信息）： + + "设计" → "这个" → "客厅" → "的" → "风格" + ↑ + 需要回溯4步才能看到"设计" + +Self-Attention（直接连接）： + + "设计" ─────────────────────→ "风格" + ↘ ↗ + "这个" ──→ "客厅" + ↗ ↘ + "的" ──────────────────→ "风格" + +每个词都可以直接"看到"所有其他词！ +``` + +### Q、K、V 机制 + +Self-Attention 借鉴了信息检索的思想： + +``` +类比：在图书馆找书 + + Q（Query/查询） = "我想找关于北欧风格室内设计的书" + K（Key/键） = 每本书的标签："现代设计""北欧风格""古典建筑"... + V（Value/值） = 每本书的实际内容 + +计算过程： + 1. Q 和每个 K 比较相似度 → 得到"关注程度" + 2. 按关注程度加权求和 V → 得到最终结果 +``` + +在序列建模中，每个位置同时扮演 Q、K、V 三个角色： + +``` +输入序列 X：[x₁, x₂, x₃, x₄] + +线性变换： + Q = X · W_Q # 查询矩阵：我想找什么？ + K = X · W_K # 键矩阵：我包含什么信息？ + V = X · W_V # 值矩阵：我的具体内容是什么？ +``` + +### Scaled Dot-Product Attention + +完整的注意力计算公式： + +``` + Q · Kᵀ +Attention(Q,K,V) = softmax(─────) · V + √d_k + +步骤分解： + + 步骤1：计算注意力分数 + scores = Q · Kᵀ # 矩阵乘法，得到每对位置的相似度 + + 步骤2：缩放 + scores = scores / √d_k # 除以维度平方根，防止梯度消失 + + 步骤3：归一化 + weights = softmax(scores) # 转为概率分布，和为1 + + 步骤4：加权求和 + output = weights · V # 按注意力权重聚合信息 +``` + +### 为什么要缩放（Scale）？ + +``` +当 d_k 较大时，Q·Kᵀ 的值也会很大 +→ softmax 输入很大时会进入"饱和区" +→ 梯度变得极小，训练困难 +→ 除以 √d_k 将值拉回合理范围 + +示例（d_k = 64）： + 缩放前：softmax([10, 8, 3, -5]) → [0.87, 0.12, 0.001, 0.000001] + 缩放后：softmax([1.25, 1.0, 0.375, -0.625]) → [0.38, 0.30, 0.16, 0.07] +``` + +### 代码实现 + +```python +import torch +import torch.nn.functional as F + +def scaled_dot_product_attention(Q, K, V): + """ + Q: (batch, seq_len, d_k) + K: (batch, seq_len, d_k) + V: (batch, seq_len, d_v) + """ + d_k = Q.size(-1) + + # 步骤1 & 2: 计算缩放后的注意力分数 + scores = torch.matmul(Q, K.transpose(-2, -1)) / (d_k ** 0.5) + + # 步骤3: softmax 归一化 + weights = F.softmax(scores, dim=-1) + + # 步骤4: 加权求和 + output = torch.matmul(weights, V) + + return output, weights + +# 示例：对句子"客厅 采用 开放式 布局"做自注意力 +seq_len, d_k = 4, 64 +Q = torch.randn(1, seq_len, d_k) +K = torch.randn(1, seq_len, d_k) +V = torch.randn(1, seq_len, d_k) + +output, attn_weights = scaled_dot_product_attention(Q, K, V) +print(f"注意力权重形状: {attn_weights.shape}") # (1, 4, 4) - 每个词对其他词的关注度 +print(f"输出形状: {output.shape}") # (1, 4, 64) +``` + +--- + +## Multi-Head Attention：多头注意力 + +### 为什么需要多头？ + +单个注意力头只能学习一种"关注模式"。现实中的语言理解需要同时关注多种关系： + +``` +句子："设计师用木质材料打造了温馨的北欧风格客厅" + +头1 关注：语法关系 → "设计师"是主语，"打造"是谓语 +头2 关注：修饰关系 → "温馨的"修饰"客厅"，"北欧风格"修饰"客厅" +头3 关注：语义关系 → "木质材料"与"北欧风格"语义关联 +头4 关注：设计属性 → "温馨"是情感描述，"北欧风格"是风格类别 +``` + +### 结构示意 + +``` +输入 X + │ + ├──→ Head 1: Q₁=X·W₁ᵠ, K₁=X·W₁ᵏ, V₁=X·W₁ᵛ → Attention(Q₁,K₁,V₁) → head₁ + ├──→ Head 2: Q₂=X·W₂ᵠ, K₂=X·W₂ᵏ, V₂=X·W₂ᵛ → Attention(Q₂,K₂,V₂) → head₂ + ├──→ Head 3: Q₃=X·W₃ᵠ, K₃=X·W₃ᵏ, V₃=X·W₃ᵛ → Attention(Q₃,K₃,V₃) → head₃ + │ ... + └──→ Head h: Qₕ=X·Wₕᵠ, Kₕ=X·Wₕᵏ, Vₕ=X·Wₕᵛ → Attention(Qₕ,Kₕ,Vₕ) → headₕ + │ + Concat(head₁, ..., headₕ) → Linear → Output │ +``` + +### 代码实现 + +```python +class MultiHeadAttention(nn.Module): + def __init__(self, d_model, num_heads): + super().__init__() + assert d_model % num_heads == 0 + + self.d_k = d_model // num_heads + self.num_heads = num_heads + + # 为每个头创建 Q, K, V 的线性变换 + self.W_q = nn.Linear(d_model, d_model) + self.W_k = nn.Linear(d_model, d_model) + self.W_v = nn.Linear(d_model, d_model) + self.W_o = nn.Linear(d_model, d_model) + + def forward(self, x): + batch_size = x.size(0) + + # 线性变换并分割为多头 + Q = self.W_q(x).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2) + K = self.W_k(x).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2) + V = self.W_v(x).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2) + + # 计算注意力 + attn_output, _ = scaled_dot_product_attention(Q, K, V) + + # 合并多头 + attn_output = attn_output.transpose(1, 2).contiguous() + attn_output = attn_output.view(batch_size, -1, self.num_heads * self.d_k) + + # 最终线性变换 + return self.W_o(attn_output) +``` + +--- + +## Positional Encoding：位置编码 + +### 为什么需要位置信息？ + +Self-Attention 本身是"位置无关"的——它把输入看作一个集合（Set），而不是序列（Sequence）： + +``` +输入 A："客厅 在 北面" +输入 B："北面 在 客厅" + +Self-Attention 不加位置信息时，会把两者视为完全相同！ +（因为词相同，只是顺序不同，但 Attention 是排列不变的） +``` + +### 正弦/余弦位置编码 + +Transformer 使用正弦和余弦函数为每个位置生成独特的编码： + +``` +PE(pos, 2i) = sin(pos / 10000^(2i/d_model)) +PE(pos, 2i+1) = cos(pos / 10000^(2i/d_model)) + +其中： + pos = 位置索引（第几个词） + i = 维度索引 + d_model = 模型维度 +``` + +``` +位置编码示意（d_model=4 简化版）： + +位置0: [sin(0), cos(0), sin(0), cos(0) ] +位置1: [sin(1), cos(1), sin(0.0001), cos(0.0001) ] +位置2: [sin(2), cos(2), sin(0.0002), cos(0.0002) ] +位置3: [sin(3), cos(3), sin(0.0003), cos(0.0003) ] +... +``` + +### 代码实现 + +```python +import torch +import math + +def positional_encoding(seq_len, d_model): + """生成位置编码矩阵""" + pe = torch.zeros(seq_len, d_model) + position = torch.arange(0, seq_len).unsqueeze(1).float() + + # 计算频率 + div_term = torch.exp( + torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model) + ) + + pe[:, 0::2] = torch.sin(position * div_term) # 偶数维度 + pe[:, 1::2] = torch.cos(position * div_term) # 奇数维度 + + return pe + +# 示例：为长度50的序列生成64维位置编码 +pe = positional_encoding(50, 64) +print(f"位置编码形状: {pe.shape}") # (50, 64) +``` + +--- + +## Self-Attention vs RNN：全面对比 + +| 特性 | RNN/LSTM | Self-Attention | +|------|----------|----------------| +| 计算方式 | 串行（逐步） | 并行（一步） | +| 长距离依赖 | 需要传递多步，信息衰减 | 任意距离，一步直达 | +| 训练速度 | 慢（无法充分并行） | 快（GPU 友好） | +| 位置信息 | 天然有序（按时间步处理） | 需要额外位置编码 | +| 内存消耗 | O(1) 每步 | O(n²) 需存储 n×n 注意力矩阵 | +| 适用长度 | 中短序列（<100） | 中长序列（<数万，受内存限制） | + +``` +计算复杂度对比： + + RNN: O(n · d²) - 线性于序列长度 + Attention: O(n² · d) - 二次于序列长度 + + 当 n（序列长度）远大于 d（维度）时，Attention 更慢 + 但 Attention 的并行性弥补了这一劣势 +``` + +--- + +# 3.3 Transformer 架构 + +## 整体结构 + +Transformer 由 Vaswani 等人在2017年提出，采用 **Encoder-Decoder**（编码器-解码器）结构： + +``` +┌──────────────────────────────────────────────────────────────┐ +│ Transformer 架构 │ +│ │ +│ 输入序列 输出序列 │ +│ "设计一个客厅" "现代简约风格客厅..." │ +│ │ ↑ │ +│ ▼ │ │ +│ ┌──────────────┐ ┌──────────────┐ │ +│ │ Encoder │ │ Decoder │ │ +│ │ ┌────────┐ │ │ ┌────────┐ │ │ +│ │ │ Enc │ │ │ │ Dec │ │ │ +│ │ │ Layer │ │ ────────→ │ │ Layer │ │ │ +│ │ │ ×N │ │ 编码信息 │ │ ×N │ │ │ +│ │ └────────┘ │ │ └────────┘ │ │ +│ └──────────────┘ └──────────────┘ │ +│ ↑ ↑ │ +│ 输入嵌入 输出嵌入 │ +│ + 位置编码 + 位置编码 │ +└──────────────────────────────────────────────────────────────┘ +``` + +--- + +## Encoder Layer（编码器层） + +每一层编码器包含两个子层： + +``` +输入 + │ + ▼ +┌──────────────────────────┐ +│ Multi-Head Attention │ ← 子层1：自注意力 +│ (Self-Attention) │ +└──────────────────────────┘ + │ ↑ + ├──── Add & Norm ────┘ ← 残差连接 + 层归一化 + │ + ▼ +┌──────────────────────────┐ +│ Feed-Forward Network │ ← 子层2：前馈网络 +│ (FFN) │ +└──────────────────────────┘ + │ ↑ + ├──── Add & Norm ────┘ ← 残差连接 + 层归一化 + │ + ▼ +输出 → 传递给下一层或 Decoder +``` + +### 子层详解 + +**子层1：多头自注意力** + +```python +# Encoder 中的 Self-Attention +# Q, K, V 都来自同一个输入 +attn_output = MultiHeadAttention(x, x, x) +x = LayerNorm(x + attn_output) # 残差连接 + 层归一化 +``` + +**子层2：前馈网络（FFN）** + +``` +FFN(x) = W₂ · ReLU(W₁ · x + b₁) + b₂ + +# 两层线性变换，中间用 ReLU 激活 +# 通常 d_ff = 4 × d_model（先升维再降维） +``` + +```python +class FeedForward(nn.Module): + def __init__(self, d_model, d_ff=2048): + super().__init__() + self.linear1 = nn.Linear(d_model, d_ff) + self.linear2 = nn.Linear(d_ff, d_model) + + def forward(self, x): + return self.linear2(F.relu(self.linear1(x))) +``` + +--- + +## Decoder Layer（解码器层） + +解码器比编码器多了一个**交叉注意力**（Cross-Attention）子层： + +``` +输入（已生成的输出） + │ + ▼ +┌──────────────────────────┐ +│ Masked Multi-Head │ ← 子层1：掩码自注意力 +│ Self-Attention │ （只能看到已生成的词） +└──────────────────────────┘ + │ ↑ + ├──── Add & Norm ────┘ + │ + ▼ +┌──────────────────────────┐ +│ Multi-Head │ ← 子层2：交叉注意力 +│ Cross-Attention │ Q来自Decoder，K/V来自Encoder +│ (Q: Dec, K,V: Enc) │ +└──────────────────────────┘ + │ ↑ + ├──── Add & Norm ────┘ + │ + ▼ +┌──────────────────────────┐ +│ Feed-Forward Network │ ← 子层3：前馈网络 +└──────────────────────────┘ + │ ↑ + ├──── Add & Norm ────┘ + │ + ▼ +输出 → 传递给下一层或最终线性层 +``` + +### Masked Self-Attention：为什么要"掩码"？ + +在生成文本时，模型不能"偷看"未来的词： + +``` +生成 "现代 简约 风格 客厅"： + + 时刻1：生成 "现代" → 只能看到起始符 [BOS] + 时刻2：生成 "简约" → 只能看到 [BOS, 现代] + 时刻3：生成 "风格" → 只能看到 [BOS, 现代, 简约] + 时刻4：生成 "客厅" → 只能看到 [BOS, 现代, 简约, 风格] + +掩码矩阵（上三角遮住未来信息）： + + 现代 简约 风格 客厅 + 现代 [ 1 0 0 0 ] ← 只看自己 + 简约 [ 1 1 0 0 ] ← 看自己和"现代" + 风格 [ 1 1 1 0 ] ← 看前面三个 + 客厅 [ 1 1 1 1 ] ← 看所有 + + 0 = 被遮住（设为 -inf，softmax 后变为 0） +``` + +--- + +## 残差连接与层归一化 + +### 残差连接（Residual Connection） + +``` +核心公式：output = LayerNorm(x + Sublayer(x)) + +为什么重要？ + ┌──────────────────────────────────────────────┐ + │ 没有残差连接：梯度要穿过每一层 │ + │ x → Layer1 → Layer2 → ... → Layer12 → Loss │ + │ │ + │ 有残差连接：梯度有"捷径"可以直接回传 │ + │ x → Layer1 → (+x) → Layer2 → (+x) → ... │ + │ ↑ │ + │ └── 梯度可以直接沿加法路径回传 ──→ │ + └──────────────────────────────────────────────┘ +``` + +### 层归一化（Layer Normalization） + +``` +对每个样本的所有特征进行归一化： + + LayerNorm(x) = (x - μ) / σ · γ + β + + 其中 μ, σ 是该样本所有特征的均值和标准差 + γ, β 是可学习的缩放和偏移参数 + +作用：稳定训练过程，加速收敛 +``` + +--- + +## Transformer 三大变体 + +``` + Transformer 家族树 + + Original Transformer + (Encoder + Decoder) + ┌────────┴────────┐ + │ │ + ┌──────┴──────┐ ┌─────┴─────┐ + │ │ │ │ + BERT GPT T5/BART + (Encoder-only) (Decoder-only) (Encoder-Decoder) + │ │ │ + 理解为主 生成为主 理解+生成 +``` + +### BERT（Encoder-only） + +``` +特点：双向理解，擅长"阅读理解" + +训练方式： + 1. MLM（Masked Language Model）：随机遮住15%的词，让模型预测 + "客厅采用了[MASK]风格的设计" → 预测 [MASK] = "北欧" + + 2. NSP（Next Sentence Prediction）：判断两句话是否相邻 + +擅长任务： + - 文本分类（设计文档分类） + - 命名实体识别（提取设计要素） + - 问答系统（设计知识库问答） + - 情感分析（用户评价分析） +``` + +### GPT（Decoder-only） + +``` +特点：自回归生成，擅长"续写" + +训练方式： + 给定前面的词，预测下一个词： + "设计师选择的" → 预测下一个词（可能是"材料"/"色彩"/"风格"） + +擅长任务： + - 文本生成（设计描述生成） + - 对话系统（设计咨询助手） + - 代码生成（设计自动化） + - 创意构思（头脑风暴） +``` + +### T5（Encoder-Decoder） + +``` +特点：用统一的"文本到文本"框架处理所有NLP任务 + +设计理念： + 所有NLP任务都转化为：输入文本 → 输出文本 + + 翻译： "translate English to Chinese: Hello" → "你好" + 摘要： "summarize: 很长的设计文档..." → "核心要点..." + 分类： "classify: 这是一篇关于景观的文章" → "景观设计" +``` + +### 三大变体对比 + +| 特性 | BERT | GPT | T5 | +|------|------|-----|-----| +| 架构 | Encoder | Decoder | Encoder-Decoder | +| 方向 | 双向 | 单向（从左到右） | 编码双向，解码单向 | +| 核心能力 | 理解 | 生成 | 理解+生成 | +| 典型规模 | 340M | 117M ~ 1.8T | 60M ~ 11B | +| 设计应用 | 分析评价 | 生成方案 | 转换/翻译 | + +--- + +## Token 处理流水线 + +文本进入 Transformer 之前，需要经过完整的预处理流水线： + +``` +原始文本 Tokenization Embedding +"设计一个温馨的客厅" → [设,计,一,个,温,馨,的,客,厅] → 每个token → 768维向量 + ↓ + + Positional Encoding + ↓ + 输入 Transformer +``` + +### Tokenization：分词 + +``` +三种分词策略： + +1. 字符级（Character-level） + "设计" → ["设", "计"] + ✗ 优点：词表小 ✗ 缺点：序列太长，丢失词义 + +2. 词级（Word-level） + "设计一个客厅" → ["设计", "一个", "客厅"] + ✓ 优点：保留语义 ✗ 缺点：词表巨大，无法处理新词 + +3. 子词级（Subword-level） ← BPE/GPT 使用的方式 + "uncomfortable" → ["un", "comfort", "able"] + ✓ 优点：平衡词表大小和语义 ✓ 缺点：无明显缺点 +``` + +```python +# 使用 HuggingFace 的分词器 +from transformers import AutoTokenizer + +tokenizer = AutoTokenizer.from_pretrained("bert-base-chinese") +tokens = tokenizer("设计一个温馨的客厅") +print(f"Token IDs: {tokens['input_ids']}") +print(f"Token 文本: {tokenizer.convert_ids_to_tokens(tokens['input_ids'])}") + +# 输出示例： +# Token IDs: [101, 6371, 2552, 671, 702, 3649, 5889, 4638, 2642, 1079, 102] +# Token 文本: ['[CLS]', '设', '计', '一', '个', '温', '馨', '的', '客', '厅', '[SEP]'] +``` + +--- + +# 3.4 大语言模型 + +## 从 Transformer 到大语言模型 + +Transformer 论文发表后的几年里，研究者们发现了一个关键规律：**只要持续增大模型的规模（参数量、数据量、计算量），模型的能力就会不断提升**。这就是 Scaling Law 的威力。 + +大语言模型（Large Language Model, LLM）的演进时间线： + +``` +模型规模指数级增长： + +参数量 + │ + │ GPT-4 + │ (~1.8T) + │ GPT-3 + │ (175B) ────────╮ + │ GPT-2 │ + │ (1.5B) │ + │ GPT-1 │ + │ (117M) │ + │ BERT │ + │ (340M) │ + │ │ + └──┴─────┴──────┴──────┴──────┴──────┴───────┴──── 时间 + 2018 2018 2019 2020 2022 2023 +``` + +--- + +## GPT 系列演进 + +### GPT-1（2018）：奠定基础 + +``` +参数量：117M +训练数据：约5GB文本 +核心贡献：证明了"预训练 + 微调"范式的有效性 + + 预训练阶段：在大规模无标注文本上学习语言规律 + 微调阶段：在小规模有标注数据上适应特定任务 +``` + +### GPT-2（2019）：规模的力量 + +``` +参数量：1.5B（15亿） +训练数据：约40GB文本（WebText） +核心发现：模型足够大时，无需微调就能完成多种任务 + + "零样本学习"（Zero-shot）能力初现： + 直接输入任务描述，模型就能理解并执行 +``` + +### GPT-3（2020）：涌现能力 + +``` +参数量：175B（1750亿） +训练数据：约570GB文本 +核心突破：少样本学习（Few-shot Learning） + + 无需更新参数，只需给几个例子： + ┌──────────────────────────────────────────────────────┐ + │ Prompt: │ + │ │ + │ 将设计风格翻译为英文： │ + │ 北欧风格 → Nordic style │ + │ 日式风格 → Japanese style │ + │ 工业风格 → │ + │ │ + │ GPT-3 输出：Industrial style │ + └──────────────────────────────────────────────────────┘ +``` + +### ChatGPT（2022）：对话能力的飞跃 + +``` +核心创新：RLHF（基于人类反馈的强化学习） +意义：让 AI 学会了"对话" + + GPT-3（之前）： + 用户："帮我设计一个客厅" + GPT-3："客厅是家庭活动的中心空间..." ← 像百科全书 + + ChatGPT： + 用户："帮我设计一个客厅" + ChatGPT："很乐意帮忙！请问： + 1. 客厅面积多大？ + 2. 预算范围？ + 3. 喜欢什么风格？ + 我可以根据这些信息给你更具体的建议。" + ← 像真正的设计师在对话 +``` + +### GPT-4（2023）：多模态能力 + +``` +核心突破：不仅能理解文本，还能理解图像 + + 输入：一张客厅照片 + "如何改善这个空间？" + 输出："根据照片分析： + 1. 自然光不足 → 建议增加镜面元素反射光线 + 2. 家具尺度偏大 → 建议换用低矮家具增加空间感 + 3. 色调单一 → 建议添加暖色软装点缀..." + +模型规模的飞跃： + + ┌──────────────────────────────────────┐ + │ GPT-1 GPT-2 GPT-3 GPT-4 │ + │ 117M → 1.5B → 175B → ~1.8T │ + │ │ + │ ×13 ×117 ×15,000 ×15,000 │ + │ (相对GPT-1) │ + └──────────────────────────────────────┘ +``` + +--- + +## 训练范式：预训练 → 微调 → 指令调优 + +大语言模型的训练分为三个阶段： + +``` +阶段1：预训练（Pre-training） + 目标：学习语言的基础知识 + 数据：互联网海量文本（TB级别） + 方法：预测下一个词 + 成本：极高（数百万美元） + + "这个客厅采用了" → "现代简约" ← 正确答案 + + ↓ + +阶段2：监督微调（Supervised Fine-Tuning, SFT） + 目标：学会遵循指令 + 数据：人工编写的（指令, 回答）对 + 方法：继续训练，但用有标注数据 + + 指令："描述一下北欧风格的特点" + 回答："北欧风格以简洁、自然、功能性为核心..." + + ↓ + +阶段3：对齐优化（Alignment） + 目标：让回答更符合人类偏好 + 数据：人类对多个回答的排序 + 方法：RLHF / DPO + + 问题："设计一个50平米的客厅" + 回答A："以下是设计方案..." ← 较好 + 回答B："我无法帮您..." ← 较差 + 人类标注：A > B → 模型学习人类偏好 +``` + +### 中国的大语言模型 + +``` +┌─────────────────────────────────────────────────────┐ +│ 模型名称 开发机构 特点 │ +├─────────────────────────────────────────────────────┤ +│ 文心一言 百度 中文理解能力强 │ +│ 通义千问 阿里巴巴 多模态能力突出 │ +│ 智谱清言 智谱AI 开源生态活跃 │ +│ Kimi 月之暗面 长文本处理能力 │ +│ DeepSeek 深度求索 推理能力突出 │ +│ 讯飞星火 科大讯飞 教育领域深耕 │ +└─────────────────────────────────────────────────────┘ +``` + +--- + +# 3.5 LLM 关键技术 + +## RAG：检索增强生成 + +### 问题：大模型的"幻觉" + +LLM 会自信地编造不存在的事实： + +``` +用户："北京故宫的建筑面积是多少？" +LLM（幻觉）："北京故宫的建筑面积约为25万平方米。" +（实际约15万平方米） + +原因：LLM 的知识来自训练数据，无法实时更新 + 它生成的是"最可能"的答案，而非"最正确"的答案 +``` + +### RAG 架构 + +RAG（Retrieval-Augmented Generation）通过引入外部知识库来解决幻觉问题： + +``` +用户提问 + │ + ▼ +┌──────────────┐ +│ 1. 检索阶段 │ 在知识库中搜索相关文档 +│ (Retrieve) │ +└──────────────┘ + │ + │ 检索到的相关文档 + ▼ +┌──────────────┐ +│ 2. 增强阶段 │ 将问题 + 相关文档拼接为增强提示 +│ (Augment) │ +└──────────────┘ + │ + │ 增强后的 Prompt + ▼ +┌──────────────┐ +│ 3. 生成阶段 │ LLM 基于增强信息生成回答 +│ (Generate) │ +└──────────────┘ + │ + ▼ +准确、有据可查的回答 +``` + +### 设计领域 RAG 示例 + +```python +# 概念代码：设计知识库 RAG 系统 + +# 步骤1：建立知识库（将设计规范文档分块并编码） +documents = [ + "住宅设计规范：客厅净高不应低于2.4米...", + "建筑采光标准：居住空间采光系数不低于2%...", + "无障碍设计规范：门道净宽不小于0.8米...", + # ... 更多设计规范文档 +] + +# 步骤2：用户提问 +query = "办公空间的人均面积标准是多少？" + +# 步骤3：检索相关文档 +relevant_docs = retrieve(query, knowledge_base) +# 返回: ["办公建筑设计标准：普通办公空间人均使用面积不小于6平方米..."] + +# 步骤4：构建增强提示 +augmented_prompt = f""" +根据以下参考资料回答问题。如果资料中没有相关信息，请说明。 + +参考资料： +{relevant_docs} + +问题：{query} +""" + +# 步骤5：LLM 生成回答 +answer = llm.generate(augmented_prompt) +# 输出: "根据《办公建筑设计标准》，普通办公空间人均使用面积不应小于6平方米。" +``` + +### RAG 的优势 + +| 优势 | 说明 | +|------|------| +| 减少幻觉 | 回答基于真实文档，有据可查 | +| 知识更新 | 只需更新知识库，无需重新训练模型 | +| 领域适配 | 轻松添加专业设计知识 | +| 可追溯性 | 可以提供答案来源 | + +--- + +## RLHF：基于人类反馈的强化学习 + +### 三个训练阶段 + +``` +阶段1：监督微调（SFT） +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + 人类编写示范回答 → 训练模型模仿 + + 示例： + 指令："设计一个50人的办公空间" + 示范回答："建议采用开放式布局..." + +阶段2：训练奖励模型（Reward Model） +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + 模型生成多个回答 → 人工排序 → 训练打分模型 + + 问题："设计一个50人的办公空间" + 回答A: ████████████ 评分: 8 ← 人工标注 + 回答B: ██████████ 评分: 6 + 回答C: ██████ 评分: 3 + + → 训练一个能自动评分的 Reward Model + +阶段3：强化学习优化（RL） +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + 用 PPO 算法让模型生成高分回答 + + 模型生成回答 → Reward Model 打分 → 更新模型参数 + 重复这个过程，让模型学会生成人类偏好的回答 +``` + +### RLHF 的设计意义 + +``` +通过 RLHF，大模型学会了： + + ✓ 遵循设计约束（面积、预算、规范） + ✓ 结构化输出（分点描述，层次清晰） + ✓ 适度创意（在合理范围内创新） + ✓ 安全意识（遵守安全规范和伦理标准） + ✗ 避免不切实际的方案 + ✗ 避免忽略用户的核心需求 +``` + +--- + +## Prompt Engineering：提示工程 + +### 核心原则 + +Prompt Engineering 是与大语言模型有效沟通的"艺术与科学"： + +``` +原则一：明确任务 +━━━━━━━━━━━━━━━━ + ✗ 模糊："帮我设计一个空间" + ✓ 明确："请为一个30平米的客厅设计一个简约风格的家具布局方案" + +原则二：提供示例（Few-shot） +━━━━━━━━━━━━━━━━ + 在提示中给出1-3个示例，让模型理解期望的输出格式 + +原则三：指定格式 +━━━━━━━━━━━━━━━━ + "请按以下格式输出： + 1. 设计理念（50字以内） + 2. 空间布局（分点描述） + 3. 材料建议（列表形式） + 4. 预估预算（表格形式）" + +原则四：角色设定 +━━━━━━━━━━━━━━━━ + "你是一位有15年经验的室内设计师，擅长小户型改造..." +``` + +### 设计应用示例 + +``` +Prompt: 设计一个50人的办公空间 + +角色设定： +你是一位资深办公空间设计师，熟悉人体工程学和现代办公理念。 + +任务要求： +- 面积：约200平方米 +- 人数：50人 +- 类型：科技创业公司 +- 风格：现代简约 +- 需要考虑：开放工位、会议室、休息区、茶水间 + +请按以下结构输出： +1. 空间规划方案 +2. 动线设计要点 +3. 家具选型建议 +4. 照明设计方案 +5. 预估造价 + +--- + +LLM 输出（示例）： + +1. 空间规划方案 + ├── 开放工位区（120㎡）：40个工位，2人/组 + ├── 独立办公区（20㎡）：2间，各容纳5人 + ├── 会议室（30㎡）：1间大会议室 + 2间小会议室 + ├── 休息区（15㎡）：沙发、茶水台 + └── 茶水间（15㎡）：吧台、储物柜 + +2. 动线设计要点 + ├── 主通道宽度 ≥ 1.2m + ├── 入口直通开放区，减少干扰 + └── 会议室靠近入口，方便访客 + ... +``` + +### Prompt 设计模式 + +``` +┌─────────────────────────────────────────────────┐ +│ 模式 适用场景 示例 │ +├─────────────────────────────────────────────────┤ +│ Zero-shot 简单任务 "翻译：你好" │ +│ Few-shot 格式化输出 给2-3个范例 │ +│ Chain-of 复杂推理 "让我们一步步 │ +│ Thought 来思考..." │ +│ Role-play 专业领域 "你是一名建筑 │ +│ 设计师..." │ +│ Template 结构化输出 固定输出模板 │ +└─────────────────────────────────────────────────┘ +``` + +--- + +# 3.6 设计应用 + +## 应用一：设计文档文本分类 + +``` +场景：设计公司收到大量项目文档，需要自动分类归档 + + 输入文档 → 文本分类模型 → 类别标签 + "本项目采用新中式园林风格..." → "景观设计" + "室内空间以简约风格为主..." → "室内设计" + "建筑主体采用框架剪力墙..." → "建筑设计" +``` + +```python +from transformers import AutoModelForSequenceClassification, AutoTokenizer +import torch + +# 加载预训练的中文文本分类模型 +model_name = "bert-base-chinese" +tokenizer = AutoTokenizer.from_pretrained(model_name) +model = AutoModelForSequenceClassification.from_pretrained( + model_name, num_labels=4 # 4个设计类别 +) + +# 分类推理 +text = "本方案采用开放式布局，以白色和原木色为主色调" +inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True) +outputs = model(**inputs) +predicted_class = torch.argmax(outputs.logits, dim=1) + +categories = ["建筑设计", "景观设计", "室内设计", "平面设计"] +print(f"分类结果: {categories[predicted_class]}") +# 输出: 分类结果: 室内设计 +``` + +## 应用二：用户评价情感分析 + +``` +场景：分析用户对设计方案的反馈 + + "新方案的空间利用很合理，采光也不错" → 正面 + "走廊太窄了，家具颜色也不搭配" → 负面 + "基本满足需求，但细节还有改进空间" → 中性 +``` + +```python +# 使用预训练模型进行情感分析 +from transformers import pipeline + +sentiment_analyzer = pipeline( + "sentiment-analysis", + model="uer/roberta-base-finetuned-jd-binary-chinese" +) + +# 批量分析设计评价 +reviews = [ + "这个设计方案很有创意，空间利用率很高", + "配色方案不太协调，建议调整", + "整体还不错，就是预算偏高" +] + +for review in reviews: + result = sentiment_analyzer(review) + print(f"评价: {review}") + print(f"情感: {result[0]['label']} (置信度: {result[0]['score']:.2%})") + print() +``` + +## 应用三：设计描述自动生成 + +``` +场景：根据设计参数自动生成方案描述文本 + + 输入参数： + - 空间类型：客厅 + - 面积：35平方米 + - 风格：现代简约 + - 主色：白色 + 原木色 + - 需求：家庭聚会、阅读角 + + 生成描述： + "本方案为35平方米的客厅空间设计，采用现代简约风格。 + 空间以白色和原木色为主色调，营造明亮温馨的氛围。 + 布局上，沙发区面向景观窗，可满足家庭聚会需求； + 窗边设置阅读角，配备落地灯和单人沙发。 + 整体动线流畅，兼顾功能性与美感。" +``` + +## 应用四：对话式设计助手 + +``` +场景：设计师通过对话形式获取设计建议 + + ┌──────────────────────────────────────────────────────┐ + │ 设计师：我想为一个80平米的小户型做室内设计， │ + │ 业主要求现代简约风格，预算15万。 │ + │ │ + │ AI助手：好的，我来帮您规划。80平米做现代简约是 │ + │ 很好的选择。我有几个问题： │ + │ │ + │ 1. 户型是几室几厅？ │ + │ 2. 家庭成员构成？（是否有老人/儿童） │ + │ 3. 有没有特别的空间需求？（书房/衣帽间等） │ + │ │ + │ 设计师：两室一厅，一家三口，孩子5岁，需要一个小书房 │ + │ │ + │ AI助手：明白了。以下是我的初步建议： │ + │ │ + │ 【空间规划】 │ + │ - 主卧：约15㎡（含衣柜区） │ + │ - 儿童房：约10㎡（考虑成长性设计） │ + │ - 客厅+餐厅：约25㎡（开放式布局） │ + │ - 书房：约6㎡（可做半开放式） │ + │ - 厨卫：约12㎡ │ + │ - 阳台：约6㎡（兼顾洗衣和休闲） │ + │ ... │ + └──────────────────────────────────────────────────────┘ +``` + +### 技术实现思路 + +```python +# 对话式设计助手的基本架构 + +class DesignAssistant: + def __init__(self, llm, knowledge_base): + self.llm = llm # 大语言模型 + self.knowledge_base = knowledge_base # 设计知识库 + self.conversation_history = [] + + def chat(self, user_input): + # 1. 从知识库检索相关设计规范 + relevant_docs = self.knowledge_base.retrieve(user_input) + + # 2. 构建增强提示 + system_prompt = """ + 你是一位专业的室内设计顾问。请根据用户需求和 + 参考的设计规范，提供专业、实用的设计建议。 + 回答要有条理，必要时提出追问以明确需求。 + """ + + # 3. 组装完整提示 + messages = [ + {"role": "system", "content": system_prompt}, + *self.conversation_history, + {"role": "user", "content": f"参考资料：{relevant_docs}\n\n用户问题：{user_input}"} + ] + + # 4. 调用 LLM 生成回答 + response = self.llm.chat(messages) + + # 5. 更新对话历史 + self.conversation_history.append({"role": "user", "content": user_input}) + self.conversation_history.append({"role": "assistant", "content": response}) + + return response +``` + +--- + +# 思考与练习 + +1. **模型选择**：在设计项目文档分类任务中，你会选择 BERT 还是 GPT 架构？为什么？考虑模型规模、训练成本、任务特点等因素。 + +2. **RAG vs 微调**：你正在为一家建筑设计院开发 AI 设计助手。设计规范经常更新，且需要提供条文来源。你会选择 RAG 还是模型微调？请分析两种方案的优劣。 + +3. **Prompt 设计**：尝试设计一个高质量的 Prompt，让大语言模型帮助分析一份景观设计方案的优缺点。你的 Prompt 中应该包含哪些要素？考虑角色设定、输出格式、评估维度等。 + +--- + +# 关键术语 + +| 中文 | 英文 | 说明 | +|------|------|------| +| 循环神经网络 | RNN (Recurrent Neural Network) | 处理序列数据的基础网络结构 | +| 长短期记忆网络 | LSTM (Long Short-Term Memory) | 解决 RNN 梯度消失问题的改进结构 | +| 门控循环单元 | GRU (Gated Recurrent Unit) | LSTM 的简化版本，参数更少 | +| 自注意力机制 | Self-Attention | 序列内部元素之间直接计算关联的机制 | +| 缩放点积注意力 | Scaled Dot-Product Attention | 带缩放的注意力计算公式 | +| 多头注意力 | Multi-Head Attention | 多组并行的注意力，捕获多种关系模式 | +| 位置编码 | Positional Encoding | 为序列中的位置信息编码的方法 | +| Transformer | Transformer | 基于注意力机制的序列模型架构 | +| 掩码注意力 | Masked Attention | 防止解码器看到未来信息的注意力机制 | +| 大语言模型 | LLM (Large Language Model) | 参数量巨大的预训练语言模型 | +| 检索增强生成 | RAG (Retrieval-Augmented Generation) | 结合外部知识库的生成方法 | +| 人类反馈强化学习 | RLHF (Reinforcement Learning from Human Feedback) | 基于人类偏好优化模型的方法 | +| 提示工程 | Prompt Engineering | 设计有效提示以引导模型输出的技术 | +| 分词 | Tokenization | 将文本拆分为最小处理单元的过程 | +| 词嵌入 | Embedding | 将离散的词映射为连续向量表示 | +| 预训练 | Pre-training | 在大规模数据上的初始训练阶段 | +| 微调 | Fine-tuning | 在特定任务数据上的调整训练 | +| 自回归 | Autoregressive | 逐步生成，每步依赖之前输出 | +| 幻觉 | Hallucination | 模型生成看似合理但实际错误的内容 | +| 缩放定律 | Scaling Law | 模型性能与规模之间的关系规律 | + +--- + +# 延伸阅读 + +- [Attention Is All You Need](https://arxiv.org/abs/1706.03762) — Transformer 原始论文 +- [The Illustrated Transformer](https://jalammar.github.io/illustrated-transformer/) — Transformer 可视化解读 +- [BERT: Pre-training of Deep Bidirectional Transformers](https://arxiv.org/abs/1810.04805) — BERT 论文 +- [Language Models are Few-Shot Learners (GPT-3)](https://arxiv.org/abs/2005.14165) — GPT-3 论文 +- [Training language models to follow instructions with human feedback](https://arxiv.org/abs/2203.02155) — InstructGPT/RLHF 论文 +- [Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks](https://arxiv.org/abs/2005.11401) — RAG 原始论文 diff --git a/03-computer-vision/03-computer-vision.md b/03-computer-vision/03-computer-vision.md deleted file mode 100644 index 3489960..0000000 --- a/03-computer-vision/03-computer-vision.md +++ /dev/null @@ -1,464 +0,0 @@ -# 第三篇：计算机视觉与空间图像 - -本篇深入讲解计算机视觉的核心技术CNN，以及目标检测和语义分割在空间分析中的应用。 - -## 篇章导读 - -计算机视觉让机器"看见"世界。从图像分类到目标检测，从语义分割到场景理解，视觉技术正在改变设计领域对空间信息的处理方式。 - -本篇将系统介绍CNN原理及其在空间分析中的应用。 - ---- - -### 学习目标 - -理解CNN的核心思想：局部连接与权重共享 - -掌握卷积、激活、池化三大组件 - -了解CNN与MLP的区别和联系 - -### 为什么需要CNN - -MLP的问题 - -将图像展平成一维向量输入MLP： - -`28×28``图像`` → 784``维向量`` → MLP` - -**问题**： 1. 参数量巨大：784×1000 = 784,000个参数 2. 忽略空间结构：相邻像素的关系被破坏 3. 缺乏平移不变性：物体移位后需要重新学习 - -#### CNN的解决方案 - - ------------------------------------------------------------ - 特性 说明 优势 - ------------ -------------------------- -------------------- - 局部连接 每个神经元只连接局部区域 符合图像局部相关性 - - 权重共享 同一卷积核扫描全图 大幅减少参数 - - 层次化特征 低层→高层特征抽象 自动学习特征表达 - ------------------------------------------------------------ - -### CNN三大组件 - -#### 1. 卷积层 (Convolution) - -**卷积操作**：用卷积核（Filter）在图像上滑动，计算局部特征 - -`输入图像`` ``卷积核`` ``特征图`\ -`┌─────────┐ ┌─────┐ ┌─────────┐`\ -`│ 1 2 3 │ │ 1 0 │ │ 8 10 │`\ -`│ 4 5 6 │ ⊗ │ 0 -1 │ = │ 14 16 │`\ -`│ 7 8 9 │ │ │ │ │`\ -`└─────────┘ └─────┘ └─────────┘` - -**计算示例**： - -`输出``(1,1) = 1×1 + 2×0 + 4×0 + 5×(-1) = 1 - 5 = -4` - -**多通道卷积**： - -`RGB``图像`` (3``通道``) + ``卷积核`` (3×3×3) → ``特征图`` (``单通道``)` - -#### 2. 激活层 (Activation) - -通常使用ReLU： - -`output ``=`` ``max``(``0``, ``feature_map``)` - -作用：引入非线性，使网络能学习复杂模式 - -#### 3. 池化层 (Pooling) - -**最大池化** (Max Pooling)： - -`2×2``窗口`` → ``取最大值`\ -`┌─────┐ ┌───┐`\ -`│3 1 │ │ 3 │`\ -`│2 5 │ → │ │`\ -`└─────┘ │ 5 │`\ -` └───┘` - -作用： - 降低维度，减少计算量 - 增强平移不变性 - 扩大感受野 - -### CNN架构示例 - -#### LeNet-5 (经典架构) - -`输入``(32×32) → ``卷积层`` → ``池化层`` → ``卷积层`` → ``池化层`\ -` ↓`\ -` ``全连接层`` → ``输出` - -#### VGG-16 (深层架构) - -`输入`` → [Conv×3 + Pool] ×2 → [Conv×3 + Pool] ×3`\ -` → [Conv×3 + Pool] ×3 → FC×3 → ``输出` - -### CNN vs MLP - - ------------------------------------- - 特性 MLP CNN - ---------- -------------- ----------- - 连接方式 全连接 局部连接 - - 权重 每个连接独立 同层共享 - - 空间结构 忽略 保留 - - 参数量 大 小 - - 适用任务 结构化数据 图像/语音 - ------------------------------------- - -### 经典网络架构演进 - -`LeNet`` (1998) → ``首次定义``CNN``结构`\ -` ↓`\ -`AlexNet`` (2012) → ``深度学习爆发，``ReLU``激活`\ -` ↓`\ -`VGG (2014) → ``更深网络，``3×3``小卷积核`\ -` ↓`\ -`GoogLeNet`` (2014) → Inception``模块，多尺度`\ -` ↓`\ -`ResNet`` (2015) → ``残差连接，``152``层`\ -` ↓`\ -`EfficientNet`` (2019) → ``复合缩放，高效` - -### 思考与练习 - -1.为什么卷积核通常选择奇数尺寸（3×3, 5×5）？ - -2.感受野如何随着网络深度增加？ - -3.设计一个简单的CNN用于手写数字识别 - -### 关键术语 - - ------------------------------------------------------- - 中文 英文 说明 - -------- ----------------- ---------------------------- - 卷积核 Kernel/Filter 用于特征提取的小矩阵 - - 步幅 Stride 卷积核滑动的步长 - - 填充 Padding 边缘补零以保持尺寸 - - 感受野 Receptive Field 神经元响应的输入区域 - - 通道 Channel 图像的颜色维度或特征图数量 - ------------------------------------------------------- - -### 延伸阅读 - -[CS231n: Convolutional Neural Networks](http://cs231n.stanford.edu/) - -[Understanding CNNs](https://poloclub.github.io/cnn-explainer/) \# 02.2 目标检测 - ---- - -## 学习目标 - -理解目标检测与图像分类的区别 - -掌握YOLO系列的发展脉络 - -了解目标检测在设计中的应用 - -### 从分类到检测 - -#### 图像分类 - -`输入图像`` → CNN → ``类别标签`\ -`"``猫``" (``单标签``)` - -#### 目标检测 - -`输入图像`` → CNN → [``位置``, ``类别``]`\ -`[``边界框``, "``猫``", 0.95]`\ -`[``边界框``, "``狗``", 0.87]` - -**核心差异**：检测需要同时解决"是什么"和"在哪里" - -### 检测器类型 - -#### Two-Stage检测器 - -`第一阶段：候选区域生成`\ -` RPN (Region Proposal Network)`\ -\ -`第二阶段：分类与回归`\ -` ``对每个候选框进行精确预测`\ -\ -`代表：``R-CNN, Fast R-CNN, Faster R-CNN` - -特点：准确率高，速度慢 - -#### One-Stage检测器 - -`直接预测：一次性输出所有边界框和类别`\ -\ -`代表：``YOLO, SSD, ``RetinaNet` - -特点：速度快，实时性好 - -### YOLO系列演进 - -#### YOLO v1 (2016) - -**核心思想**：将检测转化为回归问题 - -`输入图像`` → S×S``网格`` → ``每个网格预测``B``个边界框` - -创新点： - 端到端训练 - 实时检测 (45 FPS) - -#### YOLO v2-v4 - - ---------------------------------- - 版本 主要改进 - ------ --------------------------- - v2 Batch Normalization, 锚框 - - v3 多尺度预测 - - v4 CSPDarknet, PANet - - v5 PyTorch实现，工程优化 - - v8 重新设计，更易用 - ---------------------------------- - -#### YOLO工作流程 - -##### 1. 输入图像 (640×640) - -`↓` - -##### 2. Backbone特征提取 - -`↓` - -##### 3. Neck特征融合 (FPN + PAN) - -`↓` - -##### 4. Head检测输出 - -`- ``边界框坐标` - -`- ``目标置信度` - -`- ``类别概率` - -### 评估指标 - -#### IoU (交并比) - -`IoU`` = ``预测框与真实框的交集`` / ``并集`\ -\ -` ┌─────────┐`\ -` │ ``预测框`` │`\ -` │ ┌───┐ │`\ -` │ │``真`` │ │`\ -` └──┼──┼─┘`\ -` └───┘`\ -\ -`IoU`` = ``重叠面积`` / ``总面积` - -### mAP (平均精度均值) - -在不同IoU阈值(0.5, 0.75...)下的平均精度 - -综合衡量定位准确度和分类准确度 - -### COCO数据集 - -80类物体，包含： - 目标检测 - 实例分割 - 关键点检测 - 图像说明 - -## 设计领域应用 - -建筑识别 - -`卫星图像`` → YOLO → ``建筑物边界框`\ -` ↓`\ -`自动生成建筑轮廓` - -场景分析 - -`室内照片`` → ``目标检测`` → ``家具识别`\ -` ↓`\ -`空间布局分析` - -遗产保护 - -`无人机影像`` → ``建筑病害检测`\ -` ↓`\ -`自动化巡检与记录` - -## 思考与练习 - -1.Two-Stage和One-Stage检测器的权衡是什么？ - -2.为什么YOLO能实现实时检测？ - -3.目标检测在规划设计中有哪些潜在应用？ - -## 关键术语 - - ------------------------------------------------------- - 中文 英文 说明 - -------------- -------------- ------------------------- - 边界框 Bounding Box 矩形目标框 - - 锚框 Anchor Box 预定义的候选框 - - 非极大值抑制 NMS 去除重复检测 - - 交并比 IoU Intersection over Union - - 平均精度 AP Average Precision - ------------------------------------------------------- - -## 延伸阅读 - -[Ultralytics YOLO文档](https://docs.ultralytics.com/) - -[COCO数据集](https://cocodataset.org/) \# 02.3 语义分割与空间分析 - ---- - -## 学习目标 - -理解图像分析的三种层级 - -掌握语义分割与实例分割的区别 - -了解分割技术在空间分析中的应用 - -## 图像分析层级 - -### Pixel-Level (像素级) - -`每个像素独立处理`\ -`问题：不考虑上下文` - -### Patch-Level (图块级) - -`以图像块为单位`\ -`特点：保留局部空间关系`\ -`应用：``CNN``卷积操作` - -### Object-Level (对象级) - -`以完整对象为单位`\ -`特点：语义完整`\ -`应用：目标检测、分割` - -### 语义分割 vs 实例分割 - -#### 语义分割 (Semantic Segmentation) - -`所有同类对象归为一类`\ -`图像`` → [``道路``, ``建筑``, ``车辆``, ``行人``, ...]` - -特点： - 同类别用同一种颜色 - 不区分个体数量 - -#### 实例分割 (Instance Segmentation) - -`每个对象单独分割`\ -`图像`` → [``建筑``1, ``建筑``2, ``车``1, ``车``2, ...]` - -特点： - 区分同类对象的不同个体 - 更精细的场景理解 - -### 分割网络架构 - -#### FCN (全卷积网络) - -`CNN``特征提取`` → ``上采样`` → ``像素级预测` - -创新：用卷积层替代全连接层，输出热力图 - -#### U-Net - -`编码器`` → ``瓶颈层`` → ``解码器`\ -` ↓ ↑`\ -`跳跃连接`` ───────────────┘` - -特点： - U型对称结构 - 跳跃连接融合多尺度特征 - 医学图像分割经典架构 - -#### DeepLab系列 - -空洞卷积 (Atrous Convolution) - -扩大感受野而不降低分辨率 - -ASPP (空洞空间金字塔池化) - -### 空间分析应用 - -#### 遥感影像分析 - -`卫星图像`` → ``语义分割`` → ``土地利用分类`\ -` ↓`\ -`- ``建筑用地`\ -`- ``农用地`\ -`- ``水体`\ -`- ``森林` - -#### 城市形态分析 - -`街景图像`` → ``分割`` → ``空间品质评估`\ -` ↓`\ -`- ``绿视率`\ -`- ``天空开阔度`\ -`- ``建筑密度` - -#### 景观格局分析 - -`高分辨率影像`` → ``生态源地识别`\ -` ↓`\ -`景观连接性评估` - -### 分割与检测对比 - - -------------------------------- - 特性 目标检测 语义分割 - -------- ---------- ------------ - 输出 矩形框 像素级标注 - - 精度 粗糙 精细 - - 计算量 较低 较高 - - 应用 目标定位 场景理解 - -------------------------------- - -### 思考与练习 - -1.语义分割和实例分割分别在什么场景下更有用？ - -2.U-Net的跳跃连接为什么重要？ - -3.分割技术如何辅助规划设计决策？ - -### 关键术语 - - ----------------------------------------------------- - 中文 英文 说明 - ---------- ----------------------- ------------------ - 语义分割 Semantic Segmentation 按类别分割像素 - - 实例分割 Instance Segmentation 按对象个体分割 - - 热力图 Heatmap 像素级预测结果 - - 空洞卷积 Atrous Convolution 扩大感受野的卷积 - - 跳跃连接 Skip Connection 跨层连接 - ----------------------------------------------------- - -### 延伸阅读 - -[Fully Convolutional Networks](https://arxiv.org/abs/1411.4038) - -[U-Net: Convolutional Networks for Biomedical Image Segmentation](https://arxiv.org/abs/1505.04597) diff --git a/04-2d-vision/04-2d-vision.md b/04-2d-vision/04-2d-vision.md new file mode 100644 index 0000000..3ea3326 --- /dev/null +++ b/04-2d-vision/04-2d-vision.md @@ -0,0 +1,867 @@ +# 第三篇：二维数据——图像与视觉 + +本篇聚焦二维数据的智能处理。图像是最常见的二维数据形式，也是设计领域最核心的信息载体。本篇将追溯从卷积神经网络到视觉Transformer、再到大视觉模型的技术演进脉络，帮助读者理解计算机视觉技术的发展全貌及其在设计领域的广泛应用。 + +## 篇章导读 + +人类感知世界，约80%的信息来自视觉。对于设计师而言，图像不仅是设计成果的呈现形式，更是灵感来源、分析对象和沟通媒介。 + +本章将沿着一条清晰的技术演进主线展开：**从小模型时代（CNN）到大模型时代（Vision Transformer），再到多模态大视觉模型**。我们将看到，计算机视觉如何从"识别图片中的猫"一步步发展到"理解任意场景中的任意内容"，以及这些技术如何赋能建筑识别、街景分析、设计素材管理等设计实践。 + +通过本章学习，你将： + +- 理解卷积神经网络（CNN）的核心原理与经典架构 +- 掌握目标检测、语义分割等核心视觉任务的原理与方法 +- 了解Vision Transformer如何颠覆CNN的统治地位 +- 认识CLIP、SAM等大视觉模型带来的范式变革 +- 将上述技术思维应用于设计场景分析 + +--- + +## 4.1 卷积神经网络 + +### 4.1.1 为什么不用MLP处理图像 + +在第2章中，我们学习了多层感知机（MLP）。一个自然的问题是：**能否直接用MLP处理图像？** + +假设输入一张 224×224 的RGB图像。如果将其展平为向量，输入维度为： + +``` +224 × 224 × 3 = 150,528 +``` + +若第一个隐藏层有1024个神经元，则该层的参数量为： + +``` +150,528 × 1024 + 1024（偏置） ≈ 1.54亿 +``` + +**仅仅一层就有1.54亿参数！** 而一个实用的网络通常需要多个隐藏层。这意味着： + +- **参数爆炸**：模型过于庞大，训练困难，极易过拟合 +- **忽略空间结构**：展平操作破坏了像素之间的二维空间关系，而图像的语义恰恰蕴含在空间结构中 +- **平移敏感性**：同一物体出现在图像不同位置时，MLP的响应完全不同 + +因此，我们需要一种专为二维数据设计的网络架构——**卷积神经网络（Convolutional Neural Network, CNN）**。 + +### 4.1.2 CNN的三大核心思想 + +CNN通过三个关键设计解决了MLP的上述缺陷： + +| 核心思想 | 含义 | 解决的问题 | +|----------|------|------------| +| 局部连接 | 每个神经元只关注局部区域 | 大幅减少参数量 | +| 权重共享 | 同一卷积核在整张图上滑动 | 平移等变性 | +| 层级特征 | 逐层提取从简单到复杂的特征 | 自动学习特征层级 | + +**直觉理解**：人在识别一张建筑照片时，不会同时关注所有像素，而是先看局部特征（窗户、门、柱子），再组合成整体判断。CNN正是模拟了这种"从局部到整体"的视觉处理方式。 + +### 4.1.3 卷积操作 + +卷积操作是CNN的核心。它通过一个小的**卷积核（Kernel/Filter）**在输入图像上滑动，逐区域计算加权和，提取局部特征。 + +**单通道卷积示意**： + +``` +输入图像 (5×5) 卷积核 (3×3) 输出特征图 (3×3) +┌───┬───┬───┬───┬───┐ ┌───┬───┬───┐ ┌───┬───┬───┐ +│ 1 │ 0 │ 1 │ 0 │ 1 │ │ 1 │ 0 │-1 │ │ 2 │ 0 │ 1 │ +├───┼───┼───┼───┼───┤ ├───┼───┼───┤ ├───┼───┼───┤ +│ 0 │ 1 │ 0 │ 1 │ 0 │ │ 1 │ 0 │-1 │ │ 1 │ 3 │ 2 │ +├───┼───┼───┼───┼───┤ ├───┼───┼───┤ ├───┼───┼───┤ +│ 1 │ 0 │ 1 │ 0 │ 1 │ │ 1 │ 0 │-1 │ │ 2 │ 0 │ 1 │ +├───┼───┼───┼───┼───┤ └───┴───┴───┘ └───┴───┴───┘ +│ 0 │ 1 │ 0 │ 1 │ 0 │ +├───┼───┼───┼───┼───┤ +│ 1 │ 0 │ 1 │ 0 │ 1 │ +└───┴───┴───┴───┴───┘ +``` + +计算过程（左上角第一个输出值）： + +``` +(1×1 + 0×0 + 1×(-1)) + (0×1 + 1×0 + 0×(-1)) + (1×1 + 0×0 + 1×(-1)) += 1 + 0 - 1 + 0 + 0 + 0 + 1 + 0 - 1 = 0 + +加上偏置后得到输出值 +``` + +**多通道卷积**：实际图像通常是RGB三通道。卷积核也需要匹配输入通道数。例如，输入为3通道时，一个 3×3 卷积核的实际尺寸为 3×3×3，对三个通道分别计算后求和，产生一个输出通道。使用多个卷积核即可产生多个输出通道。 + +``` +RGB输入 (H×W×3) 多个卷积核 输出特征图 +┌─────────────┐ ┌──────────┐ ┌──────────┐ +│ R通道 │ │核1: 3×3×3│──→ 通道1 │ │ +│ G通道 │ × │核2: 3×3×3│──→ 通道2 │ H'×W'×K │ +│ B通道 │ │ ... │ │ │ +└─────────────┘ │核K: 3×3×3│──→ 通道K │ │ + └──────────┘ └──────────┘ + K个卷积核 +``` + +**卷积的关键参数**： + +| 参数 | 含义 | 典型值 | +|------|------|--------| +| 卷积核大小 | 每次看到的局部区域大小 | 3×3, 5×5 | +| 步长（Stride） | 卷积核每次移动的像素数 | 1, 2 | +| 填充（Padding） | 在输入边缘补零 | 0, 1 | +| 输出通道数 | 使用的卷积核数量 | 64, 128, 256 | + +### 4.1.4 激活函数：ReLU + +卷积操作是线性的，如果不引入非线性变换，无论堆叠多少层卷积，最终等价于一个线性变换。因此需要在卷积后添加**激活函数**。 + +CNN中最常用的激活函数是 **ReLU（Rectified Linear Unit）**： + +``` +ReLU(x) = max(0, x) + + 输出 + │ / + │ / + │ / + │ / +─────┼───── 输入 + │ + │ +``` + +ReLU的优势： + +- **计算简单**：只需判断正负，比Sigmoid和Tanh快得多 +- **缓解梯度消失**：正区间梯度恒为1，反向传播时信号不会衰减 +- **稀疏激活**：负值被置零，使网络天然具有稀疏性 + +### 4.1.5 池化操作 + +池化（Pooling）操作的作用是降低特征图的空间尺寸，减少参数量和计算量，同时增强特征的平移不变性。 + +**最大池化（Max Pooling）示意**： + +``` +输入特征图 (4×4) 2×2 最大池化 输出 (2×2) +┌───┬───┬───┬───┐ 步长=2 ┌───┬───┐ +│ 1 │ 3 │ 2 │ 1 │ │ 6 │ 8 │ +├───┼───┼───┼───┤ ┌───┬───┐ ├───┼───┤ +│ 5 │ 6 │ 7 │ 4 │ │max│max│ │ 9 │12 │ +├───┼───┼───┼───┤ └───┴───┘ └───┴───┘ +│ 3 │ 2 │ 1 │ 8 │ max(1,3,5,6)=6 +├───┼───┼───┼───┤ max(2,1,7,4)=7→8修正 6, 8 +│ 4 │ 9 │ 3 │12 │ max(3,2,4,9)=9 9, 12 +└───┴───┴───┴───┘ max(1,8,3,12)=12 +``` + +池化的效果： + +- **降维**：特征图尺寸减半，计算量减少为1/4 +- **平移不变性**：局部区域内的微小位移不影响最大值 +- **保留主要特征**：最大池化保留了最显著的特征响应 + +### 4.1.6 经典架构演进 + +CNN架构在过去二十多年中经历了显著的演进： + +``` +LeNet (1998) AlexNet (2012) VGG (2014) ResNet (2015) + 手写数字识别 图像分类突破 结构简洁优雅 解决退化问题 + 6万参数 6000万参数 1.38亿参数 深度可达152层+ + + │ │ │ │ + ▼ ▼ ▼ ▼ + 卷积→池化→ 更深更宽+ 小卷积核 残差连接 + 卷积→池化→ Dropout+ 堆叠(3×3) F(x)+x + 全连接 数据增强 统一规范 +``` + +**架构时间线与关键创新**： + +| 架构 | 年份 | 深度 | 关键创新 | 意义 | +|------|------|------|----------|------| +| LeNet-5 | 1998 | 5层 | 首个成功的CNN | 手写数字识别，邮局实用 | +| AlexNet | 2012 | 8层 | ReLU、Dropout、GPU训练 | ImageNet竞赛冠军，深度学习复兴 | +| VGGNet | 2014 | 16-19层 | 3×3小卷积核堆叠 | 证明"更深=更好"的简洁设计 | +| ResNet | 2015 | 152层+ | 残差连接（Skip Connection） | 突破深度瓶颈，可训练极深网络 | + +### 4.1.7 ResNet的残差连接：突破深度瓶颈 + +随着网络加深，出现了一个反直觉的现象：**网络越深，训练误差反而越大**。这不是过拟合（训练集误差也增大），而是**退化问题（Degradation Problem）**——深层网络难以优化。 + +ResNet的核心创新是**残差连接（Residual Connection）**： + +``` + 输入 x + │ + │ ┌──────────────────┐ + │ │ │ + └────────→│ 恒等映射（跳过） │ + │ │ + ┌─────────┴────────┐ │ + │ 残差块 F(x) │ │ + │ (两层卷积+ReLU) │ │ + └─────────┬────────┘ │ + │ │ + ▼ ▼ + ⊕ ← ← ← ← ← ← ← ← ┘ + │ + ▼ + 输出 = F(x) + x +``` + +核心公式： + +``` +输出 = F(x) + x +``` + +其中 F(x) 是残差映射，x 是恒等映射（直接传递）。 + +**为什么有效？** + +- 如果最优解接近恒等映射，网络只需学习残差 F(x) ≈ 0，比从零学习 x 容易得多 +- 梯度可以直接通过跳跃连接回传，缓解梯度消失 +- 使得训练上百层甚至上千层的网络成为可能 + +> **设计思维链接**：残差连接的思想类似于设计中的"增量修改"——在保留原有方案（x）的基础上进行改进（F(x)），而非推倒重来。这种"在已有基础上做调整"的策略，在参数空间中比"从零开始学习"高效得多。 + +--- + +## 4.2 目标检测 + +### 4.2.1 从分类到检测 + +图像分类回答的问题是"这是什么"，而目标检测需要同时回答两个问题： + +``` +分类： "这是一张建筑的照片" → what + +检测： "左上角有一栋现代建筑， → what + where + 右下角有一棵树， + 中间有一条道路" +``` + +目标检测的输出是若干**边界框（Bounding Box）**及其对应的类别和置信度： + +``` +┌─────────────────────────────┐ +│ ┌──────────┐ │ +│ │ 建筑 0.95│ │ +│ └──────────┘ │ +│ ┌─────────┐ │ +│ │ 汽车 │ │ +│ │ 0.87 │ │ +│ └─────────┘ │ +│ ┌────┐ │ +│ │树木│ ┌──────┐ │ +│ │0.92│ │ 行人 │ │ +│ └────┘ │ 0.78 │ │ +│ └──────┘ │ +└─────────────────────────────┘ +``` + +### 4.2.2 两阶段检测器 + +两阶段方法的思路是"先找候选区域，再分类判别"，精度高但速度较慢。 + +**演进路线**： + +``` +R-CNN (2014) Fast R-CNN (2015) Faster R-CNN (2015) + │ │ │ + ▼ ▼ ▼ +选择性搜索 选择性搜索 区域建议网络 +找2000个候选框 找2000个候选框 (RPN) 自动生成 + │ │ │ + ▼ ▼ ▼ +逐个裁剪送入CNN 整图送入CNN 整图送入CNN +2000次前向传播 共享特征图 共享特征图 + │ │ │ + ▼ ▼ ▼ +SVM分类 ROI Pooling ROI Pooling +边框回归 全连接层分类 全连接层分类 + 边框回归 边框回归 + + 速度：极慢 速度：较快 速度：实时级 + 精度：一般 精度：较高 精度：高 +``` + +### 4.2.3 单阶段检测器：YOLO系列 + +YOLO（You Only Look Once）的核心思想是：**一次前向传播同时完成定位和分类**，将检测问题转化为回归问题。 + +**YOLO工作原理**： + +``` +输入图像 划分网格 (S×S) 每个网格预测 +┌─────────────┐ ┌───┬───┬───┐ ┌─────────┐ +│ │ │ │ │ │ │B个边界框 │ +│ 目标1 │ → ├───┼───┼───┤ → │(x,y,w,h)│ +│ 目标2│ │ │ │ │ │+ 置信度 │ +│ │ ├───┼───┼───┤ │+ 类别概率│ +└─────────────┘ │ │ │ │ └─────────┘ + └───┴───┴───┘ +``` + +**YOLO系列演进**： + +| 版本 | 年份 | 关键改进 | 特点 | +|------|------|----------|------| +| YOLOv1 | 2016 | 划分网格，统一回归 | 开创单阶段检测，速度快但精度有限 | +| YOLOv2 | 2017 | Batch Normalization、锚框 | 引入锚框提升召回率 | +| YOLOv3 | 2018 | 多尺度预测（FPN） | 三种尺度检测，小目标能力提升 | +| YOLOv4 | 2020 | CSPNet、Mosaic增强 | 训练技巧系统化集成 | +| YOLOv5 | 2020 | Ultralytics实现 | 工程化、易用性、部署友好 | +| YOLOv8 | 2023 | Anchor-free、解耦头 | 检测+分割统一框架，当前主流 | + +**两阶段 vs 单阶段对比**： + +| 维度 | 两阶段（Faster R-CNN） | 单阶段（YOLO） | +|------|------------------------|----------------| +| 速度 | 较慢（5-10 FPS） | 快（30-160 FPS） | +| 精度 | 高（适合小目标） | 较高（持续提升中） | +| 流程 | 先候选框→再分类 | 端到端回归 | +| 适用场景 | 精度优先 | 实时应用 | + +### 4.2.4 评价指标 + +**IoU（Intersection over Union）**：衡量预测框与真实框的重合程度。 + +``` + 预测框 + ┌───────────┐ + │ ┌──────┼────────┐ + │ 交集区域 │ │ ← 真实框 + │ │ │ │ + └────┼──────┘ │ + └───────────────┘ + + IoU = 交集面积 / 并集面积 + IoU = 1 表示完全重合 + IoU = 0 表示完全不相交 + 通常 IoU ≥ 0.5 视为检测正确 +``` + +**mAP（mean Average Precision）**：各类别AP的平均值，是检测任务的综合评价指标。COCO数据集采用 mAP@0.5:0.95（IoU阈值从0.5到0.95的平均值）作为标准指标。 + +### 4.2.5 设计应用 + +目标检测在设计领域有广泛应用： + +- **建筑识别**：从街景或卫星图像中自动检测建筑类型、风格特征 +- **场景分析**：识别城市空间中的元素（道路、绿化、设施），支持设计决策 +- **遗产保护**：自动检测历史建筑构件，辅助数字化记录与保护规划 +- **设计素材管理**：自动标注图片素材中的物体类型，实现智能检索 + +--- + +## 4.3 语义分割 + +### 4.3.1 像素级分类 + +如果说图像分类是对整张图给出一个标签，目标检测是给每个物体画一个框，那么**语义分割（Semantic Segmentation）**则是对每个像素给出一个类别标签——它是像素级别的分类任务。 + +``` +图像分类 目标检测 语义分割 +┌───────┐ ┌───────┐ ┌───────┐ +│ │ │ ┌───┐ │ │AAAAA │ +│ 猫 │ │ │猫 │ │ │AA┌──┐A│ +│ │ │ └───┘ │ │──│猫│─│ +└───────┘ │ ┌──┐│ │BB│ │B│ + "猫" │ │狗││ │BB└──┘B│ + └───┴──┘┘ └───────┘ + 猫+狗的位置 每个像素的类别 + +A=背景 B=地面 猫/狗=对应类别 +``` + +### 4.3.2 全卷积网络（FCN） + +FCN（Fully Convolutional Network, 2015）是语义分割的开创性工作，其核心思想是：**将分类网络中的全连接层替换为卷积层**，使网络可以接受任意尺寸的输入，并输出与输入空间对应的分割图。 + +``` +编码器（下采样） 解码器（上采样） +┌────────┐ ┌────────┐ +│ 卷积+池化│ → 1/2 →│ 上采样 │ → 2倍 +│ 卷积+池化│ → 1/4 →│ 上采样 │ → 4倍 +│ 卷积+池化│ → 1/8 →│ 上采样 │ → 8倍 +│ 卷积+池化│ → 1/16 →│ 上采样 │ → 16倍 +└────────┘ └────────┘ + 提取高级语义 恢复空间分辨率 + 分辨率逐步降低 分辨率逐步恢复 +``` + +### 4.3.3 U-Net：编码器-解码器与跳跃连接 + +U-Net（2015）最初为医学图像分割设计，其对称的编码器-解码器结构和**跳跃连接（Skip Connection）**使其成为分割领域的经典架构。 + +``` + U-Net 结构示意 + + 编码器（收缩路径） 解码器（扩展路径） + + 输入 ──→ [ conv×2 ] ────────────────────→ [ conv×2 ] ──→ 输出 + │ 64 │ 64 + ↓ pool upsample ↑ + [ conv×2 ] ────────────────────→ [ conv×2 ] + │ 128 │ 128 + ↓ pool upsample ↑ + [ conv×2 ] ────────────────────→ [ conv×2 ] + │ 256 │ 256 + ↓ pool upsample ↑ + [ conv×2 ] ────────────────────→ [ conv×2 ] + │ 512 │ 512 + ↓ pool upsample ↑ + [ conv×2 ] ← 底部（瓶颈层） → [ conv×2 ] + │ 1024 +``` + +**跳跃连接的作用**：编码器中的浅层特征保留了丰富的空间细节信息（如边缘、位置），而深层特征包含高级语义信息。跳跃连接将两者结合，使分割结果既有准确的语义判别，又有精细的空间边界。 + +### 4.3.4 DeepLab系列 + +DeepLab由Google团队提出，其核心创新是**空洞卷积（Atrous Convolution）**和**ASPP（Atrous Spatial Pyramid Pooling）**。 + +**空洞卷积**：在不增加参数量和计算量的前提下扩大感受野。 + +``` +标准 3×3 卷积 空洞率=2 的 3×3 卷积 +┌───┬───┬───┐ ┌───┬───┬───┬───┬───┐ +│ * │ * │ * │ │ * │ │ * │ │ * │ +├───┼───┼───┤ ├───┼───┼───┼───┼───┤ +│ * │ * │ * │ │ │ │ │ │ │ +├───┼───┼───┤ ├───┼───┼───┼───┼───┤ +│ * │ * │ * │ │ * │ │ * │ │ * │ +└───┴───┴───┘ ├───┼───┼───┼───┼───┤ + │ │ │ │ │ │ +感受野: 3×3 ├───┼───┼───┼───┼───┤ + │ * │ │ * │ │ * │ + └───┴───┴───┴───┴───┘ + 感受野: 5×5（不增加参数） +``` + +**ASPP**：使用多个不同空洞率的卷积并行提取多尺度上下文信息。 + +### 4.3.5 语义分割 vs 实例分割 + +``` +语义分割 实例分割 +┌───────────────┐ ┌───────────────┐ +│AAA BBB AAA │ │A1 B1 A2 │ +│AAA BBB AAA │ │A1 B1 A2 │ +│AAA BBB AAA │ │A1 B1 A2 │ +│ CCC BBB │ │ C1 B2 │ +└───────────────┘ └───────────────┘ + +每个像素标记类别 区分同类的不同实例 +不区分个体 A1≠A2, B1≠B2 + +例：所有建筑标为同一类 例：每栋建筑单独标记 +``` + +此外还有**全景分割（Panoptic Segmentation）**，结合了语义分割和实例分割的优点，对背景类进行像素级分类，对前景类进行实例级区分。 + +### 4.3.6 设计应用 + +- **用地分类**：从卫星遥感图像中分割住宅、商业、绿地、水体等用地类型，支持城市规划分析 +- **城市形态分析**：量化建筑密度、街道宽度、开放空间比例等空间指标 +- **绿视率计算**：从街景图像中分割绿色植被区域，计算视野中绿化覆盖比例，评估街道空间品质 +- **天空开敞度**：分割天空区域，分析街道峡谷的天空可见比例 + +--- + +## 4.4 视觉Transformer + +### 4.4.1 ViT：Transformer进入视觉 + +2020年，Google团队提出了 **ViT（Vision Transformer）**，首次证明纯Transformer架构可以在图像任务上达到甚至超越CNN的性能，开启了视觉领域的Transformer时代。 + +**ViT的核心思路**：将图像切割为固定大小的图块（Patch），将每个图块视为一个"词"（Token），然后送入标准Transformer编码器处理。 + +``` +输入图像 (224×224×3) 切分为图块 线性嵌入 +┌───┬───┬───┬───┬───┬───┐ 每个 16×16 每个 patch 展平 +│ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ → 14×14=196 → 768维向量 +├───┼───┼───┼───┼───┼───┤ 个 patches +│ 7 │ 8 │ 9 │10 │11 │12 │ +├───┼───┼───┼───┼───┼───┤ │ +│...│...│...│...│...│...│ ▼ +└───┴───┴───┴───┴───┴───┘ 加入位置编码 + (告知空间位置) + │ + ▼ + ┌──────────────────┐ + │ Transformer 编码器 │ + │ (多层自注意力 + │ + │ 前馈网络) │ + └──────────────────┘ + │ + ▼ + 分类头 → 类别预测 +``` + +**ViT的处理流程**： + +1. **图块切分**：将图像切分为 N 个固定大小的 patch（如 16×16），共 196 个 +2. **线性嵌入**：每个 patch 展平后通过线性映射转换为 D 维向量 +3. **位置编码**：为每个 patch 向量加入可学习的位置信息 +4. **分类 Token**：在序列开头加入一个特殊的 [CLS] token，用于汇总全局信息 +5. **Transformer 编码器**：多层自注意力 + MLP，处理 patch 序列 +6. **分类输出**：取 [CLS] token 的输出进行分类 + +### 4.4.2 为什么ViT有效：全局注意力 vs 局部卷积 + +CNN和ViT处理图像的方式有本质区别： + +``` +卷积（局部连接） 自注意力（全局连接） +┌───┬───┬───┬───┬───┐ ┌───┬───┬───┬───┬───┐ +│ │ │ │ │ │ │↔↔│↔↔│↔↏│↔↏│↔↏│ +├───┼───┼───┼───┼───┤ ├───┼───┼───┼───┼───┤ +│ │[k]│ │ │ │ │↔↏│↔↏│↔↏│↔↏│↔↏│ +├───┼───┼───┼───┼───┤ ├───┼───┼───┼───┼───┤ +│ │ │ │ │ │ │↔↏│↔↏│↔↏│↔↏│↔↏│ +└───┴───┴───┴───┴───┘ └───┴───┴───┴───┴───┘ + 只看3×3邻域 每个位置关注所有位置 + 感受野受限于层数 第一层就有全局视野 +``` + +| 维度 | CNN | ViT | +|------|-----|-----| +| 感受野 | 受限于卷积核大小和层数 | 第一层即全局感受野 | +| 归纳偏置 | 强（局部性、平移等变性） | 弱（几乎不做假设） | +| 数据需求 | 较少（归纳偏置提供先验） | 较多（需从数据中学习规律） | +| 计算量 | 与分辨率线性相关 | 与patch数二次相关 | +| 远程依赖 | 需要深层堆叠 | 天然建模全局关系 | +| 最适合场景 | 中小规模数据集 | 大规模数据集 | + +**关键洞察**：CNN通过归纳偏置（局部性假设）在小数据上表现好，但在大数据上，ViT的弱归纳偏置反而成为优势——它可以从海量数据中学到更灵活、更强大的特征表示。 + +### 4.4.3 Swin Transformer + +标准ViT的全局注意力计算量与图像大小呈二次关系，难以处理高分辨率图像。**Swin Transformer（2021）**通过**层级结构**和**移位窗口注意力**解决了这一问题。 + +``` +标准ViT（单一分辨率） Swin Transformer（层级结构） + +Patch Size: 16×16 Stage 1: 4×4 patch → 高分辨率 + ↓ Patch Merging + ┌─────────────┐ Stage 2: 8×8 patch → 中分辨率 + │ 全局注意力 │ ↓ Patch Merging + │ 所有patch │ Stage 3: 16×16 patch → 低分辨率 + │ 互相通信 │ ↓ Patch Merging + └─────────────┘ Stage 4: 32×32 patch → 最低分辨率 + 计算量: O(N²) + + 窗口内注意力 → 计算量: O(N) +``` + +**移位窗口（Shifted Window）**机制： + +``` +常规窗口划分 移位窗口划分 +┌───┬───┬───┬───┐ ┌─┬─────┬─────┬─┐ +│ W1│ W1│ W2│ W2│ │ │ W1 │ W2 │ │ +├───┤ ├───┤ │ ├─┤ ├─────┤ │ +│ │ │ │ │ │W5│ │ │W6 +├───┼───┼───┼───┤ ├──┤─────┤─────┤─┤ +│ W3│ W3│ W4│ W4│ │W7│ │ │W8 +├───┤ ├───┤ │ ├─┤ ├─────┤ │ +│ │ │ │ │ │ │ W3 │ W4 │ │ +└───┴───┴───┴───┘ └─┴─────┴─────┴─┘ + +窗口内计算注意力 窗口移位，跨窗口信息交换 +``` + +Swin Transformer的设计使其兼具CNN的层级特征提取优势和Transformer的强大表达能力，成为视觉Transformer的重要里程碑。 + +--- + +## 4.5 大视觉模型 + +### 4.5.1 从小模型到大模型 + +在前面的章节中，我们讨论的模型（CNN、ViT）通常针对特定任务训练，如分类、检测或分割。**大视觉模型（Large Vision Model）**代表了一种新的范式：通过大规模预训练，学习通用的视觉理解能力，然后通过提示（Prompt）适配到各种下游任务。 + +``` +小模型范式 大模型范式 +┌────────────┐ ┌────────────────┐ +│ 特定任务数据 │ ──→ 训练 ──→ │ 海量多模态数据 │ ──→ 预训练 ──→ +│ （如建筑分类）│ 特定模型 │ （图像+文本对） │ 通用视觉模型 +└────────────┘ └────────────────┘ + │ + ┌──────────┬─────────┼─────────┬──────────┐ + ▼ ▼ ▼ ▼ ▼ + 零样本分类 图文检索 目标分割 视觉问答 任意任务 + (无需微调) (跨模态) (提示驱动) (多模态) (通用能力) +``` + +### 4.5.2 CLIP：图文对齐与零样本学习 + +**CLIP（Contrastive Language-Image Pre-training, OpenAI, 2021）**通过对比学习，将图像和文本映射到同一个语义空间，实现了突破性的零样本分类能力。 + +**训练原理**： + +``` + 共享语义空间 + ┌──────────────────┐ + ┌────→│ "一只猫的照片" │←────┐ + │ │ "一条狗的照片" │ │ + │ │ "一栋建筑的照片" │ │ +图像编码器 │ └──────────────────┘ │ 文本编码器 +(ViT/CNN) │ 对比学习 │ (Transformer) + │ 拉近匹配对，推远不匹配对 │ +┌─────────┐ │ │ ┌──────────┐ +│ 🐱 图片 │───┤ ├───┤ "猫" 文本 │ +│ 🐶 图片 │───┘ └───┤ "狗" 文本 │ +└─────────┘ └──────────┘ +``` + +CLIP的训练目标：对于N个"图像-文本"配对，最大化正确配对的相似度，最小化错误配对的相似度。 + +**零样本分类**： + +``` +输入：一张建筑照片 +候选文本："一栋住宅的照片" "一栋商业建筑的照片" "一个公园的照片" + +→ 图像编码器提取图像特征 +→ 文本编码器提取每个文本特征 +→ 计算图像与每个文本的相似度 +→ 选择最相似的文本作为分类结果 + +无需任何建筑类别的训练数据！ +``` + +CLIP的意义在于：**用自然语言定义视觉概念**，打破了传统计算机视觉需要固定类别标签的限制。设计师可以用自然语言描述来检索、分类和理解图像。 + +### 4.5.3 SAM：分割一切 + +**SAM（Segment Anything Model, Meta, 2023）**是一个"可提示"的通用分割模型，能够根据各种提示（点、框、文本）分割图像中的任意目标。 + +``` +SAM 的三种提示方式 + + 点提示 框提示 文本提示 +┌───────────┐ ┌───────────┐ ┌───────────┐ +│ │ │ ┌───────┐ │ │ │ +│ ● │ │ │ │ │ │ 建筑 │ +│ ┌───┐ │ │ │ 目标 │ │ │ ┌───┐ │ +│ │ │ │ │ │ │ │ │ │ │ │ +│ └───┘ │ │ └───────┘ │ │ └───┘ │ +│ │ │ │ │ │ +└───────────┘ └───────────┘ └───────────┘ + 点击目标位置 画框框住目标 输入目标名称 + → 分割该目标 → 分割框内目标 → 分割对应目标 +``` + +**SAM的核心能力**： + +- **零样本泛化**：训练时没见过的物体类型也能分割 +- **歧义感知**：一个点可能对应多个层级的目标（如点击窗户 → 返回窗户、墙面、建筑三个层级） +- **自动分割**：无需提示，可自动分割图像中的所有物体 +- **海量数据集**：SA-1B数据集包含10亿级自动标注的分割掩码 + +SAM的设计理念是成为视觉领域的"基础模型"——像大语言模型处理文本一样，成为处理视觉分割任务的基础设施。 + +### 4.5.4 DINOv2：自监督视觉特征 + +**DINOv2（Meta, 2023）**通过自监督学习训练，无需人工标注即可学习强大的视觉特征表示。 + +``` +训练方式（自蒸馏 + 对比学习） + +┌─────────────┐ ┌─────────────┐ +│ 全局视图 │ │ 局部视图 │ +│ (整张图) │ │ (裁剪块) │ +└──────┬──────┘ └──────┬──────┘ + │ │ + ▼ ▼ +┌──────────────┐ ┌──────────────┐ +│ 教师网络 │ │ 学生网络 │ +│ (EMA更新) │ │ (梯度更新) │ +└──────┬──────┘ └──────┬──────┘ + │ │ + └─────── 对齐 ───────┘ + 使两者的输出一致 +``` + +DINOv2学到的特征具有惊人的语义对齐能力——无需文本训练，其特征空间自然聚类出语义类别。它可以直接用于： + +- 图像检索（找到视觉语义相似的图片） +- 密集预测（分割、深度估计） +- 图像分类（作为特征提取器） + +### 4.5.5 视觉-语言模型 + +大视觉模型发展的一个重要趋势是**视觉与语言模态的融合**。模型不再仅"看图说话"，而是真正理解图像内容并可以回答关于图像的复杂问题。 + +**典型任务与模型**： + +| 任务 | 描述 | 代表模型 | +|------|------|----------| +| 图像描述 | 自动生成图像的自然语言描述 | BLIP, BLIP-2 | +| 视觉问答 | 根据图像内容回答自然语言问题 | LLaVA, GPT-4V | +| 图文检索 | 用文本搜索图像，或反之 | CLIP, ALIGN | +| 指代表达 | 根据语言描述定位图像中的区域 | GLIP, Grounding DINO | +| 视觉对话 | 围绕图像内容进行多轮对话 | LLaVA, Qwen-VL | + +**模态融合的演进**： + +``` +单模态时代 早期多模态 大一统时代 +┌──────────┐ ┌──────────┐ ┌──────────────────┐ +│ 视觉模型 │ │ 视觉+文本 │ │ 统一多模态模型 │ +│ (CNN/ViT)│ │ 浅层融合 │ │ (视觉+语言+更多) │ +├──────────┤ ├──────────┤ ├──────────────────┤ +│ 语言模型 │ → │ 各自编码 │ → │ 共享表示空间 │ +│(RNN/TF) │ │ 拼接特征 │ │ 端到端联合训练 │ +└──────────┘ └──────────┘ └──────────────────┘ +各自独立 简单组合 深度融合 +``` + +这种融合趋势对设计领域意义深远：设计师可以用自然语言与视觉模型交互，用文字描述需求、用图像表达想法，AI能够同时理解两者并做出响应。 + +--- + +## 4.6 设计应用 + +### 4.6.1 建筑检测与识别 + +利用目标检测和语义分割技术，可以从遥感图像和街景图像中自动提取建筑信息。 + +**应用场景**： + +``` +卫星/遥感图像输入 + │ + ▼ +┌──────────────────┐ +│ 建筑检测模型 │ → 建筑位置、边界框 +│ (YOLO/Faster R-CNN)│ +└────────┬─────────┘ + │ + ▼ +┌──────────────────┐ +│ 建筑分割模型 │ → 建筑轮廓、精确边界 +│ (U-Net/Mask R-CNN)│ +└────────┬─────────┘ + │ + ▼ +┌──────────────────┐ +│ 风格分类模型 │ → 建筑风格（现代/古典/...） +│ (ViT/CLIP) │ +└──────────────────┘ +``` + +实际应用包括：城市建筑存量调查、历史街区建筑类型统计、违章建筑监测等。 + +### 4.6.2 街景品质评估 + +街景图像（Street View Imagery）已成为城市设计分析的重要数据源。通过视觉模型可以从大规模街景中自动提取城市环境品质指标。 + +**典型分析指标**： + +| 指标 | 定义 | 分析方法 | +|------|------|----------| +| 绿视率 | 视野中绿色植被占比 | 语义分割：像素级统计 | +| 天空开敞度 | 视野中天空可见比例 | 语义分割：天空区域提取 | +| 建筑围合度 | 视野中建筑遮挡比例 | 语义分割+深度估计 | +| 街道活力 | 行人、车辆、商业活动密度 | 目标检测：计数+密度估计 | +| 景观丰富度 | 视觉元素多样性 | 分类/聚类：元素类型统计 | + +``` +街景图像 ──→ 语义分割 ──→ 各类像素统计 ──→ 品质指标计算 + │ + ├── 天空: 35% + ├── 建筑: 25% + ├── 道路: 15% + ├── 植被: 18% + ├── 车辆: 4% + └── 其他: 3% + +→ 绿视率 = 18% +→ 天空开敞度 = 35% +→ 建筑围合度 = 25% +``` + +### 4.6.3 设计素材理解与智能标注 + +利用CLIP等视觉-语言模型，可以实现设计素材的智能理解和管理： + +- **智能标签**：自动为设计素材添加语义标签，无需人工标注 +- **自然语言检索**：用文字描述查找设计参考图（如"带玻璃幕墙的现代商业建筑"） +- **风格分类**：自动识别设计作品的风格特征 +- **相似推荐**：基于视觉语义相似度推荐相关素材 + +### 4.6.4 风格分析与分类 + +建筑与设计的风格分析是视觉模型在设计领域的典型应用： + +``` +设计图像 → 特征提取 (ViT/DINOv2) → 风格特征向量 + │ + ┌─────────────────────┼─────────────────────┐ + │ │ │ + ▼ ▼ ▼ + 风格分类 风格聚类 风格检索 + (现代/古典/ (自动发现 (找到风格相似 + 后现代/...) 未知风格) 的设计案例) +``` + +结合CLIP的零样本能力，设计师可以自定义风格类别（如"新中式""极简主义""有机建筑"等），无需收集训练数据即可进行风格分类。 + +--- + +## 本章小结 + +本章沿着**"CNN → 目标检测/语义分割 → Vision Transformer → 大视觉模型"**的技术演进主线，系统介绍了计算机视觉的核心方法和前沿进展。 + +``` +技术演进脉络 + +CNN时代 (2012-2020) Transformer时代 (2020-) +┌────────────────────┐ ┌────────────────────────┐ +│ AlexNet → VGG │ │ ViT: 图像=Patch序列 │ +│ → ResNet │ → │ Swin: 层级Transformer │ +│ 分类 / 检测 / 分割 │ │ │ +│ 任务专用模型 │ │ 大视觉模型: │ +└────────────────────┘ │ CLIP: 图文对齐 │ + │ SAM: 分割一切 │ + │ DINOv2: 自监督特征 │ + │ VLM: 视觉-语言融合 │ + └────────────────────────┘ +``` + +关键趋势：模型从**任务专用**走向**通用基础**，从**纯视觉**走向**视觉-语言融合**，从**监督学习**走向**自监督和提示学习**。这些趋势正在为设计领域带来更强大、更灵活、更易用的视觉智能工具。 + +--- + +## 思考与练习 + +1. **架构对比**：CNN通过局部卷积提取特征，ViT通过全局自注意力建立关系。在设计场景中（如建筑立面分析、街景品质评估），你认为哪种架构更适合？为什么？ + +2. **零样本能力**：CLIP实现了"用自然语言做图像分类"的零样本能力。如果你是一名城市设计师，想用CLIP分析城市街景的"宜居性"，你会如何设计提示文本？考虑需要哪些视觉线索。 + +3. **大模型与传统方法**：SAM号称可以"分割一切"。在专业设计领域（如建筑精细构件识别、景观植物种类分割），通用大模型和针对特定任务训练的小模型各有什么优势和局限？你会如何选择？ + +--- + +## 关键术语 + +| 中文 | 英文 | 说明 | +|------|------|------| +| 卷积神经网络 | Convolutional Neural Network (CNN) | 利用卷积操作提取局部特征的神经网络 | +| 卷积核/滤波器 | Kernel / Filter | 卷积操作中用于特征提取的小矩阵 | +| 池化 | Pooling | 降低特征图空间尺寸的下采样操作 | +| 感受野 | Receptive Field | 神经元能"看到"的输入区域大小 | +| 残差连接 | Residual/Skip Connection | 将输入直接加到输出上，解决深层网络退化问题 | +| 目标检测 | Object Detection | 同时识别图像中目标的类别和位置 | +| 边界框 | Bounding Box | 用矩形框标出目标位置的表示方法 | +| 语义分割 | Semantic Segmentation | 对每个像素进行类别标签预测 | +| 实例分割 | Instance Segmentation | 区分同类别的不同个体实例 | +| 视觉Transformer | Vision Transformer (ViT) | 将图像切分为Patch序列，用Transformer处理 | +| 零样本学习 | Zero-shot Learning | 在未见过的类别上直接进行推理 | +| 对比学习 | Contrastive Learning | 通过对比正负样本学习特征表示 | +| 视觉-语言模型 | Vision-Language Model | 同时理解图像和文本的多模态模型 | +| 提示学习 | Prompt Learning | 通过自然语言提示引导模型完成特定任务 | +| 基础模型 | Foundation Model | 在大规模数据上预训练的通用模型 | diff --git a/04-transformer/04-transformer.md b/04-transformer/04-transformer.md deleted file mode 100644 index bc905b3..0000000 --- a/04-transformer/04-transformer.md +++ /dev/null @@ -1,494 +0,0 @@ -# 第四篇：Transformer与大模型 - -本篇介绍革命性的Transformer架构和大语言模型，理解Self-Attention机制和LLM应用。 - -## 篇章导读 - -Transformer是AI领域最重要的架构创新之一。它不仅彻底改变了自然语言处理，还通过Attention机制启发了计算机视觉的范式变革。 - -本篇将从注意力机制出发，深入理解Transformer架构，并探讨大语言模型在设计领域的应用。 - ---- - -### 学习目标 - -理解Self-Attention的动机和原理 - -掌握Q、K、V的计算过程 - -了解Multi-Head Attention的优势 - -### 为什么需要Attention - -#### 序列标注问题 - -`输入序列：``x₁, x₂, ..., xₙ (N``个元素``)`\ -`输出序列：``y₁, y₂, ..., yₙ' (N'``个元素``)` - -传统方法 (RNN/FCN)： - 固定窗口大小 - 长距离依赖丢失 - 难以并行计算 - -Self-Attention： - 每个元素都能关注所有元素 - 直接建模任意距离依赖 - 可以并行计算 - -### Self-Attention原理 - -#### 核心思想 {#核心思想-1} - -为每个输出元素，计算输入序列中所有元素的相关性： - -`对于每个位置``i``：`\ -` yᵢ = Σ (``注意力权重`` × ``对应输入值``)` - -#### Q、K、V计算 - -`输入``X → ``三个线性变换`\ -` ↓`\ -`Q (Query): "``我想找什么``"`\ -`K (Key): "``我有什么标签``"`\ -`V (Value): "``我的实际内容``"` - -#### 注意力分数计算 - -`1. ``计算相似度：``Score = Q × Kᵀ` - -`2. ``缩放：``Score = Score / √dₖ` - -`3. ``Softmax``：``Weight = ``softmax``(Score)` - -`4. ``加权求和：``Output = Weight × V` - -#### 直观理解 {#直观理解-2} - -`查询：``"``苹果``"`\ -` ↓`\ -`与所有``Key``计算相似度`\ -` ↓`\ -`权重高的``Key``对应``Value``贡献更大`\ -` ↓`\ -`输出：融合上下文的``"``苹果``"``表示` - -### Multi-Head Attention - -单头 vs 多头 - -**单头注意力**： - -`一组``Q``、``K``、``V → ``一个注意力表示` - -**多头注意力**： - -`多组``Q``、``K``、``V → ``多个注意力表示`` → ``拼接` - -#### 多头优势 - - --------------------- - 头 关注内容 - -------- ------------ - Head 1 语法关系 - - Head 2 语义指代 - - Head 3 长距离依赖 - - ... ... - --------------------- - -多头让模型从不同角度理解序列。 - -### Positional Encoding - -#### 问题 - -Self-Attention本身是**置换不变**的： - -`Attention(``[A, B, C]) = Attention([B, A, C])` - -但序列位置很重要！ - -#### 解决方案 - -添加位置信息： - -`输入`` = X + ``PositionalEncoding` - -常用方法： - 正弦/余弦位置编码 - 可学习位置编码 - -### Self-Attention vs CNN - -感受野对比 - - ------------------------------------ - 层级 CNN Self-Attention - ------ ------------ ---------------- - 单层 局部感受野 全局感受野 - - 深层 逐层扩大 始终全局 - ------------------------------------ - -计算复杂度 - - -------------------------------------- - 操作 CNN Self-Attention - -------- ------------ ---------------- - 复杂度 O(k²·C) O(n²·d) - - n 图像尺寸 序列长度 - - k 卷积核大小 \- - -------------------------------------- - -### 思考与练习 - -1.为什么Attention需要Scaling (除以√dₖ)？ - -2.Multi-Head Attention中，头数越多越好吗？ - -3.Self-Attention如何应用在图像上？ - -### 关键术语 - - ------------------------------------------------------ - 中文 英文 说明 - ---------- -------------------- ---------------------- - 查询 Query 查询向量 - - 键 Key 键向量 - - 值 Value 值向量 - - 缩放点积 Scaled Dot-Product 注意力计算方式 - - 掩码 Mask 屏蔽某些位置的注意力 - ------------------------------------------------------ - -### 延伸阅读 - -[Attention Is All You Need](https://arxiv.org/abs/1706.03762) - -[The Illustrated Transformer](https://jalammar.github.io/illustrated-transformer/) \# 03.2 Transformer架构 - ---- - -### 学习目标 - -理解Transformer的Encoder-Decoder结构 - -掌握各组件的作用和连接方式 - -了解Token处理流程 - -### 整体架构 - -`输入``Token``序列`` → Encoder → ``编码表示`\ -` ↓`\ -`输出``Token``序列`` ← Decoder ← ``编码表示` - -### Encoder层 - -单层结构 - -`输入``X`\ -` ↓`\ -`Multi-Head Self-Attention`\ -` ↓`\ -`Add & Norm (``残差连接`` + ``层归一化``)`\ -` ↓`\ -`Feed-Forward Network (FFN)`\ -` ↓`\ -`Add & Norm`\ -` ↓`\ -`输出``H` - -#### 残差连接 - -`输出`` = F(x) + x` - -作用： - 缓解梯度消失 - 便于训练深层网络 - -#### 层归一化 - -`输出`` = ``LayerNorm``(x + F(x))` - -作用： - 稳定训练 - 加速收敛 - -#### FFN (前馈网络) - -`FFN(x) = ``ReLU``(``xW``₁ + b₁)W₂ + b₂` - -本质：两层全连接网络，非线性变换 - -### Decoder层 - -#### 结构 - -`输入``X`\ -` ↓`\ -`Masked Self-Attention (``只能看之前的位置``)`\ -` ↓`\ -`Add & Norm`\ -` ↓`\ -`Cross-Attention (Query``来自``Decoder, Key/Value``来自``Encoder)`\ -` ↓`\ -`Add & Norm`\ -` ↓`\ -`FFN`\ -` ↓`\ -`Add & Norm`\ -` ↓`\ -`输出`` (``接``Softmax``预测概率``)` - -#### Cross-Attention - -`Q: Decoder``的隐藏状态`\ -`K, V: Encoder``的输出` - -作用：让Decoder关注Encoder的相关部分 - -## Token处理流程 - -### 输入处理 - -`文本`` → Tokenize → Token IDs`\ -` ↓`\ -` Embedding``层`\ -` ↓`\ -` ``位置编码相加`\ -` ↓`\ -` Encoder/Decoder` - -### 输出处理 - -`Decoder``输出`` → ``线性层`` → ``Softmax`` → ``概率分布`\ -` ↓`\ -` ``选择最大值` - -## 训练与推理 - -训练阶段 - -`教师强制`` (Teacher Forcing)``：`\ -` ``真实标签作为``Decoder``输入`\ -` ``可以并行计算` - -推理阶段 - -`自回归生成`` (Autoregressive)``：`\ -` ``生成一个``Token → ``加入输入`` → ``生成下一个`\ -` ``串行计算` - -## Transformer变体 - -BERT (Encoder-only) - -`输入`` → Encoder → [CLS]``表示`` / ``每个``Token``表示` - -应用：分类、NER、问答 - -GPT (Decoder-only) - -`输入`` → Decoder → ``下一个``Token``预测` - -应用：文本生成 - -T5 (Encoder-Decoder) - -`输入`` → Encoder → ``表示`` → Decoder → ``输出` - -应用：翻译、摘要 - -## 思考与练习 - -1. 为什么Decoder需要Masked Attention？ - -2. Encoder-only和Decoder-only模型各有什么优势？ - -3. Transformer如何处理超长序列？ - -## 关键术语 - - ---------------------------------------------------------- - 中文 英文 说明 - --------------- --------------------- -------------------- - 残差连接 Residual Connection 跨层连接 - - 层归一化 Layer Normalization 归一化层 - - 教师强制 Teacher Forcing 训练时使用真实标签 - - 自回归 Autoregressive 基于前序生成后续 - - 编码器-解码器 Encoder-Decoder Seq2Seq架构 - ---------------------------------------------------------- - -## 延伸阅读 - -1. [The Annotated Transformer](https://nlp.seas.harvard.edu/2018/04/03/attention.html) - - [Visualizing A Machine Learning Model](https://poloclub.github.io/transformer-explainer/) \# 03.3 大语言模型应用 - ---- - -## 学习目标 - -3. 理解从Transformer到ChatGPT的演进 - - 掌握RAG、RLHF等关键技术 - - 了解Prompt工程在设计中的应用 - -## 从Transformer到ChatGPT - -### GPT系列演进 - - ------------------------------------------------------ - 模型 发布时间 参数量 特点 - --------- ---------- -------- ------------------------ - GPT-1 2018 117M 验证Decoder-only可行性 - - GPT-2 2019 1.5B 展示零样本能力 - - GPT-3 2020 175B 少样本学习震撼业界 - - ChatGPT 2022 \~ 对话能力达到新高度 - - GPT-4 2023 \~ 多模态能力 - ------------------------------------------------------ - -### 训练范式 - -`预训练`` (Pre-training)``：`\ -` ``大规模文本`` → ``无监督学习`` → ``语言模型`\ -\ -`微调`` (Fine-tuning)``：`\ -` ``特定任务`` → ``有监督学习`` → ``任务模型` - -## RAG：检索增强生成 - -### 核心思想 {#核心思想-2} - - 用户提问 → 检索相关文档 → LLM生成答案 - ↑ - 外部知识库 - -### RAG架构 - -#### 文档索引 - -`文档`` → ``切分`` → Embedding → ``向量数据库` - -#### - -`2. ``检索阶段` - -#### 问题 → Embedding → 相似度搜索 → 相关文档 - -`3. ``生成阶段` - - 问题 + 相关文档 → LLM → 答案 - -### RAG优势 - - --------------------------- - 特点 说明 - ---------- ---------------- - 减少幻觉 基于检索的事实 - - 可更新 更新知识库即可 - - 可解释 显示参考来源 - --------------------------- - -## RLHF：人类反馈强化学习 - -### 为什么需要RLHF - -预训练模型可能： - 生成有害内容 - 不符合人类偏好 - 产生无意义输出 - -### RLHF三阶段 - -#### 有监督微调 (SFT) - -`人工标注对话`` → ``微调模型` - -`2. ``奖励模型`` (RM)` - -#### 多个输出 → 人类排序 → 训练奖励模型 - -`3. ``强化学习`` (RL)` - - PPO算法 → 优化策略 - -### 效果 - -1. 输出更符合人类偏好 - - 减少有害内容 - - 提高回答质量 - -## Prompt工程 - -### Prompt设计原则 - -#### 明确任务 - -`好：请总结以下文本的主要观点`\ -`差：看看这段文字` - -#### 提供示例 - -`任务：情感分类`\ -`示例：`\ -`"``这部电影太棒了！``" → ``正面`\ -`"``服务态度很差。``" → ``负面`\ -`现在分类：``"..."` - -### 指定格式 - -`请按以下格式输出：`\ -`- ``观点``1``：``...`\ -`- ``观点``2``：``...`\ -`- ``结论：``...` - -## 设计领域应用 - - ------------------------------------------------------- - 任务 Prompt示例 - ---------- -------------------------------------------- - 方案生成 "设计一个50人的办公空间，要求开放式布局" - - 代码生成 "写一个Python脚本计算建筑容积率" - - 文档撰写 "帮我写一份景观设计说明书的框架" - ------------------------------------------------------- - -## 思考与练习 - -1. RAG和微调（Fine-tuning）各适用于什么场景？ - -2. 如何评估LLM输出的质量？ - -3. Prompt工程在设计工作流中能解决什么问题？ - -## 关键术语 - - ------------------------------------------------------------------------------------ - 中文 英文 说明 - ------------------ -------------------- -------------------------------------------- - 检索增强生成 RAG Retrieval-Augmented Generation - - 人类反馈强化学习 RLHF Reinforcement Learning from Human Feedback - - 提示工程 Prompt Engineering 设计输入以引导模型输出 - - 向量数据库 Vector Database 存储和检索向量表示 - - 幻觉 Hallucination 模型编造错误信息 - ------------------------------------------------------------------------------------ - -## 延伸阅读 - -1. [Language Models are Few-Shot Learners (GPT-3)](https://arxiv.org/abs/2005.14165) - - [Training Language Models to Follow Instructions with Human Feedback](https://arxiv.org/abs/2203.02155) - - [LangChain RAG教程](https://python.langchain.com/docs/tutorials/rag/) diff --git a/05-3d-spatial/05-3d-spatial.md b/05-3d-spatial/05-3d-spatial.md new file mode 100644 index 0000000..ba081c9 --- /dev/null +++ b/05-3d-spatial/05-3d-spatial.md @@ -0,0 +1,1421 @@ +# 第5章：三维数据——空间与3D + +## 篇章导读 + +三维数据是AI与物理世界之间最直接的桥梁。从建筑到城市规划，从景观到工业设计，空间理解始终是设计实践的核心能力。一架无人机飞过城市上空，激光雷达 (LiDAR) 每秒发射数十万束激光，返回的每一个点都在描述一个真实的空间坐标——这些点汇聚成点云，构成数字世界的三维基础。一个设计师用手机扫描房间，几秒钟后便得到完整的三维模型；一位规划师输入"现代化办公椅"的文本描述，AI便能生成一个可编辑的3D模型。 + +这些场景不再是科幻。从传统的多视图立体匹配 (MVS) 到神经辐射场 (NeRF)，从三维高斯溅射 (3D Gaussian Splatting) 到大规模空间智能模型，三维AI正在经历从小模型到大模型、从感知到推理的范式跃迁。本章将带你走进三维数据的世界，理解AI如何"看见"和"重建"空间，并探索空间智能在设计领域的广阔应用。 + +--- + +# 5.1 三维数据表示 + +## 学习目标 + +- 理解四种主要3D数据表示形式的特点与适用场景 +- 掌握点云、网格、体素、深度图的区别与联系 +- 了解Open3D等工具的基本使用方法 + +### 为什么需要多种3D表示 + +现实世界是三维的，但计算机需要用特定的数据结构来存储和处理3D信息。不同的表示方式在精度、内存效率和处理难度上各有权衡，选择合适的表示方式是3D AI的第一步。 + +``` +物理世界 + ↓ 采集/建模 +三维数据 ──→ 点云 (Point Cloud) + ──→ 网格 (Mesh) + ──→ 体素 (Voxel) + ──→ 深度图 (Depth Map) +``` + +### 点云 (Point Cloud) + +**定义**：一组三维坐标点的集合，每个点包含 (x, y, z) 坐标，可选附加颜色 (r, g, b)、法向量等属性。 + +``` +点云示例： + ● ● + ● ● + ● ● ● + ● ● + ● ● + +每个点：P = (x, y, z) 或 (x, y, z, r, g, b) +``` + +**特点**： + +- 最接近原始传感器数据的表示形式 +- 不规则、无序、无拓扑关系 +- 点的数量可变（置换不变性问题） +- 适合大规模场景的快速采集 + +**常见来源**： + +- 激光雷达 (LiDAR)：自动驾驶、城市扫描 +- 深度相机 (RGB-D Camera)：室内扫描、物体识别 +- 摄影测量 (Photogrammetry)：无人机航拍重建 + +### 网格 (Mesh) + +**定义**：由顶点 (Vertices)、边 (Edges) 和面 (Faces) 组成的多面体表示，是最常见的3D模型格式。 + +``` +网格结构： + v₁ ──── v₂ + | ＼ | + | f₁ | + | ＼ | + v₃ ──── v₄ + +顶点：v₁, v₂, v₃, v₄ (各含 x, y, z 坐标) +面： f₁ = (v₁, v₂, v₃), f₂ = (v₂, v₃, v₄) 等 +``` + +**特点**： + +- 具有拓扑关系，能表示物体表面 +- 渲染效率高，是游戏、动画的标准格式 +- 文件格式：OBJ, STL, PLY, FBX 等 +- 适合设计建模和可视化 + +### 体素 (Voxel) + +**定义**：三维空间中的规则网格单元，是二维像素 (Pixel) 在三维空间的推广——"三维像素"。 + +``` +体素网格： + ┌───┬───┬───┐ + │ 1 │ 0 │ 1 │ 1 = 占据 + ├───┼───┼───┤ 0 = 空闲 + │ 0 │ 1 │ 0 │ + ├───┼───┼───┤ + │ 1 │ 1 │ 0 │ + └───┴───┴───┘ + +类似"我的世界"(Minecraft)的方块表示 +``` + +**特点**： + +- 规则网格结构，可直接使用3D卷积 +- 内存消耗与分辨率的立方成正比 +- 分辨率有限时存在"方块效应" +- 适合3D卷积神经网络处理 + +### 深度图 (Depth Map) + +**定义**：二维图像，每个像素存储的是该位置到相机的距离（深度值），也称2.5D表示。 + +``` +深度图： + ┌─────┬─────┬─────┐ + │ 2.1 │ 2.3 │ 8.5 │ 数值 = 到相机的距离 + ├─────┼─────┼─────┤ (单位：米) + │ 2.0 │ 2.2 │ 9.1 │ + ├─────┼─────┼─────┤ + │ 2.2 │ 2.1 │ 8.8 │ + └─────┴─────┴─────┘ + +近处物体：深度值小 (2.0) +远处背景：深度值大 (9.1) +``` + +**特点**： + +- 本质是二维数组，处理效率高 +- 只包含单视角的深度信息（不完全的3D） +- 可直接与RGB图像对齐 +- 常见于深度相机（Kinect, RealSense）输出 + +### 四种表示方式对比 + +| 特性 | 点云 (Point Cloud) | 网格 (Mesh) | 体素 (Voxel) | 深度图 (Depth Map) | +|------|--------------------|--------------|---------------|---------------------| +| 数据结构 | 无序点集 | 顶点 + 面 | 规则3D网格 | 2D数组 | +| 内存效率 | 较高 | 高 | 低(立方增长) | 高 | +| 分辨率 | 灵活(点密度) | 可调(面数) | 受网格限制 | 受图像分辨率限制 | +| 拓扑信息 | 无 | 有 | 隐含 | 无 | +| 深度学习适配 | 需特殊处理 | 需转换 | 直接3D卷积 | 直接2D卷积 | +| 常见来源 | LiDAR, RGB-D | 建模软件 | 体素化转换 | 深度相机 | +| 典型应用 | 场景扫描 | 设计建模 | 3D语义分割 | 室内导航 | + +### 代码实践：点云加载与可视化 + +以下示例使用 Open3D 库加载并可视化一个点云文件： + +```python +import open3d as o3d +import numpy as np + +# 创建一个示例点云（模拟简单的建筑体量） +pcd = o3d.geometry.PointCloud() + +# 生成一个"盒子"形状的点云 +points = [] +# 底面 +for x in np.linspace(0, 10, 50): + for y in np.linspace(0, 8, 40): + points.append([x, y, 0]) + points.append([x, y, 5]) # 顶面 +# 侧面 +for x in np.linspace(0, 10, 50): + for z in np.linspace(0, 5, 25): + points.append([x, 0, z]) + points.append([x, 8, z]) +for y in np.linspace(0, 8, 40): + for z in np.linspace(0, 5, 25): + points.append([0, y, z]) + points.append([10, y, z]) + +pcd.points = o3d.utility.Vector3dVector(np.array(points)) + +# 统计点云信息 +print(f"点云包含 {len(pcd.points)} 个点") +print(f"边界框: {pcd.get_min_bound()} ~ {pcd.get_max_bound()}") + +# 可视化 +o3d.visualization.draw_geometries( + [pcd], + window_name="建筑体量点云", + width=800, height=600, + point_show_normal=False +) +``` + +加载真实点云文件（如 PLY 格式）只需一行： + +```python +pcd = o3d.io.read_point_cloud("building_scan.ply") +o3d.visualization.draw_geometries([pcd]) +``` + +### 思考与练习 + +1. 为什么点云是无序的？这对深度学习模型设计有什么影响？ +2. 如果要表示一个室内场景，哪种3D表示方式最合适？为什么？ +3. 体素的内存消耗与分辨率的关系是什么？分辨率为256^3时有多少个体素？ + +### 关键术语 + +| 中文 | 英文 | 说明 | +|------|------|------| +| 点云 | Point Cloud | 三维坐标点的集合 | +| 网格 | Mesh | 顶点、边、面组成的多面体表示 | +| 体素 | Voxel | 三维空间中的规则网格单元 | +| 深度图 | Depth Map | 存储距离信息的二维图像 | +| 激光雷达 | LiDAR | 激光测距传感器 | +| 法向量 | Normal Vector | 垂直于表面的方向向量 | + +### 延伸阅读 + +- [Open3D 官方文档](http://www.open3d.org/docs/) +- [Point Cloud Library (PCL)](https://pointclouds.org/) + +--- + +# 5.2 三维理解 + +## 学习目标 + +- 理解PointNet的核心创新：直接处理点云的置换不变性 +- 了解三维目标检测与分割的基本方法 +- 掌握3D理解在设计领域的典型应用场景 + +### 小模型时代的3D理解 + +在Transformer等大模型出现之前，3D深度学习主要依赖专门设计的小型网络架构。核心挑战在于：三维数据不像图像那样具有规则的网格结构，无法直接使用标准卷积操作。 + +``` +3D理解的三个核心任务： + +输入: 三维数据 (点云/网格/体素/深度图) + ↓ + ├── 3D分类: "这是什么？" → 类别标签 + ├── 3D检测: "物体在哪？" → 3D边界框 + 类别 + └── 3D分割: "每个部分是什么？" → 逐点/逐体素标签 +``` + +### PointNet (2017)：直接处理点云 + +#### 核心问题 + +点云是无序集合。同样的点集，无论以什么顺序输入，输出应该相同——这就是**置换不变性** (Permutation Invariance)。 + +``` +同一个物体的点云，点的排列顺序不同： + +表示1: {P₁, P₂, P₃, ..., Pₙ} +表示2: {P₃, P₁, Pₙ, ..., P₂} ← 顺序不同 +表示3: {Pₙ, Pₙ₋₁, ..., P₁} ← 完全倒序 + +期望：f(表示1) = f(表示2) = f(表示3) +``` + +#### PointNet的解决方案 + +``` +输入点云: N × 3 (N个点，每个3个坐标) + ↓ +逐点MLP: 3 → 64 → 128 → 1024 (对每个点独立处理) + ↓ +对称函数: Max Pooling (取每个特征维度的最大值) + ↓ +全局特征: 1 × 1024 + ↓ +全连接层 → 分类/分割输出 + +关键: Max Pooling 天然满足置换不变性 + max(a, b, c) = max(c, a, b) = max(b, c, a) +``` + +#### PointNet架构简图 + +``` + 输入点云 T-Net MLP Max Pooling 全连接 + (N×3) → (空间变换换) → (64→128→1024) → (1×1024) → 输出 + ↑ ↑ + 对齐输入 全局特征向量 +``` + +**T-Net**：学习一个空间变换矩阵，将输入点云对齐到规范姿态（类似空间归一化）。 + +#### 代码示例：理解PointNet的核心思想 + +```python +import torch +import torch.nn as nn + +class SimplePointNet(nn.Module): + """简化版PointNet，展示核心思想""" + def __init__(self, num_classes=10): + super().__init__() + # 逐点MLP：对每个点独立提取特征 + self.mlp = nn.Sequential( + nn.Linear(3, 64), + nn.ReLU(), + nn.Linear(64, 128), + nn.ReLU(), + nn.Linear(128, 1024) + ) + # 分类头 + self.classifier = nn.Sequential( + nn.Linear(1024, 512), + nn.ReLU(), + nn.Dropout(0.3), + nn.Linear(512, num_classes) + ) + + def forward(self, x): + # x: (batch_size, num_points, 3) + x = self.mlp(x) # (B, N, 1024) + x = torch.max(x, dim=1)[0] # (B, 1024) ← 对称函数！ + x = self.classifier(x) # (B, num_classes) + return x + +# 测试置换不变性 +model = SimplePointNet(num_classes=5) +points = torch.randn(1, 100, 3) # 1个样本，100个点 + +# 原始顺序 +out1 = model(points) +# 随机打乱顺序 +perm = torch.randperm(100) +out2 = model(points[:, perm, :]) + +print(f"输出差异: {torch.max(torch.abs(out1 - out2)).item():.6f}") +# 输出差异应接近0 —— 置换不变性！ +``` + +### PointNet++：层次化点集学习 + +PointNet将所有点直接映射为全局特征，缺乏捕捉局部结构的能力。PointNet++引入了层次化 (Hierarchical) 结构： + +``` +PointNet: 所有点 ──→ 全局特征 (单层，无局部结构) + +PointNet++: 点集 → 局部区域1 → 局部区域2 → ... → 全局特征 + ↑ 每层都是一个小PointNet + ↑ 逐步扩大感受野 +``` + +``` +层次化处理流程： + 输入: N个点 + ↓ 采样 + 分组 (Ball Query) + N个局部区域 (每个含K个点) + ↓ 对每个区域用 PointNet + N'个新的特征点 + ↓ 采样 + 分组 + 更少的局部区域 + ↓ 对每个区域用 PointNet + 全局特征 +``` + +**核心改进**： + +- **最远点采样 (Farthest Point Sampling)**：均匀选取中心点 +- **球查询 (Ball Query)**：查找半径范围内的邻域点 +- **多尺度分组 (MSG)**：不同半径捕捉不同尺度的局部特征 + +### 基于体素的3D CNN + +另一种思路是将不规则3D数据转换为规则网格，然后使用3D卷积： + +``` +点云/网格 + ↓ 体素化 (Voxelization) +规则体素网格 (如 32×32×32) + ↓ 3D卷积 +3D特征图 + ↓ 分类/检测/分割 + +2D卷积核: H × W (如 3×3) +3D卷积核: D × H × W (如 3×3×3) +``` + +**优势**：可直接利用成熟的CNN框架 + +**劣势**：内存消耗大（分辨率立方增长）、量化损失 + +### 三维目标检测与分割 + +#### 3D目标检测 + +``` +输入: 3D场景 (点云/体素) + ↓ +3D检测器 + ↓ +输出: 3D边界框 [(x, y, z, l, w, h, θ, class), ...] + 位置 长宽高 朝向 类别 +``` + +代表性方法： + +| 方法 | 类型 | 特点 | +|------|------|------| +| VoteNet (2019) | 点云投票 | 从点云直接预测3D框 | +| PointPillars (2019) | 点云→伪图像 | 高效的激光雷达检测 | +| VoxelNet (2018) | 体素化 | 端到端3D检测 | +| CenterPoint (2021) | 中心点检测 | 以中心 heatmap 方式检测 | + +#### 3D语义分割 + +``` +室内场景点云 + ↓ 逐点分类 +[墙壁, 墙壁, 地板, 地板, 椅子, 椅子, 桌子, ...] + ↓ +每个点获得语义标签 +``` + +### 设计应用 + +#### 建筑足迹提取 + +``` +无人机激光扫描 + ↓ +3D点云数据 + ↓ PointNet++ / 语义分割 +地面点 | 建筑点 | 植被点 + ↓ +建筑足迹向量 (可导入GIS/CAD) +``` + +#### 地形分类 + +``` +LiDAR地形扫描 + ↓ 3D语义分割 +分类结果: [裸地, 草地, 灌木, 林地, 水体, 道路] + ↓ +用于景观规划、生态评估 +``` + +#### 室内场景理解 + +``` +深度相机扫描 + ↓ 3D实例分割 +[墙1, 墙2, 地板, 天花板, 沙发, 桌子, 椅子1, 椅子2] + ↓ +自动生成室内平面图和家具布局 +``` + +### 思考与练习 + +1. PointNet的Max Pooling为什么能满足置换不变性？除了Max Pooling，还有哪些对称函数？ +2. 体素表示为什么内存消耗大？如果场景中有大量空白区域，如何优化？ +3. 设计一个用PointNet对建筑风格进行分类的方案，需要哪些数据和步骤？ + +### 关键术语 + +| 中文 | 英文 | 说明 | +|------|------|------| +| 置换不变性 | Permutation Invariance | 输入顺序不影响输出 | +| 对称函数 | Symmetric Function | 对输入顺序不敏感的函数 | +| 最远点采样 | Farthest Point Sampling | 均匀选取代表点 | +| 球查询 | Ball Query | 查找半径内的邻域点 | +| 3D边界框 | 3D Bounding Box | 三维空间中的矩形框 | +| 体素化 | Voxelization | 将不规则数据转为规则体素 | + +### 延伸阅读 + +- [PointNet: Deep Learning on Point Sets (Qi et al., 2017)](https://arxiv.org/abs/1612.00593) +- [PointNet++: Deep Hierarchical Feature Learning (Qi et al., 2017)](https://arxiv.org/abs/1706.02413) + +--- + +# 5.3 三维重建与生成 + +## 学习目标 + +- 理解传统3D重建方法（SfM、MVS）的基本原理 +- 掌握NeRF和3D Gaussian Splatting的核心思想 +- 了解Text-to-3D和Image-to-3D生成模型的发展 + +### 从传统方法到神经渲染 + +三维重建是从2D图像或传感器数据中恢复3D场景的过程。从传统几何方法到深度学习驱动的方法，这一领域经历了革命性的变化。 + +``` +3D重建方法演进： + +传统几何方法 (2000s) + SfM → MVS → 稠密点云 + ↓ +深度学习增强 (2015+) + 学习型MVS → 更鲁棒的重建 + ↓ +神经渲染 (2020) + NeRF: 神经网络隐式表示场景 + ↓ +显式表示复兴 (2023) + 3D Gaussian Splatting: 高效实时渲染 + ↓ +3D大模型生成 (2023+) + Text-to-3D / Image-to-3D +``` + +### 传统方法 + +#### Structure from Motion (SfM，运动恢复结构) + +**核心思想**：从一系列不同角度拍摄的2D照片中，同时恢复相机的位置 (运动) 和场景的3D结构。 + +``` +SfM流程： + 多张照片 (不同角度) + ↓ 特征提取与匹配 + 特征对应关系 + ↓ 几何约束求解 + 相机位姿 (位置+朝向) + ↓ 三角测量 + 稀疏3D点云 +``` + +``` +相机1 场景点P 相机2 + ○ ──────── x ←───────→ x ────────── ○ + 光线1 光线2 + ╲ ╱ + ╲ ╱ + ╲ 交点= ╱ + ╲ P的3D ╱ + 位置 ╱ +``` + +**关键步骤**： + +1. **特征检测**：SIFT/SUPERPOINT等算法检测每张图片的关键特征 +2. **特征匹配**：在不同图片之间找到相同的特征点 +3. **运动估计**：根据匹配关系计算相机运动 +4. **三角测量**：利用两个视角的射线交汇得到3D坐标 + +#### Multi-View Stereo (MVS，多视图立体匹配) + +SfM只产生稀疏点云，MVS则在此基础上生成稠密重建： + +``` +SfM稀疏点云 + ↓ +MVS稠密匹配 + ↓ +稠密点云 / 深度图 + ↓ +表面重建 (Poisson, Delaunay) + ↓ +完整3D网格模型 +``` + +**局限性**： + +- 对纹理缺乏区域（白墙、玻璃）重建效果差 +- 计算耗时较长 +- 难以处理反光、透明材质 + +### NeRF (Neural Radiance Fields，神经辐射场) + +2020年，加州大学伯克利分校的研究团队提出了NeRF，彻底改变了3D重建的范式。 + +#### 核心思想 + +不再显式存储3D模型（点云/网格），而是用一个神经网络来"记住"整个三维场景： + +``` +传统: 场景 → 存储为点云/网格/体素 +NeRF: 场景 → 训练一个神经网络 + +网络输入: (x, y, z, θ, φ) + 3D坐标 观察方向 +网络输出: (r, g, b, σ) + 颜色 密度 +``` + +``` + ┌──────────────────┐ +(x,y,z,θ,φ) ────→ │ MLP │ ────→ (r, g, b) + 空间位置+视角 │ (8-12层, 256宽) │ + │ │ ────→ σ (密度) + └──────────────────┘ + +σ 控制该点是否"有物体"： + σ ≈ 0 → 空气（光线直接穿过） + σ ≈ 大 → 实体（光线被吸收/着色） +``` + +#### 体渲染 (Volume Rendering) + +NeRF通过体渲染将3D神经场合成为2D图像： + +``` +对于图像上的每个像素: + ↓ +从相机发射一条光线穿过场景 + ↓ +沿光线采样多个3D点 + ↓ +对每个点查询NeRF网络得到(颜色, 密度) + ↓ +沿光线积分 → 像素颜色 + +C(r) = ∫ T(t) · σ(t) · c(t) dt + +其中 T(t) = exp(-∫ σ(s) ds) 是透射率 +``` + +直观理解： + +``` +相机 ──光线──→ ●密度高(墙) ──→ ●密度低(窗) ──→ ●密度高(树) + 颜色=灰色 颜色=透明 颜色=绿色 + ↓ ↓ ↓ + 最终权重=高 权重=低 权重=中 + ↓ + 最终像素颜色 = 加权混合 +``` + +#### 训练过程 + +``` +输入: 多张不同角度的照片 + 相机参数 + ↓ +对每张照片的每个像素: + 1. 发射光线 + 2. 采样3D点，查询MLP + 3. 体渲染得到预测颜色 + ↓ +计算损失: L = ||预测颜色 - 真实像素颜色||² + ↓ +反向传播，更新MLP权重 + ↓ +重复数万次 → MLP"记住"了整个场景 +``` + +#### NeRF的优势与局限 + +| 优势 | 局限 | +|------|------| +| 重建质量极高 | 训练慢（数小时/场景） | +| 能处理复杂光照 | 渲染慢（逐光线查询MLP） | +| 连续表示，无分辨率限制 | 难以编辑/修改 | +| 不需要网格/纹理等显式表示 | 泛化能力有限（每场景训练） | + +### 3D Gaussian Splatting (三维高斯溅射, 2023) + +NeRF的隐式表示虽然质量高，但速度慢、难以编辑。3D Gaussian Splatting (3DGS) 用显式的高斯椭球体取代了隐式神经网络，实现了实时渲染。 + +#### 核心思想 + +场景由大量3D高斯椭球体组成，每个高斯体具有： + +``` +一个3D高斯体的属性： + - 位置 μ = (x, y, z) ← 在哪 + - 协方差 Σ (旋转+缩放) ← 形状 + - 不透明度 α ← 透明度 + - 球谐系数 SH ← 颜色（依赖视角） + +数学表示: + G(x) = exp(-½(x-μ)ᵀ Σ⁻¹ (x-μ)) +``` + +``` +场景表示： + ● = 高斯体1 (椭圆，浅蓝，半透明) + ● = 高斯体2 (圆形，深蓝，不透明) + ● = 高斯体3 (扁平，白色，透明) + ● = ... + 成千上万个高斯体叠加 → 完整场景 +``` + +#### Splatting（溅射）过程 + +``` +3D高斯体 → 投影到2D图像平面 → 排序 → 混合 → 最终图像 + +名称由来: 像把"颜料"溅射 (Splat) 到画布上 +``` + +``` + 3D空间 2D图像 + ● ● ● ┌─────────┐ + ● ● ● ● ● 投影→ │ 渲染结果 │ + ● ● ● │ (实时) │ + ● ● └─────────┘ + +3D高斯体 ──→ 2D椭圆 ──→ 按深度排序 ──→ Alpha混合 +``` + +#### 3DGS vs NeRF + +| 特性 | NeRF | 3D Gaussian Splatting | +|------|------|------------------------| +| 场景表示 | 隐式 (MLP权重) | 显式 (高斯体集合) | +| 训练时间 | 数小时 | 数分钟到数十分钟 | +| 渲染速度 | 慢（逐点查询） | 实时（>100 FPS） | +| 渲染质量 | 高 | 高（相当或更好） | +| 可编辑性 | 困难 | 可以操作高斯体 | +| 存储 | 小（网络权重） | 较大（百万高斯体） | + +### 3D生成模型 + +从2023年开始，AI不仅能"重建"已有场景，还能从零"生成"新的3D内容。 + +#### Text-to-3D (文本生成3D) + +``` +文本描述 → 3D生成模型 → 3D模型 + +示例: +"a modern office chair with armrests" + → 可编辑的3D办公椅模型 + +"a traditional Chinese pavilion" + → 中国古亭的3D模型 +``` + +#### Image-to-3D (图像生成3D) + +``` +单张照片 → 3D生成模型 → 3D模型 + +示例: +一张建筑立面照片 → 完整的3D建筑模型 +一张产品照片 → 360°可旋转的3D模型 +``` + +#### 代表性方法 + +| 模型 | 年份 | 输入 | 方法 | 特点 | +|------|------|------|------|------| +| DreamFusion | 2022 | 文本 | SDS + NeRF | 首个高质量Text-to-3D | +| Point-E | 2022 | 文本 | 扩散模型→点云 | 速度快，质量一般 | +| Shap-E | 2023 | 文本/图像 | 扩散模型→隐式函数 | 支持3D和纹理 | +| LRM | 2023 | 图像 | Transformer | 大规模重建模型 | +| TripoSR | 2024 | 图像 | Transformer+NeRF | 开源，快速单图重建 | +| CLAY | 2024 | 文本 | 大型3D原生模型 | 设计级3D生成 | +| Trellis | 2024 | 文本/图像 | 结构化隐式+高斯 | 高质量，可编辑 | + +#### DreamFusion的SDS原理 (Score Distillation Sampling) + +DreamFusion的核心创新在于：利用预训练的2D扩散模型来指导3D生成。 + +``` +思路： + 2D扩散模型懂得"什么图像是合理的" + → 让它来"指导"3D模型的渲染结果 + + 随机初始化的NeRF + ↓ 渲染为2D图像 + 2D扩散模型评估并给出梯度 + ↓ 更新NeRF参数 + 反复迭代 + ↓ + NeRF渲染出的图像越来越好 + → NeRF本身就是一个好的3D模型 +``` + +### 代码示例：简化版NeRF概念实现 + +以下代码展示NeRF的核心组件——一个将3D坐标和观察方向映射为颜色和密度的MLP： + +```python +import torch +import torch.nn as nn + +class SimpleNeRF(nn.Module): + """简化版NeRF，展示核心映射思想""" + def __init__(self, pos_dim=3, dir_dim=3, hidden=64): + super().__init__() + # 位置编码 (Positional Encoding) 提升高频细节 + self.pos_encode_freq = 6 # 编码频率数 + + # 编码后的维度: 3 × 2 × 6 = 36 (sin+cos, 6个频率) + encoded_pos_dim = pos_dim * 2 * self.pos_encode_freq + + # 主干网络: 处理空间位置 + self.backbone = nn.Sequential( + nn.Linear(encoded_pos_dim, hidden), + nn.ReLU(), + nn.Linear(hidden, hidden), + nn.ReLU(), + nn.Linear(hidden, hidden), + nn.ReLU(), + ) + # 密度分支: 从位置预测密度 + self.density_head = nn.Linear(hidden, 1) + # 颜色分支: 从位置+方向预测颜色 + self.color_head = nn.Sequential( + nn.Linear(hidden + dir_dim, hidden // 2), + nn.ReLU(), + nn.Linear(hidden // 2, 3), + nn.Sigmoid() # 颜色值在[0,1] + ) + + def positional_encoding(self, x): + """位置编码: 让MLP能学习高频细节""" + encoded = [] + for freq in range(self.pos_encode_freq): + for fn in [torch.sin, torch.cos]: + encoded.append(fn(2**freq * x)) + return torch.cat(encoded, dim=-1) + + def forward(self, positions, directions): + """ + positions: (B, 3) - 3D空间坐标 + directions: (B, 3) - 观察方向 + """ + # 位置编码 + encoded_pos = self.positional_encoding(positions) + # 提取特征 + features = self.backbone(encoded_pos) + # 预测密度 + density = self.density_head(features) # (B, 1) + # 预测颜色 (依赖位置和观察方向) + color = self.color_head( + torch.cat([features, directions], dim=-1) + ) # (B, 3) + return color, density + + +# 演示: 查询一个空间点的颜色和密度 +model = SimpleNeRF() +pos = torch.randn(100, 3) # 100个空间点 +dir = torch.randn(100, 3) # 100个观察方向 +dir = dir / dir.norm(dim=-1, keepdim=True) # 归一化方向 + +color, density = model(pos, dir) +print(f"颜色范围: [{color.min():.3f}, {color.max():.3f}]") +print(f"密度范围: [{density.min():.3f}, {density.max():.3f}]") +print(f"颜色形状: {color.shape}, 密度形状: {density.shape}") +``` + +### 思考与练习 + +1. NeRF中位置编码 (Positional Encoding) 的作用是什么？没有它会发生什么？ +2. 3D Gaussian Splatting 为什么比NeRF渲染速度快？从数据结构的角度分析。 +3. 如果要为一个建筑外观设计项目选择3D重建方案，你会选择NeRF还是3DGS？为什么？ + +### 关键术语 + +| 中文 | 英文 | 说明 | +|------|------|------| +| 神经辐射场 | NeRF | 用MLP隐式表示3D场景 | +| 体渲染 | Volume Rendering | 沿光线积分合成图像 | +| 三维高斯溅射 | 3D Gaussian Splatting | 用高斯椭球体显式表示场景 | +| 运动恢复结构 | Structure from Motion (SfM) | 从照片恢复3D结构和相机位姿 | +| 多视图立体匹配 | Multi-View Stereo (MVS) | 从多视角生成稠密3D重建 | +| 位置编码 | Positional Encoding | 用三角函数提升高频细节表达 | + +### 延伸阅读 + +- [NeRF: Representing Scenes as Neural Radiance Fields (Mildenhall et al., 2020)](https://arxiv.org/abs/2003.08934) +- [3D Gaussian Splatting for Real-Time Radiance Field Rendering (Kerbl et al., 2023)](https://arxiv.org/abs/2308.04079) +- [DreamFusion: Text-to-3D using 2D Diffusion (Poole et al., 2022)](https://arxiv.org/abs/2209.14988) + +--- + +# 5.4 空间智能 + +## 学习目标 + +- 理解空间智能的概念及其对设计领域的意义 +- 了解多模态空间推理和场景理解的前沿方向 +- 掌握数字孪生的四个演进层次 +- 认识GIS+AI的融合趋势 + +### 从3D感知到空间推理 + +前两节我们学习了AI如何"感知"和"重建"三维世界。空间智能 (Spatial Intelligence) 则更进一步——不仅要感知空间，还要理解和推理空间中的关系、规律与语义。 + +``` +3D能力层次： + +感知层: 识别物体和几何形状 + ↓ +理解层: 理解空间语义（这是什么空间？功能是什么？） + ↓ +推理层: 空间关系推理（A在B的左边，C挡住了D的视线） + ↓ +规划层: 基于空间理解进行决策和设计 +``` + +**为什么空间智能对设计至关重要？** + +设计本质上是空间思维的活动——建筑师需要理解空间的比例与流线，景观设计师需要分析地形与视廊，城市规划师需要把握城市形态与功能关系。AI如果能够理解空间，就能成为设计过程中的真正协作伙伴。 + +### 多模态空间推理 + +#### 概念 + +将视觉信息、语言描述和三维空间理解结合起来，进行空间相关的推理和问答。 + +``` +输入: 一张室内照片 + 问题 "沙发后面是什么？" + ↓ 多模态空间推理 +输出: "沙发后面是一面挂画的白墙" +``` + +``` +多模态空间推理框架: + + 视觉模态 ──→ 视觉编码器 ──┐ + ├──→ 空间推理模块 ──→ 回答/决策 + 语言模态 ──→ 语言编码器 ──┤ + │ + 3D模态 ──→ 3D编码器 ──┘ + (点云/网格) +``` + +#### 空间推理任务类型 + +| 任务 | 输入 | 输出 | 示例 | +|------|------|------|------| +| 空间问答 (Spatial QA) | 图像 + 问题 | 文字答案 | "这栋建筑有几层？" | +| 空间关系描述 | 3D场景 | 关系三元组 | (树, 在...前面, 建筑) | +| 导航指令 | 语言指令 | 路径/动作 | "走到窗边左转" | +| 场景变化检测 | 两个时刻的场景 | 变化描述 | "左侧新增了一棵树" | + +### 场景理解 + +场景理解是对一个完整空间的多层次分析： + +``` +场景理解三层次: + + 语义理解 (Semantic) + ┌─────────────────────────────────────────────┐ + │ 这是什么？每个部分的功能是什么？ │ + │ "这是客厅" "那是厨房" "这是走廊" │ + └─────────────────────────────────────────────┘ + + 几何理解 (Geometric) + ┌─────────────────────────────────────────────┐ + │ 空间的几何属性是什么？ │ + │ 面积、高度、距离、角度、曲率 │ + └─────────────────────────────────────────────┘ + + 关系理解 (Relational) + ┌─────────────────────────────────────────────┐ + │ 物体之间的关系是什么？ │ + │ A在B的上方、C连接D、E包围F │ + └─────────────────────────────────────────────┘ +``` + +#### 具体任务 + +- **语义分割**：每个区域的功能标注（居住、商业、绿地...） +- **布局估计**：房间的结构（墙壁、门窗位置） +- **物体关系图**：构建场景中物体之间的空间关系图 + +``` +场景图 (Scene Graph): + + [桌子] ──在上面──→ [电脑] + │ │ + 在旁边 连接到 + ↓ ↓ + [椅子] [显示器] + │ + 在下面 + ↓ + [地毯] +``` + +### 大型空间模型 + +大型空间模型 (Large Spatial Models) 是一个新兴研究方向，旨在将大语言模型的推理能力与空间数据相结合。 + +``` +大语言模型 (LLM): 擅长语言理解与推理 + + +空间数据/模型: 擅长空间感知与几何计算 + ↓ +大型空间模型: 能理解和推理空间信息 + +类比: + LLM 是"能说话的大脑" + 视觉模型是"能看的眼睛" + 大型空间模型是"能理解空间的身体" +``` + +#### 代表性工作 + +| 方向 | 代表工作 | 描述 | +|------|----------|------| +| 3D-LLM | 3D-LLM (2023) | 将3D场景编码后输入LLM进行推理 | +| 空间问答 | SQA3D (2023) | 基于3D场景的问答基准 | +| 具身导航 | CLIPORT (2022) | 语言指导的机器人操作 | +| 场景生成 | SceneCraft (2024) | LLM驱动的场景布局生成 | + +### GIS + AI：智能地理分析 + +地理信息系统 (Geographic Information System, GIS) 是空间设计的核心工具。AI正在重塑GIS的分析能力。 + +``` +传统GIS: + 数据采集 → 存储 → 可视化 → 人工分析 + +AI增强GIS: + 数据采集 → 自动标注 → 智能分析 → 预测模拟 → 决策支持 + ↑ ↑ ↑ + 深度学习 空间推理 时空预测 +``` + +#### AI+GIS的典型应用 + +| 应用场景 | AI技术 | 设计意义 | +|----------|--------|----------| +| 地物分类 | 语义分割 | 自动提取建筑、道路、水体 | +| 城市形态分析 | 深度学习 | 自动识别街区类型和肌理 | +| 地形分析 | 点云分割 | 坡度、坡向、汇水分析 | +| 变化检测 | 孪生网络 | 监测城市扩张和土地利用变化 | +| 选址分析 | 多因子评价 | AI辅助最优选址决策 | +| 交通模拟 | 图神经网络 | 预测交通流量和拥堵 | + +### 数字孪生的演进 + +数字孪生 (Digital Twin) 是空间智能的终极目标——在数字世界中完整复制物理空间。 + +``` +数字孪生的四个层次: + +1. 几何孪生 (Geometric Twin) + ┌───────────────────────────────────┐ + │ 精确的3D几何模型 │ + │ 例: 建筑BIM模型、城市3D白模 │ + │ 静态的形状与空间关系 │ + └───────────────────────────────────┘ + ↓ + +2. 物理孪生 (Physical Twin) + ┌───────────────────────────────────┐ + │ 叠加物理属性与仿真 │ + │ 例: 结构力学模拟、日照分析 │ + │ 可以模拟物理过程 │ + └───────────────────────────────────┘ + ↓ + +3. 行为孪生 (Behavioral Twin) + ┌───────────────────────────────────┐ + │ 实时数据驱动的动态模型 │ + │ 例: 实时人流监测、能耗数据 │ + │ 反映当前状态和行为模式 │ + └───────────────────────────────────┘ + ↓ + +4. 认知孪生 (Cognitive Twin) + ┌───────────────────────────────────┐ + │ 具备推理和决策能力 │ + │ 例: AI分析异常、推荐优化方案 │ + │ 能"思考"和"建议" │ + └───────────────────────────────────┘ +``` + +#### 设计领域的数字孪生案例 + +- **建筑数字孪生**：从BIM模型到实时运维管理，结合IoT传感器数据监测建筑健康状态 +- **城市数字孪生**：新加坡Virtual Singapore项目，完整的城市级数字孪生平台 +- **景观数字孪生**：结合生态模型模拟植被生长、水文过程、生物多样性 + +### 思考与练习 + +1. 空间智能与2D图像理解的核心区别是什么？为什么空间推理需要三维信息？ +2. 数字孪生的四个层次在设计实践中分别对应哪些具体工具和方法？ +3. 设想一个"认知孪生"校园，它能做哪些事情？需要哪些技术支撑？ + +### 关键术语 + +| 中文 | 英文 | 说明 | +|------|------|------| +| 空间智能 | Spatial Intelligence | 理解和推理空间关系的能力 | +| 多模态推理 | Multi-modal Reasoning | 融合多种信息模态进行推理 | +| 场景图 | Scene Graph | 描述物体间关系的图结构 | +| 大型空间模型 | Large Spatial Model | 结合LLM与空间数据的模型 | +| 数字孪生 | Digital Twin | 物理空间的数字副本 | +| 地理信息系统 | GIS | 地理空间数据管理系统 | + +### 延伸阅读 + +- [3D-LLM: Injecting 3D World into LLMs (Hong et al., 2023)](https://arxiv.org/abs/2307.12981) +- [SQA3D: Situated Question Answering in 3D Scenes (Ma et al., 2023)](https://arxiv.org/abs/2305.14086) +- [Microsoft Digital Twins](https://learn.microsoft.com/en-us/azure/digital-twins/) + +--- + +# 5.5 设计应用 + +## 学习目标 + +- 了解3D AI在建筑设计、景观设计、城市设计等领域的综合应用 +- 理解从数据采集到设计迭代的完整工作流 +- 掌握实际项目中3D技术的选型思路 + +### 建筑：从概念到三维模型 + +#### 概念草图到3D模型 + +``` +设计师手绘草图 + ↓ AI理解 (2D → 3D) +3D概念体量模型 + ↓ 参数化调整 +优化方案 + ↓ BIM生成 +完整建筑信息模型 +``` + +**关键技术**： + +- 草图理解：深度学习识别建筑平面图中的墙体、门窗、空间 +- 3D生成：Image-to-3D模型将草图转化为体量模型 +- 参数化设计：AI根据设计约束（面积、高度、朝向）自动调整参数 + +#### 自动化BIM生成 + +``` +无人机扫描既有建筑 + ↓ 3D重建 (NeRF/3DGS) +点云/网格模型 + ↓ 语义分割 +识别: 墙体、楼板、梁柱、门窗 + ↓ 自动建模 +Revit/ArchiCAD BIM模型 + ↓ 工程应用 +结构分析 / 能耗模拟 / 施工管理 +``` + +#### 设计迭代辅助 + +``` +设计约束: 面积≥500m², 层数≤6, 日照≥2h/天 + ↓ +AI生成多个满足约束的体量方案 + ↓ +设计师选择并微调 + ↓ +AI实时反馈: 容积率、日照、风环境 +``` + +### 景观：从地形到生态 + +#### 地形分析 + +``` +无人机航拍 + ↓ 摄影测量 / LiDAR +DEM (数字高程模型) + ↓ AI地形分析 + ├── 坡度分级图 + ├── 坡向分析图 + ├── 汇水流域图 + └── 视域分析图 +``` + +#### 植被模拟 + +``` +当前场地点云 + ↓ 3D语义分割 +识别现有植被（树种、冠幅、高度） + ↓ 生长模型 + AI预测 +模拟5年/10年/20年后的植被状态 + ↓ +辅助种植设计决策 +``` + +#### 视廊分析 + +``` +3D城市模型 + 观察点 + ↓ 视线追踪算法 +计算每个区域的可见度 + ↓ 生成视域图 (Viewshed) + ├── 确定最佳观景点 + ├── 保护重要景观视廊 + └── 评估新建建筑对景观的影响 +``` + +### 城市设计：数字孪生城市 + +#### 从无人机航拍到3D城市模型 + +**完整工作流案例**： + +``` +Step 1: 数据采集 + 无人机搭载相机/LiDAR + 覆盖1km²区域，重叠率70%+ + ↓ + +Step 2: 3D重建 + 照片 → SfM → 稀疏点云 + → MVS → 稠密点云 + → 网格重建 → 纹理映射 + 或: 照片 → 3DGS → 实时渲染场景 + ↓ + +Step 3: 语义理解 + 点云/网格 → 3D语义分割 + 识别: 建筑、道路、植被、水体、地面 + ↓ + +Step 4: 城市分析 + ├── 城市形态: 建筑密度、高度分布、街区肌理 + ├── 开放空间: 绿地可达性、公共空间品质 + ├── 交通网络: 道路连通性、步行友好度 + └── 微气候: 日照、风环境、热岛效应 + ↓ + +Step 5: 决策支持 + 方案对比模拟 → 可视化呈现 → 辅助规划决策 +``` + +#### 城市形态分析 + +``` +3D城市模型 + ↓ AI自动提取 +建筑轮廓 + 高度 + 功能 + ↓ 形态学分析 + ├── 街道宽高比 (D/H) + ├── 建筑密度 (FAR) + ├── 天际线分析 + └── 街区类型分类 + ↓ +城市设计导则制定 +``` + +### 室内设计：从扫描到设计 + +#### 室内设计全流程 + +``` +Step 1: 房间扫描 + 手机/深度相机扫描 + ↓ + 实时3D重建 (如 LiDAR iPad/iPhone) + ↓ + 完整室内点云/网格 + ↓ + +Step 2: 场景理解 + 3D语义分割 + ↓ + 识别: 墙壁、地面、天花板、门窗、现有家具 + ↓ + 自动生成户型图 + 尺寸标注 + ↓ + +Step 3: 设计生成 + 输入: 户型图 + 风格偏好 + 预算 + ↓ AI辅助 + 生成多个布局方案 (2D + 3D) + ↓ + 材质搭配 + 灯光设计 + ↓ + +Step 4: 可视化与迭代 + 实时3D渲染 / VR预览 + ↓ + 设计师/客户反馈 → AI调整 + ↓ + 最终方案 +``` + +### 工业设计：逆向工程与再设计 + +#### 产品扫描到再设计 + +``` +现有产品 (如: 经典椅子) + ↓ 3D扫描 (结构光/激光) +高精度点云/网格 + ↓ + ├── 逆向工程: 提取设计参数 + │ 曲面分析、人机工程参数 + │ + ├── 缺陷检测: 识别磨损/变形区域 + │ 为改良设计提供依据 + │ + └── AI再设计: 基于原始形态生成变体 + "保留经典轮廓，增加人体工学支撑" +``` + +``` +3D扫描模型 + ↓ AI分析 +特征提取 (曲率、对称性、风格特征) + ↓ 参数化表示 + ↓ 生成式设计 +新的变体方案 + ↓ + ├── 拓扑优化 (减重、增强) + ├── 可制造性分析 (3D打印/CNC) + └── 风格迁移 (保留功能，改变风格) +``` + +### 综合案例：从无人机航测到3D城市模型 + +以下代码展示一个简化但完整的城市3D重建工作流： + +```python +import open3d as o3d +import numpy as np + +# ===== Step 1: 加载无人机航测生成的点云 ===== +# 实际项目中由COLMAP/OpenMVS/Pix4D等工具从照片生成 +pcd = o3d.io.read_point_cloud("aerial_survey.ply") + +# ===== Step 2: 点云预处理 ===== +# 下采样 (减少点数，保留结构) +pcd_down = pcd.voxel_down_sample(voxel_size=0.05) + +# 去除噪声点 (统计滤波) +pcd_clean, _ = pcd_down.remove_statistical_outlier( + nb_neighbors=20, std_ratio=2.0 +) + +# 估计法向量 +pcd_clean.estimate_normals( + search_param=o3d.geometry.KDTreeSearchParamHybrid( + radius=0.1, max_nn=30 + ) +) + +print(f"处理后点数: {len(pcd_clean.points)}") + +# ===== Step 3: 地面分割 (简化版) ===== +points = np.asarray(pcd_clean.points) + +# 用高度阈值简单分割（实际项目用CSF等算法） +min_z = points[:, 2].min() +ground_mask = points[:, 2] < min_z + 0.5 # 地面点 +building_mask = points[:, 2] >= min_z + 1.5 # 建筑点 + +ground_pcd = pcd_clean.select_by_index( + np.where(ground_mask)[0] +) +building_pcd = pcd_clean.select_by_index( + np.where(building_mask)[0] +) + +# 给不同类别上色 +ground_pcd.paint_uniform_color([0.6, 0.8, 0.6]) # 绿色=地面 +building_pcd.paint_uniform_color([0.7, 0.7, 0.9]) # 蓝色=建筑 + +# ===== Step 4: 可视化 ===== +o3d.visualization.draw_geometries( + [ground_pcd, building_pcd], + window_name="城市3D模型 - 地面(绿)+建筑(蓝)", + width=1200, height=800 +) + +# ===== Step 5: 基础分析 ===== +print(f"\n===== 场景分析 =====") +print(f"地面点: {np.sum(ground_mask)}") +print(f"建筑点: {np.sum(building_mask)}") +print(f"建筑最高点: {points[building_mask, 2].max():.1f}m") +print(f"场景范围: {points.max(axis=0) - points.min(axis=0)}") + +# ===== Step 6: 表面重建 (可选) ===== +# 使用Poisson重建将点云转为网格 +mesh, densities = o3d.geometry.TriangleMesh.create_from_point_cloud_poisson( + pcd_clean, depth=8 +) + +# 保存网格模型 +o3d.io.write_triangle_mesh("city_model.obj", mesh) +print("城市模型已保存为 city_model.obj") +``` + +### 各领域3D技术选型参考 + +| 设计领域 | 首选3D表示 | 推荐技术 | 典型工具 | +|----------|------------|----------|----------| +| 建筑 | 网格 + BIM | 3DGS/NeRF重建 | Pix4D, RealityCapture | +| 景观 | 点云 + DEM | LiDAR + 语义分割 | CloudCompare, LAStools | +| 城市设计 | 网格 + 体素 | 倾斜摄影测量 | Cesium, CityEngine | +| 室内设计 | 网格 | RGB-D扫描 | Matterport, Polycam | +| 工业设计 | 网格 | 结构光扫描 | Artec, Shining 3D | + +### 思考与练习 + +1. 如果你需要为一个历史街区制定保护规划，会采用哪种3D数据采集和重建方案？说明理由。 +2. 比较NeRF和3DGS在建筑外观重建中的优缺点，什么场景下选哪种？ +3. 设计一个利用3D扫描和AI技术辅助室内改造的完整方案，包括数据流、技术选型和用户交互。 + +--- + +## 思考与练习 + +1. **表示方式选择**：针对以下三种场景，分别选择最合适的3D表示方式（点云、网格、体素或深度图），并说明理由：(a) 自动驾驶中的实时障碍物检测；(b) 游戏中的角色建模；(c) 室内装修方案的VR预览。 + +2. **技术路线对比**：NeRF和3D Gaussian Splatting分别代表了隐式和显式的场景表示路线。请从设计应用的角度分析：哪些设计场景更适合NeRF，哪些更适合3DGS？未来两者会融合还是分化？ + +3. **空间智能畅想**：设想你正在设计一个"AI空间设计师助手"，它能理解建筑平面图、3D模型和自然语言描述。请描述这个系统的核心功能模块，以及每个模块需要用到本章学到的哪些技术。 + +## 关键术语 + +| 中文 | 英文 | 说明 | +|------|------|------| +| 点云 | Point Cloud | 三维坐标点的集合 | +| 网格 | Mesh | 顶点、边、面组成的多面体 | +| 体素 | Voxel | 三维空间规则网格单元 | +| 深度图 | Depth Map | 存储距离信息的二维图像 | +| 激光雷达 | LiDAR | 激光测距三维传感器 | +| 置换不变性 | Permutation Invariance | 输入顺序不影响输出 | +| 运动恢复结构 | Structure from Motion (SfM) | 从多视角照片恢复3D结构 | +| 多视图立体匹配 | Multi-View Stereo (MVS) | 稠密3D重建方法 | +| 神经辐射场 | NeRF | 用MLP隐式表示三维场景 | +| 体渲染 | Volume Rendering | 沿光线积分合成图像 | +| 三维高斯溅射 | 3D Gaussian Splatting | 用高斯椭球体显式表示场景 | +| 位置编码 | Positional Encoding | 提升高频细节的编码方法 | +| 空间智能 | Spatial Intelligence | 理解和推理空间关系的能力 | +| 场景图 | Scene Graph | 描述物体间关系的图结构 | +| 数字孪生 | Digital Twin | 物理空间的完整数字副本 | +| 地理信息系统 | GIS | 地理空间数据管理系统 | diff --git a/05-generative-ai/05-generative-ai.md b/05-generative-ai/05-generative-ai.md deleted file mode 100644 index 34dabdc..0000000 --- a/05-generative-ai/05-generative-ai.md +++ /dev/null @@ -1,344 +0,0 @@ -# 第五篇：生成式AI - -本篇讲解生成模型的发展脉络和AIGC工具链，探索AI在设计创造领域的应用。 - -## 篇章导读 - -生成式AI正在重新定义创造的边界。从图像生成到音乐创作，从文本写作到代码生成，AI正在成为人类的"创意伙伴"。 - -本篇将系统介绍生成模型的演进和AIGC工具链。 - ---- - -### 学习目标 - -1. 理解生成模型的发展脉络 - - 掌握Diffusion模型的基本原理 - - 了解各类生成模型的优缺点 - -### 生成模型家族 - -#### AE (Autoencoder，自编码器) - -`输入`` → ``编码器`` → ``潜在表示`` → ``解码器`` → ``重构` - -思想：学习数据的压缩表示 - -问题：生成的图像模糊，缺乏多样性 - -#### VAE (Variational AE，变分自编码器) - -`潜在空间约束为标准正态分布`\ -` ↓`\ -`可以随机采样`` → ``解码`` → ``生成新图像` - -改进：引入概率分布，增强生成能力 - -#### GAN (Generative Adversarial Network) - -`生成器：生成假图像`\ -`判别器：判断真假`\ -` ↓`\ -`对抗训练，相互博弈` - -优势：生成图像质量高 问题：训练不稳定，模式崩溃 - -#### Diffusion Model (扩散模型) - -`前向：逐步加噪`` → ``纯噪声`\ -`反向：学习去噪`` → ``还原图像` - -优势：训练稳定，生成质量极高 代表：Stable Diffusion, DALL-E 3 - -### Diffusion原理 - -#### 前向过程 (加噪) - -`原图`` x₀`\ -` ↓ ``加高斯噪声`\ -`x₁ = x₀ + ε₁`\ -` ↓ ``加噪声`\ -`x₂ = x₁ + ε₂`\ -` ↓ ...`\ -`x_T`` = ``纯噪声` - -#### 反向过程 (去噪) - -`纯噪声`` ``x_T`\ -` ↓ ``去噪`\ -`x_{T-1} = ``去噪网络``(``x_T``)`\ -` ↓ ``去噪`\ -`x_{T-2} = ``去噪网络``(x_{T-1})`\ -` ↓ ...`\ -`x₀ = ``原始图像` - -#### 训练目标 - -`去噪网络学习预测：`\ -` ``添加的噪声`` ε`\ -` ``或`\ -` ``原始图像`` x₀` - -### Stable Diffusion架构 - -#### 潜在空间扩散 - -`为了效率，在潜在空间操作：`\ -\ -`图像`` → VAE``编码`` → ``潜在表示`` → ``扩散`` → ``去噪`\ -` ↓`\ -` VAE``解码`` → ``图像` - -#### 核心组件 - - ------------------------------------- - 组件 作用 - -------------- ---------------------- - VAE 图像与潜在空间的转换 - - U-Net 去噪网络 - - Text Encoder 处理文本提示词 - - CLIP 文图对齐 - ------------------------------------- - -### 文生图工作流 - -#### 输入提示词 - -`"``一只猫，水彩画风格``"` - -#### - -`2. ``文本编码` - -#### → 文本向量表示 - -`3. ``初始化` - -#### → 随机噪声 - -`4. ``去噪循环` - -`for t in T...1:` - -`噪声`` → ``预测噪声`` → ``去噪` - -`5. ``解码输出` - - → 潜在表示 → VAE解码 → 图像 - -### 思考与练习 - -1. Diffusion为什么比GAN训练更稳定？ - -2. 潜在空间扩散有什么优势？ - -3. 文生图如何实现风格控制？ - -### 关键术语 - - --------------------------------------------------- - 中文 英文 说明 - ---------- ----------------- ---------------------- - 潜在空间 Latent Space 压缩后的数据表示空间 - - 去噪 Denoising 移除噪声的过程 - - 提示词 Prompt 指导生成的文本描述 - - 潜变量 Latent Variable 不可直接观测的变量 - - 模式崩溃 Mode Collapse GAN生成多样性不足 - --------------------------------------------------- - -### 延伸阅读 - -1. [Denoising Diffusion Probabilistic Models](https://arxiv.org/abs/2006.11239) - - [High-Resolution Image Synthesis with Latent Diffusion Models](https://arxiv.org/abs/2112.10752) \# 04.2 AIGC设计工具链 - ---- - -## 学习目标 - -3. 掌握ControlNet的条件控制机制 - - 理解LoRA高效微调原理 - - 了解ComfyUI工作流搭建 - -## ControlNet：精确控制 - -核心问题 - -纯文生图：难以精确控制空间结构 - -### ControlNet解决 - -`输入图像`` → ``提取条件`` (``边缘``/``深度``/``姿态``)`\ -` ↓`\ -`条件`` → ControlNet → ``主模型`` → ``输出图像` - -### 条件类型 - - ------------------------------------ - 条件 说明 应用 - -------------- ---------- ---------- - Canny 边缘检测 轮廓控制 - - Depth 深度图 空间关系 - - Pose 人体姿态 人物生成 - - Normal 法线图 表面细节 - - Segmentation 分割图 区域控制 - ------------------------------------ - -### 应用场景 - -`草图`` → ControlNet → ``精细效果图`\ -`平面图`` → ControlNet → ``三维渲染`\ -`结构图`` → ControlNet → ``风格化设计` - -LoRA：高效微调 - -问题 - -全量微调大模型：计算资源需求巨大 - -LoRA原理 - -`原始权重`` W ``固定`\ -` ↓`\ -`添加低秩分解：`\ -` ΔW = A × B`\ -` (``d×r``) × (``r×d``)`\ -` ↓`\ -`新输出`` = ``Wx`` + ``ABx` - -优势： - 参数量减少100-1000倍 - 训练速度快 - 易于切换风格 - -### 应用方式 - -`基础模型`` + ``LoRA`` A = ``风格``A`\ -`基础模型`` + ``LoRA`` B = ``风格``B`\ -`基础模型`` + ``LoRA`` A + B = ``混合风格` - -## ComfyUI：模块化工作流 - -### 核心特点 - -`节点化连接`\ -` ↓`\ -`可视化流程`\ -` ↓`\ -`灵活定制` - -### 典型节点 - - --------------------------------- - 节点类型 功能 - ------------------ -------------- - Load Checkpoint 加载模型 - - CLIP Text Encode 文本编码 - - KSampler 采样生成 - - VAE Decode 潜在空间解码 - - Save Image 保存图像 - - ControlNet 条件控制 - - LoRA Loader 加载LoRA - --------------------------------- - -### 工作流示例 - -`文本提示`` → CLIP``编码`` →`\ -` ↓`\ -`正负提示`` ────→ ``KSampler`` ← ControlNet`\ -` ↓`\ -` VAE``解码`\ -` ↓`\ -` ``保存图像` - -## 设计领域应用案例 - -### 建筑设计 - -`草图生成`` → ControlNet (Canny) → ``效果图`\ -`方案变体`` → ``LoRA``风格微调`` → ``多方案对比` - -### 室内设计 - -`户型图`` → ControlNet → ``三维效果图`\ -`风格迁移`` → ``LoRA`` → ``不同材质方案` - - --------------------------------------- - 工具 核心价值 - ------------------ -------------------- - Midjourney 快速创意探索 - - Stable Diffusion 本地部署，可控生成 - - ControlNet 精确结构控制 - - ComfyUI 定制化工作流 - --------------------------------------- - -## 版权与伦理 - -### 版权问题 - -6. AI训练数据的版权归属 - - AI生成作品的版权保护 - - 风格模仿的法律边界 - -### 伦理考量 - -9. 深度伪造 (Deepfake) - - 虚假信息传播 - - 创作者职业影响 - -## 思考与练习 - -1. ControlNet如何平衡条件控制与创造性？ - -2. LoRA和全量微调各适用于什么场景？ - -3. AIGC工具如何融入设计工作流？ - -## 关键术语 - - ------------------------------------------------------ - 中文 英文 说明 - ---------- --------------------- --------------------- - 条件控制 Conditional Control 引导生成过程 - - 低秩适应 LoRA Low-Rank Adaptation - - 工作流 Workflow 节点化的处理流程 - - 采样器 Sampler 去噪采样算法 - - 潜在空间 Latent Space 压缩的特征空间 - ------------------------------------------------------ - -## 延伸阅读 - -1. [ControlNet官方论文](https://arxiv.org/abs/2302.05543) - - [LoRA官方论文](https://arxiv.org/abs/2106.09685) - - [ComfyUI文档](https://docs.comfy.org/) diff --git a/06-agent/06-agent.md b/06-agent/06-agent.md deleted file mode 100644 index 91a6255..0000000 --- a/06-agent/06-agent.md +++ /dev/null @@ -1,535 +0,0 @@ -# 第六篇：AI Agent与自主设计 - -本篇探讨AI Agent的架构和具身智能，展望AI在规划设计中的应用前景。 - -## 篇章导读 - -AI Agent代表了人工智能的下一个前沿：从"被动响应"到"主动行动"，从"单一能力"到"系统协同"。 - -本篇将系统介绍Agent架构和在设计领域的应用。 - ---- - -## 学习目标 - -1. 理解从规则到LLM-based Agent的演进 - - 掌握Agent的核心组件 - - 了解ReAct和CoT推理模式 - -## 从规则到LLM Agent - -### 规则系统时代 - -`if`` ``condition_A``:`\ -` ``action_``B``(``)`\ -`elif`` ``condition_C``:`\ -` ``action_D``()`\ -`else``:`\ -` ``action_E``()` - -局限：规则难以穷举，无法应对新情况 - -### LLM-based Agent - -`用户请求`` → LLM``理解`` → ``规划`` → ``调用工具`` → ``反思`` → ``输出` - -优势： - 自然语言交互 - 上下文理解 - 泛化能力强 - -## Agent核心组件 - -### 感知 (Perception) - -`输入信息`` → ``理解与解析`\ -` - ``用户指令`\ -` - ``环境状态`\ -` - ``工具反馈` - -### 规划 (Planning) - -`目标`` → ``分解为子任务`\ -` - ``任务分析`\ -` - ``步骤规划`\ -` - ``依赖管理` - -### 记忆 (Memory) - -`┌─────────────────────────────┐`\ -`│ ``短期记忆`` (Short-term) │`\ -`│ ``对话上下文、临时状态`` │`\ -`├─────────────────────────────┤`\ -`│ ``长期记忆`` (Long-term) │`\ -`│ ``知识库、经验积累`` │`\ -`└─────────────────────────────┘` - -### 工具调用 (Tool Use) - -`可用工具集：`\ -` - ``数据库查询`\ -` - API``调用`\ -` - ``文件操作`\ -` - ``代码执行`\ -` ...` - -## 推理模式 - -Chain of Thought (CoT) - -`问题`` → ``思考链`` → ``答案` - -`"``设计一个公园``"` - -` ↓` - -1. `分析场地条件` - -2. `2. ``确定功能分区` - -3. `3. ``布局路径系统` - -`4. ``选择植物配置` - -`↓` - - 完整方案 - -### ReAct (Reasoning + Acting) - -`循环：思考`` → ``行动`` → ``观察`` → ``思考`` ...`\ -\ -`思考：需要查询场地数据`\ -`行动：调用``GIS``工具`\ -`观察：获取到高程信息`\ -`思考：基于高程做排水设计`\ -`行动：生成排水方案`\ -`...` - -## Agent架构示例 - -单Agent架构 - -`┌─────────────────────────────┐`\ -`│ LLM Core │`\ -`│ (``规划、推理、决策``) │`\ -`├─────────────────────────────┤`\ -`│ ┌───┐ ┌───┐ ┌───┐ ┌───┐ │`\ -`│ │``感知``││``记忆``││``工具``││``反思``│ │`\ -`│ └───┘ └───┘ └───┘ └───┘ │`\ -`└─────────────────────────────┘`\ -` ↓`\ -` ``执行任务` - -### 多Agent协作 - -`┌─────────┐ ┌─────────┐ ┌─────────┐`\ -`│ ``规划``Agent│→│``分析``Agent│→│``设计``Agent│`\ -`└─────────┘ └─────────┘ └─────────┘`\ -` ↓ ↓ ↓`\ -` ``任务分解`` ``数据分析`` ``方案生成` - -## 思考与练习 - -1. 单Agent和多Agent系统各有什么优势？ - -2. 如何设计Agent的记忆系统？ - -3. CoT和ReAct各适用于什么场景？ - -## 关键术语 - - -------------------------------------------- - 中文 英文 说明 - ---------- ------------ -------------------- - 思考链 CoT Chain of Thought - - 推理行动 ReAct Reasoning + Acting - - 记忆 Memory 存储和检索信息 - - 反思 Reflection 自我评估与改进 - - 工具使用 Tool Use 调用外部能力 - -------------------------------------------- - -## 延伸阅读 - -1. [LLM Powered Autonomous Agents](https://lilianweng.github.io/posts/2023-06-23-agent/) - - [ReAct: Synergizing Reasoning and Acting](https://arxiv.org/abs/2210.03629) \# 05.2 具身智能 - ---- - -# 学习目标 - -3. 理解具身智能的概念和特点 - - 了解数字孪生与物理世界的交互 - - 掌握强化学习在具身AI中的应用 - -# 什么是具身智能 - -## 定义 - -**具身智能 (Embodied AI)**：具有物理实体或虚拟身体的智能系统，能够通过与环境的交互来学习和完成任务。 - -## 与传统AI的区别 - - ------------------------------------ - 特性 传统AI 具身AI - ---------- ------------ ------------ - 交互方式 数据输入 主动探索 - - 学习方式 从数据学习 从交互学习 - - 输出形式 预测/生成 行动/操作 - ------------------------------------ - -# 数字孪生 - -## 概念 - -`物理世界`` → ``数字映射`` → ``仿真预测`` → ``反向控制` - -## 应用层次 - - -------------------------------- - 层次 内容 应用 - ---------- ---------- ---------- - 几何孪生 三维模型 可视化 - - 物理孪生 物理仿真 性能分析 - - 行为孪生 行为模拟 场景预测 - - 认知孪生 决策支持 智能控制 - -------------------------------- - -# 强化学习基础 - -## 核心要素 - -`┌─────────────────────────────────────┐`\ -`│ │`\ -`│ ``环境`` ← ``状态`` ──────→ Agent │`\ -`│ ↑ │ │`\ -`│ └──── ``奖励`` ←─── ``动作`` ─┘ │`\ -`│ │`\ -`└─────────────────────────────────────┘` - -## 训练循环 - -1. `观察环境状态` - -2. `选择行动` - -3. `执行行动` - -4. `获得奖励` - -5. `更新策略` - -6. `重复``...` - -## Gymnasium环境 - -`import gymnasium as gym`\ -\ -`env = ``gym.make``("CartPole-v1")`\ -`state, _ = ``env.reset``()`\ -\ -`for _ in range(1000):`\ -` action = policy(state)`\ -` state, reward, done, _, _ = ``env.step``(action)`\ -` if done:`\ -` break` - -# 具身AI应用场景 - -## 机器人设计 - -`感知环境`` → ``规划路径`` → ``执行动作`` → ``反馈调整`\ -` ↓`\ -`建筑机器人、施工机器人` - -## 虚拟角色 - -`游戏``NPC``、虚拟助手、元宇宙居民`\ -` ↓`\ -`自然行为、智能对话` - -## 仿真训练 - -`虚拟环境`` → ``训练策略`` → ``迁移到真实`\ -` ↓`\ -`降低试错成本` - -# 虚拟到真实的迁移 - -## 挑战 - - ----------------------------------- - 问题 说明 - -------------- -------------------- - Sim2Real Gap 仿真与现实的差异 - - 感官差异 虚拟与真实感知不同 - - 物理特性 真实物理更复杂 - ----------------------------------- - -## 解决方案 - -1. 域随机化 (Domain Randomization) - - 真实数据混合 - - 在线微调 - -# 思考与练习 - -1. 具身智能在规划设计中有哪些应用前景？ - -2. 数字孪生如何辅助设计决策？ - -3. Sim2Real迁移的主要挑战是什么？ - -# 关键术语 - - -------------------------------------------------- - 中文 英文 说明 - ---------- -------------- ------------------------ - 具身智能 Embodied AI 有身体形式的AI - - 数字孪生 Digital Twin 物理世界的数字映射 - - 强化学习 RL Reinforcement Learning - - 状态 State 环境的当前情况 - - 动作 Action Agent对环境的影响 - -------------------------------------------------- - -# 延伸阅读 - -1. [Gymnasium文档](https://gymnasium.org.cn/) - - [DeepMind's Embodied AI Research](https://www.deepmind.com/research/embodied) \# 05.3 规划设计应用与MCP - ---- - -# 学习目标 - -3. 理解MCP协议的核心思想 - - 掌握HITL协作模式 - - 了解Agent在规划设计中的落地场景 - -# MCP协议 - -## 什么是MCP - -**Model Context Protocol (模型上下文协议)**：连接AI模型与外部数据/工具的开放标准。 - -## 核心价值 - -`传统方式：`\ -` AI``模型`` → ``各自独立`` → ``数据孤岛`\ -\ -`MCP``方式：`\ -` AI``模型`` ← MCP → ``统一接口`` → ``所有工具``/``数据` - -MCP架构 - -`┌─────────────────────────────────────┐`\ -`│ AI Application │`\ -`│ (Claude, ``ChatGPT``, ``等``) │`\ -`└─────────────┬───────────────────────┘`\ -` │ MCP`\ -`┌─────────────┴───────────────────────┐`\ -`│ MCP Client │`\ -`├─────────────────────────────────────┤`\ -`│ ┌──────┐ ┌──────┐ ┌──────┐ │`\ -`│ │File │ │DB │ │API │ ... │`\ -`│ │``Server│ │Server│ │Server│ │`\ -`│ └──────┘ └──────┘ └──────┘ │`\ -`└─────────────────────────────────────┘` - -# HITL：人机协作模式 - -## 什么是HITL - -**Human-in-the-Loop (人在回路)**：在AI决策关键环节引入人类干预。 - -## HITL层次 - - ---------------------------------- - 层次 人类角色 自动化程度 - ---------- ---------- ------------ - 完全自动 无 100% - - 人工审核 监督者 80-90% - - 交互决策 合作伙伴 50-70% - - 人工主导 操作者 \<50% - ---------------------------------- - -## 规划设计中的HITL - -`AI``生成方案`\ -` ↓`\ -`设计师审核`` ← ``修改意见`` → AI``调整`\ -` ↓`\ -`最终确认` - -# 规划设计Agent案例 - -## 场景分析Agent - -`输入：场地数据` - -`↓` - -`分析流程：` - -1. `地形分析`` (``坡度、高程``)` - -2. `气候分析`` (``日照、风向``)` - -3. `交通分析`` (``可达性``)` - -4. `视觉分析`` (``视域、景观``)` - -`↓` - -`输出：场地分析报告` - -## 方案生成Agent - -`输入：设计要求`` + ``场地分析` - -`↓` - -`生成流程：` - -1. `理解需求`` (``CoT``推理``)` - -2. `布局功能`` (``工具调用``)` - -3. `连接路径`` (``图算法``)` - -4. `优化调整`` (``迭代改进``)` - -`↓` - -`输出：初步设计方案` - -## 合规审查Agent - -`输入：设计方案` - -`↓` - -`审查流程：` - -1. `调用规范库` - -2. `逐条核对` - -3. `标记问题` - -4. `生成报告` - -`↓` - -`输出：合规审查意见` - -# Agent落地挑战 - -技术挑战 - - --------------------------- - 挑战 说明 - ---------- ---------------- - 准确性 复杂任务易出错 - - 可解释性 决策过程不透明 - - 鲁棒性 边界情况处理 - --------------------------- - -应用挑战 - - ----------------------------- - 挑战 说明 - ------------ ---------------- - 工作流整合 与现有流程融合 - - 责任界定 AI错误的后果 - - 成本控制 API调用费用 - ----------------------------- - -## 解决方向 - -1. 分级应用：简单任务自动化，复杂任务辅助 - - 渐进式：从局部到整体 - - 人机协同：关键环节人工确认 - -# 未来展望：AI设计师 - -### 短期 (1-2年) - -`AI``作为工具`\ -` - ``数据分析`\ -` - ``方案生成`\ -` - ``合规检查` - -### 中期 (3-5年) - -`AI``作为助手`\ -` - ``创意启发`\ -` - ``方案优化`\ -` - ``文档撰写` - -### 长期 (5-10年) - -`AI``作为合作伙伴`\ -` - ``共同创造`\ -` - ``自主决策`\ -` - ``专业评审` - -## 思考与练习 - -1. MCP如何解决AI应用的"数据孤岛"问题？ - -2. 规划设计中哪些环节适合引入HITL？ - -3. AI设计师如何与人类设计师协作？ - -## 关键术语 - - ---------------------------------------------------------------- - 中文 英文 说明 - ---------------- ---------------------- ------------------------ - 模型上下文协议 MCP Model Context Protocol - - 人在回路 HITL Human-in-the-Loop - - 数据孤岛 Data Silo 独立的数据存储 - - 协议 Protocol 通信标准 - - 工作流整合 Workflow Integration 融入现有流程 - ---------------------------------------------------------------- - -## 延伸阅读 - -1. [MCP官方文档](https://modelcontextprotocol.io/) - - [Human-in-the-Loop AI](https://arxiv.org/abs/2301.02629) diff --git a/06-reinforcement/06-reinforcement.md b/06-reinforcement/06-reinforcement.md new file mode 100644 index 0000000..820fa7d --- /dev/null +++ b/06-reinforcement/06-reinforcement.md @@ -0,0 +1,896 @@ +# 第6章：强化学习——从决策到对齐 + +## 篇章导读 + +强化学习（Reinforcement Learning, RL）是一种通过与环境交互、从反馈中学习的范式。与监督学习从标注数据中学习不同，强化学习的智能体（Agent）通过不断尝试行动、接收奖励或惩罚信号来优化自身行为策略。 + +2016年，AlphaGo击败围棋世界冠军李世石，让强化学习走入公众视野。此后，从蛋白质结构预测（AlphaFold）到大语言模型的人类对齐（RLHF），强化学习已深入AI的各个核心领域，成为现代人工智能不可或缺的基石。 + +本章将系统介绍强化学习的基础原理、核心算法、里程碑突破，以及它在大模型对齐和设计领域的应用。我们将看到，强化学习不仅是一种算法工具，更是理解"智能体如何在复杂世界中做出决策"的关键框架。 + +--- + +## 学习目标 + +1. 理解强化学习的基本框架：智能体-环境交互循环 +2. 掌握从Q-Learning到PPO的核心算法演进 +3. 了解Alpha系列的技术突破及其意义 +4. 理解RLHF如何将大语言模型与人类偏好对齐 +5. 认识具身智能（Embodied AI）与强化学习的关联 +6. 思考强化学习在设计领域的应用场景 + +--- + +# 6.1 RL基础 + +## 6.1.1 核心框架：智能体与环境的交互 + +强化学习的核心是一个**智能体（Agent）与环境（Environment）的交互循环**： + +``` +┌─────────────────────────────────────────┐ +│ │ +│ ┌──────────┐ 动作 (Action) ┌──────────┐ │ +│ │ │ ──────────────────> │ │ │ +│ │ 智能体 │ │ 环境 │ │ +│ │ (Agent) │ <────────────────── │(Environ.)│ │ +│ │ │ 状态 (State) │ │ │ +│ │ │ 奖励 (Reward) │ │ │ +│ └──────────┘ └──────────┘ │ +│ │ +└─────────────────────────────────────────┘ +``` + +在每一个时间步 t，交互过程如下： + +1. 智能体观察环境的**状态（State）** s_t +2. 智能体根据策略选择一个**动作（Action）** a_t +3. 环境返回**奖励（Reward）** r_t 和新的状态 s_{t+1} +4. 智能体根据反馈更新策略，目标是最大化**累积奖励** + +这个过程就像一个学生做练习题：做题（选择动作），对答案（接收反馈），总结经验（更新策略），最终提高成绩（最大化累积奖励）。 + +## 6.1.2 马尔可夫决策过程 + +强化学习的数学基础是**马尔可夫决策过程（Markov Decision Process, MDP）**。一个MDP由五元组 (S, A, P, R, γ) 定义： + +| 符号 | 含义 | 说明 | +|------|------|------| +| S | 状态空间（State Space） | 环境所有可能的状态集合 | +| A | 动作空间（Action Space） | 智能体可采取的所有动作集合 | +| P | 状态转移概率（Transition Probability） | P(s'|s,a)，在状态s采取动作a后转移到s'的概率 | +| R | 奖励函数（Reward Function） | R(s,a)，在状态s采取动作a获得的即时奖励 | +| γ | 折扣因子（Discount Factor） | 0 ≤ γ ≤ 1，衡量未来奖励的重要性 | + +**马尔可夫性质（Markov Property）** 是MDP的核心假设：未来只取决于当前状态，与过去无关。这就像下棋时，当前的棋盘状态已经包含了所有必要信息，不需要知道之前的每一步走法。 + +## 6.1.3 价值函数 + +智能体的目标是最大化累积折扣奖励： + +$$G_t = r_t + \gamma r_{t+1} + \gamma^2 r_{t+2} + ... = \sum_{k=0}^{\infty} \gamma^k r_{t+k}$$ + +为了评估"处于某个状态有多好"，我们定义两种价值函数： + +**状态价值函数（State Value Function）V(s)**：在状态s下，遵循策略π所能获得的期望累积奖励。 + +$$V^\pi(s) = \mathbb{E}_\pi [G_t | S_t = s]$$ + +**动作价值函数（Action Value Function）Q(s,a)**：在状态s下采取动作a，之后遵循策略π所能获得的期望累积奖励。 + +$$Q^\pi(s, a) = \mathbb{E}_\pi [G_t | S_t = s, A_t = a]$$ + +两者的关系是：V(s) 是对所有可能动作的Q值的加权平均。Q函数更为实用，因为它直接告诉我们在某个状态下"哪个动作最好"。 + +## 6.1.4 Q-Learning + +**Q-Learning** 是一种经典的免策略（Off-policy）时序差分算法，它直接学习最优Q函数，而不需要知道环境的具体模型。 + +其更新规则为： + +$$Q(s, a) \leftarrow Q(s, a) + \alpha [r + \gamma \max_{a'} Q(s', a') - Q(s, a)]$$ + +其中： +- α 是学习率（Learning Rate），控制每次更新的步长 +- r + γ max Q(s', a') 是**目标值**，即当前奖励加上下一状态的最大Q值 +- Q(s, a) 是**当前估计值** +- 方括号内的差值称为**时序差分误差（TD Error）** + +这就像考试估分：你先估计自己能得多少分（当前Q值），对答案后发现实际得分（目标值），然后修正你的估计。 + +**探索与利用的平衡（Exploration vs. Exploitation）** 是Q-Learning的关键问题。ε-greedy策略是最简单的解决方案：以概率ε随机选择动作（探索），以概率1-ε选择当前最优动作（利用）。 + +## 6.1.5 DQN：深度Q网络 + +当状态空间很大时（如像素级游戏画面），用表格存储所有Q值不再可行。2015年，DeepMind提出的**DQN（Deep Q-Network）**用神经网络来近似Q函数，实现了从感知到决策的端到端学习。 + +DQN的两个关键创新： + +**经验回放（Experience Replay）**：将智能体的经历 (s, a, r, s') 存储在回放缓冲区中，训练时随机采样小批量数据。这打破了数据之间的时间相关性，提高了训练稳定性。 + +**目标网络（Target Network）**：使用一个独立的目标网络来计算目标值，每隔一定步数才更新。这避免了"追逐移动目标"的不稳定性。 + +```python +# DQN核心思路伪代码 +import torch +import torch.nn as nn +import random +from collections import deque + +class DQN(nn.Module): + def __init__(self, state_dim, action_dim): + super().__init__() + self.net = nn.Sequential( + nn.Linear(state_dim, 128), + nn.ReLU(), + nn.Linear(128, 128), + nn.ReLU(), + nn.Linear(128, action_dim) + ) + + def forward(self, x): + return self.net(x) # 输出每个动作的Q值 + +# 经验回放缓冲区 +replay_buffer = deque(maxlen=10000) + +# 训练循环（简化版） +for episode in range(num_episodes): + state = env.reset() + for step in range(max_steps): + # ε-greedy选择动作 + if random.random() < epsilon: + action = env.action_space.sample() # 探索 + else: + with torch.no_grad(): + action = q_network(state).argmax() # 利用 + + next_state, reward, done, _ = env.step(action) + replay_buffer.append((state, action, reward, next_state)) + + # 从回放缓冲区采样并训练 + if len(replay_buffer) >= batch_size: + batch = random.sample(replay_buffer, batch_size) + # 计算损失并更新网络 + # loss = MSE(Q(s,a), r + γ * max Q_target(s', a')) + ... + + if done: + break +``` + +**突破性成果**：DQN在49款Atari游戏上达到了人类水平的性能，仅从游戏画面的像素输入和分数反馈就能学会各种不同的游戏策略。这一成果标志着深度强化学习时代的开启。 + +## 6.1.6 代码示例：网格世界中的Q-Learning + +下面是一个简化的Q-Learning完整示例，智能体在4×4网格中学习从起点走到终点： + +```python +import numpy as np + +# 定义4×4网格世界 +# 状态：0-15（网格中的每个格子） +# 动作：0=上, 1=右, 2=下, 3=左 +grid_size = 4 +n_states = grid_size * grid_size +n_actions = 4 +goal = 15 # 目标状态：右下角 + +# 初始化Q表（所有值设为0） +Q = np.zeros((n_states, n_actions)) + +# 超参数 +alpha = 0.1 # 学习率 +gamma = 0.95 # 折扣因子 +epsilon = 0.1 # 探索率 +episodes = 500 + +# 动作对应的位移 +action_map = { + 0: -grid_size, # 上 + 1: 1, # 右 + 2: grid_size, # 下 + 3: -1 # 左 +} + +def get_next_state(state, action): + """执行动作后的下一个状态""" + next_state = state + action_map[action] + # 边界检查 + if next_state < 0 or next_state >= n_states: + return state # 撞墙，留在原地 + # 左右边界检查 + if action == 1 and state % grid_size == grid_size - 1: + return state + if action == 3 and state % grid_size == 0: + return state + return next_state + +# Q-Learning训练 +for ep in range(episodes): + state = 0 # 起点：左上角 + while state != goal: + # ε-greedy选择动作 + if np.random.random() < epsilon: + action = np.random.randint(n_actions) + else: + action = np.argmax(Q[state]) + + next_state = get_next_state(state, action) + + # 奖励设计：到达目标+10，每步-1（鼓励快速到达） + reward = 10 if next_state == goal else -1 + + # Q-Learning更新 + Q[state, action] += alpha * ( + reward + gamma * np.max(Q[next_state]) - Q[state, action] + ) + + state = next_state + +# 输出学到的策略 +directions = ['↑', '→', '↓', '←'] +print("学到的最优策略：") +for s in range(n_states): + if s == goal: + print('🎯', end=' ') + else: + print(directions[np.argmax(Q[s])], end=' ') + if (s + 1) % grid_size == 0: + print() +# 输出示例： +# → → ↓ ↓ +# ↓ → ↓ ↓ +# → ↓ ↓ ↓ +# ↓ → → 🎯 +``` + +> **小贴士**：这个简单示例展示了强化学习的核心思想——智能体不需要任何人告诉它"该怎么走"，它只通过不断尝试和接收奖励反馈，就自己发现了最优路径。这正是强化学习区别于监督学习的本质。 + +--- + +# 6.2 策略优化 + +Q-Learning和DQN属于**基于价值（Value-Based）** 的方法：先学习价值函数，再间接推导策略。另一类方法是**基于策略（Policy-Based）** 的方法，直接优化策略本身。 + +## 6.2.1 策略梯度（Policy Gradient） + +策略梯度方法直接参数化策略 π_θ(a|s)，通过梯度上升最大化期望累积奖励： + +$$\nabla_\theta J(\theta) = \mathbb{E}_{\pi_\theta} \left[ \sum_t \nabla_\theta \log \pi_\theta(a_t|s_t) \cdot G_t \right]$$ + +直觉理解：如果某条轨迹的总回报G_t很高，就增大产生该轨迹的概率；反之则降低。这就像鼓励好的行为、惩罚坏的行为。 + +**REINFORCE算法**是最基本的策略梯度方法： + +```python +# REINFORCE算法核心思路 +import torch +import torch.nn as nn +import torch.optim as optim + +class PolicyNetwork(nn.Module): + def __init__(self, state_dim, action_dim): + super().__init__() + self.net = nn.Sequential( + nn.Linear(state_dim, 128), + nn.ReLU(), + nn.Linear(128, action_dim), + nn.Softmax(dim=-1) + ) + + def forward(self, x): + return self.net(x) # 输出动作概率分布 + +policy = PolicyNetwork(state_dim, action_dim) +optimizer = optim.Adam(policy.parameters(), lr=0.01) + +for episode in range(num_episodes): + log_probs = [] # 存储每步的log概率 + rewards = [] # 存储每步的奖励 + + state = env.reset() + while not done: + action_probs = policy(state) + action = torch.distributions.Categorical(action_probs).sample() + log_probs.append(torch.log(action_probs[action])) + + state, reward, done, _ = env.step(action) + rewards.append(reward) + + # 计算折扣累积奖励 + returns = compute_returns(rewards, gamma) + + # 策略梯度更新 + loss = -sum(lp * G for lp, G in zip(log_probs, returns)) + optimizer.zero_grad() + loss.backward() + optimizer.step() +``` + +REINFORCE的问题在于**方差大**：由于每条轨迹的回报波动很大，梯度估计不稳定，训练效率低。 + +## 6.2.2 Actor-Critic方法 + +**Actor-Critic** 方法结合了基于价值和基于策略的优势： + +``` +┌─────────────────────────────────┐ +│ Actor-Critic 架构 │ +│ │ +│ ┌─────────┐ ┌───────────┐ │ +│ │ Actor │ │ Critic │ │ +│ │ (策略网络)│ │(价值网络) │ │ +│ │ │ │ │ │ +│ │ 输入：状态│ │ 输入：状态│ │ +│ │ 输出：动作│ │ 输出：V(s)│ │ +│ └─────────┘ └───────────┘ │ +│ │ +│ Actor根据Critic的评估改进策略 │ +│ Critic学习更准确地评估状态价值 │ +└─────────────────────────────────┘ +``` + +- **Actor（演员）**：策略网络，负责选择动作 +- **Critic（评论家）**：价值网络，负责评估当前状态的好坏 + +Critic提供一个**基线（Baseline）**，使得梯度估计的方差大大降低。具体来说，使用**优势函数（Advantage Function）**： + +$$A(s, a) = Q(s, a) - V(s)$$ + +优势函数衡量的是"采取动作a比平均水平好多少"。如果A > 0，说明这个动作比期望的好，应该增加其概率；反之则降低。 + +## 6.2.3 PPO：近端策略优化 + +**PPO（Proximal Policy Optimization, 2017）** 是由OpenAI提出的一种策略优化算法，它通过限制策略更新的幅度来保证训练稳定性，成为当前最广泛使用的强化学习算法之一。 + +PPO的核心思想：每次更新策略时，新策略与旧策略不能相差太大。这通过**裁剪目标函数（Clipped Objective）** 实现： + +$$L^{CLIP}(\theta) = \mathbb{E}_t \left[ \min \left( r_t(\theta) \hat{A}_t, \; \text{clip}(r_t(\theta), 1-\epsilon, 1+\epsilon) \hat{A}_t \right) \right]$$ + +其中 r_t(θ) = π_θ(a_t|s_t) / π_θ_old(a_t|s_t) 是新旧策略的概率比。 + +```python +# PPO核心思路（简化版） +def ppo_update(states, actions, old_log_probs, returns, advantages): + for epoch in range(ppo_epochs): + # 计算新的log概率 + new_log_probs = policy.get_log_prob(states, actions) + ratio = torch.exp(new_log_probs - old_log_probs) + + # PPO裁剪目标 + surr1 = ratio * advantages + surr2 = torch.clamp(ratio, 1 - clip_epsilon, 1 + clip_epsilon) * advantages + actor_loss = -torch.min(surr1, surr2).mean() + + # Critic损失 + values = critic(states) + critic_loss = nn.MSELoss()(values, returns) + + # 总损失 + loss = actor_loss + 0.5 * critic_loss + optimizer.zero_grad() + loss.backward() + optimizer.step() +``` + +**为什么PPO成为标准？** + +| 特性 | 说明 | +|------|------| +| 稳定性 | 裁剪机制防止策略突变，训练过程平稳 | +| 简洁性 | 相比TRPO等算法，实现简单，超参数少 | +| 性能 | 在多种任务上表现优异 | +| 通用性 | 适用于连续和离散动作空间 | +| 可扩展性 | 是RLHF训练大语言模型的核心算法 | + +> **关键连接**：PPO正是ChatGPT等大语言模型在RLHF（人类反馈强化学习）阶段使用的核心算法。我们在6.4节将详细讨论这一过程。 + +## 6.2.4 A3C / A2C + +**A3C（Asynchronous Advantage Actor-Critic, 2016）** 是DeepMind提出的并行训练框架： + +- 多个Actor-Critic智能体同时在不同的环境副本中运行 +- 异步更新全局网络参数 +- 大幅提升训练速度和样本效率 + +**A2C（Advantage Actor-Critic）** 是A3C的同步版本，去掉了异步机制，实现更简洁，性能相当： + +``` +A3C: 多个Worker异步更新 → 参数可能冲突，但整体有效 +A2C: 多个Worker同步更新 → 等待所有Worker完成，再统一更新 +``` + +--- + +# 6.3 Alpha系列 + +从2016年开始，DeepMind的Alpha系列成果不断刷新人们对AI能力的认知。这些突破展示了一个共同的技术范式：**搜索 + 深度学习 + 海量计算**。 + +## 6.3.1 AlphaGo（2016） + +2016年3月，AlphaGo以4:1击败围棋世界冠军李世石，这是AI发展史上的里程碑事件。围棋的状态空间约为10^170，远超国际象棋（10^47），被普遍认为在短期内不可能被机器攻克。 + +AlphaGo的核心技术组合： + +**策略网络（Policy Network）**：学习"下一步应该下在哪里"，输入棋盘状态，输出每个位置落子的概率分布。 + +**价值网络（Value Network）**：学习"当前局面谁更可能赢"，输入棋盘状态，输出一个-1到1之间的胜率评估。 + +**蒙特卡洛树搜索（Monte Carlo Tree Search, MCTS）**：在策略网络的指导下进行前瞻搜索，通过模拟大量对局来评估每个候选落子点的价值。 + +``` +AlphaGo的训练流程： + +第一步：监督学习 + ← 人类专家棋谱 → 训练策略网络（预测人类落子） + +第二步：强化学习 + ← 策略网络自我对弈 → 提升策略网络 + +第三步：强化学习 + ← 自我对弈数据 → 训练价值网络（评估局面） + +第四步：实战 + ← 策略网络 + 价值网络 + MCTS → 与人类对弈 +``` + +AlphaGo的意义远超围棋本身。它证明了：**在极其复杂的决策空间中，深度学习与搜索的结合可以超越人类数千年的知识积累**。 + +## 6.3.2 AlphaZero（2017） + +如果说AlphaGo还需要人类棋谱作为起点，那么**AlphaZero**则完全抛弃了人类知识，仅通过**自我对弈（Self-Play）** 从零开始学习。 + +``` +AlphaGo : 人类棋谱 → 监督学习 → 强化学习 → MCTS +AlphaZero : 随机下棋 → 自我对弈 → 不断改进 → MCTS +``` + +AlphaZero用同一个框架掌握了三种完全不同的棋类： + +| 游戏 | 训练时间 | 成果 | +|------|---------|------| +| 围棋（Go） | 21天 | 击败此前的AlphaGo版本 | +| 国际象棋（Chess） | 4小时 | 击败Stockfish（世界冠军级引擎） | +| 将棋（Shogi） | 2小时 | 击败Elmo（日本将棋冠军程序） | + +AlphaZero的启示：**当我们摆脱对人类数据的依赖，让AI完全通过自我探索来学习时，它可能发现人类从未想到过的策略**。在对弈中，AlphaZero经常下出人类专家认为"错误"的棋，最终却证明是更优的选择。 + +## 6.3.3 AlphaFold（2020） + +**AlphaFold** 将强化学习的思想拓展到科学发现领域。它解决了困扰生物学界50年的**蛋白质结构预测**问题——根据氨基酸序列预测蛋白质的三维结构。 + +``` +蛋白质折叠问题： + +氨基酸序列（一维）→ ? → 蛋白质结构（三维） + +AlphaFold的思路： + - 将结构预测转化为"空间约束满足"问题 + - 利用注意力机制捕捉氨基酸之间的长程相互作用 + - 迭代优化，逐步精化结构预测 +``` + +AlphaFold的意义对设计领域尤其深远： + +- **分子/空间推理**：蛋白质折叠本质上是一个三维空间优化问题，与设计中的空间布局、形态优化有深刻的相似性 +- **从规则到预测**：从传统的物理实验方法转向数据驱动的预测方法，这与设计领域从经验到数据驱动的发展方向一致 +- **科学发现的范式**：展示了AI如何加速科学发现，为设计领域的创新提供了新思路 + +## 6.3.4 Alpha系列的技术范式 + +总结Alpha系列的成功模式： + +``` +┌──────────────────────────────────────────┐ +│ Alpha系列技术范式 │ +│ │ +│ ┌─────────┐ ┌──────────┐ ┌───────┐ │ +│ │ 搜索 │＋│ 深度学习 │＋│ 大计算 │ │ +│ │ (Search)│ │(Deep L.) │ │(Scale)│ │ +│ └─────────┘ └──────────┘ └───────┘ │ +│ │ +│ AlphaGo : MCTS + CNN + GPU集群 │ +│ AlphaZero : MCTS + ResNet + TPU集群 │ +│ AlphaFold : 优化器 + Transformer + TPU│ +└──────────────────────────────────────────┘ +``` + +这一范式对设计领域的启示：复杂的设计问题（如城市规划、建筑布局）也可能通过"搜索 + 深度学习 + 计算"的组合来获得突破。 + +> **从游戏AI到科学发现**：Alpha系列的演进轨迹——从游戏（封闭规则、明确目标）到蛋白质折叠（开放规则、复杂约束）——暗示了强化学习从"玩具问题"走向"真实世界问题"的趋势。设计领域正是这种真实世界问题的重要阵地。 + +--- + +# 6.4 人类对齐 + +## 6.4.1 为什么需要对齐？ + +经过预训练的大语言模型（如第3章所述）虽然拥有强大的文本生成能力，但它本质上是在模仿训练数据中的模式。这导致几个严重问题： + +- **有害内容**：可能生成歧视、暴力、虚假信息等有害内容 +- **不一致性**：对同一问题可能给出互相矛盾的答案 +- **不服从指令**：可能忽略用户的明确要求 +- **价值观偏差**：可能反映训练数据中的偏见 + +**对齐（Alignment）** 的目标是让AI模型的行为符合人类的价值观和期望，使其成为安全、有用、诚实的助手。而**RLHF（Reinforcement Learning from Human Feedback）** 是目前最成功的对齐方法。 + +> **回顾第3章**：在第3章中我们了解了Transformer架构和语言模型的预训练过程。预训练赋予模型"能力"，而RLHF赋予模型"方向"——让能力服务于人类的目标。 + +## 6.4.2 RLHF：从人类反馈中学习 + +RLHF分为三个阶段： + +**阶段一：监督微调（Supervised Fine-Tuning, SFT）** + +``` +输入-输出对示例： + 用户：请解释什么是气候变化 + 助手：气候变化是指全球气温长期上升的现象... + + 用户：帮我写一封请假邮件 + 助手：尊敬的领导，您好！因... +``` + +用高质量的人工编写对话数据对预训练模型进行微调，让模型学会以对话的形式回应指令。 + +**阶段二：奖励模型训练（Reward Model Training）** + +``` +对于同一个问题，模型生成多个回答： + 问题：推荐一本适合初学者的设计书 + + 回答A：《设计中的设计》——原研哉 ← 标注者排序：第1 + 回答B：我推荐你看一些设计类的书... ← 标注者排序：第3 + 回答C：原研哉的《设计中的设计》是... ← 标注者排序：第2 + +根据人类的排序偏好训练奖励模型： + 输入：(问题, 回答) → 输出：标量奖励分数 +``` + +奖励模型学习人类的偏好判断：给定一个问题和多个回答，它能预测人类更偏好哪个回答，并给出一个数值分数。 + +**阶段三：PPO强化学习优化** + +``` +┌─────────────────────────────────────────────────┐ +│ RLHF 第三阶段：PPO训练 │ +│ │ +│ ┌──────────┐ 生成回答 ┌──────────┐ │ +│ │ SFT模型 │ ────────> │ 奖励模型 │ → 奖励分 │ +│ │(待优化) │ │ │ │ +│ └──────────┘ └──────────┘ │ +│ ↑ │ +│ │ 更新策略（PPO） │ +│ │ 目标：最大化奖励模型给出的分数 │ +│ ┌──────────┐ │ +│ │ KL散度约束│ → 防止偏离SFT模型太远 │ +│ └──────────┘ │ +└─────────────────────────────────────────────────┘ +``` + +在这个阶段，SFT模型成为RL的智能体： +- **状态**：用户的问题 +- **动作**：生成的回答 +- **奖励**：奖励模型给出的分数 +- **算法**：PPO，保证训练的稳定性 + +同时，通过**KL散度惩罚（KL Divergence Penalty）** 约束模型不要偏离原始SFT模型太远，防止"奖励黑客（Reward Hacking）"——模型学会生成奖励模型给高分但实际无意义的内容。 + +```python +# RLHF第三阶段伪代码 +for step in range(training_steps): + # 1. 用当前策略（SFT模型）生成回答 + prompt = sample_prompt() + response = policy.generate(prompt) + + # 2. 奖励模型打分 + reward = reward_model(prompt, response) + + # 3. KL散度惩罚（防止偏离太远） + kl_penalty = compute_kl_divergence(policy, reference_model) + adjusted_reward = reward - kl_coef * kl_penalty + + # 4. PPO更新 + ppo_update(prompt, response, adjusted_reward) +``` + +## 6.4.3 RLAIF与Constitutional AI + +RLHF需要大量人工标注，成本高昂。**RLAIF（Reinforcement Learning from AI Feedback）** 用AI替代人类标注者来提供反馈： + +**Constitutional AI（宪法AI）** 由Anthropic提出，其核心思想是让AI通过一组"宪法原则"进行自我纠正： + +``` +Constitutional AI 流程： + +1. AI生成回答（可能包含有害内容） +2. AI根据宪法原则自我批评： + "这个回答是否尊重了所有人？" + "这个回答是否准确？" +3. AI根据批评修改回答 +4. 用(问题, 修改后回答)对训练偏好模型 +5. 用RL优化策略 + +宪法原则示例： + - 选择最无害且最有帮助的回答 + - 选择最准确和真实的回答 + - 选择最尊重所有群体的回答 +``` + +这种方法的优势在于：反馈的规模不再受限于人工标注的速度，可以大规模、高效率地进行对齐训练。 + +> **思考**：从RLHF到RLAIF，我们看到一个有趣的趋势——AI越来越多地参与自身的训练和改进。这在提高效率的同时也带来了新的安全问题：如何确保AI的自我评估是可靠的？ + +--- + +# 6.5 具身智能 + +## 6.5.1 什么是具身智能？ + +**具身智能（Embodied AI）** 是指拥有物理或虚拟"身体"的AI系统，它通过与真实或模拟环境的物理交互来学习和完成任务。 + +传统AI（如大语言模型）是一个"缸中之脑"——只有信息处理能力，没有物理交互。具身智能则强调**感知-决策-行动**的闭环： + +``` +┌───────────────────────────────────────────┐ +│ 具身智能闭环 │ +│ │ +│ 感知 (Perception) → 理解物理世界 │ +│ ↓ │ +│ 决策 (Decision) → 规划行动方案 │ +│ ↓ │ +│ 行动 (Action) → 执行物理操作 │ +│ ↓ │ +│ 反馈 (Feedback) → 观察行动结果 │ +│ ↓ │ +│ 感知 (Perception) → 更新世界模型 ... │ +└───────────────────────────────────────────┘ +``` + +强化学习是训练具身智能的核心方法：智能体通过在环境中不断尝试、接收奖励反馈来学习最优行为策略。 + +## 6.5.2 数字孪生 + +**数字孪生（Digital Twin）** 是连接物理世界和数字世界的桥梁： + +``` +物理世界 数字世界 +┌─────────┐ ┌─────────┐ +│ 真实建筑 │ ←映射→ │ 数字模型 │ +│ 真实城市 │ │ 仿真环境 │ +│ 真实设备 │ │ 虚拟副本 │ +└─────────┘ └─────────┘ + │ + 强化学习训练 + │ + ↓ 控制指令 ↓ + ┌─────────┐ + │ 物理世界 │ + │ 执行控制 │ + └─────────┘ +``` + +数字孪生为强化学习提供了安全、高效的训练环境。设计师可以在虚拟环境中测试各种方案，然后用最优方案指导物理世界的实施。 + +## 6.5.3 Gymnasium环境 + +**Gymnasium**（原OpenAI Gym）是强化学习的标准环境库，提供了丰富的测试环境： + +```python +import gymnasium as gym + +# 创建CartPole环境（经典平衡控制问题） +env = gym.make("CartPole-v1") + +# 基本交互循环 +observation, info = env.reset() +for step in range(1000): + # 选择动作（这里用随机策略） + action = env.action_space.sample() + + # 与环境交互 + observation, reward, terminated, truncated, info = env.step(action) + + # observation: [小车位置, 小车速度, 杆子角度, 杆子角速度] + # action: 0=向左推, 1=向右推 + # reward: 杆子保持直立的每一步得+1分 + + if terminated or truncated: + observation, info = env.reset() + +env.close() +``` + +Gymnasium中与设计相关的环境包括： + +| 环境 | 说明 | 设计关联 | +|------|------|---------| +| CartPole-v1 | 平衡控制 | 结构稳定性 | +| LunarLander-v2 | 月球着陆 | 着陆规划 | +| Ant/Humanoid | 机器人运动 | 人体工程学 | +| MuJoCo系列 | 物理仿真 | 材料与结构 | + +## 6.5.4 Sim2Real：从仿真到现实 + +强化学习在仿真环境中训练智能体，但仿真与真实世界之间存在**Sim2Real差距（Sim2Real Gap）**： + +``` +仿真环境 (Sim) 真实世界 (Real) +┌──────────────┐ ┌──────────────┐ +│ 完美的物理模型│ │ 复杂的摩擦力 │ +│ 确定的传感器 │ │ 噪声和延迟 │ +│ 可控的环境 │ │ 不可预测的变化 │ +│ 无限试错 │ │ 安全限制 │ +└──────────────┘ └──────────────┘ + ↕ Sim2Real Gap ↕ +``` + +缩小Sim2Real差距的主要方法： + +- **域随机化（Domain Randomization）**：在训练时随机改变仿真参数（摩擦力、光照、传感器噪声等），使策略对不同环境条件具有鲁棒性 +- **系统辨识（System Identification）**：从真实世界数据中学习更准确的仿真参数 +- **渐进迁移（Progressive Transfer）**：先在仿真中训练，再在真实环境中微调 + +## 6.5.5 具身智能的挑战与前景 + +当前面临的挑战： + +- **安全约束**：真实世界的错误可能导致物理损坏或人员伤害 +- **泛化能力**：训练环境中学会的策略能否适应未知的新环境 +- **样本效率**：机器人交互数据获取成本高，需要更高效的算法 +- **多模态融合**：整合视觉、触觉、听觉等多种感知信息 + +设计领域的应用前景： + +- **建筑施工机器人**：自动砌砖、3D打印建筑、无人驾驶施工车辆 +- **自主测量无人机**：自动巡检建筑工地、生成地形测绘 +- **智能材料实验**：机器人自动进行材料性能测试 +- **交互式设计原型**：具身智能体与设计方案的物理验证 + +--- + +# 6.6 设计应用 + +强化学习为设计领域提供了从"被动工具"到"主动智能体"的范式转变。以下是一些具有代表性的应用场景。 + +## 6.6.1 空间布局优化 + +将家具/房间布局问题建模为强化学习问题： + +``` +状态 (State)：当前布局方案 + - 家具的位置、朝向 + - 空间的几何约束 + - 功能区域划分 + +动作 (Action)：调整布局 + - 移动某件家具 + - 旋转某件家具 + - 交换两件家具的位置 + +奖励 (Reward)：布局质量评估 + + 功能合理性（动线通畅度） + + 美学指标（对称性、比例） + + 规范满足（消防通道、日照要求） + - 碰撞惩罚 + - 空间浪费惩罚 +``` + +与传统优化算法相比，强化学习方法的优势在于能够学习到布局的"风格"和"策略"，而不仅是找到单一最优解。 + +## 6.6.2 路径规划与导航 + +强化学习在自主导航中已有广泛应用，同样适用于设计空间中的路径规划： + +- **建筑内部导航**：优化紧急疏散路径 +- **景观游览路径**：自动生成最优游览路线 +- **施工物流规划**：建筑材料的自动运输路径 +- **城市交通信号优化**：根据实时车流动态调整信号灯 + +```python +# 城市交通信号优化概念示意 +class TrafficSignalEnv: + """交通信号控制强化学习环境""" + + def __init__(self, intersection): + self.intersection = intersection + # 状态：各方向车流量、等待时间、当前信号相位 + # 动作：切换信号相位（哪条路绿灯） + # 奖励：-（总等待时间 + 红灯通过惩罚） + + def step(self, action): + # 切换信号相位 + self.intersection.set_phase(action) + # 模拟一个时间步的交通流 + self.simulate_traffic() + # 计算奖励 + reward = -self.get_total_waiting_time() + return self.get_state(), reward, False, {} +``` + +## 6.6.3 自主设计智能体 + +将强化学习与生成模型结合，构建能够**自我改进的设计系统**： + +``` +设计智能体框架： + + 设计需求 ──→ 生成模型 ──→ 设计方案 + ↑ │ + │ ↓ + 策略改进 ←──── 设计评估 + (奖励信号) + │ + ↓ + 迭代优化 +``` + +这种框架下，设计智能体能够： +- 根据评估反馈自动调整设计参数 +- 在大量设计变体中搜索最优方案 +- 学习人类设计师的偏好和风格 + +## 6.6.4 建筑自动化 + +强化学习在建筑制造领域的应用： + +| 应用 | 状态 | 动作 | 奖励 | +|------|------|------|------| +| 砌砖机器人 | 当前砖墙状态 | 砖的放置位置和方式 | 墙体质量、效率 | +| 3D打印建筑 | 打印进度状态 | 打印路径、速度 | 结构强度、材料效率 | +| 无人施工车 | 工地地图 | 行驶路径、操作 | 任务完成度、安全性 | +| 塔吊自动化 | 吊载状态 | 运动轨迹 | 就位精度、时间效率 | + +## 6.6.5 城市系统优化 + +强化学习在城市规划和设计中的应用： + +- **交通流量优化**：多智能体强化学习协调全城交通信号 +- **能源管理**：建筑群能耗的动态优化 +- **供水系统**：管网压力和流量的智能调度 +- **垃圾回收路线**：根据实时数据动态规划回收路线 + +> **案例**：杭州城市大脑使用强化学习算法优化交通信号控制，在部分路段实现了15%的通行效率提升。这类应用展示了强化学习在城市设计中的巨大潜力。 + +--- + +## 思考与练习 + +1. **概念理解**：试比较监督学习、无监督学习和强化学习三种范式的区别。在什么场景下，强化学习比监督学习更适合？请结合设计领域的例子说明。 + +2. **算法思考**：RLHF的三个阶段（SFT → 奖励模型 → PPO优化）为什么缺一不可？如果跳过奖励模型阶段，直接用人工标注的分数进行PPO训练，会遇到什么问题？ + +3. **设计应用**：选择一个你熟悉的设计场景（如室内设计、城市规划、产品设计等），将其建模为一个强化学习问题。请定义：状态空间、动作空间、奖励函数，并分析这个建模方式的优缺点。 + +--- + +## 关键术语 + +| 中文术语 | 英文术语 | 缩写 | 简要说明 | +|---------|---------|------|---------| +| 强化学习 | Reinforcement Learning | RL | 通过与环境交互和反馈来学习决策的方法 | +| 智能体 | Agent | — | 能够感知环境并采取行动的实体 | +| 马尔可夫决策过程 | Markov Decision Process | MDP | 强化学习的数学框架，由(S,A,P,R,γ)定义 | +| 状态 | State | S | 环境在某一时刻的描述 | +| 动作 | Action | A | 智能体可采取的行为 | +| 奖励 | Reward | R | 环境对智能体行为的反馈信号 | +| 折扣因子 | Discount Factor | γ | 衡量未来奖励重要性的参数 | +| 价值函数 | Value Function | V(s) | 评估某状态的长期收益期望 | +| 动作价值函数 | Action Value Function | Q(s,a) | 评估在某状态下采取某动作的长期收益 | +| Q-Learning | Q-Learning | — | 经典的免模型强化学习算法 | +| 深度Q网络 | Deep Q-Network | DQN | 用神经网络近似Q函数的算法 | +| 策略梯度 | Policy Gradient | PG | 直接优化策略的强化学习方法 | +| 近端策略优化 | Proximal Policy Optimization | PPO | 限制策略更新幅度的稳定优化算法 | +| 人类反馈强化学习 | Reinforcement Learning from Human Feedback | RLHF | 利用人类偏好反馈训练AI的方法 | +| AI反馈强化学习 | Reinforcement Learning from AI Feedback | RLAIF | 利用AI生成的反馈进行训练 | +| 宪法AI | Constitutional AI | CAI | 通过原则进行自我纠正的对齐方法 | +| 具身智能 | Embodied AI | — | 具有物理/虚拟身体的AI系统 | +| 数字孪生 | Digital Twin | — | 物理实体的数字化映射 | +| 仿真到现实 | Sim2Real | — | 将仿真中训练的策略迁移到真实世界 | +| 蒙特卡洛树搜索 | Monte Carlo Tree Search | MCTS | 通过模拟评估决策树节点的搜索算法 | +| 自我对弈 | Self-Play | — | AI通过与自身对弈来提升能力的方法 | +| 探索与利用 | Exploration vs. Exploitation | — | 尝试新策略与使用已知最优策略的平衡 | +| 经验回放 | Experience Replay | — | 存储和复用历史交互数据的技术 | +| 对齐 | Alignment | — | 使AI行为符合人类价值观和期望的过程 | +| KL散度 | KL Divergence | KL | 衡量两个概率分布差异的指标 | diff --git a/07-generative-ai/07-generative-ai.md b/07-generative-ai/07-generative-ai.md new file mode 100644 index 0000000..db27142 --- /dev/null +++ b/07-generative-ai/07-generative-ai.md @@ -0,0 +1,496 @@ +# 第7章：生成式AI——从创造到智能生成 + +## 篇章导读 + +生成式AI（Generative AI）正在重新定义创造的边界。从图像生成到音乐创作，从文本写作到代码生成，AI不再仅仅是分析和识别的工具，而是成为人类的"创意伙伴"（Creative Partner）。设计师可以用文字描述一个想法，AI便能将其转化为可视化的图像；建筑师可以勾勒一个草图，AI便能渲染出逼真的效果图。这种从"分析"到"创造"的转变，正是生成式AI最激动人心的地方。 + +本章将从生成模型的基本原理出发，系统介绍从自编码器（AE）、对抗生成网络（GAN）到扩散模型（Diffusion Model）的技术演进，并深入探讨AIGC工具链在设计领域的实际应用。 + +--- + +## 7.1 早期生成模型 + +### 7.1.1 自编码器（Autoencoder, AE） + +自编码器是最早的生成模型思想之一，其核心理念是**学习数据的压缩表示**。 + +**基本结构：** + +``` +输入 → 编码器 (Encoder) → 潜在表示 (Latent) → 解码器 (Decoder) → 重构输出 +``` + +自编码器的工作方式可以理解为"先压缩，再还原"：编码器将输入数据压缩到一个低维的潜在空间（Latent Space），解码器再从潜在表示中还原出原始数据。通过训练使还原输出尽可能接近原始输入，模型便学会了数据的关键特征。 + +**局限性：** + +- 生成的图像通常**模糊**，缺乏细节 +- 潜在空间缺乏结构，无法保证连续采样产生有意义的输出 +- 生成**多样性不足**，更偏向重构而非创造 + +> **设计类比**：AE就像一位只会临摹的画师——他能把看到的景象画出来，但画得不够精细，也无法凭空创造出新的画面。 + +### 7.1.2 变分自编码器（Variational Autoencoder, VAE） + +VAE在AE的基础上引入了**概率思想**，是生成模型的重要进步。 + +**核心改进：** + +``` +传统AE： 编码器 → 确定的潜在向量 z → 解码器 +VAE： 编码器 → 均值 μ、方差 σ → 采样 z ~ N(μ, σ²) → 解码器 +``` + +VAE的关键在于将潜在空间约束为**标准正态分布**。这意味着潜在空间中的每个点都对应一个合理的输出，我们可以通过从正态分布中随机采样，再经过解码器，来**生成全新的图像**。 + +``` +从标准正态分布中随机采样 z + ↓ +解码器 (Decoder) + ↓ +生成全新图像 +``` + +**优势与不足：** + +| 特性 | AE | VAE | +| --- | --- | --- | +| 潜在空间 | 无约束 | 标准正态分布 | +| 可采样性 | 不可 | 可采样生成新图像 | +| 生成质量 | 模糊 | 略好但仍偏模糊 | +| 多样性 | 低 | 较高 | + +> **设计类比**：VAE就像一位理解了"风格空间"的画师——他不仅会临摹，还能在"风格空间"中探索，画出从未见过但风格一致的新作品。 + +--- + +## 7.2 对抗生成 + +### 7.2.1 生成对抗网络（GAN） + +2014年，Ian Goodfellow提出了生成对抗网络（Generative Adversarial Network, GAN），开创了生成模型的新范式。 + +**核心思想：对抗博弈** + +``` +生成器 (Generator)：生成假图像 → 试图欺骗判别器 +判别器 (Discriminator)：判断图像真假 → 试图识破生成器 + ↓ +对抗训练，相互博弈，共同进步 +``` + +GAN的训练过程可以类比为**伪造者与鉴定师**的博弈： + +- **伪造者**（生成器）不断改进伪造技术，制造更逼真的假画 +- **鉴定师**（判别器）不断提升辨别能力，区分真画和假画 +- 随着对抗的持续，伪造者的技术越来越高超，最终能制造出连鉴定师都无法分辨的"杰作" + +**训练过程：** + +``` +步骤1：生成器从随机噪声生成假图像 +步骤2：判别器同时接收真实图像和假图像 +步骤3：判别器输出"真"或"假"的判断 +步骤4：根据判别结果，同时更新生成器和判别器 +步骤5：重复以上过程，直到生成器能产生逼真图像 +``` + +**优势：** + +- 生成图像质量高，细节丰富 +- 训练速度较快（相比扩散模型） + +**问题：** + +- **训练不稳定**：生成器和判别器需要精心平衡，容易出现一方过强 +- **模式崩溃（Mode Collapse）**：生成器可能只学会生成少数几种图像，缺乏多样性 +- 超参数敏感，调参困难 + +### 7.2.2 StyleGAN：高质量人脸生成 + +StyleGAN是NVIDIA推出的系列模型，在人脸生成领域取得了突破性成果。 + +**核心创新——风格控制：** + +``` +随机噪声 z → 映射网络 → 风格向量 w + ↓ +风格向量 w 注入生成器的不同层： + - 浅层：控制粗粒度特征（脸型、姿态） + - 中层：控制中粒度特征（发型、表情） + - 深层：控制细粒度特征（肤色、细节） + ↓ +生成高质量人脸图像 +``` + +StyleGAN可以精确控制生成人脸的各个属性——年龄、性别、发型、表情等，并且生成的人脸在视觉上与真人照片几乎无法区分。 + +### 7.2.3 CycleGAN：无配对图像转换 + +CycleGAN解决了一个重要的实际问题：**无需成对训练数据**的图像风格转换。 + +``` +领域A（如：照片）←→ 领域B（如：油画） + ↓ +生成器G：A → B（照片变油画） +生成器F：B → A（油画变照片） + ↓ +循环一致性约束：F(G(A)) ≈ A +``` + +CycleGAN的设计应用十分广泛：实景照片转水彩风格、白天场景转夜晚、夏季景观转冬季等。 + +> **设计思考**：GAN系列模型展示了"对抗"这一全新的训练范式——不是告诉模型"正确答案是什么"，而是让两个模型在竞争中共同进化。这种思想在设计领域同样适用：方案生成与方案评审的对抗，可以推动设计质量的提升。 + +--- + +## 7.3 扩散模型 + +### 7.3.1 核心原理 + +扩散模型（Diffusion Model）是当前生成式AI的主流技术，其核心思想出人意料地简洁：**先学会如何破坏，再学会如何修复**。 + +**前向过程（Forward Process）——逐步加噪：** + +``` +原始图像 x₀ + ↓ 添加高斯噪声 +x₁ = √(1-β₁)·x₀ + √β₁·ε₁ + ↓ 添加噪声 +x₂ = √(1-β₂)·x₁ + √β₂·ε₂ + ↓ ...（重复T步） +x_T ≈ 纯噪声（与原始图像完全无关） +``` + +前向过程就像往一幅画上逐步泼洒墨水，每一步都让画面变得更模糊，最终变成完全的噪声。 + +**反向过程（Reverse Process）——逐步去噪：** + +``` +纯噪声 x_T + ↓ 去噪网络预测并移除噪声 +x_{T-1} = 去噪一步 + ↓ 去噪网络预测并移除噪声 +x_{T-2} = 去噪一步 + ↓ ...（重复T步） +x₀ ≈ 原始图像 +``` + +反向过程则像一位技艺精湛的修复师，从一团混沌的噪声中，逐步还原出清晰的图像。 + +**训练目标：** + +``` +去噪网络学习预测：添加的噪声 ε + 即：给定 noisy image x_t 和时间步 t，预测 ε + 损失函数：L = ||ε - ε_θ(x_t, t)||² +``` + +模型不需要学习"好图像长什么样"，而是学习"噪声长什么样"——这是一个更容易学习的目标。 + +### 7.3.2 Stable Diffusion架构 + +Stable Diffusion是扩散模型最重要的工程实现，其核心创新是**在潜在空间（Latent Space）中进行扩散**，而非直接在像素空间操作，从而大幅提升了效率。 + +**整体架构：** + +``` +文本提示 "一只猫，水彩画风格" + ↓ +Text Encoder (CLIP文本编码器) → 文本特征向量 + ↓ +随机噪声（在潜在空间中） + ↓ +U-Net 去噪网络（条件引导：文本特征） + ↓ 反复去噪T步 +去噪后的潜在表示 + ↓ +VAE Decoder (解码器) + ↓ +生成图像 +``` + +**核心组件：** + +| 组件 | 作用 | 说明 | +| --- | --- | --- | +| VAE Encoder/Decoder | 图像与潜在空间的转换 | 将高维图像压缩到低维潜在空间，提升效率 | +| U-Net | 去噪网络 | 核心生成引擎，预测并移除噪声 | +| Text Encoder (CLIP) | 文本编码 | 将文本提示转化为模型可理解的特征向量 | +| CLIP | 文图对齐 | 确保生成的图像与文本描述语义一致 | + +**潜在空间扩散的优势：** + +- 在低维空间操作，**计算量大幅降低** +- 压缩过程自动去除冗余信息，保留语义关键特征 +- 使消费级显卡也能运行生成模型 + +### 7.3.3 文生图工作流（Text-to-Image Workflow） + +从文字到图像的完整流程： + +``` +1. 输入提示词（Prompt） + "一座现代风格的别墅，白色外墙，大面积落地窗，周围绿树环绕，日落光线" + +2. 文本编码 + Prompt → CLIP Text Encoder → 文本特征向量 + +3. 初始化噪声 + 在潜在空间中生成随机噪声 + +4. 去噪循环 + for t = T → 1: + 噪声图 → U-Net（条件：文本特征 + 时间步）→ 预测噪声 → 减去噪声 + +5. 解码输出 + 潜在表示 → VAE Decoder → 最终图像 +``` + +**提示词工程（Prompt Engineering）** 是影响生成质量的关键因素。一个好的提示词通常包含： + +- **主体描述**：画面核心内容 +- **风格指定**：如"水彩画""赛博朋克""极简主义" +- **质量修饰**：如"高清""细节丰富""4K" +- **光照氛围**：如"黄金时段光线""柔和阴影" + +> **设计类比**：文生图过程就像一位设计师根据客户的文字需求进行创作。提示词是"设计任务书"，CLIP编码器理解需求，U-Net是"设计师的大脑"，而VAE解码器将脑海中的概念转化为可见的图纸。 + +--- + +## 7.4 AIGC工具链 + +### 7.4.1 ControlNet：精确条件控制 + +纯文生图虽然强大，但设计师往往需要**精确控制**空间结构——这正是ControlNet解决的问题。 + +**核心原理：** + +``` +输入图像 → 提取结构条件（边缘/深度/姿态/分割） + ↓ +条件特征注入ControlNet + ↓ +ControlNet与主U-Net协同 + ↓ +输出：保持结构条件 + 应用风格 +``` + +**支持的典型条件类型：** + +| 条件类型 | 英文名 | 说明 | 设计应用 | +| --- | --- | --- | --- | +| Canny边缘 | Canny Edge | 检测图像轮廓 | 草图控制、线稿渲染 | +| 深度图 | Depth Map | 估计场景深度 | 空间关系控制 | +| 人体姿态 | OpenPose | 检测人体关键点 | 人物场景生成 | +| 法线图 | Normal Map | 表面法线方向 | 材质细节控制 | +| 语义分割 | Segmentation | 区域语义标注 | 功能区域控制 | + +**设计工作流示例：** + +``` +手绘草图 → Canny边缘提取 → ControlNet条件控制 → 精细效果图 +户型平面图 → 深度图提取 → ControlNet条件控制 → 三维透视渲染 +结构线稿 → 分割图提取 → ControlNet条件控制 → 风格化设计方案 +``` + +### 7.4.2 LoRA：高效微调 + +全量微调一个大模型需要巨大的计算资源，而LoRA（Low-Rank Adaptation，低秩适应）提供了一种**高效微调**方案。 + +**核心原理：** + +``` +原始权重矩阵 W（冻结不变，参数量 d×d） + + +低秩分解矩阵 ΔW = A × B（仅训练这部分） + A: d×r, B: r×d（r << d） + ↓ +新权重 = W + ΔW = W + A×B + ↓ +参数量从 d² 降低到 2×d×r（减少100-1000倍） +``` + +**LoRA的核心优势：** + +- 参数量减少**100-1000倍**，大幅降低训练成本 +- 训练速度快，个人电脑即可完成 +- 多个LoRA可灵活叠加组合 + +**应用方式：** + +``` +基础模型 + LoRA_A（建筑风格）= 建筑风格生成 +基础模型 + LoRA_B（室内风格）= 室内风格生成 +基础模型 + LoRA_A + LoRA_B = 混合风格生成 +``` + +设计师可以针对特定设计风格训练专属LoRA，如"新中式风格""日式极简风格"等，实现个性化的AI生成。 + +### 7.4.3 ComfyUI：模块化工作流 + +ComfyUI是一个基于**节点化（Node-based）** 的AIGC工作流平台，允许用户通过可视化连接来构建复杂的生成流程。 + +**核心特点：** + +``` +节点化连接 → 可视化流程 → 灵活定制 → 可复用分享 +``` + +**典型节点：** + +| 节点类型 | 功能 | +| --- | --- | +| Load Checkpoint | 加载基础模型 | +| CLIP Text Encode | 文本编码（正向/负向提示词） | +| KSampler | 采样去噪（控制步数、采样器类型等） | +| VAE Decode | 潜在空间解码为图像 | +| ControlNet Apply | 应用ControlNet条件控制 | +| LoRA Loader | 加载LoRA微调模型 | +| Save Image | 保存生成图像 | + +**典型工作流示例：** + +``` +文本提示词 → CLIP编码 → 正向提示 + ↓ +负向提示词 → CLIP编码 → 负向提示 ──→ KSampler ← ControlNet条件 + ↓ + VAE解码 + ↓ + 保存图像 +``` + +### 7.4.4 Midjourney：创意探索平台 + +Midjourney是一个面向创意的AI图像生成平台，以极高的审美质量和艺术表现力著称。 + +**特点：** + +- 操作简单，通过自然语言交互即可生成 +- 生成图像具有很高的艺术审美品质 +- 适合设计前期的**创意发散和灵感探索** +- 付费云服务，依赖网络连接 + +### 7.4.5 AIGC工具对比 + +| 工具 | 核心优势 | 适用场景 | 使用门槛 | 部署方式 | +| --- | --- | --- | --- | --- | +| Midjourney | 审美品质高、操作简单 | 创意探索、灵感发散 | 低 | 云端服务 | +| Stable Diffusion | 开源可控、本地运行 | 精细控制、批量生成 | 中 | 本地部署 | +| ControlNet | 精确结构控制 | 草图渲染、条件生成 | 中高 | 模块插件 | +| ComfyUI | 灵活工作流、可视化 | 复杂流程、定制需求 | 高 | 本地部署 | + +> **设计实践建议**：在设计流程的不同阶段，可以灵活选择不同工具。前期概念阶段用Midjourney快速探索创意方向，确定方向后用Stable Diffusion + ControlNet进行精确控制，用LoRA实现风格一致性，用ComfyUI构建自动化工作流。 + +--- + +## 7.5 设计应用 + +### 7.5.1 建筑设计：从草图到渲染 + +``` +手绘概念草图 + ↓ ControlNet (Canny边缘) + + 提示词："现代风格建筑，玻璃幕墙，自然光线" + ↓ +AI生成效果图 + ↓ LoRA风格微调 +多方案对比（3-5个方案） + ↓ +设计师选择与调整 +``` + +**应用价值：** + +- 快速将手绘概念转化为可视化效果图 +- 生成多个设计方案进行比选 +- 客户沟通效率大幅提升 + +### 7.5.2 室内设计：从平面到立体 + +``` +户型平面图 + ↓ ControlNet (Depth/Segmentation) + + 提示词："北欧风格客厅，浅色木地板，简约家具" + ↓ +三维空间效果图 + ↓ LoRA材质替换 +不同材质方案（木质/石材/金属） + ↓ +风格迁移 → 多风格方案 +``` + +### 7.5.3 平面设计：品牌视觉生成 + +``` +品牌关键词："科技感、绿色环保、信任感" + ↓ +AI生成Logo候选方案（多组） + ↓ +设计师筛选与调整 + ↓ +品牌视觉系统延展（名片、海报、包装） +``` + +### 7.5.4 综合案例：住宅客厅设计工作流 + +以下是一个完整的AI辅助住宅客厅设计工作流： + +``` +第1步：需求输入 + 客户需求："20㎡客厅，现代简约，预算3万元，朝南，适合家庭活动" + ↓ +第2步：AI生成多方案 + 方案A：开放式布局，浅色调，北欧简约 + 方案B：L型沙发布局，中性色调，日式风格 + 方案C：分区布局，暖色调，现代轻奢 + ↓ +第3步：用户选择与调整 + 客户选择方案B → "希望增加书房功能" + ↓ +第4步：AI迭代优化 + 基于反馈调整 → 融合阅读角功能 + ↓ +第5步：VR预览 + AI生成全景图 → VR沉浸式体验 + ↓ +第6步：最终确认 + 设计师微调 → 客户确认 → 施工图 +``` + +> **设计反思**：生成式AI极大地提升了设计效率，但它始终是**辅助工具**而非替代者。设计师的审美判断、空间理解、人文关怀——这些是AI无法取代的核心能力。AI的价值在于扩展设计师的创造力边界，而非取代设计师本身。 + +--- + +## 思考与练习 + +1. **原理理解**：Diffusion模型为什么比GAN训练更稳定？从训练目标的角度进行分析。 + +2. **技术对比**：对比AE、VAE、GAN和Diffusion四种生成模型，分析各自的优势和局限。在什么场景下你会选择哪种模型？ + +3. **工具应用**：如果你需要将一张手绘建筑草图转化为写实渲染图，请设计一个完整的AIGC工作流（包括使用的工具、条件和提示词策略）。 + +4. **设计实践**：选择一个室内空间，分别使用Midjourney和Stable Diffusion + ControlNet生成设计方案，对比两者的生成效果和可控性。 + +5. **伦理思考**：AI生成的设计作品，版权归属于谁？训练数据中使用了大量设计师的作品，这是否构成侵权？你如何看待这个问题？ + +--- + +## 关键术语 + +| 中文 | 英文 | 说明 | +| --- | --- | --- | +| 自编码器 | Autoencoder (AE) | 学习数据压缩与重构的模型 | +| 变分自编码器 | Variational Autoencoder (VAE) | 引入概率分布的自编码器，可采样生成 | +| 生成对抗网络 | Generative Adversarial Network (GAN) | 生成器与判别器对抗训练的生成模型 | +| 扩散模型 | Diffusion Model | 通过加噪-去噪过程生成数据的模型 | +| 去噪 | Denoising | 移除噪声、还原图像的过程 | +| 潜在空间 | Latent Space | 压缩后的低维数据表示空间 | +| 提示词 | Prompt | 指导AI生成的文本描述 | +| 条件控制 | Conditional Control (ControlNet) | 通过结构条件精确引导生成过程 | +| 低秩适应 | LoRA (Low-Rank Adaptation) | 低秩矩阵分解的高效微调方法 | +| 模式崩溃 | Mode Collapse | GAN生成多样性不足的现象 | +| 采样器 | Sampler | 去噪采样算法，决定生成过程的具体方式 | +| 文图对齐 | CLIP | 实现文本与图像语义对应的技术 | +| 提示词工程 | Prompt Engineering | 设计优化提示词以提升生成质量的技术 | diff --git a/08-agent/08-agent.md b/08-agent/08-agent.md new file mode 100644 index 0000000..ba652a7 --- /dev/null +++ b/08-agent/08-agent.md @@ -0,0 +1,581 @@ +# 第8章：AI Agent——从执行到自主 + +## 篇章导读 + +AI Agent（智能体）代表了人工智能的下一个前沿：从"被动响应"到"主动行动"，从"单一能力"到"系统协同"。如果说前几章介绍的AI模型是"工具"，那么AI Agent就是能**自主使用工具的助手**。 + +想象这样一幅场景：你告诉AI"帮我分析这块场地的开发潜力"，它不再只是被动地等待你一步步指令，而是主动调用地图工具获取地块信息、查询规划数据库核对用地性质、分析日照和交通数据、最终生成一份完整的场地分析报告。这就是AI Agent——一个能感知环境、制定计划、调用工具并持续改进的智能系统。 + +本章将从规则系统出发，系统介绍LLM-based Agent的架构、推理模式、多Agent协作机制，以及在设计领域的应用前景。 + +--- + +## 8.1 从规则到智能 + +### 8.1.1 规则系统时代 + +最早的"智能系统"基于**规则（Rules）**，即"如果满足条件A，则执行动作B"。 + +**典型结构：** + +``` +if 场地坡度 > 25%: + 标记为"不适宜建设" +elif 场地坡度 > 15%: + 标记为"限制建设区" +else: + 标记为"适宜建设" +``` + +**专家系统（Expert System）** 是这一范式的代表：将领域专家的知识编码为大量if-then规则，构建知识库，通过推理引擎进行逻辑推断。 + +**局限性：** + +- 规则难以穷举——现实世界的问题远比预想的复杂 +- 无法泛化——遇到规则未覆盖的新情况便束手无策 +- 维护困难——规则数量膨胀后，系统变得难以理解和更新 +- 缺乏理解——系统并不"理解"规则背后的含义，只是机械执行 + +### 8.1.2 传统规划方法 + +在规则系统之外，符号AI（Symbolic AI）还发展出了**规划（Planning）** 方法： + +``` +定义初始状态 → 定义目标状态 → 定义操作算子 → 搜索路径 → 执行计划 +``` + +这类方法在限定领域内效果良好（如国际象棋、路径规划），但面对开放、模糊的现实设计任务时，往往难以定义完整的状态空间和操作算子。 + +### 8.1.3 LLM带来的范式转变 + +大语言模型（LLM, Large Language Model）的出现，为Agent的发展带来了根本性的转变： + +| 特性 | 规则系统 | LLM-based Agent | +| --- | --- | --- | +| 知识表示 | 人工编写规则 | 从海量数据中学习 | +| 理解能力 | 无真正理解 | 深度语义理解 | +| 泛化能力 | 仅限规则覆盖范围 | 可处理未见过的任务 | +| 交互方式 | 结构化输入 | 自然语言对话 | +| 推理能力 | 逻辑推理 | 逻辑+常识+类比推理 | + +LLM之所以能成为Agent的"大脑"，关键在于它具备了： + +- **语义理解**：理解用户的真实意图，而非仅仅匹配关键词 +- **常识推理**：运用大量世界知识进行合理推断 +- **指令遵循**：按照复杂的指令序列执行任务 +- **工具学习**：通过描述快速学会使用新工具 + +--- + +## 8.2 LLM-based Agent + +### 8.2.1 核心组件 + +一个完整的LLM-based Agent由以下核心模块构成： + +``` +┌─────────────────────────────────────────────────┐ +│ LLM Core │ +│ （大语言模型：推理、决策中枢） │ +├─────────────────────────────────────────────────┤ +│ │ +│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ +│ │ 感知 │ │ 记忆 │ │ 工具 │ │ +│ │Perception│ │ Memory │ │ Tool Use │ │ +│ └──────────┘ └──────────┘ └──────────┘ │ +│ │ +│ ┌──────────┐ ┌──────────┐ │ +│ │ 规划 │ │ 反思 │ │ +│ │ Planning │ │Reflection│ │ +│ └──────────┘ └──────────┘ │ +│ │ +└─────────────────────────────────────────────────┘ +``` + +### 8.2.2 感知（Perception） + +感知模块负责**接收和理解外部信息**： + +``` +输入信息 → 解析与理解 + - 用户指令："帮我设计一个小型社区公园" + - 环境状态：场地数据、周边条件、限制因素 + - 工具反馈：查询结果、执行状态、错误信息 +``` + +感知的关键在于**理解意图**——用户说"设计一个公园"，Agent需要理解这涉及场地分析、功能分区、路径规划、植物配置等多个子任务。 + +### 8.2.3 规划（Planning） + +规划模块负责**将复杂目标分解为可执行的步骤**： + +``` +目标："设计一个社区公园" + ↓ 分解 +子任务1：分析场地条件（地形、面积、周边环境） +子任务2：确定功能分区（儿童游乐、健身、休憩、绿化） +子任务3：布局路径系统（主入口、环线、无障碍通道） +子任务4：选择植物配置（适地适树、四季景观） +子任务5：评估与优化（成本、可达性、景观效果） + ↓ +确定执行顺序和依赖关系 +``` + +### 8.2.4 记忆（Memory） + +记忆模块为Agent提供**信息存储和检索**能力： + +``` +┌─────────────────────────────────────────┐ +│ 短期记忆 (Short-term Memory) │ +│ 对话上下文、当前任务状态、临时变量 │ +│ 特点：容量有限，任务结束后清除 │ +├─────────────────────────────────────────┤ +│ 长期记忆 (Long-term Memory) │ +│ 知识库、经验积累、历史案例 │ +│ 特点：持久存储，可跨任务复用 │ +└─────────────────────────────────────────┘ +``` + +**记忆的常见实现方式：** + +| 类型 | 实现方式 | 说明 | +| --- | --- | --- | +| 短期记忆 | 上下文窗口（Context Window） | 当前对话的历史记录 | +| 工作记忆 | 划痕板（Scratchpad） | 中间计算结果和推理过程 | +| 长期记忆 | 向量数据库（Vector Database） | 嵌入式检索相关知识 | +| 程序性记忆 | 工具库（Tool Library） | 已学会的工具使用方法 | + +### 8.2.5 工具调用（Tool Use） + +工具调用是Agent与外部世界交互的关键能力： + +``` +可用工具集： + - 数据库查询：查询规划规范、用地数据 + - GIS工具：获取地形、高程、坡度信息 + - API调用：获取天气数据、交通数据 + - 代码执行：运行计算脚本、数据处理 + - 图像生成：调用Stable Diffusion等生成模型 + - 文件操作：读取CAD图纸、导出PDF报告 +``` + +Agent的核心能力在于根据任务需要**自主选择和组合工具**，而非按预设流程机械调用。 + +--- + +## 8.3 推理模式 + +### 8.3.1 思维链（Chain of Thought, CoT） + +CoT是最基础的推理增强技术，核心思想是**将推理过程显式化**。 + +**基本模式：** + +``` +问题 → 推理链（一步步思考） → 答案 +``` + +**设计示例——"设计一个公园"：** + +``` +问题："在3000㎡的社区用地上设计一个公园" + +推理链： +Step 1：分析场地条件 + → 场地面积3000㎡，属于中小型社区公园 + → 需要满足不同年龄段的休闲需求 + +Step 2：确定功能分区 + → 儿童活动区（约600㎡）：滑梯、沙坑、秋千 + → 健身运动区（约500㎡）：器材、慢跑道 + → 休闲游憩区（约800㎡）：座椅、凉亭、景观小品 + → 绿化种植区（约1100㎡）：草坪、花境、乔木 + +Step 3：布局路径系统 + → 主入口连接城市道路 + → 环形主路串联各功能区 + → 次级步道提供更丰富的游线体验 + +Step 4：选择植物配置 + → 选用本地适生树种 + → 考虑四季景观变化 + → 兼顾遮阴和观赏需求 + +答案：完整的公园设计方案 +``` + +CoT的价值在于**让思考过程可见**，这不仅提升了推理的准确性，也使结果更具可解释性。 + +### 8.3.2 ReAct（Reasoning + Acting） + +ReAct模式将**推理与行动交替进行**，形成"思考-行动-观察"的循环。 + +**基本循环：** + +``` +Think（思考）：分析当前状态，决定下一步行动 + ↓ +Act（行动）：调用工具或执行操作 + ↓ +Observe（观察）：获取行动结果和反馈 + ↓ +Think（思考）：基于观察结果，决定下一步行动 + ↓ +...（循环直到任务完成） +``` + +**设计示例——场地分析任务：** + +``` +Think：用户要求分析这块场地的开发潜力，我需要先获取基本信息。 +Act：调用GIS工具，获取场地位置和高程数据。 +Observe：场地位于北纬31.2°，东经121.5°，平均高程12m，最大高差3m。 + +Think：地形比较平坦，适合建设。接下来需要查询规划限制。 +Act：调用规划数据库，查询该地块的用地性质和容积率限制。 +Observe：用地性质为R2（二类居住用地），容积率≤2.5，建筑限高60m。 + +Think：用地性质和开发强度明确。现在分析日照和交通条件。 +Act：调用日照分析工具和交通数据API。 +Observe：南侧无遮挡，日照充足。距地铁站800m，公交站200m。 + +Think：所有关键数据已获取，可以生成分析报告了。 +Act：整合信息，生成场地开发潜力评估报告。 +Observe：报告已生成，包含地形、规划、日照、交通四维分析。 + +Think：任务完成，向用户展示报告。 +``` + +ReAct模式的优势在于**可以根据中间结果动态调整策略**，而非严格按照预设流程执行。 + +### 8.3.3 反思（Reflection） + +反思机制使Agent能够**自我评估和改进**： + +``` +执行任务 → 评估结果 → 发现不足 → 调整策略 → 重新执行 +``` + +**示例：** + +``` +第1轮：Agent生成设计方案A +反思：方案A的路径系统不够流畅，存在多个死角 +调整：优化路径拓扑结构，增加环路设计 + +第2轮：Agent生成改进方案B +反思：方案B的绿化率偏低，不满足规范要求 +调整：增加绿化面积，调整硬质铺装比例 + +第3轮：Agent生成最终方案C +评估：满足所有约束条件，方案质量达标 +输出：最终方案 +``` + +--- + +## 8.4 多Agent协作 + +### 8.4.1 单Agent架构 + +单Agent适合**相对简单的任务**： + +``` +用户请求 → 单一Agent（LLM + 工具） → 执行结果 +``` + +当任务复杂度增加时，单个Agent面临挑战： + +- 上下文窗口有限，难以处理大量信息 +- 同时扮演多个角色，专业性不足 +- 错误容易累积，缺乏交叉验证 + +### 8.4.2 多Agent协作 + +多Agent系统通过**分工协作**解决复杂任务： + +``` +┌───────────┐ ┌───────────┐ ┌───────────┐ +│ 规划Agent │ → │ 分析Agent │ → │ 设计Agent │ +│ Planner │ │ Analyst │ │ Designer │ +└───────────┘ └───────────┘ └───────────┘ + ↓ ↓ ↓ + 任务分解 数据分析 方案生成 +``` + +**各Agent的职责分工：** + +| Agent角色 | 职责 | 使用工具 | +| --- | --- | --- | +| 规划Agent (Planner) | 理解需求、分解任务、协调进度 | 任务管理、调度工具 | +| 分析Agent (Analyst) | 场地分析、数据收集、条件评估 | GIS工具、数据库查询、统计分析 | +| 设计Agent (Designer) | 方案生成、空间布局、效果渲染 | CAD工具、生成模型、设计规范库 | +| 审查Agent (Reviewer) | 合规检查、质量评估、问题标记 | 规范数据库、检查规则 | + +### 8.4.3 Agent通信模式 + +多Agent之间的通信是协作的关键： + +``` +模式1：顺序传递（Pipeline） + Agent_A → Agent_B → Agent_C → 最终结果 + +模式2：讨论协商（Debate） + Agent_A ← 讨论 → Agent_B + ↓ 达成共识 + 最终方案 + +模式3：层级管理（Hierarchical） + 管理Agent → 分配任务给多个子Agent → 汇总结果 + +模式4：群体协作（Group Chat） + 多个Agent在同一"讨论组"中协作 + 各自贡献专业能力，共同解决问题 +``` + +### 8.4.4 新兴Agent社会 + +随着Agent技术的发展，正在出现更复杂的协作形态： + +- **Agent团队**：多个Agent组成固定团队，各有专长 +- **Agent市场**：Agent可以"雇佣"其他Agent完成特定子任务 +- **Agent社会**：大量Agent在开放环境中自主交互和协作 + +> **设计思考**：多Agent协作模式与设计团队的工作方式高度相似——项目总负责人协调各专业（规划、建筑、结构、景观），各专业设计师各司其职又相互配合。AI Agent系统的设计可以从现实设计团队的协作经验中汲取灵感。 + +--- + +## 8.5 协作与协议 + +### 8.5.1 MCP协议（Model Context Protocol） + +**MCP（模型上下文协议）** 是连接AI模型与外部工具和数据的开放标准。 + +**核心问题：数据孤岛** + +``` +传统方式： + AI模型A → 只能访问数据源X + AI模型B → 只能访问数据源Y + AI模型C → 只能访问数据源Z + → 数据孤岛，工具碎片化 + +MCP方式： + AI模型 ← MCP统一接口 → 所有工具和数据源 + → 标准化连接，即插即用 +``` + +**MCP架构：** + +``` +┌────────────────────────────────────────────┐ +│ AI Application │ +│ （Claude、ChatGPT、自定义应用等） │ +└──────────────────┬─────────────────────────┘ + │ MCP协议 +┌──────────────────┴─────────────────────────┐ +│ MCP Client（客户端） │ +├────────────────────────────────────────────┤ +│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ +│ │ 文件系统 │ │ 数据库 │ │ API服务 │ │ +│ │ Server │ │ Server │ │ Server │ │ +│ └──────────┘ └──────────┘ └──────────┘ │ +│ ┌──────────┐ ┌──────────┐ │ +│ │ GIS工具 │ │ 设计软件 │ ...更多工具 │ +│ │ Server │ │ Server │ │ +│ └──────────┘ └──────────┘ │ +└────────────────────────────────────────────┘ +``` + +**MCP的核心价值：** + +- **标准化**：统一接口协议，不同工具无需逐一适配 +- **即插即用**：新增工具只需实现MCP接口即可接入 +- **安全可控**：权限管理、审计日志、访问控制 +- **生态开放**：社区可贡献各类MCP Server + +### 8.5.2 HITL：人在回路（Human-in-the-Loop） + +**HITL（Human-in-the-Loop）** 是在AI决策的关键环节引入人类干预的协作模式。 + +**HITL的层次：** + +| 层次 | 人类角色 | 自动化程度 | 适用场景 | +| --- | --- | --- | --- | +| 完全自动 | 无干预 | 100% | 低风险、标准化任务 | +| 人工审核 | 监督者 | 80-90% | 常规任务，抽查关键节点 | +| 交互决策 | 合作伙伴 | 50-70% | 复杂设计，人机共创 | +| 人工主导 | 操作者 | <50% | 高风险、创新性任务 | + +**设计中的HITL工作流：** + +``` +阶段1：需求输入 + 设计师 → 描述设计需求 → AI理解 + ↓ +阶段2：AI生成 + AI → 生成多个候选方案 → 呈现给设计师 + ↓ +阶段3：设计师审核 + 设计师 → 评估方案 → 提出修改意见 + ↓ +阶段4：AI调整 + AI → 基于反馈迭代优化 → 再次呈现 + ↓ +阶段5：最终确认 + 设计师 → 确认最终方案 → AI输出成果 +``` + +> **设计实践原则**：AI负责快速的方案生成和数据分析，设计师负责审美判断、人文考量和最终决策。HITL不是在降低效率，而是在确保质量——让机器做机器擅长的事，让设计师专注于真正需要人类智慧的部分。 + +--- + +## 8.6 设计应用与展望 + +### 8.6.1 场景分析Agent + +**输入：** 场地基础数据（位置、面积、周边环境） + +**分析流程：** + +``` +Step 1：地形分析 → 调用GIS工具 → 获取坡度、高程、排水方向 +Step 2：气候分析 → 调用气象数据API → 获取日照、风向、降雨 +Step 3：交通分析 → 调用地图API → 获取可达性、公共交通覆盖 +Step 4：视觉分析 → 调用视域分析工具 → 获取景观视野、视廊 +Step 5：法规分析 → 查询规划数据库 → 获取用地限制、退让要求 + ↓ +输出：场地综合分析报告（数据、图表、建议） +``` + +### 8.6.2 设计生成Agent + +**输入：** 设计需求 + 场地分析报告 + +**生成流程：** + +``` +Step 1：理解需求（CoT推理） + → 解析功能要求、风格偏好、预算约束 +Step 2：功能布局（调用空间规划工具） + → 基于场地条件和需求，生成功能分区方案 +Step 3：路径连接（调用图算法） + → 设计交通流线，连接各功能区域 +Step 4：效果渲染（调用生成模型） + → 将布局方案转化为可视化效果图 + ↓ +输出：初步设计方案（图纸、效果图、说明） +``` + +### 8.6.3 合规审查Agent + +**输入：** 设计方案 + +**审查流程：** + +``` +Step 1：调用规范库 → 获取适用的规划条文和建筑规范 +Step 2：逐条核对 → 对比设计方案与规范要求 +Step 3：标记问题 → 高亮不符合项，标注具体条款 +Step 4：生成报告 → 输出合规审查意见，含修改建议 + ↓ +输出：合规审查报告 +``` + +### 8.6.4 多Agent协同设计流程 + +三个Agent协同工作的完整流程： + +``` +场景分析Agent 设计生成Agent + ↓ ↓ +场地综合分析报告 ────────→ 需求+分析→设计方案 + ↓ + 合规审查Agent + ↓ + 审查报告+修改建议 + ↓ + 设计生成Agent（迭代优化） + ↓ + 最终设计方案（设计师确认） +``` + +### 8.6.5 未来展望 + +AI在设计领域的角色将经历三个阶段的演进： + +**短期（1-2年）：AI作为工具** + +``` +AI辅助能力： + - 数据分析与可视化 + - 快速方案生成（基于模板和规则） + - 合规自动化检查 + - 文档自动生成 + +设计师角色：主导者，AI是高效的辅助工具 +``` + +**中期（3-5年）：AI作为助手** + +``` +AI增强能力： + - 创意发散与灵感推荐 + - 多方案自动优化与比选 + - 设计文档智能撰写 + - 实时协作与迭代反馈 + +设计师角色：导演者，AI是得力的智能助手 +``` + +**长期（5-10年）：AI作为合作伙伴** + +``` +AI协作能力： + - 与设计师共同创造 + - 自主处理复杂设计任务 + - 专业评审与质量把控 + - 跨领域知识融合与创新 + +设计师角色：战略决策者，AI是平等的创造伙伴 +``` + +> **核心观点**：无论技术如何演进，设计的核心——对人需求的理解、对美的追求、对社会和环境的责任——始终需要人类设计师的参与。AI Agent的发展方向不是取代设计师，而是让设计师从重复性劳动中解放出来，专注于更有创造性和价值的工作。 + +--- + +## 思考与练习 + +1. **架构理解**：LLM-based Agent与传统规则系统相比，有哪些本质性的优势？又可能引入哪些新的风险？ + +2. **推理模式**：CoT和ReAct各适用于什么场景？请分别举一个设计领域的应用案例。 + +3. **多Agent设计**：如果要设计一个"城市规划审批Agent系统"，你会设计哪些Agent角色？它们之间如何协作？ + +4. **HITL实践**：在设计流程中，哪些环节应该由AI自动完成，哪些环节必须保留人工审核？请给出你的判断依据。 + +5. **MCP理解**：MCP协议如何解决设计领域AI应用的"数据孤岛"问题？以一个具体的建筑设计场景为例进行说明。 + +6. **未来展望**：你认为AI Agent在未来10年会如何改变设计行业的就业结构？设计师应该如何准备？ + +--- + +## 关键术语 + +| 中文 | 英文 | 说明 | +| --- | --- | --- | +| 智能体 | Agent | 能感知环境并自主行动的AI系统 | +| 感知 | Perception | 接收和理解外部信息的能力 | +| 规划 | Planning | 将目标分解为可执行步骤的能力 | +| 记忆 | Memory | 存储和检索信息的能力（短期+长期） | +| 工具调用 | Tool Use | 调用外部工具和API的能力 | +| 思维链 | Chain of Thought (CoT) | 将推理过程显式化的技术 | +| 推理与行动 | ReAct | 交替进行思考和行动的推理模式 | +| 反思 | Reflection | 自我评估与改进的机制 | +| 多Agent协作 | Multi-Agent Collaboration | 多个Agent分工协作解决复杂任务 | +| 模型上下文协议 | MCP (Model Context Protocol) | 连接AI与外部工具/数据的开放标准 | +| 人在回路 | HITL (Human-in-the-Loop) | 在AI关键决策环节引入人类干预 | +| 数据孤岛 | Data Silo | 各系统独立存储数据、互不连通的问题 | +| 专家系统 | Expert System | 基于规则的早期AI系统 | +| 上下文窗口 | Context Window | LLM一次能处理的最大文本长度 |