test in latnent upcale

pipeline.py

@@ -848,13 +848,13 @@ class StableDiffusionLongPromptWeightingPipeline(StableDiffusionPipeline):
         print("after first step denoise latents")
         # print(latents)
         print(latents.shape)
-        latents = torch.nn.functional.interpolate(
+        upscale_latents = torch.nn.functional.interpolate(
             latents, size=(int(height*resize_scale)//8, int(width*resize_scale)//8))
         
         for i, t in enumerate(self.progress_bar(timesteps)):
             # expand the latents if we are doing classifier free guidance
             latent_model_input = torch.cat(
-                [latents] * 2) if do_classifier_free_guidance else latents
+                [upscale_latents] * 2) if do_classifier_free_guidance else upscale_latents
             print("latent_model_input 2nd step")
             # print(latent_model_input)
             print(latent_model_input.shape)
@@ -864,6 +864,10 @@ class StableDiffusionLongPromptWeightingPipeline(StableDiffusionPipeline):
 
             latent_model_input = self.scheduler.scale_model_input(
                 latent_model_input, t)
+            
+
+
+
             print("latent_model_input after scheduler")
             # print(latent_model_input)
             print(latent_model_input.shape)
@@ -879,26 +883,30 @@ class StableDiffusionLongPromptWeightingPipeline(StableDiffusionPipeline):
                 noise_pred = noise_pred_uncond + guidance_scale * \
                     (noise_pred_text - noise_pred_uncond)
 
+            print("compute the previous noisy sample")
             # compute the previous noisy sample x_t -> x_t-1
-            latents = self.scheduler.step(
-                noise_pred, t, latents, **extra_step_kwargs).prev_sample
+            upscale_latents = self.scheduler.step(
+                noise_pred, t, upscale_latents, **extra_step_kwargs).prev_sample
 
+
+            print("compute mask")
             if mask is not None:
                 # masking
                 init_latents_proper = self.scheduler.add_noise(
                     init_latents_orig, noise, torch.tensor([t]))
-                latents = (init_latents_proper * mask) + (latents * (1 - mask))
+                upscale_latents = (init_latents_proper *
+                                   mask) + (latents * (1 - mask))
 
             # call the callback, if provided
             if i % callback_steps == 0:
                 if callback is not None:
-                    callback(i, t, latents)
+                    callback(i, t, upscale_latents)
                 if is_cancelled_callback is not None and is_cancelled_callback():
                     return None
         #do latent upscale  here
 
         # 9. Post-processing
-        image = self.decode_latents(latents)
+        image = self.decode_latents(upscale_latents)
 
 
         # 10. Run safety checker