跳到正文
Andrej Karpathy:Blog·· 2026-02-12精選AI 評分79

Andrej Karpathy 用 200 行純 Python microgpt 解説 GPT 訓練與推理

microgpt

AI 導讀

Andrej Karpathy 以 microgpt 示範如何用一個 200 行、無依賴的純 Python 檔案訓練及推理 GPT。程式涵蓋資料集、Tokenizer、自動微分、GPT-2-like 架構、Adam 及生成流程;示例以約 32,000 個名字訓練,模型有 4,192 個參數。文中亦對照生產級 LLM 在數據、模型規模、訓練和推理工程上的差異。

推薦理由

文章將 GPT 的演算法核心與生產級 LLM 的規模化工程逐項對照,呈現數據、模型規模、訓練及推理流程的差異。

正文 · 繁體中文

這是我新藝術項目 microgpt 的簡短介紹:它是一個只有 200 行的純 Python 單一檔案,沒有任何相依套件,可用來訓練 GPT 並進行推理。這個檔案包含所需的完整演算法內容:文件數據集、分詞器、自動微分引擎、類似 GPT-2 的神經網絡架構、Adam 最佳化器、訓練迴圈,以及推理迴圈。其他一切都只是為了提升效率。我已無法再進一步簡化。這個程式碼是多個項目(micrograd、makemore、nanogpt 等)的集大成之作,也凝聚了我十年來致力於將 LLM 簡化至最基本要素的執著,我覺得它很美 🥹。它甚至能完美分成 3 欄:

在哪裏可以找到:

以下是我的指南,會逐步帶領有興趣的讀者閲讀程式碼。

數據集

大型語言模型的燃料是文字數據串流,並可選擇按文件分隔。在正式級別的應用中,每份文件都會是一個互聯網網頁;但在 microgpt 中,我們採用較簡單的例子:32,000 個名字,每行一個:

# Let there be an input dataset `docs`: list[str] of documents (e.g. a dataset of names)
if not os.path.exists('input.txt'):
    import urllib.request
    names_url = 'https://raw.githubusercontent.com/karpathy/makemore/refs/heads/master/names.txt'
    urllib.request.urlretrieve(names_url, 'input.txt')
docs = [l.strip() for l in open('input.txt').read().strip().split('\n') if l.strip()] # list[str] of documents
random.shuffle(docs)
print(f"num docs: {len(docs)}")

數據集如下所示。每個名字都是一份文件:

emma
olivia
ava
isabella
sophia
charlotte
mia
amelia
harper
... (~32,000 names follow)

模型的目標是學習數據中的模式,然後生成具有相同統計模式的相似新文件。先預告一下,程式碼執行完畢時,模型便會生成一些聽起來合理的新名字(「幻覺」!)。先看結果:

sample  1: kamon
sample  2: ann
sample  3: karai
sample  4: jaire
sample  5: vialan
sample  6: karia
sample  7: yeran
sample  8: anna
sample  9: areli
sample 10: kaina
sample 11: konna
sample 12: keylen
sample 13: liole
sample 14: alerin
sample 15: earan
sample 16: lenne
sample 17: kana
sample 18: lara
sample 19: alela
sample 20: anton

看起來或許沒甚麼特別,但從 ChatGPT 這類模型的角度來看,你與它的對話只是一份看起來有點奇怪的「文件」。當你用提示詞初始化這份文件時,從模型的角度來看,它的回應只是在統計上補全文字。

分詞器

在底層,神經網絡處理的是數字,而不是字元,因此我們需要一種方法,將文字轉換成整數 token ID 序列,並可反向轉換。tiktoken(GPT-4 使用的分詞器)等正式分詞器會按字元片段處理,以提升效率;但最簡單的分詞器,只會為數據集中的每個獨立字元分配一個整數:

# Let there be a Tokenizer to translate strings to discrete symbols and back
uchars = sorted(set(''.join(docs))) # unique characters in the dataset become token ids 0..n-1
BOS = len(uchars) # token id for the special Beginning of Sequence (BOS) token
vocab_size = len(uchars) + 1 # total number of unique tokens, +1 is for BOS
print(f"vocab size: {vocab_size}")

在上面的程式碼中,我們收集數據集中所有不重複的字元(也就是全部小寫字母 a-z),將它們排序,並按索引為每個字母分配 ID。請注意,整數值本身沒有任何意義;每個 token 都只是一個獨立的離散符號。它們不用是 0、1、2,也可以是不同的 emoji。此外,我們會建立另一個名為 BOS 的特殊 token(序列起始標記,Beginning of Sequence),作為分隔符:它會告訴模型「新文件由此開始/結束」。在稍後的訓練過程中,每份文件的兩側都會加上 BOS:[BOS, e, m, m, a, BOS]。模型會學懂 BOS 代表一個新名字的開始,而另一個 BOS 則代表名字結束。因此,最終的詞彙表共有 27 個 token(26 個小寫字母 a-z,以及 1 個 BOS token)。

