第2次热潮之后的寒冬，与悄悄长出的新芽

011984〜1996・美国

用数字测量寒冬的冷

1984年担心过的寒冬，真的来了吗？

1984年8月，美国人工智能学会（AAAI）大会的一场讨论会上，主持人麦克德莫特（McDermott）描绘了一个：5年左右之内，国防部的失败，新兴公司倒闭，AI的资金断绝。他介绍说，这种状态有人称为。不过他本人也说，自己认为发生的可能性并不高。

右边的图是后来美国的数据。AAAI的会员数在1987年达到峰值16,421人，到1996年减少到4,000〜5,000人。研发Lisp机器（AI专用计算机）的Symbolics公司，产品销售额在1986〜1988财年从1.016亿美元降到5,560万美元。单位不同的数，把峰值都定为100，就可以比较了。

归一后的值＝当年的数 ÷ 峰值年的数 × 100

峰值: 数值最大的那一年

常见说法常见说法：1984年的讨论准确地预言了AI寒冬
原始资料里：主持人只是把它作为提出，并说发生的可能性不高。情形中的很多内容后来确实发生了，但并不是5年后一下子全部发生。

021987〜2003・日本

日本没有迎来寒冬？

美国在谈寒冬的时候，日本怎么样？

1991年3月，通商产业省监修的写道，日本“没有迎来以前在美国出现过的AI‘寒冬’”。当时日本流行模糊（fuzzy，处理含糊性的理论），1990年“模糊”还拿下了新词·流行语大奖（日本的年度流行语评选）新词部门的金奖。

白皮书的依据之一是1989年的调查。引进了AI的比例是：回答问卷的计算机使用单位中占26.2%，AI中心会员中占80.5%，总体为37.8%。但是，发出调查表的7,084处里，回答的只有1,844处。在右边的图里，看看问的是谁会让这个比例怎样变化。

把图切换到学会的会员，企业等会员在1991、1992年的155家达到峰值，到2003年减少到49家。日本的寒冬，看起来是迟来的，而且来得很慢。

回答者中的比例＝引进的数 ÷ 回答的数

下限: 假定没有回答的单位全都没有引进时的比例（引进的数 ÷ 发出的数）

常见说法常见说法：第2次热潮之后，日本和世界同时迎来了寒冬
原始资料里：1991年由国家监修的白皮书写的是，日本没有迎来美国那样的寒冬。学会的企业会员开始减少，是在其后1993年的报告里。

031992〜1995・日本的国家计划

从符号的计划，到学习的计划

第五代计算机之后，日本的国家计划瞄准了什么？

1995年，日本国家的3个计划一起结束了。一个是以逻辑推理的计算机为目标的第五代计算机，一个是靠手工编出计算机用巨型词典的日本电子化词典研究所（EDR，1986〜1995年），还有处理含糊性的LIFE（1989〜1995年）。

在此之前的1992年，通商产业省启动了十年计划。据主持推进的大津展之说，第五代追求的是，而RWC瞄准的是，也就是图像、声音这类含糊的信息，目标是用学习灵活地处理它们。

在右边的图里拖动“当前年份”，可以看到当年在推进的计划，其重点正从符号转向模式与学习。

每年的平均＝资金总额 ÷ 年数

平均: 并不是每年金额相同，而是除以年数后拉平的值

041982・神经网络

落入能量山谷的网络

会“回想”的网络，为什么总能在某处稳定下来？

1982年4月，物理学家霍普菲尔德发表了一种网络：所有神经元取 +1或 −1的值，彼此全部相连。连接的强度是双向相同的。神经元逐个更新，依据周围输入之和的正负号来决定。

论文借用研究磁体性质的物理学思路，给状态定义了一个叫能量的数。每更新一个神经元，能量不是下降就是不变。所以，它总会在某个谷底停下来。只要把记住的模式设为谷底，即使从残缺的模式开始，也会落入附近的山谷，从而“回想”起来。

在右边图的下方图表里，确认一下能量一次也没有上升过。论文写道，可以记住的模式数最多约为神经元数N的0.15倍。

E＝ −½ Σ_i≠j w_ij s_i s_j　　s_i ← 符号（Σ_j w_ij s_j）

s_i: 神经元i的值（+1或 −1）
w_ij: i与j的连接强度（双向相同）
E: 整体的能量

常见说法常见说法：联想记忆的网络是霍普菲尔德在1982年首次造出来的
原始资料里：他本人的论文也把甘利俊一（1977、1978）等列为先行研究。1972年，中野馨和甘利俊一就发表过相近的机制（第5章）。

每更新一个神经元后的能量

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

u08_hopfield_energy.py

# u08 ホップフィールドネットワーク：ニューロンを1つ更新するたびに、エネルギーは下がるか変わらない
#
# どの出来事か：1982年4月、物理学者ホップフィールドの論文（記録 hopfield_network_1982）。
#   多数の単純なニューロンを全結合し、記憶したパターンの一部から全体を想起するネットワークを、
#   磁石の性質を調べる物理学の考え方（全体がエネルギーの低い状態に落ち着く）で説明した。
#   論文では、ニューロン数 N の約 0.15 倍のパターンまで同時に記憶できると報告した。
#   1972年には中野馨と甘利俊一が近い仕組みを発表していた（5章の u05_associatron.py）。
# 仕組み：各ニューロンの値は +1 または −1。結合の強さは双方向で同じ（w[i][j] = w[j][i]、自分自身へは 0）。
#   ニューロンを1つ選び、周囲からの入力の合計の符号に合わせて更新する。
#   ネットワークのエネルギー E = −½ Σ w[i][j] s[i] s[j] は、
#   1回更新するたびに下がるか変わらない（上がることはない）。そのため、やがてエネルギーの谷底で停止する。
# 試してみよう：
#   - NOISE（反転させる割合）を 0.4 にしても、元に戻るか
#   - 下の「覚える数」の表で、N = 100 のネットワークが約 15 個を超えると想起できなくなっていく様子を見る

import random

random.seed(1982)
SIZE = 8
N = SIZE * SIZE
NOISE = 0.25

def pattern(rows):
    return [1 if c == "#" else -1 for r in rows for c in r]

PATS = [
    pattern(["...##...", "..###...", "...##...", "...##...", "...##...", "...##...", "...##...", "..####.."]),   # 1
    pattern(["########", "#......#", "#......#", "#......#", "#......#", "#......#", "#......#", "########"]),   # 口
    pattern(["#......#", ".#....#.", "..#..#..", "...##...", "...##...", "..#..#..", ".#....#.", "#......#"]),   # X
]

def learn(pats, n):
    w = [[0.0] * n for _ in range(n)]
    for p in pats:
        for i in range(n):
            for j in range(n):
                if i != j:
                    w[i][j] += p[i] * p[j] / n
    return w

def energy(w, s):
    n = len(s)
    return -0.5 * sum(w[i][j] * s[i] * s[j] for i in range(n) for j in range(n))

def show(s):
    return ["".join("■" if s[r * SIZE + c] > 0 else "・" for c in range(SIZE)) for r in range(SIZE)]

w = learn(PATS, N)
s = [(-v if random.random() < NOISE else v) for v in PATS[1]]
start = s[:]
print(f"「口」の {NOISE:.0%} にノイズを加えて開始。ニューロンを1つ更新するごとのエネルギー（下がるか変わらない）")
e_prev = energy(w, s)
history = [e_prev]
for sweep in range(3):
    changed = 0
    for i in random.sample(range(N), N):
        h = sum(w[i][j] * s[j] for j in range(N))
        new = 1 if h >= 0 else -1
        e = e_prev - (new - s[i]) * h      # 1つ更新したときのエネルギーの変化量（− 変化量 × 入力の合計）
        if new != s[i]:
            s[i] = new
            changed += 1
        assert e <= e_prev + 1e-9, "エネルギーが増加した？"
        e_prev = e
        history.append(e)
    assert abs(e_prev - energy(w, s)) < 1e-6   # 差分で更新した値と、定義式から再計算した値が一致するか確認
    print(f"  {sweep + 1} 回目（{N} 個を1つずつ）：状態が変わったニューロン {changed:2d} 個、エネルギー {e_prev:7.2f}")
    if changed == 0:
        break
for a, b in zip(show(start), show(s)):
    print(f"   {a}  →  {b}")
print("  元の「口」と一致：", s == PATS[1])

print("\n覚える数を増やすと（N = 100、ランダムなパターン、1割にノイズを加えて想起、各10回の平均）")
n = 100
for k in (5, 10, 15, 20, 30):
    ok = 0.0
    for _ in range(10):
        pats = [[random.choice((1, -1)) for _ in range(n)] for _ in range(k)]
        wk = learn(pats, n)
        x = [(-v if random.random() < 0.1 else v) for v in pats[0]]
        for _ in range(3):
            for i in random.sample(range(n), n):
                x[i] = 1 if sum(wk[i][j] * x[j] for j in range(n)) >= 0 else -1
        ok += sum(a == b for a, b in zip(x, pats[0])) / n
    print(f"  {k:2d} 個（{k / n:.2f}N）→ 値が正しいニューロン {ok / 10:.0%}  " + "█" * int(ok / 10 * 30))

051985・神经网络

靠概率行动的神经元

如果停在了很浅的山谷里，怎么办？

霍普菲尔德网络只能往下坡走。1985年，Ackley、辛顿、Sejnowski的玻尔兹曼机里，神经元是按概率选择开或关的，所以有时也能走上坡。决定随机程度的是温度 T。一点点降低温度，就更容易落到低能量的状态（与物理上的退火是同样的想法）。

在右边的图里，多按几次“退火（慢慢冷却）”和“骤冷”，比较到达最深山谷的次数。

论文还给出了训练含隐藏神经元的网络的规则。比较“数据固定”和“自由运行”两种情况下两个神经元同时处于开状态的概率，用二者之差来修正权重。起初计算很费时间，没怎么派上用场（诺贝尔奖委员会的解说，2024）。

P（开）＝1／（1＋e^−ΔE/T）　　Δw_ij ∝ p^＋_ij − p⁻_ij

ΔE: 变为开状态时下降的能量
T: 温度
p^＋・p⁻: 固定时、自由时同时处于开状态的概率

常见说法常见说法：含隐藏层的网络的学习是从1986年的反向传播开始的
原始资料里：1985年的玻尔兹曼机论文，已经给出了含隐藏神经元的网络的学习规则。

运行时的能量

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

u08_boltzmann.py

# u08 ボルツマンマシン：確率で動くニューロンと、温度を下げる「焼きなまし」、隠れ層のニューロンまで学習させる規則
#
# どの出来事か：1985 年、アクリー・ヒントン・セイノフスキーの論文（記録 boltzmann_machine_1985）。ニューロンは、周囲と
#   重みから決まる確率でオンかオフを選ぶ。温度（ランダムさの大きさ）を高い状態から少しずつ下げると、ネットワーク全体が
#   エネルギーの低い状態に落ち着きやすい（物理の焼きなましと同じ考え）。学習の規則は、訓練データを与えて見える層のニューロンを
#   固定した時と、自由に動かした時とで、接続された 2 つのニューロンが同時にオンになる確率を比べ、その差に比例して重みを更新する。
# 仕組み：
#   ① 12 個のニューロンによるネットワーク（重みはこのサイトがランダムに作った例）で、下り坂しか進まない動かし方（温度 0）と、焼きなましを比べる。
#      2 の 12 乗＝4096 通りの状態をすべて調べて、最も低いエネルギーを先に求めておく。
#   ② 見える層 3 個と、隠れ層 2 個の小さなネットワークに、「1 の数が偶数の模様だけが出る」という出方を学習させる。
#      ニューロンが少ないため、確率はランダムに動かさず全状態を数えて正確に計算する（実際のネットワークでは、動かして見積もる）。
# 試してみよう：
#   - STEPS（焼きなましの長さ）を短くすると、最も深い谷に到達する回数はどうなるか
#   - HIDDEN を 0 にすると、偶数のパターンだけを再現できるよう学習できるか

