第3次热潮的高峰

012015・训练的技巧

让输入每层的值保持整齐

叠了10层、20层的网络，为什么以前很难训练？

深层网络要把输出的误差传回输入一侧来修正权重（反向传播，第8章）。传回去的信号，每经过一层，就要乘上这一层的权重和神经元的斜率。S形的sigmoid函数斜率不超过0.25，所以光是斜率这一项，10层下来就只剩约100万分之一。

2010〜2012年的ReLU和权重初始值的技巧，我们在第9章已经看过。2015年，谷歌的Ioffe和Szegedy提出了批归一化：把进入每一层的值，按一次学习所用的那一批数据，统一调整为平均0、方差1。右边的图是一个20层的网络，测量向前传的值的分布（蓝）和往回传的信号（紫）。切换ReLU、权重初始值、批归一化，来比一比吧。

往回传的信号 ≈ 出口的信号 ×（w₁·f′₁）×（w₂·f′₂）× … ×（w_L·f′_L）

f′: 神经元的斜率（sigmoid不超过0.25，ReLU是0或1）
w: 权重
L: 层数

常见说法常见说法：批归一化有效，是因为它纠正了进入各层的值的分布偏移
原始资料里：论文就是这么想的，并写道只用14分之一的训练次数就达到了同样的精度。2018年MIT的论文把题目取为（译），并报告说，即使故意让分布发生偏移，训练的效果也几乎一样。它究竟为什么有效，至今没有定论。

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u10_vanishing_signal.py

# u10 深いニューラルネットワークで、逆伝播する信号は消えるのか（ReLU・重みの初期値・バッチ正規化）
#
# どの出来事か：2010年のネアとヒントンが命名したReLU（記録 relu_rectified_linear_2010。
#   同じ形のニューロンは 1968 年の福島邦彦 fukushima_feature_network_1968）、2010 年のグロロとベンジオによる
#   重みの初期値の決定法と、2015 年のヒーたちによる ReLU 用の決定法（weight_init_glorot_2010）、
#   2015 年のイオッフェとセゲディのバッチ正規化（batch_normalization_2015）。
# 仕組み：幅 WIDTH の層を DEPTH 段重ねたネットワークに、ランダムな入力を BATCH 個まとめて入れ、
#   順伝播する値の広がり（標準偏差）と、逆伝播する信号の大きさを、層ごとに測定する。
#   逆伝播する信号は、層を 1 つ通るたびに「重み × 素子の傾き」を掛けられる。シグモイドの傾きは 0.25 以下。
#   ネットワークも入力も、このサイトがランダムに作った例（学習はさせていない。学習前の初期状態を観察する）。
# 試してみよう：
#   - ACT を "sigmoid"・"tanh"・"relu" に変えると、入力層に戻る信号はどう変わるか
#   - INIT を "old"（±1/√n。かつてよく使われた値）・"glorot"・"he"・"big" に変える
#   - BATCHNORM を True にすると、順伝播する値の広がりはどうなるか

import math
import random

WIDTH = 24
DEPTH = 20
BATCH = 16
ACT = "sigmoid"
INIT = "old"
BATCHNORM = False

def act(z, kind):
    if kind == "sigmoid":
        return 1 / (1 + math.exp(-max(-60, min(60, z))))
    if kind == "tanh":
        return math.tanh(z)
    return z if z > 0 else 0.0

def slope(z, kind):
    if kind == "sigmoid":
        s = act(z, "sigmoid")
        return s * (1 - s)
    if kind == "tanh":
        return 1 - math.tanh(z) ** 2
    return 1.0 if z > 0 else 0.0

def weights(n_in, n_out, kind, rnd):
    if kind == "old":
        a = 1 / math.sqrt(n_in)
        return [[rnd.uniform(-a, a) for _ in range(n_in)] for _ in range(n_out)]
    if kind == "glorot":
        a = math.sqrt(6) / math.sqrt(n_in + n_out)
        return [[rnd.uniform(-a, a) for _ in range(n_in)] for _ in range(n_out)]
    if kind == "he":
        s = math.sqrt(2 / n_in)
        return [[rnd.gauss(0, s) for _ in range(n_in)] for _ in range(n_out)]
    a = 3 / math.sqrt(n_in)   # big：大きすぎる幅
    return [[rnd.uniform(-a, a) for _ in range(n_in)] for _ in range(n_out)]

def std(xs):
    m = sum(xs) / len(xs)
    return math.sqrt(sum((x - m) ** 2 for x in xs) / len(xs))

def run(act_kind, init_kind, bn, seed=2010):
    rnd = random.Random(seed)
    Ws = [weights(WIDTH, WIDTH, init_kind, rnd) for _ in range(DEPTH)]
    h = [[rnd.gauss(0, 1) for _ in range(WIDTH)] for _ in range(BATCH)]
    saved = []          # 層ごとに (入力値, z, 正規化の情報)
    fwd = []
    for W in Ws:
        z = [[sum(W[j][i] * x[i] for i in range(WIDTH)) for j in range(WIDTH)] for x in h]
        info = None
        if bn:          # ミニバッチ内で、ニューロンごとに平均 0・分散 1 にそろえる
            info = []
            for j in range(WIDTH):
                col = [z[b][j] for b in range(BATCH)]
                mu = sum(col) / BATCH
                sd = math.sqrt(sum((c - mu) ** 2 for c in col) / BATCH + 1e-5)
                info.append(sd)
                for b in range(BATCH):
                    z[b][j] = (z[b][j] - mu) / sd
        saved.append((h, z, info))
        h = [[act(v, act_kind) for v in row] for row in z]
        fwd.append(std([v for row in h for v in row]))
    # 逆伝播：出力層にランダムな信号を与え、入力層まで戻す
    g = [[rnd.gauss(0, 1) for _ in range(WIDTH)] for _ in range(BATCH)]
    top = math.sqrt(sum(v * v for row in g for v in row) / (BATCH * WIDTH))
    back = []
    for (x, z, info), W in zip(reversed(saved), reversed(Ws)):
        dz = [[g[b][j] * slope(z[b][j], act_kind) for j in range(WIDTH)] for b in range(BATCH)]
        if bn:          # 正規化を逆向きに通す
            for j in range(WIDTH):
                dy = [dz[b][j] for b in range(BATCH)]
                zh = [z[b][j] for b in range(BATCH)]
                s1, s2 = sum(dy), sum(d * y for d, y in zip(dy, zh))
                for b in range(BATCH):
                    dz[b][j] = (BATCH * dy[b] - s1 - zh[b] * s2) / (BATCH * info[j])
        g = [[sum(W[j][i] * dz[b][j] for j in range(WIDTH)) for i in range(WIDTH)] for b in range(BATCH)]
        back.append(math.sqrt(sum(v * v for row in g for v in row) / (BATCH * WIDTH)) / top)
    back.reverse()      # back[0] が入力層
    return fwd, back

def bar(v):
    """10 倍ごとの対数目盛りの棒グラフ（1 が 20 目盛り、1e-8 で 0）"""
    if v <= 0:
        return ""
    n = int(round((math.log10(v) + 8) * 2.5))
    return "■" * max(0, min(40, n))

fwd, back = run(ACT, INIT, BATCHNORM)
print(f"活性化関数：{ACT}　重みの初期値：{INIT}　バッチ正規化：{'あり' if BATCHNORM else 'なし'}　（{DEPTH} 層・幅 {WIDTH}）")
print("層  順伝播の値の広がり   逆伝播した信号（出力層を 1 とする。棒は 10 倍ごとの目盛り）")
for i in range(DEPTH):
    print(f"{i + 1:2d}   {fwd[i]:10.3g}          {back[i]:10.3g}  {bar(back[i])}")

print("\n組み合わせごとに、入力層まで戻った信号（出力層を 1 とする）")
print("活性化関数 重みの初期値 正規化なし   正規化あり")
for a in ("sigmoid", "tanh", "relu"):
    for k in ("old", "glorot", "he", "big"):
        r0 = run(a, k, False)[1][0]
        r1 = run(a, k, True)[1][0]
        print(f"{a:8s}  {k:10s}  {r0:10.2g}   {r1:10.2g}")
print("\nシグモイド関数の傾きは 0.25 以下。0.25 を 20 回かけると", f"{0.25 ** 20:.1g}")

022012〜2015・过拟合

Dropout与知识蒸馏

如何防止对训练数据拟合过度的过拟合？

在训练数据上全是正确答案，一遇到新数据却会出错。这就是过拟合。第9章里讲过的2012年的 Dropout，是每给网络看一个数据，就让隐藏层的神经元随机休息一半。它的效果接近于许多细小网络的平均。

在右边的图里，让曲线去拟合12个点（本站做的例子）。不让神经元休息的话，它和新的点（蓝色的圆）之间的误差会越来越大。

2015年的知识蒸馏，是让小网络去模仿大网络的输出，而这个输出是用温度T把概率变得柔和之后的结果。点“知识蒸馏”并提高T，就能看出正确答案以外的各个答案之间的差别。论文的看法是：这些差别里也有知识。

柔和的答案q_i ＝exp(z_i／T) ÷ Σ_j exp(z_j／T)

z_i: 输出i的分数
T: 温度（1时是通常的概率，越大越平缓）

常见说法常见说法：知识蒸馏是2015年辛顿等人开创的
原始资料里：2015年的论文本身就写道，同一方法的一种形式，早在2006年就由Caruana等人开拓了。

学过的点的误差（实线）和新的点的误差（虚线）。蓝＝不让神经元休息，绿＝第2个网络。纵轴每格是10倍

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u10_dropout.py

# u10 ニューロンの半分を休ませる（ドロップアウト）と、温度でやわらかくした答え（知識の蒸留）
#
# どの出来事か：2012 年 7 月、トロント大学のヒントンたちのドロップアウト（記録 dropout_2012。2014 年にくわしい論文）。
#   2015 年、グーグルのヒントン・ビニャルス・ディーンの知識の蒸留（knowledge_distillation_2015）。
# 仕組み：
#   1) 12 個の点（このサイトが作った例。sin 曲線にノイズを加えた点）に、隠れ層のニューロン HIDDEN 個のニューラルネットワークで曲線を近似する。
#      訓練データの誤差は 0 に近づくのに、テストデータ（sin 曲線そのもの）との誤差が増えるのが「覚えすぎ」（過学習）。
#      ドロップアウトでは、1 回学習するたびに、隠れ層のニューロンを DROP の割合でランダムに休ませる（出力を 0 にする）。
#      推論時はすべてのニューロンを使い、出力側の重みに（1 − DROP）を掛ける。学習法はこの章の Adam。
#   2) 大規模なネットワークが出したスコア（このサイトが作った例）を、温度 T の softmax 関数で確率に変換する。
#      T を上げると、正解以外の予測同士の確率の違いが見えてくる（蒸留で小さなネットワークにまねさせる「やわらかい答え」）。
# 試してみよう：
#   - DROP を 0.2 や 0.8 にすると、テストデータの誤差はどう変わるか
#   - HIDDEN を 10 にすると、ドロップアウトなしでも「覚えすぎ」（過学習）は起きるか
#   - LOGITS の数値を変更して、T を上げたときの確率の並びを見る

import numpy as np

HIDDEN = 100
DROP = 0.5
STEPS = 4000
rng = np.random.default_rng(2012)
N = 12
x_train = np.sort(rng.uniform(-3, 3, N))
y_train = np.sin(x_train) + rng.normal(0, 0.35, N)
x_test = np.linspace(-3, 3, 60)
y_test = np.sin(x_test)

def train(drop, seed=1):
    r = np.random.default_rng(seed)
    W1 = r.normal(0, 2, (HIDDEN, 1))
    b1 = r.normal(0, 2, HIDDEN)
    W2 = r.normal(0, 1 / np.sqrt(HIDDEN), (1, HIDDEN))
    b2 = np.zeros(1)
    params = [W1, b1, W2, b2]
    m = [np.zeros_like(p) for p in params]
    v = [np.zeros_like(p) for p in params]

def predict(x):          # 推論時：すべてのニューロンを使い、重みに (1 − drop) を掛ける
        h = np.tanh(x[:, None] @ W1.T + b1) * (1 - drop)
        return (h @ W2.T).ravel() + b2

history = []
    for t in range(1, STEPS + 1):
        X = x_train[:, None]
        z = X @ W1.T + b1
        h = np.tanh(z)
        mask = r.random(h.shape) >= drop       # True のニューロンだけ動作する（drop が 0 ならすべて）
        h = h * mask
        e = (h @ W2.T).ravel() + b2 - y_train
        gy = 2 * e / N
        gW2 = gy[None, :] @ h
        gb2 = gy.sum(keepdims=True)
        gz = (gy[:, None] @ W2) * mask * (1 - np.tanh(z) ** 2)
        grads = [gz.T @ X, gz.sum(0), gW2, gb2]
        for i, (p, g) in enumerate(zip(params, grads)):   # Adam
            m[i] = 0.9 * m[i] + 0.1 * g
            v[i] = 0.999 * v[i] + 0.001 * g * g
            p -= 0.01 * (m[i] / (1 - 0.9 ** t)) / (np.sqrt(v[i] / (1 - 0.999 ** t)) + 1e-8)
        if t % 500 == 0:
            history.append((t, np.mean((predict(x_train) - y_train) ** 2), np.mean((predict(x_test) - y_test) ** 2)))
    return history

for drop in (0.0, DROP):
    print(f"ドロップアウト {'なし' if drop == 0 else f'あり（休ませる割合 {drop}）'}")
    print("  学習回数    学習した点の誤差  新しい点の誤差")
    for t, tr, te in train(drop):
        print(f"  {t:6d}       {tr:10.4f}      {te:10.4f}  {'■' * int(te * 40)}")

print("\n温度 T でやわらかくした答え（手書きの 7 の画像を見た大きなネットワークの点数。このサイトが作った数）")
LOGITS = {"0": 1.0, "1": 5.0, "2": 3.5, "3": 1.5, "4": 2.0, "5": 0.5, "6": -1.0, "7": 9.0, "8": 1.0, "9": 4.0}
for T in (1, 3, 10):
    z = np.array(list(LOGITS.values())) / T
    q = np.exp(z - z.max())
    q /= q.sum()
    print(f"T = {T:2d}：" + "  ".join(f"{k}:{p:.3f}" for k, p in zip(LOGITS, q)))
print("T = 1 ではほとんど 7 だけ。T を上げると、1 と 9（7 に似た字）が、5 や 6 より何倍も高いことが見えてくる。")

032013・词的向量

词的加法

把单词变成一组数，连意义之间的关系也能计算吗？

2013年，谷歌Mikolov等人的 word2vec，用几百个数字组成的一组数（向量）来表示单词。它从大量文章中学习，让用法相近的单词靠得更近。用16亿个词，只用1个CPU，不到1天就做出了100万个词、300维的向量。

做出来的向量，可以用加法和减法来表示意义的关系。论文用这样一个问题的正确率来衡量性能：biggest − big＋small的答案是不是smallest。在右边的图（本站做的2维例子）里，试着点3个单词吧。

答案是排除了题目里的3个词之后离得最近的单词（这是9月版论文中补写的注释）。如果不排除，在这个例子里排第一的会是small。

v(答案) ≈ v(biggest) − v(big)＋v(small)

v(单词): 该单词的向量
答案: 离算出的点最近的单词（题目里的3个词除外）

