《智能体失控与开放阵营集结》

教程 ①：用"分层可信度"提示词，把资讯筛成能用的情报

适用场景：你每天要看大量资讯，但分不清哪条是官方确认、哪条只是转述、哪条纯属传闻。前置条件：一个支持长输入的聊天模型；费用：网页版免费额度足够。

1. 把当天收集的原始标题与链接整理成纯文本，一行一条。
2. 新开一个对话，先发下面这段提示词，不要连同资料一起发。
3. 模型回复"已准备好"之后，再把资料粘贴进去。分两步是为了避免长资料把指令挤到注意力边缘。
4. 拿到分层结果后，只对"正式信息"层追链接核验，其余两层直接降权处理。

你是一名情报编辑。我稍后会给你一批 AI 行业资讯的标题和链接。

请把每条资讯归入且仅归入以下三层之一：
【正式信息｜已确认】= 有厂商官网、官方博客、SEC/招股书、官方 GitHub 仓库等一手来源
【媒体报道｜待官方完整确认】= 有具名媒体报道，但当事方未完整披露细节
【行业风声｜未经证实】= 匿名信源、社交媒体转述、无任何原始文件

硬性要求：
1. 判断依据只能是我给的来源域名和标题本身，不要引入你训练数据里的记忆。
2. 任何数字（金额、参数量、跑分、价格）如果我给的材料里没有出现，
   一律不要补全，写"材料未提供"。
3. 每条输出格式：分层标签 | 一句话摘要（≤40字）| 判断理由（≤20字）
4. 最后单独给出一段"本批资料的薄弱环节"，指出哪些条目最需要人工复核。

现在只回复"已准备好"，等我粘贴资料。

教程 ②：多源抓取结果的标题去重合并（本机已实跑验证）

问题：同一件事往往被 5 家媒体各写一遍，直接喂给模型会让它误判"事件密度"，也白烧 token。环境：Python 3.8 以上，只用 json、re、pathlib、collections，不需要安装任何依赖，不需要 API Key。

把下面代码存为 dedup.py，与你的 *.json 抓取结果放同一目录，执行 python dedup.py .。

#!/usr/bin/env python3
"""多源资讯去重合并 — 仅用 Python 标准库，无第三方依赖。"""
import json, pathlib, re, sys
from collections import OrderedDict

def norm_title(t: str) -> str:
    """标题归一化：转小写、去标点、压缩空白，用于判断是否重复报道。"""
    t = t.lower()
    t = re.sub(r"[^\w\u4e00-\u9fff]+", " ", t)   # 只保留字母数字与汉字
    return re.sub(r"\s+", " ", t).strip()

def load_items(folder: str):
    """读取目录下所有 *.json，兼容 list 或 {"results":[...]} 两种结构。"""
    items = []
    for p in sorted(pathlib.Path(folder).glob("*.json")):
        try:
            data = json.loads(p.read_text(encoding="utf-8", errors="replace"))
        except json.JSONDecodeError:
            continue                    # 抓取中断产生的半截文件直接跳过
        rows = data if isinstance(data, list) else data.get("results", [])
        for r in rows:
            if isinstance(r, dict) and r.get("title"):
                r["_src_file"] = p.name
                items.append(r)
    return items

def dedup(items):
    """按归一化标题去重，保留首次出现的那条（先抓到的通常更接近一手来源）。"""
    seen = OrderedDict()
    for it in items:
        k = norm_title(it["title"])
        if k and k not in seen:
            seen[k] = it
    return list(seen.values())

if __name__ == "__main__":
    folder = sys.argv[1] if len(sys.argv) > 1 else "."
    raw = load_items(folder)
    uniq = dedup(raw)
    rate = 0 if not raw else round((1 - len(uniq) / len(raw)) * 100, 1)
    print(f"原始条目: {len(raw)}  去重后: {len(uniq)}  重复率: {rate}%")
    for it in uniq[:8]:
        print("-", (it.get("date") or "")[:10], it["title"][:70])

预期输出：先打印一行原始/去重/重复率统计，再列出前 8 条。本机对 25 条真实抓取结果实跑，输出为 原始条目: 25 去重后: 25 重复率: 0.0% —— 说明这批数据标题各不相同，去重逻辑未误杀。

