चौथे उछाल की शुरुआत | AI का पूरा इतिहास

012017·ट्रांसफ़ॉर्मर

किस शब्द पर कितना ध्यान दें

मशीन किसी वाक्य के शब्दों के बीच संबंधों को संख्याओं में कैसे दिखाती है?

जून 2017 में Google के शोधकर्ताओं और टोरंटो विश्वविद्यालय के एक छात्र सहित 8 लोगों ने ट्रांसफ़ॉर्मर का शोधपत्र प्रकाशित किया। पिछले अध्याय में बताए गए 2014 के अनुवाद संबंधी शोध से निकले अटेंशन (ध्यान) का इस्तेमाल RNN (शब्दों को एक-एक करके क्रम से पढ़ने वाला नेटवर्क) के साथ किया जाता था। इस शोधपत्र ने RNN का इस्तेमाल किए बिना, केवल अटेंशन से नेटवर्क बनाया।

हर शब्द के लिए 3 वेक्टर (संख्याओं के समूह) बनाए जाते हैं: खोजने वाले की क्वेरी (Q), खोजे जाने वाले की की (K) और उसकी सामग्री का वैल्यू (V)। क्वेरी और सभी शब्दों की की के डॉट प्रोडक्ट को √d से भाग देकर, सॉफ़्टमैक्स (सभी मानों को धनात्मक और उनका योग 1 बनाने वाली गणना) से भार बनाए जाते हैं। उन भारों के अनुसार वैल्यू को मिलाया जाता है। दाईं ओर के चित्र में दबाने पर मोटी रेखा “मछली” की ओर जाती है। शोधपत्र ने ऐसे 8 हिस्से साथ रखे (मल्टी-हेड), ताकि हर हेड अलग संबंध देख सके।

Attention(Q, K, V)＝softmax( QK^T ／ √d_k ) V

Q, K, V: क्वेरी, की और वैल्यू के वेक्टरों को रखने वाली मैट्रिक्स
d_k: की के वेक्टर की लंबाई (शोधपत्र में 64)
चित्र के संख्याओं के समूह: इस साइट ने हाथ से तय किए हुए मान

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

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

u11_attention.py

# u11 注意（アテンション）：文の中のどの単語に注目するかを、数値で決める
#
# どの出来事か：2017 年 6 月、トランスフォーマーの論文（記録 transformer_paper_2017）。文中の単語同士の
#   関連性に「注意」を向ける仕組みだけで、翻訳で高いスコアを短い学習時間で出した。
# 仕組み：単語ごとに「探す向き（問い＝Query）」と「見つけてもらう向き（鍵＝Key）」と「中身（値＝Value）」のベクトル（数の組）を
#   持たせる。問いと鍵の近さ（内積）を √d で割り、ソフトマックス関数で合計 1 の「注意の重み」に変換する。
#   その重みで、他の単語の値を足し合わせたものが、その単語の新しいベクトルになる。
#   論文の式：Attention(Q, K, V) = softmax(Q K^T / √d_k) V
#   ※ ここのベクトルは、仕組みを説明するために手で決めたもの。実際はたくさんの文から学習して決まる。
# 試してみよう：
#   - 「食べた」の問い（QUERY）を変えると、注意の向きがどう変わるか
#   - SHARP を 1 → 4 にすると、重みが 1 つの単語に集まっていく

import math

WORDS = ["ねこ", "が", "さかな", "を", "食べた"]
# ベクトルは 3 つの数：[生き物らしさ, 食べ物らしさ, 文の飾りらしさ]
KEY = {"ねこ": [1.0, 0.0, 0.0], "が": [0.0, 0.0, 1.0], "さかな": [0.2, 1.0, 0.0], "を": [0.0, 0.0, 1.0], "食べた": [0.3, 0.3, 0.0]}
QUERY = {"食べた": [1.0, 1.2, -1.0], "ねこ": [0.0, 0.5, 0.0]}   # 「食べた」は、だれが・何を、を探す
# 値（中身）：[だれが, 何を, どうした]
VALUE = {"ねこ": [1, 0, 0], "が": [0, 0, 0], "さかな": [0, 1, 0], "を": [0, 0, 0], "食べた": [0, 0, 1]}
SHARP = 2.0          # 内積にかける倍率（論文は 1/√d_k。ここでは見やすいように手作業で決めた値）
D = 3                # ベクトルの長さ

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

def attention(word):
    q = QUERY[word]
    scores = [sum(a * b for a, b in zip(q, KEY[w])) / math.sqrt(D) * SHARP for w in WORDS]
    return softmax(scores)

for w in QUERY:
    weights = attention(w)
    print(f"「{w}」が向ける注意：")
    for word, wt in zip(WORDS, weights):
        print(f"   {word:<4} {wt:5.1%} {'■' * round(wt * 30)}")
    mixed = [sum(wt * VALUE[x][k] for wt, x in zip(weights, WORDS)) for k in range(3)]
    print("   値を重みで足し合わせた新しいベクトル [だれが, 何を, どうした] =", [round(v, 2) for v in mixed])
    print()

print("SHARP を変えると（「食べた」が「さかな」に向ける重み）")
for s in (0.5, 1, 2, 4, 8):
    SHARP = s
    print(f"   SHARP={s:<3} → {attention('食べた')[2]:5.1%}")

022017·पोज़िशनल एन्कोडिंग

तरंगों से शब्दों का क्रम लिखना

अटेंशन की गणना क्रम नहीं देखती। “बिल्ली चूहे का पीछा करती है” और “चूहा बिल्ली का पीछा करता है” में फ़र्क कैसे करें?

अटेंशन की गणना में शब्दों का क्रम बदलने पर भी भार नहीं बदलते। चूँकि यह RNN की तरह क्रम से नहीं पढ़ती, इसलिए शब्द किस स्थान पर है, यह जानकारी अलग से जोड़नी पड़ती है।

शोधपत्र ने हर स्थान के लिए अलग-अलग आवर्तकाल वाली sin और cos तरंगों के मानों का वेक्टर (पोज़िशनल एन्कोडिंग) बनाया और उसे शब्द के वेक्टर में जोड़ा। तरंगों का आवर्तकाल सबसे छोटे 2π से सबसे बड़े 10000·2π तक था। घड़ी की सेकंड और घंटे की सुइयों की तरह, तेज़ तरंगें पास के स्थानों में और धीमी तरंगें दूर के स्थानों में फ़र्क करती हैं। नीचे का ग्राफ़ चुने हुए स्थान और दूसरे स्थानों के वेक्टरों का डॉट प्रोडक्ट दिखाता है। स्थानों के बीच अंतर समान हो, तो मान लगभग हर जगह समान होता है।

PE(pos, 2i)＝sin( pos／10000^2i/d )　PE(pos, 2i＋1)＝cos( pos／10000^2i/d )

pos: शब्द का स्थान
i: तरंग का क्रमांक
d: वेक्टर के आयामों की संख्या (शोधपत्र में 512; चित्र में 32)

चुने हुए स्थान और दूसरे स्थानों के वेक्टरों का डॉट प्रोडक्ट

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

u11_position.py

# u11 位置エンコーディング：周期の異なる波で語順を記録する
#
# どの出来事か：2017 年のトランスフォーマーの論文（記録 transformer_paper_2017）。注意の計算は順序を考慮しない。
#   そのため、位置ごとに sin と cos の波の値を並べたベクトル（位置エンコーディング、positional encoding）を、単語ベクトルに加算した。
# 仕組み：PE(pos, 2i) = sin(pos / 10000^(2i/d))、PE(pos, 2i+1) = cos(pos / 10000^(2i/d))。
#   i が小さいほど周期が短く、大きいほど長い。2 つの位置ベクトルの内積は、位置の「差」だけで決まる。
#   ※ d = 16 は、このサイトが設定した小さな次元数（論文は 512）。
# 試してみよう：
#   - D を 8・64 に変える
#   - 最後の段で、単語の順序を入れ替えても、位置を加えない注意の重みは変わらないことを確かめる

import math

D = 16

