Update app.py

app.py

@@ -1,6 +1,361 @@
 import gradio as gr
+import torch
+import os
+import gc
+import numpy as np
+from PIL import Image
+import tempfile
+from typing import Optional, Tuple
+import time
 
-gr.load(
-   "models/Lightricks/LTX-Video",
-   provider="fal-ai",
-).launch()
+# Check if we're running on Hugging Face Spaces
+IS_SPACES = os.environ.get("SPACE_ID") is not None
+
+def check_system():
+    """Check system capabilities"""
+    gpu_available = torch.cuda.is_available()
+    gpu_memory = 0
+    if gpu_available:
+        gpu_memory = torch.cuda.get_device_properties(0).total_memory / (1024**3)
+    
+    return {
+        "gpu_available": gpu_available,
+        "gpu_memory": gpu_memory,
+        "is_spaces": IS_SPACES
+    }
+
+def load_ltx_model():
+    """Load LTX-Video model with optimizations for HF Spaces"""
+    try:
+        from diffusers import LTXVideoPipeline
+        from diffusers.utils import export_to_video
+        
+        system_info = check_system()
+        
+        # Model loading strategy based on available resources
+        model_id = "Lightricks/LTX-Video"
+        
+        if system_info["gpu_available"] and system_info["gpu_memory"] > 12:
+            # High-end GPU setup
+            pipe = LTXVideoPipeline.from_pretrained(
+                model_id,
+                torch_dtype=torch.bfloat16,
+                variant="fp16"
+            ).to("cuda")
+            device = "cuda"
+            dtype = torch.bfloat16
+        elif system_info["gpu_available"] and system_info["gpu_memory"] > 6:
+            # Mid-range GPU setup with optimizations
+            pipe = LTXVideoPipeline.from_pretrained(
+                model_id,
+                torch_dtype=torch.float16,
+                variant="fp16",
+                low_cpu_mem_usage=True
+            ).to("cuda")
+            device = "cuda"
+            dtype = torch.float16
+        else:
+            # CPU fallback or low memory GPU
+            pipe = LTXVideoPipeline.from_pretrained(
+                model_id,
+                torch_dtype=torch.float32,
+                low_cpu_mem_usage=True
+            )
+            device = "cpu"
+            dtype = torch.float32
+        
+        # Enable memory efficient attention if available
+        if hasattr(pipe, "enable_memory_efficient_attention"):
+            pipe.enable_memory_efficient_attention()
+        
+        # Enable CPU offload for low memory setups
+        if system_info["gpu_memory"] < 16 and device == "cuda":
+            pipe.enable_sequential_cpu_offload()
+        
+        return pipe, device, dtype, system_info
+        
+    except ImportError:
+        return None, "cpu", torch.float32, {"error": "diffusers library not installed or LTX model not available"}
+    except Exception as e:
+        return None, "cpu", torch.float32, {"error": f"Model loading failed: {str(e)}"}
+
+# Initialize model
+print("Loading LTX-Video model...")
+PIPE, DEVICE, DTYPE, SYSTEM_INFO = load_ltx_model()
+
+def generate_video(
+    prompt: str,
+    negative_prompt: str = "",
+    num_frames: int = 25,
+    height: int = 512,
+    width: int = 512,
+    num_inference_steps: int = 20,
+    guidance_scale: float = 7.5,
+    seed: int = -1
+) -> Tuple[Optional[str], str]:
+    """Generate video using LTX-Video model"""
+    
+    if PIPE is None:
+        error_msg = f"❌ Model not loaded: {SYSTEM_INFO.get('error', 'Unknown error')}"
+        return None, error_msg
+    
+    # Input validation
+    if not prompt.strip():
+        return None, "❌ Please enter a valid prompt."
+    
+    if len(prompt) > 500:
+        return None, "❌ Prompt too long. Please keep it under 500 characters."
+    
+    # Adjust parameters based on system capabilities
+    if DEVICE == "cpu":
+        num_frames = min(num_frames, 16)  # Limit frames for CPU
+        num_inference_steps = min(num_inference_steps, 15)
+        height = min(height, 256)
+        width = min(width, 256)
+    elif SYSTEM_INFO.get("gpu_memory", 0) < 8:
+        num_frames = min(num_frames, 20)
+        height = min(height, 512)
+        width = min(width, 512)
+    
+    try:
+        # Clear cache
+        if DEVICE == "cuda":
+            torch.cuda.empty_cache()
+        gc.collect()
+        
+        # Set seed for reproducibility
+        generator = None
+        if seed != -1:
+            generator = torch.Generator(device=DEVICE).manual_seed(seed)
+        else:
+            seed = np.random.randint(0, 2**32 - 1)
+            generator = torch.Generator(device=DEVICE).manual_seed(seed)
+        
+        start_time = time.time()
+        
+        # Generate video
+        with torch.autocast(DEVICE, dtype=DTYPE):
+            result = PIPE(
+                prompt=prompt,
+                negative_prompt=negative_prompt if negative_prompt else None,
+                num_frames=num_frames,
+                height=height,
+                width=width,
+                num_inference_steps=num_inference_steps,
+                guidance_scale=guidance_scale,
+                generator=generator
+            )
+        
+        end_time = time.time()
+        generation_time = end_time - start_time
+        
+        # Save video to temporary file
+        video_frames = result.frames[0]
+        
+        with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmp_file:
+            # Convert frames to video
+            from diffusers.utils import export_to_video
+            export_to_video(video_frames, tmp_file.name, fps=8)
+            video_path = tmp_file.name
+        
+        success_msg = f"""
+        ✅ Video generated successfully!
+        
+        📝 Prompt: {prompt}
+        🎬 Frames: {num_frames}
+        📐 Resolution: {width}x{height}
+        ⚙️ Steps: {num_inference_steps}
+        🎯 Guidance: {guidance_scale}
+        🎲 Seed: {seed}
+        ⏱️ Generation Time: {generation_time:.1f}s
+        🖥️ Device: {DEVICE}
+        """
+        
+        return video_path, success_msg
+        
+    except torch.cuda.OutOfMemoryError:
+        return None, "❌ GPU memory exceeded. Try reducing resolution, frames, or inference steps."
+    except Exception as e:
+        return None, f"❌ Generation failed: {str(e)}"
+
+def get_system_info():
+    """Get detailed system information"""
+    info = f"""
+    ## 🖥️ System Information
+    
+    **Hardware:**
+    - GPU Available: {'✅' if SYSTEM_INFO.get('gpu_available', False) else '❌'}
+    - GPU Memory: {SYSTEM_INFO.get('gpu_memory', 0):.1f} GB
+    - Device: {DEVICE}
+    - Data Type: {DTYPE}
+    
+    **Environment:**
+    - Hugging Face Spaces: {'✅' if IS_SPACES else '❌'}
+    - PyTorch Version: {torch.__version__}
+    
+    **Model Status:**
+    - LTX-Video Loaded: {'✅' if PIPE is not None else '❌'}
+    """
+    
+    if "error" in SYSTEM_INFO:
+        info += f"\n**Error:** {SYSTEM_INFO['error']}"
+    
+    return info
+
+# Create Gradio interface
+with gr.Blocks(title="LTX-Video Generator", theme=gr.themes.Soft()) as demo:
+    
+    gr.Markdown("""
+    # 🎬 LTX-Video Generator by Lightricks
+    
+    Generate high-quality videos from text descriptions using the LTX-Video model.
+    """)
+    
+    with gr.Tab("🎥 Generate Video"):
+        with gr.Row():
+            with gr.Column(scale=1):
+                prompt_input = gr.Textbox(
+                    label="📝 Video Prompt",
+                    placeholder="A serene lake surrounded by mountains at sunset...",
+                    lines=3,
+                    max_lines=5
+                )
+                
+                negative_prompt_input = gr.Textbox(
+                    label="🚫 Negative Prompt (Optional)",
+                    placeholder="blurry, low quality, distorted...",
+                    lines=2
+                )
+                
+                with gr.Row():
+                    num_frames = gr.Slider(
+                        minimum=8,
+                        maximum=50,
+                        value=25,
+                        step=1,
+                        label="🎬 Number of Frames"
+                    )
+                    
+                    num_steps = gr.Slider(
+                        minimum=10,
+                        maximum=50,
+                        value=20,
+                        step=1,
+                        label="⚙️ Inference Steps"
+                    )
+                
+                with gr.Row():
+                    width = gr.Dropdown(
+                        choices=[256, 512, 768, 1024],
+                        value=512,
+                        label="📐 Width"
+                    )
+                    
+                    height = gr.Dropdown(
+                        choices=[256, 512, 768, 1024],
+                        value=512,
+                        label="📏 Height"
+                    )
+                
+                with gr.Row():
+                    guidance_scale = gr.Slider(
+                        minimum=1.0,
+                        maximum=20.0,
+                        value=7.5,
+                        step=0.5,
+                        label="🎯 Guidance Scale"
+                    )
+                    
+                    seed = gr.Number(
+                        label="🎲 Seed (-1 for random)",
+                        value=-1,
+                        precision=0
+                    )
+                
+                generate_btn = gr.Button("🎬 Generate Video", variant="primary", size="lg")
+                
+            with gr.Column(scale=1):
+                video_output = gr.Video(
+                    label="🎥 Generated Video",
+                    height=400
+                )
+                
+                result_text = gr.Textbox(
+                    label="📋 Generation Info",
+                    lines=8,
+                    show_copy_button=True
+                )
+        
+        # Event handler
+        generate_btn.click(
+            fn=generate_video,
+            inputs=[
+                prompt_input, negative_prompt_input, num_frames,
+                height, width, num_steps, guidance_scale, seed
+            ],
+            outputs=[video_output, result_text]
+        )
+        
+        # Example prompts
+        gr.Examples(
+            examples=[
+                ["A majestic waterfall cascading down rocky cliffs", "", 25, 512, 512, 20, 7.5, 42],
+                ["A cute kitten playing with colorful yarn balls", "blurry, low quality", 20, 512, 512, 20, 8.0, 123],
+                ["Time-lapse of clouds moving over a city skyline", "", 30, 768, 512, 25, 7.0, 456],
+                ["A peaceful forest with sunlight filtering through trees", "dark, gloomy", 25, 512, 768, 20, 7.5, 789]
+            ],
+            inputs=[prompt_input, negative_prompt_input, num_frames, height, width, num_steps, guidance_scale, seed]
+        )
+    
+    with gr.Tab("ℹ️ System Info"):
+        with gr.Row():
+            info_btn = gr.Button("🔍 Check System Status", variant="secondary")
+            
+        system_output = gr.Markdown()
+        
+        info_btn.click(
+            fn=get_system_info,
+            outputs=system_output
+        )
+        
+        # Initial system info display
+        demo.load(
+            fn=get_system_info,
+            outputs=system_output
+        )
+    
+    with gr.Tab("📚 Usage Tips"):
+        gr.Markdown("""
+        ## 💡 Tips for Better Results
+        
+        **Prompt Writing:**
+        - Be descriptive and specific
+        - Include camera movements (zoom, pan, etc.)
+        - Specify lighting and mood
+        - Mention style if desired (cinematic, artistic, etc.)
+        
+        **Parameter Tuning:**
+        - **Frames:** More frames = longer video but slower generation
+        - **Inference Steps:** Higher steps = better quality but slower
+        - **Guidance Scale:** 7-9 usually works best
+        - **Resolution:** Start with 512x512 for faster results
+        
+        **Performance:**
+        - CPU generation is slower but works on all systems
+        - GPU generation requires sufficient VRAM
+        - Lower settings if you encounter memory errors
+        
+        **Negative Prompts:** Help avoid unwanted elements
+        - Common: "blurry, low quality, distorted, pixelated"
+        - Specific: "text, watermark, signature, logo"
+        """)
+
+# Launch configuration
+if __name__ == "__main__":
+    demo.launch(
+        share=False,
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_error=True,
+        show_api=False
+    )