250行程式碼從頭搭建Llama 3，GitHub一天4.6k星！Karpathy大贊

2024-05-29碼農

點選上方↑↑↑「OpenCV學堂」關註我

來源：公眾號新智元授權

【導讀】 Llama 3釋出一個月後，一位開發者在GitHub上建立了名為「從頭開始實作Llama 3」的計畫，引起了開源社群的廣泛關註。程式碼非常詳細地展現了Llama所使用的Transformer架構，甚至讓Andrej Karpathy親自下場「背書」。

Llama系列作為為數不多的優質開源LLM，一直受到開發者們的追捧。在Hugging Face社群的文本生成模型中，幾乎是「霸榜」的存在。

就在520這天，一位名叫Nishant Aklecha的開發者在推特上宣布了自己的一個開源計畫，名為「從頭開始實作Llama 3」。

這個計畫詳細到什麽程度呢——

矩陣乘法、註意力頭、位置編碼等模組全部都拆開解釋。

而且計畫全部用Jupyter Notebook寫成，小白都可以直接上手執行。

堪比哈佛NLP小組曾經出品的「The Annotated Transformer」。

https://nlp.seas.harvard.edu/annotated-transformer/

才一天多的時間，小哥發表的這篇推特已經有32萬次閱讀，甚至被Andrej Karpathy大佬親自點贊——

「全部拆開解釋之後，透過模組的巢狀以及互相呼叫，可以更清楚地看到模型到底做了什麽。」

計畫也在GitHub上獲得了4.6k星。

計畫地址：https://github.com/naklecha/llama3-from-scratch

那就讓我們來看看作者是如何深入拆解Llama 3的。

下載並讀取模型權重

首先需要從Meta官網下載模型權重檔，以便後續執行時使用。

https://github.com/meta-llama/llama3/blob/main/README.md

下載後需要先讀取權重檔中的變量名：

model = torch.load("Meta-Llama-3-8B/consolidated.00.pth") print(json.dumps(list(model.keys())[:20], indent=4))

[ "tok_embeddings.weight", "layers.0.attention.wq.weight", "layers.0.attention.wk.weight", "layers.0.attention.wv.weight", "layers.0.attention.wo.weight", "layers.0.feed_forward.w1.weight", "layers.0.feed_forward.w3.weight", "layers.0.feed_forward.w2.weight", "layers.0.attention_norm.weight", "layers.0.ffn_norm.weight", "layers.1.attention.wq.weight", "layers.1.attention.wk.weight", "layers.1.attention.wv.weight", "layers.1.attention.wo.weight", "layers.1.feed_forward.w1.weight", "layers.1.feed_forward.w3.weight", "layers.1.feed_forward.w2.weight", "layers.1.attention_norm.weight", "layers.1.ffn_norm.weight", "layers.2.attention.wq.weight" ]

以及模型的配置資訊：

with open("Meta-Llama-3-8B/params.json", "r") asf: config = json.load(f) config

{'dim': 4096, 'n_layers': 32, 'n_heads': 32, 'n_kv_heads': 8, 'vocab_size': 128256, 'multiple_of': 1024, 'ffn_dim_multiplier': 1.3, 'norm_eps': 1e-05, 'rope_theta': 500000.0}

根據以上輸出，可以推斷出模型架構的資訊——

32個transformer層

每個多頭註意力模組有32個註意力頭

分詞器的詞匯量為128256

直接將模型配置資訊儲存到變量中，方便使用。

dim = config["dim"]n_layers = config["n_layers"]n_heads = config["n_heads"]n_kv_heads = config["n_kv_heads"]vocab_size = config["vocab_size"]multiple_of = config["multiple_of"]ffn_dim_multiplier = config["ffn_dim_multiplier"]norm_eps = config["norm_eps"]rope_theta = torch.tensor(config["rope_theta"])

分詞器與編碼

那麽就從語言模型的第一步——分詞器開始，但是這一步並不需要我們自己手寫。

Llama 3使用了GPT等大模型常用的BPE分詞器，karpathy大佬之前就復現過一個最簡版。

