El comienzo del cuarto auge | Toda la historia de la IA

012017 · Transformer

Qué palabras mirar y cuánto

¿Cómo expresa una máquina con números las relaciones entre las palabras de una oración?

En junio de 2017, ocho personas, entre investigadores de Google y un estudiante de la Universidad de Toronto, publicaron el artículo del Transformer. La atención, que surgió en la traducción de 2014 vista en el capítulo anterior, se usaba junto con una RNN (una red que lee las palabras una a una, en orden). Este artículo construyó una red usando solo atención, sin RNN.

Para cada palabra se crean tres vectores (conjuntos de números): una consulta (Q) que busca, una clave (K) que se busca y un valor (V) que contiene la información. Se divide el producto interno entre la consulta y las claves de todas las palabras por √d, y se aplica softmax (un cálculo que hace que todos los valores sean positivos y sumen 1) para obtener los pesos. Con esos pesos se mezclan los valores. Al pulsar en la figura de la derecha, una línea gruesa apunta a “pez”. El artículo colocó ocho de estos mecanismos en paralelo (atención multicabeza), para que cada cabeza pudiera observar una relación distinta.

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

Q, K, V: matrices que reúnen los vectores de consultas, claves y valores
d_k: longitud del vector de la clave (64 en el artículo)
conjuntos de números de la figura: valores elegidos a mano por este sitio

Lo que se cree saberLo que suele decirse:Un artículo para crear una IA que conversa (IA de chat)
Según la fuente original:Lo que el artículo probó fue la traducción y el análisis sintáctico de oraciones en inglés. En la conclusión, las siguientes metas también eran ampliar el sistema a imágenes, audio y video; el texto no habla de conversación.

Este código Python reproduce el mismo mecanismo que “Explorar”. Al pulsar ▶ Ejecutar, el resultado aparece debajo. Se pueden cambiar los números y volver a ejecutarlo.

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 · Codificación posicional

Escribir el orden con ondas

El cálculo de atención no observa el orden. ¿Cómo distingue “el gato persigue al ratón” de “el ratón persigue al gato”?

En el cálculo de atención, los pesos no cambian aunque se altere el orden de las palabras. Como no se lee en orden, a diferencia de una RNN, hay que añadir por separado la información sobre la posición.

Para cada posición, el artículo creó un vector con valores de ondas sin y cos de distintos períodos (codificación posicional) y lo sumó al vector de la palabra. Los períodos van desde el más corto, 2π, hasta el más largo, 10000·2π. Como el segundero y la aguja de las horas de un reloj, las ondas rápidas distinguen posiciones cercanas y las lentas, posiciones lejanas. El gráfico inferior muestra el producto interno entre la posición elegida y las demás. Si la diferencia entre posiciones es la misma, el valor es casi igual en cualquier parte.

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

pos: posición de la palabra
i: número de la onda
d: dimensión del vector (512 en el artículo; 32 en la figura)

Producto interno entre el vector de la posición elegida y los de las demás posiciones

Este código Python reproduce el mismo mecanismo que “Explorar”. Al pulsar ▶ Ejecutar, el resultado aparece debajo. Se pueden cambiar los números y volver a ejecutarlo.

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

La misma palabra, números distintos

En inglés, play puede ser una jugada de béisbol o una obra de teatro. ¿Basta un solo conjunto de números para cada palabra?

word2vec (2013) y otros métodos del capítulo anterior asignaban un único vector a cada palabra. Por eso, play tenía el mismo vector en una oración sobre béisbol y en otra sobre teatro. En febrero de 2018, siete personas, entre ellas Matthew Peters, del Instituto Allen de Inteligencia Artificial y la Universidad de Washington, presentaron ELMo.

Con grandes cantidades de texto, se entrenan una LSTM que lee hacia delante y predice la palabra siguiente y otra que lee hacia atrás y predice la palabra anterior (dos capas cada una). La representación de una palabra es la suma de los estados internos de cada capa, con pesos aprendidos para cada tarea. El artículo dice que las capas inferiores destacan al identificar categorías gramaticales, y las superiores, al distinguir significados de las palabras (figura de la derecha).

En las seis tareas, bastó añadir ELMo para superar los mejores resultados de entonces, reduciendo los errores hasta aproximadamente un 20%.

ELMo_k ＝γ Σ_j s_j h_k,j

