जापान की पाँचवीं पीढ़ी | AI का पूरा इतिहास

011946〜1981 · नाम

नाम क्यों?

कंप्यूटरों की “पीढ़ियाँ” किस आधार पर गिनी जाती थीं?

कभी कंप्यूटरों की पीढ़ियाँ उनमें इस्तेमाल होने वाले इलेक्ट्रॉनिक घटकों के आधार पर गिनी जाती थीं। जापान सूचना प्रसंस्करण विकास संघ (JIPDEC) की 1981 की पुस्तिका ने इन्हें इस तरह बाँटा: पहली पीढ़ी (वैक्यूम ट्यूब), दूसरी पीढ़ी (ट्रांज़िस्टर), तीसरी पीढ़ी (IC), 3.5वीं पीढ़ी (LSI) और चौथी पीढ़ी (VLSI)। उसने लिखा कि उस समय चौथी पीढ़ी की शुरुआत हो रही थी और इनमें से लगभग सभी कंप्यूटर वॉन नॉयमन ढाँचे पर चलते थे, जिसे वॉन नॉयमन (von Neumann) ने 1946 में प्रस्तुत किया था।

इस ढाँचे में निर्देश और डेटा एक ही मेमोरी में रखे जाते हैं। निर्देशों को एक-एक करके निकाला और क्रम से चलाया जाता है। पुस्तिका ने कहा कि इस ढाँचे की कमज़ोरियों से आगे जाने के लिए (अनुवाद) पाँचवीं पीढ़ी की ज़रूरत है। दाईं आकृति में पीढ़ियों के खानों को दबाएँ। केवल पाँचवीं पीढ़ी के लिए घटक को (अनुवाद) कहा गया है, और उसका काम (अनुवाद) है: तर्क निकालना, ज्ञान का भंडार और समझदारी से संवाद करने वाला इंटरफ़ेस। यह घटकों का बदलाव नहीं, सोच की अगली पीढ़ी थी।

परियोजना के लिए अध्ययन वित्त वर्ष 1979 में शुरू हुआ। समिति के अध्यक्ष टोक्यो विश्वविद्यालय के तोरू मोटो-ओका (Tohru Moto-oka) थे। उसी वर्ष, अगस्त 1979 में, छठा अंतरराष्ट्रीय संयुक्त कृत्रिम बुद्धिमत्ता सम्मेलन (IJCAI) टोक्यो में हुआ। पहले के 5 सम्मेलन वॉशिंगटन, लंदन, स्टैनफ़र्ड, त्बिलिसी और कैम्ब्रिज में हुए थे।

021981 · लक्ष्य

आँख, कान और मुँह वाला कंप्यूटर जो बात समझे

1981 में पाँचवीं पीढ़ी के लिए कैसा कंप्यूटर बनाने का लक्ष्य लिखा गया था?

नवंबर 1981 की JIPDEC पुस्तिका ने पाँचवीं पीढ़ी के कंप्यूटर के बारे में लिखा कि (अनुवाद)। उसने (अनुवाद), यानी एक प्रयोगात्मक मशीन बनाना, संभव करने के लिए जल्दी शोध शुरू करने की ज़रूरत बताई। उसने लक्ष्य के रूप में 8 क्षमताएँ गिनाईं। इनमें आवाज़ और चित्रों को सीधे संभालने वाला (अनुवाद), स्वाभाविक भाषा में बात करने वाला (अनुवाद), जिसके लिए (अनुवाद) कहा गया, और सामान्य समझ के साथ तर्क से समस्याएँ हल करने वाला कंप्यूटर शामिल थे।

दाईं आकृति का एक छोटा उदाहरण है, जिसे 3 चरणों में बाँटा गया है: ① बात को तार्किक प्रश्न में बदलना, ② तर्क निकालना, ③ ज्ञान खोजना। बात कहने का तरीका थोड़ा बदलते ही यह ① पर रुक जाता है। साथ ही, “उम्र में बड़ा?” जैसे प्रश्न का उत्तर देने के लिए यह सामान्य ज्ञान दर्ज होना चाहिए कि माता-पिता अपने बच्चे से बड़े होते हैं।

1993 की अंतिम मूल्यांकन रिपोर्ट में लिखा है कि शोध के दौरान समझ में आया कि आवाज़ और चित्रों को ज्ञान की तरह इस्तेमाल करने के लिए बहुत बड़े पैमाने पर पृष्ठभूमि का ज्ञान इकट्ठा करके व्यवस्थित करना ज़रूरी है।

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:पाँचवीं पीढ़ी ने 10 साल में इंसान की तरह बोलने वाला कंप्यूटर बनाने का वादा किया था
मूल स्रोत के अनुसार:1981 के दस्तावेज़ में सचमुच (अनुवाद) और (अनुवाद) लिखा है। लेकिन निदेशक काज़ुहिरो फ़ुची (Kazuhiro Fuchi) ने 1992 में बताया कि 1982 में वास्तव में शुरू हुई योजना में मशीन अनुवाद जैसी अनुप्रयोग प्रणालियों का विकास लक्ष्य से हटा दिया गया था और शोध तर्क निकालने वाली मशीनों तक सीमित था। किस वर्ष का कौन-सा दस्तावेज़ देखें, इसके अनुसार घोषित लक्ष्य बदलते हैं।

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

u07_knowledge_pipeline.py

# u07 「話がわかるコンピュータ」を小さく作る：日常の言葉 → 論理の問い → 推論 → 答え
#
# どの出来事か：1981年の冊子は、第五世代の目指す姿として「話がわかるコンピュータ」や
#   「常識ある問題解決型コンピュータ」などを挙げた（記録 fgcs_goals_prediction_1981）。
#   1993年の最終評価では、音声や画像を知識として扱うには、膨大な背景知識を蓄積して整理する必要があると
#   研究の途中で分かった、と総括された（記録 fgcs_final_evaluation_1993）。
# 仕組み：3つの段階に分ける。
#   ① 入出力（口・耳）：決まったパターンの文を、論理の問いに変換する（ここでは型の照合のみ）
#   ② 推論：事実と規則から、問いの答えを導く（後向き推論）
#   ③ 知識：事実と規則の集まり。ここに「常識」の規則がないと、答えられない問いがある
#   文のパターン・事実・規則は、このサイトが作った小さな例。
# 試してみよう：
#   - COMMON_SENSE の規則を 1 つずつ消して、どの問いに答えられなくなるか確かめる
#   - 言い回しを少し変えた問い（例：「はなこの おとうさんは だれ？」）を足す。①の段階で止まるはず

import re

FACTS = {
    ("親", "たろう", "はなこ"), ("親", "たろう", "じろう"), ("親", "うめ", "たろう"),
    ("男", "たろう"), ("男", "じろう"), ("女", "はなこ"), ("女", "うめ"),
    ("天気", "あした", "雨"),
}
RULES = [  # (頭部, [本体]) 大文字で始まる語は変数
    (("父", "X", "Y"), [("親", "X", "Y"), ("男", "X")]),
    (("祖母", "X", "Z"), [("親", "X", "Y"), ("親", "Y", "Z"), ("女", "X")]),
]
COMMON_SENSE = [
    (("年上", "X", "Y"), [("親", "X", "Y")]),                                   # 親は子より年上
    (("年上", "X", "Z"), [("親", "X", "Y"), ("年上", "Y", "Z")]),               # 年上の年上は年上
    (("要る", "かさ", "D"), [("天気", "D", "雨")]),                             # 雨の日は、傘が要る
]

# ① 文のパターン → 論理の問い
PATTERNS = [
    (r"^(\S+)の 父は だれ？$", lambda m: ("父", "W", m[1])),
    (r"^(\S+)の 祖母は だれ？$", lambda m: ("祖母", "W", m[1])),
    (r"^(\S+)は (\S+)より 年上？$", lambda m: ("年上", m[1], m[2])),
    (r"^(\S+)は かさが 要る？$", lambda m: ("要る", "かさ", m[1])),
]

is_var = lambda t: t[:1].isupper()

def subst(t, env):
    while is_var(t) and t in env:
        t = env[t]
    return t

def unify(a, b, env):
    if len(a) != len(b):
        return None
    env = dict(env)
    for x, y in zip(a, b):
        x, y = subst(x, env), subst(y, env)
        if x == y:
            continue
        if is_var(x):
            env[x] = y
        elif is_var(y):
            env[y] = x
        else:
            return None
    return env

def solve(goals, env, rules, depth=0, n=[0]):
    if not goals:
        yield env
        return
    if depth > 12:
        return
    g, rest = goals[0], goals[1:]
    for f in sorted(FACTS):
        e = unify(g, f, env)
        if e is not None:
            yield from solve(rest, e, rules, depth, n)
    for head, body in rules:
        n[0] += 1
        ren = lambda t: tuple(f"{x}_{n[0]}" if is_var(x) else x for x in t)
        e = unify(g, ren(head), env)
        if e is not None:
            yield from solve([ren(b) for b in body] + rest, e, rules, depth + 1, n)

def show(q):
    return f"{q[0]}({', '.join(q[1:])})"

def answer(text, rules):
    for pat, make in PATTERNS:
        m = re.match(pat, text)
        if m:
            q = make(m)
            break
    else:
        return "①で止まった：この言い回しは登録されていない"
    found = [subst("W", e) if "W" in q else "はい" for e in solve([q], {}, rules)]
    if not found:
        return f"②③で止まった：{show(q)} を導けない（知識が足りない）"
    return f"{show(q)} → " + "、".join(dict.fromkeys(found))

