第4次熱潮的開端

012017·Transformer

該看哪些詞，各看多少

句子裡詞與詞之間的關係，機器是怎麼用數字表示的？

2017年6月，Google的研究人員和多倫多大學的一名學生，共8人發表了Transformer的論文。上一章2014年的翻譯研究中誕生的注意力（attention），當時是和RNN（逐個依序讀詞的網路）搭配使用的。這篇論文不用RNN，只靠注意力建立網路。

每個詞都會產生3個向量（一組數）：負責尋找的查詢（Q）、被尋找的鍵（K）、帶有內容的值（V）。把查詢與所有詞的鍵做內積，除以 √d，再用softmax（讓所有數都為正且總和為1的計算）轉成權重，然後用這些權重把各個值混合起來。在右邊的圖裡按，粗線就會指向「魚」。論文把這個計算並排做了8份（多頭），讓每個頭可以看不同的關係。

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

Q, K, V: 把查詢、鍵、值的向量排列起來的矩陣
d_k: 鍵向量的長度（論文中為64）
圖中的一組組數: 本站手動設定的值

以為知道的事常見說法：這是為了製作聊天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年2月，艾倫人工智慧研究所和華盛頓大學的Peters等7人發表了 ELMo。

他們用大量文章訓練兩個LSTM（各2層）：一個從前往後讀、預測下一個詞，一個從後往前讀、預測前一個詞。詞的表示，是把各層內部的狀態，依照每項任務學到的權重加起來得到的。論文寫道，下層擅長辨識詞性，上層擅長辨別詞義（右邊的圖）。

在6項任務中，只要加上ELMo，每一項都超過了當時的最佳成績，錯誤最多減少了約20%。

ELMo_k ＝γ Σ_j s_j h_k,j

h_k,j: 讀到第k個詞時第j層的狀態
s_j: 每一層的權重（用softmax使總和為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年6月，OpenAI發表了這樣的做法：先讓一個12層的Transformer，用相當於7,000本書的文章學習猜下一個詞（預訓練）；然後用少量例子教它個別的任務。在測試的12項任務中，有9項超過了先前的最佳成績。

根據到目前為止的句子，算出下一個詞的機率的系統，叫做語言模型。反覆依機率選出下一個詞，就能寫出句子。這個想法很早就有了，1948年夏農的論文也是根據前面2個字母決定下一個字母的機率，產生了像英文的字母串。右邊的圖，是用本站紀錄裡的句子統計出的、從前面的字到下一個字的機率。前面的字數一開始為2個，可在1〜3個之間切換。把溫度調高，各個機率會變得比較接近；調低，選擇就會集中在機率高的字上。

第4次熱潮的不同之處在於：算出機率的是大型類神經網路（Transformer），而且用多得多的文章來學習。

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

z_i: 字i的分數（圖中是統計次數的對數）
T: 溫度
p_i: 選中字i的機率

以為知道的事常見說法：最初的GPT被稱為GPT-1
原始資料中：2018年6月的論文和發表文章裡，一次也沒有出現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·詞元

把句子切成詞元

語言模型是一個字一個字地讀，還是一個詞一個詞地讀？

語言模型處理的句子片段叫做詞元（token）。一個字一個字地切，序列會太長；一個詞一個詞地切，遇到詞典裡沒有的詞就麻煩了。GPT和GPT-2用的是位元組配對編碼（BPE）。一開始把文字拆成單個字元，找出文章裡最常相鄰的兩個，把它們合併成一個新詞元，如此反覆。在右邊的圖裡按「合併1次」試試看。

2018年的GPT用的是合併了4萬次的詞典。根據2019年GPT-2的論文，如果直接用文字（Unicode），合併之前的詞典就超過13萬。所以他們先把文字拆成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年10月，Google的4個人發表了 BERT。GPT是從左往右讀，猜下一個詞；而BERT選出句子中15%的詞元藏起來，同時以左右兩邊為線索去猜（被選中的位置裡，80%換成 [MASK]標記，10%換成別的詞，10%保持原樣）。論文寫道，這個想法受到1953年一種叫Cloze的填空測驗啟發。

右邊的圖裡有「我把 [MASK]喝了」。只看左邊，分不清是水、茶、麵包還是蘋果；看到右邊的「喝了」之後，就能縮小到飲料。