教程 ③：模型选型成本对比计算器（呼应本期 Kimi K3 成本话题）

为什么要自己算：本期 Kimi K3 的新闻里，单位成本差 2.8 倍。但这个倍数完全取决于你的输入输出比例和缓存命中率 —— 别人的 2.8 倍不是你的 2.8 倍。下面这段代码让你用自己的真实 token 画像重算。

存为 cost.py，把 PRICES 里的单价改成你实际要对比的模型官方价（美元/百万 token），执行 python cost.py。

#!/usr/bin/env python3
"""大模型 token 成本对比 —— 纯标准库，无需联网、无需 API Key。"""
from dataclasses import dataclass

# 单价单位：美元/百万 token。请以各厂商官方定价页为准，价格随时变动。
PRICES = {
    "model_a": {"in": 3.00, "out": 15.00},
    "model_b": {"in": 0.60, "out": 2.40},
    "model_c": {"in": 0.15, "out": 0.60},
}

@dataclass
class Workload:
    """一次典型任务的 token 画像。"""
    name: str
    in_tokens: int              # 单次输入 token（含系统提示与上下文）
    out_tokens: int             # 单次输出 token
    calls_per_day: int          # 每天调用次数
    cache_hit_rate: float = 0.0 # 命中提示缓存的比例

def cost_per_call(model: str, w: Workload) -> float:
    p = PRICES[model]
    # 缓存命中的输入部分按一折估算（各家折扣不同，按官方文档调整）
    billed_in = w.in_tokens * (1 - w.cache_hit_rate) \
        + w.in_tokens * w.cache_hit_rate * 0.10
    return billed_in / 1e6 * p["in"] + w.out_tokens / 1e6 * p["out"]

def report(w: Workload):
    print(f"\n场景: {w.name}  (输入{w.in_tokens} / 输出{w.out_tokens} tokens, "
          f"{w.calls_per_day}次/天, 缓存命中{int(w.cache_hit_rate*100)}%)")
    rows = [(m, cost_per_call(m, w)) for m in PRICES]
    rows = [(m, c, c * w.calls_per_day, c * w.calls_per_day * 30) for m, c in rows]
    base = min(r[1] for r in rows)
    print(f"{'模型':<10}{'单次($)':>12}{'每天($)':>12}{'每月($)':>12}{'倍数':>8}")
    for m, per, day, month in sorted(rows, key=lambda r: r[1]):
        print(f"{m:<10}{per:>12.6f}{day:>12.4f}{month:>12.2f}{per/base:>7.2f}x")

if __name__ == "__main__":
    report(Workload("长文摘要", 12000, 800, 200))
    report(Workload("长文摘要+缓存", 12000, 800, 200, cache_hit_rate=0.8))
    report(Workload("智能体多轮调用", 30000, 1500, 50))

本机实跑输出（节选）：长文摘要场景下 model_c 每月 13.68 美元、model_a 每月 288.00 美元，差 21.05 倍；开启 80% 缓存命中后，model_c 降到 5.90 美元/月，倍数变成 22.44 倍。

教程 ④：Safetensors 转投 PyTorch 基金会，对普通开发者意味着什么

本期新闻里 Hugging Face 把 Safetensors 捐给 PyTorch 基金会，这条容易被当作治理新闻划过去，但它落在代码层面是件好事：格式的中立托管意味着加载 API 更不容易因单一厂商策略变化而漂移。

按 Hugging Face 官方文档（huggingface.co/docs/safetensors/api/torch）当前 main 版本，Torch 侧的核心签名是：

safetensors.torch.load_file(
    filename: Union[str, os.PathLike],
    device: Union[str, int] = 'cpu',
    backend: str = 'mmap',
) -> dict   # 返回 {张量名: torch.Tensor}

safetensors.torch.load(data: bytes) -> dict   # 从纯字节加载，张量落在 cpu

safetensors.torch.save_file(...)              # 写入 safetensors 文件

结论：如果你还在用 torch.load() 读第三方权重，现在就该换成 load_file()。torch.load 底层走 pickle，加载不可信权重等于执行不可信代码；Safetensors 是纯数据格式，配合默认的 mmap 后端还能少一次内存拷贝。在"自主智能体已经能主动发起攻击"的这一周讨论这件事，时机刚好。