h_k,j: estado de la capa j al leer la palabra k
s_j: peso de cada capa (suman 1 mediante softmax)
γ: escala global

Lo que se cree saberLo que suele decirse:ELMo fue el primero en representar palabras cuyo significado cambia con el contexto
Según la fuente original:El propio artículo de ELMo cita investigaciones de 2017 y CoVe como antecedentes, y dice que su diferencia está en usar (traducción). Ocho meses después, el artículo de BERT llamó a ELMo (traducción). Sus creadores llamaron profundo al método, mientras que el siguiente artículo lo llamó superficial.

Este código Python reproduce el mismo mecanismo que “Explorar”. Al pulsar ▶ Ejecutar, el resultado aparece debajo. Se pueden cambiar los números y volver a ejecutarlo.

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 · Modelo de lenguaje

Aprender a predecir la palabra siguiente

¿Qué puede aprender una máquina de textos que no llevan respuestas correctas?

En junio de 2018, OpenAI presentó este procedimiento. Primero, se entrena un Transformer de 12 capas para predecir la palabra siguiente usando el texto de 7,000 libros (preentrenamiento). Después, se le enseñan tareas específicas con unos pocos ejemplos. Superó los mejores resultados anteriores en nueve de las 12 tareas evaluadas.

Un sistema que calcula las probabilidades de la palabra que sigue al texto escrito hasta ese momento se llama modelo de lenguaje. Al elegir repetidamente la palabra siguiente según esas probabilidades, se forma un texto. La idea es antigua: el artículo de Shannon de 1948 también determinaba la probabilidad de la siguiente letra a partir de las dos anteriores y creaba secuencias de letras parecidas al inglés. La figura de la derecha muestra las probabilidades del carácter siguiente a partir de los anteriores, contadas en los textos de los registros de este sitio. Al principio se usan dos caracteres anteriores, y se puede cambiar entre uno y tres. Al subir la temperatura, las probabilidades se vuelven más uniformes; al bajarla, la elección se concentra en los caracteres más probables.

La diferencia del cuarto auge es que las probabilidades las calcula una gran red neuronal (un Transformer), entrenada con muchos más textos.

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

z_i: puntuación del carácter i (en la figura, el logaritmo del número de apariciones)
T: temperatura
p_i: probabilidad de elegir el carácter i

Lo que se cree saberLo que suele decirse:Se lo llama el primer GPT (GPT-1)
Según la fuente original:En el artículo y el anuncio de junio de 2018, la palabra GPT no aparece ni una sola vez. Cuatro meses después, el artículo de BERT de Google lo llamó “transformador generativo preentrenado (OpenAI GPT)” (traducción). Todavía no se ha confirmado el origen del nombre GPT-1.

Este código Python reproduce el mismo mecanismo que “Explorar”. Al pulsar ▶ Ejecutar, el resultado aparece debajo. Se pueden cambiar los números y volver a ejecutarlo.

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

Dividir el texto en tokens

¿Un modelo de lenguaje lee las oraciones carácter por carácter o palabra por palabra?

Los fragmentos de texto que maneja un modelo de lenguaje se llaman tokens. Al dividir por caracteres, la secuencia se alarga; al dividir por palabras, hay un problema cuando aparece una palabra que no está en el diccionario. GPT y GPT-2 usaron codificación de pares de bytes (BPE). Primero se divide el texto en caracteres individuales y se unen los dos elementos que aparecen juntos con mayor frecuencia para crear un token nuevo. El proceso se repite. En la figura de la derecha se puede pulsar “Unir una vez”.

GPT, de 2018, usó un diccionario formado tras 40,000 uniones. Según el artículo de GPT-2 de 2019, si se trabaja directamente con caracteres (Unicode), el diccionario inicial, antes de las uniones, supera los 130,000 elementos. Por eso, primero dividieron los caracteres en bytes individuales (256 posibilidades) y después aplicaron BPE, para obtener un diccionario de 50,257 elementos. También ampliaron la longitud que podía leerse de una vez, de 512 a 1,024 tokens.

par que aparece junto con mayor frecuencia (a, b) → nuevo token ab (repetir)

lo que se cuenta: veces que b aparece inmediatamente después de a en el texto

El artículo de GPT-2 añadió un recurso para no unir caracteres de distintas categorías. Así se evita que una misma palabra, junto a signos de puntuación, ocupe tokens distintos innecesariamente, como dog. dog! dog?

