whisper.rn 0.5.0-rc.9 → 0.5.1

package/cpp/ggml.c

@@ -1,6 +1,14 @@
 #define _CRT_SECURE_NO_DEPRECATE // Disables "unsafe" warnings on Windows
 #define _USE_MATH_DEFINES // For M_PI on MSVC
 
+// GGML build info
+#ifndef WSP_GGML_VERSION
+#define WSP_GGML_VERSION "unknown"
+#endif
+#ifndef WSP_GGML_COMMIT
+#define WSP_GGML_COMMIT "unknown"
+#endif
+
 #include "ggml-backend.h"
 #include "ggml-impl.h"
 #include "ggml-threading.h"
@@ -202,19 +210,34 @@ void wsp_ggml_print_backtrace(void) {
 }
 #endif
 
+static wsp_ggml_abort_callback_t g_abort_callback = NULL;
+
+// Set the abort callback (passing null will restore original abort functionality: printing a message to stdout)
+WSP_GGML_API wsp_ggml_abort_callback_t wsp_ggml_set_abort_callback(wsp_ggml_abort_callback_t callback) {
+    wsp_ggml_abort_callback_t ret_val = g_abort_callback;
+    g_abort_callback = callback;
+    return ret_val;
+}
+
 void wsp_ggml_abort(const char * file, int line, const char * fmt, ...) {
     fflush(stdout);
 
-    fprintf(stderr, "%s:%d: ", file, line);
+    char message[2048];
+    int offset = snprintf(message, sizeof(message), "%s:%d: ", file, line);
 
     va_list args;
     va_start(args, fmt);
-    vfprintf(stderr, fmt, args);
+    vsnprintf(message + offset, sizeof(message) - offset, fmt, args);
     va_end(args);
 
-    fprintf(stderr, "\n");
+    if (g_abort_callback) {
+        g_abort_callback(message);
+    } else {
+        // default: print error and backtrace to stderr
+        fprintf(stderr, "%s\n", message);
+        wsp_ggml_print_backtrace();
+    }
 
-    wsp_ggml_print_backtrace();
     abort();
 }
 
@@ -458,6 +481,14 @@ bool wsp_ggml_guid_matches(wsp_ggml_guid_t guid_a, wsp_ggml_guid_t guid_b) {
     return memcmp(guid_a, guid_b, sizeof(wsp_ggml_guid)) == 0;
 }
 
+const char * wsp_ggml_version(void) {
+    return WSP_GGML_VERSION;
+}
+
+const char * wsp_ggml_commit(void) {
+    return WSP_GGML_COMMIT;
+}
+
 //
 // timing
 //
@@ -559,9 +590,6 @@ FILE * wsp_ggml_fopen(const char * fname, const char * mode) {
 #endif
 
 }
