第4次热潮的开端

012017・Transformer

该看哪些词，各看多少

句子里词与词之间的关系，机器是怎样用数字表示的？

2017年6月，谷歌的研究人员和多伦多大学的一名学生，共8人发表了Transformer的论文。上一章2014年的翻译研究中诞生的注意力（attention），当时是和RNN（逐个读词的网络）搭配使用的。这篇论文不用RNN，只靠注意力搭起了整个网络。

每个词都生成3个向量（一组数）：负责查找的查询（Q）、被查找的键（K）、携带内容的值（V）。把查询与所有词的键做内积，除以 √d，再用softmax（让所有数都为正且总和为1的计算）变成权重，然后用这些权重把各个值混合起来。在右边的图里点，粗线就会指向“鱼”。论文把这个计算并排做了8份（多头），让每个头可以看不同的关系。

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

Q, K, V: 把查询・键・值的向量排列起来的矩阵
d_k: 键向量的长度（论文中为64）
图中的数组: 本站手工设定的值

常见说法常见说法：这是为制作聊天AI而写的论文
原始资料里：论文试验的是翻译和英语句法分析。结尾提出的下一个目标也是扩展到图像、声音、视频，正文里没有出现对话的内容。

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u11_attention.py

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

import math

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

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

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

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

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

022017・位置编码

把词的顺序写成波

注意力的计算不看顺序。“猫追老鼠”和“老鼠追猫”该怎么区分？

在注意力的计算里，即使把词的顺序调换，权重也不会变。它不像RNN那样按顺序读，所以必须另外补上“这是第几个词”的信息。

论文给每个位置造了一个向量（位置编码），由周期各不相同的sin和cos波的值排列而成，再加到词的向量上。波的周期，最短是2π，最长是10000・2π。就像钟表的秒针和时针一样，用快波区分近处，用慢波区分远处。下面的图表是选定位置与其他位置的内积。只要位置之差相同，不管在哪里，值都几乎一样。

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

pos: 词的位置
i: 第几个波
d: 向量的维数（论文中为512，图中为32）

选定位置与其他位置的向量内积

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u11_position.py

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

import math

D = 16

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

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

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

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

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

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

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

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

032018・上下文

同一个词，在不同的句子里数值不同

play既可以是棒球的比赛动作，也可以是戏剧。一个词只用一组数够吗？

上一章的word2vec（2013）等方法，给一个词只分配一个向量。所以play无论出现在棒球的句子里还是戏剧的句子里，向量都是同一个。2018年2月，艾伦人工智能研究所和华盛顿大学的彼得斯等7人发表了 ELMo。

他们用大量文章训练两个LSTM（各2层）：一个从前往后读、预测下一个词，一个从后往前读、预测前一个词。词的表示，是把各层内部的状态按每个任务学习出的权重加起来得到的。论文写道，下层擅长词性，上层擅长辨别词义（右边的图）。

在6项任务中，只要加上ELMo，每一项都超过了当时的最好成绩，错误最多减少了约20%。

ELMo_k ＝γ Σ_j s_j h_k,j

h_k,j: 读到第k个词时第j层的状态
s_j: 每一层的权重（用softmax使总和为1）
γ: 整体的大小

常见说法常见说法：随上下文改变含义的词的表示，ELMo是最早的
原始资料里：ELMo的论文自己就把2017年的研究和CoVe列为先例，并写道，自己的不同之处在于使用了（译）。8个月后，BERT的论文把ELMo称为（译）。同一种方法，作者称之为深，下一篇论文却称之为浅。

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u11_context_vectors.py

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

import math

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

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

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

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

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

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

042018・语言建模

只靠“猜下一个词”来学习

没有标注正确答案的文章，机器能从中学到什么？

2018年6月，OpenAI发表了这样的做法：先让一个12层的Transformer，用相当于7,000本书的文章学习猜下一个词（预训练）；然后用少量例子教它具体的任务。在所调查的12项任务中，有9项超过了此前的最好成绩。

