AI के तीसरे उछाल का शिखर | AI का पूरा इतिहास

012015·सीखने की तरकीबें

परत के इनपुट हर बार एक पैमाने पर

10 या 20 परतों वाले नेटवर्क को सीखने में इतनी मुश्किल क्यों होती थी?

गहरा नेटवर्क आउटपुट की त्रुटि को इनपुट की ओर वापस भेजकर अपने वज़न सुधारता है (बैकप्रोपेगेशन, अध्याय 8)। लौटते सिग्नल को हर परत में वज़न और न्यूरॉन के ढलान से गुणा किया जाता है। S के आकार वाले सिग्मॉइड फ़ंक्शन का ढलान 0.25 या उससे कम होता है, इसलिए केवल ढलानों से ही सिग्नल 10 परतों में लगभग 1/1,000,000 रह जाता है।

2010〜2012 के ReLU और वज़नों के शुरुआती मान तय करने की तरकीबें हमने अध्याय 9 में देखीं। 2015 में Google के सर्गेई इओफ़े (Sergey Ioffe) और क्रिश्चियन सेगेडी (Christian Szegedy) का बैच नॉर्मलाइज़ेशन किसी परत में आने वाले मानों का औसत 0 और विचरण 1 करता है, हर बार एक साथ सीखने वाले डेटा के छोटे समूह के लिए अलग-अलग। दाईं ओर का चित्र 20 परतों वाले नेटवर्क में आगे जाने वाले मानों का फैलाव (नीला) और लौटने वाला सिग्नल (बैंगनी) मापता है। ReLU, वज़नों के शुरुआती मान और बैच नॉर्मलाइज़ेशन बदलकर तुलना करें।

लौटने वाला सिग्नल ≈ आउटपुट का सिग्नल × (w₁·f′₁) × (w₂·f′₂) × … × (w_L·f′_L)

f′: न्यूरॉन का ढलान (सिग्मॉइड के लिए 0.25 या कम, ReLU के लिए 0 या 1)
w: वज़न
L: परतों की संख्या

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:बैच नॉर्मलाइज़ेशन इसलिए काम करता है क्योंकि वह परत में आने वाले मानों के वितरण में बदलाव सुधारता है
मूल स्रोत के अनुसार:शोधपत्र ने यही माना और लिखा कि वह उसी सटीकता तक सीखने के 1/14 चरणों में पहुँचा। MIT के 2018 के शोधपत्र ने अपने शीर्षक में (अनुवाद) लिखा और बताया कि वितरण को जानबूझकर बदलने पर भी नेटवर्क लगभग उतनी ही अच्छी तरह सीख पाया। यह क्यों काम करता है, इस पर अभी अंतिम निर्णय नहीं हुआ है।

यह “आज़माएँ” वाली प्रक्रिया का Python कोड है। ▶ चलाएँ दबाने पर नीचे नतीजा दिखेगा। संख्याएँ बदलकर फिर से चलाकर देखें।

u10_vanishing_signal.py

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

import math
import random

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

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

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

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

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

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

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

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

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

022012〜2015·ओवरफ़िटिंग

ड्रॉपआउट और नॉलेज डिस्टिलेशन

ट्रेनिंग डेटा पर ज़रूरत से ज़्यादा फिट होने वाली ओवरफ़िटिंग को कैसे रोकें?

ट्रेनिंग डेटा पर सभी उत्तर सही हों, लेकिन नए डेटा पर गलतियाँ हों। इसे ओवरफ़िटिंग कहते हैं। अध्याय 9 में देखा गया 2012 का ड्रॉपआउट, हर बार एक डेटा उदाहरण दिखाते समय छिपी परतों के आधे न्यूरॉनों को यादृच्छिक रूप से आराम देता है। इसका असर कई पतले नेटवर्कों का औसत लेने जैसा होता है।

दाईं ओर के चित्र में 12 बिंदुओं (इस साइट का बनाया उदाहरण) पर एक वक्र फिट करें। अगर किसी न्यूरॉन को आराम न दें, तो नए बिंदुओं (नीले गोले) पर त्रुटि बढ़ती जाती है।

2015 का नॉलेज डिस्टिलेशन बड़े नेटवर्क के आउटपुट की संभावनाओं को तापमान T से नरम करता है और छोटे नेटवर्क को उनकी नकल करना सिखाता है। “नॉलेज डिस्टिलेशन” में T बढ़ाने पर सही उत्तर के अलावा दूसरे उत्तरों के बीच के अंतर दिखते हैं। शोधपत्र का विचार है कि इनमें भी ज्ञान है।

नरम उत्तर q_i ＝exp(z_i／T) ÷ Σ_j exp(z_j／T)

z_i: आउटपुट i का स्कोर
T: तापमान (1 पर सामान्य संभावनाएँ; बड़ा होने पर वितरण अधिक सपाट)

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:नॉलेज डिस्टिलेशन की शुरुआत 2015 में जेफ़्री हिंटन (Geoffrey Hinton) और उनके साथियों ने की
मूल स्रोत के अनुसार:2015 का शोधपत्र खुद कहता है कि इसी विधि के एक रूप की शुरुआत रिच करुआना (Rich Caruana) और उनके साथियों ने 2006 में की थी।

सीखे हुए बिंदुओं पर त्रुटि (ठोस रेखा) और नए बिंदुओं पर त्रुटि (बिंदीदार रेखा)। नीला＝आराम नहीं, हरा＝दूसरा नेटवर्क। ऊर्ध्वाधर पैमाना हर चरण में 10 गुना

यह “आज़माएँ” वाली प्रक्रिया का Python कोड है। ▶ चलाएँ दबाने पर नीचे नतीजा दिखेगा। संख्याएँ बदलकर फिर से चलाकर देखें।

u10_dropout.py

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

import numpy as np

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

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

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

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

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

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

032013·शब्दों के वेक्टर

शब्दों को जोड़ना

शब्दों को संख्याओं के समूह में बदलकर क्या अर्थों के संबंध भी गणना से निकाले जा सकते हैं?

2013 में Google के टोमाश मिकोलोव (Tomas Mikolov) और उनके साथियों का word2vec हर शब्द को कुछ सौ संख्याओं के समूह (वेक्टर) से दर्शाता है। वह बहुत सारे पाठ से इस तरह सीखता है कि समान उपयोग वाले शब्द पास आ जाएँ। 1.6 अरब शब्दों से 10 लाख शब्दों के 300 आयाम वाले वेक्टर, 1 CPU पर 1 दिन से कम समय में बनाए जा सके।

इन वेक्टरों के जोड़ और घटाव से अर्थों के संबंध दिखाए जा सके। शोधपत्र ने biggest − big＋small का उत्तर smallest आता है या नहीं, ऐसे सवालों के सही उत्तरों की दर से प्रदर्शन मापा। दाईं ओर के चित्र (इस साइट का बनाया 2 आयाम वाला उदाहरण) में 3 शब्द दबाएँ।

उत्तर सबसे पास वाला शब्द था, सवाल के 3 शब्दों को हटाने के बाद (यह टिप्पणी शोधपत्र के सितंबर वाले संस्करण में जोड़ी गई)। उन्हें न हटाएँ तो इस उदाहरण में पहले स्थान पर small आता है।

v(उत्तर) ≈ v(biggest) − v(big)＋v(small)

v(शब्द): उस शब्द का वेक्टर
उत्तर: गणना से मिले बिंदु के सबसे पास का शब्द (सवाल के 3 शब्द छोड़कर)

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:king − man＋woman＝queen की गणना word2vec के शोधपत्र ने खोजी और उसका उत्तर बिल्कुल सही आता है
मूल स्रोत के अनुसार:जनवरी 2013 का शोधपत्र खुद इस उदाहरण को पिछले शोध के परिणाम के रूप में उद्धृत करता है। उत्तर खोजने से पहले सवाल के 3 शब्द संभावित उत्तरों में से हटा दिए गए थे।

यह “आज़माएँ” वाली प्रक्रिया का Python कोड है। ▶ चलाएँ दबाने पर नीचे नतीजा दिखेगा। संख्याएँ बदलकर फिर से चलाकर देखें।

