Update app.py

app.py

@@ -1,30 +1,136 @@
-import gradio as gr
+import os
 import torch
-from diffusers import DiffusionPipeline # Ajustar según el modelo específico
+import math
+import gradio as gr
 from PIL import Image
-import base64
-import io
-
-# 1. Cargar el modelo en memoria al iniciar el Space
-device = "cuda" if torch.cuda.is_available() else "cpu"
-# Este es un ejemplo, debes ajustar el ID según el modelo de Qwen que uses
-model_id = "joyfox/Qwen-Image-Edit-Cosplay" 
-pipe = DiffusionPipeline.from_pretrained(model_id).to(device)
-
-def procesar_cosplay(imagen_real, imagen_ref, prompt):
-    # 2. Tu lógica para convertir Base64 a imagen real
-    # (Tu función de decodificación actual ya es correcta)
+from diffusers import QwenImageEditPlusPipeline, FlowMatchEulerDiscreteScheduler
+from huggingface_hub import WebhooksServer
+
+# Configuración de variables globales del sistema
+BASE_MODEL = "Qwen/Qwen-Image-Edit-2509"
+LORA_COSPLAY = "joyfox/Qwen-Image-Edit-Cosplay"
+LORA_LIGHTNING = "lightx2v/Qwen-Image-Lightning"
+
+# 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,
+}
+
+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
+)
+
+# Descarga de pesos utilizando la API de Hugging Face e instanciación en GPU
+pipe.to("cuda")
+
+# 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.")
+
+def process_cosplay_edit(base_image, reference_image, prompt, steps, cfg, 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.")
     
-    # 3. Ejecutar la inferencia localmente
-    resultado = pipe(prompt=prompt, image=imagen_real, ref_image=imagen_ref).images[0]
+    # Garantizar la carga del adaptador únicamente cuando se solicita la inferencia
+    load_cosplay_adapters_on_demand()
     
-    return resultado
+    # 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
 
-# 4. Interfaz Gradio
-demo = gr.Interface(
-    fn=procesar_cosplay,
-    inputs=[gr.Image(type="pil"), gr.Image(type="pil"), gr.Textbox()],
-    outputs="image"
-)
+    base_resized = base_image.resize((width, height), Image.Resampling.LANCZOS)
+    ref_resized = reference_image.resize((width, height), Image.Resampling.LANCZOS)
+
+    generator = torch.Generator("cuda").manual_seed(int(seed))
+    
+    # Inferencia sin seguimiento de gradiente para liberar caché de la GPU activamente
+    with torch.inference_mode():
+        output = pipe(
+            image=[base_resized, ref_resized],
+            prompt=prompt,
+            negative_prompt=" ",
+            width=width,
+            height=height,
+            num_inference_steps=int(steps),
+            true_cfg_scale=float(cfg),
+            generator=generator
+        )
+        
+    return output.images
+
+# 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.")
+    
+    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")
+            prompt_input = gr.Textbox(
+                label="Instrucción de Edición Semántica",
+                value="把图2中动漫人物中的发型，服饰和装扮道具迁移到图1的真实人物，图1真实人物保持高度人脸一致性",
+                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")
+                
+            generate_btn = gr.Button("Ejecutar Edición", variant="primary")
+            
+        with gr.Column():
+            output_display = gr.Image(label="Imagen Resultante")
+
+    generate_btn.click(
+        fn=process_cosplay_edit,
+        inputs=[base_input, ref_input, prompt_input, inference_steps, cfg_scale, seed_num],
+        outputs=output_display
+    )
 
+# Inicializar la aplicación de Gradio
+demo.queue()
 demo.launch()