生成式检索将文档检索问题转化为序列生成任务，这使得解码策略的选择变得至关重要。与传统检索方法的简单排序不同，生成式方法需要在庞大的文档ID空间中进行高效且准确的序列生成。本章深入探讨各种解码策略，从约束解码到高级的非自回归方法，以及如何在保持检索质量的同时优化推理效率。我们将特别关注实际部署中的挑战，包括延迟、吞吐量和内存占用的权衡。
在生成式检索中，模型需要生成有效的文档标识符序列。与开放域文本生成不同，文档ID必须对应于实际存在的文档，这就需要约束解码机制来确保生成的有效性。
约束解码可以分为两大类：硬约束和软约束。
硬约束确保生成的每个token都来自有效的词汇表子集。在生成式检索中，这意味着：
Valid_tokens(prefix) = {t | prefix + t ∈ Prefix(DocIDs)}
其中Prefix(DocIDs)表示所有有效文档ID的前缀集合。硬约束的实现通常采用掩码机制：
Step 1: [START] → 可选: {1, 2, 3, 4, 5}
Step 2: [START, 2] → 可选: {0, 1, 3, 7, 9}
Step 3: [START, 2, 3] → 可选: {4, 5}
词汇表掩码示例:
[1, 1, 1, 1, 1, 0, 0, ...] # Step 1
[1, 1, 0, 1, 0, 0, 0, 1, 0, 1, ...] # Step 2
软约束则通过调整概率分布来引导生成，而不完全禁止某些token：
\[p'(t|prefix) = \frac{p(t|prefix) \cdot \mathbb{1}[t \in Valid(prefix)]^\alpha}{\sum_{t'} p(t'|prefix) \cdot \mathbb{1}[t' \in Valid(prefix)]^\alpha}\]其中$\alpha$控制约束的强度，$\alpha \to \infty$时退化为硬约束。
Trie（前缀树）是实现约束解码的核心数据结构。每个节点代表一个前缀，叶节点对应完整的文档ID：
root
/ | \
1 2 3
/| |\ \
0 2 0 3 4
/ | | \ \
5 3 1 7 5
对应文档IDs: {105, 123, 201, 237, 345}
Trie的关键操作包括：
| 有效后继获取：O( | Σ | )，Σ为词汇表大小 |
生成式检索的文档ID设计直接影响约束解码的效率。不同的ID设计策略带来不同的约束特性和计算复杂度。
层次化ID：如[类别][子类][文档号]的结构允许逐层约束：
类别阶段: p(c) = softmax(W_c · h_0)
子类阶段: p(s|c) = softmax(W_s^c · h_1) # 条件参数
文档阶段: p(d|c,s) = softmax(W_d^{c,s} · h_2)
层次化设计的优势在于每一层的决策空间相对较小。例如，如果有1000个类别、每类100个子类、每子类1000个文档，则每步只需从最多1000个选项中选择，而非从1亿个文档中直接选择。这种分解极大降低了计算复杂度：
\[\text{Complexity}_{hierarchical} = O(C + S + D) \ll O(C \times S \times D) = \text{Complexity}_{flat}\]语义聚类ID：相似文档共享前缀，可利用语义信息进行软约束：
Similarity_boost(t, query) = exp(cos(embed(t), embed(query)) / τ)
p'(t|prefix, query) ∝ p(t|prefix) · Similarity_boost(t, query)
语义聚类的关键在于构建高质量的聚类树。常用方法包括：
数值ID的特殊处理： 当使用数值ID（如0-999999）时，可以利用数值属性进行高效约束：
def numerical_constraint(prefix, min_id, max_id):
# 利用数值范围快速剪枝
prefix_val = int(''.join(prefix))
prefix_len = len(prefix)
# 计算当前前缀可达的数值范围
min_reachable = prefix_val * (10 ** (6 - prefix_len))
max_reachable = (prefix_val + 1) * (10 ** (6 - prefix_len)) - 1
if max_reachable < min_id or min_reachable > max_id:
return [] # 该前缀无法到达有效ID
# 返回有效的下一位数字
valid_digits = []
for digit in range(10):
new_prefix = prefix + [str(digit)]
if is_valid_prefix(new_prefix, min_id, max_id):
valid_digits.append(digit)
return valid_digits
Beam Search是生成式检索中最常用的解码算法，但标准版本并不完全适合检索任务的特殊需求。本节探讨针对检索优化的各种变体。
标准Beam Search维护固定大小k的候选序列集合：
初始化: beams = [{seq: [START], score: 0}]
For step in 1..max_length:
candidates = []
For beam in beams:
For token in vocabulary:
new_seq = beam.seq + [token]
new_score = beam.score + log(p(token|beam.seq))
candidates.append({seq: new_seq, score: new_score})
beams = top_k(candidates, k)
在检索场景中，标准Beam Search存在几个问题：
为增加检索结果的多样性，Diverse Beam Search将beam分组，组间施加多样性惩罚：
Groups = G个组，每组k/G个beam
For group g in 1..G:
diversity_penalty(seq, prev_groups) = λ · max_{s∈prev} sim(seq, s)
score'(seq) = score(seq) - diversity_penalty(seq, groups[1:g-1])
多样性度量可以基于：
文档ID长度差异导致短序列偏好问题。长度归一化通过调整评分机制解决：
\[score_{norm}(seq) = \frac{1}{|seq|^\alpha} \sum_{i=1}^{|seq|} \log p(t_i|t_{<i})\]其中$\alpha \in [0.6, 1.0]$是长度惩罚因子。实践中，可以根据文档ID分布动态调整：
α(length) = α_base + β · (length - avg_length) / std_length
固定beam size在不同查询难度下效率不一。自适应策略根据置信度动态调整，这种动态调整不仅考虑当前步的不确定性，还要考虑历史信息和全局约束。
置信度度量:
- 熵: H(p) = -Σ p(t) log p(t)
- Top-k概率和: Σ_{i=1}^k p_i
- 概率比: p_1 / p_2
- 预测方差: Var(p) = Σ p_i(1-p_i)
动态调整规则:
if H(p) < threshold_low:
beam_size = max(2, beam_size // 2)
elif H(p) > threshold_high:
beam_size = min(max_beam, beam_size * 2)
多维度自适应策略：
beam_size = base_size * (1 + complexity_factor * query_complexity)
2. **深度自适应**：
```python
def depth_adaptive_beam(current_depth, max_depth):
# 越深入解码树，beam size越小
decay_factor = 0.8 ** (current_depth / max_depth)
return int(initial_beam_size * decay_factor)
class PerformanceAdaptiveBeam:
def __init__(self, target_latency=50):
self.target_latency = target_latency
self.history = deque(maxlen=100)
def adjust_beam_size(self, current_size, last_latency):
self.history.append(last_latency)
avg_latency = np.mean(self.history)
if avg_latency > self.target_latency * 1.1:
return max(2, int(current_size * 0.8))
elif avg_latency < self.target_latency * 0.9:
return min(32, int(current_size * 1.2))
return current_size
实验表明，自适应beam size可以在保持检索质量的同时减少30-50%的计算量。在实际部署中，不同类型查询的beam size分布呈现明显模式：
前缀树（Trie）不仅用于约束解码，还是加速生成式检索的核心数据结构。本节深入探讨如何利用Trie优化推理效率。
标准Trie可以通过以下优化提升检索性能：
压缩路径：单子节点路径压缩成边，减少遍历步骤：
标准Trie: 压缩Trie:
1 1
| |
2 23
| / \
3 4 7
/ \
4 7
位图索引：使用位图加速子节点查找：
struct TrieNode {
uint256 child_bitmap; // 256位，标记存在的子节点
Node* children[popcnt(child_bitmap)]; // 只存储实际子节点
}
查找复杂度: O(1) with SIMD popcnt
缓存友好布局：将热点路径的节点在内存中连续存储：
内存布局: [root][高频子树1][高频子树2]...[低频节点]
Cache line利用率提升40-60%
实时剪枝可以大幅减少搜索空间：
概率剪枝：当累积概率低于阈值时停止扩展：
prune_threshold = max_score - δ
if current_score < prune_threshold:
停止该分支探索
Top-k剪枝：只保留每层概率最高的k个节点：
Layer 1: 保留top-100节点
Layer 2: 保留top-50节点
Layer 3: 保留top-20节点
...逐层递减
自适应剪枝：根据查询复杂度动态调整：
查询长度 < 5: aggressive_pruning
查询长度 5-10: moderate_pruning
查询长度 > 10: conservative_pruning
批处理和并行化是提升生成式检索吞吐量的关键技术。通过充分利用现代硬件的并行能力，可以实现数量级的性能提升。
SIMD并行前缀匹配：
// AVX2实现的8路并行前缀匹配
__m256i query_vec = _mm256_loadu_si256(query);
for(int i = 0; i < num_docs; i += 8) {
__m256i doc_vecs = _mm256_loadu_si256(&docs[i]);
__m256i match = _mm256_cmpeq_epi32(query_vec, doc_vecs);
int mask = _mm256_movemask_epi8(match);
if(mask) {
// 找到匹配，提取具体位置
int pos = __builtin_ctz(mask) / 4 + i;
results.push_back(pos);
}
}
// AVX-512进一步提升到16路并行
__m512i query_vec_512 = _mm512_loadu_si512(query);
for(int i = 0; i < num_docs; i += 16) {
__m512i doc_vecs = _mm512_loadu_si512(&docs[i]);
__mmask16 match = _mm512_cmpeq_epi32_mask(query_vec_512, doc_vecs);
if(match) {
process_matches(match, i);
}
}
GPU加速Trie遍历：
// 优化的GPU Trie遍历，使用共享内存缓存热点节点
__global__ void trie_search_optimized(TrieNode* nodes, int* queries,
int* results, int num_queries) {
extern __shared__ TrieNode shared_cache[];
int tid = blockIdx.x * blockDim.x + threadIdx.x;
// 协作加载热点节点到共享内存
if(threadIdx.x < CACHE_SIZE) {
shared_cache[threadIdx.x] = nodes[hot_node_indices[threadIdx.x]];
}
__syncthreads();
if(tid < num_queries) {
int query = queries[tid];
TrieNode* current = &nodes[0]; // root
while(current && query) {
int child_idx = query & 0xFF;
// 先检查共享内存缓存
int cache_idx = find_in_cache(current, child_idx);
if(cache_idx >= 0) {
current = &shared_cache[cache_idx];
} else {
// 从全局内存读取
current = current->children[child_idx];
}
query >>= 8;
}
results[tid] = current ? current->doc_id : -1;
}
}
// Warp级别的协作搜索
__global__ void warp_collaborative_search(TrieNode* nodes, int* queries,
int* results) {
int warp_id = threadIdx.x / 32;
int lane_id = threadIdx.x % 32;
int query_id = blockIdx.x * (blockDim.x/32) + warp_id;
if(query_id < num_queries) {
int query = queries[query_id];
TrieNode* current = &nodes[0];
// Warp内线程协作遍历不同分支
while(current) {
int num_children = current->num_children;
int child_per_thread = (num_children + 31) / 32;
for(int i = 0; i < child_per_thread; i++) {
int child_idx = lane_id + i * 32;
if(child_idx < num_children) {
// 每个线程探索一个子节点
explore_branch(current->children[child_idx]);
}
}
// Warp投票选择最优分支
int best_branch = warp_vote_best_branch();
current = __shfl_sync(0xffffffff, current, best_branch);
}
}
}
多级并行策略：
class MultiLevelParallelizer:
def __init__(self):
self.cpu_executor = ThreadPoolExecutor(max_workers=16)
self.gpu_available = torch.cuda.is_available()
def process_batch(self, queries):
# Level 1: 按查询复杂度分组
simple_queries = [q for q in queries if len(q) < 10]
complex_queries = [q for q in queries if len(q) >= 10]
# Level 2: 简单查询CPU并行，复杂查询GPU处理
futures = []
# CPU处理简单查询
for batch in chunk(simple_queries, 64):
future = self.cpu_executor.submit(self.cpu_batch_search, batch)
futures.append(future)
# GPU处理复杂查询
if self.gpu_available and complex_queries:
gpu_results = self.gpu_batch_search(complex_queries)
# 收集结果
cpu_results = [f.result() for f in futures]
return merge_results(cpu_results, gpu_results)
不同的Trie变体在内存和速度间有不同权衡：
| 数据结构 | 内存占用 | 查询速度 | 适用场景 |
|---|---|---|---|
| 标准Trie | O(N×M) | O(M) | 小规模精确匹配 |
| 压缩Trie | O(N) | O(M) | 中等规模 |
| HAT-Trie | O(N/B) | O(M×logB) | 大规模缓存优化 |
| Succinct Trie | O(N×H(Σ)) | O(M×logΣ) | 超大规模 |
其中N是文档数，M是平均ID长度，B是桶大小，Σ是字符集大小。
传统的自回归（AR）解码逐个生成token，推理延迟与序列长度成正比。非自回归（NAR）模型通过并行生成所有token来突破这一限制，为生成式检索带来显著的速度提升。
非自回归模型的核心思想是打破token间的顺序依赖：
自回归生成： \(p_{AR}(y|x) = \prod_{t=1}^T p(y_t|y_{<t}, x)\)
非自回归生成： \(p_{NAR}(y|x) = p(T|x) \prod_{t=1}^T p(y_t|x)\)
其中T是序列长度，可以通过长度预测器获得。
NAR在生成式检索中的实现需要特殊设计：
1. 长度预测：
length_logits = length_predictor(query_encoding)
predicted_lengths = top_k(softmax(length_logits), k=3)
# 同时尝试多个长度，后处理选择最佳
2. 并行位置生成：
# 所有位置同时预测
position_embeddings = get_position_embeddings(max_length)
decoder_input = query_encoding + position_embeddings
all_logits = decoder(decoder_input) # [batch, max_length, vocab]
3. CTC解码（处理重复和空白）：
原始输出: [1, 1, ε, 2, 2, 3, ε, 3]
CTC合并: [1, 2, 3] # ε表示空白，重复合并
NAR的一次生成质量通常不如AR，迭代精化可以改善。精化的核心思想是通过多轮迭代逐步提高生成质量，每轮聚焦于修正低置信度的部分。
Mask-Predict策略：
Step 1: 初始并行生成 y^(0)
Step 2-N: 迭代精化
- 计算每个位置的置信度: conf_t = p(y_t^(i-1)|x)
- Mask低置信位置: mask = (conf < threshold)
- 重新预测masked位置: y^(i) = predict(y^(i-1), mask, x)
这种策略的关键在于置信度估计的准确性。实践中常用的置信度度量包括：
置信度驱动的精化：
def iterative_refine(query, max_iters=3):
y = initial_predict(query)
refinement_history = []
for i in range(max_iters):
confidences = get_confidences(y, query)
avg_conf = np.mean(confidences)
refinement_history.append(avg_conf)
if min(confidences) > threshold:
break
# 自适应阈值：随迭代次数增加而放松
mask = confidences < adaptive_threshold(i)
# 只精化最需要改进的位置
num_to_refine = max(1, int(sum(mask) * decay_rate ** i))
positions_to_refine = np.argsort(confidences)[:num_to_refine]
y = refine(y, positions_to_refine, query)
# 早停检测
if i > 0 and abs(avg_conf - refinement_history[-2]) < epsilon:
break # 置信度不再显著提升
return y
CMLM（Conditional Masked Language Model）精化：
class CMLMRefiner:
def __init__(self, model, mask_ratio_schedule):
self.model = model
self.mask_schedule = mask_ratio_schedule # [0.5, 0.3, 0.1]
def refine(self, query, initial_output, num_iters=3):
current = initial_output
for iter_idx in range(num_iters):
mask_ratio = self.mask_schedule[min(iter_idx, len(self.mask_schedule)-1)]
# 基于置信度的自适应masking
token_probs = self.model.get_token_probabilities(current, query)
num_mask = int(len(current) * mask_ratio)
# 优先mask低置信度token
mask_positions = np.argsort(token_probs)[:num_mask]
# 条件生成
masked_input = self.apply_mask(current, mask_positions)
predictions = self.model.predict_masked(masked_input, query)
# 更新masked位置
for pos in mask_positions:
current[pos] = predictions[pos]
return current
实践中，混合架构往往能取得最佳效果。关键在于如何智能地结合两种范式的优势：AR的高质量生成和NAR的高效推理。
浅层AR + 深层NAR：
前缀生成(AR): [类别][子类] # 2-3步，确定大方向
后缀生成(NAR): [文档编号] # 并行生成剩余部分
优势分析：
- 前缀的准确性对最终结果影响大，使用AR保证质量
- 后缀在前缀确定后选择空间小，NAR足够准确
- 总延迟 = AR_steps × t_ar + t_nar ≈ 3×5ms + 10ms = 25ms
置信度切换：
class AdaptiveDecoder:
def __init__(self, ar_model, nar_model):
self.ar_model = ar_model
self.nar_model = nar_model
self.complexity_estimator = QueryComplexityEstimator()
def decode(self, query):
complexity = self.complexity_estimator.estimate(query)
# 多维度决策
factors = {
'query_length': len(query.split()),
'vocabulary_entropy': compute_vocab_entropy(query),
'expected_results': estimate_result_count(query),
'latency_budget': get_current_latency_budget()
}
if self.should_use_nar(complexity, factors):
return self.nar_decode_with_fallback(query)
else:
return self.ar_decode_with_early_stop(query)
def nar_decode_with_fallback(self, query):
# NAR生成
results = self.nar_model.generate(query)
confidences = self.nar_model.get_confidences(results)
# 低置信度时回退到AR
if min(confidences) < self.confidence_threshold:
return self.ar_model.generate(query)
return results
级联架构：
class CascadeRetrieval:
def __init__(self):
self.nar_coarse = FastNARModel()
self.ar_fine = AccurateARModel()
self.reranker = LearnedReranker()
def retrieve(self, query, top_k=10):
# Stage 1: NAR快速召回
t1 = time.time()
coarse_candidates = self.nar_coarse.generate_batch(
query,
num_candidates=100,
beam_size=5 # NAR使用小beam
)
coarse_time = time.time() - t1 # ~10ms
# Stage 2: AR精细重排
t2 = time.time()
refined_candidates = []
for candidate in coarse_candidates[:20]: # 只精排top-20
score = self.ar_fine.score(query, candidate)
refined_candidates.append((candidate, score))
refined_candidates.sort(key=lambda x: x[1], reverse=True)
rerank_time = time.time() - t2 # ~20ms
# Stage 3: 学习的重排器（可选）
if self.reranker:
final_results = self.reranker.rerank(
query,
[c[0] for c in refined_candidates[:top_k]]
)
else:
final_results = [c[0] for c in refined_candidates[:top_k]]
total_time = coarse_time + rerank_time
return final_results, {'latency': total_time}
动态架构选择：
class DynamicArchitectureSelector:
def __init__(self):
self.models = {
'pure_ar': PureARModel(),
'pure_nar': PureNARModel(),
'hybrid_shallow': ShallowARDeepNAR(),
'hybrid_cascade': CascadeModel()
}
self.performance_tracker = PerformanceTracker()
def select_architecture(self, query, context):
# 基于历史性能数据选择
query_features = extract_features(query)
predicted_performance = {}
for name, model in self.models.items():
# 预测每种架构的性能
predicted_performance[name] = self.performance_tracker.predict(
model_name=name,
features=query_features,
metrics=['latency', 'accuracy']
)
# 多目标优化：延迟vs准确率
best_architecture = self.pareto_optimal_choice(
predicted_performance,
latency_weight=context.get('latency_importance', 0.5),
accuracy_weight=context.get('accuracy_importance', 0.5)
)
return self.models[best_architecture]
不同解码策略在各种维度上的详细对比：
| 指标 | 自回归(AR) | 非自回归(NAR) | 混合架构 |
| 推理延迟 | O(T)，~100ms | O(1)，~20ms | O(k), k«T，~30ms |
| 准确率@1 | 95% | 88% | 93% |
| 准确率@10 | 98% | 94% | 97% |
| 吞吐量 | 100 QPS | 500 QPS | 300 QPS |
| 模型大小 | 1× | 1.2× | 1.5× |
| GPU内存占用 | 基准 | +20%（并行化） | +30%（双模型） |
| 训练复杂度 | 标准 | 2×（需要特殊损失） | 2.5×（联合训练） |
| 部署复杂度 | 简单 | 中等 | 复杂 |
细粒度性能分析：
查询长度 | AR延迟 | NAR延迟 | 混合延迟 | 最优选择
---------|--------|---------|----------|----------
1-3词 | 30ms | 15ms | 20ms | NAR
4-7词 | 60ms | 18ms | 25ms | 混合
8-15词 | 120ms | 25ms | 35ms | 混合
>15词 | 200ms+ | 35ms | 50ms | NAR(精度容忍时)
文档数量 | AR性能 | NAR性能 | 推荐方案
----------|----------|----------|------------
<10K | 优秀 | 良好 | AR（质量优先）
10K-100K | 良好 | 优秀 | 混合
100K-1M | 一般 | 优秀 | NAR+精排
>1M | 差 | 良好 | 分层NAR
def hardware_optimized_selection(hardware_profile):
if hardware_profile['gpu_memory'] < 8: # GB
return 'quantized_nar' # 量化的NAR模型
elif hardware_profile['gpu_compute'] < 7.0: # 计算能力
return 'cpu_ar_gpu_nar' # CPU运行AR，GPU运行NAR
elif hardware_profile['num_gpus'] > 1:
return 'pipeline_hybrid' # 流水线并行的混合模型
else:
return 'standard_hybrid'
字节跳动在抖音搜索中部署生成式检索面临独特挑战：亿级短视频库、毫秒级延迟要求、每秒数万查询。本节深入分析其优化策略。
抖音搜索采用三层架构：
用户查询
↓
[召回层] 生成式检索 + 传统倒排
↓ 1000候选
[粗排层] 轻量级打分
↓ 100候选
[精排层] 复杂模型打分
↓ 10结果
展示给用户
生成式检索在召回层承担主要职责，需要在50ms内返回结果。
1. 知识蒸馏：
教师模型: 24层BERT-large (340M参数)
学生模型: 6层DistilBERT (66M参数)
蒸馏损失:
L = α·L_hard + (1-α)·L_soft
L_soft = KL(student_logits/T, teacher_logits/T)
2. 混合精度推理：
3. 动态批处理：
class DynamicBatcher:
def __init__(self, max_batch=32, max_wait=10ms):
self.pending_queries = []
def add_query(self, query):
self.pending_queries.append(query)
if len(self.pending_queries) >= max_batch:
return self.process_batch()
elif time_since_first() > max_wait:
return self.process_batch()
模型分片：
Model Parallel:
- Embedding Table: 4个节点分片
- Transformer Layers: 2个节点pipeline
- 总延迟: max(shard_latencies) + communication
Data Parallel:
- 8个副本处理不同batch
- Load Balancer: 一致性哈希
缓存策略：
三级缓存:
L1: 进程内LRU (命中率~30%)
L2: Redis集群 (命中率~50%)
L3: CDN边缘节点 (命中率~70%)
缓存key设计:
key = hash(query_normalized + time_bucket + user_city)
增量索引：
每小时更新:
1. 收集新视频ID
2. 生成临时Trie分支
3. 无锁合并到主Trie
4. 原子切换指针
热更新不影响服务，延迟增加 < 1ms
查询自适应：
def adaptive_decode(query, stats):
# 根据历史统计选择策略
if stats.avg_results < 10:
return aggressive_beam_search(query)
elif stats.click_entropy > threshold:
return diverse_beam_search(query)
else:
return standard_decode(query)
部署后的关键指标：
| 指标 | 优化前 | 优化后 | 提升 |
|---|---|---|---|
| P50延迟 | 120ms | 45ms | 62.5% |
| P99延迟 | 500ms | 150ms | 70% |
| QPS容量 | 10K | 50K | 5× |
| 召回率@100 | 75% | 82% | +7pp |
| 硬件成本 | 100台 | 40台 | 60%减少 |
本章深入探讨了生成式检索中的解码策略与推理优化技术。我们从约束解码的基础概念出发，详细分析了如何通过Trie等数据结构实现高效的文档ID生成约束。在Beam Search部分，我们不仅回顾了标准算法，还介绍了针对检索任务优化的多种变体，包括多样性增强、长度归一化和自适应beam size等技术。
前缀树加速章节展示了如何通过数据结构优化、动态剪枝和硬件加速来提升推理效率。特别是SIMD和GPU并行化技术，能够带来数量级的性能提升。在高级话题部分，我们探讨了非自回归解码这一前沿方向，包括并行生成、迭代精化和混合架构等创新方法。
通过字节跳动抖音搜索的工业案例，我们看到了这些技术在实际大规模系统中的应用。关键优化包括模型压缩、动态批处理、分布式部署和多级缓存等，这些技术的综合应用使得系统能够在毫秒级延迟内处理亿级视频库的检索请求。
核心要点总结：
习题6.1：解释硬约束和软约束在生成式检索中的区别，并给出各自的适用场景。
习题6.2：给定一个包含1000个文档的集合，文档ID采用3层层次化设计（10个类别，每类10个子类，每子类10个文档），计算使用层次化约束相比扁平化搜索的计算复杂度降低比例。
习题6.3：实现一个简单的Diverse Beam Search算法，要求支持基于编辑距离的多样性惩罚。
习题6.4：设计一个自适应的解码策略选择器，能够根据查询特征（长度、复杂度、历史点击率等）自动选择最优的解码方法（AR、NAR或混合）。
习题6.5：分析并比较Mask-Predict和CMLM两种迭代精化策略的优缺点，并提出一种结合两者优势的新方法。
习题6.6：针对动态更新的文档集合（每天新增/删除10%文档），设计一个增量式的Trie更新算法，要求不影响在线服务。
习题6.7：设计一个性能监控和自动调优系统，能够实时检测生成式检索系统的性能瓶颈并自动调整参数。
习题6.8：假设你需要将生成式检索部署到边缘设备（如手机），内存限制2GB，延迟要求<100ms，设计一个完整的优化方案。
继续学习：第7章：NCI与可扩展性 →