El invierno tras el segundo auge y los brotes que crecieron en silencio

011984–1996 · Estados Unidos

Medir el frío del invierno con números

¿Llegó realmente el invierno que preocupaba en 1984?

En agosto de 1984, en un debate del congreso de la Asociación Estadounidense de Inteligencia Artificial (AAAI), el moderador Drew McDermott describió “el peor escenario” (traducción). En unos 5 años fracasaría la de Defensa, quebrarían las empresas emergentes y se interrumpiría la financiación de la IA. Explicó que algunas personas llamaban a esta situación. Sin embargo, también dijo que no creía que fuera muy probable.

La figura de la derecha muestra los datos posteriores de Estados Unidos. El número de miembros de la AAAI alcanzó su máximo de 16,421 en 1987 y en 1996 había caído a 4,000–5,000. Las ventas de productos de Symbolics, que desarrollaba máquinas Lisp (computadoras dedicadas a la IA), bajaron de 101.6 millones a 55.6 millones de dólares entre los ejercicios fiscales de 1986 y 1988. Incluso las cifras con unidades distintas se pueden comparar si se fija cada máximo en 100.

Valor ajustado＝cifra de ese año ÷ cifra del año del máximo × 100

Máximo: año con el valor más alto

Lo que se cree saberLo que suele decirse:El debate de 1984 predijo con exactitud el invierno de la IA
Según la fuente original:El moderador lo presentó como “el peor escenario” (traducción) y dijo que no era muy probable. Muchas partes del escenario ocurrieron, pero no todas a la vez 5 años después.

021987–2003 · Japón

¿No llegó el invierno a Japón?

¿Cómo estaba Japón cuando en Estados Unidos se hablaba de un invierno?

En marzo de 1991, el (traducción), supervisado por el Ministerio de Comercio Internacional e Industria, escribió que Japón “no entró en una ‘época de invierno’ de la IA como la que se había visto antes en Estados Unidos” (traducción). En Japón se popularizó la lógica difusa (una teoría que trata la imprecisión), y en 1990 la palabra ganó el premio de oro en la categoría de palabras nuevas de los Premios a las Nuevas Palabras y Expresiones de Moda.

Una de las bases del libro blanco era una encuesta de 1989. Habían adoptado la IA el 26.2% de los establecimientos usuarios de computadoras que respondieron, el 80.5% de los miembros del centro de IA y el 37.8% del total. Pero de los 7,084 lugares a los que se envió el cuestionario, respondieron 1,844. La figura de la derecha permite ver cómo cambia el porcentaje según a quién se preguntó.

Al cambiar la figura a los miembros de la sociedad científica, los miembros institucionales, como las empresas, alcanzaron un máximo de 155 empresas en 1991 y 1992, y se redujeron a 49 en 2003. Parece que el invierno llegó a Japón más tarde y poco a poco.

Proporción entre quienes respondieron＝número que adoptó la IA ÷ número que respondió

Límite inferior: proporción si se supone que ninguno de los lugares que no respondieron había adoptado la IA (número que la adoptó ÷ número al que se envió el cuestionario)

Lo que se cree saberLo que suele decirse:Tras el segundo auge, Japón entró en invierno al mismo tiempo que el resto del mundo
Según la fuente original:El libro blanco de 1991, supervisado por el gobierno, escribió que Japón no había entrado en un invierno como el de Estados Unidos. Los miembros empresariales de la sociedad empezaron a disminuir después, a partir del informe de 1993.

031992–1995 · Programas nacionales de Japón

De los símbolos al aprendizaje

¿Qué buscaban los programas nacionales de Japón después de la quinta generación?

En 1995 terminaron juntos 3 programas nacionales de Japón: el de quinta generación, que buscaba computadoras que razonaran con lógica; el Instituto Japonés de Investigación de Diccionarios Electrónicos (EDR, 1986–1995), que creó a mano un enorme diccionario para computadoras; y LIFE (1989–1995), dedicado a tratar la imprecisión.

Antes, en 1992, el Ministerio de Comercio Internacional e Industria había iniciado un programa de 10 años, . Según Nobuyuki Otsu, que dirigió el programa, mientras la quinta generación perseguía el “aspecto lógico (procesamiento simbólico)” (traducción), RWC perseguía el “aspecto intuitivo (procesamiento de patrones)” (traducción). Es decir, buscaba tecnologías que trataran con flexibilidad, mediante el aprendizaje, información imprecisa como imágenes y sonidos.

