Update app.py

app.py

@@ -3,86 +3,50 @@ import torch
 import os
 import gc
 import numpy as np
-from PIL import Image
 import tempfile
 from typing import Optional, Tuple
 import time
 
-# Check if we're running on Hugging Face Spaces
-IS_SPACES = os.environ.get("SPACE_ID") is not None
+# ZeroGPU import - bu çok önemli!
+import spaces
 
-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
-    }
+# Check if running in ZeroGPU environment
+IS_ZERO_GPU = os.environ.get("SPACES_ZERO_GPU") == "true"
+IS_SPACES = os.environ.get("SPACE_ID") is not None
 
-def load_ltx_model():
-    """Load LTX-Video model with optimizations for HF Spaces"""
+def load_model():
+    """Load LTX-Video model - this will run on ZeroGPU when decorated"""
     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"
+        print("🔄 Loading LTX-Video model...")
         
-        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()
+        pipe = LTXVideoPipeline.from_pretrained(
+            "Lightricks/LTX-Video",
+            torch_dtype=torch.bfloat16,
+            use_safetensors=True,
+        )
         
-        # Enable CPU offload for low memory setups
-        if system_info["gpu_memory"] < 16 and device == "cuda":
-            pipe.enable_sequential_cpu_offload()
+        # ZeroGPU optimizations
+        if IS_ZERO_GPU:
+            pipe = pipe.to("cuda")
+            # Enable memory optimizations
+            pipe.enable_vae_slicing()
+            pipe.enable_vae_tiling()
+            if hasattr(pipe, 'enable_memory_efficient_attention'):
+                pipe.enable_memory_efficient_attention()
         
-        return pipe, device, dtype, system_info
+        print("✅ Model loaded successfully!")
+        return pipe
         
-    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)}"}
+        print(f"❌ Model loading failed: {e}")
+        return None
 
-# Initialize model
-print("Loading LTX-Video model...")
-PIPE, DEVICE, DTYPE, SYSTEM_INFO = load_ltx_model()
+# Global model variable - will be loaded when needed
+MODEL = None
 
