第3次熱潮的高峰

012015·訓練的技巧

每次都調整進入各層的值

疊了10層、20層的網路，為什麼以前很難訓練？

深層網路要把輸出的誤差傳回輸入端來修正權重（反向傳播，第8章）。傳回去的訊號，每經過一層，就要乘上這一層的權重和神經元的斜率。S形的sigmoid函數斜率不超過0.25，所以光是斜率這一項，10層下來就只剩約100萬分之1。

2010〜2012年的ReLU和權重初始值的技巧，我們在第9章已經看過。2015年，Google的Ioffe和Szegedy提出了批次正規化：把進入各層的值，依一次訓練所用的那批資料，統一調整為平均值0、變異數1。右圖是一個20層的網路，測量向前傳的值的分布（藍）和往回傳的訊號（紫）。切換ReLU、權重初始值、批次正規化，來比一比吧。

往回傳的訊號 ≈ 輸出端的訊號 ×（w₁·f′₁）×（w₂·f′₂）× … ×（w_L·f′_L）

f′: 神經元的斜率（sigmoid不超過0.25，ReLU是0或1）
w: 權重
L: 層數

以為知道的事常見說法：批次正規化有效，是因為它修正了進入各層的值的分布偏移
原始資料中：論文就是這麼想的，並寫道只用14分之1的訓練次數就達到了相同的準確度。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，是每給網路看1筆資料，就讓隱藏層的神經元隨機休息一半。它的效果接近許多小型網路的平均。

在右圖裡，試著讓曲線去擬合12個點（本站製作的例子）。不讓神經元休息的話，曲線和新點（藍色的圓）之間的誤差會越來越大。

2015年的知識蒸餾，是讓小網路模仿大網路的輸出，而這個輸出是用溫度T把機率變得柔和之後的結果。選擇「知識蒸餾」並提高T，就能看出正確答案以外的各個答案之間的差別。論文的看法是：這些差別裡也有知識。

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

z_i: 輸出i的分數
T: 溫度（1時是一般的機率，越大越平緩）

以為知道的事常見說法：知識蒸餾是2015年辛頓等人開創的
原始資料中：2015年的論文本身就寫道，同一方法的1種形式，早在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年，Google的Mikolov等人提出的 word2vec，用數百個數組成的一組數（向量）來表示詞。它從大量文章中學習，讓用法相近的詞靠得更近。用16億個詞，只用1個CPU，不到1天就做出了100萬個詞的300維向量。

這些向量，可以用加法和減法來表示意義的關係。論文用這樣一個問題的正確率來衡量效能：biggest − big＋small的答案是不是smallest。在右圖（本站製作的2維例子）裡，試著點選3個詞吧。

答案是排除題目裡的3個詞之後，最接近的詞（這是9月版論文補上的註解）。如果不排除，在這個例子裡排第1的會是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值）列成表，每採取一次行動就稍微更新一點。在右邊的迷宮（本站製作的例子）裡，看看終點的得分是怎麼每次往前1步傳到前面的格子的。

2013年12月，倫敦DeepMind的 DQN，用卷積類神經網路取代了表。它把畫面的像素直接當作輸入，用調整過的Q學習方法來學習。在7款早已存在的電玩遊戲中，有6款超越以往的方法，有3款超越人類的熟練玩家。2015年發表在Nature上的論文，用同1套機制學習了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款。論文本身寫道，需要長遠規劃的遊戲（例如《蒙特祖瑪的復仇》）仍是一個很大的課題。

每1次的結果（綠＝到達終點，紫＝掉進洞裡，灰＝時間到）

這是用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個數），當作另一項任務的特徵。即使是每1個類別只學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·物件偵測

在哪裡，是什麼，有幾個

怎麼把照片裡的東西用方框圈出來，並標上名稱？

影像分類是給每1張影像1個答案。物件偵測則是替照片中的每1個物件畫上方框，並標上名稱。

2013年11月，加州大學柏克萊分校Girshick等人的 R-CNN，先用一種不需要學習的方法產生約2000個候選方框，每次送1個進CNN，再用各個類別的SVM評分。因為圈住同一個東西的方框會留下好幾個，所以要移除與高分方框大幅重疊的方框（非極大值抑制）。會議版在PASCAL VOC 2012上取得mAP 53.3%，大幅超越先前的最佳成績，但每1張影像用GPU處理要花13秒。

