Function compressor_decode_one

ds4.c:8665–8760

Streaming compressor update for one token. It projects kv/score rows, * updates the rolling state, and emits a compressed KV row on ratio boundaries. */

        uint64_t          *bytes_out) {
    if (bytes_out) *bytes_out = 0;
    if (!w || !bytes_out) return false;

    ds4_model_map_span_vec spans;
    const bool include_token =
        weights_layer_has_required(&w->layer[0], 0);
    if (!weights_model_map_decode_static_spans(w,
                                               include_token,
                                               weights_have_output_head(w),
                                               &spans)) {
        return false;
    }
    *bytes_out = model_map_span_vec_total_bytes(&spans);
    free(spans.v);
    return true;
}

static DS4_MAYBE_UNUSED bool weights_model_map_token_spans(
        const ds4_weights *w,
        ds4_model_map_span_vec *spans) {
    if (!w || !spans) return false;
    memset(spans, 0, sizeof(*spans));
    model_map_span_vec_include_one(spans, w->token_embd);
    return model_map_span_vec_finish(spans);
}

static DS4_MAYBE_UNUSED bool weights_model_map_output_spans(
        const ds4_weights *w,
        ds4_model_map_span_vec *spans) {
    if (!w || !spans) return false;
    memset(spans, 0, sizeof(*spans));
    model_map_span_vec_include_output(spans, w);
    return model_map_span_vec_finish(spans);
}

static void mtp_weights_bind(ds4_mtp_weights *w, const ds4_model *m) {
    memset(w, 0, sizeof(*w));

    w->hc_head_base  = required_tensor(m, "mtp.0.hc_head_base.weight");
    w->hc_head_fn    = required_tensor(m, "mtp.0.hc_head_fn.weight");
    w->hc_head_scale = required_tensor(m, "mtp.0.hc_head_scale.weight");
    w->e_proj        = required_tensor(m, "mtp.0.e_proj.weight");
    w->h_proj        = required_tensor(m, "mtp.0.h_proj.weight");
    w->enorm         = required_tensor(m, "mtp.0.enorm.weight");
    w->hnorm         = required_tensor(m, "mtp.0.hnorm.weight");
    w->norm          = required_tensor(m, "mtp.0.norm.weight");

    ds4_layer_weights *l = &w->block;
    l->hc_attn_fn      = required_tensor(m, "mtp.0.hc_attn_fn.weight");
    l->hc_attn_scale   = required_tensor(m, "mtp.0.hc_attn_scale.weight");
    l->hc_attn_base    = required_tensor(m, "mtp.0.hc_attn_base.weight");
    l->attn_norm       = required_tensor(m, "mtp.0.attn_norm.weight");
    l->attn_q_a        = required_tensor(m, "mtp.0.attn_q_a.weight");
    l->attn_q_a_norm   = required_tensor(m, "mtp.0.attn_q_a_norm.weight");
    l->attn_q_b        = required_tensor(m, "mtp.0.attn_q_b.weight");
    l->attn_kv         = required_tensor(m, "mtp.0.attn_kv.weight");
    l->attn_kv_a_norm  = required_tensor(m, "mtp.0.attn_kv_a_norm.weight");
    l->attn_sinks      = required_tensor(m, "mtp.0.attn_sinks.weight");
    l->attn_output_a   = required_tensor(m, "mtp.0.attn_output_a.weight");