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