The Start of the Fourth Boom | All History of AI

012017 · The Transformer

Which words to look at, and how much

How does a machine turn the relationships between words in a sentence into numbers?

In June 2017, eight people from Google and the University of Toronto published the Transformer paper. Attention, born in the 2014 translation work of the previous chapter, had been used together with RNNs (networks that read words one at a time, in order). This paper dropped the RNN and built the network from attention alone.

For each word, three vectors (sets of numbers) are made: a query (Q) for the searching side, a key (K) for the side being searched, and a value (V) for the content. The dot product of the query with the keys of all the words is divided by √d, then turned into weights with a softmax (a calculation that makes every number positive and the total 1). The values are mixed using those weights. In the figure on the right, press "it" and a thick line points to "fish". The paper runs eight of these side by side (multi-head), so that each head can look at a different kind of relationship.

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

Q, K, V: matrices holding the query, key and value vectors
d_k: length of the key vector (64 in the paper)
the numbers in the model: values chosen by hand for this site

What you think you knowThe popular story:A paper for building conversational AI (chatbots)
The original source says:The paper tested translation and English constituency parsing. Its closing named extending the method to images, audio and video as the next goal, and conversation never appears in the text.

This is the same mechanism as "Try it", written as Python code. Press ▶ Run and the result appears below. Change the numbers and run it again.

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 · Positional encoding

Writing word order in as waves

Attention does not look at order. How can it tell "the cat chases the mouse" from "the mouse chases the cat"?

In the attention calculation, shuffling the order of the words does not change the weights. Because it does not read in order the way an RNN does, the position of each word has to be added separately.

The paper builds a vector from sin and cos waves of different periods for each position (the positional encoding) and adds it to the word's vector. The wave periods run from the shortest, 2π, to the longest, 10000·2π. Like the second hand and hour hand of a clock, fast waves tell nearby positions apart and slow waves tell distant ones apart. The graph below shows the dot product between a chosen position and every other position. When the gap between positions is the same, the value comes out almost the same wherever you are.

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

pos: position of the word
i: which wave
d: dimension of the vector (512 in the paper; 32 in the figure)

Dot product between the chosen position and the other positions

This is the same mechanism as "Try it", written as Python code. Press ▶ Run and the result appears below. Change the numbers and run it again.

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 · Context

One word, different numbers by context

"Play" can mean a play in baseball or a play on stage. Is one set of numbers per word enough?

word2vec (2013) and similar methods from the previous chapter gave each word a single vector. So "play" had the same vector in a baseball sentence and in a theater sentence. In February 2018, seven people including Matthew Peters of the Allen Institute for AI and the University of Washington introduced ELMo.

On a huge amount of text, it trains an LSTM that reads forward and predicts the next word and an LSTM that reads backward and predicts the previous word (two layers each). A word's representation is the internal states of every layer added together with weights learned for each task. The paper says the lower layers are better at parts of speech and the upper layers at telling word meanings apart (the figure on the right).

On each of six tasks, just adding ELMo beat the best results of the time, cutting errors by up to about 20%.

ELMo_k ＝γ Σ_j s_j h_k,j

h_k,j: state of layer j when reading the k-th word
s_j: weight for each layer (softmax, total 1)
γ: overall scale

What you think you knowThe popular story:ELMo was the first to represent words by their context
The original source says:The ELMo paper itself names 2017 work and CoVe as earlier examples, and says its own difference is using . Eight months later, the BERT paper called ELMo . The same method was called deep by its makers and shallow by the next paper.

This is the same mechanism as "Try it", written as Python code. Press ▶ Run and the result appears below. Change the numbers and run it again.

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 · Language models

Just by guessing the next word

What can a machine learn from text that has no correct answers attached?

In June 2018, OpenAI announced the following approach. First, a 12-layer Transformer is trained to guess the next word on text from 7,000 books (pretraining). Then it is taught each task with a few examples. It beat the best previous results on 9 of the 12 tasks tested.