QUESTIONS = ["はなこの 父は だれ？", "はなこの 祖母は だれ？", "うめは はなこより 年上？",
             "あしたは かさが 要る？", "はなこの おとうさんは だれ？"]

for label, rules in (("常識の規則 なし", RULES), ("常識の規則 あり", RULES + COMMON_SENSE)):
    print(f"--- {label}（規則 {len(rules)} 個・事実 {len(FACTS)} 個）")
    for q in QUESTIONS:
        print(f"  {q:18}  {answer(q, rules)}")
print("\n文の型を合わせるだけでは、言い回しが少し変わると止まる。常識が足りないと、推論はできても答えが出ない")

031981〜1995 · अनुसंधान संस्थान

सम्मेलन से ICOT संस्थान तक

राष्ट्रीय परियोजना को किन लोगों ने और कैसे आगे बढ़ाया?

19〜22 अक्टूबर 1981 को टोक्यो में (अनुवाद) हुआ। आयोजकों की पुस्तिका के अनुसार, 15 देशों से लगभग 300 लोग आए।

अप्रैल 1982 में “नई पीढ़ी की कंप्यूटर तकनीक विकास संस्था (ICOT)” (अनुवाद) नाम की संस्था बनी और जून में उसके अनुसंधान संस्थान ने शोध शुरू किया। इलेक्ट्रोटेक्निकल लैबोरेटरी से आए काज़ुहिरो फ़ुची (Kazuhiro Fuchi) निदेशक बने। शोधकर्ता इलेक्ट्रोटेक्निकल लैबोरेटरी, निप्पॉन टेलीग्राफ़ ऐंड टेलीफ़ोन सार्वजनिक निगम और 8 कंप्यूटर कंपनियों से भेजे गए थे। शुरुआत लगभग 40 लोगों से हुई और आम तौर पर हर 3〜4 साल में उनकी जगह नए लोग आए। पूरा धन अंतरराष्ट्रीय व्यापार और उद्योग मंत्रालय द्वारा सौंपे गए काम के लिए मिला था।

