图片详情
—
Skip to content

demo_alkane.py ​

返回章节 · 配套代码说明

复制以下内容并保存为 demo_alkane.py,使用方法见配套代码说明。

python
# ===========================================================================
# 代码清单 2-8  案例三:正构烷烃沸点的外推(依赖 linear_unit、chem_data)
# ===========================================================================
"""
案例三:用 C1–C10 训练,外推预测 C11–C20 的常压沸点。
数据为 C1–C20 正构烷烃在 1 atm 下的沸点(手册值)。
"""

import math
import unicodedata

from linear_unit import (LinearUnit, PolynomialFeatures, StandardScaler,
                         r2_score, rmse)
from chem_data import build_alkane_dataset

N_TRAIN = 10          # 用 C1–C10 训练,C11–C20 做外推检验


def display_width(text):
    return sum(2 if unicodedata.east_asian_width(ch) in "WF" else 1
               for ch in text)


def pad(text, width, align="left"):
    space = " " * max(0, width - display_width(text))
    if align == "right":
        return space + text
    return text + space


def row(cells, widths, aligns):
    return "  ".join(pad(c, w, a) for c, w, a in zip(cells, widths, aligns))


def header(title):
    print("\n" + "=" * 78)
    print(title)
    print("=" * 78)


def fit_on_train(ns, bp, feat, lr=0.2, n_epochs=40000):
    """用前 N_TRAIN 个点训练,返回 (模型, scaler, 特征构造函数)。

    feat 是一个 n -> list[float] 的函数,代表"我们决定用哪些特征"。
    """
    X = [feat(float(n)) for n in ns]
    scaler = StandardScaler()
    Xtr = scaler.fit_transform(X[:N_TRAIN])
    model = LinearUnit(lr=lr, n_epochs=n_epochs, mode="batch").fit(
        Xtr, bp[:N_TRAIN])

    def predict_at(n):
        return model.predict(scaler.transform([feat(float(n))]))[0]

    return model, scaler, predict_at


def evaluate(ns, bp, feat, label):
    """训练 + 外推,打印一行结果,返回 (训练 RMSE, 外推 RMSE, n=20 预测)。"""
    model, scaler, predict_at = fit_on_train(ns, bp, feat)
    tr_pred = model.predict(scaler.transform([feat(float(n)) for n in ns[:N_TRAIN]]))
    te_pred = [predict_at(n) for n in ns[N_TRAIN:]]
    tr = rmse(bp[:N_TRAIN], tr_pred)
    te = rmse(bp[N_TRAIN:], te_pred)
    p20 = predict_at(20)
    widths = (30, 14, 16, 16)
    print(row((label, "%.1f" % tr, "%.1f" % te, "%.0f" % p20),
              widths, ("left", "right", "right", "right")))
    return tr, te, p20


def show_data(ns, names, bp):
    header("数据:20 个正构烷烃的常压沸点")
    print("\n" + row(("碳数 n", "名称", "沸点 / °C"), (10, 34, 14),
                     ("right", "left", "right")))
    print("-" * 60)
    for n, name, t in zip(ns, names, bp):
        mark = "  ← 训练" if n <= N_TRAIN else ""
        print(row(("%d" % n, name, "%.1f" % t), (10, 34, 14),
                  ("right", "left", "right")) + mark)
    print("\n前 %d 个(C1–C10)用来训练,后 10 个(C11–C20)完全不给模型看," % N_TRAIN)
    print("它们专门用来回答一个问题:把模型推出它见过的范围,会发生什么。")


def act_one(ns, bp):
    header("第一幕:特征只有碳数 n")
    print("\n这是最自然的想法——沸点随碳数增长,那就拿碳数当特征。")
    print("\n线性单元学到的是:Tb ≈ a·n + b")
    print("\n" + row(("特征组合", "训练 RMSE", "外推 RMSE", "n=20 预测"),
                     (30, 14, 16, 16), ("left", "right", "right", "right")))
    print("-" * 78)
    tr, te, p20 = evaluate(ns, bp, lambda n: [n], "只用 n")
    print("\n真实沸点:C20 是 %.1f °C,模型预测 %.0f °C,差了 %.0f °C。"
          % (bp[-1], p20, p20 - bp[-1]))
    print("\n为什么?因为沸点随碳数的增长是「越来越慢」的:")
    diffs = [round(bp[i + 1] - bp[i], 1) for i in range(9)]
    print("   相邻烷烃的沸点差(C1→C10):%s" % diffs)
    print("   从 72.9 °C 一路掉到 23.3 °C,而且还在继续变小。")
    print("   一条直线只会保持同一个斜率,所以往外推得越远,错得越离谱。")
    return tr, te, p20