-static void wsp_ggml_vec_dot_f32(int n, float * WSP_GGML_RESTRICT s, size_t bs, const float * WSP_GGML_RESTRICT x, size_t bx, const float * WSP_GGML_RESTRICT y, size_t by, int nrc);
-static void wsp_ggml_vec_dot_f16(int n, float * WSP_GGML_RESTRICT s, size_t bs, wsp_ggml_fp16_t * WSP_GGML_RESTRICT x, size_t bx, wsp_ggml_fp16_t * WSP_GGML_RESTRICT y, size_t by, int nrc);
-static void wsp_ggml_vec_dot_bf16(int n, float * WSP_GGML_RESTRICT s, size_t bs, wsp_ggml_bf16_t * WSP_GGML_RESTRICT x, size_t bx, wsp_ggml_bf16_t * WSP_GGML_RESTRICT y, size_t by, int nrc);
 
 static const struct wsp_ggml_type_traits type_traits[WSP_GGML_TYPE_COUNT] = {
     [WSP_GGML_TYPE_I8] = {
@@ -667,6 +695,14 @@ static const struct wsp_ggml_type_traits type_traits[WSP_GGML_TYPE_COUNT] = {
         .is_quantized             = true,
         .from_float_ref           = (wsp_ggml_from_float_t) wsp_quantize_row_q8_1_ref,
     },
+    [WSP_GGML_TYPE_MXFP4] = {
+        .type_name                = "mxfp4",
+        .blck_size                = QK_MXFP4,
+        .type_size                = sizeof(block_mxfp4),
+        .is_quantized             = true,
+        .to_float                 = (wsp_ggml_to_float_t) wsp_dewsp_quantize_row_mxfp4,
+        .from_float_ref           = (wsp_ggml_from_float_t)wsp_quantize_row_mxfp4_ref,
+    },
     [WSP_GGML_TYPE_Q2_K] = {
         .type_name                = "q2_K",
         .blck_size                = QK_K,
@@ -894,6 +930,7 @@ static const char * WSP_GGML_OP_NAME[WSP_GGML_OP_COUNT] = {
 
     "DUP",
     "ADD",
+    "ADD_ID",
     "ADD1",
     "ACC",
     "SUB",
@@ -945,7 +982,9 @@ static const char * WSP_GGML_OP_NAME[WSP_GGML_OP_COUNT] = {
     "CONV_TRANSPOSE_1D",
     "IM2COL",
     "IM2COL_BACK",
+    "IM2COL_3D",
     "CONV_2D",
+    "CONV_3D",
     "CONV_2D_DW",
     "CONV_TRANSPOSE_2D",
     "POOL_1D",
@@ -983,17 +1022,19 @@ static const char * WSP_GGML_OP_NAME[WSP_GGML_OP_COUNT] = {
     "CROSS_ENTROPY_LOSS",
     "CROSS_ENTROPY_LOSS_BACK",
     "OPT_STEP_ADAMW",
+    "OPT_STEP_SGD",
 
     "GLU",
 };
 
-static_assert(WSP_GGML_OP_COUNT == 86, "WSP_GGML_OP_COUNT != 86");
+static_assert(WSP_GGML_OP_COUNT == 90, "WSP_GGML_OP_COUNT != 90");
 
 static const char * WSP_GGML_OP_SYMBOL[WSP_GGML_OP_COUNT] = {
     "none",
 
     "x",
     "x+y",
+    "x[i]+y",
     "x+y",
     "view(x,nb,offset)+=y->x",
     "x-y",
@@ -1045,7 +1086,9 @@ static const char * WSP_GGML_OP_SYMBOL[WSP_GGML_OP_COUNT] = {
     "conv_transpose_1d(x)",
     "im2col(x)",
     "im2col_back(x)",
+    "im2col_3d(x)",
     "conv_2d(x)",
+    "conv_3d(x)",
     "conv_2d_dw(x)",
     "conv_transpose_2d(x)",
     "pool_1d(x)",
@@ -1083,15 +1126,15 @@ static const char * WSP_GGML_OP_SYMBOL[WSP_GGML_OP_COUNT] = {
     "cross_entropy_loss(x,y)",
     "cross_entropy_loss_back(x,y)",
     "adamw(x)",
+    "sgd(x)",
 
     "glu(x)",
 };
 
-static_assert(WSP_GGML_OP_COUNT == 86, "WSP_GGML_OP_COUNT != 86");
+static_assert(WSP_GGML_OP_COUNT == 90, "WSP_GGML_OP_COUNT != 90");
 
 static_assert(WSP_GGML_OP_POOL_COUNT == 2, "WSP_GGML_OP_POOL_COUNT != 2");
 
-
 static const char * WSP_GGML_UNARY_OP_NAME[WSP_GGML_UNARY_OP_COUNT] = {
     "ABS",
     "SGN",
@@ -1117,9 +1160,12 @@ static const char * WSP_GGML_GLU_OP_NAME[WSP_GGML_GLU_OP_COUNT] = {
     "REGLU",
     "GEGLU",
     "SWIGLU",
+    "SWIGLU_OAI",
+    "GEGLU_ERF",
+    "GEGLU_QUICK",
 };
 
-static_assert(WSP_GGML_GLU_OP_COUNT == 3, "WSP_GGML_GLU_OP_COUNT != 3");
+static_assert(WSP_GGML_GLU_OP_COUNT == 6, "WSP_GGML_GLU_OP_COUNT != 6");
 
 
 static_assert(sizeof(struct wsp_ggml_object)%WSP_GGML_MEM_ALIGN == 0, "wsp_ggml_object size must be a multiple of WSP_GGML_MEM_ALIGN");
@@ -1287,6 +1333,7 @@ enum wsp_ggml_type wsp_ggml_ftype_to_wsp_ggml_type(enum wsp_ggml_ftype ftype) {
         case WSP_GGML_FTYPE_MOSTLY_Q5_0:          wtype = WSP_GGML_TYPE_Q5_0;  break;
         case WSP_GGML_FTYPE_MOSTLY_Q5_1:          wtype = WSP_GGML_TYPE_Q5_1;  break;
         case WSP_GGML_FTYPE_MOSTLY_Q8_0:          wtype = WSP_GGML_TYPE_Q8_0;  break;
+        case WSP_GGML_FTYPE_MOSTLY_MXFP4:         wtype = WSP_GGML_TYPE_MXFP4; break;
         case WSP_GGML_FTYPE_MOSTLY_Q2_K:          wtype = WSP_GGML_TYPE_Q2_K;  break;
         case WSP_GGML_FTYPE_MOSTLY_Q3_K:          wtype = WSP_GGML_TYPE_Q3_K;  break;
         case WSP_GGML_FTYPE_MOSTLY_Q4_K:          wtype = WSP_GGML_TYPE_Q4_K;  break;
@@ -1937,6 +1984,27 @@ struct wsp_ggml_tensor * wsp_ggml_add_cast(
     return wsp_ggml_add_cast_impl(ctx, a, b, type);
 }
 
+struct wsp_ggml_tensor * wsp_ggml_add_id(
+            struct wsp_ggml_context * ctx,
+            struct wsp_ggml_tensor  * a,
+            struct wsp_ggml_tensor  * b,
+            struct wsp_ggml_tensor  * ids) {
+
+    WSP_GGML_ASSERT(a->ne[0] == b->ne[0]);
+    WSP_GGML_ASSERT(a->ne[1] == ids->ne[0]);
+    WSP_GGML_ASSERT(a->ne[2] == ids->ne[1]);
+    WSP_GGML_ASSERT(ids->type == WSP_GGML_TYPE_I32);
+
+    struct wsp_ggml_tensor * result = wsp_ggml_dup_tensor(ctx, a);
+
+    result->op     = WSP_GGML_OP_ADD_ID;
+    result->src[0] = a;
+    result->src[1] = b;
+    result->src[2] = ids;
+
+    return result;
+}
+
 // wsp_ggml_add1
 
 static struct wsp_ggml_tensor * wsp_ggml_add1_impl(
@@ -2745,6 +2813,61 @@ struct wsp_ggml_tensor * wsp_ggml_swiglu_split(
     return wsp_ggml_glu_impl(ctx, a, b, WSP_GGML_GLU_OP_SWIGLU, false);
 }
 
+// wsp_ggml_geglu_erf
+
+struct wsp_ggml_tensor * wsp_ggml_geglu_erf(
+        struct wsp_ggml_context * ctx,
+        struct wsp_ggml_tensor  * a) {
+    return wsp_ggml_glu_impl(ctx, a, NULL, WSP_GGML_GLU_OP_GEGLU_ERF, false);
+}
+
+struct wsp_ggml_tensor * wsp_ggml_geglu_erf_swapped(
+        struct wsp_ggml_context * ctx,
+        struct wsp_ggml_tensor  * a) {
+    return wsp_ggml_glu_impl(ctx, a, NULL, WSP_GGML_GLU_OP_GEGLU_ERF, true);
+}
+
+struct wsp_ggml_tensor * wsp_ggml_geglu_erf_split(
+        struct wsp_ggml_context * ctx,
+        struct wsp_ggml_tensor  * a,
+        struct wsp_ggml_tensor  * b) {
+    return wsp_ggml_glu_impl(ctx, a, b, WSP_GGML_GLU_OP_GEGLU_ERF, false);
+}
+
+// wsp_ggml_geglu_quick
+
+struct wsp_ggml_tensor * wsp_ggml_geglu_quick(
+        struct wsp_ggml_context * ctx,
+        struct wsp_ggml_tensor  * a) {
+    return wsp_ggml_glu_impl(ctx, a, NULL, WSP_GGML_GLU_OP_GEGLU_QUICK, false);
+}
+
+struct wsp_ggml_tensor * wsp_ggml_geglu_quick_swapped(
+        struct wsp_ggml_context * ctx,
+        struct wsp_ggml_tensor  * a) {
+    return wsp_ggml_glu_impl(ctx, a, NULL, WSP_GGML_GLU_OP_GEGLU_QUICK, true);
+}
+
+struct wsp_ggml_tensor * wsp_ggml_geglu_quick_split(
+        struct wsp_ggml_context * ctx,
+        struct wsp_ggml_tensor  * a,
+        struct wsp_ggml_tensor  * b) {
+    return wsp_ggml_glu_impl(ctx, a, b, WSP_GGML_GLU_OP_GEGLU_QUICK, false);
+}
+
+struct wsp_ggml_tensor * wsp_ggml_swiglu_oai(
+        struct wsp_ggml_context * ctx,
+        struct wsp_ggml_tensor  * a,
+        struct wsp_ggml_tensor  * b,
+        float                 alpha,
+        float                 limit) {
+    struct wsp_ggml_tensor * result = wsp_ggml_glu_impl(ctx, a, b, WSP_GGML_GLU_OP_SWIGLU_OAI, false);
+    wsp_ggml_set_op_params_f32(result, 2, alpha);
+    wsp_ggml_set_op_params_f32(result, 3, limit);
+
+    return result;
+}
+
 // wsp_ggml_norm
 
 static struct wsp_ggml_tensor * wsp_ggml_norm_impl(
@@ -3002,12 +3125,14 @@ static struct wsp_ggml_tensor * wsp_ggml_scale_impl(
         struct wsp_ggml_context * ctx,
         struct wsp_ggml_tensor  * a,
         float                 s,
+        float                 b,
         bool                  inplace) {
     WSP_GGML_ASSERT(wsp_ggml_is_padded_1d(a));
 
     struct wsp_ggml_tensor * result = inplace ? wsp_ggml_view_tensor(ctx, a) : wsp_ggml_dup_tensor(ctx, a);
 
-    wsp_ggml_set_op_params(result, &s, sizeof(s));
+    float params[2] = { s, b };
+    wsp_ggml_set_op_params(result, &params, sizeof(params));
 
     result->op     = WSP_GGML_OP_SCALE;
     result->src[0] = a;
@@ -3019,14 +3144,30 @@ struct wsp_ggml_tensor * wsp_ggml_scale(
         struct wsp_ggml_context * ctx,
         struct wsp_ggml_tensor  * a,
         float                 s) {
-    return wsp_ggml_scale_impl(ctx, a, s, false);
+    return wsp_ggml_scale_impl(ctx, a, s, 0.0, false);
 }
 
 struct wsp_ggml_tensor * wsp_ggml_scale_inplace(
         struct wsp_ggml_context * ctx,
         struct wsp_ggml_tensor  * a,
         float                 s) {
-    return wsp_ggml_scale_impl(ctx, a, s, true);
+    return wsp_ggml_scale_impl(ctx, a, s, 0.0, true);
+}
+
+struct wsp_ggml_tensor * wsp_ggml_scale_bias(
+        struct wsp_ggml_context * ctx,
+        struct wsp_ggml_tensor  * a,
+        float                 s,
+        float                 b) {
+    return wsp_ggml_scale_impl(ctx, a, s, b, false);
+}
+
+struct wsp_ggml_tensor * wsp_ggml_scale_bias_inplace(
+        struct wsp_ggml_context * ctx,
+        struct wsp_ggml_tensor  * a,
+        float                 s,
+        float                 b) {
+    return wsp_ggml_scale_impl(ctx, a, s, b, true);
 }
 
 // wsp_ggml_set
@@ -3490,6 +3631,7 @@ struct wsp_ggml_tensor * wsp_ggml_get_rows(
         struct wsp_ggml_tensor  * a,
         struct wsp_ggml_tensor  * b) {
     WSP_GGML_ASSERT(a->ne[2] == b->ne[1]);
+    WSP_GGML_ASSERT(a->ne[3] == b->ne[2]);
     WSP_GGML_ASSERT(b->ne[3] == 1);
     WSP_GGML_ASSERT(b->type == WSP_GGML_TYPE_I32);
 
@@ -3543,7 +3685,7 @@ struct wsp_ggml_tensor * wsp_ggml_set_rows(
     WSP_GGML_ASSERT(b->ne[3] % c->ne[2] == 0);
     WSP_GGML_ASSERT(c->ne[3] == 1);
     WSP_GGML_ASSERT(b->type == WSP_GGML_TYPE_F32);
-    WSP_GGML_ASSERT(c->type == WSP_GGML_TYPE_I64);
+    WSP_GGML_ASSERT(c->type == WSP_GGML_TYPE_I64 || c->type == WSP_GGML_TYPE_I32);
 
     WSP_GGML_ASSERT(wsp_ggml_is_contiguous_rows(a));
     WSP_GGML_ASSERT(wsp_ggml_is_contiguous_rows(b));
@@ -3553,6 +3695,7 @@ struct wsp_ggml_tensor * wsp_ggml_set_rows(
     result->op     = WSP_GGML_OP_SET_ROWS;
     result->src[0] = b;
     result->src[1] = c;
+    result->src[2] = a; // note: order is weird due to legacy reasons (https://github.com/ggml-org/llama.cpp/pull/16063#discussion_r2385795931)
 
     return result;
 }
@@ -3651,9 +3794,10 @@ static struct wsp_ggml_tensor * wsp_ggml_soft_max_impl(
     if (mask) {
         WSP_GGML_ASSERT(mask->type == WSP_GGML_TYPE_F16 || mask->type == WSP_GGML_TYPE_F32);
         WSP_GGML_ASSERT(wsp_ggml_is_contiguous(mask));
-        WSP_GGML_ASSERT(wsp_ggml_is_matrix(mask));
         WSP_GGML_ASSERT(mask->ne[0] == a->ne[0]);
         WSP_GGML_ASSERT(mask->ne[1] >= a->ne[1]);
+        WSP_GGML_ASSERT(a->ne[2]%mask->ne[2] == 0);
+        WSP_GGML_ASSERT(a->ne[3]%mask->ne[3] == 0);
     }
 
     if (max_bias > 0.0f) {
@@ -3693,6 +3837,22 @@ struct wsp_ggml_tensor * wsp_ggml_soft_max_ext(
     return wsp_ggml_soft_max_impl(ctx, a, mask, scale, max_bias, false);
 }
 
+void wsp_ggml_soft_max_add_sinks(
+        struct wsp_ggml_tensor * a,
+        struct wsp_ggml_tensor * sinks) {
+    if (!sinks) {
+        a->src[2] = NULL;
+        return;
+    }
+
+    WSP_GGML_ASSERT(a->op == WSP_GGML_OP_SOFT_MAX);
+    WSP_GGML_ASSERT(a->src[2] == NULL);
+    WSP_GGML_ASSERT(a->src[0]->ne[2] == sinks->ne[0]);
+    WSP_GGML_ASSERT(sinks->type == WSP_GGML_TYPE_F32);
+
+    a->src[2] = sinks;
+}
+
 // wsp_ggml_soft_max_ext_back
 
 static struct wsp_ggml_tensor * wsp_ggml_soft_max_ext_back_impl(
@@ -3740,6 +3900,7 @@ static struct wsp_ggml_tensor * wsp_ggml_rope_impl(
         struct wsp_ggml_tensor  * b,
         struct wsp_ggml_tensor  * c,
         int                   n_dims,
+        int                   sections[WSP_GGML_MROPE_SECTIONS],
         int                   mode,
         int                   n_ctx_orig,
         float                 freq_base,
@@ -3753,15 +3914,19 @@ static struct wsp_ggml_tensor * wsp_ggml_rope_impl(
 
     WSP_GGML_ASSERT(wsp_ggml_is_vector(b));
     WSP_GGML_ASSERT(b->type == WSP_GGML_TYPE_I32);
-    WSP_GGML_ASSERT(a->ne[2] == b->ne[0]);
+
+    bool mrope_used = mode & WSP_GGML_ROPE_TYPE_MROPE;
+    if (mrope_used) {
+        WSP_GGML_ASSERT(a->ne[2] * 4 == b->ne[0]); // mrope expecting 4 position ids per token
+    } else {
+        WSP_GGML_ASSERT(a->ne[2] == b->ne[0]);
+    }
 
     if (c) {
         WSP_GGML_ASSERT(c->type == WSP_GGML_TYPE_F32);
         WSP_GGML_ASSERT(c->ne[0] >= n_dims / 2);
     }
 
-    int sections[4] = {0, 0, 0, 0};
-
     struct wsp_ggml_tensor * result = inplace ? wsp_ggml_view_tensor(ctx, a) : wsp_ggml_dup_tensor(ctx, a);
 
     int32_t params[15] = { /*n_past*/ 0, n_dims, mode, /*n_ctx*/ 0, n_ctx_orig };
@@ -3771,7 +3936,11 @@ static struct wsp_ggml_tensor * wsp_ggml_rope_impl(
     memcpy(params +  8, &attn_factor,  sizeof(float));
     memcpy(params +  9, &beta_fast,    sizeof(float));
     memcpy(params + 10, &beta_slow,    sizeof(float));
-    memcpy(params + 11, &sections,     sizeof(int)*4);
+    if (mrope_used && sections) {
+        memcpy(params + 11, sections,  sizeof(int32_t) * WSP_GGML_MROPE_SECTIONS);
+    } else {
+        memset(params + 11, 0,         sizeof(int32_t) * WSP_GGML_MROPE_SECTIONS);
+    }
     wsp_ggml_set_op_params(result, params, sizeof(params));
 
     result->op     = WSP_GGML_OP_ROPE;
@@ -3789,7 +3958,7 @@ struct wsp_ggml_tensor * wsp_ggml_rope(
         int                   n_dims,
         int                   mode) {
     return wsp_ggml_rope_impl(
-        ctx, a, b, NULL, n_dims, mode, 0, 10000.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, false
+        ctx, a, b, NULL, n_dims, NULL, mode, 0, 10000.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, false
     );
 }
 
@@ -3799,7 +3968,7 @@ struct wsp_ggml_tensor * wsp_ggml_rope_multi(
         struct wsp_ggml_tensor  * b,
         struct wsp_ggml_tensor  * c,
         int                   n_dims,
-        int                   sections[4],
+        int                   sections[WSP_GGML_MROPE_SECTIONS],
         int                   mode,
         int                   n_ctx_orig,
         float                 freq_base,
@@ -3808,36 +3977,31 @@ struct wsp_ggml_tensor * wsp_ggml_rope_multi(
         float                 attn_factor,
         float                 beta_fast,
         float                 beta_slow) {
-    // Multimodal Rotary Position Embedding
-    WSP_GGML_ASSERT((mode & 1) == 0 && "mode & 1 == 1 is no longer supported");
-
-    WSP_GGML_ASSERT(wsp_ggml_is_vector(b));
-    WSP_GGML_ASSERT(b->type == WSP_GGML_TYPE_I32);
-    WSP_GGML_ASSERT(a->ne[2] * 4 == b->ne[0]); // mrope expecting 4 position ids per token
-
-    if (c) {
-        WSP_GGML_ASSERT(c->type == WSP_GGML_TYPE_F32);
-        WSP_GGML_ASSERT(c->ne[0] >= n_dims / 2);
-    }
-
-    struct wsp_ggml_tensor * result = wsp_ggml_dup_tensor(ctx, a);
-
-    int32_t params[11 + 4] = { /*n_past*/ 0, n_dims, mode, /*n_ctx*/ 0, n_ctx_orig };
-    memcpy(params +  5, &freq_base,    sizeof(float));
-    memcpy(params +  6, &freq_scale,   sizeof(float));
-    memcpy(params +  7, &ext_factor,   sizeof(float));
-    memcpy(params +  8, &attn_factor,  sizeof(float));
-    memcpy(params +  9, &beta_fast,    sizeof(float));
-    memcpy(params + 10, &beta_slow,    sizeof(float));
-    memcpy(&params[11], sections,      sizeof(int)*4);
-    wsp_ggml_set_op_params(result, params, sizeof(params));
-
-    result->op   = WSP_GGML_OP_ROPE;
-    result->src[0] = a;
-    result->src[1] = b;
-    result->src[2] = c;
+    return wsp_ggml_rope_impl(
+        ctx, a, b, c, n_dims, sections, mode, n_ctx_orig, freq_base, freq_scale,
+        ext_factor, attn_factor, beta_fast, beta_slow, false
+    );
+}
 
-    return result;
+struct wsp_ggml_tensor * wsp_ggml_rope_multi_inplace(
+        struct wsp_ggml_context * ctx,
+        struct wsp_ggml_tensor  * a,
+        struct wsp_ggml_tensor  * b,
+        struct wsp_ggml_tensor  * c,
+        int                   n_dims,
+        int                   sections[WSP_GGML_MROPE_SECTIONS],
+        int                   mode,
+        int                   n_ctx_orig,
+        float                 freq_base,
+        float                 freq_scale,
+        float                 ext_factor,
+        float                 attn_factor,
+        float                 beta_fast,
+        float                 beta_slow) {
+    return wsp_ggml_rope_impl(
+        ctx, a, b, c, n_dims, sections, mode, n_ctx_orig, freq_base, freq_scale,
+        ext_factor, attn_factor, beta_fast, beta_slow, true
+    );
 }
 
 struct wsp_ggml_tensor * wsp_ggml_rope_inplace(
@@ -3847,7 +4011,7 @@ struct wsp_ggml_tensor * wsp_ggml_rope_inplace(
         int                   n_dims,
         int                   mode) {
     return wsp_ggml_rope_impl(
-        ctx, a, b, NULL, n_dims, mode, 0, 10000.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, true
+        ctx, a, b, NULL, n_dims, NULL, mode, 0, 10000.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, true
     );
 }
 
@@ -3866,7 +4030,7 @@ struct wsp_ggml_tensor * wsp_ggml_rope_ext(
         float                 beta_fast,
         float                 beta_slow) {
     return wsp_ggml_rope_impl(
-        ctx, a, b, c, n_dims, mode, n_ctx_orig, freq_base, freq_scale,
+        ctx, a, b, c, n_dims, NULL, mode, n_ctx_orig, freq_base, freq_scale,
         ext_factor, attn_factor, beta_fast, beta_slow, false
     );
 }
@@ -3886,7 +4050,7 @@ struct wsp_ggml_tensor * wsp_ggml_rope_ext_inplace(
         float                 beta_fast,
         float                 beta_slow) {
     return wsp_ggml_rope_impl(
-        ctx, a, b, c, n_dims, mode, n_ctx_orig, freq_base, freq_scale,
+        ctx, a, b, c, n_dims, NULL, mode, n_ctx_orig, freq_base, freq_scale,
         ext_factor, attn_factor, beta_fast, beta_slow, true
     );
 }
@@ -3905,7 +4069,7 @@ struct wsp_ggml_tensor * wsp_ggml_rope_custom(
         float                 beta_fast,
         float                 beta_slow) {
     return wsp_ggml_rope_impl(
-        ctx, a, b, NULL, n_dims, mode, n_ctx_orig, freq_base, freq_scale,
+        ctx, a, b, NULL, n_dims, NULL, mode, n_ctx_orig, freq_base, freq_scale,
         ext_factor, attn_factor, beta_fast, beta_slow, false
     );
 }
@@ -3924,7 +4088,7 @@ struct wsp_ggml_tensor * wsp_ggml_rope_custom_inplace(
         float                 beta_fast,
         float                 beta_slow) {
     return wsp_ggml_rope_impl(
-        ctx, a, b, NULL, n_dims, mode, n_ctx_orig, freq_base, freq_scale,
+        ctx, a, b, NULL, n_dims, NULL, mode, n_ctx_orig, freq_base, freq_scale,
         ext_factor, attn_factor, beta_fast, beta_slow, true
     );
 }
@@ -4122,14 +4286,13 @@ struct wsp_ggml_tensor * wsp_ggml_conv_1d_dw(
         int                   s0,
         int                   p0,
         int                   d0) {
-    struct wsp_ggml_tensor * new_a = wsp_ggml_reshape_4d(ctx, a, a->ne[0], 1, a->ne[1], a->ne[2]);
     struct wsp_ggml_tensor * new_b = wsp_ggml_reshape_4d(ctx, b, b->ne[0], 1, b->ne[1], b->ne[2]);
 
-    struct wsp_ggml_tensor * im2col = wsp_ggml_im2col(ctx, new_a, new_b, s0, 0, p0, 0, d0, 0, false, WSP_GGML_TYPE_F16);
+    struct wsp_ggml_tensor * im2col = wsp_ggml_im2col(ctx, a, new_b, s0, 0, p0, 0, d0, 0, false, WSP_GGML_TYPE_F16);
 
     struct wsp_ggml_tensor * result = wsp_ggml_mul_mat(ctx, im2col, a);
 
-    result = wsp_ggml_reshape_3d(ctx, result, b->ne[0], b->ne[1], 1);
+    result = wsp_ggml_reshape_3d(ctx, result, result->ne[0], result->ne[2], 1);
 
     return result;
 }
@@ -4210,6 +4373,91 @@ struct wsp_ggml_tensor * wsp_ggml_conv_2d(
     return result;
 }
 
+// a: [OC*IC, KD, KH, KW]
+// b: [N*IC, ID, IH, IW]
+// result: [N*OD, OH, OW, IC * KD * KH * KW]
+struct wsp_ggml_tensor * wsp_ggml_im2col_3d(
+        struct wsp_ggml_context * ctx,
+        struct wsp_ggml_tensor  * a,
+        struct wsp_ggml_tensor  * b,
+        int64_t               IC,
+        int                   s0, // stride width
+        int                   s1, // stride height
+        int                   s2, // stride depth
+        int                   p0, // padding width
+        int                   p1, // padding height
+        int                   p2, // padding depth
+        int                   d0, // dilation width
+        int                   d1, // dilation height
+        int                   d2, // dilation depth
+        enum wsp_ggml_type        dst_type) {
+    const int64_t N = b->ne[3] / IC;
+    const int64_t ID = b->ne[2];
+    const int64_t IH = b->ne[1];
+    const int64_t IW = b->ne[0];
+
+    const int64_t OC = a->ne[3] / IC;
+    UNUSED(OC);
+    const int64_t KD = a->ne[2];
+    const int64_t KH = a->ne[1];
+    const int64_t KW = a->ne[0];
+    const int64_t OD = wsp_ggml_calc_conv_output_size(ID, KD, s2, p2, d2);
+    const int64_t OH = wsp_ggml_calc_conv_output_size(IH, KH, s1, p1, d1);
+    const int64_t OW = wsp_ggml_calc_conv_output_size(IW, KW, s0, p0, d0);
+
+    WSP_GGML_ASSERT((OD > 0)  && "b too small compared to a");
+    WSP_GGML_ASSERT((OH > 0)  && "b too small compared to a");
+    WSP_GGML_ASSERT((OW > 0)  && "b too small compared to a");
+
+
+    const int64_t ne[4] = {KW*KH*KD*IC, OW, OH, OD*N};
+
+    struct wsp_ggml_tensor * result = wsp_ggml_new_tensor(ctx, dst_type, 4, ne);
+    int32_t params[] = { s0, s1, s2, p0, p1, p2, d0, d1, d2, (int32_t)IC};
+    wsp_ggml_set_op_params(result, params, sizeof(params));
+
+    result->op     = WSP_GGML_OP_IM2COL_3D;
+    result->src[0] = a;
+    result->src[1] = b;
+
+    return result;
+}
+
+// a: [OC*IC, KD, KH, KW]
+// b: [N*IC, ID, IH, IW]
+// result: [N*OC, OD, OH, OW]
+struct wsp_ggml_tensor * wsp_ggml_conv_3d(
+        struct wsp_ggml_context * ctx,
+        struct wsp_ggml_tensor  * a,
+        struct wsp_ggml_tensor  * b,
+        int64_t               IC,
+        int                   s0, // stride width
+        int                   s1, // stride height
+        int                   s2, // stride depth
+        int                   p0, // padding width
+        int                   p1, // padding height
+        int                   p2, // padding depth
+        int                   d0, // dilation width
+        int                   d1, // dilation height
+        int                   d2  // dilation depth
+        ) {
+    struct wsp_ggml_tensor * im2col = wsp_ggml_im2col_3d(ctx, a, b, IC, s0, s1, s2, p0, p1, p2, d0, d1, d2, a->type); // [N*OD, OH, OW, IC * KD * KH * KW]
+
+    int64_t OC = a->ne[3] / IC;
+    int64_t N = b->ne[3] / IC;
+    struct wsp_ggml_tensor * result =
+        wsp_ggml_mul_mat(ctx,
+                wsp_ggml_reshape_2d(ctx, im2col, im2col->ne[0], im2col->ne[3] * im2col->ne[2] * im2col->ne[1]), // [N*OD, OH, OW, IC * KD * KH * KW] => [N*OD*OH*OW, IC * KD * KH * KW]
+                wsp_ggml_reshape_2d(ctx, a, (a->ne[0] * a->ne[1] * a->ne[2] * IC), OC));                          // [OC*IC, KD, KH, KW] => [OC, IC * KD * KH * KW]
+
+    int64_t OD = im2col->ne[3] / N;
+    result = wsp_ggml_reshape_4d(ctx, result, im2col->ne[1]*im2col->ne[2], OD, N, OC); // [OC, N*OD*OH*OW] => [OC, N, OD, OH*OW]
+    result = wsp_ggml_cont(ctx, wsp_ggml_permute(ctx, result, 0, 1, 3, 2)); // [N, OC, OD, OH*OW]
+    result = wsp_ggml_reshape_4d(ctx, result, im2col->ne[1], im2col->ne[2], OD, OC * N); // [N*OC, OD, OH, OW]
+
+    return result;
+}
+
 // wsp_ggml_conv_2d_sk_p0
 
 struct wsp_ggml_tensor * wsp_ggml_conv_2d_sk_p0(
@@ -4331,6 +4579,56 @@ struct wsp_ggml_tensor * wsp_ggml_conv_2d_direct(
     return result;
 }
 
+// wsp_ggml_conv_3d_direct
+
+struct wsp_ggml_tensor * wsp_ggml_conv_3d_direct(
+        struct wsp_ggml_context * ctx,
+        struct wsp_ggml_tensor  * a,
+        struct wsp_ggml_tensor  * b,
+        int                   s0,
+        int                   s1,
+        int                   s2,
+        int                   p0,
+        int                   p1,
+        int                   p2,
+        int                   d0,
+        int                   d1,
+        int                   d2,
+        int                   c,
+        int                   n,
+        int                   oc) {
+
+    WSP_GGML_ASSERT(a->ne[3] == (int64_t) c * oc);
+    WSP_GGML_ASSERT(b->ne[3] == (int64_t) c * n);
+
+    int64_t ne[4];
+    ne[0] = wsp_ggml_calc_conv_output_size(b->ne[0], a->ne[0], s0, p0, d0);
+    ne[1] = wsp_ggml_calc_conv_output_size(b->ne[1], a->ne[1], s1, p1, d1);
+    ne[2] = wsp_ggml_calc_conv_output_size(b->ne[2], a->ne[2], s2, p2, d2);
+    ne[3] = (int64_t) oc * n;
+
+    struct wsp_ggml_tensor * result = wsp_ggml_new_tensor(ctx, WSP_GGML_TYPE_F32, 4, ne);
+
+    wsp_ggml_set_op_params_i32(result, 0,  s0);
+    wsp_ggml_set_op_params_i32(result, 1,  s1);
+    wsp_ggml_set_op_params_i32(result, 2,  s2);
+    wsp_ggml_set_op_params_i32(result, 3,  p0);
+    wsp_ggml_set_op_params_i32(result, 4,  p1);
+    wsp_ggml_set_op_params_i32(result, 5,  p2);
+    wsp_ggml_set_op_params_i32(result, 6,  d0);
+    wsp_ggml_set_op_params_i32(result, 7,  d1);
+    wsp_ggml_set_op_params_i32(result, 8,  d2);
+    wsp_ggml_set_op_params_i32(result, 9,  c);
+    wsp_ggml_set_op_params_i32(result, 10, n);
+    wsp_ggml_set_op_params_i32(result, 11, oc);
+
+    result->op = WSP_GGML_OP_CONV_3D;
+    result->src[0] = a;
+    result->src[1] = b;
+
+    return result;
+}
+
 // wsp_ggml_conv_transpose_2d_p0
 
 static int64_t wsp_ggml_calc_conv_transpose_output_size(int64_t ins, int64_t ks, int s, int p) {
@@ -4509,11 +4807,36 @@ struct wsp_ggml_tensor * wsp_ggml_pad(
         int                   p1,
         int                   p2,
         int                   p3) {
+    return wsp_ggml_pad_ext(ctx, a, 0, p0, 0, p1, 0, p2, 0, p3);
+}
+
+struct wsp_ggml_tensor * wsp_ggml_pad_ext(
+            struct wsp_ggml_context * ctx,
+            struct wsp_ggml_tensor  * a,
+            int                  lp0,
+            int                  rp0,
+            int                  lp1,
+            int                  rp1,
+            int                  lp2,
+            int                  rp2,
+            int                  lp3,
+            int                  rp3
+            ) {
     struct wsp_ggml_tensor * result = wsp_ggml_new_tensor_4d(ctx, a->type,
-            a->ne[0] + p0,
-            a->ne[1] + p1,
-            a->ne[2] + p2,
-            a->ne[3] + p3);
+            a->ne[0] + lp0 + rp0,
+            a->ne[1] + lp1 + rp1,
+            a->ne[2] + lp2 + rp2,
+            a->ne[3] + lp3 + rp3);
+
+    wsp_ggml_set_op_params_i32(result, 0, lp0);
+    wsp_ggml_set_op_params_i32(result, 1, rp0);
+    wsp_ggml_set_op_params_i32(result, 2, lp1);
+    wsp_ggml_set_op_params_i32(result, 3, rp1);
+    wsp_ggml_set_op_params_i32(result, 4, lp2);
+    wsp_ggml_set_op_params_i32(result, 5, rp2);
+    wsp_ggml_set_op_params_i32(result, 6, lp3);
+    wsp_ggml_set_op_params_i32(result, 7, rp3);
+
 
     result->op     = WSP_GGML_OP_PAD;
     result->src[0] = a;
@@ -4609,12 +4932,8 @@ struct wsp_ggml_tensor * wsp_ggml_timestep_embedding(
         struct wsp_ggml_tensor  * timesteps,
         int                   dim,
         int                   max_period) {
-    int actual_dim = dim;
-    if (dim % 2 != 0) {
-        actual_dim = dim + 1;
-    }
 
-    struct wsp_ggml_tensor * result = wsp_ggml_new_tensor_2d(ctx, WSP_GGML_TYPE_F32, actual_dim, timesteps->ne[0]);
+    struct wsp_ggml_tensor * result = wsp_ggml_new_tensor_2d(ctx, WSP_GGML_TYPE_F32, dim, timesteps->ne[0]);
 
     wsp_ggml_set_op_params_i32(result, 0, dim);
     wsp_ggml_set_op_params_i32(result, 1, max_period);
@@ -4674,13 +4993,17 @@ struct wsp_ggml_tensor * wsp_ggml_flash_attn_ext(
     WSP_GGML_ASSERT(wsp_ggml_can_mul_mat(k, q));
     // TODO: check if vT can be multiplied by (k*qT)
 
+    WSP_GGML_ASSERT(q->ne[3] == k->ne[3]);
+    WSP_GGML_ASSERT(q->ne[3] == v->ne[3]);
+
     if (mask) {
         WSP_GGML_ASSERT(wsp_ggml_is_contiguous(mask));
-        WSP_GGML_ASSERT(mask->ne[2] == 1);
-        WSP_GGML_ASSERT(mask->ne[3] == 1);
         WSP_GGML_ASSERT(mask->ne[1] >= WSP_GGML_PAD(q->ne[1], WSP_GGML_KQ_MASK_PAD) &&
                 "the Flash-Attention kernel requires the mask to be padded to WSP_GGML_KQ_MASK_PAD and at least n_queries big");
         //WSP_GGML_ASSERT(wsp_ggml_can_repeat_rows(mask, qk));
+
+        WSP_GGML_ASSERT(q->ne[2] % mask->ne[2] == 0);
+        WSP_GGML_ASSERT(q->ne[3] % mask->ne[3] == 0);
     }
 
     if (max_bias > 0.0f) {
@@ -4722,6 +5045,22 @@ enum wsp_ggml_prec wsp_ggml_flash_attn_ext_get_prec(
     return (enum wsp_ggml_prec) prec_i32;
 }
 
+void wsp_ggml_flash_attn_ext_add_sinks(
+        struct wsp_ggml_tensor * a,
+        struct wsp_ggml_tensor * sinks) {
+    if (!sinks) {
+        a->src[4] = NULL;
+        return;
+    }
+
+    WSP_GGML_ASSERT(a->op == WSP_GGML_OP_FLASH_ATTN_EXT);
+    WSP_GGML_ASSERT(a->src[4] == NULL);
+    WSP_GGML_ASSERT(a->src[0]->ne[2] == sinks->ne[0]);
+    WSP_GGML_ASSERT(sinks->type == WSP_GGML_TYPE_F32);
+
+    a->src[4] = sinks;
+}
+
 // wsp_ggml_flash_attn_back
 
 struct wsp_ggml_tensor * wsp_ggml_flash_attn_back(
@@ -4808,7 +5147,6 @@ struct wsp_ggml_tensor * wsp_ggml_ssm_conv(
     const int64_t n_s     = sx->ne[2];
 
     // TODO: maybe support other strides than 1?
-    // FIXME: this is always true?
     WSP_GGML_ASSERT(sx->ne[0] == d_conv - 1 + n_t);
     WSP_GGML_ASSERT(sx->ne[1] == d_inner);
     WSP_GGML_ASSERT(n_t >= 0);
@@ -4831,36 +5169,49 @@ struct wsp_ggml_tensor * wsp_ggml_ssm_scan(
         struct wsp_ggml_tensor  * dt,
         struct wsp_ggml_tensor  * A,
         struct wsp_ggml_tensor  * B,
-        struct wsp_ggml_tensor  * C) {
+        struct wsp_ggml_tensor  * C,
+        struct wsp_ggml_tensor  * ids) {
     WSP_GGML_ASSERT(wsp_ggml_is_contiguous(s));
-    WSP_GGML_ASSERT(wsp_ggml_is_contiguous(x));
     WSP_GGML_ASSERT(wsp_ggml_is_contiguous(dt));
     WSP_GGML_ASSERT(wsp_ggml_is_contiguous(A));
-    WSP_GGML_ASSERT(wsp_ggml_is_matrix(A));
-    WSP_GGML_ASSERT(wsp_ggml_is_3d(B));
-    WSP_GGML_ASSERT(wsp_ggml_is_3d(s));
+    WSP_GGML_ASSERT(x->nb[0] == wsp_ggml_type_size(x->type));
     WSP_GGML_ASSERT(B->nb[0] == wsp_ggml_type_size(B->type));
     WSP_GGML_ASSERT(C->nb[0] == wsp_ggml_type_size(C->type));
-    WSP_GGML_ASSERT(wsp_ggml_are_same_shape(x, dt));
+    WSP_GGML_ASSERT(x->nb[1] == x->ne[0]*x->nb[0]);
+    WSP_GGML_ASSERT(B->nb[1] == B->ne[0]*B->nb[0]);
+    WSP_GGML_ASSERT(C->nb[1] == C->ne[0]*C->nb[0]);
     WSP_GGML_ASSERT(wsp_ggml_are_same_shape(B, C));
+    WSP_GGML_ASSERT(ids->type == WSP_GGML_TYPE_I32);
 
     {
         const int64_t d_state      = s->ne[0];
-        const int64_t d_inner      = s->ne[1];
-        const int64_t n_seq_tokens = x->ne[1];
-        const int64_t n_seqs       = x->ne[2];
-
-        WSP_GGML_ASSERT(s->ne[2] == n_seqs);
-        WSP_GGML_ASSERT(x->ne[0] == d_inner);
-        WSP_GGML_ASSERT(A->ne[0] == d_state);
-        WSP_GGML_ASSERT(A->ne[1] == d_inner);
+        const int64_t head_dim     = x->ne[0];
+        const int64_t n_head       = x->ne[1];
+        const int64_t n_seq_tokens = x->ne[2];
+        const int64_t n_seqs       = x->ne[3];
+
+        WSP_GGML_ASSERT(dt->ne[0] == n_head);
+        WSP_GGML_ASSERT(dt->ne[1] == n_seq_tokens);
+        WSP_GGML_ASSERT(dt->ne[2] == n_seqs);
+        WSP_GGML_ASSERT(wsp_ggml_is_3d(dt));
+        WSP_GGML_ASSERT(s->ne[1] == head_dim);
+        WSP_GGML_ASSERT(s->ne[2] == n_head);
         WSP_GGML_ASSERT(B->ne[0] == d_state);
-        WSP_GGML_ASSERT(B->ne[1] == n_seq_tokens);
-        WSP_GGML_ASSERT(B->ne[2] == n_seqs);
+        WSP_GGML_ASSERT(B->ne[2] == n_seq_tokens);
+        WSP_GGML_ASSERT(B->ne[3] == n_seqs);
+        WSP_GGML_ASSERT(ids->ne[0] == n_seqs);
+        WSP_GGML_ASSERT(wsp_ggml_is_vector(ids));
+        WSP_GGML_ASSERT(A->ne[1] == n_head);
+        WSP_GGML_ASSERT(wsp_ggml_is_matrix(A));
+
+        if (A->ne[0] != 1) {
+            // Mamba-1 has more granular decay factors
+            WSP_GGML_ASSERT(A->ne[0] == d_state);
+        }
     }
 
     // concatenated y + ssm_states
-    struct wsp_ggml_tensor * result = wsp_ggml_new_tensor_1d(ctx, WSP_GGML_TYPE_F32, wsp_ggml_nelements(x) + wsp_ggml_nelements(s));
+    struct wsp_ggml_tensor * result = wsp_ggml_new_tensor_1d(ctx, WSP_GGML_TYPE_F32, wsp_ggml_nelements(x) + s->ne[0]*s->ne[1]*s->ne[2]*ids->ne[0]);
 
     result->op   = WSP_GGML_OP_SSM_SCAN;
     result->src[0] = s;
@@ -4869,6 +5220,7 @@ struct wsp_ggml_tensor * wsp_ggml_ssm_scan(
     result->src[3] = A;
     result->src[4] = B;
     result->src[5] = C;
+    result->src[6] = ids;
 
     return result;
 }
@@ -5424,6 +5776,28 @@ struct wsp_ggml_tensor * wsp_ggml_opt_step_adamw(
     return result;
 }
 
+// opt_step_sgd
+
+struct wsp_ggml_tensor * wsp_ggml_opt_step_sgd(
+        struct wsp_ggml_context * ctx,
+        struct wsp_ggml_tensor  * a,
+        struct wsp_ggml_tensor  * grad,
+        struct wsp_ggml_tensor  * params) {
+    WSP_GGML_ASSERT(a->flags & WSP_GGML_TENSOR_FLAG_PARAM);
+    WSP_GGML_ASSERT(wsp_ggml_are_same_shape(a, grad));
+    WSP_GGML_ASSERT(params->type == WSP_GGML_TYPE_F32);
+    WSP_GGML_ASSERT(wsp_ggml_nelements(params) == 2);
+
+    struct wsp_ggml_tensor * result = wsp_ggml_view_tensor(ctx, a);
+
+    result->op     = WSP_GGML_OP_OPT_STEP_SGD;
+    result->src[0] = a;
+    result->src[1] = grad;
+    result->src[2] = params;
+
+    return result;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 struct wsp_ggml_hash_set wsp_ggml_hash_set_new(size_t size) {
@@ -5692,7 +6066,7 @@ static void wsp_ggml_compute_backward(
         } break;
         case WSP_GGML_OP_MEAN: {
             if (src0_needs_grads) {
-                wsp_ggml_add1_or_set(ctx, cgraph, isrc0, wsp_ggml_scale_impl(ctx, grad, 1.0f/src0->ne[0], false));
+                wsp_ggml_add1_or_set(ctx, cgraph, isrc0, wsp_ggml_scale_impl(ctx, grad, 1.0f/src0->ne[0], 0.0, false));
             }
         } break;
         case WSP_GGML_OP_REPEAT: {
@@ -5769,7 +6143,7 @@ static void wsp_ggml_compute_backward(
             if (src0_needs_grads) {
                 float s;
                 memcpy(&s, tensor->op_params, sizeof(float));
-                wsp_ggml_add_or_set(ctx, cgraph, isrc0, wsp_ggml_scale_impl(ctx, grad, s, false));
+                wsp_ggml_add_or_set(ctx, cgraph, isrc0, wsp_ggml_scale_impl(ctx, grad, s, 0.0, false));
             }
         } break;
         case WSP_GGML_OP_SET: {
@@ -6009,13 +6383,28 @@ static void wsp_ggml_compute_backward(
             }
             WSP_GGML_ASSERT(!src1_needs_grads && "backward pass for labels not implemented");
         } break;
+        case WSP_GGML_OP_GLU: {
+            switch (wsp_ggml_get_glu_op(tensor)) {
+                case WSP_GGML_GLU_OP_SWIGLU: {
+                    if (src0_needs_grads) {
+                        WSP_GGML_ASSERT(src1 && "backward pass only implemented for split swiglu");
+                        wsp_ggml_add_or_set(ctx, cgraph, isrc0, wsp_ggml_silu_back(ctx, wsp_ggml_mul(ctx, grad, src1), src0));
+                    }
+                    if (src1_needs_grads) {
+                        wsp_ggml_add_or_set(ctx, cgraph, isrc1, wsp_ggml_mul(ctx, wsp_ggml_silu(ctx, src0), grad));
+                    }
+                } break;
+                default: {
+                    WSP_GGML_ABORT("unsupported glu op for backward pass: %s", wsp_ggml_glu_op_name(wsp_ggml_get_glu_op(tensor)));
+                } //break;
+            }
+        } break;
         case WSP_GGML_OP_NONE: {
             // noop
         } break;
         case WSP_GGML_OP_COUNT:
         default: {
-            fprintf(stderr, "%s: unsupported ggml op for backward pass: %s\n", __func__, wsp_ggml_op_name(tensor->op));
-            WSP_GGML_ABORT("fatal error");
+            WSP_GGML_ABORT("%s: unsupported ggml op for backward pass: %s\n", __func__, wsp_ggml_op_name(tensor->op));
         } //break;
     }
 
@@ -6522,20 +6911,18 @@ static struct wsp_ggml_tensor * wsp_ggml_graph_get_parent(const struct wsp_ggml_
 static void wsp_ggml_graph_dump_dot_node_edge(FILE * fp, const struct wsp_ggml_cgraph * gb, struct wsp_ggml_tensor * node, struct wsp_ggml_tensor * parent, const char * label)  {
     struct wsp_ggml_tensor * gparent = wsp_ggml_graph_get_parent(gb, node);
     struct wsp_ggml_tensor * gparent0 = wsp_ggml_graph_get_parent(gb, parent);
-    fprintf(fp, "  \"%p\":%s -> \"%p\":%s [ arrowhead = %s; style = %s; label = \"%s\"; ]\n",
+    fprintf(fp, "  \"%p\" -> \"%p\" [ arrowhead = %s; style = %s; label = \"%s\"; ]\n",
             gparent0 ? (void *) gparent0 : (void *) parent,
-            gparent0 ? "g" : "x",
             gparent ? (void *) gparent : (void *) node,
-            gparent ? "g" : "x",
             gparent ? "empty" : "vee",
             gparent ? "dashed" : "solid",
             label);
 }
 
 static void wsp_ggml_graph_dump_dot_leaf_edge(FILE * fp, struct wsp_ggml_tensor * node, struct wsp_ggml_tensor * parent, const char * label)  {
-    fprintf(fp, "  \"%p\":%s -> \"%p\":%s [ label = \"%s\"; ]\n",
-            (void *) parent, "x",
-            (void *) node, "x",
+    fprintf(fp, "  \"%p\" -> \"%p\" [ label = \"%s\"; ]\n",
+            (void *) parent,
+            (void *) node,
             label);
 }
 
@@ -6756,6 +7143,7 @@ size_t wsp_ggml_wsp_quantize_chunk(
         case WSP_GGML_TYPE_Q5_0:    result = wsp_quantize_q5_0(src + start, (char *) dst + start_row * row_size, nrows, n_per_row, imatrix); break;
         case WSP_GGML_TYPE_Q5_1:    result = wsp_quantize_q5_1(src + start, (char *) dst + start_row * row_size, nrows, n_per_row, imatrix); break;
         case WSP_GGML_TYPE_Q8_0:    result = wsp_quantize_q8_0(src + start, (char *) dst + start_row * row_size, nrows, n_per_row, imatrix); break;
+        case WSP_GGML_TYPE_MXFP4:   result = wsp_quantize_mxfp4(src + start, (char *) dst + start_row * row_size, nrows, n_per_row, imatrix); break;
         case WSP_GGML_TYPE_Q2_K:    result = wsp_quantize_q2_K(src + start, (char *) dst + start_row * row_size, nrows, n_per_row, imatrix); break;
         case WSP_GGML_TYPE_Q3_K:    result = wsp_quantize_q3_K(src + start, (char *) dst + start_row * row_size, nrows, n_per_row, imatrix); break;
         case WSP_GGML_TYPE_Q4_K:    result = wsp_quantize_q4_K(src + start, (char *) dst + start_row * row_size, nrows, n_per_row, imatrix); break;