u10_skipgram.py

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

import numpy as np

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

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

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

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

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

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

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

042013〜2015·रिइनफ़ोर्समेंट लर्निंग

केवल स्कोर से खेलना सीखना

नियम सिखाए बिना, केवल स्क्रीन और स्कोर से क्या कोई खेल में अच्छा हो सकता है?

रिइनफ़ोर्समेंट लर्निंग में कोशिश और गलती से सीखकर उन कामों को अधिक किया जाता है जिनसे अंक मिले। Q-लर्निंग एक तालिका में रखती है कि किसी स्थिति में कोई कदम उठाने से भविष्य में कितने अंक मिल सकते हैं (Q-मान), और हर कदम के बाद तालिका को थोड़ा बदलती है। दाईं ओर की भूलभुलैया (इस साइट का बनाया उदाहरण) में देखें कि लक्ष्य का इनाम कैसे एक-एक कदम पीछे वाले खानों तक पहुँचता है।

दिसंबर 2013 में लंदन की DeepMind के DQN ने तालिका की जगह कन्वोल्यूशनल न्यूरल नेटवर्क इस्तेमाल किया। उसने स्क्रीन के पिक्सेल सीधे इनपुट लिए और Q-लर्निंग की संशोधित विधि से सीखा। 7 पुराने वीडियो गेमों में से 6 में उसने पुरानी विधियों को और 3 में अनुभवी मानव खिलाड़ियों को पीछे छोड़ा। Nature के 2015 के शोधपत्र में उसी एक व्यवस्था ने 49 गेम सीखे।

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

