Spaces:
Paused
Paused
| # 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. |