पहले उछाल की उपलब्धियाँ और भविष्यवाणियाँ

011960〜1966 · जापान

आवाज़ की एक-एक ध्वनि पहचानना

मशीन “अ” और “इ” का अंतर आवाज़ की किस विशेषता से पहचानती है?

1960 में क्योटो विश्वविद्यालय के तोशियुकी सकाई (Toshiyuki Sakai) और उनके साथी पर शोध कर रहे थे, जो मनुष्य की आवाज़ पहचानकर उसे अक्षरों में बदलता। उस समय के लेख के अनुसार, लक्ष्य जापानी के 100 एकल अक्षरांशों (एक-एक ध्वनि) को पहचानने वाला उपकरण था। स्वर पहचानने के लिए आवाज़ में तेज़ गूँज वाली 2 आवृत्ति-चोटियों (पहले और दूसरे फ़ॉर्मेंट) की स्थिति का इस्तेमाल होता था। व्यंजन पहचानने के लिए तरंग के 0 को पार करने की संख्या जैसे कई संकेतों को मिलाया जाता था।

दाईं आकृति एक समतल है, जिसके अक्ष इन 2 चोटियों की आवृत्तियाँ हैं। “अ, इ, उ, ए, ओ” अलग-अलग द्वीपों जैसे समूहों में इकट्ठे हैं। बिंदु हिलाएँ तो सबसे पास वाले द्वीप का स्वर उत्तर बनता है। शोर बढ़ाने पर द्वीपों के बीच गलतियाँ होने लगती हैं।

उत्तर ＝ वह स्वर k जिसके लिए √((F1−F1ₖ)² ＋ (F2−F2ₖ)²) सबसे छोटा हो

F1, F2: आवाज़ की पहली और दूसरी चोटी की ऊँचाई (आवृत्ति)
F1ₖ, F2ₖ: स्वर k के द्वीप का केंद्र (इस साइट के तय किए लगभग मान)

जापानी में के लिए इस्तेमाल होने वाला शब्द शोधपत्रों में 1962 से मिलता है। तोहोकु विश्वविद्यालय की 1966 की संगोष्ठी का विषय अंग्रेज़ी में ही (Artificial Intelligence; अनुवाद) रखा गया था। क्योटो विश्वविद्यालय की अक्षर पढ़ने वाली “पहचान करने वाली मशीनें” जैसे विषयों पर व्याख्यान सुनने 200 से अधिक लोग आए।

आवाज़ की तरंग और उसके 0 को पार करने की संख्या

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

u04_vowel_formant.py

# u04 声の 2 つの周波数の山で母音を聞き分ける（音声タイプライターの考え方）
#
# どの出来事か：1960 年、京都大学の坂井利之たちの「音声タイプライター」（記録 kyoto_phonetic_typewriter_1960）。
#   当時の記事によると、母音は声の響きの山（第 1・第 2 ホルマント）の位置で、
#   子音は波が 0 を横切る回数などを組み合わせて識別しようとしていた。
# 仕組み：
#   ① 2 つの高さの波を足して「母音らしい音」を作る（山の高さは、このサイトが決めたおおよその数）。
#   ② 音の中にどの高さの波がどれだけ入っているかを、1 つずつ掛け算して足して調べる（離散フーリエ変換）。
#   ③ 大きい山 2 つの周波数（F1, F2）を取り出し、いちばん近い母音の島を答えにする。
#   ④ 子音のような雑音は、0 を横切る回数が母音よりずっと多い。
# 試してみよう：
#   - NOISE を 0.5 → 1.5 → 3.0 と上げると、どこから母音を間違え始めるか
#   - ISLANDS の数値を動かして、島どうしを近づけるとどうなるか

import math
import random

random.seed(1960)
RATE = 8000          # 1 秒に何回、音を記録するか
N = 400              # 1 つの音で使う記録の数（0.05 秒）
NOISE = 0.8          # 足す雑音の強さ
# 母音の島の中心（F1, F2。単位はヘルツ）。仕組みを示すための、このサイトのおおよその数
ISLANDS = {"あ": (800, 1250), "い": (300, 2300), "う": (330, 1350), "え": (500, 1900), "お": (500, 850)}

def make_sound(f1, f2, noise):
    """2 つの周波数の波を足した音。雑音も少し足す。"""
    return [math.sin(2 * math.pi * f1 * t / RATE) + 0.7 * math.sin(2 * math.pi * f2 * t / RATE)
            + noise * random.gauss(0, 1) for t in range(N)]

def spectrum(x, lo=200, hi=3000, step=50):
    """周波数 f の成分の大きさ（振幅）を、f を 50 ヘルツずつ変えて調べる。"""
    out = []
    for f in range(lo, hi + 1, step):
        re = sum(v * math.cos(2 * math.pi * f * t / RATE) for t, v in enumerate(x))
        im = sum(v * math.sin(2 * math.pi * f * t / RATE) for t, v in enumerate(x))
        out.append((f, math.hypot(re, im)))
    return out

def two_peaks(spec):
    """いちばん大きい山と、そこから 300 ヘルツ以上離れた 2 番目の山。低い方を F1 とする。"""
    s = sorted(spec, key=lambda p: -p[1])
    a = s[0][0]
    b = next(f for f, _ in s if abs(f - a) >= 300)
    return min(a, b), max(a, b)

def nearest(f1, f2):
    return min(ISLANDS, key=lambda k: math.hypot(f1 - ISLANDS[k][0], f2 - ISLANDS[k][1]))

def zero_cross(x):
    return sum(1 for a, b in zip(x, x[1:]) if (a < 0) != (b < 0))

print("母音を 1 つずつ識別する（雑音の強さ", NOISE, "）")
print("  正解  見つけた F1   F2    判定")
ok = 0
for i in range(10):
    v = random.choice(list(ISLANDS))
    c1, c2 = ISLANDS[v]
    f1, f2 = c1 + random.gauss(0, 40), c2 + random.gauss(0, 80)   # 人による声の違い
    p1, p2 = two_peaks(spectrum(make_sound(f1, f2, NOISE)))
    ans = nearest(p1, p2)
    ok += ans == v
    print(f"  {v}     {p1:5d} {p2:5d}    {ans} {'○' if ans == v else '×'}")
print(f"  正しく聞き分けた：{ok} / 10")

print("\n雑音を強くすると？（各 30 回）")
for noise in (0.5, 1.5, 3.0, 5.0):
    ok = 0
    for _ in range(30):
        v = random.choice(list(ISLANDS))
        p1, p2 = two_peaks(spectrum(make_sound(*ISLANDS[v], noise)))
        ok += nearest(p1, p2) == v
    print(f"  雑音 {noise:3.1f}：{'■' * ok}{'□' * (30 - ok)} {ok}/30")

print("\n0 を横切る回数（0.05 秒の間）")
vowel = make_sound(*ISLANDS["あ"], 0.05)
hiss = [random.gauss(0, 1) for _ in range(N)]   # 「すー」のような雑音の音
print(f"  母音「あ」：{zero_cross(vowel):4d} 回")
print(f"  雑音の音  ：{zero_cross(hiss):4d} 回  ← ずっと多い。母音か、雑音のような子音かの手がかりになる")

021961〜1969 · रोबोट

गति याद करके दोहराने वाली बाँह

कारखाने में काम करने वाले पहले रोबोट ने क्या “याद” किया था?

1961 में मंज़ूर हुए डेवोल (Devol) के पेटेंट में कैम (घूमने वाली प्लेट के आकार से केवल तय गति बनाने वाला पुर्जा) की जगह ऐसी बाँह का विचार था, जो गति का क्रम (प्रोग्राम) याद रख सके और जिसे बदला जा सके। इसे कहा गया। उसी वर्ष यूनिमेशन कंपनी का रोबोट जनरल मोटर्स के कारखाने में लगा। वह साँचे से निकले गर्म पुर्ज़े उठाकर ढेर में रखता था।

दाईं आकृति में गति का क्रम बदलकर देखें। बाँह सिखाए गए बिंदुओं तक बारी-बारी जाती है, लेकिन उसे नहीं पता कि यह गति किस उद्देश्य से है। 1969 में कावासाकी हेवी इंडस्ट्रीज़ ने जापान में बना पहला औद्योगिक रोबोट “कावासाकी यूनिमेट मॉडल 2000” तैयार किया। जापान में के रूप में इसकी बड़ी चर्चा हुई।

x＝L₁cos θ₁ ＋L₂cos(θ₁＋θ₂)

x: हाथ की क्षैतिज स्थिति (ऊर्ध्वाधर स्थिति y का सूत्र भी ऐसा ही है, बस cos की जगह sin है)
θ₁, θ₂: 2 जोड़ों के कोण (क्रम के रूप में याद रखी गई संख्याएँ)
L₁, L₂: बाँह के हिस्सों की लंबाई

1 जनवरी 1963 को टीवी एनिमेशन शुरू हुआ। हर हफ़्ते टीवी पर भावनाओं वाला एक रोबोट लड़का दिखाई देता था। कारखाने का रोबोट, याद की गई गति दोहराने वाली एक बाँह था।

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात: जापान का पहला टीवी एनिमेशन था
मूल स्रोत के अनुसार:प्रसारण अभिलेखागार और निर्माता कंपनी इसे कहते हैं। इससे पहले भी जापान में बने छोटे टीवी एनिमेशन मौजूद थे।

031962〜2007 · खेल

चेकर्स: क्या खेल ?

किसी खेल को “हल करना” क्या होता है?

1962 में IBM के आर्थर सैम्युअल (Arthur Samuel) के चेकर्स प्रोग्राम ने दृष्टिहीन खिलाड़ी नीली (Nealey) को एक बाज़ी में हराया। चेकर्स 8×8 के बोर्ड पर खेला जाता है, जिसमें प्रतिद्वंद्वी की गोटी के ऊपर से कूदकर उसे लिया जाता है। ख़बर आई कि चेकर्स । 1965 में रिचर्ड बेलमैन (Richard Bellman) ने लिखा, (अनुवाद)।

खेल को हल करने का मतलब है, हर स्थिति के लिए यह तय करना कि दोनों खिलाड़ी सबसे अच्छी चालें चलें तो जीत, हार या ड्रॉ में से कौन-सा परिणाम होगा। एक पक्का तरीका अंतिम स्थितियों से उलटी दिशा में चलना है (पीछे की ओर विश्लेषण)। दाईं ओर पत्थर लेने वाले खेल में “1 कदम पीछे जाएँ” दबाएँ। जिस खिलाड़ी की बारी 0 पत्थर बचे होने पर आती है, वह हारता है। अगर कोई चाल प्रतिद्वंद्वी को हार वाली स्थिति में पहुँचा सकती है, तो मौजूदा स्थिति जीत वाली है।

चेकर्स में लगभग 5×10²⁰ स्थितियाँ हैं। 2007 में अल्बर्टा विश्वविद्यालय की टीम ने 1989 से चली गणना के आधार पर साबित किया कि दोनों खिलाड़ी बिल्कुल सही खेलें तो ड्रॉ होता है।

स्थिति का मूल्य ＝ जीत (हार वाली स्थिति में जाने की कम से कम 1 चाल है)／ हार (हर चाल जीत वाली स्थिति में जाती है)

स्थिति: किसी समय बोर्ड पर गोटियों की व्यवस्था
चाल: अगली स्थिति में ले जाने वाली एक चाल

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:1962 में सैम्युअल के प्रोग्राम ने चेकर्स के एक मास्टर को हराया और चेकर्स हल हो गया
मूल स्रोत के अनुसार:जीत केवल 1 बाज़ी में हुई थी, और प्रतिद्वंद्वी मास्टर से एक स्तर नीचे था। अगले वर्ष के मुकाबले में प्रतिद्वंद्वी बिना कोई बाज़ी हारे जीत गया। 1965 में प्रोग्राम विश्व चैंपियनशिप के 2 खिलाड़ियों से सभी 8 बाज़ियाँ हार गया। चेकर्स वास्तव में 2007 में हल हुआ।

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

u04_retrograde_stones.py

# u04 ゲームを「解く」：終わりの局面から逆にたどる（後ろ向きの解析）
#
# どの出来事か：1962 年、サミュエルのチェッカーのプログラムの 1 勝（記録 samuel_nealey_game_1962）、
#   1965 年のベルマンの見通し「10 年以内に…完全に決着のつくゲームになる」（記録 bellman_checkers_prediction_1965）、
#   2007 年にチェッカーが解かれたこと（記録 checkers_solved_2007）。
#   2007 年の論文は、終わりの局面から逆にたどる方法（retrograde analysis）で、
#   駒が 10 個以下の局面を全部調べた、と書いている。
# 仕組み：石取りゲーム（石が n 個。自分の手番で 1〜K 個取る。最後の石を取ると勝ち）を、
#   石 0 個（手番の人の負け）から逆にたどって、全部の局面に「勝ち・負け」の印をつける。
#   ・負けの局面へ行ける手が 1 つでもあれば、その局面は「勝ち」
#   ・どの手も勝ちの局面へ進むなら、その局面は「負け」
# 試してみよう：
#   - K（1 回に取れる数）を 2・4・5 に変えて、負けの局面の並び方を見る
#   - 2 つの山のゲーム（ニム）の表で、負けの局面がどこに並ぶか見る

K = 3
N = 30

