揭秘 LLM 的随机性黑盒：从 Temperature + Top-K 到 LangChain Chain 工作流实战

揭秘 LLM 的随机性黑盒：从 Temperature + Top-K 到 LangChain Chain 工作流实战

你有没有想过：为什么同一个问题问 ChatGPT 两次，答案可能不一样？为什么 LLM 有时候严谨得像律师，有时候又天马行空像诗人？这一切的背后，是概率分布 和采样策略 在作祟。本文将从 LLM 生成文本的底层原理出发，深入解析 temperature 和 topK 两个核心参数，再用 LangChain 的 PromptTemplate + StringOutputParser + .pipe() 构建可复用的 AI 工作流，让"随机性"真正为你所用。

前置知识

• 了解 LLM 的基本概念（Transformer、Token 生成）
• 了解 LangChain 基础（ChatOpenAI 调用）
• 有 Node.js + npm 基础

如果还不熟悉 LLM 内部原理，建议先阅读：

• 拆解 LLM 的内部黑盒：从 Token 到 Self-Attention 的逐层解码之旅
• 从零手写 AI Agent

---

一、LLM 是怎么"说话"的？

1.1 不是背诵，是预测

大语言模型（LLM）生成文本的核心机制是自回归预测：给定前面的词，预测下一个词的概率分布。

输入："你好"

LLM 内部计算后，输出下一个词的概率分布：
┌────────┬──────────┐
│  候选词  │  概率     │
├────────┼──────────┤
│  吗     │   0.60   │ ← 概率最高
│  啊     │   0.15   │
│  呀     │   0.10   │
│  美     │   0.05   │
│  坏     │   0.01   │
│  ...   │   ...    │
└────────┴──────────┘

这些概率加起来 = 1.0（概率分布）

LLM 不会直接输出概率最高的词，而是从这个概率分布中采样------就像从一个装了不同颜色球的袋子里随机摸一个，概率高的球更容易被摸到，但概率低的球也有可能。

这就是为什么 LLM 有随机性：每次采样都是一个随机事件。

1.2 控制随机性的两个旋钮

作为开发者，我们有两个核心参数可以调节这种随机性：

参数	作用	类比
temperature	改变概率分布的"陡峭程度"	调音台的均衡器
topK	限制候选词的数量	从全班选 vs 从全校选

---

二、Temperature：把概率分布变"平"或变"陡"

2.1 原理图解

Temperature（温度）通过数学变换改变概率分布的形状：

原始概率分布（temperature = 1.0，不做变换）：

概率
  │
0.6├──────  ┐
   │        │
0.3├────    │
   │   │    │
0.1├─  │    │
   ││  │    │
  ─┴┴──┴────┴───→ 候选词
     吗   啊   呀   美   坏

low temperature = 0.2（分布变"陡"，赢家通吃）：

概率
  │
0.9├────────┐
   │        │
0.1├─       │
   ││       │
  ─┴┴───────┴───→ 候选词
     吗   啊   呀   美   坏
     ↑ 概率被放大，更容易选中"吗"

high temperature = 0.8（分布变"平"，百花齐放）：

概率
  │
0.4├────  ┐
   │      │
0.3├───   │
   │  │   │
0.2├─ │   │
   ││ │   │
0.1├┘ │   │
  ─┴──┴───┴───→ 候选词
     吗   啊   呀   美   坏
     ↑ 概率被压缩，"啊""呀"也有较大机会被选中

2.2 temperature 的实际效果

temperature	效果	适用场景
0	确定性输出，每次都选概率最高的词	代码生成、数学计算、法律合同
0.2~0.4	低随机性，保守但可靠	事实问答、数据分析、技术文档
0.6~0.8	中等随机性，有一定创意	通用对话、头脑风暴、内容改写
1.0+	高随机性，天马行空	创意写作、诗歌、角色扮演

temperature = 0 时，LLM 变成确定性模型：同一个输入永远输出同一个结果。这在需要可重复性的场景中非常有用（比如自动化测试）。

---

三、Top-K：从全班选，还是从全校选？

3.1 原理图解

Top-K 限制了采样时的候选词数量：只从概率最高的前 K 个词中随机选择，其他词直接忽略。

原始概率分布（假设有 50000 个候选词）：

  吗(0.60) 啊(0.15) 呀(0.10) 美(0.05) 坏(0.01) ... 其他49995个词(...)
    │        │        │        │        │           │
    └────────┴────────┴────────┴────────┴───────────┘
                          全部 50000 个词

