Update app.py

app.py

@@ -33,19 +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
-    # Zero GPU를 위한 보수적인 기본값
-    default_height: int = 384
-    default_width: int = 384
-    max_area: float = 384.0 * 384.0  # Zero GPU에 최적화
+    # 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 = 640  # 더 낮은 최대값
+    slider_max_h: int = 512  # 더 낮은 최대값
     slider_min_w: int = 128
-    slider_max_w: int = 640  # 더 낮은 최대값
+    slider_max_w: int = 512  # 더 낮은 최대값
     fixed_fps: int = 24
     min_frames: int = 8
-    max_frames: int = 36  # 더 낮은 최대 프레임
-    default_prompt: str = "make this image come alive, cinematic motion"
-    default_negative_prompt: str = "static, blurred, low quality"
+    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
@@ -101,23 +101,37 @@ class VideoGenerator:
         
         aspect_ratio = orig_h / orig_w
         
-        # Zero GPU에 최적화된 작은 해상도
-        max_area = 384.0 * 384.0
+        # 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)
         
-        # 최대 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))
+        # 최대 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
     
     def validate_inputs(self, image: Image.Image, prompt: str, height: int, 
@@ -128,26 +142,31 @@ class VideoGenerator:
         if not prompt or len(prompt.strip()) == 0:
             return False, "✍️ Please provide a prompt"
         
-        if len(prompt) > 300:  # 더 짧은 프롬프트 제한
-            return False, "⚠️ Prompt is too long (max 300 characters)"
+        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.5:
-            return False, "⏱️ Duration too long (max 1.5s for stability)"
+        if duration > 1.2:  # 더 짧은 최대 duration
+            return False, "⏱️ Duration too long (max 1.2s for stability)"
         
-        # 픽셀 수 제한 (384x384 = 147,456 픽셀)
-        max_pixels = 384 * 384
+        # 픽셀 수 제한 (더 보수적으로)
+        max_pixels = 320 * 320  # 102,400 픽셀
         if height * width > max_pixels:
-            return False, f"📐 Total pixels limited to {max_pixels:,} (e.g., 384×384)"
+            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"
         
-        if height > 640 or width > 640:
-            return False, "📐 Maximum dimension is 640 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 > 6:
-            return False, "🔧 Maximum 6 steps in Zero GPU environment"
+        if steps > 5:  # 더 낮은 최대 스텝
+            return False, "🔧 Maximum 5 steps in Zero GPU environment"
         
         return True, None
     
@@ -179,27 +198,34 @@ 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 = 40  # 기본 40초
+    base_duration = 50  # 기본 50초로 증가
     
     # 픽셀 수에 따른 추가 시간
     pixels = height * width
-    if pixels > 200000:  # 448x448 이상
+    if pixels > 147456:  # 384x384 이상
         base_duration += 20
-    elif pixels > 147456:  # 384x384 이상
+    elif pixels > 100000:  # ~316x316 이상
         base_duration += 10
     
     # 스텝 수에 따른 추가 시간
     if steps > 4:
+        base_duration += 15
+    elif steps > 2:
         base_duration += 10
     
-    # 최대 70초로 제한 (Zero GPU의 안전한 한계)
-    return min(base_duration, 70)
+    # 종횡비가 극단적인 경우 추가 시간
+    aspect_ratio = max(height/width, width/height)
+    if aspect_ratio > 1.5:  # 3:2 이상의 비율
+        base_duration += 10
+    
+    # 최대 90초로 제한
+    return min(base_duration, 90)
 
 @spaces.GPU(duration=get_duration)
 @measure_time
 def generate_video(input_image, prompt, height, width, 
                    negative_prompt=config.default_negative_prompt, 
-                   duration_seconds=1.0, guidance_scale=1, steps=3,
+                   duration_seconds=0.8, guidance_scale=1, steps=3,
                    seed=42, randomize_seed=False, 
                    progress=gr.Progress(track_tqdm=True)):
     
@@ -218,6 +244,7 @@ def generate_video(input_image, prompt, height, width,
             input_image, prompt, height, width, duration_seconds, steps
         )
         if not is_valid:
+            logger.warning(f"Validation failed: {error_msg}")
             raise gr.Error(error_msg)
         
         # 메모리 정리
@@ -228,6 +255,8 @@ def generate_video(input_image, prompt, height, width,
         # 모델 로딩 (GPU 함수 내에서)
         if pipe is None:
             try:
+                logger.info("Loading model components...")
+                
                 # 컴포넌트 로드
                 image_encoder = CLIPVisionModel.from_pretrained(
                     config.model_id, 
@@ -257,16 +286,8 @@ def generate_video(input_image, prompt, height, width,
                     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")
+                # LoRA 로드 건너뛰기 (안정성을 위해)
+                logger.info("Skipping LoRA for stability")
                 
                 # GPU로 이동
                 pipe.to("cuda")
@@ -275,11 +296,8 @@ def generate_video(input_image, prompt, height, width,
                 pipe.enable_vae_slicing()
                 pipe.enable_vae_tiling()
                 
-                # xFormers 시도
-                try:
-                    pipe.enable_xformers_memory_efficient_attention()
-                except:
-                    pass
+                # 모델 CPU 오프로드 활성화 (메모리 절약)
+                pipe.enable_model_cpu_offload()
                 
                 logger.info("Model loaded successfully")
                 
@@ -296,10 +314,12 @@ def generate_video(input_image, prompt, height, width,
         # 프레임 수 계산 (매우 보수적)
         num_frames = min(
             int(round(duration_seconds * config.fixed_fps)),
-            36  # 최대 36프레임 (1.5초)
+            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)
         
         # 이미지 리사이즈
@@ -308,37 +328,58 @@ def generate_video(input_image, prompt, height, width,
         progress(0.4, desc="🎬 Generating video...")
         
         # 비디오 생성
-        with torch.inference_mode(), torch.amp.autocast('cuda', enabled=True):
+        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[:200],  # 프롬프트 길이 제한
-                    negative_prompt=negative_prompt[:100],  # 네거티브 프롬프트도 제한
+                    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
+                    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.")
+                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: {e}")
-                raise gr.Error(f"❌ Generation failed: {str(e)[:100]}")
+                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...")
         
         # 비디오 저장
-        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)
+        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")
         
         progress(1.0, desc="✨ Complete!")
         logger.info(f"Video generated: {num_frames} frames, {target_h}x{target_w}")
@@ -346,15 +387,16 @@ def generate_video(input_image, prompt, height, width,
         # 메모리 정리
         del output_frames_list
         del resized_image
-        clear_gpu_memory()
+        torch.cuda.empty_cache()
+        gc.collect()
         
         return video_path, current_seed
         
     except gr.Error:
         raise
     except Exception as e:
-        logger.error(f"Unexpected error: {e}")
-        raise gr.Error(f"❌ Error: {str(e)[:100]}")
+        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()
@@ -425,12 +467,13 @@ with gr.Blocks(css=css, theme=gr.themes.Soft()) as demo:
         # 경고
         gr.HTML("""
         <div class="warning-box">
-            <strong>⚡ Zero GPU Limitations:</strong>
+            <strong>⚡ Zero GPU Strict Limitations:</strong>
             <ul style="margin: 5px 0; padding-left: 20px;">
-                <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>
+                <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>
         """)
@@ -452,9 +495,9 @@ with gr.Blocks(css=css, theme=gr.themes.Soft()) as demo:
                 
                 duration_input = gr.Slider(
                     minimum=0.3,
-                    maximum=1.5,
+                    maximum=1.2,
                     step=0.1,
-                    value=1.0,
+                    value=0.8,
                     label="⏱️ Duration (seconds)"
                 )
                 
@@ -468,25 +511,25 @@ with gr.Blocks(css=css, theme=gr.themes.Soft()) as demo:
                     with gr.Row():
                         height_slider = gr.Slider(
                             minimum=128,
-                            maximum=640,
+                            maximum=512,
                             step=32,
-                            value=384,
+                            value=256,
                             label="Height"
                         )
                         width_slider = gr.Slider(
                             minimum=128,
-                            maximum=640,
+                            maximum=512,
                             step=32,
-                            value=384,
+                            value=256,
                             label="Width"
                         )
                     
                     steps_slider = gr.Slider(
                         minimum=1,
-                        maximum=6,
+                        maximum=5,
                         step=1,
-                        value=3,
-                        label="Steps (3-4 recommended)"
+                        value=2,
+                        label="Steps (2-3 recommended)"
                     )
                     
                     with gr.Row():
@@ -524,11 +567,18 @@ with gr.Blocks(css=css, theme=gr.themes.Soft()) as demo:
                 )
                 
                 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
+                ### 💡 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
                 """)
         
         # Event handlers