diff --git a/common/debug.cpp b/common/debug.cpp index 0df409a79..102c6924d 100644 --- a/common/debug.cpp +++ b/common/debug.cpp @@ -1,9 +1,38 @@ #include "debug.h" +#include "common.h" #include "log.h" #include +#include #include +#include + +struct common_debug_cb_user_data::impl { + std::vector data; + std::vector tensor_filters; + bool abort_on_nan{false}; +}; + +common_debug_cb_user_data::common_debug_cb_user_data() : pimpl(std::make_unique()) {} +common_debug_cb_user_data::~common_debug_cb_user_data() = default; + +common_debug_cb_user_data::common_debug_cb_user_data(common_params & params, const std::vector & filter_patterns, bool abort_on_nan) + : pimpl(std::make_unique()) +{ + for (const auto & pattern : filter_patterns) { + try { + std::string anchored_pattern = "^" + pattern; + pimpl->tensor_filters.emplace_back(anchored_pattern, std::regex::optimize); + } catch (const std::regex_error & e) { + throw std::runtime_error("Invalid regex pattern '" + pattern + "': " + e.what()); + } + } + pimpl->abort_on_nan = abort_on_nan; + + params.cb_eval = common_debug_cb_eval; + params.cb_eval_user_data = this; +} static std::string common_ggml_ne_string(const ggml_tensor * t) { std::string str; @@ -47,8 +76,7 @@ static float common_ggml_get_float_value(const uint8_t * data, #define INDENT " " -template -void common_debug_print_tensor(uint8_t * data, ggml_type type, const int64_t * ne, const size_t * nb, int64_t n) { +static void common_debug_print_tensor(uint8_t * data, ggml_type type, const int64_t * ne, const size_t * nb, int64_t n, bool abort_on_nan) { GGML_ASSERT(n > 0); float sum = 0; for (int64_t i3 = 0; i3 < ne[3]; i3++) { @@ -94,7 +122,7 @@ void common_debug_print_tensor(uint8_t * data, ggml_type type, const int64_t * n LOG(INDENT "sum = %f\n", sum); } - if constexpr (abort) { + if (abort_on_nan) { if (std::isnan(sum)) { LOG("encountered NaN - aborting\n"); exit(0); @@ -112,8 +140,9 @@ void common_debug_print_tensor(uint8_t * data, ggml_type type, const int64_t * n * @param user_data user data to pass at each call back * @return true to receive data or continue the graph, false otherwise */ -template bool common_debug_cb_eval(struct ggml_tensor * t, bool ask, void * user_data) { - auto * cb_data = (base_callback_data *) user_data; +bool common_debug_cb_eval(struct ggml_tensor * t, bool ask, void * user_data) { + auto * cb_data = (common_debug_cb_user_data *) user_data; + auto * pimpl = cb_data->pimpl.get(); const struct ggml_tensor * src0 = t->src[0]; const struct ggml_tensor * src1 = t->src[1]; @@ -122,10 +151,10 @@ template bool common_debug_cb_eval(struct ggml_tensor * t, b return true; // Always retrieve data } - bool matches_filter = cb_data->tensor_filters.empty(); + bool matches_filter = pimpl->tensor_filters.empty(); if (!matches_filter) { - for (const auto & filter : cb_data->tensor_filters) { + for (const auto & filter : pimpl->tensor_filters) { if (std::regex_search(t->name, filter)) { matches_filter = true; break; @@ -148,20 +177,14 @@ template bool common_debug_cb_eval(struct ggml_tensor * t, b if (!is_host) { auto n_bytes = ggml_nbytes(t); - cb_data->data.resize(n_bytes); - ggml_backend_tensor_get(t, cb_data->data.data(), 0, n_bytes); + pimpl->data.resize(n_bytes); + ggml_backend_tensor_get(t, pimpl->data.data(), 0, n_bytes); } if (!ggml_is_quantized(t->type) && matches_filter) { - uint8_t * data = is_host ? (uint8_t *) t->data : cb_data->data.data(); - common_debug_print_tensor(data, t->type, t->ne, t->nb, 3); + uint8_t * data = is_host ? (uint8_t *) t->data : pimpl->data.data(); + common_debug_print_tensor(data, t->type, t->ne, t->nb, 3, pimpl->abort_on_nan); } return true; } - -// Explicit template instantiations -template bool common_debug_cb_eval(ggml_tensor *, bool, void *); -template bool common_debug_cb_eval(ggml_tensor *, bool, void *); -template void common_debug_print_tensor(uint8_t *, ggml_type, const int64_t *, const size_t *, int64_t); -template void common_debug_print_tensor(uint8_t *, ggml_type, const int64_t *, const size_t *, int64_t); diff --git a/common/debug.h b/common/debug.h index e563b40d6..8b8f8c7aa 100644 --- a/common/debug.h +++ b/common/debug.h @@ -1,43 +1,31 @@ #pragma once -#include "common.h" + +#include #include #include -#include // common debug functions and structs -// Print a tensor's detailed data -// data - the tensor's data in byte format -// type - the tensor's quantization type -// ne - the tensor dimensions array -// nb - the tensor strides array -// n - the number of rows/columns to fully print -template void common_debug_print_tensor(uint8_t * data, ggml_type type, const int64_t * ne, const size_t * nb, int64_t n); +struct common_params; // Intended to use as callback for ggml_backend_sched_eval_callback // prints tensors that are processed in the computation graph -// by default prints all tensors, but can be configured by creating a `base_callback_data` instance with -// non-empty filter_patterns. See examples/debug.ccp for possible usage patterns -// The template parameter determines whether an error should be thrown whenever a NaN is encountered +// by default prints all tensors, but can be configured by creating a `common_debug_cb_user_data` instance with +// non-empty filter_patterns. See examples/debug.cpp for possible usage patterns +// `common_debug_cb_user_data` contains `abort_on_nan` flag that determines whether an error should be thrown whenever a NaN is encountered // in a tensor (useful for stopping debug sessions on first erroneous tensor) // The callback data will be passed as the third parameter (user_data) -template bool common_debug_cb_eval(struct ggml_tensor * t, bool ask, void * user_data); -struct base_callback_data { - std::vector data; - std::vector tensor_filters; +bool common_debug_cb_eval(struct ggml_tensor * t, bool ask, void * user_data); - base_callback_data() = default; +struct common_debug_cb_user_data { + struct impl; + std::unique_ptr pimpl; - base_callback_data(common_params & params, const std::vector & filter_patterns) { - for (const auto & pattern : filter_patterns) { - try { - std::string anchored_pattern = "^" + pattern; - tensor_filters.emplace_back(anchored_pattern, std::regex::optimize); - } catch (const std::regex_error & e) { - throw std::runtime_error("Invalid regex pattern '" + pattern + "': " + e.what()); - } - } - params.cb_eval = common_debug_cb_eval; - params.cb_eval_user_data = this; - } + common_debug_cb_user_data(); + ~common_debug_cb_user_data(); + + common_debug_cb_user_data(const common_debug_cb_user_data &) = delete; + common_debug_cb_user_data & operator=(const common_debug_cb_user_data &) = delete; + + common_debug_cb_user_data(common_params & params, const std::vector & filter_patterns, bool abort_on_nan = false); }; diff --git a/common/download.cpp b/common/download.cpp index 66b0c0b7e..c7a717f0a 100644 --- a/common/download.cpp +++ b/common/download.cpp @@ -630,7 +630,7 @@ static hf_cache::hf_file find_best_model(const hf_cache::hf_files & files, if (!tag.empty()) { tags.push_back(tag); } else { - tags = {"Q4_K_M", "Q4_0"}; + tags = {"Q4_K_M", "Q8_0"}; } for (const auto & t : tags) { diff --git a/common/fit.cpp b/common/fit.cpp index 4b9528890..aca3f4d40 100644 --- a/common/fit.cpp +++ b/common/fit.cpp @@ -856,7 +856,7 @@ void common_memory_breakdown_print(const struct llama_context * ctx) { ggml_backend_dev_memory(dev, &free, &total); const size_t self = mb.model + mb.context + mb.compute; - const size_t unaccounted = total - self - free; + const int64_t unaccounted = static_cast(total) - static_cast(free) - static_cast(self); table_data.push_back({ template_gpu, @@ -867,7 +867,7 @@ void common_memory_breakdown_print(const struct llama_context * ctx) { std::to_string(mb.model / MiB), std::to_string(mb.context / MiB), std::to_string(mb.compute / MiB), - std::to_string(unaccounted / MiB)}); + std::to_string(unaccounted / static_cast(MiB))}); } // print memory breakdown for host: diff --git a/convert_hf_to_gguf.py b/convert_hf_to_gguf.py index 93d5509e6..bf8af863a 100755 --- a/convert_hf_to_gguf.py +++ b/convert_hf_to_gguf.py @@ -272,6 +272,22 @@ class ModelBase: return tensors + @staticmethod + def _scale_is_trivial(scale: Tensor) -> bool: + return scale.numel() <= 1 and abs(float(scale.float().sum()) - 1.0) < 1e-6 + + def _write_scale_tensor(self, scale_name: str, scale: Tensor): + if not self._scale_is_trivial(scale): + scale_f32 = scale.float().numpy().flatten() + logger.info(f" + {scale_name} (per-tensor scale, shape [{scale_f32.size}])") + self.gguf_writer.add_tensor(scale_name, scale_f32) + + def _write_scales_tensor(self, scale_name: str, scales: list[float]): + if not np.allclose(scales, 1.0, atol=1e-6): + scale_vals = np.array(scales, dtype=np.float32) + logger.info(f" + {scale_name} (per-expert scale, shape [{len(scales)}])") + self.gguf_writer.add_tensor(scale_name, scale_vals) + def dequant_model(self): # If all quantized tensors were already handled (e.g. pure NVFP4), skip if self._is_nvfp4 and not any(k.endswith((".weight_scale", ".weight_scale_inv")) for k in self.model_tensors): @@ -494,7 +510,7 @@ class ModelBase: s = self.model_tensors[name] self.model_tensors[weight_name] = lambda w=w, s=s: dequant_simple(w(), s(), None) tensors_to_remove.append(name) - if name.endswith((".k_scale", ".v_scale")): + if name.endswith((".input_scale", ".k_scale", ".v_scale")): tensors_to_remove.append(name) elif quant_method is not None: raise NotImplementedError(f"Quant method is not yet supported: {quant_method!r}") @@ -602,10 +618,6 @@ class ModelBase: raw = np.concatenate([d_grouped, qs_grouped], axis=-1).reshape(out_features, n_super * 36) return raw, [out_features, n_super * 64] - @staticmethod - def _nvfp4_scale2_is_trivial(scale2: Tensor) -> bool: - return scale2.numel() <= 1 and abs(float(scale2.float().sum()) - 1.0) < 1e-6 - def _repack_nvfp4(self, name: str, weight: Tensor, scale: Tensor, scale2: Tensor, input_scale: Tensor): if "language_model." in name: name = name.replace("language_model.", "") @@ -616,19 +628,8 @@ class ModelBase: logger.info(f"Repacked {new_name} with shape {shape} and quantization NVFP4") self.gguf_writer.add_tensor(new_name, raw, raw_dtype=gguf.GGMLQuantizationType.NVFP4) - # Emit per-tensor scale2 as a separate F32 tensor when non-trivial - if not self._nvfp4_scale2_is_trivial(scale2): - scale2_f32 = scale2.float().numpy().flatten() - scale_name = new_name.replace(".weight", ".scale") - logger.info(f" + {scale_name} (per-tensor NVFP4 scale2, shape [{scale2_f32.size}])") - self.gguf_writer.add_tensor(scale_name, scale2_f32) - - # Emit per-tensor input_scale as a separate F32 tensor when non-trivial - if not self._nvfp4_scale2_is_trivial(input_scale): - input_scale_f32 = input_scale.float().numpy().flatten() - input_scale_name = new_name.replace(".weight", ".input_scale") - logger.info(f" + {input_scale_name} (per-tensor NVFP4 input_scale, shape [{input_scale_f32.size}])") - self.gguf_writer.add_tensor(input_scale_name, input_scale_f32) + self._write_scale_tensor(new_name.replace(".weight", ".scale"), scale2) + self._write_scale_tensor(new_name.replace(".weight", ".input_scale"), input_scale) def _generate_nvfp4_tensors(self): # Per-layer expert merging to avoid holding all experts in memory @@ -719,21 +720,11 @@ class ModelBase: logger.info(f"Repacked {new_name} with shape [{len(experts)}, {shape[0]}, {shape[1]}] and quantization NVFP4") self.gguf_writer.add_tensor(new_name, merged, raw_dtype=gguf.GGMLQuantizationType.NVFP4) - # Emit per-expert scale2 tensor if any expert has non-trivial scale2 scales.sort(key=lambda x: x[0]) - scale_vals = np.array([s[1] for s in scales], dtype=np.float32) - if not np.allclose(scale_vals, 1.0, atol=1e-6): - scale_name = new_name.replace(".weight", ".scale") - logger.info(f" + {scale_name} (per-expert NVFP4 scale2, shape [{len(scales)}])") - self.gguf_writer.add_tensor(scale_name, scale_vals) + self._write_scales_tensor(new_name.replace(".weight", ".scale"), [s[1] for s in scales]) - # Emit per-expert input_scale tensor if any expert has non-trivial input_scale input_scales.sort(key=lambda x: x[0]) - input_scale_vals = np.array([s[1] for s in input_scales], dtype=np.float32) - if not np.allclose(input_scale_vals, 1.0, atol=1e-6): - input_scale_name = new_name.replace(".weight", ".input_scale") - logger.info(f" + {input_scale_name} (per-expert NVFP4 input_scale, shape [{len(input_scales)}])") - self.gguf_writer.add_tensor(input_scale_name, input_scale_vals) + self._write_scales_tensor(new_name.replace(".weight", ".input_scale"), [s[1] for s in input_scales]) del experts, merged diff --git a/ggml/src/ggml-backend-meta.cpp b/ggml/src/ggml-backend-meta.cpp index 6d22f3421..41a61775b 100644 --- a/ggml/src/ggml-backend-meta.cpp +++ b/ggml/src/ggml-backend-meta.cpp @@ -1205,40 +1205,57 @@ static void ggml_backend_meta_buffer_set_tensor(ggml_backend_buffer_t buffer, gg if (split_state.n_segments != 1) { GGML_ASSERT(split_state.axis >= 0 && split_state.axis < GGML_MAX_DIMS); - GGML_ASSERT(offset == 0); - GGML_ASSERT(size == ggml_nbytes(tensor)); GGML_ASSERT(tensor->ne[3] == 1); + size_t offset_data = 0; std::vector simple_offsets(n_bufs, 0); if (split_state.axis == GGML_BACKEND_SPLIT_AXIS_0) { GGML_ASSERT(tensor->ne[2] == 1); + + const size_t row_stride = tensor->nb[1]; + GGML_ASSERT(offset % row_stride == 0); + GGML_ASSERT(size % row_stride == 0); + const int64_t r_start = offset / row_stride; + const int64_t r_count = size / row_stride; + GGML_ASSERT(r_start + r_count <= tensor->ne[1]); + const int64_t blck_size = ggml_blck_size(tensor->type); for (size_t s = 0; s < split_state.n_segments; s++) { for (size_t j = 0; j < n_bufs; j++) { ggml_tensor * simple_tensor = ggml_backend_meta_buffer_simple_tensor(tensor, j); GGML_ASSERT(split_state.ne[s*n_bufs + j] % blck_size == 0); const size_t nbytes = split_state.ne[s*n_bufs + j]/blck_size * tensor->nb[0]; - ggml_backend_tensor_set_2d(simple_tensor, (const char *) data + offset_data, simple_offsets[j], nbytes, - tensor->ne[1], simple_tensor->nb[1], tensor->nb[1]); + ggml_backend_tensor_set_2d(simple_tensor, (const char *) data + offset_data, + simple_offsets[j] + r_start * simple_tensor->nb[1], nbytes, + r_count, simple_tensor->nb[1], tensor->nb[1]); offset_data += nbytes; simple_offsets[j] += nbytes; } } - GGML_ASSERT(offset_data*tensor->ne[1] == size); + GGML_ASSERT(offset_data*r_count == size); return; } GGML_ASSERT(split_state.axis == GGML_BACKEND_SPLIT_AXIS_1); + + const size_t row_stride = tensor->nb[2]; + GGML_ASSERT(offset % row_stride == 0); + GGML_ASSERT(size % row_stride == 0); + const int64_t r_start = offset / row_stride; + const int64_t r_count = size / row_stride; + GGML_ASSERT(r_start + r_count <= tensor->ne[2]); + for (size_t s = 0; s < split_state.n_segments; s++) { for (size_t j = 0; j < n_bufs; j++) { ggml_tensor * simple_tensor = ggml_backend_meta_buffer_simple_tensor(tensor, j); const size_t nbytes = split_state.ne[s*n_bufs + j] * tensor->nb[1]; - ggml_backend_tensor_set_2d(simple_tensor, (const char *) data + offset_data, simple_offsets[j], nbytes, - tensor->ne[2], simple_tensor->nb[2], tensor->nb[2]); + ggml_backend_tensor_set_2d(simple_tensor, (const char *) data + offset_data, + simple_offsets[j] + r_start * simple_tensor->nb[2], nbytes, + r_count, simple_tensor->nb[2], tensor->nb[2]); offset_data += nbytes; simple_offsets[j] += nbytes; } } - GGML_ASSERT(offset_data*tensor->ne[2] == size); + GGML_ASSERT(offset_data*r_count == size); return; } @@ -1295,40 +1312,57 @@ static void ggml_backend_meta_buffer_get_tensor(ggml_backend_buffer_t buffer, co if (split_state.n_segments != 1) { GGML_ASSERT(split_state.axis >= 0 && split_state.axis < GGML_MAX_DIMS); - GGML_ASSERT(offset == 0); - GGML_ASSERT(size == ggml_nbytes(tensor)); GGML_ASSERT(tensor->ne[3] == 1); + size_t offset_data = 0; std::vector simple_offsets(n_bufs, 0); if (split_state.axis == GGML_BACKEND_SPLIT_AXIS_0) { GGML_ASSERT(tensor->ne[2] == 1); + + const size_t row_stride = tensor->nb[1]; + GGML_ASSERT(offset % row_stride == 0); + GGML_ASSERT(size % row_stride == 0); + const int64_t r_start = offset / row_stride; + const int64_t r_count = size / row_stride; + GGML_ASSERT(r_start + r_count <= tensor->ne[1]); + const int64_t blck_size = ggml_blck_size(tensor->type); for (size_t s = 0; s < split_state.n_segments; s++) { for (size_t j = 0; j < n_bufs; j++) { const ggml_tensor * simple_tensor = ggml_backend_meta_buffer_simple_tensor(tensor, j); GGML_ASSERT(split_state.ne[s*n_bufs + j] % blck_size == 0); const size_t nbytes = split_state.ne[s*n_bufs + j]/blck_size * tensor->nb[0]; - ggml_backend_tensor_get_2d(simple_tensor, (char *) data + offset_data, simple_offsets[j], nbytes, - tensor->ne[1], simple_tensor->nb[1], tensor->nb[1]); + ggml_backend_tensor_get_2d(simple_tensor, (char *) data + offset_data, + simple_offsets[j] + r_start * simple_tensor->nb[1], nbytes, + r_count, simple_tensor->nb[1], tensor->nb[1]); offset_data += nbytes; simple_offsets[j] += nbytes; } } - GGML_ASSERT(offset_data*tensor->ne[1] == size); + GGML_ASSERT(offset_data*r_count == size); return; } GGML_ASSERT(split_state.axis == GGML_BACKEND_SPLIT_AXIS_1); + + const size_t row_stride = tensor->nb[2]; + GGML_ASSERT(offset % row_stride == 0); + GGML_ASSERT(size % row_stride == 0); + const int64_t r_start = offset / row_stride; + const int64_t r_count = size / row_stride; + GGML_ASSERT(r_start + r_count <= tensor->ne[2]); + for (size_t s = 0; s < split_state.n_segments; s++) { for (size_t j = 0; j < n_bufs; j++) { const ggml_tensor * simple_tensor = ggml_backend_meta_buffer_simple_tensor(tensor, j); const size_t nbytes = split_state.ne[s*n_bufs + j] * tensor->nb[1]; - ggml_backend_tensor_get_2d(simple_tensor, (char *) data + offset_data, simple_offsets[j], nbytes, - tensor->ne[2], simple_tensor->nb[2], tensor->nb[2]); + ggml_backend_tensor_get_2d(simple_tensor, (char *) data + offset_data, + simple_offsets[j] + r_start * simple_tensor->nb[2], nbytes, + r_count, simple_tensor->nb[2], tensor->nb[2]); offset_data += nbytes; simple_offsets[j] += nbytes; } } - GGML_ASSERT(offset_data*tensor->ne[2] == size); + GGML_ASSERT(offset_data*r_count == size); return; } diff --git a/src/models/llama.cpp b/src/models/llama.cpp index ddaa6c40f..8d478dc67 100644 --- a/src/models/llama.cpp +++ b/src/models/llama.cpp @@ -72,9 +72,6 @@ llm_build_llama::llm_build_llama(const llama_model & model, const llm_gra cur = build_attn(inp_attn, model.layers[il].wo, model.layers[il].wo_b, model.layers[il].wo_s, Qcur, Kcur, Vcur, nullptr, nullptr, nullptr, kq_scale, il); - if (model.layers[il].wo_s) { - cur = ggml_mul(ctx0, cur, model.layers[il].wo_s); - } cb(cur, "attn_out", il); } if (il == n_layer - 1 && inp_out_ids) { diff --git a/src/models/qwen3.cpp b/src/models/qwen3.cpp index e6f1fc81d..883dd5f9a 100644 --- a/src/models/qwen3.cpp +++ b/src/models/qwen3.cpp @@ -58,9 +58,6 @@ llm_build_qwen3::llm_build_qwen3(const llama_model & model, const llm_graph_para cur = build_attn(inp_attn, model.layers[il].wo, model.layers[il].wo_b, model.layers[il].wo_s, Qcur, Kcur, Vcur, nullptr, nullptr, nullptr, 1.0f/sqrtf(float(n_embd_head)), il); - if (model.layers[il].wo_s) { - cur = ggml_mul(ctx0, cur, model.layers[il].wo_s); - } } if (il == n_layer - 1 && inp_out_ids) { cur = ggml_get_rows(ctx0, cur, inp_out_ids); diff --git a/src/models/qwen3moe.cpp b/src/models/qwen3moe.cpp index dc554b5b3..16bedba99 100644 --- a/src/models/qwen3moe.cpp +++ b/src/models/qwen3moe.cpp @@ -58,9 +58,6 @@ llm_build_qwen3moe::llm_build_qwen3moe(const llama_model & model, const llm_grap cur = build_attn(inp_attn, model.layers[il].wo, model.layers[il].wo_b, model.layers[il].wo_s, Qcur, Kcur, Vcur, nullptr, nullptr, nullptr, 1.0f/sqrtf(float(n_embd_head)), il); - if (model.layers[il].wo_s) { - cur = ggml_mul(ctx0, cur, model.layers[il].wo_s); - } } if (il == n_layer - 1 && inp_out_ids) { cur = ggml_get_rows(ctx0, cur, inp_out_ids); diff --git a/tools/mtmd/debug/mtmd-debug.cpp b/tools/mtmd/debug/mtmd-debug.cpp index 6e32b283a..1e41ef793 100644 --- a/tools/mtmd/debug/mtmd-debug.cpp +++ b/tools/mtmd/debug/mtmd-debug.cpp @@ -72,7 +72,7 @@ int main(int argc, char ** argv) { mtmd::context_ptr ctx_mtmd; common_init_result_ptr llama_init; - base_callback_data cb_data; + common_debug_cb_user_data cb_data; llama_init = common_init_from_params(params); { @@ -89,7 +89,7 @@ int main(int argc, char ** argv) { { // always enable debug callback mparams.cb_eval_user_data = &cb_data; - mparams.cb_eval = common_debug_cb_eval; + mparams.cb_eval = common_debug_cb_eval; } ctx_mtmd.reset(mtmd_init_from_file(clip_path, model, mparams)); if (!ctx_mtmd.get()) { diff --git a/tools/mtmd/mtmd-cli.cpp b/tools/mtmd/mtmd-cli.cpp index dd72dfb17..be958bd17 100644 --- a/tools/mtmd/mtmd-cli.cpp +++ b/tools/mtmd/mtmd-cli.cpp @@ -90,7 +90,7 @@ struct mtmd_cli_context { int n_threads = 1; llama_pos n_past = 0; - base_callback_data cb_data; + common_debug_cb_user_data cb_data; mtmd_cli_context(common_params & params) : llama_init(common_init_from_params(params)) { model = llama_init->model(); @@ -145,7 +145,7 @@ struct mtmd_cli_context { mparams.image_max_tokens = params.image_max_tokens; if (std::getenv("MTMD_DEBUG_GRAPH") != nullptr) { mparams.cb_eval_user_data = &cb_data; - mparams.cb_eval = common_debug_cb_eval; + mparams.cb_eval = common_debug_cb_eval; } ctx_vision.reset(mtmd_init_from_file(clip_path, model, mparams)); if (!ctx_vision.get()) {