import itertools
import math
import random

random.seed(1985)

# ---------- ① 焼きなまし ----------
n = 12
net = random.Random(1984)          # ネットワークの重みを作る乱数（このサイトが作った例）
W = [[0.0] * n for _ in range(n)]
for i in range(n):
    for j in range(i + 1, n):
        W[i][j] = W[j][i] = net.gauss(0, 1)
B = [net.gauss(0, 0.5) for _ in range(n)]

def E(s):
    return -sum(W[i][j] * s[i] * s[j] for i in range(n) for j in range(i + 1, n)) - sum(B[i] * s[i] for i in range(n))

best = min(E(s) for s in itertools.product((0, 1), repeat=n))
STEPS = 3000

def run(anneal):
    s = [random.randint(0, 1) for _ in range(n)]
    for t in range(STEPS):
        T = 3.0 * (0.02 / 3.0) ** (t / STEPS) if anneal else 0.0
        i = random.randrange(n)
        gap = sum(W[i][j] * s[j] for j in range(n) if j != i) + B[i]   # オンになると下がるエネルギー
        if T == 0:
            s[i] = 1 if gap > 0 else 0
        else:
            s[i] = 1 if random.random() < 1 / (1 + math.exp(-gap / T)) else 0
    return E(s)

print(f"① 12 個のネットワーク。最も低いエネルギーは {best:.2f}（4096 通りをすべて調べた）")
for name, a in (("温度 0（下り坂だけ）", False), ("焼きなまし（温度 3 → 0.02）", True)):
    got = [run(a) for _ in range(40)]
    hit = sum(abs(g - best) < 1e-9 for g in got)
    print(f"  {name:16s} 40 回中 {hit:2d} 回 最も深い谷に到達した  " + "█" * hit)

# ---------- ② 隠れ層のニューロンまで学習させる ----------
V, HIDDEN = 3, 2
m = V + HIDDEN
DATA = {v: (0.25 if sum(v) % 2 == 0 else 0.0) for v in itertools.product((0, 1), repeat=V)}
w = [[0.0] * m for _ in range(m)]
for i in range(m):
    for j in range(i + 1, m):
        w[i][j] = w[j][i] = random.gauss(0, 1.0)
b = [0.0] * m
STATES = list(itertools.product((0, 1), repeat=m))

def probs():
    es = [math.exp(sum(w[i][j] * s[i] * s[j] for i in range(m) for j in range(i + 1, m)) + sum(b[i] * s[i] for i in range(m))) for s in STATES]
    z = sum(es)
    return [e / z for e in es]

def visible_dist(p):
    out = {v: 0.0 for v in DATA}
    for s, q in zip(STATES, p):
        out[s[:V]] += q
    return out

def show(title, p):
    d = visible_dist(p)
    print(title)
    for v, q in d.items():
        print(f"   {''.join(map(str, v))}  ネットワーク {q:5.1%}  データ {DATA[v]:4.0%}  " + "█" * int(q * 60))

show("\n② 学習前：見える層 3 個のパターンが現れる確率", probs())
RATE = 1.0
for step in range(1500):
    p = probs()
    # 自由に動かした時：全状態の確率から計算する
    free = [[sum(q * s[i] * s[j] for s, q in zip(STATES, p)) for j in range(m)] for i in range(m)]
    # 訓練データを与えて固定した時：見える層はデータ、隠れ層はそのデータのもとでの確率で計算する
    clamp = [[0.0] * m for _ in range(m)]
    for v, pv in DATA.items():
        if pv == 0:
            continue
        sub = [(s, q) for s, q in zip(STATES, p) if s[:V] == v]
        z = sum(q for _, q in sub)
        for s, q in sub:
            for i in range(m):
                for j in range(m):
                    clamp[i][j] += pv * (q / z) * s[i] * s[j]
    for i in range(m):
        for j in range(i + 1, m):
            d = RATE * (clamp[i][j] - free[i][j])      # 固定した時と自由に動かした時の、同時にオンになる確率の差
            w[i][j] += d
            w[j][i] += d
        b[i] += RATE * (clamp[i][i] - free[i][i])
show("\n学習後（1500 回更新）：偶数のパターンに確率が集まるか", probs())

061986・神经网络

只连接两层之间

同一层内部不连接，会省下什么麻烦？

1986年，在《并行分布式处理（PDP）》第1卷的第6章里，Smolensky提出了一种叫harmonium的神经网络。他把神经元分成可见层和隐藏层，连接只存在于层与层之间。他在脚注里还写道，这是玻尔兹曼机中（译）的特殊情形。今天称为受限玻尔兹曼机（RBM）。

由于同一层内部没有连接，只要一层确定了，另一层就可以同时一起算出来。右边图里的“1往复（向上、向下）”，就是各层同时更新一次。学习了条纹图案的网络，即使图像残缺了，来回几次也能复原。

2002年，辛顿发表了只来回一次就能学习的快速方法（对比散度法）（第9章）。

P（h_j＝1｜v）＝σ（b_j ＋Σ_i w_ij v_i）

v: 可见层
h: 隐藏层
σ: 把值变换到0〜1的函数
b: 偏置

常见说法常见说法：受限玻尔兹曼机是辛顿为2000年代的深度学习造出来的
原始资料里：辛顿本人在2002年的论文里写明，受限的类型是Smolensky（1986）提出的。2000年代的工作，是快速学习的方法，以及把它们叠起来造出深层网络的方法。

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

u08_rbm_cd.py

# u08 制限ボルツマンマシン（RBM）：結合を 2 つの層の間だけに制限し、層ごとに一括更新する
#
# どの出来事か：1986 年、書籍『並列分散処理（PDP）』第 1 巻第 6 章で、スモレンスキーが harmonium を提案した
#   （記録 rbm_harmonium_1986）。見える層と隠れ層の間だけを結合し、上の層全体を一度に、次に下の層全体を一度に更新する。
#   脚注で、ボルツマンマシンのうち結合が 2 つの層の間だけに制限された特別な場合、と説明した。
#   2002 年、ヒントンは 1 往復だけで学習させる高速な手法（対比発散、contrastive divergence）を提案した。このプログラムでは、
#   その 2002 年の手法を用いている（1986 年の章の手法そのものではない）。
# 仕組み：学習させるパターンは、3×3 マスの「縦じま・横じま」（このサイトが選んだ訓練パターン）。
#   ① 見える層 v から、隠れ層 h の各ユニットが 1 になる確率 σ(b + Σ w v) を一括で計算する
#   ② h から見える層を一括で再構成する（1 往復）
#   ③ 重みを「データでの v·h」−「1 往復した後の v·h」に比例して更新する
# 試してみよう：
#   - HIDDEN を 2 にすると、再構成はどれだけ悪くなるか
#   - 最後の「こわれた模様を直す」で、反転させるマスを増やしてみる

import math
import random

random.seed(1986)
VIS, HIDDEN, RATE, EPOCHS = 9, 8, 0.1, 1000

def sig(x):
    return 1 / (1 + math.exp(-x))

# 縦じま・横じま：3 本の列（または行）のうち、どれを黒にするかの組み合わせ（すべて白・すべて黒は 1 つずつ）
PATS = set()
for mask in range(8):
    cols = [(mask >> k) & 1 for k in range(3)]
    PATS.add(tuple(cols[c] for r in range(3) for c in range(3)))   # 縦じま
    PATS.add(tuple(cols[r] for r in range(3) for c in range(3)))   # 横じま
PATS = sorted(PATS)

w = [[random.gauss(0, 0.1) for _ in range(HIDDEN)] for _ in range(VIS)]
a = [0.0] * VIS      # 見える層のバイアス
b = [0.0] * HIDDEN   # 隠れ層のバイアス

def up(v):
    return [sig(b[j] + sum(w[i][j] * v[i] for i in range(VIS))) for j in range(HIDDEN)]

def down(h):
    return [sig(a[i] + sum(w[i][j] * h[j] for j in range(HIDDEN))) for i in range(VIS)]

def sample(p):
    return [1 if random.random() < q else 0 for q in p]

def recon_error():
    return sum(sum((x - y) ** 2 for x, y in zip(v, down(up(v)))) for v in PATS) / len(PATS)

print(f"訓練パターン {len(PATS)} 個（3×3 の縦じま・横じま）。1 往復で再構成したときの誤差（小さいほどよい）")
for ep in range(EPOCHS + 1):
    if ep in (0, 50, 100, 300, 1000):
        e = recon_error()
        print(f"  {ep:4d} 周目  誤差 {e:.3f}  " + "█" * int(e * 20))
    if ep == EPOCHS:
        break
    for v in PATS:
        ph0 = up(v)
        h0 = sample(ph0)
        v1 = down(h0)           # 見える層を一括で再構成する（確率値のまま使う）
        ph1 = up(v1)
        for i in range(VIS):
            for j in range(HIDDEN):
                w[i][j] += RATE * (v[i] * ph0[j] - v1[i] * ph1[j])
        for i in range(VIS):
            a[i] += RATE * (v[i] - v1[i])
        for j in range(HIDDEN):
            b[j] += RATE * (ph0[j] - ph1[j])

def show(v):
    return ["".join("■" if v[r * 3 + c] > 0.5 else "・" for c in range(3)) for r in range(3)]

print("\nこわれた模様を直す（1 マスを反対にして、上下を 5 往復）")
for target in (PATS[3], PATS[10]):
    broken = list(target)
    k = random.randrange(VIS)
    broken[k] = 1 - broken[k]
    v = broken[:]
    for _ in range(5):
        v = down(up(v))
    for x, y, z in zip(show(broken), show(v), show(target)):
        print(f"   {x}  →  {y}    元 {z}")
    print()

071967〜1986・学习方式

沿着误差的坡往下走

参数很多的网络，怎样一点一点地改进？

学习型机器的误差，权重一确定就是一个数。把权重取成横轴和纵轴，就形成有山有谷的地形。梯度下降是朝着下降最陡的方向（梯度的反方向）一点一点前进，从而减小误差的方法。

在右边的地形上点一下放下小球，看它往下滚。一步（学习率η）太大会跳过山谷，再大就会飞到外面去。选择“每个例子更新一次”来计算时，前进的路线会摇摆不定，但每一步的计算很轻（随机梯度下降）。

1967年，甘利俊一在理论上研究了每看一个例子就一点点更新权重的学习方法，并在1968年的日语解说里称之为“随机下降法”。1986年的反向传播，也用到这种沿坡下降的想法。

w ← w − η ∂L／ ∂w

