大模型(LLMs)进阶面试题及答案详解

二、进阶面试题

一、什么是生成式大模型?

答案:

生成式大模型(Generative Large Language Models)是能够生成新内容的大规模语言模型。

定义:

生成式大模型 = 大规模参数 + 自回归生成 + 概率建模
 
核心特征:
1. 可以生成新的、原创的内容
2. 基于概率分布采样
3. 自回归方式逐token生成
4. 规模通常在数十亿到数万亿参数

1. 生成式 vs 判别式

判别式模型(Discriminative):

# 学习条件概率 P(Y|X)
# "给定输入X,输出Y的概率"
 
示例:
- 分类器:P(类别|文本)
  "这个评论是正面还是负面?"
  
- BERT: 判别式
  输入: "The movie was [MASK]"
  输出: P(word|context)  # 填空

生成式模型(Generative):

# 学习联合概率 P(X,Y) 或条件概率 P(X|Y)  
# "生成符合分布的新样本"
 
示例:
- 语言模型:P(下一个词|前面的词)
  "根据前文生成下一个词"
  
- GPT: 生成式
  输入: "Once upon a time"
  输出: 生成连续的文本
  "Once upon a time, there was a princess..."

对比:

维度判别式生成式
学习目标P(Y|X)P(X) 或 P(X|Y)
能力分类、预测生成新内容
示例BERT, 分类器GPT, LLaMA
应用理解任务生成任务

2. 自回归生成机制

核心思想:

# 逐个token生成,每次生成依赖之前生成的内容
 
生成过程:
1. 给定初始prompt: "The cat"
2. 预测下一个token: "sat" → "The cat sat"
3. 继续预测: "on" → "The cat sat on"
4. 继续: "the" → "The cat sat on the"
5. 继续: "mat" → "The cat sat on the mat"
6. 直到生成结束符或达到最大长度

数学表达:

# 序列的联合概率分解为条件概率的乘积
 
P(x₁, x₂, ..., xₙ) = P(x₁) × P(x₂|x₁) × P(x₃|x₁,x₂) × ... × P(xₙ|x₁,...,xₙ₋₁)
 
# 自回归生成:
for t in range(1, n+1):
    xₜ ~ P(xₜ | x₁, ..., xₜ₋₁)  # 从条件分布采样

实现示例:

def generate(model, prompt, max_length=50):
    tokens = tokenize(prompt)  # ["The", "cat"]
    
    for _ in range(max_length):
        # 计算下一个token的概率分布
        logits = model(tokens)  # (vocab_size,)
        probs = softmax(logits)
        
        # 采样下一个token
        next_token = sample(probs)  # 例如: "sat"
        
        # 添加到序列
        tokens.append(next_token)
        
        # 如果生成结束符,停止
        if next_token == "<EOS>":
            break
    
    return tokens  # ["The", "cat", "sat", "on", "the", "mat"]

3. 概率建模

语言模型的目标:

# 建模自然语言的概率分布
 
目标: 最大化训练数据的对数似然
Loss = -Σ log P(xₜ | x₁, ..., xₜ₋₁)
 
# 训练时:
输入: ["The", "cat", "sat"]
标签: ["cat", "sat", "on"]  # 错位一个位置
 
# 计算loss:
loss = -log P("cat" | "The")
       -log P("sat" | "The", "cat")
       -log P("on" | "The", "cat", "sat")

softmax输出层:

# 模型最后一层输出vocabulary上的概率分布
 
logits = model(input)  # (vocab_size,)
# logits = [3.2, -1.5, 0.8, ..., 2.1]
 
probs = softmax(logits)
# probs = [0.25, 0.001, 0.02, ..., 0.08]
# Σprobs = 1.0
 
# 每个token的概率
P("cat") = probs[vocab["cat"]]
P("dog") = probs[vocab["dog"]]
...

4. 生成式大模型的架构

主流架构:Transformer Decoder

class GenerativeTransformer(nn.Module):
    def __init__(self, vocab_size, d_model, n_layers):
        self.token_embed = nn.Embedding(vocab_size, d_model)
        self.pos_embed = PositionalEncoding(d_model)
        
        # Decoder-only架构
        self.layers = nn.ModuleList([
            DecoderLayer(d_model)  # 只有decoder
            for _ in range(n_layers)
        ])
        
        self.lm_head = nn.Linear(d_model, vocab_size)
    
    def forward(self, input_ids):
        # Token + Position Embedding
        x = self.token_embed(input_ids) + self.pos_embed
        
        # Causal Masking(因果mask)
        # 每个位置只能看到之前的位置
        for layer in self.layers:
            x = layer(x, causal_mask=True)
        
        # 预测下一个token的logits
        logits = self.lm_head(x)
        return logits  # (batch, seq_len, vocab_size)