2015年6月，華盛頓大學Redmon等人的 YOLO，把影像分成7×7的格子，讓網路在1次計算中同時輸出每個格子的2個方框（共98個）和類別。每1秒45張，63.4%。同月，Ren等人的 Faster R-CNN 連候選也讓網路來產生，每1秒5張，73.2%。在右圖裡比一比吧。

IoU＝重疊的面積 ÷ 合併後的面積

IoU: 預測方框與正確方框重疊的比例（1為完全一致，0為完全沒有重疊）

以為知道的事常見說法：YOLO是第一個即時找出物件的方法
原始資料中：YOLO的論文本身就舉出了更早以每1秒30張運作的DPM（2014年Sadeghi和Forsyth）。YOLO的主張是：在即時方法中，準確率提高到了2倍以上（26.1% → 63.4%）。每1秒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再也分辨不出來的狀態。

右邊是1條數線上的GAN（本站製作的小例子）。開啟圖時，紫色的假資料分布就會向藍色的真資料分布靠近，D的線接近0.5。依照G和D的學習速度組合，可能會集中在1處，或來回震盪。競爭並不總是能順利收斂。

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個譯詞時，都會決定對原文各個詞的關注程度（合計為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·訓練方法

怎麼走下細長的山谷

沿著誤差變小的方向前進時，1步的幅度該怎麼決定？

訓練網路的基本方法是梯度下降法：在誤差構成的地形上，順著下坡的方向（梯度）一點一點往前走。地形如果是細長的山谷，陡的方向會走過頭，緩的方向又很難前進（右邊的深藍色小球）。

2014年12月，Kingma和Ba的 Adam，對每個權重，都分別記錄梯度的移動平均值，以及梯度的2次方的移動平均值，用它們的比值來決定步幅。梯度一直很大的方向走得小一點，梯度小的方向走得大一點，所以紫色的小球會稍微走過頭，逐步走向谷底。剛開始時，移動平均值會偏向0；取消勾選「偏誤修正」，就能比較有沒有修正這個偏差的差別。

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

g: 梯度
m, v: 梯度的移動平均值，以及梯度的2次方的移動平均值
m̂, v̂: 修正後的值
η: 學習率（前進的幅度）

以為知道的事常見說法：Adam是被證明一定會收斂的方法
原始資料中：2018年，Google的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字形結構，並使用了把壓縮前的細節特徵複製過來接上的捷徑。它是為顯微鏡影像的區域分割而設計的。在右圖裡切換這2種捷徑看看吧。

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張）。另1個只練習100張的人，在258張上的錯誤率是12.0%。切換右邊的「人類基準線」，被超越的年份就會移動。

2016年的對話語音辨識中，人類的錯誤率也因測量方法不同，有4%、5.9%、5.1%的差別。2014年宣布（譯）的那個活動，所用的30%這條線，也是主辦單位自己決定的。

以為知道的事常見說法：2015年，影像辨識AI超越了人類
原始資料中：拿來比較的人類的5.1%只是1人的數字，另1人是12.0%。聲稱超越人類的論文本身也寫道：（譯）。

132015·影像生成

畫畫的2種方法

用訓練好的網路畫畫，該怎麼做？

2015年8月，圖賓根大學等機構的Gatys等人的畫風轉換，不改變訓練好的網路，而是修改影像的像素。它把深層的反應當作內容，把各個特徵是否一起強烈出現的表（Gram矩陣）當作畫風，讓兩者的差異都變小。右邊的「畫風轉換」是只有小型濾波器的最簡單形式（本站製作的例子）。

同年3月，史丹佛大學Sohl-Dickstein等人的擴散模型，是反覆往資料裡加雜訊來破壞它，再讓網路學習反方向的1步。從雜訊出發，反覆做反方向的步驟，就能得到新的資料。選擇「擴散模型」，把螺旋破壞再還原看看。

畫風轉換：差異＝α ×（內容的差異）＋β ×（Gram矩陣的差異）　　擴散的1步：x ← √(1−β_t)·x＋ √β_t·ε

α, β: 2種差異的權重
β_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·日本

實力逆轉的10年

職業棋士和軟體的實力，是什麼時候逆轉的？

