test in latnent upcale

pipeline.py

@@ -842,10 +842,42 @@ class StableDiffusionLongPromptWeightingPipeline(StableDiffusionPipeline):
                     return None
         print(latents)
         print(latents.shape)
-        resized_image = torch.nn.functional.interpolate(
+        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
+            latent_model_input = self.scheduler.scale_model_input(
+                latent_model_input, t)
+
+            # predict the noise residual
+            noise_pred = self.unet(latent_model_input, t,
+                                   encoder_hidden_states=text_embeddings).sample
+
+            # perform guidance
+            if do_classifier_free_guidance:
+                noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
+                noise_pred = noise_pred_uncond + guidance_scale * \
+                    (noise_pred_text - noise_pred_uncond)
+
+            # compute the previous noisy sample x_t -> x_t-1
+            latents = self.scheduler.step(
+                noise_pred, t, latents, **extra_step_kwargs).prev_sample
 
-        print(resized_image.shape)
+            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))
+
+            # call the callback, if provided
+            if i % callback_steps == 0:
+                if callback is not None:
+                    callback(i, t, latents)
+                if is_cancelled_callback is not None and is_cancelled_callback():
+                    return None
         #do latent upscale  here
 
         # 9. Post-processing