# 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_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_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_()` (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.