https://github.com/karpathy/minbpe

除了Karapthy大佬復現的版本，OpenAI也開源了一個執行速度很快的分詞器tiktoken。這兩個隨便挑，估計都比自己從頭訓練的要強。

https://github.com/openai/tiktoken

有了分詞器，下一步就是要把輸入的文本切分為token。

prompt = "the answer to the ultimate question of life, the universe, and everything is "tokens = [128000] + tokenizer.encode(prompt)print(tokens)tokens = torch.tensor(tokens)prompt_split_as_tokens = [tokenizer.decode([token.item()]) for token in tokens]print(prompt_split_as_tokens)

[128000, 1820, 4320, 311, 279, 17139, 3488, 315, 2324, 11, 279, 15861, 11, 323, 4395, 374, 220]['<|begin_of_text|>', 'the', ' answer', ' to', ' the', ' ultimate', ' question', ' of', ' life', ',', ' the', ' universe', ',', ' and', ' everything', ' is', ' ']

再使用PyTorch內建的神經網路模組（torch.nn）將token轉換為embedding，[17x1]的token維度變為[17x4096]。

embedding_layer = torch.nn.Embedding(vocab_size, dim)embedding_layer.weight.data.copy_(model["tok_embeddings.weight"])token_embeddings_unnormalized = embedding_layer(tokens).to(torch.bfloat16)token_embeddings_unnormalized.shape

torch.Size([17, 4096])

此處應該是整個計畫中唯一使用PyTorch內建模組的地方。而且，作者給出了溫馨提示——記得經常打印一下張量維度，更容易理解。

之後再使用RMS對embedding進行歸一化處理。這一步不會改變張量形狀，只是歸一化其中的數值，公式如下：

模型配置中的norm_eps變量設定為1e-5，就是用在此處，防止rms值意外設定為0。

# def rms_norm(tensor, norm_weights):# rms = (tensor.pow(2).mean(-1, keepdim=True) + norm_eps)**0.5# return tensor * (norm_weights / rms)defrms_norm(tensor, norm_weights):return (tensor * torch.rsqrt(tensor.pow(2).mean(-1, keepdim=True) + norm_eps)) * norm_weights

構建Transformer層

每一個Transformer層都需要經過如下步驟：

由於是從頭構建，我們只需要存取模型字典中第一層（layer.0）的權重。

先用剛才定義的rms_norm函式，結合模型權重，進行embedding的歸一化處理。

token_embeddings = rms_norm(token_embeddings_unnormalized, model["layers.0.attention_norm.weight"])token_embeddings.shape

torch.Size([17, 4096])

多頭註意力

查詢向量

讓我們先用一張圖復習註意力機制的計算過程：

如果從模型直接載入查詢、鍵、值和輸出的權重，我們會得到四個二維矩陣，形狀分別為 [4096x4096]、[1024x4096]、[1024x4096]、[4096x4096]。

print( model["layers.0.attention.wq.weight"].shape, model["layers.0.attention.wk.weight"].shape, model["layers.0.attention.wv.weight"].shape, model["layers.0.attention.wo.weight"].shape)

torch.Size([4096, 4096]) torch.Size([1024, 4096]) torch.Size([1024, 4096]) torch.Size([4096, 4096])

因為大模型考慮了註意力中乘法並列化的需求，壓縮了矩陣維度。但是為了更清楚地展示機制，作者決定將這些矩陣都展開。

模型有32個註意力頭，因此查詢權重矩陣應該展開為[32x128x4096]，其中128是查詢向量的長度，4096是embedding的維度。

q_layer0 = model["layers.0.attention.wq.weight"]head_dim = q_layer0.shape[0] // n_headsq_layer0 = q_layer0.view(n_heads, head_dim, dim)q_layer0.shape

torch.Size([32, 128, 4096])

於是可以存取第一個註意力頭的查詢權重，維度是[128x4096]。

q_layer0_head0 = q_layer0[0]q_layer0_head0.shape

torch.Size([128, 4096])

