Optimizar configuración de modelos - Respetar configuraciones del usuario y agregar más parámetros

app.py

@@ -7,16 +7,22 @@ from PIL import Image
 import io
 import json
 import os
+import time
 
 # import spaces #[uncomment to use ZeroGPU]
 from diffusers import DiffusionPipeline
 import torch
 from huggingface_hub import login
 
+print("🚀 Iniciando aplicación...")
+print(f"📁 Directorio actual: {os.getcwd()}")
+print(f"🐍 Python version: {os.sys.version}")
+
 # Configurar autenticación con Hugging Face
 HF_TOKEN = os.getenv("HF_TOKEN") or os.getenv("HUGGING_FACE_HUB_TOKEN")
 if HF_TOKEN:
     try:
+        print(f"🔑 Token detectado: {HF_TOKEN[:10]}...")
         login(token=HF_TOKEN)
         print("✅ Autenticado con Hugging Face")
         print(f"🔑 Token configurado: {HF_TOKEN[:10]}...")
@@ -27,12 +33,15 @@ else:
     print("💡 Para usar modelos FLUX, configura la variable de entorno HF_TOKEN en el Space")
 
 device = "cuda" if torch.cuda.is_available() else "cpu"
+print(f"🖥️ Dispositivo detectado: {device}")
+print(f"🔥 CUDA disponible: {torch.cuda.is_available()}")
+if torch.cuda.is_available():
+    print(f"🎮 GPU: {torch.cuda.get_device_name(0)}")
+    print(f"💾 Memoria GPU: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.1f} GB")
 
-# Modelos disponibles de alta calidad
+# Modelos disponibles de alta calidad (optimizados - solo los que funcionan)
 MODELS = {
     "SDXL Turbo (stabilityai/sdxl-turbo)": "stabilityai/sdxl-turbo",
-    "SDXL Lightning (ByteDance/SDXL-Lightning)": "ByteDance/SDXL-Lightning",
-    "SDXL Lightning 4Step (ByteDance/SDXL-Lightning-4Step)": "ByteDance/SDXL-Lightning-4Step",
     "SD Turbo (stabilityai/sd-turbo)": "stabilityai/sd-turbo",
     "SDXL Base (stabilityai/stable-diffusion-xl-base-1.0)": "stabilityai/stable-diffusion-xl-base-1.0",
     "Realistic Vision (SG161222/Realistic_Vision_V5.1_noVAE)": "SG161222/Realistic_Vision_V5.1_noVAE",
@@ -41,6 +50,12 @@ MODELS = {
     "Waifu Diffusion (hakurei/waifu-diffusion)": "hakurei/waifu-diffusion",
     "Deliberate v2 (XpucT/deliberate-v2)": "XpucT/deliberate-v2",
     "Dreamlike Diffusion (dreamlike-art/dreamlike-diffusion-1.0)": "dreamlike-art/dreamlike-diffusion-1.0",
+    # Modelos adicionales que funcionan bien en CPU
+    "Stable Diffusion v1.5 (runwayml/stable-diffusion-v1-5)": "runwayml/stable-diffusion-v1-5",
+    "Stable Diffusion v1.4 (CompVis/stable-diffusion-v1-4)": "CompVis/stable-diffusion-v1-4",
+    "Midjourney Style (prompthero/openjourney)": "prompthero/openjourney",
+    "Orange Mixs (WarriorMama777/OrangeMixs)": "WarriorMama777/OrangeMixs",
+    "Kohaku V2.1 (KBlueLeaf/kohaku-v2.1)": "KBlueLeaf/kohaku-v2.1",
     "FLUX.1-Kontext-Dev (API External)": "api_external",
 }
 
@@ -52,8 +67,15 @@ if HF_TOKEN:
     }
     MODELS.update(FLUX_MODELS)
     print("🔓 Modelos FLUX habilitados con autenticación")
