一、标注才是贵的那一项

先把问题摆对。「数据不够」有三种常见的应对，代价完全不同：

二、能搬的到底是什么

不是答案，是「哪些方向有用」。先看源任务学出了什么：

三、收益曲线：数据越少越值钱

把目标任务的标注量从每类 5 条扫到 200 条，两种训法各跑 20 次取平均：

四、负迁移：搬错了比不搬还差

上面那个目标任务是「门槛从 0 挪到 1.0」，方向没变。 现在换个狠的：规则完全反过来——前两维相加小于 0 才算正例。

五、练多少步：冻结、微调、分层学习率

还是那个反向任务，每类只给 10 条。从源权重出发，跑不同的步数：

六、动手 Demo：把学过的搬过来用

五段：两个任务、源任务学到了什么、数据量扫描、负迁移、微调步数。 第 3 段和第 4 段是同一张表的两面：一个正迁移、一个负迁移。 这一节所有数字都来自同一个 16 维的小模型，唯一改动的是「目标任务怎么定义」。 这样才看得出：帮不帮上忙，取决于任务之间的关系，不取决于搬多少。

def make(n, kind, r=None):           # 造数据：16 维，只有前 4 维有信息
    X = r.normal(0.0, 1.0, (n, D))
    if kind == u"源":
        y = (X[:, :INF].sum(1) > 0).astype(int)
    elif kind == u"目标":
        y = (X[:, :INF].sum(1) > 1.0).astype(int)     # 同一批特征，门槛挪了
    else:
        y = ((X[:, 0] + X[:, 1]) < 0).astype(int)     # 反向：方向正好相反
    return X, y

def train(X, y, w0=None, steps=300, lr=0.5, l2=1e-3):
    w = np.zeros(D + 1) if w0 is None else w0.copy()  # 给了 w0 就是「接着练」
    for _ in range(steps):
        p = 1.0 / (1.0 + np.exp(-Xb.dot(w)))
        g = Xb.T.dot(p - y) / n + l2 * w
        w -= lr * g
    return w

WS = train(XTR, YTR)                 # 源任务 4000 条，学出一份权重
for nper in (5, 10, 20, 50, 200):     # 目标数据从几条扫到 200 条
    for s in range(20):               # 每种情况换 20 次抽样，取平均
        idx = few(YT, nper, r)
        a.append(acc(train(XT[idx], YT[idx], None), XT, YT))   # 从零训练
        b.append(acc(train(XT[idx], YT[idx], WS), XT, YT))     # 借源权重

实跑输出：

--------------------------------------------------------------------
把学过的搬过来用
--------------------------------------------------------------------
==============================================================

[1] 两个任务：一个数据多，一个数据少

  16 维输入，**只有前 4 维有信息，后 12 维是纯噪声。**两个任务都用这 16 维：

    任务                标签怎么定                        能拿到多少条
    --------------------------------------------------------------------------
    源任务              前 4 维相加 > 0                   4000 条
    目标任务            前 4 维相加 > 1.0                 每类十几条

  **这就是迁移学习的真实局面：源任务数据管够，目标任务标注贵得要命。**
  目标任务的规则跟源任务几乎一样，**只把门槛从 0 挪到了 1.0**——
  **方向完全一致，用的是同一批特征。这是「值得迁移」的典型情形。**

[2] 先看源任务学到了什么

    源任务测试准确率 0.9920
    前 4 维的权重：2.86／3.01／2.81／2.96
    后 12 维权重的平均绝对值：0.0236

  **它自己学会了「前 4 维有用、后 12 维别理」。**没人告诉它这件事——
  **是数据量把它逼出来的：4000 条数据下，把权重放在噪声维上只会拉低准确率。**
  这份权重就是「学到的经验」。**迁移学习要搬的，正是这个东西。**

[3] 目标数据越来越少时，借来的权重值多少

  目标任务测试集 3000 条。每条曲线跑 20 次不同的抽样，取平均：

    每类给几条      从零训练            拿源权重当初值        差多少
    --------------------------------------------------------------------------
    5               0.6759              0.8245                +0.1486
    10              0.7511              0.8442                +0.0932
    20              0.8379              0.8716                +0.0337
    50              0.9143              0.9220                +0.0077
    200             0.9587              0.9640                +0.0053

  **每类只有 5 条时：从零训练 0.6759，拿源权重当初值 0.8245——错误率少了 46%。**
  **每类 200 条时两条线几乎并到一起（0.9587 对 0.9640）。**
  **这就是迁移学习的收益曲线：数据越少，借来的东西越值钱；数据一多，自己学也够了。**
  所以它省的不是「训练时间」，**是「标注数据」——而标注才是真正贵的那一项。**