# ---- 1 つの山 ----
value = {0: "負け"}                     # 石 0 個で手番になった人は、もう取れないので負け
for n in range(1, N + 1):
    value[n] = "勝ち" if any(value[n - k] == "負け" for k in range(1, min(K, n) + 1)) else "負け"
print(f"石取りゲーム（1 回に 1〜{K} 個）を、石 0 個から逆にたどった結果：")
for n in range(0, N + 1):
    print(f"  石 {n:2d} 個：{'●' if value[n] == '勝ち' else '○'} {value[n]}（手番の人から見て）")
lose = [n for n in range(N + 1) if value[n] == "負け"]
print("  負けの局面：", lose, f"→ {K + 1} の倍数のみ")
print("  勝ちの局面では、相手に『負け』の局面を渡す手を打てばよい。これが『解けた』ということ。\n")

# ---- 2 つの山（ニム：どちらかの山から 1 個以上いくつでも取る）----
M = 7
val2 = {}
for total in range(0, 2 * M + 1):          # 石の合計が少ない局面から順に（逆にたどる）
    for a in range(0, M + 1):
        b = total - a
        if not 0 <= b <= M:
            continue
        nxt = [(a - k, b) for k in range(1, a + 1)] + [(a, b - k) for k in range(1, b + 1)]
        val2[(a, b)] = any(val2[p] is False for p in nxt)   # True=勝ち False=負け
print("2 つの山のゲーム（ニム）の表：横＝山 A の数、縦＝山 B の数（○＝手番の人の負け）")
print("      " + " ".join(str(a) for a in range(M + 1)))
for b in range(M + 1):
    print(f"  B={b} " + " ".join("●" if val2[(a, b)] else "○" for a in range(M + 1)))
print(f"  局面の数：{(M + 1) ** 2}。負けの局面は、2 つの山が同じ数の時だけ。\n")

# ---- チェッカーの局面数（2007 年の論文の数）----
checkers_all = 500_995_484_682_338_672_639      # 駒 1〜24 個の局面の合計（2007 年の論文の表 1）
checkers_db = 3.9e13                             # 終わりから逆にたどって調べた、駒 10 個以下の局面
speed = 1_000_000                                # 仮に 1 秒に 100 万局面調べるとすると
for name, n in (("この石取りゲーム", N + 1), ("2 つの山のゲーム", (M + 1) ** 2),
                ("チェッカーの駒 10 個以下", checkers_db), ("チェッカー全局面", checkers_all)):
    sec = n / speed
    t = f"{sec:.6f} 秒" if sec < 60 else (f"{sec / 86400:,.0f} 日" if sec < 3.15e7 else f"{sec / 3.15e7:,.1f} 年")
    print(f"  {name:<16} 局面 {n:>12.3g}　1 秒に 100 万ずつなら {t}")
print("  チェッカーは、全部の局面を調べずに、関係のある局面だけをたどる工夫を重ねて、2007 年に解かれた。")

041964 · शब्दों में लिखे सवाल

सवाल को समीकरण बनाकर हल करना

मशीन ने “... से 15 प्रतिशत सस्ता” को समीकरण में कैसे बदला?

1964 में MIT के स्नातकोत्तर छात्र डैनियल बॉब्रो (Daniel Bobrow) ने अपनी डॉक्टरेट थीसिस के लिए STUDENT नाम का प्रोग्राम बनाया, जो अंग्रेज़ी में लिखे बीजगणित के सवाल पढ़कर हल करता था। हाई स्कूल के पहले वर्ष की पाठ्यपुस्तक के कुछ सवालों को STUDENT के पढ़ सकने वाली अंग्रेज़ी में दोबारा लिखकर आज़माया गया।

STUDENT वाक्य के अर्थ पर विचार नहीं करता। अंग्रेज़ी के is को बराबर का चिह्न और percent less than को गुणा में बदलने जैसे तरीकों से वह तय वाक्यांशों की जगह समीकरण के हिस्से रखता है। दाईं आकृति में “1 कदम आगे बढ़ें” दबाएँ। समीकरण कम होने पर वह जैसे ज्ञात संबंध जोड़ता और उपयोगकर्ता को बताता कि उसने क्या मान लिया है। नियमों में शामिल न होने वाला वाक्यांश, अर्थ समान होने पर भी समीकरण नहीं बन सकता।

69.70＝ (1 − 15/100) × लिखी हुई कीमत

is: बराबर के चिह्न में बदलें
percent less than: × (1 − p/100) में बदलें
sum of: जोड़ में बदलें

बॉब्रो ने कहने का अर्थ इस सीमा के वाक्यों के लिए तय किया था।

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

u04_student_equations.py

# u04 STUDENT のまね：決まった言い回しを式の部品に置き換えて、文章題を解く
#
# どの出来事か：1964 年、MIT のボブローの博士論文のプログラム STUDENT（記録 bobrow_student_1964）。
#   STUDENT は、制限つきの英語の代数の文章題を読み、「is」を等号にするなど、決まった言い回しを式に直して解いた。
#   式が足りない時は「距離＝速さ×時間」のような知っている関係を補い、置いた仮定を利用者に伝えた。
# このサンプルの問題文は、論文の図 1 の問題をもとに、このサイトが「区切った日本語」で作った例（論文の文の訳ではない）。
# 仕組み：
#   ① 決まった言い回しの置き換え（例：「2 つ の 数」→「一方 の 数 と もう一方 の 数」）
#   ② 文ごとに、決まりの形（は・より〜パーセント 安い・の〜倍・の 和 は・次 の 数）に当てはめて式にする
#   ③ 式を連立方程式として解く。式が足りなければ、知っている関係を補ってもう一度解く
#   文の意味は考えていない。形が決まりに合わなければ、誤った式ができるか、解けなくなる。
# 試してみよう：
#   - PROBLEMS の数を変えて解き直す
#   - 最後の「決まりに無い言い方」の問題を、決まりに合う形に書き直して解かせる

import re
from fractions import Fraction as F

PROBLEMS = [
    "ラジオ の 値段 は 69.70 ドル 。 この 値段 は 表示 の 値段 より 15 パーセント 安い 。 表示 の 値段 を 求めよ 。",
    "2 つ の 数 の 和 は 111 。 一方 の 数 は もう一方 の 数 の 次 の 数 。 2 つ の 数 を 求めよ 。",
    "ニューヨーク から ロサンゼルス まで の 距離 は 3000 マイル 。 ジェット機 の 速さ は 時速 600 マイル 。 "
    "ジェット機 で ニューヨーク から ロサンゼルス まで かかる 時間 を 求めよ 。",
    "ビル の 父 の おじ の 年齢 は ビル の 父 の 年齢 の 2 倍 。 2 年後 ビル の 父 の 年齢 は ビル の 年齢 の 3 倍 。 "
    "ビル の 父 の おじ の 年齢 と ビル の 父 の 年齢 と ビル の 年齢 の 和 は 92 。 ビル の 年齢 を 求めよ 。",
    "ラジオ は 表示 の 値段 から 15 パーセント 値引き されて 69.70 ドル 。 表示 の 値段 を 求めよ 。",   # 決まりに無い言い方
]
IDIOMS = [("2 つ の 数 の 和", "一方 の 数 と もう一方 の 数 の 和"), ("2 つ の 数 を 求めよ", "一方 の 数 と もう一方 の 数 を 求めよ")]
KNOWN = [("距離", "速さ", "時間")]     # 知っている関係：距離 ＝ 速さ × 時間
NUM = r"(\d+(?:\.\d+)?)"

def name(s):
    return s.replace(" ", "")

def lin(var=None, k=1, c=0):
    """1 次式：{変数: 係数, None: 定数項}"""
    e = {None: F(c)}
    if var:
        e[var] = e.get(var, 0) + F(k)
    return e

def add(*es):
    out = {}
    for e in es:
        for v, k in e.items():
            out[v] = out.get(v, 0) + k
    return out

def scale(e, k):
    return {v: c * F(k) for v, c in e.items()}

def to_eq(sentence, last):
    """1 文を式（左辺−右辺＝0）に変換する。どの決まりを使ったかも返す。"""
    s = sentence
    m = re.fullmatch(r"(.+?) は (.+?) より " + NUM + r" パーセント 安い", s)
    if m:
        x, y, p = resolve(m.group(1), last), name(m.group(2)), F(m.group(3))
        return add(lin(x), scale(lin(y), -(1 - p / 100))), f"「より〜パーセント 安い」→ {x} ＝ (1 − {p}/100) × {y}"
    m = re.fullmatch(r"(.+?) は (.+) の 次 の 数", s)
    if m:
        x, y = name(m.group(1)), name(m.group(2))
        return add(lin(x), scale(lin(y), -1), lin(c=-1)), f"「次 の 数」→ {x} ＝ {y} ＋ 1"
    m = re.fullmatch(NUM + r" 年後 (.+?) は (.+) の " + NUM + r" 倍", s)
    if m:
        n, x, y, k = F(m.group(1)), name(m.group(2)), name(m.group(3)), F(m.group(4))
        return add(lin(x, c=n), scale(lin(y, c=n), -k)), f"「〜年後 … の〜倍」→ {x} ＋ {n} ＝ {k} × ({y} ＋ {n})"
    m = re.fullmatch(r"(.+?) は (.+) の " + NUM + r" 倍", s)
    if m:
        x, y, k = name(m.group(1)), name(m.group(2)), F(m.group(3))
        return add(lin(x), scale(lin(y), -k)), f"「の〜倍」→ {x} ＝ {k} × {y}"
    m = re.fullmatch(r"(.+) の 和 は " + NUM, s)
    if m:
        parts = [name(p) for p in m.group(1).split(" と ")]
        return add(*[lin(p) for p in parts], lin(c=-F(m.group(2)))), f"「の 和 は」→ {' ＋ '.join(parts)} ＝ {m.group(2)}"
    m = re.fullmatch(r"(.+?) は (?:時速 )?" + NUM + r"(?: \S+)?", s)
    if m:
        x = name(m.group(1))
        return add(lin(x), lin(c=-F(m.group(2)))), f"「は」→ {x} ＝ {m.group(2)}"
    m = re.fullmatch(r"(.+?) は (.+)", s)
    if m:
        x, y = name(m.group(1)), name(m.group(2))
        return add(lin(x), scale(lin(y), -1)), f"「は」→ {x} ＝ {y}　（意味は考えずに、そのまま等号にした）"
    return None, "決まりに合う形がない"

def resolve(phrase, last):
    """「この 値段」→ 直前に現れた「値段」を含む語（前の文の主語）"""
    m = re.fullmatch(r"この (\S+)", phrase)
    if m:
        for v in reversed(last):
            if m.group(1) in v:
                return v
    return name(phrase)

def solve(eqs):
    """連立 1 次方程式を掃き出し法で解き、求まった変数の値を返す。"""
    vars_ = sorted({v for e in eqs for v in e if v is not None})
    rows = [[e.get(v, F(0)) for v in vars_] + [-e.get(None, F(0))] for e in eqs]
    known, r = {}, 0
    pivots = []
    for c in range(len(vars_)):
        p = next((i for i in range(r, len(rows)) if rows[i][c] != 0), None)
        if p is None:
            continue
        rows[r], rows[p] = rows[p], rows[r]
        rows[r] = [x / rows[r][c] for x in rows[r]]
        for i in range(len(rows)):
            if i != r and rows[i][c] != 0:
                rows[i] = [a - rows[i][c] * b for a, b in zip(rows[i], rows[r])]
        pivots.append((r, c))
        r += 1
    for rr, c in pivots:
        if all(rows[rr][j] == 0 for j in range(len(vars_)) if j != c):
            known[vars_[c]] = rows[rr][-1]
    return known

def show(v):
    return f"{float(v):g}"

for no, text in enumerate(PROBLEMS, 1):
    print(f"━━ 問題 {no}：{name(text)}")
    for a, b in IDIOMS:
        if a in text:
            text = text.replace(a, b)
            print(f"   言い回しを置き換え：「{name(a)}」→「{name(b)}」")
    sentences = [s.strip() for s in text.split("。") if s.strip()]
    goal, eqs, last = [], [], []
    for s in sentences:
        m = re.fullmatch(r"(.+) を 求めよ", s)
        if m:
            goal = [name(p) for p in m.group(1).split(" と ")]
            continue
        e, why = to_eq(s, last)
        print(f"   文「{name(s)}」 {why}")
        if e:
            eqs.append(e)
            last += [v for v in e if v]
    known = solve(eqs) if eqs else {}
    if not all(g in known for g in goal):
        for rel in KNOWN:
            slots = {}
            for w in rel:
                hit = [v for v in set(last) | set(goal) if w in v]
                if hit:
                    slots[w] = hit[0]
            if len(slots) == len(rel):
                print(f"   式が足りない → 知っている関係を使う：{rel[0]} ＝ {rel[1]} × {rel[2]}")
                for w, v in slots.items():
                    print(f"     仮定：{w} は「{v}」のこと")
                d, sp, t = (slots[w] for w in rel)
                vals = {**known}
                if d in vals and sp in vals:
                    known[t] = vals[d] / vals[sp]
                elif d in vals and t in vals:
                    known[sp] = vals[d] / vals[t]
                elif sp in vals and t in vals:
                    known[d] = vals[sp] * vals[t]
    for g in goal:
        print(f"   答え：{g} は {show(known[g])}" if g in known else f"   答え：{g} は求められなかった（式が足りず、知っている関係にも合わない）")
    print()

051966 · बातचीत

ELIZA का रहस्य खुलता है

मनुष्यों से लिखकर बातचीत करने वाला प्रोग्राम क्या “समझता” था?

जनवरी 1966 में MIT के जोसेफ़ वाइज़ेनबाउम (Joseph Weizenbaum) ने ELIZA पर शोधपत्र प्रकाशित किया। यह कंप्यूटर से लिखित बातचीत करने वाला प्रोग्राम था। ELIZA दिए गए वाक्य में मुख्य शब्द खोजता है। उस शब्द के लिए तय किए विभाजन नियम से वाक्य को हिस्सों में काटता है, फिर उन्हें दोबारा जोड़ने के नियम से उत्तर बनाता है। मुख्य शब्द न मिले तो बिना खास अर्थ वाला सामान्य उत्तर देता है।

मुख्य शब्दों की प्राथमिकता तय होती है। शोधपत्र के उदाहरण में everybody की प्राथमिकता I से ऊपर रखी गई है। इससे प्रोग्राम everybody पर प्रतिक्रिया देकर पूछ सकता है कि किसकी बात हो रही है। दाईं आकृति में वाक्य लिखने पर मिला मुख्य शब्द और इस्तेमाल हुआ नियम दिखाई देता है। मुख्य शब्दों और नियमों का पूरा संग्रह (स्क्रिप्ट) प्रोग्राम से अलग डेटा है। इसे बदलने पर बातचीत करने वाले की भूमिका बदल जाती है।

(0 YOU 0 ME) → (WHAT MAKES YOU THINK I 3 YOU)

0: ऐसा हिस्सा जिसमें कितने भी शब्द आ सकते हैं
3: विभाजन से बने तीसरे हिस्से को ज्यों का त्यों रख दें (शोधपत्र का उदाहरण)

शोधपत्र के समय सबसे बड़ी स्क्रिप्ट में भी लगभग 50 मुख्य शब्द थे। अंग्रेज़ी के अलावा वेल्श और जर्मन की स्क्रिप्ट भी थीं।

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:ELIZA को मनुष्य जैसा संवाद करने वाला AI बनाने के लिए बनाया गया था
मूल स्रोत के अनुसार:शोधपत्र की शुरुआत में लिखा है, (अनुवाद)। इसके बाद लिखा है, (अनुवाद)।

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

u04_eliza_ja.py

# u04 ELIZA の仕組み：キーワードを見つけて、決まり通りに組みかえて返す（種明かしつき）
#
# どの出来事か：1966 年 1 月、ワイゼンバウムの論文（記録 eliza_1966）。
#   ELIZA は、入力された文からキーワードを探す。
#   キーワードごとの「分け方の決まり」で文を分解し、「組みかえの決まり」で返事を作る。
#   キーワードがなければ、つなぎの返事を返す。
#   論文のねらいの 1 つは、すごそうに見えるプログラムの種明かしだった。
# このサンプルの決まり（SCRIPT）は、論文の仕組みにならって日本語で作った例（論文の台本の訳ではない）。
# 試してみよう：
#   - TALK に自分の文を足して、どの決まりが使われたかを見る
#   - SCRIPT に新しいキーワードを足す（順位 rank が大きいほど優先される）
#   - 「みんな」の順位を 1 にすると、最後の文への返事がどう変わるか（論文の everybody と I の例）
#   - 組みかえの「{2}」の前後のかぎかっこを消すと、返事の日本語が不自然になることがある。
#     ELIZA は言葉の意味も文法も知らず、切り取った文字列を当てはめているだけだから

import re

SCRIPT = [
    # (キーワード, 順位, 分け方（正規表現）, 組みかえの候補)
    ("みんな", 6, r"(.*)", ["だれか、特定の人のことを思いうかべていますか？"]),   # 論文の例：everybody を I より高い順位に
    ("いつも", 5, r"(.*)", ["たとえば、どんな時ですか？", "いつも、ですか。"]),
    ("母", 4, r"(.*)母(.*)", ["お母さんのことを、もう少し話してください。", "家族のことで、ほかに思い浮かぶことは？"]),
    ("私は", 3, r"(.*)私は(.*)です", ["あなたが「{2}」と感じるのは、なぜですか？", "「{2}」と感じるようになったのは、いつからですか？"]),
    ("私は", 3, r"(.*)私は(.*)", ["あなたは「{2}」のですね。"]),
    ("悲しい", 3, r"(.*)", ["悲しいと聞いて、残念です。", "何があったのか、話してくれますか？"]),
    ("あなた", 2, r"(.*)あなた(.*)", ["私のことより、あなたのことを話しましょう。"]),
]
NO_KEYWORD = ["続けてください。", "それで？", "もう少しくわしく話してください。"]

used = {}       # 同じ決まりの組みかえ候補を順番に使うための記録
fallback = [0]

def reply(sentence):
    hits = [(kw, rank, pat, outs) for kw, rank, pat, outs in SCRIPT if kw in sentence]
    for kw, rank, pat, outs in sorted(hits, key=lambda h: -h[1]):
        m = re.fullmatch(pat, sentence.rstrip("。！？"))
        if not m:
            continue   # 分け方の決まりに合わなければ、次の決まりへ
        n = used.get((kw, pat), 0)
        used[(kw, pat)] = n + 1
        template = outs[n % len(outs)]
        parts = {str(i): g for i, g in enumerate(m.groups(), 1)}
        text = template.format(*[""] + [parts.get(str(i), "") for i in range(1, 4)])
        return text, f"キーワード「{kw}」（順位 {rank}）・分け方 {pat}・組みかえ {n % len(outs) + 1} 番"
    text = NO_KEYWORD[fallback[0] % len(NO_KEYWORD)]
    fallback[0] += 1
    return text, "キーワードなし → つなぎの返事"

TALK = [
    "人はみんな同じです。",
    "いつも何かで私を困らせるんです。",
    "私は悲しいです。",
    "母が心配しています。",
    "あなたは機械ですね。",
    "私は本当は元気です。",
    "私はみんなに笑われている気がします。",
]
for line in TALK:
    answer, why = reply(line)
    print(f"人  ：{line}")
    print(f"ELIZA：{answer}")
    print(f"   （種明かし：{why}）")

061964 या 1966 · जापानी शिक्षण सामग्री

ELIZA किस वर्ष का है?

समयरेखा में “1964” किस घटना का वर्ष है?

हाई स्कूल के “सूचना II (जापानी हाई स्कूल में सूचना और कंप्यूटर से जुड़ा विषय)” विषय के शिक्षकों की सामग्री (2020) की तालिका में लिखा है (अनुवाद)। यह तालिका 2016 की सरकारी सर्वेक्षण रिपोर्ट से आंतरिक मामलों और संचार मंत्रालय के श्वेतपत्र में, और वहाँ से शिक्षण सामग्री में उतारी गई।

मूल स्रोत साथ रखें तो पता चलता है कि वाइज़ेनबाउम (Weizenbaum) का शोधपत्र सितंबर 1965 में स्वीकार हुआ और जनवरी 1966 के अंक में प्रकाशित हुआ। उस समय MIT की वार्षिक रिपोर्ट (जुलाई 1964〜जुलाई 1965 की अवधि) कहती है कि लोगों और कंप्यूटर के बीच स्वाभाविक भाषा में बातचीत की प्रणाली का विकास इस अवधि में शुरू हुआ था। मिला हुआ मूल प्रोग्राम 1965 का संस्करण था।

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

अंग्रेज़ी स्रोतों में भी वर्ष का अंतर है। कंप्यूटर के अग्रदूतों का IEEE परिचय वाइज़ेनबाउम को कहता है (अनुवाद), और शोधपत्र वाले अंक का वर्ष भी 1965 देता है (छपा हुआ अंक 1966 का है)।

071965 · रसायन

सभी विकल्प बनाएँ, नियमों से छाँटें

जब लाखों संभावित उत्तर हों, तो विशेषज्ञ उन्हें कैसे छाँटते हैं?

स्टैनफ़र्ड विश्वविद्यालय के जोशुआ लेडरबर्ग (Joshua Lederberg) रासायनिक सूत्र से अणु की सभी संभव संरचनाओं को पेड़ के ढाँचे में गिनने की विधि DENDRAL बना रहे थे (1964)। 1965 से एडवर्ड फ़ाइगेनबाउम (Edward Feigenbaum) और साथियों ने रसायन विशेषज्ञों के अनुभव से मिले ज्ञान को नियमों में जोड़कर विकल्प छाँटने वाला प्रोग्राम बनाया। यह मास स्पेक्ट्रोमेट्री (अणु तोड़कर टुकड़ों का द्रव्यमान मापने का तरीका) के डेटा को पढ़ने का ज्ञान था। एक यौगिक की 14,715,813 संभव संरचनाएँ मास स्पेक्ट्रोमेट्री से घटकर 1,284,792 रह गईं। एक और मापन (नाभिकीय चुंबकीय अनुनाद) भी इस्तेमाल करने पर सिर्फ़ 1 संरचना बची।

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

बनाएँ → अनुमान लगाएँ → तुलना करें (केवल मेल खाने वाले रखें)

टुकड़े का द्रव्यमान: k कार्बन परमाणुओं वाले टुकड़े के लिए 14k＋1 रखा गया है (इस साइट का सरल नियम। असली मास स्पेक्ट्रोमेट्री अधिक जटिल है)

1970 के शोधपत्र में लिखा है, (अनुवाद)।

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:पहला एक्सपर्ट सिस्टम MYCIN (1972) था
मूल स्रोत के अनुसार:जापान का श्वेतपत्र ऐसा कहता है। लेकिन विशेषज्ञों के अनुभव से मिले ज्ञान को नियमों के रूप में जोड़ने वाला प्रोग्राम DENDRAL, 1965 में शुरू हो चुका था। इसके विकासकर्ताओं ने भी 1993 के शोधपत्र के शीर्षक में इसे कहा है (अनुवाद)।

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

u04_dendral_isomers.py

# u04 DENDRAL の考え方：候補の構造を全部作り、測ったデータと合わないものを消す
#
# どの出来事か：1965 年からの DENDRAL（記録 dendral_1965）。レダーバーグの、分子の構造を木の形で全部数え上げる手順に、
#   化学者の経験の知識（質量分析のデータの読み方）を「もし〜なら」の規則で組み込み、候補を絞った。
#   Nilsson（2010）の例：14,715,813 の候補 → 質量分析で 1,284,792 → 別の測定（核磁気共鳴）も使うと 1 つ。
# このサンプルの仕組み（このサイトが小さくした例。実際の質量分析はもっと複雑）：
#   ① 作る：炭素 n 個の、枝分かれした骨組み（アルカン）の構造を全部作る（同じ構造は 1 つにまとめる）
#   ② 予想する：結合を 1 か所切ったときの、2 つのかけらの炭素の数（重さ 14k＋1 の山になる）
#   ③ 比べる：測った山の並びと予想が合わない構造を消す。まだ残れば、別の測定で絞る
#      （ここでは「CH₃・CH₂・CH・C の炭素がそれぞれ何個あるか」が分かる測定とした。本物の核磁気共鳴を単純にしたもの）
# 試してみよう：
#   - N を 6・8・9 に変える（候補の数は 5・18・35 と増える）
#   - TARGET を別の番号にして、どの構造なら 1 つに絞れるか調べる

N = 7          # 炭素の数
TARGET = 2     # 「正体の分からない分子」にする構造の番号（0から）

def canon(adj, root, parent=-1):
    """木の形を、根から見た文字列にする（形が同じなら同じ文字列になる）。"""
    return "(" + "".join(sorted(canon(adj, c, root) for c in adj[root] if c != parent)) + ")"

def centers(adj):
    n = len(adj)
    deg = [len(a) for a in adj]
    leaves = [i for i in range(n) if deg[i] <= 1]
    left = n
    while left > 2:
        left -= len(leaves)
        nxt = []
        for v in leaves:
            for u in adj[v]:
                deg[u] -= 1
                if deg[u] == 1:
                    nxt.append(u)
            deg[v] = 0
        leaves = nxt
    return leaves if leaves else [0]

def key(adj):
    return min(canon(adj, c) for c in centers(adj))

def grow(n):
    """炭素1個から始め、結合数が4未満の炭素に1個ずつ足していく。"""
    level = {key([[]]): [[]]}
    for _ in range(n - 1):
        nxt = {}
        for adj in level.values():
            for v in range(len(adj)):
                if len(adj[v]) < 4:
                    new = [list(a) for a in adj] + [[v]]
                    new[v].append(len(adj))
                    nxt.setdefault(key(new), new)
        level = nxt
    return list(level.values())

def pieces(adj):
    """結合を 1 か所切ったときの、かけらの炭素の数（小さい方, 大きい方）のリスト。"""
    n, out = len(adj), []
    for v in range(n):
        for u in adj[v]:
            if u > v:
                seen, stack = {v}, [v]
                while stack:
                    x = stack.pop()
                    for y in adj[x]:
                        if y not in seen and not (x == v and y == u):
                            seen.add(y)
                            stack.append(y)
                a = len(seen)
                out.append(tuple(sorted((a, n - a))))
    return sorted(out)

def kinds(adj):
    """CH₃（結合数1）・CH₂（2）・CH（3）・C（4）の炭素がそれぞれ何個あるか。"""
    return tuple(sum(1 for a in adj if len(a) == k) for k in (1, 2, 3, 4))

print("炭素の数と、考えられる骨組みの構造の数")
for n in range(1, 11):
    print(f"  炭素 {n:2d} 個：{len(grow(n)):3d} 通り")

cands = grow(N)
target = cands[TARGET]
spec = pieces(target)
print(f"\n正体の分からない分子（炭素 {N} 個）を測った山（かけらの炭素の数の組）：")
print("  ", " ".join(f"{a}+{b}" for a, b in spec), " → 重さの山：", sorted({14 * k + 1 for ab in spec for k in ab}))
print(f"\n① 作る：候補 {len(cands)} 通り")
left = [c for c in cands if pieces(c) == spec]
print(f"② かけらの予想が合うものだけ残す：{len(left)} 通り")
k = kinds(target)
left2 = [c for c in left if kinds(c) == k]
print(f"③ 別の測定（CH₃ {k[0]}・CH₂ {k[1]}・CH {k[2]}・C {k[3]} 個）も合うものだけ：{len(left2)} 通り")
print("   残った構造（炭素どうしの結合）：")
for c in left2:
    print("   ", [(v, u) for v in range(len(c)) for u in c[v] if u > v])

print("\nどの構造なら、かけらの山だけで 1 つに絞れるか：")
same = {}
for c in cands:
    same.setdefault(tuple(pieces(c)), []).append(c)
for i, c in enumerate(cands):
    k = len(same[tuple(pieces(c))])
    print(f"  構造 {i}：炭素の種類 {kinds(c)}　かけらの山が同じ構造 {k} 通り{'  ← 山だけで 1 つに絞れる' if k == 1 else ''}")

081965 · समुच्चय

कितने cm से कोई “लंबा व्यक्ति” है?

ऐसे समूह को संख्या से कैसे बताएँ जिसमें सदस्य होने की स्पष्ट सीमा न हो?

1965 में कैलिफ़ोर्निया विश्वविद्यालय, बर्कले के लोत्फ़ी ज़ादेह (Lotfi Zadeh) ने नाम का शोधपत्र प्रकाशित किया। और जैसे समूहों में सदस्य होने या न होने की सीमा स्पष्ट नहीं होती। फिर भी ऐसे समूह, आकृतियाँ पहचानने और जानकारी साझा करने में मनुष्यों के लिए अहम भूमिका निभाते हैं। इसलिए ज़ादेह ने किसी सदस्य का समूह में शामिल होने का स्तर 0 से 1 तक की संख्या (सदस्यता की मात्रा) से बताया।

दाईं आकृति में कद बदलकर देखें। सामान्य समुच्चय में एक खास कद पर मान अचानक 0 से 1 हो जाता है। फ़ज़ी सेट में मान धीरे-धीरे बढ़ता है। शोधपत्र ने “या” को बड़े मान, “और” को छोटे मान, और “नहीं” को 1 में से मान घटाने के रूप में परिभाषित किया।

या ＝Max[μ_A, μ_B]　और ＝Min[μ_A, μ_B]　नहीं ＝1 − μ_A

μ_A: समुच्चय A की सदस्यता की मात्रा (0〜1)

सदस्यता की मात्रा का रूप (160 cm पर 0, 185 cm पर 1) इस साइट का तय किया उदाहरण है। इसे कौन और कैसे तय करेगा, यह उपयोग की स्थिति के अनुसार तय होता है।

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

u04_fuzzy_tall.py

# u04 ファジィ集合：「背の高い人」の集まりを、0〜1 の度合いで表す
#
# どの出来事か：1965 年、ザデーの論文「ファジィ集合」（記録 zadeh_fuzzy_sets_1965）。
#   「背の高い男の人の集まり」のように、入るか入らないかの境目がはっきりしない集まりを、
#   要素がその集まりにどれくらい属しているか（所属の度合い、0〜1）で表した。
#   論文は、2 つのファジィ集合の「または」を大きい方（Max）、「かつ」を小さい方（Min）、
#   「〜でない」を 1 から引いた数、と決めている。
# 仕組み：度合いの形（下の tall・medium）は、このサイトが決めた例。誰がどう決めるかは、使う場面ごとの約束になる。
# 試してみよう：
#   - tall の 160・185 を変えると、どの身長の度合いが変わるか
#   - ふつうの集合（175 cm 以上なら 1）と比べて、174 cm と 176 cm の差を見る

def crisp_tall(h):
    return 1.0 if h >= 175 else 0.0          # ふつうの集合：175 cm で急に入る

def tall(h):                                  # ファジィ集合「背が高い」：160 cm で 0、185 cm で 1
    return min(1.0, max(0.0, (h - 160) / 25))

def medium(h):                                # ファジィ集合「ふつうの背」：170 cm で 1、158・182 cm で 0
    return max(0.0, 1 - abs(h - 170) / 12)

def bar(v, n=20):
    return "■" * round(v * n) + "□" * (n - round(v * n))

print("身長   ふつうの集合    ファジィ集合「背が高い」")
for h in range(150, 201, 5):
    print(f"{h} cm  {crisp_tall(h):.0f}  {bar(crisp_tall(h), 5)}   {tall(h):.2f} {bar(tall(h))}")

print("\n174 cm と 176 cm：")
for h in (174, 176):
    print(f"  {h} cm：ふつうの集合 {crisp_tall(h):.0f}　ファジィ {tall(h):.2f}")
print("  → ふつうの集合では 2 cm で 0 から 1 に跳ぶ。ファジィ集合では、ほとんど変わらない。")

print("\n2 つのファジィ集合を組み合わせる（論文の決め方）")
print("身長   高い  ふつう  高い または ふつう(Max)  高い かつ ふつう(Min)  高くない(1−高い)")
for h in range(155, 196, 5):
    a, b = tall(h), medium(h)
    print(f"{h} cm  {a:.2f}  {b:.2f}   {max(a, b):.2f} {bar(max(a, b), 10)}      {min(a, b):.2f} {bar(min(a, b), 10)}     {1 - a:.2f}")

091960〜1966 · भविष्यवाणी

क्या मशीनें मनुष्य का हर काम कर पाएँगी?

क्या “20 वर्षों के भीतर” वाली भविष्यवाणी का मतलब मनुष्यों के काम खत्म होना था?

1965 में हर्बर्ट साइमन (Herbert Simon) ने अपनी किताब में लिखा, (अनुवाद)। मूल 1960 के शोधपत्र में उन्होंने (अनुवाद) की उम्मीद बताई थी। लेकिन तुरंत बाद लिखा था, (अनुवाद)।

साइमन ने अर्थशास्त्र के का विचार इस्तेमाल किया। मशीन हर काम में मनुष्य से तेज़ हो, तब भी मशीन का समय सीमित है। दोनों अपने अपेक्षाकृत बेहतर काम सँभालें, तो मिलकर अधिक उत्पादन कर सकते हैं। दाईं आकृति में मशीन की गति बढ़ाने पर भी “खूबी के अनुसार बाँटें” चुनने से मनुष्य के लिए काम बचता है।

मनुष्य का काम ＝ वह काम जिसमें (मशीन की गति ÷ मनुष्य की गति) का अनुपात सबसे छोटा है

तुलनात्मक लाभ: दूसरों की तुलना में किसी काम में अपेक्षाकृत बेहतर होना (केवल गति की बात नहीं)

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:साइमन ने भविष्यवाणी की थी कि 20 वर्षों में मशीनें मनुष्यों के सभी काम छीन लेंगी
मूल स्रोत के अनुसार:मूल शोधपत्र ने तकनीकी क्षमता के अनुमान और उसके उपयोग को अलग रखा था। उन्होंने माना था कि लंबे समय में काम करना चाहने वाले लगभग सभी लोग काम कर पाएँगे। 1966 में भी उन्होंने जवाब दिया कि रोज़गार का स्तर तकनीक से नहीं, अर्थव्यवस्था की व्यवस्था से तय होता है।

101965 · भविष्यवाणी

हर साल दोगुना, लगातार 10 साल

हर वर्ष 2 गुना होने वाली चीज़ 10 वर्षों में कितनी गुना हो जाएगी?

1965 में फ़ेयरचाइल्ड सेमीकंडक्टर के गॉर्डन मूर (Gordon Moore) ने लेख में लिखा कि एक सर्किट में घटकों की संख्या लगभग हर वर्ष 2 गुनी होती आई है (वह संख्या जिस पर प्रति घटक खर्च सबसे कम होता है)। उन्होंने अनुमान लगाया कि यह दर जारी रहेगी और 1975 में संख्या 65,000 हो जाएगी।

दाईं ओर ग्राफ़ में “हर निशान पर दोगुना” चुनने पर रेखा सीधी हो जाती है। यह हर वर्ष समान अनुपात से बढ़ने का संकेत है। दोगुना होने में लगने वाले वर्षों T को बदलने पर 1975 का अनुमान बहुत बदल जाता है। “विस्तार: लेख के बिंदु, खर्च और स्रोत” में नीचे का ग्राफ़ दिखाता है कि सबसे कम प्रति घटक खर्च वाली संख्या समय के साथ दाईं ओर कैसे बढ़ती है।

घटकों की संख्या ＝64 × 2^{(वर्ष − 1965) ÷ T}

T: दोगुना होने में लगने वाले वर्ष (लेख में लगभग 1 वर्ष)
64: 2⁶ (1965 का बिंदु)

1975 में मूर ने पीछे देखकर कहा कि तब तक संख्या लगभग हर वर्ष दोगुनी होती रही थी। आगे के लिए उन्होंने के आसपास की दर संभव बताकर अपना अनुमान बदला। नाम किसी और ने दिया था।

प्रति घटक खर्च और घटकों की संख्या (हर वर्ष सबसे कम खर्च वाला बिंदु)

111965〜1967 · आलोचना

जाँची जाने वाली चालें छाँटना

क्या शतरंज कंप्यूटर हर संभव चाल की आगे की स्थिति जाँचते थे?

1965 में दार्शनिक ह्यूबर्ट ड्रेफ़स (Hubert Dreyfus) ने RAND की रिपोर्ट में तर्क दिया कि शुरुआती सफलताओं के बाद AI अपेक्षा से बड़ी बाधा का सामना कर रहा है। उन्होंने लिखा कि मनुष्य सोचते समय अपनी दृष्टि के किनारे के संकेतों और क्या महत्वपूर्ण है इसकी पहचान का इस्तेमाल करते हैं। लेकिन कंप्यूटर की भाषा में बदलने पर ये बातें छूट जाती हैं।

1967 में MIT के रिचर्ड ग्रीनब्लैट (Richard Greenblatt) का शतरंज प्रोग्राम Mac Hack VI ड्रेफ़स के साथ हुई बाज़ी जीत गया। यह प्रोग्राम सभी चालों की आगे की स्थिति नहीं जाँचता। लगभग 50 संकेतों से हर चाल को उचित होने का स्कोर देता है और केवल ऊँचे स्कोर वाली चालें जाँचता है। प्रतियोगिता में पहले और दूसरे कदम के लिए जाँची जाने वाली चालें 15, तीसरे और चौथे के लिए 9, और आगे के लिए 7 रखी गई थीं। दाईं आकृति में छँटाई और गहराई बदलकर देखें।

जाँची गई स्थितियाँ ＝w₁ × w₂ × … × w_d (सभी चालें जाँचने पर b^d)

w_k: kवें कदम पर जाँची गई चालों की संख्या
b: संभव चालों की संख्या (आकृति में उदाहरण की संख्या)
d: गहराई

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:ड्रेफ़स ने भविष्यवाणी की थी कि कंप्यूटर शतरंज में शौकिया खिलाड़ी को भी नहीं हरा सकते, फिर खुद हार गए
मूल स्रोत के अनुसार:1965 के मूल वाक्य (अनुवाद) में उस समय की स्थिति का वर्णन था। उन्होंने खुद जवाब दिया कि (अनुवाद), जैसा कि सीमोर पैपर्ट (Seymour Papert) के ज्ञापन में बताया गया है।

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

u04_selective_search.py

# u04 読む手を絞る：全部読むか、もっともらしい手だけ読むか
#
# どの出来事か：1967年、MITのグリーンブラットのチェスプログラム（Mac Hack VI）がドレイファスとの対局に勝った
#   （記録 dreyfus_machack_game_1967、dreyfus_alchemy_1965）。1967年の論文によると、このプログラムは
#   約50の手がかりで手ごとにもっともらしさの点をつけ、点の高い手だけを読んだ。大会では、読む手の数を
#   1・2手目は 15、3・4手目は 9、その先は 7 にした。αβ法で計算量がおよそ 100 分の 1 になるとも見積もっている。
# 仕組み：
#   ① 読む局面の数を数える：全部読む（1手ごとに b 通り）と、絞って読む（15, 15, 9, 9, 7）
#   ② 作ったゲームの木で、絞って読んだ時に、全部読んだ時と同じ手を選べるかを調べる
#      （もっともらしさは、本当の値＋見積もりの誤差。木と数値は、このサイトが作った例）
# 試してみよう：
#   - B（1手ごとの手の数。仮の数値）を 20・40 に変える
#   - GUESS_NOISE（見積もりの誤差の大きさ）を 0 にすると、絞っても同じ手を選べるか

import random

B = 30                     # 1手ごとの手の数（仮の数値）
WIDTHS = [15, 15, 9, 9, 7]  # 論文の大会の時の、読む手の数

print("① 読む局面の数")
full, sel = 1, 1
for d, w in enumerate(WIDTHS, 1):
    full *= B
    sel *= w
    print(f"  {d} 手先まで：全部読む {full:>12,}　しぼって読む {sel:>9,}　（{full / sel:,.0f} 分の 1）")
