Update pipeline_ltx_video.py

pipeline_ltx_video.py

@@ -989,24 +989,39 @@ class LTXVideoPipeline(DiffusionPipeline):
         # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
         # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
         # corresponds to doing no classifier free guidance.
-        if not isinstance(guidance_scale, List):
-            guidance_scale = [guidance_scale] * len(timesteps)
-        else:
-            guidance_scale = [
-                guidance_scale[guidance_mapping[i]] for i in range(len(timesteps))
-            ]
+        # Bloco Final e à Prova de Balas
+        def _remap_guidance_list(param, timesteps, guidance_mapping):
+            if isinstance(param, list):
+                # Caso do atalho: [1] deve ser esticado para o tamanho de timesteps
+                if len(param) == 1:
+                    return param * len(timesteps)
+                # Caso normal: remapeia usando a guidance_mapping
+                else:
+                    return [param[guidance_mapping[i]] for i in range(len(timesteps))]
+            # Caso de valor único (float/int): estica para o tamanho de timesteps
+            else:
+                return [param] * len(timesteps)
 
-        if not isinstance(stg_scale, List):
-            stg_scale = [stg_scale] * len(timesteps)
+        # Cria a guidance_mapping segura
+        if guidance_timesteps:
+            guidance_mapping = []
+            for timestep in timesteps:
+                indices = [i for i, val in enumerate(guidance_timesteps) if val >= timestep]
+                guidance_mapping.append(indices[-1] if indices else len(guidance_timesteps) - 1)
         else:
-            stg_scale = [stg_scale[guidance_mapping[i]] for i in range(len(timesteps))]
+            # Fallback seguro que previne o NameError
+            guidance_mapping = list(range(len(timesteps)))
+        
+        guidance_scale = _remap_guidance_list(guidance_scale, timesteps, guidance_mapping)
+        stg_scale = _remap_guidance_list(stg_scale, timesteps, guidance_mapping)
+        rescaling_scale = _remap_guidance_list(rescaling_scale, timesteps, guidance_mapping)
 
-        if not isinstance(rescaling_scale, List):
-            rescaling_scale = [rescaling_scale] * len(timesteps)
-        else:
-            rescaling_scale = [
-                rescaling_scale[guidance_mapping[i]] for i in range(len(timesteps))
-            ]
+        # Lógica especial para skip_block_list
+        if skip_block_list is not None:
+            if len(skip_block_list) > 0 and not isinstance(skip_block_list[0], list):
+                 skip_block_list = [skip_block_list] * len(timesteps)
+            elif isinstance(skip_block_list, list) and len(skip_block_list) > 1: # Apenas remapeia se for uma lista de listas
+                 skip_block_list = [skip_block_list[guidance_mapping[i]] for i in range(len(timesteps))]
 
         # Normalize skip_block_list to always be None or a list of lists matching timesteps
         if skip_block_list is not None: