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.