自動微分

訓練神經網絡需要計算梯度:對模型中的每個參數,我們都要知道「如果把這個數值稍微調高一點,損失會上升還是下降,幅度又有多大?」計算圖有許多輸入(模型參數和輸入 token),但最後會匯聚至單一純量輸出:損失(我們稍後會準確定義損失是甚麼)。反向傳播從這個單一輸出開始,沿計算圖反向運算,計算損失相對於每個輸入的梯度。這個過程依賴微積分的鏈式法則。在實際應用中,PyTorch 等程式庫會自動處理這些工作。在這裏,我們會從零開始,在名為 Value 的單一類別中實作:

class Value:
    __slots__ = ('data', 'grad', '_children', '_local_grads')

    def __init__(self, data, children=(), local_grads=()):
        self.data = data                # scalar value of this node calculated during forward pass
        self.grad = 0                   # derivative of the loss w.r.t. this node, calculated in backward pass
        self._children = children       # children of this node in the computation graph
        self._local_grads = local_grads # local derivative of this node w.r.t. its children

    def __add__(self, other):
        other = other if isinstance(other, Value) else Value(other)
        return Value(self.data + other.data, (self, other), (1, 1))

    def __mul__(self, other):
        other = other if isinstance(other, Value) else Value(other)
        return Value(self.data * other.data, (self, other), (other.data, self.data))

    def __pow__(self, other): return Value(self.data**other, (self,), (other * self.data**(other-1),))
    def log(self): return Value(math.log(self.data), (self,), (1/self.data,))
    def exp(self): return Value(math.exp(self.data), (self,), (math.exp(self.data),))
    def relu(self): return Value(max(0, self.data), (self,), (float(self.data > 0),))
    def __neg__(self): return self * -1
    def __radd__(self, other): return self + other
    def __sub__(self, other): return self + (-other)
    def __rsub__(self, other): return other + (-self)
    def __rmul__(self, other): return self * other
    def __truediv__(self, other): return self * other**-1
    def __rtruediv__(self, other): return other * self**-1

    def backward(self):
        topo = []
        visited = set()
        def build_topo(v):
            if v not in visited:
                visited.add(v)
                for child in v._children:
                    build_topo(child)
                topo.append(v)
        build_topo(self)
        self.grad = 1
        for v in reversed(topo):
            for child, local_grad in zip(v._children, v._local_grads):
                child.grad += local_grad * v.grad

我知道這部分在數學和演算法方面最為艱深,而我有一段 2.5 小時的影片介紹這部分:micrograd 影片。簡單來説,Value 會包裝一個純量(.data),並追蹤它的計算過程。你可以把每個操作想像成一塊小小的樂高積木:它接收一些輸入,產生一個輸出(前向傳播),並知道輸出相對於每個輸入會如何變化(局部梯度)。自動微分(autograd)從每塊積木需要的資訊就只有這些。其餘一切都只是鏈式法則,把積木串連起來。

每次你用 Value 物件進行數學運算(加法、乘法等),結果都會是一個新的 Value,它會記錄自己的輸入(_children)以及該運算的局部導數(_local_grads)。例如,__mul__ 會記錄 \(\frac{\partial(a \cdot b)}{\partial a} = b\) 和 \(\frac{\partial(a \cdot b)}{\partial b} = a\)。完整的積木清單如下:

操作 前向計算 局部梯度
a + b \(a + b\) \(\frac{\partial}{\partial a} = 1, \quad \frac{\partial}{\partial b} = 1\)
a * b \(a \cdot b\) \(\frac{\partial}{\partial a} = b, \quad \frac{\partial}{\partial b} = a\)
a ** n \(a^n\) \(\frac{\partial}{\partial a} = n \cdot a^{n-1}\)
log(a) \(\ln(a)\) \(\frac{\partial}{\partial a} = \frac{1}{a}\)
exp(a) \(e^a\) \(\frac{\partial}{\partial a} = e^a\)
relu(a) \(\max(0, a)\) \(\frac{\partial}{\partial a} = \mathbf{1}_{a > 0}\)

