它是什么

先回答三个问题

先记下你自己的答案，第三讲结束时回来对一遍

1. 你用过 AI 工具吗？用来干什么、有没有哪次结果让你不敢用了。
2. 你打开过命令行吗？不是问会不会用，是问见过没见过那个黑框。
3. 你觉得它错的时候，是「不会」还是「胡说」？先记下你的直觉，板块 1.4 会给出答案。

命令行：同一台电脑的另一个门

不是黑客的东西，是没有图形界面时的正常操作方式

图形界面和命令行不是「简单版」和「高级版」，是同一台电脑的两个门。双击文件夹图标和敲 cd study-DM001 干的是同一件事：把「我现在在哪个目录」这个状态改掉。差别只有一个——图形界面用指，命令行用说。

为什么非要有个用「说」的门？因为说出来的话可以被记下来、重放、串起来、让别人检查。指的动作不行。你没法把「鼠标移到这儿、双击、再拖到那儿」存成文件明年再跑一遍，但你能把三十行命令存成一个脚本。这就是自动化的全部秘密，也是为什么所有能自己干活的工具最后都长出一个命令行。

Python：一门和 SAS 分工不同的语言

不学语法，只建立「一个脚本是怎么跑起来的」这个直觉

先把关系摆正：Python 不是「更好的 SAS」，它是一门通用语言。SAS 是为「表格数据 + 统计过程」这一件事造的，所以它在这件事上顺手得不像话——proc freq 一行就出频数表。Python 什么都能干，代价是什么都得自己拼，或者装个库来拼。

三个必须记住的机制差别：

• SAS 的数据步自带循环，Python 的循环要写出来。data / set / run 这三行背后有一个「逐行读、逐行处理」的引擎，你只写规则。Python 里那个 for 得自己敲——这是初看 Python 代码觉得啰嗦的主要原因。
• SAS 的能力在内置的 PROC 里，Python 的能力在第三方库里。SAS 装好就有几百个过程；Python 装好只有一个很小的内核，pandas、numpy 全是外面的人写的、要自己装。这是两个世界最大的心智落差，0.3 专门讲。
• 缩进是语法。SAS 里空格随便打，Python 里缩进决定了「哪几行属于这个 if」。缩进错了就是逻辑错，而且经常不报错。

还有个更基础的问题：一个脚本到底怎么「跑起来」？check_ae.py 只是个文本文件，本身什么都不会发生。是你在命令行敲 python check_ae.py，启动了叫 Python 解释器的那个程序，让它从上到下，一行一行读这个文件并照做。SAS 里对应的是提交代码给 SAS 引擎、然后看 log——一样的道理。

proc import datafile="raw/ae.csv"
  out=ae dbms=csv replace;
run;

data ae3;
  set ae;
  if AESEV >= 3;
run;

proc freq data=ae3;
  tables USUBJID / nocum nopercent;
run;

import csv

counts = {}
with open("raw/ae.csv") as f:
    for row in csv.DictReader(f):
        if int(row["AESEV"]) >= 3:
            sid = row["USUBJID"]
            counts[sid] = counts.get(sid, 0) + 1

for sid in sorted(counts):
    print(sid, counts[sid])

import pandas as pd

ae = pd.read_csv("raw/ae.csv")
ae3 = ae[ae["AESEV"] >= 3]
print(ae3["USUBJID"]
      .value_counts()
      .sort_index())

库、框架、环境：为什么「在我这儿能跑」

时间紧时可以自学；但第三讲讲 Coding Agent 之前必须补上

一句话分清库和框架：库是你调它，框架是它调你。

• 库（library）：一堆现成的函数，你想用哪个就调哪个，主动权在你手上。pandas 读表、requests 发网络请求。约等于 SAS 里一套别人写好的宏。
• 框架（framework）：它把整个流程的骨架定好了，留出一些位置让你填。程序的运行由框架发起，你的代码只是被它在合适的时候叫起来。第二讲会提到的 LLM 应用框架就是这类东西。它省掉的是搭骨架的功夫，换来的是必须按它的规矩写。

接下来是最实际的一件事：库要装。装库的工具叫 pip，敲 pip install pandas，它去一个叫 PyPI 的公共仓库把包下载下来。这里埋着两个我们躲不开的问题。

python3
 └─ site-packages/
     └─ (空)

study-DM001/.venv/  → (空)
study-DM002/.venv/  → (空)

API 与 JSON：机器之间怎么说话

这一节是板块 0 里最该讲的——后面两讲全靠它

