Update app.py

app.py

@@ -1,138 +1,83 @@
-import os
-import torch
-import math
 import gradio as gr
+import torch
 from PIL import Image
-from diffusers import QwenImageEditPlusPipeline, FlowMatchEulerDiscreteScheduler
-from huggingface_hub import WebhooksServer
-
-# Configuración de variables globales del sistema
-BASE_MODEL = "prithivMLmods/Qwen-Image-Edit-AIO-FP8"
-LORA_COSPLAY = "joyfox/Qwen-Image-Edit-Cosplay"
-LORA_LIGHTNING = "lightx2v/Qwen-Image-Lightning"
+from diffusers import StableDiffusionXLImg2ImgPipeline
+import spaces
 
-# Inicialización de la configuración del planificador para pocos pasos de inferencia
-scheduler_config = {
-    "base_image_seq_len": 256,
-    "invert_sigmas": False,
-    "max_image_seq_len": 8192,
-    "max_shift": math.log(3),
-    "num_train_timesteps": 1000,
-    "shift": 1.0,
-    "shift_terminal": None,
-    "stochastic_sampling": False,
-    "time_shift_type": "exponential",
-    "use_beta_sigmas": False,
-    "use_dynamic_shifting": True,
-    "use_exponential_sigmas": False,
-    "use_karras_sigmas": False,
-}
+# 1. Definición del modelo súper ligero (Versión FP16 que pesa ~6.5GB)
+MODEL_ID = "stabilityai/stable-diffusion-xl-base-1.0"
 