BERT用8億詞的書籍文章和25億詞的英文維基百科來學習，在11項任務上取得了最佳成績。2019年10月，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年2月，OpenAI發表了用40GB網路文章訓練的 GPT-2。參數（透過學習決定的數，本章的公式裡也稱為零件）有15億。他們擔心它被用來寫假文章等，表示（譯），於是只公開了小型模型和論文。他們還寫道：（譯）。

此後他們依大小逐步公開，11月公開最大的版本時寫道：（譯）。在右邊的圖裡調整月份看看。

零件數 ≈ 12 × 層數 × d² ＋詞典大小 × d＋位置數 × d

d: 向量的長度
12 × 層數 × d²: 主體部分的計數方式（2020年縮放定律論文）
整個加法: 本站的估算

以為知道的事常見說法：OpenAI做出了「危險到不能公開的AI」
原始資料中：發表文章裡沒有dangerous（危險）這個詞。當天《衛報》的標題是（譯）。9個月後，他們公開了全部版本。

參數量（每10倍一格的刻度）

082020·縮放定律

增加參數，還是增加文章？

只增加參數量，而學習用的文章不夠，會怎麼樣？

2020年1月，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¹³

以為知道的事常見說法：只要做大，就能無限變聰明，這就是定律
原始資料中：論文自己寫明了：終有一天必然會達到極限，而且對此沒有理論上的理解。

固定文章量、只增加參數量時的損失

092020·給出範例

不重新學習，只給幾個例子

教一項新任務，能不能不改變AI內部的數（權重）？

2020年5月，OpenAI的31個人發表了參數1,750億的 GPT-3。它是先前同類AI的10倍大，用3,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年2月，Google的Chen、辛頓等4人發表了把影像對比學習簡化整理的SimCLR。

對1張照片做兩次裁切、變色、模糊等處理，得到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·影像的Transformer

把影像變成16×16方塊的序列

要讓為文章設計的Transformer讀圖，該怎麼辦？

2020年10月，Google的Dosovitskiy等12人發表了 ViT（Vision Transformer）。他們把影像切成同樣大小的小方塊（patch），把每一塊變成一列向量，再加上位置向量，像文章裡的詞一樣送進Transformer。序列最前面還要加一個用來給出答案的標記。

論文訓練所用的影像是224×224。按16×16切，就成了196塊的序列。在右邊的圖裡把方塊調小，序列就變長，注意力的計算也變得更繁重（序列的長度與方塊邊長的平方成反比）。

只用ImageNet（約130萬張）訓練時，成績比上一章的CNN（卷積）的ResNet低幾個百分點。用1,400萬〜3億張圖預訓練後，就與CNN持平或超過，最好的模型達到88.55%。論文總結道：大規模學習，勝過了CNN一開始就具備的影像處理結構。

N＝H × W／P²

H, W: 影像的縱、橫像素數
P: 方塊的邊長
N: 序列的長度（方塊的數量）

以為知道的事常見說法：把影像切成小方塊送進Transformer的想法，是ViT最先提出的
原始資料中：提交給學術會議的最終版把Cordonnier等人（2020）列為最接近的研究，並補寫道，他們會從輸入影像中，而且（兩者皆為譯文）。論文認為自己新的地方在於：只要在大規模資料上預訓練，沒有特殊設計的Transformer也能與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預測胺基酸彼此之間的距離地圖。再根據這張地圖建立分數的公式，用梯度下降法一點一點修正形狀。

右邊的圖是把這個方法縮到最小的版本。一條形狀雜亂的鏈，會朝著符合左邊地圖（本站設定的數值）的方向移動。

兩年後CASP14（2020年）的AlphaFold 2，根據諾貝爾委員會的解說，是（譯）的。它不再用卷積，而改用Transformer的注意力，直接給出原子的位置。難題的分數，從約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的Radford等12人發表了 CLIP。他們用從網路上收集的4億組影像和說明文字，同時訓練兩個部分：把影像變成向量的部分，和把句子變成向量的部分。一次排出32,768組，讓正確配對的方向相近、其他配對的方向相遠（對比學習）。

右邊的圖是影像與句子相似程度（餘弦相似度）的表。按「學習」，正確配對所在的對角線就會變亮。學習之後，把類別名稱寫成A photo of a dog. 這樣的句子，只要選出最接近的句子就能分類（零樣本）。完全沒用ImageNet的訓練影像，就達到了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年，史丹佛大學等處的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年12月）也把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年12月，慕尼黑大學、海德堡大學和Runway的Rombach等人提出了潛在擴散模型。他們用自動編碼器（上一章；壓縮後再還原）把影像壓縮成潛在表示，再讓擴散模型在那裡運作。他們比較了1〜32的壓縮比例f，認為4〜16能兼顧速度和品質。

