Update app.py

app.py

@@ -11,525 +11,444 @@ from PIL import Image
 import random
 import logging
 import gc
-import time
-import hashlib
-from dataclasses import dataclass
-from typing import Optional, Tuple
-from functools import wraps
-import threading
-import os
-
-# GPU 메모리 관리 설정
-os.environ['PYTORCH_CUDA_ALLOC_CONF'] = 'max_split_size_mb:256'  # 더 작은 청크 사용
 
 # 로깅 설정
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# 설정 관리
-@dataclass
-class VideoGenerationConfig:
-    model_id: str = "Wan-AI/Wan2.1-I2V-14B-480P-Diffusers"
-    lora_repo_id: str = "Kijai/WanVideo_comfy"
-    lora_filename: str = "Wan21_CausVid_14B_T2V_lora_rank32.safetensors"
-    mod_value: int = 32
-    # Zero GPU를 위한 매우 보수적인 기본값
-    default_height: int = 320
-    default_width: int = 320
-    max_area: float = 320.0 * 320.0  # Zero GPU에 최적화
-    slider_min_h: int = 128
-    slider_max_h: int = 512  # 더 낮은 최대값
-    slider_min_w: int = 128
-    slider_max_w: int = 512  # 더 낮은 최대값
-    fixed_fps: int = 24
-    min_frames: int = 8
-    max_frames: int = 30  # 더 낮은 최대 프레임 (1.25초)
-    default_prompt: str = "make this image move, smooth motion"
-    default_negative_prompt: str = "static, blur"
-    # GPU 메모리 최적화 설정
-    enable_model_cpu_offload: bool = True
-    enable_vae_slicing: bool = True
-    enable_vae_tiling: bool = True
-    
-    @property
-    def max_duration(self):
-        """최대 허용 duration (초)"""
-        return self.max_frames / self.fixed_fps
-    
-    @property
-    def min_duration(self):
-        """최소 허용 duration (초)"""
-        return self.min_frames / self.fixed_fps
+# 모델 설정
+MODEL_ID = "Wan-AI/Wan2.1-I2V-14B-480P-Diffusers"
+LORA_REPO_ID = "Kijai/WanVideo_comfy"
+LORA_FILENAME = "Wan21_CausVid_14B_T2V_lora_rank32.safetensors"
+
+# 파라미터 설정
+MOD_VALUE = 32
+DEFAULT_H_SLIDER_VALUE = 512
+DEFAULT_W_SLIDER_VALUE = 512  # Zero GPU를 위해 정사각형 기본값
+NEW_FORMULA_MAX_AREA = 480.0 * 832.0 
 
-config = VideoGenerationConfig()
+SLIDER_MIN_H, SLIDER_MAX_H = 128, 896
+SLIDER_MIN_W, SLIDER_MAX_W = 128, 896
 MAX_SEED = np.iinfo(np.int32).max
 
-# 글로벌 변수
-pipe = None
-generation_lock = threading.Lock()
-
-# 성능 측정 데코레이터
-def measure_time(func):
-    @wraps(func)
-    def wrapper(*args, **kwargs):
-        start = time.time()
-        result = func(*args, **kwargs)
-        logger.info(f"{func.__name__} took {time.time()-start:.2f}s")
-        return result
-    return wrapper
-
-# GPU 메모리 정리 함수
-def clear_gpu_memory():
-    """메모리 정리 (Zero GPU 안전)"""
-    gc.collect()
-    if torch.cuda.is_available():
-        try:
-            torch.cuda.empty_cache()
-            torch.cuda.synchronize()
-        except:
-            pass
-
-# 비디오 생성기 클래스
-class VideoGenerator:
-    def __init__(self, config: VideoGenerationConfig):
-        self.config = config
+FIXED_FPS = 24
+MIN_FRAMES_MODEL = 8
+MAX_FRAMES_MODEL = 81 
+
+default_prompt_i2v = "make this image come alive, cinematic motion, smooth animation"
+default_negative_prompt = "static, blurred, low quality, watermark, text"
+
+# 모델 글로벌 로딩
+logger.info("Loading model components...")
+image_encoder = CLIPVisionModel.from_pretrained(MODEL_ID, subfolder="image_encoder", torch_dtype=torch.float32)
+vae = AutoencoderKLWan.from_pretrained(MODEL_ID, subfolder="vae", torch_dtype=torch.float32)
+pipe = WanImageToVideoPipeline.from_pretrained(
+    MODEL_ID, vae=vae, image_encoder=image_encoder, torch_dtype=torch.bfloat16
+)
+pipe.scheduler = UniPCMultistepScheduler.from_config(pipe.scheduler.config, flow_shift=8.0)
+pipe.to("cuda")
+
+# LoRA 로딩
+try:
+    causvid_path = hf_hub_download(repo_id=LORA_REPO_ID, filename=LORA_FILENAME)
+    pipe.load_lora_weights(causvid_path, adapter_name="causvid_lora")
+    pipe.set_adapters(["causvid_lora"], adapter_weights=[0.95])
+    pipe.fuse_lora()
+    logger.info("LoRA loaded successfully")
+except Exception as e:
+    logger.warning(f"LoRA loading failed: {e}")
+
+# 메모리 최적화 활성화
+pipe.enable_vae_slicing()
+pipe.enable_vae_tiling()
+pipe.enable_model_cpu_offload()
+
+logger.info("Model loaded and ready")
+
+def _calculate_new_dimensions_wan(pil_image, mod_val, calculation_max_area,
+                                 min_slider_h, max_slider_h,
+                                 min_slider_w, max_slider_w,
+                                 default_h, default_w):
+    orig_w, orig_h = pil_image.size
+    if orig_w <= 0 or orig_h <= 0:
+        return default_h, default_w
+
+    aspect_ratio = orig_h / orig_w
     