API 是一台机器留给另一台机器用的表单。它规定了三件事：往哪个地址发、表单上有哪些格子、填对了会回你什么。人用网页，机器用 API，背后往往是同一套系统。

那张表单用 JSON 这种格式写。JSON 只有两种结构，看一眼就够：{} 是「键值对」（像一行观测，字段名 → 值），[] 是「列表」（像一叠行）。整个 AI 应用领域的数据都长这个样子，包括第二讲的工具调用、第三讲的 Agent 消息记录。板块 3.3 还会讲怎么让模型直接吐 JSON。

POST https://api.anthropic.com/v1/messages
x-api-key: sk-ant-••••••••••••
anthropic-version: 2023-06-01
content-type: application/json

{
  "model": "claude-opus-5",
  "max_tokens": 2048,
  "system": "你是临床数据审阅助手。只依据提供的数据回答，无法确定时明确说无法确定。",
  "messages": [
    {
      "role": "user",
      "content": "以下是 3 条 AE 记录……01-001-0042 有几条 3 级事件？"
    }
  ],
  "output_config": { "effort": "medium" },
  "thinking": { "type": "adaptive" }
}

{
  "id": "msg_01Ab2Cd3Ef4Gh5",
  "type": "message",
  "role": "assistant",
  "model": "claude-opus-5",
  "content": [
    {
      "type": "text",
      "text": "01-001-0042 有 2 条 3 级事件：\n中性粒细胞减少（2026-03-14）、\n发热（2026-03-21）。"
    }
  ],
  "stop_reason": "end_turn",
  "usage": {
    "input_tokens": 1284,
    "output_tokens": 96,
    "cache_read_input_tokens": 0
  }
}

Git：为什么 Agent 都围着它转

时间紧时可以自学；只需要建立一个概念

Git 是版本控制工具。对这门课来说，只需要理解它提供的一样东西：一个可以随时回到的已知良好状态。

• commit（提交）：给当前所有文件拍一张快照，附一句说明。快照永远在，随时能回去。
• branch（分支）：从主线拉一条岔路做实验，做坏了整条丢掉，主线一点没动。
• diff（差异）：两个快照之间逐行的变化。这是审阅的单位。
• PR（合并请求）：「我改完了，请复核后并回主线」——一个带评论和批准的正式流程。

这四个词解释了第三讲的一个观察：所有严肃的 Coding Agent 都要求项目在 Git 里。原因很直白——它要改一堆文件，而你需要在它改坏的时候一键回退，还需要逐行看它到底改了什么。Git 是把「让 AI 改代码」从赌博变成可控操作的那件东西。

@@ -4,7 +4,9 @@
 counts = {}
 with open("raw/ae.csv") as f:
     for row in csv.DictReader(f):
-        if int(row["AESEV"]) >= 3:
+        sev = row["AESEV"].strip()
+        if not sev.isdigit():
+            continue
+        if int(sev) >= 3:
             sid = row["USUBJID"]

上面是一个 Agent 真实会产出的那种改动：它发现 AESEV 有空值时原来的 int() 会崩，于是加了防护。这就是你要审的东西——四行，一眼能看完，判断得出对不对。

它只做一件事：猜下一个 token

全课程最重要的一节。后面所有结论都从这一句推出来

大模型的全部工作是：读入一段文字，输出「下一个 token 该是什么」的一张概率表。就这样。没有理解、没有意图、没有查询数据库。它反复做这一件事，一次一个 token，把自己刚吐出来的接回输入，再猜下一个。

先解决那个词：token 不是「字」也不是「词」，是模型的最小切分单位。它是拿海量文本统计出来的——常见的片段占一个位置，不常见的被拆开。模型眼里的世界就是一串 token 编号，它从来没见过「字母」这个东西。这一条比听起来重要，先摸一下。

知道了输入是什么，再看那个循环。这是全课程最该记住的一张图：

从「补全机器」到「助手」：三段式训练

这一节解释为什么它会「听话」——以及听话是被训出来的，不是天生的

上一节那个循环只会补全文本。一个只会补全的模型，你问它问题，它不会回答，它会接着往下编更多问题。它变成一个「助手」，靠的是训练完之后的两道加工。

三个硬约束：token、上下文窗口、知识截止

这三条不是缺点，是物理边界。绕不过去，只能规划