Top-K = 3（只从前 3 个词中选）：

  吗(0.60) 啊(0.15) 呀(0.10)  美  坏  ...
    │        │        │       ✗   ✗   ✗
    └────────┴────────┴───────────────
        只有 3 个候选词

Top-K = 8（从前 8 个词中选）：

  吗  啊  呀  美  坏  好  啦  呢  ...
    │   │   │   │   │   │   │   ✗
    └────────────────────────────
        有 8 个候选词，更多选择

3.2 Top-K 的作用

Top-K 是一个安全阀：即使 temperature 很高（分布很平），Top-K 也能防止 LLM 选中那些概率极低、完全不相关的词。

Top-K	效果	适用场景
1	只选概率最高的词（等同于 temperature=0）	确定性任务
3~4	少量候选，创意可控	需要一定随机性但不想太离谱
8~10	较多候选，创意丰富	创意写作、头脑风暴
50+	接近不限，随机性主要取决于 temperature	极少使用

---

四、Temperature + Top-K：组合拳

4.1 为什么要组合使用？

组合	效果	场景
temperature 低 + Top-K 大	准确 + 信息完整	代码生成、法律合同：低温保证准确，大 Top-K 保证不因过度截断而遗漏关键信息
temperature 高 + Top-K 小	靠谱地创意	创意写作：高温激发灵感，小 Top-K 防止跑偏到奇怪的方向
temperature 低 + Top-K 小	极度保守	数学题、JSON 格式化：几乎确定性的输出
temperature 高 + Top-K 大	极度发散	诗歌、艺术实验：可能产生惊喜，也可能产生胡言乱语

4.2 常见误区

❌ 误区 1："temperature 和 Top-K 都调到最大，创意最强"
   → 结果：胡言乱语，完全不相关

❌ 误区 2："temperature 和 Top-K 都调到最小，最准确"
   → 结果：虽然准确，但可能过于死板，缺乏灵活性

✅ 正解：根据业务场景组合使用
   代码生成：temperature=0.2, topK=8
   创意写作：temperature=0.8, topK=4

---

五、LangChain Chain 工作流：让 Prompt 和模型可复用

5.1 为什么需要 Chain？

传统的 LLM 调用是这样的：

// ❌ 硬编码 prompt，难以维护
const prompt = `请写一篇短篇散文，主题：秋日山野晚风
风格温柔治愈，篇幅200字左右...`;
const response = await model.invoke(prompt);

问题：

• Prompt 和业务逻辑混在一起
• 同样的 prompt 结构无法复用（换主题就要重写）
• 输出格式不统一（有时候返回对象，有时候返回字符串）

LangChain 的 Chain 把 AI 工作流拆成独立的节点，用 .pipe() 串联起来：

输入变量 ──→ PromptTemplate ──→ LLM ──→ OutputParser ──→ 纯文本输出
   │            │              │           │
   │         模板渲染         模型推理     格式统一
   │         {theme}          deepseek   .content
   │
秋日山野晚风

5.2 Chain 的三大组件

组件	作用	类比
PromptTemplate	定义 prompt 模板，支持变量插值	Vue/React 的模板引擎
ChatOpenAI	LLM 模型，负责推理	后端 API
StringOutputParser	统一解析输出为纯字符串	数据转换器

---

六、完整代码实战

6.1 项目初始化

mkdir llm-chain-demo && cd llm-chain-demo
npm init -y
npm install @langchain/openai @langchain/core dotenv

创建 .env 文件：

DEEPSEEK_API_KEY=sk-your-deepseek-key

6.2 核心代码（main.mjs）

import 'dotenv/config'
import { ChatOpenAI } from '@langchain/openai'
import { StringOutputParser } from '@langchain/core/output_parsers'
import { PromptTemplate } from '@langchain/core/prompts'

// ========== 1. 配置两个不同性格的模型 ==========

// 创意模式：temperature 高，topK 小，天马行空但有边界
const creativeModel = new ChatOpenAI({
  apiKey: process.env.DEEPSEEK_API_KEY,
  model: 'deepseek-v4-pro',
  temperature: 0.8,   // 高随机性，增强创意的发散性
  topK: 4,            // 仅从前 4 个高概率词中采样，限制跑偏
  maxTokens: 600,     // 最大生成 token 数
  configuration: {
    baseURL: 'https://api.deepseek.com/v1',
  }
})

