Update app.py

app.py

@@ -3,33 +3,70 @@ import numpy as np
 from PIL import Image
 import torch
 import gc
+import os
+import warnings
+
+# Suppress specific warnings
+warnings.filterwarnings('ignore', category=FutureWarning)
+warnings.filterwarnings('ignore', category=UserWarning)
+warnings.filterwarnings('ignore', message='.*torch_dtype.*deprecated.*')
+warnings.filterwarnings('ignore', message='.*CLIPFeatureExtractor.*deprecated.*')
+
+# Performance optimizations
+if torch.cuda.is_available():
+    torch.backends.cudnn.benchmark = True
+    torch.backends.cuda.matmul.allow_tf32 = True
+    torch.backends.cudnn.allow_tf32 = True
 
 # Device
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 dtype = torch.float16 if torch.cuda.is_available() else torch.float32
 
+print(f"🖥️  Device: {device} | dtype: {dtype}")
+
 # Lazy import (to avoid long startup if unused)
 from diffusers import StableDiffusionControlNetPipeline, ControlNetModel, StableDiffusionPipeline
-from diffusers import StableDiffusionInstructPix2PixPipeline
 from controlnet_aux import LineartDetector, LineartAnimeDetector
 
+# Memory optimization
+if torch.cuda.is_available():
+    torch.cuda.empty_cache()
+    # Set memory fraction to prevent OOM
+    torch.cuda.set_per_process_memory_fraction(0.95)
+    print(f"🔥 GPU Memory: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.2f} GB")
+else:
+    print("⚠️  Running on CPU - Image generation will be significantly slower")
+
 # ===== Model & Config =====
-PIPELINES = {}  # key: (model_name, is_anime) -> pipeline
+CURRENT_CONTROLNET_PIPE = None
+CURRENT_CONTROLNET_KEY = None  # (model_name, is_anime)
 LINEART_DETECTOR = None
 LINEART_ANIME_DETECTOR = None
 CURRENT_T2I_PIPE = None
 CURRENT_T2I_MODEL = None
-CURRENT_PIX2PIX_PIPE = None
-CURRENT_PIX2PIX_MODEL = None
 
 def get_pipeline(model_name: str, anime_model: bool = False):
     """Get or create a ControlNet pipeline for the given model and anime flag"""
+    global CURRENT_CONTROLNET_PIPE, CURRENT_CONTROLNET_KEY
+    
     key = (model_name, anime_model)
     
-    if key in PIPELINES:
-        return PIPELINES[key]
+    # ถ้าเป็นโมเดลเดิมให้ใช้ต่อ
+    if CURRENT_CONTROLNET_KEY == key and CURRENT_CONTROLNET_PIPE is not None:
+        print(f"✅ Reusing existing ControlNet pipeline: {model_name}, anime: {anime_model}")
+        return CURRENT_CONTROLNET_PIPE
+    
+    # ถ้าเป็นโมเดลใหม่ ลบอันเก่าก่อน
+    if CURRENT_CONTROLNET_PIPE is not None:
+        print(f"🗑️ Unloading old ControlNet pipeline: {CURRENT_CONTROLNET_KEY}")
+        del CURRENT_CONTROLNET_PIPE
+        CURRENT_CONTROLNET_PIPE = None
+        CURRENT_CONTROLNET_KEY = None
+        gc.collect()
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
     
-    print(f"Loading ControlNet pipeline for model: {model_name}, anime: {anime_model}")
+    print(f"📥 Loading ControlNet pipeline for model: {model_name}, anime: {anime_model}")
     
     try:
         # โหลด ControlNet ที่เหมาะสม
@@ -50,20 +87,111 @@ def get_pipeline(model_name: str, anime_model: bool = False):
             controlnet=controlnet, 
             torch_dtype=dtype,
             safety_checker=None, 
-            requires_safety_checker=False
+            requires_safety_checker=False,
+            use_safetensors=True,
+            variant="fp16" if dtype == torch.float16 else None
         ).to(device)
         
-        pipe.enable_attention_slicing()
+        # Aggressive memory optimizations
+        pipe.enable_attention_slicing(slice_size="max")
+        
+        # Use new API for VAE slicing
+        if hasattr(pipe, 'vae') and hasattr(pipe.vae, 'enable_slicing'):
+            pipe.vae.enable_slicing()
+        else:
+            # Fallback for older versions
+            try:
+                pipe.enable_vae_slicing()
+            except:
+                pass
+        
         if device.type == "cuda":
+            # Use xformers if available for better performance
+            try:
+                pipe.enable_xformers_memory_efficient_attention()
+                print("✅ xFormers enabled for ControlNet")
+            except:
+                print("⚠️  xFormers not available, using standard attention")
+                pass
+            
+            # Enable model CPU offload for memory efficiency
             pipe.enable_model_cpu_offload()
         
-        # เก็บ pipeline ไว้ใน cache
-        PIPELINES[key] = pipe
+        # Compile model for faster inference (PyTorch 2.0+)
+        if hasattr(torch, 'compile') and device.type == "cuda":
+            try:
+                pipe.unet = torch.compile(pipe.unet, mode="reduce-overhead", fullgraph=True)
+                print("✅ Model compiled with torch.compile")
+            except Exception as e:
+                print(f"⚠️  torch.compile not available: {e}")
+                pass
+        
+        # เก็บ pipeline ปัจจุบัน
+        CURRENT_CONTROLNET_PIPE = pipe
+        CURRENT_CONTROLNET_KEY = key
         return pipe
         
     except Exception as e:
         print(f"Error loading ControlNet pipeline: {e}")
-        raise
+        print(f"⚠️  Trying to load without use_safetensors...")
+        
+        # Retry without use_safetensors for models that don't support it
+        try:
+            if anime_model:
+                controlnet = ControlNetModel.from_pretrained(
+                    "lllyasviel/control_v11p_sd15s2_lineart_anime", 
+                    torch_dtype=dtype
+                ).to(device)
+            else:
+                controlnet = ControlNetModel.from_pretrained(
+                    "lllyasviel/control_v11p_sd15_lineart", 
+                    torch_dtype=dtype
+                ).to(device)
+            
+            pipe = StableDiffusionControlNetPipeline.from_pretrained(
+                model_name, 
+                controlnet=controlnet, 
+                torch_dtype=dtype,
+                safety_checker=None, 
+                requires_safety_checker=False
+            ).to(device)
+            
+            # Optimizations
+            pipe.enable_attention_slicing(slice_size="max")
+            if hasattr(pipe, 'vae') and hasattr(pipe.vae, 'enable_slicing'):
+                pipe.vae.enable_slicing()
+            else:
+                try:
+                    pipe.enable_vae_slicing()
+                except:
+                    pass
+            
+            if device.type == "cuda":
+                try:
+                    pipe.enable_xformers_memory_efficient_attention()
+                    print("✅ xFormers enabled for ControlNet")
+                except:
+                    print("⚠️  xFormers not available, using standard attention")
+                    pass
+                pipe.enable_model_cpu_offload()
+            
+            if hasattr(torch, 'compile') and device.type == "cuda":
+                try:
+                    pipe.unet = torch.compile(pipe.unet, mode="reduce-overhead", fullgraph=True)
+                    print("✅ Model compiled with torch.compile")
+                except Exception as compile_err:
+                    print(f"⚠️  torch.compile not available: {compile_err}")
+                    pass
+            
+            CURRENT_CONTROLNET_PIPE = pipe
+            CURRENT_CONTROLNET_KEY = key
+            return pipe
+            
+        except Exception as retry_e:
+            print(f"❌ Error loading ControlNet pipeline (retry): {retry_e}")
+            CURRENT_CONTROLNET_PIPE = None
+            CURRENT_CONTROLNET_KEY = None
+            raise
 
 def load_lineart_detectors():
     """Load lineart detectors if not already loaded"""
@@ -83,56 +211,97 @@ def load_t2i_model(model_name: str):
         if CURRENT_T2I_MODEL == model_name and CURRENT_T2I_PIPE is not None:
             return
         if CURRENT_T2I_PIPE is not None:
+            print(f"🗑️ Unloading old T2I model: {CURRENT_T2I_MODEL}")
             del CURRENT_T2I_PIPE
             CURRENT_T2I_PIPE = None
             gc.collect()
             if torch.cuda.is_available():
                 torch.cuda.empty_cache()
         
-        print(f"Loading T2I model: {model_name}")
+        print(f"📥 Loading T2I model: {model_name}")
         CURRENT_T2I_PIPE = StableDiffusionPipeline.from_pretrained(
-            model_name, torch_dtype=dtype, safety_checker=None, requires_safety_checker=False
+            model_name, 
+            torch_dtype=dtype, 
+            safety_checker=None, 
+            requires_safety_checker=False,
+            use_safetensors=True,
+            variant="fp16" if dtype == torch.float16 else None
         ).to(device)
