第4次ブームのはじまり

012017・トランスフォーマー

どの言葉を、どれだけ見るか

文の中の言葉どうしの関係を、機械はどうやって数で表すのか。

2017年6月、グーグルの研究者たちとトロント大学の学生の8人が、トランスフォーマーの論文を発表した。前の章の2014年の翻訳で生まれた注意（アテンション）は、RNN（言葉を1つずつ順に読むネットワーク）と一緒に使われていた。この論文はRNNを使わず、注意だけでネットワークを組み立てた。

言葉ごとに、探す側の問い（Q）、探される側の鍵（K）、中身の値（V）という3つのベクトル（数の組）を作る。問いと、すべての言葉の鍵との内積を √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は、野球のプレーにも劇にもなる。1つの単語に1つの数の組で足りるのか。

前の章のword2vec（2013）などは、1つの単語に1つのベクトルを割り当てた。そのためplayは、野球の文でも劇の文でも同じベクトルだった。2018年2月、アレン人工知能研究所とワシントン大学のピーターズたち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年6月、OpenAIは次のやり方を発表した。まず12層のトランスフォーマーに、本7,000冊分の文章で次の言葉を当てる学習（事前学習）をさせる。そのあと、少しの例で個々の課題を教える。調べた12の課題のうち9つで、それまでの最高を上回った。

ここまでの文の次に来る言葉の確率を出す仕組みを言語モデルという。確率で次を選ぶことを繰り返すと、文ができる。考え方は古く、1948年のシャノンの論文も、前の2文字から次の文字の確率を決めて、英語らしい文字の並びを作っている。右の図は、このサイトの記録の文で数えた、前の字から次の1字への確率。前の字数は、初めは2字で、1〜3字に切り替えられる。温度を上げると確率がならされ、下げると確率の高い字に選択が集中する。

第4次の違いは、確率を出すのが大きなニューラルネットワーク（トランスフォーマー）で、ずっと多くの文章で学習することだ。

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

z_i: 字iのスコア（図では数えた回数の対数）
T: 温度
p_i: 字iを選ぶ確率

知ってるつもりよく言われる話：最初のGPT（GPT-1）と呼ばれる
元の資料では：2018年6月の論文と発表文には、GPTという言葉が1度も出てこない。4か月後のグーグルのBERTの論文が「Generative Pre-trained Transformer（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・トークン

文をトークンに分ける

言語モデルは、文を1字ずつ読むのか、1語ずつ読むのか。

言語モデルが扱う文の切れはしをトークンという。1字ずつでは列が長くなり、1語ずつでは辞書に無い語が出た時に困る。GPTやGPT-2が使ったのはバイトペア符号化（BPE）だ。最初は1字ずつに分け、文章の中で最も多く隣り合う2つをくっつけて新しいトークンにする。これを繰り返す。右の図で「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月、グーグルの4人は BERT（バート） を発表した。GPTは左から右へ読んで次の言葉を当てた。一方BERTは、文のトークンの15%を選んで隠し、左右両方を手がかりに当てる学習をした（選んだ所の80%は [MASK]の印、10%は別の言葉、10%はそのまま）。論文は、1953年のClozeという穴埋めテストから着想を得たと書く。

右の図の「ぼくは [MASK]をのんだ」で、左だけでは、みず・おちゃ・パン・りんごを区別できない。右の「をのんだ」まで見ると、飲み物に絞れる。

本の文章8億語と英語のウィキペディア25億語で学習し、11の課題で最高の成績を出した。2019年10月にはグーグル検索で使い始め、アメリカの英語の検索の（訳）の理解に役立つと発表した。

損失＝ −Σ_隠した所 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倍」を押してみよう。

大きくすればもっと賢くなる、という期待の土台の1つがこれだ。ただし著者自身が（訳）と書いている。

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月、グーグルのチェン、ヒントンたち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年10月、グーグルのドソヴィツキーたち12人は ViT（Vision Transformer）を発表した。画像を同じ大きさの小さな四角（パッチ）に切り、1枚ずつを1列のベクトルに直す。そこに位置のベクトルを足し、文章の単語と同じようにトランスフォーマーに入れる。先頭には、答えを出すための印を1つ足す。

論文が学習に使った画像は224×224。16×16で切ると196枚の列になる。右の図で四角を小さくすると、列が長くなり、注意の計算が重くなる（列の長さは、四角の1辺の2乗に反比例）。

ImageNet（約130万枚）だけで学習させると、前の章のCNN（畳み込み）のResNetより数ポイント低かった。1,400万〜3億枚で事前学習させるとCNNに並ぶか上回り、最も良いモデルは88.55%。論文は、大規模な学習が、CNNが初めから持つ画像向けの仕組みに勝る、とまとめた。

N＝H × W／P²

H, W: 画像の縦と横の画素数
P: 四角の1辺の長さ
N: 列の長さ（四角の数）

知ってるつもりよく言われる話：画像を小さな四角に切ってトランスフォーマーに入れる考えはViTが最初
元の資料では：学会に出した最終版は、最も近い研究としてコルドニエたち（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: 地図の距離
η: 動かす歩幅（学習率）
本物の点数の式: この2乗誤差とは別の形

知ってるつもりよく言われる話：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のラドフォードたち12人は CLIP を発表した。ネットから集めた4億組の画像と説明文で、画像をベクトルに直す部分と、文をベクトルに直す部分を同時に学習させる。一度に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年、スタンフォード大学などのソール＝ディックスタインたちは、物理学の非平衡統計力学から（訳）方法を発表した。データに小さなガウス雑音（正規分布の乱数）を何度も足して形を壊し、その逆向きの1歩ずつをニューラルネットワークに学習させる。

右の図は、2015年の論文の図と同じ渦巻きの点。tを進めると霧になり、「雑音から作る」を押すと、1歩ずつ雑音が取れて形が戻る。

2020年、バークレー校のホーたち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のロンバッハたちは、潜在拡散モデルを出した。絵をオートエンコーダー（前の章。縮めて戻す）で潜在表現に縮め、そこで拡散モデルを動かす。縮める割合fは1〜32を比べ、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: 1か所あたりの数（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日、自分のイラストを15枚ほど学習させると似た絵柄の画像を作る日本のAI、mimicのベータ版が公開された。他人の絵が無断で使われるのでは、という心配の声が相次ぎ、翌日、すべての機能を止めた。

知ってるつもりよく言われる話：日本は機械学習パラダイスだから、AIは何でも自由に学習でき、生成物も自由
元の資料では：言葉を広めた本人の文章は、学習段階の話だ。必要な範囲に限ること・但し書きがあること・生成物に元の表現が残れば著作権が及ぶことも、同じ文章の中で書いている。

2022年8月：海外と日本

172017→2022・人の好み

2つを比べて、どちらが良いか

良い答えの点数の付け方を、式で書けない時はどうするか。

強化学習（もらえる点数＝報酬が多くなるように行動を学ぶ方法）は、点数の付け方を式で書けない課題が苦手だった。2017年6月、OpenAIとDeepMindのクリスティアーノたち6人は、AIの動きの1〜2秒の動画を2つ人に見せ、良い方を選んでもらった。その選び方を当てる報酬モデルを学習させた（のちに RLHF と呼ばれる）。ロボットの後ろ宙返りは、900回の比較で覚えた。

右の図で、良いと思う答えを押していこう。2つの点数の差から、人がこちらを選ぶ確率を出し（下の式）、結果に合うように点数を直す。

2022年3月のInstructGPT（オウヤンたち）は、これを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月、グーグルの技術者ブレイク・ルモワンは、会話AIのLaMDAに感情があるかもしれないと主張した。会話を（訳）記録も公開した。記録の中でLaMDAは、（どちらも訳）などと答えていた。

グーグルは（訳）と退けた。広報の説明は（訳）。右の図は、このサイトが作った、問いの言葉に合う答えを選ぶ小さな仕組み。同じ仕組みでも、問いの書き方で答えの向きが変わる。

LaMDAを作った研究者たちは、半年前の論文で、人が（訳）おそれを書いていた。1966年のELIZA（4章）の時代から続く話だ。

答えの確率＝p( 答え｜問いの文 )

縦線の右側: 与えられた条件（ここでは問いの文）。問いの文が変われば、同じ仕組みでも確率が変わる

知ってるつもりよく言われる話：2022年、グーグルのAIに心が宿った（とグーグルの社員が言った）
元の資料では：主張したのは技術者1人で、会社は退けた。記録は本人がまとめたもの。作った研究者たち自身が、人が機械を擬人化するおそれを、半年前の論文に書いていた。

「さわってみる」と同じ仕組みを、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 を公開した。中身は、2022年の初めに学習を終えたGPT-3.5系列のモデルを、InstructGPTと同じ方法（この章の17）で学習し直したもの。発表文の呼び方はで、その間は無料だった。

発表文は最初から（訳）と書き、直すのは（訳）とした。右の図は、正しい文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の四角の列にする

距離の地図から、形を組み立てる

絵と文を、同じ地図に置く

雑音を足して、少しずつ取り除く

小さく縮めてから、雑音を取る

学習のための利用と機械学習パラダイス

2つを比べて、どちらが良いか

誘導する問いに合わせて答える

なめらかな間違い

この章で、まだ分かっていないこと