在將棋方面，2005年，化學研究者保木邦仁公開了Bonanza。它讓機器學習評估函數（替局面好壞評分的算式）的權重，使它走出與職業棋譜相同的下一手。2007年3月渡邊明龍王擊敗Bonanza後不久，研究者松原仁寫道，對頂尖職業棋士取得勝多敗少的成績，（譯）。

右邊的方塊，每一個代表1局公開對局。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個胺基酸之間的距離地圖。再用梯度下降法調整形狀，使它符合由這張地圖建立的評分公式，從而組出形狀。

右邊是把這個組合過程簡化的例子（本站製作的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年，野村綜合研究所與同樣這2人合作研究，宣布（譯）。

高風險類別的比例＝（在機率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寫的小說通過了獎項評審。實際上發生了什麼？

日本國立情報學研究所的Torobo-kun（2011年起），把目標定為（譯），以及（譯）。在2016年的模擬考中，中心考試（日本的全國統一大學入學考試）得525分、偏差值（日本用來表示成績相對位置的指標）57.1，東大模擬考的數學（理科組）偏差值是76.2。同一年，由於（譯）很難，研究者表示將停止像人類一樣解答中心考試的嘗試。

2016年3月，讓AI寫小說的研究所產生的作品，有一部分通過了日經「星新一獎」（譯）的第1輪評審，在第2輪落選。在圖裡選擇「星新一獎2016」，再按方塊看看吧。情節（包括結局）和句子的零件是人類準備的，由程式來組合。

以為知道的事常見說法：Torobo-kun放棄了考東大（失敗了）
原始資料中：國立情報學研究所的公告裡沒有放棄這個詞。報告會上說的是（譯），以及（譯）。

這是用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年讓沒有方向盤、沒有踏板的Level 4自駕車，以叫車、共乘服務的形式、（均為譯文）上路。日本政府寫道，在限定區域內提供車內沒有駕駛的交通服務，要（譯）。政府的白皮書介紹說，一部分研究者認為（譯）。

在右圖裡移動「目前年份」，到了核對年份的預言，就會顯示之後發生了什麼。選擇「辛頓·放射科醫師」時，長條上的數字是美國住院醫師的招募名額（官方表格中2016年和2025年這2個點）。

以為知道的事常見說法：5年內AI會取代放射科醫師
原始資料中：在原始影片裡，他緊接著補了一句（譯）。他說的是深度學習而不是AI，並沒有說工作會在哪一年消失（以影片的自動字幕確認）。

212014〜2019·規範

是寫給誰的規範

AI的研究者和各國政府，制定了什麼規範，是寫給誰的？

2014年1月，日本人工智慧學會會刊的新封面（畫著一個拿掃帚打掃的女性型機器人）引來批評，認為（譯）。學會寫道：（譯）。這成為設立倫理委員會的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月，Gartner日本公司把人工智慧放在「幻滅期」（期望過高之後，失望蔓延的時期）。

期望的高峰形狀（技術成熟度曲線）是調查公司用來評估的模式，並沒有被驗證為定律。2020〜2021年次數減少的原因，也無法歸結為1個因素（與疫情的年份重疊）。

每次都調整進入各層的值

Dropout與知識蒸餾

詞的加法

只靠分數學會怎麼玩

重複運用訓練好的網路

在哪裡，是什麼，有幾個

壓縮，再展開

製造假鈔的人與警察

細管，還是注意力

怎麼走下細長的山谷

跳過層的捷徑

被超越的人類是誰

畫畫的2種方法

一邊執行，一邊組建

試下，與2個網路

實力逆轉的10年

從距離地圖組出形狀

47%與49%的內涵

讀到哪裡，寫到哪裡

預言的時鐘

是寫給誰的規範

熱潮何時越過高峰

這一章裡，還不清楚的事

OpenAI宣布成立（2015年12月）：「為了全人類的利益」的非營利研究公司

政府「人工智慧技術戰略會議」（2016）與「人工智慧技術戰略」（2017）

中國政府在「新一代人工智慧發展規劃」中訂定2020、2025、2030年的3階段目標

OpenAI宣布成立（2015年12月）：的非營利研究公司

政府「人工智慧技術戰略會議」（2016）與（2017）

中國政府在中訂定2020、2025、2030年的3階段目標