-        CURRENT_T2I_PIPE.enable_attention_slicing()
+        
+        # Optimizations
+        CURRENT_T2I_PIPE.enable_attention_slicing(slice_size="max")
+        
+        # Use new API for VAE slicing
+        if hasattr(CURRENT_T2I_PIPE, 'vae') and hasattr(CURRENT_T2I_PIPE.vae, 'enable_slicing'):
+            CURRENT_T2I_PIPE.vae.enable_slicing()
+        else:
+            try:
+                CURRENT_T2I_PIPE.enable_vae_slicing()
+            except:
+                pass
+        
         if device.type == "cuda":
+            try:
+                CURRENT_T2I_PIPE.enable_xformers_memory_efficient_attention()
+                print("✅ xFormers enabled for T2I")
+            except:
+                pass
             CURRENT_T2I_PIPE.enable_model_cpu_offload()
+        
+        # Compile if available
+        if hasattr(torch, 'compile') and device.type == "cuda":
+            try:
+                CURRENT_T2I_PIPE.unet = torch.compile(CURRENT_T2I_PIPE.unet, mode="reduce-overhead", fullgraph=True)
+                print("✅ T2I model compiled")
+            except:
+                pass
+        
         CURRENT_T2I_MODEL = model_name
         
     except Exception as e:
         print(f"Error loading T2I model {model_name}: {e}")
-        # รีเซ็ตตัวแปรเมื่อโหลดไม่ส���เร็จ
-        CURRENT_T2I_PIPE = None
-        CURRENT_T2I_MODEL = None
-        raise
-
-def load_pix2pix_model():
-    """Load Instruct-Pix2Pix model for image editing"""
-    global CURRENT_PIX2PIX_PIPE, CURRENT_PIX2PIX_MODEL
-    
-    if CURRENT_PIX2PIX_PIPE is not None:
-        return CURRENT_PIX2PIX_PIPE
-    
-    try:
-        print("Loading Instruct-Pix2Pix model...")
-        CURRENT_PIX2PIX_PIPE = StableDiffusionInstructPix2PixPipeline.from_pretrained(
-            "timbrooks/instruct-pix2pix",
-            torch_dtype=dtype,
-            safety_checker=None,
-            requires_safety_checker=False
-        ).to(device)
+        print(f"⚠️  Trying to load without use_safetensors...")
         
-        CURRENT_PIX2PIX_PIPE.enable_attention_slicing()
-        if device.type == "cuda":
-            CURRENT_PIX2PIX_PIPE.enable_model_cpu_offload()
-        
-        CURRENT_PIX2PIX_MODEL = "timbrooks/instruct-pix2pix"
-        return CURRENT_PIX2PIX_PIPE
-        
-    except Exception as e:
-        print(f"Error loading Instruct-Pix2Pix model: {e}")
-        CURRENT_PIX2PIX_PIPE = None
-        CURRENT_PIX2PIX_MODEL = None
-        raise
+        # Retry without use_safetensors
+        try:
+            CURRENT_T2I_PIPE = StableDiffusionPipeline.from_pretrained(
+                model_name, 
+                torch_dtype=dtype, 
+                safety_checker=None, 
+                requires_safety_checker=False
+            ).to(device)
+            
+            CURRENT_T2I_PIPE.enable_attention_slicing(slice_size="max")
+            if hasattr(CURRENT_T2I_PIPE, 'vae') and hasattr(CURRENT_T2I_PIPE.vae, 'enable_slicing'):
+                CURRENT_T2I_PIPE.vae.enable_slicing()
+            else:
+                try:
+                    CURRENT_T2I_PIPE.enable_vae_slicing()
+                except:
+                    pass
+            
+            if device.type == "cuda":
+                try:
+                    CURRENT_T2I_PIPE.enable_xformers_memory_efficient_attention()
+                    print("✅ xFormers enabled for T2I")
+                except:
+                    pass
+                CURRENT_T2I_PIPE.enable_model_cpu_offload()
+            
+            if hasattr(torch, 'compile') and device.type == "cuda":
+                try:
+                    CURRENT_T2I_PIPE.unet = torch.compile(CURRENT_T2I_PIPE.unet, mode="reduce-overhead", fullgraph=True)
+                    print("✅ T2I model compiled")
+                except:
+                pass
+            
+            CURRENT_T2I_MODEL = model_name
+            
+        except Exception as retry_e:
+            print(f"❌ Error loading T2I model (retry): {retry_e}")
+            CURRENT_T2I_PIPE = None
+            CURRENT_T2I_MODEL = None
+            raise
 
 # ===== Utils =====
 def is_lineart(img: Image.Image) -> bool:
@@ -161,97 +330,82 @@ def resize_image(image, max_size=512):
 # ===== Functions =====
 def colorize(sketch, base_model, anime_model, prompt, seed, steps, scale, cn_weight):
     try:
-        # โหลด pipeline ที่เหมาะสม
+        # โหลด pipeline ที่เหมาะสม (จะลบอันเก่าออกอัตโนมัติถ้าเปลี่ยนโมเดล)
         pipe = get_pipeline(base_model, anime_model)
         
+        # แสดงโมเดลที่กำลังใช้
+        controlnet_type = "Anime" if anime_model else "Standard"
+        status_msg = f"🎨 Using: {base_model} + {controlnet_type} ControlNet"
+        print(status_msg)
+        
         # สกัด lineart
         lineart = extract_lineart(sketch, anime_model)
         
-        # สร้างภาพ
+        # สร้างภาพ with optimizations
         gen = torch.Generator(device=device).manual_seed(int(seed))
-        out = pipe(
-            prompt, 
-            image=lineart, 
-            num_inference_steps=int(steps),
-            guidance_scale=float(scale), 
-            controlnet_conditioning_scale=float(cn_weight),
-            generator=gen
-        ).images[0]
+        
+        with torch.inference_mode():
+            out = pipe(
+                prompt, 
+                image=lineart, 
+                num_inference_steps=int(steps),
+                guidance_scale=float(scale), 
+                controlnet_conditioning_scale=float(cn_weight),
+                generator=gen
+            ).images[0]
+        
+        # Clear cache after generation
+        if device.type == "cuda":
+            torch.cuda.empty_cache()
         
         return out, lineart
     except Exception as e:
-        print(f"Error in colorize: {e}")
-        # ส่งกลับรูปภาพว่างพร้อมแสดง error
+        print(f"❌ Error in colorize: {e}")
         error_img = Image.new('RGB', (512, 512), color='red')
-        error_text = f"Error: {str(e)[:50]}..."
         return error_img, Image.new('RGB', (512, 512), color='gray')
 
 def t2i(prompt, model, seed, steps, scale, w, h):
     try:
         load_t2i_model(model)
-        gen = torch.Generator(device=device).manual_seed(int(seed))
-        return CURRENT_T2I_PIPE(
-            prompt, 
-            width=int(w), 
-            height=int(h),
-            num_inference_steps=int(steps), 
-            guidance_scale=float(scale),
-            generator=gen
-        ).images[0]
-    except Exception as e:
-        print(f"Error in t2i: {e}")
-        # ส่งกลับรูปภาพว่างพร้อมแสดง error
-        error_img = Image.new('RGB', (int(w), int(h)), color='red')
-        return error_img
-
-def pix2pix_edit(image, instruction, seed, steps, scale, image_scale):
-    """Edit image using Instruct-Pix2Pix"""
-    try:
-        # โหลดโมเดล
-        pipe = load_pix2pix_model()
+        print(f"🖼️ Using T2I model: {model}")
         
-        # ปรับขนาดภาพ
-        image = resize_image(image, max_size=768)
-        
-        # สร้าง generator
         gen = torch.Generator(device=device).manual_seed(int(seed))
         
-        # แก้ไขภาพ
-        result = pipe(
-            instruction,
-            image=image,
-            num_inference_steps=int(steps),
-            guidance_scale=float(scale),
-            image_guidance_scale=float(image_scale),
-            generator=gen
-        ).images[0]
+        with torch.inference_mode():
+            result = CURRENT_T2I_PIPE(
+                prompt, 
+                width=int(w), 
+                height=int(h),
+                num_inference_steps=int(steps), 
+                guidance_scale=float(scale),
+                generator=gen
+            ).images[0]
         
-        return result
+        if device.type == "cuda":
+            torch.cuda.empty_cache()
         
+        return result
     except Exception as e:
-        print(f"Error in pix2pix_edit: {e}")
-        # ส่งกลับรูปภาพ error
-        if image:
-            error_img = Image.new('RGB', image.size, color='red')
-        else:
-            error_img = Image.new('RGB', (512, 512), color='red')
+        print(f"❌ Error in t2i: {e}")
+        error_img = Image.new('RGB', (int(w), int(h)), color='red')
         return error_img
 
 # ===== Function to unload all models =====
 def unload_all_models():