给出到目前为止的句子之后，算出下一个词的概率的系统，叫作语言建模（language model）。反复按概率选出下一个词，就能写出句子。这个想法很古老，1948年香农的论文也是根据前面2个字母决定下一个字母的概率，造出了像英语的字母串。右边的图，是用本站记录里的句子统计出的“由前面的字推出下一个字”的概率。前面的字数初始为2个，可在1〜3个之间切换。把温度调高，概率会被拉平；调低，选择就会集中在概率高的字上。

第4次热潮的不同之处在于：算出概率的是大型神经网络（Transformer），而且用多得多的文章来学习。

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

z_i: 字i的得分（图中是统计次数的对数）
T: 温度
p_i: 选中字i的概率

常见说法常见说法：最初的GPT被称为GPT-1
原始资料里：2018年6月的论文和发布文章里，一次也没有出现GPT这个词。4个月后，谷歌的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・词元

把句子切成词元

语言建模系统是一个字一个字地读，还是一个词一个词地读？

语言建模系统处理的句子碎片叫作词元（token）。一个字一个字地切，序列会太长；一个词一个词地切，遇到词典里没有的词就麻烦了。GPT和GPT-2用的是字节对编码（BPE）。一开始把文本拆成单个字符，找出文章里最常相邻的两个，把它们合并成一个新词元，如此反复。在右边的图里点“合并1次”试试吧。

2018年的GPT用的是合并了4万次的词典。据2019年GPT-2的论文，如果直接用文字（Unicode），合并之前的词典就超过13万。所以他们先把文字拆成1个字节（256种）一个，再做BPE，把词典定为50,257个。一次能读的长度，也从512个词元扩大到了1,024个。

最常相邻的一对 (a, b) → 新词元ab（反复进行）

计数的对象: 文章里a后面紧跟着b出现的次数

GPT-2的论文加了一个办法：不跨字符种类合并。这是为了避免dog. dog! dog? 这样，同一个词因为带了不同的符号而变成不同词元的浪费。

合并次数与词元数

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u11_bpe.py

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

from collections import Counter

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

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

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

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

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

062018・填空

挖个洞，从前后两边来预测

不猜下一个词，而是让机器猜句子中间的空缺，会有什么不同？

2018年10月，谷歌的4个人发表了 BERT。GPT是从左往右读，猜下一个词；而BERT选出句子中15%的词元藏起来，同时以左右两边为线索去猜（被选中的位置里，80%换成 [MASK]标记，10%换成别的词，10%保持原样）。论文写道，这个想法受到了1953年一种叫Cloze的填空测验的启发。

右边的图里有一个句子（ぼくは [MASK]をのんだ，意为“我喝了 [MASK]”）。只看左边，分不清是水、茶、面包还是苹果；看到右边的“喝了”之后，就能缩小到饮料。

BERT用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”试试吧。

“越大就越聪明”这种期待，它是其中一块基石。不过作者自己写道：（译）。

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张“正确的一对”。训练的目标是让这一对靠近（余弦相似度变大），同时与其他照片远离。在右边的图里点“继续学习”试试吧。

在没有正确答案时学到的特征之上，只用带答案的数据训练一个简单的分类层，在ImageNet上达到了76.5%。这与用带答案的数据训练的ResNet-50不相上下。

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

z: 照片的特征向量
(i, j): 由同一张照片生成的一对
sim: 余弦相似度
τ: 温度参数

常见说法常见说法：没有正确答案也能学习图像的对比学习，是SimCLR开创的
原始资料里：论文自己写道（译），并且在列举对比学习的例子时，第一个就是 2006年纽约大学的论文。那篇论文写的是（译）。

损失（按学习次数）

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u11_contrastive.py

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

import math
import random

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

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

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

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

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

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

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

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

112020・图像的Transformer

把图像变成16×16方块的序列

要让为文章设计的Transformer读图画，该怎么办？