+@spaces.GPU(duration=120)  # ZeroGPU decorator - 2 dakika GPU kullanımı
 def generate_video(
     prompt: str,
     negative_prompt: str = "",
@@ -93,49 +57,48 @@ def generate_video(
     guidance_scale: float = 7.5,
     seed: int = -1
 ) -> Tuple[Optional[str], str]:
-    """Generate video using LTX-Video model"""
+    """Generate video using LTX-Video with ZeroGPU"""
+    
+    global MODEL
     
-    if PIPE is None:
-        error_msg = f"❌ Model not loaded: {SYSTEM_INFO.get('error', 'Unknown error')}"
-        return None, error_msg
+    # Load model if not already loaded
+    if MODEL is None:
+        MODEL = load_model()
+    
+    if MODEL is None:
+        return None, "❌ Model loading failed. Please try again."
     
     # 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."
+    if len(prompt) > 300:
+        return None, "❌ Prompt too long. Please keep it under 300 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)
+    # ZeroGPU optimizations - limit parameters for stability
+    num_frames = min(num_frames, 25)  # Max 25 frames
+    num_inference_steps = min(num_inference_steps, 25)  # Max 25 steps
+    height = min(height, 768)  # Max 768px
+    width = min(width, 768)   # Max 768px
     
     try:
-        # Clear cache
-        if DEVICE == "cuda":
-            torch.cuda.empty_cache()
+        # Clear CUDA cache
+        torch.cuda.empty_cache()
         gc.collect()
         
         # Set seed for reproducibility
         generator = None
-        if seed != -1:
-            generator = torch.Generator(device=DEVICE).manual_seed(seed)
-        else:
+        if seed == -1:
             seed = np.random.randint(0, 2**32 - 1)
-            generator = torch.Generator(device=DEVICE).manual_seed(seed)
         
+        generator = torch.Generator(device="cuda").manual_seed(seed)
+        
+        print(f"🎬 Generating video: {prompt}")
         start_time = time.time()
         
         # Generate video
-        with torch.autocast(DEVICE, dtype=DTYPE):
-            result = PIPE(
+        with torch.autocast("cuda", dtype=torch.bfloat16):
+            result = MODEL(
                 prompt=prompt,
                 negative_prompt=negative_prompt if negative_prompt else None,
                 num_frames=num_frames,
@@ -143,136 +106,159 @@ def generate_video(
                 width=width,
                 num_inference_steps=num_inference_steps,
                 guidance_scale=guidance_scale,
-                generator=generator
+                generator=generator,
             )
         
         end_time = time.time()
         generation_time = end_time - start_time
         
-        # Save video to temporary file
+        # Export video
         video_frames = result.frames[0]
         
         with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmp_file:
-            # Convert frames to video
+            # Export to video file
             from diffusers.utils import export_to_video
             export_to_video(video_frames, tmp_file.name, fps=8)
             video_path = tmp_file.name
         
+        # Clear memory
+        torch.cuda.empty_cache()
+        gc.collect()
+        
         success_msg = f"""
-        ✅ Video generated successfully!
+        ✅ Video generated successfully with ZeroGPU!
         
         📝 Prompt: {prompt}
         🎬 Frames: {num_frames}
-        📐 Resolution: {width}x{height}
-        ⚙️ Steps: {num_inference_steps}
-        🎯 Guidance: {guidance_scale}
+        📐 Resolution: {width}x{height}  
+        ⚙️ Inference Steps: {num_inference_steps}
+        🎯 Guidance Scale: {guidance_scale}
         🎲 Seed: {seed}
         ⏱️ Generation Time: {generation_time:.1f}s
-        🖥️ Device: {DEVICE}
+        🖥️ ZeroGPU: {'✅' if IS_ZERO_GPU else '❌'}
         """
         
         return video_path, success_msg
         
     except torch.cuda.OutOfMemoryError:
-        return None, "❌ GPU memory exceeded. Try reducing resolution, frames, or inference steps."
+        torch.cuda.empty_cache()
+        gc.collect()
+        return None, "❌ GPU memory exceeded. Try reducing frames, resolution, or inference steps."
+    
     except Exception as e:
+        torch.cuda.empty_cache()
+        gc.collect()
         return None, f"❌ Generation failed: {str(e)}"
 
 def get_system_info():
-    """Get detailed system information"""
-    info = f"""
-    ## 🖥️ System Information
+    """Get system information"""
+    gpu_info = "Not available"
+    if torch.cuda.is_available():
+        gpu_info = f"{torch.cuda.get_device_name(0)} ({torch.cuda.get_device_properties(0).total_memory / 1024**3:.1f} GB)"
     
-    **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}
+    return f"""
+    ## 🖥️ System Information
     
     **Environment:**
+    - ZeroGPU: {'✅ Active' if IS_ZERO_GPU else '❌ Not detected'}
     - Hugging Face Spaces: {'✅' if IS_SPACES else '❌'}
-    - PyTorch Version: {torch.__version__}
+    - CUDA Available: {'✅' if torch.cuda.is_available() else '❌'}
+    - GPU: {gpu_info}
+    - PyTorch: {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']}"
+    - LTX-Video: {'✅ Loaded' if MODEL is not None else '⏳ Will load on first use'}
     
-    return info
+    **ZeroGPU Benefits:**
+    - ✅ Free GPU access
+    - ✅ A100 40GB GPU
+    - ✅ Automatic resource management
+    - ⏱️ 120 second timeout per generation
+    """
 
 # Create Gradio interface
-with gr.Blocks(title="LTX-Video Generator", theme=gr.themes.Soft()) as demo:
+with gr.Blocks(title="LTX-Video with ZeroGPU", theme=gr.themes.Soft()) as demo:
     
     gr.Markdown("""
-    # 🎬 LTX-Video Generator by Lightricks
+    # 🚀 LTX-Video Generator (ZeroGPU Powered)
+    
+    Generate high-quality videos from text using Lightricks' LTX-Video model, powered by **ZeroGPU**!
     
-    Generate high-quality videos from text descriptions using the LTX-Video model.
+    ⚡ **Free GPU access** - No need to upgrade your Space hardware!
     """)
     
+    if IS_ZERO_GPU:
+        gr.Markdown("✅ **ZeroGPU Active** - You have free access to A100 GPU!")
+    else:
+        gr.Markdown("⚠️ **ZeroGPU not detected** - Make sure you've enabled ZeroGPU in your Space settings.")
+    
     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...",
+                    placeholder="A serene mountain lake reflecting the aurora borealis...",
                     lines=3,
                     max_lines=5
                 )
                 
                 negative_prompt_input = gr.Textbox(
                     label="🚫 Negative Prompt (Optional)",
-                    placeholder="blurry, low quality, distorted...",
+                    placeholder="blurry, low quality, distorted, text, watermark...",
                     lines=2
                 )
                 
-                with gr.Row():
-                    num_frames = gr.Slider(
-                        minimum=8,
-                        maximum=50,
-                        value=25,
-                        step=1,
-                        label="🎬 Number of Frames"
-                    )
+                with gr.Accordion("🔧 Advanced Settings", open=False):
+                    with gr.Row():
+                        num_frames = gr.Slider(
+                            minimum=8,
+                            maximum=25,  # Limited for ZeroGPU
+                            value=16,
+                            step=1,
+                            label="🎬 Number of Frames"
+                        )
+                        
+                        num_steps = gr.Slider(
+                            minimum=10,
+                            maximum=25,  # Limited for ZeroGPU  
+                            value=20,
+                            step=1,
+                            label="⚙️ Inference Steps"
+                        )
                     
-                    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"
-                    )
+                    with gr.Row():
+                        width = gr.Dropdown(
+                            choices=[256, 512, 768],  # Limited for ZeroGPU
+                            value=512,
+                            label="📐 Width"
+                        )
+                        
+                        height = gr.Dropdown(
+                            choices=[256, 512, 768],  # Limited for ZeroGPU
+                            value=512,
+                            label="📏 Height"
+                        )
                     
-                    height = gr.Dropdown(
-                        choices=[256, 512, 768, 1024],
-                        value=512,
-                        label="📏 Height"
-                    )
+                    with gr.Row():
+                        guidance_scale = gr.Slider(
+                            minimum=1.0,
+                            maximum=15.0,
+                            value=7.5,
+                            step=0.5,
+                            label="🎯 Guidance Scale"
+                        )
+                        
+                        seed = gr.Number(
+                            label="🎲 Seed (-1 for random)",
+                            value=-1,
+                            precision=0
+                        )
                 
-                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 with ZeroGPU", variant="primary", size="lg")
                 
-                generate_btn = gr.Button("🎬 Generate Video", variant="primary", size="lg")
+                gr.Markdown("""
+                **⏱️ Note:** Each generation uses 2 minutes of ZeroGPU time.
+                """)
                 
             with gr.Column(scale=1):
                 video_output = gr.Video(
@@ -299,63 +285,55 @@ with gr.Blocks(title="LTX-Video Generator", theme=gr.themes.Soft()) as demo:
         # 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]
+                ["A majestic eagle soaring over snow-capped mountains", "blurry, low quality", 16, 512, 512, 20, 7.5, 42],
+                ["Ocean waves gently lapping on a tropical beach at sunset", "", 20, 512, 512, 20, 8.0, 123],
+                ["A steaming cup of coffee on a rainy window sill", "text, watermark", 16, 512, 512, 15, 7.0, 456],
+                ["Cherry blossoms falling in a peaceful Japanese garden", "", 20, 768, 512, 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")
-            
+        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
-        )
+        info_btn.click(fn=get_system_info, outputs=system_output)
+        demo.load(fn=get_system_info, outputs=system_output)
     
-    with gr.Tab("📚 Usage Tips"):
+    with gr.Tab("📚 ZeroGPU Guide"):
         gr.Markdown("""
-        ## 💡 Tips for Better Results
+        ## 🚀 ZeroGPU Nedir?
+        
+        **ZeroGPU**, Hugging Face'in ücretsiz GPU hizmetidir:
         
-        **Prompt Writing:**
-        - Be descriptive and specific
-        - Include camera movements (zoom, pan, etc.)
-        - Specify lighting and mood
-        - Mention style if desired (cinematic, artistic, etc.)
+        ### ✅ Avantajları:
+        - **Ücretsiz A100 GPU** erişimi
+        - **40GB GPU belleği** 
+        - Otomatik kaynak yönetimi
+        - CPU Basic Space'te bile çalışır
         
-        **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
+        ### ⚙️ Nasıl Etkinleştirilir:
+        1. Space Settings → Advanced → ZeroGPU etkinleştir
+        2. `requirements.txt`'e `spaces` ekle  
+        3. Kodda `@spaces.GPU()` decorator kullan
         
-        **Performance:**
-        - CPU generation is slower but works on all systems
-        - GPU generation requires sufficient VRAM
-        - Lower settings if you encounter memory errors
+        ### 📊 Limitler:
+        - Fonksiyon başına max 120 saniye
+        - Eşzamanlı kullanım sınırı
+        - Yoğun zamanlarda kuyruk
         
-        **Negative Prompts:** Help avoid unwanted elements
-        - Common: "blurry, low quality, distorted, pixelated"
-        - Specific: "text, watermark, signature, logo"
+        ### 💡 İpuçları:
+        - Küçük parametrelerle başlayın
+        - İlk çalıştırma model yükleme nedeniyle uzun sürebilir
+        - Hata alırsanız birkaç saniye bekleyip tekrar deneyin
         """)
 
-# Launch configuration
+# Launch the app
 if __name__ == "__main__":
+    demo.queue(max_size=10)  # ZeroGPU için queue gerekli
     demo.launch(
         share=False,
-        server_name="0.0.0.0",
+        server_name="0.0.0.0", 
         server_port=7860,
-        show_error=True,
-        show_api=False
+        show_error=True
     )