Al mover “Año actual” en la figura de la derecha, los objetivos de los programas en marcha ese año pasan de los símbolos a los patrones y el aprendizaje.

Promedio por año＝dinero total ÷ número de años

Promedio: valor obtenido al dividir entre el número de años; no significa que cada año se gastara lo mismo

041982 · Redes neuronales

Caer al fondo de un valle de energía

¿Por qué una red que recuerda siempre termina por estabilizarse en algún lugar?

En abril de 1982, el físico John Hopfield presentó una red en la que todas las neuronas estaban conectadas entre sí y tomaban el valor +1 o −1. La fuerza de cada conexión es la misma en ambas direcciones. Las neuronas se actualizan una a una, según el signo de la suma de las entradas que reciben de las demás.

El artículo definió para cada estado una cifra llamada energía, usando ideas de la física que estudia las propiedades de los imanes. Cada vez que se actualiza una neurona, la energía baja o permanece igual. Por eso, siempre acaba deteniéndose en el fondo de algún valle. Si los patrones aprendidos se sitúan en el fondo de los valles, incluso al empezar con un patrón deteriorado la red cae en un valle cercano y lo recuerda.

El gráfico bajo la figura de la derecha permite comprobar que la energía nunca sube. El artículo decía que la red podía recordar un número de patrones de aproximadamente 0.15 veces el número N de neuronas.

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

s_i: valor de la neurona i (+1 o −1)
w_ij: fuerza de la conexión entre i y j (igual en ambas direcciones)
E: energía total

Lo que se cree saberLo que suele decirse:Hopfield creó la primera red de memoria asociativa en 1982
Según la fuente original:Su propio artículo cita trabajos anteriores, como los de Shun-ichi Amari (1977 y 1978). En 1972, Kaoru Nakano y Shun-ichi Amari ya habían publicado mecanismos similares (capítulo 5).

Energía después de actualizar una neurona

Este código Python reproduce el mismo mecanismo que “Explorar”. Al pulsar ▶ Ejecutar, el resultado aparece debajo. Se pueden cambiar los números y volver a ejecutarlo.

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 · Redes neuronales

Neuronas que actúan según probabilidades

¿Qué se puede hacer si la red se detiene en un valle poco profundo?

La red de Hopfield solo puede avanzar cuesta abajo. En 1985, en la máquina de Boltzmann de Ackley, Hinton y Sejnowski, las neuronas eligen activarse o desactivarse según probabilidades, por lo que a veces también pueden avanzar cuesta arriba. La temperatura T determina el grado de aleatoriedad. Al bajar la temperatura poco a poco, es más fácil que la red se estabilice con poca energía (la misma idea que el recocido en física).

En la figura de la derecha se pueden pulsar varias veces “Recocido (enfriar despacio)” y “Enfriar de golpe” para comparar cuántas veces se llega al valle más profundo.

El artículo también presentó una regla para entrenar redes con neuronas ocultas. Compara la probabilidad de que 2 neuronas estén activas al mismo tiempo cuando se muestran los datos y se mantienen fijos, y cuando la red funciona libremente. Los pesos se corrigen con esa diferencia. Al principio, los cálculos tardaban mucho y el método no era muy útil (explicación del Comité Nobel, 2024).

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

ΔE: energía que disminuye al activarse la neurona
T: temperatura
p^＋, p⁻: probabilidad de que ambas estén activas a la vez con los datos fijos y en funcionamiento libre

Lo que se cree saberLo que suele decirse:El aprendizaje de redes con capas ocultas empezó con la retropropagación del error en 1986
Según la fuente original:El artículo de 1985 sobre la máquina de Boltzmann ya había presentado una regla de aprendizaje para redes con neuronas ocultas.

Energía durante el funcionamiento

Este código Python reproduce el mismo mecanismo que “Explorar”. Al pulsar ▶ Ejecutar, el resultado aparece debajo. Se pueden cambiar los números y volver a ejecutarlo.

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 · Redes neuronales

Conectar solo entre 2 capas

¿Qué se simplifica si no hay conexiones dentro de una misma capa?

En 1986, en el capítulo 6 del volumen 1 del libro “Procesamiento distribuido en paralelo (PDP)” (traducción), Paul Smolensky propuso una red neuronal llamada harmonium. Dividía las neuronas en una capa visible y una capa oculta, con conexiones solo entre las capas. En una nota al pie también la describió como un caso especial de máquina de Boltzmann en el que “las conexiones se limitan a unir únicamente dos capas” (traducción). Hoy se llama máquina de Boltzmann restringida (RBM).

