Upload pangu-diffusion-llamacpp.patch with huggingface_hub

pangu-diffusion-llamacpp.patch

@@ -1,8 +1,8 @@
 diff --git a/common/arg.cpp b/common/arg.cpp
-index 8b302d5..ac587a2 100644
+index 8b302d5..9c2c761 100644
 --- a/common/arg.cpp
 +++ b/common/arg.cpp
-@@ -4522,6 +4522,11 @@ common_params_context common_params_parser_init(common_params & params, llama_ex
+@@ -4522,6 +4522,16 @@ common_params_context common_params_parser_init(common_params & params, llama_ex
          string_format("llada block length for generation (default: %d)", params.diffusion.block_length),
          [](common_params & params, int value) { params.diffusion.block_length = value; }
      ).set_examples({ LLAMA_EXAMPLE_DIFFUSION }));
@@ -10,15 +10,20 @@ index 8b302d5..ac587a2 100644
 +        {"--diffusion-small-block"}, "N",
 +        string_format("small block length inside a block for context-causal block diffusion, 0 = whole block (default: %d)", params.diffusion.small_block_length),
 +        [](common_params & params, int value) { params.diffusion.small_block_length = value; }
++    ).set_examples({ LLAMA_EXAMPLE_DIFFUSION }));
++    add_opt(common_arg(
++        {"--diffusion-confidence-threshold"}, "F",
++        string_format("context-causal block diffusion: reveal every masked token above this confidence each step, 0 = one token per step (default: %.2f)", (double) params.diffusion.confidence_threshold),
++        [](common_params & params, const std::string & value) { params.diffusion.confidence_threshold = std::stof(value); }
 +    ).set_examples({ LLAMA_EXAMPLE_DIFFUSION }));
      add_opt(common_arg(
          {"--diffusion-cfg-scale"}, "F",
          string_format("llada classifier-free guidance scale (default: %.3f)", (double) params.diffusion.cfg_scale),
 diff --git a/common/common.h b/common/common.h
-index 0c2d5e4..386de7f 100644
+index 0c2d5e4..de32160 100644
 --- a/common/common.h
 +++ b/common/common.h
-@@ -413,6 +413,7 @@ struct common_params_diffusion {
+@@ -413,11 +413,13 @@ struct common_params_diffusion {
  
      float   eps           = 0;        // epsilon for timesteps
      int32_t block_length  = 0;        // block length for generation
@@ -26,6 +31,12 @@ index 0c2d5e4..386de7f 100644
  
      int32_t algorithm     = 4;        // default algorithm: low-confidence
      float   alg_temp      = 0.0f;     // algorithm temperature
+ 
+     float   cfg_scale     = 0;        // classifier-free guidance scale
++    float   confidence_threshold = 0; // context-causal block diffusion: reveal all tokens above this confidence per step (>0 enables it)
+     bool    add_gumbel_noise = false; // add gumbel noise to the logits if temp > 0.0
+ };
+ 
 diff --git a/conversion/pangu.py b/conversion/pangu.py
 index 74c7653..6b00cec 100644
 --- a/conversion/pangu.py
@@ -75,10 +86,10 @@ index 74c7653..6b00cec 100644
          if name == "lm_head.weight":
              if self.hparams.get("tie_word_embeddings", False):
 diff --git a/examples/diffusion/diffusion-cli.cpp b/examples/diffusion/diffusion-cli.cpp
-index c646113..76b3dd0 100644
+index c646113..cdcd6f9 100644
 --- a/examples/diffusion/diffusion-cli.cpp
 +++ b/examples/diffusion/diffusion-cli.cpp
-@@ -186,10 +186,20 @@ int main(int argc, char ** argv) {
+@@ -186,10 +186,21 @@ int main(int argc, char ** argv) {
          diff_params.shift_logits = true;
      }
  
@@ -95,23 +106,25 @@ index c646113..76b3dd0 100644
 +    GGML_ASSERT(!diff_params.block_attention || params.diffusion.block_length > 0);
 +
 +    if (diff_params.block_attention) {
-+        diff_params.block_length       = params.diffusion.block_length;
-+        diff_params.small_block_length = params.diffusion.small_block_length;
-+        diff_params.schedule           = DIFFUSION_TRANSFER_SCHEDULE_BLOCK_BASED;
++        diff_params.block_length           = params.diffusion.block_length;
++        diff_params.small_block_length     = params.diffusion.small_block_length;
++        diff_params.confidence_threshold   = params.diffusion.confidence_threshold;
++        diff_params.schedule               = DIFFUSION_TRANSFER_SCHEDULE_BLOCK_BASED;
 +    } else if (params.diffusion.eps) {
          diff_params.schedule = DIFFUSION_TRANSFER_SCHEDULE_TIMESTEP_BASED;
          diff_params.eps      = params.diffusion.eps;
      } else if (params.diffusion.block_length) {
-@@ -242,6 +252,8 @@ int main(int argc, char ** argv) {
+@@ -242,6 +253,9 @@ int main(int argc, char ** argv) {
          LOG_INF("diffusion_params: - %-25s u32              = %d\n", "block_length", diff_params.block_length);
          LOG_INF("diffusion_params: - %-25s f32              = %.3f\n", "cfg_scale", diff_params.cfg_scale);
      }
 +    LOG_INF("diffusion_params: - %-25s bool             = %s\n", "block_attention", diff_params.block_attention ? "true" : "false");
 +    LOG_INF("diffusion_params: - %-25s u32              = %d\n", "small_block_length", diff_params.small_block_length);
++    LOG_INF("diffusion_params: - %-25s f32              = %.3f\n", "confidence_threshold", diff_params.confidence_threshold);
  
      diffusion_generate(ctx, input_tokens.data(), output_tokens.data(), n_input, diff_params, n_generated);
  
-@@ -251,6 +263,7 @@ int main(int argc, char ** argv) {
+@@ -251,6 +265,7 @@ int main(int argc, char ** argv) {
              LOG_INF("\033[2J\033[H");
          }
  
@@ -120,10 +133,10 @@ index c646113..76b3dd0 100644
          std::string output_data = common_detokenize(vocab, output_tokens, false);
          LOG_INF("\n%s\n", output_data.c_str());
 diff --git a/examples/diffusion/diffusion.cpp b/examples/diffusion/diffusion.cpp
-index 0ff57d9..3e5ce80 100644
+index 0ff57d9..adc6857 100644
 --- a/examples/diffusion/diffusion.cpp
 +++ b/examples/diffusion/diffusion.cpp
-@@ -102,6 +102,199 @@ static std::vector<int32_t> get_num_transfer_tokens(int32_t mask_count, int32_t
+@@ -102,6 +102,250 @@ static std::vector<int32_t> get_num_transfer_tokens(int32_t mask_count, int32_t
      return num_transfer_tokens;
  }
  
@@ -187,6 +200,10 @@ index 0ff57d9..3e5ce80 100644
 +
 +    common_batch batch(ctx);
 +
++    std::vector<int32_t>     step_pos;
++    std::vector<llama_token> step_tok;
++    std::vector<float>       step_conf;
++
 +    auto run_range = [&](int32_t p0, int32_t p1) -> const float * {
 +        batch.clear();
 +        for (int32_t p = p0; p < p1; ++p) {
@@ -208,6 +225,33 @@ index 0ff57d9..3e5ce80 100644
 +        llama_token_data_array cur_p = { candidates.data(), (size_t) n_vocab, -1, false };
 +        llama_sampler_apply(sampler, &cur_p);
 +        tok  = cur_p.data[cur_p.selected].id;
++
++        // the greedy sampler does not compute probabilities - do it here so that the
++        // confidence/entropy/margin based reveal order is meaningful
++        bool probs_ready = false;
++        for (size_t i = 0; i < cur_p.size; ++i) {
++            if (cur_p.data[i].p != 0.0f) {
++                probs_ready = true;
++                break;
++            }
++        }
++        if (!probs_ready) {
++            float mx = -INFINITY;
++            for (size_t i = 0; i < cur_p.size; ++i) {
++                mx = std::max(mx, cur_p.data[i].logit);
++            }
++            float sum = 0.0f;
++            for (size_t i = 0; i < cur_p.size; ++i) {
++                cur_p.data[i].p = expf(cur_p.data[i].logit - mx);
++                sum += cur_p.data[i].p;
++            }
++            if (sum > 0.0f) {
++                for (size_t i = 0; i < cur_p.size; ++i) {
++                    cur_p.data[i].p /= sum;
++                }
++            }
++        }
++
 +        conf = calculate_confidence(cur_p, params.algorithm, rng);
 +    };
 +
@@ -258,10 +302,17 @@ index 0ff57d9..3e5ce80 100644
 +                    return;
 +                }
 +
-+                // predict every masked position of the current small block, reveal the most confident one
++                // predict every masked position of the current small block; reveal the most
++                // confident one and, when a confidence threshold is given, every position whose
++                // confidence exceeds it (this is what makes the "confidence_threshold" mode fast)
 +                float       best_conf = -INFINITY;
 +                int32_t     best_pos  = -1;
 +                llama_token best_tok  = 0;
++
++                step_pos.clear();
++                step_tok.clear();
++                step_conf.clear();
++
 +                for (int32_t p = sub_start; p < sub_end; ++p) {
 +                    if (output_tokens[p] != params.mask_token_id) {
 +                        continue;
@@ -271,13 +322,26 @@ index 0ff57d9..3e5ce80 100644
 +                    llama_token   tok;
 +                    float         conf;
 +                    sample_from(lp, tok, conf);
++
++                    step_pos.push_back(p);
++                    step_tok.push_back(tok);
++                    step_conf.push_back(conf);
++
 +                    if (conf > best_conf) {
 +                        best_conf = conf;
 +                        best_pos  = p;
 +                        best_tok  = tok;
 +                    }
 +                }
-+                if (best_pos >= 0) {
++
++                if (params.confidence_threshold > 0.0f) {
++                    for (size_t i = 0; i < step_pos.size(); ++i) {
++                        if (step_conf[i] > params.confidence_threshold) {
++                            output_tokens[step_pos[i]] = step_tok[i];
++                        }
++                    }
++                }
++                if (best_pos >= 0 && output_tokens[best_pos] == params.mask_token_id) {
 +                    output_tokens[best_pos] = best_tok;
 +                }
 +            }
@@ -323,7 +387,7 @@ index 0ff57d9..3e5ce80 100644
  void diffusion_generate(llama_context *          ctx,
                          const llama_token *      input_tokens,
                          llama_token *            output_tokens,
-@@ -113,6 +306,11 @@ void diffusion_generate(llama_context *          ctx,
+@@ -113,6 +357,11 @@ void diffusion_generate(llama_context *          ctx,
          return;
      }
  
@@ -336,15 +400,16 @@ index 0ff57d9..3e5ce80 100644
  
      // Initialize with input and pad with mask tokens
 diff --git a/examples/diffusion/diffusion.h b/examples/diffusion/diffusion.h
-index 7831445..85f6eb7 100644
+index 7831445..5cd4c58 100644
 --- a/examples/diffusion/diffusion.h
 +++ b/examples/diffusion/diffusion.h
-@@ -43,6 +43,8 @@ struct diffusion_params {
+@@ -43,6 +43,9 @@ struct diffusion_params {
      float   cfg_scale        = 0.;     // Config scale for classifier-free guidance
      float   eps              = 0.;     // Timestep scheduling
      int32_t block_length     = 0;      // Block size (for block scheduling)
 +    int32_t small_block_length = 0;    // Small block size inside a block (context-causal block diffusion)
 +    bool    block_attention  = false;  // Context-causal block diffusion (openPangu-R-Diffusion)
++    float   confidence_threshold = 0.; // Reveal all masked tokens above this confidence per step (0 = one token per step)
      float   alg_temp         = 0;      // algorithm temperature (0.0 = deterministic)
      bool    add_gumbel_noise = false;  // Add gumbel noise to the logits if temp > 0.0