Function sam3_test_run_patch_mulmat_host_ref

sam3.cpp:6516–6578

}

bool sam3_test_run_patch_mulmat_host_ref(const sam3_model         & model,
                                         const float              * input_data,
                                         const int64_t              input_ne[4],
                                         bool                       use_double_accum,
                                         std::vector<float>       & output_data,
                                         int64_t                    output_ne[4]) {
    if (!input_data) {
        return false;
    }

    int64_t ne[4];
    sam3_normalize_ne4(input_ne, ne);

    const int64_t patch_k = model.vit.patch_embed_w->ne[0] * model.vit.patch_embed_w->ne[1] * model.vit.patch_embed_w->ne[2];
    const int64_t n_img = model.hparams.n_img_embd();

    if (ne[0] != patch_k || ne[1] != n_img || ne[2] != n_img) {
        fprintf(stderr, "%s: patch_mulmat input shape mismatch [%lld,%lld,%lld,%lld]\n",
                __func__,
                (long long) ne[0], (long long) ne[1], (long long) ne[2], (long long) ne[3]);
        return false;
    }

    const int64_t n_patch = ne[1] * ne[2] * ne[3];
    const int64_t n_out = model.vit.patch_embed_w->ne[3];

    std::vector<ggml_fp16_t> input_f16((size_t) (patch_k * n_patch));
    ggml_fp32_to_fp16_row(input_data, input_f16.data(), patch_k * n_patch);

    std::vector<ggml_fp16_t> weight_f16((size_t) (patch_k * n_out));
    ggml_backend_tensor_get(model.vit.patch_embed_w, weight_f16.data(), 0, weight_f16.size() * sizeof(ggml_fp16_t));

    output_data.resize((size_t) (n_patch * n_out));
    output_ne[0] = n_patch;
    output_ne[1] = n_out;
    output_ne[2] = 1;
    output_ne[3] = 1;

    for (int64_t oc = 0; oc < n_out; ++oc) {
        const ggml_fp16_t * w_row = weight_f16.data() + oc * patch_k;
        float * dst_row = output_data.data() + oc * n_patch;

        for (int64_t p = 0; p < n_patch; ++p) {
            const ggml_fp16_t * x_row = input_f16.data() + p * patch_k;

            if (use_double_accum) {
                double acc = 0.0;
                for (int64_t k = 0; k < patch_k; ++k) {
                    acc += (double) ggml_fp16_to_fp32(x_row[k]) * (double) ggml_fp16_to_fp32(w_row[k]);
                }
                dst_row[p] = (float) acc;
            } else {
                float acc = 0.0f;
                for (int64_t k = 0; k < patch_k; ++k) {
                    acc += ggml_fp16_to_fp32(x_row[k]) * ggml_fp16_to_fp32(w_row[k]);
                }
                dst_row[p] = acc;
            }