关键设计:

1. Causal Masking:
   确保生成时只看到之前的tokens
   
2. Decoder-only:
   不需要Encoder,简化架构
   
3. 参数共享:
   所有层使用相同的架构
   
4. 自回归:
   训练和推理都是逐token生成

5. 生成策略

Greedy Decoding(贪心解码):

# 每次选择概率最高的token
def greedy_generate(model, prompt):
    tokens = [prompt]
    for _ in range(max_len):
        probs = model(tokens)
        next_token = argmax(probs[-1])  # 选概率最大的
        tokens.append(next_token)
    return tokens
 
# 优点:快速、确定性
# 缺点:可能陷入局部最优,生成单调

Beam Search(束搜索):

# 保留top-k个候选序列
def beam_search(model, prompt, beam_width=5):
    candidates = [(prompt, 0)]  # (序列, 累积log概率)
    
    for _ in range(max_len):
        new_candidates = []
        for seq, score in candidates:
            probs = model(seq)
            # 扩展每个候选
            for token, prob in top_k(probs, beam_width):
                new_seq = seq + [token]
                new_score = score + log(prob)
                new_candidates.append((new_seq, new_score))
        
        # 保留top beam_width个
        candidates = sorted(new_candidates, key=lambda x: x[1])[:beam_width]
    
    return candidates[0][0]  # 返回最佳序列
 
# 优点:质量更高
# 缺点:计算量大,仍可能单调

Sampling(采样):

# 从概率分布中随机采样
def sampling_generate(model, prompt, temperature=1.0):
    tokens = [prompt]
    for _ in range(max_len):
        logits = model(tokens) / temperature  # 温度控制
        probs = softmax(logits[-1])
        next_token = random.choice(vocab, p=probs)  # 随机采样
        tokens.append(next_token)
    return tokens
 
# 优点:多样性高
# 缺点:可能生成低质量内容

Top-k Sampling:

# 只从概率最高的k个token中采样
def top_k_sampling(model, prompt, k=50):
    tokens = [prompt]
    for _ in range(max_len):
        probs = model(tokens)[-1]
        top_k_probs, top_k_indices = torch.topk(probs, k)
        
        # 重新归一化
        top_k_probs = top_k_probs / top_k_probs.sum()
        
        # 从top-k中采样
        next_token = random.choice(top_k_indices, p=top_k_probs)
        tokens.append(next_token)
    return tokens
 
# 优点:平衡质量和多样性

Nucleus Sampling (Top-p):

# 从累积概率达到p的最小token集合中采样
def nucleus_sampling(model, prompt, p=0.9):
    tokens = [prompt]
    for _ in range(max_len):
        probs = model(tokens)[-1]
        sorted_probs, sorted_indices = torch.sort(probs, descending=True)
        
        # 累积概率
        cumsum_probs = torch.cumsum(sorted_probs, dim=0)
        
        # 找到累积概率刚超过p的位置
        nucleus = sorted_indices[cumsum_probs <= p]
        
        # 从nucleus中采样
        nucleus_probs = probs[nucleus]
        nucleus_probs = nucleus_probs / nucleus_probs.sum()
        next_token = random.choice(nucleus, p=nucleus_probs)
        tokens.append(next_token)
    return tokens
 
# 优点:动态调整采样范围,效果好

6. 训练过程

预训练(Pre-training):

# 在大规模无标注文本上训练
 
数据: 互联网文本、书籍、代码...
目标: 下一个词预测(语言模型目标)
 
# 训练示例
text = "The cat sat on the mat"
tokens = ["The", "cat", "sat", "on", "the", "mat"]
 
# 构造训练样本
for i in range(len(tokens)-1):
    input = tokens[:i+1]   # ["The"], ["The", "cat"], ...
    target = tokens[i+1]   # "cat", "sat", ...
    
    # 计算loss
    logits = model(input)
    loss = CrossEntropy(logits, target)
    
    # 反向传播
    loss.backward()
    optimizer.step()
 