Como no hay conexiones dentro de una misma capa, una vez fijada una capa, la otra se puede calcular toda a la vez. El botón “1 ida y vuelta (arriba y abajo)” de la figura de la derecha actualiza simultáneamente las neuronas de cada capa. Una red que ha aprendido un patrón de rayas también restaura una imagen deteriorada tras varias idas y vueltas.

En 2002, Hinton presentó un método rápido que entrena con 1 ida y vuelta: la divergencia contrastiva (capítulo 9).

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

v: capa visible
h: capa oculta
σ: función que transforma un valor en otro entre 0 y 1
b: sesgo

Lo que se cree saberLo que suele decirse:Hinton creó la máquina de Boltzmann restringida para el aprendizaje profundo de la década de 2000
Según la fuente original:El propio Hinton escribió en su artículo de 2002 que Smolensky (1986) había propuesto la variante restringida. El trabajo de la década de 2000 fue desarrollar una forma de entrenarla rápidamente y otra de apilarla para crear redes profundas.

Este código Python reproduce el mismo mecanismo que “Explorar”. Al pulsar ▶ Ejecutar, el resultado aparece debajo. Se pueden cambiar los números y volver a ejecutarlo.

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 · Formas de aprender

Bajar por la pendiente del error

¿Cómo se mejora poco a poco un modelo con muchos pesos?

Una vez fijados los pesos, el error de una máquina que aprende queda determinado por un solo número. Al colocar los pesos en los ejes horizontal y vertical, se forma un terreno con montañas y valles. El descenso del gradiente reduce el error avanzando poco a poco en la dirección de la bajada más pronunciada (la opuesta al gradiente).

Al pulsar sobre el terreno de la derecha se coloca una bola que puede empezar a descender. Si el paso (la tasa de aprendizaje η) es demasiado grande, salta por encima del valle; si es aún mayor, sale del terreno. Al calcular “Por cada ejemplo”, el recorrido oscila, pero el cálculo de cada paso es más ligero (descenso estocástico del gradiente).

En 1967, Shun-ichi Amari estudió teóricamente un método de aprendizaje que actualiza los pesos poco a poco cada vez que ve un ejemplo. En una explicación en japonés de 1968 lo llamó “método de descenso estocástico”. La retropropagación del error de 1986 también utiliza esta idea de bajar por una pendiente.

w ← w − η ∂L／ ∂w

L: magnitud del error
∂L／ ∂w: cambio de L al modificar un poco w (gradiente)
η: tasa de aprendizaje

Lo que se cree saberLo que suele decirse:El entrenamiento de las capas ocultas empezó con la retropropagación del error en 1986
Según la fuente original:El propio Amari (2025) y la presentación del Premio Kioto afirman que la teoría de 1967 proponía aprender mediante el gradiente, incluidas las capas ocultas. Este sitio no ha podido consultar el texto del artículo de 1967.

Número de actualizaciones y magnitud del error (escala vertical en múltiplos de 10)

Este código Python reproduce el mismo mecanismo que “Explorar”. Al pulsar ▶ Ejecutar, el resultado aparece debajo. Se pueden cambiar los números y volver a ejecutarlo.

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 · Redes neuronales

Propagar el error hacia atrás

¿Cómo se deben corregir los pesos de la capa oculta?

En octubre de 1986, Rumelhart, Hinton y Williams presentaron en un artículo de Nature un método para entrenar redes neuronales con una capa oculta entre la entrada y la salida. El error de la salida se reparte entre las neuronas de la capa oculta retrocediendo, paso a paso, desde la salida hacia la entrada, y los pesos se corrigen poco a poco (retropropagación del error).

La red de la figura de la derecha permite aprender XOR, que el perceptrón de una sola capa del capítulo 5 no podía aprender. Cada neurona oculta traza una línea de separación distinta (línea de puntos), y la red clasifica XOR entre esas líneas. Si se reduce la capa oculta a 1 neurona, no puede aprenderlo.

El propio artículo dice: “Se han descubierto de forma independiente variantes del procedimiento de aprendizaje” (traducción). Esas variantes fueron descubiertas por Parker y Le Cun, cada uno por separado.

δ_salida ＝（y − t）y（1 − y）　　δ_j ＝δ_salida w_j h_j（1 − h_j）

y, t: valor de salida y respuesta correcta
h_j, w_j: valor de la neurona oculta j y peso de su conexión a la salida
δ: error repartido