Número de uniones y número de tokens

Este código Python reproduce el mismo mecanismo que “Explorar”. Al pulsar ▶ Ejecutar, el resultado aparece debajo. Se pueden cambiar los números y volver a ejecutarlo.

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 · Completar huecos

Predecir mirando a ambos lados

¿Qué cambia si se pide predecir un hueco dentro de la oración, en lugar de la palabra siguiente?

En octubre de 2018, cuatro personas de Google presentaron BERT. GPT leía de izquierda a derecha para predecir la palabra siguiente. En cambio, BERT seleccionaba y ocultaba el 15% de los tokens de la oración y aprendía a predecirlos usando pistas de ambos lados (el 80% de los seleccionados se sustituía por [MASK], el 10% por otra palabra y el 10% quedaba igual). El artículo dice que se inspiró en la prueba de completar huecos Cloze, de 1953.

En “yo [MASK] bebí” de la figura de la derecha, al mirar solo a la izquierda no se puede distinguir entre agua, té, pan y manzana. Al observar también “bebí” a la derecha, la elección se limita a bebidas.

Se entrenó con 800 millones de palabras de libros y 2.5 mil millones de palabras de Wikipedia en inglés, y obtuvo los mejores resultados en 11 tareas. En octubre de 2019, Google empezó a usarlo en su buscador y anunció que ayudaría a comprender (traducción).

pérdida＝ −Σ_{posiciones ocultas} log p( palabra real｜palabras a ambos lados )

p: probabilidad que da el modelo
posiciones ocultas: 15% de los tokens seleccionados

Este código Python reproduce el mismo mecanismo que “Explorar”. Al pulsar ▶ Ejecutar, el resultado aparece debajo. Se pueden cambiar los números y volver a ejecutarlo.

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 · Publicación por etapas

Publicar en 9 meses por temor al mal uso

¿Qué pasó cuando se decidió no publicar de inmediato toda la IA que se había creado?

En febrero de 2019, OpenAI anunció GPT-2, entrenado con 40 GB de textos de internet. Tiene 1.5 mil millones de parámetros (números que se fijan mediante el entrenamiento; en las fórmulas de este capítulo también se llaman componentes). Ante posibles usos como artículos falsos, alegó (traducción), y solo publicó un modelo pequeño y el artículo. También escribió: (traducción).

Después fue publicando modelos cada vez mayores. En noviembre, al publicar la versión más grande, escribió: (traducción). En la figura de la derecha se puede cambiar el mes.

número de componentes ≈ 12 × número de capas × d² ＋tamaño del diccionario × d＋número de posiciones × d

d: longitud del vector
12 × número de capas × d²: forma de contar el cuerpo principal (artículo de las leyes de escalamiento de 2020)
suma total: estimación de este sitio

Lo que se cree saberLo que suele decirse:OpenAI creó una “IA demasiado peligrosa para publicarla”
Según la fuente original:La palabra dangerous (peligroso) no aparece en el anuncio. El titular de The Guardian de aquel día fue (traducción). Nueve meses después lo publicaron por completo.

Número de parámetros (escala en la que cada paso multiplica por 10)

082020 · Leyes de escalamiento

Más parámetros o más texto

¿Qué pasa si solo aumenta el número de parámetros y no hay suficiente texto para entrenar?

En enero de 2020, diez personas de OpenAI y la Universidad Johns Hopkins mostraron que, al aumentar el número de parámetros, la cantidad de texto y la cantidad de cálculo, la pérdida de una IA de lenguaje (la dificultad para predecir la palabra siguiente) disminuye siguiendo una ley de potencias, y que esta tendencia se mantiene en un intervalo de más de siete órdenes de magnitud (más detalles en el capítulo 12).

El artículo también presentó una fórmula en la que influyen tanto el número de parámetros N como la cantidad de texto D. Si solo aumenta uno de los dos, la mejora se frena. Dice que, si se multiplican los parámetros por ocho, conviene multiplicar el texto por aproximadamente cinco para no perder eficiencia. En la figura de la derecha se puede pulsar “N × 8 y D × 5”.

Esta es una de las bases de la expectativa de que un modelo más grande será más inteligente. Sin embargo, los propios autores escriben: (traducción).

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

N: número de parámetros
D: cantidad de texto (número de tokens)
α_N, α_D: valores del artículo: 0.076 y 0.095
N_c, D_c: valores del artículo: 8.8×10¹³ y 5.4×10¹³

Lo que se cree saberLo que suele decirse:Una ley según la cual, cuanto mayor sea el modelo, más inteligente será, sin límite
Según la fuente original:El propio artículo dice que la tendencia necesariamente acabará por estabilizarse y que no hay una comprensión teórica.

Pérdida al fijar la cantidad de texto y aumentar solo el número de parámetros

092020 · Mostrar ejemplos

Ejemplos sin volver a entrenar

¿Se puede enseñar una tarea nueva sin cambiar los números internos de la IA (los pesos)?

En mayo de 2020, 31 personas de OpenAI presentaron GPT-3, con 175 mil millones de parámetros. Era diez veces más grande que las IA similares anteriores y se entrenó con 300 mil millones de tokens.

En lugar de volver a entrenar para cada tarea (cambiar los pesos), se incluyen en el texto una explicación de la tarea y algunos ejemplos, y se pide que escriba la continuación. Sin ejemplos (zero-shot), con uno (one-shot) o con unos pocos (few-shot). Los pesos no cambian. Así realizó traducciones, respondió preguntas e hizo cálculos de tres cifras, entre otras tareas. La figura de la derecha es un mecanismo pequeño creado por este sitio (no representa el interior de GPT-3). Solo conserva las reglas que encajan con los ejemplos, de modo que, al aumentar estos, se reducen las respuestas posibles.

Cuando se pidió a personas que distinguieran entre noticias escritas por GPT-3 y por personas, acertaron el 52% de las veces, casi lo mismo que al elegir al azar (50%).

texto mostrado＝explicación de la tarea＋ejemplo 1＋ … ＋ejemplo k＋pregunta　→　escribir la continuación

k: número de ejemplos mostrados
longitud que se puede leer de una vez: 2,048 tokens (GPT-3)

Número de parámetros (escala en la que cada paso multiplica por 10; cifras de los registros)

Este código Python reproduce el mismo mecanismo que “Explorar”. Al pulsar ▶ Ejecutar, el resultado aparece debajo. Se pueden cambiar los números y volver a ejecutarlo.

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 · Aprendizaje autosupervisado

Acercar imágenes sin etiquetas

¿Se pueden aprender características útiles para distinguir fotos sin ponerles etiquetas correctas?

El aprendizaje autosupervisado es un método que aprende con problemas creados a partir de los propios datos, sin que las personas añadan respuestas correctas (etiquetas). Predecir la palabra siguiente y completar huecos también pertenecen a esta familia. En febrero de 2020, cuatro personas de Google, entre ellas Ting Chen y Geoffrey Hinton, presentaron SimCLR, una formulación sencilla del aprendizaje contrastivo para imágenes.

Se aplican dos veces transformaciones como recortes, cambios de color y desenfoque a una foto para crear un par correcto de imágenes. Se entrena para que las imágenes del par estén cerca (con una similitud del coseno alta) y lejos de otras fotos. En la figura de la derecha se puede pulsar “Seguir aprendiendo”.

Sobre las características aprendidas sin etiquetas, se entrenó únicamente una capa sencilla de clasificación con respuestas correctas, y se obtuvo un 76.5% en ImageNet. Un resultado comparable al de ResNet-50 entrenado con etiquetas.

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

z: vector de características de la foto
(i, j): par creado a partir de la misma foto
sim: similitud del coseno
τ: parámetro de temperatura

Lo que se cree saberLo que suele decirse:SimCLR inició el aprendizaje contrastivo de imágenes sin etiquetas
Según la fuente original:El propio artículo dice: (traducción), y cita primero un artículo de 2006 de la Universidad de Nueva York como ejemplo de aprendizaje contrastivo. Aquel artículo decía: (traducción).

Pérdida en cada paso de entrenamiento

Este código Python reproduce el mismo mecanismo que “Explorar”. Al pulsar ▶ Ejecutar, el resultado aparece debajo. Se pueden cambiar los números y volver a ejecutarlo.

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 para imágenes

Una secuencia de cuadrados de 16×16

¿Cómo hacer que un Transformer para textos lea una imagen?

En octubre de 2020, 12 personas de Google, entre ellas Alexey Dosovitskiy, presentaron ViT (Vision Transformer). Divide la imagen en pequeños cuadrados (parches) del mismo tamaño y convierte cada uno en un vector de una sola fila. Se añade un vector de posición y se introducen en el Transformer como las palabras de un texto. Al principio se agrega un marcador para producir la respuesta.

