图片详情
—
Skip to content

demo_playground.py ​

返回章节 · 配套代码说明

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

python
# ===========================================================================
# 代码清单 2-5  梯度下降逐步演示(依赖模块 linear_unit 与 chem_data)
# ===========================================================================
"""
把梯度下降的每一步都打印出来。

这段代码刻意不做任何抽象,逐步打印 w、b、损失与梯度,
让读者亲眼看到参数如何一步步滑向损失曲面的谷底。

建议:先跑一遍,再改几个数字(学习率、特征数量)跑第二遍。
"""

import math

from linear_unit import LinearUnit, StandardScaler, normal_equation
from chem_data import build_gap_dataset


def show_trace():
    """第一部分:一元线性单元,逐步打印。"""
    print("=" * 78)
    print("第一部分:一个只有一个特征的例子,每一步都打印出来")
    print("=" * 78)
    print("示意数据:σ 取自常见取代基常数,y 是为演示而构造的 lg(k/k0),并非实验值")

    sigma = [-0.83, -0.66, -0.37, -0.27, -0.17, 0.00,
             0.06, 0.11, 0.23, 0.42, 0.54, 0.66, 0.78]
    y = [-0.80, -0.63, -0.34, -0.28, -0.13, 0.01,
         0.05, 0.09, 0.28, 0.38, 0.57, 0.62, 0.80]
    X = [[s] for s in sigma]

    print("\n前 5 个数据点:")
    print("  " + "  ".join("(σ=%.2f, y=%.2f)" % (s, v)
                           for s, v in list(zip(sigma, y))[:5]))

    model = LinearUnit(lr=0.5, n_epochs=500, mode="batch")
    model.n_features_ = 1
    model.w = [0.0]
    model.b = 0.0

    print("\n初始状态:w = 0.000,  b = 0.000")
    print("学习率 η = 0.5,一共走 500 步。前 12 步:")
    print("\n%6s %10s %10s %14s %14s %14s" %
          ("迭代", "w", "b", "J(w,b)", "dJ/dw", "dJ/db"))
    print("-" * 78)

    for epoch in range(model.n_epochs):
        if epoch < 12 or epoch in (50, 100, 250, 499):
            J = model.loss(X, y)
            gw, gb = model.gradient(X, y)
            print("%6d %10.4f %10.4f %14.6f %14.5f %14.5f"
                  % (epoch, model.w[0], model.b, J, gw[0], gb))
        if epoch in (11, 49, 99, 249):
            print("       ...")
        # 一步标准梯度下降
        gw, gb = model.gradient(X, y)
        model.w = [model.w[0] - model.lr * gw[0]]
        model.b = model.b - model.lr * gb

    w_ne, b_ne = normal_equation(X, y)
    print("-" * 78)
    print("跑 500 步之后:  w = %.6f,  b = %.6f" % (model.w[0], model.b))
    print("解析解(正规方程):w = %.6f,  b = %.6f" % (w_ne[0], b_ne))
    print("两者之差:%.2e / %.2e  —— 梯度下降确实走到了同一个地方" %
          (abs(model.w[0] - w_ne[0]), abs(model.b - b_ne)))
    print("\n注意观察 dJ/dw 那一列:每一步都在变小,最后接近 0。")
    print("「梯度接近 0」就是「到达碗底」的数学写法。")
    print("也要注意它慢下来的样子:越靠近碗底,梯度越小,步子越短。")


def show_learning_rate():
    """第二部分:学习率对收敛的影响。"""
    print("\n" + "=" * 78)
    print("第二部分:同一份数据,五种学习率")
    print("=" * 78)

    sigma = [-0.83, -0.66, -0.37, -0.27, -0.17, 0.00,
             0.06, 0.11, 0.23, 0.42, 0.54, 0.66, 0.78]
    y = [s * 1.0 + 0.03 * math.sin(i * 2.1)
         for i, s in enumerate(sigma)]
    X = [[s] for s in sigma]

    w_ne, b_ne = normal_equation(X, y)
    j_opt = sum((yi - (w_ne[0] * s + b_ne)) ** 2
                for s, yi in zip(sigma, y)) / (2 * len(y))
    print("\n最小二乘解对应的最低损失 J* = %.6g(数据含扰动项,J* 不为 0)" % j_opt)
    print("\n%10s %16s %16s %s" % ("学习率 η", "第 20 步 J", "第 200 步 J", "现象"))
    print("-" * 78)
    for lr in (0.01, 0.1, 0.5, 1.0, 2.2):
        m = LinearUnit(lr=lr, n_epochs=200, mode="batch")
        m.fit(X, y)
        losses = m.history["loss"]
        j20 = losses[19] if len(losses) > 19 else float("nan")
        j200 = losses[-1]
        if not math.isfinite(j200) or j200 > 1e6:
            note = "发散:一步比一步更远"
        elif j200 - j_opt < 1e-3 * j_opt and j20 - j_opt < 1e-3 * j_opt:
            note = "20 步内已基本收敛"
        elif j200 - j_opt < 1e-3 * j_opt:
            note = "200 步内收敛"
        else:
            note = "仍在缓慢下降"
        print("%10.2f %16.6g %16.6g %s"
              % (lr, j20, j200 if math.isfinite(j200) else float("inf"), note))

    print("\n结论:本次选取的四个稳定学习率中,η = 1.0 最快;稳定范围约为 η < 2.0。")
    print("      η = 2.2 时迭代发散;不能据此认为整个稳定区间内学习率越大越快。")