2020年10月，谷歌的多索维茨基等12人发表了 ViT（Vision Transformer）。他们把图像切成同样大小的小方块（patch），把每一块变成一列向量，再加上位置向量，像文章里的词一样送进Transformer。队列最前面还要加一个用来给出答案的标记。

论文学习所用的图像是224×224。按16×16切，就成了196块的序列。在右边的图里把方块调小，序列就变长，注意力的计算也变重（序列的长度与方块边长的平方成反比）。

只用ImageNet（约130万张）训练时，成绩比上一章的CNN（卷积）类ResNet低几个百分点。用1,400万〜3亿张图预训练后，就与CNN持平或超过，最好的网络达到88.55%。论文总结道：大规模学习，胜过了CNN与生俱来的、专为图像设计的结构。

N＝H × W／P²

H, W: 图像的纵、横像素数
P: 方块的边长
N: 序列的长度（方块的数量）

常见说法常见说法：把图像切成小方块送进Transformer的想法，是ViT最先提出的
原始资料里：提交学会的最终版把科尔多涅等人（2020）列为最接近的研究，并补写道，他们会，并且（均为译）。论文认为自己新的地方在于：只要在大规模数据上预训练，没有特殊设计的Transformer也能与CNN持平。

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u11_patches.py

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

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

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

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

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

122018・2020・蛋白质

从距离地图，拼出形状

只凭氨基酸的排列，能预测蛋白质的立体结构吗？

它们不是写文章、画图的AI，但在同一时期，作为科学工具的AI也有了很大进步。蛋白质是氨基酸链折叠起来后形状才确定的。在2018年的结构预测大赛CASP13上，DeepMind的第一代AlphaFold 用CNN预测氨基酸两两之间的距离地图。再根据这张地图列出得分公式，用梯度下降一点一点修正形状。

右边的图是把这个方法缩到最小的样子。一条形状杂乱的链，会朝着符合左边的地图（本站设定的数）的方向移动。

两年后CASP14（2020年）的AlphaFold 2，据诺贝尔委员会的解说，是（译）的。它不再用卷积，而改用Transformer的注意力，直接给出原子的位置。难题的得分，从约60%提高到了约90%。

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

x_i: 第i个氨基酸的位置
d_ij: 地图上的距离
η: 移动的步长（学习率）
真正的得分公式: 与这个平方误差形式不同

常见说法常见说法：AI解开了蛋白质折叠之谜
原始资料里：论文自己划定的范围是“‘蛋白质折叠问题’中的结构预测部分”（译）。

误差总和E（每10倍一格的刻度）

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u11_distance_fold.py

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

import math
import random

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

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

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

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

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

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

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

132021・图与文

把图和文放到同一张地图上

一张狗的照片和描述它的句子，吻合程度能用数值来衡量吗？

2021年，OpenAI的拉德福德等12人发表了 CLIP。他们用从网上收集的4亿组图像和说明文字，同时训练两个部分：把图像变成向量的部分，和把句子变成向量的部分。一次摆出32,768组，让正确的一组方向相近、其他组相远（对比学习）。

右边的图是图像与句子相似程度（余弦相似度）的表。点“学习”，正确组合所在的对角线就会变亮。学习之后，把类别名写成A photo of a dog. 这样的句子，只要选出最接近的句子就能分类（零样本）。完全没用ImageNet的训练图像，就达到了76.2%。

相似程度＝cos(u_i, v_j)＝u_i・v_j ／ ( |u_i| |v_j| )

u: 图像的向量
v: 句子的向量
损失的方向: 逐行（图像→句子）和逐列（句子→图像）两个方向

常见说法常见说法：CLIP是画图的AI
原始资料里：CLIP不会画图。它是衡量图像和句子有多吻合的网络。

损失（按学习次数）

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u11_clip_table.py

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

import math
import random

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

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

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

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

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

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

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

142015→2020・扩散

加上噪声，再一点一点去掉

