* convert : add Inkling2 text GGUF conversion Assisted-by: Codex * llama : implement Inkling2 text inference Assisted-by: Codex * tests : cover Inkling2 text support Assisted-by: Codex * conversion : dequantize packed Inkling2 experts in row chunks Decode per-layer NVFP4 and MXFP8 schemes, validate companions, and use stored scale shapes with a warning for the declared MXFP8 [32,32] grid. Reorder packed w13 rows and their scale rows together. Keep normal GGUF outtype selection and 3D expert tensors. Stream 128 rows per expert through LazyChunkedTensor. Real w13 (384x4608x4608) needs a 2.25 MiB F32 chunk instead of a 30.375 GiB expanded layer. Real-shaped sparse probes peak below 5.8 MiB of Python/NumPy chunk allocations, plus 5.2 MiB of callback metadata: budget about 16 MiB per projection including mapped pages, excluding runtime, other tensors and OS cache. Full-model chunk metadata is roughly 370 MiB. Packed synthetic GGUF weights match the independent pinned vLLM decode bit-for-bit. CPU prefill/decode logits remain within 3.1e-6 absolute error, with 100% argmax agreement. Float fixtures, original-name conversion and CPU architecture checks pass. Real checkpoint conversion remains untested. Assisted-by: Codex * convert : add Inkling2 vision mmproj support Assisted-by: Codex * mtmd : implement Inkling2 still-image encoder Assisted-by: Codex * inkling2 : scope image loading Assisted-by: Codex * inkling2 : enable flash attention with folded bias and sinks Assisted-by: Codex * cuda : route per-head flash attention masks through vec Assisted-by: Codex * mtmd : support Inkling2 temporal frame means Assisted-by: Codex * style : restore shared image comment Assisted-by: Codex * tests : enlarge Inkling2 context fixture Assisted-by: Codex * inkling2 : load per-layer expert feed-forward widths Assisted-by: Codex * tests : add Inkling2 Metal fusion baselines Assisted-by: Codex * inkling2 : group and align registry entries Assisted-by: Fable * convert : regenerate the Inkling2 tokenizer hash with the update script Assisted-by: Fable * conversion : revert the print_registered_models change Assisted-by: Fable * conversion : sort the Inkling2 model map entries Assisted-by: Fable * convert : map Inkling2 vision checkpoint names in the tensor table Assisted-by: Fable * convert : map Inkling2 text checkpoint names in the tensor table Assisted-by: Fable * tests : document the Inkling2 packed expert conversion test Assisted-by: Fable * tests : cover Inkling2 checkpoint and transformers tensor names Assisted-by: Fable * llama : place Inkling2 fields and list entries by file convention Assisted-by: Fable * gguf-py : align Inkling2 tensor mapping comments Assisted-by: Fable * mtmd : place Inkling2 entries by file convention Assisted-by: Fable * tests : place Inkling2 cases after the existing ones Assisted-by: Fable * cuda : index per-head flash attention masks in the tile and mma kernels Assisted-by: Claude Claude-Session: https://claude.ai/code/session_01GbYSza1yxgmTz8wdr6uV8Q * inkling2 : project the relative bias before the gather, drop arch branches Assisted-by: Claude Claude-Session: https://claude.ai/code/session_01GbYSza1yxgmTz8wdr6uV8Q * convert : require Inkling2 hparams, add inkling2 pre-tokenizer Assisted-by: Claude Claude-Session: https://claude.ai/code/session_01GbYSza1yxgmTz8wdr6uV8Q * mtmd : cap Inkling2 image size, drop video frame averaging Assisted-by: Claude Claude-Session: https://claude.ai/code/session_01GbYSza1yxgmTz8wdr6uV8Q * inkling2 : fix CI build, Meta device assert and Windows conversion test Assisted-by: Claude * tests : use the default sliding window for the Inkling2 test model Assisted-by: Claude * simplify mtmd part * give _v arch for vision * remove alpha channel handling, it should be a follow up * explicit rule about audio + vision models * add audio support * rm audio * rm gguf mtmd rope base * address review comment * nits * do not normalize embd from mtmd --------- Co-authored-by: Xuan Son Nguyen <son@huggingface.co>
359 lines
9.5 KiB
C++
359 lines
9.5 KiB
C++
#include "llama-hparams.h"
|
|
|
|
#include "ggml.h"
|
|
|
|
#include <algorithm>
|
|
#include <cassert>
|
|
|
|
void llama_hparams::set_swa_pattern(uint32_t n_pattern, bool dense_first) {
|
|
if (dense_first) {
|
|
for (uint32_t il = 0; il < n_layer(); ++il) {
|
|
is_swa_impl[il] = n_pattern == 0 || (il % n_pattern != 0);
|
|
}
|
|
} else {
|
|
for (uint32_t il = 0; il < n_layer(); ++il) {
|
|
is_swa_impl[il] = n_pattern == 0 || (il % n_pattern < (n_pattern - 1));
|
|
}
|
|
}
|
|
|
|
for (uint32_t il = n_layer(); il < n_layer_all; ++il) {
|
|
is_swa_impl[il] = false;
|
|
}
|
|
}
|
|
|
|
void llama_hparams::set_recr_pattern(uint32_t n_pattern, bool dense_first) {
|
|
if (dense_first) {
|
|
for (uint32_t il = 0; il < n_layer(); ++il) {
|
|
is_recr_impl[il] = n_pattern == 0 || (il % n_pattern != 0);
|
|
}
|
|
} else {
|
|
for (uint32_t il = 0; il < n_layer(); ++il) {
|
|
is_recr_impl[il] = n_pattern == 0 || (il % n_pattern < (n_pattern - 1));
|
|
}
|
|
}
|
|
|
|
for (uint32_t il = n_layer(); il < n_layer_all; ++il) {
|
|
is_recr_impl[il] = false;
|
|
}
|
|
}
|
|
|
|
bool llama_hparams::is_swa_any() const {
|
|
for (uint32_t il = 0; il < n_layer_all; ++il) {
|
|
if (is_swa_impl[il]) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
uint32_t llama_hparams::n_head(uint32_t il) const {
|
|
if (il < n_layer_all) {
|
|
return n_head_arr[il];
|
|
}
|
|
|
|
GGML_ABORT("fatal error");
|
|
}
|
|
|
|
uint32_t llama_hparams::n_head_kv(uint32_t il) const {
|
|
if (il < n_layer_all) {
|
|
return n_head_kv_arr[il];
|
|
}
|
|
|
|
GGML_ABORT("fatal error");
|
|
}
|
|
|
|
uint32_t llama_hparams::n_ff(uint32_t il) const {
|
|
if (il < n_layer_all) {
|
|
return n_ff_arr[il];
|
|
}
|
|
|
|
GGML_ABORT("fatal error");
|
|
}
|
|
|
|
uint32_t llama_hparams::n_ff_exp(uint32_t il) const {
|
|
if (il < n_layer_all) {
|
|
return n_ff_exp_arr[il];
|
|
}
|
|
|
|
GGML_ABORT("fatal error");
|
|
}
|
|
|
|
uint32_t llama_hparams::n_expert_used(uint32_t il) const {
|
|
if (il < n_layer_all) {
|
|
return n_expert_used_arr[il];
|
|
}
|
|
|
|
GGML_ABORT("fatal error");
|
|
}
|
|
|
|
uint32_t llama_hparams::n_expert_used_max() const {
|
|
uint32_t val = 0;
|
|
for (uint32_t il = 0; il < n_layer_all; ++il) {
|
|
val = std::max(val, n_expert_used(il));
|
|
}
|
|
|
|
return val;
|
|
}
|
|
|
|
uint32_t llama_hparams::n_gqa(uint32_t il) const {
|
|
const uint32_t n_head = this->n_head(il);
|
|
const uint32_t n_head_kv = this->n_head_kv(il);
|
|
|
|
if (n_head_kv == 0) {
|
|
return 0;
|
|
}
|
|
|
|
return n_head/n_head_kv;
|
|
}
|
|
|
|
uint32_t llama_hparams::n_rot(uint32_t il) const {
|
|
if (il < n_layer_all) {
|
|
return is_swa(il) ? n_rot_swa : n_rot_full;
|
|
}
|
|
|
|
GGML_ABORT("fatal error");
|
|
}
|
|
|
|
uint32_t llama_hparams::n_embd_inp() const {
|
|
if (n_embd_inp_impl > 0) {
|
|
return n_embd_inp_impl;
|
|
}
|
|
|
|
uint32_t n_embd_inp = n_embd;
|
|
|
|
if (n_deepstack_layers > 0) {
|
|
n_embd_inp += n_embd * n_deepstack_layers;
|
|
}
|
|
|
|
return n_embd_inp;
|
|
}
|
|
|
|
uint32_t llama_hparams::n_embd_inp_enc() const {
|
|
return n_embd_inp_enc_impl > 0 ? n_embd_inp_enc_impl : n_embd_inp();
|
|
}
|
|
|
|
uint32_t llama_hparams::n_embd_out() const {
|
|
return n_embd_out_impl > 0 ? n_embd_out_impl : n_embd;
|
|
}
|
|
|
|
uint32_t llama_hparams::n_embd_head_k(uint32_t il) const {
|
|
if (il < n_layer_all) {
|
|
return is_swa(il) ? n_embd_head_k_swa : n_embd_head_k_full;
|
|
}
|
|
|
|
GGML_ABORT("fatal error");
|
|
}
|
|
|
|
uint32_t llama_hparams::n_embd_head_v(uint32_t il) const {
|
|
if (il < n_layer_all) {
|
|
return is_swa(il) ? n_embd_head_v_swa : n_embd_head_v_full;
|
|
}
|
|
|
|
GGML_ABORT("fatal error");
|
|
}
|
|
|
|
uint32_t llama_hparams::n_embd_k_gqa(uint32_t il) const {
|
|
const uint32_t n_head_kv = this->n_head_kv(il);
|
|
|
|
return n_embd_head_k(il) * n_head_kv;
|
|
}
|
|
|
|
uint32_t llama_hparams::n_embd_v_gqa(uint32_t il) const {
|
|
const uint32_t n_head_kv = this->n_head_kv(il);
|
|
|
|
return n_embd_head_v(il) * n_head_kv;
|
|
}
|
|
|
|
bool llama_hparams::is_n_embd_k_gqa_variable() const {
|
|
const uint32_t val = n_embd_k_gqa();
|
|
for (uint32_t il = 0; il < n_layer_all; ++il) {
|
|
if (val != n_embd_k_gqa(il)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool llama_hparams::is_n_embd_v_gqa_variable() const {
|
|
const uint32_t val = n_embd_v_gqa();
|
|
for (uint32_t il = 0; il < n_layer_all; ++il) {
|
|
if (val != n_embd_v_gqa(il)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
uint32_t llama_hparams::n_embd_k_gqa_max() const {
|
|
uint32_t val = n_embd_k_gqa();
|
|
for (uint32_t il = 0; il < n_layer_all; ++il) {
|
|
val = std::max(val, n_embd_k_gqa(il));
|
|
}
|
|
|
|
return val;
|
|
}
|
|
|
|
uint32_t llama_hparams::n_embd_v_gqa_max() const {
|
|
uint32_t val = n_embd_v_gqa();
|
|
for (uint32_t il = 0; il < n_layer_all; ++il) {
|
|
val = std::max(val, n_embd_v_gqa(il));
|
|
}
|
|
|
|
return val;
|
|
}
|
|
|
|
uint32_t llama_hparams::n_embd_r() const {
|
|
if (wkv_head_size != 0) {
|
|
// for RWKV models
|
|
return token_shift_count * n_embd;
|
|
}
|
|
|
|
if (n_sconv_channels != 0) {
|
|
// for Inkling2 models, checked before LFM2 as they set n_shortconv_l_cache too
|
|
return n_sconv_channels * (n_shortconv_l_cache - 1);
|
|
}
|
|
|
|
if (n_shortconv_l_cache != 0) {
|
|
// for LFM2 models
|
|
return n_embd * (n_shortconv_l_cache - 1);
|
|
}
|
|
|
|
if (n_embd_head_kda != 0) {
|
|
// for Kimi KDA layers
|
|
// Conv state for Q, K, V: 3 * (d_conv - 1) * n_head * head_dim
|
|
const uint32_t d_inner = n_head() * n_embd_head_kda; // 32 * 128 = 4096
|
|
return 3 * (ssm_d_conv > 0 ? ssm_d_conv - 1 : 3) * d_inner;
|
|
}
|
|
|
|
// TODO: maybe support other convolution strides than 1
|
|
// NOTE: since the first column of the conv_state is shifted out each time, it's not actually needed
|
|
// Corresponds to Mamba's conv_states size
|
|
const uint32_t n_conv = (ssm_d_conv > 0 ? ssm_d_conv - 1 : 0) * (ssm_d_inner + 2*ssm_n_group*ssm_d_state);
|
|
|
|
// PLE conv history needs its own row: Meta splits cache_r_l by head, so a history packed behind the first is unaddressable
|
|
// it lives in cache_ple_r_l instead, mirrored like the rest of the PLE module
|
|
return n_conv;
|
|
}
|
|
|
|
uint32_t llama_hparams::n_embd_s() const {
|
|
if (wkv_head_size != 0) {
|
|
// corresponds to RWKV's wkv_states size
|
|
return n_embd * wkv_head_size;
|
|
}
|
|
|
|
if (n_embd_head_kda != 0) {
|
|
// for Kimi KDA layers
|
|
// Full recurrent state: head_dim * head_dim * n_head
|
|
// h tensor shape for delta attention: [head_dim, head_dim, n_head]
|
|
return n_embd_head_kda * n_embd_head_kda * n_head(); // 128 * 128 * 32 = 524288
|
|
}
|
|
|
|
if (n_embd_head_la != 0) {
|
|
// for MiniMax-Text-01 linear attention layers
|
|
// Full recurrent state: head_dim * head_dim * n_head
|
|
// tensor shape for linear attention: [head_dim, head_dim, n_head]
|
|
return n_embd_head_la * n_embd_head_la * n_head(); // 128 * 128 * 64 = 1048576
|
|
}
|
|
|
|
// corresponds to Mamba's ssm_states size
|
|
return ssm_d_state * ssm_d_inner;
|
|
}
|
|
|
|
bool llama_hparams::is_recr(uint32_t il) const {
|
|
if (il < n_layer_all) {
|
|
return is_recr_impl[il];
|
|
}
|
|
|
|
GGML_ABORT("%s: il (%u) out of bounds (n_layer_all: %u)\n", __func__, il, n_layer_all);
|
|
}
|
|
|
|
uint32_t llama_hparams::ple_conv_state() const {
|
|
if (ple_n_heads == 0 || ple_conv_kernel == 0) {
|
|
return 0;
|
|
}
|
|
|
|
// dilation equals the n-gram size, matching the reference module
|
|
return (ple_conv_kernel - 1) * ple_ngram_size * dsv4_hc_mult * n_embd;
|
|
}
|
|
|
|
bool llama_hparams::is_ple(uint32_t il) const {
|
|
if (il < n_layer_all) {
|
|
return is_ple_impl[il];
|
|
}
|
|
|
|
GGML_ABORT("%s: il (%u) out of bounds (n_layer_all: %u)\n", __func__, il, n_layer_all);
|
|
}
|
|
|
|
uint32_t llama_hparams::n_pos_per_embd() const {
|
|
return (rope_type == LLAMA_ROPE_TYPE_MROPE || rope_type == LLAMA_ROPE_TYPE_IMROPE)
|
|
? GGML_MROPE_SECTIONS : 1;
|
|
}
|
|
|
|
bool llama_hparams::is_swa(uint32_t il) const {
|
|
if (il < n_layer_all) {
|
|
return is_swa_impl[il];
|
|
}
|
|
|
|
GGML_ABORT("%s: il (%u) out of bounds (n_layer_all: %u)\n", __func__, il, n_layer_all);
|
|
}
|
|
|
|
bool llama_hparams::is_mla() const {
|
|
assert((n_embd_head_k_mla_impl == 0 && n_embd_head_v_mla_impl == 0) ||
|
|
(n_embd_head_k_mla_impl != 0 && n_embd_head_v_mla_impl != 0));
|
|
|
|
return n_embd_head_k_mla_impl != 0 && n_embd_head_v_mla_impl != 0;
|
|
}
|
|
|
|
bool llama_hparams::is_indexer_full(uint32_t il) const {
|
|
if (il < n_layer()) {
|
|
return is_indexer_full_impl[il];
|
|
}
|
|
|
|
GGML_ABORT("%s: il (%u) out of bounds (n_layer: %u)\n", __func__, il, n_layer());
|
|
}
|
|
|
|
uint32_t llama_hparams::n_embd_head_k_mla() const {
|
|
return is_mla() ? n_embd_head_k_mla_impl : n_embd_head_k();
|
|
}
|
|
|
|
uint32_t llama_hparams::n_embd_head_v_mla() const {
|
|
return is_mla() ? n_embd_head_v_mla_impl : n_embd_head_v();
|
|
}
|
|
|
|
bool llama_hparams::has_kv(uint32_t il) const {
|
|
return kv_source(il) == il;
|
|
}
|
|
|
|
uint32_t llama_hparams::kv_source(uint32_t il) const {
|
|
if (il < n_layer_all) {
|
|
return kv_source_impl[il];
|
|
}
|
|
|
|
GGML_ABORT("%s: il (%u) out of bounds (n_layer_all: %u)\n", __func__, il, n_layer_all);
|
|
}
|
|
|
|
bool llama_hparams::has_rope(uint32_t il) const {
|
|
// the router layer stores adapter routing signal, not positional info,
|
|
// so it must not be RoPE-shifted
|
|
if (router_layer >= 0 && (int32_t) il == router_layer) {
|
|
return false;
|
|
}
|
|
|
|
if (il < n_layer_all) {
|
|
return rope_pattern[il] != 0;
|
|
}
|
|
|
|
GGML_ABORT("%s: il (%u) out of bounds (n_layer_all: %u)\n", __func__, il, n_layer_all);
|
|
}
|
|
|
|
uint32_t llama_hparams::n_layer() const {
|
|
return n_layer_all - n_layer_nextn;
|
|
}
|
|
|
|
bool llama_hparams::use_mrope() const {
|
|
return rope_sections[0] > 0 && rope_sections[1] > 0;
|
|
}
|