2022年8月的 Stable Diffusion 就是這個形式。根據說明文件，它把縱橫各縮小為8分之1，用CLIP的文字部分把句子變成向量，再透過注意力連接到去除雜訊的U-Net（上一章）上。在右邊的圖裡改變f看看。

誰能使用它，也在不到2年裡改變了。2021年1月的DALL·E只公開範例，2022年4月的DALL·E 2只開放給被選中的少數人。2022年8月的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分之1）

以為知道的事常見說法：Stable Diffusion是Stability AI這家公司做的
原始資料中：Stability AI自己的發表文章寫道：（譯）。

162017〜2022·日本

學習用途與機器學習天堂

對於AI從作品中學習，日本的法律是怎麼規定的？

2018年5月，日本的著作權法修正了（2019年1月施行）。新增的第30條之4規定，只要不是為了讓人欣賞、享受作品而使用，在必要的範圍內，不經著作權人許可就可以使用。它的標題是（譯）。不過也有但書：（譯）。在右邊的圖裡選擇使用方式，卡片就會停在第一道關卡，或前進到關卡2、3的判斷入口。

條文和國家的摘要裡都沒有AI這個詞。文化廳的解說網頁（2018年）舉的例子是（譯），隔年的文件則把（譯）放在成效舉例的第一位。早稻田大學的法學者上野達弘，從2017年起一直說明：（譯）。

2022年8月29日，日本AI mimic的測試版公開，只要讓它學習約15張自己的插畫，就能產生畫風相似的影像。隨後擔心別人的畫被擅自使用的聲音接連出現，隔天它就停掉了所有功能。

以為知道的事常見說法：日本是機器學習天堂，所以AI可以自由學習任何東西，生成的作品也都能自由使用
原始資料中：推廣這個詞的人，文章談的是學習階段的事。他在同一篇文章裡也寫了：只限於必要的範圍、有但書，以及生成的作品中如果留有原作的表達，著作權就會涉及。

2022年8月：海外與日本

172017→2022·人的偏好

兩個相比，哪個更好？

沒辦法用公式寫出好答案的評分方式時，怎麼辦？

強化學習（以得到更多分數＝獎勵為目標來學習行動的方法）不擅長處理無法用公式寫出評分方式的任務。2017年6月，OpenAI和DeepMind的Christiano等6人，把AI動作的兩段1〜2秒影片給人看，請人選出好的那一個。然後訓練一個能猜出這種選擇的獎勵模型（後來被稱為 RLHF）。機器人的後空翻，就是透過900次比較學會的。

在右邊的圖裡，依序按你認為好的答案。根據兩個分數之差算出人選這個答案的機率（下面的公式），再依結果調整分數。

2022年3月的InstructGPT（Ouyang等人）把它用到了GPT-3上：先用示範重新學習，再由4〜9個答案的排名建立獎勵模型，然後做強化學習（PPO）。參數13億的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回答「害怕」，就表示AI有心嗎？

2022年6月，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·對話

流暢的錯誤

能寫出流暢的文章，和傳達正確的內容，是一回事嗎？

2022年11月30日，OpenAI公開了以對話形式回答問題的 ChatGPT。它的核心，是用與InstructGPT相同的方法（本章第17個跨頁），重新訓練了2022年初完成學習的GPT-3.5系列模型。發表文章裡的稱呼是，在這段期間免費。

發表文章一開始就寫道：（譯），並說要改正（譯）。右邊的圖，是只用12條正確句子訓練出來的小系統。句子雖然流暢，但名字和年份的配對會張冠李戴。

2023年2月廣為流傳的「ChatGPT在2個月內達到1億使用者」，並不是公司的發表，而是銀行分析師的（譯）（第12章詳述）。

下一個詞～p( w｜到目前為止的句子 )　（反覆進行）

～: 依機率選出1個
正確性: 這個公式裡完全沒有

以為知道的事常見說法：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方塊的序列

從距離地圖，組出形狀

把圖和文放到同一張地圖上

加上雜訊，再一點一點去掉

先縮小，再去掉雜訊

學習用途與機器學習天堂

兩個相比，哪個更好？

順著引導性的提問回答

流暢的錯誤

這一章裡，還有哪些不知道的事