GROMAIVN / LLAMACPP_PATCH_GUIDE.md
GRIMIAI-VNAnhdev's picture
Upload 101 files
ea19761 verified
|
Raw History Blame
13.2 kB
# 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.