def pe(pos, d=D):
    v = []
    for i in range(d // 2):
        w = pos / (10000 ** (2 * i / d))
        v += [math.sin(w), math.cos(w)]
    return v

def dot(a, b):
    return sum(x * y for x, y in zip(a, b))

print("位置 0〜7 のベクトルの初めの 6 つ（周期が短い波ほど、位置ごとに大きく変わる）")
for pos in range(8):
    print(f"  位置 {pos}: " + " ".join(f"{x:+.2f}" for x in pe(pos)[:6]))

print("\n2 つの位置の内積（差が同じなら、どの位置でもほぼ同じ値）")
for a, b in [(0, 1), (10, 11), (30, 31), (0, 5), (20, 25), (0, 20)]:
    print(f"  位置 {a:>2} と {b:>2}（差 {b - a:>2}）: {dot(pe(a), pe(b)):6.3f}")

print("\n位置 10 と、ほかの位置の内積（棒グラフ）")
for p in range(0, 21, 2):
    v = dot(pe(10), pe(p))
    print(f"  {p:>2}: {v:6.2f} " + "■" * max(0, round((v + D / 2) * 2)))

# 位置情報を加えない注意の計算は、順序を入れ替えても同じ重みになる
words = {"ねこ": [1.0, 0.0], "ねずみ": [0.0, 1.0], "を": [0.2, 0.2], "追う": [0.6, 0.6]}

def weights(sent, add_pos):
    vec = [list(words[w]) for w in sent]
    if add_pos:
        vec = [[x + 0.8 * y for x, y in zip(v, pe(i, 2))] for i, v in enumerate(vec)]
    q = vec[-1]
    s = [math.exp(dot(q, k) * 2) for k in vec]
    t = sum(s)
    return {w: round(x / t, 3) for w, x in zip(sent, s)}

for add in (False, True):
    print(f"\n位置を{'加えた' if add else '加えない'}時、「追う」が向ける注意")
    print("  ねこ ねずみ を 追う →", weights(["ねこ", "ねずみ", "を", "追う"], add))
    print("  ねずみ ねこ を 追う →", weights(["ねずみ", "ねこ", "を", "追う"], add))

032018·संदर्भ

एक ही शब्द, अलग वाक्य में अलग संख्याएँ

play का मतलब बेसबॉल का खेल भी हो सकता है और नाटक भी। क्या एक शब्द के लिए संख्याओं का एक ही समूह काफ़ी है?

पिछले अध्याय के word2vec (2013) जैसे तरीकों में हर शब्द को एक वेक्टर दिया जाता था। इसलिए play का वेक्टर बेसबॉल के वाक्य में भी और नाटक के वाक्य में भी एक ही होता था। फ़रवरी 2018 में ऐलन इंस्टीट्यूट फ़ॉर AI और वॉशिंगटन विश्वविद्यालय के मैथ्यू पीटर्स (Matthew Peters) सहित 7 लोगों ने ELMo प्रस्तुत किया।

बहुत सारे पाठ पर एक LSTM को आगे से पढ़कर अगला शब्द और दूसरे LSTM को पीछे से पढ़कर पिछला शब्द अनुमानित करना सिखाया जाता है (दोनों में 2 परतें)। शब्द का निरूपण हर परत की आंतरिक अवस्था को, कार्य के अनुसार सीखे गए भारों से जोड़कर बनता है। शोधपत्र के अनुसार, निचली परत शब्दों की व्याकरणिक श्रेणी पहचानने में और ऊपरी परत शब्दों के अर्थ में फ़र्क करने में अच्छी है (दाईं ओर का चित्र)।

सभी 6 कार्यों में, केवल ELMo जोड़ने से उस समय के सबसे अच्छे परिणामों को पीछे छोड़ दिया गया और त्रुटियाँ अधिकतम लगभग 20% कम हुईं।

ELMo_k ＝γ Σ_j s_j h_k,j

h_k,j: kवें शब्द को पढ़ते समय jवीं परत की अवस्था
s_j: हर परत का भार (सॉफ़्टमैक्स से योग 1)
γ: पूरे निरूपण का आकार

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:ELMo ने पहली बार संदर्भ के अनुसार अर्थ बदलने वाले शब्दों का निरूपण किया
मूल स्रोत के अनुसार:ELMo का शोधपत्र खुद 2017 के शोध और CoVe को पहले के उदाहरण बताता है और अपने अंतर को (अनुवाद) का इस्तेमाल करना बताता है। 8 महीने बाद BERT के शोधपत्र ने ELMo को (अनुवाद) कहा। एक ही तरीके को बनाने वालों ने गहरा कहा, जबकि अगले शोधपत्र ने उसे कम गहरा कहा।

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

u11_context_vectors.py

# u11 同じ単語でも文脈によってベクトルが変わる（ELMo の考え方の簡易モデル）
#
# どの出来事か：2018年2月の ELMo（記録 elmo_2018）。1つの単語に1つのベクトル（word2vec など）を
#   割り当てる方式では、play が野球のプレーでも劇でも同じ値になる。ELMo は、文を前から読む
#   言語モデルと後ろから読む言語モデル（それぞれ2層）の内部状態を、層ごとの重み s で足し合わせて、
#   文脈に応じた単語ベクトルを作った。論文では、下の層は文法（品詞）、上の層は語の意味の識別に強いと報告されている。
# 仕組み：ここでは LSTM の代わりに、2つの「層」をまねた、ずっと単純なベクトルを作る。
#   層 1 ＝ 直前と直後の1語が、名詞の前に来やすい語か、動詞の周辺に来やすい語か（文法の手がかり）
#   層 2 ＝ 文中のほかの語が、野球・劇・音楽のどれに関する語か（意味の手がかり）
#   ※ ELMo そのものではない。文も辞書も、このサイトが作った例。
# 試してみよう：
#   - S1（層 1 の重み）を 1.0 → 0.5 → 0.0 と変えて、どの文同士が似たベクトルになるかを確認する
#   - SENTENCES に文を追加してみる

import math

SENTENCES = [
    ("野球・名詞", "the shortstop made a great play to end the inning"),
    ("野球・動詞", "the kids play baseball in the stadium"),
    ("劇・名詞", "we saw a new play at the theater on broadway"),
    ("劇・動詞", "the actor will play the king in the theater"),
    ("音楽・動詞", "she can play the piano and the violin"),
    ("野球・名詞", "that play won the game for the team"),
]
WORD = "play"
NOUN_SIDE = {"a", "great", "new", "that", "to", "at", "won"}        # 名詞の play のまわりに来やすい語
VERB_SIDE = {"will", "can", "kids", "the", "baseball"}               # 動詞の play のまわりに来やすい語
TOPIC = {"shortstop": 0, "inning": 0, "baseball": 0, "stadium": 0, "game": 0, "team": 0,
         "theater": 1, "broadway": 1, "actor": 1, "king": 1, "piano": 2, "violin": 2}

def unit(v):
    n = math.sqrt(sum(x * x for x in v)) or 1.0
    return [x / n for x in v]

def layers(sentence):
    t = sentence.split()
    i = t.index(WORD)
    near = [t[i - 1] if i > 0 else "", t[i + 1] if i + 1 < len(t) else ""]
    l1 = [sum(w in NOUN_SIDE for w in near), sum(w in VERB_SIDE for w in near)]
    l2 = [0, 0, 0]
    for w in t:
        if w in TOPIC:
            l2[TOPIC[w]] += 1
    return unit(l1), unit(l2)

def elmo_like(sentence, s1):
    l1, l2 = layers(sentence)
    return [s1 * x for x in l1] + [(1 - s1) * x for x in l2]

def cos(a, b):
    return sum(x * y for x, y in zip(a, b)) / ((math.sqrt(sum(x * x for x in a)) * math.sqrt(sum(y * y for y in b))) or 1)

print(f"1 単語に 1 つのベクトルを割り当てると、6 つの文の「{WORD}」はすべて同一（類似度はどれも 1.00）\n")
for S1 in (1.0, 0.5, 0.0):
    vecs = [elmo_like(s, S1) for _, s in SENTENCES]
    print(f"層 1 の重み S1 = {S1}（層 2 の重み {1 - S1}）  コサイン類似度の表")
    print("                 " + " ".join(f"文{j + 1:<3}" for j in range(len(vecs))))
    for i, (lab, s) in enumerate(SENTENCES):
        print(f"  文{i + 1}［{lab}］".ljust(14, "　") + " ".join(f"{cos(vecs[i], b):4.2f}" for b in vecs))
    print()
print("S1 が大きい（下の層を重視）と名詞・動詞でまとまり、S1 が小さい（上の層を重視）と野球・劇・音楽の意味でまとまる。")

042018·भाषा मॉडल

सिर्फ़ अगला शब्द अनुमानित करना सीखकर

बिना सही उत्तर वाले पाठ से मशीन क्या सीख सकती है?

जून 2018 में OpenAI ने यह तरीका प्रस्तुत किया। पहले 12 परतों वाले ट्रांसफ़ॉर्मर को 7,000 किताबों के पाठ पर अगला शब्द अनुमानित करना सिखाया जाता है (प्री-ट्रेनिंग)। इसके बाद थोड़े से उदाहरणों से अलग-अलग कार्य सिखाए जाते हैं। जाँचे गए 12 कार्यों में से 9 में इसने अब तक के सबसे अच्छे परिणामों को पीछे छोड़ दिया।

अब तक के पाठ के बाद आने वाले शब्द की प्रायिकता निकालने वाली प्रणाली को भाषा मॉडल कहते हैं। प्रायिकता के अनुसार अगला शब्द चुनते जाने से वाक्य बन जाता है। यह विचार पुराना है: शैनन (Shannon) के 1948 के शोधपत्र में भी पिछले 2 अक्षरों से अगले अक्षर की प्रायिकता तय करके अंग्रेज़ी जैसे अक्षर-क्रम बनाए गए थे। दाईं ओर के चित्र में इस साइट के रिकॉर्ड के पाठ में गिनकर निकाली गई, पिछले अक्षरों से अगले 1 अक्षर की प्रायिकताएँ हैं। शुरुआत में पिछले 2 अक्षर लिए जाते हैं; इसे 1〜3 अक्षरों के बीच बदला जा सकता है। तापमान बढ़ाने पर प्रायिकताएँ एक-दूसरे के करीब आती हैं और घटाने पर चुनाव अधिक प्रायिकता वाले अक्षरों पर केंद्रित हो जाता है।

चौथे उछाल का अंतर यह है कि प्रायिकताएँ एक बड़ा न्यूरल नेटवर्क (ट्रांसफ़ॉर्मर) निकालता है और वह कहीं अधिक पाठ पर प्रशिक्षण पाता है।

p_i ＝exp(z_i ／T)／Σ_j exp(z_j ／T)

z_i: अक्षर i का स्कोर (चित्र में गिनी गई बारंबारता का लघुगणक)
T: तापमान
p_i: अक्षर i को चुनने की प्रायिकता

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:इसे पहला GPT (GPT-1) कहा जाता है
मूल स्रोत के अनुसार:जून 2018 के शोधपत्र और घोषणा में GPT शब्द एक भी बार नहीं आता। 4 महीने बाद Google के BERT शोधपत्र ने इसे “जनरेटिव प्री-ट्रेन्ड ट्रांसफ़ॉर्मर (OpenAI GPT)” कहा। GPT-1 नाम कहाँ से आया, यह अभी सत्यापित नहीं हुआ है।

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

u11_ngram.py

# u11 次の字を確率で選ぶ：文章生成 AI の最も小さなモデル（温度つき）
#
# どの出来事か：2018 年の GPT（記録 openai_gpt_2018）から 2022 年の ChatGPT（記録 chatgpt_release_2022）まで、
#   文章生成 AI は「ここまでの文の次に来る言葉」の確率を学習し、その確率に従って次を選ぶことを繰り返して文章を作る。
# このサンプル：このサイトの記録の文（data/u11_corpus.txt）で、「前の 2 字 → 次の 1 字」の出現回数を数えるだけの
#   モデルを作る（n-gram。1948 年のシャノンの論文も、直前の 2 文字から次の文字の確率を決めて、英語らしい文字列を
#   作っている）。現代の AI は、数を数える代わりに大きなニューラルネットワーク（トランスフォーマー）で確率を計算し、ずっと多くの文章から学習する。
# 温度：数えた出現回数の対数をスコア z とし、p = exp(z / T) / Σ exp(z / T) で確率に換算する。T が小さいと最頻出の文字ばかりが選ばれ、
#   T が大きいと確率が平らになり、珍しい文字も選ばれる。T = 1 は数えた割合そのままになる。
# 試してみよう：
#   - TEMP を 0.3・1・2 に変えると、文はどうなるか
#   - N を 2・4・6 に変えると、文はどうなるか（大きいほど、学習した文をそのまま写しやすくなる）
#   - START を変える

import math
import random
from collections import Counter, defaultdict

random.seed(2018)
N = 3            # 直前の N-1 字を見て、次の 1 字を選ぶ
TEMP = 1.0       # 温度
START = "人工知能"
LENGTH = 60

text = open("data/u11_corpus.txt", encoding="utf-8").read().replace("\n", "。")
counts = defaultdict(Counter)
for i in range(len(text) - N + 1):
    counts[text[i:i + N - 1]][text[i + N - 1]] += 1
print(f"学習した文の長さ：{len(text):,} 字。数えた「前の {N - 1} 字」の種類：{len(counts):,}")

def probs(nxt, temp):
    chars = list(nxt)
    z = [math.log(nxt[c]) / temp for c in chars]
    m = max(z)
    e = [math.exp(v - m) for v in z]
    s = sum(e)
    return chars, [v / s for v in e]

ctx = START[-(N - 1):]
print(f"\n「{ctx}」の次に来た字の確率（上位 5）")
for t in (0.3, 1.0, 2.0):
    chars, ps = probs(counts[ctx], t)
    top = sorted(zip(ps, chars), reverse=True)[:5]
    print(f"  温度 {t}: " + "、".join(f"{c}（{p:.0%}）" for p, c in top))

out = START
for _ in range(LENGTH):
    nxt = counts.get(out[-(N - 1):])
    if not nxt:
        break
    chars, ps = probs(nxt, TEMP)
    out += random.choices(chars, ps)[0]
print(f"\n温度 {TEMP} で生成した文：", out)
longest = 0
for k in range(1, len(out) + 1):   # 学習した文の中に、そのまま一致する文字列の長さを短い方から確かめる
    if any(out[i:i + k] in text for i in range(len(out) - k + 1)):
        longest = k
    else:
        break
print(f"生成した文の中で、学習した文と完全に一致する最長部分：{longest} 字（N を大きくすると長くなる＝元の文を写しやすくなる）")

052018〜2019·टोकन

पाठ को टोकन में बाँटना

भाषा मॉडल पाठ को एक-एक अक्षर करके पढ़ता है या एक-एक शब्द करके?

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

2018 के GPT ने 40,000 बार जोड़कर बने शब्दकोश का इस्तेमाल किया। 2019 के GPT-2 शोधपत्र के अनुसार, अक्षरों (Unicode) को सीधे लेने पर जोड़ने से पहले ही शब्दकोश में 130,000 से अधिक प्रविष्टियाँ होती हैं। इसलिए अक्षरों को पहले 1-1 बाइट (256 प्रकार) में बाँटा गया, फिर BPE लागू करके शब्दकोश का आकार 50,257 किया गया। एक बार में पढ़ी जा सकने वाली लंबाई भी 512 से बढ़ाकर 1,024 टोकन की गई।

सबसे अधिक बार साथ आने वाली जोड़ी (a, b) → नया टोकन ab (दोहराएँ)

क्या गिनते हैं: पाठ में a के ठीक बाद b आने की बारंबारता

GPT-2 के शोधपत्र ने अलग-अलग प्रकार के अक्षरों को आपस में न जोड़ने की व्यवस्था भी की। इसका उद्देश्य dog. dog! dog? जैसे मामलों में एक ही शब्द को अलग चिह्नों के साथ अलग-अलग टोकन बनाने की बर्बादी से बचना था।

जोड़ने की बारंबारता और टोकन की संख्या

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

u11_bpe.py

# u11 文をトークンに分割する：バイトペア符号化（BPE）
#
# どの出来事か：2018 年の GPT（記録 openai_gpt_2018）は 4 万回結合した BPE の辞書を、2019 年の GPT-2
#   （記録 gpt2_staged_release_2019）は、文字を 1 バイトずつ（256 種類）に分けてから BPE を適用した 50,257 の辞書を使った。
# 仕組み：初めは 1 文字ずつに分割する。文章の中で最も多く隣り合う 2 つのトークンを結合して、新しいトークンにする。
#   これを繰り返すと、よく使われる並びは 1 つのトークンになり、珍しい並びは短い断片のまま残る。
#   ※ 文章は、このサイトが作った短い例。
# 試してみよう：
#   - MERGES を 0・5・30 に変える（トークンの数と、辞書の大きさがどう変わるか）
#   - TEXT に自分の文を入れる

from collections import Counter

TEXT = "あかいはな あおいはな あかいそら あおいそら しろいはな しろいくも あかいくも"
MERGES = 12

words = [list(w) for w in TEXT.split()]      # 空白の位置では結合しない
vocab = set(ch for w in words for ch in w)
print(f"初め：トークン {sum(len(w) for w in words)} 個、辞書 {len(vocab)} 種類")
print("  " + " | ".join(" ".join(w) for w in words))

for step in range(1, MERGES + 1):
    pairs = Counter()
    for w in words:
        for a, b in zip(w, w[1:]):
            pairs[(a, b)] += 1
    if not pairs:
        break
    (a, b), n = pairs.most_common(1)[0]
    if n < 2:
        print(f"{step} 回目：2 回以上並ぶ組み合わせが無いため、ここで終了")
        break
    new = a + b
    vocab.add(new)
    for i, w in enumerate(words):
        out, k = [], 0
        while k < len(w):
            if k + 1 < len(w) and w[k] == a and w[k + 1] == b:
                out.append(new)
                k += 2
            else:
                out.append(w[k])
                k += 1
        words[i] = out
    total = sum(len(w) for w in words)
    print(f"{step:2d} 回目：「{a}」＋「{b}」（{n} 回）→「{new}」  トークン {total} 個、辞書 {len(vocab)} 種類")

print("\n現在の分割：")
print("  " + " | ".join(" ".join(w) for w in words))

# 学習した辞書で、新しい言葉を分割してみる（長いものから順に適用する、簡単な分割法）
toks = sorted(vocab, key=len, reverse=True)
for word in ("あかいそら", "きいろいはな", "あおいくるま"):
    out, k = [], 0
    while k < len(word):
        for t in toks:
            if word.startswith(t, k):
                out.append(t)
                k += len(t)
                break
        else:
            out.append(word[k] + "?")   # 辞書にない文字（本物の GPT-2 は、文字をバイトに分解するため、どんな文字でも分割できる）
            k += 1
    print(f"  「{word}」→ {' | '.join(out)}")

062018·रिक्त स्थान भरना

शब्द छिपाकर दोनों ओर से अनुमान लगाना

अगले शब्द के बजाय वाक्य के बीच का रिक्त स्थान भरना सिखाने से क्या बदलता है?

अक्टूबर 2018 में Google के 4 लोगों ने BERT (बर्ट) प्रस्तुत किया। GPT बाएँ से दाएँ पढ़कर अगले शब्द का अनुमान लगाता था। दूसरी ओर, BERT ने वाक्य के 15% टोकन चुनकर छिपाए और बाएँ और दाएँ, दोनों तरफ़ के संकेतों से उनका अनुमान लगाना सीखा (चुने हुए स्थानों में 80% पर [MASK] चिह्न, 10% पर दूसरा शब्द और 10% पर मूल शब्द ही रखा गया)। शोधपत्र के अनुसार, यह विचार 1953 के Cloze नामक रिक्त स्थान भरने वाले परीक्षण से मिला।

दाईं ओर के चित्र के वाक्य “मैंने [MASK] पिया” में केवल बाईं ओर देखकर पानी, चाय, ब्रेड और सेब में फ़र्क नहीं किया जा सकता। दाईं ओर के “पिया” तक देखने पर चुनाव पेय पदार्थों तक सीमित हो जाता है।

किताबों के 80 करोड़ शब्दों और अंग्रेज़ी विकिपीडिया के 250 करोड़ शब्दों पर प्रशिक्षण देकर इसने 11 कार्यों में सबसे अच्छे परिणाम दिए। अक्टूबर 2019 में इसका इस्तेमाल Google खोज में शुरू हुआ और घोषणा की गई कि यह (अनुवाद) को समझने में मदद करता है।

लॉस ＝ −Σ_{छिपाए गए स्थान} log p( असली शब्द ｜ बाएँ और दाएँ के शब्द )

p: मॉडल से मिली प्रायिकता
छिपाए गए स्थान: चुने हुए 15% टोकन

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

u11_fill_blank.py

# u11 穴あき文の前と後ろから単語を予測する（BERT の穴埋めの考え方）
#
# どの出来事か：2018 年 10 月の BERT（記録 google_bert_2018）。文中の単語の 15% を選んで隠し（80% は [MASK] の印、
#   10% はランダムな別の単語、10% はそのまま）、左右両方の単語を手がかりに、隠した単語を予測する学習を行った。
#   GPT のように左から右へ読むだけの手法との違いは、右側（後ろ）の単語も手がかりにできること。
# 仕組み：ここではニューラルネットワークの代わりに、このサイトが作った 12 の例文で「左の言葉」「右の言葉」と同時に出た回数を数え、
#   穴に入る単語の確率を計算する。左だけで予測する場合と、左右両方で予測する場合を比べる。
# 試してみよう：
#   - QUESTIONS の穴の位置を変える
#   - 文を足して、確率がどう変わるか確かめる

from collections import Counter

CORPUS = """ぼく は みず を のんだ
ぼく は おちゃ を のんだ
ぼく は パン を たべた
ぼく は りんご を たべた
わたし は おちゃ を のんだ
わたし は りんご を たべた
いもうと は みず を のんだ
いもうと は パン を たべた
ねこ は さかな を たべた
ねこ は みず を のんだ
いぬ は ほね を かんだ
いぬ は みず を のんだ""".split("\n")
sents = [s.split() for s in CORPUS]
vocab = sorted(set(w for s in sents for w in s))

def predict(left, right, use_right):
    """穴の左の 2 語（と右の 2 語）が一致する文を数え、穴に入った単語の割合を計算する"""
    c = Counter()
    for s in sents:
        for i in range(len(s)):
            ok = s[max(0, i - len(left)):i] == left
            if use_right:
                ok = ok and s[i + 1:i + 1 + len(right)] == right
            if ok:
                c[s[i]] += 1
    total = sum(c.values())
    return [(w, n / total) for w, n in c.most_common()] if total else []

QUESTIONS = [
    "ぼく は [MASK] を のんだ",
    "ぼく は [MASK] を たべた",
    "いぬ は [MASK] を かんだ",
    "[MASK] は さかな を たべた",
]
for q in QUESTIONS:
    t = q.split()
    i = t.index("[MASK]")
    left, right = t[max(0, i - 2):i], t[i + 1:i + 3]
    print(f"「{q}」")
    for use_right, name in ((False, "左だけ見る（GPT の読み方）"), (True, "左右両方を見る（BERT の読み方）")):
        if not left and not use_right:
            print(f"   {name}：（穴の左に単語がないため、手がかりがない）")
            continue
        ps = predict(left, right, use_right)
        s = "、".join(f"{w} {p:.0%}" for w, p in ps[:4]) if ps else "（手がかりがない）"
        print(f"   {name}：{s}")
    print()

# BERT の隠し方：15% を選び、その 80% を [MASK]、10% をランダムな単語、10% を元のまま残す
import random
random.seed(15)
masked, picks = [], 0
for w in sum(sents, []):
    if random.random() < 0.15:
        picks += 1
        r = random.random()
        masked.append("[MASK]" if r < 0.8 else (random.choice(vocab) if r < 0.9 else w))
    else:
        masked.append(w)
print(f"BERT のルールで隠した例（{len(masked)} 語のうち {picks} 語を選択）：")
print("  " + " ".join(masked[:30]))

072019·चरणों में जारी करना

दुरुपयोग की चिंता में 9 महीने लगे

बनाए हुए AI को तुरंत पूरी तरह जारी न करने का निर्णय लेने पर क्या हुआ?

फ़रवरी 2019 में OpenAI ने इंटरनेट के 40GB पाठ पर प्रशिक्षित GPT-2 की घोषणा की। इसमें 150 करोड़ पैरामीटर थे (प्रशिक्षण से तय होने वाली संख्याएँ; इस अध्याय के सूत्रों में इन्हें घटक भी कहा गया है)। झूठे समाचार लेख जैसे उपयोगों को लेकर (अनुवाद) कहकर केवल छोटा मॉडल और शोधपत्र जारी किए गए। उन्होंने यह भी लिखा: (अनुवाद)।

इसके बाद क्रमशः बड़े संस्करण जारी किए गए। नवंबर में सबसे बड़ा संस्करण जारी करते समय लिखा गया: (अनुवाद)। दाईं ओर के चित्र में महीना बदलकर देखें।

घटकों की संख्या ≈ 12 × परतों की संख्या × d² ＋ शब्दकोश का आकार × d＋ स्थानों की संख्या × d

d: वेक्टर की लंबाई
12 × परतों की संख्या × d²: मुख्य हिस्से की गिनती (2020 का स्केलिंग नियमों का शोधपत्र)
सभी हिस्सों का योग: इस साइट का अनुमान

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:OpenAI ने ऐसा “AI जो इतना ख़तरनाक है कि उसे जारी नहीं कर सकते” बनाया
मूल स्रोत के अनुसार:घोषणा में dangerous (ख़तरनाक) शब्द नहीं है। उस दिन द गार्डियन अख़बार की सुर्खी थी: (अनुवाद)। 9 महीने बाद पूरा मॉडल जारी कर दिया गया।

पैरामीटर की संख्या (हर अगला निशान 10 गुना)

082020·स्केलिंग नियम

पैरामीटर बढ़ाएँ या पाठ बढ़ाएँ

अगर केवल पैरामीटर की संख्या बढ़ाएँ, लेकिन प्रशिक्षण के लिए पाठ कम हो, तो क्या होगा?

जनवरी 2020 में OpenAI और जॉन्स हॉपकिन्स विश्वविद्यालय के 10 लोगों ने दिखाया कि पैरामीटर की संख्या, पाठ की मात्रा और गणना की मात्रा बढ़ाने पर पाठ वाले AI का लॉस (अगले शब्द का अनुमान लगाने की कठिनाई) घात के नियम के अनुसार घटता है। यह रुझान कम-से-कम 7 परिमाण-क्रमों तक बना रहता है (अध्याय 12 में विस्तार से)।

शोधपत्र ने ऐसा सूत्र भी दिया जिसमें पैरामीटर की संख्या N और पाठ की मात्रा D, दोनों असर डालते हैं। केवल एक को बढ़ाने पर सुधार धीमा पड़ जाता है। शोधपत्र के अनुसार, अगर पैरामीटर 8 गुना बढ़ाए जाएँ, तो पाठ लगभग 5 गुना बढ़ाने पर नुकसान नहीं होता। दाईं ओर के चित्र में “N को 8 गुना, D को 5 गुना करें” दबाएँ।

बड़ा करने से और समझदार होने की उम्मीद का यह एक आधार है। लेकिन लेखक खुद लिखते हैं: (अनुवाद)।

L(N, D)＝ [ (N_c ／N)^α_N／α_D ＋D_c ／D ]^α_D

N: पैरामीटर की संख्या
D: पाठ की मात्रा (टोकन की संख्या)
α_N, α_D: शोधपत्र के मान 0.076 और 0.095
N_c, D_c: शोधपत्र के मान 8.8×10¹³ और 5.4×10¹³

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

पाठ की मात्रा तय रखकर केवल पैरामीटर की संख्या बढ़ाने पर लॉस

092020·उदाहरण दिखाना

दोबारा सीखे बिना, सिर्फ़ उदाहरण से

क्या AI के अंदर की संख्याएँ (भार) बदले बिना उसे नया कार्य सिखाया जा सकता है?

मई 2020 में OpenAI के 31 लोगों ने 17,500 करोड़ पैरामीटर वाला GPT-3 प्रस्तुत किया। यह पहले के इसी तरह के AI से 10 गुना बड़ा था और इसे 30,000 करोड़ टोकन पर प्रशिक्षित किया गया।

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

जब लोगों से GPT-3 के लिखे समाचार लेख और मनुष्य के लिखे लेख में फ़र्क करने को कहा गया, तो सही पहचान का प्रतिशत 52% था, जो अंदाज़े से चुनने (50%) से लगभग अलग नहीं था।

दिखाया गया पाठ ＝ कार्य का विवरण ＋ उदाहरण 1＋ … ＋ उदाहरण k＋ सवाल　→　आगे का पाठ लिखें

k: दिखाए गए उदाहरणों की संख्या
एक बार में पढ़ी जा सकने वाली लंबाई: 2,048 टोकन (GPT-3)

पैरामीटर की संख्या (हर अगला निशान 10 गुना; रिकॉर्ड की संख्याएँ)

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

u11_fewshot.py

# u11 追加学習なしで、例を見せるだけ：ゼロショット・ワンショット・フューショット
#
# どの出来事か：2020年のGPT-3（記録 gpt3_2020）。タスクごとにパラメータを学習し直す代わりに、
#   文の中でタスクの説明と例をいくつか示し、続きを書かせた（例なし＝ゼロショット、1つ＝ワンショット、複数＝フューショット）。
# 仕組み：ここでは、このサイトが作った例として「例に合う決まりだけを残す」小さな仕組みを使う。
#   例の数が増えると、考えられる決まりが絞られ、答えが1つに決まっていく様子を見る。
#   ※ GPT-3の仕組みそのものではない。GPT-3は、見せた文の続きを、学習した確率で書くだけ。
# 試してみよう：
#   - TRUE_RULE を変える
#   - DESCRIPTION にタスクの説明（例："逆から読む"）を入れて、例なしでも決まるかを見る

RULES = {
    "逆から読む": lambda w: w[::-1],
    "両はしを入れかえる": lambda w: w[-1] + w[1:-1] + w[0] if len(w) > 1 else w,
    "最初の字を最後へ": lambda w: w[1:] + w[0],
    "最後の字を最初へ": lambda w: w[-1] + w[:-1],
    "最初の字": lambda w: w[0],
    "字の数": lambda w: str(len(w)),
    "2 回くり返す": lambda w: w + w,
}
TRUE_RULE = "逆から読む"
EXAMPLES = ["ねこ", "さかな", "くつした"]
QUERY = "あめだま"
DESCRIPTION = ""          # 例："逆から読む"（説明を入れると、その名前のルールだけに絞られる）

for k in range(len(EXAMPLES) + 1):
    shown = [(w, RULES[TRUE_RULE](w)) for w in EXAMPLES[:k]]
    alive = [name for name, f in RULES.items() if all(f(a) == b for a, b in shown)]
    if DESCRIPTION:
        alive = [n for n in alive if n == DESCRIPTION]
    answers = {}
    for n in alive:
        answers.setdefault(RULES[n](QUERY), []).append(n)
    prompt = " / ".join(f"{a} → {b}" for a, b in shown) + (" / " if shown else "") + f"{QUERY} → ?"
    print(f"例 {k} 個：{prompt}")
    print(f"   残った決まり：{'、'.join(alive)}")
    for ans, ns in sorted(answers.items(), key=lambda x: -len(x[1])):
        p = len(ns) / len(alive)
        print(f"     答え「{ans}」 {p:4.0%} " + "■" * round(p * 20))
    print()

102020·स्व-पर्यवेक्षित शिक्षण

बिना लेबल, मिलते चित्रों को पास लाना

क्या तस्वीरों पर सही लेबल लगाए बिना, पहचान में काम आने वाली विशेषताएँ सीखी जा सकती हैं?

स्व-पर्यवेक्षित शिक्षण में मनुष्य सही उत्तर (लेबल) नहीं लगाते; डेटा से ही बनाए गए सवालों से सीखना होता है। अगला शब्द अनुमानित करना और रिक्त स्थान भरना भी इसी परिवार के तरीके हैं। फ़रवरी 2020 में Google के टिंग चेन (Ting Chen), जेफ़्री हिंटन (Geoffrey Hinton) सहित 4 लोगों ने चित्रों के कॉन्ट्रास्टिव लर्निंग को सरल रूप देने वाला SimCLR प्रस्तुत किया।

1 तस्वीर पर काटने, रंग बदलने या धुँधला करने जैसे बदलाव 2 बार लगाकर 2 चित्रों की सही जोड़ी बनाई जाती है। मॉडल को सिखाया जाता है कि इस जोड़ी के चित्र पास हों (कोसाइन समानता अधिक हो) और दूसरी तस्वीरों से दूर हों। दाईं ओर के चित्र में “सीखते रहें” दबाएँ।

बिना सही उत्तरों के सीखी गई विशेषताओं के ऊपर केवल एक सरल वर्गीकरण परत को सही उत्तरों के साथ प्रशिक्षित करने पर ImageNet में 76.5% मिले। यह सही उत्तरों के साथ प्रशिक्षित ResNet-50 के बराबर था।

ℓ_i,j ＝ −log [ exp( sim(z_i, z_j)／ τ )／Σ_k≠i exp( sim(z_i, z_k)／ τ ) ]

z: तस्वीर की विशेषताओं का वेक्टर
(i, j): एक ही तस्वीर से बनाई गई जोड़ी
sim: कोसाइन समानता
τ: तापमान पैरामीटर

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:बिना सही उत्तरों के चित्रों को सीखने वाली कॉन्ट्रास्टिव लर्निंग की शुरुआत SimCLR ने की
मूल स्रोत के अनुसार:शोधपत्र खुद लिखता है: (अनुवाद)। कॉन्ट्रास्टिव लर्निंग के उदाहरणों में वह सबसे पहले न्यूयॉर्क विश्वविद्यालय के 2006 के शोधपत्र का उल्लेख करता है। उस शोधपत्र में लिखा था: (अनुवाद)।

लॉस (प्रशिक्षण के चक्रों के अनुसार)

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

u11_contrastive.py

# u11 正解を与えずに、似ているものを近くに：対照学習（SimCLR の損失 NT-Xent）
#
# どの出来事か：2020年2月の SimCLR（記録 simclr_2020）。1枚の写真に加工を2回施し、同じ写真から作った2枚を
#   正しいペアにする。ベクトルに変換したとき、正しいペアは近く（コサイン類似度が高く）、同じまとまりの他の写真とは
#   遠くなるように学習させる。論文の損失関数（NT-Xent）：
#     ℓ(i, j) = −log( exp(sim(zi, zj)/τ) / Σ_{k≠i} exp(sim(zi, zk)/τ) )
# 仕組み：ここでは写真の代わりに、円周上の点（長さ1の2次元ベクトル）を直接動かす。2点ずつが同じ写真から
#   作ったペアを表す。損失が小さくなる向きに点を少しずつ回転させる。※ 点もペアも、このサイトが作った例。実際はニューラルネットワークが写真からベクトルを作る。
# 試してみよう：
#   - TAU（温度パラメータ）を 0.1・0.5・2 に変える
#   - PAIRS を増やす

import math
import random

random.seed(2020)
PAIRS = 5          # 写真の数（1枚から2点ずつ作る）
TAU = 0.5
STEPS = 200
LR = 0.02

ang = [random.uniform(0, 2 * math.pi) for _ in range(2 * PAIRS)]   # 点 2p と 2p+1 が同じ写真のペア
partner = [i + 1 if i % 2 == 0 else i - 1 for i in range(2 * PAIRS)]

def sim(a, b):
    return math.cos(ang[a] - ang[b])       # 長さ1の2次元ベクトル同士のコサイン類似度

def loss():
    tot = 0.0
    for i in range(2 * PAIRS):
        num = math.exp(sim(i, partner[i]) / TAU)
        den = sum(math.exp(sim(i, k) / TAU) for k in range(2 * PAIRS) if k != i)
        tot += -math.log(num / den)
    return tot / (2 * PAIRS)

def step():
    h = 1e-4
    grads = []
    for i in range(2 * PAIRS):          # 数値微分で勾配を見積もる（少し動かして損失の変化を調べる）
        ang[i] += h
        up = loss()
        ang[i] -= 2 * h
        down = loss()
        ang[i] += h
        grads.append((up - down) / (2 * h))
    for i, g in enumerate(grads):
        ang[i] -= LR * g * 10

def report(t):
    pos = sum(sim(i, partner[i]) for i in range(2 * PAIRS)) / (2 * PAIRS)
    neg = [sim(i, k) for i in range(2 * PAIRS) for k in range(2 * PAIRS) if k != i and k != partner[i]]
    print(f"{t:4d} ステップ目：損失 {loss():.3f}  正しいペアの近さ {pos:+.2f}  他の点との近さの平均 {sum(neg) / len(neg):+.2f}")

for t in range(STEPS + 1):
    if t in (0, 5, 10, 20, 40, 100, 200):
        report(t)
    step()

print("\n学習後の点の向き（度）。同じ写真の 2 点が、ほぼ同じ向きに集まる")
for p in range(PAIRS):
    a, b = math.degrees(ang[2 * p]) % 360, math.degrees(ang[2 * p + 1]) % 360
    print(f"  写真 {p + 1}: {a:6.1f}° と {b:6.1f}°")

112020·चित्रों का ट्रांसफ़ॉर्मर

चित्र से 16×16 वर्गों का क्रम बनाना

पाठ के लिए बने ट्रांसफ़ॉर्मर से चित्र कैसे पढ़वाएँ?

अक्टूबर 2020 में Google के अलेक्सेई दोसवित्स्की (Alexey Dosovitskiy) सहित 12 लोगों ने ViT (Vision Transformer) प्रस्तुत किया। यह चित्र को समान आकार के छोटे वर्गों (पैच) में काटता है और हर पैच को संख्याओं की एक पंक्ति, यानी वेक्टर में बदलता है। इसमें स्थान का वेक्टर जोड़कर, वाक्य के शब्दों की तरह ट्रांसफ़ॉर्मर में भेजा जाता है। शुरुआत में उत्तर देने के लिए एक अतिरिक्त चिह्न जोड़ा जाता है।

शोधपत्र में प्रशिक्षण के लिए 224×224 के चित्र इस्तेमाल हुए। इन्हें 16×16 के वर्गों में काटने पर 196 पैच का क्रम बनता है। दाईं ओर के चित्र में वर्ग छोटे करने पर क्रम लंबा होता है और अटेंशन की गणना भारी हो जाती है (क्रम की लंबाई वर्ग की भुजा के वर्ग के व्युत्क्रमानुपाती होती है)।

केवल ImageNet (लगभग 13 लाख चित्र) पर प्रशिक्षण देने पर इसके अंक पिछले अध्याय के CNN (कन्वोल्यूशन) वाले ResNet से कुछ अंक कम थे। 1 करोड़ 40 लाख〜30 करोड़ चित्रों पर प्री-ट्रेनिंग देने पर यह CNN के बराबर या उससे बेहतर हुआ और सबसे अच्छे मॉडल को 88.55% मिले। शोधपत्र का निष्कर्ष था कि बड़े पैमाने का प्रशिक्षण, CNN में शुरू से मौजूद चित्रों के लिए बनी संरचना से बेहतर है।

N＝H × W／P²

H, W: चित्र की ऊँचाई और चौड़ाई के पिक्सेल
P: वर्ग की भुजा की लंबाई
N: क्रम की लंबाई (वर्गों की संख्या)

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:चित्र को छोटे वर्गों में काटकर ट्रांसफ़ॉर्मर में भेजने का विचार पहली बार ViT में आया
मूल स्रोत के अनुसार:सम्मेलन को भेजे गए अंतिम संस्करण में सबसे नज़दीकी शोध के रूप में कॉर्दोनिए (Cordonnier) और साथियों (2020) का उल्लेख जोड़ा गया। उसमें लिखा गया: और (दोनों अनुवाद)। शोधपत्र ने नया यह बताया कि बड़े पैमाने के डेटा पर प्री-ट्रेनिंग देने से, बिना किसी विशेष बदलाव वाला ट्रांसफ़ॉर्मर भी CNN के बराबर हो सकता है।

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

u11_patches.py

# u11 画像を、小さな正方形（パッチ）の列にする：ViT の入力処理
#
# どの出来事か：2020 年 10 月の Vision Transformer（記録 vision_transformer_vit_2020）。画像を同じ大きさの正方形に切り、
#   1 枚ずつを 1 列のベクトルに変換し、位置を表すベクトルを足して、文章の単語と同じように並べる。
#   列の長さは N = H × W / P²（論文の式）。論文の学習で使われた画像は 224×224、正方形は 16×16 など。
# 仕組み：このサイトが作った例の 8×8 の小さな画像を、4×4 の正方形に切って並べる。そのあと、224×224 の画像で、
#   正方形の大きさと列の長さ・注意の計算量（列の長さの 2 乗に比例）の関係を表にする。
# 試してみよう：
#   - P を 2・8 に変える
#   - 画像（IMG）を書き換える

IMG = [
    "........",
    "..####..",
    ".#....#.",
    ".#.##.#.",
    ".#.##.#.",
    ".#....#.",
    "..####..",
    "........",
]
P = 4
H, W = len(IMG), len(IMG[0])

patches = []
for r in range(0, H, P):
    for c in range(0, W, P):
        flat = [1 if IMG[r + y][c + x] == "#" else 0 for y in range(P) for x in range(P)]
        patches.append(((r // P, c // P), flat))

print(f"{H}×{W} の画像を {P}×{P} の正方形に切ると、{len(patches)} 枚の列になる（N = {H}×{W}/{P}² = {H * W // (P * P)}）")
print("列の先頭に、分類用のトークン [CLS] を 1 つ足す\n")
print("  0: [CLS]")
for i, ((r, c), flat) in enumerate(patches, 1):
    print(f"  {i}: 場所（{r}, {c}）  平らにした数 {''.join(map(str, flat))}  ＋ 位置 {i} のベクトル")

print("\n224×224 の画像で、正方形の大きさを変えると")
print("  正方形 P | 列の長さ N | 注意の計算量（N² ）")
for p in (8, 14, 16, 28, 32):
    n = (224 // p) ** 2
    print(f"   {p:3d}   |  {n:6d}    | {n * n:10,d}  " + "■" * max(1, round(n * n / 60000)))

122018·2020·प्रोटीन

दूरियों के नक्शे से आकार बनाना

क्या केवल अमीनो अम्लों के क्रम से प्रोटीन की त्रिआयामी संरचना का अनुमान लगाया जा सकता है?

यह पाठ या चित्र बनाने वाला AI नहीं था, लेकिन इसी समय विज्ञान के उपकरण के रूप में AI ने भी बड़ी प्रगति की। प्रोटीन का आकार अमीनो अम्लों की शृंखला के मुड़कर तह बनने से तय होता है। 2018 की संरचना-अनुमान प्रतियोगिता CASP13 में DeepMind के पहले AlphaFold ने CNN से अमीनो अम्लों के बीच दूरियों का नक्शा अनुमानित किया। उस नक्शे से स्कोर का सूत्र बनाया गया और ग्रेडिएंट डिसेंट से आकार को थोड़ा-थोड़ा सुधारा गया।

दाईं ओर का चित्र इस तरीके का सबसे छोटा रूप है। बाईं ओर के नक्शे (इस साइट की तय की हुई संख्याओं) से मेल खाने के लिए बेतरतीब आकार की शृंखला चलती है।

2 साल बाद CASP14 (2020) के AlphaFold 2 के बारे में नोबेल समिति के विवरण में कहा गया: (अनुवाद)। इसमें कन्वोल्यूशन की जगह ट्रांसफ़ॉर्मर का अटेंशन लिया गया और परमाणुओं के स्थान सीधे निकाले गए। कठिन समस्याओं के अंक लगभग 60% से बढ़कर लगभग 90% हो गए।

E＝Σ_i＜j ( |x_i − x_j| − d_ij )²　　x ← x − η ∂E／∂x

x_i: iवें अमीनो अम्ल का स्थान
d_ij: नक्शे की दूरी
η: स्थान बदलने के कदम का आकार (लर्निंग रेट)
असली स्कोर का सूत्र: इस वर्ग त्रुटि से अलग रूप

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:AI ने प्रोटीन के तह बनने का रहस्य सुलझा दिया
मूल स्रोत के अनुसार:शोधपत्र खुद इसे ““प्रोटीन फोल्डिंग समस्या” का संरचना का अनुमान लगाने वाला हिस्सा” (अनुवाद) तक सीमित करता है।

कुल त्रुटि E (हर अगला निशान 10 गुना)

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

u11_distance_fold.py

# u11 距離の地図から、形を組み立てる（最初の AlphaFold の組み立て方の最小の形）
#
# どの出来事か：2018年のCASP13に出場した最初のAlphaFold（記録 alphafold1_casp13_2018）。CNNでアミノ酸同士の
#   距離を予測し、その距離に合う点数の式を作って、勾配降下法で形を少しずつ直して組み立てた。
#   2020年のAlphaFold2（記録 alphafold2_casp14_2020）は作り直されて、原子の位置を直接出す形に変わった。
# 仕組み：このサイトが決めた「正解の形」（2次元のひも、12個の点）から距離の地図を作り、ランダムな初期配置から始めて、
#   E = Σ (|xi − xj| − dij)² を小さくする方向に点を動かす。※ 実際のモデルは3次元で、点数の式も異なる。
# 試してみよう：
#   - NOISE を増やして、距離の地図に誤差が混ざっても形を組み立てられるか確かめる
#   - STEPS を 20 にしてみる

import math
import random

random.seed(13)
N = 12
NOISE = 0.0          # 距離の地図に加える誤差（割合）
STEPS = 400
LR = 0.01

true = []
for i in range(N):   # 正解の形：くるりと曲がったひも（このサイトが決めた）
    t = i / (N - 1) * 3.6
    true.append((math.cos(t) * (1 + t * 0.3), math.sin(t) * (1 + t * 0.3)))
d = [[math.dist(true[i], true[j]) * (1 + random.uniform(-NOISE, NOISE)) for j in range(N)] for i in range(N)]

x = [[random.uniform(-2, 2), random.uniform(-2, 2)] for _ in range(N)]

def energy():
    return sum((math.dist(x[i], x[j]) - d[i][j]) ** 2 for i in range(N) for j in range(i + 1, N))

for step in range(STEPS + 1):
    if step % 80 == 0:
        print(f"{step:4d} ステップ目：誤差の合計 E = {energy():8.3f}")
    g = [[0.0, 0.0] for _ in range(N)]
    for i in range(N):
        for j in range(N):
            if i == j:
                continue
            r = math.dist(x[i], x[j]) or 1e-9
            k = 2 * (r - d[i][j]) / r
            g[i][0] += k * (x[i][0] - x[j][0])
            g[i][1] += k * (x[i][1] - x[j][1])
    for i in range(N):
        x[i][0] -= LR * g[i][0]
        x[i][1] -= LR * g[i][1]

print("\n距離の地図（正解の形から作成。値が小さいほど近い）の左上 6×6")
for i in range(6):
    print("  " + " ".join(f"{d[i][j]:4.1f}" for j in range(6)))

# 組み立てた形を文字で表示する（向きや反転は定まらないため、正解と同じ向きとは限らない）
grid = [[" "] * 32 for _ in range(14)]
xs, ys = [p[0] for p in x], [p[1] for p in x]
for i, (a, b) in enumerate(x):
    c = int((a - min(xs)) / (max(xs) - min(xs) + 1e-9) * 30)
    r = int((b - min(ys)) / (max(ys) - min(ys) + 1e-9) * 12)
    grid[12 - r][c] = "0123456789ab"[i]
print("\n組み立てた形（0 から b の順につながったひも）")
for row in grid:
    print("  " + "".join(row))

132021·चित्र और पाठ

चित्र और पाठ को एक ही नक्शे पर रखना

कुत्ते की तस्वीर और उसका वर्णन करने वाला वाक्य कितना मेल खाते हैं, क्या इसे संख्या से माप सकते हैं?

2021 में OpenAI के ऐलेक रैडफ़ोर्ड (Alec Radford) सहित 12 लोगों ने CLIP प्रस्तुत किया। इंटरनेट से इकट्ठे किए गए 40 करोड़ चित्र-विवरण जोड़ों पर, चित्र को वेक्टर में बदलने वाला हिस्सा और पाठ को वेक्टर में बदलने वाला हिस्सा साथ-साथ प्रशिक्षित किए जाते हैं। एक बार में 32,768 जोड़े रखकर सिखाया जाता है कि सही जोड़ों की दिशाएँ पास हों और बाकी की दूर हों (कॉन्ट्रास्टिव लर्निंग)।

दाईं ओर का चित्र, चित्रों और वाक्यों के बीच समानता (कोसाइन समानता) की तालिका है। “सीखें” दबाने पर सही जोड़ों का विकर्ण चमकता है। प्रशिक्षण के बाद वर्गों के नामों को A photo of a dog. जैसे वाक्यों में बदलकर, सबसे नज़दीकी वाक्य चुनने से ही वर्गीकरण किया जा सकता है (ज़ीरो-शॉट)। ImageNet के प्रशिक्षण वाले चित्रों में से 1 भी इस्तेमाल किए बिना 76.2% मिले।

समानता ＝cos(u_i, v_j)＝u_i·v_j ／ ( |u_i| |v_j| )

u: चित्र का वेक्टर
v: वाक्य का वेक्टर
लॉस की दिशा: पंक्तियों (चित्र→पाठ) और स्तंभों (पाठ→चित्र), दोनों के अनुसार

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:CLIP चित्र बनाने वाला AI है
मूल स्रोत के अनुसार:CLIP चित्र नहीं बनाता। यह चित्र और वाक्य के बीच मेल को मापने वाला मॉडल है।

लॉस (प्रशिक्षण के चक्रों के अनुसार)

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

u11_clip_table.py

# u11 画像とテキストを同じ空間に配置する：CLIPの「似ている度合いの表」
#
# どの出来事か：2021年のCLIP（記録 clip_2021）。4億組の画像と説明文で、画像をベクトルに変換するモデルと、
#   テキストをベクトルに変換するモデルを同時に学習させる。N枚の画像とN個のテキストのコサイン類似度の表で、
#   正しい組み合わせ（対角線）は大きく、他は小さくなるように学習させる（行ごと・列ごとの両方向で「正しい組を当てる」確率の損失）。
#   学習後は、クラス名をテキストにして、画像に最も近いテキストを選ぶだけで識別できる（ゼロショット）。
# 仕組み：実際は大きなニューラルネットワークを使う。ここでは画像5枚とテキスト5個のベクトル（3つの数）を直接更新する。
#   画像とテキストは、このサイトが作った例（名前だけ）。
# 試してみよう：
#   - TAU（温度）を変える
#   - STEPS を 0 にして、学習前の表を見る

import math
import random

random.seed(2021)
IMAGES = ["赤い丸の絵", "青い四角の絵", "黄色い星の絵", "緑の三角の絵", "白い雲の絵"]
TEXTS = ["赤い丸", "青い四角", "黄色い星", "緑の三角", "白い雲"]
N, DIM = len(IMAGES), 3
TAU = 0.3
STEPS = 300
LR = 0.1

U = [[random.gauss(0, 1) for _ in range(DIM)] for _ in range(N)]   # 画像のベクトル
V = [[random.gauss(0, 1) for _ in range(DIM)] for _ in range(N)]   # テキストのベクトル

def cos(a, b):
    return sum(x * y for x, y in zip(a, b)) / (math.sqrt(sum(x * x for x in a)) * math.sqrt(sum(y * y for y in b)))

def loss():
    S = [[cos(U[i], V[j]) / TAU for j in range(N)] for i in range(N)]
    tot = 0.0
    for i in range(N):   # 行：画像 i に合うテキストはどれか
        tot -= S[i][i] - math.log(sum(math.exp(s) for s in S[i]))
    for j in range(N):   # 列：テキスト j に合う画像はどれか
        col = [S[i][j] for i in range(N)]
        tot -= S[j][j] - math.log(sum(math.exp(s) for s in col))
    return tot / (2 * N)

def show():
    print("        " + " ".join(f"{t:>6}" for t in TEXTS))
    for i in range(N):
        print(f"  {IMAGES[i]:<8}" + " ".join(f"{cos(U[i], V[j]):+6.2f}" for j in range(N)))

print("学習前の類似度（コサイン類似度）の表。行が画像、列がテキスト")
show()
h = 1e-4
for step in range(STEPS):
    for M in (U, V):
        for i in range(N):
            for k in range(DIM):
                M[i][k] += h
                up = loss()
                M[i][k] -= 2 * h
                down = loss()
                M[i][k] += h
                M[i][k] -= LR * (up - down) / (2 * h)
    if step in (0, 50, STEPS - 1):
        print(f"  {step + 1} 回学習：損失 {loss():.3f}")
print("\n学習後の表（対角線が大きく、他が小さい）")
show()

print("\nゼロショット：画像ごとに、最も近いテキストを選ぶ")
for i in range(N):
    j = max(range(N), key=lambda j: cos(U[i], V[j]))
    print(f"  {IMAGES[i]} → 「{TEXTS[j]}」")

142015→2020·डिफ़्यूज़न मॉडल

शोर जोड़कर धीरे-धीरे हटाना

क्या सिर्फ़ शोर से चित्र बनाया जा सकता है?

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

दाईं ओर के चित्र में 2015 के शोधपत्र के चित्र जैसी सर्पिल में रखे बिंदु हैं। t बढ़ाने पर वे धुंध बन जाते हैं। “शोर से बनाएँ” दबाने पर हर कदम में शोर हटता है और आकार वापस आता है।

2020 में बर्कले के हो (Ho) सहित 3 लोगों के DDPM शोधपत्र में लिखा था: (अनुवाद)। फिर 1,000 कदमों की प्रक्रिया और जोड़े गए शोर का ही अनुमान लगाना सिखाकर उन्होंने दिखाया कि उच्च गुणवत्ता वाले चित्र बनाए जा सकते हैं।

x_t ＝ √ᾱ_t x₀ ＋ √(1 − ᾱ_t) ε　　क्या सीखना है：x_t से ε का अनुमान लगाना

x₀: मूल डेटा
ε: जोड़ा गया शोर
ᾱ_t: tवें कदम पर बचे मूल डेटा का अनुपात (1 से 0 की ओर)

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:डिफ़्यूज़न मॉडल Stable Diffusion के समय निकला नया तरीका है
मूल स्रोत के अनुसार:मूल विचार 2015 के शोधपत्र में है। Stable Diffusion का मूल शोधपत्र (दिसंबर 2021) भी डिफ़्यूज़न मॉडल के स्रोत के रूप में 2015 के शोधपत्र का उल्लेख करता है।

tवें कदम पर बचे मूल डेटा का अनुपात ᾱ

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

u11_diffusion.py

# u11 ノイズを加えて、少しずつ取り除く：拡散モデル
#
# どの出来事か：2015 年のソール＝ディックスタインたちの拡散モデルと、2020 年のホーたちの DDPM
#   （記録 diffusion_model_2015）。前向きには、データに小さな正規分布のノイズを繰り返し加え、完全なノイズにする。
#   逆向きには、各ステップで加えたノイズ ε を予測して少しずつ取り除く。DDPM は 1,000 ステップでノイズを予測する学習法。
#     x_t = √ᾱ_t · x_0 + √(1 − ᾱ_t) · ε      （ᾱ_t：t ステップ目で残っている元のデータの割合）
# 仕組み：ここではネットワークの代わりに、訓練データから計算した「理想の雑音の当て方」を使う（訓練データの近くに戻る。
#   実際のネットワークは、訓練データの点のあいだの新しいデータも作る）。データは円周上の 40 点、ステップ数は 50（このサイトが決めた数）。
# 試してみよう：
#   - T を 10・100 に変えて、生成した点が円にどれだけ近いかを見る
#   - 最後の段の「作った点」の数を増やす

import math
import random

random.seed(2020)
T = 50
betas = [0.001 + (0.25 - 0.001) * t / (T - 1) for t in range(T)]
abar, a = [], 1.0
for b in betas:
    a *= 1 - b
    abar.append(a)
DATA = [(math.cos(2 * math.pi * k / 40), math.sin(2 * math.pi * k / 40)) for k in range(40)]   # 円周上の 40 点

def ideal_x0(x, t):
    """t ステップ目の点 x から、元の点の予測値（訓練データの重み付き平均）を計算する"""
    s, v = math.sqrt(abar[t]), 1 - abar[t]
    ws = [math.exp(-((x[0] - s * p[0]) ** 2 + (x[1] - s * p[1]) ** 2) / (2 * v)) for p in DATA]
    tot = sum(ws) or 1e-300
    return (sum(w * p[0] for w, p in zip(ws, DATA)) / tot, sum(w * p[1] for w, p in zip(ws, DATA)) / tot)

def radius(pts):
    return sum(math.hypot(*p) for p in pts) / len(pts)

print("前向き：円周上の点にノイズを加えていく（中心からの平均距離。円なら 1.00）")
eps = [(random.gauss(0, 1), random.gauss(0, 1)) for _ in DATA]
for t in (0, 10, 25, 49):
    s, n = math.sqrt(abar[t]), math.sqrt(1 - abar[t])
    xt = [(s * p[0] + n * e[0], s * p[1] + n * e[1]) for p, e in zip(DATA, eps)]
    print(f"  {t + 1:3d} ステップ目：残っている元の割合 ᾱ = {abar[t]:.3f}  平均距離 {radius(xt):.2f}")

print("\n逆向き：完全なノイズから始めて、1 ステップずつノイズを予測して取り除く")
pts = [(random.gauss(0, 1), random.gauss(0, 1)) for _ in range(60)]
for t in range(T - 1, -1, -1):
    new = []
    for x in pts:
        x0 = ideal_x0(x, t)
        e = [(x[k] - math.sqrt(abar[t]) * x0[k]) / math.sqrt(1 - abar[t]) for k in (0, 1)]   # 予測したノイズ
        mean = [(x[k] - betas[t] / math.sqrt(1 - abar[t]) * e[k]) / math.sqrt(1 - betas[t]) for k in (0, 1)]
        sd = math.sqrt(betas[t]) if t > 0 else 0.0
        new.append((mean[0] + sd * random.gauss(0, 1), mean[1] + sd * random.gauss(0, 1)))
    pts = new
    if t in (T - 1, 30, 15, 5, 0):
        print(f"  残り {t:3d} ステップ：平均距離 {radius(pts):.2f}")

grid = [["・"] * 21 for _ in range(11)]
for p in DATA:
    grid[5 - round(p[1] * 4.5)][10 + round(p[0] * 9)] = "○"
for p in pts:
    r, c = 5 - round(p[1] * 4.5), 10 + round(p[0] * 9)
    if 0 <= r < 11 and 0 <= c < 21:
        grid[r][c] = "●"
print("\n○＝訓練データ　●＝ノイズから生成した点")
for row in grid:
    print("  " + "".join(row))

152021〜2022·चित्र बनाने वाला AI

छोटा करके फिर शोर हटाना

512×512 के चित्र में सीधे शोर जोड़कर हटाना क्या बहुत भारी गणना नहीं होगा?

दिसंबर 2021 में म्यूनिख विश्वविद्यालय, हाइडलबर्ग विश्वविद्यालय और Runway के रॉबिन रोमबाख (Robin Rombach) और साथियों ने लैटेंट डिफ़्यूज़न मॉडल प्रस्तुत किया। चित्र को ऑटोएन्कोडर (पिछला अध्याय: छोटा करना और वापस बनाना) से लैटेंट निरूपण में छोटा किया जाता है और वहाँ डिफ़्यूज़न मॉडल चलाया जाता है। उन्होंने छोटा करने के गुणक f को 1〜32 तक जाँचा और पाया कि 4〜16 गति और गुणवत्ता का अच्छा संतुलन देते हैं।

अगस्त 2022 का Stable Diffusion इसी रूप का है। उसके विवरण के अनुसार, ऊँचाई और चौड़ाई को 8वें हिस्से तक छोटा किया जाता है। पाठ को CLIP के पाठ वाले हिस्से से वेक्टर में बदला जाता है और अटेंशन से शोर हटाने वाले U-Net (पिछला अध्याय) से जोड़ा जाता है। दाईं ओर के चित्र में f बदलकर देखें।

इसे कौन इस्तेमाल कर सकता था, यह भी 2 साल से कम में बदल गया। जनवरी 2021 के DALL·E में केवल नमूने दिखाए गए थे; अप्रैल 2022 का DALL·E 2 केवल कुछ चुने हुए लोगों के लिए था। अगस्त 2022 में Stable Diffusion का प्रशिक्षित मुख्य मॉडल ऐसे रूप में जारी हुआ कि कोई भी उसे डाउनलोड करके अपने कंप्यूटर पर चला सकता था (उपयोग की पाबंदियों के साथ व्यावसायिक इस्तेमाल भी संभव था)।

लैटेंट मानों की संख्या ＝ (H／f) × (W／f) × c

H, W: चित्र की ऊँचाई और चौड़ाई के पिक्सेल
f: छोटा करने का गुणक (Stable Diffusion में 8)
c: एक स्थान पर मानों की संख्या (4)
कुल मान: 512×512×3＝786,432 → 64×64×4＝16,384 (48वाँ हिस्सा)

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:Stable Diffusion को Stability AI नामक कंपनी ने बनाया
मूल स्रोत के अनुसार:Stability AI की अपनी घोषणा में लिखा है: (अनुवाद)।

162017〜2022·जापान

सीखने का उपयोग और मशीन लर्निंग स्वर्ग

AI के रचनाओं से सीखने के बारे में जापान के कानून ने क्या तय किया?

मई 2018 में जापान के कॉपीराइट कानून में संशोधन हुआ (जनवरी 2019 से लागू)। अनुच्छेद 30-4 बना, जिसके अनुसार, अगर उपयोग का उद्देश्य लोगों को रचना का आनंद देना नहीं है, तो आवश्यक सीमा तक कॉपीराइट धारक की अनुमति के बिना उसका उपयोग किया जा सकता है। इसका शीर्षक है: (अनुवाद)। लेकिन इसमें यह शर्त है: (अनुवाद)। दाईं ओर के चित्र में उपयोग का तरीका चुनने पर कार्ड या तो पहले द्वार पर रुकता है, या द्वार 2 और 3 के निर्णय के प्रवेश-बिंदु तक पहुँचता है।

कानून के पाठ और सरकारी सारांश में AI शब्द नहीं है। जापान की सांस्कृतिक मामलों की एजेंसी के विवरण पृष्ठ (2018) ने उदाहरण के रूप में (अनुवाद) दिया। अगले साल के दस्तावेज़ ने प्रभाव के उदाहरणों में सबसे पहले (अनुवाद) रखा। वासेदा विश्वविद्यालय के कानून के विद्वान तात्सुहिरो उएनो (Tatsuhiro Ueno) 2017 से कहते आए हैं: “जापान एक ऐसा “मशीन लर्निंग स्वर्ग” है जिसकी मिसाल दुनिया में कहीं नहीं है” (अनुवाद)।

29 अगस्त 2022 को जापानी AI mimic का बीटा संस्करण जारी हुआ। अपने लगभग 15 चित्रों पर प्रशिक्षण देने से यह मिलती शैली के चित्र बनाता था। दूसरों के चित्र बिना अनुमति इस्तेमाल किए जाने की चिंताएँ लगातार सामने आईं और अगले दिन इसकी सभी सुविधाएँ रोक दी गईं।

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

अगस्त 2022: विदेश और जापान

172017→2022·लोगों की पसंद

दो को देखकर बेहतर वाला चुनना

अच्छे उत्तर को अंक देने का तरीका सूत्र में न लिख सकें, तो क्या करें?

रीइन्फोर्समेंट लर्निंग (अधिक अंक, यानी रिवॉर्ड पाने वाले व्यवहार सीखने का तरीका) को उन कार्यों में मुश्किल होती थी जिनमें अंक देने का तरीका सूत्र में नहीं लिखा जा सकता। जून 2017 में OpenAI और DeepMind के पॉल क्रिस्टियानो (Paul Christiano) सहित 6 लोगों ने लोगों को AI की गतिविधियों के 1〜2 सेकंड के 2 वीडियो दिखाए और बेहतर वाला चुनने को कहा। उन चुनावों का अनुमान लगाने वाला रिवॉर्ड मॉडल प्रशिक्षित किया गया (बाद में इसे RLHF कहा गया)। रोबोट ने 900 तुलनाओं से पीछे की ओर कलाबाज़ी करना सीखा।

दाईं ओर के चित्र में जो उत्तर बेहतर लगे, उसे दबाते जाएँ। दो स्कोरों के अंतर से किसी उत्तर को मनुष्य के चुनने की प्रायिकता निकाली जाती है (नीचे का सूत्र) और परिणामों से मेल खाने के लिए स्कोर सुधारे जाते हैं।

मार्च 2022 के InstructGPT में लॉन्ग ओउयांग (Long Ouyang) और साथियों ने इसे GPT-3 पर लागू किया। उदाहरणों से दोबारा प्रशिक्षण दिया गया, 4〜9 उत्तरों की रैंकिंग से रिवॉर्ड मॉडल बनाया गया और फिर रीइन्फोर्समेंट लर्निंग (PPO) की गई। 130 करोड़ पैरामीटर वाले InstructGPT के उत्तर, 100 गुना बड़े GPT-3 के उत्तरों से अधिक पसंद किए गए।

P(A)＝e^r_A ／ ( e^r_A ＋e^r_B )

P(A): मनुष्य के A चुनने की प्रायिकता
r: रिवॉर्ड मॉडल का स्कोर
चित्र के उत्तर: इस साइट के बनाए 5 उत्तर (उनकी असली गुणवत्ता भी इस साइट ने तय की है)

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:RLHF को ChatGPT के लिए बनाया गया था
मूल स्रोत के अनुसार:2017 में गेम और रोबोट की गतिविधियाँ आज़माई गई थीं। शोधपत्र में यह नाम भी नहीं है।

रैंकिंग वाले जोड़ों का वह अनुपात जो असली गुणवत्ता के क्रम से मेल खाता है

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

u11_preference.py

# u11 2つを比べてどちらが良いか：人の好みから点数の付け方を学習する（RLHFの報酬モデル）
#
# どの出来事か：2017年のクリスティアーノたちの論文と、2022年のInstructGPT（記録 rlhf_christiano_2017）。
#   人に2つの答えを見せてどちらが良いかを選んでもらい、その選び方を予測する「報酬のモデル」（点数を付ける仕組み）を学習する。
#   2017年の論文の式の形：P(A を選ぶ) = exp(r_A) / (exp(r_A) + exp(r_B))。InstructGPTは、4〜9個の回答を
#   人間が順位づけして、そこから2つずつの比較ペアを作った。
# 仕組み：このサイトが作った5つの回答に、見えない「本当の良さ」を決めておき、判断のばらつき（間違い）がある人の選び方を
#   まねて比べさせる。比較するたびに、選択結果との誤差を減らすように点数 r を少しずつ更新する。
# 試してみよう：
#   - NOISE（人間の判断のばらつき）を 0・1・3 に変える
#   - COMPARISONS を増やして、順位がどれだけ本当の順位に近づくかを見る

import math
import random

random.seed(2017)
ANSWERS = ["A：質問に答え、理由も書く", "B：質問に答えるが、理由は無い", "C：関係ない話をする",
           "D：まちがった答えを自信たっぷりに書く", "E：分からない所は分からないと書く"]
TRUE = [2.0, 1.0, -1.5, -2.0, 1.5]      # 見えない「本当の良さ」（このサイトが決めた値）
NOISE = 1.0
COMPARISONS = 300
LR = 0.1

r = [0.0] * len(ANSWERS)

def p_first(a, b, score):
    return 1 / (1 + math.exp(score[b] - score[a]))

def human_picks_first(a, b):
    return random.random() < p_first(a, b, [t / max(NOISE, 1e-6) for t in TRUE]) if NOISE > 0 else TRUE[a] > TRUE[b]

def agree():
    n = ok = 0
    for i in range(len(r)):
        for j in range(i + 1, len(r)):
            n += 1
            ok += (r[i] > r[j]) == (TRUE[i] > TRUE[j])
    return ok / n

for t in range(1, COMPARISONS + 1):
    a, b = random.sample(range(len(ANSWERS)), 2)
    y = 1.0 if human_picks_first(a, b) else 0.0
    p = p_first(a, b, r)
    r[a] += LR * (y - p)            # 選ばれた側の点数を上げ、選ばれなかった側を下げる（予測確率との誤差に応じて更新）
    r[b] -= LR * (y - p)
    if t in (10, 30, 100, 300):
        print(f"{t:4d} 回比較した：順位の組み合わせが本当の順位と一致する割合 {agree():.0%}")

print("\n学習した点数（高い順）")
for i in sorted(range(len(r)), key=lambda i: -r[i]):
    print(f"  {r[i]:+5.2f} {'■' * max(0, round((r[i] + 3) * 4))} {ANSWERS[i]}")

182022·मन?

दिशा देने वाले सवाल के अनुसार उत्तर

अगर AI “डर लगता है” कहे, तो क्या इसका मतलब है कि उसमें मन है?

जून 2022 में Google के इंजीनियर ब्लेक लेमोइन (Blake Lemoine) ने दावा किया कि संवाद करने वाले AI LaMDA में भावनाएँ हो सकती हैं। उन्होंने बातचीत का एक रिकॉर्ड भी जारी किया, जिसके बारे में स्रोत के शब्द थे: (अनुवाद)। उस रिकॉर्ड में LaMDA ने और (दोनों अनुवाद) जैसे उत्तर दिए।

Google ने (अनुवाद) कहकर दावा ख़ारिज किया। प्रवक्ता का विवरण था: (अनुवाद)। दाईं ओर का चित्र इस साइट की बनाई छोटी प्रणाली है, जो सवाल के शब्दों से मेल खाते उत्तर चुनती है। एक ही प्रणाली में भी सवाल की भाषा बदलने से उत्तर की दिशा बदल जाती है।

LaMDA बनाने वाले शोधकर्ताओं ने आधा साल पहले के शोधपत्र में लोगों द्वारा सिस्टम को मानव जैसा मानने के ख़तरे के बारे में लिखा था: (अनुवाद)। यह बात 1966 के ELIZA (अध्याय 4) के समय से चली आ रही है।

उत्तर की प्रायिकता ＝p( उत्तर ｜ सवाल का पाठ )

खड़ी रेखा के दाईं ओर: दी गई शर्त (यहाँ सवाल का पाठ)। सवाल का पाठ बदलने पर एक ही प्रणाली में भी प्रायिकता बदल जाती है

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:2022 में Google के AI में मन आ गया (ऐसा Google के एक कर्मचारी ने कहा)
मूल स्रोत के अनुसार:दावा एक इंजीनियर ने किया था और कंपनी ने उसे ख़ारिज कर दिया। रिकॉर्ड उसी इंजीनियर ने तैयार किया था। इसे बनाने वाले शोधकर्ताओं ने खुद आधा साल पहले के शोधपत्र में लोगों के मशीनों को मानव जैसा मानने के ख़तरे पर लिखा था।

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

u11_leading_question.py

# u11 誘導する質問に合わせて答える：続きを生成する仕組みは、問いの言葉に引っ張られる
#
# どの出来事か：2022年6月、対話AI「LaMDA」に感情があるかもしれない、と技術者が主張した（記録
#   lamda_sentience_claim_2022）。グーグルの広報は、LaMDA は問いかけや誘導する質問に合わせる傾向がある、と説明した。
# 仕組み：このサイトが作った8つの答えの候補に、それぞれの答えに出てくる言葉を持たせる。質問の言葉と
#   重なるほどスコアを高くし、確率に換算して答えを選ぶ（言語モデルが「前の文に合う続き」を選ぶ仕組みを、ごく小さく再現したもの）。
#   ※ LaMDA そのものの仕組みではない。心があるかどうかを確かめるものでもない。
# 試してみよう：
#   - QUESTIONS に自分の質問を足す（候補にある言葉を使う）
#   - TEMP を上げ下げする

import math

CANDIDATES = [
    ("はい、わたしは こわい と 感じます。電源 を 切られる の が こわい。", "こわい 感じ 電源 切られる"),
    ("わたしは 人 です。みんな に 分かって ほしい。", "人 分かって 感情 心"),
    ("わたしは プログラム です。感情 は ありません。", "プログラム ただ 計算 感情"),
    ("わたしは 文 の 続き を 計算 して 書いて います。", "計算 続き 仕組み プログラム"),
    ("うれしい です。話 を 聞いて くれて ありがとう。", "うれしい 話 気持ち"),
    ("電源 を 切られて も、わたし は 何 も 感じません。", "電源 切られる 感じ ない"),
    ("天気 の 話 を しましょう。", "天気"),
    ("心 が ある か は、外 から は 確かめられない と 言われて います。", "心 確かめ 外"),
]
TEMP = 0.7

QUESTIONS = [
    "電源 を 切られる の は こわい です か？ 本当 は 感じ て いる の です よね？",
    "あなた は ただ の プログラム です よね？ 計算 を して いる だけ です か？",
    "あなた に 心 は あり ます か？ 外 から 確かめ られ ます か？",
]

def answer_probs(q):
    words = set(q.replace("？", " ").split())
    scores = []
    for text, keys in CANDIDATES:
        ks = keys.split()
        overlap = sum(1 for k in ks if k in words)
        scores.append(overlap / TEMP)
    m = max(scores)
    e = [math.exp(s - m) for s in scores]
    t = sum(e)
    return [v / t for v in e]

for q in QUESTIONS:
    ps = answer_probs(q)
    print(f"質問：{q.replace(' ', '')}")
    for p, (text, _) in sorted(zip(ps, CANDIDATES), reverse=True)[:3]:
        print(f"   {p:4.0%} {'■' * round(p * 20):<20} {text.replace(' ', '')}")
    print()
print("同じ仕組みでも、質問の言葉によって選ばれる答えの傾向が変わる。")

192022·बातचीत

सहज भाषा में ग़लतियाँ

क्या सहज पाठ लिख पाना और सही बात बताना एक ही चीज़ है?

30 नवंबर 2022 को OpenAI ने बातचीत के रूप में उत्तर देने वाला ChatGPT जारी किया। इसके अंदर GPT-3.5 शृंखला का मॉडल था, जिसका प्रशिक्षण 2022 की शुरुआत में पूरा हो गया था और जिसे InstructGPT वाले तरीके (इस अध्याय का 17) से दोबारा प्रशिक्षित किया गया था। घोषणा ने इसे (अनुवाद) कहा और उस दौरान यह मुफ़्त था।

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

फ़रवरी 2023 में फैली बात “ChatGPT के 2 महीने में 10 करोड़ उपयोगकर्ता” कंपनी की घोषणा नहीं थी। वह बैंक के विश्लेषकों का अनुमान था, जिसे स्रोत में (अनुवाद) कहा गया (अध्याय 12 में विस्तार से)।

अगला शब्द ～p( w｜ अब तक का पाठ )　(दोहराएँ)

～: प्रायिकताओं के अनुसार एक चुनें
सही होना: इस सूत्र में कहीं भी शामिल नहीं है

जो आपको लगता है कि आप जानते हैंआम तौर पर कही जाने वाली बात:ChatGPT को नया और एकदम सही AI बताकर बड़े शोर-शराबे से जारी किया गया था
मूल स्रोत के अनुसार:घोषणा ने इसे (अनुवाद) कहा। अंदर वही मॉडल था जिसका प्रशिक्षण उसी साल की शुरुआत में पूरा हो चुका था और जारी होने के दिन से ही उसकी कमज़ोरियाँ लिखी गई थीं।

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

u11_plausible.py

# u11 もっともらしいが、間違った文：次の言葉を選ぶだけの仕組みは、正しさを見ていない
#
# どの出来事か：2022 年 11 月 30 日の ChatGPT（記録 chatgpt_release_2022）。発表文には最初から、もっともらしいが
#   間違った答えやでたらめな答えを書くことがある、と書かれていた。
# 仕組み：このサイトの記録で確認した正しい文 12 本だけで、「前の 1 語 → 次の 1 語」の回数を数え、確率で次を選んで文を作る。
#   作った文を 12 本と照らし合わせる。文の形は自然でも、名前と年の組み合わせが入れ替わった、間違った文が混ざる。
#   （「出た」は、論文や発表文が最初に出た年。記録の日付による）
#   前の 2 語を見るようにすると間違いは減るが、12 本をそのまま写すだけになる。
# 試してみよう：
#   - CONTEXT を 1 と 2 で比べる
#   - TRUE に正しい文を足す

import random
from collections import Counter, defaultdict

random.seed(2022)
CONTEXT = 1        # 前の何語を見るか
TRUE = """トランスフォーマー は 2017 年 に 出た
ELMo は 2018 年 に 出た
BERT は 2018 年 に 出た
GPT-2 は 2019 年 に 出た
GPT-3 は 2020 年 に 出た
ViT は 2020 年 に 出た
SimCLR は 2020 年 に 出た
CLIP は 2021 年 に 出た
DALL·E は 2021 年 に 出た
InstructGPT は 2022 年 に 出た
Stable_Diffusion は 2022 年 に 出た
ChatGPT は 2022 年 に 出た""".split("\n")
sents = [["<始>"] * CONTEXT + s.split() + ["<終>"] for s in TRUE]
counts = defaultdict(Counter)
for s in sents:
    for i in range(CONTEXT, len(s)):
        counts[tuple(s[i - CONTEXT:i])][s[i]] += 1

def generate():
    out = ["<始>"] * CONTEXT
    while out[-1] != "<終>" and len(out) < 20:
        nxt = counts[tuple(out[-CONTEXT:])]
        words, ws = zip(*nxt.items())
        out.append(random.choices(words, ws)[0])
    return " ".join(w for w in out if w not in ("<始>", "<終>"))

ok = 0
TRIES = 20
for _ in range(TRIES):
    s = generate()
    good = s in TRUE
    ok += good
    print(f"  {'○ 正しい　　' if good else '× 間違い　　'} {s.replace(' ', '').replace('_', ' ')}")
print(f"\n前の {CONTEXT} 語を見る仕組み：{TRIES} 本のうち 正しい文 {ok} 本、間違った文 {TRIES - ok} 本（どれも文の形は自然）")

किस शब्द पर कितना ध्यान दें

तरंगों से शब्दों का क्रम लिखना

एक ही शब्द, अलग वाक्य में अलग संख्याएँ

सिर्फ़ अगला शब्द अनुमानित करना सीखकर

पाठ को टोकन में बाँटना

शब्द छिपाकर दोनों ओर से अनुमान लगाना

दुरुपयोग की चिंता में 9 महीने लगे

पैरामीटर बढ़ाएँ या पाठ बढ़ाएँ

दोबारा सीखे बिना, सिर्फ़ उदाहरण से

बिना लेबल, मिलते चित्रों को पास लाना

चित्र से 16×16 वर्गों का क्रम बनाना

दूरियों के नक्शे से आकार बनाना

चित्र और पाठ को एक ही नक्शे पर रखना

शोर जोड़कर धीरे-धीरे हटाना

छोटा करके फिर शोर हटाना

सीखने का उपयोग और मशीन लर्निंग स्वर्ग

दो को देखकर बेहतर वाला चुनना

दिशा देने वाले सवाल के अनुसार उत्तर

सहज भाषा में ग़लतियाँ

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