Upload pipeline_ltx_video.py

pipeline_ltx_video.py

@@ -24,15 +24,6 @@ from transformers import (
     AutoTokenizer,
 )
 
-
-from huggingface_hub import logging
-
-
-logging.set_verbosity_error()
-logging.set_verbosity_warning()
-logging.set_verbosity_info()
-logging.set_verbosity_debug()
-
 from ltx_video.models.autoencoders.causal_video_autoencoder import (
     CausalVideoAutoencoder,
 )
@@ -54,8 +45,7 @@ from ltx_video.models.autoencoders.vae_encode import (
 )
 
 
-logger = logging.get_logger(__name__)  
-
+logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
 
 
 ASPECT_RATIO_1024_BIN = {
@@ -933,9 +923,6 @@ class LTXVideoPipeline(DiffusionPipeline):
             latent_height,
             latent_width,
         )
-        
-        print(f"[ltxxxxxxxx] latent_shape {latent_shape}")
-      
 
         # Prepare the list of denoising time-steps
 
@@ -968,60 +955,38 @@ class LTXVideoPipeline(DiffusionPipeline):
                     timestep in self.allowed_inference_steps
                 ), f"Invalid inference timestep {timestep}. Allowed timesteps are {self.allowed_inference_steps}."
 
-
-        # Versão Corrigida em pipeline_ltx_video.py
         if guidance_timesteps:
             guidance_mapping = []
             for timestep in timesteps:
                 indices = [
                     i for i, val in enumerate(guidance_timesteps) if val <= timestep
                 ]
+                # assert len(indices) > 0, f"No guidance timestep found for {timestep}"
                 guidance_mapping.append(
                     indices[0] if len(indices) > 0 else (len(guidance_timesteps) - 1)
                 )
-        else:
-            # CORREÇÃO: Garante que guidance_mapping exista mesmo se guidance_timesteps não for fornecido.
-            # Cria um mapeamento de identidade seguro.
-            guidance_mapping = list(range(len(timesteps)))
-            
-        print(f"[ltxxxxxxxx] guidance_mapping {guidance_mapping}")
-            
+
         # 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.
-        # 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(guidance_scale, List):
+            guidance_scale = [guidance_scale] * len(timesteps)
+        else:
+            guidance_scale = [
+                guidance_scale[guidance_mapping[i]] for i in range(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)
+        if not isinstance(stg_scale, List):
+            stg_scale = [stg_scale] * len(timesteps)
         else:
-            # 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)
-
-        # 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))]
+            stg_scale = [stg_scale[guidance_mapping[i]] for i in range(len(timesteps))]
+
+        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))
+            ]
 
         # Normalize skip_block_list to always be None or a list of lists matching timesteps
         if skip_block_list is not None:
@@ -1116,8 +1081,6 @@ class LTXVideoPipeline(DiffusionPipeline):
             generator=generator,
             vae_per_channel_normalize=vae_per_channel_normalize,
         )
-        
-        
 
         # Update the latents with the conditioning items and patchify them into (b, n, c)
         latents, pixel_coords, conditioning_mask, num_cond_latents = (