+    print(f"📊 Total de modelos disponibles: {len(MODELS)}")
 else:
     print("🔒 Modelos FLUX deshabilitados - requiere HF_TOKEN")
+    print(f"📊 Total de modelos disponibles: {len(MODELS)}")
+
+print("📋 Modelos cargados:")
+for i, (name, model_id) in enumerate(MODELS.items(), 1):
+    status = "🔐" if "flux" in model_id.lower() or "black-forest" in model_id.lower() else "📦"
+    print(f"  {i:2d}. {status} {name}")
 
 # Estado del pipeline
 pipe = None
@@ -61,8 +83,10 @@ current_model_id = None
 
 if torch.cuda.is_available():
     torch_dtype = torch.float16
+    print("⚡ Usando torch.float16 para GPU")
 else:
     torch_dtype = torch.float32
+    print("🐌 Usando torch.float32 para CPU")
 
 MAX_SEED = np.iinfo(np.int32).max
 MAX_IMAGE_SIZE = 1024
@@ -70,11 +94,16 @@ MAX_IMAGE_SIZE = 1024
 # Función para cargar el modelo
 def load_model(model_id):
     global pipe, current_model_id
+    print(f"\n🔄 Iniciando carga del modelo: {model_id}")
+    
     if pipe is None or model_id != current_model_id:
         try:
+            start_time = time.time()
+            
             # Usar token de autenticación si está disponible
             if HF_TOKEN and ("flux" in model_id.lower() or "black-forest" in model_id.lower()):
                 print(f"🔐 Cargando modelo gated: {model_id}")
+                print(f"🔑 Usando token de autenticación...")
                 pipe = DiffusionPipeline.from_pretrained(
                     model_id, 
                     torch_dtype=torch_dtype,
@@ -86,27 +115,45 @@ def load_model(model_id):
                     model_id, 
                     torch_dtype=torch_dtype
                 )
+            
+            load_time = time.time() - start_time
+            print(f"⏱️ Tiempo de carga: {load_time:.2f} segundos")
+            
+            print(f"🚀 Moviendo modelo a dispositivo: {device}")
             pipe = pipe.to(device)
+            
             current_model_id = model_id
             print(f"✅ Modelo {model_id} cargado exitosamente")
+            print(f"💾 Memoria utilizada: {torch.cuda.memory_allocated() / 1024**3:.2f} GB" if torch.cuda.is_available() else "💾 Memoria CPU")
+            
         except Exception as e:
             print(f"❌ Error cargando modelo {model_id}: {e}")
+            print(f"🔍 Tipo de error: {type(e).__name__}")
             raise e
+    else:
+        print(f"♻️ Modelo {model_id} ya está cargado, reutilizando...")
 
 # Función para usar la API externa de FLUX.1-Kontext-Dev
 def use_external_api(prompt, negative_prompt, seed, randomize_seed, width, height, guidance_scale, num_inference_steps):
     try:
-        print("🌐 Conectando a API externa FLUX.1-Kontext-Dev...")
+        print("\n🌐 Conectando a API externa FLUX.1-Kontext-Dev...")
+        print(f"📝 Prompt: {prompt[:50]}...")
+        print(f"🔧 Parámetros: {width}x{height}, guidance={guidance_scale}, steps={num_inference_steps}")
+        
+        start_time = time.time()
+        
         # URL de la API del Space externo
         api_url = "https://black-forest-labs-flux-1-kontext-dev.hf.space/api/predict/"
         
         # Crear una imagen base simple para la API (requiere input_image)
+        print("🖼️ Creando imagen base para API...")
         base_image = Image.new('RGB', (width, height), color='white')
         img_byte_arr = io.BytesIO()
         base_image.save(img_byte_arr, format='PNG')
         img_byte_arr = img_byte_arr.getvalue()
         
         # Preparar los datos para la API