L: 误差的大小
∂L／ ∂w: 稍微移动w时L的变化（梯度）
η: 学习率

常见说法常见说法：训练隐藏层的方法是从1986年的反向传播开始的
原始资料里：甘利本人（2025）和京都奖的介绍都说，1967年的理论，就是连隐藏层也包括在内、用梯度来训练的想法。1967年那篇论文的正文，本站尚未确认。

更新次数与误差的大小（纵轴每格为10倍）

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

u08_gradient_descent.py

# u08 勾配降下法：誤差の坂を少しずつ下る（全データで1歩／データ1件ごとに1歩）
#
# どの出来事か：1967年、甘利俊一の論文「適応的なパターン分類器の理論」と、1968年の日本語の解説で、データを1件見るたびに、
#   誤差に応じて重みを少しずつ修正する学習法を「確率的降下法」と呼んだ（記録 amari_adaptive_classifier_1967）。
#   1986年の誤差逆伝播法（記録 backprop_nature_1986）も、多層ニューラルネットワークでこの坂を下る考え方を使う。
# 仕組み：点の並び（このサイトが作った例 20 個）に、直線 y = a·x + b を当てはめる。誤差の大きさ
#   L = 平均（予測 − 正解）² は、a と b を決めると1つの値に決まる。a を少し動かした時の L の変わり方（勾配）を計算し、
#   その反対の向きへ η（学習率）だけ進む。
#   ① 全データで勾配を計算して1歩進む（勾配降下法）　② データを1件選んで、その勾配で1歩進む（確率的勾配降下法）
# 試してみよう：
#   - ETA を 0.01・0.9・1.2 に変えて、ゆっくり下る・振動しながら下る・発散する様子を見る（a と b を毎歩 print するとよく分かる）
#   - ②の1歩は、①の1歩より計算量が20分の1で済む。同じ計算量で比べるとどうなるか

import random

random.seed(1967)
XS = [i / 19 * 2 - 1 for i in range(20)]
DATA = [(x, 1.5 * x + 0.5 + random.gauss(0, 0.2)) for x in XS]   # 正解は a=1.5, b=0.5 付近（このサイトが作った例）
ETA = 0.3

def loss(a, b, data=DATA):
    return sum((a * x + b - y) ** 2 for x, y in data) / len(data)

def grad(a, b, data):
    n = len(data)
    ga = sum(2 * (a * x + b - y) * x for x, y in data) / n
    gb = sum(2 * (a * x + b - y) for x, y in data) / n
    return ga, gb

def bar(v):
    return "█" * min(50, int(v * 10))

print(f"① 全データで1歩（ETA = {ETA}）")
a, b = -1.0, -1.0
for step in range(31):
    if step in (0, 1, 2, 5, 10, 20, 30):
        print(f"  {step:3d} 歩  a={a:6.3f} b={b:6.3f}  L={loss(a, b):.4f} {bar(loss(a, b))}")
    ga, gb = grad(a, b, DATA)
    a, b = a - ETA * ga, b - ETA * gb

print(f"\n② データ1件ごとに1歩（ETA = {ETA / 3:.2f}。同じ計算量＝データを600回見る）")
a, b = -1.0, -1.0
for step in range(601):
    if step in (0, 20, 60, 200, 600):
        print(f"  {step:3d} 歩  a={a:6.3f} b={b:6.3f}  L={loss(a, b):.4f} {bar(loss(a, b))}")
    ga, gb = grad(a, b, [random.choice(DATA)])
    a, b = a - ETA / 3 * ga, b - ETA / 3 * gb

print("\n学習率 ETA を変えて、①を30歩（最後の L）")
for eta in (0.01, 0.1, 0.5, 0.9, 1.2):
    a, b = -1.0, -1.0
    for _ in range(30):
        ga, gb = grad(a, b, DATA)
        a, b = a - eta * ga, b - eta * gb
    L = loss(a, b)
    print(f"  ETA={eta:4.2f} → L={L:12.4f}  " + ("発散した" if L > 10 else bar(L)))

081986・神经网络

把误差，从后往前传

隐藏层的权重，该怎样修正？

1986年10月，鲁梅尔哈特（Rumelhart）、辛顿、威廉姆斯（Williams）在Nature上的论文里，给出了输入与输出之间有隐藏层的神经网络的学习方法。把输出的误差，从输出一侧向输入一侧依次传回去，把误差分配给隐藏层的神经元，一点一点修正权重（反向传播）。

第5章里单层感知机学不会的XOR，让右边图里的网络来学一学。隐藏层的每个神经元各画一条不同的边界线（虚线），在线与线之间对XOR进行分类。把隐藏层的神经元减到1个，就学不会了。

论文自己就写道：（译）。

δ_输出＝（y − t）y（1 − y）　　δ_j ＝δ_输出 w_j h_j（1 − h_j）

y・t: 输出值与正确答案
h_j・w_j: 隐藏层神经元j的值与通向输出的权重
δ: 分配到的误差

常见说法常见说法：反向传播是辛顿发明的
原始资料里：论文自己就写道，别人也独立发现过。诺贝尔奖委员会的解说（2024）也称之为，并认为重要的是证明了：含隐藏层的网络，能解决没有这一层就解决不了的课题。

每次训练后的误差大小

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

u08_backprop_xor.py

# u08 隠れ層と誤差逆伝播法（「うしろから直す」学習法）で、XOR が解ける
#
# どの出来事か：1986 年 10 月、ラメルハート、ヒントン、ウィリアムズの Nature 論文（記録 backprop_nature_1986）。
#   出力と正解の誤差を、出力層から入力層へ逆向きに伝えながら、重みを少しずつ修正する
#   （誤差逆伝播法、バックプロパゲーション）。隠れ層が、教えていない特徴を自ら表現するようになった。
#   論文自身が、他にも発見者がいたと記している。日本では甘利俊一が 1967 年に、誤差から少しずつ
#   重みを修正する学習法（確率的降下法）を理論化していた（記録 amari_adaptive_classifier_1967）。
# 仕組み：入力 2 → 隠れ層 HIDDEN 個 → 出力 1。u05 で単層では学習できなかった XOR を学習する。
# 試してみよう：
#   - HIDDEN を 1 にすると学習できるか（隠れ層が狭すぎると、u05 と同じ壁に当たる）
#   - RATE（1 回の更新量）を 0.05 や 5 にすると、学習の進み方はどう変わるか

import math
import random

random.seed(1986)
HIDDEN = 3
RATE = 0.8
EPOCHS = 4000
DATA = [((0, 0), 0), ((0, 1), 1), ((1, 0), 1), ((1, 1), 0)]

def sig(x):
    return 1 / (1 + math.exp(-x))

# 重み：w1[h] = (入力 1 から, 入力 2 から, バイアス)、w2 = (隠れ層 1..H から, バイアス)
w1 = [[random.uniform(-1, 1) for _ in range(3)] for _ in range(HIDDEN)]
w2 = [random.uniform(-1, 1) for _ in range(HIDDEN + 1)]

def forward(x):
    h = [sig(w[0] * x[0] + w[1] * x[1] + w[2]) for w in w1]
    y = sig(sum(w2[i] * h[i] for i in range(HIDDEN)) + w2[HIDDEN])
    return h, y

for epoch in range(EPOCHS + 1):
    loss = 0.0
    for x, t in DATA:
        h, y = forward(x)
        loss += (y - t) ** 2
        # 出力の誤差 → 出力層の重みの更新量
        dy = (y - t) * y * (1 - y)
        # 誤差を、隠れ層へ「うしろから」伝える
        dh = [dy * w2[i] * h[i] * (1 - h[i]) for i in range(HIDDEN)]
        for i in range(HIDDEN):
            w2[i] -= RATE * dy * h[i]
        w2[HIDDEN] -= RATE * dy
        for i in range(HIDDEN):
            w1[i][0] -= RATE * dh[i] * x[0]
            w1[i][1] -= RATE * dh[i] * x[1]
            w1[i][2] -= RATE * dh[i]
    if epoch in (0, 100, 500, 1000, 2000, 4000):
        print(f"{epoch:5d} 周目：誤差の大きさ（2 乗の合計）{loss:.4f}")

print("\n学習後の出力（0.5 より大きければ 1）")
for x, t in DATA:
    h, y = forward(x)
    print(f"  {x} → {y:.3f}（正解 {t}）  隠れ層の値 {[round(v, 2) for v in h]}")

091985〜1987・神经网络

把8个压缩成3个

不另外准备正确答案，能让网络自己造出编码吗？

让中间一层很细的网络学习“输出和输入一样的东西”这个课题。8个输入中只有1个是1的模式，经过3个隐藏神经元，映射到同样的8个输出。网络对这8种模式，只能自己分配出一组3个值（编码）。

这个课题在1985年的玻尔兹曼机论文里，是作为编码问题（encoder problem）出现的，1986年那本书的反向传播一章里也训练过。据该章所述，隐藏神经元不只用0和1，也用到了中间的值。在右边的图里，看8种模式在立方体的不同位置散开的样子。

1987年，Ballard提出了把这种网络叠起来的方法。现在称为自编码器（autoencoder）。

编码z＝σ（W₁x）　　输出y＝σ（W₂z）　　复原误差＝Σ（y − x）²

x・z: 输入（8个）・隐藏层（3个）
W₁・W₂: 前半部分（编码器）・后半部分（解码器）的权重

常见说法常见说法：自编码器是辛顿在2006年开创的
原始资料里：1985〜1987年就已经有了。2006年那篇Science论文也写道，深层自编码器效果很好这一点（译）。

每次学习迭代后的复原误差

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

u08_autoencoder_838.py

# u08 オートエンコーダーの原点：8 つのパターンを、3 つのニューロンに圧縮して、復元する（8−3−8 の符号化問題）
#
# どの出来事か：1985 年のボルツマンマシンの論文の encoder problem（符号化問題）と、1986 年の誤差逆伝播法の本の章
#   （記録 autoencoder_origins_1986、boltzmann_machine_1985）。章では、8 個の入力を 3 個の隠れ層のニューロンを通して同じ 8 個の出力に
#   写す課題を学習させると、隠れ層のニューロンが 8 つの入力それぞれに別々の値の組み合わせ（符号）を割り当てた。0 と 1 だけでなく中間の値も使った。
#   1987 年にバラードは、入力と同じものを出力させるネットワークを部品にして、積み重ねる方法を提案した。
# 仕組み：入力は 8 個のうち 1 つだけが 1 のパターン（8 通り）。真ん中の 3 個を通して、同じパターンを出力させる。
#   正解は入力そのものなので、人が別に正解を用意しなくてよい。学習には誤差逆伝播法を使う（u08_backprop_xor.py と同じ）。
# 試してみよう：
#   - HIDDEN を 2 にすると、8 つを識別できるか（中間の値を使えば、できることがある）
#   - 学習後の「符号」の表で、0 と 1 だけの 3 桁の数（2 進数）になっているかを見る

import math
import random

random.seed(1985)
N, HIDDEN, RATE, EPOCHS = 8, 3, 1.5, 3000
X = [[1 if i == k else 0 for i in range(N)] for k in range(N)]

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

