update

app.py

@@ -294,6 +294,49 @@ def load_image_model(model_name):
                         safety_checker=None
                     )
             
+            # Configuración especial para SDXL Turbo (requiere parámetros específicos)
+            elif "sdxl-turbo" in model_name:
+                try:
+                    print("⚡ Cargando SDXL Turbo con configuración específica...")
+                    from diffusers import AutoPipelineForText2Image
+                    pipe = AutoPipelineForText2Image.from_pretrained(
+                        model_name,
+                        torch_dtype=torch_dtype,
+                        variant="fp16" if use_fp16_variant else None
+                    )
+                    print("✅ SDXL Turbo cargado exitosamente")
+                except Exception as e:
+                    print(f"❌ Error cargando SDXL Turbo: {e}")
+                    print(f"🔍 Tipo de error: {type(e).__name__}")
+                    # Fallback a SD Turbo
+                    print("🔄 Fallback a SD Turbo...")
+                    pipe = StableDiffusionPipeline.from_pretrained(
+                        "stabilityai/sd-turbo",
+                        torch_dtype=torch_dtype,
+                        safety_checker=None
+                    )
+            
+            # Configuración especial para SD Turbo
+            elif "sd-turbo" in model_name:
+                try:
+                    print("⚡ Cargando SD Turbo...")
+                    pipe = StableDiffusionPipeline.from_pretrained(
+                        model_name,
+                        torch_dtype=torch_dtype,
+                        safety_checker=None,
+                        requires_safety_checker=False,
+                        variant="fp16" if use_fp16_variant else None
+                    )
+                    print("✅ SD Turbo cargado exitosamente")
+                except Exception as e:
+                    print(f"❌ Error cargando SD Turbo: {e}")
+                    # Fallback a SD 1.4
+                    pipe = StableDiffusionPipeline.from_pretrained(
+                        "CompVis/stable-diffusion-v1-4",
+                        torch_dtype=torch_dtype,
+                        safety_checker=None
+                    )
+            
             # Configuración especial para LDM
             elif "ldm-text2im" in model_name:
                 try:
@@ -684,24 +727,44 @@ def generate_image(prompt, model_name, negative_prompt="", seed=0, width=1024, h
         # Cargar el modelo
         pipe = load_image_model(model_name)
         
+        # Verificar que el modelo se cargó correctamente
+        if pipe is None:
+            print("❌ Error: El modelo no se pudo cargar")
+            raise Exception("Modelo no disponible")
+        
+        print(f"✅ Modelo cargado correctamente: {type(pipe).__name__}")
+        
         # Ajustar parámetros según el tipo de modelo
-        if "turbo" in model_name.lower():
+        if "sdxl-turbo" in model_name.lower():
+            # SDXL Turbo requiere parámetros específicos
+            guidance_scale = 0.0  # SDXL Turbo funciona mejor sin guidance
+            num_inference_steps = 1  # SDXL Turbo es muy rápido
+            print(f"⚡ SDXL Turbo - Ajustando parámetros: guidance={guidance_scale}, steps={num_inference_steps}")
+        elif "sd-turbo" in model_name.lower():
             guidance_scale = min(guidance_scale, 1.0)
-            num_inference_steps = min(num_inference_steps, 4)
+            num_inference_steps = min(num_inference_steps, 2)  # Reducir de 4 a 2 para ahorrar cuota
+            print(f"⚡ SD Turbo - Ajustando parámetros: guidance={guidance_scale}, steps={num_inference_steps}")
+        elif "turbo" in model_name.lower():
+            guidance_scale = min(guidance_scale, 1.0)
+            num_inference_steps = min(num_inference_steps, 2)  # Reducir de 4 a 2 para ahorrar cuota
             print(f"⚡ Modelo turbo - Ajustando parámetros: guidance={guidance_scale}, steps={num_inference_steps}")
         elif "lightning" in model_name.lower():
             guidance_scale = min(guidance_scale, 1.0)
-            num_inference_steps = max(num_inference_steps, 4)
+            num_inference_steps = max(num_inference_steps, 2)  # Reducir de 4 a 2
             print(f"⚡ Modelo lightning - Ajustando parámetros: guidance={guidance_scale}, steps={num_inference_steps}")
         elif "flux" in model_name.lower():
             guidance_scale = max(3.5, min(guidance_scale, 7.5))
-            num_inference_steps = max(15, num_inference_steps)
+            num_inference_steps = max(10, num_inference_steps)  # Reducir de 15 a 10
             print(f"🔐 Modelo FLUX - Ajustando parámetros: guidance={guidance_scale}, steps={num_inference_steps}")
         elif "stable-diffusion-3.5-large" in model_name:
             # SD 3.5 Large funciona mejor con guidance_scale entre 3.5-4.5 y 28 steps
             guidance_scale = max(3.5, min(guidance_scale, 4.5))
-            num_inference_steps = max(28, num_inference_steps)
+            num_inference_steps = max(20, num_inference_steps)  # Reducir de 28 a 20
             print(f"🌟 SD 3.5 Large - Ajustando parámetros: guidance={guidance_scale}, steps={num_inference_steps}")
+        else:
+            # Para otros modelos, usar menos pasos por defecto
+            num_inference_steps = min(num_inference_steps, 15)  # Reducir de 20 a 15
+            print(f"🎨 Modelo estándar - Ajustando parámetros: guidance={guidance_scale}, steps={num_inference_steps}")
         
         generator = torch.Generator(device=device).manual_seed(seed)
         
@@ -715,9 +778,6 @@ def generate_image(prompt, model_name, negative_prompt="", seed=0, width=1024, h
             # Limpiar cache de GPU antes de la inferencia
             torch.cuda.empty_cache()
             
-            # Generar la imagen
-            print("⚡ Generando imagen con H200...")
-            
             # Configurar parámetros de generación
             generation_kwargs = {
                 "prompt": prompt,
@@ -728,9 +788,33 @@ def generate_image(prompt, model_name, negative_prompt="", seed=0, width=1024, h
                 "generator": generator
             }
             
-            # Agregar parámetros opcionales
-            if negative_prompt and negative_prompt.strip():
-                generation_kwargs["negative_prompt"] = negative_prompt.strip()
+            # Configuración específica para SDXL Turbo
+            if "sdxl-turbo" in model_name.lower():
+                # SDXL Turbo requiere configuración especial según documentación oficial
+                generation_kwargs = {
+                    "prompt": prompt,
+                    "height": height,
+                    "width": width,
+                    "guidance_scale": 0.0,  # SDXL Turbo NO usa guidance
+                    "num_inference_steps": 1,  # SDXL Turbo es muy rápido
+                    "generator": generator
+                }
+                # SDXL Turbo NO usa negative_prompt
+                print("⚡ Usando configuración específica para SDXL Turbo (sin negative_prompt)")
+            else:
+                # Configuración estándar para otros modelos
+                generation_kwargs = {
+                    "prompt": prompt,
+                    "height": height,
+                    "width": width,
+                    "guidance_scale": guidance_scale,
+                    "num_inference_steps": num_inference_steps,
+                    "generator": generator
+                }
+                
+                # Agregar parámetros opcionales
+                if negative_prompt and negative_prompt.strip():
+                    generation_kwargs["negative_prompt"] = negative_prompt.strip()
             
             # Generar la imagen
             result = pipe(**generation_kwargs)