+        print("📦 Preparando datos para API...")
         files = {
             'data': (None, json.dumps([
                 base64.b64encode(img_byte_arr).decode('utf-8'),  # input_image
@@ -119,29 +166,95 @@ def use_external_api(prompt, negative_prompt, seed, randomize_seed, width, heigh
         }
         
         # Hacer la petición a la API
+        print(f"🌐 Enviando petición a: {api_url}")
         response = requests.post(api_url, files=files, timeout=60)
         
+        api_time = time.time() - start_time
+        print(f"⏱️ Tiempo de respuesta API: {api_time:.2f} segundos")
+        
         if response.status_code == 200:
+            print("✅ Respuesta exitosa de API")
             result = response.json()
             # La API devuelve [image_data, seed]
             image_data = result['data'][0]
             new_seed = result['data'][1]
             
+            print("🖼️ Decodificando imagen...")
             # Decodificar la imagen
             image_bytes = base64.b64decode(image_data.split(',')[1])
             image = Image.open(io.BytesIO(image_bytes))
             
-            print("✅ API externa exitosa")
+            total_time = time.time() - start_time
+            print(f"✅ API externa exitosa - Tiempo total: {total_time:.2f} segundos")
             return image, new_seed
         else:
+            print(f"❌ Error de API: {response.status_code}")
+            print(f"📄 Respuesta: {response.text[:200]}...")
             raise Exception(f"API Error: {response.status_code} - {response.text}")
             
     except Exception as e:
         print(f"❌ Error usando API externa: {e}")
+        print(f"🔍 Tipo de error: {type(e).__name__}")
         # Fallback: crear una imagen de error
         error_image = Image.new('RGB', (width, height), color='red')
         return error_image, seed
 
+# Función para mostrar información del modelo seleccionado
+def get_model_info(model_name):
+    model_id = MODELS.get(model_name, "")
+    
+    if not model_id:
+        return "**Model Info:** Select a model to see its specific configuration recommendations."
+    
+    info = f"**Model Info:** {model_name}\n\n"
+    
+    # Información específica por modelo
+    if "turbo" in model_id.lower():
+        info += "⚡ **Fast Model** - Optimized for speed\n"
+        info += "• Recommended steps: 1-4\n"
+        info += "• Guidance scale: 0.0-1.0\n"
+        info += "• Best for: Quick iterations\n\n"
+    elif "lightning" in model_id.lower():
+        info += "⚡ **Lightning Model** - Ultra fast\n"
+        info += "• Recommended steps: 4-8\n"
+        info += "• Guidance scale: 0.0-1.0\n"
+        info += "• Best for: Rapid prototyping\n\n"
+    elif "flux" in model_id.lower():
+        info += "🔐 **FLUX Model** - High quality\n"
+        info += "• Recommended steps: 20-50\n"
+        info += "• Guidance scale: 3.5-7.5\n"
+        info += "• Best for: Professional results\n\n"
+    elif "realistic" in model_id.lower():
+        info += "👤 **Realistic Model** - Photorealistic\n"
+        info += "• Recommended steps: 25-50\n"
+        info += "• Guidance scale: 7.5-12.0\n"
+        info += "• Best for: Realistic portraits\n\n"
+    elif "openjourney" in model_id.lower():
+        info += "🎨 **OpenJourney Model** - Midjourney style\n"
+        info += "• Recommended steps: 20-30\n"
+        info += "• Guidance scale: 7.5-10.0\n"
+        info += "• Best for: Artistic styles\n\n"
+    elif "waifu" in model_id.lower():
+        info += "🌸 **Waifu Model** - Anime style\n"
+        info += "• Recommended steps: 20-30\n"
+        info += "• Guidance scale: 7.5-10.0\n"
+        info += "• Best for: Anime characters\n\n"
+    elif "anything" in model_id.lower():
+        info += "🎭 **Anything Model** - Versatile\n"
+        info += "• Recommended steps: 20-30\n"
+        info += "• Guidance scale: 7.5-10.0\n"
+        info += "• Best for: Creative concepts\n\n"
+    else:
+        info += "📦 **Standard Model**\n"
+        info += "• Recommended steps: 20-50\n"
+        info += "• Guidance scale: 7.5-12.0\n"
+        info += "• Best for: General use\n\n"
+    
+    info += f"**Model ID:** `{model_id}`\n"
+    info += "**Status:** ✅ Available"
+    
+    return info
+
 # @spaces.GPU #[uncomment to use ZeroGPU]
 def infer(
     prompt,
@@ -153,70 +266,131 @@ def infer(
     guidance_scale,
     num_inference_steps,
     model_name,
+    eta=0.0,
+    strength=1.0,
+    num_images_per_prompt=1,
+    safety_checker=True,
     progress=gr.Progress(track_tqdm=True),
 ):
     try:
+        print(f"\n🎨 Iniciando generación de imagen...")
+        print(f"📝 Prompt: {prompt}")
+        print(f"🚫 Negative prompt: {negative_prompt}")
+        print(f"🎲 Seed: {seed} (randomize: {randomize_seed})")
+        print(f"📐 Dimensiones: {width}x{height}")
+        print(f"🎯 Guidance scale: {guidance_scale}")
+        print(f"🔄 Inference steps: {num_inference_steps}")
+        print(f"🎯 Eta: {eta}")
+        print(f"💪 Strength: {strength}")
+        print(f"🖼️ Images per prompt: {num_images_per_prompt}")
+        print(f"🛡️ Safety checker: {safety_checker}")
+        print(f"🎯 Modelo seleccionado: {model_name}")
+        
+        start_time = time.time()
+        
         # Verificar si es el modelo externo
         if model_name == "FLUX.1-Kontext-Dev (API External)":
             return use_external_api(prompt, negative_prompt, seed, randomize_seed, width, height, guidance_scale, num_inference_steps)
         
         # Cargar el modelo seleccionado
         model_id = MODELS[model_name]
+        print(f"🔧 Cargando modelo: {model_id}")
         load_model(model_id)
         
         if randomize_seed:
+            old_seed = seed
             seed = random.randint(0, MAX_SEED)
+            print(f"🎲 Seed aleatorizado: {old_seed} → {seed}")
 
+        print(f"🎲 Configurando generador con seed: {seed}")
         generator = torch.Generator().manual_seed(seed)
 
-        # Configuraciones específicas según el modelo
-        if "turbo" in model_id.lower() or "lightning" in model_id.lower():
-            # Modelos rápidos
-            guidance_scale = 0.0
-            num_inference_steps = 1 if "turbo" in model_id.lower() else 4
-        elif "flux" in model_id.lower():
-            # Modelos FLUX
-            guidance_scale = 7.5
-            num_inference_steps = 20
-        elif "realistic" in model_id.lower():
-            # Realistic Vision
-            guidance_scale = 7.5
-            num_inference_steps = 25
-        elif "openjourney" in model_id.lower():
-            # OpenJourney
-            guidance_scale = 7.5
-            num_inference_steps = 20
-        elif "anything" in model_id.lower():
-            # Anything v3
-            guidance_scale = 7.5
-            num_inference_steps = 20
-        elif "waifu" in model_id.lower():
-            # Waifu Diffusion
-            guidance_scale = 7.5
-            num_inference_steps = 20
-        elif "deliberate" in model_id.lower():
-            # Deliberate v2
-            guidance_scale = 7.5
-            num_inference_steps = 20
-        elif "dreamlike" in model_id.lower():
-            # Dreamlike Diffusion
-            guidance_scale = 7.5
-            num_inference_steps = 20
+        # RESPETAR LAS CONFIGURACIONES DEL USUARIO
+        # Solo aplicar límites mínimos para modelos específicos si es necesario
+        final_guidance_scale = guidance_scale
+        final_inference_steps = num_inference_steps
+        
+        # Aplicar límites mínimos solo para modelos que lo requieren
+        if "turbo" in model_id.lower():
+            # Para modelos turbo, asegurar al menos 1 paso
+            if final_inference_steps < 1:
+                final_inference_steps = 1
+                print(f"⚡ Modelo turbo - Ajustando steps mínimo: {num_inference_steps} → {final_inference_steps}")
+        elif "lightning" in model_id.lower():
+            # Para modelos lightning, asegurar al menos 4 pasos
+            if final_inference_steps < 4:
+                final_inference_steps = 4
+                print(f"⚡ Modelo lightning - Ajustando steps mínimo: {num_inference_steps} → {final_inference_steps}")
+        
+        # Aplicar límites de guidance scale solo si es necesario
+        if final_guidance_scale < 0.0:
+            final_guidance_scale = 0.0
+            print(f"⚠️ Guidance scale ajustado al mínimo: {guidance_scale} → {final_guidance_scale}")
+        elif final_guidance_scale > 20.0:
+            final_guidance_scale = 20.0
+            print(f"⚠️ Guidance scale ajustado al máximo: {guidance_scale} → {final_guidance_scale}")
+
+        print(f"⚙️ Parámetros finales (respetando configuración del usuario):")
+        print(f"   - Guidance scale: {guidance_scale} → {final_guidance_scale}")
+        print(f"   - Inference steps: {num_inference_steps} → {final_inference_steps}")
+        print(f"   - Width: {width}, Height: {height}")
+        print(f"   - Seed: {seed}")
+        print(f"   - Eta: {eta}")
+        print(f"   - Strength: {strength}")
+        print(f"   - Images per prompt: {num_images_per_prompt}")
 
+        print("🎨 Iniciando generación de imagen...")
+        inference_start = time.time()
+        
+        # Preparar parámetros adicionales para modelos que los soporten
+        additional_params = {}
+        
+        # Agregar parámetros adicionales según el modelo
+        if hasattr(pipe, 'scheduler') and hasattr(pipe.scheduler, 'beta_start'):
+            # Algunos modelos soportan parámetros de scheduler
+            additional_params['eta'] = eta
+        
+        if hasattr(pipe, 'vae') and hasattr(pipe.vae, 'scale_factor'):
+            # Algunos modelos soportan parámetros de VAE
+            additional_params['output_type'] = 'pil'
+        
+        # Configurar safety checker
+        if hasattr(pipe, 'safety_checker') and not safety_checker:
+            pipe.safety_checker = None
+            print("🛡️ Safety checker deshabilitado")
+        
+        # Configurar número de imágenes
+        if num_images_per_prompt > 1:
+            additional_params['num_images_per_prompt'] = num_images_per_prompt
+        
+        print(f"🔧 Parámetros adicionales: {additional_params}")
+        
         image = pipe(
             prompt=prompt,
             negative_prompt=negative_prompt,
-            guidance_scale=guidance_scale,
-            num_inference_steps=num_inference_steps,
+            guidance_scale=final_guidance_scale,
+            num_inference_steps=final_inference_steps,
             width=width,
             height=height,
             generator=generator,
+            **additional_params
         ).images[0]
 
+        inference_time = time.time() - inference_start
+        total_time = time.time() - start_time
+        
+        print(f"✅ Imagen generada exitosamente!")
+        print(f"⏱️ Tiempo de inferencia: {inference_time:.2f} segundos")
+        print(f"⏱️ Tiempo total: {total_time:.2f} segundos")
+        print(f"🎲 Seed final: {seed}")
+        print(f"💾 Memoria utilizada: {torch.cuda.memory_allocated() / 1024**3:.2f} GB" if torch.cuda.is_available() else "💾 Memoria CPU")
+
         return image, seed
         
     except Exception as e:
         print(f"❌ Error en inferencia: {e}")
+        print(f"🔍 Tipo de error: {type(e).__name__}")
+        print(f"📋 Detalles del error: {str(e)}")
         # Crear imagen de error
         error_image = Image.new('RGB', (width, height), color='red')
         return error_image, seed
@@ -267,20 +441,20 @@ with gr.Blocks(css=css) as demo:
             
             negative_prompt = gr.Text(
                 label="Negative prompt",
-                max_lines=1,
-                placeholder="Enter a negative prompt",
-                visible=False,
-            )
-
-            seed = gr.Slider(
-                label="Seed",
-                minimum=0,
-                maximum=MAX_SEED,
-                step=1,
-                value=0,
+                max_lines=2,
+                placeholder="Enter a negative prompt (optional)",
+                visible=True,
             )
 
-            randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
+            with gr.Row():
+                seed = gr.Slider(
+                    label="Seed",
+                    minimum=0,
+                    maximum=MAX_SEED,
+                    step=1,
+                    value=0,
+                )
+                randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
 
             with gr.Row():
                 width = gr.Slider(
@@ -288,34 +462,75 @@ with gr.Blocks(css=css) as demo:
                     minimum=256,
                     maximum=MAX_IMAGE_SIZE,
                     step=32,
-                    value=1024,  # Replace with defaults that work for your model
+                    value=1024,
                 )
-
                 height = gr.Slider(
                     label="Height",
                     minimum=256,
                     maximum=MAX_IMAGE_SIZE,
                     step=32,
-                    value=1024,  # Replace with defaults that work for your model
+                    value=1024,
                 )
 
             with gr.Row():
                 guidance_scale = gr.Slider(
                     label="Guidance scale",
                     minimum=0.0,
-                    maximum=10.0,
+                    maximum=20.0,
                     step=0.1,
-                    value=0.0,  # Replace with defaults that work for your model
+                    value=7.5,
+                    info="Controls how closely the image follows the prompt (higher = more adherence)"
                 )
-
                 num_inference_steps = gr.Slider(
                     label="Number of inference steps",
                     minimum=1,
-                    maximum=50,
+                    maximum=100,
                     step=1,
-                    value=2,  # Replace with defaults that work for your model
+                    value=20,
+                    info="More steps = higher quality but slower generation"
                 )
 
+            with gr.Row():
+                # Parámetros adicionales para modelos avanzados
+                eta = gr.Slider(
+                    label="Eta (DDIM)",
+                    minimum=0.0,
+                    maximum=1.0,
+                    step=0.01,
+                    value=0.0,
+                    info="DDIM eta parameter (0 = deterministic, 1 = stochastic)"
+                )
+                strength = gr.Slider(
+                    label="Strength",
+                    minimum=0.0,
+                    maximum=1.0,
+                    step=0.01,
+                    value=1.0,
+                    info="Strength of the transformation (for img2img models)"
+                )
+
+            with gr.Row():
+                # Configuraciones de calidad
+                num_images_per_prompt = gr.Slider(
+                    label="Images per prompt",
+                    minimum=1,
+                    maximum=4,
+                    step=1,
+                    value=1,
+                    info="Number of images to generate (may slow down generation)"
+                )
+                safety_checker = gr.Checkbox(
+                    label="Safety checker",
+                    value=True,
+                    info="Enable content safety filtering"
+                )
+
+            # Información del modelo seleccionado
+            model_info = gr.Markdown(
+                value="**Model Info:** Select a model to see its specific configuration recommendations.",
+                label="Model Information"
+            )
+
         gr.Examples(examples=examples, inputs=[prompt])
     gr.on(
         triggers=[run_button.click, prompt.submit],
@@ -330,9 +545,21 @@ with gr.Blocks(css=css) as demo:
             guidance_scale,
             num_inference_steps,
             model_selector,
+            eta,
+            strength,
+            num_images_per_prompt,
+            safety_checker,
         ],
         outputs=[result, seed],
     )
 
+    # Actualizar información del modelo cuando se seleccione
+    model_selector.change(
+        fn=get_model_info,
+        inputs=[model_selector],
+        outputs=[model_info]
+    )
+
 if __name__ == "__main__":
+    print("🚀 Iniciando Gradio app...")
     demo.launch()