Update app.py

app.py

@@ -24,42 +24,42 @@ IS_ZERO_GPU = os.environ.get("SPACES_ZERO_GPU") == "true"
 IS_SPACES = os.environ.get("SPACE_ID") is not None
 HAS_CUDA = torch.cuda.is_available()
 
-print(f"🚀 H200 Premium Setup: ZeroGPU={IS_ZERO_GPU}, Spaces={IS_SPACES}, CUDA={HAS_CUDA}")
+print(f"🚀 H200 CogVideoX Setup: ZeroGPU={IS_ZERO_GPU}, Spaces={IS_SPACES}, CUDA={HAS_CUDA}")
 
-# PREMIUM MODELS ONLY - No low quality fallbacks
-PREMIUM_MODELS = [
+# WORKING MODELS - Tested and confirmed
+WORKING_MODELS = [
     {
-        "id": "THUDM/CogVideoX-5b",
-        "name": "CogVideoX-5B",
+        "id": "THUDM/CogVideoX-2b",
+        "name": "CogVideoX-2B",
         "pipeline_class": "CogVideoXPipeline",
-        "resolution_options": [(720, 480), (480, 720)],
+        "resolution": (720, 480),
         "max_frames": 49,
         "dtype": torch.bfloat16,
         "fps": 8,
         "priority": 1,
-        "description": "5B parameter video model - high quality"
+        "description": "2B parameter model - fast and high quality"
     },
     {
-        "id": "THUDM/CogVideoX-2b", 
-        "name": "CogVideoX-2B",
+        "id": "THUDM/CogVideoX-5b",
+        "name": "CogVideoX-5B", 
         "pipeline_class": "CogVideoXPipeline",
-        "resolution_options": [(720, 480), (480, 720)],
+        "resolution": (720, 480),
         "max_frames": 49,
         "dtype": torch.bfloat16,
         "fps": 8,
         "priority": 2,
-        "description": "2B parameter model - faster generation"
+        "description": "5B parameter model - maximum quality"
     },
     {
-        "id": "Lightricks/LTX-Video",
-        "name": "LTX-Video",
+        "id": "damo-vilab/text-to-video-ms-1.7b",
+        "name": "ModelScope T2V 1.7B",
         "pipeline_class": "DiffusionPipeline",
-        "resolution_options": [(512, 512), (768, 768)],
-        "max_frames": 121,  # LTX supports longer videos
-        "dtype": torch.bfloat16,
-        "fps": 24,  # Higher FPS
+        "resolution": (256, 256),
+        "max_frames": 16,
+        "dtype": torch.float16,
+        "fps": 8,
         "priority": 3,
-        "description": "Professional video generation model"
+        "description": "Reliable fallback model"
     }
 ]
 
@@ -77,115 +77,121 @@ def log_loading(message):
     LOADING_LOGS.append(formatted_msg)
 
 def get_h200_memory():
-    """Get detailed H200 memory stats"""
+    """Get H200 memory stats"""
     if HAS_CUDA:
         try:
             total = torch.cuda.get_device_properties(0).total_memory / (1024**3)
             allocated = torch.cuda.memory_allocated(0) / (1024**3)
-            reserved = torch.cuda.memory_reserved(0) / (1024**3)
-            return total, allocated, reserved
+            return total, allocated
         except:
-            return 0, 0, 0
-    return 0, 0, 0
+            return 0, 0
+    return 0, 0
 
-def load_premium_model():
-    """Load premium models only - no fallbacks"""
+def load_working_model():
+    """Load first working model - CogVideoX priority"""
     global MODEL, MODEL_INFO, LOADING_LOGS
     
     if MODEL is not None:
         return True
     
     LOADING_LOGS = []
-    log_loading("🎯 H200 Premium Model Loading - QUALITY PRIORITY")
+    log_loading("🎯 H200 Working Model Loading - CogVideoX Priority")
     
-    total_mem, allocated_mem, reserved_mem = get_h200_memory()
-    log_loading(f"💾 H200 Memory: {total_mem:.1f}GB total, {allocated_mem:.1f}GB allocated, {reserved_mem:.1f}GB reserved")
+    total_mem, allocated_mem = get_h200_memory()
+    log_loading(f"💾 H200 Memory: {total_mem:.1f}GB total, {allocated_mem:.1f}GB allocated")
     
-    # Sort by priority (premium first)
-    sorted_models = sorted(PREMIUM_MODELS, key=lambda x: x["priority"])
+    # Try models in priority order
+    sorted_models = sorted(WORKING_MODELS, key=lambda x: x["priority"])
     
     for model_config in sorted_models:
-        if try_load_premium_model(model_config):
+        if try_load_working_model(model_config):
             return True
     
-    log_loading("❌ All premium models failed - check model availability")
+    log_loading("❌ All working models failed")
     return False
 
-def try_load_premium_model(config):
-    """Try loading premium model with optimized settings"""
+def try_load_working_model(config):
+    """Try loading a specific working model"""
     global MODEL, MODEL_INFO
     
     model_id = config["id"]
     model_name = config["name"]
     
-    log_loading(f"🔄 Loading {model_name} (Premium)...")
-    log_loading(f"  📋 Target: {config['pipeline_class']}, {config['max_frames']} frames, {config['fps']} fps")
+    log_loading(f"🔄 Loading {model_name}...")
+    log_loading(f"  📋 Config: {model_id}")
+    log_loading(f"  🎯 Target: {config['max_frames']} frames, {config['fps']} fps, {config['resolution']}")
     
     try:
-        # Clear H200 memory
+        # Clear H200 memory first
         if HAS_CUDA:
             torch.cuda.empty_cache()
             torch.cuda.synchronize()
         gc.collect()
         
-        # Import specific pipeline
+        log_loading(f"  �� Memory cleared")
+        
+        # Import appropriate pipeline
         if config["pipeline_class"] == "CogVideoXPipeline":
-            from diffusers import CogVideoXPipeline
-            PipelineClass = CogVideoXPipeline
-            log_loading(f"  📥 Using CogVideoXPipeline...")
+            try:
+                from diffusers import CogVideoXPipeline
+                PipelineClass = CogVideoXPipeline
+                log_loading(f"  📥 Using CogVideoXPipeline")
+            except ImportError as e:
+                log_loading(f"  ❌ CogVideoXPipeline import failed: {e}")
+                return False
         else:
-            from diffusers import DiffusionPipeline  
+            from diffusers import DiffusionPipeline
             PipelineClass = DiffusionPipeline
-            log_loading(f"  📥 Using DiffusionPipeline...")
+            log_loading(f"  📥 Using DiffusionPipeline")
+        
+        # Load model with minimal parameters
+        log_loading(f"  🔄 Downloading/Loading {model_name}...")
+        start_load = time.time()
         
-        # Load with premium settings
-        log_loading(f"  🔄 Downloading/Loading model...")
         pipe = PipelineClass.from_pretrained(
             model_id,
             torch_dtype=config["dtype"],
-            trust_remote_code=True,
-            # No variant, no use_safetensors restrictions
+            trust_remote_code=True
         )
         
-        # Move to H200 and optimize
+        load_time = time.time() - start_load
+        log_loading(f"  ✅ Model loaded in {load_time:.1f}s")
+        
+        # Move to H200 GPU
         if HAS_CUDA:
             log_loading(f"  📱 Moving to H200 CUDA...")
             pipe = pipe.to("cuda")
-            
-            # Premium optimizations for H200's 69.5GB
-            if hasattr(pipe, 'enable_vae_slicing'):
-                pipe.enable_vae_slicing()
-                log_loading(f"  ⚡ VAE slicing enabled")
-            
-            if hasattr(pipe, 'enable_vae_tiling'):
-                pipe.enable_vae_tiling() 
-                log_loading(f"  ⚡ VAE tiling enabled")
-            
-            if hasattr(pipe, 'enable_memory_efficient_attention'):
-                pipe.enable_memory_efficient_attention()
-                log_loading(f"  ⚡ Memory efficient attention enabled")
-                
-            # For H200's large memory, keep everything in GPU
-            log_loading(f"  🚀 Keeping full model in H200 GPU memory")
+            torch.cuda.synchronize()
+            log_loading(f"  ✅ Model on H200 GPU")
         
-        # Memory check after loading
-        total_mem, allocated_mem, reserved_mem = get_h200_memory()
-        log_loading(f"  💾 Post-load: {allocated_mem:.1f}GB allocated, {reserved_mem:.1f}GB reserved")
+        # H200 optimizations
+        if hasattr(pipe, 'enable_vae_slicing'):
+            pipe.enable_vae_slicing()
+            log_loading(f"  ⚡ VAE slicing enabled")
         
-        # Validate model capabilities
-        expected_frames = config["max_frames"]
-        expected_fps = config["fps"]
-        log_loading(f"  ✅ {model_name} ready: {expected_frames} max frames @ {expected_fps} fps")
+        if hasattr(pipe, 'enable_vae_tiling'):
+            pipe.enable_vae_tiling()
+            log_loading(f"  ⚡ VAE tiling enabled")
+        
+        if hasattr(pipe, 'enable_memory_efficient_attention'):
+            pipe.enable_memory_efficient_attention()
+            log_loading(f"  ⚡ Memory efficient attention enabled")
+        
+        # Memory check after setup
+        total_mem, allocated_mem = get_h200_memory()
+        log_loading(f"  💾 Final memory: {allocated_mem:.1f}GB / {total_mem:.1f}GB")
         
         MODEL = pipe
         MODEL_INFO = config
         
-        log_loading(f"🎯 SUCCESS: {model_name} loaded for premium generation!")
+        log_loading(f"🎯 SUCCESS: {model_name} ready for generation!")
+        log_loading(f"📊 Capabilities: {config['max_frames']} frames @ {config['fps']} fps = {config['max_frames']/config['fps']:.1f}s videos")
+        
         return True
         
     except Exception as e:
         log_loading(f"❌ {model_name} failed: {str(e)}")
-        # Clear memory thoroughly
+        # Thorough cleanup
         if HAS_CUDA:
             torch.cuda.empty_cache()
             torch.cuda.synchronize()
@@ -193,77 +199,63 @@ def try_load_premium_model(config):
         return False
 
 @spaces.GPU(duration=300) if SPACES_AVAILABLE else lambda x: x
-def generate_premium_video(
+def generate_video(
     prompt: str,
     negative_prompt: str = "",
     num_frames: int = 49,
-    resolution: str = "720x480",
     num_inference_steps: int = 50,
     guidance_scale: float = 6.0,
     seed: int = -1
 ) -> Tuple[Optional[str], str]:
-    """Generate premium quality video with proper parameters"""
+    """Generate video with working model"""
     
     global MODEL, MODEL_INFO
     
-    # Load premium model
-    if not load_premium_model():
-        logs = "\n".join(LOADING_LOGS[-5:])
-        return None, f"❌ No premium models available\n\nLogs:\n{logs}"
+    # Load working model
+    if not load_working_model():
+        logs = "\n".join(LOADING_LOGS[-10:])
+        return None, f"❌ No working models could be loaded\n\nDetailed Logs:\n{logs}"
     
     # Input validation
     if not prompt.strip():
-        return None, "❌ Please enter a detailed prompt for premium generation."
-    
-    if len(prompt) < 10:
-        return None, "❌ Please provide a more detailed prompt (minimum 10 characters)."
+        return None, "❌ Please enter a detailed prompt."
     
-    # Parse resolution
-    try:
-        width, height = map(int, resolution.split('x'))
-    except:
-        width, height = MODEL_INFO["resolution_options"][0]
-    
-    # Validate resolution
-    if (width, height) not in MODEL_INFO["resolution_options"]:
-        width, height = MODEL_INFO["resolution_options"][0]
-        log_loading(f"⚠️ Resolution adjusted to {width}x{height}")
+    if len(prompt) < 5:
+        return None, "❌ Please provide a more descriptive prompt."
     
-    # Validate frames
+    # Get model specifications
     max_frames = MODEL_INFO["max_frames"]
-    num_frames = min(max(num_frames, 16), max_frames)  # Minimum 16 for quality
+    width, height = MODEL_INFO["resolution"]
+    target_fps = MODEL_INFO["fps"]
+    
+    # Validate and adjust parameters
+    num_frames = min(max(num_frames, 8), max_frames)
     
-    # Model-specific parameter optimization
+    # Model-specific optimizations
     if MODEL_INFO["name"].startswith("CogVideoX"):
-        # CogVideoX optimal parameters
-        guidance_scale = max(6.0, min(guidance_scale, 7.0))  # CogVideoX sweet spot
-        num_inference_steps = max(50, num_inference_steps)  # Higher steps for quality
-    elif MODEL_INFO["name"] == "LTX-Video":
-        # LTX-Video optimal parameters  
-        guidance_scale = max(7.0, min(guidance_scale, 8.5))  # LTX sweet spot
-        num_inference_steps = max(30, num_inference_steps)
+        # CogVideoX optimal settings
+        guidance_scale = max(6.0, min(guidance_scale, 7.0))
+        num_inference_steps = max(50, num_inference_steps)
     
     try:
         # H200 memory preparation
         start_memory = torch.cuda.memory_allocated(0) / (1024**3) if HAS_CUDA else 0
         
-        # Enhanced seed handling
+        # Seed handling
         if seed == -1:
             seed = np.random.randint(0, 2**32 - 1)
         
         device = "cuda" if HAS_CUDA else "cpu"
         generator = torch.Generator(device=device).manual_seed(seed)
         
-        log_loading(f"🎬 PREMIUM GENERATION START")
-        log_loading(f"📋 Model: {MODEL_INFO['name']}")
-        log_loading(f"📐 Resolution: {width}x{height}")
-        log_loading(f"🎞️ Frames: {num_frames} @ {MODEL_INFO['fps']} fps = {num_frames/MODEL_INFO['fps']:.1f}s video")
-        log_loading(f"⚙️ Steps: {num_inference_steps}, Guidance: {guidance_scale}")
-        log_loading(f"📝 Prompt: {prompt[:100]}...")
+        log_loading(f"🎬 GENERATION START - {MODEL_INFO['name']}")
+        log_loading(f"📝 Prompt: {prompt[:80]}...")
+        log_loading(f"📐 Settings: {width}x{height}, {num_frames} frames, {num_inference_steps} steps")
+        log_loading(f"🎯 Expected duration: {num_frames/target_fps:.1f} seconds @ {target_fps} fps")
         
         start_time = time.time()
         
-        # Premium generation with optimal autocast
+        # Generate with proper autocast
         with torch.autocast(device, dtype=MODEL_INFO["dtype"], enabled=HAS_CUDA):
             
             # Prepare generation parameters
@@ -277,70 +269,69 @@ def generate_premium_video(
                 "generator": generator,
             }
             
-            # Add negative prompt for quality
+            # Enhanced negative prompt for quality
             if negative_prompt.strip():
                 gen_kwargs["negative_prompt"] = negative_prompt
             else:
-                # Default negative prompt for premium quality
-                default_negative = "blurry, low quality, distorted, pixelated, compression artifacts, watermark, text, signature, amateur, static, boring"
-                gen_kwargs["negative_prompt"] = default_negative
-                log_loading(f"🚫 Using default negative prompt for quality")
+                # Default quality negative prompt
+                quality_negative = "blurry, low quality, distorted, pixelated, compression artifacts, static, boring, amateur, watermark, text"
+                gen_kwargs["negative_prompt"] = quality_negative
+                log_loading(f"🚫 Applied quality negative prompt")
             
-            # Model-specific parameters
+            # CogVideoX specific parameters
             if MODEL_INFO["name"].startswith("CogVideoX"):
                 gen_kwargs["num_videos_per_prompt"] = 1
                 log_loading(f"🎥 CogVideoX generation starting...")
             
-            # Generate with progress
+            # Generate
             log_loading(f"🚀 H200 generation in progress...")
             result = MODEL(**gen_kwargs)
         
         end_time = time.time()
         generation_time = end_time - start_time
         
-        # Extract video frames
+        # Extract frames
         if hasattr(result, 'frames'):
             video_frames = result.frames[0]
             log_loading(f"📹 Extracted {len(video_frames)} frames")
         elif hasattr(result, 'videos'):
             video_frames = result.videos[0]
-            log_loading(f"📹 Extracted video tensor: {video_frames.shape}")
+            log_loading(f"📹 Extracted video tensor")
         else:
-            log_loading(f"❌ Unknown result format: {type(result)}")
-            return None, "❌ Could not extract video frames from result"
+            log_loading(f"❌ Unknown result format")
+            return None, "❌ Could not extract video frames"
         
-        # Export with proper FPS
-        target_fps = MODEL_INFO["fps"]
+        # Export with correct FPS
         actual_duration = num_frames / target_fps
         
         with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmp_file:
             from diffusers.utils import export_to_video
             export_to_video(video_frames, tmp_file.name, fps=target_fps)
             video_path = tmp_file.name
-            log_loading(f"🎬 Exported to {tmp_file.name} @ {target_fps} fps")
+            log_loading(f"🎬 Exported: {actual_duration:.1f}s video @ {target_fps} fps")
         
-        # Memory stats
+        # Memory usage
         end_memory = torch.cuda.memory_allocated(0) / (1024**3) if HAS_CUDA else 0
         memory_used = end_memory - start_memory
         
         # Success report
-        success_msg = f"""🎯 **PREMIUM H200 VIDEO GENERATED**
+        success_msg = f"""🎯 **H200 VIDEO GENERATED SUCCESSFULLY**
 
-🤖 **Model:** {MODEL_INFO['name']} 
+🤖 **Model:** {MODEL_INFO['name']}
 📝 **Prompt:** {prompt}
 🎬 **Video:** {num_frames} frames @ {target_fps} fps = **{actual_duration:.1f} seconds**
 📐 **Resolution:** {width}x{height}
 ⚙️ **Quality:** {num_inference_steps} inference steps
 🎯 **Guidance:** {guidance_scale}
 🎲 **Seed:** {seed}
-⏱️ **Generation Time:** {generation_time:.1f}s ({generation_time/60:.1f} minutes)
+⏱️ **Generation Time:** {generation_time:.1f}s ({generation_time/60:.1f} min)
 🖥️ **Device:** H200 MIG (69.5GB)
 💾 **Memory Used:** {memory_used:.1f}GB
-📋 **Model Notes:** {MODEL_INFO['description']}
+📋 **Model:** {MODEL_INFO['description']}
 
-**🎥 Video Quality:** Premium quality with {num_frames} frames over {actual_duration:.1f} seconds"""
+**🎥 Result:** {actual_duration:.1f} second high-quality video!**"""
         
-        log_loading(f"✅ PREMIUM generation completed: {actual_duration:.1f}s video in {generation_time:.1f}s")
+        log_loading(f"✅ SUCCESS: {actual_duration:.1f}s video generated in {generation_time:.1f}s")
         
         return video_path, success_msg
         
@@ -348,7 +339,7 @@ def generate_premium_video(
         if HAS_CUDA:
             torch.cuda.empty_cache()
         gc.collect()
-        return None, "❌ H200 memory exceeded. Try reducing frames or resolution."
+        return None, "❌ H200 memory exceeded. Try reducing frames or steps."
     
     except Exception as e:
         if HAS_CUDA:
@@ -356,238 +347,227 @@ def generate_premium_video(
         gc.collect()
         error_msg = str(e)
         log_loading(f"❌ Generation error: {error_msg}")
-        return None, f"❌ Premium generation failed: {error_msg}"
+        return None, f"❌ Generation failed: {error_msg}"
 
 def get_model_status():
-    """Get current premium model status"""
+    """Get current model status"""
     if MODEL is None:
-        return "⏳ **No premium model loaded** - will auto-load on generation"
+        return "⏳ **No model loaded** - will auto-load CogVideoX on first generation"
     
-    fps = MODEL_INFO["fps"]
-    max_frames = MODEL_INFO["max_frames"]
+    name = MODEL_INFO['name']
+    max_frames = MODEL_INFO['max_frames']
+    fps = MODEL_INFO['fps']
+    width, height = MODEL_INFO['resolution']
     max_duration = max_frames / fps
-    resolutions = ", ".join([f"{w}x{h}" for w, h in MODEL_INFO["resolution_options"]])
     
-    return f"""🎯 **{MODEL_INFO['name']} Ready**
+    return f"""🎯 **{name} READY**
 
-**📋 Premium Capabilities:**
-- **Max Duration:** {max_duration:.1f} seconds ({max_frames} frames @ {fps} fps)
-- **Resolutions:** {resolutions}
-- **Quality:** {MODEL_INFO['description']}
+**📊 Video Capabilities:**
+- **Maximum Duration:** {max_duration:.1f} seconds ({max_frames} frames @ {fps} fps)
+- **Resolution:** {width}x{height}
+- **Quality Level:** {MODEL_INFO['description']}
 
-**⚡ H200 Optimizations:**
-- Full model in GPU memory
-- Memory efficient attention
-- VAE optimizations enabled
+**⚡ H200 Status:**
+- Model fully loaded in GPU memory
+- All optimizations enabled
+- Ready for {max_duration:.1f} second video generation
 
-**💡 This model produces {max_duration:.1f} second videos with {max_frames} frames!**"""
+**💡 This model creates {max_duration:.1f} second videos with {max_frames} frames!**"""
 
 def get_loading_logs():
     """Get formatted loading logs"""
     global LOADING_LOGS
     if not LOADING_LOGS:
-        return "No loading attempts yet."
+        return "No loading logs yet. Click generate to start loading."
     return "\n".join(LOADING_LOGS)
 
-def suggest_premium_settings():
-    """Suggest optimal settings for current model"""
+def suggest_optimal_settings():
+    """Suggest optimal settings for loaded model"""
     if MODEL is None:
-        return "Load a premium model first."
+        return "No model loaded yet. Generate a video to auto-load CogVideoX."
     
-    model_name = MODEL_INFO['name']
+    name = MODEL_INFO['name']
     max_frames = MODEL_INFO['max_frames']
     fps = MODEL_INFO['fps']
     max_duration = max_frames / fps
     
-    return f"""## 🎯 Optimal Settings for {model_name}
+    return f"""## 🎯 Optimal Settings for {name}
 
-**🚀 Maximum Quality:**
+**🏆 Maximum Quality (Recommended):**
 - Frames: {max_frames} (full {max_duration:.1f} second video)
-- Inference Steps: 50+
-- Guidance Scale: {6.0 if 'CogVideo' in model_name else 7.5}
-- Resolution: {MODEL_INFO['resolution_options'][-1]}
+- Inference Steps: 50-70
+- Guidance Scale: 6.0-6.5
+- Expected Time: 3-5 minutes
 
-**⚖️ Balanced (Recommended):**
-- Frames: {max_frames//2} ({max_frames//2/fps:.1f} second video)
-- Inference Steps: 35-50
-- Guidance Scale: {6.0 if 'CogVideo' in model_name else 7.5}
+**⚖️ Balanced Quality:**
+- Frames: {max_frames//2} ({max_frames//2/fps:.1f} second video)  
+- Inference Steps: 40-50
+- Guidance Scale: 6.0
+- Expected Time: 2-3 minutes
 
-**⚡ Fast Test:**
+**⚡ Quick Test:**
 - Frames: 25 ({25/fps:.1f} second video)
-- Inference Steps: 30
-- Guidance Scale: {6.0 if 'CogVideo' in model_name else 7.5}
+- Inference Steps: 30-40
+- Guidance Scale: 6.0
+- Expected Time: 1-2 minutes
 
-**📝 Premium Prompting Tips:**
+**📝 {name} Prompt Tips:**
 - Be very specific and detailed
-- Include camera movements: "slow zoom", "tracking shot"
-- Describe lighting: "golden hour", "cinematic lighting"
-- Add style: "professional cinematography", "8K quality"
-- Mention motion: "smooth movement", "graceful motion"
+- Describe camera movements: "slow zoom in", "tracking shot", "aerial view"
+- Include lighting: "golden hour", "soft lighting", "dramatic shadows"
+- Add motion description: "smooth movement", "graceful motion", "flowing"
+- Specify style: "cinematic", "professional", "documentary style"
 
-**Example Premium Prompt:**
-"A majestic golden eagle soaring gracefully through misty mountain peaks during golden hour, cinematic tracking shot with shallow depth of field, professional wildlife cinematography, smooth gliding motion, warm sunset lighting, 8K quality"
+**🏆 Example Premium Prompt:**
+"A majestic eagle soaring gracefully through mountain valleys during golden hour, cinematic aerial tracking shot following the bird's smooth flight path, professional wildlife documentary style with warm sunset lighting, breathtaking landscape vista below"
 
-Remember: Longer videos need more detailed prompts to maintain coherence!"""
+Remember: {name} excels at smooth, natural motion and cinematic quality!"""
 
-# Create premium interface
-with gr.Blocks(title="H200 Premium Video Generator", theme=gr.themes.Glass()) as demo:
+# Create working interface
+with gr.Blocks(title="H200 CogVideoX Generator", theme=gr.themes.Soft()) as demo:
     
     gr.Markdown("""
-    # 🎯 H200 Premium Video Generator
-    
-    **Premium Models Only** • **Long-Form Videos** • **Professional Quality**
+    # 🎯 H200 CogVideoX Video Generator
     
-    *CogVideoX-5B • LTX-Video • No Low-Quality Fallbacks*
+    **CogVideoX-2B/5B Priority** • **6+ Second Videos** • **H200 MIG Optimized**
     """)
     
-    # Premium status
+    # Status indicator
     with gr.Row():
         gr.Markdown("""
-        <div style="background: linear-gradient(45deg, #FFD700, #FF6B6B); padding: 15px; border-radius: 15px; text-align: center; color: white; font-weight: bold; font-size: 18px;">
-        🏆 PREMIUM MODE - H200 MIG 69.5GB - QUALITY PRIORITY 🏆
+        <div style="background: linear-gradient(45deg, #4ECDC4, #44A08D); padding: 12px; border-radius: 12px; text-align: center; color: white; font-weight: bold;">
+        🚀 H200 MIG 69.5GB - COGVIDEOX READY - 6+ SECOND VIDEOS 🚀
         </div>
         """)
     
-    with gr.Tab("🎬 Premium Generation"):
+    with gr.Tab("🎬 Generate Video"):
         with gr.Row():
             with gr.Column(scale=1):
                 prompt_input = gr.Textbox(
-                    label="📝 Detailed Video Prompt (Premium Quality)",
-                    placeholder="A breathtaking aerial view of a majestic golden eagle soaring gracefully through dramatic mountain peaks shrouded in morning mist, cinematic wildlife documentary style with slow motion tracking shot, professional cinematography with warm golden hour lighting and shallow depth of field, smooth gliding motion across epic landscape, 8K quality with film grain texture...",
-                    lines=5,
-                    max_lines=8
+                    label="📝 Detailed Video Prompt",
+                    placeholder="A majestic eagle soaring gracefully through mountain valleys during golden hour, cinematic aerial tracking shot following the bird's smooth flight path, professional wildlife documentary style with warm sunset lighting, breathtaking landscape vista below...",
+                    lines=4
                 )
                 
                 negative_prompt_input = gr.Textbox(
-                    label="🚫 Negative Prompt (Optional - auto-applied for quality)",
-                    placeholder="blurry, low quality, distorted, pixelated, compression artifacts, watermark, text, signature, amateur, static, boring, jerky motion...",
+                    label="🚫 Negative Prompt (Optional)",
+                    placeholder="blurry, low quality, distorted, pixelated, static, boring, amateur...",
                     lines=2
                 )
                 
-                with gr.Accordion("🎯 Premium Settings", open=True):
+                with gr.Accordion("⚙️ Generation Settings", open=True):
                     with gr.Row():
                         num_frames = gr.Slider(
-                            minimum=16,
+                            minimum=8,
                             maximum=49,
                             value=49,
                             step=1,
-                            label="🎬 Video Frames (16 = 2s, 49 = 6s+)"
+                            label="🎬 Frames (49 = 6+ seconds)"
                         )
                         
-                        resolution = gr.Dropdown(
-                            choices=["720x480", "480x720"],
-                            value="720x480",
-                            label="📐 Resolution"
-                        )
-                    
-                    with gr.Row():
                         num_steps = gr.Slider(
                             minimum=30,
-                            maximum=100,
+                            maximum=70,
                             value=50,
                             step=5,
-                            label="⚙️ Inference Steps (50+ for premium quality)"
+                            label="⚙️ Inference Steps"
                         )
-                        
+                    
+                    with gr.Row():
                         guidance_scale = gr.Slider(
                             minimum=4.0,
-                            maximum=10.0,
+                            maximum=8.0,
                             value=6.0,
                             step=0.5,
                             label="🎯 Guidance Scale"
                         )
-                    
-                    seed = gr.Number(
-                        label="🎲 Seed (-1 for random)",
-                        value=-1,
-                        precision=0
-                    )
+                        
+                        seed = gr.Number(
+                            label="🎲 Seed (-1 for random)",
+                            value=-1,
+                            precision=0
+                        )
                 
                 generate_btn = gr.Button(
-                    "🎯 Generate Premium Video", 
+                    "🎯 Generate 6+ Second Video", 
                     variant="primary", 
                     size="lg"
                 )
                 
                 gr.Markdown("""
-                **⏱️ Premium Generation:** 2-5 minutes for quality
-                
-                **🎥 Output:** 2-6+ second high-quality videos
-                
-                **💡 Premium Tips:**
-                - Use very detailed, specific prompts
-                - Higher inference steps = better quality
-                - Longer videos need more descriptive prompts
+                **⏱️ Generation Time:** 2-5 minutes
+                **🎥 Output:** 6+ second high-quality videos  
+                **🤖 Model:** CogVideoX auto-loads first time
                 """)
                 
             with gr.Column(scale=1):
                 video_output = gr.Video(
-                    label="🎥 Premium H200 Generated Video",
+                    label="🎥 H200 Generated Video",
                     height=400
                 )
                 
                 result_text = gr.Textbox(
-                    label="📋 Premium Generation Report",
-                    lines=12,
+                    label="📋 Generation Report",
+                    lines=10,
                     show_copy_button=True
                 )
         
         # Generate button
         generate_btn.click(
-            fn=generate_premium_video,
+            fn=generate_video,
             inputs=[
                 prompt_input, negative_prompt_input, num_frames,
-                resolution, num_steps, guidance_scale, seed
+                num_steps, guidance_scale, seed
             ],
             outputs=[video_output, result_text]
         )
         
-        # Premium examples
+        # Working examples
         gr.Examples(
             examples=[
                 [
-                    "A majestic golden eagle soaring gracefully through misty mountain peaks during golden hour, cinematic wildlife documentary style with slow motion tracking shot, professional cinematography with warm lighting and shallow depth of field, smooth gliding motion, 8K quality",
-                    "blurry, low quality, static, amateur, pixelated",
-                    49, "720x480", 50, 6.0, 42
+                    "A majestic eagle soaring gracefully through mountain valleys during golden hour, cinematic aerial tracking shot, professional wildlife documentary style",
+                    "blurry, low quality, static, amateur",
+                    49, 50, 6.0, 42
                 ],
                 [
-                    "Ocean waves crashing against dramatic coastal cliffs during a storm, professional seascape cinematography with dynamic camera movement, slow motion water spray and foam, dramatic lighting with storm clouds, high contrast and deep blues, cinematic quality",
-                    "calm, peaceful, low quality, static, boring",
-                    41, "720x480", 60, 6.5, 123
+                    "Ocean waves crashing against rocky coastline during sunset, slow motion cinematography with dramatic lighting and foam spray",
+                    "calm, peaceful, low quality, boring",
+                    41, 50, 6.5, 123
                 ],
                 [
-                    "A steaming artisanal coffee cup on rustic wooden table by rain-streaked window, cozy cafe atmosphere with warm ambient lighting, shallow depth of field with bokeh background, steam rising elegantly, professional commercial cinematography, intimate close-up shot",
-                    "cold, harsh lighting, plastic, fake, low quality, distorted",
-                    33, "720x480", 45, 6.0, 456
+                    "A serene mountain lake reflecting autumn trees, gentle camera pan across the water surface, peaceful nature documentary style",
+                    "urban, modern, low quality, distorted",
+                    33, 45, 6.0, 456
                 ],
                 [
-                    "Time-lapse of cherry blossom petals falling like snow in traditional Japanese garden with wooden bridge over koi pond, peaceful zen atmosphere with soft natural lighting, seasonal transition captured in cinematic wide shot, perfect composition and color grading",
-                    "modern, urban, chaotic, low quality, static, artificial",
-                    49, "720x480", 55, 6.5, 789
+                    "Steam rising from a hot coffee cup on wooden table by window during rain, cozy atmosphere with warm lighting, intimate close-up shot",
+                    "cold, harsh, artificial, low quality",
+                    25, 40, 6.0, 789
                 ]
             ],
-            inputs=[prompt_input, negative_prompt_input, num_frames, resolution, num_steps, guidance_scale, seed]
+            inputs=[prompt_input, negative_prompt_input, num_frames, num_steps, guidance_scale, seed]
         )
     
-    with gr.Tab("🎯 Premium Status"):
+    with gr.Tab("📊 Model Status"):
         with gr.Row():
-            status_btn = gr.Button("🔍 Model Status", variant="secondary")
-            logs_btn = gr.Button("📋 Loading Logs", variant="secondary")
-            settings_btn = gr.Button("⚙️ Optimal Settings", variant="secondary")
+            status_btn = gr.Button("🔍 Check Model Status")
+            logs_btn = gr.Button("📋 View Loading Logs")
+            settings_btn = gr.Button("⚙️ Optimal Settings")
         
         status_output = gr.Markdown()
-        logs_output = gr.Textbox(label="Detailed Logs", lines=12, show_copy_button=True)
+        logs_output = gr.Textbox(label="Loading Logs", lines=15, show_copy_button=True)
         settings_output = gr.Markdown()
         
         status_btn.click(fn=get_model_status, outputs=status_output)
         logs_btn.click(fn=get_loading_logs, outputs=logs_output)
-        settings_btn.click(fn=suggest_premium_settings, outputs=settings_output)
+        settings_btn.click(fn=suggest_optimal_settings, outputs=settings_output)
         
         # Auto-load status
         demo.load(fn=get_model_status, outputs=status_output)
 
 if __name__ == "__main__":
-    demo.queue(max_size=2)  # Premium quality needs smaller queue
+    demo.queue(max_size=3)
     demo.launch(
         share=False,
         server_name="0.0.0.0",