Update app.py

app.py

@@ -20,7 +20,7 @@ import threading
 import os
 
 # GPU 메모리 관리 설정
-os.environ['PYTORCH_CUDA_ALLOC_CONF'] = 'max_split_size_mb:512'
+os.environ['PYTORCH_CUDA_ALLOC_CONF'] = 'max_split_size_mb:256'  # 더 작은 청크 사용
 
 # 로깅 설정
 logging.basicConfig(level=logging.INFO)
@@ -33,18 +33,19 @@ class VideoGenerationConfig:
     lora_repo_id: str = "Kijai/WanVideo_comfy"
     lora_filename: str = "Wan21_CausVid_14B_T2V_lora_rank32.safetensors"
     mod_value: int = 32
-    default_height: int = 512
-    default_width: int = 512  # Zero GPU 환경을 위해 기본값 수정
-    max_area: float = 480.0 * 832.0
+    # Zero GPU를 위한 보수적인 기본값
+    default_height: int = 384
+    default_width: int = 384
+    max_area: float = 384.0 * 384.0  # Zero GPU에 최적화
     slider_min_h: int = 128
-    slider_max_h: int = 832  # Zero GPU 환경을 위해 수정
+    slider_max_h: int = 640  # 더 낮은 최대값
     slider_min_w: int = 128
-    slider_max_w: int = 832  # Zero GPU 환경을 위해 수정
+    slider_max_w: int = 640  # 더 낮은 최대값
     fixed_fps: int = 24
     min_frames: int = 8
-    max_frames: int = 81
-    default_prompt: str = "make this image come alive, cinematic motion, smooth animation"
-    default_negative_prompt: str = "static, blurred, low quality, watermark, text"
+    max_frames: int = 36  # 더 낮은 최대 프레임
+    default_prompt: str = "make this image come alive, cinematic motion"
+    default_negative_prompt: str = "static, blurred, low quality"
     # GPU 메모리 최적화 설정
     enable_model_cpu_offload: bool = True
     enable_vae_slicing: bool = True
@@ -63,7 +64,8 @@ class VideoGenerationConfig:
 config = VideoGenerationConfig()
 MAX_SEED = np.iinfo(np.int32).max
 
-# 글로벌 락 (동시 실행 방지)
+# 글로벌 변수
+pipe = None
 generation_lock = threading.Lock()
 
 # 성능 측정 데코레이터
@@ -78,175 +80,19 @@ def measure_time(func):
 
 # GPU 메모리 정리 함수
 def clear_gpu_memory():
-    """강력한 GPU 메모리 정리"""
-    # Zero GPU 환경에서는 메인 프로세스에서 CUDA 초기화 방지
-    if hasattr(spaces, 'GPU'):
-        # Zero GPU 환경에서는 @spaces.GPU 내에서만 GPU 작업 수행
-        gc.collect()
-        return
-    
+    """메모리 정리 (Zero GPU 안전)"""
+    gc.collect()
     if torch.cuda.is_available():
         try:
             torch.cuda.empty_cache()
