前言:聊天记录不能直接排版,得先变成“书的素材”
我想把一段很长的微信聊天记录做成一本书。
原因也简单:这段聊天记录对我来说很有纪念意义。手机里的记录平时就是往上翻一翻,翻着翻着就沉底了,有些话、有些事,过几年可能就想不起来了。做成一本书就不一样了,能拿在手里,一页一页翻,也能放着过几年再看。所以我想趁着还记得清楚,把它整理出来,留个纪念。
真动手才发现,难点根本不在排版。聊天记录导出来是二十多万行数据,里面有系统消息、有连着发的十几条短消息、有隔了好几天又接上的话题。你把这个东西直接丢给排版软件,出来的不是书,是一本流水账,谁也看不下去。
所以整个流程其实是五步:
- 清洗:探查导出文件的结构,按时间截取要用的范围,去掉系统消息的干扰;
- 切分:先把连续发言合并成“轮”,再按时间间隔把对话切成大章(Episode)和小节(Scene);
- 筛选:先用零成本的机械规则初筛,把明显的噪音挑出去,剩下的再让 AI 逐节提炼、打分;
- 人工编辑:AI 打完分不算数,人还要过三道筛选,最后自己定全书结构;
- 成书:按结构把素材重组,在一个本地编辑工作台里逐场编辑,导出排版文件。
下面按实际做的顺序写,每一步都说清楚为什么这么做、代码长什么样、坑在哪。数据规模我给个大概量级:原始导出二十多万行,最终进编辑工作台的是几十个场景。中间每一步砍掉多少、为什么砍,后面都有数字。
一、探查:先别急着处理,先看清导出文件长什么样
先说导出:这一步我不展开,GitHub 上有很多开源的微信聊天记录导出项目,自己搜一下就能找到,挑一个能导出成 JSONL 格式的就行。
导出拿到的是一个 JSONL 文件,一行一个 JSON 对象。二十多 MB、二十多万行,这个体量有个纪律:所有探查和清洗都逐行流式读,绝不整体加载进内存。一行一行读,内存里最多留统计结果,这是后面每个脚本都遵守的。
探查脚本做三件事:统计总行数和解析成功率、递归扫描字段结构(只扫前 2000 行做代表性采样,够看清结构了)、给每个字段留几个样本值。核心就是下面这段:
import json
from collections import defaultdict
SRC = "chat_export.jsonl" # 换成你的导出文件
INVENTORY_TOP = 2000 # 字段结构只扫前 2000 行
collector = defaultdict(lambda: {"types": set(), "count": 0})
samples = defaultdict(list)
total = ok = err = 0
with open(SRC, encoding="utf-8", errors="replace") as f:
for ln in f:
total += 1
s = ln.strip()
if not s:
continue
try:
obj = json.loads(s)
ok += 1
except Exception:
err += 1
continue
if total <= INVENTORY_TOP and isinstance(obj, dict):
for k, v in obj.items():
collector[k]["types"].add(type(v).__name__)
collector[k]["count"] += 1
if isinstance(v, (str, int, float)) and len(samples[k]) < 5:
samples[k].append(str(v)[:120])
print(f"总行数 {total},解析成功 {ok},失败 {err}")
for k in sorted(collector):
print(k, collector[k]["types"], samples.get(k, []))
探查完要确认这几件事,后面全靠它们:
- 行分三类,靠
_type区分:header(文件头,只有 1 行)、member(成员信息)、message(消息主体)。处理时只认message,但header要原样保留,别弄丢。 - 消息的时间在
timestamp字段,是 Unix 秒。所有时间计算都基于它,展示时再按北京时间(UTC+8)转。 - 消息类型在
type字段:0是普通文本,80是系统消息 / 时间分隔消息。这个 80 后面会反复出现——它不是人说的话,统计和切分时要单独对待。 - 说话人靠
accountName/sender区分。归一化成三类就够了:我、对方、系统。
二、截取:只取要做成书的那段时间
一本书装不下全部历史,我只取其中一段时间做正文。截取脚本的要点有两个:
第一,时间边界必须带时区算。timestamp 是 Unix 秒,你心里想的“某天零点”是北京时间零点,换算时必须显式带 timezone(timedelta(hours=8)),直接用本地时间或 UTC 算都会偏 8 小时,要么漏掉第一天,要么多收一天。
第二,没有时间戳的结构行(header / member)原样保留,只按时间过滤消息行。不然截完的文件头就没了,后面的脚本会找不到元信息。
import json
from datetime import datetime, timezone, timedelta
SRC = "chat_export.jsonl"
OUT = "chathistory.jsonl"
# 起始日零点,北京时间。示例日期,换成你自己选的那天
CUTOFF_DT = datetime(2025, 1, 1, 0, 0, 0,
tzinfo=timezone(timedelta(hours=8)))
CUTOFF_TS = int(CUTOFF_DT.timestamp())
NOW_TS = int(datetime.now(timezone.utc).timestamp())
total_out = msg_out = 0
kept_min = kept_max = None
with open(SRC, encoding="utf-8", errors="replace") as fin, \
open(OUT, "w", encoding="utf-8") as fout:
for ln in fin:
raw = ln.rstrip("\n")
if not raw.strip():
continue
obj = json.loads(raw)
ts = obj.get("timestamp")
if ts is None:
fout.write(raw + "\n") # 结构行原样保留
total_out += 1
continue
if CUTOFF_TS <= ts <= NOW_TS:
fout.write(raw + "\n")
total_out += 1
msg_out += 1
kept_min = ts if kept_min is None else min(kept_min, ts)
kept_max = ts if kept_max is None else max(kept_max, ts)
print(f"输出 {total_out} 行,其中消息 {msg_out} 行")
我这次截完剩 8.6 万条消息,后面所有处理都基于这个范围。
三、定阈值之前,先统计间隔:切分参数不能拍脑袋
后面要按“沉默了多久”来切分对话:沉默多久算一节结束?多久算一章结束?这个数不能拍脑袋,要先统计相邻消息的真实间隔分布,再从分布里选。
统计方法很简单:把所有消息的时间戳升序排好,算相邻差 gap[i] = t[i] - t[i-1],然后看中位数、均值和 P90 / P95 / P99 分位数,再做一张“如果阈值取 X 分钟,会切出多少个断点”的参考表。注意要出两套数:一套含系统消息,一套排除 type=80——系统消息会在隔夜处插一个“伪长间隔”再接一个近零间隔,污染分布,按真实内容切分要用排除系统消息的那套。
import json, statistics
def collect_timestamps(path):
all_ts, real_ts = [], []
with open(path, encoding="utf-8", errors="replace") as f:
for ln in f:
s = ln.strip()
if not s:
continue
try:
obj = json.loads(s)
except Exception:
continue
if obj.get("_type") != "message":
continue
ts = obj.get("timestamp")
if not isinstance(ts, (int, float)):
continue
all_ts.append(int(ts))
if obj.get("type") != 80: # 排除系统消息
real_ts.append(int(ts))
return sorted(all_ts), sorted(real_ts)
def gaps(ts_list):
return [ts_list[i] - ts_list[i-1] for i in range(1, len(ts_list))]
all_ts, real_ts = collect_timestamps("chathistory.jsonl")
g = gaps(real_ts)
qs = statistics.quantiles(g, n=100, method="inclusive")
print(f"中位数 {statistics.median(g)}s,均值 {statistics.mean(g):.0f}s")
print(f"P90 {qs[89]/60:.1f} 分,P95 {qs[94]/60:.1f} 分,P99 {qs[98]/60:.1f} 分")
# 阈值参考表:取这个阈值,会切出多少个断点
for t_min in [5, 15, 30, 60, 120, 360, 1440]:
breaks = sum(1 for x in g if x > t_min * 60)
print(f"阈值 {t_min:>4} 分钟 → 潜在断点 {breaks}")
我这份数据的结果(消息级):
- 中位数只有 7 秒,均值却有 6.4 分钟,最大间隔 41 小时。典型的强右偏长尾:绝大多数消息是秒回,少数沉默特别长。
- 82.66% 的间隔在 1 分钟以内;P90 是 4.8 分钟,P95 是 19.4 分钟,P99 是 111 分钟。
- 阈值参考:取常见的 30 分钟,会切出 3101 个断点;取 2 小时,813 个;取 6 小时,378 个。
这张表就是后面所有时间参数的依据,思路是这样的:
- 阈值必须落在长尾里,不能落在主体分布里。 中位数 7 秒、P90 才 4.8 分钟,说明几分钟的停顿根本就是正常聊天节奏的一部分,拿 5 分钟、15 分钟当断点,会把一次好好的对话切得稀碎。
- 书的切分单位要比“会话”大。 做客服质检、做会话分析的人常用 30 分钟切 session,但一本书的一节不等于一次 session。3101 个断点意味着三千多个碎片,人根本没法往下编。所以最后定的两档是:2 小时切一节(Scene),6 小时切一章(Episode)。2 小时在 P99 附近,意味着“沉默超过 2 小时”已经是不到 1% 的少数事件,拿它当断点,切出来的正好是“一场完整的对话”;6 小时基本就是隔夜、隔天了,天然是章节之间的分界。
- 这两个数不是通用真理,是从这份数据的分布里长出来的。你的数据节奏不一样,先跑一遍这个统计,再定你自己的。
四、合并连续发言:一轮一行
微信聊天的常态是一个人连发好几条短消息,那是一句话分了几条发,不是几轮对话。如果不先合并,后面的间隔统计和切分全是错的:轮内的秒级间隔会把分布压扁,切出来的场景也会碎。
合并规则:
- 说话人归三类:我 / 对方 / 系统(
type=80)。 - 同一人连续发的消息合成一轮,内容用换行拼接,记一个
merged_count。 - 每一轮的
timestamp取该轮最后一条消息的时间,另存ts_start记第一条的时间。这样相邻两轮的间隔,正好是“上一轮说完到下一轮开口”的真实空闲时间,后面切分算的就是这个。 - 加一条 2 小时断点规则:同一个人,如果相邻两条消息间隔超过 2 小时,也强制断成新的一轮。
最后这条是踩过坑才加的。第一版没这条规则,结果有的“轮”名义上是同一个人连续发言,中间其实隔了几个小时——人睡了一觉起来接着说,也被算成同一轮。重跑时加上 MERGE_GAP = 2 小时,轮数从 34394 变成 34825。判定的是“相邻两条消息的间隔”,不是“这一轮总共持续了多久”:一轮可以累计聊 5 个多小时,只要中间没有超过 2 小时的沉默,它就还是连续的一轮,没毛病。
import json
SRC = "chathistory.jsonl"
OUT = "chathistory_merged.jsonl"
MERGE_GAP = 2 * 3600 # 同一人相邻消息间隔 >2h 也断开
SYS_TYPES = {80}
LABEL = {"me": "我", "other": "对方", "system": "系统"}
def speaker_key(obj):
if obj.get("type") in SYS_TYPES:
return "system"
if obj.get("accountName") == "我":
return "me"
return "other"
header_line, msgs = None, []
with open(SRC, encoding="utf-8", errors="replace") as f:
for ln in f:
s = ln.strip()
if not s:
continue
obj = json.loads(s)
if obj.get("_type") == "header" and header_line is None:
header_line = s
continue
if obj.get("_type") != "message":
continue
ts = obj.get("timestamp")
if isinstance(ts, (int, float)):
msgs.append({"ts": int(ts), "key": speaker_key(obj),
"sender": obj.get("sender"),
"type": obj.get("type"),
"content": obj.get("content", "")})
msgs.sort(key=lambda m: m["ts"])
turns, cur, prev_ts = [], None, None
for m in msgs:
if cur is None or m["key"] != cur["key"] or (m["ts"] - prev_ts) > MERGE_GAP:
cur = {"key": m["key"], "contents": [], "start_ts": m["ts"],
"end_ts": m["ts"], "sender": m["sender"], "type": m["type"]}
turns.append(cur)
cur["contents"].append(m["content"])
cur["end_ts"] = m["ts"]
prev_ts = m["ts"]
with open(OUT, "w", encoding="utf-8") as f:
if header_line:
f.write(header_line + "\n")
for t in turns:
f.write(json.dumps({
"_type": "message", "sender": t["sender"],
"accountName": LABEL[t["key"]],
"timestamp": t["end_ts"], "ts_start": t["start_ts"],
"type": t["type"], "merged_count": len(t["contents"]),
"content": "\n".join(t["contents"]),
}, ensure_ascii=False) + "\n")
print(f"{len(msgs)} 条消息 → {len(turns)} 轮")
合并完再跑一遍第三节的间隔统计(轮级口径):中位数变成 23 秒,P95 变成 57 分钟,P99 变成 433 分钟(约 7.2 小时)。轮内的秒级间隔被剔掉之后,分布才真正反映“对话和对话之间的空闲”,2 小时 / 6 小时这两档阈值放在这个分布里看,正好一个在 P95 与 P99 之间、一个贴近 P99,和第三节的判断对得上。
五、分界线裁切:按日期硬切会切断上下文
正文开始的那一天,我心里是有一条分界线的。麻烦在于:分界线之前还有一小段记录,它和分界线之后的内容是不是一回事,不能只看日期。
举例说:分界线前一天晚上聊到一半,睡了几个小时,第二天接着聊——这段其实是正文的开头,硬按日期切就把它切没了。再往前,还有些更早的、零散的旧片段,中间隔着很长的沉默,那些才是真正要丢掉的。
所以裁切规则不是“分界线之前全丢”,而是:
- 分界线及之后的轮,全部保留;
- 分界线之前的轮,从最靠近分界线的那一条往回扫,只要相邻间隔不超过 2 小时,就认为它和后面是连着的,保留;遇到第一个超过 2 小时的间隔就停,那个间隔之前的全部丢弃。
阈值还是 2 小时,和合并、切分用同一把尺子,逻辑是一致的:超过 2 小时的沉默,就是一次“断开”。
import json
from datetime import datetime, timezone, timedelta
SRC = "chathistory_merged.jsonl"
OUT = "chathistory_merged_trimmed.jsonl"
TZ = timezone(timedelta(hours=8))
CUT_DATE = (2025, 1, 15) # 分界线日期,示例,换成你自己的
GAP_SEC = 2 * 3600 # 相邻间隔 >2h 即截断
line_ts = int(datetime(*CUT_DATE, 0, 0, 0, tzinfo=TZ).timestamp())
header_line, turns = None, []
with open(SRC, encoding="utf-8", errors="replace") as f:
for ln in f:
s = ln.strip()
if not s:
continue
obj = json.loads(s)
if obj.get("_type") == "header" and header_line is None:
header_line = s
continue
if obj.get("_type") == "message" and isinstance(obj.get("timestamp"), (int, float)):
turns.append(obj)
turns.sort(key=lambda o: o["timestamp"])
before = [t for t in turns if t["timestamp"] < line_ts]
after = [t for t in turns if t["timestamp"] >= line_ts]
keep_before, last_kept_ts = [], None
for t in reversed(before):
if last_kept_ts is None:
keep_before.append(t) # 最靠近分界线的,必留
elif last_kept_ts - t["timestamp"] <= GAP_SEC:
keep_before.append(t) # 还连着,留
else:
break # 断开了,更早的全丢
last_kept_ts = t["timestamp"]
keep_before.reverse()
with open(OUT, "w", encoding="utf-8") as f:
if header_line:
f.write(header_line + "\n")
for t in keep_before + after:
f.write(json.dumps(t, ensure_ascii=False) + "\n")
print(f"分界线前 {len(before)} 轮,保留尾部 {len(keep_before)} 轮,"
f"丢弃 {len(before) - len(keep_before)} 轮")
我这次的结果:分界线前有 1159 轮,最后只保留了尾部 6 轮,丢掉 1153 轮。看着砍得多,其实是对的——那 6 轮正是分界线前夜连着聊下来的开头,再往前隔着一段很长的空白,旧片段留着只会让书的开头莫名其妙。
六、两级切分:6 小时一章,2 小时一节
裁切完,就可以正式切结构了。两级:
- 相邻两轮间隔 > 6 小时 → 新的一章(Episode);
- 同一章内,间隔 > 2 小时 → 新的一节(Scene)。
为什么是这两档,第三节已经从分布上解释过了,这里再补一句体感上的:6 小时基本意味着“睡了一觉”或者“隔天了”,是一天和另一天的分界,放在章与章之间正好;2 小时意味着“这场对话聊完了,过了一阵子又起了个新话题”,是一场和一场的分界,放在节与节之间正好。切分的尺子要和人的生活节奏对上,光看统计数字不够。
切分代码本身不复杂,核心就是维护“当前章、当前节、上一轮时间”三个状态往下走:
import json
from datetime import datetime, timezone, timedelta
EPISODE_GAP = 6 * 3600 # >6h 开新章
SCENE_GAP = 2 * 3600 # >2h 开新节
TZ = timezone(timedelta(hours=8))
def fmt(ts):
return datetime.fromtimestamp(ts, TZ).strftime("%Y-%m-%d %H:%M:%S")
# turns 是从 chathistory_merged_trimmed.jsonl 读出、按 timestamp 升序的轮列表
episodes, cur_ep, cur_scene, prev_ts = [], None, None, None
def new_episode():
ep = {"episode_index": len(episodes) + 1, "scenes": []}
episodes.append(ep)
return ep
def new_scene(ep):
sc = {"scene_index": len(ep["scenes"]) + 1, "turns": []}
ep["scenes"].append(sc)
return sc
for t in turns:
ts = t["timestamp"]
if cur_ep is None:
cur_ep = new_episode()
cur_scene = new_scene(cur_ep)
else:
gap = ts - prev_ts
if gap > EPISODE_GAP:
cur_ep = new_episode()
cur_scene = new_scene(cur_ep)
elif gap > SCENE_GAP:
cur_scene = new_scene(cur_ep)
cur_scene["turns"].append(t)
prev_ts = ts
total_scenes = sum(len(ep["scenes"]) for ep in episodes)
print(f"{len(episodes)} 章 / {total_scenes} 节 / {len(turns)} 轮")
我这次切出来是 360 章、888 节。
切完马上生成了一个可视化页面检查效果:把结构化 JSON 内嵌进一个单文件 HTML,双击就能打开,左边是章列表,右边按节折叠展示对话,我在一侧、对方在另一侧、系统消息居中虚线。这里有个贯穿全程的小技巧:内嵌 JSON 时要把 < 转义掉(json.dumps(...).replace("<", "\\u003c")),不然对话内容里只要出现一个 </script>,整个页面就废了。后面每个 HTML 工具都用了这一手。
七、机械分级:先零成本初筛,别一上来就烧 API
888 节全丢给 AI 分析,又慢又贵,而且里面有大量没营养的内容:互发一个表情、转个账、问一句“到了吗”。先用纯规则做一轮机械分级,一分钱不花,先把盘子缩小。
先算一条全局基线:全量真实轮次(排除系统消息)的单条字数,均值 μ≈21 字,标准差 σ≈49 字。然后逐节抽 7 个特征:
| 特征 | 含义 |
|---|---|
| turns | 这一节有多少轮 |
| total_chars | 总字数 |
| max_len / z_score_max | 最长一条的字数,及其离群程度 Z = (Lmax - μ) / σ |
| has_midnight | 是否包含凌晨 1 点到 5 点的消息 |
| burst_max_5m | 5 分钟滑动窗口内最多的轮数 |
| has_special | 是否含 [图片]、[转账] 这类占位标记 |
分级按严格优先级,先判高光,再判噪音,剩下的是常规:
- 高光:
Z > 2.5(突然写了一篇“小作文”,字数离群),或深夜时段且总字数 ≥ 30(深夜长聊),或 5 分钟内轮数 ≥ 15(你来我往的密集对话)——命中任意一条即高光; - 噪音:轮数 ≤ 3 且真实文字 < 15 字;
- 常规:其余全部。
import re
_SPECIAL_RE = re.compile(r"\[[^\[\]]+\]")
def real_text_len(s: str) -> int:
"""真实文字数:扣掉 [图片]/[转账]/[语音] 这类 [...] 占位符后的长度。"""
return len(s) - sum(len(m) for m in _SPECIAL_RE.findall(s))
def tier_of(T, C_total, real_text_total, Z_max, H_midnight, V_burst):
reasons = []
if Z_max > 2.5:
reasons.append("Z_max > 2.5(小作文)")
if H_midnight == 1 and C_total >= 30:
reasons.append("深夜长聊")
if V_burst >= 15:
reasons.append("密集对话(5 分钟内 ≥15 轮)")
if reasons:
return "high_priority", reasons
if T <= 3 and real_text_total < 15:
return "noise", ["极短且真实文字 <15"]
if real_text_total == 0:
return "noise", ["纯占位,无任何文字"]
return "normal", ["常规归流"]
这一节有两个坑,都是真踩了才知道的:
坑一:噪音判定会被占位符骗过去。 第一版噪音规则是“轮数 ≤3、总字数 <15、无特殊标记”。结果互发转账这种内容漏网了:两条 [转账] 占位符本身就凑够了十几个字符,字数不达标;而且“有特殊标记”本来是想保护有图片的场景,反倒把纯转账也保护了。修法是上面那个 real_text_len():算字数之前先把所有 [...] 占位符扣掉,只算真实文字;再加一条兜底,真实文字等于 0 的,不管多少轮都是噪音。改完噪音从 63 节涨到 114 节,这才是对的。
坑二:公式算出来的比例和直觉差很远,要老实记录偏差,别硬凑。 按上面的公式跑出来:高光 318 节(35.8%)、常规 456 节、噪音 114 节(12.8%)。事先的预期是高光 15%~25%、噪音 20%~30%,两头都偏。原因也想得明白:噪音偏低,是因为切分单位是“节”,一节是按 2 小时聚合起来的,里面天然有很多轮,“≤3 轮且 <15 字”本来就很难满足;高光偏高,是因为字数分布强右偏,σ 被少数长文拉得很大,μ + 2.5σ ≈ 145 字这个门槛其实不高,稍微写长一点就命中了。公式是按规范实现的,偏差是数据本身的性质——这种时候我选择把偏差和原因写下来,不为了凑预期去改公式。
初筛完,噪音 114 节直接归档,剩下 774 节进入 AI 分析。API 调用量先砍掉一成多,更重要的是,AI 不用再在垃圾内容上浪费判断力。
八、AI 逐节提炼:让它淘金,不要让它写流水账
剩下的 774 节,逐节独立发给一个 OpenAI 兼容接口的模型分析。每个场景一次请求:系统提示词是单独一个 Markdown 文件,全程只引用、不改;用户消息由两块拼成——场景元数据(场景 ID、初筛分级和触发原因、时间区间、参与者)和对话原文流(一行一轮,前面标说话人)。
提示词的设计是这一步的灵魂。我的要求是让 AI 做“淘金”,不是做摘要复读机。输出严格限定为一个 JSON 对象,字段如下:
{
"scene_id": "ep023_sc01",
"title": "15 字以内的小标题,要有生活气息,不要工作汇报腔",
"summary": "40 字以内,客观交代这段在聊什么、做了什么决定",
"sentiment": "情绪氛围,2~4 个词自由描摹,不许用固定分类标签",
"golden_quotes": ["严格原文摘录的 1~2 句,不许润色改字,没有就空数组"],
"inside_jokes": ["只有当事人懂的暗号、谐音梗、口头禅,没有就空数组"],
"book_score": 3,
"bookscore_reason": "站在成书视角说清为什么给这个分"
}
几个设计决定,解释一下:
- 情绪不给固定选项。 给它“开心 / 难过 / 生气”这种标签,出来的全是正确的废话。让它用 2~4 个词自由描摹当时的语气和氛围,出来的东西才有质地,才能帮人回忆起那一段到底是什么感觉。
- 金句必须严格原文摘录,一个字都不许改。 AI 一润色,那句话就不是聊天记录里的话了,做成书也就没意义了。宁可返回空数组,也不许编。
- 评分是“书籍价值分”,1 到 5 分,标准写死在提示词里:5 分是必须收录的高光,4 分是优质章节素材,3 分是过渡铺垫,2 分是平淡琐碎,1 分是不建议收录。打分的同时必须给理由,后面人工筛选时,理由比分数更有用。
工程上,这一步的脚本是最长的,因为 774 次请求跑下来,什么都会发生。关键能力一个都不能少:
- 先 dry-run,再真跑:用模拟响应把拼接、落盘、续传整条链路走一遍,确认无误再花钱。
- max_tokens 先探测、再按体量给:先调
/models拿模型的输出上限,探测失败用一个兜底值;每个场景的max_tokens = min(模型上限, max(2048, 输入字数 / 2)),短场景不浪费,长场景不截断。 - 失败重试 3 次,带退避;如果报错说不支持
response_format(JSON 模式),就关掉它再重试——不是所有兼容接口都支持这个参数。 - 每处理完一个场景就实时落盘,结果 JSON 和一份逐事件的日志 JSONL 同时写。几百个场景跑一两个小时,中途断电、断网、手贱关窗口,都不该从头再来。
- 断点续传有两道保险:重跑时先读结果 JSON,跳过已成功的;再兜底扫一遍日志 JSONL 里标记成功的场景,防止结果文件损坏时丢进度。
- Ctrl+C 是安全退出,不是硬杀:注册信号后只设一个停止标志,把当前场景处理完再退,退出时照样写盘出报告。
- 每 10 秒一个心跳输出,免得长时间没动静,你以为它死了把它关了;进度每到 10% 推一条通知到手机,失败的场景单独通知。
从模型返回里提取 JSON 也是个坑:它经常多话、带代码围栏、甚至用中文引号。下面这个提取函数是被现实教育出来的版本——先剥围栏、再取首尾大括号、严格解析失败后还有一层宽松修复(全角引号转半角、单引号转双引号、去掉尾随逗号):
import json, re
def extract_json(text):
if text is None:
raise ValueError("模型返回为空")
s = text.strip()
if not s:
raise ValueError("模型返回为空字符串")
if s.startswith("```"): # 剥 markdown 围栏
nl = s.find("\n")
if nl != -1:
s = s[nl + 1:]
lf = s.rfind("```")
if lf != -1:
s = s[:lf]
s = s.strip()
a, b = s.find("{"), s.rfind("}")
if a == -1 or b <= a:
raise ValueError("响应中未找到合法 JSON 对象")
s = s[a:b + 1]
try:
return json.loads(s) # 严格解析
except json.JSONDecodeError:
pass
s2 = (s.replace("“", '"').replace("”", '"')
.replace("‘", "'").replace("’", "'"))
s2 = s2.replace("'", '"')
s2 = re.sub(r",(\s*[}\]])", r"\1", s2) # 去尾随逗号
return json.loads(s2) # 宽松回退,仍失败就抛错走重试
最后单独提醒一个安全问题:API Key 千万不要像我一开始那样图省事写死在脚本里。写死的东西会跟着文件到处跑,迟早泄出去。正确做法是放环境变量,脚本里只读环境变量:
import os
API_KEY = os.environ["OPENAI_API_KEY"] # 只从环境变量读
BASE_URL = os.environ.get("OPENAI_BASE_URL", "https://api.deepseek.com")
MODEL = os.environ.get("OPENAI_MODEL", "deepseek-flash")
774 节最后全部分析成功。AI 给出的分数分布是:高分档(4~5 分)399 节、中档(3 分)195 节、低分档(1~2 分)180 节——注意这是 AI 的分,和第七节机械分级是两套东西,别混。
九、人工筛选三道门:AI 打分只是参考,留不留人说了算
774 节不可能全进书,也不可能靠 AI 的分数一刀切。人工筛选我做了三道门,每道门都是一个本地单文件 HTML 工具,数据内嵌、双击打开、离线可用。
第一道门:分档检视。 把 AI 的分析按分数分成高 / 中 / 低三档,每档内按对话时间从旧到新、按章和节组织成一个报告页,先对三档的体量和质量有个整体印象:哪些是肯定要的,哪些是肯定不要的,哪些是拿不准的。
第二道门:全量勾选导出。 一个页面把 774 节全铺开:左边是对话原文,右边是 AI 的标题、摘要、情绪、金句和评分理由,逐节看,勾选要留的。勾选状态自动存浏览器本地存储,关掉页面下次打开还在。最后导出一个只含勾选场景的 JSON。这一步我留下了 406 节。
这里有个大坑,值得单独说:这个页面第一次打开是空白的,数据一条都没渲染出来。 查了半天,根因是生成脚本的内联 JS 里,同一个常量被声明了两次(const SCENE_MAP 在两个地方各写了一遍),浏览器解析时直接报语法错误,整段脚本不执行,页面自然一片空白。改掉重复声明就好了。教训是硬的:凡是 Python 生成、内嵌了一大段 JS 的 HTML,交付前必须把内联 JS 抽出来跑一遍 node --check,光靠眼睛复核代码逻辑,查不出这种低级但致命的错误。后面每个 HTML 工具我都加了这一步,还用 Node 加 DOM 桩做了一轮运行时冒烟(把加载、渲染、导出都调一遍,不抛异常才算过)。
第三道门:逐条快筛。 把第二道门留下的 406 节做成一个“一次只看一条”的页面:左 AI 分析、右对话原文,键盘操作,左箭头删除、右箭头保留、按 R 撤回上一条重判。决定实时存本地,最后导出保留的场景。为什么要一屏一条?因为几百条全铺在一个页面里,人筛到后面注意力就散了,标准会飘;一次一条、按键即走,节奏逼着你当场决断。防卡死上也更稳:每次只渲染当前一条的 DOM,不一次性铺几百个节点。
筛选完还有一个小动作很关键:把留下的场景精简成一份“核心元数据”。先抽成每条 7 个字段的 JSON(场景 ID、日期、标题、摘要、情绪、金句、评分),再转成一份只留 5 个字段的 Markdown——按日期分组、一条一行、竖线分隔、文本里的竖线先换成全角防止串列。这份 Markdown 不是给人看的,是给下一步定结构时喂回给 AI 和自己快速通读用的:几百节的全文有几百万字,元数据版只有几万字,一遍就能读完,全书的脉络就是对着它想出来的。
def clean(s):
"""单行化:换行变空格,竖线换全角,避免破坏一行一条的格式。"""
if s is None:
return ""
return str(s).replace("\r", " ").replace("\n", " ").strip().replace("|", "|")
# 按日期分组输出,每个场景一行:**标题** | id | 情绪 | 摘要
lines, cur_date = [], None
for e in core_meta: # core_meta 是精简后的场景列表
date = clean(e.get("date")) or "未知日期"
if date != cur_date:
lines += ["## " + date, ""]
cur_date = date
lines.append("**%s** | %s | %s | %s" % (
clean(e.get("title")) or "(无标题)", clean(e.get("scene_id")),
clean(e.get("sentiment")), clean(e.get("summary"))))
十、定结构:先有人写目录,再让脚本按目录捞素材
结构不能让 AI 自由发挥。流程是反的:人(对着上一节那份元数据 Markdown)先写出一份全书结构文件,也是 Markdown,四级层次——卷 → 章 → 幕 → 场。每一场只写一行:场景 ID、日期、标题、再加一句自己的批注(为什么选它、放在这里想还原什么)。批注别小看,它是作者意图,排版和写旁白时要反复回来看,一个字都不能在后面的处理里丢掉。
结构写好,再用脚本按这份目录,把每个场景的完整记录(AI 分析 + 原始对话 + 全部字段)从筛选导出的 JSON 里捞出来,挂到目录对应的位置上,生成一份按书籍结构组织的 JSON:
import re
RE_VOL = re.compile(r"^#\s+(卷[^\n|]+?)\s*(?:\|\s*([^\n]+?)\s*)?$")
RE_CHAP = re.compile(r"^##\s+(章[^\n]+)$")
RE_ACT = re.compile(r"^###\s+(幕[^\n]+)$")
RE_SCENE = re.compile(r"^\*\s+(ep\w+_sc\w+)\s*\|\s*([\d\-]+)\s*\|\s*([^|]+?)\s*\|\s*(.+)$")
# 解析时逐行匹配四种行:卷行开新卷、章行开新章、幕行开新幕、场景行挂到当前幕下
# 特别处理:有的章下面直接挂场景、没有分幕——给它建一个占位幕“(未分幕)”
# 把场景收进去,保证四级层次完整,一条材料都不丢
# 挂素材时逐个核对:目录点名的场景,必须在导出 JSON 里全部找到
scene_map = {s["scene_id"]: s for s in export["scenes"]}
missing = []
for vol in volumes:
for chap in vol["chapters"]:
for act in chap["acts"]:
for sc in act["scenes"]:
sc["record"] = scene_map.get(sc["scene_id"])
sc["found"] = sc["record"] is not None
if not sc["found"]:
missing.append(sc["scene_id"])
print(f"目录点名 {total} 场,命中 {total - len(missing)},未找到 {missing}")
我最后定下来的结构是 4 卷、8 章、十几幕、49 场,脚本核对结果:49 场全部命中,未找到 0。这个“全部命中”的校验不能省——目录里手写错一个场景 ID,脚本默默丢一场,你到排版时都未必发现得了。
十一、编辑工作台:单文件 HTML 里改完整本书
最后一步是逐场编辑:给每场写引子、写旁白、整理对话、配上图片(聊天里发过的照片、截图,就是书里的“物证”插图)。这活儿没有现成的软件顺手,我就生成了一个本地工作台:还是单文件 HTML,数据内嵌,双击打开,左边是卷—章—幕—场的树,中间编辑,右边是仿大 32 开版式的实时预览,改动自动保存,最后能导出编辑后的 JSON 和一个 Typst 排版文件(A5 纸,卷、章、幕、场分别映射成各级标题,对话、旁白、图片各有自己的样式命令),拿去排版出书。
这个工作台踩的坑最密集,全是“打开空白”“数据丢了”这一类,全记下来:
坑一:file:// 双击打开,存储可能不可用。 工作台的数据存在浏览器里,首选 IndexedDB。但有些浏览器在 file:// 协议下会禁用 IndexedDB,只用 IndexedDB 的话,页面在这些浏览器里直接不可用。必须加一层 localStorage 退化:IndexedDB 能用就用,不能用自动落到 localStorage。凡是做“双击打开的单文件工具”,这条都要默认带上。
坑二:首开空白——默认数据构造把已编辑内容丢了。 有一场在种子数据里已经有整理好的对话和图片了,但首开(没有浏览器缓存)时页面是空的。根因是构造默认文档的函数只从原始记录推导对话,还把图片列表硬编码成了空数组,种子里现成的已编辑版本根本没被读。修法是专门写一个从种子数据构造文档的函数:优先用种子里已编辑的对话和图片,缺了才回退到从原始记录推导。这类 bug 的共性是:数据明明在文件里,构造环节却走了另一条丢数据的路径——排查时别光盯着存储层,先看“第一次打开、没有缓存”这条冷启动路径。
坑三:说话人对不上,整列全变成“我”。 原始数据里说话人有一套取值(我 / 对方 / 系统),编辑界面的下拉框里写的是另一套叫法,两套对不上号。对不上号的那个值,浏览器会默认选中第一项,于是所有“对方”的话在界面上全显示成“我”发的。修法是载入时做一次归一化,把旧值统一映射到界面用的值,导入旧文件时也做一遍。教训:枚举值在流水线里流转,每一站的取值集合必须一致,不一致就在入口处归一化,别指望后面自觉。
坑四:换行在编辑里被吃掉。 快速编辑功能把一轮对话序列化成一行文本时,图省事把内容里的换行全替换成了空格,一提交,换行永久丢失;就算数据里还有换行,预览函数不把换行转成 <br>,HTML 也会把它折叠成空格,看着一样是没了。修法:序列化时把真实换行转义成字面 \n 写进行内(行与行之间仍然用真实换行分隔条目),解析时再还原;预览时显式把换行替换成 <br>。还有个连带提醒:如果已经在有 bug 的版本里提交过,浏览器缓存里存的已经是“空格版”了,修好代码还得重新导入一次源文件,才能把换行刷回来。
坑五:图片的 base64 缩略图把文件撑爆。 编辑时选的图片一度以 base64 缩略图的形式存进了数据,种子文件和导出文件越滚越大。修法是生成和导出时统一剥掉缩略图,只留图片的相对路径和说明文字,图片文件就放在同目录的 pics/ 文件夹里。另外给图片加了一个“别名”:在引子、对话、旁白的文字里写 $别名$,预览和导出排版时就自动把那张图内嵌到那个位置,比“图片统一堆在一场末尾”自然得多。
坑六:拿其他语言的习惯写当前语言。 生成器里犯过把 Python 的 json.dumps 写进浏览器 JS(浏览器里只有 JSON.stringify)、把不存在的语法写进 Typst 这类错。跨语言拼装的生成器,写完必须真跑一遍冒烟,不能靠“我觉得语法是对的”。
十二、附带产物:九张统计图
主线之外,我还用合并后的轮数据做过一组九张统计图,纯属把这份数据再榨一遍:年度活跃热力图、24 小时作息极坐标、昼夜分布、双方各自的专属词、共同高频词词云、回复延迟分布、话题发起与终结的流向、双方发言量对比、多媒体消息的时间轴条码。
做法上两个要点:一是中文分词用 jieba 精确模式,停用词加载现成的标准停用词表(不自己硬编码一份),分词后过滤掉单字词、停用词和非中文词;二是图表用 ECharts,库文件和数据全部内联进单文件 HTML,离线可开。回复延迟这类指标要先按 120 分钟间隔把轮切成会话再算,不然算出来的“延迟”会把隔夜的沉默也算进去,全是假数据。
这组图进不进书是另一回事,但做一遍很值:很多切分和筛选时的直觉,就是看着这些图才确认的。
十三、踩坑总表
| 坑 | 现象 | 根因 | 修法 |
|---|---|---|---|
| 时间边界没带时区 | 截取范围多一天或少一天 | 拿 UTC 或本地时间算“零点” | 显式 timezone(timedelta(hours=8)) |
| 系统消息污染统计 | 间隔分布出现伪长间隔 | type=80 不是人说的话 |
统计和切分出“含 / 不含系统消息”两套口径 |
| 同一轮跨了几小时 | 一轮里隔着一觉 | 合并时只看说话人、不看间隔 | 同一人相邻间隔 >2h 也强制断轮 |
| 日期硬切断上下文 | 正文开头被切没 | 分界线前夜的对话和后面是连着的 | 从分界线往回扫,到第一个 >2h 间隔才停 |
| 噪音判定漏网 | 纯转账、纯图片被当正常内容 | 占位符本身算字数,“有标记”反被保护 | 算字数先扣 [...] 占位符;真实文字为 0 直接判噪音 |
| 分级比例偏离预期 | 高光偏多、噪音偏少 | 右偏分布下 σ 被长文拉高;切分单位太大 | 记录偏差和原因,不硬改公式凑数 |
| 模型返回不是合法 JSON | 带围栏、中文引号、尾随逗号 | 模型输出不守规矩 | 剥围栏 + 取大括号 + 宽松修复三层提取 |
| Key 写死在脚本里 | 文件传到哪,钥匙跟到哪 | 图省事 | 只读环境变量,文件里不落明文 |
| 内联 JS 重复声明 | 页面打开全空白 | const 同名声明两次,整段脚本报语法错 |
交付前抽出内联 JS 跑 node --check + 冒烟 |
file:// 下存储不可用 |
双击打开页面存不了 | 部分浏览器禁用 file:// 的 IndexedDB |
IndexedDB + localStorage 双层存储 |
| 冷启动丢数据 | 首开空白,图片和已编辑对话没了 | 默认构造走了丢数据的路径 | 优先用种子里的已编辑数据,缺失才回退推导 |
| 说话人枚举不一致 | 对方的话全显示成“我” | 上游取值和界面下拉对不上 | 入口处统一归一化映射 |
| 换行被吃掉 | 对话里的换行变空格 | 序列化图省事替换了换行;预览没转 <br> |
行内换行转义存储;预览显式转 <br> |
| base64 缩略图膨胀 | 种子和导出文件越来越大 | 图片数据内嵌进 JSON | 只存相对路径,生成和导出时统一剥除 |
结尾:这套流程真正管用的几个原则
回头看,把聊天记录做成书,技术上没有哪一步是难的,难的是顺序和纪律。总结成几条,换成任何一份聊天记录都成立:
- 先统计,再定参数。 切分阈值、合并规则、分级门槛,全是从数据的真实分布里长出来的,不拍脑袋,也不照搬别人的经验值。
- 一把尺子用到底。 2 小时这个数,同时是合并断轮、裁切停点、场景切分三处的阈值,整条流水线的“断开”定义是一致的,前后产物才对得上。
- 先机械、后 AI、再人工,顺序不能反。 机械规则零成本砍噪音,AI 只对剩下的做提炼和打分,人最后做决定。反过来一上来就全量烧 API,又贵又乱。
- 每一步的产物都要能立刻打开看。 切分完有预览页、分级完有预览页、筛选有筛选页。数据处理最怕闷头跑十步才发现第二步就错了。
- 所有长任务都要能断点续传、能安全中断、能 dry-run。 几百次 API 调用、几万行数据,跑一半出事是常态,不是意外。
- 隐私在流程里解决,不靠自觉。 原始记录不出本机,分析只发必要的文本,Key 只进环境变量,写出来给人看的文字里不出现真实姓名、账号和原话。
最后说一句体感:这件事做完,最大的感受是聊天记录这个东西,平时看着就是一堆碎碎念,真按时间、按场景、按情绪把它理一遍,它是有结构、有起伏的。把它理成一本书的过程,本身就是把那段时间重新过了一遍。
