pix2pix: fix img range?

Author: stduhpf

ggml_extend.hpp

@@ -301,7 +301,7 @@ __STATIC_INLINE__ float sigmoid(float x) {
 
 // SPECIAL OPERATIONS WITH TENSORS
 
-__STATIC_INLINE__ uint8_t* sd_tensor_to_image(struct ggml_tensor* input) {
+__STATIC_INLINE__ uint8_t* sd_tensor_to_image(struct ggml_tensor* input, bool remap = false) {
     int64_t width    = input->ne[0];
     int64_t height   = input->ne[1];
     int64_t channels = input->ne[2];
@@ -310,7 +310,10 @@ __STATIC_INLINE__ uint8_t* sd_tensor_to_image(struct ggml_tensor* input) {
     for (int iy = 0; iy < height; iy++) {
         for (int ix = 0; ix < width; ix++) {
             for (int k = 0; k < channels; k++) {
-                float value                                               = ggml_tensor_get_f32(input, ix, iy, k);
+                float value = ggml_tensor_get_f32(input, ix, iy, k);
+                if (remap) {
+                    value = value * .5 + .5;
+                }
                 *(image_data + iy * width * channels + ix * channels + k) = (uint8_t)(value * 255.0f);
             }
         }
@@ -337,7 +340,8 @@ __STATIC_INLINE__ uint8_t* sd_tensor_to_mul_image(struct ggml_tensor* input, int
 
 __STATIC_INLINE__ void sd_image_to_tensor(const uint8_t* image_data,
                                           struct ggml_tensor* output,
-                                          bool scale = true) {
+                                          bool scale = true,
+                                          bool remap = false) {
     int64_t width    = output->ne[0];
     int64_t height   = output->ne[1];
     int64_t channels = output->ne[2];
@@ -349,6 +353,9 @@ __STATIC_INLINE__ void sd_image_to_tensor(const uint8_t* image_data,
                 if (scale) {
                     value /= 255.f;
                 }
+                if (remap) {
+                    value = value * 2. - 1.;
+                }
                 ggml_tensor_set_f32(output, value, ix, iy, k);
             }
         }

stable-diffusion.cpp

@@ -49,8 +49,7 @@ const char* sampling_methods_str[] = {
     "iPNDM_v",
     "LCM",
     "DDIM \"trailing\"",
-    "TCD"
-};
+    "TCD"};
 
 /*================================================== Helper Functions ================================================*/
 
@@ -683,7 +682,7 @@ class StableDiffusionGGML {
             float curr_multiplier        = kv.second;
             lora_state_diff[lora_name] -= curr_multiplier;
         }
-        
+
         size_t rm = lora_state_diff.size() - lora_state.size();
         if (rm != 0) {
             LOG_INFO("Attempting to apply %lu LoRAs (removing %lu applied LoRAs)", lora_state.size(), rm);
@@ -806,7 +805,6 @@ class StableDiffusionGGML {
                         float skip_layer_start       = 0.01,
                         float skip_layer_end         = 0.2,
                         ggml_tensor* noise_mask      = nullptr) {
-
         // TODO (Pix2Pix): separate image guidance params (right now it's reusing distilled guidance)
 
         float img_cfg_scale = guidance;
@@ -834,7 +832,7 @@ class StableDiffusionGGML {
 
         bool has_unconditioned = cfg_scale != 1.0 && uncond.c_crossattn != NULL;
         bool has_img_guidance  = version == VERSION_INSTRUCT_PIX2PIX && cfg_scale != img_cfg_scale;
-        has_unconditioned = has_unconditioned || has_img_guidance;
+        has_unconditioned      = has_unconditioned || has_img_guidance;
         bool has_skiplayer     = slg_scale != 0.0 && skip_layers.size() > 0;
 
         // denoise wrapper
@@ -988,7 +986,7 @@ class StableDiffusionGGML {
                         int64_t i3  = i / out_cond->ne[0] * out_cond->ne[1] * out_cond->ne[2];
                         float scale = min_cfg + (cfg_scale - min_cfg) * (i3 * 1.0f / ne3);
                     } else {
-                        if(has_img_guidance){
+                        if (has_img_guidance) {
                             latent_result = negative_data[i] + img_cfg_scale * (img_cond_data[i] - negative_data[i]) + cfg_scale * (positive_data[i] - img_cond_data[i]);
                         } else {
                             latent_result = negative_data[i] + cfg_scale * (positive_data[i] - negative_data[i]);
@@ -1553,7 +1551,7 @@ sd_image_t* generate_image(sd_ctx_t* sd_ctx,
         result_images[i].width   = width;
         result_images[i].height  = height;
         result_images[i].channel = 3;
-        result_images[i].data    = sd_tensor_to_image(decoded_images[i]);
+        result_images[i].data    = sd_tensor_to_image(decoded_images[i], sd_ctx->sd->version == VERSION_INSTRUCT_PIX2PIX);
     }
     ggml_free(work_ctx);
 
@@ -1737,7 +1735,7 @@ sd_image_t* img2img(sd_ctx_t* sd_ctx,
 
     sd_mask_to_tensor(mask.data, mask_img);
 
-    sd_image_to_tensor(init_image.data, init_img);
+    sd_image_to_tensor(init_image.data, init_img, true, sd_ctx->sd->version == VERSION_INSTRUCT_PIX2PIX);
 
     ggml_tensor* masked_image;