Upload latent2video.py

latent2video.py

@@ -0,0 +1,154 @@
+import argparse
+from pathlib import Path
+from typing import Union, List
+from PIL import Image
+import os
+import torch
+import torch.nn as nn
+from diffusers import AutoencoderKLWan
+from diffusers.video_processor import VideoProcessor
+from diffusers.utils import export_to_video
+
+def save_images_as_gif(images: List[Image.Image], save_path: str, fps=8) -> None:
+
+    images[0].save(
+        save_path,
+        save_all=True,
+        append_images=images[1:],
+        loop=0,
+        duration=int(1000 / fps),
+    )
+    
+def save_video_to_dir(video_frames, save_dir, save_suffix, save_type='frame', fps=8):
+    os.makedirs(save_dir, exist_ok=True)
+
+    save_type_list = save_type.split('_')
+
+    # save frame
+    if 'frame' in save_type_list:
+        frame_save_dir = os.path.join(save_dir, 'frames')
+        os.makedirs(frame_save_dir, exist_ok=True)
+        for idx, img in enumerate(video_frames):
+            img.save(os.path.join(frame_save_dir, f'{idx:05d}_{save_suffix}.jpg'))
+
+    # save to gif
+    if 'gif' in save_type_list:
+        gif_save_path = os.path.join(save_dir, f'{save_suffix}.gif')
+        save_images_as_gif(video_frames, gif_save_path, fps=fps)
+
+    # save to video
+    if 'mp4' in save_type_list:
+        video_save_path = os.path.join(save_dir, f'{save_suffix}.mp4')
+        export_to_video(video_frames, video_save_path, fps=fps)
+
+def setup_vae(model_path: str, device: torch.device) -> AutoencoderKLWan:
+    """
+    Initialize and setup the VAE model.
+    
+    Args:
+        model_path: Path to the VAE model
+        device: Target device for model execution
+        
+    Returns:
+        Initialized VAE model
+    """
+    vae = AutoencoderKLWan.from_pretrained(
+        model_path,
+        subfolder="vae",
+        torch_dtype=torch.float32
+    ).eval().to(device)
+    
+    # Ensure all parameters are float32
+    for param in vae.parameters():
+        param.data = param.data.to(torch.float32)
+        
+    return vae
+
+
+def process_latents(latents: torch.Tensor, vae: nn.Module, device: torch.device) -> torch.Tensor:
+    """
+    Process and denormalize latent vectors if necessary.
+    
+    Args:
+        latents: Input latent vectors
+        vae: VAE model containing normalization parameters
+        device: Target device for processing
+        
+    Returns:
+        Processed latent vectors
+    """
+    # Ensure latents are in correct shape [B, C, T, H, W]
+    if len(latents.shape) == 4:
+        latents = latents.unsqueeze(0)
+    
+    # Apply denormalization if mean/std are available
+    if hasattr(vae.config, 'latents_mean') and hasattr(vae.config, 'latents_std'):
+        latents_mean = torch.tensor(vae.config.latents_mean, device=device, dtype=torch.float32).view(1, -1, 1, 1, 1)
+        latents_std = 1.0 / torch.tensor(vae.config.latents_std, device=device, dtype=torch.float32).view(1, -1, 1, 1, 1)
+        return latents / latents_std + latents_mean
+    
+    return latents
+
+
+def latent_to_video(latent_path: Union[str, Path], output_path: Union[str, Path]) -> None:
+    """
+    Convert latent vectors to video frames and save as MP4.
+    
+    Args:
+        latent_path: Path to the latent file (.pth)
+        output_path: Path to save the output video (.mp4)
+    """
+    # Setup device and paths
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    latent_path = Path(latent_path)
+    output_path = Path(output_path)
+    
+    # Initialize VAE model
+    vae = setup_vae("Wan-AI/Wan2.1-T2V-1.3B-Diffusers", device)
+    
+    # Load and process latents
+    latent_dict = torch.load(latent_path, map_location=device)
+    latents = latent_dict['latents'].to(torch.float32)
+    processed_latents = process_latents(latents, vae, device)
+    
+    # Setup video processor
+    vae_scale_factor = 2 ** len(vae.temperal_downsample) if getattr(vae, "vae", None) else 8
+    video_processor = VideoProcessor(vae_scale_factor=vae_scale_factor)
+    
+    # Generate video frames
+    with torch.no_grad():
+        video_frames = vae.decode(processed_latents, return_dict=False)[0]
+    
+    # Post-process and save video
+    video_frames = video_processor.postprocess_video(video_frames, output_type="np")
+    save_video_to_dir(
+        video_frames[0],
+        save_dir=str(output_path.parent),
+        save_suffix=output_path.stem,
+        save_type='mp4',
+        fps=16
+    )
+
+
+def main():
+    """Parse command line arguments and run the conversion."""
+    parser = argparse.ArgumentParser(description="Convert latent vectors to video")
+    parser.add_argument('--latent', type=str, required=True, help='Path to the .pth latent file')
+    parser.add_argument('--output', type=str, required=True, help='Path to save the output .mp4 video')
+    args = parser.parse_args()
+    
+    latent_path = Path(args.latent)
+    output_path = Path(args.output)
+    
+    # Validate input/output formats
+    assert latent_path.suffix == '.pth', "Latent file must be a .pth file"
+    assert output_path.suffix == '.mp4', "Output file must be a .mp4 file"
+    
+    # Ensure output directory exists
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    
+    latent_to_video(latent_path, output_path)
+
+
+if __name__ == '__main__':
+    main()