現在將查詢權重與embedding相乘，就得到了查詢矩陣，維度為[17x128]，表示長度為17的句子，其中每個token都有維度為128的查詢向量。

q_per_token = torch.matmul(token_embeddings, q_layer0_head0.T)q_per_token.shape

torch.Size([17, 128])

位置編碼

由於註意力機制中對每個token沒有序列「位置」的概念，第一個詞和最後一個詞在Q、K、V矩陣看來都是一樣的，因此需要在查詢向量中嵌入維度為[1x128]的位置編碼。

位置編碼有多種方法，Llama模型采用的是旋轉位置編碼（RoPE）。

首先將查詢向量兩兩分為一對，共有64對。

q_per_token_split_into_pairs = q_per_token.float().view(q_per_token.shape[0], -1, 2)q_per_token_split_into_pairs.shape

torch.Size([17, 64, 2])

句子中在m位置的一對查詢向量，旋轉角度為m*(rope_theta)，其中rope_theta也在模型的配置資訊中。

zero_to_one_split_into_64_parts = torch.tensor(range(64))/64zero_to_one_split_into_64_parts

tensor([0.0000, 0.0156, 0.0312, 0.0469, 0.0625, 0.0781, 0.0938, 0.1094, 0.1250, 0.1406, 0.1562, 0.1719, 0.1875, 0.2031, 0.2188, 0.2344, 0.2500, 0.2656, 0.2812, 0.2969, 0.3125, 0.3281, 0.3438, 0.3594, 0.3750, 0.3906, 0.4062, 0.4219, 0.4375, 0.4531, 0.4688, 0.4844, 0.5000, 0.5156, 0.5312, 0.5469, 0.5625, 0.5781, 0.5938, 0.6094, 0.6250, 0.6406, 0.6562, 0.6719, 0.6875, 0.7031, 0.7188, 0.7344, 0.7500, 0.7656, 0.7812, 0.7969, 0.8125, 0.8281, 0.8438, 0.8594, 0.8750, 0.8906, 0.9062, 0.9219, 0.9375, 0.9531, 0.9688, 0.9844])

freqs = 1.0 / (rope_theta ** zero_to_one_split_into_64_parts)freqs

tensor([1.0000e+00, 8.1462e-01, 6.6360e-01, 5.4058e-01, 4.4037e-01, 3.5873e-01, 2.9223e-01, 2.3805e-01, 1.9392e-01, 1.5797e-01, 1.2869e-01, 1.0483e-01, 8.5397e-02, 6.9566e-02, 5.6670e-02, 4.6164e-02, 3.7606e-02, 3.0635e-02, 2.4955e-02, 2.0329e-02, 1.6560e-02, 1.3490e-02, 1.0990e-02, 8.9523e-03, 7.2927e-03, 5.9407e-03, 4.8394e-03, 3.9423e-03, 3.2114e-03, 2.6161e-03, 2.1311e-03, 1.7360e-03, 1.4142e-03, 1.1520e-03, 9.3847e-04, 7.6450e-04, 6.2277e-04, 5.0732e-04, 4.1327e-04, 3.3666e-04, 2.7425e-04, 2.2341e-04, 1.8199e-04, 1.4825e-04, 1.2077e-04, 9.8381e-05, 8.0143e-05, 6.5286e-05, 5.3183e-05, 4.3324e-05, 3.5292e-05, 2.8750e-05, 2.3420e-05, 1.9078e-05, 1.5542e-05, 1.2660e-05, 1.0313e-05, 8.4015e-06, 6.8440e-06, 5.5752e-06, 4.5417e-06, 3.6997e-06, 3.0139e-06, 2.4551e-06])

freqs_for_each_token = torch.outer(torch.arange(17), freqs)freqs_cis = torch.polar(torch.ones_like(freqs_for_each_token), freqs_for_each_token)

經過以上操作後，我們構建了freq_cis矩陣，儲存句子中每個位置的、對查詢向量每個值的旋轉角度。

將每對查詢向量轉換為復數，之後進行與旋轉角度進行點積操作。

