ggml : add ggml_backend_sched_debug_tensor ggml_backend API

This commit adds a new function `ggml_backend_sched_debug_tensor` to the
ggml_backend API. This function allows users to print the values of a
specified tensor after graph computation, along with the mean squared
value.

The motivation for this addition is that it can be useful to use this as
ha "ballpark" check to check tensors before/after operations have been
been executed. This came out of use cases when converting new models to
llama.cpp and the need to track down discrepancies in tensor values.

As an example of usage, this function can be called after the graph has
been excuted, for example in `process_ubatch` in llama-context.cpp:
```c++
    ggml_backend_sched_debug_tensor(sched.get(), res->get_gf(), "inp_embd", 10);
```
This will log something like the following, assuming logging is set to
debug/verbose level:
```console
ggml_backend_sched_debug_tensor: Tensor 'inp_embd', type: f32
ggml_backend_sched_debug_tensor: ne = [2048 6 1 1]
ggml_backend_sched_debug_tensor: Tensor value at [0, 0, 0, 0]: 7.241361
ggml_backend_sched_debug_tensor: Tensor value at [0, 0, 0, 1]: 5.649519
ggml_backend_sched_debug_tensor: Tensor value at [0, 0, 0, 2]: 9.418730
ggml_backend_sched_debug_tensor: Tensor value at [0, 0, 0, 3]: 8.292873
ggml_backend_sched_debug_tensor: Tensor value at [0, 0, 0, 4]: 9.473540
ggml_backend_sched_debug_tensor: Tensor value at [0, 0, 0, 5]: 9.034624
ggml_backend_sched_debug_tensor: Tensor value at [0, 0, 0, 6]: 9.187912
ggml_backend_sched_debug_tensor: Tensor value at [0, 0, 0, 7]: 1.406322
ggml_backend_sched_debug_tensor: Tensor value at [0, 0, 0, 8]: 4.729420
ggml_backend_sched_debug_tensor: Tensor value at [0, 0, 0, 9]: 4.343110
ggml_backend_sched_debug_tensor: inp_embd mean_sq = 41.4566065470
```
One thing to keep in mind is that the tensor needs to have a name and
also we need to ensure that the graph does not reuse the tensor during
scheduling. This can be done by setting the tensor as output to
preserve it.

Author: danbev

ggml/include/ggml-backend.h

@@ -339,6 +339,13 @@ extern "C" {
     // Set a callback to be called for each resulting node during graph compute
     GGML_API void                 ggml_backend_sched_set_eval_callback(ggml_backend_sched_t sched, ggml_backend_sched_eval_callback callback, void * user_data);
 
+    // Debug/log the tensor mean squared value and optionally a specified number
+    // of values from the tensor.
+    //
+    // Note that the tensor in needs to be named using ggml_set_name or equivalent,
+    // and it also has to be prevented from being reused (optimized out) by the graph scheduler.
+    GGML_API void                 ggml_backend_sched_debug_tensor(ggml_backend_sched_t sched, struct ggml_cgraph * graph, const char * name, size_t n_values_to_log);
+
     //
     // Utils
     //

ggml/src/ggml-backend.cpp

@@ -1803,6 +1803,74 @@ void ggml_backend_sched_set_eval_callback(ggml_backend_sched_t sched, ggml_backe
     sched->callback_eval_user_data = user_data;
 }
 
+static float ggml_get_float_value(const uint8_t * data, enum ggml_type type,
+        const size_t * nb, size_t i0, size_t i1, size_t i2, size_t i3) {
+    size_t i = i3 * nb[3] + i2 * nb[2] + i1 * nb[1] + i0 * nb[0];
+    switch (type) {
+        case GGML_TYPE_F16:
+            return ggml_fp16_to_fp32(*(const ggml_fp16_t *) &data[i]);
+        case GGML_TYPE_F32:
+            return *(const float *) &data[i];
+        case GGML_TYPE_I64:
+            return (float) *(const int64_t *) &data[i];
+        case GGML_TYPE_I32:
+            return (float) *(const int32_t *) &data[i];
+        case GGML_TYPE_I16:
+            return (float) *(const int16_t *) &data[i];
+        case GGML_TYPE_I8:
+            return (float) *(const int8_t *) &data[i];
+        case GGML_TYPE_BF16:
+            return ggml_compute_bf16_to_fp32(*(const ggml_bf16_t *) &data[i]);
+        default:
+            GGML_ABORT("fatal error");
+    }
+}
+
+void ggml_backend_sched_debug_tensor(ggml_backend_sched_t sched, struct ggml_cgraph * graph, const char * name, size_t n_values_to_log) {
+    GGML_ASSERT(sched);
+    GGML_ASSERT(graph);
+
+    struct ggml_tensor * t = ggml_graph_get_tensor(graph, name);
+    if (t == nullptr) {
+        GGML_LOG_DEBUG("%s: Tensor '%s' not found in graph.\n", __func__, name);
+        return;
+    }
+
+    GGML_LOG_DEBUG("%s: Tensor '%s', type: %s\n", __func__, t->name, ggml_type_name(t->type));
+    GGML_LOG_DEBUG("%s: ne = [%lld %lld %lld %lld]\n", __func__, (long long) t->ne[0], (long long) t->ne[1], (long long) t->ne[2], (long long) t->ne[3]);
+
+    size_t n_bytes = ggml_nbytes(t);
+    std::vector<uint8_t> data_bytes(n_bytes);
+
+    ggml_backend_t backend = ggml_backend_sched_get_tensor_backend(sched, t);
+
+    ggml_backend_tensor_get_async(backend, t, data_bytes.data(), 0, n_bytes);
+    ggml_backend_sched_synchronize(sched);
+
+    float sum_sq = 0.0;
+    uint8_t * d = data_bytes.data();
+
+    size_t v_count = 0;
+    for (int64_t i3 = 0; i3 < t->ne[3]; i3++) {
+        for (int64_t i2 = 0; i2 < t->ne[2]; i2++) {
+            for (int64_t i1 = 0; i1 < t->ne[1]; i1++) {
+                for (int64_t i0 = 0; i0 < t->ne[0]; i0++) {
+                    const float v = ggml_get_float_value(d, t->type, t->nb, i0, i1, i2, i3);
+                    sum_sq += v * v;
+
+                    if (v_count++ < n_values_to_log) {
+                        GGML_LOG_DEBUG("%s: Tensor value at [%lld, %lld, %lld, %lld]: %.6f\n", __func__,
+                            (long long)i3, (long long)i2, (long long)i1, (long long)i0, v);
+                    }
+                }
+            }
+        }
+    }
+
+    double mean_sq = sum_sq / (double) ggml_nelements(t);
+    GGML_LOG_DEBUG("%s: %s mean_sq = %.10f\n", __func__, t->name, mean_sq);
+}
+
 int ggml_backend_sched_get_n_splits(ggml_backend_sched_t sched) {
     GGML_ASSERT(sched);
     return sched->n_splits;