Upload pipeline_ltx_video.py

LTX-Video/ltx_video/pipelines/pipeline_ltx_video.py

@@ -13,7 +13,7 @@ from diffusers.image_processor import VaeImageProcessor
 from diffusers.models import AutoencoderKL
 from diffusers.pipelines.pipeline_utils import DiffusionPipeline, ImagePipelineOutput
 from diffusers.schedulers import DPMSolverMultistepScheduler
-#from diffusers.utils import deprecate, logging
+from diffusers.utils import deprecate, logging
 from diffusers.utils.torch_utils import randn_tensor
 from einops import rearrange
 from transformers import (
@@ -24,7 +24,6 @@ from transformers import (
     AutoTokenizer,
 )
 
-
 from ltx_video.models.autoencoders.causal_video_autoencoder import (
     CausalVideoAutoencoder,
 )
@@ -45,127 +44,8 @@ from ltx_video.models.autoencoders.vae_encode import (
     normalize_latents,
 )
 
-import warnings
-warnings.filterwarnings("ignore", category=UserWarning)
-warnings.filterwarnings("ignore", category=FutureWarning)
-warnings.filterwarnings("ignore", message=".*")
-
-from huggingface_hub import logging
-
-logging.set_verbosity_error()
-logging.set_verbosity_warning()
-logging.set_verbosity_info()
-logging.set_verbosity_debug()
-
-
-#logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
-
-
-class SpyLatent:
-
-    """
-    Uma classe para inspecionar tensores latentes em vários estágios de um pipeline.
-    Imprime estatísticas e pode salvar visualizações decodificadas por um VAE.
-    """
-
-    import torch
-    import os
-    import traceback
-    from einops import rearrange
-    from torchvision.utils import save_image
-
-    def __init__(self, vae=None, output_dir: str = "/app/output"):
-        """
-        Inicializa o espião.
-
-        Args:
-            vae: A instância do modelo VAE para decodificar os latentes. Se for None,
-                 a visualização será desativada.
-            output_dir (str): O diretório padrão para salvar as imagens de visualização.
-        """
-        self.vae = vae
-        self.output_dir = output_dir
-        self.device = vae.device if hasattr(vae, 'device') else torch.device("cpu")
-        
-        if self.vae is None:
-            print("[SpyLatent] AVISO: VAE não fornecido. A funcionalidade de visualização de imagem está desativada.")
-
-    def inspect(
-        self,
-        tensor: torch.Tensor,
-        tag: str,
-        reference_shape_5d: tuple = None,
-        save_visual: bool = True,
-    ):
-        """
-        Inspeciona um tensor latente.
-
-        Args:
-            tensor (torch.Tensor): O tensor a ser inspecionado.
-            tag (str): Um rótulo para identificar o ponto de inspeção nos logs.
-            reference_shape_5d (tuple, optional): A forma 5D de referência (B, C, F, H, W)
-                                                  necessária se o tensor de entrada for 3D.
-            save_visual (bool): Se True, decodifica com o VAE e salva uma imagem.
-        """
-        #print(f"\n--- [INSPEÇÃO DE LATENTE: {tag}] ---")
-        #if not isinstance(tensor, torch.Tensor):
-        #    print(f"  AVISO: O objeto fornecido para '{tag}' não é um tensor.")
-        #    print("--- [FIM DA INSPEÇÃO] ---\n")
-        #    return
-
-        try:
-            # --- Imprime Estatísticas do Tensor Original ---
-            #self._print_stats("Tensor Original", tensor)
-
-            # --- Converte para 5D se necessário ---
-            tensor_5d = self._to_5d(tensor, reference_shape_5d)
-            if tensor_5d is not None and tensor.ndim == 3:
-                self._print_stats("Convertido para 5D", tensor_5d)
-
-            # --- Visualização com VAE ---
-            if save_visual and self.vae is not None and tensor_5d is not None:
-                os.makedirs(self.output_dir, exist_ok=True)
-                #print(f"  VISUALIZAÇÃO (VAE): Salvando imagem em {self.output_dir}...")
-                
-                frame_idx_to_viz = min(1, tensor_5d.shape[2] - 1)
-                if frame_idx_to_viz < 0:
-                    print("  VISUALIZAÇÃO (VAE): Tensor não tem frames para visualizar.")
-                else:
-                    #print(f"  VISUALIZAÇÃO (VAE): Usando frame de índice {frame_idx_to_viz}.")
-                    latent_slice = tensor_5d[:, :, frame_idx_to_viz:frame_idx_to_viz+1, :, :]
-                    
-                    with torch.no_grad(), torch.autocast(device_type=self.device.type):
-                        pixel_slice = self.vae.decode(latent_slice / self.vae.config.scaling_factor).sample
-
-                    save_image((pixel_slice / 2 + 0.5).clamp(0, 1), os.path.join(self.output_dir, f"inspect_{tag.lower()}.png"))
-                    print("  VISUALIZAÇÃO (VAE): Imagem salva.")
-
-        except Exception as e:
-            #print(f"  ERRO na inspeção: {e}")
-            traceback.print_exc()
-        
-    def _to_5d(self, tensor: torch.Tensor, shape_5d: tuple) -> torch.Tensor:
-        """Converte um tensor 3D patchificado de volta para 5D."""
-        if tensor.ndim == 5:
-            return tensor
-        if tensor.ndim == 3 and shape_5d:
-            try:
-                b, c, f, h, w = shape_5d
-                return rearrange(tensor, "b (f h w) c -> b c f h w", c=c, f=f, h=h, w=w)
-            except Exception as e:
-                #print(f"  AVISO: Erro ao rearranjar tensor 3D para 5D: {e}. A visualização pode falhar.")
-                return None
-        return None
-
-    def _print_stats(self, prefix: str, tensor: torch.Tensor):
-        """Helper para imprimir estatísticas de um tensor."""
-        mean = tensor.mean().item()
-        std = tensor.std().item()
-        min_val = tensor.min().item()
-        max_val = tensor.max().item()
-        print(f"  {prefix}: {tensor.shape}")
-        
 
+logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
 
 
 ASPECT_RATIO_1024_BIN = {
@@ -247,8 +127,8 @@ def retrieve_timesteps(
     num_inference_steps: Optional[int] = None,
     device: Optional[Union[str, torch.device]] = None,
     timesteps: Optional[List[int]] = None,
-    skip_initial_inference_steps: Optional[int] = 0,
-    skip_final_inference_steps: Optional[int] = 0,
+    skip_initial_inference_steps: int = 0,
+    skip_final_inference_steps: int = 0,
     **kwargs,
 ):
     """
@@ -306,12 +186,6 @@ def retrieve_timesteps(
         ]
         scheduler.set_timesteps(timesteps=timesteps, device=device, **kwargs)
         num_inference_steps = len(timesteps)
-        
-        try:
-            print(f"[LTX]LATENTS {latents.shape}")
-        except Exception:
-                pass
- 
 
     return timesteps, num_inference_steps
 
@@ -358,8 +232,6 @@ class LTXVideoPipeline(DiffusionPipeline):
         scheduler ([`SchedulerMixin`]):
             A scheduler to be used in combination with `transformer` to denoise the encoded image latents.
     """
-    
-    
 
     bad_punct_regex = re.compile(
         r"["
@@ -422,8 +294,6 @@ class LTXVideoPipeline(DiffusionPipeline):
         self.image_processor = VaeImageProcessor(vae_scale_factor=self.vae_scale_factor)
 
         self.allowed_inference_steps = allowed_inference_steps
-        
-        self.spy = SpyLatent(vae=vae)
 
     def mask_text_embeddings(self, emb, mask):
         if emb.shape[0] == 1:
@@ -473,7 +343,7 @@ class LTXVideoPipeline(DiffusionPipeline):
 
         if "mask_feature" in kwargs:
             deprecation_message = "The use of `mask_feature` is deprecated. It is no longer used in any computation and that doesn't affect the end results. It will be removed in a future version."
-            #deprecate("mask_feature", "1.0.0", deprecation_message, standard_warn=False)
+            deprecate("mask_feature", "1.0.0", deprecation_message, standard_warn=False)
 
         if device is None:
             device = self._execution_device
@@ -486,10 +356,9 @@ class LTXVideoPipeline(DiffusionPipeline):
             batch_size = prompt_embeds.shape[0]
 
         # See Section 3.1. of the paper.
-        max_length = 256
-        #(
-        #    text_encoder_max_tokens  # TPU supports only lengths multiple of 128
-        #)
+        max_length = (
+            text_encoder_max_tokens  # TPU supports only lengths multiple of 128
+        )
         if prompt_embeds is None:
             assert (
                 self.text_encoder is not None
@@ -515,10 +384,10 @@ class LTXVideoPipeline(DiffusionPipeline):
                 removed_text = self.tokenizer.batch_decode(
                     untruncated_ids[:, max_length - 1 : -1]
                 )
-                #logger.warning(
-                #    "The following part of your input was truncated because CLIP can only handle sequences up to"
-                #    f" {max_length} tokens: {removed_text}"
-                #)
+                logger.warning(
+                    "The following part of your input was truncated because CLIP can only handle sequences up to"
+                    f" {max_length} tokens: {removed_text}"
+                )
 
             prompt_attention_mask = text_inputs.attention_mask
             prompt_attention_mask = prompt_attention_mask.to(text_enc_device)
@@ -1006,21 +875,15 @@ class LTXVideoPipeline(DiffusionPipeline):
             tone_map_compression_ratio: compression ratio for tone mapping, defaults to 0.0.
                         If set to 0.0, no tone mapping is applied. If set to 1.0 - full compression is applied.
         Examples:
+
         Returns:
             [`~pipelines.ImagePipelineOutput`] or `tuple`:
                 If `return_dict` is `True`, [`~pipelines.ImagePipelineOutput`] is returned, otherwise a `tuple` is
                 returned where the first element is a list with the generated images
         """
-        
-        try:
-            print(f"[LTX]LATENTS {latents.shape}")
-        except Exception:
-            pass
- 
-        
         if "mask_feature" in kwargs:
             deprecation_message = "The use of `mask_feature` is deprecated. It is no longer used in any computation and that doesn't affect the end results. It will be removed in a future version."
-            #deprecate("mask_feature", "1.0.0", deprecation_message, standard_warn=False)
+            deprecate("mask_feature", "1.0.0", deprecation_message, standard_warn=False)
 
         is_video = kwargs.get("is_video", False)
         self.check_inputs(
@@ -1085,12 +948,7 @@ class LTXVideoPipeline(DiffusionPipeline):
             skip_final_inference_steps=skip_final_inference_steps,
             **retrieve_timesteps_kwargs,
         )
-        
-        try:
-            print(f"[LTX2]LATENTS {latents.shape}")
-        except Exception:
-            pass
-            
+
         if self.allowed_inference_steps is not None:
             for timestep in [round(x, 4) for x in timesteps.tolist()]:
                 assert (
@@ -1158,12 +1016,7 @@ class LTXVideoPipeline(DiffusionPipeline):
                 conditioning_items,
                 max_new_tokens=text_encoder_max_tokens,
             )
-            
-        try:
-            print(f"[LTX3]LATENTS {latents.shape}")
-        except Exception:
-            pass
-            
+
         # 3. Encode input prompt
         if self.text_encoder is not None:
             self.text_encoder = self.text_encoder.to(self._execution_device)
@@ -1228,15 +1081,7 @@ class LTXVideoPipeline(DiffusionPipeline):
             generator=generator,
             vae_per_channel_normalize=vae_per_channel_normalize,
         )
-        
-        try:
-            print(f"[LTX4]LATENTS {latents.shape}")
-            original_shape = latents
-        except Exception:
-            pass   
-            
-            
-        
+
         # Update the latents with the conditioning items and patchify them into (b, n, c)
         latents, pixel_coords, conditioning_mask, num_cond_latents = (
             self.prepare_conditioning(
@@ -1251,33 +1096,9 @@ class LTXVideoPipeline(DiffusionPipeline):
         )
         init_latents = latents.clone()  # Used for image_cond_noise_update
 
-        try:
-            print(f"[LTXCond]conditioning_mask {conditioning_mask.shape}")
-        except Exception:
-            pass
-            
-        try:
-            print(f"[LTXCond]pixel_coords {pixel_coords.shape}")
-        except Exception:
-            pass
-            
-        try:
-            print(f"[LTXCond]pixel_coords {pixel_coords.shape}")
-        except Exception:
-            pass
-            
-
-
-        
         # 6. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline
         extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta)
 
-
-        try:
-            print(f"[LTX5]LATENTS {latents.shape}")
-        except Exception:
-            pass
-        
         # 7. Denoising loop
         num_warmup_steps = max(
             len(timesteps) - num_inference_steps * self.scheduler.order, 0
@@ -1336,14 +1157,6 @@ class LTXVideoPipeline(DiffusionPipeline):
                         orig_conditioning_mask,
                         generator,
                     )
-                    
-                try:
-                   print(f"[LTX6]LATENTS {latents.shape}")
-                   self.spy.inspect(latents, "LTX6_After_Patchify", reference_shape_5d=original_shape)
-                except Exception:
-                   pass
-                   
-                
 
                 latent_model_input = (
                     torch.cat([latents] * num_conds) if num_conds > 1 else latents
@@ -1351,12 +1164,6 @@ class LTXVideoPipeline(DiffusionPipeline):
                 latent_model_input = self.scheduler.scale_model_input(
                     latent_model_input, t
                 )
-                
-                try:
-                   print(f"[LTX7]LATENTS {latent_model_input.shape}")
-                   self.spy.inspect(latents, "LTX7_After_Patchify", reference_shape_5d=original_shape)
-                except Exception:
-                   pass
 
                 current_timestep = t
                 if not torch.is_tensor(current_timestep):
@@ -1472,12 +1279,6 @@ class LTXVideoPipeline(DiffusionPipeline):
                     extra_step_kwargs,
                     stochastic_sampling=stochastic_sampling,
                 )
-                
-                try:
-                   print(f"[LTX8]LATENTS {latents.shape}")
-                   self.spy.inspect(latents, "LTX8_After_Patchify", reference_shape_5d=original_shape)
-                except Exception:
-                   pass
 
                 # call the callback, if provided
                 if i == len(timesteps) - 1 or (
@@ -1488,16 +1289,6 @@ class LTXVideoPipeline(DiffusionPipeline):
                 if callback_on_step_end is not None:
                     callback_on_step_end(self, i, t, {})
 
-
-
-        try:
-            print(f"[LTX9]LATENTS {latents.shape}")
-            self.spy.inspect(latents, "LTX9_After_Patchify", reference_shape_5d=original_shape)
-      
-        except Exception:
-            pass
-            
-            
         if offload_to_cpu:
             self.transformer = self.transformer.cpu()
             if self._execution_device == "cuda":
@@ -1505,13 +1296,6 @@ class LTXVideoPipeline(DiffusionPipeline):
 
         # Remove the added conditioning latents
         latents = latents[:, num_cond_latents:]
-        
-        
-        try:
-             print(f"[LTX10]LATENTS {latents.shape}")
-             self.spy.inspect(latents, "LTX10_After_Patchify", reference_shape_5d=original_shape)
-        except Exception:
-            pass
 
         latents = self.patchifier.unpatchify(
             latents=latents,
@@ -1547,11 +1331,6 @@ class LTXVideoPipeline(DiffusionPipeline):
                 vae_per_channel_normalize=kwargs["vae_per_channel_normalize"],
                 timestep=decode_timestep,
             )
-            
-            try:
-                 print(f"[LTX11]LATENTS {latents.shape}")
-            except Exception:
-                 pass
 
             image = self.image_processor.postprocess(image, output_type=output_type)
 
@@ -1659,30 +1438,41 @@ class LTXVideoPipeline(DiffusionPipeline):
 
             # Process each conditioning item
             for conditioning_item in conditioning_items:
-                conditioning_item = self._resize_conditioning_item(
-                    conditioning_item, height, width
-                )
-                media_item = conditioning_item.media_item
-                media_frame_number = conditioning_item.media_frame_number
-                strength = conditioning_item.conditioning_strength
-                assert media_item.ndim == 5  # (b, c, f, h, w)
-                b, c, n_frames, h, w = media_item.shape
-                assert (
-                    height == h and width == w
-                ) or media_frame_number == 0, f"Dimensions do not match: {height}x{width} != {h}x{w} - allowed only when media_frame_number == 0"
-                assert n_frames % 8 == 1
-                assert (
-                    media_frame_number >= 0
-                    and media_frame_number + n_frames <= num_frames
-                )
-
-                # Encode the provided conditioning media item
-                media_item_latents = vae_encode(
-                    media_item.to(dtype=self.vae.dtype, device=self.vae.device),
-                    self.vae,
-                    vae_per_channel_normalize=vae_per_channel_normalize,
-                ).to(dtype=init_latents.dtype)
-
+            
+                print(f"media_item_latents ini {conditioning_item.media_item.shape}")
+                
+                c = conditioning_item.media_item.shape[1]
+                if c == self.transformer.config.in_channels:
+                    media_item_latents = conditioning_item.media_item.to(dtype=init_latents_dtype, device=init_latents_device)
+                    strength = conditioning_item.conditioning_strength
+                    media_frame_number = conditioning_item.media_frame_number
+                else: 
+                    conditioning_item = self._resize_conditioning_item(
+                        conditioning_item, height, width
+                    )
+                    media_item = conditioning_item.media_item
+                    media_frame_number = conditioning_item.media_frame_number
+                    strength = conditioning_item.conditioning_strength
+                    assert media_item.ndim == 5  # (b, c, f, h, w)
+                    b, c, n_frames, h, w = media_item.shape
+                    assert (
+                        height == h and width == w
+                    ) or media_frame_number == 0, f"Dimensions do not match: {height}x{width} != {h}x{w} - allowed only when media_frame_number == 0"
+                    assert n_frames % 8 == 1
+                    assert (
+                        media_frame_number >= 0
+                        and media_frame_number + n_frames <= num_frames
+                    )
+    
+                    # Encode the provided conditioning media item
+                    media_item_latents = vae_encode(
+                        media_item.to(dtype=self.vae.dtype, device=self.vae.device),
+                        self.vae,
+                        vae_per_channel_normalize=vae_per_channel_normalize,
+                    ).to(dtype=init_latents.dtype)
+                    
+                    print(f"media_item_latents encode vae {conditioning_item.media_item.shape}")
+   
                 # Handle the different conditioning cases
                 if media_frame_number == 0:
                     # Get the target spatial position of the latent conditioning item