print(f"  αβ 法でさらにおよそ 100 分の 1 なら、しぼって読む局面は約 {sel // 100:,}\n")

# ② 作ったゲームの木で比べる
random.seed(1967)
DEPTH, BR = 4, 8
GUESS_NOISE = 0.2

def make_tree(depth):
    if depth == 0:
        return random.gauss(0, 1)
    return [make_tree(depth - 1) for _ in range(BR)]

def minimax(node, me):
    if not isinstance(node, list):
        return node
    vals = [minimax(c, not me) for c in node]
    return max(vals) if me else min(vals)

def narrow(node, me, width, depth=0):
    """もっともらしさ（本当の値＋見積もりの誤差）の高い手を width 本だけ読む。"""
    if not isinstance(node, list):
        return node
    guess = [(minimax(c, not me) * (1 if me else -1) + random.gauss(0, GUESS_NOISE), i) for i, c in enumerate(node)]
    keep = [node[i] for _, i in sorted(guess, reverse=True)[:width]]
    vals = [narrow(c, not me, width, depth + 1) for c in keep]
    return max(vals) if me else min(vals)

def best_move(tree, width=None):
    if width is None:
        vals = [minimax(c, False) for c in tree]
    else:
        guess = sorted(((minimax(c, False) + random.gauss(0, GUESS_NOISE), i) for i, c in enumerate(tree)), reverse=True)[:width]
        vals = [-9e9] * len(tree)
        for _, i in guess:
            vals[i] = narrow(tree[i], False, width)
    return max(range(len(tree)), key=lambda i: vals[i])

trees = [make_tree(DEPTH) for _ in range(60)]
print(f"② 作ったゲームの木（1手ごとに {BR} 通り・{DEPTH} 手先まで）60本で、全部読んだ時と同じ手を選べた割合")
for width in (1, 2, 3, 5, 8):
    same = sum(best_move(t, width) == best_move(t) for t in trees)
    print(f"  読む手 {width} 本：{'■' * (same // 3)}{'□' * (20 - same // 3)} {same}/60（読む局面 {width ** DEPTH:,}）")
print("  → 絞るほど速いが、見積もりに誤差があると、最善手を読み落とすことがある。")

121966〜1972 · रोबोट

टकराए तो नक्शा सुधारकर फिर खोजें

रोबोट किसी अनदेखी चीज़ से टकरा जाए तो क्या करे?

1966 से 1972 तक स्टैनफ़र्ड रिसर्च इंस्टीट्यूट (SRI) ने पहियों वाले रोबोट पर शोध किया। इसमें टीवी कैमरा, दूरी मापने वाला उपकरण और टक्कर सेंसर थे। रेडियो से जुड़ा बड़ा कंप्यूटर दिखी चीज़ों से कमरे का नक्शा बनाता, रास्ता तय करता और रोबोट चलाता था। अचानक रुकने पर इसका ढाँचा हिलता था, इसलिए इसे शैकी (हिलने वाला) कहा गया।

1970 की रिपोर्ट के काम के उदाहरण में शैकी रास्ता तय करके आगे बढ़ता है। किसी अनदेखी चीज़ से टकराने पर वह रुकता है, फिर तस्वीर लेता है और दोबारा योजना बनाता है। दाईं आकृति अपने आप चलती है। “रोकें” से इसे रोकें और “आगे बढ़ते रहें” से फिर चलाएँ। बिंदीदार रेखाओं वाली चीज़ें अभी नक्शे में नहीं हैं। खोज के लिए चौड़ाई-प्रथम तरीका, जो पास की जगहों से फैलता है, और गहराई-प्रथम तरीका, जो जहाँ तक संभव हो आगे जाता है और फिर लौटता है, चुन सकते हैं।

चौड़ाई-प्रथम ← कतार　गहराई-प्रथम ← स्टैक

कतार: पहले मिली जगह पहले जाँचें (पहले आया, पहले निकला)
स्टैक: सबसे बाद में मिली जगह पहले जाँचें (बाद में आया, पहले निकला)

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:Life पत्रिका ने शैकी को “पहला इलेक्ट्रॉनिक मनुष्य” कहा
मूल स्रोत के अनुसार:लेख में ये शब्द पत्रकार को घुमाने वाले युवा शोधकर्ता के उद्धरण के रूप में हैं। उसी लेख में पत्रकार ने देखे गए काम के बारे में लिखा, (अनुवाद)। SRI के 1984 के सारांश ने शैकी को वाला रोबोट बताया (अनुवाद)।

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

u04_shakey_replan.py

# u04 シェーキーのように：地図で道を探し、ぶつかったら地図を直して探し直す
#
# どの出来事か：1966〜1972 年、SRI のロボット「シェーキー」（記録 shakey_sri_robot_1966）。
#   1970 年の報告の作業例：目的地までの経路を計画し、見えなかった物にぶつかると止まって写真を撮り直し、計画し直す。
# 仕組み：
#   ・地図（ロボットが知っている壁）の上で経路を探す。探し方は 2 つ：
#       幅優先＝近い場所から順に広げる（先に見つけた場所から調べる。待ち行列）
#       深さ優先＝行ける所まで進んでから戻る（最後に見つけた場所から調べる。積み重ね）
#   ・実際の部屋には、地図にない物（?）がある。進む先にそれがあったら、地図に書き足して探し直す。
#   部屋と物の置き方は、このサイトが作った例（シェーキーの実際の部屋ではない）。
# 試してみよう：
#   - ROOM の ? を増やす・動かすと、探し直す回数はどうなるか
#   - 深さ優先の経路が、なぜ遠回りになるのかを、調べた順番から考える

from collections import deque

ROOM = [
    "S...?...#.........",
    "........#.........",
    "........#....?....",
    "........#.........",
    "....#.......###...",
    "....#.....?.......",
    "....#.........#...",
    "....#.........#..G",
]
H, W = len(ROOM), len(ROOM[0])
START = next((r, c) for r in range(H) for c in range(W) if ROOM[r][c] == "S")
GOAL = next((r, c) for r in range(H) for c in range(W) if ROOM[r][c] == "G")

def search(known, start, how):
    """known＝地図上の壁。how＝'幅優先' か '深さ優先'。経路と、調べたマス目の数を返す。"""
    todo = deque([start])
    came = {start: None}
    looked = 0
    while todo:
        p = todo.popleft() if how == "幅優先" else todo.pop()
        looked += 1
        if p == GOAL:
            break
        for dr, dc in ((0, 1), (1, 0), (0, -1), (-1, 0)):
            q = (p[0] + dr, p[1] + dc)
            if 0 <= q[0] < H and 0 <= q[1] < W and q not in known and q not in came:
                came[q] = p
                todo.append(q)
    if GOAL not in came:
        return None, looked
    path, p = [], GOAL
    while p:
        path.append(p)
        p = came[p]
    return path[::-1], looked

def run(how):
    known = {(r, c) for r in range(H) for c in range(W) if ROOM[r][c] == "#"}   # 初めの地図（? は知らない）
    pos, walked, plans, looked_all = START, [START], 0, 0
    while pos != GOAL:
        path, looked = search(known, pos, how)
        plans += 1
        looked_all += looked
        if path is None:
            print("  経路が見つからない")
            return
        for q in path[1:]:
            if ROOM[q[0]][q[1]] == "?":          # ぶつかった。地図に書き足して、ここから探し直す
                known.add(q)
                print(f"  {len(walked) - 1:2d} 歩目で、地図にない物にぶつかった → 地図に書き足して、探し直す")
                break
            pos = q
            walked.append(q)
    print(f"  {how}：計画 {plans} 回、調べたマス目 合計 {looked_all}、移動距離 {len(walked) - 1} 歩")
    route = set(walked)
    for r in range(H):
        row = ""
        for c in range(W):
            ch = ROOM[r][c]
            row += ch if ch in "#SG?" else ("o" if (r, c) in route else ".")
        print("     " + row)

for how in ("幅優先", "深さ優先"):
    print(f"【{how}で探す】")
    run(how)
    print()
print("# = 地図にある壁　? = 地図にない物　o = 歩いた道")
print("幅優先は、地図の上で最短経路を見つける。深さ優先は、見つけた経路を進むだけなので、遠回りになりやすい。")

131966 · कंप्यूटर की दृष्टि

वस्तु और पृष्ठभूमि अलग करना

कंप्यूटर तस्वीर में कैसे खोजता है?

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

दाईं आकृति पहले कदम, यानी “वस्तु और पृष्ठभूमि अलग करने” की विधि दिखाती है। सीमा मान से गहरे बिंदुओं को वस्तु माना जाता है, और जुड़े बिंदुओं को एक समूह बनाकर गिना जाता है। एकसमान पृष्ठभूमि हो तो गिनती सही होती है। लेकिन पृष्ठभूमि असमान हो तो उसका पैटर्न भी वस्तु बन जाता है, और छूती हुई वस्तुएँ मिलकर एक हो जाती हैं।

वस्तु का बिंदु ⇔ चमक ＜ सीमा मान　समूह ＝ ऊपर, नीचे, बाएँ या दाएँ जुड़े वस्तु के बिंदुओं का संग्रह

AI का इतिहास लिखने वाले निल्सन (Nilsson, 2010) के अनुसार, यह योजना अपेक्षा से बहुत कठिन थी, लेकिन इससे MIT में दृष्टि पर लगातार शोध की शुरुआत हुई।

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:MIT ने एक स्नातक छात्र से एक गर्मी में “कंप्यूटर दृष्टि” हल करवाने की कोशिश की
मूल स्रोत के अनुसार:ज्ञापन में लगभग 11 लोगों के नाम ज़िम्मेदारी के लिए दिए हैं। जुलाई में एकसमान पृष्ठभूमि पर केवल गोले, ईंटें और बेलन लेने, फिर अगस्त में धीरे-धीरे दायरा बढ़ाने की योजना थी। फिर भी, बाद की इतिहास की किताबें भी कहती हैं कि यह अपेक्षा से बहुत कठिन था।

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

u04_figure_ground.py

# u04 物と背景を分ける：しきい値で分け、つながった点をひとまとまりにして数える
#
# どの出来事か：1966年7月、MITの「夏の視覚プロジェクト」の覚え書き（記録 summer_vision_project_1966）。
#   画像の中で「物」と「背景」を分け、面の性質を調べ、知っている物の名前を当てる計画。
#   7月は、重ならずに置いた球・れんが・円柱だけ（面の色も背景も一様）で、8月に少しずつ広げる段階の計画だった。
# 仕組み（計画の最初の一歩を、最も単純にした例）：
#   ① 明るさがしきい値より暗い点を「物の点」とする
#   ② 上下左右でつながった物の点を、ひとまとまりにする（塗りつぶし）
#   ③ まとまりの数を数える
#   画像は、このサイトが作った例（覚え書きの図ではない）。
# 試してみよう：
#   - 最後の for の数値（背景のむら）を変えて、どこから個数が狂うか見る
#   - THRESHOLD を変えて、むらのある背景でも正しく 3 個と数えられるか試す

import random

W, H = 48, 20
THRESHOLD = 0.5

def scene(clutter, seed=1966):
    rnd = random.Random(seed)
    img = [[0.9 for _ in range(W)] for _ in range(H)]          # 白く一様な背景（明るさ 0.9）
    for y in range(H):
        for x in range(W):
            img[y][x] -= clutter * rnd.random()                 # 背景の模様（明るさのむら）
    for y in range(H):                                          # 球（円）
        for x in range(W):
            if (x - 8) ** 2 + ((y - 9) * 1.8) ** 2 < 36:
                img[y][x] = 0.2
    for y in range(6, 15):                                      # れんが（長方形）
        for x in range(18, 30):
            img[y][x] = 0.3
    for y in range(4, 17):                                      # 円柱（横から見た形）
        for x in range(37, 43):
            img[y][x] = 0.25
    return img

def label(img, th):
    lab = [[0] * W for _ in range(H)]
    n = 0
    for y in range(H):
        for x in range(W):
            if img[y][x] < th and not lab[y][x]:
                n += 1
                stack = [(y, x)]
                lab[y][x] = n
                while stack:
                    cy, cx = stack.pop()
                    for dy, dx in ((1, 0), (-1, 0), (0, 1), (0, -1)):
                        ny, nx = cy + dy, cx + dx
                        if 0 <= ny < H and 0 <= nx < W and img[ny][nx] < th and not lab[ny][nx]:
                            lab[ny][nx] = n
                            stack.append((ny, nx))
    return lab, n

MARK = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
for clutter in (0.0, 0.3, 0.45, 0.6):
    img = scene(clutter)
    lab, n = label(img, THRESHOLD)
    sizes = sorted((sum(row.count(k) for row in lab) for k in range(1, n + 1)), reverse=True)
    print(f"背景のむら {clutter}：見つけたまとまり {n} 個（正解は 3 個）　大きさ {sizes[:6]}{' …' if n > 6 else ''}")
    if clutter in (0.0, 0.6):          # 図は、いちばん一様なときと、むらがいちばん大きいときだけ出す
        for row in lab:
            print("   " + "".join(MARK[(k - 1) % 26] if k else "." for k in row))
        print()
print("一様な背景なら、しきい値1つで3つの物に分けられた。背景に模様があると、模様まで「物」になってしまう。")

141967 · जापान · सीखने का तरीका

त्रुटि से थोड़ा-थोड़ा सीखना

जो डेटा साफ़ अलग नहीं हो सकता, उससे मशीन कैसे सीखे?

1967 में शुनइचि अमारी (Shun'ichi Amari) ने शोधपत्र में सीखने की विधि का गणितीय अध्ययन किया। इसमें हर उदाहरण देखने पर, त्रुटि के अनुसार भार (किस विशेषता को कितना महत्व देना है) थोड़ा सुधारा जाता है। सारांश ने दिखाया कि 2 समूह साफ़ अलग न हो सकें, तब भी भार सबसे अच्छे मानों के पास पहुँचते हैं, और गति तथा सटीकता के बीच समझौता दिखाया। 1968 के जापानी विवरण में इसे “स्टोकास्टिक डिसेंट विधि” कहा गया है।

दाईं आकृति में 2 समूहों के बिंदु एक-दूसरे में मिले हैं। सीखने की दर η बड़ी रखें तो सही मानों के पास जल्दी पहुँचते हैं, लेकिन उतार-चढ़ाव चलता रहता है। छोटी रखें तो स्थिर होते हैं, लेकिन समय लगता है। η को धीरे-धीरे छोटा करने पर दोनों के फायदे मिल सकते हैं।

w ← w − η ∇L (x, t ; w)

w: भार
η: सीखने की दर (सुधार का आकार)
L: उस 1 उदाहरण की त्रुटि
∇L: वह दिशा जो बताती है कि किस ओर सुधारने पर L घटेगा

श्मिटहुबर (Schmidhuber, 2022) इसे संभवतः पहला शोधपत्र बताते हैं जिसने इस विधि से बहुस्तरीय न्यूरल नेटवर्क को सिखाया। लेकिन 1967 का सारांश रैखिक क्लासिफ़ायर और उनके विस्तार का सिद्धांत बताता है।

देखे गए उदाहरणों की संख्या और त्रुटि दर (बिंदीदार रेखा: सबसे अच्छी रेखा)

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

u04_amari_online.py

# u04 誤差から少しずつ修正する学習法（甘利の 1967 年の理論の考え方）
#
# どの出来事か：1967 年、甘利俊一の論文「適応するパターン分類器の理論」（記録 amari_adaptive_classifier_1967）。
#   例を 1 つ見るたびに、誤差に応じて重みを少しずつ修正する学習法を数学的に分析した。
#   2 つの組がきれいに分けられないデータでも、最適な重みに近づくことや、
#   修正の速さと正確さの引きかえを示した。
#   1968 年の日本語の解説では、この学習法を「確率的降下法」と呼んでいる。
# このサンプルの仕組み：
#   2 つの組の点が重なり合っている（直線 1 本では、どう引いても誤りが残る）。
#   点を 1 つ見るたびに、誤差（ここでは (正解 − 線の値)² ÷ 2）が減る向きへ、重みを η だけ動かす。
#   データと数値は、このサイトが作った例。誤差の決め方は、ここでは一例（論文はもっと広く扱う）。
# 試してみよう：
#   - ETAS の η を変えて、「速いがゆれる」「落ち着くが遅い」を見る
#   - 「だんだん小さく」の 100 を 10 や 1000 にする

import random

random.seed(1967)

def sample():
    t = random.choice((1, -1))
    cx, cy = (0.8, 0.6) if t == 1 else (-0.5, -0.4)
    return (cx + random.gauss(0, 0.9), cy + random.gauss(0, 0.9)), t

TEST = [sample() for _ in range(2000)]
STREAM = [sample() for _ in range(3000)]

def err_rate(w):
    return sum(1 for (x, y), t in TEST if (w[0] * x + w[1] * y + w[2] > 0) != (t > 0)) / len(TEST)

def learn(eta_of):
    w = [-1.5, 1.0, 1.0]                         # 重みの初期値（わざと誤った向きにしておく）
    hist = []
    for n, ((x, y), t) in enumerate(STREAM, 1):
        u = w[0] * x + w[1] * y + w[2]
        g = t - u                                # 誤差を減らす向き
        eta = eta_of(n)
        w = [w[0] + eta * g * x, w[1] + eta * g * y, w[2] + eta * g]
        if n in (10, 50, 200, 1000, 3000) or (n > 2500 and n % 25 == 0):
            hist.append((n, err_rate(w)))
    return hist

ETAS = {
    "η = 0.1（大きく直す）": lambda n: 0.1,
    "η = 0.002（少しずつ直す）": lambda n: 0.002,
    "η をだんだん小さく": lambda n: 0.1 / (1 + n / 100),
}
print("見た例の数ごとの誤り率（別の 2000 個の点＝テストデータで調べた）")
for name, f in ETAS.items():
    hist = learn(f)
    main = [(n, e) for n, e in hist if n in (10, 50, 200, 1000, 3000)]
    tail = [e for n, e in hist if n > 2500]
    swing = max(tail) - min(tail)
    print(f"\n【{name}】")
    for n, e in main:
        print(f"  {n:5d} 個見た後：{e:5.1%} {'■' * round(e * 60)}")
    print(f"  最後の 500 個での誤り率のゆれ：{swing:.1%}")
print("\n大きく直すと早く良くなるが、最後までゆれる。少しずつ直すと落ち着くが、時間がかかる。")
print("だんだん小さくすると、初めは速く、最後は落ち着く（速さと正確さの引きかえ）。")

151968 · खोज

तय दूरी + अनुमान से सबसे छोटा रास्ता

भूलभुलैया में खोज करते समय कौन-सा खाना पहले जाँचें?

जुलाई 1968 में SRI के हार्ट (Hart), निल्सन (Nilsson) और राफ़ाएल (Raphael) ने संकेत (ह्यूरिस्टिक) से सबसे कम खर्च वाला रास्ता खोजने के सिद्धांत पर शोधपत्र प्रकाशित किया। निल्सन की यादों के अनुसार, शैकी का रास्ता खोजने के लिए लक्ष्य तक के अनुमान में जोड़ने का विचार आया। अगर अनुमान असली बची दूरी से बड़ा न हो, तो सबसे छोटा रास्ता ज़रूर मिलता है। इस खोज विधि को A* (ए-स्टार) नाम दिया गया।

दाईं भूलभुलैया में 3 तरीके तुलना करके देखें। अनुमान न इस्तेमाल करें तो शुरुआत के पास से दूरी के क्रम में आसपास के सभी खाने जाँचे जाते हैं। A* लक्ष्य की ओर फैलता है। अनुमान 3 गुना करें तो कम खाने जाँचने पड़ते हैं, लेकिन रास्ता सबसे छोटा नहीं रहता।

f(n)＝g(n)＋h(n)　सबसे छोटे f वाला खाना पहले जाँचें

g(n): शुरुआत से n तक की दूरी
h(n): n से लक्ष्य तक का अनुमान (ऊर्ध्वाधर और क्षैतिज सीधी दूरी)

इस भूलभुलैया में जाँचे गए खानों की संख्या 133, 97 और 52 थी, और रास्तों की लंबाई 29, 29 और 39 थी। आज A* कार के नेविगेशन और खेलों में भी इस्तेमाल होता है (निल्सन 2010)।

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

u04_astar_maze.py

# u04 A*（エースター）：「ここまでの道のり＋ゴールまでの見積もり」で探す
#
# どの出来事か：1968 年 7 月、ハート、ニルソン、ラファエルの論文（記録 astar_search_1968）。
#   ロボット「シェーキー」の道探しのために、ここまで進んだ道のりに、ゴールまでのまっすぐの見積もりを
#   足して探す方法を作った。見積もりが本当の残りより大きくなければ、必ず最短の道が見つかることを示した。
# 仕組み：①見積もりなし（近い順に探索）②A*（ここまで＋見積もり）③見積もりを大きくしすぎた A* を比べる。
# 試してみよう：
#   - 3 つの結果の「調べたます目」と「道の長さ」を比べる（3 倍にすると速いが、最短ではなくなった）
#   - MAZE の壁（#）を動かす

import heapq

MAZE = [
    "S.##...#.#..........",
    ".#........#..#......",
    "....#...#......##...",
    ".........##.........",
    "#.......#...#..#..#.",
    ".....#..#..##.......",
    ".#..#..#....#...##.#",
    "...#.#.#..###..###.#",
    "#.#.#....#......##.G",
]
H, W = len(MAZE), len(MAZE[0])
start = next((r, c) for r in range(H) for c in range(W) if MAZE[r][c] == "S")
goal = next((r, c) for r in range(H) for c in range(W) if MAZE[r][c] == "G")

def search(weight):
    """weight=0 は見積もりなし、1 は A*、2 以上は見積もりを大きくしたもの。"""
    def guess(p):
        return weight * (abs(p[0] - goal[0]) + abs(p[1] - goal[1]))   # ゴールまでの見積もり（縦横の距離）
    frontier = [(guess(start), 0, start)]
    came = {start: None}
    cost = {start: 0}
    visited = []
    while frontier:
        _, g, p = heapq.heappop(frontier)
        if g > cost[p]:
            continue
        visited.append(p)
        if p == goal:
            break
        for dr, dc in ((1, 0), (-1, 0), (0, 1), (0, -1)):
            q = (p[0] + dr, p[1] + dc)
            if 0 <= q[0] < H and 0 <= q[1] < W and MAZE[q[0]][q[1]] != "#":
                ng = g + 1
                if ng < cost.get(q, 10 ** 9):
                    cost[q] = ng
                    came[q] = p
                    heapq.heappush(frontier, (ng + guess(q), ng, q))
    path, p = [], goal
    while p:
        path.append(p)
        p = came[p]
    return visited, path[::-1]

for name, weight in (("見積もりなし（近い順）", 0), ("A*（ここまで＋見積もり）", 1), ("見積もりを 3 倍にしたもの", 3)):
    visited, path = search(weight)
    print(f"{name}：調べたます目 {len(visited)}、見つけた道の長さ {len(path) - 1}")
    seen, route = set(visited), set(path)
    for r in range(H):
        row = ""
        for c in range(W):
            ch = MAZE[r][c]
            if ch == "#":
                row += "■"
            elif ch in "SG":
                row += "Ｓ" if ch == "S" else "Ｇ"
            elif (r, c) in route:
                row += "◎"
            elif (r, c) in seen:
                row += "・"
            else:
                row += "　"
        print("   " + row)
print("■＝壁　◎＝見つけた道　・＝調べたけれど道にならなかったます目")

161968 · जापान

ऋणात्मक तो 0, धनात्मक तो वही मान

केवल जोड़ने वाले न्यूरॉन कितनी भी परतों में रखें, क्या उनकी क्षमता बढ़ती है?

1968 में NHK की प्रसारण विज्ञान की बुनियादी अनुसंधान प्रयोगशाला के कुनिहिको फ़ुकुशिमा (Kunihiko Fukushima) ने बिल्ली और बंदर की आँखों और मस्तिष्क पर प्रयोगों से प्रेरणा लेकर परतों वाले नेटवर्क का कंप्यूटर पर सिम्युलेशन किया। यह हाथ से लिखे अक्षर पढ़ने वाली मशीन की ओर पहला कदम था। परतों से आगे बढ़ते हुए आकृति अलग बिंदुओं और अलग दिशाओं के रेखाखंडों में बँटती है, फिर रेखाखंडों के सिरे खोजे जाते हैं।

इस्तेमाल हुआ न्यूरॉन इनपुट के योग को धनात्मक होने पर ज्यों का त्यों, और ऋणात्मक होने पर 0 देता है। यह आज डीप लर्निंग में व्यापक रूप से इस्तेमाल होने वाले ReLU का ही रूप है। उन्होंने यह भी लिखा कि सब न्यूरॉन केवल जोड़ने वाले हों, तो कितनी भी परतें रखें, परिणाम 2 परतों जैसा ही है। दाईं आकृति में “ऋणात्मक तो 0 (ReLU · रेलू)” बंद करने पर रेखा न होने वाली जगहों के ऋणात्मक मान अगली परत में पहुँचते हैं, और सिरे सही नहीं मिलते।

आउटपुट ＝max(0, Σ भार × इनपुट)

max(0, u): u ऋणात्मक हो तो 0, धनात्मक हो तो वही मान (आज इसका नाम ReLU है)

आकृति के भार इस साइट ने सरल बनाए हैं (ये 1968 के नेटवर्क के असली भार नहीं हैं)। सिरा खोजने वाला न्यूरॉन रेखा पर पड़ोसी मानों को घटाता है।

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:ReLU 2010 के दशक की डीप लर्निंग का आविष्कार है
मूल स्रोत के अनुसार:इसी रूप का सक्रियण फ़ंक्शन (ऋणात्मक तो 0, धनात्मक तो वही मान) फ़ुकुशिमा के 1968 के जापानी विवरण और 1969 के अंग्रेज़ी शोधपत्र में आँख के काम करने की नकल के लिए इस्तेमाल हो चुका था।

इनपुट का योग और न्यूरॉन का आउटपुट

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

u04_relu_layers.py

# u04 「負なら 0、正ならそのまま」のニューロンを重ねて、線と線の端を見つける
#
# どの出来事か：1968 年、NHK の福島邦彦の「アナログ多層回路網による特徴抽出」（記録 fukushima_feature_network_1968）。
#   目と脳の仕組みを手本に層を重ね、図形を、孤立した点・向きごとの線分・線分の端点に分けていった。
#   ニューロンは、入力の合計が正ならそのまま、負なら 0 を出すもの（今の ReLU と同じ形）。
#   全部を足し算だけにすると、何層重ねても 2 層と同じになる、とも書いている。
# このサンプルの仕組み（このサイトが単純化した例。1968 年の回路網の重みそのものではない）：
#   ① 線の層：向き（横・縦）ごとに、隣の 3 つの点を足して 2 を引く → 3 つ並んでいる所だけ正になる
#   ② 端の層：線の層のある点から、その向きの隣の点を引く（隣に線が続いていなければ正）
#   ③ それぞれの層で「負なら 0」を使うか使わないかを切り替えて、結果を比べる
# 試してみよう：
#   - PATTERN の形を変える（「十」「L」など）
#   - 結果の「負なら 0」を使わない（足し算だけ）の方で、端ではない所にまで反応が出る理由を考える

PATTERN = [
    "..........",
    ".#######..",
    "....#.....",
    "....#.....",
    "....#.....",
    "....#.....",
    "..........",
]
H, W = len(PATTERN), len(PATTERN[0])
IMG = [[1 if ch == "#" else 0 for ch in row] for row in PATTERN]
DIRS = {"横": (0, 1), "縦": (1, 0)}

def px(img, y, x):
    return img[y][x] if 0 <= y < H and 0 <= x < W else 0

def relu(u, on=True):
    return max(0, u) if on else u

def line_layer(img, d, on):
    dy, dx = d
    return [[relu(px(img, y - dy, x - dx) + px(img, y, x) + px(img, y + dy, x + dx) - 2, on) for x in range(W)] for y in range(H)]

def end_layer(line, d, sign, on):
    """sign=+1：その向きの先の端、-1：手前の端。隣を引き、線が続いていない所だけ正にする。"""
    dy, dx = d[0] * sign, d[1] * sign
    return [[relu(px(line, y, x) - px(line, y + dy, x + dx), on) for x in range(W)] for y in range(H)]

def show(grid):
    return ["".join("." if v == 0 else ("+" if v > 0 else "-") for v in row) for row in grid]

for on in (True, False):
    print(f"━━ 「負なら 0」を {'使う（ReLU）' if on else '使わない（足し算だけ）'}")
    ends = set()
    for name, d in DIRS.items():
        ln = line_layer(IMG, d, on)
        e1, e2 = end_layer(ln, d, +1, on), end_layer(ln, d, -1, on)
        for grid in (e1, e2):
            ends |= {(y, x) for y in range(H) for x in range(W) if grid[y][x] > 0}
        print(f"  {name}の線の層" + " " * 6 + f"{name}の端の層（先・手前）")
        for a, b, c in zip(show(ln), show(e1), show(e2)):
            print(f"   {a}   {b}  {c}")
    print(f"  端と答えた場所：{len(ends)} か所（+ は正、- は負）\n")
print("足し算だけだと、線のない所の負の値（-2 など）が次の層に流れ込み、引き算で消えたり、端でない所に正が出たりする。")

# 足し算だけの層を重ねても、入力と出力の 2 層だけの回路（掛けて足す 1 回）にまとまることを確かめる
a = [[2, -1], [0, 3]]
b = [[1, 4], [-2, 1]]
ab = [[sum(b[i][k] * a[k][j] for k in range(2)) for j in range(2)] for i in range(2)]
x = [1, -2]
two = [sum(b[i][k] * sum(a[k][j] * x[j] for j in range(2)) for k in range(2)) for i in range(2)]
one = [sum(ab[i][j] * x[j] for j in range(2)) for i in range(2)]
print(f"\n足し算だけの層を 2 段通す：{two}　掛け算をまとめて 1 段で：{one} → 同じ（何段重ねても、入力と出力の 2 層だけの回路と同じ）")
print(f"段の間に「負なら 0」を挟むと：{[relu(sum(b[i][k] * relu(sum(a[k][j] * x[j] for j in range(2))) for k in range(2))) for i in range(2)]}（まとめられない）")

171968〜1969 · जापान

हाथ से लिखे डाक कोड पढ़ना

मशीन न पढ़ सकने वाले अक्षरों का क्या करती थी?

1 जुलाई 1968 को, जिस दिन जापान में डाक कोड प्रणाली शुरू हुई, टोक्यो के केंद्रीय डाकघर में डाक कोड पढ़ने और डाक छाँटने की स्वचालित मशीन दिखाई गई। इसे तोशिबा ने डाक और दूरसंचार मंत्रालय के मार्गदर्शन में बनाया था। मनुष्यों के अपनी सामान्य लिखावट में लिखे अंक पढ़कर डाक छाँटना माना जाता है। पूरे देश से जुटाए लगभग 300,000 हाथ से लिखे अंकों का विश्लेषण किया गया। ऑप्टिकल फ़िल्टर से लाल खाने हटाकर, मशीन लगभग 6 डाक प्रति सेकंड की गति से पहले 3 अंक पढ़ती थी।

विकासकर्ताओं के 1969 के शोधपत्र के अनुसार, मशीन अक्षर को क्षैतिज पट्टियों में जाँचती थी। विशेषताओं को 19 प्रकारों में बाँटती और उनके ऊपर से नीचे के क्रम की तुलना शब्दकोश में रखे हर अंक के अलग-अलग रूपों के क्रम से करती थी। जिस अंक में 2 या अधिक बेमेल जगहें हों, उसे हटा देती थी। केवल 1 बचा हो तो वही उत्तर था। 0 या 2 या अधिक बचें तो “पढ़ने से इनकार” मानकर डाक मनुष्य के पास भेज दी जाती थी।

बचे हुए अंक ＝ { d｜ बेमेल जगहों की संख्या (अक्षर का क्रम, d के शब्दकोश का क्रम)＜2 }

केवल 1 बचा: वही उत्तर
0 या 2 या अधिक: पढ़ने से इनकार (मनुष्य पढ़ता है)

आकृति के अक्षर और विशेषताएँ (5 प्रकार) इस साइट के बनाए उदाहरण हैं। 1969 के पहले अंतरराष्ट्रीय संयुक्त AI सम्मेलन में जापान के 5 शोधपत्रों में से 3 अक्षर पहचानने पर थे।

शोर की मात्रा और पढ़ने के परिणाम

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

u04_postal_digits.py

# u04 手書きの郵便番号を読む：型と比べ、自信がない字は人に回す
#
# どの出来事か：1968年7月1日、郵便番号制度が始まった日に、東芝が郵政省の指導で開発した
#   郵便番号自動読取区分機が公開された（記録 postal_code_reader_1968）。読めない字は「読取拒否」として人に回した。
# このサンプルの仕組み：数字の「型」（5×7のマス目）と、ゆがんだ手書き風の数字を1マスずつ比べ、
#   いちばん似ている型を答えにする。1位と2位の差が小さい（自信がない）ときは、答えずに人に回す。
#   ※ 1968年の機械は、線の向きの並びを使うなど、もっと工夫した読み方をしていた。いちばん下に、
#     それに近い読み方（横の帯の特徴の上下の並びを辞書と比べ、2か所以上合わない数字は外す）も入れた。
#   ※ 手書き風の数字は、このプログラムが型をずらしたり、点の白黒を変えたりして作った例（本物の手書きではない）。
# 試してみよう：
#   - NOISE（点の白黒が変わる割合）を上げると、何が起きるか
#   - 最後の「ずらして比べる」は、なぜ効くのか（→ u05 の福島さんのネオコグニトロン）
#   - いちばん下の「1968 年の機械に近い読み方」で、合わない所をいくつまで許すか（< 2）を < 1 にすると、どう変わるか

import random

random.seed(1968)
NOISE = 0.10    # 1 マスの白黒が反転する割合
SHIFT = 0.5     # 字が上下左右に 1 マスずれる割合
FONT = {
    "0": [".###.", "#...#", "#..##", "#.#.#", "##..#", "#...#", ".###."],
    "1": ["..#..", ".##..", "..#..", "..#..", "..#..", "..#..", ".###."],
    "2": [".###.", "#...#", "....#", "...#.", "..#..", ".#...", "#####"],
    "3": ["#####", "...#.", "..#..", "...#.", "....#", "#...#", ".###."],
    "4": ["...#.", "..##.", ".#.#.", "#..#.", "#####", "...#.", "...#."],
    "5": ["#####", "#....", "####.", "....#", "....#", "#...#", ".###."],
    "6": ["..##.", ".#...", "#....", "####.", "#...#", "#...#", ".###."],
    "7": ["#####", "....#", "...#.", "..#..", ".#...", ".#...", ".#..."],
    "8": [".###.", "#...#", "#...#", ".###.", "#...#", "#...#", ".###."],
    "9": [".###.", "#...#", "#...#", ".####", "....#", "...#.", ".##.."],
}
H, W = 7, 5

def to_grid(rows):
    return [[1 if ch == "#" else 0 for ch in row] for row in rows]

def shifted(g, dy, dx):
    return [[g[y - dy][x - dx] if 0 <= y - dy < H and 0 <= x - dx < W else 0 for x in range(W)] for y in range(H)]

def handwrite(d):
    g = to_grid(FONT[d])
    if random.random() < SHIFT:
        g = shifted(g, random.choice([-1, 0, 1]), random.choice([-1, 0, 1]))
    return [[1 - v if random.random() < NOISE else v for v in row] for row in g]

def similarity(a, b):
    return sum(a[y][x] == b[y][x] for y in range(H) for x in range(W))   # 一致するマスの数（35 点満点）

TEMPLATES = {d: to_grid(rows) for d, rows in FONT.items()}

def read(g, try_shifts=False):
    scores = []
    for d, t in TEMPLATES.items():
        cands = [t] if not try_shifts else [shifted(t, dy, dx) for dy in (-1, 0, 1) for dx in (-1, 0, 1)]
        scores.append((max(similarity(g, c) for c in cands), d))
    scores.sort(reverse=True)
    (s1, d1), (s2, _) = scores[0], scores[1]
    return d1, s1 - s2   # 答えと、1 位と 2 位の差（自信）

tests = [(d, handwrite(d)) for d in FONT for _ in range(100)]   # 各数字 100 字、計 1000 字
print("手書き風の 3 の例:")
for row in [d for d in tests if d[0] == "3"][0][1]:
    print("   " + "".join("■" if v else "・" for v in row))

for try_shifts in (False, True):
    results = [(d, *read(g, try_shifts)) for d, g in tests]
    title = "型をずらして比べる" if try_shifts else "型をそのまま比べる"
    print(f"\n【{title}】")
    print("  人に回す基準（差がこれ未満なら人へ）  人に回した字  機械が読んだ字の正しさ")
    for margin in (0, 1, 2, 3, 4):
        taken = [(d, a) for d, a, gap in results if gap >= margin]
        ok = sum(d == a for d, a in taken)
        print(f"  差 {margin} 未満 {'':18} {1000 - len(taken):4d} 字 {'':10} {ok / max(1, len(taken)):.1%}")

# ---------------------------------------------------------------------------
# 1968 年の機械に近い読み方：横の帯の特徴の「上下の並び」を、辞書の並びと比べる
#   1969 年の開発者の論文（記録 postal_code_reader_1968）によると、字を横の細い帯ごとに調べて
#   横の特徴を 19 種類に分け、その上下の並びを、辞書に入れた各数字の変形の並びと比べた。
#   合わない所が 2 か所以上ある数字は外し、残りが 1 つなら答え、0 か 2 つ以上なら「読取拒否」とした。
#   ここでは、特徴を 5 種類だけにした（このサイトが単純にした例）：
#     _＝何もない  -＝横棒  L＝左に線  C＝中央に線  R＝右に線  D＝線が 2 本
# ---------------------------------------------------------------------------

def row_feature(row):
    runs, x = [], 0
    while x < W:
        if row[x]:
            s = x
            while x < W and row[x]:
                x += 1
            runs.append((s, x - 1))
        x += 1
    if not runs:
        return "_"
    if len(runs) >= 2:
        return "D"
    s, e = runs[0]
    if e - s >= 2:
        return "-"
    c = (s + e) / 2
    return "L" if c < 1.5 else ("R" if c > 2.5 else "C")

def feature_seq(g):
    seq = [row_feature(r) for r in g]
    out = [f for i, f in enumerate(seq) if i == 0 or f != seq[i - 1]]   # 同じ特徴の連続を 1 つにまとめる
    return "".join(out).strip("_")

def mismatch(a, b):
    """合わない所の数（1 文字の置換・挿入・削除を 1 回と数える）"""
    d = list(range(len(b) + 1))
    for i, ca in enumerate(a, 1):
        prev, d[0] = d[0], i
        for j, cb in enumerate(b, 1):
            prev, d[j] = d[j], min(d[j] + 1, d[j - 1] + 1, prev + (ca != cb))
    return d[-1]

# 辞書：型そのものと、上下左右に 1 マスずらした変形の並び（1968 年の辞書は、約 30 万字の手書き数字の分析から作った）
DICT = {d: sorted({feature_seq(shifted(t, dy, dx)) for dy in (-1, 0, 1) for dx in (-1, 0, 1)}) for d, t in TEMPLATES.items()}
print("\n【1968 年の機械に近い読み方：横の特徴の並びを辞書と比べる】")
print("  辞書（数字ごとの並びの変形。一部）：")
for d, seqs in DICT.items():
    print(f"    {d}：{' / '.join(seqs[:5])}{' …' if len(seqs) > 5 else ''}")

def read_1968(g):
    seq = feature_seq(g)
    left = [d for d, seqs in DICT.items() if min(mismatch(seq, s) for s in seqs) < 2]   # 合わない所が 2 か所以上なら外す
    return (left[0] if len(left) == 1 else None), seq, left

def score(samples):
    right = wrong = reject = 0
    for d, g in samples:
        ans, _, _ = read_1968(g)
        if ans is None:
            reject += 1
        elif ans == d:
            right += 1
        else:
            wrong += 1
    return right, wrong, reject

ex = [t for t in tests if t[0] == "3"][0][1]
ans, seq, left = read_1968(ex)
print(f"  上の手書き風の 3 の並び：{seq}　残った数字：{left} → {ans if ans else '読取拒否'}")
for noise in (0.0, 0.02, NOISE):
    rnd = random.Random(7)
    samples = []
    for d in FONT:
        for _ in range(100):
            g = to_grid(FONT[d])
            if rnd.random() < SHIFT:
                g = shifted(g, rnd.choice([-1, 0, 1]), rnd.choice([-1, 0, 1]))
            samples.append((d, [[1 - v if rnd.random() < noise else v for v in row] for row in g]))
    right, wrong, reject = score(samples)
    print(f"  雑音 {noise:.2f} の 1000 字：正しく読んだ {right}、まちがえた {wrong}、読取拒否（人へ） {reject}"
          f"　機械が答えた字の正しさ {right / max(1, right + wrong):.1%}")
print("  特徴を 5 種類にしぼったので、別の数字と並びが似てしまい、読取拒否が多くなる（1968 年の機械は 19 種類）。")
print("  雑音が増えると、読取拒否もまちがいも増える。1968 年の機械は、線の太さをそろえる回路や、")
print("  字の大きさをそろえる回路で、比べる前に字を整えていた。")

181967〜1970 · भविष्यवाणी

एक पीढ़ी, 3〜8 वर्ष, जल्द संभव नहीं

उसी समय की भविष्यवाणियाँ कहाँ लिखी गई थीं?

1967 में मार्विन मिन्स्की (Marvin Minsky) ने अपनी किताब में लिखा, “एक पीढ़ी के भीतर … बनाने की समस्याएँ काफी हद तक हल हो जाएँगी” (अनुवाद)। 1970 में Life पत्रिका के पत्रकार के लेख ने बताया कि मिन्स्की ने (अनुवाद) वाली मशीन बनने की बात कही थी। लेख ने एक और शोधकर्ता के (अनुवाद) कहने की भी ख़बर दी। 1968 की फ़िल्म में मनुष्य की आवाज़ में बोलने वाला कंप्यूटर HAL 9000 आता है।

उसी 1968 में जापान के शुनइचि अमारी (Shun'ichi Amari) ने लिखा, (अनुवाद)। दाईं आकृति में भविष्यवाणी के वर्ष से उसकी समय-सीमा तक रेखा खींची गई है। रंग और कार्ड का आकार शब्दों का स्रोत बताते हैं। “मौजूदा वर्ष” बदलने पर दिखता है कि समय-सीमा पूरी होने वाली भविष्यवाणियों का क्या हुआ।

किताब नहीं बताती कि कितने वर्ष हैं। इतिहासकार की किताब कहती है कि मिन्स्की ने बाद में उद्धरण का खंडन लिखा। लेकिन यह पुष्टि नहीं हुई कि उन्होंने वाली बात का ही खंडन किया था।

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:मिन्स्की ने 1970 में निश्चित रूप से कहा कि “3〜8 वर्षों में मनुष्य जैसी बुद्धिमत्ता वाली मशीन” आएगी
मूल स्रोत के अनुसार:ये शब्द मूल रूप से पत्रिका के पत्रकार के लेख में थे (Life, 20 नवंबर 1970 का अंक, पृष्ठ 58D)। उनकी अपनी किताब (1967) में शब्द थे (किताब के पन्ने नहीं देखे जा सके; इसकी पुष्टि उसे उद्धृत करने वाली 2 किताबों से हुई)।

191971 · भाषा

ब्लॉकों की दुनिया में बातचीत चलती है

दायरा सीमित कर दें तो क्या कंप्यूटर भाषा “समझता” है?

जनवरी 1971 में MIT के टेरी विनोग्रैड (Terry Winograd) ने डॉक्टरेट थीसिस में एक प्रोग्राम प्रस्तुत किया, जिसे बाद में SHRDLU कहा गया। यह अंग्रेज़ी की बातचीत में सवालों के जवाब देता और निर्देश पूरा करता था। इसकी दुनिया में हाथ और आँख वाला एक साधारण रोबोट मेज़ पर ब्लॉक और पिरामिड हिलाता है। (अनुवाद) कहने पर इसने ऊपर रखा ब्लॉक पहले हटाया, फिर माँगा गया ब्लॉक उठाकर कहा। (अनुवाद) कहने पर, दृश्य में 3 पिरामिड होने के कारण इसने पूछा, (अनुवाद)।

दाईं आकृति में “निर्देश दें” दबाएँ। आकार, रंग और माप के शब्दों से वस्तुएँ छाँटी जाती हैं। केवल 1 बचे तो काम करता है, 2 या अधिक हों तो पूछता है; कोई न हो तो यह बता देता है। थीसिस में शब्दावली 200 शब्दों की थी और 1 वाक्य में 5〜20 सेकंड लगते थे।

मेल खाने वाली 1 वस्तु → काम करें　2 या अधिक → फिर पूछें　0 → बताएँ कि कोई नहीं है

मेल खाने वाली वस्तुएँ: वे वस्तुएँ जिनका आकार, रंग और माप निर्देश के शब्दों से मेल खाते हैं

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:SHRDLU ने रोबोट की बाँह से असली ब्लॉक हिलाए और अंग्रेज़ी समझी
मूल स्रोत के अनुसार:थीसिस में रोबोट और ब्लॉक स्क्रीन पर सिम्युलेशन थे। “रोबोट की किसी तरह की “आँख”” होने का अनुमान लगाकर दृश्य का डेटा शुरू में ही दिया गया था। बातचीत लिखकर होती थी। 2004 में विनोग्रैड ने खुद लिखा कि SHRDLU के काम करने के तरीके और मस्तिष्क के काम के बीच बुनियादी अंतर है (निल्सन (Nilsson) के अनुसार)।

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

u04_blocks_world.py

# u04 積み木の世界で命令を聞く（SHRDLU のまね）
#
# どの出来事か：1971年1月、MITのウィノグラードの博士論文のプログラム（のちにSHRDLUと呼ばれる。記録 winograd_shrdlu_1971）。
#   机の上の積み木やピラミッドを動かす世界。「大きな赤い積み木を持ち上げて」（訳）には上の積み木をどけて持ち上げた。
#   「そのピラミッドをつかんで」（訳）には、場面に3つあるので聞き返した。「それ」が何を指すかも判断した。
#   ロボットと積み木は画面上のシミュレーションで、語彙は200語だった。
# このサンプルの仕組み（このサイトが小さくした例。論文のプログラムの中身ではない）：
#   ① 命令を言葉に分け、知っている言葉（大きさ・色・形・動き）だけで読む。知らない言葉があれば、そう答える
#   ② 大きさ・色・形が合う物を探す。1つなら動く。2つ以上なら聞き返す。0なら「見つからない」
#   ③ 持ち上げる物の上に何か載っていれば、先にどける。手に何か持っていれば、先に置く
#   ④ 「それ」は、前の命令で決まった物を指す
# 試してみよう：
#   - COMMANDS に「小さな 緑の 積み木 を 持ち上げて」を足す
#   - 知らない言葉（例：「そっと」）を入れると、どう答えるか

SIZE = {"大きな": "大", "小さな": "小"}
COLOR = {"赤い": "赤", "緑の": "緑", "青い": "青", "黄色い": "黄"}
SHAPE = {"積み木": "積み木", "ピラミッド": "ピラミッド", "箱": "箱"}
VERB = {"持ち上げて": "take", "つかんで": "take", "置いて": "put", "入れて": "into"}
OTHER = {"を", "に", "それ", "机"}

# 物：名前 → (大きさ, 色, 形)。位置：何の上（または中）にあるか
THINGS = {
    "A": ("大", "赤", "積み木"), "B": ("小", "緑", "積み木"), "C": ("大", "緑", "積み木"),
    "D": ("小", "赤", "ピラミッド"), "E": ("小", "緑", "ピラミッド"), "F": ("大", "青", "ピラミッド"), "箱": ("大", "白", "箱"),
}
ON = {"A": "机", "B": "A", "C": "机", "D": "C", "E": "机", "F": "箱", "箱": "机"}
hand = None
last = None

def desc(k):
    s, c, sh = THINGS[k]
    adj = {"赤": "赤い", "緑": "緑の", "青": "青い", "白": "白い", "黄": "黄色い"}[c]
    return f"{'大きな' if s == '大' else '小さな'}{adj}{sh}（{k}）"

def top_of(k):
    return [x for x, below in ON.items() if below == k and THINGS[k][2] != "箱"]

def put_on_table(k, log):
    ON[k] = "机"
    log.append(f"{desc(k)}を机に置く")

def take(k, log):
    global hand
    if hand and hand != k:
        put_on_table(hand, log)
        hand = None
    for x in top_of(k):                      # 上に載っている物を先にどける
        take(x, log)
        put_on_table(x, log)
        globals()["hand"] = None
    ON[k] = "手"
    hand = k
    log.append(f"{desc(k)}を持ち上げる")

def command(text):
    global last, hand
    words = text.split()
    unknown = [w for w in words if w not in SIZE and w not in COLOR and w not in SHAPE and w not in VERB and w not in OTHER]
    if unknown:
        return f"知らない言葉があります：{'・'.join(unknown)}", []
    verb = next((VERB[w] for w in words if w in VERB), None)
    obj_words = words[:words.index("を")] if "を" in words else []
    if obj_words == ["それ"]:
        found = [last] if last else []
    else:
        size = [SIZE[w] for w in obj_words if w in SIZE]
        color = [COLOR[w] for w in obj_words if w in COLOR]
        shape = [SHAPE[w] for w in obj_words if w in SHAPE]
        found = [k for k, (s, c, sh) in THINGS.items()
                 if (not size or s == size[0]) and (not color or c == color[0]) and (not shape or sh == shape[0])]
    if not found:
        return "そんな物は見つかりません。", []
    if len(found) > 1:
        name = obj_words[-1] if obj_words else "物"
        return f"どの{name}のことか分かりません。（候補：{'、'.join(desc(k) for k in found)}）", []
    k = found[0]
    last = k
    log = []
    if verb == "take":
        if THINGS[k][2] == "箱":
            return "箱は持ち上げられません。", []
        take(k, log)
    elif verb == "put":
        if hand != k:
            take(k, log)
        put_on_table(k, log)
        hand = None
    elif verb == "into":
        if hand != k:
            take(k, log)
        ON[k] = "箱"
        hand = None
        log.append(f"{desc(k)}を箱に入れる")
    return "OK.", log

def scene():
    rows = []
    for base in [k for k, b in ON.items() if b == "机"]:
        stack, cur = [base], base
        while True:
            up = [x for x, b in ON.items() if b == cur]
            if not up or THINGS[cur][2] == "箱":
                break
            cur = up[0]
            stack.append(cur)
        inside = [x for x, b in ON.items() if b == "箱"] if base == "箱" else []
        rows.append(" の上に ".join(desc(x) for x in stack) + (f"［中：{'、'.join(desc(x) for x in inside)}］" if inside else ""))
    return rows + ([f"手：{desc(hand)}"] if hand else ["手：なし"])

COMMANDS = [
    "大きな 赤い 積み木 を 持ち上げて",
    "ピラミッド を つかんで",
    "青い ピラミッド を つかんで",
    "それ を 箱 に 入れて",
    "緑の 積み木 を 持ち上げて",
    "黄色い 積み木 を 持ち上げて",
    "赤い ピラミッド を そっと 置いて",
]
print("初めの場面：")
for r in scene():
    print("   ", r)
for c in COMMANDS:
    answer, log = command(c)
    print(f"\n人：{c.replace(' ', '')}")
    for step in log:
        print(f"   （動き）{step}")
    print(f"機械：{answer}")
print("\n終わりの場面：")
for r in scene():
    print("   ", r)

आवाज़ की एक-एक ध्वनि पहचानना

गति याद करके दोहराने वाली बाँह

चेकर्स: क्या खेल “हल हो गया”?

सवाल को समीकरण बनाकर हल करना

ELIZA का रहस्य खुलता है

ELIZA किस वर्ष का है?

सभी विकल्प बनाएँ, नियमों से छाँटें

कितने cm से कोई “लंबा व्यक्ति” है?

क्या मशीनें मनुष्य का हर काम कर पाएँगी?

हर साल दोगुना, लगातार 10 साल

जाँची जाने वाली चालें छाँटना

टकराए तो नक्शा सुधारकर फिर खोजें

वस्तु और पृष्ठभूमि अलग करना

त्रुटि से थोड़ा-थोड़ा सीखना

तय दूरी + अनुमान से सबसे छोटा रास्ता

ऋणात्मक तो 0, धनात्मक तो वही मान

हाथ से लिखे डाक कोड पढ़ना

एक पीढ़ी, 3〜8 वर्ष, जल्द संभव नहीं

ब्लॉकों की दुनिया में बातचीत चलती है

इस अध्याय में क्या अब भी अज्ञात है

चेकर्स: क्या खेल ?