能从纯粹的噪声里生成图画吗？

2015年，斯坦福大学等处的索尔-迪克斯坦等人发表了一种（译）于物理学非平衡统计力学的方法：给数据反复加上微小的高斯噪声（正态分布的随机数）把形状破坏掉，再让神经网络学习与此相反的每一小步。

右边的图是与2015年论文的图相同的漩涡状点群。推进t就会变成一团雾；点“从噪声生成”，噪声一步一步被去掉，形状就恢复了。

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: 每处的数量（4）
数的总量: 512×512×3＝786,432个 → 64×64×4＝16,384个（48分之1）

常见说法常见说法：Stable Diffusion是Stability AI这家公司做的
原始资料里：Stability AI自己的发布文章写道：（译）。

162017〜2022・日本

用于学习的利用与机器学习天堂

对于AI从作品中学习，日本的法律是怎么规定的？

2018年5月，日本的著作权法修改了（2019年1月起施行）。新增了第30条之4：只要不是为了让人欣赏、享受作品而使用，在必要的范围内，不经著作权人许可就可以利用。它的标题是。不过也有但书：。在右边的图里选择使用方式，卡片就会停在第一道关卡，或前进到关卡2、3的判断入口。

条文和国家的概要里都没有AI这个词。文化厅的解说页面（2018年）举的例子是，第二年的文件则把放在效果举例的第一位。早稻田大学的法学者上野达弘，从2017年起一直解释说。

2022年8月29日，一款日本AI——mimic的测试版公开了，只要让它学习约15张自己的插画，就能生成画风相似的图像。随后担心别人的画被擅自使用的声音接连出现，第二天它就停掉了所有功能。

常见说法常见说法：日本是机器学习天堂，所以AI可以随意学习任何东西，生成物也随意
原始资料里：推广这个词的本人，文章讲的是学习阶段的事。他在同一篇文章里也写了：只限于必要的范围、有但书，以及生成物中如果留有原作的表达，著作权就会涉及。

2022年8月：海外与日本

172017→2022・人的喜好

两个相比，哪个更好？

好答案的评分方法没法用公式写出来时，怎么办？

强化学习（以得到的分数＝奖励尽量多为目标来学习行动的方法）不擅长处理“评分方法无法用公式写出来”的课题。2017年6月，OpenAI和DeepMind的克里斯蒂亚诺等6人，把AI动作的两段1〜2秒的视频给人看，请人选出好的一个。然后训练一个能猜出这种选择的奖励网络（后来被称为 RLHF）。机器人的后空翻，就是通过900次比较学会的。

在右边的图里，依次点你认为好的答案。根据两个分数之差算出人选这一个的概率（下面的公式），再按结果调整分数。

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有了心（谷歌员工这么说）
原始资料里：提出主张的只是一名工程师，公司驳回了。记录是本人整理的。创造它的研究人员自己，半年前就在论文里写到过人会把机器拟人化的风险。

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u11_leading_question.py

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

import math

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

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

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

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

192022・对话

流畅的错误

能写出流畅的文章，和传达正确的内容，是一回事吗？

2022年11月30日，OpenAI公开了以对话形式回答问题的 ChatGPT。它的内核，是用与InstructGPT相同的方法（本章第17个见开页），重新训练了2022年初完成学习的GPT-3.5系列网络。发布文章里的称呼是，在此期间免费。

发布文章一开始就写道：（译），并说要改正（译）。右边的图，是只用12条正确的句子训练出来的小系统。句子虽然流畅，但名字和年份的配对会张冠李戴。

2023年2月广为流传的“ChatGPT两个月就有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方块的序列

从距离地图，拼出形状

把图和文放到同一张地图上

加上噪声，再一点一点去掉

先缩小，再去噪声

用于学习的利用与机器学习天堂

两个相比，哪个更好？

顺着引导性的提问来回答

流畅的错误

这一章里，还有哪些尚不清楚的事