Upload 2 files

LTX-Video/ltx_video/pipelines/pipeline_ltx_video.py

@@ -24,6 +24,8 @@ from transformers import (
     AutoTokenizer,
 )
 
+from ltx_video.models.pipelines.spy_latent import SpyLatent
+
 from ltx_video.models.autoencoders.causal_video_autoencoder import (
     CausalVideoAutoencoder,
 )
@@ -250,6 +252,8 @@ 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"["
@@ -312,6 +316,8 @@ 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=self.pipeline.vae)
 
     def mask_text_embeddings(self, emb, mask):
         if emb.shape[0] == 1:
@@ -1116,12 +1122,14 @@ class LTXVideoPipeline(DiffusionPipeline):
             vae_per_channel_normalize=vae_per_channel_normalize,
         )
         
-        
         try:
             print(f"[LTX4]LATENTS {latents.shape}")
+            original_shape = latents
         except Exception:
-            pass        
-
+            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(
@@ -1136,6 +1144,21 @@ 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
+            
 
 
         
@@ -1209,8 +1232,11 @@ class LTXVideoPipeline(DiffusionPipeline):
                     
                 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
@@ -1221,6 +1247,7 @@ class LTXVideoPipeline(DiffusionPipeline):
                 
                 try:
                    print(f"[LTX7]LATENTS {latent_model_input.shape}")
+                   self.spy.inspect(latents, "LTX7_After_Patchify", reference_shape_5d=original_shape)
                 except Exception:
                    pass
 
@@ -1341,6 +1368,7 @@ class LTXVideoPipeline(DiffusionPipeline):
                 
                 try:
                    print(f"[LTX8]LATENTS {latents.shape}")
+                   self.spy.inspect(latents, "LTX8_After_Patchify", reference_shape_5d=original_shape)
                 except Exception:
                    pass
 
@@ -1357,9 +1385,12 @@ class LTXVideoPipeline(DiffusionPipeline):
 
         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":
@@ -1371,6 +1402,7 @@ class LTXVideoPipeline(DiffusionPipeline):
         
         try:
              print(f"[LTX10]LATENTS {latents.shape}")
+             self.spy.inspect(latents, "LTX10_After_Patchify", reference_shape_5d=original_shape)
         except Exception:
             pass
 
@@ -1402,7 +1434,7 @@ class LTXVideoPipeline(DiffusionPipeline):
                 decode_timestep = None
             latents = self.tone_map_latents(latents, tone_map_compression_ratio)
             image = vae_decode(
-                latents,
+                latents,,
                 self.vae,
                 is_video,
                 vae_per_channel_normalize=kwargs["vae_per_channel_normalize"],

LTX-Video/ltx_video/pipelines/spy_late.py

@@ -0,0 +1,115 @@
+# spy_latent.py
+
+import torch
+import os
+import traceback
+from einops import rearrange
+from torchvision.utils import save_image
+
+# Tenta importar o VAE do pipeline. Se não conseguir, a visualização será desativada.
+try:
+    from ltx_video.models.autoencoders.causal_video_autoencoder import CausalVideoAutoencoder
+except ImportError:
+    CausalVideoAutoencoder = None
+
+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.
+    """
+    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()
+        finally:
+            print("--- [FIM DA INSPEÇÃO] ---\n")
+
+    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}: Shape={list(tensor.shape)}, Mean={mean:.4f}, Std={std:.4f}, Min={min_val:.4f}, Max={max_val:.4f}")
+
+# Exemplo de como instanciar globalmente (se desejado)
+# spy = SpyLatent() 
+# A melhor prática é instanciar dentro da sua classe principal, passando o VAE.