// 严谨模式：temperature 低，topK 大，准确且信息完整
const preciseModel = new ChatOpenAI({
  apiKey: process.env.DEEPSEEK_API_KEY,
  model: 'deepseek-v4-pro',
  temperature: 0.2,   // 低随机性，保守可靠
  topK: 8,            // 更大的候选池，保证信息完整性
  maxTokens: 600,
  configuration: {
    baseURL: 'https://api.deepseek.com/v1',
  }
})

// ========== 2. 定义可复用的 Prompt 模板 ==========

const storyPrompt = PromptTemplate.fromTemplate(`
请写一篇短篇散文，主题：{theme}
风格温柔治愈，篇幅200字左右，不要分段，文字细腻有画面感。
`)

// ========== 3. 定义输出解析器 ==========

// StringOutputParser 把 LLM 的输出（通常是对象）统一解析为纯文本
const outputParser = new StringOutputParser()

// ========== 4. 用 .pipe() 构建 Chain ==========

// Chain = PromptTemplate → LLM → OutputParser
// .pipe() 就是"连接"的意思，前一个组件的输出作为后一个的输入
const creativeChain = storyPrompt
  .pipe(creativeModel)
  .pipe(outputParser)

const preciseChain = storyPrompt
  .pipe(preciseModel)
  .pipe(outputParser)

// ========== 5. 运行对比 ==========

async function runWriteDemo() {
  const theme = '秋日山野晚风'

  console.log('🎨 创意写作模式（temperature=0.8, topK=4）')
  console.log('='.repeat(60))
  const creativeStory = await creativeChain.invoke({ theme })
  console.log(creativeStory)

  console.log('\n')
  console.log('📝 严谨写实模式（temperature=0.2, topK=8）')
  console.log('='.repeat(60))
  const preciseStory = await preciseChain.invoke({ theme })
  console.log(preciseStory)
}

runWriteDemo().catch(console.error)

6.3 运行效果

node main.mjs

🎨 创意写作模式（temperature=0.8, topK=4）
============================================================
山野的晚风是一位温柔的旅人，它穿过金色的稻田，掀起层层波浪。
风里有柿子熟透的甜香，有远处炊烟的暖意，还有落叶飘零时低声的絮语。
夕阳把最后一抹橙红涂在云边，晚风便带着这份温柔，轻轻拂过每一张疲倦的脸庞...

📝 严谨写实模式（temperature=0.2, topK=8）
============================================================
秋日的山野，晚风从山谷吹来，带来凉爽的气息。
稻田已经收割完毕，只剩下整齐的稻茬。
远处的山峦在夕阳下呈现出深浅不一的褐色。
晚风拂过树梢，发出沙沙的声响，几片枯叶飘落地面...

注意：由于 LLM 的随机性，你运行时的实际输出可能与上面不同。尤其是创意模式，每次运行结果都会不同；严谨模式则相对稳定。

---

七、代码逐行深度解读

7.1 .pipe() 的本质

const creativeChain = storyPrompt.pipe(creativeModel).pipe(outputParser)

这行代码构建了一个数据流水线：

invoke({ theme: "秋日山野晚风" })
    │
    ▼
storyPrompt.fromTemplate()
  输入：{ theme: "秋日山野晚风" }
  输出："请写一篇短篇散文，主题：秋日山野晚风\n风格温柔治愈..."
    │
    ▼
creativeModel (ChatOpenAI)
  输入：prompt 字符串
  输出：AIMessage { content: "山野的晚风...", ... }
    │
    ▼
outputParser (StringOutputParser)
  输入：AIMessage 对象
  输出："山野的晚风..."（纯字符串）
    │
    ▼
返回给用户："山野的晚风..."

.pipe() 的核心价值：每个组件只负责一件事，组合起来就是完整的 AI 工作流。

7.2 PromptTemplate 的变量插值

const storyPrompt = PromptTemplate.fromTemplate(`
请写一篇短篇散文，主题：{theme}
风格温柔治愈，篇幅200字左右...
`)

// 调用时传入变量
await creativeChain.invoke({ theme: '秋日山野晚风' })

// 渲染后的 prompt：
// "请写一篇短篇散文，主题：秋日山野晚风
//  风格温柔治愈，篇幅200字左右..."

PromptTemplate 的好处：

• 可复用：同一个模板，换变量就能生成不同的 prompt
• 可维护：prompt 和代码分离，修改 prompt 不用改业务逻辑
• 可组合：多个模板可以串联、嵌套

7.3 StringOutputParser 的作用

