|
Download LLAMACPP_PATCH_GUIDE.md from GRIMIAI-VNAnhdev/GROMAIVN: direct link, hf CLI and curl.
- Browser
- Download file 13.2 kB
-
https://huggingface.co/datasets/GRIMIAI-VNAnhdev/GROMAIVN/resolve/main/LLAMACPP_PATCH_GUIDE.md
- Command line
-
hf download hf://datasets/GRIMIAI-VNAnhdev/GROMAIVN/LLAMACPP_PATCH_GUIDE.md
-
curl -L -o LLAMACPP_PATCH_GUIDE.md https://huggingface.co/datasets/GRIMIAI-VNAnhdev/GROMAIVN/resolve/main/LLAMACPP_PATCH_GUIDE.md
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. | |