backward() 的方法會按反向拓撲次序遍歷這個計算圖(從損失開始,到參數為止),並在每一步套用鏈式法則。如果損失為 \(L\),而節點 \(v\) 有一個子節點 \(c\),其局部梯度為 \(\frac{\partial v}{\partial c}\),那麼:

\[\frac{\partial L}{\partial c} \mathrel{+}= \frac{\partial v}{\partial c} \cdot \frac{\partial L}{\partial v}\]

如果你對微積分不太熟悉,這看起來可能有點嚇人,但實際上這只是用直觀的方式把兩個數相乘。可以這樣理解:「如果汽車的速度是單車的兩倍,而單車的速度是步行者的四倍,那麼汽車的速度就是步行者的 2 x 4 = 8 倍。」鏈式法則的原理相同:把沿途的變化率相乘。

我們從在損失節點設定 self.grad = 1 開始,因為 \(\frac{\partial L}{\partial L} = 1\):損失相對於自身的變化率自然是 1。之後,鏈式法則只需把沿着每條路徑返回參數的局部梯度相乘。

留意 +=(累加,而非賦值)。當某個值在計算圖中的多個位置使用(即計算圖出現分支)時,梯度會沿每條分支各自反向傳播,因此必須將它們相加。這是多變數鏈式法則的結果:如果 \(c\) 經由多條路徑對 \(L\) 產生影響,總導數便是各條路徑所帶來的貢獻之和。

backward() 完成後,計算圖中的每個 Value 都會有一個 .grad,當中包含 \(\frac{\partial L}{\partial v}\),告訴我們如果稍微調整該值,最終損失會如何變化。

以下是一個具體例子。請注意,a 會用到兩次(計算圖會分支),因此它的梯度是兩條路徑的總和:

a = Value(2.0)
b = Value(3.0)
c = a * b       # c = 6.0
L = c + a       # L = 8.0
L.backward()
print(a.grad)   # 4.0 (dL/da = b + 1 = 3 + 1, via both paths)
print(b.grad)   # 2.0 (dL/db = a = 2)

這正是 PyTorch 的 .backward() 所提供的結果:

import torch
a = torch.tensor(2.0, requires_grad=True)
b = torch.tensor(3.0, requires_grad=True)
c = a * b
L = c + a
L.backward()
print(a.grad)   # tensor(4.)
print(b.grad)   # tensor(2.)

這就是 PyTorch 的 loss.backward() 所執行的同一套演算法,只是處理純量而非張量(由純量組成的陣列)——在演算法上完全相同,規模小得多、也簡單得多,但當然效率低得多。

讓我們仔細解讀上面的 .backward() 結果。Autograd 計算出,如果 L = a*b + a,而且 a=2 和 b=3,那麼 a.grad = 4.0 就是在告訴我們 a 對 L 的局部影響。若稍微改變輸入 a,L 會朝哪個方向變化?在這裏,L 對 a 的導數是 4.0,表示如果我們將 a 稍微增加一點(例如 0.001),L 就會增加約 4 倍(0.004)。同樣地,b.grad = 2.0 表示對 b 作同樣幅度的微調,L 就會增加約 2 倍(0.002)。換言之,這些梯度告訴我們每個個別輸入對最終輸出(損失)的影響方向(正負取決於符號)和幅度(大小)。這樣我們便可以反覆微調神經網絡的參數,以降低損失,從而改善模型的預測。

參數

參數就是模型所掌握的知識。它們是大量浮點數(為了讓 autograd 使用而包裝在 Value 中),一開始是隨機值,並在訓練期間反覆最佳化。每個參數的確切作用,要等到下文定義模型架構後才會更清楚;目前我們只需要將它們初始化:

n_embd = 16     # embedding dimension
n_head = 4      # number of attention heads
n_layer = 1     # number of layers
block_size = 16 # maximum sequence length
head_dim = n_embd // n_head # dimension of each head
matrix = lambda nout, nin, std=0.08: [[Value(random.gauss(0, std)) for _ in range(nin)] for _ in range(nout)]
state_dict = {'wte': matrix(vocab_size, n_embd), 'wpe': matrix(block_size, n_embd), 'lm_head': matrix(vocab_size, n_embd)}
for i in range(n_layer):
    state_dict[f'layer{i}.attn_wq'] = matrix(n_embd, n_embd)
    state_dict[f'layer{i}.attn_wk'] = matrix(n_embd, n_embd)
    state_dict[f'layer{i}.attn_wv'] = matrix(n_embd, n_embd)
    state_dict[f'layer{i}.attn_wo'] = matrix(n_embd, n_embd)
    state_dict[f'layer{i}.mlp_fc1'] = matrix(4 * n_embd, n_embd)
    state_dict[f'layer{i}.mlp_fc2'] = matrix(n_embd, 4 * n_embd)