W1 = [[random.uniform(-0.5, 0.5) for _ in range(N + 1)] for _ in range(HIDDEN)]   # 前半（エンコーダー）＋バイアス
W2 = [[random.uniform(-0.5, 0.5) for _ in range(HIDDEN + 1)] for _ in range(N)]   # 後半（デコーダー）＋バイアス

def forward(x):
    z = [sig(sum(w[i] * x[i] for i in range(N)) + w[N]) for w in W1]
    y = [sig(sum(w[j] * z[j] for j in range(HIDDEN)) + w[HIDDEN]) for w in W2]
    return z, y

for ep in range(EPOCHS + 1):
    total = 0.0
    for x in X:
        z, y = forward(x)
        total += sum((yi - xi) ** 2 for yi, xi in zip(y, x))
        dy = [(y[i] - x[i]) * y[i] * (1 - y[i]) for i in range(N)]
        dz = [sum(dy[i] * W2[i][j] for i in range(N)) * z[j] * (1 - z[j]) for j in range(HIDDEN)]
        for i in range(N):
            for j in range(HIDDEN):
                W2[i][j] -= RATE * dy[i] * z[j]
            W2[i][HIDDEN] -= RATE * dy[i]
        for j in range(HIDDEN):
            for i in range(N):
                W1[j][i] -= RATE * dz[j] * x[i]
            W1[j][N] -= RATE * dz[j]
    if ep in (0, 300, 1000, 2000, 3000):
        print(f"{ep:5d} 周目  復元の誤差（2 乗の合計）{total:7.3f}  " + "█" * int(total * 4))

print("\n学習後：入力 → 隠れ層の 3 個（符号）→ 出力で最大の位置")
ok = 0
for k, x in enumerate(X):
    z, y = forward(x)
    best = max(range(N), key=lambda i: y[i])
    ok += best == k
    print(f"  {''.join(map(str, x))} → 符号 ({', '.join(f'{v:.2f}' for v in z)}) → {best + 1} 番目が 1 {'○' if best == k else '×'}")
print(f"8 つのうち {ok} つを、隠れ層の {HIDDEN} 個だけから復元できた")

101986〜1990・神经网络

把前一刻的自己放进来

依次到来的字符，网络是怎样记住的？

1990年，Elman给3层神经网络加了上下文单元。把隐藏层的值原样复制到上下文单元，在下一个时刻与输入一起放进去（循环网络，RNN）。复制用的连接，权重固定为1。

让网络在没有写明间隔的字符序列里预测下一个字符，预测误差在单词开头时大，单词往后进行就变小。并没有教过它，单词的分界却浮现出来了。右边的图是本站做的、排列了5个单词的例子。只有紫色的柱（第1个字符）一直很高。

Elman自己写道，这个想法始于Jordan 1986年的报告。

h_t ＝tanh（W x_t ＋U h_t−1）

x_t: 时刻t的字符
h_t−1: 前一时刻的隐藏层
U: 来自上下文单元的连接

常见说法常见说法：RNN是Elman在1990年发明的
原始资料里：Elman的论文本身就说，这是Jordan（1986）最先写下的想法，并列举了先行的例子。诺贝尔奖委员会的解说还写道，霍普菲尔德网络也是循环的。

单词的第几个字符与预测误差的平均

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

u08_elman_srn.py

# u08 エルマンの再帰型ニューラルネットワーク：1 つ前の状態を入力に戻し、次の文字を予測する。予測誤差の山が単語の切れ目になる
#
# どの出来事か：1990 年、エルマンの論文（記録 elman_simple_recurrent_network_1990）。通常の 3 層ニューラルネットワークに文脈ユニットを追加した。
#   各時刻の隠れ層の値をそのまま文脈ユニットにコピーし（コピーする結合は重み 1 で固定、学習しない）、次の時刻に入力と一緒に与える。
#   区切りの書いていない文字の並びで次の文字を予測させると、誤差は単語の始まりで大きく、単語が進むと小さくなった。
#   エルマンは、この考えがジョーダンの 1986 年の報告に始まると書いている。
# 仕組み：このサイトが作った 5 つの単語（ローマ字）を、ランダムな順序で区切りなしに並べる。文字を 1 つずつ入力して次の文字を予測させ、
#   誤差逆伝播法で 1 ステップ分だけ重みを更新する（文脈ユニットは、通常の入力として扱う。エルマンの論文と同じ考え方）。
#   学習後、単語の中の何文字目かごとに、予測誤差の平均を計算する。
# 試してみよう：
#   - WORDS に単語を足すと、単語の 1 文字めの予測誤差はどうなるか
#   - CONTEXT を False にして（1 つ前の隠れ層の値を入れない）、2 文字めより後も予測できるか

import math
import random

random.seed(1990)
WORDS = ["neko", "inu", "sakana", "tori", "kuma"]
CONTEXT = True
LETTERS = sorted(set("".join(WORDS)))
L, H, RATE = len(LETTERS), 16, 0.1

def stream(n_words):
    seq, pos = [], []
    for _ in range(n_words):
        w = random.choice(WORDS)
        for k, ch in enumerate(w):
            seq.append(LETTERS.index(ch))
            pos.append(k)
    return seq, pos

def softmax(z):
    m = max(z)
    e = [math.exp(v - m) for v in z]
    s = sum(e)
    return [v / s for v in e]

Wx = [[random.gauss(0, 0.3) for _ in range(L)] for _ in range(H)]
Wc = [[random.gauss(0, 0.3) for _ in range(H)] for _ in range(H)]
bh = [0.0] * H
Wy = [[random.gauss(0, 0.3) for _ in range(H)] for _ in range(L)]
by = [0.0] * L

def step(x, ctx):
    h = [math.tanh(Wx[j][x] + (sum(Wc[j][k] * ctx[k] for k in range(H)) if CONTEXT else 0) + bh[j]) for j in range(H)]
    p = softmax([sum(Wy[i][j] * h[j] for j in range(H)) + by[i] for i in range(L)])
    return h, p

def train(seq):
    ctx = [0.0] * H
    for t in range(len(seq) - 1):
        x, y = seq[t], seq[t + 1]
        h, p = step(x, ctx)
        dz = [p[i] - (1 if i == y else 0) for i in range(L)]
        dh = [sum(dz[i] * Wy[i][j] for i in range(L)) * (1 - h[j] ** 2) for j in range(H)]
        for i in range(L):
            for j in range(H):
                Wy[i][j] -= RATE * dz[i] * h[j]
            by[i] -= RATE * dz[i]
        for j in range(H):
            Wx[j][x] -= RATE * dh[j]
            bh[j] -= RATE * dh[j]
            if CONTEXT:
                for k in range(H):
                    Wc[j][k] -= RATE * dh[j] * ctx[k]
        ctx = h      # 隠れ層の値を、そのまま文脈ユニットにコピーする

def errors(seq, pos):
    ctx, by_pos, shown = [0.0] * H, {}, []
    for t in range(len(seq) - 1):
        h, p = step(seq[t], ctx)
        err = 1 - p[seq[t + 1]]          # 予測誤差（次の文字の確率が低いほど大きい）
        by_pos.setdefault(pos[t + 1], []).append(err)
        shown.append((LETTERS[seq[t + 1]], err))
        ctx = h
    return by_pos, shown

for rnd in range(10):
    s, _ = stream(300)
    train(s)
test, tpos = stream(60)
by_pos, shown = errors(test, tpos)
print("単語の中の何文字目か → 予測誤差の平均（1 に近いほど、予測できない）")
for k in sorted(by_pos):
    e = sum(by_pos[k]) / len(by_pos[k])
    print(f"  {k + 1} 文字目  {e:.2f}  " + "█" * int(e * 40))
print("\n並びの一部（下の段の棒の高さが予測誤差。単語の始まりで高くなる）")
BARS = " ▁▂▃▄▅▆▇█"
for a in range(0, 72, 36):
    part = shown[a:a + 36]
    print("  文字    " + "".join(ch for ch, _ in part))
    print("  誤差    " + "".join(BARS[min(8, int(e * 9))] for _, e in part))

111989・卷积

把同一个窗口反复使用

怎样造出连位置稍有偏移的手写数字也能读的神经网络？

1989年，贝尔实验室的杨立昆（LeCun）等7人，用美国信封上手写的邮政编码数字9,298个，训练了一个识别数字的神经网络。关键在于，把同一个5×5的小窗口（寻找特征的滤波器），在图像的各个位置反复使用（用今天的话说就是卷积）。

在右边的图里选一个窗口，再把数字挪一挪。窗口与形状吻合的地方会有反应，有反应的位置也会跟着一起移动。由于窗口反复使用，需要学习的权重数大幅减少（右上方的数）。

在2,007个测试数据上，错误率为5.0%。论文只引用了一处福岛邦彦1980年的论文（新认知机）。

特征图（x, y）＝Σ_i,j k（i, j）× 图像（x＋i, y＋j）

k: 窗口（5×5的权重。在任何位置都相同）

常见说法常见说法：图像识别的深度学习（卷积）诞生在美国
原始资料里：杨立昆等人自己在1998年就写道：（译）。区别在于，新认知机没有训练整个网络的方法（反向传播）。

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

u08_convolution_shift.py

# u08 同じ「小さな窓」を滑らせる：位置がずれても形を検出できる（畳み込み）
#
# どの出来事か：1979 年、NHK の研究所の福島邦彦によるネオコグニトロン（記録 fukushima_neocognitron_1979）。
#   同じ面の細胞は、同じ結合を位置だけずらして持つ（S 細胞）。位置のずれを吸収する層（C 細胞）を重ねる。
#   1989 年、ベル研究所のルカンたちは、同じ 5×5 の窓を画像の各部で共有して、郵便番号の手書き数字を
#   認識した（記録 lecun_zipcode_cnn_1989。論文は福島 1980 を引いている）。
# 仕組み：3×3 の「角」の窓を、画像上のすべての位置に当てて、一致度のマップを作る（畳み込み）。
#   次に 2×2 ごとに最大値だけを残す（ずれを吸収する。今でいう「プーリング」）。
# 試してみよう：
#   - IMG の中の # の形の位置を動かしても、最後の「見つかった」が変わらないか
#   - KERNEL を縦線の形に変える

IMG = [
    "..........",
    "..........",
    "..###.....",
    "..#.......",
    "..#.......",
    "..........",
    "......###.",
    "......#...",
    "......#...",
    "..........",
]
KERNEL = [   # 窓（フィルター）：左上の角（「┌」の形）
    "###",
    "#..",
    "#..",
]

def grid(rows):
    return [[1 if c == "#" else -1 for c in r] for r in rows]

img, ker = grid(IMG), grid(KERNEL)
H, W, K = len(img), len(img[0]), len(ker)

# 畳み込み：窓を 1 マスずつずらしながら、掛け算して足し合わせる（完全に一致すると 9）
fmap = [[sum(img[y + i][x + j] * ker[i][j] for i in range(K) for j in range(K)) for x in range(W - K + 1)] for y in range(H - K + 1)]
print("窓を当てた一致度のマップ（9 が満点）")
for row in fmap:
    print("   " + " ".join(f"{v:2d}" for v in row))

# 2×2 ごとに最大値を残す（位置のずれの影響を少し減らす）
pooled = [[max(fmap[y][x], fmap[y][x + 1], fmap[y + 1][x], fmap[y + 1][x + 1]) for x in range(0, len(fmap[0]) - 1, 2)] for y in range(0, len(fmap) - 1, 2)]
print("2×2 ごとに最大値を残したマップ")
for row in pooled:
    print("   " + " ".join(f"{v:2d}" for v in row))
found = [(y, x) for y, row in enumerate(fmap) for x, v in enumerate(row) if v == 9]
print(f"角が見つかった場所（窓の左上の位置）：{found}。同じ窓 1 つで、異なる 2 か所の角を検出した")

121989〜1998・卷积

没把握的字符交给人

错5%的机器，在银行里不能用吗？

1989年读邮政编码的网络，在测试数据上错了5.0%。论文还指出，要把错误率压到1%，必须把12.1%当作“读不出”剔除掉。把答案把握较低的交给人，机器作答的那部分里的错误就会减少。在右边的图里，拖动剔除线θ看看。

1998年，杨立昆等人汇总了7层的卷积神经网络LeNet-5和支票读取系统。这个系统被装进NCR公司的支票读取机，在美国的一些银行里使用。在这篇论文用的手写数字数据集MNIST（训练数据6万、测试数据1万）上，错误率为0.95%。

剔除比例＝把握＜θ的数 ÷ 全部的数

θ: 作为剔除标准的线
把握: 输出值中最大的那一个

图里把握的分布，是本站为了接近1989年论文中的2个点而做的例子。

常见说法常见说法：深度学习是从2012年开始派上用场的
原始资料里：1990年代后半，卷积神经网络就已经在银行里读支票，做着实际的工作。

剔除比例与作答部分中的错误率

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

u08_reject_curve.py

# u08 自信のない文字は人に回す：棄却率と残りの誤り率のトレードオフ
#
# どの出来事か：1989年、ベル研究所のルカンたちによる郵便番号認識ネットワーク（記録 lecun_zipcode_cnn_1989）。テストデータ 2,007 個での
#   誤り率は 5.0%（102 個）。論文では、誤り率を 1% に抑えるには 12.1% を「読めない」として棄却（除外）する必要があると報告された。
#   1998年の LeNet-5 は NCR 社の小切手読み取り機に組み込まれ、アメリカの複数の銀行で実用化された（記録 lenet5_check_reading_1998）。
# 仕組み：ネットワークの予測には確信度（出力層の最大値）が付いている。確信度がしきい値 θ より低いものは判定せずに人に回す。
#   θ を上げると棄却する割合が増え、判定した文字の誤り率は下がる。
#   ※ ここでの確信度の分布は、論文の2点（棄却なしで 5.0%、12.1% 棄却で 1%）を通るように、このサイトが作った例。
#     実際のネットワークの確信度の値ではない。
# 試してみよう：
#   - 誤り 1 個のコストを 10、人が 1 枚確認するコストを 1 として、総コストが最も小さくなる θ を探す（最後の表）
#   - COST_ERROR を 100 にすると、最適な θ はどう変化するか

N_TEST, N_WRONG = 2007, 102
COST_ERROR, COST_HUMAN = 10, 1

def spread(n, k):
    # 0.5〜1 の確信度を特定の分布で n 個並べる（k が大きいほど 1 の近くに集中する）
    return [1 - 0.5 * ((i + 0.5) / n) ** k for i in range(n)]

right = spread(N_TEST - N_WRONG, 10.2)   # 正解した文字の確信度（作った例）
wrong = spread(N_WRONG, 0.5)            # 誤った文字の確信度（作った例）
items = sorted([(c, True) for c in right] + [(c, False) for c in wrong])

def at(theta):
    kept = [ok for c, ok in items if c >= theta]
    rej = 1 - len(kept) / len(items)
    err = (kept.count(False) / len(kept)) if kept else 0.0
    return rej, err, len(items) - len(kept), kept.count(False)

print(" θ      除外率    判定した中の誤り率")
for theta in (0.0, 0.6, 0.7, 0.8, 0.85, 0.9, 0.95):
    rej, err, nr, nw = at(theta)
    print(f" {theta:4.2f}   {rej:6.1%}    {err:5.2%}  " + "█" * int(err * 400))

# 誤り率が 1% 以下になる最小の除外率
for k in range(len(items)):
    kept = items[k:]
    if sum(1 for _, ok in kept if not ok) / len(kept) <= 0.01:
        print(f"\n誤り率を 1% 以下にするには {k / len(items):.1%} を除外する（論文は 12.1%）")
        break

print(f"\nコストの合計（誤り 1 個 = {COST_ERROR}、人が 1 枚確認 = {COST_HUMAN}）")
best = None
for i in range(0, 100, 5):
    theta = 0.5 + i / 200
    rej, err, nr, nw = at(theta)
    cost = nw * COST_ERROR + nr * COST_HUMAN
    if best is None or cost < best[0]:
        best = (cost, theta)
    if i % 10 == 0:
        print(f"  θ={theta:4.2f}  人に回す {nr:4d} 枚・誤り {nw:3d} 個 → コスト {cost:5d}")
print(f"最もコストが小さい θ は {best[1]:.3f}（コスト {best[0]}）")

131990・机器翻译

从对译中计算概率

不写词典也不写语法，能收集到翻译的线索吗？

1990年6月，IBM的Brown、Jelinek等8人发表了把翻译当作概率计算来处理的方法。他们用的材料，是同时以英语和法语两种语言记录的加拿大议会记录（英语约1亿词）。

虽然有成对的译文句子，但并没有写明哪个单词是哪个的译词。于是论文采用了语音识别中用过的EM算法。一开始，假定任何单词译成任何单词的概率都相同，再根据这个概率重新计数，把这样的计算反复进行。在右边的图里按一下“重复1次”看看（句子对是本站做的例子）。

论文从4万对句子里估算了约8,100万个数，并写道，the自动地与le、la联系起来，not也自动地与pas联系起来。73个新句子的翻译里，一字不差的占5%，通顺的译文占48%。

份额＝t（f｜e）÷ Σ_e′ t（f｜e′）

t（f | e）: 英语的e被译成法语的f的概率
e′: 同一句子对里的所有英语单词

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

u08_em_alignment.py

# u08 文法規則を書かずに、対訳文から「どの単語がどの単語の訳か」の確率を学習する（EM アルゴリズムの簡易版）
#
# どの出来事か：1990 年 6 月、IBM のブラウン、ジェリネックたち 8 人の論文（記録 ibm_statistical_mt_1990）。翻訳を確率の計算として扱い、
#   カナダ議会の記録（英語とフランス語の両方で記録）から、4 万組の文で約 8,100 万個の数値を推定した。
#   文の対応はあっても単語ごとの対応は書かれていないため、音声認識で使われていた EM アルゴリズムを翻訳に応用した。
#   初めは、どのフランス語の単語も、どの英語の単語の訳である確率も同じと仮定した。論文によると、英語の the はフランス語の
#   le や la に、not は pas に、自動で結びついた。
# 仕組み（論文を簡単にした形）：
#   ① 翻訳確率 t(f|e)（英語 e がフランス語 f に訳される確率）を、初めはすべて均等にする
#   ② 文のペアごとに、f の相手が e である「分け前」＝ t(f|e) ÷（同じ文の英語の単語全体の t(f|e′) の合計）を求めて集計する
#   ③ 集計した分け前を e ごとに合計が 1 になるように正規化し、新しい t(f|e) に更新する。②③を繰り返す
#   ※ 1990 年の論文は、1 つの単語が何語に訳されるかや、並ぶ位置の確率も計算している。ここでは単語の翻訳確率だけを扱う。
#   ※ 文の組は、このサイトが作った例（4 組）。
# 試してみよう：
#   - PAIRS に ("une fleur", "a flower") を足すと、a の訳は何になるか
#   - ROUNDS を 1 にすると、まだどれくらい確率が定まっていないか

PAIRS = [
    ("la maison", "the house"),
    ("la maison bleue", "the blue house"),
    ("la fleur", "the flower"),
    ("la fleur bleue", "the blue flower"),
]
ROUNDS = 10

pairs = [(f.split(), e.split()) for f, e in PAIRS]
F = sorted({w for f, _ in pairs for w in f})
E = sorted({w for _, e in pairs for w in e})
t = {(f, e): 1 / len(F) for f in F for e in E}      # ① 初めはすべて均等

def show(title):
    print(title)
    for e in E:
        row = sorted(((t[(f, e)], f) for f in F), reverse=True)
        print(f"  {e:7s} → " + "  ".join(f"{f} {p:.2f}" for p, f in row[:3]))

show("繰り返す前（どれも均等な確率）")
for r in range(1, ROUNDS + 1):
    count = {k: 0.0 for k in t}
    total = {e: 0.0 for e in E}
    for fs, es in pairs:
        for f in fs:
            z = sum(t[(f, e)] for e in es)
            for e in es:
                share = t[(f, e)] / z            # ② f の相手が e である分け前
                count[(f, e)] += share
                total[e] += share
    t = {(f, e): count[(f, e)] / total[e] for f, e in t}   # ③ e ごとに合計が 1 になるよう正規化する
    if r in (1, 3, ROUNDS):
        show(f"\n{r} 回繰り返した後（確率の高い順に 3 つ）")

141991・神经网络

把工作分给各位专家

让一个神经网络学习各种各样的工作，会怎么样？

让一个网络学习各种各样的工作时，它们会互相干扰，学习变慢。1991年，Jacobs、Jordan、Nowlan、辛顿针对这个问题，把多个专家网络，与给出“交给哪位专家”概率的门控网络组合到了一起。

由于把误差的衡量方式改成了竞争而不是协作，每位专家只负责输入数据的一部分。右边的图，是让两位只能画直线的专家，去学习左右形状不同的点阵。下方的色带表示门控。

2017年，还出现了从成千上万位专家中只挑选前几位的大规模机制（第11章）。

y＝Σ_k g_k y_k　　g_k ＝e^s_k ／Σ_m e^s_m

y_k: 专家k的输出
g_k: 门控交给k的概率（总和为1）

常见说法常见说法：专家混合（MoE）是为这几年的大语言AI（LLM）想出的新办法
原始资料里：基本想法在1991年的论文里就有了。2017年的论文自己也写道，这种方法（译）已有很多研究。

每次迭代的误差平均

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

u08_mixture_experts.py

# u08 専門家の混合（MoE）：複数の専門家ネットワークと、割り当てを決めるゲートネットワーク
#
# どの出来事か：1991 年、ジェイコブス、ジョーダン、ナウラン、ヒントンの論文『Adaptive Mixtures of Local Experts』
#   （記録 mixture_of_experts_1991）。1 つのネットワークに多様な課題をまとめて学習させると、干渉し合って学習が遅くなる。
#   そこで複数の専門家ネットワークを用意した。入力に応じてどの専門家に任せるかの確率を出力するゲートネットワーク
#   （出力はソフトマックス関数：総和が 1）と組み合わせた。誤差の計算を協力型ではなく競争型にしたため、
#   各専門家が入力データの一部分だけを分担して学習するようになった。
#   2017 年には、数千の専門家から上位の一部だけを選ぶ大規模なモデルも開発された。
# 仕組み：左右で形が違う点の並び（このサイトが作った例）を、直線しか引けない 2 人の専門家に学習させる。
#   ① 競争する形：誤差 ＝ −log Σ g_k exp(−(y − y_k)²／2)。最も予測が近い専門家が、その点を「引き受ける」
#   ② 協力する形：誤差 ＝（y − Σ g_k y_k）²／2。全員の出力を混ぜたものの誤差だけを見る
# 試してみよう：
#   - EXPERTS を 3 にすると、3 人目は何を担当するか
#   - 協力する形と競争する形で、ゲートの確率がどれだけ明確に 0 と 1 に分かれるかを比べる

