第3次ブームの山｜AIの全歴史

012015・学習の工夫

層に入る値を毎回そろえる

層を10も20も重ねたネットワークは、なぜ学習しにくかったのか。

深いネットワークは、出力の誤差を入力側へ戻して重みを直す（誤差逆伝播法、8章）。戻る信号には、層ごとに重みとニューロンの傾きが掛かる。S字のシグモイド関数は傾きが0.25以下なので、傾きだけでも 10層で約100万分の1になる。

2010〜2012年のReLUと重みの初期値の工夫は9章で見た。2015年、グーグルのイオッフェとセゲディのバッチ正規化は、層に入る値を、一度に学習するデータのまとまりごとに平均0・分散1にそろえる。右の図は20層のネットワークで、前へ進む値の広がり（青）と戻る信号（紫）を測る。ReLU・重みの初期値・バッチ正規化を切り替えて比べよう。

戻る信号 ≈ 出口の信号 ×（w₁·f′₁）×（w₂·f′₂）× … ×（w_L·f′_L）

f′: ニューロンの傾き（シグモイドは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・過学習

ドロップアウトと知識の蒸留

訓練データに合いすぎる過学習を、どう防ぐか。

訓練データでは正解ばかりなのに、新しいデータでは間違える。これを過学習という。9章で見た2012年のドロップアウトは、データを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年にカルアナたちが先に開拓していたと書く。

学習した点の誤差（実線）と新しい点の誤差（点線）。青＝休ませない、緑＝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年、グーグルのミコロフたちの word2vec は、単語を数百個の数の組（ベクトル）で表す。使われ方の似た単語ほど近くに来るように、大量の文章から学習する。16億語から100万語分の300次元ベクトルを、CPU 1つで1日かからずに作れた。

できたベクトルは、足し算や引き算で意味の関係を表せた。論文は、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月、カリフォルニア大学バークレー校のドナヒューたちの DeCAF は、同じ形のネットワークの重みを固定したまま、出力に近い層の反応（4096個の数）を別の仕事の特徴量にした。1種類30枚しか学ばないCaltech-101でも、線形分類器を載せるだけで86.9%を当て、手作りの特徴量を5つ合わせた当時の最高を上回った。これを転移学習という。

ネットワーク全体を、新しい仕事のデータで小さな歩幅で学習し直すのが微調整（ファインチューニング）。次の見開きの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月、カリフォルニア大学バークレー校のギルシックたちの R-CNN は、学習しない方法で候補の四角を約2000個作り、1つずつCNNに通して種類ごとのSVMでスコアをつけた。同じ物を囲む四角がいくつも残るため、スコアの高い四角と大きく重なる四角を取り除く（非最大値抑制）。学会版はPASCAL VOC 2012でmAP 53.3%とそれまでの最高を大きく上回ったが、1枚にGPUで13秒かかった。

2015年6月、ワシントン大学のレドモンたちの YOLO は、画像を7×7の格子に分け、マス目ごとの四角2つ（計98個）と種類をネットワーク1回で同時に出す。1秒45枚で63.4%。同月のレンたちの Faster R-CNN は候補もネットワークに作らせ、1秒5枚で73.2%。右の図で比べよう。

IoU＝重なった面積 ÷ 合わせた面積

IoU: 予測の四角と正解の四角が重なる割合（1で完全一致、0で重なりなし）

知ってるつもりよく言われる話：YOLOが初めてリアルタイムで物体を見つけた
元の資料では：YOLOの論文自身が、先に1秒30枚で動いていたDPM（2014年のサデギとフォーサイス）を挙げている。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月、アムステルダム大学のキングマとウェリングの 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月、モントリオール大学のグッドフェローたちの 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月のチョたちや9月のスツケヴァーたちの seq2seq は、文を決まった長さの数の組にまとめ、そこから訳文を出した。チョたちはLSTMを簡略化した部品（のちの GRU）も示した。右の「細い管（seq2seq・GRU）」で、長い文ほど前の単語が薄れるのを見よう。

同じ9月、バーダナウたちは訳語を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年のトランスフォーマーの論文で生まれた
元の資料では：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月、キングマとバーの Adam は、重みごとに、勾配の移動平均と、勾配の2乗の移動平均を記録し、その比で幅を決める。勾配が常に大きい向きは控えめに、小さい向きは大きめに進むため、紫の玉は小さく行きすぎながら谷底へ向かう。初めのうち移動平均が0に寄る偏りを直す計算（バイアス補正）を、「バイアス補正」のチェックを外して比べよう。

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