params = [p for mat in state_dict.values() for row in mat for p in row]
print(f"num params: {len(params)}")

每個參數都會初始化為從高斯分佈中抽取的小幅隨機值。state_dict 會將它們整理成具名矩陣(沿用 PyTorch 的術語):嵌入表、注意力權重、MLP 權重,以及最終輸出投影。我們也會將所有參數攤平成單一清單 params,讓最佳化器之後可以逐一處理。在這個小型模型中,總共有 4,192 個參數。GPT-2 有 1.6 billion 個參數,而現代 LLM 則有數千億個。

架構

模型架構是一個無狀態函數:它接收一個 token、一個位置、參數,以及先前位置快取的鍵/值,並傳回各 token 的 logits(分數),表示模型認為序列中下一個應出現哪個 token。我們沿用 GPT-2 的架構,並作少量簡化:以 RMSNorm 取代 LayerNorm、不使用偏置,並以 ReLU 取代 GeLU。首先介紹三個小型輔助函數:

def linear(x, w):
    return [sum(wi * xi for wi, xi in zip(wo, x)) for wo in w]

linear 是矩陣向量乘法。它接收向量 x 和權重矩陣 w,並為 w 的每一行計算一個點積。這是神經網絡的基本構件:可學習的線性轉換。

def softmax(logits):
    max_val = max(val.data for val in logits)
    exps = [(val - max_val).exp() for val in logits]
    total = sum(exps)
    return [e / total for e in exps]

softmax 會將原始分數(logits)向量轉換成機率分佈;原始分數的範圍可以由 \(-\infty\) 到 \(+\infty\),轉換後所有值都會落在 \([0, 1]\) 範圍內,而且總和為 1。為了確保數值穩定,我們會先減去最大值(這在數學上不會改變結果,但可以防止在 exp 中溢位)。

def rmsnorm(x):
    ms = sum(xi * xi for xi in x) / len(x)
    scale = (ms + 1e-5) ** -0.5
    return [xi * scale for xi in x]

rmsnorm(均方根正規化)會重新縮放向量,使其數值的均方根為 1。這可避免激活值在網絡中傳遞時不斷變大或變小,從而令訓練更穩定。它是較原版 GPT-2 所用的 LayerNorm 更簡單的變體。

接下來是模型本身:

def gpt(token_id, pos_id, keys, values):
    tok_emb = state_dict['wte'][token_id] # token embedding
    pos_emb = state_dict['wpe'][pos_id] # position embedding
    x = [t + p for t, p in zip(tok_emb, pos_emb)] # joint token and position embedding
    x = rmsnorm(x)

    for li in range(n_layer):
        # 1) Multi-head attention block
        x_residual = x
        x = rmsnorm(x)
        q = linear(x, state_dict[f'layer{li}.attn_wq'])
        k = linear(x, state_dict[f'layer{li}.attn_wk'])
        v = linear(x, state_dict[f'layer{li}.attn_wv'])
        keys[li].append(k)
        values[li].append(v)
        x_attn = []
        for h in range(n_head):
            hs = h * head_dim
            q_h = q[hs:hs+head_dim]
            k_h = [ki[hs:hs+head_dim] for ki in keys[li]]
            v_h = [vi[hs:hs+head_dim] for vi in values[li]]
            attn_logits = [sum(q_h[j] * k_h[t][j] for j in range(head_dim)) / head_dim**0.5 for t in range(len(k_h))]
            attn_weights = softmax(attn_logits)
            head_out = [sum(attn_weights[t] * v_h[t][j] for t in range(len(v_h))) for j in range(head_dim)]
            x_attn.extend(head_out)
        x = linear(x_attn, state_dict[f'layer{li}.attn_wo'])
        x = [a + b for a, b in zip(x, x_residual)]
        # 2) MLP block
        x_residual = x
        x = rmsnorm(x)
        x = linear(x, state_dict[f'layer{li}.mlp_fc1'])
        x = [xi.relu() for xi in x]
        x = linear(x, state_dict[f'layer{li}.mlp_fc2'])
        x = [a + b for a, b in zip(x, x_residual)]

    logits = linear(x, state_dict['lm_head'])
    return logits

這個函數會處理位於特定時間位置(pos_id)的一個 token(其 ID 為 token_id),以及由 keys 和 values 中的啟動值概括、來自先前迭代的一些上下文;這些稱為 KV Cache。以下是逐步説明:

嵌入。 神經網絡無法直接處理像 5 這樣的原始 token ID,只能處理向量(數字列表)。因此,我們為每個可能的 token 配上一個經學習得出的向量,並將它作為該 token 的神經特徵輸入。token ID 和位置 ID 會分別從各自的嵌入表(wte 和 wpe)中查找一列。將這兩個向量相加後,便會得到一個表示方式,讓模型同時掌握 token 是甚麼,以及它在序列中的位置。現代 LLM 通常會略過位置嵌入,改用其他基於相對位置的定位方案,例如 RoPE。

Attention 區塊。 當前 token 會投影成三個向量:查詢(Q)、鍵(K)和值(V)。直觀來説,查詢表示「我在找甚麼?」,鍵表示「我包含甚麼?」,而值則表示「如果選中我,我能提供甚麼?」例如,在名稱「emma」中,當模型處理第二個「m」並嘗試預測接下來的內容時,它可能會學到類似「最近出現過甚麼元音?」的查詢。較早出現的「e」會有一個與這項查詢十分匹配的鍵,因此會獲得較高的注意力權重,而它的值(關於它是元音的資訊)則會傳遞到當前位置。鍵和值會附加到 KV cache,讓模型可以取得先前位置的資訊。每個注意力頭都會計算其查詢與所有已快取鍵之間的點積(以 \(\sqrt{d_{head}}\) 縮放),再透過 softmax 得到注意力權重,並對已快取的值作加權總和。所有注意力頭的輸出會串接起來,再經過 attn_wo 投影。值得強調的是,Attention 區塊是 token 在位置 t 唯一可以「查看」過去 0..t-1 的 token 的地方。Attention 是 token 之間的通訊機制。

MLP 區塊。 MLP 是「多層感知器」(multilayer perceptron)的簡稱,是一個兩層前饋網絡:先投影至嵌入維度的 4 倍,再套用 ReLU,然後投影回原來的維度。模型在這裡對每個位置進行大部分的「思考」。與 Attention 不同,這項運算完全侷限於時間 t。Transformer 會交替進行通訊(Attention)和運算(MLP)。

殘差連接。 Attention 和 MLP 區塊都會將各自的輸出加回輸入(x = [a + b for ...])。這讓梯度可以直接在網絡中傳遞,令更深的模型也能訓練。

輸出。 最後的隱藏狀態會經過 lm_head 投影至詞彙表大小,為詞彙表中的每個 token 產生一個 logit。這個例子中,總共只有 27 個數字。logit 越高,代表模型認為相應的 token 越有可能是接下來出現的內容。

你可能會留意到,我們在訓練期間使用了 KV cache,這並不常見。一般人通常只會把 KV cache 與推理聯繫起來。但從概念上説,KV cache 一直都存在,包括訓練期間。在正式環境的實作中,它只是隱藏在高度向量化的注意力計算內,而這項計算會同時處理序列中的所有位置。由於 microgpt 一次只處理一個 token(沒有批次維度,也沒有平行時間步),我們會明確建立 KV cache。與一般推理情境中儲存已分離張量的 KV cache 不同,此處快取的鍵和值是計算圖中仍在運作的 Value 節點,因此我們實際上會透過它們進行反向傳播。

訓練迴圈

現在我們把所有部分連接起來。訓練迴圈會重複以下步驟:(1) 選取一份文件,(2) 讓模型依序處理其中的 token,(3) 計算損失,(4) 反向傳播以取得梯度,以及 (5) 更新參數。

# Let there be Adam, the blessed optimizer and its buffers
learning_rate, beta1, beta2, eps_adam = 0.01, 0.85, 0.99, 1e-8
m = [0.0] * len(params) # first moment buffer
v = [0.0] * len(params) # second moment buffer

# Repeat in sequence
num_steps = 1000 # number of training steps
for step in range(num_steps):

    # Take single document, tokenize it, surround it with BOS special token on both sides
    doc = docs[step % len(docs)]
    tokens = [BOS] + [uchars.index(ch) for ch in doc] + [BOS]
    n = min(block_size, len(tokens) - 1)

    # Forward the token sequence through the model, building up the computation graph all the way to the loss.
    keys, values = [[] for _ in range(n_layer)], [[] for _ in range(n_layer)]
    losses = []
    for pos_id in range(n):
        token_id, target_id = tokens[pos_id], tokens[pos_id + 1]
        logits = gpt(token_id, pos_id, keys, values)
        probs = softmax(logits)
        loss_t = -probs[target_id].log()
        losses.append(loss_t)
    loss = (1 / n) * sum(losses) # final average loss over the document sequence. May yours be low.

    # Backward the loss, calculating the gradients with respect to all model parameters.
    loss.backward()

    # Adam optimizer update: update the model parameters based on the corresponding gradients.
    lr_t = learning_rate * (1 - step / num_steps) # linear learning rate decay
    for i, p in enumerate(params):
        m[i] = beta1 * m[i] + (1 - beta1) * p.grad
        v[i] = beta2 * v[i] + (1 - beta2) * p.grad ** 2
        m_hat = m[i] / (1 - beta1 ** (step + 1))
        v_hat = v[i] / (1 - beta2 ** (step + 1))
        p.data -= lr_t * m_hat / (v_hat ** 0.5 + eps_adam)
        p.grad = 0

    print(f"step {step+1:4d} / {num_steps:4d} | loss {loss.data:.4f}")

逐一看看各個部分:

Tokenization。 每個訓練步驟都會選取一份文件,並在兩端加上 BOS:名稱「emma」會變成 [BOS, e, m, m, a, BOS]。模型的任務是根據之前的 token,預測下一個 token。

前向傳播與損失。 我們逐一把 token 輸入模型,並在過程中建立 KV cache。在每個位置,模型會輸出 27 個 logits,再透過 softmax 將它們轉換為機率。每個位置的損失是正確下一個 token 的負對數機率:\(-\log p(\text{target})\)。這稱為交叉熵損失。直觀來説,損失反映預測錯誤的程度:模型對實際接下來出現的內容有多意外。如果模型為正確的 token 指派 1.0 的機率,它完全不會感到意外,損失便是 0。如果它指派的機率接近 0,模型就會非常意外,損失會趨向 \(+\infty\)。我們會對整份文件各位置的損失取平均,得出單一純量損失。

反向傳播。 呼叫一次 loss.backward(),便會沿整個計算圖執行反向傳播,從損失一路經過 softmax 和模型,再傳至每個參數。完成後,每個參數的 .grad 都會告訴我們應如何調整它,才能降低損失。

Adam 最佳化器。 我們可以直接使用 p.data -= lr * p.grad(梯度下降),但 Adam 更聰明。它會為每個參數維持兩個移動平均值:m 追蹤近期梯度的平均值(動量,就像滾動中的球),而 v 追蹤近期梯度平方的平均值(按參數調整學習率)。m_hat 和 v_hat 是偏差修正,用來處理 m 和 v 初始化為零、需要暖身的情況。學習率會在訓練過程中線性衰減。更新後,我們會重設 .grad = 0,以進行下一步。

經過 1,000 個步驟,損失會由約 3.3(在 27 個 token 中隨機猜測:\(-\log(1/27) \approx 3.3\))降至約 2.37。損失越低越好,最低可達 0(預測完全正確),所以仍有改善空間,但模型顯然正在學習名稱中的統計模式。

推理

訓練完成後,我們可以從模型抽樣產生新名稱。參數會固定不變,我們只需在迴圈中執行前向傳播,並把每個生成的 token 再輸入模型,作為下一步的輸入:

temperature = 0.5 # in (0, 1], control the "creativity" of generated text, low to high
print("\n--- inference (new, hallucinated names) ---")
for sample_idx in range(20):
    keys, values = [[] for _ in range(n_layer)], [[] for _ in range(n_layer)]
    token_id = BOS
    sample = []
    for pos_id in range(block_size):
        logits = gpt(token_id, pos_id, keys, values)
        probs = softmax([l / temperature for l in logits])
        token_id = random.choices(range(vocab_size), weights=[p.data for p in probs])[0]
        if token_id == BOS:
            break
        sample.append(uchars[token_id])
    print(f"sample {sample_idx+1:2d}: {''.join(sample)}")

我們以 BOS token 開始每個樣本,這會告訴模型「開始一個新名稱」。模型會輸出 27 個 logits,我們將它們轉換為機率,然後根據這些機率隨機抽取一個 token。接着將該 token 傳回,作為下一個輸入,重複以上步驟,直到模型再次輸出 BOS(表示「我完成了」),或達到序列長度上限。

temperature 參數控制隨機程度。在 softmax 之前,我們會將 logits 除以温度。温度為 1.0 時,會直接按模型學得的分佈抽樣。較低的温度(例如這裏的 0.5)會令分佈更集中,使模型更保守,並更傾向選擇排名最高的選項。温度趨近 0 時,模型會一直選擇機率最高的單一 token(貪婪解碼)。較高的温度會令分佈更平坦,輸出更多樣,但連貫性可能較低。

執行

你只需要 Python(毋須 pip install,亦無需安裝依賴項):

python train.py