Las imágenes usadas para entrenar en el artículo eran de 224×224. Al dividirlas en cuadrados de 16×16, se obtiene una secuencia de 196 parches. Al reducir el tamaño de los cuadrados en la figura de la derecha, la secuencia se alarga y el cálculo de atención se vuelve más costoso (la longitud de la secuencia es inversamente proporcional al cuadrado del lado de cada parche).

Entrenado solo con ImageNet (aproximadamente 1.3 millones de imágenes), obtuvo unos puntos menos que ResNet, la CNN (red convolucional) del capítulo anterior. Tras un preentrenamiento con entre 14 y 300 millones de imágenes, igualó o superó a las CNN; el mejor modelo obtuvo un 88.55%. El artículo concluyó que el entrenamiento a gran escala supera los mecanismos específicos para imágenes que las CNN incorporan desde el principio.

N＝H × W／P²

H, W: número de píxeles de alto y de ancho de la imagen
P: longitud del lado del cuadrado
N: longitud de la secuencia (número de cuadrados)

Lo que se cree saberLo que suele decirse:ViT fue el primero en proponer dividir una imagen en cuadrados pequeños e introducirlos en un Transformer
Según la fuente original:La versión final presentada a la conferencia citó a Cordonnier y sus colegas (2020) como el trabajo más cercano y añadió que y que (ambas citas son traducciones). La novedad que reivindicaba el artículo era mostrar que, con preentrenamiento en grandes conjuntos de datos, un Transformer sin modificaciones especiales puede igualar a las CNN.

Este código Python reproduce el mismo mecanismo que “Explorar”. Al pulsar ▶ Ejecutar, el resultado aparece debajo. Se pueden cambiar los números y volver a ejecutarlo.

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 · Proteínas

De un mapa de distancias a la forma

¿Se puede predecir la estructura tridimensional de una proteína solo a partir de su secuencia de aminoácidos?

Aunque no se trata de una IA que crea textos o imágenes, en esa misma época la IA también avanzó mucho como herramienta científica. Las proteínas adquieren su forma al plegarse una cadena de aminoácidos. En CASP13, el concurso de predicción de estructuras de 2018, el primer AlphaFold de DeepMind predijo con una CNN un mapa de distancias entre aminoácidos. A partir de ese mapa creó una fórmula de puntuación y ajustó la forma poco a poco mediante descenso de gradiente.

La figura de la derecha es una versión mínima de este método. Una cadena con una forma aleatoria se mueve para ajustarse al mapa de la izquierda (números elegidos por este sitio).

Dos años después, según la explicación del Comité Nobel, AlphaFold 2, de CASP14 (2020), (traducción). Dejó de usar convoluciones, utilizó la atención del Transformer y pasó a producir directamente las posiciones de los átomos. La puntuación en los problemas difíciles subió de aproximadamente el 60% al 90%.

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

x_i: posición del aminoácido i
d_ij: distancia en el mapa
η: tamaño del paso (tasa de aprendizaje)
fórmula de puntuación real: tiene una forma distinta de este error cuadrático

Lo que se cree saberLo que suele decirse:La IA resolvió el misterio del plegamiento de las proteínas
Según la fuente original:El propio artículo delimita lo que resolvió a (traducción).

Error total E (escala en la que cada paso multiplica por 10)

Este código Python reproduce el mismo mecanismo que “Explorar”. Al pulsar ▶ Ejecutar, el resultado aparece debajo. Se pueden cambiar los números y volver a ejecutarlo.

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 · Imágenes y textos

Imágenes y textos en el mismo mapa

Una foto de un perro y una oración que la describe. ¿Se puede medir con números cuánto coinciden?

En 2021, 12 personas de OpenAI, entre ellas Alec Radford, presentaron CLIP. Con 400 millones de pares de imágenes y descripciones recogidos de internet, se entrenan al mismo tiempo una parte que convierte imágenes en vectores y otra que convierte textos en vectores. Se disponen 32,768 pares a la vez y se entrena para que los pares correctos apunten en direcciones cercanas y los demás, en direcciones lejanas (aprendizaje contrastivo).