# 在数万亿tokens上训练数周/数月

微调(Fine-tuning):

# SFT: Supervised Fine-Tuning
# 在指令-回答对上微调
 
示例数据:
{
    "instruction": "将这句话翻译成法语",
    "input": "Hello, how are you?",
    "output": "Bonjour, comment allez-vous?"
}
 
# 训练时仍然是next token prediction
# 但格式化为对话形式
prompt = f"Instruction: {instruction}\nInput: {input}\nOutput: "
target = output
 
# 微调使模型学会遵循指令

RLHF(强化学习):

# 根据人类偏好进一步优化
 
1. 收集人类偏好数据:
   response_A vs response_B → 人类选择A
 
2. 训练奖励模型:
   reward_model(prompt, response) → score
   
3. 用PPO优化策略:
   maximize E[reward_model(prompt, model_output)]
 
# 使模型输出更符合人类偏好

7. 生成式大模型的应用

1. 文本生成:
   - 文章写作
   - 故事创作
   - 诗歌生成
 
2. 对话系统:
   - ChatGPT
   - Claude
   - 客服机器人
 
3. 代码生成:
   - GitHub Copilot
   - CodeLLaMA
   - 自动编程
 
4. 内容创作:
   - 营销文案
   - 产品描述
   - 邮件写作
 
5. 教育辅导:
   - 问题解答
   - 概念解释
   - 作业辅导
 
6. 数据生成:
   - 合成训练数据
   - 数据增强
   - 测试用例生成

8. 生成式大模型的特点

特点1: 开放域生成
- 可以生成任何话题的内容
- 不限于特定领域
 
特点2: 上下文学习
- 根据prompt调整输出
- 无需重新训练
 
特点3: 涌现能力
- 规模够大时出现新能力
- 推理、规划等
 
特点4: 多样性
- 可以生成多种风格
- 创意性强
 
特点5: 可控性
- 通过prompt engineering控制
- 通过参数(temperature等)调节

总结:

生成式大模型的核心要素:

  1. 生成能力:能创造新内容
  2. 自回归:逐token生成
  3. 概率建模:基于条件概率
  4. 大规模:数十亿到数万亿参数
  5. 预训练:在海量数据上学习

与判别式模型的区别:

  • 判别式:理解和分类(BERT)
  • 生成式:创造和生成(GPT)

关键技术:

  • Transformer Decoder架构
  • Causal Masking
  • 多种解码策略
  • 大规模预训练

当前代表:

  • GPT系列
  • LLaMA系列
  • Claude
  • PaLM
  • …

核心洞察:

生成式大模型 = 学习语言的概率分布
→ 可以生成符合分布的新文本
→ "理解"语言的统计规律
→ 展现出类似人类的语言能力

二、大模型是怎么让生成的文本丰富而不单调的呢?

答案:

LLMs通过多种技术手段来确保生成文本的多样性和丰富性,避免单调重复。

核心机制概览:

文本多样性 = 采样策略 + 温度控制 + Top-k/Top-p + 惩罚机制

1. 采样 vs 贪心解码

贪心解码(Greedy Decoding)- 单调的根源:

# 总是选择概率最高的token
def greedy_decode(model, prompt):
    tokens = tokenize(prompt)
    for _ in range(max_length):
        probs = model(tokens)  # 获取下一个token的概率分布
        next_token = argmax(probs)  # 选择概率最大的
        tokens.append(next_token)
    return tokens
 
# 问题:
# 1. 确定性输出 - 相同输入总是相同输出
# 2. 容易陷入重复循环
# 3. 缺乏创造性
 
# 示例输出(单调):
"The cat sat on the mat. The cat sat on the mat. The cat sat on the mat..."

随机采样(Sampling)- 引入随机性:

# 从概率分布中随机采样
def random_sample(model, prompt):
    tokens = tokenize(prompt)
    for _ in range(max_length):
        probs = model(tokens)
        # 按概率分布随机选择
        next_token = np.random.choice(vocab, p=probs)
        tokens.append(next_token)
    return tokens
 
# 优点:
# ✓ 每次运行可能不同
# ✓ 增加多样性
# ✓ 更有创造性
 
# 但可能太随机,质量下降

2. Temperature(温度)控制

Temperature的作用:

# Temperature调节概率分布的"平滑度"
 
