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)

// 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

// 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:

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):

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

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.