Unifited latent np-torch conversion

app.py

@@ -183,30 +183,32 @@ class ImageEditor(object):
 
     def get_target_latents(self, source_latent, edit_choices, generators):
 
-        np_source_latent = source_latent.squeeze(0).cpu().detach().numpy()
-
         target_latents = []
 
         if edit_choices["edit_type"] == "InterFaceGAN":
+            np_source_latent = source_latent.squeeze(0).cpu().detach().numpy()
+
             for attribute_name in ["pose", "smile", "gender", "age", "hair_length"]:
                 strength = edit_choices[attribute_name]
                 if strength != 0.0:
-                    target_latents.append(project_code_by_edit_name(np_source_latent, attribute_name, strength))
+                    projected_code_np = project_code_by_edit_name(np_source_latent, attribute_name, strength)
+                    target_latents.append(torch.from_numpy(projected_code_np).float().to(self.device))
 
         elif edit_choices["edit_type"] == "StyleCLIP":
-            source_s_dict = generators[0].get_s_code(source_latent, input_is_latent=True)[0]
-            target_latents.append(project_code_with_styleclip(source_s_dict, 
-                                                              edit_choices["src_text"], 
-                                                              edit_choices["tar_text"], 
-                                                              edit_choices["alpha"], 
-                                                              edit_choices["beta"], 
-                                                              generators[0],
-                                                              self.styleclip_fs3, 
-                                                              self.clip_model))
+            if edit_choices["alpha"] != 0.0:
+                source_s_dict = generators[0].get_s_code(source_latent, input_is_latent=True)[0]
+                target_latents.append(project_code_with_styleclip(source_s_dict, 
+                                                                edit_choices["src_text"], 
+                                                                edit_choices["tar_text"], 
+                                                                edit_choices["alpha"], 
+                                                                edit_choices["beta"], 
+                                                                generators[0],
+                                                                self.styleclip_fs3, 
+                                                                self.clip_model))
         
-        # if edit type is none or if all slides were set to 0
+        # if edit type is none or if all sliders were set to 0
         if not target_latents:
-            target_latents = [np_source_latent, ] * max((len(generators) - 1), 1)
+            target_latents = [source_latent, ] * max((len(generators) - 1), 1)
         
         return target_latents
 
@@ -249,8 +251,7 @@ class ImageEditor(object):
                         latent_for_gen = style_tensor_to_style_dict(latent_for_gen, g_ema)
                         img, _ = g_ema(latent_for_gen, input_is_s_code=True, input_is_latent=True, truncation=1, randomize_noise=False)
                     else:
-                        latent_for_gen = [torch.from_numpy(latent_for_gen).float().to(self.device)]
-                        img, _ = g_ema(latent_for_gen, input_is_latent=True, truncation=1, randomize_noise=False)
+                        img, _ = g_ema([latent_for_gen], input_is_latent=True, truncation=1, randomize_noise=False)
 
                     output_path = os.path.join(out_dir, f"out_{len(output_paths)}.jpg")
                     utils.save_image(img, output_path, nrow=1, normalize=True, range=(-1, 1))

generate_videos.py

@@ -64,21 +64,21 @@ def generate_frames(source_latent, target_latents, g_ema_list, output_dir):
 
     device = "cuda" if torch.cuda.is_available() else "cpu"
 
-    code_is_s = target_latents.size()[1] == 9088
+    code_is_s = target_latents[0].size()[1] == 9088
 
     if code_is_s:
         source_s_dict = g_ema_list[0].get_s_code(source_latent, input_is_latent=True)[0]
         np_latent = style_dict_to_style_tensor(source_s_dict, g_ema_list[0]).cpu().detach().numpy()
-        target_latents = target_latents.cpu().detach().numpy()
     else:
         np_latent = source_latent.squeeze(0).cpu().detach().numpy()
 
+    np_target_latents = [target_latent.cpu().detach().numpy() for target_latent in target_latents]
 
     num_alphas = min(10, 30 // len(target_latents))
 
     alphas = np.linspace(0, 1, num=num_alphas)
     
-    latents = interpolate_with_target_latents(np_latent, target_latents, alphas)
+    latents = interpolate_with_target_latents(np_latent, np_target_latents, alphas)
 
     segments = len(g_ema_list) - 1