def softmax_with_temperature(logits, temperature=1.0):
    """
    temperature: 温度参数
    - T = 1.0: 原始分布
    - T > 1.0: 分布更平滑(更随机)
    - T < 1.0: 分布更尖锐(更确定)
    - T → 0: 接近argmax(贪心)
    - T → ∞: 均匀分布(完全随机)
    """
    scaled_logits = logits / temperature
    return softmax(scaled_logits)

不同Temperature的效果:

# 原始logits
logits = [3.0, 2.0, 1.0, 0.5]  # 4个候选token
 
# T = 0.5 (低温,更确定)
probs = softmax(logits / 0.5)
# = [0.76, 0.19, 0.04, 0.01]  # 分布尖锐,倾向于最高概率
 
# T = 1.0 (标准温度)
probs = softmax(logits / 1.0)
# = [0.50, 0.27, 0.15, 0.08]  # 原始分布
 
# T = 2.0 (高温,更随机)
probs = softmax(logits / 2.0)
# = [0.38, 0.28, 0.21, 0.13]  # 分布平滑,更多样化

Temperature对生成的影响:

prompt = "Once upon a time"
 
# T = 0.1 (接近确定性)
output = "Once upon a time, there was a princess who lived in a castle."
# 保守、可预测
 
# T = 0.7 (平衡)
output = "Once upon a time, in a distant galaxy, a curious explorer discovered..."
# 合理且有创意
 
# T = 1.5 (高创意)
output = "Once upon a time, quantum mechanics whispered secrets to butterflies..."
# 非常创意,但可能不太连贯
 
# T = 2.5 (过于随机)
output = "Once upon elephant purple mathematics seven..."
# 太随机,失去意义

最佳实践:

任务类型与Temperature:
 
事实性任务 (T = 0.1 - 0.3):
- 问答、翻译
- 需要准确性
- 示例: "What is 2+2?" → 需要精确答案
 
平衡任务 (T = 0.7 - 1.0):
- 对话、邮件
- 需要自然且适度创意
- 示例: 写商务邮件
 
创意任务 (T = 1.0 - 1.5):
- 故事创作、诗歌
- 需要想象力
- 示例: 写科幻小说
 
极端创意 (T > 1.5):
- 头脑风暴
- 探索性写作
- 通常不推荐生产使用

3. Top-k Sampling(Top-k采样)

原理:

# 只从概率最高的k个token中采样
 
def top_k_sampling(logits, k=50):
    """
    k: 保留的候选数量
    - k = 1: 等同于greedy
    - k = vocab_size: 等同于random sampling
    - k = 50: 常用默认值
    """
    # 获取top-k
    top_k_probs, top_k_indices = torch.topk(softmax(logits), k)
    
    # 重新归一化
    top_k_probs = top_k_probs / top_k_probs.sum()
    
    # 从top-k中采样
    next_token = np.random.choice(top_k_indices, p=top_k_probs)
    return next_token

为什么有效:

# 过滤掉低概率、可能不合理的token
 
原始概率分布(词表50000个词):
P(the) = 0.20
P(a) = 0.15
P(cat) = 0.10
...
P(xyzabc) = 0.00001  # 极低概率的无意义词
P(qwerty) = 0.00002
 
# Top-k=50采样:
只考虑前50个高概率词
过滤掉49950个低概率词(通常是无意义的)
 
效果:
✓ 保持多样性(50个选择)
✓ 避免生成垃圾词
✓ 平衡质量和创意

不同k值的影响:

k = 1:  # 等同于greedy
"The cat sat on the mat."  # 最保守
 
k = 10:  # 非常保守
"The cat rested on the mat."  # 略有变化
 
k = 50:  # 标准设置
"The feline lounged upon the cushioned surface."  # 更多样
 
k = 200:  # 更随机
"The cat, surprisingly, meditated atop the vintage rug."  # 很创意
 
k = vocab_size:  # 完全随机
"The purple mathematics seven..."  # 可能无意义

4. Nucleus Sampling / Top-p Sampling

核心思想:

# 动态选择候选集,使累积概率达到p
 