常见说法常见说法：king − man＋woman＝queen是word2vec的论文发现的算式，恰好能得出答案
原始资料里：2013年1月的论文本身，是把这个例子作为先行研究的结果来引用的。它找答案时，是把题目里的3个词从候选中排除的。

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u10_skipgram.py

# u10 単語をベクトルにする（word2vec の Skip-gram を小さく再現）
#
# どの出来事か：2013 年、グーグルのミコロフたちの word2vec（記録 word2vec_2013）。
#   単語をベクトルで表し、中心の単語から周辺の単語を予測するように学習させる（Skip-gram）。
#   得られたベクトルは、足し算と引き算で単語の関係を表せる。論文では biggest − big + small に
#   最も近い単語が smallest かという類推問題の正解率で性能を評価した。答えを探す時は、問題の 3 語を除外した。
# 仕組み：このサイトが作った例の 45 の短い文（5 つの国・首都・言語・料理）から、中心の単語の前後 2 語を予測
#   するように、単語ごとに DIM 次元のベクトルを学習させる（原論文は 16 億語・300 次元）。
#   似た使われ方の単語が近くに来るか、「日本語 − 日本 ＋ ドイツ」のような類推ができるかを確かめる。
# 試してみよう：
#   - DIM を 4 や 24 にすると、正解率はどう変わるか
#   - EXCLUDE を False にすると（問題の 3 語を答えの候補から除外しないと）、正解率はどう変わるか
#   - 文（TEMPLATES）を追加・削除してみる

import numpy as np

DIM = 12
EPOCHS = 2000
RATE = 5.0
EXCLUDE = True
PAIRS = [("日本", "東京", "日本語", "すし"), ("フランス", "パリ", "フランス語", "パン"),
         ("イタリア", "ローマ", "イタリア語", "パスタ"), ("ドイツ", "ベルリン", "ドイツ語", "ソーセージ"),
         ("中国", "北京", "中国語", "ぎょうざ")]
TEMPLATES = ["{c} は {k} の 首都 です", "{k} の 首都 は {c} です", "{c} の 町 を 歩く",
             "{k} の 人 は {l} を 話す", "{k} で は {l} が 使われる", "{k} の 料理 は {f} です",
             "{c} で {f} を 食べる", "{c} で {l} を 聞く", "{k} の {c} に 行く"]

sents = [t.format(k=k, c=c, l=l, f=f).split() for k, c, l, f in PAIRS for t in TEMPLATES]
vocab = sorted({w for s in sents for w in s})
ix = {w: i for i, w in enumerate(vocab)}
pairs = np.array([(ix[w], ix[s[j]]) for s in sents for i, w in enumerate(s)
                  for j in range(max(0, i - 2), min(len(s), i + 3)) if j != i])
print(f"文 {len(sents)}・単語の種類 {len(vocab)}・（真ん中, まわり）の組 {len(pairs)}")

rng = np.random.default_rng(2013)
E = rng.normal(0, 0.1, (len(vocab), DIM))     # 単語ベクトル（word2vec の学習結果）
O = rng.normal(0, 0.1, (len(vocab), DIM))     # 周辺単語を予測するための、もう 1 組の重みベクトル
for ep in range(EPOCHS):
    Ec = E[pairs[:, 0]]
    S = Ec @ O.T
    S -= S.max(1, keepdims=True)
    P = np.exp(S)
    P /= P.sum(1, keepdims=True)              # 周辺単語の予測確率（softmax 関数）
    P[np.arange(len(pairs)), pairs[:, 1]] -= 1  # 目的の単語との誤差
    P /= len(pairs)
    gO = P.T @ Ec
    gE = np.zeros_like(E)
    np.add.at(gE, pairs[:, 0], P @ O)
    E -= RATE * gE
    O -= RATE * gO

V = E - E.mean(0)                             # 平均ベクトルを引いて中心化してから比べる
V /= np.linalg.norm(V, axis=1, keepdims=True)

def nearest(v, exclude=()):
    s = V @ (v / np.linalg.norm(v))
    return [(vocab[i], float(s[i])) for i in np.argsort(-s) if vocab[i] not in exclude]

print("\nいちばん近い単語（向きの近さ。1 が同じ向き）")
for w in ("東京", "フランス", "パスタ", "日本語"):
    print(f"  {w}：" + "、".join(f"{x}（{s:.2f}）" for x, s in nearest(V[ix[w]], (w,))[:3]))

questions = []
for k1, c1, l1, f1 in PAIRS:
    for k2, c2, l2, f2 in PAIRS:
        if k1 != k2:
            questions += [(k1, c1, c2, k2), (l1, k1, k2, l2), (f1, k1, k2, f2)]
print(f"\n問い「A − B ＋ C は？」{len(questions)} 問（国と首都・国と言葉・国と料理）")
for excl in (True, False):
    ok = sum(nearest(V[ix[a]] - V[ix[b]] + V[ix[c]], (a, b, c) if excl else ())[0][0] == ans for a, b, c, ans in questions)
    print(f"  問いの 3 語を{'外す' if excl else '外さない'}：{ok} 問 正解（{ok / len(questions):.0%}）")
print("\n例（問いの 3 語を" + ("外す" if EXCLUDE else "外さない") + "）")
for a, b, c, ans in questions[:: len(questions) // 6][:6]:
    top = nearest(V[ix[a]] - V[ix[b]] + V[ix[c]], (a, b, c) if EXCLUDE else ())[:3]
    mark = "○" if top[0][0] == ans else "×"
    print(f"  {a} − {b} ＋ {c} → " + "、".join(x for x, _ in top) + f"　（期待：{ans} {mark}）")

042013〜2015・强化学习

只凭分数学会怎么玩

不教规则，只凭画面和分数，游戏就能玩得越来越好吗？

强化学习是通过反复试错，增加那些带来得分的行动的学习方法。Q学习把“在某个状态下怎么做、将来能得多少分”（Q值）列成表，每做一次行动就稍微更新一点。在右边的迷宫（本站做的例子）里，看看终点的得分是怎样一步一步传到前面的格子的。

2013年12月，伦敦DeepMind的 DQN，用卷积神经网络代替了表。它把画面的像素直接作为输入，用改造过的Q学习方法来学习。在以前就有的7个电视游戏中，有6个超过了以往的方法，有3个超过了人类的熟练玩家。2015年发表在Nature上的论文，用同一套机制学习了49个游戏。

Q(s, a) ← Q(s, a)＋α［r＋γ max_a′ Q(s′, a′) − Q(s, a)］

s: 当前的状态
a: 行动
r: 得到的奖励
s′: 下一个状态
α: 学习率
γ: 未来奖励的权重

常见说法常见说法：AI在电视游戏上超过了人类
原始资料里：2015年论文的说法是（译）。能拿到人类得分75%以上的，49个里有29个。论文本身写道，需要长远规划的游戏（如蒙特祖玛的复仇等）仍是一个很大的课题。

每一次的结果（绿＝到达终点，紫＝掉进洞里，灰＝超时）

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u10_q_learning.py

# u10 得点だけを手がかりに、迷路の歩き方を学習する（Q学習。DQNの基礎となった学習法）
#
# どの出来事か：2013年12月、DeepMindのDQN（記録 deepmind_dqn_atari_2013）。
#   論文の要旨によると、画面のピクセルを直接入力する畳み込みニューラルネットワークをQ学習の変形手法で学習させ、
#   将来得られる得点の期待値（Q値）を出力させた。7本のテレビゲームのうち6本で従来の手法を上回った。
# 仕組み：このサイトが作った小さな迷路で、「このますでこの向きに動いたら、先々どれだけ点が入りそうか」の表
#   （Qテーブル）を、行動するたびに少しずつ更新する。ゴールで +1 点、穴で −1 点。ほかは 0 点。
#   DQNは、この表の代わりにニューラルネットワークを使い、マスの番号の代わりに画面そのものを入力した。
# 試してみよう：
#   - EPSILON（ランダムに動く割合）を 0 にすると、道を見つけられるか
#   - GAMMA（将来の得点をどれだけ重視するか）を 0.5 にすると、ゴールから遠いマスの Q はどうなるか
#   - MAZE の文字を書きかえて、別の迷路にする（S＝出発、G＝ゴール、X＝穴、#＝壁）

import random

MAZE = ["....#G",
        ".##.#.",
        "....X.",
        ".#X...",
        "S....."]
EPISODES = 300
ALPHA = 0.5      # 更新の速さ（学習率）
GAMMA = 0.9      # 将来の得点をどれだけ重視するか（割引率）
EPSILON = 0.2    # ランダムに動く割合
random.seed(2013)

H, W = len(MAZE), len(MAZE[0])
MOVES = {"↑": (-1, 0), "→": (0, 1), "↓": (1, 0), "←": (0, -1)}
start = next((r, c) for r in range(H) for c in range(W) if MAZE[r][c] == "S")
Q = {(r, c): {a: 0.0 for a in MOVES} for r in range(H) for c in range(W)}

def step(s, a):
    r, c = s[0] + MOVES[a][0], s[1] + MOVES[a][1]
    if not (0 <= r < H and 0 <= c < W) or MAZE[r][c] == "#":
        r, c = s                       # 壁：動けない
    cell = MAZE[r][c]
    if cell == "G":
        return (r, c), 1.0, True
    if cell == "X":
        return (r, c), -1.0, True
    return (r, c), 0.0, False

def best(s):
    m = max(Q[s].values())
    return random.choice([a for a, v in Q[s].items() if v == m])

scores = []
for ep in range(EPISODES):
    s, total = start, 0.0
    for t in range(60):
        a = random.choice(list(MOVES)) if random.random() < EPSILON else best(s)
        s2, r, done = step(s, a)
        target = r if done else r + GAMMA * max(Q[s2].values())
        Q[s][a] += ALPHA * (target - Q[s][a])       # Q(s,a) ← Q(s,a) + α [ r + γ max Q(s′,a′) − Q(s,a) ]
        s, total = s2, total + r
        if done:
            break
    scores.append(total)
    if (ep + 1) % 50 == 0:
        last = scores[-50:]
        print(f"{ep + 1:4d} 回目まで：直近 50 回で ゴール {last.count(1.0):2d} 回・穴 {last.count(-1.0):2d} 回")

print("\n学習後の、マスごとの最適な向き（数値はその向きの Q 値）")
for r in range(H):
    row = []
    for c in range(W):
        ch = MAZE[r][c]
        if ch in "#GX":
            row.append({"#": "  ■  ", "G": " ゴール", "X": "  穴 "}[ch])
        else:
            a = max(Q[(r, c)], key=Q[(r, c)].get)
            row.append(f"{a}{Q[(r, c)][a]:4.2f}")
    print(" ".join(row))
print("\nゴールの 1 点が、1 歩手前ごとに GAMMA 倍されながら、出発のマスまで伝わっている。")

052013〜2014・迁移学习

把学好的网络拿来重复使用

只有几十张照片的任务，也能用深度学习吗？

2012年的AlexNet，是用ImageNet大赛里约120万张、1000个类别的图片训练出来的。2013年10月，加州大学伯克利分校Donahue等人的 DeCAF，在固定同一结构网络的权重不动的情况下，把靠近输出的那一层的反应（4096个数），拿来作为另一项任务的特征量。即使是每个类别只学30张的Caltech-101，只在上面加一个线性分类器，也答对了86.9%，超过了把5种手工特征量合在一起的当时最高水平。这就叫迁移学习。

用新任务的数据，以很小的步幅重新训练整个网络，叫微调（fine-tuning）。在下一个见开页的R-CNN里，微调使mAP提高了8个百分点。

右边的图（本站做的8×8的例子），把在识别1条线时学到的网络，用来识别2条线的组合。改变例子的数量来比一比吧。

新的答案＝softmax( W_新 · φ(x) )

φ(x): 之前学过的那一层的反应（DeCAF里是4096个。固定时不改变）
W_新: 新训练的最后一层

常见说法常见说法：迁移学习是深度学习时代才诞生的想法
原始资料里：2010年人工智能学会志（日本人工智能学会的会刊）上的解说写道，并说它从1995年的NIPS研讨会起成为机器学习的一个分支。DeCAF的论文也把“从相关工作中学习”的研究历史从1996〜1997年算起。

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u10_transfer_finetune.py

# u10 学習したネットワークを再利用する（転移学習）：中間層を固定する・一から学習する・微調整する
#
# どの出来事か：2013 年 10 月、カリフォルニア大学バークレー校のドナヒューたちの DeCAF（記録 decaf_2013）。
#   ImageNet で学習した CNN の重みを固定したまま、途中の層の出力を別のタスクの特徴量にし、
#   1 種類 30 枚の Caltech-101 で正解率 86.9% を出した。R-CNN（rcnn_2013）は、ネットワーク全体を小さな学習率で再学習する
#   微調整（ファインチューニング）で mAP を 8 ポイント上げた。2014 年のヨシンスキーたち（transferable_features_2014）は、
#   どの層までが別のタスクに移せるかを 1 層ずつ検証した。2018 年のヒーたち（rethinking_imagenet_pretraining_2018）は、
#   データが十分なら一から学習しても追いつくが、極めて少ない時は事前学習したネットワークが大きく勝つと報告した。
# 仕組み：
#   1) 事前タスク（ImageNet の代わり）：8×8 の画像に線が 1 本。横 6・縦 6・斜め 2 の 14 種類を、
#      1 種類 150 枚（ノイズつき）で、64 → 16 → 14 のネットワークに学習させる。中間層の 16 個のニューロンが、線を検出する特徴になる。
#   2) 新しいタスク：線 2 本の組み合わせの 4 種類。1 種類 N 枚だけで、次の 3 つの学習方法を比べる。
#      ・固定：事前学習した中間層（64 → 16）をそのまま使い、出力層（16 → 4）だけ学習する（DeCAF の形式）
#      ・一から：ランダムな重みの初期値から、すべての層を一から学習する
#      ・微調整：事前学習した中間層から始めて、すべての層を学習する。中間層の学習率は 10 分の 1（R-CNN の形式）
#      おまけに、ランダムな重みの中間層を固定して出力層だけ学習するもの（事前学習なし）も比べる。
#   画像・種類・枚数は、このサイトが作った例（本物の写真ではない）。正解率は、別に作ったテストデータ（1 種類 100 枚）で測る。
# 試してみよう：
#   - NOISE を 0.3 や 0.9 にすると、固定と一からの差はどう変わるか
#   - 前の仕事を線 2 本の組にする（OLD = [(0, 6), (5, 11), (2, 8)] など）と、新しい仕事への役立ち方はどう変わるか
#   - HIDDEN を 8 や 32 にする

import numpy as np

S = 8            # 画像の大きさ（8×8）
NOISE = 0.6      # ノイズの大きさ
HIDDEN = 16      # 中間層のニューロンの数
SEEDS = 3        # 同じ N で何回繰り返して平均するか

rng = np.random.default_rng(2014)

def stroke(k):
    """線の部品：0〜5 は横線（上から 2〜7 行目）、6〜11 は縦線、12 は＼、13 は／"""
    img = np.zeros((S, S))
    if k < 6:
        img[k + 1, 1:7] = 1
    elif k < 12:
        img[1:7, k - 5] = 1
    elif k == 12:
        for i in range(1, 7):
            img[i, i] = 1
    else:
        for i in range(1, 7):
            img[i, 7 - i] = 1
    return img

# 前の仕事：線 1 本の 14 種類（同じ線を 2 回書く形にしてある）。新しい仕事：線 2 本の組 4 種類
OLD = [(k, k) for k in range(14)]
NEW = [(1, 7), (4, 9), (3, 12), (8, 11)]

def make(classes, n, r):
    X, y = [], []
    for k, (a, b) in enumerate(classes):
        base = np.maximum(stroke(a), stroke(b))
        for _ in range(n):
            X.append((base * r.uniform(0.6, 1.0) + r.normal(0, NOISE, (S, S))).ravel())
            y.append(k)
    return np.array(X), np.array(y)

def init(n_in, n_out, r):
    return [r.normal(0, 1 / np.sqrt(n_in), (n_in, n_out)), np.zeros(n_out)]

def forward(X, W1, b1, W2, b2):
    h = np.tanh(X @ W1 + b1)
    z = h @ W2 + b2
    z = z - z.max(axis=1, keepdims=True)
    p = np.exp(z)
    return h, p / p.sum(axis=1, keepdims=True)

def train(X, y, W1, b1, W2, b2, epochs, lr_mid, lr_top, batch=None, r=None):
    """lr_mid が 0 なら真ん中の層は固定。batch が None なら全部の例で 1 歩"""
    K = W2.shape[1]
    Y = np.eye(K)[y]
    n = len(X)
    for _ in range(epochs):
        order = r.permutation(n) if batch else np.arange(n)
        for s in range(0, n, batch or n):
            j = order[s:s + (batch or n)]
            h, p = forward(X[j], W1, b1, W2, b2)
            g = (p - Y[j]) / len(j)                      # 交差エントロピー誤差の勾配
            gW2, gb2 = h.T @ g, g.sum(axis=0)
            gh = (g @ W2.T) * (1 - h ** 2)               # tanh の勾配
            gW1, gb1 = X[j].T @ gh, gh.sum(axis=0)
            W2 -= lr_top * gW2
            b2 -= lr_top * gb2
            if lr_mid:
                W1 -= lr_mid * gW1
                b1 -= lr_mid * gb1
    return W1, b1, W2, b2

def accuracy(X, y, W1, b1, W2, b2):
    return float((forward(X, W1, b1, W2, b2)[1].argmax(axis=1) == y).mean())

# ---- 1) 事前タスクで学習する ----
XA, yA = make(OLD, 150, rng)
W1, b1 = init(S * S, HIDDEN, rng)
W2, b2 = init(HIDDEN, len(OLD), rng)
train(XA, yA, W1, b1, W2, b2, epochs=30, lr_mid=0.1, lr_top=0.1, batch=20, r=rng)
XAt, yAt = make(OLD, 50, rng)
print(f"事前タスク（線 1 本の 14 種類 × 150 枚）で学習したネットワークの正解率：{accuracy(XAt, yAt, W1, b1, W2, b2):.0%}")

# 中間層のニューロンの重みが、どの線の部品に最も似ているか（向きの ± は問わない）
PARTS = [f"横線（{k + 2} 行目）" for k in range(6)] + [f"縦線（{k + 2} 列目）" for k in range(6)] + ["＼", "／"]
P = np.array([stroke(k).ravel() - stroke(k).mean() for k in range(14)])
sim = np.abs((W1.T - W1.T.mean(axis=1, keepdims=True)) @ P.T) / (np.linalg.norm(W1.T - W1.T.mean(axis=1, keepdims=True), axis=1, keepdims=True) * np.linalg.norm(P, axis=1))
best = np.argsort(-sim.max(axis=1))[:2]
print("\n事前に学習した中間層のニューロンのうち、線の形にいちばん似ている 2 つ（＋＝強くプラス、－＝強くマイナス）")
for u in best:
    w = W1[:, u].reshape(S, S)
    t = 0.35 * np.abs(w).max()
    rows = ["".join("＋" if v > t else "－" if v < -t else "・" for v in row) for row in w]
    print(f"  ニューロン {u:2d}（{PARTS[sim[u].argmax()]} に似ている。似かた {sim[u].max():.2f}）")
    print("      " + "\n      ".join(rows))

# ---- 2) 新しいタスクで、3 つの学習方法を比べる ----
XBt, yBt = make(NEW, 100, rng)
NS = [1, 2, 3, 5, 10, 20, 40]
names = {"fix": "固定", "scratch": "一から", "ft": "微調整", "rand": "ランダム固定"}
table = {k: [] for k in names}
for n in NS:
    acc = {k: [] for k in names}
    for s in range(SEEDS):
        r = np.random.default_rng(100 + s)
        XB, yB = make(NEW, n, r)
        top = init(HIDDEN, len(NEW), r)
        acc["fix"].append(accuracy(XBt, yBt, *train(XB, yB, W1.copy(), b1.copy(), *top, 200, 0, 0.5)))
        mid = init(S * S, HIDDEN, r)
        top = init(HIDDEN, len(NEW), r)
        acc["scratch"].append(accuracy(XBt, yBt, *train(XB, yB, *mid, *top, 200, 0.5, 0.5)))
        top = init(HIDDEN, len(NEW), r)
        acc["ft"].append(accuracy(XBt, yBt, *train(XB, yB, W1.copy(), b1.copy(), *top, 200, 0.05, 0.5)))
        mid = init(S * S, HIDDEN, r)
        top = init(HIDDEN, len(NEW), r)
        acc["rand"].append(accuracy(XBt, yBt, *train(XB, yB, *mid, *top, 200, 0, 0.5)))
    for k in names:
        table[k].append(np.mean(acc[k]))

print(f"\n新しいタスク（4 種類。当てずっぽうなら 25%）のテストの正解率（{SEEDS} 回の平均）")
print("例の数　" + "".join(f"{n:>6}" for n in NS))
print("（固定＝事前に学習した中間層を固定して最後の層だけ学習／一から＝全部をランダムな値から学習／微調整＝事前に学習した層から全部を学習／ランダム固定＝ランダムな中間層を固定）")
for k, name in names.items():
    print(f"{name:　<6}" + "".join(f"{v:6.0%}" for v in table[k]))

print("\n例が 1 種類 2 枚の時（棒 1 つ＝5%）")
i = NS.index(2)
for k, name in names.items():
    v = table[k][i]
    print(f"  {name:　<6} {'■' * int(round(v * 20)):<20} {v:.0%}")
print("\n例が少ないうちは、事前に学習した層を使う方がよく当てる。例が増えると、一から学習する方が追いつき、追いこすこともある。")

062013〜2015・物体检测

在哪里，是什么，有几个

怎样才能把照片里的东西用方框圈出来并标上名字？

图像分类是给每张图片一个答案。物体检测则是把照片中的东西一个一个用方框圈起来，并标上名字。

2013年11月，加州大学伯克利分校Girshick等人的 R-CNN，先用一种不需要学习的方法做出约2000个候选方框，一个个送进CNN，再用各个类别的SVM打分。因为围着同一个东西的方框会留下好几个，所以要把与得分高的方框大幅重叠的方框去掉（非极大值抑制）。学会版本在PASCAL VOC 2012上取得mAP 53.3%，大幅超过此前的最高水平，但每张图在GPU上要花13秒。

2015年6月，华盛顿大学Redmon等人的 YOLO，把图像分成7×7的格子，让网络一次同时给出每个格子的2个方框（共98个）和类别。每秒45张，63.4%。同月，Ren等人的 Faster R-CNN 连候选也让网络来做，每秒5张，73.2%。在右边的图里比一比吧。

IoU＝重叠的面积 ÷ 合起来的面积

IoU: 预测的方框与正确的方框重叠的比例（1为完全一致，0为完全不重叠）

常见说法常见说法：YOLO是第一个实时找出物体的
原始资料里：YOLO的论文本身就举出了更早以每秒30张运行的DPM（2014年Sadeghi和Forsyth）。YOLO的主张是：在实时方法中，准确率提高到了2倍以上（26.1% → 63.4%）。每秒0.5张的Fast R-CNN（70.0%）更准确，而YOLO的位置偏差更多。

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u10_object_detect.py

# u10 物体検出：候補の領域を 1 つずつ調べる（R-CNN 風）と、グリッドで同時に予測する（YOLO 風）
#
# どの出来事か：2013 年 11 月、ギルシックたちの R-CNN（記録 rcnn_2013）。機械学習を使わない手法で候補領域（四角）を
#   画像 1 枚あたり約 2000 個作成し、1 つずつ CNN に通してスコアをつけた。そして、スコアの高い領域と大きく重なる領域を除去した（非最大値抑制）。
#   2015 年 6 月、レドモンたちの YOLO（yolo_2015）。画像を 7×7 のグリッド（格子）に分割し、セルごとに 2 つの領域（計 98 個）を
#   ネットワークの 1 回の計算で同時に出力した。同じ月のレンたちの Faster R-CNN（faster_rcnn_2015）は、候補領域の生成もネットワークに任せた。
# 仕組み：
#   ・IoU（重なりの割合）＝ 重なった面積 ÷ 合わせた面積。1 で完全一致、0 で重なりなし。
#   ・非最大値抑制：スコアの高い順に領域を取り出し、それと IoU がしきい値を超える領域を除去する処理を繰り返す。
#   ・画像は、このサイトが作った例として 32×32 のドット絵（丸・四角・三角）を使用。本物の写真ではない。
#   ・スコアの計算は、ネットワークの代わりにこのサイトが作った簡易ルール：領域内で最多を占める図形の塊を見つけ、
#     その塊を囲む四角との IoU をスコアとする。本物の R-CNN は CNN の特徴量と SVM で、YOLO は 1 つの CNN でスコアを予測する。
# 試してみよう：
#   - N_PROPOSALS を 100 や 5000 にすると、検出数やスコアを計算した回数はどう変わるか
#   - NMS_IOU を 0.1 や 0.9 にすると、残る四角の数はどう変わるか
#   - GRID を 4 や 14 にする（YOLO の論文は 7）

import random

W = H = 32
N_PROPOSALS = 2000   # R-CNN の論文：候補は約 2000 個
GRID = 7             # YOLO の論文：7×7 の格子、セルごとに 2 つの領域
NMS_IOU = 0.5        # これより大きく重なる領域を除去する（このサイトの設定）
SCORE_MIN = 0.6      # これよりスコアの低い領域は最初から除外する（このサイトの設定）
NAMES = {1: "丸", 2: "四角", 3: "三角"}
MARK = {0: ".", 1: "o", 2: "#", 3: "^"}

random.seed(2015)

# ---- 画像を生成する ----
img = [[0] * W for _ in range(H)]
truth = []   # 正解の領域 (x0, y0, x1, y1, クラス)。x1・y1 は含まない端

def put_circle(cx, cy, r):
    for y in range(H):
        for x in range(W):
            if (x + 0.5 - cx) ** 2 + (y + 0.5 - cy) ** 2 <= r * r:
                img[y][x] = 1
    truth.append((round(cx - r), round(cy - r), round(cx + r), round(cy + r), 1))

def put_square(x0, y0, s):
    for y in range(y0, y0 + s):
        for x in range(x0, x0 + s):
            img[y][x] = 2
    truth.append((x0, y0, x0 + s, y0 + s, 2))

def put_triangle(x0, y0, s):
    for y in range(s):
        for x in range(s):
            if abs(x + 0.5 - s / 2) <= (y + 1) / 2:   # 下へ行くほど幅が広がる
                img[y0 + y][x0 + x] = 3
    truth.append((x0, y0, x0 + s, y0 + s, 3))

put_circle(8.5, 9.5, 5.5)
put_square(19, 4, 9)
put_triangle(6, 19, 10)
put_circle(24.5, 24.5, 4.5)

def iou(a, b):
    ix = max(0, min(a[2], b[2]) - max(a[0], b[0]))
    iy = max(0, min(a[3], b[3]) - max(a[1], b[1]))
    inter = ix * iy
    union = (a[2] - a[0]) * (a[3] - a[1]) + (b[2] - b[0]) * (b[3] - b[1]) - inter
    return inter / union if union else 0.0

# 画像のドットを連結した塊に分ける（同じ種類で上下左右につながる点）。塊ごとに外接する四角を求める
label = [[-1] * W for _ in range(H)]
blobs = []   # (x0, y0, x1, y1, クラス)
for y in range(H):
    for x in range(W):
        if img[y][x] and label[y][x] < 0:
            c, stack, pts = img[y][x], [(x, y)], []
            label[y][x] = len(blobs)
            while stack:
                px, py = stack.pop()
                pts.append((px, py))
                for qx, qy in ((px + 1, py), (px - 1, py), (px, py + 1), (px, py - 1)):
                    if 0 <= qx < W and 0 <= qy < H and img[qy][qx] == c and label[qy][qx] < 0:
                        label[qy][qx] = len(blobs)
                        stack.append((qx, qy))
            xs, ys = [q[0] for q in pts], [q[1] for q in pts]
            blobs.append((min(xs), min(ys), max(xs) + 1, max(ys) + 1, c))

def score(box):
    """ネットワークの代わりの簡易ルール。領域内で最多を占める塊を囲む四角との IoU を計算する。戻り値は（スコア, クラス）"""
    x0, y0, x1, y1 = box[:4]
    n = {}
    for y in range(y0, y1):
        for x in range(x0, x1):
            if label[y][x] >= 0:
                n[label[y][x]] = n.get(label[y][x], 0) + 1
    if not n:
        return 0.0, 0
    b = blobs[max(n, key=n.get)]
    return iou(box, b), b[4]

def nms(boxes, thr):
    """boxes：(スコア, クラス, x0, y0, x1, y1)。クラスごとにスコアが高い順に残し、重なる領域を除去する"""
    keep = []
    for b in sorted(boxes, reverse=True):
        if all(k[1] != b[1] or iou(k[2:], b[2:]) <= thr for k in keep):
            keep.append(b)
    return keep

def hits(found):
    """正解の領域ごとに、同じクラスで IoU が 0.5 より大きい予測があるか判定（YOLO の論文が誤りを分類した線と同じ）"""
    return sum(1 for t in truth if any(f[1] == t[4] and iou(f[2:], t[:4]) > 0.5 for f in found))

def show(found):
    grid = [[MARK[img[y][x]] for x in range(W)] for y in range(H)]
    for f in found:
        x0, y0, x1, y1 = f[2:]
        for x in range(x0, x1):
            for y in (y0, y1 - 1):
                grid[y][x] = "+"
        for y in range(y0, y1):
            for x in (x0, x1 - 1):
                grid[y][x] = "+"
    print("\n".join("  " + " ".join(row) for row in grid))

print("このサイトが作った例：32×32 の画像（o＝丸、#＝四角、^＝三角）。正解の領域は", len(truth), "個")

print("\nIoU のテスト：正解の丸の領域", truth[0][:4])
for d in (0, 2, 4, 8):
    b = (truth[0][0] + d, truth[0][1], truth[0][2] + d, truth[0][3])
    print(f"  右に {d} ずらした四角 {b} → IoU {iou(b, truth[0]):.2f}")

# ---- R-CNN 風：候補を作成し、1 つずつスコアを計算する ----
props = []
for i in range(N_PROPOSALS):
    if i % 2 == 0:   # 半分は物体の周辺（本物は selective search。ここはこのサイトの簡単な作り方）
        t = random.choice(truth)
        w, h = t[2] - t[0], t[3] - t[1]
        x0 = t[0] + round(random.gauss(0, w * 0.25))
        y0 = t[1] + round(random.gauss(0, h * 0.25))
        x1 = x0 + max(2, round(w * random.uniform(0.6, 1.4)))
        y1 = y0 + max(2, round(h * random.uniform(0.6, 1.4)))
    else:            # 残りはランダムな位置と大きさ
        x0, y0 = random.randrange(0, W - 2), random.randrange(0, H - 2)
        x1, y1 = x0 + random.randint(2, 16), y0 + random.randint(2, 16)
    props.append((max(0, x0), max(0, y0), min(W, x1), min(H, y1)))
props = [p for p in props if p[2] - p[0] >= 2 and p[3] - p[1] >= 2]

scored = []
for p in props:              # ここが「1 つずつ網に通す」所（R-CNN では 1 枚 GPU で 13 秒）
    s, c = score(p)
    if s >= SCORE_MIN:
        scored.append((s, c) + p)
rcnn = nms(scored, NMS_IOU)

# ---- YOLO 風：格子のセルごとに 2 つの領域を、1 回でまとめて出力する ----
cell = W / GRID
preds = []
for gy in range(GRID):
    for gx in range(GRID):
        cx, cy = (gx + 0.5) * cell, (gy + 0.5) * cell
        for b in range(2):
            # セルの中心が物体の塊の四角の中にあれば、その四角にずれを加えて予測する（ネットワークの代わりの、このサイトの作り方）
            near = [t for t in blobs if t[0] <= cx < t[2] and t[1] <= cy < t[3]]
            if near:
                t = near[0]
                j = 1 + b          # 2 つ目の四角は、ずれを大きく
                box = (t[0] + random.randint(-j, j), t[1] + random.randint(-j, j), t[2] + random.randint(-j, j), t[3] + random.randint(-j, j))
            else:
                s = random.randint(2, 6)
                box = (int(cx) - s // 2, int(cy) - s // 2, int(cx) + s - s // 2, int(cy) + s - s // 2)
            box = (max(0, box[0]), max(0, box[1]), min(W, box[2]), min(H, box[3]))
            s, c = score(box)
            preds.append((s, c) + box)
yolo = nms([p for p in preds if p[0] >= SCORE_MIN], NMS_IOU)

print("\n           通した回数  出た領域  スコア {:.1f} 以上  重なりを除いた後  検出成功（正解 {} 個）".format(SCORE_MIN, len(truth)))
print(f"R-CNN 風   {len(props):>10}  {len(props):>8}  {len(scored):>10}  {len(rcnn):>18}  {hits(rcnn):>6}")
print(f"YOLO 風    {1:>10}  {len(preds):>8}  {len([p for p in preds if p[0] >= SCORE_MIN]):>10}  {len(yolo):>18}  {hits(yolo):>6}")
print("（R-CNN 風は候補の数だけネットワークに通す。YOLO 風はネットワーク 1 回で 98 個の領域を同時に出力する。どちらも最後に非最大値抑制を行う）")

print("\nR-CNN 風で残った領域")
for s, c, *b in rcnn:
    print(f"  {NAMES[c]:　<3} スコア {s:.2f}  {tuple(b)}")
print("\nR-CNN 風の検出結果を描画（+ が枠線）")
show(rcnn)

072013・生成方法（1）

压缩，再展开

把数据压缩成2个数，能用这2个数造出新的数据吗？

自编码器是一种学习“输出与输入相同的东西”的网络，中间层很细。前半部分（编码器）把数据压缩成少数几个数，后半部分（解码器）再还原。这种结构在1985〜1987年就有了，但压缩出来的数之间到处是空隙，从那里造东西，形状会崩掉。

2013年12月，阿姆斯特丹大学Kingma和Welling的 VAE（变分自编码器），让压缩出来的数的分布逐渐逼近平均0、离散程度1的正态分布来学习。所以只要从正态分布里选数，就能造出新的数据。右边是本站用Python训练的例子：把12×12的人脸压缩成2个数。比一比这2个数吧。

z＝μ＋σ × ε（ε是平均0、离散程度1的随机数）

μ: 编码器给出的平均
σ: 离散程度
z: 选中的点

常见说法常见说法：自编码器是2006年辛顿开创的
原始资料里：让网络通过细的层输出与输入相同的东西，这个课题在1985年和1986年的论文里就已经有了。2006年的那篇论文本身也写道，深层自编码器效果很好这件事（译）。

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u10_vae_faces.py

# u10 縮めて、また広げる：オートエンコーダーと VAE（変分オートエンコーダー）
#
# どの出来事か：2013 年 12 月、アムステルダム大学のキングマとウェリングの VAE（記録 vae_kingma_welling_2013）。
#   入力と同じデータを狭い層を通して復元する構成（オートエンコーダー）は、1985〜1987 年にすでにあった（autoencoder_origins_1986）。
# 仕組み：このサイトが作った 12×12 の顔画像（口の曲がり方と目の大きさの 2 つだけが変わる）を、
#   エンコーダーで 2 つの数値 z に圧縮し、デコーダーで元の画像に復元するように学習させる。
#   ・オートエンコーダー（AE）：z は 1 つの点。復元誤差だけを小さくする。
#   ・VAE：エンコーダーは平均 μ とばらつき σ を出力し、z ＝ μ ＋ σ × ε（ε は乱数）で点を選ぶ。
#     復元誤差と同時に、z の分布を平均 0・分散 1 の正規分布に近づける（KL ダイバージェンスという、分布のずれ）。
#   学習後、正規分布から z を選んでデコーダーに通すと、新しい顔が生成できるかを比べる。
# 試してみよう：
#   - BETA（正規分布に近づける強さ）を 0 にすると、VAE は AE とどう違ってくるか
#   - STEPS を減らすと、生成した顔はどうなるか

import numpy as np

SIZE = 12
HIDDEN = 32
STEPS = 2500
BETA = 1.0
rng = np.random.default_rng(2013)

def face(smile, eye):
    """smile：−1（への字）〜 1（笑う）、eye：0（小さい）〜 1（大きい）"""
    y, x = np.mgrid[0:SIZE, 0:SIZE] + 0.5
    img = np.clip(1.2 - abs(np.hypot(x - 6, y - 6) - 5.2) * 1.6, 0, 1)            # 輪郭
    r = 0.6 + 1.0 * eye
    for ex in (4.2, 7.8):
        img = np.maximum(img, np.clip(1.4 - (np.hypot(x - ex, y - 4.6) - r) * 2.2, 0, 1))  # 目
    t = np.clip((x - 6) / 2.4, -1, 1)
    my = 8.0 + smile * 1.3 * (1 - t ** 2) - smile * 0.4                              # 口
    mouth = np.clip(1.2 - abs(y - my) * 1.8, 0, 1) * (abs(x - 6) < 2.6)
    return np.clip(np.maximum(img, mouth), 0, 1).ravel()

params = rng.uniform([-1, 0], [1, 1], (400, 2))
X = np.array([face(s, e) for s, e in params])

def init(n_in, n_out):
    return [rng.normal(0, 1 / np.sqrt(n_in), (n_in, n_out)), np.zeros(n_out)]

def train(vae):
    enc = init(SIZE * SIZE, HIDDEN) + init(HIDDEN, 4 if vae else 2)
    dec = init(2, HIDDEN) + init(HIDDEN, SIZE * SIZE)
    ps = enc + dec
    m = [np.zeros_like(p) for p in ps]
    v = [np.zeros_like(p) for p in ps]
    for t in range(1, STEPS + 1):
        x = X[rng.integers(0, len(X), 64)]
        h1 = np.tanh(x @ ps[0] + ps[1])
        o = h1 @ ps[2] + ps[3]
        if vae:
            mu, logv = o[:, :2], o[:, 2:]
            eps = rng.normal(size=mu.shape)
            z = mu + np.exp(0.5 * logv) * eps          # z = μ + σ × ε
        else:
            z = o
        h2 = np.tanh(z @ ps[4] + ps[5])
        y = 1 / (1 + np.exp(-(h2 @ ps[6] + ps[7])))
        # 誤差逆伝播（復元誤差：交差エントロピー）
        gy = (y - x) / len(x)
        g6, g7 = h2.T @ gy, gy.sum(0)
        gh2 = (gy @ ps[6].T) * (1 - h2 ** 2)
        g4, g5 = z.T @ gh2, gh2.sum(0)
        gz = gh2 @ ps[4].T
        if vae:   # KL ＝ ½ Σ (μ² + σ² − log σ² − 1) の勾配も足す
            gmu = gz + BETA * mu / len(x)
            glogv = gz * 0.5 * np.exp(0.5 * logv) * eps + BETA * 0.5 * (np.exp(logv) - 1) / len(x)
            go = np.hstack([gmu, glogv])
        else:
            go = gz
        g2, g3 = h1.T @ go, go.sum(0)
        gh1 = (go @ ps[2].T) * (1 - h1 ** 2)
        g0, g1 = x.T @ gh1, gh1.sum(0)
        for i, g in enumerate([g0, g1, g2, g3, g4, g5, g6, g7]):   # Adam
            m[i] = 0.9 * m[i] + 0.1 * g
            v[i] = 0.999 * v[i] + 0.001 * g * g
            ps[i] -= 0.01 * (m[i] / (1 - 0.9 ** t)) / (np.sqrt(v[i] / (1 - 0.999 ** t)) + 1e-8)
    codes = (np.tanh(X @ ps[0] + ps[1]) @ ps[2] + ps[3])[:, :2]
    return ps, codes

def decode(ps, z):
    return 1 / (1 + np.exp(-(np.tanh(np.asarray(z) @ ps[4] + ps[5]) @ ps[6] + ps[7])))

def show(imgs, titles):
    print("   ".join(f"{t:^12s}" for t in titles))
    for r in range(SIZE):
        print("   ".join("".join(" .:*#"[min(4, int(v * 5))] for v in img[r * SIZE:(r + 1) * SIZE]) for img in imgs))

print("元の顔（このサイトが作った絵）")
show([face(-1, 0.2), face(0, 0.5), face(1, 0.9)], ["への字・小", "まっすぐ", "笑う・大"])
for vae in (False, True):
    ps, codes = train(vae)
    name = "VAE" if vae else "オートエンコーダー"
    print(f"\n{name}：400 枚の顔を縮めた 2 つの数 z の散らばり")
    print(f"  z₁ の範囲 {codes[:, 0].min():6.2f} 〜 {codes[:, 0].max():6.2f}　z₂ の範囲 {codes[:, 1].min():6.2f} 〜 {codes[:, 1].max():6.2f}")
    zs = rng.normal(size=(4, 2))
    print(f"{name}：平均 0・ばらつき 1 の正規分布から z をランダムに 4 つ選んで作った顔")
    show([decode(ps, z) for z in zs], [f"({z[0]:.1f},{z[1]:.1f})" for z in zs])

082014・生成方法（2）

造假钞的人与警察

造出以假乱真的东西的能力，是不是让它和识破它的对手竞争就能长进？

2014年6月，蒙特利尔大学Goodfellow等人的 GAN（生成对抗网络），让生成数据的网络G，和判断数据是真是假的网络D互相竞争。论文把G比作（译），把D比作（译）。最终的归宿，是D再也分辨不出来的状态。

右边是一条数轴上的GAN（本站做的小例子）。打开图时，紫色的假数据之山就会向蓝色的真数据之山靠拢，D线接近0.5。根据G和D的学习速度组合，会挤成一堆，或者来回振荡。竞争并不总是能漂亮地收敛。

D要让log D(x)＋log(1 − D(G(z)))变大，G要让log(1 − D(G(z)))变小

x: 真数据
z: 随机数
G(z): 生成的假数据
D(·): 判定为真的概率

假数据的平均（紫）和离散程度（绿）。虚线是真数据的值

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u10_gan_1d.py

# u10 にせ札づくりと警察：1本の数直線上のGAN
#
# どの出来事か：2014年6月、モントリオール大学のグッドフェローたちがGAN（敵対的生成ネットワーク。記録 goodfellow_gan_2014）を発表した。
#   データを生成するニューラルネットワーク G と、本物か偽物かを識別するニューラルネットワーク D を同時に学習させる。論文は G を「にせ札を作るチーム」、
#   D を「警察」にたとえた（どちらも訳）。
# 仕組み：本物のデータは、平均 REAL_MEAN・標準偏差 REAL_SD の乱数（このサイトが設定した）。
#   G：乱数 z を x ＝ a·z ＋ b に変換する（a と b を学習する）。初めは平均 0・標準偏差 1。
#   D：D(x) ＝ σ(w0 ＋ w1·u ＋ w2·u²)（u ＝ x/4。σ は 0〜1 に変換するシグモイド関数）。本物らしいほど 1 に近づく。
#   交互に、D は log D(本物) ＋ log(1 − D(にせもの)) を大きくし、G は log D(にせもの) を大きくする方向に更新する。
#   D の重みは、1ステップごとに少し 0 に戻す（DECAY。このサイトのモデルが、振動を抑えるために加えた工夫）。
# 試してみよう：
#   - RATE_G を 0.6 にすると、偽物の分布はどうなるか（途中で1か所に固まりかける）
#   - DECAY を 0 にすると、分布が固まったり広がったりを繰り返す。安定するか、振動し続けるか
#   - REAL_MEAN を −3 にしても、G は追いかけられるか

import math
import random

REAL_MEAN, REAL_SD = 4.0, 0.5
RATE_D, RATE_G = 1.0, 0.2
DECAY = 0.01
STEPS = 2000
BATCH = 32
random.seed(2014)
a, b = 1.0, 0.0            # G の2つのパラメータ
w = [0.0, 0.0, 0.0]        # D の3つの重み

def sig(t):
    return 1 / (1 + math.exp(-max(-40, min(40, t))))

def D(x):
    u = x / 4
    return sig(w[0] + w[1] * u + w[2] * u * u)

def hist(xs, lo=-3, hi=7, n=20):
    c = [0] * n
    for x in xs:
        k = int((x - lo) / (hi - lo) * n)
        if 0 <= k < n:
            c[k] += 1
    return "".join(" .:-=+*#%@"[min(9, v * 9 // max(1, max(c)))] for v in c)

print(f"数直線 −3 〜 7 上の分布（本物は平均 {REAL_MEAN}・標準偏差 {REAL_SD}）")
print("学習回数    偽物：平均      標準偏差   本物                   偽物")
real_line = hist([random.gauss(REAL_MEAN, REAL_SD) for _ in range(2000)])
for step in range(STEPS + 1):
    if step % 200 == 0:
        fake = [a * random.gauss(0, 1) + b for _ in range(2000)]
        print(f"{step:6d}       {b:6.2f}    {abs(a):6.2f}   [{real_line}] [{hist(fake)}]")
    # 警察（D）を1ステップ学習させる
    g = [0.0, 0.0, 0.0]
    for _ in range(BATCH):
        x = random.gauss(REAL_MEAN, REAL_SD)
        d, u = D(x), x / 4
        for i, f in enumerate((1, u, u * u)):
            g[i] += (1 - d) * f           # 本物を「本物」と識別できるように
        x = a * random.gauss(0, 1) + b
        d, u = D(x), x / 4
        for i, f in enumerate((1, u, u * u)):
            g[i] -= d * f                 # 偽物を「にせもの」と識別できるように
    for i in range(3):
        w[i] += RATE_D * g[i] / BATCH - DECAY * w[i]
    # にせ札チーム（G）を1ステップ学習させる：D に「本物」と判定される方向へ、作り方を動かす
    ga = gb = 0.0
    for _ in range(BATCH):
        z = random.gauss(0, 1)
        x = a * z + b
        d, u = D(x), x / 4
        gx = (1 - d) * (w[1] + 2 * w[2] * u) / 4
        ga += gx * z
        gb += gx
    a += RATE_G * ga / BATCH
    b += RATE_G * gb / BATCH
print("\n偽物の分布が本物の分布に重なると、D はどちらも0.5前後としか判定できなくなる：")
print("  D(本物の平均) =", round(D(REAL_MEAN), 2), "  D(0) =", round(D(0), 2))

092014〜2016・神经网络翻译

细管，还是注意力

翻译长句子时，网络该记住原文的哪些部分？

2014年，把整句话直接交给神经网络翻译的研究接连出现。6月Cho等人和9月Sutskever等人的 seq2seq，把句子归纳成一组长度固定的数，再由这组数生成译文。Cho等人还提出了简化LSTM的部件（后来的 GRU）。在右边的“细管（seq2seq・GRU）”里，可以看到句子越长，前面的单词越淡。

同年9月，Bahdanau等人在每输出一个译词时，都会决定对原文各个单词的关注程度（合计为1的权重）。这就是注意力的开端。点“注意力（2014）”，再点译词的标签试试。2016年，Google翻译换成了读取整句话的神经网络方式。

α_ij ＝exp(e_ij) ÷ Σ_k exp(e_ik)　　c_i ＝Σ_j α_ij h_j

e_ij: 输出第i个译词时，原文第j个单词的分数
h_j: 原文单词特征的汇总
c_i: 关注后收集到的内容

常见说法常见说法：注意力机制是2017年Transformer的论文提出的
原始资料里：2014年的这篇论文里就已经有了，2017年的论文也引用了它。2017年的论文认为自己新的地方，是不用RNN、只靠注意力来搭建网络。

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u10_attention_align.py

# u10 文を 1 本の管に通すか、訳語ごとに元の文を見るか（seq2seq・GRU・注意）
#
# どの出来事か：2014 年 6 月、チョたちの RNN エンコーダー・デコーダーと、のちに GRU と呼ばれるユニット（記録 gru_rnn_encoder_decoder_2014）。
#   2014 年 9 月、スツケヴァーたちの seq2seq（seq2seq_sutskever_2014）。入力文を逆順にするとスコアが上がった。
#   2014 年 9 月、バーダナウたちの、訳語ごとに原文のどこに注目するかを決める手法（attention_bahdanau_2014。注意の始まり）。
# 仕組み：
#   1) 細い管：文を 1 語ずつ読み、決まった長さのベクトル h に混ぜていく。2014 年の論文の式 (7)
#      h ← z·h ＋ (1 − z)·h̃（z は更新ゲート＝前の状態を持ち越す割合、h̃ は新しい単語から作った状態）で、
#      最後の h に、何番目の単語がどれだけ残るかを計算する。（実際の GRU では z も単語ごとにニューラルネットワークが決める。ここでは固定）
#   2) 注意：訳語を 1 つ出力するたびに、原文の単語ごとにスコア e をつけ、合計 1 の重み α に変換して、原文の単語のベクトルを足し合わせる。
#      スコアのつけ方は、2014 年の論文の形（加法注意）e ＝ v・tanh(W s ＋ U h) を、手で決めた小さな数値で動かす。
#      数値は、このサイトが決めたもの（実際には、たくさんの対訳の文から学習する）。
# 試してみよう：
#   - Z（更新ゲート）を 0.9 や 0.4 にすると、文頭の単語はどれだけ残るか
#   - REVERSE を True にすると、どの単語が最も残るか
#   - WANT の並びを変えて、訳語の順番を入れ替えてみる

import math

# ---- 1) 細い管 ----
Z = 0.7          # 更新ゲート（前の状態を持ち越す割合）
REVERSE = False
for n in (5, 10, 20, 40):
    order = list(range(n))[::-1] if REVERSE else list(range(n))
    share = [0.0] * n
    for step, j in enumerate(order):             # 読んだ順に j 番目の単語を加える
        share = [s * Z for s in share]           # 前の状態は Z 倍だけ持ち越す
        share[j] += 1 - Z                        # 新しい単語が (1 − Z) 入る
    print(f"{n:2d} 語の文：1 語目の残り {share[0]:.4f}　最後の語の残り {share[-1]:.4f}　" +
          "".join(" .:-=+*#%@"[min(9, int(s / max(share) * 9.99))] for s in share[:40]))
print("（左から 1 語目・2 語目…。濃いほど、最後のベクトルに多く残っている）\n")

# ---- 2) 注意 ----
SRC = ["the", "European", "Economic", "Area"]       # 原文（英語）
DST = ["la", "zone", "économique", "européenne"]     # 訳文（フランス語）。語順が逆になる箇所がある
MEANING = {"the": 0, "European": 1, "Economic": 2, "Area": 3}
WANT = ["the", "Area", "Economic", "European"]       # 訳語を出力する際に、注目したい意味（手動で設定）

def onehot(k, n=4):
    return [1.0 if i == k else 0.0 for i in range(n)]

h = [onehot(MEANING[w]) for w in SRC]               # 原文の単語ごとのベクトル（ここでは意味の番号のみ）
v = [4.0] * 4                                       # 加法注意の重み v（手動で設定）
for i, word in enumerate(DST):
    s = onehot(MEANING[WANT[i]])                    # デコーダーの状態（いま探しているもの）
    e = [sum(vk * math.tanh(1.5 * sk + 1.5 * hk - 2.0) for vk, sk, hk in zip(v, s, hj)) for hj in h]
    m = max(e)
    ex = [math.exp(x - m) for x in e]
    alpha = [x / sum(ex) for x in ex]               # 合計 1 の重み
    c = [sum(a * hj[k] for a, hj in zip(alpha, h)) for k in range(4)]   # 注目して集めた中身
    print(f"{word:12s} → " + "  ".join(f"{w}:{a:.2f}" for w, a in zip(SRC, alpha)) +
          f"　最も注目した単語：{SRC[alpha.index(max(alpha))]}")
print("\nzone（地域）を出力する時は Area に、européenne を出力する時は European に注目する。語順が逆でも、参照する単語を選べる。")

102014・训练方法

怎样走下细长的山谷

沿着误差变小的方向前进时，一步的幅度该怎么定？

训练网络的基本方法是梯度下降：在误差构成的地形上，顺着下坡的方向（梯度）一点一点往前走。地形如果是细长的山谷，陡的方向会走过头，缓的方向又半天走不动（右边的深蓝色小球）。

2014年12月，Kingma和Ba的 Adam，对每个权重，都分别记录梯度的移动平均，以及梯度平方的移动平均，用它们的比值来定步幅。梯度一直很大的方向走得谨慎些，梯度小的方向走得大胆些，所以紫色的小球会稍稍走过头，逐步走向谷底。开头一段时间，移动平均会偏向0；纠正这个偏差的计算（偏差修正），可以取消勾选“偏差修正”来比较。

m ← β₁m＋ (1−β₁)g　　v ← β₂v＋ (1−β₂)g²　　w ← w − η · m̂ ÷ (√v̂ ＋ε)

g: 梯度
m, v: 梯度的移动平均，以及梯度平方的移动平均
m̂, v̂: 修正后的值
η: 学习率（前进的幅度）

常见说法常见说法：Adam是被证明一定会收敛的方法
原始资料里：2018年，谷歌Reddi等人的论文给出了即使是简单的问题，Adam也到不了最优解的例子，并指出了原来的证明哪里有问题。

每一步的误差（深蓝＝梯度下降，紫＝Adam。纵轴每格是10倍）

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u10_adam_valley.py

# u10 細長い谷を下りる：勾配降下法と Adam
#
# どの出来事か：2014 年 12 月、キングマとバーが Adam を発表（記録 adam_optimizer_2014）。
#   重みごとに勾配の移動平均 m と、勾配の 2 乗の移動平均 v を記録する。
#   m を √v で割った幅だけ動かす。初めのうち m と v が 0 に偏るのを直す計算（バイアス補正）もある。
# 仕組み：このサイトが決めた細長い谷 f(x, y) ＝ ½(x² ＋ 100y²) を、同じ出発点から下りる。
#   勾配降下法は、急な y 方向で行ったり来たりして、緩やかな x 方向にはなかなか進まない。
#   Adam は、方向ごとに歩幅を調整するため、谷の底へまっすぐ近づく。
# 試してみよう：
#   - GD_RATE を 0.021 にすると、勾配降下法はどうなるか（100 × 0.02 ＝ 2 が境目）
#   - BIAS_CORRECTION を False にすると、Adam の初めの数歩はどう変わるか
#   - STEEP を 1 にすると（丸い谷。GD_RATE は 0.5 に）、2 つの差はどうなるか

import math

STEEP = 100.0
GD_RATE = 0.019
ADAM_RATE = 0.2
BETA1, BETA2, EPS = 0.9, 0.999, 1e-8
BIAS_CORRECTION = True
START = (-4.0, 1.5)
STEPS = 80

def f(x, y):
    return 0.5 * (x * x + STEEP * y * y)

def grad(x, y):
    return x, STEEP * y

def gd():
    x, y = START
    path = [(x, y)]
    for _ in range(STEPS):
        gx, gy = grad(x, y)
        x, y = x - GD_RATE * gx, y - GD_RATE * gy
        path.append((x, y))
    return path

def adam(correct=True):
    x, y = START
    m = [0.0, 0.0]
    v = [0.0, 0.0]
    path = [(x, y)]
    for t in range(1, STEPS + 1):
        g = grad(x, y)
        p = [x, y]
        for i in range(2):
            m[i] = BETA1 * m[i] + (1 - BETA1) * g[i]
            v[i] = BETA2 * v[i] + (1 - BETA2) * g[i] ** 2
            mh = m[i] / (1 - BETA1 ** t) if correct else m[i]
            vh = v[i] / (1 - BETA2 ** t) if correct else v[i]
            p[i] -= ADAM_RATE * mh / (math.sqrt(vh) + EPS)
        x, y = p
        path.append((x, y))
    return path

runs = {"勾配降下法": gd(), "Adam": adam(BIAS_CORRECTION), "Adam（補正なし）": adam(False)}
print("歩数   " + "   ".join(f"{k:>16s}" for k in runs))
for t in (0, 1, 2, 3, 5, 10, 20, 40, 80):
    print(f"{t:4d}   " + "   ".join(f"{f(*p[t]):16.4f}" for p in runs.values()))

print("\n勾配降下法の初めの 8 歩（y が + と − を行ったり来たり＝ジグザグ）")
for t, (x, y) in enumerate(runs["勾配降下法"][:8]):
    print(f"  {t}: x = {x:6.2f}  y = {y:6.2f}")
print("Adam の初めの 8 歩")
for t, (x, y) in enumerate(runs["Adam"][:8]):
    print(f"  {t}: x = {x:6.2f}  y = {y:6.2f}")

112015・捷径

跳过层的捷径

把层数叠得更深，网络就会更聪明吗？

微软研究院的何恺明等人表明，光是把层叠起来，56层的网络连训练数据上的错误率都比20层的高。于是，他们在每一组层的输出上，反复加入一条原样加上进入这组层之前的值的捷径（ResNet）。网络可以深到152层，在2015年的图像大赛中拿到第1名（错误率3.57%）。

同在2015年，弗莱堡大学Ronneberger等人的 U-Net，是一种压缩后把握整体、再展开还原的U字形结构，并使用了把压缩之前的细节特征复制过来接上的捷径。它是为显微镜图像的区域分割而做的。在右边的图里切换这两种捷径看看吧。

ResNet：输出＝F(x)＋x　　U-Net：展开阶段的输入＝［从下面展开上来的部分, 同样大小那一阶段的副本］

x: 进入这组层的值
F(x): 这组层所学习的剩余部分（残差）

常见说法常见说法：跳过层的连接是ResNet首创的
原始资料里：论文本身就写道，捷径已被研究了很久，并举出了同一时期的highway networks（2015年5月，带门的捷径，数百层）。ResNet的不同之处，是没有门、把值原样传递的捷径。

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u10_resnet_shortcut.py

# u10 層を飛び越す近道：通常のネットワークと ResNet で、逆伝播する信号を比べる
#
# どの出来事か：2015年12月、マイクロソフト・リサーチのヒーたちが発表した ResNet（記録 resnet_2015）。
#   いくつかの層の出力に、入力の値をそのまま足す近道（出力 ＝ F(x) ＋ x）を繰り返し配置し、
#   152 層まで深くした。単純に重ねたネットワークでは、20 層より 56 層の方が、訓練データでの誤り率まで高くなった。
#   なぜ近道があると学習させやすいのかは、論文では仮説として書かれている。ここで見るのは、仕組みの 1 つの見方。
# 仕組み：幅 WIDTH の層を DEPTH 段重ねたネットワークを、ランダムな重みで作り（学習はさせない）、出口の信号を
#   入口まで逆伝播させて、各層に届く大きさを測る。
#   ・通常のネットワーク：x ← ReLU(W x)。重みの初期値はヒーたちの手法（分散 2/n）。
#   ・近道つき：x ← x ＋ W₂ ReLU(W₁ x)。枝の W₂ は小さめ（分散を 1/DEPTH 倍）に設定した（このサイトの設定）。
#   ネットワークも信号も、このサイトがランダムに作った例。幅が狭いほど、通常のネットワークの信号はばらつきやすい。
# 試してみよう：
#   - DEPTH を 20・56・152 と変えてみる
#   - WIDTH を 64 にすると、通常のネットワークの減り方はどう変わるか（少し時間がかかる）

import math
import random

WIDTH = 16
DEPTH = 56
SAMPLES = 4

def matrix(rnd, sd):
    return [[rnd.gauss(0, sd) for _ in range(WIDTH)] for _ in range(WIDTH)]

def mv(W, x):
    return [sum(W[j][i] * x[i] for i in range(WIDTH)) for j in range(WIDTH)]

def mtv(W, g):
    return [sum(W[j][i] * g[j] for j in range(WIDTH)) for i in range(WIDTH)]

def signal(depth, shortcut, seed):
    rnd = random.Random(seed)
    he = math.sqrt(2 / WIDTH)
    layers = [(matrix(rnd, he), matrix(rnd, he / math.sqrt(depth)) if shortcut else None) for _ in range(depth)]
    reach = [0.0] * depth
    for _ in range(SAMPLES):
        x = [rnd.gauss(0, 1) for _ in range(WIDTH)]
        cache = []
        for W1, W2 in layers:                    # 順伝播
            z = mv(W1, x)
            a = [max(0.0, v) for v in z]
            cache.append(z)
            x = [xi + v for xi, v in zip(x, mv(W2, a))] if shortcut else a
        g = [rnd.gauss(0, 1) for _ in range(WIDTH)]
        top = math.sqrt(sum(v * v for v in g))
        for l in range(depth - 1, -1, -1):       # 逆伝播
            W1, W2 = layers[l]
            z = cache[l]
            if shortcut:                          # 近道を通る分（g そのもの）＋ 枝を通った分
                ga = mtv(W2, g)
                gz = [gi if zi > 0 else 0.0 for gi, zi in zip(ga, z)]
                g = [gi + v for gi, v in zip(g, mtv(W1, gz))]
            else:
                gz = [gi if zi > 0 else 0.0 for gi, zi in zip(g, z)]
                g = mtv(W1, gz)
            reach[l] += math.sqrt(sum(v * v for v in g)) / top / SAMPLES
    return reach

def bar(v):
    n = int(round((math.log10(v) + 6) * 4)) if v > 0 else 0
    return "■" * max(0, min(36, n))

for shortcut in (False, True):
    r = signal(DEPTH, shortcut, 2015)
    print(f"{'近道つき（ResNet の構造）' if shortcut else '通常のネットワーク'}：{DEPTH} 層（棒は 10 倍ずつの目盛り。出口を 1 とする）")
    for l in list(range(0, DEPTH, max(1, DEPTH // 8))) + [DEPTH - 1]:
        print(f"  {l + 1:3d} 層目に届いた信号 {r[l]:9.2g}  {bar(r[l])}")

print("\n深さごとに、入口の層に届いた信号（ランダムなネットワーク 5 つの中央値）")
for depth in (20, 56, 152):
    row = []
    for shortcut in (False, True):
        vals = sorted(signal(depth, shortcut, s)[0] for s in range(5))
        row.append(f"{vals[2]:9.2g}")
    print(f"  {depth:3d} 層：通常 {row[0]}　近道つき {row[1]}")

122014〜2016・人类的基准线

被超过的人类是谁

说AI超过了人类，被拿来比较的人类是谁？

图像识别大赛（1000个类别，可以给出5个答案）第1名的错误率，从2010年的28.2%降到了2017年的2.3%（右图，官方数字）。2015年2月，微软研究院的何恺明等人做到了4.94%，并写道（译）。

那个5.1%，是大赛主办方测量的2个人中其中1个人的数字（练习了500张，识别1500张）。另一个只练习了100张的人，在258张上的错误率是12.0%。切换右边的“人类基准线”，被超过的年份就会移动。

2016年的对话语音识别中，人类的错误率也因测量方法不同，有4%、5.9%、5.1%的差别。2014年宣布（译）的那个活动，所用的30%这条线，也是主办方自己定的。

常见说法常见说法：2015年，图像识别AI超过了人类
原始资料里：拿来比较的人类的5.1%只是1个人的数字，另一个人是12.0%。写下的论文本身也写道：（译）。

132015・图像生成

画画的两种方法

用训练好的网络画画，该怎么做？

2015年8月，图宾根大学等的Gatys等人的画风转换，不改变训练好的网络，而是修改图像的像素。它把深层的反应当作内容，把“各个特征是否一起强烈出现”的表（格拉姆矩阵）当作画风，让两者的差异都变小。右边的“画风转换”是只有小滤波器的最小形式（本站做的例子）。

同年3月，斯坦福大学Sohl-Dickstein等人的扩散方法，是反复往数据里加噪声把它破坏掉，再让网络学习反方向的1步。从噪声出发，反复做反方向的步骤，就能得到新的数据。点“扩散”，把漩涡破坏再还原看看。

画风转换：差异＝α ×（内容的差异）＋β ×（格拉姆矩阵的差异）　　扩散的1步：x ← √(1−β_t)·x＋ √β_t·ε

α, β: 两种差异的权重
β_t: 第t步的噪声量
ε: 平均0、方差1的随机数

常见说法常见说法：扩散方法是2022年前后（或2020年的DDPM）诞生的新方法
原始资料里：想法在2015年的论文里就有了，论文写道自己是从物理学的想法中（译）。2020年的DDPM论文写道，此前（译），并证明了这一点。

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u10_diffusion_roll.py

# u10 ノイズを加えて崩し、逆向きにたどって復元する（拡散モデルを 2 次元の点で）
#
# どの出来事か：2015 年 3 月、スタンフォード大学のソール＝ディックスタインたちの拡散モデル（記録 diffusion_model_2015）。
#   データに小さなノイズを繰り返し加え、完全なノイズへと崩す。ニューラルネットワークは、その 1 歩ずつの逆向きの復元を学習する。
#   2015 年の論文では、2 次元の渦巻き（スイスロール）でも実験した。
# 仕組み：このサイトが作った例では、渦巻きの点 N 個に、1 歩ずつ x ← √(1−β)·x ＋ √β·ε のノイズを加える（STEPS 歩）。
#   本来はニューラルネットワークが逆向きの 1 歩を学習する。ここではネットワークの代わりに、「いまの点は、元のどの点から来たらしいか」を
#   元の点の集合から直接計算し（重み付き平均）、少しずつ復元する（学習を行わない近道。生成した点は元の点の近くに集まる）。
#   同じ 2015 年 8 月の画風変換（neural_style_transfer_2015）は、見開きの模型で動かせる。
# 試してみよう：
#   - STEPS を 10 にすると、復元した点の形はどうなるか（1 歩の変化が大きすぎる）
#   - NOISE_END を小さくすると、崩しきれずに元の形が残るか

import math
import random

N = 80
STEPS = 60
NOISE_START, NOISE_END = 0.002, 0.15
random.seed(2015)

def swiss_roll(n):
    pts = []
    for _ in range(n):
        t = 1.5 * math.pi * (1 + 2 * random.random())
        pts.append((t * math.cos(t) / 10, t * math.sin(t) / 10))
    return pts

def picture(pts, w=36, h=15, lo=-1.6, hi=1.6):
    grid = [[" "] * w for _ in range(h)]
    for x, y in pts:
        c, r = int((x - lo) / (hi - lo) * w), int((hi - y) / (hi - lo) * h)
        if 0 <= c < w and 0 <= r < h:
            grid[r][c] = "*"
    return ["".join(row) for row in grid]

data = swiss_roll(N)
betas = [NOISE_START + (NOISE_END - NOISE_START) * t / (STEPS - 1) for t in range(STEPS)]
abar = []
p = 1.0
for b in betas:
    p *= 1 - b
    abar.append(p)

# 前向き：ノイズを加えて崩す
x = [list(pt) for pt in data]
for b in betas:
    x = [[v * math.sqrt(1 - b) + math.sqrt(b) * random.gauss(0, 1) for v in pt] for pt in x]
noised = [tuple(pt) for pt in x]

def guess_x0(pt, t):
    """現在の点が元のどの点から来たらしいかの重み付き平均（ニューラルネットワークの代わり）"""
    s, v = math.sqrt(abar[t]), 1 - abar[t]
    ws = [-((pt[0] - s * d[0]) ** 2 + (pt[1] - s * d[1]) ** 2) / (2 * v) for d in data]
    m = max(ws)
    ws = [math.exp(w - m) for w in ws]
    tot = sum(ws)
    return [sum(w * d[k] for w, d in zip(ws, data)) / tot for k in range(2)]

# 逆向き：完全なノイズから、1 歩ずつ復元する
x = [[random.gauss(0, 1), random.gauss(0, 1)] for _ in range(N)]
for t in range(STEPS - 1, -1, -1):
    b = betas[t]
    ab_prev = abar[t - 1] if t > 0 else 1.0
    new = []
    for pt in x:
        x0 = guess_x0(pt, t)
        # q(x_{t−1} | x_t, x0) の平均（DDPM の式）
        c0 = math.sqrt(ab_prev) * b / (1 - abar[t])
        ct = math.sqrt(1 - b) * (1 - ab_prev) / (1 - abar[t])
        mean = [c0 * x0[k] + ct * pt[k] for k in range(2)]
        sd = math.sqrt(b * (1 - ab_prev) / (1 - abar[t])) if t > 0 else 0.0
        new.append([m + sd * random.gauss(0, 1) for m in mean])
    x = new

left, mid, right = picture(data), picture(noised), picture([tuple(p) for p in x])
def pad(s, cols=38):   # 全角文字を 2 文字分として幅をそろえる
    return s + " " * max(1, cols - sum(2 if ord(ch) > 0x2000 else 1 for ch in s))

print(pad("元の渦巻き") + pad(f"{STEPS} 歩ノイズを加えた") + "ノイズから復元した")
for a, b, c in zip(left, mid, right):
    print(a + "  " + b + "  " + c)
print(f"\n{STEPS} 歩のあと、元の形が残っている割合（√ᾱ）：{math.sqrt(abar[-1]):.3f}")

142014〜2015・日本

边运行边搭建

不先把网络的形状全部定下来，就没法训练吗？

2014年3月，西川徹和冈野原大辅创办了Preferred Networks（PFN）。2015年6月，PFN把可以用Python来编写并训练神经网络的工具 Chainer 公开，任何人都能使用。

此前的许多工具（Caffe等），都是先把计算的路线全部定好，再让数据流过去（Chainer的论文称之为Define-and-Run）。Chainer则是在计算的那一刻记录路线，再倒着走回去求出梯度（Define-by-Run）。处理长度不一的句子的网络，也可以用普通的for语句和if语句来写。在右边点“前进1行”试试。

2019年PyTorch的论文认为，开创这种写法的是Chainer和DyNet。PFN在2019年12月，把研发的基础转到了PyTorch上。

常见说法常见说法：边运行边搭建的写法（Define-by-Run）是美国的PyTorch开创的
原始资料里：PyTorch 2019年的论文本身就写道，开创这种设计的是Chainer和DyNet。不过，同一篇论文也写道，Chainer的做法牺牲了速度。

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u10_tiny_autograd.py

# u10 動かしながら、計算の道すじを記録する（Define-by-Run の小さな自動微分）
#
# どの出来事か：2015 年 6 月、日本の Preferred Networks が公開した Chainer（記録 chainer_define_by_run_2015、
#   会社は preferred_networks_2014）。それまでの多くのツールは、先にニューラルネットワークの形（計算グラフ）を
#   全部決めてからデータを流した（Chainer の論文はこれを Define-and-Run と名づけた）。Chainer は、データを流して
#   計算するその時にグラフを記録し、それを逆にたどって勾配を計算した（Define-by-Run）。
# 仕組み：数値を 1 つ包む Value を作る。加算・乗算・tanh を計算するたびに、「どの数から作られたか」を記録する。
#   最後の出力から計算グラフを逆にたどれば、どの重みをどちらへ動かせばよいか（勾配）が分かる。
#   通常の Python の for 文で長さの異なる系列（数値の並び）を処理すると、その長さの分だけ計算グラフが伸びる。
# 試してみよう：
#   - SENTENCES に、もっと長い並びを足すと、記録される計算の数はどう増えるか
#   - if 文で「負の数は読みとばす」ようにしても、そのまま勾配が計算できるか

import math

class Value:
    count = 0                       # 記録した計算の数

def __init__(self, v, parents=(), grads=()):
        self.v, self.parents, self.local, self.g = v, parents, grads, 0.0
        Value.count += 1

def __add__(self, o):
        o = o if isinstance(o, Value) else Value(o)
        return Value(self.v + o.v, (self, o), (1.0, 1.0))

def __mul__(self, o):
        o = o if isinstance(o, Value) else Value(o)
        return Value(self.v * o.v, (self, o), (o.v, self.v))

def tanh(self):
        t = math.tanh(self.v)
        return Value(t, (self,), (1 - t * t,))

def backward(self):
        order, seen = [], set()

def visit(n):               # 記録した計算グラフを、後ろから順に並べる
            if id(n) not in seen:
                seen.add(id(n))
                for p in n.parents:
                    visit(p)
                order.append(n)
        visit(self)
        self.g = 1.0
        for n in reversed(order):   # 計算グラフを逆にたどって、勾配を配る
            for p, lg in zip(n.parents, n.local):
                p.g += lg * n.g

w, u = Value(0.5), Value(0.8)       # 学習させる 2 つの重み
SENTENCES = [[1.0, -0.5], [0.3, 0.9, -1.2, 0.4], [0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5]]
TARGET = 0.5
for xs in SENTENCES:
    Value.count = 0
    w.g = u.g = 0.0
    h = Value(0.0)
    for x in xs:                    # 通常の for 文。長さは系列ごとに異なる
        h = (w * h + u * x).tanh()
    loss = (h + (-TARGET)) * (h + (-TARGET))
    loss.backward()
    print(f"長さ {len(xs)} の並び：記録した計算 {Value.count:3d} 個　誤差 {loss.v:.4f}　"
          f"w の勾配 {w.g:+.4f}　u の勾配 {u.g:+.4f}")

print("\n学習させてみる（3 つの並びを順に見て、勾配の逆向きに少しずつ動かす）")
for epoch in range(1, 201):
    total = 0.0
    for xs in SENTENCES:
        w.g = u.g = 0.0
        h = Value(0.0)
        for x in xs:
            h = (w * h + u * x).tanh()
        loss = (h + (-TARGET)) * (h + (-TARGET))
        loss.backward()
        w.v -= 0.3 * w.g
        u.v -= 0.3 * u.g
        total += loss.v
    if epoch in (1, 10, 50, 200):
        print(f"  {epoch:3d} 周目：誤差の合計 {total:.4f}　w = {w.v:.3f}　u = {u.v:.3f}")

152006〜2017・围棋

试下，与2个网络

在难以给局面打分的围棋里，是怎样挑选下一手的？

围棋可以落子的地方很多，给局面打分也很困难。2006年，法国Coulom的蒙特卡洛树搜索，是从当前往后随机地一直下到最后，反复下很多次，用胜率来比较各步棋，越有希望的分支就查得越深（决定每步棋试多少次的UCT也是同一年提出的）。右边是在四子棋上运行的例子。点一下列，来对战看看吧。

DeepMind的AlphaGo，在这个基础上加上了挑选着法的网络和评价局面的网络。2015年10月，它以5比0战胜了樊麾二段。论文写道，在不让子的情况下战胜职业棋手，（译）。2016年3月，它以4比1战胜了李世石九段。2017年10月的 AlphaGo Zero 只靠自我对弈来学习，72小时后，对战胜过李世石的那个版本取得了100战100胜。

UCT的分数＝胜率＋C √( ln N ÷ n )

N: 这个局面总共试过的次数
n: 这一手试过的次数
C: 对没怎么试过的着法也去尝试的程度

常见说法常见说法：AlphaGo是只靠自己学习而变强的
原始资料里：2016年战胜李世石的那个版本，也是先以16万局人类的对局为范本学习，再通过自己和自己对战变强的。不使用人类对局，是从2017年10月的AlphaGo Zero才开始的。就连那个Zero，规则以及把棋盘当作19×19图像来处理的结构，也是人给的。

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u10_mcts_connect4.py

# u10 ランダムに最後まで打ってみて、勝率で手を選ぶ（モンテカルロ木探索）
#
# どの出来事か：2006 年、クーロンの論文と、コチシュとセペシュヴァーリの UCT（記録 monte_carlo_tree_search_2006）。
#   局面の評価が難しい囲碁で、先をランダムに最後まで何度も打ってみて、勝率で手を比べ、
#   有望な枝ほど深く調べた。2016 年の AlphaGo は、これにニューラルネットワークを 2 つ組み合わせた。
# このサンプル：囲碁の代わりに「四目並べ（重力つき。縦 6×横 7）」で、同じ探索アルゴリズムを小さく動かす。
# 試してみよう：
#   - 最後の for 文の組 (po_o, po_x)（〇と×の、1 手あたりの試し打ちの回数）を変えると、強さがどう変わるか
#   - C（まだ試していない手も試す度合い）を 0 にすると？

import math
import random

random.seed(2006)
ROWS, COLS = 6, 7
C = 1.4

def new_board():
    return [["."] * COLS for _ in range(ROWS)]

def moves(b):
    return [c for c in range(COLS) if b[0][c] == "."]

def drop(b, c, p):
    """列 c に p の石を落とす（盤を書き換え、置いた行を返す）"""
    for r in range(ROWS - 1, -1, -1):
        if b[r][c] == ".":
            b[r][c] = p
            return r

def won_at(b, r, c, p):
    """いま (r, c) に置いた石で、縦・横・斜めに 4 つ並んだかを判定する"""
    for dr, dc in ((0, 1), (1, 0), (1, 1), (1, -1)):
        n = 1
        for sgn in (1, -1):
            rr, cc = r + sgn * dr, c + sgn * dc
            while 0 <= rr < ROWS and 0 <= cc < COLS and b[rr][cc] == p:
                n += 1
                rr += sgn * dr
                cc += sgn * dc
        if n >= 4:
            return True
    return False

def other(p):
    return "×" if p == "〇" else "〇"

def rollout(b, p):
    """ランダムに最後まで打つ（プレイアウト）。勝者を返す（引き分けは None）"""
    b = [row[:] for row in b]
    while True:
        m = moves(b)
        if not m:
            return None
        c = random.choice(m)
        r = drop(b, c, p)
        if won_at(b, r, c, p):
            return p
        p = other(p)

def mcts(b, p, playouts):
    stats = {c: [0, 0.0] for c in moves(b)}   # 手 → [試した回数, 勝ちの合計]
    for n in range(1, playouts + 1):
        # まだ試していない手を優先。あとは「勝率＋試しの少なさ」が大きい手を選ぶ（UCT）
        def score(c):
            t, w = stats[c]
            return float("inf") if t == 0 else w / t + C * math.sqrt(math.log(n) / t)
        c = max(stats, key=score)
        nb = [row[:] for row in b]
        r = drop(nb, c, p)
        result = p if won_at(nb, r, c, p) else rollout(nb, other(p))
        stats[c][0] += 1
        stats[c][1] += 1.0 if result == p else (0.5 if result is None else 0.0)
    return max(stats, key=lambda c: stats[c][0])   # 最も多く試した手を選ぶ

def game(playouts_o, playouts_x):
    b = new_board()
    p = "〇"
    while moves(b):
        n = playouts_o if p == "〇" else playouts_x
        c = mcts(b, p, n) if n else random.choice(moves(b))
        r = drop(b, c, p)
        if won_at(b, r, c, p):
            return p
        p = other(p)
    return "引き分け"

GAMES = 10
for po_o, po_x in ((5, 0), (50, 0), (200, 50), (50, 200)):
    results = [game(po_o, po_x) for _ in range(GAMES)]
    x_name = "ランダムな×" if po_x == 0 else f"試し打ち {po_x} 回の×"
    print(f"試し打ち {po_o:3d} 回の〇 と {x_name} で {GAMES} 局：〇の勝ち {results.count('〇')}・×の勝ち {results.count('×')}・引き分け {results.count('引き分け')}")

162007〜2017・日本

逆转的十年

职业棋手和软件的实力，是什么时候逆转的？

在将棋方面，2005年，化学研究者保木邦仁公开了Bonanza。它让机器学习评价函数（给局面好坏打分的式子）的权重，使其走出与职业棋谱相同的着法。2007年3月渡边明龙王战胜Bonanza之后不久，研究者松原仁写道，在对顶尖职业棋手的比赛中取得胜多负少的成绩，（译）。

右边的方块，每一个代表一局公开对局。2015年10月，信息处理学会宣布（译），并结束了将棋项目。2017年，PONANZA对名人佐藤天彦取得2连胜。切换到“围棋（电圣战）”时，可以看到在日本的电圣战中，软件所获让子的数目从5子减到了0子。

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u10_eval_learning.py

# u10 プロと同じ手を選ぶように評価関数の重みを学習する（Bonanza の手法の簡略版）と、プロとソフトの 10 年
#
# どの出来事か：2005 年に公開された将棋ソフト Bonanza（記録 bonanza_2006_watanabe_2007）。プロの棋譜と同じ手を
#   指すように、局面の良し悪しを点数にする式（評価関数）の重みを機械に学習させた。
#   将棋のプロ棋士とソフトの公開対局の結果（shogi_pro_vs_software_record_2017）。
# 仕組み：
#   1) このサイトが作った例：300 の局面を用意する。各局面に指せる手が 5 つあり、指した後の局面を 4 つの
#      特徴量（駒の得・王の守り・駒の働き・攻めの速さ）で表す。「プロ」は、このサイトが隠して決めた重みで局面を評価し、
#      最も評価値の高い手を選ぶ（少しだけ迷いも入れた）。
#      評価関数の重み w の初期値を 0 とし、w で選んだ手がプロの手と異なる時だけ、
#      w ← w ＋ η ×（プロの手の特徴 − w が選んだ手の特徴）と更新する。
#   2) 実際の結果：2007〜2017 年の公開対局の勝敗（記録の数）。
# 試してみよう：
#   - NOISE（プロの評価のばらつき）を大きくすると、一致率はどこまで上がるか
#   - FEATURES を 2 つだけにすると（王の守りを評価しない場合）、どうなるか

import random

FEATURES = ["駒の得", "王の守り", "駒の働き", "攻めの速さ"]
HIDDEN_W = [1.0, 0.6, 0.4, 0.8]          # 「プロ」の評価基準（このサイトが決めて隠した重み）
NOISE = 0.3
ETA = 0.1
random.seed(2006)

positions = []
for _ in range(300):
    moves = [[random.gauss(0, 1) for _ in FEATURES] for _ in range(5)]
    scores = [sum(h * f for h, f in zip(HIDDEN_W, m)) + random.gauss(0, NOISE) for m in moves]
    positions.append((moves, scores.index(max(scores))))
train, test = positions[:200], positions[200:]

def choose(w, moves):
    vals = [sum(a * b for a, b in zip(w, m)) for m in moves]
    return vals.index(max(vals))

def agree(w, data):
    return sum(choose(w, m) == pro for m, pro in data) / len(data)

w = [0.0] * len(FEATURES)
print("周   訓練データの一致率   テストデータの一致率 重み（" + "・".join(FEATURES) + "）")
for epoch in range(1, 11):
    for moves, pro in train:
        mine = choose(w, moves)
        if mine != pro:
            w = [wi + ETA * (a - b) for wi, a, b in zip(w, moves[pro], moves[mine])]
    if epoch in (1, 2, 3, 5, 10):
        scale = w[0] if w[0] else 1
        print(f"{epoch:2d}        {agree(w, train):6.1%}            {agree(w, test):6.1%}        " +
              "・".join(f"{x / scale:.2f}" for x in w) + "（駒の得を 1 とした比）")
print("隠した重みの比：" + "・".join(f"{x / HIDDEN_W[0]:.2f}" for x in HIDDEN_W))

print("\n将棋のプロとソフトの公開対局（記録の数。プロの勝ち・ソフトの勝ち・引き分け）")
RECORD = [(2007, "渡辺明竜王 対 Bonanza", 1, 0, 0), (2010, "清水市代女流王将 対 あから2010", 0, 1, 0),
          (2012, "第 1 回電王戦 米長邦雄永世棋聖（引退した棋士）", 0, 1, 0), (2013, "第 2 回電王戦（5 対 5）", 1, 3, 1),
          (2014, "第 3 回電王戦", 1, 4, 0), (2015, "電王戦 FINAL", 3, 2, 0),
          (2016, "2 番勝負（相手のソフトは Ponanza）", 0, 2, 0), (2017, "第 2 期電王戦 佐藤天彦名人 対 PONANZA", 0, 2, 0)]
pro = soft = 0
for y, name, p, s, d in RECORD:
    pro, soft = pro + p, soft + s
    mark = "○" * p + "●" * s + "△" * d
    print(f"  {y}  {mark}{'・' * (5 - len(mark))}  {name}")
print(f"  合計：プロ {pro} 勝・ソフト {soft} 勝（○＝プロの勝ち、●＝ソフトの勝ち、△＝引き分け）")

172018・走向科学

由距离地图组装出形状

在游戏中变强的AI方法，也能用在科学问题上吗？

蛋白质是由氨基酸连成的长链折叠起来而决定形状的。在2018年的预测大赛CASP13（约100个研究小组）上，DeepMind的第一代 AlphaFold，用卷积网络预测了每两个氨基酸之间的距离地图。再用梯度下降法调整形状，使它符合由这张地图做出来的评分式，从而把形状组装出来。

右边是把这种组装方式缩到最小的例子（本站做的2维长链和地图）。打开图时，笔直的长链就会折成与地图相符的形状。试着把地图打乱，或者只保留距离较近的那些组合吧。困难类别的总分是68.3，超过了第2名的48.2。不过，得到高精度的，43个里只有11个。

误差＝Σ_i＜j（|p_i − p_j| − d_ij）²　移动p使它变小

p_i: 第i个氨基酸的位置
d_ij: 预测的i与j的距离

常见说法常见说法：AlphaFold在2020年突然出现，并直接拿了诺贝尔化学奖
原始资料里：最初的AlphaFold在2018年的CASP13上就已出场。不过，2020年的AlphaFold2是（译）的，它放弃了卷积而用了注意力。获奖对象是AlphaFold2，在第11章里讲。

组装的步数与地图的误差（纵轴每格是10倍）

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u10_distance_fold.py

# u10 距離の地図から、ひもの形を組み立てる（最初の AlphaFold の組み立て方を小さく再現）
#
# どの出来事か：2018 年の CASP13 に出場した最初の AlphaFold（記録 alphafold1_casp13_2018）。
#   畳み込みニューラルネットワークでアミノ酸ペアの距離の確率の地図を予測し、その地図から
#   点数の式を作り、勾配降下法で形を少しずつ直して組み立てた。2020 年の AlphaFold2 は作り直された別の手法（11 章）。
# 仕組み：このサイトが作った例の 2 次元のひも（点 N 個）の「本当の形」から、各ペアの距離の地図を作り、
#   少しノイズ（NOISE）を足して「予想した地図」とする。直線状のひもから開始し、
#   誤差 ＝ Σ ( |p_i − p_j| − d_ij )² が小さくなる方向へ、各点の位置を少しずつ動かす。
#   完成した形を本当の形と重ね合わせ（回転・反転は自由）、誤差（RMSD）を測る。
# 試してみよう：
#   - NOISE を 0.5 にすると、組み上がる形はどれだけずれるか
#   - NEAR_ONLY を 3 にすると（ひもの上で 3 つ以内のペアの距離しか使わない）、形は決まるか

import math
import random

N = 14
NOISE = 0.1
NEAR_ONLY = None          # None ならすべてのペアの距離を使う
STEPS = 3000
RATE = 0.01
random.seed(2018)

# 本当の形（このサイトが作った例。途中で折り返すひも）
true = []
for i in range(N):
    a = i * 0.55
    true.append((math.cos(a) * (1.8 - 0.1 * i), math.sin(a) * (1.8 - 0.1 * i)))
D = [[math.dist(true[i], true[j]) + (random.gauss(0, NOISE) if i != j else 0) for j in range(N)] for i in range(N)]
pairs = [(i, j) for i in range(N) for j in range(i + 1, N) if NEAR_ONLY is None or j - i <= NEAR_ONLY]

def energy(p):
    return sum((math.dist(p[i], p[j]) - D[i][j]) ** 2 for i, j in pairs)

def rmsd(p, q):
    """p を回転・反転・平行移動して q に重ねたときの、点ごとの誤差の平均（2 乗平均の平方根）"""
    best, placed = 1e9, None
    for flip in (1, -1):
        pp = [(x, flip * y) for x, y in p]
        cx, cy = sum(x for x, _ in pp) / N, sum(y for _, y in pp) / N
        qx, qy = sum(x for x, _ in q) / N, sum(y for _, y in q) / N
        a = [(x - cx, y - cy) for x, y in pp]
        b = [(x - qx, y - qy) for x, y in q]
        th = math.atan2(sum(ax * by - ay * bx for (ax, ay), (bx, by) in zip(a, b)),
                        sum(ax * bx + ay * by for (ax, ay), (bx, by) in zip(a, b)))
        c, s = math.cos(th), math.sin(th)
        r = math.sqrt(sum((c * ax - s * ay - bx) ** 2 + (s * ax + c * ay - by) ** 2 for (ax, ay), (bx, by) in zip(a, b)) / N)
        if r < best:
            best, placed = r, [(c * ax - s * ay + qx, s * ax + c * ay + qy) for ax, ay in a]
    return best, placed

p = [(i * 0.6, random.gauss(0, 0.05)) for i in range(N)]     # 直線状のひもから開始
for t in range(STEPS + 1):
    if t in (0, 10, 50, 200, 1000, STEPS):
        print(f"{t:5d} 歩：地図との誤差 {energy(p):9.3f}　本当の形との誤差（RMSD）{rmsd(p, true)[0]:.3f}")
    g = [[0.0, 0.0] for _ in range(N)]
    for i, j in pairs:
        dx, dy = p[i][0] - p[j][0], p[i][1] - p[j][1]
        r = math.hypot(dx, dy) + 1e-9
        k = 2 * (r - D[i][j]) / r
        g[i][0] += k * dx
        g[i][1] += k * dy
        g[j][0] -= k * dx
        g[j][1] -= k * dy
    p = [(x - RATE * gx, y - RATE * gy) for (x, y), (gx, gy) in zip(p, g)]

def picture(pts, w=30, h=13, lo=-2.2, hi=2.2):
    grid = [["・"] * w for _ in range(h)]
    for k, (x, y) in enumerate(pts):
        c = min(w - 1, max(0, int((x - lo) / (hi - lo) * (w - 1))))
        r = min(h - 1, max(0, int((hi - y) / (hi - lo) * (h - 1))))
        grid[r][c] = "０１２３４５６７８９ＡＢＣＤ"[k] if k < 14 else "＊"
    return ["".join(row) for row in grid]

print("\n本当の形（左）と、地図から組み立てて本当の形に重ねた形（右）。数字はひもの何番目の点か")
for a, b in zip(picture(true), picture(rmsd(p, true)[1])):
    print(a + "　　" + b)

182013〜2015・对工作的预言

47%与49%的内涵

“工作的47%会消失”，在论文的哪里写着？

2013年9月，牛津大学的Frey和Osborne，推算了美国702种职业被计算机取代的可能性。只对有把握的70种职业，手工打上了能自动化（1）或不能自动化（0）的标签。再根据表示感知与手部操作、创造性、与人交往的9个变量，用分类器推测其余的职业。

概率0.7以上算高风险类别，不足0.3算低风险类别，按从业人数来数，低33%、中19%、高47%。在右边的图里移动分界线，标题里的数字就会变化（职业和人数是本站做的例子）。2015年，野村综合研究所与同样这两个人合作研究，发表了（译）。

高风险类别的比例＝（在概率0.7以上的职业中工作的人数）÷（全部从业人数）

概率: 该职业在技术上有可能被自动化的可能性（推算值）

常见说法常见说法：10〜20年内美国47%的工作会消失
原始资料里：论文的表述是（译），意思是这样的职业，有可能在不确定的年数（大概是10〜20年）之内被自动化。这并不是对实际上有多少人会失业的预测。野村综研也写道，实际上会不会被取代，社会因素的影响也很大，并没有算进估算里。

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u10_risk_category.py

# u10 「危険の高い区分に 47%」は、どうやって出た数か（小さな町の架空の例で、同じ手順をたどる）
#
# どの出来事か：2013 年 9 月、オックスフォード大学のフレイとオズボーンの論文（記録 frey_osborne_jobs_2013）。
#   アメリカの 702 の職業のうち、研究者たちが自信のある 70 の職業にだけ「自動化できる（1）・できない（0）」の
#   ラベルを手作業で付けた。知覚と手先の作業・創造性・人とのやりとりの力を表す 9 つの変数から、
#   残りの職業の確率をガウス過程（確率的な分類モデル）で推定した。確率 0.7 以上を高い区分、0.3 未満を低い区分とし、
#   労働者数で集計すると、高い区分は 47%（低 33%・中 19%）となった。2015 年の野村総合研究所の 49%（nri_jobs_49percent_2015）も
#   同じ 2 人との共同研究で、日本の 601 の職業を試算したもの。
# 仕組み：このサイトが作った架空の町の 40 の仕事（仕事 A〜）と、3 つの変数（手先の細かさ・創造性・人とのやりとり）、
#   働く人の数を使う。そのうち 12 の仕事にだけ 1・0 のラベルを付け、ロジスティック回帰（論文のガウス過程の代わりの、
#   最も簡単な確率の分類モデル）で、すべての仕事の確率を推定する。しきい値を変えると、見出しの数字がどう変わるかを見る。
#   数値はどれも架空のもので、実際の職業の統計ではない。
# 試してみよう：
#   - HIGH を 0.5 や 0.9 にすると、「高い区分」の割合は何 % になるか
#   - ラベルを付ける仕事（LABELED）を変えると、確率はどう変わるか

import math
import random

HIGH, LOW = 0.7, 0.3
random.seed(2013)
jobs = []
for k in range(40):
    name = "仕事 " + "ABCDEFGHIJKLMNOPQRSTUVWXYZ"[k % 26] + ("" if k < 26 else "2")
    f = [random.random(), random.random(), random.random()]    # 手先の細かさ・創造性・人とのやりとり（0〜1）
    people = random.randint(5, 60) * 100
    jobs.append([name, f, people])

# ラベル付け（研究者の判断の代わり）：3 つの「難所」がどれも低い仕事は 1、どれかがとても高い仕事は 0
LABELED = [j for j in jobs if max(j[1]) < 0.45 or max(j[1]) > 0.85][:12]
labels = [1 if max(j[1]) < 0.45 else 0 for j in LABELED]
print(f"ラベルを付けた仕事 {len(LABELED)} 個（1 が {sum(labels)} 個）。残り {len(jobs) - len(LABELED)} 個は、モデルで確率を推定する")

w, b = [0.0, 0.0, 0.0], 0.0
for _ in range(3000):                                          # ロジスティック回帰を勾配降下法で学習
    gw, gb = [0.0, 0.0, 0.0], 0.0
    for j, y in zip(LABELED, labels):
        p = 1 / (1 + math.exp(-(sum(a * x for a, x in zip(w, j[1])) + b)))
        for i in range(3):
            gw[i] += (p - y) * j[1][i]
        gb += p - y
    w = [a - 0.5 * g / len(LABELED) for a, g in zip(w, gw)]
    b -= 0.5 * gb / len(LABELED)
for j in jobs:
    j.append(1 / (1 + math.exp(-(sum(a * x for a, x in zip(w, j[1])) + b))))

total = sum(j[2] for j in jobs)
print("\n確率の高い順（棒は確率。人数は架空の数値）")
for name, f, people, p in sorted(jobs, key=lambda j: -j[3])[:12]:
    print(f"  {name:6s} 確率 {p:.2f} {'■' * int(p * 20):20s} {people:5d} 人")
print("  …")

def shares(high, low):
    hi = sum(j[2] for j in jobs if j[3] >= high) / total
    lo = sum(j[2] for j in jobs if j[3] < low) / total
    return hi, 1 - hi - lo, lo

h, m, l = shares(HIGH, LOW)
print(f"\nしきい値 {LOW} と {HIGH}：高い区分 {h:.0%}・中 {m:.0%}・低 {l:.0%}（働く人の数で計算した割合）")
print("しきい値を変えると、見出しの数字が変わる：")
for high in (0.5, 0.6, 0.7, 0.8, 0.9):
    print(f"  確率 {high} 以上を「高い」とすると：{shares(high, LOW)[0]:.0%}")
print("\nどの数値も「技術的に置きかえられうる確率」の推計。実際に何人の仕事がなくなるかは、この計算に含まれていない。")

192011〜2016・日本

读到哪里，写到哪里

AI放弃了东大，AI写的小说通过了奖项评审。实际上发生了什么？

国立情报学研究所的东机器人（東ロボくん，2011年起），把目标定为（译），以及（译）。在2016年的模拟考试中，中心考试（日本的全国统一大学入学考试）得525分、偏差值（日本表示考试成绩的指标，平均为50）57.1，东大模拟考试的数学（理科）偏差值是76.2。同一年，有人说，由于（译）很难，将停止像人一样解答中心考试的尝试。

2016年3月，让AI写小说的研究所产生的作品，有一部分通过了日经“星新一奖”的第1轮评审，在第2轮落选。在图里点“星新一奖2016”的方块看看吧。情节（包括结局）和句子的部件是人准备的，由程序来组合。

常见说法常见说法：东机器人放弃了考东大（失败了）
原始资料里：国立情报学研究所的发布里没有“放弃”这个词。报告会上说的是“将‘像人一样’解答大学入学考试（中心考试）的研究，到本年度为止冻结”，以及。

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u10_novel_parts.py

# u10 人が決めた筋書きと文の部品を、プログラムが選んで組み立てる（「AI が書いた小説」の仕組みを小さく再現）
#
# どの出来事か：2016 年 3 月、日経「星新一賞」に応募された、AI に小説を書かせる研究の作品（記録 hoshi_award_ai_novel_2016）。
#   中心となった松原仁さんの記事によると、筋書き（オチを含むシナリオ）は人が考え、プログラムは人が用意した
#   文の部品を使って、筋書きどおりに日本語の文章を組み立てた。1 次審査を通過し、2 次審査で落選した。
# 仕組み：このサイトが作った例。4 場面の筋書き（人が決める）と、場面ごとの文の部品（人が用意する）。
#   プログラムは部品の候補から 1 つずつ選び、名前や天気などの空き（｛｝）を埋めて並べる。
#   どの文字を人が書き、どこをプログラムが決めたかを数える。
# 試してみよう：
#   - SEED を変えると、違う文章になるか。筋書き（オチ）は変わるか
#   - PARTS に候補を足すと、作れる文章の数はどう増えるか

import random

SEED = 3
random.seed(SEED)
PLOT = ["はじまり", "こまりごと", "ためしたこと", "オチ"]          # 人が決めた筋書き（オチも人が決める）
PARTS = {                                                          # 人が用意した文の部品
    "はじまり": ["その日、{名}は{天気}の窓の外をながめていた。", "{天気}の朝、{名}はいつもより早く目をさました。"],
    "こまりごと": ["部屋のロボットが、なぜか何も話さなくなった。", "部屋のロボットが、同じ言葉ばかりくり返すようになった。"],
    "ためしたこと": ["{名}は説明書を 3 回読み、電源を入れ直した。", "{名}はロボットに、好きな歌を歌って聞かせた。",
                     "{名}は友だちに電話して、直し方をたずねた。"],
    "オチ": ["ロボットは小さな声で言った。「きょうは、わたしも休みたかったのです」", ],
}
FILL = {"名": ["ユキ", "ハル", "ソラ"], "天気": ["雨", "くもり", "晴れ"]}

chosen = {k: random.choice(v) for k, v in FILL.items()}           # プログラムが決める部分 1：空きを埋める
text = []
program_choices = 0
for scene in PLOT:
    part = random.choice(PARTS[scene])                             # プログラムが決める部分 2：部品を選ぶ
    program_choices += 1 if len(PARTS[scene]) > 1 else 0
    text.append(part.format(**chosen))
print("できた文章：")
print("  " + "".join(text))

human_chars = sum(len(p) for v in PARTS.values() for p in v)
count = 1
for v in PARTS.values():
    count *= len(v)
for v in FILL.values():
    count *= len(v)
print(f"\n人が用意したもの：筋書き {len(PLOT)} 場面（オチも）、文の部品 {sum(len(v) for v in PARTS.values())} 個（合わせて {human_chars} 字）")
print(f"プログラムが決めたもの：部品の選び方 {program_choices} か所、空きの埋め方 {len(FILL)} か所")
print(f"この部品から作れる文章の数：{count} 通り（オチはどれも同じ）")
print("\nどちらが何割書いたかを 1 つの数で表すのは難しい。文字数で数えるか、決めたことの数で数えるかで変わる。")

202016・预言的时钟

预言的时钟

在热潮的年代给出具体年份的预言，到了那一年怎么样了？

2016年，辛顿在多伦多的一场会议上说：，（均为译文）。同年8月，福特宣布，将在2021年让没有方向盘、没有踏板的L4级自动驾驶汽车，以叫车、拼车服务的形式、（均为译文）上路。日本政府写道，在限定区域内开展无人驾驶的出行服务，要。政府的白皮书介绍说，一部分研究者认为。

在右边的图里移动“当前年份”，到了答案年份的预言，会显示它之后发生了什么。选择“辛顿·放射科医生”时显示的柱子上的数字，是美国住院医师招募的数量（官方表格中2016年和2025年这2个点）。

常见说法常见说法：5年内AI会取代放射科医生
原始资料里：在原视频里，他紧接着补了一句（译）。他说的不是AI，而是深度学习，并没有说工作会在哪一年消失（已用视频的自动字幕确认）。

212014〜2019・规则

是写给谁的规则

AI的研究者和各国政府，制定了怎样的规则，是写给谁看的？

2014年1月，人工智能学会志的新封面（画着一个拿着扫帚打扫的女性形象机器人）招来批评，说。学会写道：。这成为设立伦理委员会的契机之一。2017年学会的中，最后的第9条是，这一条是写给AI自己的。

2016年3月，微软的对话AI Tay，被一部分串通好的人抓住弱点，在24小时内发布了不当言论而被停用。在右边的“模仿着学的对话”，本站做的最简单的图，不是Tay的真实机制）里，动一动串通者的比例看看吧。

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u10_learn_from_users.py

# u10 人とのやりとりから「まねして学ぶ」会話AIは、示し合わせた人たちにどう崩されるか
#
# どの出来事か：2016年3月、マイクロソフトの会話AI「Tay」（記録 microsoft_tay_2016）。人とのやりとりから学習する
#   設計だったが、公開後24時間以内に、一部の人たちが示し合わせて弱点を突いた。その結果、ひどく不適切な
#   言葉を投稿して停止された。会社自身が、悪用を事前にすべて見通すことはできないと書いている。
# 仕組み：このサイトが作った、最も単純な「まねして学ぶ」会話モデル（Tay の実際の仕組みではない）。
#   話しかけられた言葉をすべて記憶し、その中から返事を選ぶ。聞いた回数が多い言葉ほど選ばれやすい。
#   ふつうの人はさまざまな言葉を話し、示し合わせた人たちは同じ不適切な言葉（ここでは ×××× と書く）を繰り返す。
# 試してみよう：
#   - GROUP（示し合わせた人の割合）を 0.02 にすると、返事が不適切な言葉になる割合はどれくらいになるか
#   - BLOCK を True にすると（記憶する前に特定の言葉を除外する）、どう変わるか。別の言い回しをされたら？

import random

GROUP = 0.10
BLOCK = False
MESSAGES = 3000
random.seed(2016)
NORMAL = ["おはよう", "今日は暑いね", "好きな食べ物は？", "宿題おわった？", "おやすみ", "その歌いいね",
          "週末どこか行く？", "ねこかわいい", "雨ふってきた", "ありがとう"]
BAD = ["××××"]
memory = {}
bad_replies = 0
checkpoints = {100, 500, 1000, 3000}
for n in range(1, MESSAGES + 1):
    said = random.choice(BAD) if random.random() < GROUP else random.choice(NORMAL)
    if not (BLOCK and said in BAD):
        memory[said] = memory.get(said, 0) + 1          # 聞いた言葉を記憶する
    words, counts = zip(*memory.items())
    reply = random.choices(words, weights=counts)[0]   # 聞いた回数が多い言葉ほど選ばれやすい
    if reply in BAD:
        bad_replies += 1
    if n in checkpoints:
        share = sum(memory.get(b, 0) for b in BAD) / sum(memory.values())
        top = max(memory, key=memory.get)
        print(f"{n:5d} 回話しかけられた後：記憶した言葉のうち不適切な言葉 {share:5.1%}　"
              f"これまでの返事のうち不適切な返事 {bad_replies / n:5.1%}　いちばん多く聞いた言葉「{top}」")
print(f"\n示し合わせた人の割合 {GROUP:.0%}、除外機能 {'あり' if BLOCK else 'なし'}")
print("このまねの仕組みでは、示し合わせた人の割合が、そのまま返事に現れる。")
print(f"ふつうの人の言葉は {len(NORMAL)} 通りに分かれるため、1つの言葉を繰り返す人が1割いるだけで、")
print("その言葉が「いちばん多く聞いた言葉」になりやすい。")

222015〜2019・高峰的终结

热潮的高峰是什么时候过去的

热潮的高峰，是在什么时候、怎样过去的？

2015年3月，松尾丰的书《人工智能会超越人类吗》，把AI的历史分成了第1〜3次AI热潮几章。2016年日本政府的《信息通信白皮书》参考这本书等资料，说明AI的研究是的，现在是第三次热潮。2015年，软银宣布Pepper已经。

右边的柱子，是国会发言中表示AI含义的“ＡＩ”一词出现的次数（本站从会议记录里数出来的）。从2015年的11次增加到2019年的593次，2020、2021年减少了。2019年10月，高德纳日本公司把人工智能放在了“幻灭期”（期待过高之后，失望蔓延的时期）。

期待的高峰的形状（炒作周期）是调查公司看法的一种模式，并没有被验证为规律。2020〜2021年次数减少的原因，也无法归结为单一一个（与疫情之年重合）。

让输入每层的值保持整齐

Dropout与知识蒸馏

词的加法

只凭分数学会怎么玩

把学好的网络拿来重复使用

在哪里，是什么，有几个

压缩，再展开

造假钞的人与警察

细管，还是注意力

怎样走下细长的山谷

跳过层的捷径

被超过的人类是谁

画画的两种方法

边运行边搭建

试下，与2个网络

逆转的十年

由距离地图组装出形状

47%与49%的内涵

读到哪里，写到哪里

预言的时钟

是写给谁的规则

热潮的高峰是什么时候过去的

这一章里，还不清楚的事

OpenAI成立（2015年12月）：“最有可能造福全人类”的非营利公司

政府“人工智能技术战略会议”（2016）与“人工智能技术战略”（2017）

中国《新一代人工智能发展规划》定下2020、2025、2030年3步目标

OpenAI成立（2015年12月）：的非营利公司

政府“人工智能技术战略会议”（2016）与（2017）