pengxiao/2026_DesignAI
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects 1 Releases Wiki Activity
Files
de7a47db9d06f9448285fb6d632f7223af57094e
2026_DesignAI/officefile/03-1d-sequence/03-1d-sequence.md
T
pengxiao c81cf83c13 feat(latex): 新增 LaTeX 排版系统，从 Markdown 生成 ctexbook 
- 新增 officefile/latex/ 目录，包含 main.tex、preamble.tex 及 14 个章节 + 10 个附录 tex 文件
- md→tex 转换流程：pandoc 转换 + _postprocess.py 后处理（去编号、修破折号、清标签）
- 修复 5 个 md 源文件的标题层级（H1→H2 降级，统一层级结构）
- 配置 VS Code LaTeX Workshop（xelatex + ctexbook 编译链）
- 新增 VS Code workspace 和 .gitignore（排除 LaTeX 编译产物）

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
2026-05-29 12:21:15 +08:00

1596 lines
56 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# 第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 原始论文
Reference in New Issue View Git Blame Copy Permalink