-print("Cargando planificador de flujo de acoplamiento...")
-scheduler = FlowMatchEulerDiscreteScheduler.from_config(scheduler_config)
-
-print("Inicializando tubería multireferencia QwenImageEditPlusPipeline...")
-pipe = QwenImageEditPlusPipeline.from_pretrained(
-    BASE_MODEL,
-    scheduler=scheduler,
-    torch_dtype=torch.bfloat16,
-    low_cpu_mem_usage=True # <-- AÑADIDO: Previene el colapso OOM de la RAM del sistema
+print("Descargando e inicializando SDXL FP16...")
+pipe = StableDiffusionXLImg2ImgPipeline.from_pretrained(
+    MODEL_ID,
+    torch_dtype=torch.float16,
+    variant="fp16",
+    use_safetensors=True
 )
 
-# ELIMINADO: pipe.to("cuda") (Forzaba todo el modelo a la GPU de golpe)
-# AÑADIDO: Descarga inteligente entre CPU y GPU para ahorrar VRAM
+# 2. Descarga del modelo a CPU para ahorrar VRAM
 pipe.enable_model_cpu_offload()
 
-# Diccionario para controlar el estado de carga perezosa de la LoRA de cosplay
-loaded_adapters = {}
-
-def load_cosplay_adapters_on_demand():
-    """Carga de forma perezosa el adaptador LoRA de cosplay para optimizar la memoria"""
-    if "cosplay" not in loaded_adapters:
-        print("Carga perezosa activada: Descargando pesos de joyfox/Qwen-Image-Edit-Cosplay...")
-        pipe.load_lora_weights(LORA_COSPLAY, adapter_name="cosplay")
-        
-        print("Cargando adaptador de velocidad Qwen-Image-Lightning...")
-        pipe.load_lora_weights(
-            LORA_LIGHTNING,
-            weight_name="Qwen-Image-Lightning-8steps-V1.0.safetensors",
-            adapter_name="lightning"
-        )
-        
-        # Establecemos los pesos de fusión óptimos entre la velocidad y la especialización
-        pipe.set_adapters(["cosplay", "lightning"], adapter_weights=[0.85, 1.0])
-        loaded_adapters["cosplay"] = True
-        print("Adaptadores fusionados y listos en GPU.")
+# 3. Cargamos IP-Adapter (El puente que transfiere la ropa del anime a la persona)
+print("Cargando IP-Adapter para transferencia de estilo...")
+pipe.load_ip_adapter("h94/IP-Adapter", subfolder="sdxl_models", weight_name="ip-adapter_sdxl.safetensors")
+# Ajustamos la fuerza con la que el anime afectará la foto real (0.0 a 1.0)
+pipe.set_ip_adapter_scale(0.65) 
 
-def process_cosplay_edit(base_image, reference_image, prompt, steps, cfg, seed):
+# El decorador @spaces.GPU le dice a Hugging Face que te preste una A100 gratis por unos segundos
+@spaces.GPU
+def process_cosplay_edit(base_image, reference_image, prompt, steps, strength, seed):
     if base_image is None or reference_image is None:
-        raise gr.Error("Es obligatorio proporcionar tanto la imagen humana base como la referencia de anime.")
+        raise gr.Error("Es obligatorio proporcionar ambas imágenes.")
     
-    # Garantizar la carga del adaptador únicamente cuando se solicita la inferencia
-    load_cosplay_adapters_on_demand()
-    
-    # Redimensionamiento de las imágenes manteniendo la coherencia de dimensiones múltiples de 8
-    width, height = base_image.size
-    max_dimension = 1024
-    if max(width, height) > max_dimension:
-        factor = max_dimension / max(width, height)
-        width = int((width * factor) // 8) * 8
-        height = int((height * factor) // 8) * 8
-    else:
-        width = int(width // 8) * 8
-        height = int(height // 8) * 8
-
-    base_resized = base_image.resize((width, height), Image.Resampling.LANCZOS)
-    ref_resized = reference_image.resize((width, height), Image.Resampling.LANCZOS)
+    # Redimensionar para SDXL (optimizado para 1024x1024)
+    base_resized = base_image.resize((1024, 1024), Image.Resampling.LANCZOS)
+    ref_resized = reference_image.resize((1024, 1024), Image.Resampling.LANCZOS)
 
     generator = torch.Generator("cuda").manual_seed(int(seed))
     
-    # Inferencia sin seguimiento de gradiente para liberar caché de la GPU activamente
+    # La Inferencia
     with torch.inference_mode():
         output = pipe(
-            image=[base_resized, ref_resized],
             prompt=prompt,
-            negative_prompt=" ",
-            width=width,
-            height=height,
+            image=base_resized,           # La foto de la persona real (Estructura base)
+            ip_adapter_image=ref_resized, # La imagen del anime (Transferencia de estilo/ropa)
+            strength=float(strength),     # Cuánto permitimos que cambie la foto original
             num_inference_steps=int(steps),
-            true_cfg_scale=float(cfg),
+            guidance_scale=7.5,
             generator=generator
         )
         
-    return output.images
+    return output.images[0]
 
-# Construcción de la interfaz gráfica y de la API de backend de Gradio
-# delete_cache=(300, 300) limpia archivos temporales cada 5 minutos
-with gr.Blocks(delete_cache=(300, 300), theme=gr.themes.Default()) as demo:
-    gr.Markdown("# **Estudio de Transferencia de Vestimenta Cosplay (Qwen-Image-Edit)**")
-    gr.Markdown("Servicio REST y de interfaz para la clonación semántica de atuendos anime sobre personas reales.")
+# --- Interfaz de Gradio ---
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# **Estudio de Transferencia Cosplay (Modo Ligero - SDXL)**")
+    gr.Markdown("Ecosistema optimizado al 100% para el nivel gratuito de Hugging Face.")
     
     with gr.Row():
         with gr.Column():
-            base_input = gr.Image(label="Persona Real (Imagen 1)", type="pil")
-            ref_input = gr.Image(label="Personaje de Anime (Imagen 2)", type="pil")
+            base_input = gr.Image(label="Persona Real (Base)", type="pil")
+            ref_input = gr.Image(label="Personaje de Anime (Estilo/Ropa)", type="pil")
             prompt_input = gr.Textbox(
-                label="Instrucción de Edición Semántica",
-                value="把图2中动漫人物中的发型，服饰和装扮道具迁移到图1的真实人物，图1真实人物保持高度人脸一致性",
+                label="Instrucción",
+                value="masterpiece, best quality, highly detailed, realistic person wearing the exact cosplay outfit from the reference image, perfect face, cinematic lighting",
                 lines=3
             )
-            with gr.Accordion("Parámetros del Transformador", open=False):
-                inference_steps = gr.Slider(minimum=4, maximum=24, value=8, step=1, label="Pasos de Inferencia (Lightning)")
-                cfg_scale = gr.Slider(minimum=1.0, maximum=8.0, value=1.5, step=0.5, label="True CFG Scale")
-                seed_num = gr.Number(value=1337, label="Semilla Aleatoria")
+            with gr.Accordion("Parámetros Avanzados", open=False):
+                inference_steps = gr.Slider(minimum=10, maximum=50, value=25, step=1, label="Pasos de Inferencia")
+                strength_scale = gr.Slider(minimum=0.1, maximum=1.0, value=0.75, step=0.05, label="Fuerza de Transformación (Strength)")
+                seed_num = gr.Number(value=42, label="Semilla Aleatoria")
                 
-            generate_btn = gr.Button("Ejecutar Edición", variant="primary")
+            generate_btn = gr.Button("Ejecutar Transferencia", variant="primary")
             
         with gr.Column():
-            output_display = gr.Image(label="Imagen Resultante")
+            output_display = gr.Image(label="Resultado Final")
 
     generate_btn.click(
         fn=process_cosplay_edit,
-        inputs=[base_input, ref_input, prompt_input, inference_steps, cfg_scale, seed_num],
+        inputs=[base_input, ref_input, prompt_input, inference_steps, strength_scale, seed_num],
         outputs=output_display
     )
 
-# Inicializar la aplicación de Gradio
-demo.queue()
-demo.launch()
+demo.queue().launch()