import math
import random

EXPERTS, RATE, EPOCHS = 2, 0.05, 400

def target(x):
    return -1.5 * x - 0.5 if x < 0 else 2.0 * x - 0.5

def make_data(seed):
    rnd = random.Random(seed)
    xs = [rnd.uniform(-1, 1) for _ in range(80)]
    return [(x, target(x) + rnd.gauss(0, 0.05)) for x in xs]

def softmax(z):
    m = max(z)
    e = [math.exp(v - m) for v in z]
    s = sum(e)
    return [v / s for v in e]

def train(compete, seed=1991):
    rnd = random.Random(seed)
    data = make_data(7)
    ex = [[rnd.gauss(0, 0.5), rnd.gauss(0, 0.5)] for _ in range(EXPERTS)]   # 専門家 k：y_k = a·x + b
    gate = [[rnd.gauss(0, 0.5), 0.0] for _ in range(EXPERTS)]              # ゲートのスコア s_k = u·x + c
    for _ in range(EPOCHS):
        rnd.shuffle(data)
        for x, y in data:
            yk = [a * x + b for a, b in ex]
            g = softmax([u * x + c for u, c in gate])
            if compete:
                lik = [g[k] * math.exp(-0.5 * (y - yk[k]) ** 2) for k in range(EXPERTS)]
                z = sum(lik)
                h = [v / z for v in lik]                      # その点を引き受ける割合
                dy = [-h[k] * (y - yk[k]) for k in range(EXPERTS)]
                ds = [g[k] - h[k] for k in range(EXPERTS)]
            else:
                yhat = sum(g[k] * yk[k] for k in range(EXPERTS))
                err = yhat - y
                dy = [err * g[k] for k in range(EXPERTS)]
                ds = [err * g[k] * (yk[k] - yhat) for k in range(EXPERTS)]
            for k in range(EXPERTS):
                ex[k][0] -= RATE * dy[k] * x
                ex[k][1] -= RATE * dy[k]
                gate[k][0] -= RATE * 4 * ds[k] * x
                gate[k][1] -= RATE * 4 * ds[k]
    return ex, gate

for name, compete in (("① 競争する形", True), ("② 協力する形", False)):
    ex, gate = train(compete)
    print(name)
    for k, (a, b) in enumerate(ex):
        print(f"  専門家 {k + 1}：y = {a:+.2f}·x {b:+.2f}")
    print("  x の位置ごとに、ゲートが割り当てる確率（█ が専門家 1、░ が専門家 2）と、混ぜた予測の誤差")
    total = 0.0
    for i in range(9):
        x = -1 + i * 0.25
        g = softmax([u * x + c for u, c in gate])
        yk = [a * x + b for a, b in ex]
        pick = max(range(EXPERTS), key=lambda k: g[k])
        yhat = yk[pick] if compete else sum(g[k] * yk[k] for k in range(EXPERTS))
        total += abs(yhat - target(x))
        bar = "█" * int(g[0] * 20) + "░" * (20 - int(g[0] * 20))
        print(f"   x={x:+.2f}  {bar}  誤差 {abs(yhat - target(x)):.2f}")
    print(f"  誤差の平均 {total / 9:.2f}")
    solo = []
    for i in range(41):
        x = -1 + i * 0.05
        g = softmax([u * x + c for u, c in gate])
        k = max(range(EXPERTS), key=lambda j: g[j])
        solo.append(abs(ex[k][0] * x + ex[k][1] - target(x)))
    print(f"  担当の専門家 1 人だけで予測したときの平均誤差 {sum(solo) / len(solo):.2f}（専門家がどれだけ担当範囲を学習したか）\n")
print("正解の関数：x が負なら y = −1.5x − 0.5、正なら y = 2x − 0.5（このサイトが作った例）")

151992〜1997・强化学习

只从胜负中学习

不告诉每一步的正确答案，能学到强的下法吗？

1992年，IBM的Tesauro做出的TD-Gammon里，3层神经网络与自己下西洋双陆棋，对战了几十万次，只从胜负中学习（强化学习）。对战了150万次的版本，在与前世界冠军Robertie的40局比赛中，只差1分就追平了。

关键是时间差（TD）。每走一步，就把对当前局面“易胜程度”的预测值，向下一个局面的预测值靠近一点。最终的胜负，就这样一点一点向前面的局面传递。右边的图用井字棋做同样的学习。点空白格，还可以用×跟它对战。

1997年8月，奥赛罗（黑白棋）世界冠军村上健，以0胜6负输给了通过自我对战等方式学习的程序Logistello。Logistello是在普通的个人电脑上运行的。

V（s_t）← V（s_t）＋α［V（s_t＋1）− V（s_t）］

V（s）: 局面s的易胜程度预测值
α: 让预测靠近的比例

常见说法常见说法：AI改变人类下法，是从围棋的AlphaGo（2016）开始的
原始资料里：Nilsson的书里引用了这样的记述：1990年代，西洋双陆棋的顶尖棋手们模仿TD-Gammon改变了开局的下法。

与随机落子的对手对战200局（紫＝输，灰＝平局）

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

u08_selfplay_td.py

# u08 自分どうしで対戦し、勝敗だけで学習する（TD学習を三目並べで小さく試す）
#
# どの出来事か：1992年、IBMのテサウロによるTD-Gammon（記録 td_gammon_1992）。ニューラルネットワークが
#   自分自身と何十万回も対戦し、勝敗の結果だけから学習して、バックギャモンで世界トップ近くまで強くなった。
# 仕組み：局面ごとに「この局面からの勝ちやすさ」の見積もりを表に持つ。1手打つごとに、次の局面の見積もりに
#   少し近づくよう更新する（時間差＝TD学習）。ゲーム終了時には勝ち（1）・引き分け（0.5）・負け（0）を与える。
#   ※ TD-Gammonは表ではなくニューラルネットワークを使った。ここでは同じ学習法の小さな模型を動かす。
# 試してみよう：
#   - 学習前でも〇がよく勝つのは、勝てる手や負けない手は最後の局面の点数で分かるため。
#     学習後に「負け」が減るのは、何手も先の負けを、見積もりの表で前もって避けられるようになったから。
#   - EXPLORE（わざと別の手を試す割合）を 0 にすると、学習が進まなくなることがある

import random

random.seed(1992)
GAMES = 5000
RATE = 0.2
EXPLORE = 0.1
LINES = [(0, 1, 2), (3, 4, 5), (6, 7, 8), (0, 3, 6), (1, 4, 7), (2, 5, 8), (0, 4, 8), (2, 4, 6)]
value = {}   # 局面 → 〇の勝ちやすさの見積もり（初期値は 0.5）

def winner(b):
    for i, j, k in LINES:
        if b[i] != "." and b[i] == b[j] == b[k]:
            return b[i]
    return "引き分け" if "." not in b else None

def v(b):
    w = winner(b)
    if w == "〇":
        return 1.0
    if w == "×":
        return 0.0
    if w == "引き分け":
        return 0.5
    return value.get(b, 0.5)

def choose(b, turn, explore):
    moves = [i for i, c in enumerate(b) if c == "."]
    if random.random() < explore:
        return random.choice(moves)
    nexts = [(v(b[:i] + turn + b[i + 1:]), i) for i in moves]
    best = max(nexts)[0] if turn == "〇" else min(nexts)[0]
    return random.choice([i for s, i in nexts if s == best])

def play(learn, x_random=False, explore=EXPLORE):
    b, turn = ".........", "〇"
    while winner(b) is None:
        if turn == "×" and x_random:
            i = random.choice([i for i, c in enumerate(b) if c == "."])
        else:
            i = choose(b, turn, explore)
        nb = b[:i] + turn + b[i + 1:]
        if learn and b != ".........":
            value[b] = v(b) + RATE * (v(nb) - v(b))   # 前の局面の見積もりを、次の局面の見積もりに近づける
        b, turn = nb, ("×" if turn == "〇" else "〇")
    if learn:
        value[b] = v(b)
    return winner(b)

def test(n=1000):
    res = [play(False, x_random=True, explore=0) for _ in range(n)]
    return res.count("〇"), res.count("引き分け"), res.count("×")

print("学習前：ランダムな×と 1000 回対戦（〇の勝ち, 引き分け, 負け）", test())
played = 0
for checkpoint in (500, 2000, GAMES):
    while played < checkpoint:
        play(True)
        played += 1
    print(f"自分どうしで {played:5d} 回対戦した後：", test(), f"（学習した局面数 {len(value)}）")

161992〜1995・机器学习

最宽的路的正中间

能分开数据的边界线可以画很多条时，哪条最好？

Vapnik等人认为，如果在离两类数据都尽可能远的、最宽的路的正中间画线，没见过的数据也能分类得很好。路宽的一半叫间隔（margin）。

决定边界线的，只是碰到路边的少数几个点（支持向量＝撑住这条路的点）。在右边的图里拖一拖点。移动带圈的点，路就会改变；而其他的点，只要不进入路里，怎么移动边界线都不变。

在手写数字MNIST上，Cortes和Vapnik的方法错误率为1.1%，成绩接近LeNet。不过，识别一个字符大约需要1,400万次乘法和加法。

使间隔＝1／ ‖w‖ 最大　　条件：y_i（w · x_i ＋b）≥ 1

w・b: 决定边界线的参数
y_i: 点i所属的组（＋1或 −1）

常见说法常见说法：1980年代之后，神经网络一直是主角
原始资料里：2000年前后的10年里，很多实用的识别任务被支持向量机等神经网络以外的方法占据了（Schmidhuber，2014）。

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

u08_svm_margin.py

# u08 サポートベクターマシン：2つのグループの間に最も広い道を探し、その中央に境界線を引く
#
# どの出来事か：1992年のボーザー、ギヨン、バプニクの発表と、コルテスとバプニクの方法（記録 support_vector_machine_1995）。
#   どちらのデータからもできるだけ遠い、最も広い道の中央に境界線を引くと、初めて見るデータもうまく分類できる。
#   道の端にある少数のデータ（サポートベクター＝道を支える点）だけで境界線を計算できる。手書き数字の MNIST で誤り率 1.1%。
# 仕組み（平面のデータで、直線で分離できる場合だけ）：直線の向きを 0.25 度ずつすべて試し、その向きで2つのグループが最も近づく
#   隙間（マージン＝道の幅）を測る。最も広い向きを選び、隙間の中央に境界線を引く。道の端に接する点がサポートベクター。
#   比較対象はパーセプトロン（5 章）の境界線：正しく分類できれば学習が止まるため、データのすぐ近くに線を引くことがある。
#   データは、このサイトがランダムに作成した例。
# 試してみよう：
#   - サポートベクター以外のデータを 1 つ削除しても、境界線が変わらないことを確かめる（最後の行）
#   - 訓練データを減らす（N_TRAIN を 6 にする）と、2つの手法の差はどうなるか

