remove debug comments

rmatif · rmatif · commit c242dd4e6216 · 2025-05-09T11:11:22.000Z
diff --git a/denoiser.hpp b/denoiser.hpp
@@ -237,21 +237,14 @@ struct GITSSchedule : SigmaSchedule {
 
 struct SGMUniformSchedule : SigmaSchedule {
     std::vector<float> get_sigmas(uint32_t n, float sigma_min_in, float sigma_max_in, t_to_sigma_t t_to_sigma_func) override {
-        // This schedule's core logic is now handled directly in Denoiser::get_sigmas
-        // to ensure correct access to both sigma_to_t and t_to_sigma.
-        // This method is overridden to fulfill the virtual contract but ideally should not be
-        // the primary execution path for SGMUniform when called from Denoiser::get_sigmas.
-        // If it IS called, it means the Denoiser::get_sigmas logic wasn't triggered, which is unexpected.
-        LOG_WARN("SGMUniformSchedule::get_sigmas was called directly. This might indicate an issue with Denoiser dispatch.");
-        // Provide a default (potentially incorrect for SGMUniform's intent) or empty schedule to avoid crashes.
-        // For safety, returning a simple discrete-like schedule in t-space if this is ever hit.
+
         std::vector<float> result;
         if (n == 0) {
             result.push_back(0.0f);
             return result;
         }
         result.reserve(n + 1);
-        int t_max = TIMESTEPS -1; // A common max t value
+        int t_max = TIMESTEPS -1; 
         float step = static_cast<float>(t_max) / static_cast<float>(n > 1 ? (n -1) : 1) ;
         for(uint32_t i=0; i<n; ++i) {
             result.push_back(t_to_sigma_func(t_max - step * i));
@@ -284,39 +277,27 @@ struct SimpleSchedule : SigmaSchedule {
         std::vector<float> result_sigmas;
 
         if (n == 0) {
-            return result_sigmas; // Return empty for n=0, consistent with DiscreteSchedule
+            return result_sigmas;
         }
 
         result_sigmas.reserve(n + 1);
 
-        // TIMESTEPS is the length of the model's internal sigmas array, typically 1000.
-        // t_to_sigma(t) maps a timestep t (0 to TIMESTEPS-1) to its sigma value.
         int model_sigmas_len = TIMESTEPS; 
 
-        // ss = len(s.sigmas) / steps in Python
         float step_factor = static_cast<float>(model_sigmas_len) / static_cast<float>(n);
 
         for (uint32_t i = 0; i < n; ++i) {
-            // Python: s.sigmas[-(1 + int(x * ss))]
-            // x corresponds to i (0 to n-1)
-            // int(x * ss) in Python is static_cast<int>(static_cast<float>(i) * step_factor)
-            // The index -(1 + offset) means (model_sigmas_len - 1 - offset) from the start of a 0-indexed array.
+
             int offset_from_start_of_py_array = static_cast<int>(static_cast<float>(i) * step_factor);
             int timestep_index = model_sigmas_len - 1 - offset_from_start_of_py_array;
 
-            // Ensure the index is within valid bounds [0, model_sigmas_len - 1]
             if (timestep_index < 0) {
                 timestep_index = 0;
             }
-            // No need for upper bound check like `timestep_index >= model_sigmas_len` because
-            // max offset is for i=n-1: int((n-1)/n * model_sigmas_len) which is < model_sigmas_len.
-            // So, model_sigmas_len - 1 - max_offset is >= 0 if model_sigmas_len/n >= 1.
-            // If n > model_sigmas_len, then model_sigmas_len/n < 1, resulting in timestep_index potentially being <0,
-            // which is handled by the clamp above.
 
             result_sigmas.push_back(t_to_sigma(static_cast<float>(timestep_index)));
         }
-        result_sigmas.push_back(0.0f); // Append the final zero sigma
+        result_sigmas.push_back(0.0f);
         return result_sigmas;
     }
 };
@@ -334,7 +315,6 @@ struct Denoiser {
     virtual std::vector<float> get_sigmas(uint32_t n) {
         // Check if the current schedule is SGMUniformSchedule
         if (std::dynamic_pointer_cast<SGMUniformSchedule>(schedule)) {
-            LOG_DEBUG("Denoiser::get_sigmas - Using SGM_UNIFORM specific logic");
             std::vector<float> sigs;
             sigs.reserve(n + 1);
 
@@ -347,26 +327,22 @@ struct Denoiser {
             float start_t_val = this->sigma_to_t(this->sigma_max());
             float end_t_val   = this->sigma_to_t(this->sigma_min());
 
-            // Python: torch.linspace(start, end, n + 1)[:-1]
-            // This creates n points. The k-th point (0-indexed) is start_t_val + k * (end_t_val - start_t_val) / n.
             float dt_per_step;
-            if (n > 0) { // Avoid division by zero if n=0, though covered by earlier check
+            if (n > 0) { 
                  dt_per_step = (end_t_val - start_t_val) / static_cast<float>(n);
             } else {
                  dt_per_step = 0.0f;
             }
 
-
             for (uint32_t i = 0; i < n; ++i) {
                 float current_t = start_t_val + static_cast<float>(i) * dt_per_step;
                 sigs.push_back(this->t_to_sigma(current_t));
             }
 
-            sigs.push_back(0.0f); // Append the final zero sigma
+            sigs.push_back(0.0f); 
             return sigs;
 
         } else { // For all other schedules, use the existing virtual dispatch
-            LOG_DEBUG("Denoiser::get_sigmas - Using general schedule dispatch for %s", typeid(*schedule.get()).name());
             auto bound_t_to_sigma = std::bind(&Denoiser::t_to_sigma, this, std::placeholders::_1);
             return schedule->get_sigmas(n, sigma_min(), sigma_max(), bound_t_to_sigma);
         }
diff --git a/examples/cli/main.cpp b/examples/cli/main.cpp
@@ -128,10 +128,10 @@ struct SDParams {
     int upscale_repeats           = 1;
 
     std::vector<int> skip_layers = {7, 8, 9};
-    float slg_scale              = 0.f; // Removed duplicate line
+    float slg_scale              = 0.f;
     float skip_layer_start       = 0.01f;
     float skip_layer_end         = 0.2f;
-    int shifted_timestep         = -1; // Keep the added parameter from previous step
+    int shifted_timestep         = -1;
 };
 
 void print_params(SDParams params) {
@@ -248,7 +248,7 @@ void print_usage(int argc, const char* argv[]) {
     printf("  --control-net-cpu                  keep controlnet in cpu (for low vram)\n");
     printf("  --canny                            apply canny preprocessor (edge detection)\n");
     printf("  --color                            Colors the logging tags according to level\n");
-    printf("  --timestep-shift N                 shift timestep for SDXL models (NitroFusion paper, default: -1 off, N between 1 and 1000)\n");
+    printf("  --timestep-shift N                 shift timestep for NitroFusion models, default: -1 off, recommended N for NitroSD-Realism around 250 and 500 for NitroSD-Vibrant\n");
     printf("  -v, --verbose                      print extra info\n");
 }
 
@@ -539,15 +539,14 @@ void parse_args(int argc, const char** argv, SDParams& params) {
             }
             const char* schedule_selected = argv[i];
             int schedule_found            = -1;
-            // N_SCHEDULES will be updated by the .h change, so this loop limit is fine
             for (int d = 0; d < N_SCHEDULES; d++) { 
                 if (!strcmp(schedule_selected, schedule_str[d])) {
                     schedule_found = d;
                 }
             }
             if (schedule_found == -1) {
                 fprintf(stderr, "error: invalid schedule %s, must be one of [discrete, karras, exponential, ays, gits, sgm_uniform, simple]\n", schedule_selected);
-                exit(1); // Exit directly as invalid_arg only triggers at the end
+                exit(1); 
             }
             params.schedule = (schedule_t)schedule_found;
         } else if (arg == "-s" || arg == "--seed") {
@@ -635,7 +634,7 @@ void parse_args(int argc, const char** argv, SDParams& params) {
                 break;
             }
             params.skip_layer_end = std::stof(argv[i]);
-        } else if (arg == "--timestep-shift") { // Added block
+        } else if (arg == "--timestep-shift") { 
              if (++i >= argc) {
                  invalid_arg = true;
                  break;
@@ -984,7 +983,7 @@ int main(int argc, const char* argv[]) {
                           params.slg_scale,
                           params.skip_layer_start,
                           params.skip_layer_end,
-                          params.shifted_timestep); // Passed parameter
+                          params.shifted_timestep); 
    } else {
        sd_image_t input_image = {(uint32_t)params.width,
                                  (uint32_t)params.height,
@@ -1054,7 +1053,7 @@ int main(int argc, const char* argv[]) {
                               params.slg_scale,
                               params.skip_layer_start,
                               params.skip_layer_end,
-                              params.shifted_timestep); // Passed parameter
+                              params.shifted_timestep);
        }
    }
 
diff --git a/model.cpp b/model.cpp
@@ -185,7 +185,6 @@ std::string convert_open_clip_to_hf_clip(const std::string& name) {
         new_name = new_name.substr(strlen("conditioner.embedders.0."));
     } else if (starts_with(new_name, "conditioner.embedders.1.")) {
         prefix   = "cond_stage_model.1.";
-        // Corrected the substring length to match the prefix being checked
         new_name = new_name.substr(strlen("conditioner.embedders.1."));
     } else if (starts_with(new_name, "cond_stage_model.")) {
         prefix   = "cond_stage_model.";
@@ -194,8 +193,6 @@ std::string convert_open_clip_to_hf_clip(const std::string& name) {
         prefix   = new_name.substr(0, new_name.size() - strlen("vision_model.visual_projection.weight"));
         new_name = prefix + "visual_projection.weight";
         return new_name;
-    // This specific case seems less common or might be handled implicitly later,
-    // but we keep the original logic for now. If issues arise, review if this mapping is needed.
     } else if (ends_with(new_name, "transformer.text_projection.weight")) {
         prefix   = new_name.substr(0, new_name.size() - strlen("transformer.text_projection.weight"));
         new_name = prefix + "transformer.text_model.text_projection";
@@ -204,13 +201,11 @@ std::string convert_open_clip_to_hf_clip(const std::string& name) {
         return new_name;
     }
 
-    // Specific handling for text_projection variants before generic map lookup
     if (new_name == "model.text_projection.weight" || new_name == "model.text_projection") {
         new_name = "transformer.text_model.text_projection";
-    } else if (open_clip_to_hf_clip_model.count(new_name)) { // Use .count() for safety
+    } else if (open_clip_to_hf_clip_model.count(new_name)) { 
         new_name = open_clip_to_hf_clip_model[new_name];
     }
-    // Note: The specific handling above takes precedence over the map for this tensor.
 
     std::string open_clip_resblock_prefix = "model.transformer.resblocks.";
     std::string hf_clip_resblock_prefix   = "transformer.text_model.encoder.layers.";
diff --git a/stable-diffusion.cpp b/stable-diffusion.cpp