在我的 macbook 上,這個程式約需 1 分鐘執行。你會看到每一步都顯示損失值:

train.py
num docs: 32033
vocab size: 27
num params: 4192
step    1 / 1000 | loss 3.3660
step    2 / 1000 | loss 3.4243
step    3 / 1000 | loss 3.1778
step    4 / 1000 | loss 3.0664
step    5 / 1000 | loss 3.2209
step    6 / 1000 | loss 2.9452
step    7 / 1000 | loss 3.2894
step    8 / 1000 | loss 3.3245
step    9 / 1000 | loss 2.8990
step   10 / 1000 | loss 3.2229
step   11 / 1000 | loss 2.7964
step   12 / 1000 | loss 2.9345
step   13 / 1000 | loss 3.0544
...

看着數值由約 3.3(隨機)逐步降至約 2.37。這個數值越低,代表網絡原本對序列中下一個 token 的預測越準。訓練結束時,訓練 token 序列中的統計模式已濃縮在模型參數之中。固定這些參數後,我們現在可以生成新的、由模型幻覺產生的名稱。你會再次看到:

sample  1: kamon
sample  2: ann
sample  3: karai
sample  4: jaire
sample  5: vialan
sample  6: karia
sample  7: yeran
sample  8: anna
sample  9: areli
sample 10: kaina
sample 11: konna
sample 12: keylen
sample 13: liole
sample 14: alerin
sample 15: earan
sample 16: lenne
sample 17: kana
sample 18: lara
sample 19: alela
sample 20: anton

除了在自己的電腦上執行程式,你也可以嘗試直接在這個 Google Colab 筆記本上執行,並向 Gemini 提出相關問題。試試調整程式!你可以改用不同的數據集,也可以延長訓練時間(增加 num_steps),或增大模型,令結果逐步改善。

演進步驟

若要像逐層剝開洋葱一樣,逐步查看程式碼的構建過程,建議按以下步驟進行:

檔案 新增內容
train0.py 二元組計數表 — 沒有神經網絡,也沒有梯度
train1.py MLP + 手動計算梯度(數值法及解析法)+ SGD
train2.py Autograd(Value 類別)— 取代手動計算梯度
train3.py 位置嵌入 + 單頭注意力 + rmsnorm + 殘差連接
train4.py 多頭注意力 + 層迴圈 — 完整 GPT 架構
train5.py Adam 優化器 — 即 train.py

我建立了一個名為 build_microgpt.py 的 Gist。你可以在修訂記錄中查看所有這些版本,以及每個步驟之間的差異。我認為,這或許是逐步瞭解程式碼庫的好方法,每次加入一個元件。

實際應用

microgpt 包含訓練及執行 GPT 的完整演算法核心。不過,從這個程式到 ChatGPT 這類正式環境中的 LLM,還有一長串需要改變的地方。這些改變都不會影響核心演算法及整體架構,但正是它們令模型能夠大規模運作。以下按相同的次序逐一説明:

數據。正式模型訓練時使用的,不再是 32K 個短名稱,而是數萬億個來自互聯網的文字 token,包括網頁、書籍、程式碼等。數據會先去重,再按質素篩選,並仔細混合不同領域的內容。

分詞器。正式模型不再使用單一字元,而是採用 BPE(Byte Pair Encoding)等子詞分詞器。這些分詞器會學習將經常共同出現的字元序列合併成單一 token。像 “the” 這類常見詞語會變成單一 token,罕見詞語則會拆分成數個部分。這樣會形成一個包含 ~100K 個 token 的詞彙表,效率也高得多,因為模型在每個位置能處理更多內容。

自動微分。 microgpt 在純 Python 中以純量 Value 物件運作。生產環境的系統則使用張量(大型多維數字陣列),並在每秒可執行數十億次浮點運算的 GPU/TPU 上運行。PyTorch 等程式庫負責處理張量的自動微分,而 FlashAttention 等 CUDA 核心會融合多項運算以提升速度。數學原理完全相同,只是對應到大量純量同時平行運算。

架構。 microgpt 有 4,192 個參數。GPT-4 級模型則有數千億個參數。整體而言,它們都是外觀相當相似的 Transformer 神經網絡,只是寬得多(嵌入維度超過 10,000),也深得多(超過 100 層)。現代 LLM 亦會加入幾種額外的組件,並調整它們的排列次序:例如以 RoPE(旋轉位置嵌入)取代學習式位置嵌入、以 GQA(分組查詢注意力)減少 KV 快取大小、以門控線性啟動函數取代 ReLU,以及混合專家(MoE)層等。不過,注意力(負責資訊交流)和 MLP(負責計算)交錯排列於殘差流上的核心結構,仍然保留得很好。