import math
import random

random.seed(1995)
N_TRAIN, N_TEST = 12, 4000

def cloud(n, cx, cy, label):
    return [((random.gauss(cx, 0.5), random.gauss(cy, 0.5)), label) for _ in range(n)]

def make(n):
    return cloud(n, -1.0, -0.4, -1) + cloud(n, 1.0, 0.4, +1)

def widest(points):
    best = None
    for k in range(1440):
        th = math.pi * 2 * k / 1440
        w = (math.cos(th), math.sin(th))
        pos = min(w[0] * x + w[1] * y for (x, y), l in points if l > 0)
        neg = max(w[0] * x + w[1] * y for (x, y), l in points if l < 0)
        gap = pos - neg
        if best is None or gap > best[0]:
            best = (gap, w, (pos + neg) / 2)
    return best     # 道の幅（マージン）、向き w、線の位置 c（w·p = c が境界線）

def perceptron(points, seed):
    rnd = random.Random(seed)
    w, b = [0.0, 0.0], 0.0
    for _ in range(200):
        pts = points[:]
        rnd.shuffle(pts)
        miss = 0
        for (x, y), l in pts:
            if l * (w[0] * x + w[1] * y + b) <= 0:
                w[0] += l * x
                w[1] += l * y
                b += l
                miss += 1
        if miss == 0:
            break
    return w, b

def accuracy(f, pts):
    return sum(1 for p, l in pts if f(p) == l) / len(pts)