q_per_token_as_complex_numbers = torch.view_as_complex(q_per_token_split_into_pairs)q_per_token_as_complex_numbers.shape

torch.Size([17, 64])

q_per_token_as_complex_numbers_rotated = q_per_token_as_complex_numbers * freqs_cisq_per_token_as_complex_numbers_rotated.shape

torch.Size([17, 64])

這樣我們就得到了旋轉後的查詢向量，需要再轉換回實數形式。

q_per_token_split_into_pairs_rotated = torch.view_as_real(q_per_token_as_complex_numbers_rotated)q_per_token_split_into_pairs_rotated.shape

torch.Size([17, 64, 2])

q_per_token_rotated = q_per_token_split_into_pairs_rotated.view(q_per_token.shape)q_per_token_rotated.shape

torch.Size([17, 128])

旋轉後的查詢向量，維度依舊是 [17x128]。

鍵向量

鍵向量的計算與查詢向量非常類似，也需要進行旋轉位置編碼，只是維度有所差異。

鍵的權重數量僅為查詢的1/4，因為需要減少模型計算量，每個權重值被4個註意力頭共享。

k_layer0 = model["layers.0.attention.wk.weight"]k_layer0 = k_layer0.view(n_kv_heads, k_layer0.shape[0] // n_kv_heads, dim)k_layer0.shape

torch.Size([8, 128, 4096])

因此這裏第一個維度的值為8，而不是我們在查詢權重中看到的32。

k_layer0_head0 = k_layer0[0]k_per_token = torch.matmul(token_embeddings, k_layer0_head0.T)k_per_token_split_into_pairs = k_per_token.float().view(k_per_token.shape[0], -1, 2)k_per_token_as_complex_numbers = torch.view_as_complex(k_per_token_split_into_pairs)k_per_token_split_into_pairs_rotated = torch.view_as_real(k_per_token_as_complex_numbers * freqs_cis)k_per_token_rotated = k_per_token_split_into_pairs_rotated.view(k_per_token.shape)k_per_token_rotated.shape

torch.Size([17, 128])

照著前面查詢向量部份的計算流程，就可以得到句子中每個token的鍵向量了。

查詢和鍵相乘

對句子進行「自註意力」的過程，就是將查詢向量和鍵向量相乘，得到的QK矩陣中的每個值描述了對應位置token查詢值和鍵值的相關程度。

相乘後，我們會得到一個維度為[17x17]自註意力矩陣。

qk_per_token = torch.matmul(q_per_token_rotated, k_per_token_rotated.T)/(head_dim)**0.5qk_per_token.shape

torch.Size([17, 17])

掩碼

語言模型的學習目標，是根據句子之前的內容預測下一個token，因此訓練和推理時需要將token位置之後的QK分數遮蔽。

值向量

值權重數量和鍵權重一樣，都是在4個註意力頭之間共享（以節省計算量）。

v_layer0 = model["layers.0.attention.wv.weight"]v_layer0 = v_layer0.view(n_kv_heads, v_layer0.shape[0] // n_kv_heads, dim)v_layer0.shape

torch.Size([8, 128, 4096])

之後我們獲取第一層第一個註意力頭的值權重，與句子embedding相乘，獲取值向量。

v_layer0_head0 = v_layer0[0]v_per_token = torch.matmul(token_embeddings, v_layer0_head0.T)v_per_token.shape

torch.Size([17, 128])

註意力向量

將進行過掩碼的QK矩陣和句子的值向量相乘，就得到了註意力矩陣，維度為[17x128]。

qkv_attention = torch.matmul(qk_per_token_after_masking_after_softmax, v_per_token)qkv_attention.shape

torch.Size([17, 128])

多頭註意力

以上得到的註意力矩陣，是第一層第一個註意力頭的計算結果。

接下來需要執行一個迴圈，對第一層中所有32個註意力頭進行上述運算過程。

qkv_attention_store = []for head in range(n_heads): q_layer0_head = q_layer0[head] k_layer0_head = k_layer0[head//4] # key weights are shared across 4 heads v_layer0_head = v_layer0[head//4] # value weights are shared across 4 heads q_per_token = torch.matmul(token_embeddings, q_layer0_head.T) k_per_token = torch.matmul(token_embeddings, k_layer0_head.T) v_per_token = torch.matmul(token_embeddings, v_layer0_head.T) q_per_token_split_into_pairs = q_per_token.float().view(q_per_token.shape[0], -1, 2) q_per_token_as_complex_numbers = torch.view_as_complex(q_per_token_split_into_pairs) q_per_token_split_into_pairs_rotated = torch.view_as_real(q_per_token_as_complex_numbers * freqs_cis[:len(tokens)]) q_per_token_rotated = q_per_token_split_into_pairs_rotated.view(q_per_token.shape) k_per_token_split_into_pairs = k_per_token.float().view(k_per_token.shape[0], -1, 2) k_per_token_as_complex_numbers = torch.view_as_complex(k_per_token_split_into_pairs) k_per_token_split_into_pairs_rotated = torch.view_as_real(k_per_token_as_complex_numbers * freqs_cis[:len(tokens)]) k_per_token_rotated = k_per_token_split_into_pairs_rotated.view(k_per_token.shape) qk_per_token = torch.matmul(q_per_token_rotated, k_per_token_rotated.T)/(128)**0.5 mask = torch.full((len(tokens), len(tokens)), float("-inf"), device=tokens.device) mask = torch.triu(mask, diagonal=1) qk_per_token_after_masking = qk_per_token + mask qk_per_token_after_masking_after_softmax = torch.nn.functional.softmax(qk_per_token_after_masking, dim=1).to(torch.bfloat16) qkv_attention = torch.matmul(qk_per_token_after_masking_after_softmax, v_per_token) qkv_attention = torch.matmul(qk_per_token_after_masking_after_softmax, v_per_token) qkv_attention_store.append(qkv_attention)len(qkv_attention_store)

32

為了平行計算的方便，我們需要把上面展開的矩陣壓縮回去。

也就是將32個維度為[17x128]的註意力矩陣，壓縮成一個維度為[17x4096]的大矩陣。

stacked_qkv_attention = torch.cat(qkv_attention_store, dim=-1)stacked_qkv_attention.shape

torch.Size([17, 4096])

最後，別忘了乘以輸出權重矩陣。

w_layer0 = model["layers.0.attention.wo.weight"]w_layer0.shape# torch.Size([4096, 4096])embedding_delta = torch.matmul(stacked_qkv_attention, w_layer0.T)embedding_delta.shape

torch.Size([17, 4096])

至此，註意力模組的計算就結束了。

相加與歸一化

對照這張Transformer層的架構圖，在多頭自註意力模組之後還需要完成一些運算。

首先將註意力模組的輸出與原始的embedding相加。

embedding_after_edit = token_embeddings_unnormalized + embedding_deltaembedding_after_edit.shape

torch.Size([17, 4096])

之後進行RMS歸一化。

embedding_after_edit_normalized = rms_norm(embedding_after_edit, model["layers.0.ffn_norm.weight"])embedding_after_edit_normalized.shape

torch.Size([17, 4096])

前饋神經網路層

Llama 3的Transformer層中使用了SwiGLU前饋網路，這種架構非常擅長在必要情況下為模型添加非線性，這也是當今LLM中的常見操作。

SwiGLU與Vanilla兩種前饋神經網路架構的對比

於是我們從模型中載入前饋網路的權重，並按照公式計算：

w1 = model["layers.0.feed_forward.w1.weight"]w2 = model["layers.0.feed_forward.w2.weight"]w3 = model["layers.0.feed_forward.w3.weight"]output_after_feedforward = torch.matmul(torch.functional.F.silu(torch.matmul(embedding_after_edit_normalized, w1.T)) * torch.matmul(embedding_after_edit_normalized, w3.T), w2.T)output_after_feedforward.shape

torch.Size([17, 4096])

別忘了前饋層之後還有一次相加。

layer_0_embedding = embedding_after_edit+output_after_feedforwardlayer_0_embedding.shape

torch.Size([17, 4096])

以上就是一個完整Transformer層的實作，最終輸出的向量維度為[17x4096]，相當於為句子中每個token重新計算了一個長度為4096的embedding向量。

預測下一個輸出

之後的每一個Transformer層都會編碼出越來越復雜的查詢，直到最後一層的輸出的embedding可以預測句子下一個token。

因此需要再巢狀一個外層迴圈，將Transformer層的流程重復32次。

final_embedding = token_embeddings_unnormalizedforlayer in range(n_layers):qkv_attention_store = []layer_embedding_norm = rms_norm(final_embedding, model[f"layers.{layer}.attention_norm.weight"])q_layer = model[f"layers.{layer}.attention.wq.weight"]q_layer = q_layer.view(n_heads, q_layer.shape[0] // n_heads, dim)k_layer = model[f"layers.{layer}.attention.wk.weight"]k_layer = k_layer.view(n_kv_heads, k_layer.shape[0] // n_kv_heads, dim)v_layer = model[f"layers.{layer}.attention.wv.weight"]v_layer = v_layer.view(n_kv_heads, v_layer.shape[0] // n_kv_heads, dim)w_layer = model[f"layers.{layer}.attention.wo.weight"]forhead in range(n_heads):q_layer_head = q_layer[head]k_layer_head = k_layer[head//4]v_layer_head = v_layer[head//4]q_per_token = torch.matmul(layer_embedding_norm, q_layer_head.T)k_per_token = torch.matmul(layer_embedding_norm, k_layer_head.T)v_per_token = torch.matmul(layer_embedding_norm, v_layer_head.T)q_per_token_split_into_pairs = q_per_token.float().view(q_per_token.shape[0], -1, 2)q_per_token_as_complex_numbers = torch.view_as_complex(q_per_token_split_into_pairs)q_per_token_split_into_pairs_rotated = torch.view_as_real(q_per_token_as_complex_numbers * freqs_cis)q_per_token_rotated = q_per_token_split_into_pairs_rotated.view(q_per_token.shape)k_per_token_split_into_pairs = k_per_token.float().view(k_per_token.shape[0], -1, 2)k_per_token_as_complex_numbers = torch.view_as_complex(k_per_token_split_into_pairs)k_per_token_split_into_pairs_rotated = torch.view_as_real(k_per_token_as_complex_numbers * freqs_cis)k_per_token_rotated = k_per_token_split_into_pairs_rotated.view(k_per_token.shape)qk_per_token = torch.matmul(q_per_token_rotated, k_per_token_rotated.T)/(128)**0.5mask = torch.full((len(token_embeddings_unnormalized), len(token_embeddings_unnormalized)), float("-inf"))mask = torch.triu(mask, diagonal=1)qk_per_token_after_masking = qk_per_token + maskqk_per_token_after_masking_after_softmax = torch.nn.functional.softmax(qk_per_token_after_masking, dim=1).to(torch.bfloat16)qkv_attention = torch.matmul(qk_per_token_after_masking_after_softmax, v_per_token)qkv_attention_store.append(qkv_attention)stacked_qkv_attention = torch.cat(qkv_attention_store, dim=-1)w_layer = model[f"layers.{layer}.attention.wo.weight"]embedding_delta = torch.matmul(stacked_qkv_attention, w_layer.T)embedding_after_edit = final_embedding + embedding_deltaembedding_after_edit_normalized = rms_norm(embedding_after_edit, model[f"layers.{layer}.ffn_norm.weight"])w1 = model[f"layers.{layer}.feed_forward.w1.weight"]w2 = model[f"layers.{layer}.feed_forward.w2.weight"]w3 = model[f"layers.{layer}.feed_forward.w3.weight"]output_after_feedforward = torch.matmul(torch.functional.F.silu(torch.matmul(embedding_after_edit_normalized, w1.T)) * torch.matmul(embedding_after_edit_normalized, w3.T), w2.T)final_embedding = embedding_after_edit+output_after_feedforward