File size: 13,236 Bytes
ea19761 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 | # Chạy `GromGPT.gguf` trên llama.cpp — hướng dẫn patch kiến trúc mới
## Vì sao cần patch
`export_gguf.py` đóng gói checkpoint GromGPT thành 1 file `.gguf` đúng
chuẩn định dạng (magic, metadata, tensor info, tensor data — đã verify
byte-level trong quá trình phát triển script). Nhưng **định dạng file** và
**khả năng chạy model** là hai việc khác nhau:
- Bất kỳ tool đọc GGUF tổng quát nào (`gguf-dump.py`, thư viện Python
`gguf`...) đều đọc được toàn bộ metadata + tensor của file này ngay lập
tức, không cần patch gì.
- Nhưng **llama.cpp chỉ chạy được các kiến trúc nó đã biết** (`llama`,
`gpt2`, `falcon`, `qwen2`, `phi3`...). File này khai `general.architecture
= "gromgpt-tinygpt"` — một cái tên **hoàn toàn mới**, llama.cpp sẽ báo lỗi
`unknown architecture` nếu bạn nạp thẳng file vào `llama-cli`/`llama-server`
bây giờ.
Để chạy được, cần dạy llama.cpp kiến trúc `gromgpt-tinygpt`: đăng ký enum kiến
trúc mới, khai tên tensor tương ứng, và viết hàm dựng compute graph (ggml)
đúng luồng forward của `GromGPT.forward()` trong `model.py`.
**Việc này đòi hỏi sửa mã nguồn C++ và biên dịch lại llama.cpp** — không thể
làm trong môi trường chạy Python của `export_gguf.py`. Bạn cần một máy có
toàn quyền cài đặt: git, cmake/make, trình biên dịch C++ (gcc/clang/MSVC).
---
## Điểm khác biệt kiến trúc cần lưu ý khi patch
So với GPT-2 (kiến trúc gần nhất llama.cpp đã hỗ trợ sẵn), `GromGPT` có
3 điểm khác:
1. **Pre-LN thay vì Post-LN**: GPT-2 gốc là Post-LN
(`x = x + attn(x); x = ln(x)`), còn `GromGPT` dùng
`norm_first=True` của PyTorch → Pre-LN:
```
x = x + attn(ln1(x))
x = x + ffn(ln2(x))
```
Đây là điểm **DỄ NHẦM NHẤT** khi patch — nếu copy nguyên luồng GPT-2 của
llama.cpp (Post-LN) mà không đảo thứ tự, model sẽ chạy nhưng output sai
hoàn toàn (không có lỗi runtime, chỉ output vô nghĩa).
2. **Weight tying**: `head.weight = token_emb.weight` trong `model.py`.
File `.gguf` **không lưu `gromgpt.output.weight` riêng** — chỉ có
`gromgpt.token_embd.weight`. Khi build compute graph cho lớp output, phải
tái sử dụng chính tensor `token_embd` làm ma trận chiếu ra vocab
(transpose khi nhân ma trận, không load tensor thứ hai).
3. **Learned positional embedding** (giống GPT-2, khác RoPE của
LLaMA/Mistral/Qwen): cộng thẳng `pos_embd[position]` vào token embedding
trước khi vào block đầu tiên — không có rotary embedding nào trong attention.
Attention nội bộ dùng `nn.MultiheadAttention` chuẩn (không có GQA/MQA, không
sliding window, không ALiBi) — softmax attention thông thường với causal
mask tam giác trên (`torch.triu(..., diagonal=1)`), giống hệt causal
attention chuẩn mà llama.cpp đã có sẵn trong `ggml`.
---
## Bước 1 — Đăng ký kiến trúc mới
File: `src/llama-arch.h` (hoặc `llama.cpp` tuỳ phiên bản bạn checkout)
```cpp
// Thêm vào enum llm_arch
enum llm_arch {
// ... các kiến trúc có sẵn ...
LLM_ARCH_GROMGPT_TINYGPT,
LLM_ARCH_UNKNOWN,
};
```
File: `src/llama-arch.cpp`
```cpp
// Thêm vào bảng tên kiến trúc (map arch enum <-> string trong GGUF)
static const std::map<llm_arch, const char *> LLM_ARCH_NAMES = {
// ... các dòng có sẵn ...
{ LLM_ARCH_GROMGPT_TINYGPT, "gromgpt-tinygpt" },
};
// Thêm bảng tên tensor — PHẢI khớp CHÍNH XÁC tên trong export_gguf.py
// (hàm convert_tensors()), vì llama.cpp tra cứu tensor theo tên chuỗi này.
static const std::map<llm_arch, std::map<llm_tensor, const char *>> LLM_TENSOR_NAMES = {
{
LLM_ARCH_GROMGPT_TINYGPT,
{
{ LLM_TENSOR_TOKEN_EMBD, "gromgpt.token_embd" },
{ LLM_TENSOR_POS_EMBD, "gromgpt.pos_embd" },
{ LLM_TENSOR_OUTPUT_NORM, "gromgpt.output_norm" },
// Các tensor theo từng block dùng pattern "gromgpt.blk.%d.xxx"
// (số %d được llama.cpp tự điền theo block_count đọc từ metadata
// "gromgpt.block_count" — xem cách các kiến trúc khác định nghĩa
// LLM_TENSOR_ATTN_Q, LLM_TENSOR_FFN_UP, v.v. để bắt chước đúng
// convention build_tensor_name() nội bộ.
{ LLM_TENSOR_ATTN_NORM, "gromgpt.blk.%d.attn_norm" },
{ LLM_TENSOR_ATTN_Q, "gromgpt.blk.%d.attn_q" },
{ LLM_TENSOR_ATTN_K, "gromgpt.blk.%d.attn_k" },
{ LLM_TENSOR_ATTN_V, "gromgpt.blk.%d.attn_v" },
{ LLM_TENSOR_ATTN_OUT, "gromgpt.blk.%d.attn_output" },
{ LLM_TENSOR_FFN_NORM, "gromgpt.blk.%d.ffn_norm" },
{ LLM_TENSOR_FFN_UP, "gromgpt.blk.%d.ffn_up" },
{ LLM_TENSOR_FFN_DOWN, "gromgpt.blk.%d.ffn_down" },
},
},
};
```
> Tên chuỗi ở trên (`"gromgpt.token_embd"`, `"gromgpt.blk.%d.attn_q"`...) phải
> khớp *tiền tố* với tên đã ghi trong file `.gguf` bởi `export_gguf.py`
> (`gromgpt.token_embd.weight`, `gromgpt.blk.0.attn_q.weight`...) — llama.cpp tự
> gắn hậu tố `.weight`/`.bias` khi tra cứu, xem cách các kiến trúc khác làm
> trong `llama-model.cpp` (`create_tensor()`) để bắt chước đúng.
---
## Bước 2 — Đọc hyperparameter từ metadata GGUF
File: `src/llama-model.cpp`, hàm `load_hparams()` (hoặc tương đương tuỳ
phiên bản) — thêm nhánh cho `LLM_ARCH_GROMGPT_TINYGPT`, đọc đúng các khoá
`gromgpt.*` mà `export_gguf.py` đã ghi:
```cpp
case LLM_ARCH_GROMGPT_TINYGPT:
{
ml.get_key(LLM_KV_CONTEXT_LENGTH, hparams.n_ctx_train); // "gromgpt.context_length"
ml.get_key(LLM_KV_EMBEDDING_LENGTH, hparams.n_embd); // "gromgpt.embedding_length"
ml.get_key(LLM_KV_BLOCK_COUNT, hparams.n_layer); // "gromgpt.block_count"
ml.get_key(LLM_KV_ATTENTION_HEAD_COUNT, hparams.n_head); // "gromgpt.attention.head_count"
ml.get_key(LLM_KV_FEED_FORWARD_LENGTH, hparams.n_ff); // "gromgpt.feed_forward_length"
ml.get_key(LLM_KV_ATTENTION_LAYERNORM_EPS, hparams.f_norm_eps); // "gromgpt.attention.layer_norm_epsilon"
// Không có multi-query/grouped-query attention trong GromGPT:
hparams.n_head_kv = hparams.n_head;
// Model xuất ra là "gpt2-style Pre-LN" — nếu llama.cpp bạn checkout
// có struct hparams riêng cho norm_first, set true ở đây; nếu
// không có, xử lý trực tiếp trong bước dựng graph (Bước 3).
switch (hparams.n_layer) {
// Không cần map cứng n_layer -> tên model như LLaMA — GromGPT
// là kiến trúc tự do kích thước, dùng thẳng giá trị đọc được.
default: model.type = e_model::MODEL_UNKNOWN;
}
} break;
```
Đọc thêm các khoá `tokenizer.ggml.*` diễn ra ở phần load vocab chung của
llama.cpp — vì `export_gguf.py` đã ghi theo đúng convention
`tokenizer.ggml.model = "gpt2"` + `tokens`/`merges`/`scores`, phần này
**tái sử dụng được** logic BPE GPT-2 có sẵn của llama.cpp, không cần viết
tokenizer riêng.
---
## Bước 3 — Dựng compute graph (phần quan trọng nhất)
File: `src/llama-model.cpp` hoặc `src/llama-graph.cpp` tuỳ phiên bản —
tìm nơi các kiến trúc khác định nghĩa hàm `build_<arch>()` (ví dụ
`build_gpt2()`, `build_falcon()`) và thêm `build_gromgpt_tinygpt()` mới.
**Khung sườn logic** (giả code C++ theo API `ggml`, cần đối chiếu API thật
của phiên bản llama.cpp bạn checkout — tên hàm ggml có thể khác đôi chút
giữa các version):
```cpp
ggml_cgraph * build_gromgpt_tinygpt() {
ggml_cgraph * gf = ggml_new_graph(ctx0);
// 1) token + positional embedding (learned, KHÔNG phải RoPE)
ggml_tensor * inpL = ggml_get_rows(ctx0, model.tok_embd, inp_tokens);
ggml_tensor * pos = ggml_get_rows(ctx0, model.pos_embd, inp_positions);
inpL = ggml_add(ctx0, inpL, pos);
for (int il = 0; il < n_layer; ++il) {
ggml_tensor * cur;
// ---- Attention block (PRE-LN: norm TRƯỚC attention) ----
cur = ggml_norm(ctx0, inpL, f_norm_eps);
cur = ggml_add(ctx0, ggml_mul(ctx0, cur, model.layers[il].attn_norm_w),
model.layers[il].attn_norm_b);
ggml_tensor * Qcur = ggml_add(ctx0, ggml_mul_mat(ctx0, model.layers[il].wq, cur), model.layers[il].bq);
ggml_tensor * Kcur = ggml_add(ctx0, ggml_mul_mat(ctx0, model.layers[il].wk, cur), model.layers[il].bk);
ggml_tensor * Vcur = ggml_add(ctx0, ggml_mul_mat(ctx0, model.layers[il].wv, cur), model.layers[il].bv);
// reshape (n_embd, T, B) -> (head_dim, n_head, T, B), hoán vị cho
// ggml_soft_max_ext / ggml_flash_attn — xem cách build_gpt2() làm
// reshape+permute này, GromGPT dùng đúng multi-head attention chuẩn
// (không GQA), nên có thể copy gần như nguyên khối phần reshape.
// causal mask: dùng mask tam giác trên chuẩn (giống GPT-2), khớp
// với torch.triu(..., diagonal=1) trong model.py — không có gì đặc
// biệt khác so với causal attention thông thường.
ggml_tensor * attn_out = /* ... softmax(QK^T/sqrt(d) + causal_mask) @ V ... */;
attn_out = ggml_add(ctx0, ggml_mul_mat(ctx0, model.layers[il].wo, attn_out), model.layers[il].bo);
// residual: x = x + attn(ln1(x)) <-- PRE-LN, cộng residual vào
// inpL GỐC (chưa norm), không phải vào `cur` sau norm.
ggml_tensor * ffn_inp = ggml_add(ctx0, inpL, attn_out);
// ---- FFN block (PRE-LN: norm TRƯỚC feed-forward) ----
cur = ggml_norm(ctx0, ffn_inp, f_norm_eps);
cur = ggml_add(ctx0, ggml_mul(ctx0, cur, model.layers[il].ffn_norm_w),
model.layers[il].ffn_norm_b);
cur = ggml_add(ctx0, ggml_mul_mat(ctx0, model.layers[il].ffn_up_w, cur), model.layers[il].ffn_up_b);
cur = ggml_gelu(ctx0, cur); // activation="gelu" trong model.py — KHÔNG phải SiLU/GeGLU
cur = ggml_add(ctx0, ggml_mul_mat(ctx0, model.layers[il].ffn_down_w, cur), model.layers[il].ffn_down_b);
// residual: x = x + ffn(ln2(x))
inpL = ggml_add(ctx0, ffn_inp, cur);
}
// ---- Output: norm cuối + chiếu ra vocab bằng CHÍNH token_embd (tied) ----
ggml_tensor * cur = ggml_norm(ctx0, inpL, f_norm_eps);
cur = ggml_add(ctx0, ggml_mul(ctx0, cur, model.output_norm_w), model.output_norm_b);
// QUAN TRỌNG: không có model.output — dùng model.tok_embd (weight tying)
ggml_tensor * logits = ggml_mul_mat(ctx0, model.tok_embd, cur);
ggml_build_forward_expand(gf, logits);
return gf;
}
```
**3 lỗi thường gặp nhất khi patch kiến trúc Pre-LN mới** (tự kiểm tra kỹ):
1. Cộng residual vào **input gốc trước norm**, không phải vào output sau
norm — nhầm chỗ này khiến model chạy được nhưng sinh văn bản vô nghĩa,
rất khó debug vì không có lỗi runtime nào cả.
2. Dùng nhầm `ggml_silu` (phổ biến ở LLaMA-family) thay vì `ggml_gelu` —
`model.py` khai rõ `activation="gelu"`.
3. Quên xử lý weight tying, cấp phát nhầm một tensor `output.weight` rỗng
/ random thay vì trỏ lại `tok_embd` — logits sẽ ra toàn nhiễu.
---
## Bước 4 — Build & test
```bash
git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
# ... áp các patch ở Bước 1-3 ...
cmake -B build
cmake --build build --config Release -j
# Copy GromGPT.gguf (xuất bằng export_gguf.py) vào rồi chạy thử:
./build/bin/llama-cli -m /path/to/GromGPT.gguf -p "Người dùng: xin chào\nGROM:" -n 100
```
Cách kiểm tra đúng/sai nhanh nhất: so **logits của bước đầu tiên** (trước
khi sample token nào) giữa bản C++ và bản PyTorch gốc
(`model.py` + checkpoint `.pt`) trên cùng 1 chuỗi input ngắn — nếu hai bên
lệch nhiều (không phải sai số làm tròn fp16 nhỏ), gần như chắc chắn là lỗi
thứ tự residual/norm (lỗi #1 ở trên).
---
## Tóm tắt việc cần làm ở máy build của bạn
| Bước | File cần sửa | Việc |
|---|---|---|
| 1 | `src/llama-arch.h`, `src/llama-arch.cpp` | Đăng ký `LLM_ARCH_GROMGPT_TINYGPT` + tên tensor |
| 2 | `src/llama-model.cpp` (`load_hparams`) | Đọc hyperparameter từ khoá `gromgpt.*` |
| 3 | `src/llama-model.cpp`/`llama-graph.cpp` | Viết `build_gromgpt_tinygpt()` — Pre-LN, GELU, weight tying |
| 4 | build + test | So sánh logits với bản PyTorch gốc trên 1 input mẫu |
File `.gguf` do `export_gguf.py` tạo ra đã sẵn sàng — phần còn lại là công
việc C++ thuần tuý trên máy bạn.
|