Lo que se cree saberLo que suele decirse:Hinton inventó la retropropagación
Según la fuente original:El propio artículo dice que otras personas también la habían descubierto de forma independiente. La explicación del Comité Nobel (2024) también habla de reinvención: “Rumelhart, Hinton y Williams reinventaron un método para ello” (traducción). Señala que lo importante fue demostrar que una red con una capa oculta podía resolver tareas imposibles de resolver sin esa capa.

Magnitud del error en cada ronda de entrenamiento

Este código Python reproduce el mismo mecanismo que “Explorar”. Al pulsar ▶ Ejecutar, el resultado aparece debajo. Se pueden cambiar los números y volver a ejecutarlo.

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 · Redes neuronales

Comprimir 8 en 3

¿Puede una red crear un código sin preparar respuestas correctas por separado?

Se entrena una red con una capa central estrecha para que produzca la misma salida que recibe como entrada. Un patrón en el que solo 1 de las 8 entradas vale 1 pasa por 3 neuronas ocultas y se reproduce en las mismas 8 salidas. La red no tiene más opción que asignar por sí misma a los 8 patrones un conjunto de 3 valores (un código).

Esta tarea apareció como problema de codificación (encoder problem) en el artículo de 1985 sobre la máquina de Boltzmann, y también se entrenó en el capítulo sobre retropropagación del libro de 1986. Según el capítulo, las neuronas ocultas usaban no solo 0 y 1, sino también valores intermedios. La figura de la derecha muestra cómo los 8 patrones se distribuyen en lugares distintos de un cubo.

En 1987, Ballard propuso una forma de apilar estas redes. Hoy se llaman autocodificadores (autoencoders).

Código z＝σ（W₁x）　　salida y＝σ（W₂z）　　error de reconstrucción＝Σ（y − x）²

x, z: entrada (8 unidades) y capa oculta (3 unidades)
W₁, W₂: pesos de la primera mitad (codificador) y la segunda mitad (decodificador)

Lo que se cree saberLo que suele decirse:Hinton inició los autocodificadores en 2006
Según la fuente original:Ya existían en 1985–1987. El artículo de Science de 2006 también dice, sobre el buen funcionamiento de los autocodificadores profundos: “Es evidente desde la década de 1980” (traducción).

Error de reconstrucción en cada repetición del entrenamiento

Este código Python reproduce el mismo mecanismo que “Explorar”. Al pulsar ▶ Ejecutar, el resultado aparece debajo. Se pueden cambiar los números y volver a ejecutarlo.

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 · Redes neuronales

Añadir el estado anterior de la red

¿Cómo recuerda una red los caracteres que llegan en secuencia?

En 1990, Elman añadió unidades de contexto a una red neuronal de 3 capas. Los valores de la capa oculta se copian sin cambios en las unidades de contexto y se introducen junto con la entrada en el siguiente instante (red neuronal recurrente, RNN). Las conexiones que hacen la copia tienen un peso fijo de 1.

Al pedirle que predijera el siguiente carácter de una secuencia sin separaciones entre palabras, el error de predicción era grande al principio de una palabra y disminuía a medida que esta avanzaba. Sin habérselo enseñado, aparecen los límites entre palabras. La figura de la derecha muestra un ejemplo creado por este sitio con 5 palabras seguidas. Solo la barra morada (el primer carácter) permanece alta.

El propio Elman escribió que esta idea se remontaba al informe de Jordan de 1986.

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

x_t: carácter en el instante t
h_t−1: capa oculta un paso antes
U: conexiones desde las unidades de contexto

Lo que se cree saberLo que suele decirse:Elman inventó las RNN en 1990
Según la fuente original:El propio artículo de Elman dice que Jordan (1986) fue el primero en describir la idea, y cita ejemplos anteriores. La explicación del Comité Nobel dice que la red de Hopfield también es recurrente.

Posición del carácter en la palabra y error medio de predicción

Este código Python reproduce el mismo mecanismo que “Explorar”. Al pulsar ▶ Ejecutar, el resultado aparece debajo. Se pueden cambiar los números y volver a ejecutarlo.

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 · Convolución

Reutilizar la misma ventana

¿Cómo se crea una red neuronal que lea dígitos manuscritos aunque estén un poco desplazados?

En 1989, 7 investigadores de Bell Labs, entre ellos LeCun, entrenaron una red neuronal para reconocer dígitos usando 9,298 dígitos manuscritos de códigos postales en sobres estadounidenses. La clave era reutilizar la misma ventana pequeña de 5×5 (un filtro que detecta características) en muchos lugares de la imagen: lo que hoy se llama convolución.

En la figura de la derecha se puede elegir una ventana y desplazar el dígito. Los lugares cuya forma coincide con la ventana responden, y esos lugares se desplazan junto con el dígito. Como se reutiliza la ventana, el número de pesos que hay que aprender disminuye mucho (la cifra de arriba a la derecha).

En los 2,007 ejemplos de prueba, la tasa de error fue del 5.0%. El artículo cita una sola vez el artículo de Kunihiko Fukushima de 1980 sobre el neocognitrón.

Mapa（x, y）＝Σ_i,j k（i, j）× imagen（x＋i, y＋j）

k: ventana (pesos de 5×5, iguales en cualquier lugar)

Lo que se cree saberLo que suele decirse:El aprendizaje profundo para reconocer imágenes (convolución) nació en Estados Unidos
Según la fuente original:El propio LeCun y sus colegas escribieron en 1998: “La combinación de convolución y submuestreo… se implementó en el neocognitrón de Fukushima” (traducción). La diferencia era que el neocognitrón no tenía un método para entrenar toda la red (retropropagación del error).

Este código Python reproduce el mismo mecanismo que “Explorar”. Al pulsar ▶ Ejecutar, el resultado aparece debajo. Se pueden cambiar los números y volver a ejecutarlo.

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 · Convolución

Pasar los caracteres dudosos a personas

¿Una máquina que se equivoca un 5% no puede usarse en un banco?

La red de 1989 que leía códigos postales se equivocó en el 5.0% de los datos de prueba. El artículo también señaló que para limitar la tasa de error al 1% había que rechazar el 12.1% como “ilegible”. Al pasar a una persona los casos en los que la respuesta tiene poca confianza, disminuyen los errores entre los casos que la máquina sí responde. En la figura de la derecha se puede mover la línea de rechazo θ.

En 1998, LeCun y sus colegas presentaron LeNet-5, una red neuronal convolucional de 7 capas, y un sistema para leer cheques. El sistema se incorporó a las máquinas lectoras de cheques de NCR y se utilizó en varios bancos estadounidenses. En MNIST, el conjunto de datos de dígitos manuscritos de ese artículo (60,000 datos de entrenamiento y 10,000 de prueba), la tasa de error fue del 0.95%.

Proporción de rechazo＝número de casos con confianza＜θ ÷ número total

θ: línea que fija el criterio de rechazo
confianza: el mayor de los valores de salida

La distribución de la confianza de la figura es un ejemplo creado por este sitio para aproximarse a 2 puntos del artículo de 1989.

Lo que se cree saberLo que suele decirse:El aprendizaje profundo empezó a ser útil en 2012
Según la fuente original:A finales de la década de 1990, las redes neuronales convolucionales ya realizaban un trabajo real: leer cheques en los bancos.

Proporción de rechazo y tasa de error entre los casos respondidos

Este código Python reproduce el mismo mecanismo que “Explorar”. Al pulsar ▶ Ejecutar, el resultado aparece debajo. Se pueden cambiar los números y volver a ejecutarlo.

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 · Traducción automática

Probabilidades de textos paralelos

¿Se pueden reunir pistas para traducir sin escribir un diccionario ni una gramática?

En junio de 1990, 8 investigadores de IBM, entre ellos Brown y Jelinek, presentaron un método que trata la traducción como un cálculo de probabilidades. Usaron como material las actas del Parlamento de Canadá, registradas tanto en inglés como en francés (unos 100 millones de palabras en inglés).

Había pares de oraciones traducidas, pero no se indicaba qué palabra era la traducción de cuál. Por eso el artículo adoptó el algoritmo EM, utilizado en el reconocimiento de voz. Al principio se supone que todas las palabras tienen la misma probabilidad de traducirse por cada una de las otras, y se repite un cálculo que vuelve a contar basándose en esas probabilidades. En la figura de la derecha se puede pulsar “Repetir 1 vez” (los pares de oraciones son un ejemplo creado por este sitio).

El artículo estimó unos 81 millones de valores a partir de 40,000 pares de oraciones y escribió que the se vinculó automáticamente con le y la, y not con pas. De las traducciones de 73 oraciones nuevas, el 5% coincidía palabra por palabra y el 48% eran traducciones con sentido.

Parte asignada＝t（f｜e）÷ Σ_e′ t（f｜e′）