La figura de la derecha es una tabla de semejanza entre imágenes y textos (similitud del coseno). Al pulsar “Aprender”, se ilumina la diagonal de los pares correctos. Después del entrenamiento, basta convertir el nombre de cada categoría en una oración como A photo of a dog. (Una foto de un perro) y elegir la oración más cercana para clasificar (zero-shot). Obtuvo un 76.2% sin usar una sola imagen del conjunto de entrenamiento de ImageNet.

grado de semejanza＝cos(u_i, v_j)＝u_i·v_j ／ ( |u_i| |v_j| )

u: vector de la imagen
v: vector del texto
dirección de la pérdida: tanto por filas (imagen→texto) como por columnas (texto→imagen)

Lo que se cree saberLo que suele decirse:CLIP es una IA que crea imágenes
Según la fuente original:CLIP no crea imágenes. Es un modelo que mide cuánto coinciden una imagen y un texto.

Pérdida en cada paso de entrenamiento

Este código Python reproduce el mismo mecanismo que “Explorar”. Al pulsar ▶ Ejecutar, el resultado aparece debajo. Se pueden cambiar los números y volver a ejecutarlo.

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 · Modelos de difusión

Añadir ruido y quitarlo poco a poco

¿Se puede crear una imagen a partir de puro ruido?

En 2015, Jascha Sohl-Dickstein y sus colegas de la Universidad de Stanford y otras instituciones presentaron un método (traducción). Añade repetidamente pequeñas cantidades de ruido gaussiano (números aleatorios de una distribución normal) a los datos hasta destruir su forma y entrena una red neuronal para aprender cada paso del proceso inverso.

Los puntos de la figura de la derecha forman la misma espiral que aparece en una figura del artículo de 2015. Al avanzar t, se convierten en una niebla; al pulsar “Crear a partir del ruido”, el ruido se elimina paso a paso y la forma vuelve a aparecer.

En 2020, el artículo de DDPM de tres personas de la Universidad de California en Berkeley, entre ellas Jonathan Ho, escribió que, con modelos de difusión, (traducción). Con un proceso de 1,000 pasos y un entrenamiento que predice el propio ruido añadido, mostró que era posible crear imágenes de alta calidad.

x_t ＝ √ᾱ_t x₀ ＋ √(1 − ᾱ_t) ε　　lo que se aprende: predecir ε a partir de x_t

x₀: datos originales
ε: ruido añadido
ᾱ_t: proporción del original que queda en el paso t (de 1 a 0)

Lo que se cree saberLo que suele decirse:Los modelos de difusión son un método nuevo que nació en la época de Stable Diffusion
Según la fuente original:La idea ya está en el artículo de 2015. El artículo en el que se basa Stable Diffusion (diciembre de 2021) también cita el de 2015 como origen de los modelos de difusión.

Proporción del original que queda en el paso t, ᾱ

Este código Python reproduce el mismo mecanismo que “Explorar”. Al pulsar ▶ Ejecutar, el resultado aparece debajo. Se pueden cambiar los números y volver a ejecutarlo.

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 · IA que genera imágenes

Reducir antes de quitar el ruido

¿No resulta demasiado costoso añadir y quitar ruido directamente en una imagen de 512×512?

En diciembre de 2021, Robin Rombach y sus colegas de la Universidad de Múnich, la Universidad de Heidelberg y Runway presentaron el modelo de difusión latente. Un autoencoder (del capítulo anterior: reducir y reconstruir) comprime la imagen en una representación latente, donde se aplica el modelo de difusión. Compararon factores de reducción f entre 1 y 32, y consideraron que los de 4 a 16 ofrecían un buen equilibrio entre velocidad y calidad.

Stable Diffusion, de agosto de 2022, tiene esta estructura. Según su documentación, reduce el alto y el ancho a un octavo, convierte el texto en un vector con la parte de texto de CLIP y lo conecta mediante atención con la U-Net que elimina el ruido (capítulo anterior). En la figura de la derecha se puede cambiar f.

Quién podía usar estas IA también cambió en menos de dos años. DALL·E, de enero de 2021, solo publicó ejemplos; DALL·E 2, de abril de 2022, estaba disponible para un pequeño grupo de personas seleccionadas. Stable Diffusion, de agosto de 2022, se publicó de modo que cualquiera pudiera descargar el modelo entrenado y ejecutarlo en su propia computadora (también se permitía el uso comercial, con restricciones de uso).

número de valores latentes＝ (H／f) × (W／f) × c