g: 勾配
m, v: 勾配と、勾配の2乗の移動平均
m̂, v̂: 補正した値
η: 学習率（進む幅）

知ってるつもりよく言われる話：Adamは、必ず収束すると証明された方法
元の資料では：2018年、グーグルのレディたちの論文は、単純な問題でも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年、フライブルク大学のロンネベルガーたちの 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枚を識別）。100枚だけ練習したもう1人は、258枚で12.0%だった。右の「人間の線」を切り替えると、超えた年が動く。

2016年の会話の音声認識でも、人間の誤り率は4%・5.9%・5.1%と測り方で違った。2014年に（訳）と発表されたイベントの30%という線も、主催者が決めたものだった。

知ってるつもりよく言われる話：2015年、画像認識AIが人間を超えた
元の資料では：比べた人間の5.1%は1人の数字で、もう1人は12.0%。超えたと書いた論文自身も、（訳）と書いている。

132015・画像生成

絵を描く2つの方法

学習済みのネットワークで絵を描くには、どうすればよいか。

2015年8月、テュービンゲン大学などのゲイティスたちの画風変換は、学習済みのネットワークは変えず、画像の画素を直す。深い層の反応を中身、特徴どうしが一緒に強く出るかの表（グラム行列）を画風とし、両方のずれを小さくする。右の「画風変換」は、小さなフィルターだけの最小の形（このサイトが作った例）。

同年3月、スタンフォード大学のソール＝ディックスタインたちの拡散モデルは、データにノイズを繰り返し足して壊し、逆向きの1歩をネットワークに学ばせる。ノイズから逆向きを繰り返せば、新しいデータができる。「拡散モデル」で、渦巻きを壊して戻してみよう。

画風変換：ずれ＝α ×（中身のずれ）＋β ×（グラム行列のずれ）　　拡散の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年、フランスのクーロンのモンテカルロ木探索は、先をでたらめに最後まで何度も打ってみて、勝った割合で手を比べ、有望な枝ほど深く調べる（どの手をどれだけ試すかの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月、オックスフォード大学のフレイとオズボーンは、アメリカの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の小説が賞の審査を通った。本当は何が起きたのか。

国立情報学研究所の東ロボくん（2011年〜）は、、を目標にした。2016年の模試では、センター試験が525点・偏差値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月、フォードは、ハンドルもペダルもないレベル4の自動運転車を、2021年に配車・相乗りサービスで（どちらも訳）走らせると発表した。日本の国は、限られた地域で運転する人が乗らない移動サービスをと書いた。国の白書は、一部の研究者はと見ている、と紹介した。

右の図で「いまの年」を動かすと、答えの年が来た予言から、その後に起きたことが出る。「ヒントン・放射線科医」を選ぶと出る棒の数は、アメリカの研修医の募集の数（公式の表の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月、ガートナー・ジャパンは人工知能を「幻滅期」（期待が高まりすぎた後に失望が広がる時期）に置いた。

期待の山の形（ハイプ・サイクル）は調査会社の見立ての型で、法則として確かめられたものではない。2020〜2021年に回数が減った理由も1つには絞れない（感染症の年と重なる）。

層に入る値を毎回そろえる

ドロップアウトと知識の蒸留

言葉の足し算

点数だけで遊び方を覚える

学習済みのネットワークを使い回す

どこに、何が、いくつあるか

縮めて、また広げる

偽札づくりと警察

細い管か、注意か

細長い谷の下り方

層を飛び越す近道

超えた相手の人間は誰か

絵を描く2つの方法

動かしながら組み立てる

試し打ちと2つのネットワーク

逆転した10年

距離の地図から形を組む

47%と49%の中身

どこまで読み、どこまで書いたか

予言の時計

誰に向けた決まりか

ブームの山はいつ過ぎたのか

この章で、まだ分かっていないこと

OpenAI設立の発表（2015年12月）：「人類全体の利益のため」の非営利研究会社

政府の「人工知能技術戦略会議」（2016年）と「人工知能技術戦略」（2017年）

中国政府が「新世代の人工知能の発展計画」で2020・2025・2030年の3段階目標を決める

OpenAI設立の発表（2015年12月）：の非営利研究会社

政府の「人工知能技術戦略会議」（2016年）と（2017年）

中国政府がで2020・2025・2030年の3段階目標を決める