def nucleus_sampling(logits, p=0.9):
    """
    p: 累积概率阈值
    - p = 1.0: 考虑所有token(等同random sampling)
    - p = 0.5: 非常保守
    - p = 0.9: 常用默认值
    - p = 0.95: 稍微更多样
    """
    probs = softmax(logits)
    
    # 按概率降序排列
    sorted_probs, sorted_indices = torch.sort(probs, descending=True)
    
    # 计算累积概率
    cumsum_probs = torch.cumsum(sorted_probs, dim=0)
    
    # 找到累积概率刚好超过p的位置
    nucleus = sorted_indices[cumsum_probs <= p]
    
    # 如果nucleus为空,至少包含最高概率的token
    if len(nucleus) == 0:
        nucleus = sorted_indices[:1]
    
    # 从nucleus中采样
    nucleus_probs = probs[nucleus]
    nucleus_probs = nucleus_probs / nucleus_probs.sum()  # 重新归一化
    
    next_token = np.random.choice(nucleus, p=nucleus_probs)
    return next_token

Top-p vs Top-k对比:

# 概率分布示例
probs = [0.4, 0.25, 0.15, 0.08, 0.05, 0.03, 0.02, 0.01, 0.005, 0.005]
 
# Top-k = 5 (固定数量)
候选: 前5个token
累积概率: 0.4 + 0.25 + 0.15 + 0.08 + 0.05 = 0.93
 
# Top-p = 0.9 (动态数量)
候选: 累积到0.9需要的token
0.4 + 0.25 + 0.15 + 0.08 = 0.88 < 0.9
0.4 + 0.25 + 0.15 + 0.08 + 0.05 = 0.93 >= 0.9
候选: 前5个token(与top-k=5相同)
 
# 但在不同分布下会不同:

另一个例子:

# 分布更平坦时
probs = [0.15, 0.14, 0.13, 0.12, 0.11, 0.10, 0.09, 0.08, 0.05, 0.03]
 
# Top-k = 5
候选: 5个(固定)
 
# Top-p = 0.9
0.15 + 0.14 + 0.13 + 0.12 + 0.11 + 0.10 + 0.09 + 0.08 = 0.92 >= 0.9
候选: 8个(动态适应)
 
优势:
- 概率集中时:选择少(保守)
- 概率分散时:选择多(多样)
- 自适应调整

Top-p的优势:

✓ 动态调整候选集大小
✓ 适应不同的概率分布
✓ 在确定性和随机性之间平衡
✓ 通常优于固定的top-k
 
常用组合:
temperature = 0.7 + top_p = 0.9
# 既控制分布形状,又控制候选范围

5. Repetition Penalty(重复惩罚)

问题:重复生成

# LLM可能陷入重复循环
output = "I love cats. I love cats. I love cats. I love cats..."

Repetition Penalty机制:

def apply_repetition_penalty(logits, generated_tokens, penalty=1.2):
    """
    penalty: 惩罚系数
    - penalty = 1.0: 无惩罚
    - penalty > 1.0: 降低已生成token的概率
    - penalty = 1.2: 常用值
    - penalty = 1.5: 强惩罚
    """
    for token in set(generated_tokens):
        # 降低已出现token的logit
        if logits[token] > 0:
            logits[token] /= penalty
        else:
            logits[token] *= penalty
    
    return logits
 
# 使用示例
generated = ["I", "love", "cats"]
logits = model(generated)
 
# 应用惩罚
logits = apply_repetition_penalty(logits, generated, penalty=1.2)
 
# 现在"I", "love", "cats"的概率都降低了
# 更可能生成其他词

效果:

# 无惩罚
"I love cats. I love cats. I love cats."
 
# penalty = 1.2
"I love cats. They are adorable creatures. Cats make great pets."
# ✓ 避免重复,更自然

Frequency Penalty变体:

def frequency_penalty(logits, generated_tokens, penalty=0.1):
    """
    根据出现次数线性惩罚
    """
    token_counts = Counter(generated_tokens)
    
    for token, count in token_counts.items():
        # 出现越多,惩罚越重
        logits[token] -= penalty * count
    
    return logits
 
# 示例:
# "cat"出现3次 → logit减少 0.1 * 3 = 0.3
# "dog"出现1次 → logit减少 0.1 * 1 = 0.1

Presence Penalty变体:

def presence_penalty(logits, generated_tokens, penalty=0.5):
    """
    只要出现过就惩罚,不管次数
    """
    unique_tokens = set(generated_tokens)
    
    for token in unique_tokens:
        logits[token] -= penalty  # 固定惩罚
    
    return logits
 
# 鼓励使用新词,而不管旧词用了多少次