s: वर्तमान स्थिति
a: कदम
r: मिला इनाम
s′: अगली स्थिति
α: सीखने की दर
γ: भविष्य के इनाम का वज़न

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:AI ने वीडियो गेम में मनुष्यों को पीछे छोड़ दिया
मूल स्रोत के अनुसार:2015 के शोधपत्र के शब्द थे (अनुवाद)। 49 में से 29 गेमों में ही मनुष्य के स्कोर के 75% या अधिक अंक मिले। शोधपत्र खुद लिखता है कि आगे की योजना माँगने वाले गेम (जैसे Montezuma's Revenge) अभी भी बड़ी चुनौती हैं।

हर प्रयास का परिणाम (हरा＝लक्ष्य, बैंगनी＝गड्ढा, धूसर＝समय समाप्त)

यह “आज़माएँ” वाली प्रक्रिया का Python कोड है। ▶ चलाएँ दबाने पर नीचे नतीजा दिखेगा। संख्याएँ बदलकर फिर से चलाकर देखें।

u10_q_learning.py

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

import random

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

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

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

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

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

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

052013〜2014·ट्रांसफ़र लर्निंग

सीखे हुए नेटवर्क का फिर से उपयोग

जिस काम के लिए केवल कुछ दर्जन तस्वीरें हों, उसमें भी क्या डीप लर्निंग इस्तेमाल हो सकती है?

2012 के AlexNet ने ImageNet प्रतियोगिता की लगभग 12 लाख तस्वीरों और 1000 श्रेणियों से सीखा। अक्टूबर 2013 में कैलिफ़ोर्निया विश्वविद्यालय, बर्कली के जेफ़ डोनाह्यू (Jeff Donahue) और उनके साथियों के DeCAF ने उसी आकार के नेटवर्क के वज़न स्थिर रखे और आउटपुट के पास वाली परत की प्रतिक्रियाओं (4096 संख्याएँ) को दूसरे काम के लिए फ़ीचर बनाया। Caltech-101 में हर श्रेणी की केवल 30 तस्वीरों से सीखकर, केवल एक रैखिक क्लासिफ़ायर जोड़ने से 86.9% सही पहचाना। यह उस समय के सर्वोत्तम परिणाम से बेहतर था, जिसमें हाथ से बनाए 5 प्रकार के फ़ीचर जोड़े गए थे। इसे ट्रांसफ़र लर्निंग कहते हैं।

पूरे नेटवर्क को नए काम के डेटा पर छोटे कदमों से फिर सिखाना फ़ाइन-ट्यूनिंग है। अगले पृष्ठ-युग्म के R-CNN में फ़ाइन-ट्यूनिंग से mAP 8 अंक बढ़ा।

दाईं ओर का चित्र (इस साइट का बनाया 8×8 उदाहरण) एक रेखा पहचानना सीख चुके नेटवर्क को 2 रेखाओं के जोड़े पहचानने में इस्तेमाल करता है। उदाहरणों की संख्या बदलकर तुलना करें।

नया उत्तर ＝softmax( W_नया · φ(x) )

φ(x): पहले सीखी गई परतों की प्रतिक्रिया (DeCAF में 4096 संख्याएँ; स्थिर रखने पर नहीं बदलती)
W_नया: नई अंतिम परत जिसे सिखाया जाता है

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:ट्रांसफ़र लर्निंग का विचार डीप लर्निंग के युग में जन्मा
मूल स्रोत के अनुसार:जापानी कृत्रिम बुद्धिमत्ता सोसायटी की पत्रिका के 2010 के लेख ने लिखा, (अनुवाद), और कहा कि 1995 की NIPS कार्यशाला से यह मशीन लर्निंग का एक क्षेत्र बना। DeCAF का शोधपत्र भी संबंधित कामों से सीखने के शोध का इतिहास 1996〜1997 से गिनता है।

एक-एक परत को मापना

2014 में जेसन योसिन्स्की (Jason Yosinski) और उनके साथियों ने ImageNet को A और B में बाँटा, प्रत्येक में 500 श्रेणियाँ और लगभग 645,000 तस्वीरें। A पर सीखी निचली परतें B में कॉपी की गईं। परतें 1〜2 लगभग जस की तस इस्तेमाल हो सकीं। परतों 3〜5 में पड़ोसी परतों का नाज़ुक तालमेल टूटने से प्रदर्शन गिरा, और परतों 6〜7 में काम A के लिए विशेषज्ञता बाधा बनी। कॉपी करके फ़ाइन-ट्यूनिंग करने पर, B पर शुरू से सीखने की तुलना में औसतन 1.6% अधिक सही पहचाना। इस परिणाम को केवल डेटा की कमी दूर करने की तरकीब मानकर नहीं समझाया जा सकता था।

शुरू से सीखना: 2018 में FAIR के काइमिंग ही (Kaiming He) और उनके साथियों ने बताया कि COCO की वस्तु पहचान में शुरू से सीखने वाला नेटवर्क भी लंबे समय तक सीखने पर प्री-ट्रेनिंग वाले की बराबरी कर सकता है। लेकिन केवल 1000 ट्रेनिंग तस्वीरें होने पर प्री-ट्रेनिंग का AP 9.9 था और शुरू से सीखने का 3.5।

उसी समय: मार्च 2014 में स्वीडन के KTH के अली शरीफ़ रज़ावियन (Ali Sharif Razavian) और उनके साथियों ने भी सार्वजनिक नेटवर्क OverFeat के फ़ीचरों पर केवल रैखिक SVM जोड़कर दृश्य, बारीक श्रेणियाँ, छवि खोज आदि आज़माए।

उस समय जापान में: तोशिहिरो कामिशिमा (Toshihiro Kamishima, राष्ट्रीय उन्नत औद्योगिक विज्ञान और प्रौद्योगिकी संस्थान) के 2010 के लेख में नेगेटिव ट्रांसफ़र के शोध का भी परिचय है, जिसमें मूल डेटा के उपयोग से उलटे अनुमान बिगड़ जाते हैं।

यह “आज़माएँ” वाली प्रक्रिया का Python कोड है। ▶ चलाएँ दबाने पर नीचे नतीजा दिखेगा। संख्याएँ बदलकर फिर से चलाकर देखें।

u10_transfer_finetune.py

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

import numpy as np

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

rng = np.random.default_rng(2014)

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

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

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

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

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

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

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

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

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

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

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

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

062013〜2015·वस्तु पहचान

कहाँ, क्या और कितना है

तस्वीर में चीज़ों को चौकोर बक्सों से घेरकर उनके नाम कैसे बताए जाएँ?

छवि वर्गीकरण हर तस्वीर के लिए एक उत्तर देता है। वस्तु पहचान तस्वीर में हर चीज़ के चारों ओर चौकोर बक्सा बनाती है और उसका नाम बताती है।

नवंबर 2013 में कैलिफ़ोर्निया विश्वविद्यालय, बर्कली के रॉस गर्शिक (Ross Girshick) और उनके साथियों के R-CNN ने बिना सीखने वाली विधि से लगभग 2000 संभावित बक्से बनाए। फिर हर बक्से को अलग-अलग CNN से गुज़ारा और हर श्रेणी के SVM से स्कोर दिया। एक ही चीज़ के चारों ओर कई बक्से रह जाते हैं, इसलिए अधिक स्कोर वाले बक्से से बहुत ओवरलैप होने वाले बक्से हटा दिए जाते हैं (नॉन-मैक्सिमम सप्रेशन)। सम्मेलन वाले संस्करण का PASCAL VOC 2012 पर mAP 53.3% था, जो पिछले सर्वोत्तम से बहुत अधिक था। लेकिन GPU पर एक तस्वीर में 13 सेकंड लगे।

जून 2015 में वॉशिंगटन विश्वविद्यालय के जोसेफ़ रेडमन (Joseph Redmon) और उनके साथियों का YOLO तस्वीर को 7×7 ग्रिड में बाँटता है और नेटवर्क को केवल एक बार चलाकर हर खाने के 2 बक्से (कुल 98) और श्रेणियाँ एक साथ निकालता है। वह 63.4% पर 1 सेकंड में 45 तस्वीरें संभालता था। उसी महीने शाओचिंग रेन (Shaoqing Ren) और उनके साथियों के Faster R-CNN ने संभावित बक्से भी नेटवर्क से बनवाए और 73.2% पर 1 सेकंड में 5 तस्वीरें संभालीं। दाईं ओर के चित्र में तुलना करें।

IoU＝ ओवरलैप का क्षेत्रफल ÷ दोनों को मिलाने से बना क्षेत्रफल

IoU: अनुमानित बक्से और सही बक्से के ओवरलैप का अनुपात (1 पर पूरा मेल, 0 पर कोई ओवरलैप नहीं)

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:YOLO ने पहली बार वास्तविक समय में वस्तुएँ खोजीं
मूल स्रोत के अनुसार:YOLO का शोधपत्र खुद पहले से 1 सेकंड में 30 तस्वीरें संभालने वाले DPM का उल्लेख करता है (2014 में सादेगी (Sadeghi) और फ़ॉर्सिथ (Forsyth))। YOLO का दावा था कि वास्तविक समय की विधियों में सटीकता दोगुनी से अधिक हुई (26.1% → 63.4%)। 1 सेकंड में 0.5 तस्वीरें संभालने वाला Fast R-CNN (70.0%) अधिक सटीक था, और YOLO में स्थान की गलतियाँ अधिक थीं।

R-CNN के अंदर

नाम Regions with CNN features (क्षेत्र और CNN के फ़ीचर) से आया है। संभावित बक्से बनाने की विधि (selective search) और SVM कंप्यूटर विज़न के पुराने औज़ार थे। शोधपत्र के अंत ने पुराने औज़ारों और डीप लर्निंग के बारे में कहा, (अनुवाद)। चरणों में फ़ीचर बनाने के शुरुआती प्रयास के रूप में शोधपत्र कुनिहिको फ़ुकुशिमा (Kunihiko Fukushima) के नियोकोग्निट्रॉन (1980) का भी उल्लेख करता है। संभावित बक्सों को 227×227 में बदलकर CNN से गुज़ारा गया। पहले संस्करण (नवंबर 2013) का VOC 2007 पर परिणाम 48% था, जो सम्मेलन वाले संस्करण में बढ़ा।

YOLO की कमज़ोरियाँ: YOLO के शोधपत्र में सही श्रेणी और 0.5 से अधिक IoU होने पर उत्तर सही माना जाता है। हर खाने के लिए YOLO केवल 2 बक्से और 1 श्रेणी निकाल सकता है, इसलिए शोधपत्र खुद लिखता है कि पक्षियों के झुंड जैसी छोटी चीज़ों के समूह पहचानना कठिन है। पहले संस्करण (जून 2015) में कुल 49 बक्से थे।

Faster R-CNN के संभावित बक्से: Microsoft Research के रेन और उनके साथी फ़ीचर मैप के हर स्थान पर 3 आकार × 3 लंबाई-चौड़ाई अनुपात के कुल 9 आधार बक्से (ऐंकर) रखते हैं। नेटवर्क बताता है कि उनमें वस्तु होने की कितनी संभावना है और उनके स्थान को कैसे सुधारें। हर तस्वीर में 300 संभावित बक्से हैं। 2015 की COCO वस्तु पहचान प्रतियोगिता में ResNet के साथ इसे जोड़ने पर पहला स्थान मिला।

उस समय जापान में: 2017 में टोक्यो विश्वविद्यालय और Preferred Networks के लोगों ने Chainer में Faster R-CNN और SSD सिखाने की लाइब्रेरी ChainerCV जारी की। उन्होंने Faster R-CNN के शोधपत्र के 69.9% की तुलना में 70.5% दोहराया।

यह “आज़माएँ” वाली प्रक्रिया का Python कोड है। ▶ चलाएँ दबाने पर नीचे नतीजा दिखेगा। संख्याएँ बदलकर फिर से चलाकर देखें।

u10_object_detect.py

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

import random

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

random.seed(2015)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

072013·जनरेटिव मॉडल (1)

संकुचित करें, फिर फैलाएँ

डेटा को 2 संख्याओं में समेट दें, तो क्या उन 2 संख्याओं से नया डेटा बनाया जा सकता है?

ऑटोएन्कोडर ऐसा नेटवर्क है जिसे इनपुट जैसी ही चीज़ आउटपुट में देना सिखाया जाता है और जिसकी बीच की परत पतली होती है। पहला हिस्सा (एन्कोडर) कुछ संख्याओं में समेटता है और दूसरा हिस्सा (डीकोडर) उसे वापस बनाता है। यह बनावट 1985〜1987 में मौजूद थी, लेकिन समेटी गई संख्याओं के बीच की जगह में बहुत खाली हिस्से होते हैं। उनसे डेटा बनाने पर उसका आकार बिगड़ जाता है।

दिसंबर 2013 में ऐम्स्टर्डैम विश्वविद्यालय के डीडेरिक किंग्मा (Diederik Kingma) और मैक्स वेलिंग (Max Welling) के VAE (वैरिएशनल ऑटोएन्कोडर) ने समेटी गई संख्याओं के वितरण को औसत 0 और फैलाव 1 वाले सामान्य वितरण के पास लाना सीखा। इसलिए सामान्य वितरण से संख्याएँ चुनकर नया डेटा बनाया जा सकता है। दाईं ओर इस साइट द्वारा Python में सिखाया गया उदाहरण है, जिसमें 12×12 चेहरे 2 संख्याओं में समेटे जाते हैं। दोनों की तुलना करें।

z＝μ＋σ × ε (ε औसत 0 और फैलाव 1 वाली यादृच्छिक संख्या है)

μ: एन्कोडर से निकला औसत
σ: फैलाव
z: चुना हुआ बिंदु

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:ऑटोएन्कोडर की शुरुआत 2006 में जेफ़्री हिंटन (Geoffrey Hinton) ने की
मूल स्रोत के अनुसार:इनपुट को पतली परत से गुज़ारकर उसी चीज़ को आउटपुट बनवाने का काम 1985 और 1986 के शोधपत्रों में पहले से था। 2006 का शोधपत्र खुद भी गहरे ऑटोएन्कोडर के अच्छे काम करने के बारे में लिखता है, (अनुवाद)।

यह “आज़माएँ” वाली प्रक्रिया का Python कोड है। ▶ चलाएँ दबाने पर नीचे नतीजा दिखेगा। संख्याएँ बदलकर फिर से चलाकर देखें।

u10_vae_faces.py

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

import numpy as np

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

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

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

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

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

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

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

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

082014·जनरेटिव मॉडल (2)

नकली नोट बनाने वाले और पुलिस

असली जैसी चीज़ बनाने की क्षमता क्या उसे पकड़ने वाले प्रतिद्वंद्वी से मुकाबला करके बढ़ती है?

जून 2014 में मॉन्ट्रियल विश्वविद्यालय के इयन गुडफ़ेलो (Ian Goodfellow) और उनके साथियों के GAN (जनरेटिव ऐडवर्सेरियल नेटवर्क) ने डेटा बनाने वाले नेटवर्क G और असली-नकली पहचानने वाले नेटवर्क D के बीच मुकाबला कराया। शोधपत्र ने G की तुलना (अनुवाद) और D की (अनुवाद) से की। अंत की स्थिति वह है जिसमें D दोनों को अलग नहीं पहचान पाता।

दाईं ओर एक संख्या रेखा पर GAN है (इस साइट का बनाया छोटा उदाहरण)। चित्र खुलते ही नकली डेटा का बैंगनी पहाड़ असली डेटा के नीले पहाड़ के पास आता है और D की रेखा 0.5 के पास जाती है। G और D की सीखने की गति के मेल के अनुसार, नकली डेटा एक जगह अटक सकता है या आगे-पीछे डोल सकता है। मुकाबला हमेशा साफ़ तौर पर किसी स्थिर परिणाम तक नहीं पहुँचता।

D, log D(x)＋log(1 − D(G(z))) को बड़ा करता है; G, log(1 − D(G(z))) को छोटा करता है

x: असली डेटा
z: यादृच्छिक संख्या
G(z): बनाया गया नकली डेटा
D(·): असली मानने की संभावना

नकली डेटा का औसत (बैंगनी) और फैलाव (हरा)। बिंदीदार रेखाएँ असली डेटा के मान हैं

यह “आज़माएँ” वाली प्रक्रिया का Python कोड है। ▶ चलाएँ दबाने पर नीचे नतीजा दिखेगा। संख्याएँ बदलकर फिर से चलाकर देखें।

u10_gan_1d.py

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

import math
import random

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

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

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

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

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

092014〜2016·न्यूरल अनुवाद

पतली नली या अटेंशन

लंबा वाक्य अनुवाद करते समय नेटवर्क को मूल वाक्य का कौन-सा हिस्सा याद रखना चाहिए?

2014 में पूरे वाक्य को न्यूरल नेटवर्क से अनुवाद करने के शोध एक के बाद एक आए। जून के क्यॉन्गह्युन चो (Kyunghyun Cho) और उनके साथियों तथा सितंबर के इल्या सुत्सकेवर (Ilya Sutskever) और उनके साथियों के seq2seq ने वाक्य को निश्चित लंबाई वाले संख्याओं के समूह में समेटा और उससे अनुवाद निकाला। चो और उनके साथियों ने LSTM का सरल किया हुआ भाग (बाद का GRU) भी दिखाया। दाईं ओर “पतली नली (seq2seq·GRU)” में देखें कि वाक्य लंबा होने पर पुराने शब्द कैसे फीके पड़ते हैं।

उसी सितंबर में द्ज़मित्री बहदानाउ (Dzmitry Bahdanau) और उनके साथियों ने हर अनुवादित शब्द निकालते समय तय किया कि मूल वाक्य के हर शब्द पर कितना ध्यान देना है (वज़नों का कुल योग 1)। यह अटेंशन की शुरुआत थी। “अटेंशन (2014)” में अनुवादित शब्दों के कार्ड दबाएँ। 2016 में Google Translate पूरे वाक्य को पढ़ने वाली न्यूरल नेटवर्क विधि पर चला गया।

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

e_ij: i-वाँ अनुवादित शब्द निकालते समय मूल वाक्य के j-वें शब्द का स्कोर
h_j: मूल शब्द के फ़ीचरों का सार
c_i: ध्यान देकर इकट्ठा की गई जानकारी

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:अटेंशन का जन्म 2017 के Transformer शोधपत्र में हुआ
मूल स्रोत के अनुसार:यह 2014 के इस शोधपत्र में पहले से था, जिसका 2017 का शोधपत्र भी हवाला देता है। 2017 के शोधपत्र ने नया यह बताया कि नेटवर्क RNN के बिना केवल अटेंशन से बना था।

यह “आज़माएँ” वाली प्रक्रिया का Python कोड है। ▶ चलाएँ दबाने पर नीचे नतीजा दिखेगा। संख्याएँ बदलकर फिर से चलाकर देखें।

u10_attention_align.py

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

import math

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

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

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

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

102014·सीखने की विधि

लंबी सँकरी घाटी में उतरना

त्रुटि घटाने की दिशा में चलते समय हर कदम का आकार कैसे तय करें?

नेटवर्क सिखाने की बुनियादी विधि ग्रेडिएंट डिसेंट है। त्रुटि के भूभाग में ढलान की दिशा (ग्रेडिएंट) में थोड़ा-थोड़ा आगे बढ़ते हैं। भूभाग लंबी सँकरी घाटी हो, तो तीखी ढलान में ज़रूरत से ज़्यादा आगे जाते हैं और हल्की ढलान में मुश्किल से बढ़ते हैं (दाईं ओर गहरा नीला गोला)।

दिसंबर 2014 में डीडेरिक किंग्मा (Diederik Kingma) और जिमी बा (Jimmy Ba) का Adam हर वज़न के लिए ग्रेडिएंट का चल औसत और ग्रेडिएंट के वर्ग का चल औसत रखता है, और उनके अनुपात से कदम का आकार तय करता है। जिस दिशा में ग्रेडिएंट हमेशा बड़ा हो, उसमें छोटा कदम; जहाँ छोटा हो, वहाँ बड़ा कदम। इसलिए बैंगनी गोला थोड़ा आगे निकलते हुए घाटी के तल की ओर बढ़ता है। शुरुआती चल औसतों के 0 की ओर झुकाव को सुधारने वाली गणना (बायस सुधार) की तुलना के लिए “बायस सुधार” की टिक हटाएँ।

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

g: ग्रेडिएंट
m, v: ग्रेडिएंट और उसके वर्ग के चल औसत
m̂, v̂: सुधारे गए मान
η: सीखने की दर (कदम का आकार)

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:Adam ऐसी विधि है जिसके हमेशा स्थिर परिणाम तक पहुँचने का प्रमाण है
मूल स्रोत के अनुसार:Google के रेड्डी (Reddi) और उनके साथियों के 2018 के शोधपत्र ने एक सरल समस्या में भी Adam के सर्वोत्तम हल तक न पहुँचने का उदाहरण दिखाया और बताया कि मूल प्रमाण में कहाँ समस्या थी।

हर कदम पर त्रुटि (गहरा नीला＝ग्रेडिएंट डिसेंट, बैंगनी＝Adam। ऊर्ध्वाधर पैमाना हर चरण में 10 गुना)

यह “आज़माएँ” वाली प्रक्रिया का Python कोड है। ▶ चलाएँ दबाने पर नीचे नतीजा दिखेगा। संख्याएँ बदलकर फिर से चलाकर देखें।

u10_adam_valley.py

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

import math

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

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

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

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

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

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

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

112015·शॉर्टकट

परतों को पार करने का शॉर्टकट

नेटवर्क की गहराई बढ़ाने पर क्या वह अधिक समझदार बनता है?

Microsoft Research के काइमिंग ही (Kaiming He) और उनके साथियों ने दिखाया कि केवल परतें जोड़ने पर 56 परतों वाले नेटवर्क की त्रुटि दर, ट्रेनिंग डेटा पर भी, 20 परतों वाले से अधिक होती है। इसलिए उन्होंने बार-बार ऐसा शॉर्टकट जोड़ा जो परतों के समूह के आउटपुट में, उसके इनपुट को जस का तस जोड़ देता है (ResNet)। यह 152 परतों तक गहरा बन सका और 2015 की छवि प्रतियोगिता में पहले स्थान पर आया (त्रुटि दर 3.57%)।

उसी 2015 में फ़्राइबुर्ग विश्वविद्यालय के ओलाफ़ रोनेबर्गर (Olaf Ronneberger) और उनके साथियों के U-Net ने U आकार की बनावट अपनाई: पहले छोटा करके पूरी छवि समझना, फिर फैलाकर लौटना। इसमें छोटा करने से पहले के बारीक फ़ीचरों को कॉपी करके जोड़ने का शॉर्टकट था। इसे सूक्ष्मदर्शी की छवियों को क्षेत्रों में बाँटने के लिए बनाया गया था। दाईं ओर के चित्र में दोनों शॉर्टकट बदलकर देखें।

ResNet: आउटपुट ＝F(x)＋x　　U-Net: फैलाने वाले चरण का इनपुट ＝ [नीचे से फैलाया गया भाग, समान आकार वाले चरण की कॉपी]

x: परतों के समूह में आने वाला मान
F(x): परतों का समूह जिस बाकी हिस्से (रेज़िड्युअल) को सीखता है

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:परतों को पार करने वाले कनेक्शन पहली बार ResNet में आए
मूल स्रोत के अनुसार:शोधपत्र खुद कहता है कि शॉर्टकट पर लंबे समय से शोध हुआ है और उसी समय के highway networks का उल्लेख करता है (मई 2015, गेट वाले शॉर्टकटों से सैकड़ों परतें)। ResNet का अंतर यह है कि उसके शॉर्टकट में गेट नहीं है और मान सीधे जस का तस आगे जाता है।

यह “आज़माएँ” वाली प्रक्रिया का Python कोड है। ▶ चलाएँ दबाने पर नीचे नतीजा दिखेगा। संख्याएँ बदलकर फिर से चलाकर देखें।

u10_resnet_shortcut.py

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

import math
import random

WIDTH = 16
DEPTH = 56
SAMPLES = 4

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

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

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

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

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

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

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

122014〜2016·मनुष्य का स्तर

किस मनुष्य को पीछे छोड़ा?

जब कहते हैं कि AI ने मनुष्यों को पीछे छोड़ा, तो तुलना किन मनुष्यों से हुई थी?

छवि पहचान प्रतियोगिता में (1000 श्रेणियाँ, अधिकतम 5 उत्तर देने की अनुमति) विजेता की त्रुटि दर 2010 के 28.2% से घटकर 2017 में 2.3% हुई (दाईं ओर; आधिकारिक आँकड़े)। फ़रवरी 2015 में Microsoft Research के काइमिंग ही (Kaiming He) और उनके साथियों ने 4.94% प्राप्त किया और लिखा, (अनुवाद)।

यह 5.1% प्रतियोगिता के आयोजकों द्वारा मापे गए 2 लोगों में से 1 व्यक्ति का आँकड़ा था (500 छवियों पर अभ्यास, फिर 1500 की पहचान)। दूसरे व्यक्ति ने केवल 100 छवियों पर अभ्यास किया और 258 छवियों पर उसकी त्रुटि दर 12.0% थी। दाईं ओर “मनुष्य का स्तर” बदलने पर पीछे छोड़ने का साल बदलता है।

2016 की बातचीत की आवाज़ पहचानने में भी मनुष्यों की त्रुटि दर मापने के तरीके के अनुसार 4%, 5.9% और 5.1% थी। 2014 में जिस आयोजन की घोषणा (अनुवाद) कहकर हुई, उसमें 30% की सीमा भी आयोजकों ने तय की थी।

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:2015 में छवि पहचान AI ने मनुष्यों को पीछे छोड़ा
मूल स्रोत के अनुसार:तुलना में इस्तेमाल किया गया मनुष्यों का 5.1% केवल 1 व्यक्ति का आँकड़ा था; दूसरे का 12.0% था। पीछे छोड़ने की बात कहने वाला शोधपत्र खुद भी लिखता है, (अनुवाद)।

132015·छवि बनाना

चित्र बनाने के 2 तरीके

पहले से सीखे हुए नेटवर्क से चित्र कैसे बनाया जाए?

अगस्त 2015 में ट्यूबिंगेन विश्वविद्यालय आदि के लिओन गैटिस (Leon Gatys) और उनके साथियों के स्टाइल ट्रांसफ़र में सीखा हुआ नेटवर्क नहीं बदलता; छवि के पिक्सेल सुधारे जाते हैं। गहरी परतों की प्रतिक्रिया को विषयवस्तु और कौन-से फ़ीचर एक साथ मज़बूत दिखाई देते हैं, उसकी तालिका (ग्राम मैट्रिक्स) को शैली माना जाता है। दोनों में अंतर घटाया जाता है। दाईं ओर “स्टाइल ट्रांसफ़र” केवल छोटे फ़िल्टरों वाला सबसे सरल रूप है (इस साइट का बनाया उदाहरण)।

उसी साल मार्च में स्टैनफ़र्ड विश्वविद्यालय के याशा सोल-डिकस्टाइन (Jascha Sohl-Dickstein) और उनके साथियों के डिफ़्यूज़न मॉडल ने डेटा में बार-बार नॉइज़ जोड़कर उसे बिगाड़ा और नेटवर्क को एक कदम पीछे लौटना सिखाया। नॉइज़ से शुरू करके उलटी दिशा के कदम बार-बार लें, तो नया डेटा बनता है। “डिफ़्यूज़न मॉडल” में एक सर्पिल को बिगाड़कर वापस बनाएँ।

स्टाइल ट्रांसफ़र: अंतर ＝α × (विषयवस्तु का अंतर)＋β × (ग्राम मैट्रिक्स का अंतर)　　डिफ़्यूज़न का 1 कदम: x ← √(1−β_t)·x＋ √β_t·ε

α, β: दोनों अंतरों के वज़न
β_t: t-वें कदम का नॉइज़
ε: औसत 0 और विचरण 1 वाली यादृच्छिक संख्या

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:डिफ़्यूज़न मॉडल लगभग 2022 में (या 2020 के DDPM में) बनी नई विधि है
मूल स्रोत के अनुसार:यह विचार 2015 के शोधपत्र में था, जिसने लिखा कि वह (अनुवाद)। 2020 के DDPM शोधपत्र ने लिखा कि उससे पहले (अनुवाद), और ऐसा करके दिखाया।

यह “आज़माएँ” वाली प्रक्रिया का Python कोड है। ▶ चलाएँ दबाने पर नीचे नतीजा दिखेगा। संख्याएँ बदलकर फिर से चलाकर देखें।

u10_diffusion_roll.py

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

import math
import random

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

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

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

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

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

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

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

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

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

142014〜2015·जापान

चलाते समय बनाना

क्या सीखने से पहले नेटवर्क की पूरी बनावट तय करनी पड़ती है?

मार्च 2014 में तोरु निशिकावा (Toru Nishikawa) और दाइसुके ओकानोहरा (Daisuke Okanohara) ने Preferred Networks (PFN) की स्थापना की। जून 2015 में PFN ने Python में न्यूरल नेटवर्क लिखने और सिखाने का औज़ार Chainer सभी के उपयोग के लिए सार्वजनिक किया।

पहले के अधिकतर औज़ार (जैसे Caffe) पहले गणना का पूरा रास्ता तय करते थे, फिर उसमें डेटा भेजते थे (Chainer शोधपत्र में Define-and-Run)। Chainer गणना करते समय ही रास्ता दर्ज करता है और उसे उलटे क्रम में देखकर ग्रेडिएंट निकालता है (Define-by-Run)। अलग-अलग लंबाई के वाक्य संभालने वाले नेटवर्क भी सामान्य for और if स्टेटमेंट से लिखे जा सकते हैं। दाईं ओर “1 पंक्ति आगे” दबाएँ।

PyTorch के 2019 के शोधपत्र ने कहा कि इस तरीके की शुरुआत Chainer और DyNet ने की। दिसंबर 2019 में PFN ने अपने अनुसंधान और विकास का आधार PyTorch पर स्थानांतरित किया।

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:चलाते समय बनाना (Define-by-Run) अमेरिका के PyTorch ने शुरू किया
मूल स्रोत के अनुसार:PyTorch का 2019 का शोधपत्र खुद लिखता है कि इस डिज़ाइन की शुरुआत Chainer और DyNet ने की। लेकिन वही शोधपत्र यह भी कहता है कि Chainer के तरीके में गति की कीमत चुकानी पड़ी।

यह “आज़माएँ” वाली प्रक्रिया का Python कोड है। ▶ चलाएँ दबाने पर नीचे नतीजा दिखेगा। संख्याएँ बदलकर फिर से चलाकर देखें।

u10_tiny_autograd.py

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

import math

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

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

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

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

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

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

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

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

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

152006〜2017·गो

चालें आज़माना और 2 नेटवर्क

गो में स्थिति को स्कोर देना मुश्किल है, तो चाल कैसे चुनें?

गो में संभावित चालें बहुत होती हैं और स्थिति को स्कोर देना भी कठिन है। 2006 में फ़्रांस के रेमी कूलों (Rémi Coulom) की मोंटे कार्लो ट्री सर्च ने कई बार अंत तक यादृच्छिक चालें चलकर जीत के अनुपात से चालों की तुलना की और आशाजनक शाखाओं में अधिक गहराई से खोज की (कौन-सी चाल कितनी बार आज़माएँ, यह तय करने वाला UCT भी उसी साल आया)। दाईं ओर चार गोटियाँ एक पंक्ति में लगाने वाले खेल का उदाहरण है। किसी कॉलम को दबाकर खेलें।

DeepMind के AlphaGo ने इसमें चाल चुनने वाला नेटवर्क और स्थिति का मूल्यांकन करने वाला नेटवर्क जोड़ा। अक्टूबर 2015 में उसने फ़ान हुई (Fan Hui), 2 दान, को 5 जीत और 0 हार से हराया। शोधपत्र ने बिना हैंडिकैप किसी पेशेवर को हराने के बारे में लिखा, (अनुवाद)। मार्च 2016 में उसने ली सेडोल (Lee Sedol), 9 दान, को 4 जीत और 1 हार से हराया। अक्टूबर 2017 का AlphaGo Zero केवल खुद से खेलकर सीखा और 72 घंटे बाद ली सेडोल को हराने वाले संस्करण के विरुद्ध 100 में से 100 मैच जीते।

UCT का स्कोर ＝ जीत का अनुपात ＋C √( ln N ÷ n )

N: इस स्थिति को आज़माने की कुल संख्या
n: इस चाल को आज़माने की संख्या
C: कम आज़माई गई चालों को भी आज़माने की मात्रा

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:AlphaGo केवल अपने आप सीखकर मज़बूत हुआ
मूल स्रोत के अनुसार:2016 में ली सेडोल को हराने वाला संस्करण भी पहले मनुष्यों के 160,000 मैचों से सीखकर, फिर अपने आप से खेलकर मज़बूत हुआ। मनुष्यों के मैचों का उपयोग न करने की शुरुआत अक्टूबर 2017 के AlphaGo Zero से हुई। Zero को भी नियम और बोर्ड को 19×19 की छवि की तरह संभालने की बनावट मनुष्यों ने दी थी।

यह “आज़माएँ” वाली प्रक्रिया का Python कोड है। ▶ चलाएँ दबाने पर नीचे नतीजा दिखेगा। संख्याएँ बदलकर फिर से चलाकर देखें।

u10_mcts_connect4.py

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

import math
import random

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

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

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

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

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

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

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

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

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

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

162007〜2017·जापान

10 साल में पलटा मुकाबला

पेशेवरों और सॉफ़्टवेयर की ताकत का क्रम कब पलटा?

शोगी में रसायन विज्ञान के शोधकर्ता कुनिहितो होकी (Kunihito Hoki) ने 2005 में Bonanza सार्वजनिक किया। उसमें मशीन ने मूल्यांकन फ़ंक्शन (स्थिति कितनी अच्छी है, उसे स्कोर में बदलने का सूत्र) के वज़न इस तरह सीखे कि पेशेवरों के दर्ज मैचों जैसी चालें चले। मार्च 2007 में र्युओ (ड्रैगन किंग) ख़िताब वाले अकिरा वातानाबे (Akira Watanabe) द्वारा Bonanza को हराने के तुरंत बाद, शोधकर्ता हितोशी मात्सुबारा (Hitoshi Matsubara) ने शीर्ष पेशेवरों के विरुद्ध हार से अधिक जीत हासिल करने के बारे में लिखा, (अनुवाद)।

दाईं ओर हर चौकोर एक सार्वजनिक मैच दिखाता है। अक्टूबर 2015 में जापान की सूचना प्रसंस्करण सोसायटी ने कहा, (अनुवाद), और अपना शोगी प्रोजेक्ट समाप्त किया। 2017 में PONANZA ने मेइजिन ख़िताब वाले अमाहिको सातो (Amahiko Sato) को लगातार 2 बार हराया। “गो (देन्सेइसेन)” में जापान की देन्सेइसेन प्रतियोगिता में सॉफ़्टवेयर को हैंडिकैप के रूप में मिलने वाली गोटियाँ 5 से घटकर 0 होती हैं।

बराबरी तक पहुँचने का अर्थ

सोसायटी की घोषणा ने समझाया कि इसका अर्थ हर बार जीतना नहीं, बल्कि बहुत मैच खेलने पर हार से अधिक जीत की संभावना ऊँची होना है। उसने यह भी लिखा कि शीर्ष पेशेवरों से मैच अभी नहीं हुआ था। शीर्ष पेशेवर का अर्थ भी अलग स्रोतों में अलग है।

देनओसेन का क्रम: 2012 के पहले आयोजन में सेवानिवृत्त खिलाड़ी कुनियो योनेनागा (Kunio Yonenaga), आजीवन एइसेइ-किसेइ और उस समय जापान शोगी संघ के अध्यक्ष, ने खेला। जीतने वाला Bonkras, Bonanza पर आधारित था। 2013 के दूसरे आयोजन में पेशेवरों की 1 जीत, 3 हार और 1 ड्रॉ हुआ (अंतिम मैच GPS Shogi ने जीता, जो टोक्यो विश्वविद्यालय के लगभग 680 कंप्यूटरों से चालें खोजता था)। 2014 में 1 जीत और 4 हार हुईं, और 2015 में पेशेवरों की 3 जीत और 2 हार हुईं। देनओसेन 2017 में समाप्त हुई।

गो: मार्च 2016 में जब AlphaGo ने ली सेडोल (Lee Sedol) को हराया, तब देन्सेइसेन में अभी भी 3 गोटियों का हैंडिकैप था। मार्च 2017 के अंतिम आयोजन में, बिना हैंडिकैप, र्यो इचिरिकी (Ryo Ichiriki) DeepZenGo और Zetsugei से हारे। जापान के हिदेकी कातो (Hideki Kato) और उनके साथियों के Zen को मार्च 2016 से Dwango की मदद से मज़बूत करके बनाया गया DeepZenGo मार्च 2017 में ओज़ा ख़िताब वाले युता इयामा (Yuta Iyama) से जीता।

यह “आज़माएँ” वाली प्रक्रिया का Python कोड है। ▶ चलाएँ दबाने पर नीचे नतीजा दिखेगा। संख्याएँ बदलकर फिर से चलाकर देखें।

u10_eval_learning.py

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

import random

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

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

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

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

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

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

172018·विज्ञान की ओर

दूरी के नक्शे से आकार बनाना

AI को गेमों में मज़बूत करने वाली विधियाँ क्या विज्ञान की समस्याओं में भी इस्तेमाल हो सकती हैं?

प्रोटीन अमीनो अम्लों की एक जुड़ी हुई डोर है, जिसके मुड़ने से उसका आकार तय होता है। 2018 की अनुमान प्रतियोगिता CASP13 (लगभग 100 शोध समूह) में DeepMind के पहले AlphaFold ने कन्वोल्यूशनल नेटवर्क से अमीनो अम्लों के हर जोड़े के बीच दूरी का नक्शा अनुमानित किया। इस नक्शे से बने स्कोर के सूत्र से मेल कराने के लिए उसने ग्रेडिएंट डिसेंट से आकार सुधारा और बनाया।

दाईं ओर बनाने की इस विधि का सबसे सरल उदाहरण है (इस साइट की बनाई 2 आयाम वाली डोर और नक्शा)। चित्र खुलते ही सीधी डोर मुड़कर नक्शे से मेल खाने वाला आकार बनाती है। नक्शा बिगाड़कर या केवल पास के जोड़ों की दूरी रखकर देखें। कठिन श्रेणी में कुल स्कोर 68.3 था, जो दूसरे स्थान के 48.2 से अधिक था। लेकिन 43 में से केवल 11 में ऊँची सटीकता मिली।

त्रुटि ＝Σ_i＜j(|p_i − p_j| − d_ij)²　इसे कम करने के लिए p को बदलें

p_i: i-वें अमीनो अम्ल का स्थान
d_ij: i और j की अनुमानित दूरी

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:AlphaFold अचानक 2020 में आया और सीधे रसायन विज्ञान का नोबेल पुरस्कार मिला
मूल स्रोत के अनुसार:पहला AlphaFold 2018 के CASP13 में हिस्सा ले चुका था। लेकिन 2020 के AlphaFold2 के बारे में शोधपत्र ने लिखा, (अनुवाद); इसमें कन्वोल्यूशन छोड़कर अटेंशन लिया गया। पुरस्कार AlphaFold2 के लिए था, जिसे अध्याय 11 में देखेंगे।

आकार बनाने के कदम और नक्शे से अंतर (ऊर्ध्वाधर पैमाना हर चरण में 10 गुना)

यह “आज़माएँ” वाली प्रक्रिया का Python कोड है। ▶ चलाएँ दबाने पर नीचे नतीजा दिखेगा। संख्याएँ बदलकर फिर से चलाकर देखें।

u10_distance_fold.py

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

import math
import random

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

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

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

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

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

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

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

182013〜2015·नौकरियों की भविष्यवाणी

47% और 49% के पीछे क्या है

शोधपत्र में कहाँ लिखा है कि 47% नौकरियाँ समाप्त हो जाएँगी?

सितंबर 2013 में ऑक्सफ़ोर्ड विश्वविद्यालय के कार्ल बेनेडिक्ट फ़्राइ (Carl Benedikt Frey) और ऑज़बर्न (Osborne) ने अमेरिका के 702 व्यवसायों में कंप्यूटरों द्वारा स्थान लिए जाने की संभावना का अनुमान लगाया। केवल 70 व्यवसायों, जिनके बारे में उन्हें भरोसा था, पर उन्होंने हाथ से लेबल लगाए: स्वचालन संभव (1), संभव नहीं (0)। बोध और हाथों की कुशलता, रचनात्मकता तथा लोगों से व्यवहार दर्शाने वाले 9 चरों से क्लासिफ़ायर ने बाकी का अनुमान लगाया।

0.7 या उससे अधिक संभावना को उच्च श्रेणी और 0.3 से कम को निम्न श्रेणी माना। काम करने वाले लोगों की संख्या से गिनने पर निम्न 33%, मध्यम 19% और उच्च 47% था। दाईं ओर के चित्र में श्रेणियों की सीमा बदलने पर शीर्षक का आँकड़ा बदलता है (नौकरियाँ और लोगों की संख्या इस साइट के बनाए उदाहरण हैं)। 2015 में नोमुरा अनुसंधान संस्थान ने उन्हीं 2 शोधकर्ताओं के साथ संयुक्त अध्ययन में घोषणा की, (अनुवाद)।

उच्च श्रेणी का हिस्सा ＝ (0.7 या अधिक संभावना वाले व्यवसायों में काम करने वालों की संख्या) ÷ (सभी काम करने वाले लोग)

संभावना: उस व्यवसाय के तकनीकी रूप से स्वचालित हो सकने की संभावना (अनुमान)

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:10〜20 साल में अमेरिका की 47% नौकरियाँ समाप्त हो जाएँगी
मूल स्रोत के अनुसार:शोधपत्र के शब्द हैं (अनुवाद)। इसका अर्थ है कि उन व्यवसायों का स्वचालन अनिश्चित समय में (शायद 10〜20 साल) संभव हो सकता है। यह वास्तव में कितने लोगों की नौकरी जाएगी, इसका पूर्वानुमान नहीं है। नोमुरा अनुसंधान संस्थान ने भी लिखा कि वास्तविक बदलाव सामाजिक कारकों पर बहुत निर्भर है, जिन्हें इस अनुमान में शामिल नहीं किया गया।

यह “आज़माएँ” वाली प्रक्रिया का Python कोड है। ▶ चलाएँ दबाने पर नीचे नतीजा दिखेगा। संख्याएँ बदलकर फिर से चलाकर देखें।

u10_risk_category.py

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

import math
import random

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

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

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

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

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

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

192011〜2016·जापान

कितना पढ़ा, कितना लिखा

AI ने टोक्यो विश्वविद्यालय का लक्ष्य छोड़ दिया, AI की कहानी पुरस्कार की छँटनी में पास हुई। असल में क्या हुआ?

राष्ट्रीय सूचना विज्ञान संस्थान के तोरोबो-कुन (2011 से) ने और को लक्ष्य बनाया (दोनों अनुवाद)। 2016 की अभ्यास परीक्षाओं में सेंटर टेस्ट पर 525 अंक और मानकीकृत स्कोर 57.1 था। टोक्यो विश्वविद्यालय की अभ्यास परीक्षा के गणित (विज्ञान शाखा) में मानकीकृत स्कोर 76.2 था। उसी साल (अनुवाद) कठिन होने के कारण सेंटर टेस्ट को मनुष्यों की तरह हल करने का प्रयास रोकने की बात कही गई।

मार्च 2016 में AI से कहानी लिखवाने के शोध की कुछ रचनाएँ निक्केइ के “शिनइची होशी (Shinichi Hoshi) पुरस्कार” की पहली छँटनी में पास हुईं और दूसरी में असफल हुईं। चित्र में “शिनइची होशी पुरस्कार 2016” के बक्से दबाएँ। कथानक (अंत का मोड़ भी) और वाक्यों के हिस्से मनुष्यों ने तैयार किए थे, और प्रोग्राम ने उन्हें जोड़ा।

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:तोरोबो-कुन ने टोक्यो विश्वविद्यालय में प्रवेश का लक्ष्य छोड़ दिया (असफल हुआ)
मूल स्रोत के अनुसार:राष्ट्रीय सूचना विज्ञान संस्थान की घोषणा में लक्ष्य छोड़ने का शब्द नहीं है। रिपोर्ट बैठक में कहा गया था, “जापान की राष्ट्रीय विश्वविद्यालय प्रवेश परीक्षा को “मनुष्यों की तरह” हल करने का प्रयास इस वर्ष रोक दिया जाएगा” और (दोनों अनुवाद)।

यह “आज़माएँ” वाली प्रक्रिया का Python कोड है। ▶ चलाएँ दबाने पर नीचे नतीजा दिखेगा। संख्याएँ बदलकर फिर से चलाकर देखें।

u10_novel_parts.py

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

import random

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

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

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

202016·भविष्यवाणियों की घड़ी

भविष्यवाणियों की घड़ी

उछाल के दौर में तय साल बताकर की गई भविष्यवाणियों का उस साल क्या हुआ?

2016 में जेफ़्री हिंटन (Geoffrey Hinton) ने टोरंटो के सम्मेलन में कहा, और (दोनों अनुवाद)। उसी साल अगस्त में Ford ने घोषणा की कि वह स्टीयरिंग व्हील और पैडल रहित स्तर 4 की स्वचालित कारें 2021 में सवारी बुलाने और साझा सवारी की सेवाओं में , (दोनों अनुवाद) चलाएगा। जापान सरकार ने सीमित क्षेत्रों में चालक रहित परिवहन सेवाओं के बारे में लिखा, (अनुवाद)। सरकार के श्वेत पत्र ने कुछ शोधकर्ताओं के इस विचार का परिचय दिया, (अनुवाद)।

दाईं ओर “वर्तमान साल” बदलने पर, जिन भविष्यवाणियों का तय साल आ चुका है, उनके बाद हुई घटनाएँ दिखती हैं। “हिंटन·रेडियोलॉजिस्ट” चुनने पर दिखने वाले बार अमेरिका में रेज़िडेंसी प्रशिक्षण की उपलब्ध जगहों की संख्या हैं (आधिकारिक तालिका से 2016 और 2025 के 2 बिंदु)।

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:5 साल में AI रेडियोलॉजिस्टों की जगह ले लेगा
मूल स्रोत के अनुसार:मूल वीडियो में तुरंत बाद उन्होंने जोड़ा, (अनुवाद)। उन्होंने AI के बारे में नहीं, डीप लर्निंग के बारे में कहा था, और नौकरी समाप्त होने का साल नहीं बताया था (वीडियो के स्वचालित कैप्शन से जाँचा)।

212014〜2019·नियम

नियम किसके लिए थे?

AI के शोधकर्ताओं और सरकारों ने किस तरह के नियम किसके लिए बनाए?

जनवरी 2014 में जापानी कृत्रिम बुद्धिमत्ता सोसायटी की पत्रिका के नए कवर (झाड़ू लेकर सफ़ाई करते स्त्री के आकार वाले रोबोट की तस्वीर) पर (अनुवाद) कहकर आलोचना हुई। सोसायटी ने लिखा, (अनुवाद)। यह नैतिकता समिति बनाने के कारणों में से एक बना। सोसायटी के 2017 के (शीर्षक का अनुवाद) का अंतिम अनुच्छेद 9, (अनुवाद), AI को ही संबोधित करता है।

मार्च 2016 में Microsoft के बातचीत वाले AI, Tay, की कमज़ोरियों का मिलकर काम करने वाले कुछ लोगों ने फ़ायदा उठाया। उसने 24 घंटे के भीतर अनुचित शब्द पोस्ट किए और उसे बंद कर दिया गया। दाईं ओर “नकल से सीखती बातचीत” (इस साइट का बनाया सबसे सरल चित्र; यह Tay की असली व्यवस्था नहीं है) में मिलकर काम करने वालों का अनुपात बदलें।

अनुच्छेद 9 का अर्थ

यह एक शर्त वाला अनुच्छेद है: अगर AI (अनुवाद) बनता है, तो उसे सोसायटी के सदस्यों की तरह इन दिशानिर्देशों का पालन करना होगा। अनुच्छेद 1〜8 सदस्यों के आचरण बताते हैं: मानवता में योगदान, कानून का पालन, निजता, निष्पक्षता, सुरक्षा, ईमानदार व्यवहार, समाज के प्रति ज़िम्मेदारी और समाज से संवाद।

समयरेखा में क्या है: जुलाई 2015 में शोधकर्ताओं ने (अनुवाद) माँगने वाला खुला पत्र जारी किया। अप्रैल 2016 में कागावा के ताकामात्सु में G7 की बैठक में जापान ने (शीर्षक का अनुवाद) पर चर्चा का प्रस्ताव दिया। जनवरी 2017 के असिलोमार के 23 सिद्धांतों ने शोध का उद्देश्य इस तरह रखा: , बल्कि (दोनों अनुवाद) बनाना। मार्च 2019 में जापान सरकार ने (शीर्षक का अनुवाद) अपनाए।

जापान की रिन्ना: उसी कंपनी की जापान वाली रिन्ना (2015, LINE) का लक्ष्य हल्की-फुल्की बातचीत से भावनात्मक जुड़ाव बनाना था। दिसंबर तक उसके दोस्तों की संख्या 18.5 लाख से अधिक थी।

यह “आज़माएँ” वाली प्रक्रिया का Python कोड है। ▶ चलाएँ दबाने पर नीचे नतीजा दिखेगा। संख्याएँ बदलकर फिर से चलाकर देखें।

u10_learn_from_users.py

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

import random

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

222015〜2019·शिखर के बाद

उछाल का शिखर कब बीता?

उछाल का शिखर कब और कैसे बीत गया?

मार्च 2015 की युताका मात्सुओ (Yutaka Matsuo) की किताब (शीर्षक का अनुवाद) ने AI का इतिहास पहले से तीसरे उछाल के अध्यायों में बाँटा। सरकार के 2016 के (शीर्षक का अनुवाद) ने इस किताब आदि के आधार पर समझाया कि AI शोध में (अनुवाद) आए और अब तीसरा उछाल था। 2015 में SoftBank ने घोषणा की कि Pepper में (अनुवाद) की क्षमता आ गई।

दाईं ओर के बार संसद के भाषणों में कृत्रिम बुद्धिमत्ता के अर्थ में “AI” आने की संख्या दिखाते हैं (इस साइट ने कार्यवाही के अभिलेखों से गिना)। 2015 के 11 उल्लेखों से बढ़कर 2019 में 593 हुए, फिर 2020 और 2021 में घटे। अक्टूबर 2019 में Gartner Japan ने कृत्रिम बुद्धिमत्ता को “मोहभंग का दौर” में रखा (उम्मीदें बहुत बढ़ने के बाद निराशा फैलने का समय)।

उम्मीदों के पहाड़ का आकार (हाइप साइकिल) एक शोध कंपनी के आकलन का ढाँचा है; इसे नियम के रूप में प्रमाणित नहीं किया गया है। 2020〜2021 में उल्लेख घटने का भी एक ही कारण तय नहीं किया जा सकता (ये महामारी वाले साल भी थे)।

परत के इनपुट हर बार एक पैमाने पर

ड्रॉपआउट और नॉलेज डिस्टिलेशन

शब्दों को जोड़ना

केवल स्कोर से खेलना सीखना

सीखे हुए नेटवर्क का फिर से उपयोग

कहाँ, क्या और कितना है

संकुचित करें, फिर फैलाएँ

नकली नोट बनाने वाले और पुलिस

पतली नली या अटेंशन

लंबी सँकरी घाटी में उतरना

परतों को पार करने का शॉर्टकट

किस मनुष्य को पीछे छोड़ा?

चित्र बनाने के 2 तरीके

चलाते समय बनाना

चालें आज़माना और 2 नेटवर्क

10 साल में पलटा मुकाबला

दूरी के नक्शे से आकार बनाना

47% और 49% के पीछे क्या है

कितना पढ़ा, कितना लिखा

भविष्यवाणियों की घड़ी

नियम किसके लिए थे?

उछाल का शिखर कब बीता?

इस अध्याय में क्या अभी अनसुलझा है

OpenAI की स्थापना की घोषणा (दिसंबर 2015): “पूरी मानवता को लाभ पहुँचाने की सबसे अधिक संभावना” के लिए गैर-लाभकारी शोध कंपनी

सरकार की “कृत्रिम बुद्धिमत्ता प्रौद्योगिकी रणनीति परिषद” (2016) और “कृत्रिम बुद्धिमत्ता प्रौद्योगिकी रणनीति” (2017)

चीन सरकार ने “नई पीढ़ी की कृत्रिम बुद्धिमत्ता के विकास की योजना” में 2020, 2025 और 2030 के 3 चरणों के लक्ष्य तय किए

OpenAI की स्थापना की घोषणा (दिसंबर 2015): के लिए गैर-लाभकारी शोध कंपनी

सरकार की “कृत्रिम बुद्धिमत्ता प्रौद्योगिकी रणनीति परिषद” (2016) और (2017)

चीन सरकार ने में 2020, 2025 और 2030 के 3 चरणों के लक्ष्य तय किए