Felipe97/llama-cpp-compiled

1#include "llama-hparams.h"2 3#include "ggml.h"4 5#include <algorithm>6#include <cassert>7 8void llama_hparams::set_swa_pattern(uint32_t n_pattern, bool dense_first) {9    if (dense_first) {10        for (uint32_t il = 0; il < n_layer(); ++il) {11            is_swa_impl[il] = n_pattern == 0 || (il % n_pattern != 0);12        }13    } else {14        for (uint32_t il = 0; il < n_layer(); ++il) {15            is_swa_impl[il] = n_pattern == 0 || (il % n_pattern < (n_pattern - 1));16        }17    }18 19    for (uint32_t il = n_layer(); il < n_layer_all; ++il) {20        is_swa_impl[il] = false;21    }22}23 24void llama_hparams::set_recr_pattern(uint32_t n_pattern, bool dense_first) {25    if (dense_first) {26        for (uint32_t il = 0; il < n_layer(); ++il) {27            is_recr_impl[il] = n_pattern == 0 || (il % n_pattern != 0);28        }29    } else {30        for (uint32_t il = 0; il < n_layer(); ++il) {31            is_recr_impl[il] = n_pattern == 0 || (il % n_pattern < (n_pattern - 1));32        }33    }34 35    for (uint32_t il = n_layer(); il < n_layer_all; ++il) {36        is_recr_impl[il] = false;37    }38}39 40bool llama_hparams::is_swa_any() const {41    for (uint32_t il = 0; il < n_layer_all; ++il) {42        if (is_swa_impl[il]) {43            return true;44        }45    }46 47    return false;48}49 50uint32_t llama_hparams::n_head(uint32_t il) const {51    if (il < n_layer_all) {52        return n_head_arr[il];53    }54 55    GGML_ABORT("fatal error");56}57 58uint32_t llama_hparams::n_head_kv(uint32_t il) const {59    if (il < n_layer_all) {60        return n_head_kv_arr[il];61    }62 63    GGML_ABORT("fatal error");64}65 66uint32_t llama_hparams::n_ff(uint32_t il) const {67    if (il < n_layer_all) {68        return n_ff_arr[il];69    }70 71    GGML_ABORT("fatal error");72}73 74uint32_t llama_hparams::n_ff_exp(uint32_t il) const {75    if (il < n_layer_all) {76        return n_ff_exp_arr[il];77    }78 79    GGML_ABORT("fatal error");80}81 82uint32_t llama_hparams::n_expert_used(uint32_t il) const {83    if (il < n_layer_all) {84        return n_expert_used_arr[il];85    }86 87    GGML_ABORT("fatal error");88}89 90uint32_t llama_hparams::n_expert_used_max() const {91    uint32_t val = 0;92    for (uint32_t il = 0; il < n_layer_all; ++il) {93        val = std::max(val, n_expert_used(il));94    }95 96    return val;97}98 99uint32_t llama_hparams::n_gqa(uint32_t il) const {100    const uint32_t n_head    = this->n_head(il);101    const uint32_t n_head_kv = this->n_head_kv(il);102 103    if (n_head_kv == 0) {104        return 0;105    }106 107    return n_head/n_head_kv;108}109 110uint32_t llama_hparams::n_rot(uint32_t il) const {111    if (il < n_layer_all) {112        return is_swa(il) ? n_rot_swa : n_rot_full;113    }114 115    GGML_ABORT("fatal error");116}117 118uint32_t llama_hparams::n_embd_inp() const {119    if (n_embd_inp_impl > 0) {120        return n_embd_inp_impl;121    }122 123    uint32_t n_embd_inp = n_embd;124 125    if (n_deepstack_layers > 0) {126        n_embd_inp += n_embd * n_deepstack_layers;127    }128 129    return n_embd_inp;130}131 132uint32_t llama_hparams::n_embd_inp_enc() const {133    return n_embd_inp_enc_impl > 0 ? n_embd_inp_enc_impl : n_embd_inp();134}135 136uint32_t llama_hparams::n_embd_out() const {137    return n_embd_out_impl > 0 ? n_embd_out_impl : n_embd;138}139 140uint32_t llama_hparams::n_embd_head_k(uint32_t il) const {141    if (il < n_layer_all) {142        return is_swa(il) ? n_embd_head_k_swa : n_embd_head_k_full;143    }144 145    GGML_ABORT("fatal error");146}147 148uint32_t llama_hparams::n_embd_head_v(uint32_t il) const {149    if (il < n_layer_all) {150        return is_swa(il) ? n_embd_head_v_swa : n_embd_head_v_full;151    }152 153    GGML_ABORT("fatal error");154}155 156uint32_t llama_hparams::n_embd_k_gqa(uint32_t il) const {157    const uint32_t n_head_kv = this->n_head_kv(il);158 159    return n_embd_head_k(il) * n_head_kv;160}161 162uint32_t llama_hparams::n_embd_v_gqa(uint32_t il) const {163    const uint32_t n_head_kv = this->n_head_kv(il);164 165    return n_embd_head_v(il) * n_head_kv;166}167 168bool llama_hparams::is_n_embd_k_gqa_variable() const {169    const uint32_t val = n_embd_k_gqa();170    for (uint32_t il = 0; il < n_layer_all; ++il) {171        if (val != n_embd_k_gqa(il)) {172            return true;173        }174    }175 176    return false;177}178 179bool llama_hparams::is_n_embd_v_gqa_variable() const {180    const uint32_t val = n_embd_v_gqa();181    for (uint32_t il = 0; il < n_layer_all; ++il) {182        if (val != n_embd_v_gqa(il)) {183            return true;184        }185    }186 187    return false;188}189 190uint32_t llama_hparams::n_embd_k_gqa_max() const {191    uint32_t val = n_embd_k_gqa();192    for (uint32_t il = 0; il < n_layer_all; ++il) {193        val = std::max(val, n_embd_k_gqa(il));194    }195 196    return val;197}198 199uint32_t llama_hparams::n_embd_v_gqa_max() const {200    uint32_t val = n_embd_v_gqa();201    for (uint32_t il = 0; il < n_layer_all; ++il) {202        val = std::max(val, n_embd_v_gqa(il));203    }204 205    return val;206}207 208uint32_t llama_hparams::n_embd_r() const {209    if (wkv_head_size != 0) {210        // for RWKV models211        return token_shift_count * n_embd;212    }213 214    if (n_shortconv_l_cache != 0) {215        // for LFM2 models216        return n_embd * (n_shortconv_l_cache - 1);217    }218 219    if (n_embd_head_kda != 0) {220        // for Kimi KDA layers221        // Conv state for Q, K, V: 3 * (d_conv - 1) * n_head * head_dim222        const uint32_t d_inner = n_head() * n_embd_head_kda;  // 32 * 128 = 4096223        return 3 * (ssm_d_conv > 0 ? ssm_d_conv - 1 : 3) * d_inner;224    }225 226    // TODO: maybe support other convolution strides than 1227    // NOTE: since the first column of the conv_state is shifted out each time, it's not actually needed228    // Corresponds to Mamba's conv_states size229    const uint32_t n_conv = (ssm_d_conv > 0 ? ssm_d_conv - 1 : 0) * (ssm_d_inner + 2*ssm_n_group*ssm_d_state);230 231    // PLE conv history needs its own row: Meta splits cache_r_l by head, so a history packed behind the first is unaddressable232    // it lives in cache_ple_r_l instead, mirrored like the rest of the PLE module233    return n_conv;234}235 236uint32_t llama_hparams::n_embd_s() const {237    if (wkv_head_size != 0) {238        // corresponds to RWKV's wkv_states size239        return n_embd * wkv_head_size;240    }241 242    if (n_embd_head_kda != 0) {243        // for Kimi KDA layers244        // Full recurrent state: head_dim * head_dim * n_head245        // h tensor shape for delta attention: [head_dim, head_dim, n_head]246        return n_embd_head_kda * n_embd_head_kda * n_head();  // 128 * 128 * 32 = 524288247    }248 249    if (n_embd_head_la != 0) {250        // for MiniMax-Text-01 linear attention layers251        // Full recurrent state: head_dim * head_dim * n_head252        // tensor shape for linear attention: [head_dim, head_dim, n_head]253        return n_embd_head_la * n_embd_head_la * n_head();  // 128 * 128 * 64 = 1048576254    }255 256    // corresponds to Mamba's ssm_states size257    return ssm_d_state * ssm_d_inner;258}259 260bool llama_hparams::is_recr(uint32_t il) const {261    if (il < n_layer_all) {262        return is_recr_impl[il];263    }264 265    GGML_ABORT("%s: il (%u) out of bounds (n_layer_all: %u)\n", __func__, il, n_layer_all);266}267 268uint32_t llama_hparams::ple_conv_state() const {269    if (ple_n_heads == 0 || ple_conv_kernel == 0) {270        return 0;271    }272 273    // dilation equals the n-gram size, matching the reference module274    return (ple_conv_kernel - 1) * ple_ngram_size * dsv4_hc_mult * n_embd;275}276 277bool llama_hparams::is_ple(uint32_t il) const {278    if (il < n_layer_all) {279        return is_ple_impl[il];280    }281 282    GGML_ABORT("%s: il (%u) out of bounds (n_layer_all: %u)\n", __func__, il, n_layer_all);283}284 285uint32_t llama_hparams::n_pos_per_embd() const {286    return rope_type == LLAMA_ROPE_TYPE_MROPE || rope_type == LLAMA_ROPE_TYPE_IMROPE ? 4 : 1;287}288 289bool llama_hparams::is_swa(uint32_t il) const {290    if (il < n_layer_all) {291        return is_swa_impl[il];292    }293 294    GGML_ABORT("%s: il (%u) out of bounds (n_layer_all: %u)\n", __func__, il, n_layer_all);295}296 297bool llama_hparams::is_mla() const {298    assert((n_embd_head_k_mla_impl == 0 && n_embd_head_v_mla_impl == 0) ||299           (n_embd_head_k_mla_impl != 0 && n_embd_head_v_mla_impl != 0));300 301    return n_embd_head_k_mla_impl != 0 && n_embd_head_v_mla_impl != 0;302}303 304bool llama_hparams::is_indexer_full(uint32_t il) const {305    if (il < n_layer()) {306        return is_indexer_full_impl[il];307    }308 309    GGML_ABORT("%s: il (%u) out of bounds (n_layer: %u)\n", __func__, il, n_layer());310}311 312uint32_t llama_hparams::n_embd_head_k_mla() const {313    return is_mla() ? n_embd_head_k_mla_impl : n_embd_head_k();314}315 316uint32_t llama_hparams::n_embd_head_v_mla() const {317    return is_mla() ? n_embd_head_v_mla_impl : n_embd_head_v();318}319 320bool llama_hparams::has_kv(uint32_t il) const {321    if (n_layer_kv_from_start >= 0) {322        if (il < (uint32_t) n_layer_kv_from_start) {323            return true;324        }325 326        return false;327    }328 329    // by default, all layers have kv330    return true;331}332 333bool llama_hparams::has_rope(uint32_t il) const {334    // the router layer stores adapter routing signal, not positional info,335    // so it must not be RoPE-shifted336    if (router_layer >= 0 && (int32_t) il == router_layer) {337        return false;338    }339 340    if (il < n_layer_all) {341        return rope_pattern[il] != 0;342    }343 344    GGML_ABORT("%s: il (%u) out of bounds (n_layer_all: %u)\n", __func__, il, n_layer_all);345}346 347uint32_t llama_hparams::n_layer() const {348    return n_layer_all - n_layer_nextn;349}350 351bool llama_hparams::use_mrope() const {352    return rope_sections[0] > 0 && rope_sections[1] > 0;353}354