H, W: número de píxeles de alto y de ancho de la imagen
f: factor de reducción (8 en Stable Diffusion)
c: valores por posición (4)
cantidad de valores: 512×512×3＝786,432 → 64×64×4＝16,384 (una parte de 48)

Lo que se cree saberLo que suele decirse:Stable Diffusion fue creado por una empresa llamada Stability AI
Según la fuente original:El propio anuncio de Stability AI dice: (traducción).

162017–2022 · Japón

Uso para aprender y el paraíso del aprendizaje automático

¿Cómo reguló la ley japonesa el aprendizaje de la IA a partir de obras?

En mayo de 2018 se reformó la Ley de Derechos de Autor de Japón (entró en vigor en enero de 2019). Se creó el artículo 30-4, que permite, dentro de lo necesario, usar obras sin permiso del titular de los derechos de autor cuando el uso no tiene como finalidad que las personas disfruten de ellas. Su encabezado es (traducción). Sin embargo, incluye esta salvedad: (traducción). Al elegir un uso en la figura de la derecha, la tarjeta se detiene en el primer control o avanza hasta la entrada de la evaluación de los controles 2 y 3.

Ni el texto del artículo ni el resumen del Gobierno mencionan la IA. La página explicativa de la Agencia de Asuntos Culturales (2018) citó como ejemplo (traducción), y un documento del año siguiente puso (traducción) al principio de los ejemplos de sus efectos. Desde 2017, Tatsuhiro Ueno, jurista de la Universidad de Waseda, ha explicado: (traducción).

El 29 de agosto de 2022 se publicó la versión beta de mimic, una IA japonesa que, tras aprender de unas 15 ilustraciones propias, crea imágenes con un estilo parecido. Se sucedieron las voces de preocupación por que se usaran obras ajenas sin permiso y, al día siguiente, se suspendieron todas sus funciones.

Lo que se cree saberLo que suele decirse:Japón es un paraíso del aprendizaje automático, así que la IA puede aprender de cualquier cosa libremente y lo que genera también es de uso libre
Según la fuente original:El texto de quien difundió la expresión habla de la fase de aprendizaje. En ese mismo texto también dice que el uso debe limitarse a lo necesario, que hay una salvedad y que los derechos de autor se aplican al resultado si conserva la expresión original.

Agosto de 2022: fuera de Japón y en Japón

172017→2022 · Preferencias humanas

Comparar dos y elegir el mejor

¿Qué hacer cuando no se puede escribir con una fórmula cómo puntuar una buena respuesta?

El aprendizaje por refuerzo (un método para aprender acciones que obtengan más puntos, llamados recompensas) tenía dificultades con tareas cuya puntuación no puede expresarse con una fórmula. En junio de 2017, seis personas de OpenAI y DeepMind, entre ellas Paul Christiano, mostraron a personas dos videos de 1–2 segundos con movimientos de una IA y les pidieron elegir el mejor. Entrenaron un modelo de recompensa para predecir esas elecciones (más tarde llamado RLHF). Un robot aprendió un salto mortal hacia atrás con 900 comparaciones.

En la figura de la derecha se pueden ir pulsando las respuestas que se consideren mejores. A partir de la diferencia entre las dos puntuaciones se calcula la probabilidad de que una persona elija una de ellas (fórmula inferior), y se ajustan las puntuaciones para que encajen con los resultados.

InstructGPT, de marzo de 2022 (Long Ouyang y sus colegas), aplicó este método a GPT-3. Se volvió a entrenar con ejemplos de respuestas, se creó un modelo de recompensa a partir de clasificaciones de cuatro a nueve respuestas y se aplicó aprendizaje por refuerzo (PPO). Las respuestas de InstructGPT, con 1.3 mil millones de parámetros, fueron preferidas a las de GPT-3, cien veces más grande.

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

P(A): probabilidad de que una persona elija A
r: puntuación del modelo de recompensa
respuestas de la figura: cinco creadas por este sitio (su calidad real también la fija este sitio)

Lo que se cree saberLo que suele decirse:RLHF se creó para ChatGPT
Según la fuente original:Lo que se probó en 2017 fueron juegos y movimientos de robots. El nombre tampoco aparece en el artículo.

Proporción de pares ordenados que coinciden con el orden real de calidad