-            torch.cuda.ipc_collect()
-            gc.collect()
-            
-            # GPU 메모리 상태 로깅
-            allocated = torch.cuda.memory_allocated() / 1024**3
-            reserved = torch.cuda.memory_reserved() / 1024**3
-            logger.info(f"GPU Memory - Allocated: {allocated:.2f}GB, Reserved: {reserved:.2f}GB")
-        except Exception as e:
-            logger.warning(f"GPU memory clear failed: {e}")
-            gc.collect()
-
-# 모델 관리자 (싱글톤 패턴)
-class ModelManager:
-    _instance = None
-    _lock = threading.Lock()
-    
-    def __new__(cls):
-        if cls._instance is None:
-            with cls._lock:
-                if cls._instance is None:
-                    cls._instance = super().__new__(cls)
-        return cls._instance
-    
-    def __init__(self):
-        if not hasattr(self, '_initialized'):
-            self._pipe = None
-            self._is_loaded = False
-            self._initialized = True
-    
-    @property
-    def pipe(self):
-        if not self._is_loaded:
-            self._load_model()
-        return self._pipe
-    
-    @measure_time
-    def _load_model(self):
-        """메모리 효율적인 모델 로딩"""
-        with self._lock:
-            if self._is_loaded:
-                return
-                
-            try:
-                logger.info("Loading model with memory optimizations...")
-                clear_gpu_memory()
-                
-                # 모델 컴포넌트 로드 (메모리 효율적) - autocast 수정
-                if torch.cuda.is_available() and not hasattr(spaces, 'GPU'):
-                    # 일반 GPU 환경
-                    with torch.amp.autocast('cuda', enabled=False):  # 수정된 부분
-                        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
-                        )
-                else:
-                    # CPU 환경 또는 Zero GPU 환경
-                    image_encoder = CLIPVisionModel.from_pretrained(
-                        config.model_id, 
-                        subfolder="image_encoder", 
-                        torch_dtype=torch.float16 if hasattr(spaces, 'GPU') else torch.float32,
-                        low_cpu_mem_usage=True
-                    )
-                    
-                    vae = AutoencoderKLWan.from_pretrained(
-                        config.model_id, 
-                        subfolder="vae", 
-                        torch_dtype=torch.float16 if hasattr(spaces, 'GPU') else torch.float32,
-                        low_cpu_mem_usage=True
-                    )
-                    
-                self._pipe = WanImageToVideoPipeline.from_pretrained(
-                    config.model_id, 
-                    vae=vae, 
-                    image_encoder=image_encoder, 
-                    torch_dtype=torch.bfloat16 if (torch.cuda.is_available() or hasattr(spaces, 'GPU')) else torch.float32,
-                    low_cpu_mem_usage=True,
-                    use_safetensors=True
-                )
-                
-                # 스케줄러 설정
-                self._pipe.scheduler = UniPCMultistepScheduler.from_config(
-                    self._pipe.scheduler.config, flow_shift=8.0
-                )
-                
-                # LoRA 로드
-                try:
-                    causvid_path = hf_hub_download(
-                        repo_id=config.lora_repo_id, filename=config.lora_filename
-                    )
-                    self._pipe.load_lora_weights(causvid_path, adapter_name="causvid_lora")
-                    self._pipe.set_adapters(["causvid_lora"], adapter_weights=[0.95])
-                    self._pipe.fuse_lora()
-                    logger.info("LoRA weights loaded successfully")
-                except Exception as e:
-                    logger.warning(f"Failed to load LoRA weights: {e}")
-                
-                # GPU 최적화 설정
-                if hasattr(spaces, 'GPU'):  # Zero GPU 환경
-                    # Zero GPU 환경에서는 자동으로 처리됨
-                    logger.info("Model loaded for Zero GPU environment")
-                elif config.enable_model_cpu_offload and torch.cuda.is_available():
-                    self._pipe.enable_model_cpu_offload()
-                    logger.info("CPU offload enabled")
-                elif torch.cuda.is_available():
-                    self._pipe.to("cuda")
-                    logger.info("Model moved to CUDA")
-                else:
-                    logger.info("Running on CPU")
-                
-                if config.enable_vae_slicing:
-                    self._pipe.enable_vae_slicing()
-                    
-                if config.enable_vae_tiling:
-                    self._pipe.enable_vae_tiling()
-                
-                # xFormers 메모리 효율적인 attention 활성화 (가능한 경우)
-                try:
-                    self._pipe.enable_xformers_memory_efficient_attention()
-                    logger.info("xFormers memory efficient attention enabled")
-                except:
-                    logger.info("xFormers not available, using default attention")
-                
-                self._is_loaded = True
-                logger.info("Model loaded successfully with optimizations")
-                clear_gpu_memory()
-                
-            except Exception as e:
-                logger.error(f"Error loading model: {e}")
-                self._is_loaded = False
-                clear_gpu_memory()
-                raise
-    
-    def unload_model(self):
-        """모델 언로드 및 메모리 해제"""
-        with self._lock:
-            if self._pipe is not None:
-                del self._pipe
-                self._pipe = None
-                self._is_loaded = False
-                clear_gpu_memory()
-                logger.info("Model unloaded and memory cleared")
-
-# 싱글톤 인스턴스
-model_manager = ModelManager()
+            torch.cuda.synchronize()
+        except:
+            pass
 
 # 비디오 생성기 클래스
 class VideoGenerator:
-    def __init__(self, config: VideoGenerationConfig, model_manager: ModelManager):
+    def __init__(self, config: VideoGenerationConfig):
         self.config = config
-        self.model_manager = model_manager
     
     def calculate_dimensions(self, image: Image.Image) -> Tuple[int, int]:
         orig_w, orig_h = image.size
@@ -255,11 +101,8 @@ class VideoGenerator:
         
         aspect_ratio = orig_h / orig_w
         
-        # Zero GPU 환경에서는 더 작은 max_area 사용
-        if hasattr(spaces, 'GPU'):
-            max_area = 640.0 * 640.0  # 409,600 pixels
-        else:
-            max_area = self.config.max_area
+        # Zero GPU에 최적화된 작은 해상도
+        max_area = 384.0 * 384.0
         
         calc_h = round(np.sqrt(max_area * aspect_ratio))
         calc_w = round(np.sqrt(max_area / aspect_ratio))
@@ -267,16 +110,13 @@ class VideoGenerator:
         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)
         
-        # Zero GPU 환경에서 추가 제한
-        if hasattr(spaces, 'GPU'):
-            max_dim = 832
-            new_h = int(np.clip(calc_h, self.config.slider_min_h, min(max_dim, self.config.slider_max_h)))
-            new_w = int(np.clip(calc_w, self.config.slider_min_w, min(max_dim, self.config.slider_max_w)))
-        else:
-            new_h = int(np.clip(calc_h, self.config.slider_min_h, 
-                               (self.config.slider_max_h // self.config.mod_value) * self.config.mod_value))
-            new_w = int(np.clip(calc_w, self.config.slider_min_w, 
-                               (self.config.slider_max_w // self.config.mod_value) * self.config.mod_value))
+        # 최대 640으로 제한
+        new_h = int(np.clip(calc_h, self.config.slider_min_h, 640))
+        new_w = int(np.clip(calc_w, self.config.slider_min_w, 640))
+        
+        # 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
         
         return new_h, new_w
     
@@ -288,43 +128,26 @@ class VideoGenerator:
         if not prompt or len(prompt.strip()) == 0:
             return False, "✍️ Please provide a prompt"
         
-        if len(prompt) > 500:
-            return False, "⚠️ Prompt is too long (max 500 characters)"
+        if len(prompt) > 300:  # 더 짧은 프롬프트 제한
+            return False, "⚠️ Prompt is too long (max 300 characters)"
         
-        # 정확한 duration 범위 체크
-        min_duration = self.config.min_duration
-        max_duration = self.config.max_duration
+        # Zero GPU에 최적화된 제한
+        if duration < 0.3:
+            return False, "⏱️ Duration too short (min 0.3s)"
         
-        if duration < min_duration:
-            return False, f"⏱️ Duration too short (min {min_duration:.1f}s)"
+        if duration > 1.5:
+            return False, "⏱️ Duration too long (max 1.5s for stability)"
         
-        if duration > max_duration:
-            return False, f"⏱️ Duration too long (max {max_duration:.1f}s)"
+        # 픽셀 수 제한 (384x384 = 147,456 픽셀)
+        max_pixels = 384 * 384
+        if height * width > max_pixels:
+            return False, f"📐 Total pixels limited to {max_pixels:,} (e.g., 384×384)"
         
-        # Zero GPU 환경에서는 더 보수적인 제한 적용
-        if hasattr(spaces, 'GPU'):  # Spaces 환경 체크
-            if duration > 2.5:  # Zero GPU에서는 2.5초로 제한
-                return False, "⏱️ In Zero GPU environment, duration is limited to 2.5s for stability"
-            # 픽셀 수 기반 제한 (640x640 = 409,600 픽셀)
-            max_pixels = 640 * 640
-            if height * width > max_pixels:
-                return False, f"📐 In Zero GPU environment, total pixels limited to {max_pixels:,} (e.g., 640×640, 512×832)"
-            if height > 832 or width > 832:  # 한 변의 최대 길이
-                return False, "📐 In Zero GPU environment, maximum dimension is 832 pixels"
+        if height > 640 or width > 640:
+            return False, "📐 Maximum dimension is 640 pixels"
         
-        # GPU 메모리 체크 (Zero GPU 환경이 아닐 때만)
-        if torch.cuda.is_available() and not hasattr(spaces, 'GPU'):
-            try:
-                free_memory = torch.cuda.get_device_properties(0).total_memory - torch.cuda.memory_allocated()
-                required_memory = (height * width * 3 * 8 * duration * self.config.fixed_fps) / (1024**3)
-                if free_memory < required_memory * 2:
-                    clear_gpu_memory()
-                    # 재확인
-                    free_memory = torch.cuda.get_device_properties(0).total_memory - torch.cuda.memory_allocated()
-                    if free_memory < required_memory * 1.5:
-                        return False, "⚠️ Not enough GPU memory. Try smaller dimensions or shorter duration."
-            except Exception as e:
-                logger.warning(f"GPU memory check failed: {e}")
+        if steps > 6:
+            return False, "🔧 Maximum 6 steps in Zero GPU environment"
         
         return True, None
     
@@ -334,7 +157,7 @@ class VideoGenerator:
         hash_obj = hashlib.md5(unique_str.encode())
         return f"video_{hash_obj.hexdigest()[:8]}.mp4"
 
-video_generator = VideoGenerator(config, model_manager)
+video_generator = VideoGenerator(config)
 
 # Gradio 함수들
 def handle_image_upload(image):
@@ -355,53 +178,40 @@ def handle_image_upload(image):
 
 def get_duration(input_image, prompt, height, width, negative_prompt, 
                 duration_seconds, guidance_scale, steps, seed, randomize_seed, progress):
-    # Zero GPU 환경에서는 더 보수적인 시간 할당
-    base_duration = 60
-    
-    # 단계별 추가 시간
-    if steps > 8:
-        base_duration += 30
-    elif steps > 4:
-        base_duration += 15
+    # Zero GPU 환경에서 매우 보수적인 시간 할당
+    base_duration = 40  # 기본 40초
     
-    # Duration별 추가 시간
-    if duration_seconds > 2:
+    # 픽셀 수에 따른 추가 시간
+    pixels = height * width
+    if pixels > 200000:  # 448x448 이상
         base_duration += 20
-    elif duration_seconds > 1.5:
+    elif pixels > 147456:  # 384x384 이상
         base_duration += 10
     
-    # 해상도별 추가 시간 (픽셀 수 기반)
-    pixels = height * width
-    if pixels > 400000:  # 640x640 근처
-        base_duration += 20
-    elif pixels > 250000:  # 512x512 근처
+    # 스텝 수에 따른 추가 시간
+    if steps > 4:
         base_duration += 10
     
-    # Zero GPU 환경에서는 최대 90초로 제한
-    return min(base_duration, 90)
+    # 최대 70초로 제한 (Zero GPU의 안전한 한계)
+    return min(base_duration, 70)
 
 @spaces.GPU(duration=get_duration)
 @measure_time
 def generate_video(input_image, prompt, height, width, 
                    negative_prompt=config.default_negative_prompt, 
-                   duration_seconds=1.5, guidance_scale=1, steps=4,
+                   duration_seconds=1.0, guidance_scale=1, steps=3,
                    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...")
     
     try:
-        # Zero GPU 환경에서는 이제 GPU 사용 가능
-        if hasattr(spaces, 'GPU') and torch.cuda.is_available():
-            logger.info("GPU initialized in Zero GPU environment")
-        
-        progress(0.1, desc="🔍 Validating inputs...")
-        
-        # Zero GPU 환경에서 추가 검증
-        if hasattr(spaces, 'GPU'):
-            logger.info(f"Zero GPU environment detected. Duration: {duration_seconds}s, Resolution: {height}x{width}, Pixels: {height*width:,}")
+        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(
@@ -413,73 +223,117 @@ def generate_video(input_image, prompt, height, width,
         # 메모리 정리
         clear_gpu_memory()
         
-        progress(0.2, desc="🎯 Preparing image...")
+        progress(0.1, desc="🚀 Loading model...")
+        
+        # 모델 로딩 (GPU 함수 내에서)
+        if pipe is None:
+            try:
+                # 컴포넌트 로드
+                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 로드 (선택적)
+                try:
+                    causvid_path = hf_hub_download(
+                        repo_id=config.lora_repo_id, filename=config.lora_filename
+                    )
+                    pipe.load_lora_weights(causvid_path, adapter_name="causvid_lora")
+                    pipe.set_adapters(["causvid_lora"], adapter_weights=[0.95])
+                    pipe.fuse_lora()
+                except:
+                    logger.warning("LoRA loading skipped")
+                
+                # GPU로 이동
+                pipe.to("cuda")
+                
+                # 최적화 활성화
+                pipe.enable_vae_slicing()
+                pipe.enable_vae_tiling()
+                
+                # xFormers 시도
+                try:
+                    pipe.enable_xformers_memory_efficient_attention()
+                except:
+                    pass
+                
+                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)
         
-        # 프레임 수 계산 (Zero GPU 환경에서 추가 제한)
-        max_allowed_frames = int(2.5 * config.fixed_fps) if hasattr(spaces, 'GPU') else config.max_frames
+        # 프레임 수 계산 (매우 보수적)
         num_frames = min(
             int(round(duration_seconds * config.fixed_fps)),
-            max_allowed_frames
+            36  # 최대 36프레임 (1.5초)
         )
-        num_frames = np.clip(num_frames, config.min_frames, max_allowed_frames)
+        num_frames = max(8, num_frames)  # 최소 8프레임
         
         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.3, desc="🎨 Loading model...")
-        pipe = model_manager.pipe
+        progress(0.4, desc="🎬 Generating video...")
         
-        progress(0.4, desc="🎬 Generating video frames...")
-        
-        # 메모리 효율적인 생성
-        device = "cuda" if torch.cuda.is_available() else "cpu"
-        
-        if device == "cuda":
-            with torch.inference_mode(), torch.amp.autocast('cuda', enabled=True):  # 수정된 부분
-                try:
-                    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),
-                        return_dict=True
-                    ).frames[0]
-                except torch.cuda.OutOfMemoryError:
-                    clear_gpu_memory()
-                    raise gr.Error("💾 GPU out of memory. Try smaller dimensions or shorter duration.")
-                except Exception as e:
-                    logger.error(f"Generation error: {e}")
-                    raise gr.Error(f"❌ Generation failed: {str(e)}")
-        else:
-            # CPU 환경
-            with torch.inference_mode():
-                try:
-                    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().manual_seed(current_seed),
-                        return_dict=True
-                    ).frames[0]
-                except Exception as e:
-                    logger.error(f"Generation error: {e}")
-                    raise gr.Error(f"❌ Generation failed: {str(e)}")
+        # 비디오 생성
+        with torch.inference_mode(), torch.amp.autocast('cuda', enabled=True):
+            try:
+                # 짧은 타임아웃으로 생성
+                output_frames_list = pipe(
+                    image=resized_image,
+                    prompt=prompt[:200],  # 프롬프트 길이 제한
+                    negative_prompt=negative_prompt[:100],  # 네거티브 프롬프트도 제한
+                    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
+                ).frames[0]
+                
+            except torch.cuda.OutOfMemoryError:
+                clear_gpu_memory()
+                raise gr.Error("💾 GPU out of memory. Try smaller dimensions.")
+            except Exception as e:
+                logger.error(f"Generation error: {e}")
+                raise gr.Error(f"❌ Generation failed: {str(e)[:100]}")
         
         progress(0.9, desc="💾 Saving video...")
+        
+        # 비디오 저장
         filename = video_generator.generate_unique_filename(current_seed)
         with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmpfile:
             video_path = tmpfile.name
@@ -487,325 +341,173 @@ def generate_video(input_image, prompt, height, width,
         export_to_video(output_frames_list, video_path, fps=config.fixed_fps)
         
         progress(1.0, desc="✨ Complete!")
-        logger.info(f"Video generated successfully: {num_frames} frames, {target_h}x{target_w}")
+        logger.info(f"Video generated: {num_frames} frames, {target_h}x{target_w}")
         
-        # 성공 정보 반환
-        info_text = f"✅ Generated {num_frames} frames at {target_h}x{target_w} with seed {current_seed}"
-        gr.Info(info_text)
+        # 메모리 정리
+        del output_frames_list
+        del resized_image
+        clear_gpu_memory()
         
         return video_path, current_seed
         
     except gr.Error:
-        # Gradio 에러는 그대로 전달
         raise
     except Exception as e:
         logger.error(f"Unexpected error: {e}")
-        raise gr.Error(f"❌ Unexpected error: {str(e)}")
+        raise gr.Error(f"❌ Error: {str(e)[:100]}")
         
     finally:
-        # 항상 메모리 정리 및 락 해제
         generation_lock.release()
-        
-        # 메모리 정리
-        if 'output_frames_list' in locals():
-            del output_frames_list
-        if 'resized_image' in locals():
-            del resized_image
-        
         clear_gpu_memory()
 
-# 개선된 CSS 스타일
+# CSS
 css = """
 .container {
-    max-width: 1200px;
+    max-width: 1000px;
     margin: auto;
     padding: 20px;
 }
 
 .header {
     text-align: center;
-    margin-bottom: 30px;
+    margin-bottom: 20px;
     background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-    padding: 40px;
-    border-radius: 20px;
+    padding: 30px;
+    border-radius: 15px;
     color: white;
-    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; }
+    box-shadow: 0 5px 15px rgba(0,0,0,0.2);
 }
 
 .header h1 {
-    font-size: 3em;
+    font-size: 2.5em;
     margin-bottom: 10px;
-    text-shadow: 2px 2px 4px rgba(0,0,0,0.3);
-    position: relative;
-    z-index: 1;
-}
-
-.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;
+.warning-box {
+    background: #fff3cd;
+    border: 1px solid #ffeaa7;
+    border-radius: 8px;
+    padding: 12px;
+    margin: 10px 0;
+    color: #856404;
+    font-size: 0.9em;
 }
 
 .generate-btn {
     background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
     color: white;
-    font-size: 1.3em;
-    padding: 15px 40px;
-    border-radius: 30px;
+    font-size: 1.2em;
+    padding: 12px 30px;
+    border-radius: 25px;
     border: none;
     cursor: pointer;
-    transition: all 0.3s ease;
-    box-shadow: 0 5px 15px rgba(102, 126, 234, 0.4);
     width: 100%;
-    margin-top: 20px;
+    margin-top: 15px;
 }
 
 .generate-btn:hover {
     transform: translateY(-2px);
-    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;
-}
-
-/* 로딩 애니메이션 개선 */
-.progress-bar {
-    background: linear-gradient(90deg, #667eea 0%, #764ba2 50%, #667eea 100%);
-    background-size: 200% 100%;
-    animation: loading 1.5s ease-in-out infinite;
-}
-
-@keyframes loading {
-    0% { background-position: 0% 0%; }
-    100% { background-position: 200% 0%; }
+    box-shadow: 0 5px 15px rgba(102, 126, 234, 0.4);
 }
 """
 
 # Gradio UI
 with gr.Blocks(css=css, theme=gr.themes.Soft()) as demo:
     with gr.Column(elem_classes="container"):
-        # Header with GPU status
+        # Header
         gr.HTML("""
         <div class="header">
-            <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>
+            <h1>🎬 AI Video Generator</h1>
+            <p>Transform images into videos with Wan 2.1 (Zero GPU Optimized)</p>
         </div>
         """)
         
-        # GPU 메모리 경고
+        # 경고
         gr.HTML("""
         <div class="warning-box">
-            <strong>💡 Zero GPU Performance Tips:</strong>
+            <strong>⚡ Zero GPU Limitations:</strong>
             <ul style="margin: 5px 0; padding-left: 20px;">
-                <li>Maximum duration: 2.5 seconds (limited by Zero GPU)</li>
-                <li>Maximum total pixels: 409,600 (e.g., 640×640, 512×832, 448×896)</li>
-                <li>Maximum single dimension: 832 pixels</li>
-                <li>Use 4-6 steps for optimal speed/quality balance</li>
-                <li>Wait between generations to avoid queue errors</li>
+                <li>Max resolution: 384×384 (recommended)</li>
+                <li>Max duration: 1.5 seconds</li>
+                <li>Max steps: 6 (3-4 recommended)</li>
+                <li>Processing time: ~40-60 seconds</li>
             </ul>
         </div>
         """)
         
-        # 새로운 정보 박스 추가
-        gr.HTML("""
-        <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 (1.5s recommended for best results)</li>
-                <li>Click Generate and wait ~60 seconds</li>
-            </ol>
-        </div>
-        """)
-        
-        with gr.Row(elem_classes="main-content"):
+        with gr.Row():
             with gr.Column(scale=1):
-                gr.Markdown("### 📸 Input Settings")
+                input_image = gr.Image(
+                    type="pil", 
+                    label="🖼️ Upload Image"
+                )
                 
-                with gr.Column(elem_classes="input-section"):
-                    input_image = gr.Image(
-                        type="pil", 
-                        label="🖼️ Upload Your Image",
-                        elem_classes="image-upload"
-                    )
-                    
-                    prompt_input = gr.Textbox(
-                        label="✨ Animation Prompt",
-                        value=config.default_prompt,
-                        placeholder="Describe how you want your image to move...",
-                        lines=2
-                    )
-                    
-                    duration_input = gr.Slider(
-                        minimum=round(config.min_duration, 1),
-                        maximum=2.5 if hasattr(spaces, 'GPU') else round(config.max_duration, 1),  # Zero GPU 환경 제한
-                        step=0.1,
-                        value=1.5,  # 안전한 기본값
-                        label="⏱️ Video Duration (seconds) - Limited to 2.5s in Zero GPU",
-                        elem_classes="slider-container"
-                    )
+                prompt_input = gr.Textbox(
+                    label="✨ Animation Prompt",
+                    value=config.default_prompt,
+                    placeholder="Describe the motion...",
+                    lines=2,
+                    max_lines=3
+                )
                 
-                with gr.Accordion("🎛️ Advanced Settings", open=False, elem_classes="accordion"):
+                duration_input = gr.Slider(
+                    minimum=0.3,
+                    maximum=1.5,
+                    step=0.1,
+                    value=1.0,
+                    label="⏱️ Duration (seconds)"
+                )
+                
+                with gr.Accordion("⚙️ Settings", open=False):
                     negative_prompt = gr.Textbox(
-                        label="🚫 Negative Prompt",
+                        label="Negative Prompt",
                         value=config.default_negative_prompt,
-                        lines=2
+                        lines=1
                     )
                     
-                    with gr.Row():
-                        seed = gr.Slider(
-                            minimum=0,
-                            maximum=MAX_SEED,
-                            step=1,
-                            value=42,
-                            label="🎲 Seed"
-                        )
-                        randomize_seed = gr.Checkbox(
-                            label="🔀 Randomize",
-                            value=True
-                        )
-                    
                     with gr.Row():
                         height_slider = gr.Slider(
-                            minimum=config.slider_min_h,
-                            maximum=config.slider_max_h,
-                            step=config.mod_value,
-                            value=config.default_height,
-                            label="📏 Height (max 832px in Zero GPU)"
+                            minimum=128,
+                            maximum=640,
+                            step=32,
+                            value=384,
+                            label="Height"
                         )
                         width_slider = gr.Slider(
-                            minimum=config.slider_min_w,
-                            maximum=config.slider_max_w,
-                            step=config.mod_value,
-                            value=config.default_width,
-                            label="📐 Width (max 832px in Zero GPU)"
+                            minimum=128,
+                            maximum=640,
+                            step=32,
+                            value=384,
+                            label="Width"
                         )
                     
                     steps_slider = gr.Slider(
                         minimum=1,
-                        maximum=30,
+                        maximum=6,
                         step=1,
-                        value=4,
-                        label="🔧 Quality Steps (4-8 recommended)"
+                        value=3,
+                        label="Steps (3-4 recommended)"
                     )
                     
+                    with gr.Row():
+                        seed = gr.Slider(
+                            minimum=0,
+                            maximum=MAX_SEED,
+                            step=1,
+                            value=42,
+                            label="Seed"
+                        )
+                        randomize_seed = gr.Checkbox(
+                            label="Random",
+                            value=True
+                        )
+                    
                     guidance_scale = gr.Slider(
                         minimum=0.0,
-                        maximum=20.0,
+                        maximum=5.0,
                         step=0.5,
                         value=1.0,
-                        label="🎯 Guidance Scale",
+                        label="Guidance Scale",
                         visible=False
                     )
                 
@@ -816,73 +518,37 @@ 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="",
-                    autoplay=True,
-                    elem_classes="video-output"
+                    label="Generated Video",
+                    autoplay=True
                 )
                 
-                gr.HTML("""
-                <div class="footer">
-                    <p>💡 Tip: For best results, use clear images with good lighting and distinct subjects</p>
-                </div>
+                gr.Markdown("""
+                ### 💡 Tips:
+                - Use 384×384 for best results
+                - Keep prompts simple and clear
+                - 3-4 steps is optimal
+                - Wait for completion before next generation
                 """)
         
-        # Examples - 파일명 확인 필요
-        try:
-            gr.Examples(
-                examples=[
-                    ["peng.png", "a penguin playfully dancing in the snow, Antarctica", 512, 512],
-                    ["forg.jpg", "the frog jumps around", 576, 320],  # 16:9 aspect ratio within limits
-                ],
-                inputs=[input_image, prompt_input, height_slider, width_slider],
-                outputs=[video_output, seed],
-                fn=generate_video,
-                cache_examples=False  # 캐시 비활성화로 메모리 절약
-            )
-        except Exception as e:
-            logger.warning(f"Failed to load examples: {e}")
-
-        # 개선사항 요약 (작게)
-        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;">Enhanced with:</strong> 
-                🛡️ GPU Crash Protection • ⚡ Memory Optimization • 🎨 Modern UI • 🔧 Clean Architecture
-            </p>
-        </div>
-        """)
-    
-    # Event handlers
-    input_image.upload(
-        fn=handle_image_upload,
-        inputs=[input_image],
-        outputs=[height_slider, width_slider]
-    )
-    
-    input_image.clear(
-        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
-        ],
-        outputs=[video_output, seed]
-    )
+        # 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
+            ],
+            outputs=[video_output, seed]
+        )
 
 if __name__ == "__main__":
-    # Zero GPU 환경 체크 로깅
-    if hasattr(spaces, 'GPU'):
-        logger.info("Running in Zero GPU environment")
-    else:
-        logger.info("Running in standard environment")
-    
-    # 앱 실행
+    logger.info("Starting app in Zero GPU environment")
+    demo.queue(max_size=3)  # 작은 큐 사이즈
     demo.launch()