[4] 什么时候搬过来会帮倒忙

  换个目标任务：**标签完全反过来**（前两维相加小于 0 才算正例）。
  它跟源任务的规则在同样的几个特征上「方向相反」。

    每类给几条      从零训练            拿源权重当初值        差多少
    --------------------------------------------------------------------------
    10              0.7788              0.7095                -0.0693
    50              0.9225              0.9218                -0.0006
    200             0.9729              0.9728                -0.0001

  **每类 10 条时，迁移反而更差：0.7788 对 0.7095。**
  **因为源权重把「前两维取正」这个方向先写进了模型，而正确答案要求取负。**
  **初值把模型推到了错的一边，数据太少拉不回来。**
  **数据一多（每类 200 条）就又追平了：0.9729 对 0.9728。**
  **这叫负迁移。它是迁移学习唯一的真风险，也是「先看两个任务像不像」这条规矩的由来。**

[5] 「搬过来」之后要练多少步

  还是那个反向任务，每类只给 10 条。**从源权重出发，跑不同的步数看结果：**

    训练步数      测试准确率        权重前两维
    ------------------------------------------------------
    0             0.2547            2.86／3.01
    5             0.3090            1.84／1.81
    20            0.4577            0.86／-0.22
    100           0.5820            -0.13／-1.55
    300           0.6343            -0.87／-2.26
    1000          0.6817            -1.66／-2.80

  **0 步那一行就是「完全冻结」：准确率 0.2547，比瞎猜还差——因为它把方向搞反了。**
  **「冻结前面、只训最后一层」不是万能的：前面学的东西跟新任务方向相反时，冻结等于把错误焊死。**
  练到 1000 步，它确实慢慢翻过来了（0.6817）。**但同样这 20 条数据，从零训练是 0.7617。**
  **借来的东西不但没帮上忙，还拖了后腿——这就是负迁移的完整样子。**
  这几行数字把迁移学习的两难摆得很清楚：
  **练得少，怕方向错；练得多，等于没借。**
  **工程上的折中是「分层学习率」：前面几层用小学习率慢慢动，最后一层正常学。**

  三段连起来：源任务学到「哪些特征有用」→ 这份权重当目标任务的起点
  → 练多少要试。**它省的是标注，赌的是「两个任务长得像」。赌错了就叫负迁移。**

第 3 段那张表的「差多少」一列，是这一节最值得盯的一列。 +0.1486 一路掉到 +0.0053，单调下降——它同时证明了两件事：借有用、 以及借的用处会随数据变多而消失。 第 4 段那个 0.7095 是负迁移最干净的证据。同样的代码、同样的超参、 只把标签的符号反过来，迁移就从帮忙变成了拖后腿。 所以「先看两个任务像不像」不是保守，是必须。 第 5 段最该看的是最右列那两串权重，不是准确率。从 2.86／3.01 走到 −1.66／−2.80， 它证明模型真的在「掉头」，而不是在错误的坡上原地打转。 第 5 段结尾那对比（0.6817 对 0.7617）是全节最重要的一对数。 它说明「借」不是免费的：借错了，练到 1000 步也追不回从零训练。 这也是为什么真实的迁移学习工程里，验证集比源模型更值钱。

30 秒实验

1. 把第 3 段的 nper 从 5 改成 2，重跑。 差距会更大——数据越少，初值的那份先验占的比重就越大。
2. 把 train 的 steps 从 300 改成 30，重跑第 3 段。 两条线都会掉下来，但「借」那条掉得少——因为它的起点本来就更靠近答案。
3. 把源任务的标签改成「前 4 维相加 > 3.0」（更难、样本更偏），重跑第 3 段。 迁移的收益会变小——源任务自己学得越偏，搬过来的先验就越不可靠。

常见误区

1. 以为迁移学习是「省训练时间」。它省的是标注。 训练时间在今天的机器上很便宜，一条标好的专业数据才是真贵的那一项。
2. 以为「模型能复用」就等于「任务像」。像不像看的是输入到输出的关系方向， 不是输入长得像不像。Demo 第 4 段的两个任务用的是同一批特征，可关系反了，就是负迁移。
3. 以为「冻结前面」总是安全的。Demo 第 5 段 0 步那一行是 0.2547，比瞎猜还差。 前面学的东西方向错了，冻结等于把错误焊死。
4. 以为负迁移会报错。它不会。 它只让准确率悄悄往下走，所以目标任务的验证集是必需品，不是可选项。

这一节管的是「任务之间借东西」。 下一节换一个完全不同的问题：任务不变，可一台机器已经装不下它了——模型放不进显存、数据读不完、 算一遍要几个月。 那时候要解决的不是「学什么」，是「怎么把算分到很多台机器上」。

• ☐ （本节完，下一节 8.4 分布式人工智能）

相关笔记

• 集成学习
• 有监督学习
• 协变量移位下的迁移学习
• 📘 图解人工智能 · 索引