-    global PIPELINES, LINEART_DETECTOR, LINEART_ANIME_DETECTOR
+    global CURRENT_CONTROLNET_PIPE, CURRENT_CONTROLNET_KEY
+    global LINEART_DETECTOR, LINEART_ANIME_DETECTOR
     global CURRENT_T2I_PIPE, CURRENT_T2I_MODEL
-    global CURRENT_PIX2PIX_PIPE, CURRENT_PIX2PIX_MODEL
     
     print("Unloading all models from memory...")
     
-    # Unload ControlNet pipelines
-    for key, pipe in list(PIPELINES.items()):
-        try:
-            del pipe
-        except:
-            pass
-    PIPELINES.clear()
+    # Unload ControlNet pipeline
+    try:
+        if CURRENT_CONTROLNET_PIPE is not None:
+            del CURRENT_CONTROLNET_PIPE
+            CURRENT_CONTROLNET_PIPE = None
+    except:
+        pass
+    CURRENT_CONTROLNET_KEY = None
     
     # Unload lineart detectors
     try:
@@ -275,39 +429,43 @@ def unload_all_models():
             CURRENT_T2I_PIPE = None
     except:
         pass
-    
     CURRENT_T2I_MODEL = None
     
-    # Unload Pix2Pix model
-    try:
-        if CURRENT_PIX2PIX_PIPE is not None:
-            del CURRENT_PIX2PIX_PIPE
-            CURRENT_PIX2PIX_PIPE = None
-    except:
-        pass
-    
-    CURRENT_PIX2PIX_MODEL = None
-    
     # Force garbage collection
     gc.collect()
     if torch.cuda.is_available():
         torch.cuda.empty_cache()
         allocated = torch.cuda.memory_allocated() / 1024**3
-        print(f"GPU memory cleared. Allocated: {allocated:.2f} GB")
+        reserved = torch.cuda.memory_reserved() / 1024**3
+        print(f"💾 GPU memory - Allocated: {allocated:.2f} GB, Reserved: {reserved:.2f} GB")
     
     return "✅ All models unloaded from memory!"
 
 # ===== Gradio UI =====
-with gr.Blocks() as demo:
+with gr.Blocks(title="🎨 Advanced Image Generation Suite", theme=gr.themes.Soft()) as demo:
     gr.Markdown("# 🎨 Advanced Image Generation & Editing Suite")
+    gr.Markdown("### Powered by Stable Diffusion & ControlNet")
+    
+    # Add system info
+    if torch.cuda.is_available():
+        gpu_name = torch.cuda.get_device_name(0)
+        gpu_memory = torch.cuda.get_device_properties(0).total_memory / 1024**3
+        gr.Markdown(f"**GPU:** {gpu_name} ({gpu_memory:.1f} GB)")
+    else:
+        gr.Markdown("**⚠️ Running on CPU** - Generation will be slower")
     
     # Add unload button at the top
     with gr.Row():
-        unload_btn = gr.Button("🗑️ Unload All Models", variant="stop")
-        status_text = gr.Textbox(label="Status", interactive=False)
+        unload_btn = gr.Button("🗑️ Unload All Models", variant="stop", scale=1)
+        status_text = gr.Textbox(label="Status", interactive=False, scale=3)
     unload_btn.click(unload_all_models, outputs=status_text)
 
     with gr.Tab("🎨 Colorize Sketch"):
+        gr.Markdown("""
+        ### Convert your sketches to colored images using ControlNet
+        Upload a sketch or line art, and the AI will automatically colorize it based on your prompt.
+        """)
+        
         with gr.Row():
             inp = gr.Image(label="Input Sketch/Image", type="pil")
             out = gr.Image(label="Colored Output")
@@ -316,15 +474,14 @@ with gr.Blocks() as demo:
             sketch_out = gr.Image(label="Detected Lineart", type="pil")
         
         with gr.Row():
-            # เอาโมเดล stabilityai/stable-diffusion-2-1 และ runwayml/stable-diffusion-v1-5 ออกแล้ว
             base_model = gr.Dropdown(
                 choices=[
-                    "admruul/anything-v3.0",
                     "digiplay/ChikMix_V3",
                     "digiplay/chilloutmix_NiPrunedFp16Fix",
-                    "gsdf/Counterfeit-V2.5"
+                    "gsdf/Counterfeit-V2.5",
+                    "stablediffusionapi/anything-v5"
                 ],
-                value="admruul/anything-v3.0",
+                value="digiplay/ChikMix_V3",
                 label="Base Model"
             )
             anime_chk = gr.Checkbox(label="Use Anime ControlNet", value=True)