def act_two(ns, bp):
    header("第二幕:再加一个 n²")
    print("\n既然曲线是弯的,那就加一个平方项,让模型也能弯。")
    print("(严格说这仍然是「线性单元」——因为对参数 w 而言它依然是线性的,")
    print("  我们只是把特征从 [n] 换成了 [n, n²]。)")
    print("\n" + row(("特征组合", "训练 RMSE", "外推 RMSE", "n=20 预测"),
                     (30, 14, 16, 16), ("left", "right", "right", "right")))
    print("-" * 78)
    tr, te, p20 = evaluate(ns, bp, lambda n: [n, n * n], "n 和 n²")
    print("\n训练误差从 17 掉到 6 以下,看起来是进步。")
    print("但 C20 的外推预测只有 %.0f °C,偏离真值(342.7 °C)比第一幕还远。" % p20)
    print("\n原因:拟合出的抛物线在 C1–C10 上单调上升、但向下弯曲(二次项系数为负),")
    print("      但它必然有一个「顶点」。拟合出来的顶点大概在 n≈13 附近,")
    print("      过了顶点,抛物线就开始往下掉。")
    print("      模型在训练区间里学到的是「上升」,")
    print("      但在训练区间外给出的却是「下降」——这是纯粹的数学外推,")
    print("      没有任何化学在里面。")
    print("\n这是本教程最重要的一课:")
    print("  更灵活的特征会让训练误差变小,同时让外推误差变大。")
    print("  只看训练集,你永远发现不了这件事。")
    return tr, te, p20


def act_three(ns, bp):
    header("第三幕:加入 n^(2/3)——由物理图像启发的特征")
    print("\n现在换一个思路:不要问「什么函数能拟合得更好」,")
    print("而要问「什么物理量在控制沸点」。")
    print("\n物理图像:正构烷烃分子间以色散力(London 力)为主,")
    print("      色散作用的总强度大致随分子间的接触面积增长。")
    print("\n      表面积怎么随 n 变?做一次量纲分析:")
    print("        对任何形状相近的凝聚相物体,表面积 ∝ 体积^(2/3)。")
    print("        而正构烷烃每加一个 CH2,体积就增加一个固定量,")
    print("        所以体积 ∝ n,于是接触表面积 ∝ n^(2/3)。")
    print("      这只是一个粗略的标度假设:真实分子是柔性链,并不是紧凑的球体。")
    print("      但它给出了一个可以检验的预言:指数应该在 0.67 附近。")
    print("      下面我们把它跑出来看看。")
    print("\n下面采用特征 [n, n^(2/3)]:保留 n 的线性项,再加上表面积标度项 n^(2/3),")
    print("由两者的线性组合描述「先快后慢」的增长趋势。")
    print("\n" + row(("特征组合", "训练 RMSE", "外推 RMSE", "n=20 预测"),
                     (30, 14, 16, 16), ("left", "right", "right", "right")))
    print("-" * 78)
    tr, te, p20 = evaluate(ns, bp, lambda n: [n, n ** (2.0 / 3.0)],
                           "n 和 n^(2/3)")
    print("\n真实沸点 C20 = %.1f °C,预测 %.0f °C,差了 %.0f °C。"
          % (bp[-1], p20, abs(p20 - bp[-1])))
    print("外推 RMSE 从 129 °C 降到 %.1f °C,降了二十多倍。" % te)
    print("\n注意:我们并没有让模型更复杂。特征数还是 2 个,")
    print("      参数还是 3 个(w1, w2, b),训练代码一行都没改。")
    print("      改变的只是「喂给它什么」。")
    print("\n这就是特征工程的含义:")
    print("  用化学知识决定模型「看什么」,往往比单纯增加模型的灵活性更有效。")
    return tr, te, p20


def exponent_scan(ns, bp):
    header("第四幕:扫描指数 p(注意:这一步用到了外推集)")
    print("\n把特征固定成 [n, n^p],让 p 从 0.2 扫到 1.2,")
    print("看哪一个指数的外推误差最小。")
    print("\n" + row(("指数 p", "物理含义", "训练 RMSE", "外推 RMSE"),
                     (10, 24, 14, 16),
                     ("right", "left", "right", "right")))
    print("-" * 78)
    best = None
    for i in range(11):
        p = 0.2 + 0.1 * i
        X = [[float(n), float(n) ** p] for n in ns]
        scaler = StandardScaler()
        model = LinearUnit(lr=0.2, n_epochs=40000, mode="batch").fit(
            scaler.fit_transform(X[:N_TRAIN]), bp[:N_TRAIN])
        tr = rmse(bp[:N_TRAIN],
                  model.predict(scaler.transform(X[:N_TRAIN])))
        te = rmse(bp[N_TRAIN:], model.predict(scaler.transform(X[N_TRAIN:])))
        if best is None or te < best[1]:
            best = (p, te)
        note = ""
        if abs(p - 1.0) < 1e-9:
            note = "特征完全重复"
        elif abs(p - 0.6) < 1e-9:
            note = "误差最小"
        elif abs(p - 2.0 / 3.0) < 0.034:
            note = "量纲分析预言"
        print(row(("%.1f" % p, note, "%.1f" % tr, "%.1f" % te),
                  (10, 24, 14, 16), ("right", "left", "right", "right")))

    print("\n最优指数 p = %.2f,外推 RMSE 只有 %.2f °C。" % best)
    print("量纲分析预言的 2/3 ≈ 0.67 与之相差不到 0.1。")
    print("但请注意:这里按「外推 RMSE 最小」挑选 p,等于让外推集参与了模型选择,")
    print("因此 p = 0.60 时的外推误差是偏乐观的,不能作为独立检验结果。")
    print("\n注意 p = 1.0 那一行与第一幕的结果完全相同:")
    print("  [n, n^1] 就是 [n, n]——两列完全相同的特征,没有带来任何新信息。")
    print("  此时 XᵀX 奇异,正规方程没有唯一解;梯度下降从零出发,则把权重平分给两列,")
    print("  得到与只用 n 等价的模型。这是多重共线性的极端情形。")
    print("\n所以「加特征」不等于「加信息」:与已有特征重复的特征没有用处。")


def holdout_check(ns, bp):
    header("附:如果反过来外推呢(用 C11–C20 训练,预测 C1–C10)")
    print("\n换一个外推方向,进一步检查同一特征组合在这组数据上的表现。")
    print("\n" + row(("特征组合", "训练 RMSE", "外推 RMSE", "n=1 预测"),
                     (30, 14, 16, 16), ("left", "right", "right", "right")))
    print("-" * 78)
    for label, feat in (("只用 n", lambda n: [n]),
                        ("n 和 n^(2/3)", lambda n: [n, n ** (2.0 / 3.0)])):
        X = [feat(float(n)) for n in ns]
        scaler = StandardScaler()
        Xtr = scaler.fit_transform(X[N_TRAIN:])
        model = LinearUnit(lr=0.2, n_epochs=40000, mode="batch").fit(
            Xtr, bp[N_TRAIN:])
        tr_pred = model.predict(scaler.transform(X[N_TRAIN:]))
        te_pred = model.predict(scaler.transform(X[:N_TRAIN]))
        p1 = model.predict(scaler.transform([feat(1.0)]))[0]
        print(row((label,
                   "%.1f" % rmse(bp[N_TRAIN:], tr_pred),
                   "%.1f" % rmse(bp[:N_TRAIN], te_pred),
                   "%.0f" % p1), (30, 14, 16, 16),
                  ("left", "right", "right", "right")))
    print("\n真实值:甲烷沸点 %.1f °C。" % bp[0])
    print("只用 n 的直线模型向下外推同样失败(甲烷预测为 39 °C);")
    print("而 [n, n^(2/3)] 模型向下外推的误差仍然很小。")
    print("这支持该特征组合在 C1–C20 范围内描述主要趋势,")
    print("但不能据此保证更长链范围内的预测可靠。")
    print("\n但仍需谨慎:外推得越远、越接近物理机制发生变化的区域,")
    print("      任何模型——无论是否线性——都越不可信。")


def all_data(ns, bp):
    header("附:用全部 20 个点拟合,能好吗")
    print("\n" + row(("特征组合", "R²", "RMSE / °C"), (30, 12, 16),
                     ("left", "right", "right")))
    print("-" * 60)
    for label, feat in (("只用 n", lambda n: [n]),
                        ("n 和 n²", lambda n: [n, n * n]),
                        ("n 和 n^(2/3)", lambda n: [n, n ** (2.0 / 3.0)])):
        X = [feat(float(n)) for n in ns]
        scaler = StandardScaler()
        Xs = scaler.fit_transform(X)
        model = LinearUnit(lr=0.2, n_epochs=40000, mode="batch").fit(Xs, bp)
        pred = model.predict(Xs)
        print(row((label, "%.4f" % r2_score(bp, pred),
                   "%.2f" % rmse(bp, pred)), (30, 12, 16),
                  ("left", "right", "right")))
    print("\n在整个区间内,[n, n^(2/3)] 依然是最准的。")
    print("合适的特征让插值和外推同时变好;")
    print("而 n² 只改善了插值,一到外推就失效——")
    print("所以训练集上的表现不能单独作为选择特征的依据。")


def main():
    ns, names, bp = build_alkane_dataset()
    show_data(ns, names, bp)
    act_one(ns, bp)
    act_two(ns, bp)
    act_three(ns, bp)
    exponent_scan(ns, bp)
    holdout_check(ns, bp)
    all_data(ns, bp)

    header("案例总结")
    print("""
   第一幕  特征 = [n]            训练 RMSE 17.3   外推 RMSE 129.1   n=20 预测 551
   第二幕  特征 = [n, n²]        训练 RMSE  5.6   外推 RMSE 132.9   n=20 预测  95
   第三幕  特征 = [n, n^(2/3)]   训练 RMSE  1.8   外推 RMSE   5.8   n=20 预测 334

(真值:C20 的沸点是 342.7 °C)

三行数字,三个结论:

1. 训练误差不能单独用来选模型。第二幕的训练误差比第一幕小,
   外推误差却更大,需要根据实际使用范围做验证。

2. n² 和 n^(2/3) 都由同一个碳数计算得到,
   但它们让线性单元能够表达不同的曲线,外推趋势也随之改变。

3. 领域知识可以帮助提出特征候选,但效果仍需独立检验。
   本例的 n^(2/3) 是粗略标度启发的经验选择,不能当作严格物理定律。
""")


if __name__ == "__main__":
    main()

《原子智能》· 纸质出版预备版 · PolyAI Team 著