-    def calculate_dimensions(self, image: Image.Image) -> Tuple[int, int]:
-        orig_w, orig_h = image.size
-        if orig_w <= 0 or orig_h <= 0:
-            return self.config.default_height, self.config.default_width
-        
-        aspect_ratio = orig_h / orig_w
-        
-        # Zero GPU에 최적화된 매우 작은 해상도
-        max_area = 320.0 * 320.0  # 102,400 픽셀
-        
-        # 종횡비가 너무 극단적인 경우 조정
-        if aspect_ratio > 2.0:
-            aspect_ratio = 2.0
-        elif aspect_ratio < 0.5:
-            aspect_ratio = 0.5
-        
-        calc_h = round(np.sqrt(max_area * aspect_ratio))
-        calc_w = round(np.sqrt(max_area / aspect_ratio))
-        
-        # mod_value에 맞춤
-        calc_h = max(self.config.mod_value, (calc_h // self.config.mod_value) * self.config.mod_value)
-        calc_w = max(self.config.mod_value, (calc_w // self.config.mod_value) * self.config.mod_value)
-        
-        # 최대 512로 제한
-        new_h = int(np.clip(calc_h, self.config.slider_min_h, 512))
-        new_w = int(np.clip(calc_w, self.config.slider_min_w, 512))
-        
-        # mod_value에 맞춤
-        new_h = (new_h // self.config.mod_value) * self.config.mod_value
-        new_w = (new_w // self.config.mod_value) * self.config.mod_value
-        
-        # 최종 픽셀 수 확인
-        if new_h * new_w > 102400:  # 320x320
-            # 비율을 유지하면서 축소
-            scale = np.sqrt(102400 / (new_h * new_w))
-            new_h = int((new_h * scale) // self.config.mod_value) * self.config.mod_value
-            new_w = int((new_w * scale) // self.config.mod_value) * self.config.mod_value
-        
-        return new_h, new_w
+    # Zero GPU를 위한 보수적인 계산
+    if hasattr(spaces, 'GPU'):
+        # 더 작은 max_area 사용
+        calculation_max_area = min(calculation_max_area, 320.0 * 320.0)
     
-    def validate_inputs(self, image: Image.Image, prompt: str, height: int, 
-                       width: int, duration: float, steps: int) -> Tuple[bool, Optional[str]]:
-        if image is None:
-            return False, "🖼️ Please upload an input image"
-        
-        if not prompt or len(prompt.strip()) == 0:
-            return False, "✍️ Please provide a prompt"
-        
-        if len(prompt) > 200:  # 더 짧은 프롬프트 제한
-            return False, "⚠️ Prompt is too long (max 200 characters)"
-        
-        # Zero GPU에 최적화된 제한
-        if duration < 0.3:
-            return False, "⏱️ Duration too short (min 0.3s)"
-        
-        if duration > 1.2:  # 더 짧은 최대 duration
-            return False, "⏱️ Duration too long (max 1.2s for stability)"
-        
-        # 픽셀 수 제한 (더 보수적으로)
-        max_pixels = 320 * 320  # 102,400 픽셀
-        if height * width > max_pixels:
-            return False, f"📐 Total pixels limited to {max_pixels:,} (e.g., 320×320, 256×384)"
-        
-        if height > 512 or width > 512:  # 더 낮은 최대값
-            return False, "📐 Maximum dimension is 512 pixels"
-        
-        # 종횡비 체크
-        aspect_ratio = max(height/width, width/height)
-        if aspect_ratio > 2.0:
-            return False, "📐 Aspect ratio too extreme (max 2:1 or 1:2)"
-        
-        if steps > 5:  # 더 낮은 최대 스텝
-            return False, "🔧 Maximum 5 steps in Zero GPU environment"
-        
-        return True, None
+    calc_h = round(np.sqrt(calculation_max_area * aspect_ratio))
+    calc_w = round(np.sqrt(calculation_max_area / aspect_ratio))
+
+    calc_h = max(mod_val, (calc_h // mod_val) * mod_val)
+    calc_w = max(mod_val, (calc_w // mod_val) * mod_val)
+    
+    # Zero GPU 환경에서 추가 제한
+    if hasattr(spaces, 'GPU'):
+        max_slider_h = min(max_slider_h, 640)
+        max_slider_w = min(max_slider_w, 640)
     
-    def generate_unique_filename(self, seed: int) -> str:
-        timestamp = int(time.time())
-        unique_str = f"{timestamp}_{seed}_{random.randint(1000, 9999)}"
-        hash_obj = hashlib.md5(unique_str.encode())
-        return f"video_{hash_obj.hexdigest()[:8]}.mp4"
-
-video_generator = VideoGenerator(config)
-
-# Gradio 함수들
-def handle_image_upload(image):
-    if image is None:
-        return gr.update(value=config.default_height), gr.update(value=config.default_width)
+    new_h = int(np.clip(calc_h, min_slider_h, (max_slider_h // mod_val) * mod_val))
+    new_w = int(np.clip(calc_w, min_slider_w, (max_slider_w // mod_val) * mod_val))
     
+    return new_h, new_w
+
+def handle_image_upload_for_dims_wan(uploaded_pil_image, current_h_val, current_w_val):
+    if uploaded_pil_image is None:
+        return gr.update(value=DEFAULT_H_SLIDER_VALUE), gr.update(value=DEFAULT_W_SLIDER_VALUE)
     try:
-        if not isinstance(image, Image.Image):
-            raise ValueError("Invalid image format")
-        
-        new_h, new_w = video_generator.calculate_dimensions(image)
+        new_h, new_w = _calculate_new_dimensions_wan(
+            uploaded_pil_image, MOD_VALUE, NEW_FORMULA_MAX_AREA,
+            SLIDER_MIN_H, SLIDER_MAX_H, SLIDER_MIN_W, SLIDER_MAX_W,
+            DEFAULT_H_SLIDER_VALUE, DEFAULT_W_SLIDER_VALUE
+        )
         return gr.update(value=new_h), gr.update(value=new_w)
-        
     except Exception as e:
-        logger.error(f"Error processing image: {e}")
-        gr.Warning("⚠️ Error processing image")
-        return gr.update(value=config.default_height), gr.update(value=config.default_width)
-
-def get_duration(input_image, prompt, height, width, negative_prompt, 
-                duration_seconds, guidance_scale, steps, seed, randomize_seed, progress):
-    # Zero GPU 환경에서 매우 보수적인 시간 할당
-    base_duration = 50  # 기본 50초로 증가
-    
-    # 픽셀 수에 따른 추가 시간
-    pixels = height * width
-    if pixels > 147456:  # 384x384 이상
-        base_duration += 20
-    elif pixels > 100000:  # ~316x316 이상
-        base_duration += 10
-    
-    # 스텝 수에 따른 추가 시간
-    if steps > 4:
-        base_duration += 15
-    elif steps > 2:
-        base_duration += 10
-    
-    # 종횡비가 극단적인 경우 추가 시간
-    aspect_ratio = max(height/width, width/height)
-    if aspect_ratio > 1.5:  # 3:2 이상의 비율
-        base_duration += 10
+        gr.Warning("Error attempting to calculate new dimensions")
+        return gr.update(value=DEFAULT_H_SLIDER_VALUE), gr.update(value=DEFAULT_W_SLIDER_VALUE)
+
+def get_duration(input_image, prompt, height, width, 
+                   negative_prompt, duration_seconds,
+                   guidance_scale, steps,
+                   seed, randomize_seed, 
+                   progress):
+    # Zero GPU를 위한 보수적인 시간 할당
+    base_time = 60
     
-    # 최대 90초로 제한
-    return min(base_duration, 90)
+    if hasattr(spaces, 'GPU'):
+        # Zero GPU 환경에서 더 많은 시간 할당
+        if steps > 4 and duration_seconds > 2:
+            return 90
+        elif steps > 4 or duration_seconds > 2:
+            return 80
+        else:
+            return 70
+    else:
+        # 일반 GPU 환경
+        if steps > 4 and duration_seconds > 2:
+            return 90
+        elif steps > 4 or duration_seconds > 2:
+            return 75
+        else:
+            return 60
 
 @spaces.GPU(duration=get_duration)
-@measure_time
 def generate_video(input_image, prompt, height, width, 
-                   negative_prompt=config.default_negative_prompt, 
-                   duration_seconds=0.8, guidance_scale=1, steps=3,
-                   seed=42, randomize_seed=False, 
+                   negative_prompt=default_negative_prompt, duration_seconds = 2,
+                   guidance_scale = 1, steps = 4,
+                   seed = 42, randomize_seed = False, 
                    progress=gr.Progress(track_tqdm=True)):
     
-    global pipe
-    
-    # 동시 실행 방지
-    if not generation_lock.acquire(blocking=False):
-        raise gr.Error("⏳ Another video is being generated. Please wait...")
+    if input_image is None:
+        raise gr.Error("Please upload an input image.")
     
-    try:
-        progress(0.05, desc="🔍 Validating inputs...")
-        logger.info(f"Starting generation - Resolution: {height}x{width}, Duration: {duration_seconds}s, Steps: {steps}")
-        
-        # 입력 검증
-        is_valid, error_msg = video_generator.validate_inputs(
-            input_image, prompt, height, width, duration_seconds, steps
-        )
-        if not is_valid:
-            logger.warning(f"Validation failed: {error_msg}")
-            raise gr.Error(error_msg)
-        
-        # 메모리 정리
-        clear_gpu_memory()
-        
-        progress(0.1, desc="🚀 Loading model...")
-        
-        # 모델 로딩 (GPU 함수 내에서)
-        if pipe is None:
-            try:
-                logger.info("Loading model components...")
-                
-                # 컴포넌트 로드
-                image_encoder = CLIPVisionModel.from_pretrained(
-                    config.model_id, 
-                    subfolder="image_encoder", 
-                    torch_dtype=torch.float16,
-                    low_cpu_mem_usage=True
-                )
-                
-                vae = AutoencoderKLWan.from_pretrained(
-                    config.model_id, 
-                    subfolder="vae", 
-                    torch_dtype=torch.float16,
-                    low_cpu_mem_usage=True
-                )
-                
-                pipe = WanImageToVideoPipeline.from_pretrained(
-                    config.model_id, 
-                    vae=vae, 
-                    image_encoder=image_encoder, 
-                    torch_dtype=torch.bfloat16,
-                    low_cpu_mem_usage=True,
-                    use_safetensors=True
-                )
-                
-                # 스케줄러 설정
-                pipe.scheduler = UniPCMultistepScheduler.from_config(
-                    pipe.scheduler.config, flow_shift=8.0
-                )
-                
-                # LoRA 로드 건너뛰기 (안정성을 위해)
-                logger.info("Skipping LoRA for stability")
-                
-                # GPU로 이동
-                pipe.to("cuda")
-                
-                # 최적화 활성화
-                pipe.enable_vae_slicing()
-                pipe.enable_vae_tiling()
-                
-                # 모델 CPU 오프로드 활성화 (메모리 절약)
-                pipe.enable_model_cpu_offload()
-                
-                logger.info("Model loaded successfully")
-                
-            except Exception as e:
-                logger.error(f"Model loading failed: {e}")
-                raise gr.Error("Failed to load model")
-        
-        progress(0.3, desc="🎯 Preparing image...")
-        
-        # 이미지 준비
-        target_h = max(config.mod_value, (int(height) // config.mod_value) * config.mod_value)
-        target_w = max(config.mod_value, (int(width) // config.mod_value) * config.mod_value)
-        
-        # 프레임 수 계산 (매우 보수적)
-        num_frames = min(
-            int(round(duration_seconds * config.fixed_fps)),
-            24  # 최대 24프레임 (1초)
-        )
-        num_frames = max(8, num_frames)  # 최소 8프레임
-        
-        logger.info(f"Generating {num_frames} frames at {target_h}x{target_w}")
-        
-        current_seed = random.randint(0, MAX_SEED) if randomize_seed else int(seed)
-        
-        # 이미지 리사이즈
-        resized_image = input_image.resize((target_w, target_h), Image.Resampling.LANCZOS)
-        
-        progress(0.4, desc="🎬 Generating video...")
-        
-        # 비디오 생성
-        with torch.inference_mode(), torch.amp.autocast('cuda', enabled=True, dtype=torch.float16):
-            try:
-                # 메모리 효율을 위한 설정
-                torch.cuda.empty_cache()
-                
-                # 생성 파라미터 최적화
-                output_frames_list = pipe(
-                    image=resized_image,
-                    prompt=prompt[:150],  # 프롬프트 길이 제한
-                    negative_prompt=negative_prompt[:50] if negative_prompt else "",
-                    height=target_h,
-                    width=target_w,
-                    num_frames=num_frames,
-                    guidance_scale=float(guidance_scale),
-                    num_inference_steps=int(steps),
-                    generator=torch.Generator(device="cuda").manual_seed(current_seed),
-                    return_dict=True,
-                    # 추가 최적화 파라미터
-                    output_type="pil"
-                ).frames[0]
-                
-                logger.info("Video generation completed successfully")
-                
-            except torch.cuda.OutOfMemoryError:
-                logger.error("GPU OOM error")
-                clear_gpu_memory()
-                raise gr.Error("💾 GPU out of memory. Try smaller dimensions (256x256 recommended).")
-            except RuntimeError as e:
-                if "out of memory" in str(e).lower():
-                    logger.error("Runtime OOM error")
-                    clear_gpu_memory()
-                    raise gr.Error("💾 GPU memory error. Please try again with smaller settings.")
-                else:
-                    logger.error(f"Runtime error: {e}")
-                    raise gr.Error(f"❌ Generation failed: {str(e)[:50]}")
-            except Exception as e:
-                logger.error(f"Generation error: {type(e).__name__}: {e}")
-                raise gr.Error(f"❌ Generation failed. Try reducing resolution or steps.")
-        
-        progress(0.9, desc="💾 Saving video...")
-        
-        # 비디오 저장
-        try:
-            filename = video_generator.generate_unique_filename(current_seed)
-            with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmpfile:
-                video_path = tmpfile.name
-            
-            export_to_video(output_frames_list, video_path, fps=config.fixed_fps)
-            logger.info(f"Video saved: {video_path}")
-        except Exception as e:
-            logger.error(f"Save error: {e}")
-            raise gr.Error("Failed to save video")
+    # Zero GPU 환경에서 추가 검증
+    if hasattr(spaces, 'GPU'):
+        # 픽셀 제한
+        max_pixels = 409600  # 640x640
+        if height * width > max_pixels:
+            raise gr.Error(f"Resolution too high for Zero GPU. Maximum {max_pixels:,} pixels (e.g., 640×640)")
         
-        progress(1.0, desc="✨ Complete!")
-        logger.info(f"Video generated: {num_frames} frames, {target_h}x{target_w}")
+        # Duration 제한
+        if duration_seconds > 2.5:
+            duration_seconds = 2.5
+            gr.Warning("Duration limited to 2.5s in Zero GPU environment")
         
-        # 메모리 정리
-        del output_frames_list
-        del resized_image
-        torch.cuda.empty_cache()
+        # Steps 제한
+        if steps > 8:
+            steps = 8
+            gr.Warning("Steps limited to 8 in Zero GPU environment")
+
+    target_h = max(MOD_VALUE, (int(height) // MOD_VALUE) * MOD_VALUE)
+    target_w = max(MOD_VALUE, (int(width) // MOD_VALUE) * MOD_VALUE)
+    
+    num_frames = np.clip(int(round(duration_seconds * FIXED_FPS)), MIN_FRAMES_MODEL, MAX_FRAMES_MODEL)
+    
+    # Zero GPU에서 프레임 수 추가 제한
+    if hasattr(spaces, 'GPU'):
+        max_frames_zerogpu = int(2.5 * FIXED_FPS)  # 2.5초
+        num_frames = min(num_frames, max_frames_zerogpu)
+    
+    current_seed = random.randint(0, MAX_SEED) if randomize_seed else int(seed)
+
+    logger.info(f"Generating video: {target_h}x{target_w}, {num_frames} frames, seed={current_seed}")
+    
+    # 이미지 리사이즈
+    resized_image = input_image.resize((target_w, target_h), Image.Resampling.LANCZOS)
+
+    try:
+        with torch.inference_mode():
+            output_frames_list = pipe(
+                image=resized_image, 
+                prompt=prompt, 
+                negative_prompt=negative_prompt,
+                height=target_h, 
+                width=target_w, 
+                num_frames=num_frames,
+                guidance_scale=float(guidance_scale), 
+                num_inference_steps=int(steps),
+                generator=torch.Generator(device="cuda").manual_seed(current_seed)
+            ).frames[0]
+    except torch.cuda.OutOfMemoryError:
         gc.collect()
-        
-        return video_path, current_seed
-        
-    except gr.Error:
-        raise
+        torch.cuda.empty_cache()
+        raise gr.Error("GPU out of memory. Try smaller resolution or shorter duration.")
     except Exception as e:
-        logger.error(f"Unexpected error: {type(e).__name__}: {e}")
-        raise gr.Error(f"❌ Unexpected error. Please try again with smaller settings.")
-        
-    finally:
-        generation_lock.release()
-        clear_gpu_memory()
+        logger.error(f"Generation failed: {e}")
+        raise gr.Error(f"Video generation failed: {str(e)[:100]}")
+
+    # 비디오 저장
+    with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmpfile:
+        video_path = tmpfile.name
+    export_to_video(output_frames_list, video_path, fps=FIXED_FPS)
+    
+    # 메모리 정리
+    del output_frames_list
+    gc.collect()
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+    
+    return video_path, current_seed
 
-# CSS
+# CSS 스타일 (기존 UI 유지)
 css = """
 .container {
-    max-width: 1000px;
+    max-width: 1200px;
     margin: auto;
     padding: 20px;
 }
 
 .header {
     text-align: center;
-    margin-bottom: 20px;
+    margin-bottom: 30px;
     background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-    padding: 30px;
-    border-radius: 15px;
+    padding: 40px;
+    border-radius: 20px;
     color: white;
-    box-shadow: 0 5px 15px rgba(0,0,0,0.2);
+    box-shadow: 0 10px 30px rgba(0,0,0,0.2);
+    position: relative;
+    overflow: hidden;
+}
+
+.header::before {
+    content: '';
+    position: absolute;
+    top: -50%;
+    left: -50%;
+    width: 200%;
+    height: 200%;
+    background: radial-gradient(circle, rgba(255,255,255,0.1) 0%, transparent 70%);
+    animation: pulse 4s ease-in-out infinite;
+}
+
+@keyframes pulse {
+    0%, 100% { transform: scale(1); opacity: 0.5; }
+    50% { transform: scale(1.1); opacity: 0.8; }
 }
 
 .header h1 {
-    font-size: 2.5em;
+    font-size: 3em;
     margin-bottom: 10px;
+    text-shadow: 2px 2px 4px rgba(0,0,0,0.3);
+    position: relative;
+    z-index: 1;
 }
 
-.warning-box {
-    background: #fff3cd;
-    border: 1px solid #ffeaa7;
-    border-radius: 8px;
-    padding: 12px;
-    margin: 10px 0;
-    color: #856404;
-    font-size: 0.9em;
+.header p {
+    font-size: 1.2em;
+    opacity: 0.95;
+    position: relative;
+    z-index: 1;
+}
+
+.gpu-status {
+    position: absolute;
+    top: 10px;
+    right: 10px;
+    background: rgba(0,0,0,0.3);
+    padding: 5px 15px;
+    border-radius: 20px;
+    font-size: 0.8em;
+}
+
+.main-content {
+    background: rgba(255, 255, 255, 0.95);
+    border-radius: 20px;
+    padding: 30px;
+    box-shadow: 0 5px 20px rgba(0,0,0,0.1);
+    backdrop-filter: blur(10px);
+}
+
+.input-section {
+    background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
+    padding: 25px;
+    border-radius: 15px;
+    margin-bottom: 20px;
 }
 
 .generate-btn {
     background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
     color: white;
-    font-size: 1.2em;
-    padding: 12px 30px;
-    border-radius: 25px;
+    font-size: 1.3em;
+    padding: 15px 40px;
+    border-radius: 30px;
     border: none;
     cursor: pointer;
+    transition: all 0.3s ease;
+    box-shadow: 0 5px 15px rgba(102, 126, 234, 0.4);
     width: 100%;
-    margin-top: 15px;
+    margin-top: 20px;
 }
 
 .generate-btn:hover {
     transform: translateY(-2px);
-    box-shadow: 0 5px 15px rgba(102, 126, 234, 0.4);
+    box-shadow: 0 7px 20px rgba(102, 126, 234, 0.6);
+}
+
+.generate-btn:active {
+    transform: translateY(0);
+}
+
+.video-output {
+    background: #f8f9fa;
+    padding: 20px;
+    border-radius: 15px;
+    text-align: center;
+    min-height: 400px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.accordion {
+    background: rgba(255, 255, 255, 0.7);
+    border-radius: 10px;
+    margin-top: 15px;
+    padding: 15px;
+}
+
+.slider-container {
+    background: rgba(255, 255, 255, 0.5);
+    padding: 15px;
+    border-radius: 10px;
+    margin: 10px 0;
+}
+
+body {
+    background: linear-gradient(-45deg, #ee7752, #e73c7e, #23a6d5, #23d5ab);
+    background-size: 400% 400%;
+    animation: gradient 15s ease infinite;
+}
+
+@keyframes gradient {
+    0% { background-position: 0% 50%; }
+    50% { background-position: 100% 50%; }
+    100% { background-position: 0% 50%; }
+}
+
+.warning-box {
+    background: rgba(255, 193, 7, 0.1);
+    border: 1px solid rgba(255, 193, 7, 0.3);
+    border-radius: 10px;
+    padding: 15px;
+    margin: 10px 0;
+    color: #856404;
+    font-size: 0.9em;
+}
+
+.info-box {
+    background: rgba(52, 152, 219, 0.1);
+    border: 1px solid rgba(52, 152, 219, 0.3);
+    border-radius: 10px;
+    padding: 15px;
+    margin: 10px 0;
+    color: #2c5282;
+    font-size: 0.9em;
+}
+
+.footer {
+    text-align: center;
+    margin-top: 30px;
+    color: #666;
+    font-size: 0.9em;
 }
 """
 
-# Gradio UI
+# Gradio UI (기존 구조 유지)
 with gr.Blocks(css=css, theme=gr.themes.Soft()) as demo:
     with gr.Column(elem_classes="container"):
-        # Header
+        # Header with GPU status
         gr.HTML("""
         <div class="header">
-            <h1>🎬 AI Video Generator</h1>
-            <p>Transform images into videos with Wan 2.1 (Zero GPU Optimized)</p>
+            <h1>🎬 AI Video Magic Studio</h1>
+            <p>Transform your images into captivating videos with Wan 2.1 + CausVid LoRA</p>
+            <div class="gpu-status">🖥️ Zero GPU Optimized</div>
         </div>
         """)
         
-        # 경고
+        # GPU 메모리 경고
+        if hasattr(spaces, 'GPU'):
+            gr.HTML("""
+            <div class="warning-box">
+                <strong>💡 Zero GPU Performance Tips:</strong>
+                <ul style="margin: 5px 0; padding-left: 20px;">
+                    <li>Maximum duration: 2.5 seconds</li>
+                    <li>Maximum resolution: 640×640 pixels</li>
+                    <li>Recommended: 512×512 at 2 seconds</li>
+                    <li>Use 4-6 steps for optimal speed/quality balance</li>
+                    <li>Processing time: ~60-90 seconds</li>
+                </ul>
+            </div>
+            """)
+        
+        # 정보 박스
         gr.HTML("""
-        <div class="warning-box">
-            <strong>⚡ Zero GPU Strict Limitations:</strong>
-            <ul style="margin: 5px 0; padding-left: 20px;">
-                <li>Max resolution: 320×320 (recommended 256×256)</li>
-                <li>Max duration: 1.2 seconds</li>
-                <li>Max steps: 5 (2-3 recommended)</li>
-                <li>Processing time: ~50-80 seconds</li>
-                <li>Please wait for completion before next generation</li>
-            </ul>
+        <div class="info-box">
+            <strong>🎯 Quick Start Guide:</strong>
+            <ol style="margin: 5px 0; padding-left: 20px;">
+                <li>Upload your image - AI will calculate optimal dimensions</li>
+                <li>Enter a creative prompt or use the default</li>
+                <li>Adjust duration (2s recommended for best results)</li>
+                <li>Click Generate and wait for completion</li>
+            </ol>
         </div>
         """)
         
-        with gr.Row():
+        with gr.Row(elem_classes="main-content"):
             with gr.Column(scale=1):
-                input_image = gr.Image(
-                    type="pil", 
-                    label="🖼️ Upload Image"
-                )
-                
-                prompt_input = gr.Textbox(
-                    label="✨ Animation Prompt",
-                    value=config.default_prompt,
-                    placeholder="Describe the motion...",
-                    lines=2,
-                    max_lines=3
-                )
-                
-                duration_input = gr.Slider(
-                    minimum=0.3,
-                    maximum=1.2,
-                    step=0.1,
-                    value=0.8,
-                    label="⏱️ Duration (seconds)"
-                )
+                gr.Markdown("### 📸 Input Settings")
                 
-                with gr.Accordion("⚙️ Settings", open=False):
-                    negative_prompt = gr.Textbox(
-                        label="Negative Prompt",
-                        value=config.default_negative_prompt,
-                        lines=1
+                with gr.Column(elem_classes="input-section"):
+                    input_image = gr.Image(
+                        type="pil", 
+                        label="🖼️ Upload Your Image",
+                        elem_classes="image-upload"
                     )
                     
-                    with gr.Row():
-                        height_slider = gr.Slider(
-                            minimum=128,
-                            maximum=512,
-                            step=32,
-                            value=256,
-                            label="Height"
-                        )
-                        width_slider = gr.Slider(
-                            minimum=128,
-                            maximum=512,
-                            step=32,
-                            value=256,
-                            label="Width"
-                        )
+                    prompt_input = gr.Textbox(
+                        label="✨ Animation Prompt",
+                        value=default_prompt_i2v,
+                        placeholder="Describe how you want your image to move...",
+                        lines=2
+                    )
                     
-                    steps_slider = gr.Slider(
-                        minimum=1,
-                        maximum=5,
-                        step=1,
+                    duration_input = gr.Slider(
+                        minimum=round(MIN_FRAMES_MODEL/FIXED_FPS, 1),
+                        maximum=round(MAX_FRAMES_MODEL/FIXED_FPS, 1) if not hasattr(spaces, 'GPU') else 2.5,
+                        step=0.1,
                         value=2,
-                        label="Steps (2-3 recommended)"
+                        label=f"⏱️ Video Duration (seconds) - Clamped to {MIN_FRAMES_MODEL}-{MAX_FRAMES_MODEL} frames at {FIXED_FPS}fps",
+                        elem_classes="slider-container"
+                    )
+                
+                with gr.Accordion("🎛️ Advanced Settings", open=False, elem_classes="accordion"):
+                    negative_prompt = gr.Textbox(
+                        label="🚫 Negative Prompt",
+                        value=default_negative_prompt,
+                        lines=3
                     )
                     
                     with gr.Row():
@@ -538,19 +457,43 @@ with gr.Blocks(css=css, theme=gr.themes.Soft()) as demo:
                             maximum=MAX_SEED,
                             step=1,
                             value=42,
-                            label="Seed"
+                            label="🎲 Seed"
                         )
                         randomize_seed = gr.Checkbox(
-                            label="Random",
+                            label="🔀 Randomize",
                             value=True
                         )
                     
+                    with gr.Row():
+                        height_slider = gr.Slider(
+                            minimum=SLIDER_MIN_H,
+                            maximum=SLIDER_MAX_H if not hasattr(spaces, 'GPU') else 640,
+                            step=MOD_VALUE,
+                            value=DEFAULT_H_SLIDER_VALUE,
+                            label=f"📏 Height (multiple of {MOD_VALUE})"
+                        )
+                        width_slider = gr.Slider(
+                            minimum=SLIDER_MIN_W,
+                            maximum=SLIDER_MAX_W if not hasattr(spaces, 'GPU') else 640,
+                            step=MOD_VALUE,
+                            value=DEFAULT_W_SLIDER_VALUE,
+                            label=f"📐 Width (multiple of {MOD_VALUE})"
+                        )
+                    
+                    steps_slider = gr.Slider(
+                        minimum=1,
+                        maximum=30 if not hasattr(spaces, 'GPU') else 8,
+                        step=1,
+                        value=4,
+                        label="🔧 Quality Steps (4-6 recommended)"
+                    )
+                    
                     guidance_scale = gr.Slider(
                         minimum=0.0,
-                        maximum=5.0,
+                        maximum=20.0,
                         step=0.5,
                         value=1.0,
-                        label="Guidance Scale",
+                        label="🎯 Guidance Scale",
                         visible=False
                     )
                 
@@ -561,44 +504,63 @@ with gr.Blocks(css=css, theme=gr.themes.Soft()) as demo:
                 )
             
             with gr.Column(scale=1):
+                gr.Markdown("### 🎥 Generated Video")
                 video_output = gr.Video(
-                    label="Generated Video",
-                    autoplay=True
+                    label="",
+                    autoplay=True,
+                    elem_classes="video-output"
                 )
                 
-                gr.Markdown("""
-                ### 💡 Tips for Zero GPU:
-                - **Best**: 256×256 resolution
-                - **Safe**: 2-3 steps only
-                - **Duration**: 0.8s is optimal
-                - **Prompts**: Keep short and simple
-                - **Important**: Wait for completion!
-                
-                ### ⚠️ If GPU stops:
-                - Reduce resolution to 256×256
-                - Use only 2 steps
-                - Keep duration under 1 second
-                - Avoid extreme aspect ratios
+                gr.HTML("""
+                <div class="footer">
+                    <p>💡 Tip: For best results, use clear images with good lighting and distinct subjects</p>
+                </div>
                 """)
         
-        # Event handlers
-        input_image.upload(
-            fn=handle_image_upload,
-            inputs=[input_image],
-            outputs=[height_slider, width_slider]
-        )
-        
-        generate_btn.click(
-            fn=generate_video,
-            inputs=[
-                input_image, prompt_input, height_slider, width_slider,
-                negative_prompt, duration_input, guidance_scale, 
-                steps_slider, seed, randomize_seed
+        # Examples
+        gr.Examples(
+            examples=[
+                ["peng.png", "a penguin playfully dancing in the snow, Antarctica", 512, 512],
+                ["forg.jpg", "the frog jumps around", 448, 576],
             ],
-            outputs=[video_output, seed]
+            inputs=[input_image, prompt_input, height_slider, width_slider],
+            outputs=[video_output, seed],
+            fn=generate_video,
+            cache_examples=False  # 캐시 비활성화로 메모리 절약
         )
 
+        # 개선사항 요약
+        gr.HTML("""
+        <div style="background: rgba(255,255,255,0.9); border-radius: 10px; padding: 15px; margin-top: 20px; font-size: 0.8em; text-align: center;">
+            <p style="margin: 0; color: #666;">
+                <strong style="color: #667eea;">Powered by:</strong> 
+                Wan 2.1 I2V (14B) + CausVid LoRA • 🚀 4-8 steps fast inference • 🎬 Up to 81 frames
+            </p>
+        </div>
+        """)
+    
+    # Event handlers
+    input_image.upload(
+        fn=handle_image_upload_for_dims_wan,
+        inputs=[input_image, height_slider, width_slider],
+        outputs=[height_slider, width_slider]
+    )
+    
+    input_image.clear(
+        fn=handle_image_upload_for_dims_wan,
+        inputs=[input_image, height_slider, width_slider],
+        outputs=[height_slider, width_slider]
+    )
+    
+    generate_btn.click(
+        fn=generate_video,
+        inputs=[
+            input_image, prompt_input, height_slider, width_slider,
+            negative_prompt, duration_input, guidance_scale, 
+            steps_slider, seed, randomize_seed
+        ],
+        outputs=[video_output, seed]
+    )
+
 if __name__ == "__main__":
-    logger.info("Starting app in Zero GPU environment")
-    demo.queue(max_size=2)  # 작은 큐 사이즈
-    demo.launch()
+    demo.queue().launch()