// 没有 OutputParser 时，LLM 返回的是对象：
{
  content: "山野的晚风...",
  response_metadata: { ... },
  id: "run-abc123"
}

// 加了 StringOutputParser 后，直接返回：
"山野的晚风..."

在 Chain 中，OutputParser 负责格式统一。如果 Chain 后面还要连接其他组件（比如另一个 LLM 或工具调用），统一成字符串可以减少兼容性问题的发生。

---

八、温度与 Top-K 选择速查表

┌─────────────────────────────────────────────────────────────────┐
│              不同场景的 Temperature + Top-K 推荐                 │
├────────────────────┬───────────────┬─────────────┬──────────────┤
│      场景          │  temperature  │   topK      │   原因       │
├────────────────────┼───────────────┼─────────────┼──────────────┤
│ 代码生成            │     0.0-0.2   │    8-10     │ 准确第一     │
│ 数学计算            │     0.0       │    1        │ 确定性输出   │
│ 法律合同/医疗       │     0.1-0.2   │    8-10     │ 严谨可靠     │
│ 事实问答            │     0.1-0.3   │    6-8      │ 准确为主     │
│ 技术文档            │     0.2-0.4   │    6-8      │ 清晰规范     │
│ 通用对话            │     0.5-0.7   │    5-6      │ 自然灵活     │
│ 内容改写/润色       │     0.6-0.8   │    4-5      │ 有创意不跑偏 │
│ 创意写作            │     0.7-0.9   │    3-4      │ 灵感丰富     │
│ 头脑风暴            │     0.8-1.0   │    3-4      │ 发散思维     │
│ 诗歌/角色扮演       │     0.9-1.2   │    2-3      │ 天马行空     │
└────────────────────┴───────────────┴─────────────┴──────────────┘

---

九、知识图谱

LLM 随机性与 LangChain Chain 知识体系
│
├── LLM 生成机制
│   ├── 自回归预测：上一个词 → 预测下一个词
│   ├── 输出：概率分布（所有候选词的概率之和 = 1）
│   └── 采样：从概率分布中随机选择一个词
│
├── Temperature（温度）
│   ├── 作用：改变概率分布的"陡峭程度"
│   ├── 低温（0~0.3）：分布变陡，赢家通吃，输出确定
│   ├── 高温（0.7~1.0+）：分布变平，百花齐放，输出随机
│   └── 公式：对原始概率进行指数变换后重新归一化
│
├── Top-K
│   ├── 作用：限制采样时的候选词数量
│   ├── Top-K=1：只选概率最高的词（确定性）
│   ├── Top-K 小（3~4）：创意可控，有边界
│   └── Top-K 大（8~10）：信息完整，选择更多
│
├── 组合策略
│   ├── 准确+完整：temperature 低 + Top-K 大
│   ├── 靠谱创意：temperature 高 + Top-K 小
│   └── 两者都大/都小：不推荐
│
├── LangChain Chain
│   ├── PromptTemplate：模板渲染，支持变量 {theme}
│   ├── ChatOpenAI：LLM 模型推理
│   ├── StringOutputParser：统一输出为纯文本
│   └── .pipe()：连接组件，构建工作流
│
└── 注意事项
    ├── maxTokens（不是 maxToken）
    ├── baseURL 建议加 /v1 后缀
    ├── temperature=0 时输出确定
    └── 根据业务场景选择合适的参数组合

---

总结

本文从 LLM 生成文本的底层原理出发，带你完整理解了"随机性"的本质：

1. LLM 不是背诵，是预测：每次生成都是从一个概率分布中采样，所以同一个问题答案可能不同
2. Temperature 改变分布形状：低温让分布变"陡"（准确），高温让分布变"平"（创意）
3. Top-K 限制候选范围：小 Top-K 防止跑偏，大 Top-K 保证信息完整
4. 组合策略是关键：temperature 高 + Top-K 小 = "靠谱地创意"；temperature 低 + Top-K 大 = "准确地完整"
5. LangChain Chain 让 AI 工作流可复用 ：PromptTemplate + .pipe() + StringOutputParser，把 prompt 设计、模型调用、输出解析拆成独立的、可组合的节点

理解 temperature 和 Top-K，是控制 LLM "性格"的第一步。当你能根据业务场景精准调节这两个参数，LLM 就从"黑盒"变成了"可调校的引擎"。

---

参考资料

• OpenAI API: Temperature 参数说明
• DeepSeek API 文档
• LangChain Core: PromptTemplate
• LangChain Core: Output Parsers

---