6. Contrastive Search(对比搜索)

核心思想:

# 平衡"模型置信度"和"与上文的差异性"
 
def contrastive_search(model, context, alpha=0.6, k=5):
    """
    alpha: 差异性权重(0-1)
    - alpha = 0: 只考虑模型概率(退化为top-k采样)
    - alpha = 1: 只考虑差异性
    - alpha = 0.6: 常用平衡值
    
    k: 候选数量
    """
    # 1. 获取top-k候选
    logits = model(context)
    top_k_probs, top_k_tokens = torch.topk(softmax(logits), k)
    
    scores = []
    for i, token in enumerate(top_k_tokens):
        # 2. 计算模型概率得分
        prob_score = top_k_probs[i]
        
        # 3. 计算与上文的差异性(余弦相似度)
        token_hidden = model.get_embedding(token)
        context_hiddens = model.get_embedding(context)
        
        # 与上文中每个token的最大相似度
        max_similarity = max([
            cosine_similarity(token_hidden, ctx_hidden)
            for ctx_hidden in context_hiddens
        ])
        
        # 差异性得分 = 1 - 最大相似度
        degeneration_penalty = 1 - max_similarity
        
        # 4. 综合得分
        score = (1 - alpha) * prob_score + alpha * degeneration_penalty
        scores.append(score)
    
    # 5. 选择得分最高的token
    best_idx = np.argmax(scores)
    return top_k_tokens[best_idx]

为什么有效:

# 避免生成与上文相似的内容
 
上文: "The cat sat on the mat."
 
候选:
- "The" (高概率,但与上文"The"高度相似) 
  → prob_score高,degeneration_penalty低 → 总分中等
  
- "It" (中概率,与上文差异大)
  → prob_score中等,degeneration_penalty高 → 总分高 ✓
  
- "xyzabc" (低概率,差异很大)
  → prob_score很低,degeneration_penalty高 → 总分低
 
结果:选择"It"
输出: "The cat sat on the mat. It purred softly."
# ✓ 流畅且不重复

7. Beam Search(束搜索)

原理:

# 保持多个候选序列,探索不同路径
 
def beam_search(model, prompt, beam_width=5, max_length=50):
    """
    beam_width: 保持的候选序列数量
    """
    # 初始化:一个序列
    beams = [(prompt, 0.0)]  # (序列, 累积log概率)
    
    for _ in range(max_length):
        candidates = []
        
        # 对每个beam扩展
        for seq, score in beams:
            logits = model(seq)
            probs = softmax(logits)
            
            # 获取top-k扩展
            top_probs, top_tokens = torch.topk(probs, beam_width)
            
            for prob, token in zip(top_probs, top_tokens):
                new_seq = seq + [token]
                new_score = score + log(prob)  # 累积log概率
                candidates.append((new_seq, new_score))
        
        # 保留总分最高的beam_width个候选
        beams = sorted(candidates, key=lambda x: x[1], reverse=True)[:beam_width]
        
        # 如果所有beam都结束,停止
        if all(seq[-1] == EOS_TOKEN for seq, _ in beams):
            break
    
    # 返回得分最高的序列
    return beams[0][0]

Beam Search的问题:

问题1: 倾向于生成短序列
# 长序列累积概率低
# 解决:长度归一化
score = log_prob / len(sequence)^alpha  # alpha ≈ 0.6
 
问题2: 缺乏多样性
# 多个beam可能很相似
# 解决:Diverse Beam Search
 
问题3: 仍可能重复
# 需要结合repetition penalty

8. 综合策略:多种技术组合

实践中的最佳组合:

# 常用组合1: 对话系统
temperature = 0.7          # 适度随机
top_p = 0.9               # nucleus sampling
repetition_penalty = 1.2   # 轻度重复惩罚
max_tokens = 2048         # 限制长度
 
# 常用组合2: 创意写作
temperature = 1.0          # 更高随机性
top_p = 0.95              # 更宽松的nucleus
repetition_penalty = 1.5   # 强重复惩罚
frequency_penalty = 0.1    # 鼓励词汇多样性
 
# 常用组合3: 事实性任务
temperature = 0.2          # 低温,更确定
top_k = 10                # 只考虑最可能的
repetition_penalty = 1.1   # 轻微惩罚
beam_search = True        # 使用beam search
 