train = make(N_TRAIN // 2)
test = make(N_TEST // 2)
gap, w, c = widest(train)
if gap <= 0:
    print("このデータの配置は、直線 1 本では分離できない（データを作り直す）")
else:
    svm = lambda p: 1 if w[0] * p[0] + w[1] * p[1] > c else -1
    sv = [p for p, l in train if abs(abs(w[0] * p[0] + w[1] * p[1] - c) - gap / 2) < 0.01]
    print(f"最も広い道：幅 {gap:.3f}、サポートベクター {len(sv)} 個 {[(round(x, 2), round(y, 2)) for x, y in sv]}")
    print(f"  テストデータ {N_TEST} 点の正解率：{accuracy(svm, test):.1%}")
    print("\nパーセプトロンの境界線（データの順序を変えて 8 回試行）")
    for s in range(8):
        pw, pb = perceptron(train, s)
        norm = math.hypot(*pw)
        margin = min(l * (pw[0] * x + pw[1] * y + pb) for (x, y), l in train) / norm * 2
        acc = accuracy(lambda p: 1 if pw[0] * p[0] + pw[1] * p[1] + pb > 0 else -1, test)
        print(f"  {s + 1} 回目：道の幅 {margin:.3f}  テストデータ正解率 {acc:.1%}  " + "█" * int(margin * 20))
    print("\n訓練データを 30 通り作り直して、テストデータの平均正解率を比較")
    sa, pa, n = 0.0, 0.0, 0
    for rep in range(30):
        tr = make(N_TRAIN // 2)
        g3, w3, c3 = widest(tr)
        if g3 <= 0:
            continue
        pw, pb = perceptron(tr, rep)
        sa += accuracy(lambda p: 1 if w3[0] * p[0] + w3[1] * p[1] > c3 else -1, test)
        pa += accuracy(lambda p: 1 if pw[0] * p[0] + pw[1] * p[1] + pb > 0 else -1, test)
        n += 1
    print(f"  最も広い道 {sa / n:.1%}　パーセプトロン {pa / n:.1%}（直線で分けられた {n} 通りの平均）")
    # サポートベクター以外のデータを 1 つ削除しても、境界線は変わらない
    others = [(p, l) for p, l in train if p not in sv]
    gap2, w2, c2 = widest([q for q in train if q != others[0]])
    print(f"\nサポートベクター以外のデータを 1 つ削除した後の道の幅：{gap2:.3f}（削除前と同じ {gap:.3f}）")

171997・神经网络

记忆的盒子与门

很久以前的线索，网络怎样才能一直记住？

用反向传播来训练循环网络时，误差信号每往回走一个时间步，就会被乘上相近的数。小于1就消失，大于1就膨胀。Hochreiter在1991年分析了这个问题。

1997年，Hochreiter和Schmidhuber的LSTM配备了：盒子里的内容以权重1连回自己，不会消失地被传下去。进出由输入门和输出门来开关（1997年的门只有这2个）。在右边的图里按“流动”。论文写道，相隔1,000步以上的线索也能用上。

c_t ＝c_t−1 ＋i_t × g_t　　h_t ＝o_t × h（c_t）

c: 盒子里的内容
i・o: 输入门・输出门（输入门・输出门。0〜1）
g: 想放进去的值

图里LSTM的权重，是本站手工定的（没有训练）。点击“详细”打开的下方图表是每一步乘以“乘数”后剩下的误差信号。

往回走的步数与剩下的信号（纵轴每格为10倍）

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

u08_lstm_memory.py

# u08 LSTM：記憶セルと「入れる門」「出す門」で、ずっと前の手がかりを保持する
#
# どの出来事か：1997年、ホッフライターとシュミットフーバーのLSTM（記録 lstm_1997）。それまでの方法では、誤差逆伝播法の信号が
#   時間をさかのぼるうちに勾配消失（0に近づく）や勾配爆発を起こし、ずっと前の情報を保持できなかった
#   （1991年のホッフライターの分析）。LSTMは「覚えておく箱」（記憶セル）と、出し入れを開け閉めする「門」を備え、
#   1000ステップ以上離れた手がかりも使えた。1997年の論文の門は、入力ゲートと出力ゲートの2つ。
# 仕組み：
#   ① 1ステップさかのぼるたびに信号に同じ値 f が掛けられると、k ステップさかのぼった後は f の k 乗になる。
#      f < 1 なら勾配が消失し、f > 1 なら爆発する。記憶セルの値は自分自身に重み1で伝わるため、f = 1 のまま維持される。
#   ② 課題：最初の記号（A か B）を記憶し、間に T 個のランダムな値が流れた後、最後に答える。
#      LSTMの重みは、このサイトが手で決めた例（学習させていない）。入力ゲートは「はじめの印」だけで開き、
#      出力ゲートは「おわりの印」だけで開く。比較対象は、1つ前の状態に重みを掛けて足すだけのふつうの再帰型ネットワーク。
# 試してみよう：
#   - W_RNN を 1.0 や 1.5 にすると、ふつうの再帰型ネットワークはどうなるか
#   - LSTM の入力ゲートを、ランダムな値の時にも少し開く（LEAK を 0.05 に）と、長い T で何が起きるか

import math
import random

random.seed(1997)
W_RNN = 0.9
LEAK = 0.0

def sig(x):
    return 1 / (1 + math.exp(-x))

print("① 1 ステップごとに f を掛けると、k ステップさかのぼった信号の大きさ")
for f in (0.5, 0.9, 1.0, 1.1):
    row = "  ".join((f"{f ** k:9.3g}" if f ** k < 1e30 else "とても大きい") for k in (1, 10, 100, 1000))
    print(f"  f={f:3.1f}：k=1, 10, 100, 1000 → {row}")

def make(T):
    first = random.choice((1, -1))                    # A = +1、B = −1
    xs = [(first, 1, 0)] + [(random.uniform(-1, 1), 0, 0) for _ in range(T)] + [(0, 0, 1)]
    return first, xs                                   # （値, はじめの印, おわりの印）

def lstm(xs):
    c = 0.0
    for v, start, end in xs:
        i = sig(20 * start - 10) + LEAK                # 入力ゲート：はじめの印だけで開く
        o = sig(20 * end - 10)                         # 出力ゲート：おわりの印だけで開く
        g = math.tanh(2 * v)                           # 入力候補値
        c = c + i * g                                  # 記憶セル：前の値に重み 1 で足すだけ（減衰しない）
        h = o * math.tanh(c)
    return 1 if h > 0 else -1

def rnn(xs):
    h = 0.0
    for v, start, end in xs:
        h = math.tanh(W_RNN * h + v)                   # 1つ前の状態に W_RNN を掛けて、現在の値を足す
    return 1 if h > 0 else -1

print(f"\n② 最初の記号を、T 個あとに答える（各 400 回。50% はランダムに答えたのと同じ）")
for T in (1, 3, 10, 30, 100, 1000):
    n = 400 if T < 1000 else 100
    ok_l = ok_r = 0
    for _ in range(n):
        first, xs = make(T)
        ok_l += lstm(xs) == first
        ok_r += rnn(xs) == first
    print(f"  T={T:4d}  LSTM {ok_l / n:5.0%} {'█' * int(ok_l / n * 20):20s}  ふつうのネットワーク {ok_r / n:5.0%} {'█' * int(ok_r / n * 20)}")

181994〜1997・搜索

把不去读的树枝砍掉

每秒检查约2亿个棋盘局面的计算机，是把所有局面都读了一遍吗？

1997年5月，IBM的国际象棋专用计算机深蓝（Deep Blue），在纽约以2胜1负3平（3.5比2.5）战胜了世界冠军卡斯帕罗夫。它强大的根源，是每秒检查约2亿个棋盘局面的蛮力计算，以及大师们的对局记录。

即便如此，也不可能把一切都读完（第5章的组合爆炸）。α-β剪枝，会把已经知道对手有更好应对的树枝，不再往下读而直接砍掉。在右边的图里，比较读过的叶子数。答案不变，要读的数量却减少了。

西蒙等人（译）的预言（1957年），约40年后以变化了的形式实现了（第3章）。

一旦α ≥ β，这根树枝剩下的部分就不再读

α: 自己已经确保的最低得分
β: 对手不会再让你拿到的最高得分

常见说法常见说法：深蓝的胜利是AI的胜利
原始资料里：IBM自己在当时的网页上写道：“深蓝用了人工智能吗？简短的回答是‘没有’”（译），并说明它是靠庞大的计算和大师的对局记录变强的。

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

u08_alphabeta.py

# u08 アルファベータ法：探索結果に影響しない枝を、読まずに切り落とす
#
# どの出来事か：1997年5月、IBMのチェス専用コンピュータ ディープ・ブルーが、世界チャンピオンのカスパロフに 3.5 対 2.5 で勝った
#   （記録 deep_blue_kasparov_1997）。1秒に約2億の盤面を調べる力まかせの計算が、強さの源だった。
#   同年8月、オセロのプログラム Logistello は、ふつうのパソコンで1秒に16万盤面を探索した（記録 logistello_murakami_1997）。
#   チェッカーの Chinook は1994年に「人と機械の世界チャンピオン」になった（記録 chinook_world_champion_1994）。
# 仕組み：ゲーム木において、自分はスコアを最大化し、相手は最小化すると考えて先を読む（ミニマックス法、2章）。
#   アルファベータ法は、α＝自分が確保した下限値、β＝相手が確保した上限値を保持しながら探索する。
#   α ≥ β になると、その先の枝は選ばれなくなるため読まない（枝刈り）。最善手の評価値は、全探索と同じになる。
#   よい手を先に読むほど、多くの枝を切り落とせる。ここの木と葉の点数は、このサイトがランダムに作った例。
# 試してみよう：
#   - B（1手ごとの枝の数）を6、Dを7にすると、全探索と枝刈り後で探索数がどれだけ違うか（大きくしすぎると時間がかかる）
#   - 「1秒に2億」の計算力で、全探索なら何手先まで、よい順のアルファベータ法なら何手先まで読めるかを下の表で確かめる

import math
import random

random.seed(1997)
B, D = 4, 6

def make_tree(d):
    if d == 0:
        return random.randint(-50, 50)
    return [make_tree(d - 1) for _ in range(B)]

def minimax(t, me):
    global count
    if isinstance(t, int):
        count += 1
        return t
    vals = [minimax(c, not me) for c in t]
    return max(vals) if me else min(vals)

def alphabeta(t, a, b, me):
    global count
    if isinstance(t, int):
        count += 1
        return t
    if me:
        v = -math.inf
        for c in t:
            v = max(v, alphabeta(c, a, b, False))
            a = max(a, v)
            if a >= b:
                break          # 相手はこの枝を選ばない
        return v
    v = math.inf
    for c in t:
        v = min(v, alphabeta(c, a, b, True))
        b = min(b, v)
        if a >= b:
            break              # 自分はこの枝を選ばない
    return v

def order(t, me):
    """よい手を先に探索するように枝を並べ替える（ここでは答えをあらかじめ知っている、最も良い並べ方）"""
    if isinstance(t, int):
        return t, t
    kids = [order(c, not me) for c in t]
    kids.sort(key=lambda kv: kv[1], reverse=me)
    return [k for k, _ in kids], kids[0][1]

tree = make_tree(D)
count = 0
v1 = minimax(tree, True)
n_all = count
count = 0
v2 = alphabeta(tree, -math.inf, math.inf, True)
n_ab = count
count = 0
v3 = alphabeta(order(tree, True)[0], -math.inf, math.inf, True)
n_best = count
print(f"枝 {B} 本・{D} 手先までの木（葉 {B ** D:,} 枚）")
print(f"  全探索（ミニマックス法）      {n_all:6,} 枚  答え {v1}")
print(f"  アルファベータ（ランダムな順）{n_ab:6,} 枚  答え {v2}")
print(f"  アルファベータ（よい手から先）{n_best:6,} 枚  答え {v3}")
print(f"  理想的な順序での探索数の目安 B^⌈D/2⌉ + B^⌊D/2⌋ − 1 = {B ** math.ceil(D / 2) + B ** (D // 2) - 1:,}")

print("\n1 秒に読める葉の数で、何手先まで読めるか（枝 35 本の仮の数で。1 手 3 分とする）")
b = 35
for name, per_sec in (("ディープ・ブルー（1 秒に 2 億）", 2e8), ("Logistello（1 秒に 16 万）", 1.6e5)):
    budget = per_sec * 180
    full = int(math.log(budget) / math.log(b))
    best = int(2 * math.log(budget / 2) / math.log(b))
    print(f"  {name}：全探索なら {full} 手、よい順のアルファベータ法なら 約 {best} 手")
print("  ※ 枝 35 本・1 手 3 分は、このサイトが置いた仮の数値（実際のゲームでは局面ごとに枝の数が変わる）")

191985〜2005・机器人

不再“想好了再动”

没有地图的机器人，能在房间里到处走吗？

1985年9月，MIT的布鲁克斯发表了把机器人的动作按层来设计的方法。在底层（不要撞上去之类）的动作之上，叠加高级动作的层，上层只在需要的时候才压制下层。他在1991年的论文里写道：（译）。

2002年以199.95美元发售的扫地机器人Roomba，其发布资料里同样没有提到地图。它反复使用螺旋形、沿墙、直行的走法，让房间的每个部分被经过2〜5次。在右边的图里，试着加上或去掉一些层（房间是本站做的例子）。

在日本，1999年发布了索尼的AIBO，2000年发布了本田的ASIMO。

做出的动作＝当前起作用的、最上面一层的动作

层: 直行、沿墙前进、螺旋状转圈这类动作的集合

常见说法常见说法：1980年代后半〜90年代的AI寒冬里，研究本身都停了
原始资料里：就在同一时期，布鲁克斯一边写下寒冬的情形，一边指出了从身体和动作出发造出智能的另一条路，并造出了到处走动的机器人。

行驶过的地面比例（紫＝墙边，绿＝中央）

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

u08_roomba_cover.py

# u08 地図を持たないロボット：簡単な動きの層を重ねるだけで、床のどれだけを通れるか
#
# どの出来事か：1985年9月、MITのブルックスによる報告（記録 brooks_behavior_based_robots_1985）。ロボットの動作を層（レイヤー）に分け、
#   下の層（衝突回避など）の上に少しずつ高度な動作の層を重ねる。上位の層は必要な時だけ下位の層の出力を抑制する。
#   1991年の論文では、ごく単純な知能において、明示的な表現や世界のモデルは邪魔になるだけだと論じた。
#   2002年9月に199.95ドルで発売されたルンバの発表文は、渦巻き状に走り、障害物にぶつかると壁沿いに進み、
#   再び渦巻きや直進を繰り返して、時間をかけて部屋の各箇所を2〜5回通過すると説明した（記録 roomba_2002）。
# 仕組み：部屋（このサイトが作った例：20×14のマスと家具3つ）の中を次の動作で走らせ、通過したマスを数える。
#   - まっすぐ：衝突したらランダムな方向を向いて進む（最下層）
#   - 壁ぞい：衝突したら、しばらく右手を壁に沿わせて進む
#   - うず巻き：ときどき、その場で半径を広げながら回転する
#   どの層を使うかは LAYERS で選ぶ。ロボットは部屋の地図も自己位置も持たない。
# 試してみよう：
#   - LAYERS を ("まっすぐ",) だけにすると、壁際や家具のまわりの通過率はどう変わるか
#   - STEPS を2倍にすると、各マスを平均何回くらい通るか（最後のマップ）

import math
import random

random.seed(2002)
W, H = 20.0, 14.0
FURNITURE = [(4, 3, 7, 6), (12, 8, 16, 11), (14, 2, 15, 4)]   # 家具（x0, y0, x1, y1）
LAYERS = ("まっすぐ", "壁ぞい", "うず巻き")
STEPS, SPEED, R = 12000, 0.12, 0.45

def blocked(x, y):
    if x < R or y < R or x > W - R or y > H - R:
        return True
    return any(x0 - R < x < x1 + R and y0 - R < y < y1 + R for x0, y0, x1, y1 in FURNITURE)

def run(layers, steps=STEPS):
    visits = {}
    x, y, th = 2.0, 12.0, 0.0
    mode, timer, radius = ("うず巻き" if "うず巻き" in layers else "まっすぐ"), 0, 0.3
    for t in range(steps):
        timer += 1
        if mode == "うず巻き":
            radius += 0.004
            th += SPEED / radius
        elif mode == "壁ぞい":
            rx, ry = x + math.cos(th - 1.2) * 0.8, y + math.sin(th - 1.2) * 0.8   # 右前方を確認
            th += -0.12 if not blocked(rx, ry) else 0.0
            if timer > 150:
                mode, timer = "まっすぐ", 0
        nx, ny = x + math.cos(th) * SPEED, y + math.sin(th) * SPEED
        if blocked(nx, ny):                                  # 衝突
            if "壁ぞい" in layers and mode != "壁ぞい" and random.random() < 0.4:
                mode, timer = "壁ぞい", 0
                th += math.pi / 2
            elif mode == "壁ぞい":
                th += 0.5
            else:
                mode = "まっすぐ"
                th += random.uniform(math.pi / 2, 3 * math.pi / 2)
            continue
        x, y = nx, ny
        if mode == "まっすぐ" and "うず巻き" in layers and timer > 600:
            mode, timer, radius = "うず巻き", 0, 0.3
        cell = (int(x), int(y))
        visits[cell] = visits.get(cell, 0) + 1
    return visits

free = [(i, j) for i in range(int(W)) for j in range(int(H)) if not blocked(i + 0.5, j + 0.5)]
edge = [c for c in free if any(blocked(c[0] + 0.5 + dx, c[1] + 0.5 + dy) for dx, dy in ((1, 0), (-1, 0), (0, 1), (0, -1)))]
inner = [c for c in free if c not in edge]
print(f"床のマス：壁際・家具の周囲 {len(edge)} 個、中央 {len(inner)} 個。通過したマスの割合（10 回の平均）")
for layers in (("まっすぐ",), ("まっすぐ", "壁ぞい"), LAYERS):
    out = []
    for n in (1500, 4000):
        e = m = 0.0
        for k in range(10):
            random.seed(k)
            v = run(layers, n)
            e += sum(1 for c in edge if c in v) / len(edge) / 10
            m += sum(1 for c in inner if c in v) / len(inner) / 10
        out.append(f"{n:4d} 歩：壁際 {e:4.0%} 中央 {m:4.0%}")
    print(f"  {'＋'.join(layers):14s} " + "　".join(out))

random.seed(2002)
v = run(LAYERS)
print(f"\n3つの層をすべて使って {STEPS} 歩。通過回数のマップ（・未通過　１〜９ 回数の目安　■ 家具）")
for j in reversed(range(int(H))):
    line = ""
    for i in range(int(W)):
        if any(x0 <= i + 0.5 < x1 and y0 <= j + 0.5 < y1 for x0, y0, x1, y1 in FURNITURE):
            line += "■"
        else:
            c = round(v.get((i, j), 0) / 8)      # 1マスを通り抜けるのに約8歩かかる
            line += "・" if c == 0 else "１２３４５６７８９"[min(8, c - 1)]
    print("  " + line)

201993〜2005・预言

把“翻倍”的线延伸出去

能从计算机性能的提升，预言出与大脑比肩的年份吗？

1998年，卡内基梅隆大学的莫拉维克估算，人脑的工作需要约1亿MIPS（每秒100万次指令为1 MIPS）。并预言，所需的硬件将。他还写道，1960〜1990年是。

预言的年份，会随着翻倍的周期怎么设定而大幅变动。据论文，1990年便宜的个人电脑上1 MIPS要1,000美元。翻倍的周期，1980年代是18个月，1990年代后半是12个月。在右边的图里，改变周期试一试。

1993年，文奇（Vinge）写道：（译）。

到达的年份＝1990＋翻倍的周期（年）× log₂（1亿）

log₂（1亿）: 约26.6（翻倍多少次才能达到1亿倍）

常见说法常见说法：奇点是库兹韦尔的想法（2045年）
原始资料里：文奇在1993年就称之为the Singularity，并写明超人类智能将出现在2005〜2030年。文奇自己介绍说，这个词可以追溯到冯·诺依曼，想法可以追溯到I・J・古德。

用数字测量寒冬的冷

日本没有迎来寒冬？

从符号的计划，到学习的计划

落入能量山谷的网络

靠概率行动的神经元

只连接两层之间

沿着误差的坡往下走

把误差，从后往前传

把8个压缩成3个

把前一刻的自己放进来

把同一个窗口反复使用

没把握的字符交给人

从对译中计算概率

把工作分给各位专家

只从胜负中学习

最宽的路的正中间

记忆的盒子与门

把不去读的树枝砍掉

不再“想好了再动”

把“翻倍”的线延伸出去

这一章里，还有哪些尚不清楚

“麦卡锡向MYCIN输入‘男性患者的羊水’，它照单全收”——开发者记在注里