दाईं आकृति संस्थान की सीटों और उनमें बदलते लोगों को दिखाती है। शुनइची उचिदा (Shun'ichi Uchida, 2005) लिखते हैं कि बढ़ाई गई अवधि सहित 13 वर्षों में लगभग 200 लोग ICOT में प्रतिनियुक्ति पर आए। यदि 40 सीटों पर हर 3〜4 साल में लोग बदलें, तो संख्या लगभग इतनी ही होती है।

यहाँ काम कर चुके लोग ≈ S ×（1＋（T − 1）÷ L）

S: सीटों की संख्या
T: वर्षों की संख्या (13)
L: एक व्यक्ति के रहने के वर्ष (3〜4)

आए हुए लोगों की कुल संख्या (वर्ष के अनुसार)

041972〜1984 · लॉजिक प्रोग्रामिंग

तथ्यों और नियमों से उत्तर देना

क्या प्रोग्राम लिखने का मतलब केवल काम के चरण लिखना है?

1972 में मार्सेय में कोलमेरोएर (Colmerauer) और रूसेल (Roussel) ने Prolog भाषा बनाई। इसमें तर्क के कथनों को साथ रखने पर वे अपने आप एक प्रोग्राम बन जाते हैं। उनके साथ इस विचार पर काम करने वाले कोवाल्स्की (Kowalski) ने याद किया कि उसी गर्मी में (अनुवाद)।

Prolog में गणना के चरणों के बजाय तथ्य लिखे जाते हैं, जैसे तारो (Taro), हनाको (Hanako) का अभिभावक है; और नियम लिखे जाते हैं, जैसे अगर X, Y का अभिभावक है और Y, Z का अभिभावक है, तो X, Z का दादा-दादी या नाना-नानी है। प्रश्न मिलने पर कंप्यूटर ऊपर से नियम आज़माता है। मेल न हो तो वापस जाकर अगला नियम आज़माता है। इसे बैकट्रैकिंग, यानी पीछे लौटना कहते हैं। दाईं आकृति में “1 कदम” दबाएँ।

पाँचवीं पीढ़ी ने लॉजिक प्रोग्रामिंग को केंद्र में रखा। निल्सन (Nilsson, 2010) के अनुसार, कोइची फ़ुरुकावा (Koichi Furukawa), जो बाद में ICOT के उपनिदेशक बने, ने 1970 के दशक में SRI में Prolog के बारे में जाना और इसे चलाने वाला सॉफ़्टवेयर जापान लाए। काज़ुहिरो फ़ुची (Kazuhiro Fuchi) ने 1984 में कहा कि Prolog चुनने के अपने निर्णय पर उनका भरोसा लगातार बढ़ रहा है।

दादा-दादी_या_नाना-नानी(X, Z) ← अभिभावक(X, Y), अभिभावक(Y, Z)

X, Y, Z: चर
←: यदि दाईं ओर की सभी बातें सच हैं, तो बाईं ओर की बात भी सच है

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

u07_mini_prolog.py

# u07 論理プログラミング言語 Prolog の簡易実装：事実と規則から推論で問いに答える
#
# どの出来事か：1972年、マルセイユで Prolog が誕生した（記録 prolog_marseille_1972）。第五世代コンピュータ
#   プロジェクト（1982〜）は論理推論を行うマシンを目指し、1992年の並列推論マシン PIM/p（512台のコンピュータ）は
#   1秒に1億5,600万回の推論を達成した（記録 fgcs92_pim_kl1_1992。目標は1秒に1億回）。
# 仕組み：「親(たろう, はなこ)」のような事実と、「祖父母(X, Z) は 親(X, Y) かつ 親(Y, Z)」のような規則を定義する。
#   問いを入力すると、規則の左辺と問いを照合し（単一化）、右辺の条件を順に検証する。成立しなければ戻って別の道を試す（後戻り）。
#   ここでは規則を1つ適用した回数を「推論 1 回」と数える（推論速度の単位 LIPS の考え方）。
# 試してみよう：
#   - 事実を追加して、いとこや先祖を問い合わせる
#   - 最後の「1 秒に何回推論できたか」を、PIM/p の 1 億 5,600 万回と比較する

import time

# 大文字で始まる名前は「変数」、それ以外は「物の名前」
FACTS_AND_RULES = [
    (("親", "いちろう", "たろう"), []),
    (("親", "いちろう", "じろう"), []),
    (("親", "たろう", "はなこ"), []),
    (("親", "たろう", "さくら"), []),
    (("親", "じろう", "けんた"), []),
    (("祖父母", "X", "Z"), [("親", "X", "Y"), ("親", "Y", "Z")]),
    (("きょうだい", "X", "Y"), [("親", "P", "X"), ("親", "P", "Y"), ("ちがう", "X", "Y")]),
    (("いとこ", "X", "Y"), [("親", "P", "X"), ("親", "Q", "Y"), ("きょうだい", "P", "Q")]),
]
count = [0]

def is_var(t):
    return isinstance(t, str) and t[:1].isupper()

def walk(t, env):
    while is_var(t) and t in env:
        t = env[t]
    return t

def unify(a, b, env):
    a, b = walk(a, env), walk(b, env)
    if a == b:
        return env
    if is_var(a):
        return {**env, a: b}
    if is_var(b):
        return {**env, b: a}
    if isinstance(a, tuple) and isinstance(b, tuple) and len(a) == len(b):
        for x, y in zip(a, b):
            env = unify(x, y, env)
            if env is None:
                return None
        return env
    return None

def rename(t, n):
    if is_var(t):
        return f"{t}_{n}"
    if isinstance(t, tuple):
        return tuple(rename(x, n) for x in t)
    return t

def solve(goals, env, depth=0):
    if not goals:
        yield env
        return
    first, rest = goals[0], goals[1:]
    if first[0] == "ちがう":   # 組み込みの規則：2つが異なる値なら成り立つ
        if walk(first[1], env) != walk(first[2], env):
            yield from solve(rest, env, depth)
        return
    for head, body in FACTS_AND_RULES:
        count[0] += 1
        n = count[0]
        e = unify(first, rename(head, n), env)
        if e is not None:
            yield from solve([rename(g, n) for g in body] + rest, e, depth + 1)

def ask(query):
    answers = []
    for env in solve([query], {}):
        answers.append({v: walk(v, env) for v in query[1:] if is_var(v)})
    return answers

print("祖父母(いちろう, Z) ？ →", ask(("祖父母", "いちろう", "Z")))
print("きょうだい(はなこ, W) ？ →", ask(("きょうだい", "はなこ", "W")))
print("いとこ(はなこ, W) ？ →", ask(("いとこ", "はなこ", "W")))

count[0] = 0
start = time.perf_counter()
for _ in range(300):
    ask(("いとこ", "A", "B"))
sec = time.perf_counter() - start
lips = count[0] / sec
print(f"\nこのコンピュータでの小さな Prolog：1 秒に約 {lips:,.0f} 回の推論（{count[0]:,} 回を {sec:.2f} 秒）")
print(f"1992 年の PIM/p（512 台）：1 秒に 1 億 5,600 万回 → この小さな Prolog の約 {156_000_000 / lips:,.0f} 倍")
print("（この Prolog は Python 上で動く、わざと読みやすくした低速な作り。速さは実装の仕方で何十倍も変わる）")

05लॉजिक प्रोग्रामिंग · यूनिफिकेशन

रूपों को मिलाना: यूनिफिकेशन

प्रश्न और नियम का “मेल” होना क्या है?

Prolog किसी नियम का इस्तेमाल करने से पहले हमेशा यूनिफिकेशन करता है। वह प्रश्न और नियम के शीर्ष, यानी ← के बाईं ओर के हिस्से, का रूप शुरुआत से मिलाता है। फिर जाँचता है कि क्या चर, यानी ऐसे खाने जिनकी सामग्री अभी तय नहीं है, में मान भरकर दोनों का रूप एक जैसा बनाया जा सकता है। हनाको (Hanako) और तारो (Taro) के उदाहरण में, अभिभावक(X, हनाको) और अभिभावक(तारो, Y) में X की जगह तारो और Y की जगह हनाको रखें तो वे एक जैसे हो जाते हैं। जिरो (Jiro) के साथ अभिभावक(X, हनाको) और अभिभावक(तारो, जिरो) का मेल नहीं होता।

दाईं आकृति में “1 कदम” दबाने पर जिस हिस्से का मेल जाँचा जा रहा है, वह बैंगनी रंग में चमकता है। बिंदु(X, X) में पहले X में भरा गया मान बाद में होने वाले मिलान पर भी लागू होता है। X और f(X) जैसे मामले में चर को ऐसे रूप से बदलें जिसमें वही चर मौजूद हो, तो वह रूप अंतहीन हो जाता है। इसे रोकने के लिए ऑकरेंस चेक, यानी चर की मौजूदगी की जाँच की जाती है।

अंतिम मूल्यांकन (1993) के अनुसार, समानांतर तर्क मशीन PIM के प्रोसेसरों में चर में भरे मानों की कड़ियों को ढूँढ़ने, यानी डीरेफ़रेंस करने, के लिए विशेष निर्देश थे।

f(X, b) और f(a, Y) → X＝a, Y＝b

f: संरचना का नाम
X, Y: चर
a, b: स्थिर मानों के नाम
→: मेल कराने के लिए चरों में भरे जाने वाले मान

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

u07_unify.py

# u07 単一化：変数に値を代入して、2つの式を一致させる
#
# どの出来事か：1972年にマルセイユで生まれたProlog（記録 prolog_marseille_1972）は、問いと規則の頭部を
#   「単一化」で照合して推論を進める。第五世代の並列推論マシン PIM のプロセッサには、変数の参照を
#   たどる（デレファレンス）専用の命令もあった（記録 fgcs92_pim_kl1_1992、最終評価 1993）。
# 仕組み：左右の式を先頭から順に比較する。
#   - 同じもの同士 → そのまま次へ進む
#   - 片方が変数 → その変数にもう片方を代入する（代入した値は、後で参照する時にたどる）
#   - 異なるもの同士（名前や要素の数が違う）→ 一致しない（失敗）
#   - 変数を、その変数自身を含む式に代入しようとした → 一致しない（出現検査。式が無限に続いてしまうため）
# 試してみよう：
#   - PAIRS に自分で式を追加してみる。大文字で始まる名前が変数、( ) の中が引数
#   - 出現検査（OCCURS）を False にして、最後の例がどうなるか確認する（式が f(f(f(… と無限に続いて終わらなくなる）

OCCURS = True

def parse(s):
    """'親(X, はなこ)' → ('親', 'X', 'はなこ')。入れ子にも対応"""
    s = s.replace(" ", "")
    pos = 0

def term():
        nonlocal pos
        start = pos
        while pos < len(s) and s[pos] not in "(),":
            pos += 1
        name = s[start:pos]
        if pos < len(s) and s[pos] == "(":
            pos += 1
            args = [term()]
            while s[pos] == ",":
                pos += 1
                args.append(term())
            pos += 1
            return (name, *args)
        return name
    return term()

def show(t):
    return t if isinstance(t, str) else f"{t[0]}({', '.join(show(a) for a in t[1:])})"

is_var = lambda t: isinstance(t, str) and t[:1].isupper()

def walk(t, env):
    while is_var(t) and t in env:
        t = env[t]
    return t

def occurs(v, t, env):
    t = walk(t, env)
    if t == v:
        return True
    return isinstance(t, tuple) and any(occurs(v, a, env) for a in t[1:])

def unify(a, b, env, log, depth=0):
    a, b = walk(a, env), walk(b, env)
    pad = "    " * depth
    if a == b:
        log.append(f"{pad}{show(a)} と {show(b)}：同じ → 次へ進む")
        return env
    if is_var(a) or is_var(b):
        v, t = (a, b) if is_var(a) else (b, a)
        if OCCURS and occurs(v, t, env):
            log.append(f"{pad}{v} を {show(t)} に代入したいが、中に {v} 自身が含まれている → 失敗（出現検査）")
            return None
        log.append(f"{pad}{v} ← {show(t)}")
        return {**env, v: t}
    if isinstance(a, tuple) and isinstance(b, tuple):
        if a[0] != b[0] or len(a) != len(b):
            log.append(f"{pad}{show(a)} と {show(b)}：名前か引数の数が違う → 失敗")
            return None
        log.append(f"{pad}{a[0]}(…) 同士：中身を1つずつ照合する")
        for x, y in zip(a[1:], b[1:]):
            env = unify(x, y, env, log, depth + 1)
            if env is None:
                return None
        return env
    log.append(f"{pad}{show(a)} と {show(b)}：異なる値 → 失敗")
    return None

def resolve(t, env, depth=0):
    if depth > 6:
        return "…"                      # 出現検査をしないと、式が無限に続いてしまうことがある
    t = walk(t, env)
    return t if isinstance(t, str) else (t[0], *(resolve(a, env, depth + 1) for a in t[1:]))

PAIRS = [
    ("親(X, はなこ)", "親(たろう, Y)"),
    ("親(X, はなこ)", "親(たろう, じろう)"),
    ("点(X, X)", "点(3, Y)"),
    ("箱(赤, 中(Y, 青))", "箱(X, 中(黄, Z))"),
    ("列(A, 列(B, C))", "列(1, 列(2, 列(3, 空)))"),
    ("X", "f(X)"),
]
for left, right in PAIRS:
    log = []
    env = unify(parse(left), parse(right), {}, log)
    print(f"■ {left}  と  {right}")
    for line in log:
        print("   " + line)
    if env is None:
        print("   → 一致しない\n")
    else:
        print("   → 一致：" + "、".join(f"{v} = {show(resolve(v, env))}" for v in env) + f"   式全体は {show(resolve(parse(left), env))}\n")

061982〜1984 · दुनिया की प्रतिक्रिया

रिपोर्टों में “जापान”

क्या दुनिया ने जापान की योजना का मुकाबला करने के लिए कदम उठाए?

टोक्यो के सम्मेलन के बाद कई जगह बड़ी योजनाएँ शुरू हुईं। ब्रिटेन में मार्च 1982 में सूचना तकनीक के मंत्री ने एक समिति बनाई। उसी वर्ष उसकी रिपोर्ट ने सरकार, कंपनियों और विश्वविद्यालयों के संयुक्त शोध के लिए 5 साल और 35 करोड़ पाउंड की योजना सुझाई। अमेरिका में कंपनियों ने मिलकर संयुक्त अनुसंधान कंपनी MCC बनाई। रक्षा विभाग की अनुसंधान एजेंसी DARPA ने अक्टूबर 1983 में की योजना प्रकाशित की। यूरोपीय समुदाय ने 1983 में ESPRIT का प्रस्ताव रखा।

लेकिन इन दस्तावेज़ों में जापान का उल्लेख बिल्कुल अलग-अलग तरह से हुआ है। दाईं आकृति में रेखा की मोटाई दिखाती है कि किसी दस्तावेज़ में जापान पर कितना ज़ोर दिया गया है। ब्रिटेन की रिपोर्ट के मुख्य पाठ की शुरुआत में समिति बनने का कारण (अनुवाद) बताया गया है। यूरोपीय प्रस्ताव में केवल एक टिप्पणी में उदाहरण के रूप में 1 बार उल्लेख है। DARPA की योजना में न जापान और न पाँचवीं पीढ़ी का एक बार भी उल्लेख है।

“जापानी नज़रिया (1995)” चुनने पर 1995 के MITI Research Review का वर्णन दिखता है। वह कहता है कि ये सभी योजनाएँ पाँचवीं पीढ़ी से प्रेरित होकर बनीं।

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:दुनिया ने जापान का मुकाबला करने के लिए AI की योजनाएँ शुरू कीं
मूल स्रोत के अनुसार:ब्रिटेन की रिपोर्ट साफ़ कहती है कि इसकी वजह जापान की घोषणा थी। लेकिन अमेरिकी रक्षा विभाग की अनुसंधान एजेंसी की योजना (1983) में न जापान और न पाँचवीं पीढ़ी का एक बार भी उल्लेख है। इतिहास की पुस्तक के अनुसार, कांग्रेस को मनाने वाले माहौल में इसका बड़ा प्रभाव था। यूरोपीय प्रस्ताव (1983) में भी एक टिप्पणी में उदाहरण के रूप में केवल 1 बार उल्लेख हुआ था।

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

पुस्तक और भविष्यवाणी की घड़ी

जापान की योजना को बड़ा ख़तरा बनाकर किसने पेश किया?

1983 में स्टैनफ़र्ड विश्वविद्यालय में कंप्यूटर विज्ञान के प्रोफ़ेसर फ़ाइगेनबाउम (Feigenbaum) और AI के इतिहास पर भी पुस्तक लिख चुकी लेखिका मैककॉर्डक (McCorduck) ने जापान की योजना का परिचय देने वाली पुस्तक प्रकाशित की। पुस्तक का एक हिस्सा छापने वाले पत्रिका लेख में दोनों ने लिखा कि यदि पाँचवीं पीढ़ी का कोई हिस्सा भी सफल हुआ, तो जापान दुनिया के सूचना उद्योग में बहुत आगे निकल जाएगा और अमेरिका के पास इसका मुकाबला करने के लिए कोई राष्ट्रीय योजना नहीं है। उन्होंने यह भी कहा कि बहुत-से अमेरिकी संदेह करते हैं, लेकिन इस देश के दाँव के सफल होने की संभावना लोगों के अनुमान से अधिक है। इतिहास की पुस्तक में निल्सन (Nilsson, 2010) लिखते हैं कि इस पुस्तक ने शोध बजट पर विचार करने वाली कांग्रेस में संकट की भावना बढ़ाई।

दोनों ने अमेरिकी लोगों को यह समझाने के लिए लिखा था कि (अनुवाद)। दाईं ओर भविष्यवाणी की घड़ी में “अभी का वर्ष” बदलें। 1981 की पुस्तिका, इस पुस्तक और निदेशक के 1992 के अनुमान के लिए नतीजा सामने आने का वर्ष बारी-बारी से आता है, और उसके बाद की स्थिति दिखती है।

अमेरिकी कंपनियों के समूह MCC के बारे में निल्सन लिखते हैं कि जब उसके पहले अध्यक्ष 1987 में पद से हटे, तब तक पाँचवीं पीढ़ी को उतना बड़ा ख़तरा नहीं माना जा रहा था।

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:पाँचवीं पीढ़ी का ख़तरा जापान ने ख़ुद बढ़ा-चढ़ाकर प्रचारित किया
मूल स्रोत के अनुसार:जापान की योजना को बड़े ख़तरे के रूप में पेश करके फैलाने वालों में अमेरिका के AI शोधकर्ता भी शामिल थे। यह पुस्तक अमेरिका के पास राष्ट्रीय योजना न होने का सवाल उठाने के लिए लिखी गई थी।

081982〜1995 · धन

54.1 अरब येन या 56.9 अरब येन?

पाँचवीं पीढ़ी के कंप्यूटरों पर सरकार ने कितना खर्च किया?

MITI Research Review (1995) में छपी तालिका का स्रोत अंतरराष्ट्रीय व्यापार और उद्योग मंत्रालय के दस्तावेज़ थे। इसके अनुसार, सरकार ने वित्त वर्ष 1982〜1992 के 11 वर्षों में लगभग 54.1 अरब येन खर्च किए: शुरुआती चरण में 8.3 अरब, मध्य चरण में 21.6 अरब और अंतिम चरण में 24.2 अरब येन। इसके बाद वित्त वर्ष 1993〜1994 की 2 साल की अगली योजना को लगभग 2.8 अरब येन मिले। कुल राशि लगभग 56.9 अरब येन हुई। वित्त वर्ष 1986 से सामान्य खाते, यानी नियमित बजट, के अलावा अलग विशेष खाते से भी धन दिया गया।

दाईं ओर स्तंभ ग्राफ़ में “किस वर्ष तक जोड़ें” बदलें। वित्त वर्ष 1992 पर रुकें तो 54.1 अरब येन, और वित्त वर्ष 1994 तक जोड़ें तो 56.9 अरब येन होते हैं। अक्सर दिखाई देने वाले “लगभग 54 अरब येन” (1993 का अंतिम मूल्यांकन) और “57 अरब येन” (जैसे 2017 में जापानी संसद में दिया गया बयान) के बीच अंतर जोड़ने की अवधि का अंतर है। बटन दबाकर विदेशों के अनुमान भी देखे जा सकते हैं।

कुल ＝Σ（सामान्य खाता ＋ विशेष खाता）

Σ: हर वित्त वर्ष की राशि जोड़ना
वित्त वर्ष: अप्रैल से अगले वर्ष के मार्च तक

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:विदेशों में माना जाता था कि जापान ने पाँचवीं पीढ़ी में बहुत बड़ी राशि लगाई और असली रकम छिपाई
मूल स्रोत के अनुसार:ब्रिटेन की 1982 की रिपोर्ट में (अनुवाद) जैसी राय लिखी गई थी। लेकिन 1993 के अंतिम मूल्यांकन ने (अनुवाद, येन) बताया और 1995 की रिपोर्ट में हर वित्त वर्ष की राशि की तालिका थी। विदेशों में अनुमान 45 करोड़, 50 करोड़ और 85 करोड़ डॉलर थे। सबसे बड़ी संख्या योजना समाप्त होने के बाद लिखे गए विश्वकोश की थी।

091982〜1991 · जापान का उछाल

विदेश से लौटकर आया AI का उछाल

जापान में AI का दूसरा उछाल कहाँ से आया?

(अनुवाद), जिसकी निगरानी अंतरराष्ट्रीय व्यापार और उद्योग मंत्रालय के एक विभाग ने की थी, लिखता है कि (अनुवाद)। उसने जापान के उछाल को पाँचवीं पीढ़ी और उस पर विदेशों की प्रतिक्रिया से जोड़ते हुए लिखा: (अनुवाद)। वह यह भी कहता है कि ऐसा लगता है जैसे कंपनियों के शीर्ष अधिकारियों ने (अनुवाद) जैसी मिथकीय सोच से ऊपर से AI के विकास का आदेश दिया। 1985 में जापानी संसद में भी AI के बारे में (अनुवाद) कहा गया था।

तो यह शब्द कब से इस्तेमाल हो रहा था? जापान की राष्ट्रीय संसद लाइब्रेरी की पूरे पाठ में खोज करने की सुविधा से डिजिटाइज़ की गई पुस्तकों और पत्रिकाओं को सबसे पुरानी से क्रम में रखें, तो AI के अर्थ में सबसे पुराना उदाहरण अक्टूबर 1982 की एक पत्रिका में मिला। में लिखा है: (अनुवाद)। दाईं आकृति में खोजें, तो 1978 और 1981 के नतीजे पहले आते हैं। वे एक पुस्तक के लेखक ए.आई. ब्लूमफ़ील्ड (A.I. Bloomfield) के नाम और मानज़ाइ, यानी जापानी हास्य संवाद, के MANZAI उछाल से मशीन द्वारा पढ़े गए अक्षर हैं। अक्षरों का क्रम एक जैसा हो, तब भी शब्द का अर्थ एक जैसा होना ज़रूरी नहीं है।

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:जापान में AI का दूसरा उछाल इसलिए आया क्योंकि जापान की अपनी पाँचवीं पीढ़ी की योजना ने देश में उत्साह पैदा किया
मूल स्रोत के अनुसार:अंतरराष्ट्रीय व्यापार और उद्योग मंत्रालय के एक विभाग की निगरानी में बने 1991 के श्वेतपत्र ने जापान के उछाल को पाँचवीं पीढ़ी से जोड़कर लिखा: (अनुवाद)।

101984〜1988 · निदेशक के शब्द

से उलटी प्रतिक्रिया

योजना चलने के दौरान निदेशक ख़ुद क्या कह रहे थे?

निदेशक काज़ुहिरो फ़ुची (Kazuhiro Fuchi) ने बड़े सपनों की बात सीमित रखने के लिए कई बार कहा। अप्रैल 1984 में एक अमेरिकी पत्रिका को दिए इंटरव्यू में उन्होंने बताया कि वे लंबे समय से AI को लेकर संदेह करते आए थे। उन्होंने कहा कि पहले 10 वर्षों में व्यावहारिक उपयोग की उम्मीद करना यथार्थवादी नहीं था। उसी वर्ष नवंबर के मुख्य भाषण में भी उन्होंने कहा कि उनका ढाँचा एक (अनुवाद) है और इस योजना का काम उसे जाँचना है। उन्होंने कहा कि वे सीधे (अनुवाद) से जुड़े नहीं हैं।

1988 के भाषण में उन्होंने इस योजना के बारे में कहा: (अनुवाद)। राष्ट्रीय शोध योजनाओं के सामने आने वाले प्रलोभनों में से एक उन्होंने (अनुवाद) को बताया। उन्होंने चेताया कि इतिहास में ऐसे उदाहरण हैं जहाँ लक्ष्य बहुत ऊँचे होने से, या उन्हें बहुत ऊँचा समझ लिए जाने से, उलटी प्रतिक्रिया पैदा हुई।

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

वादे वाले वर्ष की उम्मीद ＝ क्षमता −（लक्ष्य × गुणक का वह हिस्सा जो क्षमता से अधिक है）। उम्मीद की न्यूनतम सीमा 0 है।

क्षमता: समय सीमा तक प्राप्त परिणाम
लक्ष्य × गुणक: दुनिया तक पहुँचा वादा

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:पाँचवीं पीढ़ी असफल हुई क्योंकि सरकार ने बोलने और सोचने वाले कंप्यूटर का सपना बहुत बढ़ा-चढ़ाकर बताया
मूल स्रोत के अनुसार:योजना के दौरान निदेशक के अपने बहुत-से शब्द ज़रूरत से ज़्यादा उम्मीदों को सीमित रखने के लिए थे। लेकिन दूसरे स्रोतों में दर्ज है कि उसी समय आसपास बढ़ा-चढ़ाकर बनी छवि फैल रही थी (इस अध्याय के 02 और 07)।

111985〜1992 · समानांतर प्रसंस्करण

काम बाँटना और जोड़ने की मेहनत

512 कंप्यूटर हों, तो क्या काम 512 गुना तेज़ होता है?

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

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

अंतिम मूल्यांकन (1993) में लिखा है कि लॉजिक सिमुलेशन में 256 कंप्यूटरों पर गति 166 गुना हुई और कुछ समस्याओं में 512 कंप्यूटरों पर लगभग 500 गुना हुई। काम बाँटने के तरीके, यानी लोड बैलेंसिंग, को सॉफ़्टवेयर घटकों के रूप में तैयार करके वितरित किया गया। निल्सन (Nilsson, 2010) लिखते हैं कि इसके अनुकूल विशेष समस्याओं के अलावा समानांतर प्रसंस्करण का पूरा लाभ लेना कठिन था।

S(P)＝T(1) ÷ T(P)

P: कंप्यूटरों की संख्या
T(P): P कंप्यूटरों पर सारा काम पूरा होने का समय, काम सौंपने के समय सहित
S(P): गति का गुणक

कंप्यूटरों की संख्या और गति का गुणक (दोनों की मापनी हर चरण पर 2 गुनी)

121985〜1992 · GHC और KL1

डेटा आने तक इंतज़ार

जब कई कंप्यूटर एक ही डेटा इस्तेमाल करें, तो काम का क्रम कैसे बना रहता है?

Prolog को कई कंप्यूटरों पर एक साथ चलाना कठिन था (निल्सन (Nilsson, 2010) के अनुसार)। काज़ुहिरो फ़ुची (Kazuhiro Fuchi) के 1992 के भाषण के अनुसार, मध्य चरण की शुरुआत में शोधकर्ता काज़ुनोरी उएदा (Kazunori Ueda) ने GHC (Guarded Horn Clauses) प्रस्तावित किया। इस पर आधारित KL1 को अनुभाग प्रमुख ताकाशी चिकायामा (Takashi Chikayama) ने डिज़ाइन किया और अंतिम चरण का सारा शोध KL1 पर एकीकृत किया गया।

GHC के नियमों में पहरा, यानी गार्ड होता है। अगर किसी ऐसे चर को पढ़ना ज़रूरी हो जिसका मान अभी नहीं आया है, तो काम वहीं सो जाता है, यानी रुककर इंतज़ार करता है, और मान आने पर जागता है। गार्ड पार करने वाले नियम को चुन लेने के बाद वापस जाकर दूसरा नियम नहीं आज़माया जाता। दाईं आकृति में कंप्यूटर 1 संख्याएँ भेजता है और कंप्यूटर 2 उन्हें जोड़ता है। अगली संख्या न आने पर कंप्यूटर 2 सो जाता है। “बनाने वाला हटाएँ” चुनें, तो सारे काम सोए रहकर रुक जाते हैं। इसे डेडलॉक कहते हैं।

अंतिम मूल्यांकन (1993) के अनुसार, KL1 में लिखे ऑपरेटिंग सिस्टम PIMOS के पहले संस्करण में लगभग 44,000 पंक्तियाँ थीं और डिबगर अपने आप डेडलॉक खोज सकता था। आकृति इस विचार का छोटा उदाहरण है।

शीर्ष :- गार्ड | मुख्य भाग

गार्ड: नियम चुनने की शर्त; मान न हो तो इंतज़ार
मुख्य भाग: चुनने के बाद किया जाने वाला काम

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

u07_ghc_stream.py

# u07 KL1 と GHC の並行処理：データが来るまで待ち、来たら 1 つに決めて進む
#
# どの出来事か：Prolog を多数のコンピュータで並列に動かすのは難しく、第五世代コンピュータ計画では GHC（Guarded Horn Clauses）
#   という論理プログラミング言語が作られた（Nilsson 2010）。所長の渕一博の 1992 年の講演によると、中期の初めに
#   上田和紀が GHC を提案し、それをもとに近山隆が KL1 を設計した。1993 年の最終評価報告書では、互いに通信し合うプロセスを
#   論理言語で記述する手法が、OS の PIMOS をはじめ、ほとんどの KL1 ソフトウェアで使われたと書かれている（記録 fgcs92_pim_kl1_1992）。
# 仕組み（GHC の考え方を簡略化したモデル。KL1 そのものではない）：
#   - 仕事（ゴール）は、規則の「見張り」（ガード）の条件が確かめられるまで待つ。値がまだ無い変数を見ようとすると、値が入るまで眠る（止まって待つ）
#   - 見張りが通った規則が 1 つ見つかったら、それに決めて進む（コミット。Prolog のようにバックトラックしてやり直すことはしない）
#   - 2 つの仕事が、同じ変数を通して、リスト（数の列）を少しずつ渡し合う。これが「流れ（ストリーム）」
# 試してみよう：
#   - MAX と WORK を変えてみる。WORK を 1 にすると、消費側の待機時間が短くなる
#   - PRODUCER を False にすると、だれもリストを作らないため、全部の仕事が眠ったまま止まる（デッドロック）

MAX = 5
WORK = 2          # 生成側が 1 つの数値を生成するのにかかる時間ステップ（遅いと消費側が待機する）
PRODUCER = True

class Var:
    n = 0

def __init__(self):
        Var.n += 1
        self.name, self.value, self.bound = f"S{Var.n}", None, False
        self.sleepers = []

def set(self, v, wake):
        self.value, self.bound = v, True
        wake.extend(self.sleepers)
        self.sleepers.clear()

def show(x):
    out = []
    while isinstance(x, Var) and x.bound:
        x = x.value
        if x == "nil":
            return "[" + ", ".join(out) + "]"
        head, x = x
        out.append(str(head))
    tail = x.name if isinstance(x, Var) else str(x)
    return "[" + ", ".join(out) + (" | " if out else "") + tail + "]"

# 仕事の形：(名前, 引数…)
def reduce(goal, wake):
    """1 回の書き換え（簡約）。('ok', 新しい仕事, メッセージ) か ('wait', 変数, メッセージ) を返す"""
    name = goal[0]
    if name == "gen":                         # gen(N, S)：N から MAX までの数値を S に順次出力する
        _, n, s, k = goal
        if k + 1 < WORK:
            return "ok", [("gen", n, s, k + 1)], f"gen({n}) 計算中"
        if n > MAX:
            s.set("nil", wake)
            return "ok", [], f"gen({n}) → {s.name} = []（終了）"
        s2 = Var()
        s.set((n, s2), wake)
        return "ok", [("gen", n + 1, s2, 0)], f"gen({n}) → {s.name} = [{n} | {s2.name}]"
    if name == "sum":                         # sum(S, Acc, R)：S から受け取った数値を累積加算する
        _, s, acc, r = goal
        if not s.bound:                        # 見張り：S の形が分からないうちは、決めて進めない
            return "wait", s, f"sum → {s.name} の値がまだ無いので眠る"
        if s.value == "nil":
            r["答え"] = acc
            return "ok", [], f"sum → {s.name} = [] なので 答え = {acc}"
        x, s2 = s.value
        return "ok", [("sum", s2, acc + x, r)], f"sum → {x} を受信、合計 {acc + x}"

s0, result = Var(), {}
queues = {"台1": [("gen", 1, s0, 0)] if PRODUCER else [], "台2": [("sum", s0, 0, result)]}
home = {"gen": "台1", "sum": "台2"}
sleeping = []
t = 0
while any(queues.values()) and t < 40:
    t += 1
    wake, line = [], []
    for cpu, q in queues.items():
        if not q:
            line.append(f"{cpu}：（手が空いている）")
            continue
        goal = q.pop(0)
        kind, x, msg = reduce(goal, wake)
        if kind == "ok":
            q.extend(x)
        else:
            x.sleepers.append(goal)
            sleeping.append(goal)
        line.append(f"{cpu}：{msg}")
    for g in wake:                            # 値が入った変数を待っていた仕事を起こす
        sleeping.remove(g)
        queues[home[g[0]]].append(g)
        line.append(f"（{g[0]} が起きる）")
    print(f"時刻 {t:2}  " + "   ".join(line))

print(f"\n流れたリスト：{show(s0)}")
if "答え" in result:
    print(f"答え：{result['答え']}（2 台が、同じリストの生成側と消費側に分かれて同時に動いた）")
else:
    print(f"全部の仕事が眠ったまま：デッドロック（眠っている仕事 {len(sleeping)} 個）。PIMOS のデバッガは、このような止まり方を自動で検出できた（最終評価 1993）")

131982〜1992 · PIM

हर सेकंड 15.6 करोड़ बार तर्क

तर्क निकालने की गति कैसे मापी गई और यह कहाँ तक पहुँची?

पाँचवीं पीढ़ी ने तर्क निकालने की गति को LIPS, यानी प्रति सेकंड निकाले गए तर्कों की संख्या, में मापा। निल्सन (Nilsson, 2010) के अनुसार, 1980 के दशक की शुरुआत के कंप्यूटर हर सेकंड लगभग 1 लाख बार तर्क निकालते थे। जापान इसे 1,000 गुने से भी अधिक बढ़ाना चाहता था। लक्ष्य था हर सेकंड 10 करोड़ बार तर्क निकालना।

शुरुआती चरण में Prolog का विस्तार करने वाली ESP भाषा और अपने आप तर्क निकालने वाली PSI मशीन विकसित हुईं। सुधारे गए संस्करणों सहित लगभग 500 मशीनें शोध में इस्तेमाल हुईं। मध्य चरण के अंत में 64 मशीनों वाला Multi-PSI और अंतिम चरण में समानांतर तर्क मशीन PIM विकसित हुई। अंतिम मूल्यांकन (1993) के अनुसार, 512 मशीनों वाले PIM/p की अधिकतम गति प्रति सेकंड 15.6 करोड़ और 256 मशीनों वाले PIM/m की 15.3 करोड़ थी। यह सामान्य उपयोग वाले बड़े कंप्यूटरों से लगभग 100 गुना तेज़ थी।

दाईं आकृति इस स्क्रीन के JavaScript से सूची का क्रम उलटने की एक छोटी समस्या हल कराकर गति मापती है। 30 वस्तुओं के लिए 496 बार तर्क निकाला जाता है। PIM का एक घटक प्रोसेसर हर सेकंड 3〜6 लाख बार तर्क निकालता था। दाईं ओर के स्लाइडर से कंप्यूटरों की संख्या के अनुसार जोड़कर बनाए गए गणना के उदाहरण की तुलना PIM/p के वास्तविक परिणाम से की जा सकती है।

LIPS＝ तर्कों की संख्या ÷ सेकंड

1 बार तर्क निकालना: किसी नियम को 1 बार इस्तेमाल करना; इस साइट में गिनने का तरीका

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:पाँचवीं पीढ़ी ने 1,000 कंप्यूटरों को जोड़कर तर्क मशीन बनाई
मूल स्रोत के अनुसार:एक मशीन के रूप में सबसे बड़ा PIM/p था, जिसमें 512 कंप्यूटर थे। अंतिम मूल्यांकन कहता है कि सभी 5 प्रकारों (512, 256, 256, 16, 16 कंप्यूटर) को जोड़ें, तो संख्या 1,000 से अधिक होती है।

PIM के 5 प्रकारों में कंप्यूटरों की संख्या

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

u07_lips_meter.py

# u07 推論速度 LIPS を測る：1 秒に何回、推論（規則の適用）ができるか
#
# どの出来事か：第五世代コンピュータプロジェクトは、推論速度を LIPS（1 秒あたりの推論回数）で測った。
#   1980 年代初めのコンピュータは 1 秒に約 10 万回で、これを 1,000 倍以上にしようとした（Nilsson 2010）。
#   目標は 1 秒に 1 億回。1992 年の並列推論マシン PIM/p（512 台）は 1 秒に 1 億 5,600 万回、PIM/m（256 台）は
#   1 億 5,300 万回を達成した（ピーク性能）。要素プロセッサ 1 台は 1 秒に 30〜60 万回の性能を持つ
#   （最終評価 1993。記録 fgcs92_pim_kl1_1992）。
# 仕組み：リストを逆順にする小さな問題（nrev）を、小さな Prolog で解かせる。長さ 30 のリストを逆順にすると、
#   規則を適用する回数（推論回数）はちょうど 496 回になる。これを繰り返し解き、かかった時間で割る。
#   ここでは「問いと決まりの頭が合って、その決まりを使った回数」を推論 1 回と数える。
# 試してみよう：
#   - N（リストの長さ）を変えて、推論回数が (N+1)(N+2)/2 になるか確かめる
#   - 最後の表で、このコンピュータの速度と、1980 年代の約 10 万回や PIM/p を比べる

import math
import time

N = 30

class V:                                     # 変数（まだ値の無い箱）
    __slots__ = ("ref",)

def __init__(self):
        self.ref = None

def deref(t):
    while isinstance(t, V) and t.ref is not None:
        t = t.ref
    return t

trail = []

def unify(a, b):
    a, b = deref(a), deref(b)
    if a is b:
        return True
    if isinstance(a, V):
        a.ref = b; trail.append(a); return True
    if isinstance(b, V):
        b.ref = a; trail.append(b); return True
    if isinstance(a, tuple) and isinstance(b, tuple) and len(a) == len(b) and a[0] == b[0]:
        return all(unify(x, y) for x, y in zip(a[1:], b[1:]))
    return a == b

def undo(mark):
    while len(trail) > mark:
        trail.pop().ref = None

cons = lambda h, t: (".", h, t)

def app_1():                                  # app([], L, L).
    L = V(); return ("app", "[]", L, L), []

def app_2():                                  # app([H|T], L, [H|R]) :- app(T, L, R).
    H, T, L, R = V(), V(), V(), V(); return ("app", cons(H, T), L, cons(H, R)), [("app", T, L, R)]

def nrev_1():                                 # nrev([], []).
    return ("nrev", "[]", "[]"), []

def nrev_2():                                 # nrev([H|T], R) :- nrev(T, RT), app(RT, [H], R).
    H, T, R, RT = V(), V(), V(), V(); return ("nrev", cons(H, T), R), [("nrev", T, RT), ("app", RT, cons(H, "[]"), R)]

DB = {"app": [app_1, app_2], "nrev": [nrev_1, nrev_2]}
count = 0

def solve(goals):
    global count
    if not goals:
        yield True
        return
    g, rest = goals[0], goals[1:]
    for make in DB[g[0]]:
        head, body = make()
        mark = len(trail)
        if unify(head, g):
            count += 1
            yield from solve(body + rest)
        undo(mark)

def to_list(xs):
    t = "[]"
    for x in reversed(xs):
        t = cons(x, t)
    return t

def from_list(t):
    out = []
    t = deref(t)
    while t != "[]":
        out.append(deref(t[1])); t = deref(t[2])
    return out

R = V()
count = 0
next(solve([("nrev", to_list(list(range(1, N + 1))), R)]))
print(f"nrev（{N} 個）の答え：{from_list(R)[:8]} …")
print(f"推論回数：{count}（(N+1)(N+2)/2 = {(N + 1) * (N + 2) // 2}）")
undo(0)

count, runs, start = 0, 0, time.perf_counter()
while time.perf_counter() - start < 0.8:
    R = V()
    next(solve([("nrev", to_list(list(range(N))), R)]))
    undo(0)
    runs += 1
sec = time.perf_counter() - start
lips = count / sec
print(f"{runs} 回解いて {count:,} 回の推論を {sec:.2f} 秒 → このコンピュータ上の小さな Prolog：1 秒に約 {lips:,.0f} 回\n")

rows = [
    ("この Python の小さな Prolog（測定値）", lips),
    ("1980 年代初めのコンピュータ（Nilsson）", 1e5),
    ("PIM の要素プロセッサ 1 台（30〜60 万回の下限）", 3e5),
    ("第五世代の目標", 1e8),
    ("PIM/m（256 台）", 153e6),
    ("PIM/p（512 台）", 156e6),
]
for name, v in rows:
    print(f"{name:34} {v:15,.0f}  " + "■" * max(1, round(math.log10(v) * 3)))
print("（■ は 10 倍ごとに 3 つ。ピーク性能は、実際の問題で出る速度とは異なる）")
print(f"\n1 台 30 万回 × 512 台 = {3e5 * 512:,.0f} 回。PIM/p の 1 億 5,600 万回は、プロセッサ台数にほぼ比例して高速化した計算になる")

141992 · प्रमेय सिद्ध करना

अनसुलझी समस्या का एक हिस्सा मशीन ने सिद्ध किया

कंप्यूटर कैसे सिद्ध करता है कि “ऐसी कोई चीज़ नहीं है”?

अंतिम मूल्यांकन (1993) के अनुसार, PIM पर चलने वाले प्रमेय सिद्ध करने के प्रोग्राम MGTP ने कनाडा के गणितज्ञ बेनेट (Bennett) द्वारा दी गई क्वासिग्रुप की अनसुलझी समस्या का एक हिस्सा अपने आप सिद्ध किया। 256 कंप्यूटरों पर इसकी गति 200 गुने से अधिक हुई। अलग-अलग मामलों में बाँटने से संभावित संयोजनों की संख्या में होने वाली भारी बढ़ोतरी को रोकने के तरीके भी जोड़े गए। काज़ुहिरो फ़ुची (Kazuhiro Fuchi) ने 1992 में बताया कि यह प्रमाणक क़ानूनी तर्क निकालने वाली एक प्रणाली के तर्क इंजन के रूप में भी इस्तेमाल होता है।

क्वासिग्रुप की गुणन तालिका में हर पंक्ति और हर स्तंभ में प्रत्येक चिह्न ठीक 1 बार आता है। ऐसी तालिका को लैटिन वर्ग कहते हैं। दाईं आकृति में एक-एक खाना भरकर तालिका खोजी जाती है और रास्ता बंद होने पर पीछे लौटा जाता है। यदि हर संभावित मामले में रास्ता बंद हो जाए, तो यह प्रमाण है कि ऐसी तालिका मौजूद नहीं है। x*x＝x और x*y＝y*x को पूरा करने वाली तालिकाएँ 3 और 5 के आकार में मिलती हैं, लेकिन 4 और 6 के आकार में नहीं होतीं। ये शर्तें इस साइट ने उदाहरण के लिए चुनी हैं।

x*x＝x, x*y＝y*x

x*y: पंक्ति x और स्तंभ y के खाने में लिखा चिह्न
आगे की जाँच: ऐसा खाना जल्दी पहचान लेना जिसमें कोई चिह्न नहीं रखा जा सकता, और खोज रोक देना

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

u07_latin_square.py

# u07 機械が証明する：場合分けをすべてたどって、「そんな表は無い」まで確かめる
#
# どの出来事か：PIM の上で動いた定理証明プログラム MGTP は、カナダの数学者 Bennett が提示した
#   「準群」の未解決問題の一部を自動で証明した。場合分けで起きる組み合わせ爆発を抑える工夫も施された
#   （最終評価 1993。記録 fgcs_final_evaluation_1993、fgcs92_pim_kl1_1992）。
# 仕組み：準群の掛け算の表は、どの行にもどの列にも同じ記号が 1 回ずつ現れる表（ラテン方陣）。
#   条件を満たす表を、マスを 1 つずつ埋めながら探索する。行き詰まったら 1 つ戻って別の記号を試す（バックトラック法）。
#   すべての場合分けで行き詰まれば「条件を満たす表は無い」ことの証明になる。
#   「先読み」を行うと、マスを埋めた時点で、残りの空きマスに入る記号がなくなった枝を早く切り捨てられる。
#   ここで試す条件（どの x も x*x = x、x*y = y*x）は、このサイトが選んだ例。Bennett の問題そのものではない。
# 試してみよう：
#   - n を 3〜7 で変えて、表がある大きさとない大きさを確認する
#   - 調べたマスの数（場合分けの数）を、先読みあり・なしで比べる。表がない大きさ（4・6）で差が出る

import time

PRUNE = True

def search(n, idem, comm, prune):
    T = [[None] * n for _ in range(n)]
    nodes = 0
    cells = [(r, c) for r in range(n) for c in range(n) if not (idem and r == c) and not (comm and c < r)]
    if idem:
        for i in range(n):
            T[i][i] = i

def ok(r, c, v):
        return all(T[r][k] != v for k in range(n)) and all(T[k][c] != v for k in range(n))

def alive():                                 # 先読み：空いているマスに、まだ入れられる記号があるか調べる
        for r in range(n):
            for c in range(n):
                if T[r][c] is None and not any(ok(r, c, v) for v in range(n)):
                    return False
        return True

def put(i):
        nonlocal nodes
        if i == len(cells):
            return True
        r, c = cells[i]
        for v in range(n):
            if ok(r, c, v) and (not comm or r == c or ok(c, r, v)):
                nodes += 1
                T[r][c] = v
                if comm:
                    T[c][r] = v
                if (not prune or alive()) and put(i + 1):
                    return True
                T[r][c] = None
                if comm:
                    T[c][r] = None
        return False

found = put(0)
    return found, T, nodes

for n in range(3, 8):
    t0 = time.perf_counter()
    found, T, nodes = search(n, idem=True, comm=True, prune=PRUNE)
    sec = time.perf_counter() - t0
    other = search(n, idem=True, comm=True, prune=not PRUNE)[2]
    print(f"n = {n}：x*x = x と x*y = y*x を満たす表は {'ある' if found else 'ない（すべての場合分けで行き詰まった）'}")
    print(f"      調べたマス：先読み{'あり' if PRUNE else 'なし'} {nodes:,}（{sec:.3f} 秒）／ 先読み{'なし' if PRUNE else 'あり'} {other:,}")
    if found and n <= 5:
        for row in T:
            print("      " + " ".join("abcdefg"[v] for v in row))
print("\n先読み（PRUNE）を無効にすると、同じ結果でも調べる場合分けが増える。表があるときは1つ示せば済むが、ないときはすべて調べる必要がある")

151986〜1995 · इलेक्ट्रॉनिक शब्दकोश

अर्थ का शब्दकोश, इंसानों के हाथों

कंप्यूटर को शब्दों का अर्थ समझने देने के लिए क्या चाहिए?

अप्रैल 1986 में “जापान इलेक्ट्रॉनिक शब्दकोश अनुसंधान संस्थान (EDR)” (अनुवाद) की 9 साल की योजना शुरू हुई। इसका काम एक बड़ा “इलेक्ट्रॉनिक शब्दकोश” (अनुवाद) बनाना था, जो कंप्यूटरों को रोज़मर्रा की भाषा के साथ काम करने का आधार दे। इसमें शब्दों को अर्थों, यानी अवधारणाओं, से जोड़ने वाला “शब्दों का शब्दकोश” (अनुवाद), अवधारणाओं के ऊपर और नीचे के संबंध दिखाने वाला “अवधारणाओं का शब्दकोश” (अनुवाद), शब्दों के आपसी संबंध का “साथ आने वाले शब्दों का शब्दकोश” (अनुवाद), जापानी और अंग्रेज़ी का “द्विभाषी शब्दकोश” (अनुवाद) आदि हैं।

दाईं आकृति इसी विचार पर आधारित एक छोटा शब्दकोश है। जापानी शब्द “अत्सुई” का अर्थ मोटा, छूने पर गरम या गरम मौसम हो सकता है। यह साथ आने वाले शब्दों के जोड़े से अर्थ चुनता है। जोड़ा न मिले, तो अवधारणाओं में ऊपर जाकर, जैसे कॉफ़ी → पेय, वहाँ जोड़ा मिलने पर भी अर्थ चुना जा सकता है।

वर्तमान जानकारी वाले पृष्ठ के अनुसार, इसमें लगभग 2.7 लाख जापानी शब्द, 4.1 लाख अवधारणाएँ और 9 लाख साथ आने वाले शब्दसमूह हैं। अंतिम मूल्यांकन ने भी लिखा कि भाषा से बाहर का ज्ञान जुटाने में अकेले ICOT की सीमाएँ हैं, और उसने EDR तथा अमेरिका के MCC की CYC परियोजना से उम्मीद जताई।

अंक ＝ सीधे साथ आने वाला जोड़ा मिले तो 2; सीधा जोड़ा न मिले, लेकिन ऊपर की अवधारणा में मिले तो 1; दोनों में न मिले तो 0

साथ आना: एक साथ आने वाले शब्दों का जोड़ा
अंक तय करने का तरीका: इस साइट की अपनी अंक प्रणाली

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

u07_cooccurrence.py

# u07 電子化辞書で言葉の意味を判別する：単語 → 概念、概念の上位・下位、共起
#
# どの出来事か：1986〜1995年、日本電子化辞書研究所（EDR）は、コンピュータが日本語と英語の意味を扱うための
#   大規模な辞書を手作業で作成した。単語と概念（意味）を結ぶ単語辞書、概念どうしの上位・下位関係を記述する概念辞書、
#   共起（いっしょに使われる言葉の組み合わせ）を記録した共起辞書などからなる（記録 edr_electronic_dictionary_1986）。
#   現在の案内ページでは、日本語単語約27万語、概念約41万、日本語共起約90万句。
# 仕組み（EDRの辞書の仕組みを参考にした、このサイト独自の小さな例）：
#   ① 単語辞書で、読みから意味の候補（概念）を引く：「あつい」→ 厚い・熱い・暑い
#   ② 共起辞書に、候補といっしょに使われる組み合わせがあれば加点する
#   ③ 組み合わせがなくても、概念辞書で上位概念（例：コーヒー → 飲み物）にさかのぼって一致すれば少し加点する
#   もっとも得点の高い候補を、その文での意味として選ぶ。
# 試してみよう：
#   - SENTENCES に「あつい スープ」「あつい ふろ」を足す。辞書に何を足せば正しく判別できるか
#   - UPPER（上位概念）の行を消すと、③が使えずに判別できない文が出る

WORDS = {  # 読み → 意味の候補（概念）
    "あつい": ["厚い", "熱い", "暑い"],
    "ほん": ["本"], "おちゃ": ["お茶"], "コーヒー": ["コーヒー"], "きょう": ["今日"], "なつ": ["夏"],
    "じしょ": ["辞書"], "へや": ["部屋"], "スープ": ["スープ"],
}
UPPER = {  # 概念 → 上位概念（概念の上位・下位関係）
    "本": "平たい物", "辞書": "本", "お茶": "飲み物", "コーヒー": "飲み物", "スープ": "食べ物",
    "今日": "時", "夏": "時", "部屋": "場所", "平たい物": "物", "飲み物": "物", "食べ物": "物",
}
COOC = {  # 共起：いっしょに使われる意味の組み合わせ
    ("厚い", "本"), ("厚い", "平たい物"), ("熱い", "お茶"), ("熱い", "飲み物"), ("暑い", "夏"), ("暑い", "時"),
}

def uppers(c):
    out = []
    while c in UPPER:
        c = UPPER[c]
        out.append(c)
    return out

def decide(words):
    amb = [w for w in words if len(WORDS.get(w, [])) > 1][0]
    others = [WORDS[w][0] for w in words if w != amb]
    score = {}
    why = {}
    for sense in WORDS[amb]:
        s, reason = 0, []
        for o in others:
            if (sense, o) in COOC:
                s += 2; reason.append(f"{sense}+{o}（共起）")
            else:
                for u in uppers(o):
                    if (sense, u) in COOC:
                        s += 1; reason.append(f"{sense}+{o}→{u}（上位概念）")
                        break
        score[sense], why[sense] = s, reason
    best = max(score.values())
    winners = [k for k, v in score.items() if v == best]
    return amb, score, why, (winners[0] if best > 0 and len(winners) == 1 else None)

SENTENCES = [["あつい", "ほん"], ["あつい", "おちゃ"], ["あつい", "コーヒー"], ["あつい", "じしょ"], ["きょう", "あつい"], ["あつい", "へや"]]
for words in SENTENCES:
    amb, score, why, pick = decide(words)
    print(f"「{' '.join(words)}」の「{amb}」：" + "  ".join(f"{k} {v} 点" for k, v in score.items()))
    for k in score:
        if why[k]:
            print(f"      {k}：{'、'.join(why[k])}")
    print(f"   → {pick if pick else '判別できない（辞書に手がかりがない）'}\n")
print("EDRの辞書（現在の案内ページ）：日本語単語 約27万語・概念 約41万・日本語共起 約90万句を手作業で作成した")

161992〜1995 · मूल्यांकन

किस पैमाने पर “असफल हुआ”?

पाँचवीं पीढ़ी सफल हुई या असफल?

जून 1992 में नतीजे प्रस्तुत करने वाले अंतरराष्ट्रीय सम्मेलन FGCS'92 के बाद The Baltimore Sun अख़बार के संपादकीय ने योजना के बारे में लिखा: (अनुवाद)। लेकिन उसी सम्मेलन के मुख्य भाषण में निदेशक काज़ुहिरो फ़ुची (Kazuhiro Fuchi) ने कहा: (अनुवाद)। फ़ुची ने समझाया कि ऐसी समीक्षाओं का आधार 1981 के सम्मेलन में पेश की गई बड़ी तस्वीर थी। उन्होंने कहा कि 1982 में शुरू हुई योजना अधिक सीमित थी और उन्हें विश्वास है कि वह सफल रही।

1993 के अंतिम मूल्यांकन ने हर लक्ष्य के अनुसार नतीजे दिए। तर्क निकालने की गति का लक्ष्य पार हुआ, लेकिन आवाज़ और चित्रों के ज़रिए इंसानों से संवाद करने की प्रणाली बन नहीं पाई। कुल मिलाकर उसका कहना था कि परियोजना ने (अनुवाद)। MITI Research Review (1995) ने कहा कि उत्पाद न बनने के कारण इसे असफल मानने वाली राय परियोजना के विचार को ठीक से नहीं समझती। साथ ही उसने लिखा कि इसके हार्डवेयर का ढाँचा भविष्य की तकनीक में शायद इस्तेमाल नहीं होगा। निल्सन (Nilsson, 2010) लिखते हैं कि बहुत-से लोग मानते हैं कि अधिकांश नतीजों का अब केवल ऐतिहासिक महत्त्व है। दाईं आकृति में पैमाना बदलने पर उसी योजना का रिपोर्ट कार्ड बदल जाता है।

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:पाँचवीं पीढ़ी असफल हुई और जापान ने भी मान लिया
मूल स्रोत के अनुसार:1992 के सम्मेलन में निदेशक ने असफलता स्वीकार नहीं की। उन्होंने बताया कि असफल कहने वाली समीक्षाओं का आधार 1981 की बड़ी तस्वीर थी। अंतिम मूल्यांकन भी हर लक्ष्य के अनुसार लिखा गया है। बनाए गए कंप्यूटर और सॉफ़्टवेयर समाज में व्यापक रूप से इस्तेमाल नहीं हुए, यह बात MITI Research Review और बाहरी शोधकर्ताओं की पुस्तकों, दोनों में कही गई है। किसे लक्ष्य मानें, इससे उत्तर बदलता है।

171987〜1995 · छोटे कंप्यूटरों की ओर बदलाव

विशेष मशीनें और सामान्य कंप्यूटर

दुनिया का सबसे तेज़ कंप्यूटर व्यापक रूप से इस्तेमाल क्यों नहीं हुआ?

PIM की तर्क निकालने की गति सामान्य उपयोग वाले बड़े कंप्यूटरों से लगभग 100 गुना थी। लेकिन निल्सन (Nilsson, 2010) के अनुसार, सामान्य वर्कस्टेशन और पर्सनल कंप्यूटर भी अधिक शक्तिशाली हो गए और PIM से आगे निकल गए। MITI Research Review (1995) ने भी लिखा कि छोटे कंप्यूटरों की ओर बदलाव, यानी डाउनसाइज़िंग, और दूसरे रुझानों के कारण इसके हार्डवेयर का ढाँचा भविष्य की तकनीक में शायद इस्तेमाल नहीं होगा।

दाईं आकृति में सामान्य मशीन की गति बढ़ने की दर बदलें। विशेष मशीन की गति वही रहती है जो उसे बनाते समय थी। शुरुआत में 100 गुने का अंतर हो, तब भी सामान्य मशीन हर साल 1.5 गुनी तेज़ बने, तो लगभग 11 वर्षों में बराबरी कर लेती है। बढ़ने की दर उदाहरण के लिए चुनी गई संख्या है।

AI के लिए बनी विशेष Lisp मशीनों के साथ भी ऐसा ही हुआ। एक विकासकर्ता की यादों के अनुसार, Sun जैसी कंपनियों के वर्कस्टेशनों पर Lisp अच्छी तरह चलने लगा और विशेष मशीनों का लाभ अचानक कम हो गया। 1991 के श्वेतपत्र ने भी लिखा कि जापान में AI के लिए इस्तेमाल होने वाले कंप्यूटर मुख्य रूप से पर्सनल कंप्यूटर जैसे सामान्य प्रकारों के हो गए थे।

n＝log（अंतर）÷ log（G）

n: बराबरी करने में लगने वाले वर्ष
अंतर: शुरुआत में गति का अंतर (100)
G: सामान्य मशीन एक वर्ष में कितनी गुनी तेज़ होती है

181992〜1995 · इसके बाद

100 सॉफ़्टवेयर पैकेज बिखरते हैं

राष्ट्रीय योजना समाप्त होने पर बनाई गई चीज़ों का क्या हुआ?

पाँचवीं पीढ़ी की मुख्य परियोजना निर्धारित 10 वर्षों से 1 वर्ष बढ़ी और मार्च 1993 में समाप्त हुई। अप्रैल से (अनुवाद) 2 वर्षों तक चली। विकसित सॉफ़्टवेयर केवल विशेष समानांतर तर्क मशीनों पर चलता था। इसलिए KL1 को C भाषा में बदलने वाला भाषा प्रोसेसर KLIC बनाया गया, ताकि यह उस समय फैल रही UNIX की समानांतर मशीनों आदि पर भी चल सके।

सॉफ़्टवेयर “ICOT मुक्त सॉफ़्टवेयर” के रूप में मुफ़्त जारी किया गया। जून 1992 के FGCS'92 में 71 पैकेज, जून 1993 में 6, नवंबर 1994 में KLIC सहित 7, और मार्च 1995 के अंत में 16 और जारी हुए। कुल संख्या 100 हुई। जिन सॉफ़्टवेयरों का कॉपीराइट सरकार के बजाय ICOT के पास था, उन्हें शोध में बाधा डालने वाले प्रतिबंध हटाकर जारी किया गया। सरकारी बजट से किया जाने वाला सारा शोध मार्च 1995 में पूरा हो गया।

दाईं आकृति में “1 पंक्ति का अनुवाद करें” दबाने पर तर्क के नियम सामान्य प्रोग्रामिंग भाषा के दोहराव (for) और शर्त के अनुसार शाखा चुनने (if) में बदलते हैं। निदेशक काज़ुहिरो फ़ुची (Kazuhiro Fuchi) ने 1992 में कहा कि उन्हें उम्मीद है कि इस परियोजना से जन्मे (अनुवाद) दुनिया की अलग-अलग जगहों पर अंकुरित होंगे।

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:पाँचवीं पीढ़ी 1982〜1992 की योजना थी
मूल स्रोत के अनुसार:मुख्य परियोजना 1 वर्ष बढ़ी और मार्च 1993, यानी वित्त वर्ष 1992 के अंत, तक चली। इसके बाद 2 वर्षों की योजना में नतीजों को UNIX कंप्यूटरों पर भी चलाने और मुफ़्त जारी करने का काम हुआ। सरकारी बजट से किया जाने वाला सारा शोध मार्च 1995 में समाप्त हुआ।

“पाँचवीं पीढ़ी” नाम क्यों?

आँख, कान और मुँह वाला कंप्यूटर जो बात समझे

सम्मेलन से ICOT संस्थान तक

तथ्यों और नियमों से उत्तर देना

रूपों को मिलाना: यूनिफिकेशन

रिपोर्टों में “जापान”

“पाँचवीं पीढ़ी” पुस्तक और भविष्यवाणी की घड़ी

54.1 अरब येन या 56.9 अरब येन?

विदेश से लौटकर आया AI का उछाल

“बहुत ऊँचे लक्ष्य” से उलटी प्रतिक्रिया

काम बाँटना और जोड़ने की मेहनत

डेटा आने तक इंतज़ार

हर सेकंड 15.6 करोड़ बार तर्क

अनसुलझी समस्या का एक हिस्सा मशीन ने सिद्ध किया

अर्थ का शब्दकोश, इंसानों के हाथों

किस पैमाने पर “असफल हुआ”?

विशेष मशीनें और सामान्य कंप्यूटर

100 सॉफ़्टवेयर पैकेज बिखरते हैं

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

नाम क्यों?

पुस्तक और भविष्यवाणी की घड़ी

से उलटी प्रतिक्रिया