A system that gives the probability of the word that comes next after the text so far is called a language model. Pick the next word by probability, again and again, and you get a sentence. The idea is old: Shannon's 1948 paper also decides the next letter from the probability given the previous two letters, and produces English-looking strings of letters. The figure on the right shows probabilities from the previous characters to the next 1 character, counted in the text of this site's records. The number of previous characters starts at 2 and can be switched from 1 to 3. Raise the temperature and the probabilities flatten out; lower it and choices concentrate on the more probable characters.

What is different in the fourth boom is that a large neural network (a Transformer) produces the probabilities, and that it learns from far more text.

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

z_i: score of character i (in the figure, the log of the count)
T: temperature
p_i: probability of choosing character i

What you think you knowThe popular story:It is called the first GPT (GPT-1)
The original source says:The word GPT never appears even once in the June 2018 paper or announcement. Four months later, Google's BERT paper calls it “Generative Pre-trained Transformer (OpenAI GPT)”. Where the name GPT-1 came from has not yet been confirmed.

This is the same mechanism as "Try it", written as Python code. Press ▶ Run and the result appears below. Change the numbers and run it again.

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 · Tokens

Cutting a sentence into tokens

Does a language model read a sentence one character at a time, or one word at a time?

The pieces of text a language model works with are called tokens. One character at a time makes the sequence too long; one word at a time causes trouble when a word is not in the dictionary. GPT and GPT-2 used byte pair encoding (BPE). It starts by splitting text into single characters, then merges the pair that sits side by side most often in the text into a new token. It repeats this. In the figure on the right, press "Merge once".

The 2018 GPT used a vocabulary built with 40,000 merges. According to the 2019 GPT-2 paper, working with characters (Unicode) directly would mean a base vocabulary of over 130,000 before any merging. So the text is split into single bytes (256 kinds) first, and BPE is applied to those, which brought the vocabulary to 50,257. The length it can read at once was also widened from 512 to 1,024 tokens.

the pair (a, b) that sits side by side most often → new token ab (repeat)

what is counted: how many times b appeared right after a in the text

The GPT-2 paper added a safeguard against merging across character types. It avoids the waste of the same word becoming separate tokens when it carries punctuation, as in dog. dog! dog?

Number of merges and number of tokens

This is the same mechanism as "Try it", written as Python code. Press ▶ Run and the result appears below. Change the numbers and run it again.

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 · Fill in the blank

Predicting a hole from both sides

What changes if, instead of the next word, the machine has to guess a hole in the middle of a sentence?

In October 2018, four people at Google introduced BERT. GPT read from left to right and guessed the next word. BERT instead chose 15% of the tokens in a sentence, hid them, and learned to guess them using both the left and the right as clues (of the chosen spots, 80% got a [MASK] marker, 10% got a different word, and 10% were left as they were). The paper says it drew inspiration from the Cloze test, a fill-in-the-blank test from 1953.

In the figure on the right, take "I drank [MASK]". Looking only at the left, the machine cannot tell water, tea, bread and apple apart. Once it sees the "drank" on the right, it narrows to drinks.

It was trained on 800 million words of books and 2.5 billion words of English Wikipedia, and set the best result on 11 tasks. In October 2019 Google began using it in Search, announcing that it would help with understanding .

loss＝ −Σ_{hidden spots} log p( true word｜words on the left and right )

p: probability the model outputs
hidden spots: 15% of the tokens chosen

This is the same mechanism as "Try it", written as Python code. Press ▶ Run and the result appears below. Change the numbers and run it again.

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 · Staged release

Released over 9 months, fearing misuse

What happened when its makers decided not to release the whole AI at once?