@@ -350,20 +507,28 @@ with gr.Blocks() as demo:
         )
 
     with gr.Tab("🖼️ Text-to-Image"):
+        gr.Markdown("""
+        ### Generate images from text descriptions
+        Describe what you want to see, and the AI will create it for you.
+        """)
+        
         with gr.Row():
             t2i_out = gr.Image(label="Output", type="pil")
         
         with gr.Row():
-            t2i_prompt = gr.Textbox(label="Prompt", lines=3)
-            # เอาโมเดล stabilityai/stable-diffusion-2-1 และ runwayml/stable-diffusion-v1-5 ออกแล้ว
+            t2i_prompt = gr.Textbox(
+                label="Prompt", 
+                lines=3,
+                placeholder="e.g., a beautiful landscape with mountains and a lake at sunset, highly detailed, 4k"
+            )
             t2i_model = gr.Dropdown(
                 choices=[
-                    "admruul/anything-v3.0",
                     "digiplay/ChikMix_V3",
                     "digiplay/chilloutmix_NiPrunedFp16Fix",
-                    "gsdf/Counterfeit-V2.5"
+                    "gsdf/Counterfeit-V2.5",
+                    "stablediffusionapi/anything-v5"
                 ],
-                value="admruul/anything-v3.0",
+                value="digiplay/ChikMix_V3",
                 label="Model"
             )
         
@@ -382,56 +547,14 @@ with gr.Blocks() as demo:
             [t2i_prompt, t2i_model, t2i_seed, t2i_steps, t2i_scale, w, h], 
             t2i_out
         )
-    
-    with gr.Tab("🔄 Instruct-Pix2Pix"):
-        gr.Markdown("### Edit Images with Text Instructions")
-        gr.Markdown("ตัวอย่างคำสั่ง: 'make it winter', 'turn day into night', 'add sunglasses', 'make it look like a painting'")
-        
-        with gr.Row():
-            with gr.Column():
-                pix2pix_input = gr.Image(label="Input Image", type="pil")
-                pix2pix_instruction = gr.Textbox(
-                    label="Edit Instruction",
-                    placeholder="e.g., make it winter, turn day into night, add sunglasses...",
-                    lines=2
-                )
-                
-                with gr.Row():
-                    pix2pix_seed = gr.Number(value=42, label="Seed")
-                    pix2pix_steps = gr.Slider(10, 100, 50, step=5, label="Steps")
-                
-                with gr.Row():
-                    pix2pix_scale = gr.Slider(1, 20, 7.5, step=0.5, label="Text Guidance Scale")
-                    pix2pix_image_scale = gr.Slider(1, 5, 1.5, step=0.1, label="Image Guidance Scale")
-                
-                pix2pix_btn = gr.Button("🔄 Edit Image", variant="primary")
-            
-            with gr.Column():
-                pix2pix_output = gr.Image(label="Edited Image", type="pil")
-        
-        # ตัวอย่างคำสั่งที่พบบ่อย
-        with gr.Row():
-            gr.Examples(
-                examples=[
-                    ["make it winter", 42, 50, 7.5, 1.5],
-                    ["turn day into night", 42, 50, 7.5, 1.5],
-                    ["make it look like a painting", 42, 50, 7.5, 1.5],
-                    ["add sunglasses", 42, 50, 7.5, 1.5],
-                    ["make it cyberpunk style", 42, 50, 7.5, 1.5],
-                    ["change hair color to blue", 42, 50, 7.5, 1.5],
-                ],
-                inputs=[pix2pix_instruction, pix2pix_seed, pix2pix_steps, pix2pix_scale, pix2pix_image_scale],
-                label="Quick Examples"
-            )
-        
-        pix2pix_btn.click(
-            pix2pix_edit,
-            [pix2pix_input, pix2pix_instruction, pix2pix_seed, pix2pix_steps, pix2pix_scale, pix2pix_image_scale],
-            pix2pix_output
-        )
 
-# เพิ่ม error handling ในการ launch
 try:
-    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)
+    demo.launch(
+        server_name="0.0.0.0", 
+        server_port=7860, 
+        share=False,
+        show_error=True,
+        quiet=False
+    )
 except Exception as e:
-    print(f"Error launching Gradio app: {e}")
+    print(f"❌ Error launching Gradio app: {e}")