Update api/ltx_server.py

api/ltx_server.py

@@ -544,6 +544,8 @@ class VideoService:
         multi_scale_pipeline = None
 
         try:
+            # Em ltx_server.py, substitua o bloco 'if improve_texture:' por este:
+
             if improve_texture:
                 if not self.latent_upsampler:
                     raise ValueError("Upscaler espacial não carregado.")
@@ -556,28 +558,26 @@ class VideoService:
                 first_pass_args = self.config.get("first_pass", {}).copy()
                 first_pass_kwargs = call_kwargs.copy()
 
-                # Carrega os parâmetros do config, incluindo listas de timesteps e guidance
                 first_pass_kwargs.update({
                     "guidance_scale": first_pass_args.get("guidance_scale", guidance_scale),
                     "stg_scale": first_pass_args.get("stg_scale"),
                     "rescaling_scale": first_pass_args.get("rescaling_scale"),
                     "skip_block_list": first_pass_args.get("skip_block_list"),
                     "guidance_timesteps": first_pass_args.get("guidance_timesteps"),
-                    "timesteps": first_pass_args.get("timesteps")
+                    "timesteps": first_pass_args.get("timesteps"),
+                    "num_inference_steps": first_pass_args.get("num_inference_steps", 20)
                 })
                 print(f"[DEBUG] Passo 1: Parâmetros do config carregados.")
 
-                # Calcula as dimensões de baixa resolução
                 downscale_factor = self.config.get("downscale_factor", 2)
                 original_height = first_pass_kwargs["height"]
                 original_width = first_pass_kwargs["width"]
                 divisor = 24
                 
-                # Para downscale_factor < 1 (ex: 0.666), a lógica é multiplicar
                 if downscale_factor < 1.0:
                     target_height_p1 = original_height * downscale_factor
                     target_width_p1 = original_width * downscale_factor
-                else: # Para downscale_factor >= 1, a lógica é dividir
+                else:
                     target_height_p1 = original_height // downscale_factor
                     target_width_p1 = original_width // downscale_factor
                 
@@ -590,7 +590,10 @@ class VideoService:
                 first_pass_kwargs["width"] = width_p1
                 
                 print(f"[DEBUG] Passo 1: Dimensões reduzidas e ajustadas para {height_p1}x{width_p1}")
-                ctx = torch.autocast(device_type="cuda", dtype=self.runtime_autocast_dtype) if self.device == "cuda" else contextlib.nullcontext()
+
+
+                print(f"[DEBUG] first_pass_kwargs {first_pass_kwargs}")
+                
                 with ctx:
                     first_pass_result = self.pipeline(**first_pass_kwargs)
                     
@@ -601,6 +604,7 @@ class VideoService:
                 gc.collect()
                 if self.device == "cuda": torch.cuda.empty_cache()
 
+                    
                 # --- PASSO INTERMEDIÁRIO: UPSCALE DOS LATENTES ---
                 print("[DEBUG] Multi-escala: Fazendo upscale dos latentes com latent_upsampler.")
                 with ctx:
@@ -616,38 +620,52 @@ class VideoService:
                 second_pass_args = self.config.get("second_pass", {}).copy()
                 second_pass_kwargs = call_kwargs.copy()
 
-                # Carrega os parâmetros do config para o segundo passo
+                # Lógica de refinamento robusta usando 'strength'
+                strength = second_pass_args.get("strength", second_pass_args.get("denoising_strength"))
+                if strength is None and "skip_initial_inference_steps" in second_pass_args:
+                    total_steps = second_pass_args.get("num_inference_steps", 30)
+                    skip_steps = second_pass_args.get("skip_initial_inference_steps", 0)
+                    if total_steps > 0:
+                        strength = 1.0 - (skip_steps / total_steps)
+                elif strength is None and "timesteps" in second_pass_args:
+                    # Se temos timesteps explícitos, o strength é o primeiro valor da lista
+                    # (já que a lista começa "tarde", ex: [0.9, 0.7...])
+                    strength = second_pass_args["timesteps"][0]
+                elif strength is None:
+                    strength = 0.5 # Fallback seguro
+
+                second_pass_kwargs["strength"] = strength
+                print(f"[DEBUG] Passo 2: Usando 'strength'={strength:.3f} para o refinamento.")
+
+                # Removemos timesteps para que a pipeline os calcule a partir do strength
+                if "timesteps" in second_pass_kwargs: del second_pass_kwargs["timesteps"]
+                if "guidance_timesteps" in second_pass_kwargs: del second_pass_kwargs["guidance_timesteps"]
+                
                 second_pass_kwargs.update({
                     "guidance_scale": second_pass_args.get("guidance_scale", guidance_scale),
                     "stg_scale": second_pass_args.get("stg_scale"),
                     "rescaling_scale": second_pass_args.get("rescaling_scale"),
                     "skip_block_list": second_pass_args.get("skip_block_list"),
-                    "guidance_timesteps": second_pass_args.get("guidance_timesteps"),
-                    "timesteps": second_pass_args.get("timesteps")
+                    "num_inference_steps": second_pass_args.get("num_inference_steps", 20)
                 })
-                print(f"[DEBUG] Passo 2: Parâmetros do config carregados.")
                 
-                # Define as dimensões de alta resolução com base no upscale
-                # O upsampler espacial dobra a resolução, então multiplicamos por 2
                 height_p2 = height_p1 * 2
                 width_p2 = width_p1 * 2
                 second_pass_kwargs["height"] = height_p2
                 second_pass_kwargs["width"] = width_p2
                 print(f"[DEBUG] Passo 2: Dimensões definidas para {height_p2}x{width_p2}")
                 
-                # A entrada para o refinamento são os latentes que sofreram upscale
                 second_pass_kwargs["latents"] = latents_high_res
-                
-                # Garante que 'strength' não seja passado, pois estamos controlando via timesteps
-                if "strength" in second_pass_kwargs:
-                    del second_pass_kwargs["strength"]
 
+                print(f"[DEBUG] second_pass_kwargs {second_pass_kwargs}")
+                
                 with ctx:
                     second_pass_result = self.pipeline(**second_pass_kwargs)
                     
                 latents = second_pass_result.images
                 log_tensor_info(latents, "Latentes Finais (Passo 2)")
                 
+                # --- FIM DA IMPLEMENTAÇÃO LIMPA ---  
                     
             else:
                 single_pass_kwargs = call_kwargs.copy()
@@ -671,6 +689,10 @@ class VideoService:
                 print("\n[INFO] Executando pipeline de etapa única...")
                 t_sp = time.perf_counter()
                 ctx = torch.autocast(device_type="cuda", dtype=self.runtime_autocast_dtype) if self.device == "cuda" else contextlib.nullcontext()
+                
+                print(f"[DEBUG] single_pass_kwargs {single_pass_kwargs}")
+                
+                
                 with ctx:
                     result = self.pipeline(**single_pass_kwargs)
                 print(f"[DEBUG] single-pass tempo={time.perf_counter()-t_sp:.3f}s")