1. token 是计价单位，进出都算。输入的每个 token 和输出的每个 token 分别计费，输出通常贵好几倍。以 Claude Opus 5 为例：输入 $5 / 百万 token，输出 $25 / 百万 token。关键是 0.4 讲过的那件事——每一轮都把全部历史重发一遍，所以一段长对话的成本不是线性增长，是越聊越快地涨。
2. 上下文窗口是一次能塞进去的 token 总量上限。Claude Opus 5 是 100 万 token，Haiku 4.5 是 20 万。但这个数字是「输入 + 输出」共享的，而且要给系统提示词、工具定义、对话历史都留位置。你真正能用来放文档的，远少于标称值。
3. 知识截止日期是一条硬线。训练数据截止之后发生的事，它一概不知道——而且不知道自己不知道。任何涉及「最新版指南」「今年的法规」「上个月的会议决定」的问题，答案只能由你提供，不能问它。

幻觉：自信和正确是两件不相干的事

回到开场第 3 题——答案是「都不是」

开场问过：它错的时候是「不会」还是「胡说」？正确答案是：这个区分在机制上不存在。它每一步都在做同一件事——从概率表里抽一个 token。表很尖的时候抽出来是对的，表很平的时候抽出来是编的，而这两种情况生成的句子在语气上完全一样。

关键在于：那张概率表里没有「我不知道」这个选项占据高位。模型必须输出某个 token，它不能输出「空」。所以在它没有相关知识时，概率会摊薄到一堆格式正确、看起来合理的候选上——然后其中一个被抽中，被当作既定事实接着往下写。

能真正降低幻觉的四件事

提示词到底在做什么：关掉歧义

先讲原理，五要素只是原理的一个清单

回到 1.1：模型在算「下一个 token 的概率分布」。你的提示词是这张分布的唯一条件。提示词模糊，意味着有一大片彼此矛盾但都合理的续写共享概率——它抽中哪个都是偶然。提示词精确，意味着概率集中到你想要的那一片上。

所以「写好提示词」不是修辞问题，是信息问题：你每补一句话，就从模型的猜测清单上划掉一项。下面这个演示把这件事直接摊开。

五要素：一张不用记的检查表

示例驱动：给两个例子胜过写五段说明

最省力的一招，原因也在 1.1 那张概率表里

为什么例子比说明有效？因为说明要模型先理解再翻译成行为，例子直接就是行为。你给它两条「输入 → 输出」的实例，它要做的只是把这个模式延续下去——而延续模式恰好是它唯一擅长的事。

更准确的说法是：例子在收窄可能性，不是在增加信息。下面这个演示把这个过程画出来。

让它「多想一会儿」：什么时候值这个钱

这一节的参数细节半年就会变，判断标准不会变

所谓推理模型（或者「思考模式」），做的事很朴素：在给出答案之前，先生成一段推导过程。那段推导也是 token，一样计费、一样占窗口，只是通常不展示给你看。

为什么这会有效？回到 1.1 的第 ③ 条——模型没有回头修正的机制，已经写出来的就是前提。所以如果它一上来就要报答案，那个答案是「一步蒙出来的」。让它先把中间步骤写出来，每一步都成为下一步的上下文，等于给了它一张草稿纸。

四种失效：每一种都有固定改法

四组前后对照，可以直接照着改自己的提示词

失效一 · 任务笼统：动词没说清

帮我处理一下这个 AE 数据集。

逐条检查下面的 AE 记录，找出
「结束日期早于开始日期」和
「严重程度为 3 级以上但结局为
已恢复且未采取任何措施」这两类
矛盾，列出涉及的 USUBJID 和
AESEQ。不要给处理建议。

失效二 · 上下文缺失：问了它不可能知道的事

我们这个研究的主要终点该怎么
定义比较合适？

以下是方案第 4 节的原文：
【粘贴原文】

依据以上原文，说明主要终点的
定义和评估时点。原文未写明的
部分，回答「方案中未写明」，
不要推测。

失效三 · 一次问太多：五个任务挤一句

把这份数据检查一遍，总结主要
发现，写成给申办方的邮件，
再列出后续要做的事，顺便看看
有没有需要报告的 SAE。

第一步（只做这一步）：逐条检查
下面记录，输出问题清单，每条
注明 USUBJID 和问题类型。

——确认清单无误后，再发第二条
提示词让它写邮件。

失效四 · 隐含前提没说：你以为是常识的东西

把这些日期统一一下格式。

把下列日期改写成 ISO 8601
（YYYY-MM-DD）。规则：
· 只有年月的写成 YYYY-MM，
  不要补日
· 完全缺失的留空，不要写 NA
· 任何无法确定的，原样保留并
  在末尾加 (?) 标记

上下文是上限

这一节只有一个观念，但它决定后面所有做法

「上下文」指的是这一次调用时，模型能看到的全部文字：系统提示词、工具定义、之前每一轮对话、你粘进去的文档、工具返回的结果——0.4 那个请求体里的全部内容。

它是上限，因为回到 1.1：模型的输出是以上下文为条件的概率分布。不在上下文里的事实，不会以任何方式影响这个分布（除了它训练时碰巧记住的那部分，而那部分你既不能查也不能改）。所以：

• 没给的事实，它只能编。不是它不努力，是那个信息根本不在算式里。
• 给错的事实，它会当真。它没有「这条看着不对」的核验步骤，除了你明确让它核。
• 给多了，它会分心。3.4 会说明为什么——这一条最反直觉。

长文档和表格是怎么进去的，以及损耗在哪

对我们最实际的一节——我们的材料几乎全是表格和长文档

模型的输入只有一种形状：一串 token。所以任何东西进去之前都要先拉平成文本。这个拉平过程是我们大部分「它读错了表」问题的真正来源。

• 表格失去二维结构。一张表拉平成文本后，「这个 3 属于 AESEV 这一列」这件事，只能靠列的先后顺序和表头的位置推断。行一多、列一宽，对齐关系就开始飘。
• PDF 的排版会打乱顺序。双栏、页眉页脚、跨页表格，抽出来的文本顺序常常和你看到的不一样。扫描版 PDF 更糟——那是图片，要先 OCR，而 OCR 会把 0 认成 O、把 1 认成 l。
• Excel 的合并单元格会变成空值。拉平后合并区域只有第一格有值，剩下的是空——而空值在它眼里就是「没有」。
• 长文档要切块。超过窗口就得切，而切在哪里，决定了信息还能不能被找到。

结构化输出：让它给 JSON，而不是给散文

这一节决定了「能不能接进现有流程」

只要结果的下一站是程序而不是人，就必须要求结构化输出。理由不是好看，是散文的形状不稳定：同一个意思它能有十种写法，而每一种都要下游写一套解析——这活干不完。下面这个演示直接跑给你看。

上下文污染：为什么对话越长越笨

这一节收掉第一讲，也直接接上第二讲

直觉会说：给的信息越多，它答得越好。实际不是。塞到一定程度之后，质量会掉。原因有五个，前两个是模型本身的，后三个是我们自己造成的。

1. 信噪比下降。相关的那两句话，从占上下文的 50% 变成占 0.5%。它没有「先检索再回答」这一步——所有 token 都平等地参与那一次计算，噪声也一样参与。
2. 中段位置劣势。放在开头和结尾的信息更容易被用上，埋在中间的最容易被忽略——即使它完全在窗口之内。这是公开研究反复观察到的现象，业内叫 lost in the middle。
3. 失效的旧指令还在里面。你第 3 轮说「用中文」，第 20 轮说「改成英文」——两条都在上下文里，它得自己判断哪条算数，有时判断错。
4. 它自己的错误成了前提。第 5 轮它编了一个变量名，这句话现在是上下文的一部分。后面每一轮它都会把那个编造当成已经确认的事实。这是 1.1 第 ③ 条在多轮尺度上的放大版。
5. 工具返回的原始结果堆积。Agent 场景里最严重：每次调用都往上下文里倒一大段原始输出，几轮之后真正的任务描述被埋在几万 token 底下。第二讲、第三讲会反复回到这个问题。

四个立刻能用的办法

如果只带走三句话

1. 它只会猜下一个 token。算数不准、会编造、错了会顺着错下去——全部从这一句推得出来，不用另外记。
2. 上下文是上限。提示词决定它怎么答，上下文决定它能不能答对。十次答不好，七次是材料没给够。
3. 自信和正确不相干。它语气最肯定的时候，恰恰可能是它最没根据的时候。「看起来很专业」在我们这行不构成任何证据。

到第二讲之间做三件事

1. 改写一句你自己的提示词，记录前后差别。用板块 2 的五问改一句你这周真的问过的话，把两次的回答都留着，第二讲开场分享。这是唯一必做的一项。
2. 找一次它编造的记录。故意问它一件它不可能知道的事（我们某个内部编号、某份内部 SOP 的条款），把它编出来的东西截图。亲眼见过一次，比听十遍「它会幻觉」有用。
3. 打开一次命令行，敲三条命令。Mac 上是「终端」，Windows 上是 PowerShell。pwd、ls（Windows 上是 dir）、cd 各一次。目标只是让那个黑框从「陌生」变成「见过」——第三讲讲终端型 Agent 时会用到这个熟悉感。