def show_scaling():
    """第三部分:特征缩放为什么是生死问题。"""
    print("\n" + "=" * 78)
    print("第三部分:不做特征缩放会怎样")
    print("=" * 78)

    # 造一个化学味的两特征问题:电负性差(~1)和摩尔质量(~100)
    X = [[0.5, 40.0], [1.0, 58.0], [1.5, 100.0], [2.0, 120.0],
         [2.5, 160.0], [3.0, 200.0], [1.8, 85.0], [0.9, 70.0]]
    y = [1.0 + 2.0 * row[0] - 0.01 * row[1] for row in X]

    print("\n原始数据的两个特征量纲差了两个数量级:")
    print("  特征 1(电负性差)的范围:%.2f ~ %.2f"
          % (min(r[0] for r in X), max(r[0] for r in X)))
    print("  特征 2(摩尔质量)的范围:%.2f ~ %.2f"
          % (min(r[1] for r in X), max(r[1] for r in X)))

    scaler = StandardScaler()
    Xs = scaler.fit_transform(X)

    print("\n用同一个学习率 η = 0.01、跑 2000 步:")
    print("%-28s %18s %s" % ("特征处理方式", "最终损失 J", "结果"))
    print("-" * 78)
    raw = LinearUnit(lr=0.01, n_epochs=2000, mode="batch").fit(X, y)
    j_raw = raw.loss(X, y)
    print("%-28s %18s %s" % ("什么都不做", _fmt(j_raw),
                             "爆炸" if (not math.isfinite(j_raw)) or j_raw > 1 else "勉强"))

    scaled = LinearUnit(lr=0.01, n_epochs=2000, mode="batch").fit(Xs, y)
    j_scaled = scaled.loss(Xs, y)
    print("%-28s %18s %s" % ("标准化(均值 0,标准差 1)", "%.3e" % j_scaled,
                             "稳定下降(真实最优 J* = 0)"))

    print("\n不缩放时,梯度在'摩尔质量'方向上是巨大的,")
    print("在'电负性差'方向上却小得可怜。一个学习率不可能同时适合两个方向。")
    print("这就是正文第 2.3.2 节与附录 B.6 讨论的标准化问题。")


def _fmt(v):
    if not math.isfinite(v):
        return "inf"
    return "%.3e" % v


def show_sgd():
    """第四部分:批量 vs 随机。"""
    print("\n" + "=" * 78)
    print("第四部分:批量梯度下降 vs 随机梯度下降")
    print("=" * 78)

    # 用 73 个化合物的带隙数据
    formulas, X, y, groups = build_gap_dataset(("d_chi", "chi_bar", "r_bar", "M"))
    scaler = StandardScaler()
    Xs = scaler.fit_transform(X)
    m_total = len(X)

    print("\n数据:%d 个化合物的带隙,4 个描述符" % m_total)
    print("\n达标标准:训练损失 J < 2.0;共训练 300 轮(epoch)。")
    print("「参数更新次数」= 每轮更新次数 × 达标轮数;")
    print("「单样本梯度计算量」= 达标轮数 × %d(每轮恰好把每个样本用一次)。" % m_total)
    print("\n%-24s %8s %8s %10s %14s %12s"
          % ("方法", "每轮更新", "达标轮数", "参数更新次数", "单样本梯度计算量", "最终损失 J"))
    print("-" * 78)
    target = 2.0
    for label, kw in [("批量 GD(每次全部 %d 个点)" % m_total,
                       dict(mode="batch", lr=0.05)),
                      ("小批量(每次 16 个点)",
                       dict(mode="minibatch", batch_size=16, lr=0.05)),
                      ("随机 GD(每次 1 个点)", dict(mode="sgd", lr=0.005))]:
        m = LinearUnit(n_epochs=300, seed=0, **kw).fit(Xs, y)
        hit = None
        for e, v in zip(m.history["epoch"], m.history["loss"]):
            if math.isfinite(v) and v < target:
                hit = e + 1
                break
        per_epoch = 1 if kw["mode"] == "batch" else (
            math.ceil(m_total / kw.get("batch_size", 1))
            if kw["mode"] == "minibatch" else m_total)
        used = hit if hit else m.n_epochs
        print("%-24s %8d %8s %10d %14d %12.6f"
              % (label, per_epoch, ("%d 轮" % hit) if hit else "未达标",
                 per_epoch * used, m_total * used, m.history["loss"][-1]))

    print("\n读法:")
    print("  1. 批量下降每轮只更新 1 次,需要较多轮数才能达标;")
    print("     随机/小批量下降每轮更新多次,达标所需的轮数(即遍历数据的次数)更少,")
    print("     因此按「单样本梯度计算量」衡量,它们反而更省。")
    print("  2. 代价是方向噪声:随机下降的单步方向抖动大,要用较小的学习率,")
    print("     且在固定学习率下最终只会在极小点附近徘徊,需要配合学习率衰减。")
    print("  3. 在向量化的数值库中,一次全量梯度可以高度并行,")
    print("     墙钟时间往往与计算量不成正比——这是小批量方法流行的主要原因。")
    print("  4. 对只有几十到几千个样本的线性问题,直接用正规方程通常最简单。")


def main():
    show_trace()
    show_learning_rate()
    show_scaling()
    show_sgd()
    print("\n" + "=" * 78)
    print("四部分演示结束。建议修改学习率、批大小等参数后再运行一次。")
    print("=" * 78)


if __name__ == "__main__":
    main()

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