Update app.py

app.py

@@ -29,7 +29,9 @@ from diffusers import (
     StableDiffusionControlNetPipeline, 
     ControlNetModel, 
     StableDiffusionPipeline,
-    StableDiffusionXLPipeline
+    StableDiffusionXLPipeline,
+    StableDiffusionXLControlNetPipeline,
+    AutoPipelineForText2Image
 )
 from diffusers import UniPCMultistepScheduler, DPMSolverMultistepScheduler, EulerAncestralDiscreteScheduler
 from controlnet_aux import (
@@ -60,11 +62,14 @@ CURRENT_CONTROLNET_KEY = None
 CURRENT_T2I_PIPE = None
 CURRENT_T2I_MODEL = None
 CURRENT_SDXL_REFINER = None
+CURRENT_TURBO_PIPE = None
+CURRENT_TURBO_MODEL = None
 
 # Enhanced SDXL Models (including NSFW-capable)
 SDXL_MODELS = [
     "stabilityai/stable-diffusion-xl-base-1.0",
     "stabilityai/stable-diffusion-xl-refiner-1.0",
+    "stabilityai/sdxl-turbo",  # เพิ่ม SDXL-Turbo
     "Laxhar/noobai-XL-1.1",
     "RunDiffusion/Juggernaut-XL-v9",
     "dataautogpt3/ProteusV0.4",
@@ -76,6 +81,12 @@ SDXL_MODELS = [
     "digiplay/Pony_Diffusion_V6_XL"
 ]
 
+# Turbo models (fast generation)
+TURBO_MODELS = [
+    "stabilityai/sdxl-turbo",
+    "stabilityai/sd-turbo"
+]
+
 # Enhanced SD1.5 Models (including NSFW-capable)
 SD15_MODELS = [
     # Original models
@@ -117,6 +128,11 @@ SD15_MODELS = [
     "Fictiverse/Stable_Diffusion_VoxelArt_Model"
 ]
 
+# Specialized models
+SPECIAL_MODELS = {
+    "waifu_colorize": "ShinoharaHare/Waifu-Colorize-XL"  # โมเดลสำหรับ colorize โดยเฉพาะ
+}
+
 # Chinese Models
 CHINESE_MODELS = [
     "AI-Chen/Chinese-Stable-Diffusion",
@@ -144,7 +160,8 @@ CONTROLNET_MODELS_SD15 = {
 CONTROLNET_MODELS_SDXL = {
     "canny_sdxl": "diffusers/controlnet-canny-sdxl-1.0",
     "depth_sdxl": "diffusers/controlnet-depth-sdxl-1.0",
-    "openpose_sdxl": "thibaud/controlnet-openpose-sdxl-1.0"
+    "openpose_sdxl": "thibaud/controlnet-openpose-sdxl-1.0",
+    "lineart_sdxl": "ShermanG/ControlNet-Standard-Lineart-for-SDXL"  # เพิ่ม ControlNet Lineart สำหรับ SDXL
 }
 
 # แก้ไข LoRA models ให้ใช้ชื่อที่ไม่มีช่องว่าง
@@ -189,7 +206,9 @@ LORA_MODELS = {
     "realistic-nsfw": "digiplay/RealisticNSFW_v1",
     "anime-nsfw": "Linaqruf/anime-nsfw-lora",
     "hentai-diffusion": "Deltaadams/Hentai-Diffusion",
-    "sexy-pose": "alvdansen/sexy-pose-lora"
+    "sexy-pose": "alvdansen/sexy-pose-lora",
+    # Colorize LoRAs
+    "colorize-xl": "ShinoharaHare/Waifu-Colorize-XL"
 }
 
 # VAE models for better quality
@@ -197,7 +216,8 @@ VAE_MODELS = {
     "None": None,
     "SD1.5 VAE": "stabilityai/sd-vae-ft-mse",
     "Anime VAE": "hakurei/waifu-diffusion-v1-4",
-    "SDXL VAE": "madebyollin/sdxl-vae-fp16-fix"
+    "SDXL VAE": "madebyollin/sdxl-vae-fp16-fix",
+    "Turbo VAE": "madebyollin/sdxl-vae-fp16-fix"
 }
 
 # Detector instances
@@ -207,6 +227,10 @@ def is_sdxl_model(model_name: str) -> bool:
     """Check if model is SDXL"""
     return model_name in SDXL_MODELS or "xl" in model_name.lower() or "XL" in model_name
 
+def is_turbo_model(model_name: str) -> bool:
+    """Check if model is Turbo"""
+    return model_name in TURBO_MODELS or "turbo" in model_name.lower()
+
 def load_detector(detector_type: str):
     """Lazy load detector"""
     global DETECTORS
@@ -250,14 +274,19 @@ def load_detector(detector_type: str):
 def get_controlnet_model(controlnet_type: str, is_sdxl: bool = False):
     """Get ControlNet model based on type"""
     if is_sdxl:
+        if controlnet_type not in CONTROLNET_MODELS_SDXL:
+            raise ValueError(f"SDXL ControlNet type must be one of: {list(CONTROLNET_MODELS_SDXL.keys())}")
         return CONTROLNET_MODELS_SDXL[controlnet_type]
     else:
+        if controlnet_type not in CONTROLNET_MODELS_SD15:
+            raise ValueError(f"SD1.5 ControlNet type must be one of: {list(CONTROLNET_MODELS_SD15.keys())}")
         return CONTROLNET_MODELS_SD15[controlnet_type]
 
 def prepare_condition_image(image, controlnet_type, is_sdxl=False):
     """Prepare condition image for ControlNet"""
-    if controlnet_type in ["lineart", "lineart_anime"]:
-        detector = load_detector("lineart_anime" if controlnet_type == "lineart_anime" else "lineart")
+    if "lineart" in controlnet_type:
+        detector_type = "lineart_anime" if "anime" in controlnet_type else "lineart"
+        detector = load_detector(detector_type)
         if detector:
             result = detector(image, detect_resolution=512 if not is_sdxl else 1024, image_resolution=512 if not is_sdxl else 1024)
             return Image.fromarray(result) if isinstance(result, np.ndarray) else result
@@ -312,11 +341,7 @@ def get_pipeline(model_name: str, controlnet_type: str = "lineart", lora_model:
     
     try:
         is_sdxl = is_sdxl_model(model_name)
-        
-        if is_sdxl and controlnet_type not in CONTROLNET_MODELS_SDXL:
-            raise ValueError(f"SDXL model only supports: {list(CONTROLNET_MODELS_SDXL.keys())}")
-        elif not is_sdxl and controlnet_type not in CONTROLNET_MODELS_SD15:
-            raise ValueError(f"SD1.5 model only supports: {list(CONTROLNET_MODELS_SD15.keys())}")
+        is_turbo = is_turbo_model(model_name)
         
         controlnet_model_name = get_controlnet_model(controlnet_type, is_sdxl)
         controlnet = ControlNetModel.from_pretrained(
@@ -325,15 +350,27 @@ def get_pipeline(model_name: str, controlnet_type: str = "lineart", lora_model:
         ).to(device)
         
         if is_sdxl:
-            pipe = StableDiffusionXLPipeline.from_pretrained(
-                model_name, 
-                controlnet=controlnet, 
-                torch_dtype=dtype,
-                safety_checker=None,
-                requires_safety_checker=False,
-                use_safetensors=True,
-                variant="fp16" if dtype == torch.float16 else None
-            ).to(device)
+            if is_turbo:
+                # สำหรับ Turbo models ใช้ pipeline ที่เหมาะสม
+                pipe = StableDiffusionXLControlNetPipeline.from_pretrained(
+                    model_name, 
+                    controlnet=controlnet, 
+                    torch_dtype=dtype,
+                    safety_checker=None,
+                    requires_safety_checker=False,
+                    use_safetensors=True,
+                    variant="fp16" if dtype == torch.float16 else None
+                ).to(device)
+            else:
+                pipe = StableDiffusionXLControlNetPipeline.from_pretrained(
+                    model_name, 
+                    controlnet=controlnet, 
+                    torch_dtype=dtype,
+                    safety_checker=None,
+                    requires_safety_checker=False,
+                    use_safetensors=True,
+                    variant="fp16" if dtype == torch.float16 else None
+                ).to(device)
         else:
             pipe = StableDiffusionControlNetPipeline.from_pretrained(
                 model_name, 
@@ -388,14 +425,23 @@ def get_pipeline(model_name: str, controlnet_type: str = "lineart", lora_model:
                 pass
             pipe.enable_model_cpu_offload()
         
-        try:
-            pipe.scheduler = EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config)
-            print("✅ Using Euler Ancestral scheduler")
-        except:
+        # ใช้ scheduler ที่เหมาะสมสำหรับแต่ละโมเดล
+        if is_turbo:
+            # สำหรับ Turbo models ใช้ scheduler ที่เร็วขึ้น
             try:
-                pipe.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
+                pipe.scheduler = UniPCMultistepScheduler.from_config(pipe.scheduler.config)
+                print("✅ Using UniPC scheduler for Turbo")
             except:
                 pass
+        else:
+            try:
+                pipe.scheduler = EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config)
+                print("✅ Using Euler Ancestral scheduler")
+            except:
+                try:
+                    pipe.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
+                except:
+                    pass
         
         CURRENT_CONTROLNET_PIPE = pipe
         CURRENT_CONTROLNET_KEY = key
@@ -410,29 +456,55 @@ def get_pipeline(model_name: str, controlnet_type: str = "lineart", lora_model:
 def load_t2i_model(model_name: str, lora_model: str = None, lora_weight: float = 0.8, 
                    vae_model: str = None):
     """Load text-to-image model with optional LoRA and VAE"""
-    global CURRENT_T2I_PIPE, CURRENT_T2I_MODEL, CURRENT_SDXL_REFINER
+    global CURRENT_T2I_PIPE, CURRENT_T2I_MODEL, CURRENT_SDXL_REFINER, CURRENT_TURBO_PIPE, CURRENT_TURBO_MODEL
     
-    use_refiner = "refiner" in model_name.lower()
-    key = (model_name, lora_model, lora_weight, vae_model, use_refiner)
+    is_turbo = is_turbo_model(model_name)
+    use_refiner = "refiner" in model_name.lower() and not is_turbo
     
-    if CURRENT_T2I_MODEL == key and CURRENT_T2I_PIPE is not None:
-        return
+    key = (model_name, lora_model, lora_weight, vae_model, use_refiner, is_turbo)
     
-    if CURRENT_T2I_PIPE is not None:
-        print(f"🗑️ Unloading old T2I model: {CURRENT_T2I_MODEL}")
-        del CURRENT_T2I_PIPE
-        CURRENT_T2I_PIPE = None
-        if CURRENT_SDXL_REFINER is not None:
-            del CURRENT_SDXL_REFINER
-            CURRENT_SDXL_REFINER = None
-        gc.collect()
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
+    if is_turbo:
+        if CURRENT_TURBO_MODEL == key and CURRENT_TURBO_PIPE is not None:
+            return
+    else:
+        if CURRENT_T2I_MODEL == key and CURRENT_T2I_PIPE is not None:
+            return
+    
+    if is_turbo:
+        if CURRENT_TURBO_PIPE is not None:
+            print(f"🗑️ Unloading old Turbo model: {CURRENT_TURBO_MODEL}")
+            del CURRENT_TURBO_PIPE
+            CURRENT_TURBO_PIPE = None
+    else:
+        if CURRENT_T2I_PIPE is not None:
+            print(f"🗑️ Unloading old T2I model: {CURRENT_T2I_MODEL}")
+            del CURRENT_T2I_PIPE
+            CURRENT_T2I_PIPE = None
+            if CURRENT_SDXL_REFINER is not None:
+                del CURRENT_SDXL_REFINER
+                CURRENT_SDXL_REFINER = None
+    
+    gc.collect()
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
     
     print(f"📥 Loading T2I model: {model_name}")
     
     try:
-        if is_sdxl_model(model_name):
+        if is_turbo:
+            # โหลด Turbo model
+            CURRENT_TURBO_PIPE = AutoPipelineForText2Image.from_pretrained(
+                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_TURBO_MODEL = key
+            pipe = CURRENT_TURBO_PIPE
+        elif is_sdxl_model(model_name):
             if use_refiner:
                 CURRENT_T2I_PIPE = StableDiffusionXLPipeline.from_pretrained(
                     "stabilityai/stable-diffusion-xl-base-1.0",
@@ -462,6 +534,9 @@ def load_t2i_model(model_name: str, lora_model: str = None, lora_weight: float =
                     use_safetensors=True,
                     variant="fp16" if dtype == torch.float16 else None
                 ).to(device)
+            
+            CURRENT_T2I_MODEL = key
+            pipe = CURRENT_T2I_PIPE
         else:
             CURRENT_T2I_PIPE = StableDiffusionPipeline.from_pretrained(
                 model_name,
@@ -471,6 +546,9 @@ def load_t2i_model(model_name: str, lora_model: str = None, lora_weight: float =
                 use_safetensors=True,
                 variant="fp16" if dtype == torch.float16 else None
             ).to(device)
+            
+            CURRENT_T2I_MODEL = key
+            pipe = CURRENT_T2I_PIPE
         
         # Load custom VAE
         if vae_model and vae_model != "None":
@@ -478,7 +556,7 @@ def load_t2i_model(model_name: str, lora_model: str = None, lora_weight: float =
                 from diffusers import AutoencoderKL
                 print(f"🔄 Loading custom VAE: {vae_model}")
                 vae = AutoencoderKL.from_pretrained(vae_model, torch_dtype=dtype).to(device)
-                CURRENT_T2I_PIPE.vae = vae
+                pipe.vae = vae
             except Exception as e:
                 print(f"⚠️  Error loading VAE: {e}")
         
@@ -488,43 +566,53 @@ def load_t2i_model(model_name: str, lora_model: str = None, lora_weight: float =
             try:
                 if lora_model in LORA_MODELS:
                     lora_path = LORA_MODELS[lora_model]
-                    CURRENT_T2I_PIPE.load_lora_weights(lora_path)
-                    CURRENT_T2I_PIPE.fuse_lora(lora_scale=lora_weight)
+                    pipe.load_lora_weights(lora_path)
+                    pipe.fuse_lora(lora_scale=lora_weight)
                 else:
-                    CURRENT_T2I_PIPE.load_lora_weights(lora_model)
-                    CURRENT_T2I_PIPE.fuse_lora(lora_scale=lora_weight)
+                    pipe.load_lora_weights(lora_model)
+                    pipe.fuse_lora(lora_scale=lora_weight)
             except Exception as e:
                 print(f"⚠️  Error loading LoRA: {e}")
         
         # Optimizations
-        CURRENT_T2I_PIPE.enable_attention_slicing(slice_size="max")
+        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()
+        if hasattr(pipe, 'vae') and hasattr(pipe.vae, 'enable_slicing'):
+            pipe.vae.enable_slicing()
         else:
             try:
-                CURRENT_T2I_PIPE.enable_vae_slicing()
+                pipe.enable_vae_slicing()
             except:
                 pass
         
         if device.type == "cuda":
             try:
-                CURRENT_T2I_PIPE.enable_xformers_memory_efficient_attention()
+                pipe.enable_xformers_memory_efficient_attention()
             except:
                 pass
-            CURRENT_T2I_PIPE.enable_model_cpu_offload()
-        
-        try:
-            CURRENT_T2I_PIPE.scheduler = EulerAncestralDiscreteScheduler.from_config(CURRENT_T2I_PIPE.scheduler.config)
-        except:
-            pass
+            pipe.enable_model_cpu_offload()
         
-        CURRENT_T2I_MODEL = key
+        # ตั้งค่า scheduler
+        if is_turbo:
+            try:
+                pipe.scheduler = UniPCMultistepScheduler.from_config(pipe.scheduler.config)
+                print("✅ Using UniPC scheduler for Turbo")
+            except:
+                pass
+        else:
+            try:
+                pipe.scheduler = EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config)
+            except:
+                pass
         
     except Exception as e:
         print(f"❌ Error loading T2I model: {e}")
-        CURRENT_T2I_PIPE = None
-        CURRENT_T2I_MODEL = None
+        if is_turbo:
+            CURRENT_TURBO_PIPE = None
+            CURRENT_TURBO_MODEL = None
+        else:
+            CURRENT_T2I_PIPE = None
+            CURRENT_T2I_MODEL = None
         raise
 
 def colorize_sd15(sketch, base_model, controlnet_type, lora_model, lora_weight, vae_model,
@@ -617,6 +705,47 @@ def colorize_sdxl(sketch, base_model, controlnet_type, lora_model, lora_weight,
         error_img = Image.new('RGB', (1024, 1024), color='red')
         return error_img, Image.new('RGB', (1024, 1024), color='gray')
 
+def colorize_waifu_xl(sketch, lora_weight, vae_model, prompt, negative_prompt, seed, steps, scale, cn_weight):
+    """Colorize function specifically for Waifu-Colorize-XL model"""
+    try:
+        model_name = "stabilityai/stable-diffusion-xl-base-1.0"
+        controlnet_type = "lineart_sdxl"
+        lora_model = "colorize-xl"
+        
+        pipe = get_pipeline(model_name, controlnet_type, lora_model, lora_weight, vae_model)
+        
+        status_msg = f"🎨 Using: Waifu-Colorize-XL (Lineart ControlNet)"
+        print(status_msg)
+        
+        condition_img = prepare_condition_image(sketch, controlnet_type, is_sdxl=True)
+        
+        gen = torch.Generator(device=device).manual_seed(int(seed))
+        
+        # สำหรับ Waifu-Colorize-XL ใช้ prompt พิเศษ
+        enhanced_prompt = f"colorized, vibrant colors, anime style, {prompt}" if prompt else "colorized, vibrant colors, anime style, masterpiece"
+        
+        with torch.inference_mode():
+            out = pipe(
+                enhanced_prompt,
+                negative_prompt=negative_prompt,
+                image=condition_img,
+                num_inference_steps=int(steps),
+                guidance_scale=float(scale),
+                controlnet_conditioning_scale=float(cn_weight),
+                generator=gen,
+                height=1024,
+                width=1024
+            ).images[0]
+        
+        if device.type == "cuda":
+            torch.cuda.empty_cache()
+        
+        return out, condition_img
+    except Exception as e:
+        print(f"❌ Error in colorize_waifu_xl: {e}")
+        error_img = Image.new('RGB', (1024, 1024), color='red')
+        return error_img, Image.new('RGB', (1024, 1024), color='gray')
+
 def t2i_sd15(prompt, negative_prompt, model, lora_model, lora_weight, vae_model,
              seed, steps, scale, w, h):
     """Text-to-image for SD1.5 models"""
@@ -669,7 +798,7 @@ def t2i_sdxl(prompt, negative_prompt, model, lora_model, lora_weight, vae_model,
             return error_img
         
         model_to_load = model
-        if use_refiner and "refiner" not in model.lower():
+        if use_refiner and "refiner" not in model.lower() and not is_turbo_model(model):
             model_to_load = "stabilityai/stable-diffusion-xl-refiner-1.0"
         
         load_t2i_model(model_to_load, lora_model, lora_weight, vae_model)
@@ -683,7 +812,7 @@ def t2i_sdxl(prompt, negative_prompt, model, lora_model, lora_weight, vae_model,
         gen = torch.Generator(device=device).manual_seed(int(seed))
         
         with torch.inference_mode():
-            if use_refiner and CURRENT_SDXL_REFINER is not None:
+            if use_refiner and CURRENT_SDXL_REFINER is not None and not is_turbo_model(model):
                 image = CURRENT_T2I_PIPE(
                     prompt=prompt,
                     negative_prompt=negative_prompt,
@@ -704,12 +833,84 @@ def t2i_sdxl(prompt, negative_prompt, model, lora_model, lora_weight, vae_model,
                     generator=gen
                 ).images[0]
             else:
-                result = CURRENT_T2I_PIPE(
+                if is_turbo_model(model):
+                    # สำหรับ Turbo models ใช้ steps น้อยลง
+                    turbo_steps = max(1, min(10, int(steps)))
+                    result = CURRENT_TURBO_PIPE(
+                        prompt,
+                        negative_prompt=negative_prompt,
+                        width=int(w),
+                        height=int(h),
+                        num_inference_steps=turbo_steps,
+                        guidance_scale=float(scale),
+                        generator=gen
+                    ).images[0]
+                else:
+                    result = CURRENT_T2I_PIPE(
+                        prompt,
+                        negative_prompt=negative_prompt,
+                        width=int(w),
+                        height=int(h),
+                        num_inference_steps=int(steps),
+                        guidance_scale=float(scale),
+                        generator=gen
+                    ).images[0]
+        
+        if device.type == "cuda":
+            torch.cuda.empty_cache()
+        
+        return result
+    except Exception as e:
+        print(f"❌ Error in t2i_sdxl: {e}")
+        error_img = Image.new('RGB', (int(w), int(h)), color='red')
+        from PIL import ImageDraw, ImageFont
+        draw = ImageDraw.Draw(error_img)
+        try:
+            font = ImageFont.truetype("arial.ttf", 20)
+        except:
+            font = ImageFont.load_default()
+        draw.text((50, 50), f"Error: {str(e)[:50]}...", fill="white", font=font)
+        return error_img
+
+def t2i_turbo(prompt, negative_prompt, model, lora_model, lora_weight, vae_model,
+              seed, steps, scale, w, h):
+    """Text-to-image for Turbo models (fast generation)"""
+    try:
+        if model not in TURBO_MODELS:
+            error_img = Image.new('RGB', (int(w), int(h)), color='red')
+            return error_img
+        
+        load_t2i_model(model, lora_model, lora_weight, vae_model)
+        
+        print(f"⚡ Using Turbo model: {model}")
+        if lora_model and lora_model != "None":
+            print(f"   with LoRA: {lora_model} (weight: {lora_weight})")
+        
+        gen = torch.Generator(device=device).manual_seed(int(seed))
+        
+        with torch.inference_mode():
+            # สำหรับ Turbo models ใช้ steps น้อยลง (1-10 steps)
+            turbo_steps = max(1, min(10, int(steps)))
+            
+            if is_sdxl_model(model):
+                # SDXL-Turbo
+                result = CURRENT_TURBO_PIPE(
                     prompt,
                     negative_prompt=negative_prompt,
                     width=int(w),
                     height=int(h),
-                    num_inference_steps=int(steps),
+                    num_inference_steps=turbo_steps,
+                    guidance_scale=float(scale),
+                    generator=gen
+                ).images[0]
+            else:
+                # SD-Turbo
+                result = CURRENT_TURBO_PIPE(
+                    prompt,
+                    negative_prompt=negative_prompt,
+                    width=int(w),
+                    height=int(h),
+                    num_inference_steps=turbo_steps,
                     guidance_scale=float(scale),
                     generator=gen
                 ).images[0]
@@ -719,7 +920,7 @@ def t2i_sdxl(prompt, negative_prompt, model, lora_model, lora_weight, vae_model,
         
         return result
     except Exception as e:
-        print(f"❌ Error in t2i_sdxl: {e}")
+        print(f"❌ Error in t2i_turbo: {e}")
         error_img = Image.new('RGB', (int(w), int(h)), color='red')
         from PIL import ImageDraw, ImageFont
         draw = ImageDraw.Draw(error_img)
@@ -734,6 +935,7 @@ def unload_all_models():
     global CURRENT_CONTROLNET_PIPE, CURRENT_CONTROLNET_KEY
     global DETECTORS
     global CURRENT_T2I_PIPE, CURRENT_T2I_MODEL, CURRENT_SDXL_REFINER
+    global CURRENT_TURBO_PIPE, CURRENT_TURBO_MODEL
     
     print("🗑️ Unloading all models from memory...")
     
@@ -766,7 +968,15 @@ def unload_all_models():
     except:
         pass
     
+    try:
+        if CURRENT_TURBO_PIPE is not None:
+            del CURRENT_TURBO_PIPE
+            CURRENT_TURBO_PIPE = None
+    except:
+        pass
+    
     CURRENT_T2I_MODEL = None
+    CURRENT_TURBO_MODEL = None
     
     gc.collect()
     if torch.cuda.is_available():
@@ -867,7 +1077,7 @@ with gr.Blocks(title="🎨 AI Image Generator Pro", theme=gr.themes.Soft()) as d
     with gr.Tab("🎨 SDXL ControlNet"):
         gr.Markdown("""
         ### Transform sketches/images using SDXL with ControlNet
-        - **Supports:** canny_sdxl, depth_sdxl, openpose_sdxl
+        - **Supports:** canny_sdxl, depth_sdxl, openpose_sdxl, lineart_sdxl (new!)
         - **Best Resolution:** 1024x1024
         - **Higher quality, more VRAM required**
         """)
@@ -884,7 +1094,7 @@ with gr.Blocks(title="🎨 AI Image Generator Pro", theme=gr.themes.Soft()) as d
                 )
                 controlnet_type_sdxl = gr.Dropdown(
                     choices=list(CONTROLNET_MODELS_SDXL.keys()),
-                    value="canny_sdxl",
+                    value="lineart_sdxl",
                     label="ControlNet Type"
                 )
                 
@@ -898,7 +1108,7 @@ with gr.Blocks(title="🎨 AI Image Generator Pro", theme=gr.themes.Soft()) as d
                     lora_weight_sdxl = gr.Slider(0.1, 2.0, 0.8, step=0.1, label="LoRA Weight")
                 
                 vae_model_sdxl = gr.Dropdown(
-                    choices=["None", "SDXL VAE"],
+                    choices=["None", "SDXL VAE", "Turbo VAE"],
                     value="None",
                     label="VAE Model (Optional)"
                 )
@@ -934,6 +1144,73 @@ with gr.Blocks(title="🎨 AI Image Generator Pro", theme=gr.themes.Soft()) as d
             [out_sdxl, condition_out_sdxl]
         )
 
+    with gr.Tab("🌸 Waifu-Colorize-XL"):
+        gr.Markdown("""
+        ### Specialized Anime Lineart Colorization
+        - **Model:** ShinoharaHare/Waifu-Colorize-XL
+        - **Specialized for:** Anime/manga lineart coloring
+        - **Features:** Automatic colorization with vibrant anime colors
+        - **Best Resolution:** 1024x1024
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                inp_waifu = gr.Image(label="Input Lineart/Sketch", type="pil")
+                
+                gr.Markdown("### Model Settings")
+                gr.Markdown("**Using:** ShinoharaHare/Waifu-Colorize-XL (Specialized Anime Colorization)")
+                
+                gr.Markdown("### Enhancement Options")
+                with gr.Row():
+                    lora_weight_waifu = gr.Slider(0.1, 2.0, 1.0, step=0.1, label="LoRA Weight")
+                
+                vae_model_waifu = gr.Dropdown(
+                    choices=["None", "SDXL VAE"],
+                    value="None",
+                    label="VAE Model (Optional)"
+                )
+            
+            with gr.Column(scale=1):
+                out_waifu = gr.Image(label="Colorized Output")
+                condition_out_waifu = gr.Image(label="Processed Lineart", type="pil")
+        
+        gr.Markdown("### Generation Parameters")
+        with gr.Row():
+            prompt_waifu = gr.Textbox(
+                label="Color Style Prompt (Optional)",
+                placeholder="vibrant colors, anime style, beautiful coloring, masterpiece",
+                lines=2
+            )
+            negative_prompt_waifu = gr.Textbox(
+                label="Negative Prompt",
+                placeholder="monochrome, grayscale, black and white, sketch, lineart only",
+                lines=2,
+                value="monochrome, grayscale, black and white, sketch, lineart only"
+            )
+        
+        with gr.Row():
+            seed_waifu = gr.Number(value=-1, label="Seed (-1 for random)")
+            steps_waifu = gr.Slider(10, 50, 25, step=1, label="Steps")
+            scale_waifu = gr.Slider(1, 20, 7.5, step=0.5, label="CFG Scale")
+            cn_weight_waifu = gr.Slider(0.1, 2.0, 1.2, step=0.1, label="ControlNet Weight")
+        
+        gr.Markdown("### Tips for Best Results:")
+        gr.Markdown("""
+        1. Use clean lineart for best results
+        2. Higher ControlNet weight (1.0-1.5) for better line following
+        3. Lower CFG scale (5-8) for more natural coloring
+        4. Add color hints in prompt (e.g., "blue hair, red eyes, pink dress")
+        5. Keep prompts simple for this specialized model
+        """)
+        
+        run_waifu = gr.Button("🌸 Colorize with Waifu-Colorize-XL", variant="primary", size="lg")
+        run_waifu.click(
+            colorize_waifu_xl,
+            [inp_waifu, lora_weight_waifu, vae_model_waifu,
+             prompt_waifu, negative_prompt_waifu, seed_waifu, steps_waifu, scale_waifu, cn_weight_waifu],
+            [out_waifu, condition_out_waifu]
+        )
+
     with gr.Tab("🖼️ SD1.5 Text-to-Image"):
         gr.Markdown("""
         ### Generate images from text descriptions using SD1.5
@@ -999,6 +1276,81 @@ with gr.Blocks(title="🎨 AI Image Generator Pro", theme=gr.themes.Soft()) as d
             t2i_out_sd15
         )
 
+    with gr.Tab("⚡ SDXL-Turbo Text-to-Image"):
+        gr.Markdown("""
+        ### Ultra-Fast Image Generation with SDXL-Turbo
+        - **Model:** stabilityai/sdxl-turbo
+        - **Features:** 1-4 steps generation, extremely fast
+        - **Best Resolution:** 512x512 to 1024x1024
+        - **Warning:** Lower quality than full SDXL but much faster
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### Model Configuration")
+                t2i_model_turbo = gr.Dropdown(
+                    choices=TURBO_MODELS,
+                    value="stabilityai/sdxl-turbo",
+                    label="Turbo Model"
+                )
+                
+                gr.Markdown("### Enhancement Options")
+                with gr.Row():
+                    t2i_lora_turbo = gr.Dropdown(
+                        choices=list(LORA_MODELS.keys()),
+                        value="None",
+                        label="LoRA Model"
+                    )
+                    t2i_lora_weight_turbo = gr.Slider(0.1, 2.0, 0.8, step=0.1, label="LoRA Weight")
+                
+                t2i_vae_turbo = gr.Dropdown(
+                    choices=["None", "Turbo VAE", "SDXL VAE"],
+                    value="None",
+                    label="VAE Model"
+                )
+            
+            with gr.Column(scale=1):
+                t2i_out_turbo = gr.Image(label="Generated Image", type="pil")
+        
+        gr.Markdown("### Prompts")
+        with gr.Row():
+            t2i_prompt_turbo = gr.Textbox(
+                label="Prompt",
+                lines=4,
+                placeholder="masterpiece, best quality, highly detailed, beautiful, 1girl"
+            )
+            t2i_negative_prompt_turbo = gr.Textbox(
+                label="Negative Prompt",
+                lines=4,
+                placeholder="lowres, bad anatomy, bad hands, text, error, missing fingers, extra digit, fewer digits, cropped, worst quality, low quality"
+            )
+        
+        gr.Markdown("### Generation Parameters (Turbo needs only 1-4 steps!)")
+        with gr.Row():
+            t2i_seed_turbo = gr.Number(value=-1, label="Seed (-1 for random)")
+            t2i_steps_turbo = gr.Slider(1, 10, 4, step=1, label="Steps (1-4 recommended)")
+            t2i_scale_turbo = gr.Slider(0, 10, 0.0, step=0.5, label="CFG Scale (0-2 recommended)")
+        
+        with gr.Row():
+            w_turbo = gr.Slider(256, 1024, 512, step=64, label="Width")
+            h_turbo = gr.Slider(256, 1024, 512, step=64, label="Height")
+        
+        gr.Markdown("### Turbo Model Tips:")
+        gr.Markdown("""
+        1. **Use very few steps:** 1-4 steps is enough!
+        2. **Low CFG Scale:** 0.0-2.0 works best
+        3. **Fast but lower quality:** For quick previews/testing
+        4. **Works well with:** Simple prompts, concept testing
+        """)
+        
+        gen_btn_turbo = gr.Button("⚡ Generate with Turbo (Fast!)", variant="primary", size="lg")
+        gen_btn_turbo.click(
+            t2i_turbo,
+            [t2i_prompt_turbo, t2i_negative_prompt_turbo, t2i_model_turbo, t2i_lora_turbo, t2i_lora_weight_turbo,
+             t2i_vae_turbo, t2i_seed_turbo, t2i_steps_turbo, t2i_scale_turbo, w_turbo, h_turbo],
+            t2i_out_turbo
+        )
+
     with gr.Tab("🖼️ SDXL Text-to-Image"):
         gr.Markdown("""
         ### Generate images from text descriptions using SDXL
@@ -1010,7 +1362,7 @@ with gr.Blocks(title="🎨 AI Image Generator Pro", theme=gr.themes.Soft()) as d
             with gr.Column(scale=1):
                 gr.Markdown("### Model Configuration")
                 t2i_model_sdxl = gr.Dropdown(
-                    choices=SDXL_MODELS,
+                    choices=[m for m in SDXL_MODELS if m not in TURBO_MODELS],  # ไม่รวม Turbo models
                     value="stabilityai/stable-diffusion-xl-base-1.0",
                     label="SDXL Base Model"
                 )
@@ -1073,104 +1425,107 @@ with gr.Blocks(title="🎨 AI Image Generator Pro", theme=gr.themes.Soft()) as d
         gr.Markdown("""
         # Model & Feature Guide
         
-        ## 🎯 SD1.5 vs SDXL Comparison
+        ## 🎯 Model Comparison
         
         ### SD1.5 (Stable Diffusion 1.5)
-        - **Pros:** Faster, lower VRAM usage, many specialized models
-        - **Cons:** Lower quality, less detail
-        - **Best for:** Quick generations, testing, lower-end hardware
-        - **Resolution:** 512x512 optimal
+        - **Pros:** Fast, low VRAM, many models
+        - **Cons:** 512px max, lower quality
+        - **Best for:** Quick tests, anime, lower-end hardware
         
         ### SDXL (Stable Diffusion XL)
-        - **Pros:** Higher quality, better composition, more detail
-        - **Cons:** Slower, higher VRAM usage
-        - **Best for:** Final quality images, professional work
-        - **Resolution:** 1024x1024 optimal
-        
-        ## 🎨 ControlNet Types
-        
-        ### SD1.5 ControlNet (12 types)
-        - **lineart/lineart_anime**: Line art to image
-        - **canny**: Edge detection
-        - **depth**: Depth map based
-        - **openpose**: Human pose
-        - **normal**: Normal map
-        - **softedge**: Soft edges
-        - **segmentation**: Semantic segmentation
-        - **mlsd**: Straight line detection
-        - **shuffle**: Color shuffle
-        - **scribble**: Scribble to image
-        - **tile**: Upscaling
-        
-        ### SDXL ControlNet (3 types)
-        - **canny_sdxl**: Edge detection
-        - **depth_sdxl**: Depth map
-        - **openpose_sdxl**: Human pose
-        
-        ## 💎 Recommended Model Combinations
-        
-        ### SD1.5 - Realistic Portraits
-        - Base: `digiplay/majicMIX_realistic_v7`
-        - LoRA: `detail-tweaker`
-        - VAE: `SD1.5 VAE`
-        - Steps: 30-40
-        - CFG: 7-9
-        
-        ### SD1.5 - Anime Style
-        - Base: `digiplay/ChikMix_V3`
-        - LoRA: `anime-art`
-        - VAE: `Anime VAE`
-        - Steps: 25-35
-        - CFG: 6-8
-        
-        ### SDXL - Photorealistic
-        - Base: `SG161222/RealVisXL_V4.0`
-        - LoRA: `photorealistic`
-        - VAE: `SDXL VAE`
-        - Use Refiner: Yes
-        - Steps: 35-45
-        - CFG: 7-10
-        
-        ### SDXL - Artistic
-        - Base: `Lykon/dreamshaper-xl-1-0`
-        - LoRA: `watercolor-style`
-        - VAE: `SDXL VAE`
-        - Steps: 30-40
-        - CFG: 6-8
-        
-        ## ⚙️ Parameter Guidelines
-        
-        ### Steps
-        - **SD1.5:** 20-35 (fast), 35-50 (quality)
-        - **SDXL:** 30-45 (fast), 45-60 (quality)
-        
-        ### CFG Scale
-        - **4-6:** Creative, loose interpretation
-        - **6-9:** Balanced (recommended)
-        - **9-12:** Strict prompt adherence
-        - **12+:** Very strict
-        
-        ### Resolution
-        - **SD1.5:** 512x512, 512x768, 768x512 (max 1024x1024)
-        - **SDXL:** 1024x1024, 1024x1536, 1536x1024 (max 2048x2048)
-        
-        ## 🚀 Performance Tips
-        
-        ### For Low VRAM (<8GB)
+        - **Pros:** 1024px+, high quality, better composition
+        - **Cons:** High VRAM, slower
+        - **Best for:** Final quality, professional work
+        
+        ### SDXL-Turbo
+        - **Pros:** Extremely fast (1-4 steps!)
+        - **Cons:** Lower quality than full SDXL
+        - **Best for:** Quick previews, concept testing
+        
+        ### Waifu-Colorize-XL
+        - **Pros:** Specialized for anime lineart coloring
+        - **Cons:** Anime-only, requires clean lineart
+        - **Best for:** Anime/manga colorization
+        
+        ## 🎨 New ControlNet for SDXL
+        
+        ### Lineart ControlNet for SDXL
+        - **Model:** ShermanG/ControlNet-Standard-Lineart-for-SDXL
+        - **Purpose:** Convert lineart to colored images
+        - **Best with:** Clean lineart, anime/manga styles
+        - **Used in:** Waifu-Colorize-XL Tab
+        
+        ## 💎 Recommended Workflows
+        
+        ### For Anime/Manga Artists
+        1. Draw lineart
+        2. Use **Waifu-Colorize-XL** Tab for automatic coloring
+        3. Or use **SDXL ControlNet** with lineart_sdxl
+        
+        ### For Quick Concepts
+        1. Use **SDXL-Turbo** Tab for 1-4 step generation
+        2. Refine in **SDXL Text-to-Image** if needed
+        
+        ### For Professional Work
+        1. Use **SDXL Text-to-Image** with Refiner
+        2. High steps (40-50), CFG 7-9
+        3. 1024x1024 resolution
+        
+        ## ⚡ Turbo Model Tips
+        
+        ### SDXL-Turbo Best Practices:
+        - **Steps:** 1-4 only!
+        - **CFG Scale:** 0.0-2.0
+        - **Prompts:** Keep simple
+        - **Resolution:** 512x512 to 1024x1024
+        - **Use case:** Storyboarding, concept art, quick iterations
+        
+        ## 🌸 Waifu-Colorize-XL Tips
+        
+        ### For Best Results:
+        1. **Clean lineart:** No stray marks
+        2. **ControlNet weight:** 1.0-1.5
+        3. **CFG Scale:** 5-8
+        4. **Simple prompts:** "vibrant colors, anime style"
+        5. **Resolution:** 1024x1024
+        
+        ### Example Workflow:
+        1. Draw/sketch in your favorite app
+        2. Export as clean lineart (black on white)
+        3. Upload to Waifu-Colorize-XL Tab
+        4. Adjust parameters as needed
+        5. Generate and refine
+        
+        ## 🚀 Performance Optimization
+        
+        ### Low VRAM (<8GB)
         - Use SD1.5 models only
+        - 512x512 resolution
         - Enable attention slicing
-        - Use lower resolutions (512x512)
-        - Reduce steps (20-30)
         
-        ### For Medium VRAM (8-12GB)
-        - Can use SD1.5 and some SDXL
-        - For SDXL, use 1024x1024
+        ### Medium VRAM (8-12GB)
+        - SD1.5 and SDXL (no refiner)
+        - 1024x1024 for SDXL
         - Enable xFormers
         
-        ### For High VRAM (12GB+)
-        - Can use all models
-        - SDXL with refiner
+        ### High VRAM (12GB+)
+        - All models including SDXL with refiner
         - Higher resolutions
+        - Multiple LoRAs
+        
+        ## 🔄 Memory Management
+        
+        ### When to Unload Models:
+        1. Switching between SD1.5 and SDXL
+        2. Getting "out of memory" errors
+        3. Changing ControlNet types
+        4. After long generation sessions
+        
+        ### Memory Saving Tips:
+        1. Use "Unload All Models" button
+        2. Generate in batches
+        3. Lower resolution for testing
+        4. Close other GPU applications
         """)
 
 try: