HunyuanVideo: Tencent's 13 Billion Parameter Open-Source Video Generation Powerhouse

import torch
from diffusers import HunyuanVideoPipeline, HunyuanVideoTransformer3DModel
from diffusers.utils import export_to_video

# Initialize the model with memory optimization
model_id = "tencent/HunyuanVideo"

# Load transformer with 8-bit quantization for 60GB GPUs
transformer = HunyuanVideoTransformer3DModel.from_pretrained(
    model_id,
    subfolder="transformer",
    torch_dtype=torch.float16,
    revision="refs/pr/18"
)

# Initialize pipeline with optimizations
pipe = HunyuanVideoPipeline.from_pretrained(
    model_id,
    transformer=transformer,
    torch_dtype=torch.float16,
    revision="refs/pr/18"
)
pipe.enable_model_cpu_offload()
pipe.enable_vae_tiling()

# Generate video with camera control
prompt = """A cinematic shot of a majestic eagle soaring through 
mountain valleys at golden hour, photorealistic details, 
4K quality. Camera: Orbit Right, then Zoom In."""

output = pipe(
    prompt=prompt,
    height=720,
    width=1280,
    num_frames=129,  # ~5 seconds at 25 fps
    num_inference_steps=50,
    guidance_scale=7.5,
    generator=torch.Generator("cuda").manual_seed(42)
)

# Export to MP4
export_to_video(output.frames[0], "eagle_flight.mp4", fps=25)
print("Video generated: eagle_flight.mp4")

from PIL import Image
import torch
from diffusers import HunyuanVideoPipeline
from diffusers.utils import export_to_video, load_image

# Initialize pipeline (same as above)
pipe = HunyuanVideoPipeline.from_pretrained(
    "tencent/HunyuanVideo",
    torch_dtype=torch.float16,
    revision="refs/pr/18"
)
pipe.enable_model_cpu_offload()
pipe.enable_vae_tiling()

# Load starting frame
init_image = load_image("product_shot.jpg")
init_image = init_image.resize((1280, 720))

# Complex prompt with multiple camera movements
prompt = """Professional product reveal of luxury smartwatch on marble pedestal, 
studio lighting with soft shadows, premium materials. 
Camera sequence: Start Static Shot, then Orbit Right 180 degrees, 
finish with Zoom In on watch face details, cinematic motion."""

negative_prompt = """blurry, low quality, distorted, warped, 
unrealistic motion, jerky movement, artifacts"""

# Generate with image conditioning
output = pipe(
    prompt=prompt,
    image=init_image,
    negative_prompt=negative_prompt,
    height=720,
    width=1280,
    num_frames=193,  # ~8 seconds
    num_inference_steps=60,
    guidance_scale=8.0,
    strength=0.8,  # How much to transform the input image
    generator=torch.Generator("cuda").manual_seed(123)
)

export_to_video(output.frames[0], "product_reveal.mp4", fps=25)

# Optional: Generate multiple variations
for i, seed in enumerate([42, 123, 456]):
    output = pipe(
        prompt=prompt,
        image=init_image,
        negative_prompt=negative_prompt,
        height=720,
        width=1280,
        num_frames=129,
        num_inference_steps=50,
        guidance_scale=8.0,
        generator=torch.Generator("cuda").manual_seed(seed)
    )
    export_to_video(output.frames[0], f"variation_{i}.mp4", fps=25)
    print(f"Generated variation {i} with seed {seed}")

import torch
import gc
from diffusers import HunyuanVideoPipeline
from diffusers.utils import export_to_video

def generate_video_batch(prompts, output_dir="output"):
    """Generate multiple videos with automatic memory management."""
    
    pipe = HunyuanVideoPipeline.from_pretrained(
        "tencent/HunyuanVideo",
        torch_dtype=torch.float16,
        revision="refs/pr/18"
    )
    pipe.enable_model_cpu_offload()
    pipe.enable_vae_tiling()
    
    # Camera movement presets
    camera_presets = {
        "dynamic": "Camera: Orbit Right, Tilt Up",
        "cinematic": "Camera: Zoom In, Pan Down",
        "stable": "Camera: Static Shot with Handheld Movement",
        "reveal": "Camera: Zoom Out, Orbit Left"
    }
    
    results = []
    
    for idx, prompt_config in enumerate(prompts):
        prompt_text = prompt_config["prompt"]
        camera_style = prompt_config.get("camera", "dynamic")
        
        # Add camera movement to prompt
        full_prompt = f"{prompt_text}. {camera_presets[camera_style]}"
        
        print(f"Generating video {idx + 1}/{len(prompts)}...")
        
        try:
            output = pipe(
                prompt=full_prompt,
                height=720,
                width=1280,
                num_frames=129,
                num_inference_steps=50,
                guidance_scale=7.5,
                generator=torch.Generator("cuda").manual_seed(
                    prompt_config.get("seed", 42)
                )
            )
            
            filename = f"{output_dir}/video_{idx:03d}.mp4"
            export_to_video(output.frames[0], filename, fps=25)
            results.append({"id": idx, "file": filename, "status": "success"})
            
        except RuntimeError as e:
            print(f"Error generating video {idx}: {e}")
            results.append({"id": idx, "status": "failed", "error": str(e)})
        
        finally:
            # Clear GPU memory between generations
            torch.cuda.empty_cache()
            gc.collect()
    
    return results

# Example usage
prompts = [
    {"prompt": "Sunset over ocean waves", "camera": "cinematic", "seed": 42},
    {"prompt": "City skyline at night with traffic", "camera": "dynamic", "seed": 123},
    {"prompt": "Forest path with autumn leaves", "camera": "stable", "seed": 456}
]

results = generate_video_batch(prompts)
print(f"Generated {sum(1 for r in results if r['status'] == 'success')} videos")