# 第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 原始论文