In February 2019, OpenAI announced GPT-2, trained on 40 GB of text from the internet. It has 1.5 billion parameters (numbers set by training; in this chapter's formula we also call them parts). Citing (for example fake articles), it released only a small model and the paper. It also wrote: .

After that it released larger and larger sizes in turn, and when the largest version came out in November it wrote: . Move the month in the figure on the right.

number of parts ≈ 12 × layers × d² ＋vocabulary size × d＋number of positions × d

d: length of the vector
12 × layers × d²: the count for the main body (from the 2020 scaling-laws paper)
the sum of everything: this site's estimate

What you think you knowThe popular story:OpenAI built an AI "too dangerous to release"
The original source says:The word "dangerous" does not appear in the announcement. The Guardian's headline that day was . Nine months later the whole thing was released.

Number of parameters (scale in steps of 10 times)

082020 · Scaling laws

Add parameters, or add text?

What happens if you only add parameters but there is not enough text to learn from?

In January 2020, ten people from OpenAI and Johns Hopkins University showed that as parameters, amount of text and amount of computation grow, the loss of a text AI (how hard the next word is to guess) falls according to a power law, and that this holds across more than 7 orders of magnitude (more in Chapter 12).

The paper also gave a formula in which both the number of parameters N and the amount of text D matter. If you increase only one, the improvement slows. The paper says that if you multiply the parameters by 8, you lose nothing by multiplying the text by about 5. In the figure on the right, press "8× N, 5× D".

This is one of the foundations of the expectation that bigger means smarter. But the authors themselves wrote: .

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

N: number of parameters
D: amount of text (number of tokens)
α_N, α_D: the paper's values 0.076 and 0.095
N_c, D_c: the paper's values 8.8×10¹³ and 5.4×10¹³

What you think you knowThe popular story:A law saying that the bigger you make it, the smarter it gets without limit
The original source says:The paper itself says that the trend must eventually level off, and that there is no theoretical understanding of it.

Loss when the amount of text is fixed and only the number of parameters is increased

092020 · Showing examples

Just show examples, with no retraining

Can you teach a new task without changing the numbers (weights) inside the AI?

In May 2020, 31 people at OpenAI announced GPT-3, with 175 billion parameters. It was 10 times the size of any similar AI before it and was trained on 300 billion tokens.

Instead of retraining for each task (changing the weights), you show a description of the task and a few examples inside the text and have it write the continuation. With no examples is zero-shot, with one is one-shot, with several is few-shot. The weights do not change. With this it handled translation, answering questions, 3-digit arithmetic and more. The figure on the right is a small mechanism made by this site (not the inside of GPT-3). It keeps only the rules that fit the examples, so the answer narrows as examples increase.

When people were asked to tell news articles written by GPT-3 from articles written by people, they were right 52% of the time, hardly different from guessing (50%).

the text shown＝task description＋example 1＋ … ＋example k＋question　→　write the continuation

k: number of examples shown
length read at once: 2,048 tokens (GPT-3)

Number of parameters (scale in steps of 10 times; the numbers in the records)

This is the same mechanism as "Try it", written as Python code. Press ▶ Run and the result appears below. Change the numbers and run it again.

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 · Self-supervised learning

No labels: pull similar images together

Can a machine learn features useful for recognition from photos without correct labels attached?

Self-supervised learning is a way of learning with no human-made correct answers (labels), using problems made from the data itself. Guessing the next word and filling in blanks belong to this family. In February 2020, four people at Google, including Ting Chen and Geoffrey Hinton, announced SimCLR, a simplified take on contrastive learning for images.

Apply two rounds of editing to one photo, such as cropping, color changes and blurring, to make a correct pair of two images. The model is trained so that this pair comes out close together (high cosine similarity) and far from other photos. In the figure on the right, press "Keep learning".

On features learned with no answers, training only a simple classification layer with answers gave 76.5% on ImageNet. That matches a ResNet-50 trained with answers.

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

z: feature vector of a photo
(i, j): a pair made from the same photo
sim: cosine similarity
τ: temperature parameter

What you think you knowThe popular story:SimCLR started contrastive learning, which learns images without answers
The original source says:The paper itself says , and its first example of contrastive learning is a 2006 paper from New York University. That paper wrote that .

Loss (by number of training rounds)

This is the same mechanism as "Try it", written as Python code. Press ▶ Run and the result appears below. Change the numbers and run it again.

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 · Transformers for images

Turning an image into 16×16 squares

How can you get a Transformer built for text to read pictures?

In October 2020, 12 people at Google, including Alexey Dosovitskiy, introduced ViT (Vision Transformer). It cuts an image into small squares (patches) of equal size and turns each one into a single row of numbers (a vector). A position vector is added, and the patches go into the Transformer just like the words of a sentence. One extra marker is added at the front, to produce the answer.

The images the paper used for training were 224×224. Cutting them into 16×16 pieces gives a sequence of 196 patches. In the figure on the right, make the squares smaller and the sequence gets longer and the attention calculation heavier (the length of the sequence is inversely proportional to the square of a patch's side).

Trained on ImageNet alone (about 1.3 million images), it scored a few points below the CNN (convolutional) ResNet of the previous chapter. Pretrained on 14 million to 300 million images, it matched or beat CNNs, and the best model reached 88.55%. The paper summed it up this way: large-scale training beats the image-specific built-in structure that CNNs start with.

N＝H × W／P²

H, W: height and width of the image in pixels
P: length of a side of a square
N: length of the sequence (number of squares)

What you think you knowThe popular story:ViT was the first to cut an image into small squares and feed them to a Transformer
The original source says:The final version submitted to the conference names Cordonnier et al. (2020) as the closest work, and added that it and that . What the paper claimed as new was showing that, with pretraining on large-scale data, a plain Transformer with no special tricks can match CNNs.

This is the same mechanism as "Try it", written as Python code. Press ▶ Run and the result appears below. Change the numbers and run it again.

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 · Proteins

Building a shape from a map of distances

Can the 3D structure of a protein be predicted from the sequence of amino acids alone?

It is not an AI that writes text or draws pictures, but around the same time, AI as a tool for science also advanced greatly. A protein's shape is decided when a chain of amino acids folds up. At the 2018 structure-prediction contest CASP13, DeepMind's first AlphaFold used a CNN to predict a map of the distances between amino acids. From that map it built a scoring formula and used gradient descent to adjust the shape little by little.

The figure on the right is this method in its smallest form. A chain in a random shape moves to fit the map on the left (numbers chosen by this site).

Two years later, at CASP14 (2020), AlphaFold 2 was, according to the Nobel Committee's explanation, . It dropped convolution, used Transformer attention, and produced atom positions directly. The score on the hard problems rose from about 60% to about 90%.

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

x_i: position of the i-th amino acid
d_ij: distance on the map
η: step size for moving (learning rate)
the real scoring formula: a different form from this squared error

What you think you knowThe popular story:AI solved the mystery of protein folding
The original source says:The paper itself draws the line at .

Total error E (scale in steps of 10 times)

This is the same mechanism as "Try it", written as Python code. Press ▶ Run and the result appears below. Change the numbers and run it again.

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 · Pictures and text

Pictures and text on one map

Take a photo of a dog and a sentence describing it. Can we measure with a number how well they match?

In 2021, 12 people at OpenAI, including Alec Radford, introduced CLIP. On 400 million pairs of images and captions collected from the internet, it trains a part that turns images into vectors and a part that turns text into vectors at the same time. It lays out 32,768 pairs at once and learns so that correct pairs point in nearby directions and the others point far apart (contrastive learning).

The figure on the right is a table of how similar each image and sentence are (cosine similarity). Press "Learn" and the diagonal of correct pairs lights up. After training, you can classify by turning each category name into a sentence like "A photo of a dog." and choosing the closest sentence (zero-shot). It got 76.2% on ImageNet without using a single one of ImageNet's training images.

similarity＝cos(u_i, v_j)＝u_i · v_j ／ ( |u_i| |v_j| )

u: image vector
v: text vector
direction of the loss: both by row (image→text) and by column (text→image)

What you think you knowThe popular story:CLIP is an AI that makes pictures
The original source says:CLIP does not make pictures. It is a model that measures how well an image and a sentence match.

Loss (by number of training rounds)

This is the same mechanism as "Try it", written as Python code. Press ▶ Run and the result appears below. Change the numbers and run it again.

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 · Diffusion models

Add noise, then remove it bit by bit

Can a picture be made from plain noise?

In 2015, Jascha Sohl-Dickstein and colleagues at Stanford University and elsewhere presented a method . It adds small amounts of Gaussian noise (random numbers from a normal distribution) to data again and again until its shape is destroyed, and has a neural network learn each step of the reverse direction.

The figure on the right shows the same spiral of points as in the 2015 paper. Advance t and it turns to fog; press "Generate from noise" and the noise is removed one step at a time, and the shape returns.

In 2020, the DDPM paper by three people including Jonathan Ho at Berkeley says that for diffusion models . It then showed that high-quality images can be made, with a 1,000-step process and training to guess the added noise itself.

x_t ＝ √ᾱ_t x₀ ＋ √(1 − ᾱ_t) ε　　what is learned: guess ε from x_t

x₀: the original data
ε: the noise added
ᾱ_t: the fraction of the original remaining at step t (from 1 to 0)

What you think you knowThe popular story:Diffusion models are a new method born around the time of Stable Diffusion
The original source says:The idea itself is in the 2015 paper. The original Stable Diffusion paper (December 2021) also cites the 2015 paper as the source of diffusion models.

Fraction of the original remaining at step t, ᾱ

This is the same mechanism as "Try it", written as Python code. Press ▶ Run and the result appears below. Change the numbers and run it again.

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 · Image-generating AI

Shrink first, then remove the noise

Isn't it too heavy to add noise to a 512×512 image directly and then remove it?

In December 2021, Robin Rombach and colleagues at Ludwig Maximilian University of Munich, Heidelberg University and Runway introduced the latent diffusion model. A picture is shrunk into a latent representation by an autoencoder (from the previous chapter: shrink, then restore), and the diffusion model runs there. They compared shrink ratios f from 1 to 32 and found 4 to 16 a good balance of speed and quality.

Stable Diffusion, in August 2022, takes this form. According to its documentation, it shrinks height and width to one eighth, turns the text into vectors with CLIP's text part, and connects it by attention to the U-Net (previous chapter) that removes the noise. Change f in the figure on the right.

Who could use it also changed in less than two years. DALL·E in January 2021 only published sample images; DALL·E 2 in April 2022 was open only to a small, selected group of people. Stable Diffusion in August 2022 was released in a form where anyone could download the trained model and run it on their own computer (with limits on use, and commercial use allowed).

number of latents＝ (H／f) × (W／f) × c

H, W: height and width of the image in pixels
f: shrink ratio (8 in Stable Diffusion)
c: numbers per spot (4)
amount of numbers: 512×512×3＝786,432 → 64×64×4＝16,384 (1/48)

What you think you knowThe popular story:Stable Diffusion was made by a company called Stability AI
The original source says:Stability AI's own announcement says it was .

162017–2022 · Japan

Learning from works, and the "paradise"

How did Japanese law decide how AI may learn from works?

In May 2018, Japan's Copyright Act was revised (in force from January 2019). It created Article 30-4: use that is not for people to enjoy a work can, within the necessary scope, be used without the permission of the copyright holder. Its heading is (translated). It has a proviso: (translated). In the figure on the right, choose a way of using a work and the card stops at the first gate or moves on to the decision point for gates 2 and 3.

The text of the article and the government's summary contain no words about AI. The Agency for Cultural Affairs' explanation page (2018) gave as an example (translated), and a document the next year put (translated) first among its examples of the effect. Tatsuhiro Ueno, a legal scholar at Waseda University, has explained since 2017: (translated).

On August 29, 2022, the beta version of mimic was released, a Japanese AI that makes images in a similar style after learning from about 15 of your own illustrations. Worried voices that other people's pictures would be used without permission followed one after another, and the next day all its functions were stopped.

What you think you knowThe popular story:Japan is a machine learning paradise, so AI can learn anything freely and what it produces is free too
The original source says:The writing of the person who spread the phrase is about the learning stage. The same text also says the use must stay within the necessary scope, that there is a proviso, and that copyright still reaches the output if the original expression remains in it.

August 2022: overseas and Japan

172017→2022 · Human preference

Compare two, pick which is better

What do you do when you can't write the scoring of a good answer as a formula?

Reinforcement learning (a way of learning actions that earn more points, called reward) had trouble with tasks where the scoring cannot be written as a formula. In June 2017, six people from OpenAI and DeepMind, including Paul Christiano, showed people two 1–2 second clips of an AI's movement and asked them to pick the better one. They trained a reward model to predict those choices (later called RLHF). A robot learned a backflip from 900 comparisons.

In the figure on the right, keep pressing the answer you think is better. From the difference between the two scores, the probability that a person picks one is worked out (the formula below), and the scores are adjusted to fit the results.

InstructGPT in March 2022 (Long Ouyang and colleagues) applied this to GPT-3. It was retrained on demonstrations, a reward model was built from rankings of 4 to 9 answers, and then reinforcement learning (PPO) was run. The answers of the 1.3-billion-parameter InstructGPT were preferred over those of the 100-times-larger GPT-3.

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

P(A): probability that a person picks A
r: score from the reward model
answers in the model: five made by this site (the true quality is also set by this site)

What you think you knowThe popular story:RLHF was invented for ChatGPT
The original source says:What was tried in 2017 was games and robot movements. The paper does not use the name either.

Share of ranked pairs that agree with the true order of quality

This is the same mechanism as "Try it", written as Python code. Press ▶ Run and the result appears below. Change the numbers and run it again.

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 · A mind?

Answering to fit a leading question

If an AI answers "scary", does that mean the AI has a mind?

In June 2022, Google engineer Blake Lemoine claimed that the conversational AI LaMDA might have feelings. He also published a record in which, in the words of the source, . In it LaMDA said things like and .

Google rejected the claim: . The spokesperson explained: . The figure on the right is a small mechanism made by this site that picks answers fitting the words of the question. With the same mechanism, how the question is written changes which way the answer goes.

The researchers who built LaMDA had written, in a paper half a year earlier, of the risk that people end up . It is a story that goes back to ELIZA in 1966 (Chapter 4).

probability of an answer＝p( answer｜question text )

right of the vertical bar: the given condition (here, the question text). If the question text changes, the probability changes even with the same mechanism

What you think you knowThe popular story:In 2022, a mind came to live in Google's AI (said a Google employee)
The original source says:The claim was made by one engineer, and the company rejected it. The record was compiled by the engineer himself. The researchers who built it had themselves written, in a paper half a year earlier, of the risk that people anthropomorphize machines.

This is the same mechanism as "Try it", written as Python code. Press ▶ Run and the result appears below. Change the numbers and run it again.

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 · Conversation

Smooth mistakes

Is being able to write smooth text the same as telling the truth?

On November 30, 2022, OpenAI released ChatGPT, which answers in conversation form. Inside is a model from the GPT-3.5 series, which finished training in early 2022, retrained with the same method as InstructGPT (spread 17 of this chapter). The announcement called it a , and it was free during that time.

From the start the announcement said that it , and said . The figure on the right is a small mechanism trained on just 12 correct sentences. The sentences are smooth, but the pairs of names and years get swapped.

The claim that spread in February 2023, "ChatGPT reached 100 million users in 2 months", was not a company announcement but a bank analyst's number, which in the sources' wording (more in Chapter 12).

next word～p( w｜the text so far )　(repeat)

～: choose one according to the probabilities
correctness: not included anywhere in this formula

What you think you knowThe popular story:ChatGPT was launched with great fanfare as a new, perfect AI
The original source says:The announcement called it a . Inside was a model that had finished training earlier the same year, and it listed its weaknesses from the day of release.

This is the same mechanism as "Try it", written as Python code. Press ▶ Run and the result appears below. Change the numbers and run it again.

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} 本（どれも文の形は自然）")

Which words to look at, and how much

Writing word order in as waves

One word, different numbers by context

Just by guessing the next word

Cutting a sentence into tokens

Predicting a hole from both sides

Released over 9 months, fearing misuse

Add parameters, or add text?

Just show examples, with no retraining

No labels: pull similar images together

Turning an image into 16×16 squares

Building a shape from a map of distances

Pictures and text on one map

Add noise, then remove it bit by bit

Shrink first, then remove the noise

Learning from works, and the "paradise"

Compare two, pick which is better

Answering to fit a leading question

Smooth mistakes

What this chapter still doesn't know