t（f | e）: probabilidad de que la palabra inglesa e se traduzca por la francesa f
e′: todas las palabras inglesas del mismo par de oraciones

Este código Python reproduce el mismo mecanismo que “Explorar”. Al pulsar ▶ Ejecutar, el resultado aparece debajo. Se pueden cambiar los números y volver a ejecutarlo.

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 · Redes neuronales

Repartir el trabajo entre expertos

¿Qué ocurre cuando una sola red neuronal aprende trabajos distintos?

Cuando una red aprende trabajos distintos, estos interfieren entre sí y el aprendizaje se vuelve más lento. En 1991, Jacobs, Jordan, Nowlan y Hinton afrontaron este problema combinando varias redes expertas con una red de selección que calcula la probabilidad de asignar el trabajo a cada experto.

Como midieron el error de una manera que hace que los expertos compitan en lugar de cooperar, cada uno termina ocupándose solo de una parte de los datos de entrada. La figura de la derecha es un ejemplo en el que 2 expertos, que solo pueden trazar líneas rectas, aprenden una distribución de puntos con formas distintas a izquierda y derecha. La franja inferior representa la red de selección.

En 2017 también se creó un mecanismo a gran escala que elige solo unos pocos de los expertos mejor situados entre miles de ellos (capítulo 11).

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

y_k: salida del experto k
g_k: probabilidad de que la red de selección asigne el trabajo a k (la suma es 1)

Lo que se cree saberLo que suele decirse:La mezcla de expertos (MoE) es una nueva técnica para los grandes modelos de lenguaje de los últimos años
Según la fuente original:La idea básica ya estaba en el artículo de 1991. El propio artículo de 2017 describe la historia del método con las palabras “Desde su introducción hace más de dos décadas” (traducción) y señala que ha habido mucha investigación.

Error medio en cada repetición

Este código Python reproduce el mismo mecanismo que “Explorar”. Al pulsar ▶ Ejecutar, el resultado aparece debajo. Se pueden cambiar los números y volver a ejecutarlo.

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 · Aprendizaje por refuerzo

Aprender solo de victorias y derrotas

¿Se puede aprender a jugar bien sin que se enseñe la jugada correcta en cada turno?

En TD-Gammon, creado por Tesauro, de IBM, en 1992, una red neuronal de 3 capas jugó cientos de miles de partidas de backgammon contra sí misma y aprendió solo de las victorias y derrotas (aprendizaje por refuerzo). La versión que jugó 1.5 millones de partidas quedó a solo 1 punto del antiguo campeón mundial Robertie en un encuentro de 40 partidas.

La clave es la diferencia temporal (TD). En cada jugada, la predicción de la probabilidad de ganar desde una posición se acerca un poco a la predicción de la siguiente posición. La victoria o derrota final se transmite poco a poco a las posiciones anteriores. La figura de la derecha realiza el mismo aprendizaje con el tres en raya. También se puede jugar con × pulsando una casilla vacía.

En agosto de 1997, Takeshi Murakami, campeón mundial de Othello, perdió con 0 victorias y 6 derrotas ante Logistello, un programa que había aprendido mediante partidas contra sí mismo y otros métodos. Logistello funcionaba en una computadora personal corriente.

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

V（s）: predicción de la probabilidad de ganar desde la posición s
α: proporción en que se acerca la predicción

Lo que se cree saberLo que suele decirse:La IA empezó a cambiar la forma de jugar de las personas con AlphaGo en el go (2016)
Según la fuente original:El libro de Nilsson cita un texto que dice que, en la década de 1990, los mejores jugadores de backgammon imitaron a TD-Gammon y cambiaron su forma de jugar las aperturas.

200 partidas contra un rival que juega al azar (morado＝derrotas, gris＝empates)

Este código Python reproduce el mismo mecanismo que “Explorar”. Al pulsar ▶ Ejecutar, el resultado aparece debajo. Se pueden cambiar los números y volver a ejecutarlo.

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 · Aprendizaje automático

El centro del camino más ancho

Si se pueden trazar muchas líneas para separar los datos, ¿cuál es la mejor?

Vapnik y sus colegas pensaron que, si se traza una línea en el centro del camino más ancho, tan lejos como sea posible de ambos tipos de datos, también se clasificarán bien los datos que se ven por primera vez. La mitad de la anchura del camino se llama margen.