# 常用组合4: 长文本生成
temperature = 0.8
top_p = 0.92
repetition_penalty = 1.3
presence_penalty = 0.6    # 鼓励使用新词

完整的生成函数:

def generate_with_diversity(
    model, 
    prompt,
    max_length=100,
    temperature=0.7,
    top_p=0.9,
    top_k=None,
    repetition_penalty=1.2,
    frequency_penalty=0.0,
    presence_penalty=0.0
):
    tokens = tokenize(prompt)
    
    for _ in range(max_length):
        # 1. 获取logits
        logits = model(tokens)
        
        # 2. 应用temperature
        logits = logits / temperature
        
        # 3. 应用repetition penalties
        if repetition_penalty != 1.0:
            logits = apply_repetition_penalty(logits, tokens, repetition_penalty)
        
        if frequency_penalty != 0:
            logits = apply_frequency_penalty(logits, tokens, frequency_penalty)
        
        if presence_penalty != 0:
            logits = apply_presence_penalty(logits, tokens, presence_penalty)
        
        # 4. 转换为概率
        probs = softmax(logits)
        
        # 5. 应用top-k
        if top_k is not None:
            probs = apply_top_k(probs, top_k)
        
        # 6. 应用top-p (nucleus)
        if top_p < 1.0:
            probs = apply_top_p(probs, top_p)
        
        # 7. 采样
        next_token = sample(probs)
        
        tokens.append(next_token)
        
        if next_token == EOS_TOKEN:
            break
    
    return tokens

9. 不同任务的参数建议

任务类型TemperatureTop-pTop-kRep. Penalty说明
问答0.1-0.30.1-0.51-101.0-1.1需要准确性
翻译0.30.5101.1保守准确
对话0.7-0.90.9-0.9540-501.1-1.3自然流畅
摘要0.50.8201.2平衡质量
故事1.0-1.20.95-1.3-1.5高创意
诗歌1.2-1.50.98-1.5-2.0极高创意
代码0.2-0.40.5-0.710-201.0-1.1准确性优先
头脑风暴1.5+1.0-1.2最大多样性

总结:如何让文本丰富不单调

核心技术:

  1. 采样策略:用随机采样替代贪心
  2. Temperature:控制分布平滑度(0.7-1.0常用)
  3. Top-k/Top-p:过滤低质量候选(p=0.9常用)
  4. Repetition Penalty:惩罚重复(1.1-1.3常用)
  5. Contrastive Search:平衡概率和差异性
  6. Beam Search:探索多条路径(某些场景)

关键原则:

多样性 ∝ 随机性
但
质量 ∝ 1 / 过度随机性
 
需要平衡!
 
最佳实践:
- 不要使用单一技术
- 组合多种策略
- 根据任务调整参数
- 多次实验找到最佳配置

调参流程:

1. 从默认值开始:
   temperature=0.7, top_p=0.9, repetition_penalty=1.2
 
2. 如果输出太保守/重复:
   ↑ temperature (0.7 → 1.0)
   ↑ top_p (0.9 → 0.95)
   ↑ repetition_penalty (1.2 → 1.5)
 
3. 如果输出太随机/无意义:
   ↓ temperature (0.7 → 0.3)
   ↓ top_p (0.9 → 0.7)
   添加 top_k = 20
 
4. 如果需要更多创意:
   ↑ temperature
   ↑ top_p
   添加 frequency_penalty
 
5. 评估并迭代

实现效果:

"Write a story about a cat"
# 贪心(单调):
"There was a cat. The cat was black. The cat sat on a mat. The cat was happy."
 
# 优化后(丰富):
"In a quaint village nestled between rolling hills, there lived an 
extraordinary feline named Whiskers. Unlike ordinary cats, Whiskers 
possessed an insatiable curiosity about the world beyond her cozy home. 
Each dawn, as golden sunlight painted the cobblestone streets, she would 
embark on new adventures, discovering hidden gardens and befriending 
unlikely companions..."
 
# ✓ 词汇丰富
# ✓ 结构多样
# ✓ 描述生动
# ✓ 无重复

关键洞察:

LLM的本质是概率模型
→ 默认追求"最可能"的输出
→ 导致单调、重复

解决方案:引入受控的随机性
→ 但不是完全随机
→ 是"聪明的随机"
→ 在质量和多样性间平衡

这就是LLM如何让生成的文本丰富而不单调!