Samplers sequence order w parameter

common/common.cpp

@@ -280,6 +280,12 @@ bool gpt_params_parse_ex(int argc, char ** argv, gpt_params & params) {
             params.yarn_beta_slow = std::stof(argv[i]);
         } else if (arg == "--memory-f32") {
             params.memory_f16 = false;
+        } else if (arg == "--sampling-seq") {
+            if (++i >= argc) {
+                invalid_param = true;
+                break;
+            }
+            sparams.samplers_sequence = argv[i];
         } else if (arg == "--top-p") {
             if (++i >= argc) {
                 invalid_param = true;

common/sampling.cpp

@@ -99,6 +99,42 @@ std::string llama_sampling_print(const llama_sampling_params & params) {
     return std::string(result);
 }
 
+std::string llama_sampling_order_print(const llama_sampling_params & params) {
+    std::string result = "CFG -> Penalties ";
+    if (params.mirostat == 0){
+        for (auto s : params.samplers_sequence){
+            switch (s){
+                case 'k':{
+                    result += "-> top_k ";
+                    break;
+                }
+                case 'f':{
+                    result += "-> tfs_z ";
+                    break;
+                }
+                case 'y':{
+                    result += "-> typical_p ";
+                    break;
+                }
+                case 'p':{
+                    result += "-> top_p ";
+                    break;
+                }
+                case 'm':{
+                    result += "-> min_p ";
+                    break;
+                }
+                case 't':{
+                    result += "-> temp ";
+                    break;
+                }
+            }
+        }
+    } else result += "-> mirostat ";
+
+    return result;
+}
+
 llama_token llama_sampling_sample(
                   struct llama_sampling_context * ctx_sampling,
                   struct llama_context * ctx_main,
@@ -122,6 +158,7 @@ llama_token llama_sampling_sample(
     const float   mirostat_tau          = params.mirostat_tau;
     const float   mirostat_eta          = params.mirostat_eta;
     const bool    penalize_nl           = params.penalize_nl;
+    const std::string samplers_sequence = params.samplers_sequence;
 
     auto & prev = ctx_sampling->prev;
     auto & cur  = ctx_sampling->cur;
@@ -188,12 +225,41 @@ llama_token llama_sampling_sample(
             // temperature sampling
             size_t min_keep = std::max(1, params.n_probs);
 
+            // llama_sample_top_k    (ctx_main, &cur_p, top_k,     min_keep);
+            // llama_sample_tail_free(ctx_main, &cur_p, tfs_z,     min_keep);
+            // llama_sample_typical  (ctx_main, &cur_p, typical_p, min_keep);
+            // llama_sample_top_p    (ctx_main, &cur_p, top_p,     min_keep);
+            // llama_sample_min_p    (ctx_main, &cur_p, min_p,     min_keep);
+            // llama_sample_temp     (ctx_main, &cur_p, temp);
+            
+            for (auto s : samplers_sequence){
+                switch (s){
+                    case 'k':{
                         llama_sample_top_k    (ctx_main, &cur_p, top_k,     min_keep);
+                        break;
+                    }
+                    case 'f':{
                         llama_sample_tail_free(ctx_main, &cur_p, tfs_z,     min_keep);
+                        break;
+                    }
+                    case 'y':{
                         llama_sample_typical  (ctx_main, &cur_p, typical_p, min_keep);
+                        break;
+                    }
+                    case 'p':{
                         llama_sample_top_p    (ctx_main, &cur_p, top_p,     min_keep);
+                        break;
+                    }
+                    case 'm':{
                         llama_sample_min_p    (ctx_main, &cur_p, min_p,     min_keep);
+                        break;
+                    }
+                    case 't':{
                         llama_sample_temp     (ctx_main, &cur_p, temp);
+                        break;
+                    }
+                }
+            }
 
             id = llama_sample_token(ctx_main, &cur_p);
 

common/sampling.h

@@ -26,6 +26,7 @@ typedef struct llama_sampling_params {
     float   mirostat_tau          = 5.00f;    // target entropy
     float   mirostat_eta          = 0.10f;    // learning rate
     bool    penalize_nl           = true;     // consider newlines as a repeatable token
+    std::string samplers_sequence = "kfypmt"; // top_k, tail_free, typical_p, top_p, min_p, temp
 
     std::string grammar;  // optional BNF-like grammar to constrain sampling
 
@@ -80,6 +81,9 @@ std::string llama_sampling_prev_str(llama_sampling_context * ctx_sampling, llama
 // Print sampling parameters into a string
 std::string llama_sampling_print(const llama_sampling_params & params);
 
+// Print sampling order into a string
+std::string llama_sampling_order_print(const llama_sampling_params & params);
+
 // this is a common sampling function used across the examples for convenience
 // it can serve as a starting point for implementing your own sampling function
 // Note: When using multiple sequences, it is the caller's responsibility to call

examples/main/main.cpp

@@ -437,6 +437,7 @@ int main(int argc, char ** argv) {
         }
     }
     LOG_TEE("sampling: \n%s\n", llama_sampling_print(sparams).c_str());
+    LOG_TEE("sampling order: \n%s\n", llama_sampling_order_print(sparams).c_str());
     LOG_TEE("generate: n_ctx = %d, n_batch = %d, n_predict = %d, n_keep = %d\n", n_ctx, params.n_batch, params.n_predict, params.n_keep);
     LOG_TEE("\n\n");