Function sam3_dump_tensor_to_path

sam3.cpp:12433–12524

}

static bool sam3_dump_tensor_to_path(struct ggml_tensor* t,
                                     const std::string& tensor_name,
                                     const std::string& output_path) {
    if (!t) {
        fprintf(stderr, "%s: tensor '%s' is null\n", __func__, tensor_name.c_str());
        return false;
    }

    int64_t numel = 1;
    for (int i = 0; i < GGML_MAX_DIMS; ++i) {
        if (t->ne[i] > 0) {
            numel *= t->ne[i];
        }
    }

    std::vector<float> data(numel);
    if (t->type != GGML_TYPE_F16 && t->type != GGML_TYPE_F32) {
        fprintf(stderr, "%s: unsupported tensor type %d for '%s'\n",
                __func__, (int)t->type, tensor_name.c_str());
        return false;
    }

    const int64_t ne0 = t->ne[0];
    const int64_t ne1 = t->ne[1];
    const int64_t ne2 = t->ne[2];
    const int64_t ne3 = t->ne[3];

    if (ggml_is_contiguous(t)) {
        if (t->type == GGML_TYPE_F16) {
            std::vector<ggml_fp16_t> f16_data(numel);
            ggml_backend_tensor_get(t, f16_data.data(), 0, numel * sizeof(ggml_fp16_t));
            ggml_fp16_to_fp32_row(f16_data.data(), data.data(), numel);
        } else {
            ggml_backend_tensor_get(t, data.data(), 0, numel * sizeof(float));
        }
    } else if (t->nb[0] == ggml_type_size(t->type)) {
        // Serialize non-contiguous logical tensors in row-major ggml order.
        if (t->type == GGML_TYPE_F16) {
            std::vector<ggml_fp16_t> row(ne0);
            for (int64_t i3 = 0; i3 < ne3; ++i3) {
                for (int64_t i2 = 0; i2 < ne2; ++i2) {
                    for (int64_t i1 = 0; i1 < ne1; ++i1) {
                        const size_t row_idx = ((size_t) i3 * ne2 * ne1 + (size_t) i2 * ne1 + (size_t) i1) * ne0;
                        const size_t offs = i3 * t->nb[3] + i2 * t->nb[2] + i1 * t->nb[1];
                        ggml_backend_tensor_get(t, row.data(), offs, ne0 * sizeof(ggml_fp16_t));
                        ggml_fp16_to_fp32_row(row.data(), data.data() + row_idx, ne0);
                    }
                }
            }
        } else {
            for (int64_t i3 = 0; i3 < ne3; ++i3) {
                for (int64_t i2 = 0; i2 < ne2; ++i2) {
                    for (int64_t i1 = 0; i1 < ne1; ++i1) {
                        const size_t row_idx = ((size_t) i3 * ne2 * ne1 + (size_t) i2 * ne1 + (size_t) i1) * ne0;
                        const size_t offs = i3 * t->nb[3] + i2 * t->nb[2] + i1 * t->nb[1];
                        ggml_backend_tensor_get(t, data.data() + row_idx, offs, ne0 * sizeof(float));
                    }
                }