Este código Python reproduce el mismo mecanismo que “Explorar”. Al pulsar ▶ Ejecutar, el resultado aparece debajo. Se pueden cambiar los números y volver a ejecutarlo.

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 · ¿Una mente?

Responder según una pregunta que orienta

Si una IA responde “tengo miedo”, ¿significa que tiene una mente?

En junio de 2022, el ingeniero de Google Blake Lemoine afirmó que la IA conversacional LaMDA podría tener sentimientos. También publicó un registro de las conversaciones; la fuente dice: (traducción). En ese registro, LaMDA respondió, entre otras cosas, y (ambas citas son traducciones).

Google rechazó la afirmación: (traducción). La explicación de su portavoz fue: (traducción). La figura de la derecha es un mecanismo pequeño creado por este sitio que elige respuestas acordes con las palabras de la pregunta. Con el mismo mecanismo, la forma de escribir la pregunta cambia la dirección de la respuesta.

Los investigadores que crearon LaMDA habían escrito, en un artículo de medio año antes, sobre el riesgo de que las personas acabaran por (traducción). Es una historia que viene desde ELIZA, de 1966 (capítulo 4).

probabilidad de la respuesta＝p( respuesta｜texto de la pregunta )

a la derecha de la línea vertical: condición dada (aquí, el texto de la pregunta). Si el texto cambia, las probabilidades cambian incluso con el mismo mecanismo

Lo que se cree saberLo que suele decirse:En 2022, la IA de Google adquirió una mente (según un empleado de Google)
Según la fuente original:La afirmación la hizo un solo ingeniero y la empresa la rechazó. Él mismo recopiló el registro. Los propios investigadores que la crearon habían escrito, en un artículo de medio año antes, sobre el riesgo de que las personas atribuyeran características humanas a las máquinas.

Este código Python reproduce el mismo mecanismo que “Explorar”. Al pulsar ▶ Ejecutar, el resultado aparece debajo. Se pueden cambiar los números y volver a ejecutarlo.

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 · Conversación

Errores escritos con fluidez

¿Es lo mismo escribir con fluidez que transmitir información correcta?

El 30 de noviembre de 2022, OpenAI publicó ChatGPT, que responde en forma de conversación. En su interior hay un modelo de la serie GPT-3.5 cuyo entrenamiento terminó a principios de 2022, entrenado de nuevo con el mismo método que InstructGPT (17 de este capítulo). El anuncio lo llamó (traducción), y durante ese período fue gratuito.

Desde el principio, el anuncio decía que (traducción), y advertía: (traducción). La figura de la derecha es un mecanismo pequeño entrenado solo con 12 oraciones correctas. Las oraciones son fluidas, pero los pares de nombres y años se intercambian.

La afirmación “ChatGPT llegó a 100 millones de usuarios en dos meses”, difundida en febrero de 2023, no era un anuncio de la empresa, sino una estimación de analistas de un banco, expresada como (traducción) (más detalles en el capítulo 12).

palabra siguiente～p( w｜texto hasta ese momento )　(repetir)

～: elegir un elemento según las probabilidades
corrección: no aparece en ninguna parte de esta fórmula

Lo que se cree saberLo que suele decirse:ChatGPT se lanzó con gran publicidad como una IA nueva y perfecta
Según la fuente original:El anuncio lo llamó (traducción). En su interior había un modelo cuyo entrenamiento había terminado a principios de ese mismo año, y sus debilidades estaban descritas desde el día de su publicación.

Este código Python reproduce el mismo mecanismo que “Explorar”. Al pulsar ▶ Ejecutar, el resultado aparece debajo. Se pueden cambiar los números y volver a ejecutarlo.

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

Qué palabras mirar y cuánto

Escribir el orden con ondas

La misma palabra, números distintos

Aprender a predecir la palabra siguiente

Dividir el texto en tokens

Predecir mirando a ambos lados

Publicar en 9 meses por temor al mal uso

Más parámetros o más texto

Ejemplos sin volver a entrenar

Acercar imágenes sin etiquetas

Una secuencia de cuadrados de 16×16

De un mapa de distancias a la forma

Imágenes y textos en el mismo mapa

Añadir ruido y quitarlo poco a poco

Reducir antes de quitar el ruido

Uso para aprender y el paraíso del aprendizaje automático

Comparar dos y elegir el mejor

Responder según una pregunta que orienta

Errores escritos con fluidez

Lo que aún no se sabe en este capítulo