Solo los pocos puntos que tocan los bordes del camino determinan la línea de separación (vectores de soporte＝puntos que sostienen el camino). En la figura de la derecha se pueden arrastrar los puntos. Al mover un punto rodeado por un círculo cambia el camino, pero al mover los demás la línea no cambia mientras no entren en el camino.

En los dígitos manuscritos de MNIST, el método de Cortes y Vapnik logró una tasa de error del 1.1%, cercana al resultado de LeNet. Sin embargo, reconocer un carácter requería unos 14 millones de multiplicaciones y sumas.

Maximizar el margen＝1／ ‖w‖　　condición: y_i（w · x_i ＋b）≥ 1

w, b: parámetros que determinan la línea de separación
y_i: grupo del punto i (＋1 o −1)

Lo que se cree saberLo que suele decirse:Las redes neuronales siguieron siendo protagonistas después de la década de 1980
Según la fuente original:Durante los 10 años en torno al año 2000, métodos distintos de las redes neuronales, como las máquinas de vectores de soporte, dominaban muchas tareas prácticas de reconocimiento (Schmidhuber, 2014).

Este código Python reproduce el mismo mecanismo que “Explorar”. Al pulsar ▶ Ejecutar, el resultado aparece debajo. Se pueden cambiar los números y volver a ejecutarlo.

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 · Redes neuronales

Una caja de memoria y sus puertas

¿Cómo puede una red recordar una pista de hace mucho tiempo?

Al entrenar una red recurrente con retropropagación del error, la señal de error se multiplica por un número parecido cada vez que retrocede 1 paso en el tiempo. Si es menor que 1, desaparece; si es mayor, crece. Hochreiter analizó este problema en 1991.

En 1997, la LSTM de Hochreiter y Schmidhuber incorporó una . El contenido de la caja se conecta consigo mismo con peso 1 y se transporta sin desaparecer. Una puerta de entrada y una puerta de salida se abren y cierran para introducir y sacar información (en 1997 solo había estas 2 puertas). En la figura de la derecha se puede pulsar “Hacer fluir”. El artículo decía que podía utilizar pistas separadas por más de 1,000 pasos.

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

c: contenido de la caja
i, o: puerta de entrada y puerta de salida (compuertas de entrada y salida; de 0 a 1)
g: valor que se quiere introducir

Este sitio fijó a mano los pesos de la LSTM de la figura (no se entrenó). El gráfico inferior, que se abre con “Más detalles”, muestra la señal de error que queda al multiplicar en cada paso por el “Factor”.

Número de pasos hacia atrás y señal restante (escala vertical en múltiplos de 10)

Este código Python reproduce el mismo mecanismo que “Explorar”. Al pulsar ▶ Ejecutar, el resultado aparece debajo. Se pueden cambiar los números y volver a ejecutarlo.

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 · Búsqueda

Podar las ramas que no hace falta leer

¿Una computadora que examina unos 200 millones de posiciones por segundo las exploró todas?

En mayo de 1997, Deep Blue, la computadora de IBM dedicada al ajedrez, derrotó en Nueva York al campeón mundial Kasparov con 2 victorias, 1 derrota y 3 empates (3.5 a 2.5). Su fuerza provenía de la capacidad de cálculo por fuerza bruta, que examinaba unos 200 millones de posiciones por segundo, y de los registros de partidas de grandes maestros.

Aun así, no puede explorarlo todo (la explosión combinatoria del capítulo 5). La poda alfa-beta corta una rama sin seguir explorándola cuando se sabe que el rival tiene una jugada mejor. En la figura de la derecha se puede comparar el número de hojas exploradas. La respuesta sigue siendo la misma y el número de hojas exploradas disminuye.

La predicción de Simon y sus colegas de 1957, “en un plazo de diez años, una computadora digital será la campeona mundial de ajedrez” (traducción), se cumplió de otra forma unos 40 años después (capítulo 3).

Cuando α ≥ β, no se explora el resto de esa rama

α: puntuación mínima que ya se ha asegurado
β: puntuación máxima que el rival permitirá obtener

Lo que se cree saberLo que suele decirse:La victoria de Deep Blue fue una victoria de la IA
Según la fuente original:La propia IBM escribió en su página de entonces: “¿Deep Blue utiliza inteligencia artificial? La respuesta breve es ‘no’.” (traducción). Explicaba que se hizo fuerte gracias a una enorme capacidad de cálculo y a los registros de partidas de grandes maestros.

Este código Python reproduce el mismo mecanismo que “Explorar”. Al pulsar ▶ Ejecutar, el resultado aparece debajo. Se pueden cambiar los números y volver a ejecutarlo.

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 · Robots

Dejar de pensar antes de moverse

¿Puede un robot sin mapa recorrer toda una habitación?

En septiembre de 1985, Brooks, del MIT, presentó un método para diseñar el comportamiento de un robot en capas. Sobre las capas inferiores (como evitar choques) se superponen capas de comportamiento más avanzado, y una capa superior suprime una inferior solo cuando hace falta. En un artículo de 1991 escribió: “las representaciones explícitas y los modelos del mundo simplemente estorban” (traducción).

El material de presentación del robot aspirador Roomba, que salió a la venta en 2002 por 199.95 dólares, tampoco habla de un mapa. Repite recorridos en espiral, junto a las paredes y en línea recta, y pasa de 2 a 5 veces por cada parte de la habitación. En la figura de la derecha se pueden añadir y quitar capas (la habitación es un ejemplo creado por este sitio).

En Japón, Sony presentó AIBO en 1999 y Honda presentó ASIMO en 2000.

Movimiento producido＝movimiento de la capa más alta que está activa ahora

Capa: conjunto de comportamientos, como avanzar en línea recta, seguir una pared o girar en espiral

Lo que se cree saberLo que suele decirse:Durante el invierno de la IA de finales de la década de 1980 y la década de 1990, la investigación se detuvo
Según la fuente original:En esa misma época, Brooks describía el invierno y, a la vez, mostraba otra vía para construir inteligencia a partir del cuerpo y el movimiento, y creaba robots que se desplazaban.

Proporción del suelo recorrido (morado＝junto a las paredes, verde＝centro)

Este código Python reproduce el mismo mecanismo que “Explorar”. Al pulsar ▶ Ejecutar, el resultado aparece debajo. Se pueden cambiar los números y volver a ejecutarlo.

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 · Predicciones

Prolongar la línea de “duplicaciones”

¿Se puede predecir el año en que la computadora igualará al cerebro a partir de su mejora de rendimiento?

En 1998, Moravec, de la Universidad Carnegie Mellon, estimó que el funcionamiento del cerebro humano requiere unos 100 millones de MIPS (1 MIPS equivale a 1 millón de instrucciones por segundo). Predijo que el hardware necesario estaría “disponible en máquinas baratas en la década de 2020” (traducción). También escribió que 1960–1990 había sido “el gélido invierno de las computadoras de 1 MIPS” (traducción).

El año predicho cambia mucho según cómo se establezca el tiempo de duplicación. Según el artículo, en 1990 una computadora personal económica ofrecía 1 MIPS por 1,000 dólares. El tiempo de duplicación era de 18 meses en la década de 1980 y de 12 meses a finales de la de 1990. En la figura de la derecha se puede cambiar ese tiempo y observar el resultado.

En 1993, Vinge escribió: “En un plazo de treinta años, tendremos los medios tecnológicos para crear una inteligencia sobrehumana” (traducción).

Año de llegada＝1990＋tiempo de duplicación (años) × log₂（100 millones）

log₂（100 millones）: aproximadamente 26.6 (cuántas veces hay que duplicar para multiplicar por 100 millones)

Lo que se cree saberLo que suele decirse:La singularidad es una idea de Kurzweil (año 2045)
Según la fuente original:Vinge la llamó the Singularity en 1993 y escribió que la inteligencia sobrehumana llegaría entre 2005 y 2030. El propio Vinge explicó que la palabra se remontaba a von Neumann y la idea, a I. J. Good.

Medir el frío del invierno con números

¿No llegó el invierno a Japón?

De los símbolos al aprendizaje

Caer al fondo de un valle de energía

Neuronas que actúan según probabilidades

Conectar solo entre 2 capas

Bajar por la pendiente del error

Propagar el error hacia atrás

Comprimir 8 en 3

Añadir el estado anterior de la red

Reutilizar la misma ventana

Pasar los caracteres dudosos a personas

Probabilidades de textos paralelos

Repartir el trabajo entre expertos

Aprender solo de victorias y derrotas

El centro del camino más ancho

Una caja de memoria y sus puertas

Podar las ramas que no hace falta leer

Dejar de pensar antes de moverse

Prolongar la línea de “duplicaciones”

Lo que aún no se sabe en este capítulo

“McCarthy introdujo en MYCIN ‘líquido amniótico de un paciente varón’ y el sistema lo aceptó” — Los propios desarrolladores lo registraron en una nota de un libro