訓練。 生產環境的訓練不會每步處理一份文件,而是使用大型批次(每步數百萬個 token)、梯度累積、混合精度(float16/bfloat16),並仔細調整超參數。訓練一個前沿模型,需要數千個 GPU 持續運行數月。

最佳化。 microgpt 使用 Adam,搭配簡單的線性學習率衰減,除此之外就沒有其他設定。在大規模情況下,最佳化本身會成為一門專業。模型會以較低精度(bfloat16,甚至 fp8)訓練,並在大型 GPU 叢集上運行以提升效率,這也帶來了數值方面的挑戰。最佳化器設定(學習率、權重衰減、beta 參數、預熱排程、衰減排程)必須精確調整,而合適的數值取決於模型大小、批次大小和數據集組成。縮放定律(例如 Chinchilla)有助於指引如何在模型大小和訓練 token 數量之間分配固定的運算預算。大規模訓練時,任何一項細節出錯都可能浪費數百萬美元的運算成本,因此團隊會先進行大量小規模實驗,預測合適的設定,再投入完整訓練。

後訓練。 訓練完成後得到的基礎模型(稱為「預訓練」模型)是文件續寫器,而不是聊天機械人。要把它變成 ChatGPT,需經過兩個階段。第一是 SFT(監督式微調):只需把文件換成經整理的對話,然後繼續訓練。從演算法角度來看,沒有任何改變。第二是 RL(強化學習):模型生成回應,然後由人類、另一個「評審」模型或演算法為回應評分,模型再從這些回饋中學習。從根本上説,模型仍然是在文件上訓練,只是這些文件現在由模型自身產生的 token 組成。

推論。 要向數百萬用戶提供模型服務,需要一套專門的工程技術:把多個請求合併批次處理、管理 KV 快取及分頁(vLLM 等)、使用推測解碼提升速度、透過量化(以 int8/int4 而非 float16 運行)減少記憶體用量,以及把模型分散到多個 GPU 上。從根本上説,我們仍然是在預測序列中的下一個 token,只是投入了大量工程工作來加快速度。

這些都是重要的工程與研究貢獻,但只要理解 microgpt,就能掌握演算法的核心。

常見問題

模型真的「理解」任何事情嗎?這是哲學問題,但從機制上來説:沒有任何魔法。模型是一個大型數學函數,將輸入詞元映射為下一個詞元的機率分佈。訓練期間會調整參數,令正確的下一個詞元出現的機率更高。這是否構成「理解」,由你自行判斷;但整個機制都包含在上面的 200 行程式碼中。

為甚麼它能運作?模型有數千個可調整的參數,而優化器每一步都會稍微調整這些參數,令損失下降。經過多個步驟後,參數會逐漸穩定在能捕捉數據統計規律的數值上。以名字為例,這些規律包括:名字往往以子音開頭、「qu」通常會一起出現,名字很少連續出現三個子音等。模型不會學習明確的規則,而是學習一個恰好反映這些規則的機率分佈。

這與 ChatGPT 有甚麼關係?ChatGPT 是同一個核心循環(預測下一個詞元、抽樣、重複)的超大規模版本,並經過後訓練,使其能進行對話。與它聊天時,系統提示詞、你的訊息和它的回覆,都只是序列中的詞元。模型會一次生成一個詞元,逐步完成整段文本,就像 microgpt 逐步生成一個名字一樣。

「幻覺」是怎麼回事?模型透過從機率分佈中抽樣來生成詞元。它沒有真偽概念,只知道根據訓練數據,哪些序列在統計上看似合理。microgpt「幻覺」出「karia」這樣的名字,與 ChatGPT 信誓旦旦地説出錯誤事實,是同一種現象。兩者生成的內容聽起來都合情合理,但實際上並不存在。

為甚麼它這麼慢?microgpt 使用純 Python,一次處理一個純量。單次訓練需要數秒。同樣的數學運算在 GPU 上可以同時處理數百萬個純量,速度快數個數量級。

我可以讓它生成更好的名字嗎?可以。延長訓練時間(增加 num_steps)、增大模型(n_embd、n_layer、n_head),或使用更大的數據集。這些也是擴大規模時同樣重要的調校項目。

如果我更改數據集會怎樣?模型會學習數據中的任何模式。換成包含城市名稱、Pokemon 名稱、英文單詞或短詩的檔案,模型就會改為學習生成這些內容。其餘程式碼無須更改。

來源:Andrej Karpathy:Blog · karpathy.github.io