Update app.py

app.py

@@ -1,4 +1,5 @@
-# app.py — InstantID SDXL (stable) : ControlNet objet unique, téléchargements sûrs, InsightFace fallback
+# app.py — InstantID SDXL + (optionnel) IP-Adapter Style pour rendu 2D
+# HF Space ready
 
 # 0) Environnement AVANT TOUT IMPORT
 import os, sys
@@ -19,15 +20,21 @@ DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
 DTYPE  = torch.float16 if DEVICE == "cuda" else torch.float32
 
 # 2) Chemins & Hub
-ASSETS_REPO = "InstantX/InstantID"       # repo Model public qui contient les poids
+ASSETS_REPO = "InstantX/InstantID"  # poids InstantID (ControlNet + ip-adapter instantid)
 CHECKPOINTS_DIR  = "./checkpoints"
 CN_LOCAL_DIR     = os.path.join(CHECKPOINTS_DIR, "ControlNetModel")
 IP_ADAPTER_LOCAL = os.path.join(CHECKPOINTS_DIR, "ip-adapter.bin")
 
+# --- IP-Adapter Style (SDXL) : h94/IP-Adapter
+IP_STYLE_REPO     = "h94/IP-Adapter"
+IP_STYLE_SUBFOLDER= "sdxl_models"
+IP_STYLE_WEIGHT   = "ip-adapter_sdxl.bin"
+IP_STYLE_LOCAL    = os.path.join(CHECKPOINTS_DIR, "ip-adapter_sdxl.bin")  # copie locale (utile hors cache HF)
+
 # 3) Téléchargements sûrs (détecte fichiers vides)
-def safe_download(repo, filename, local_dir, min_bytes, label):
+def safe_download(repo, filename, local_dir, min_bytes, label, subfolder=None):
     os.makedirs(local_dir, exist_ok=True)
-    local_path = os.path.join(local_dir, filename)
+    local_path = os.path.join(local_dir, filename if subfolder is None else os.path.basename(filename))
     if os.path.exists(local_path) and os.path.getsize(local_path) < min_bytes:
         print(f"⚠️ {label} corrompu ({os.path.getsize(local_path)} bytes) → suppression")
         try: os.remove(local_path)
@@ -36,8 +43,10 @@ def safe_download(repo, filename, local_dir, min_bytes, label):
         repo_id=repo,
         filename=filename,
         local_dir=local_dir,
+        local_dir_use_symlinks=False,
         resume_download=True,
         force_download=not os.path.exists(local_path),
+        subfolder=subfolder,
     )
     size = os.path.getsize(path)
     print(f"✅ {label} téléchargé ({size/1e6:.1f} MB)")
@@ -48,9 +57,18 @@ def safe_download(repo, filename, local_dir, min_bytes, label):
 def ensure_assets_or_download():
     os.makedirs(CHECKPOINTS_DIR, exist_ok=True)
     os.makedirs(CN_LOCAL_DIR, exist_ok=True)
+    # InstantID (IdentityNet + ip-adapter instantid)
     safe_download(ASSETS_REPO, "ControlNetModel/config.json", CHECKPOINTS_DIR, 1_000, "IdentityNet config")
     safe_download(ASSETS_REPO, "ControlNetModel/diffusion_pytorch_model.safetensors", CHECKPOINTS_DIR, 100_000_000, "IdentityNet weights")
-    safe_download(ASSETS_REPO, "ip-adapter.bin", CHECKPOINTS_DIR, 100_000_000, "ip-adapter")
+    safe_download(ASSETS_REPO, "ip-adapter.bin", CHECKPOINTS_DIR, 100_000_000, "ip-adapter (InstantID)")
+    # IP-Adapter Style (SDXL)
+    p = safe_download(IP_STYLE_REPO, IP_STYLE_WEIGHT, CHECKPOINTS_DIR, 20_000_000, "IP-Adapter Style (SDXL)", subfolder=IP_STYLE_SUBFOLDER)
+    # copieur simple pour avoir une voie locale directe si besoin
+    try:
+        if not os.path.exists(IP_STYLE_LOCAL):
+            import shutil; shutil.copy2(p, IP_STYLE_LOCAL)
+    except Exception as e:
+        print(f"ℹ️ Copie locale IP-Adapter Style ignorée: {e}")
 
 # 4) Import dynamique de la pipeline InstantID (fichier texte local)
 def import_pipeline_or_fail():
@@ -96,16 +114,34 @@ try:
 
     controlnet_identitynet = ControlNetModel.from_pretrained(CN_LOCAL_DIR, torch_dtype=DTYPE)
 
-    # 🔧 Ici: controlnet=controlnet_identitynet (objet unique)
     pipe = SDXLInstantID.from_pretrained(
         BASE_MODEL,
-        controlnet=controlnet_identitynet,
+        controlnet=controlnet_identitynet,  # objet unique
         torch_dtype=DTYPE,
         safety_checker=None,
         feature_extractor=None,
     ).to(DEVICE)
 
+    # 6.1) Charger l'IP-Adapter InstantID (pour l'identité)
+    # (la pipeline InstantID fournit cette méthode utilitaire)
     pipe.load_ip_adapter_instantid(IP_ADAPTER_LOCAL)
+
+    # 6.2) (Optionnel) Charger un IP-Adapter Style SDXL (h94/IP-Adapter)
+    # On le nomme "style" pour l'adresser séparément dans set_ip_adapter_scale().
+    # Suivant diffusers, adapter_name peut ne pas exister: gérer fallback.
+    try:
+        pipe.load_ip_adapter(
+            IP_STYLE_REPO,
+            subfolder=IP_STYLE_SUBFOLDER,
+            weight_name=IP_STYLE_WEIGHT,
+            adapter_name="style",
+        )
+        load_logs.append("✅ IP-Adapter Style (SDXL) chargé (adapter_name='style').")
+        HAS_STYLE_ADAPTER = True
+    except Exception as e:
+        load_logs.append(f"ℹ️ Impossible de charger IP-Adapter Style via load_ip_adapter: {e}")
+        HAS_STYLE_ADAPTER = False
+
     if DEVICE == "cuda":
         if hasattr(pipe, "image_proj_model"): pipe.image_proj_model.to("cuda")
         if hasattr(pipe, "unet"):             pipe.unet.to("cuda")
@@ -114,6 +150,7 @@ try:
 except Exception:
     load_logs += ["❌ ERREUR au chargement:", traceback.format_exc()]
     pipe = None
+    HAS_STYLE_ADAPTER = False
 
 if pipe is None:
     raise RuntimeError("Échec de chargement du pipeline.\n" + "\n".join(load_logs))
@@ -124,7 +161,6 @@ def load_face_analyser():
     errors = []
     for name in ("antelopev2", "buffalo_l"):
         try:
-            # cache sous ./models pour éviter les permissions
             fa = FaceAnalysis(name=name, root="./models", providers=["CPUExecutionProvider"])
             fa.prepare(ctx_id=0, det_size=(640, 640))
             print(f"✅ InsightFace chargé: {name}")
@@ -143,106 +179,115 @@ def extract_kps_image(pil_img):
     if not faces:
         raise ValueError("Aucun visage détecté dans la photo.")
     face = faces[-1]
-    # faces[-1]['kps'] → 5 points (yeux G/D, nez, bouche G/D)
     return draw_kps_local(pil_img, face["kps"])
 
-# --- util: normaliser image_embeds quelle que soit la forme renvoyée (tensor / tuple / dict / list)
+# --- util: normaliser image_embeds quelle que soit la forme renvoyée
 def _normalize_image_embeds(image_embeds):
     import numpy as np
-    # dict
     if isinstance(image_embeds, dict):
         for k in ("image_embeds", "prompt_image_embeds", "pooled_prompt_embeds"):
             if k in image_embeds and image_embeds[k] is not None:
-                image_embeds = image_embeds[k]
-                break
-    # tuple/list
+                image_embeds = image_embeds[k]; break
     if isinstance(image_embeds, (tuple, list)):
-        # heuristique: certains renvoient (image_embeds, pooled) ou l’inverse
-        if len(image_embeds) == 0:
-            return None
+        if len(image_embeds) == 0: return None
         image_embeds = image_embeds[0] if image_embeds[0] is not None else image_embeds[-1]
-    # numpy -> torch
     if isinstance(image_embeds, np.ndarray):
         image_embeds = torch.from_numpy(image_embeds)
-    # vers bon device/dtype si tensor
     if isinstance(image_embeds, torch.Tensor):
         image_embeds = image_embeds.to(device=DEVICE, dtype=DTYPE if DEVICE == "cuda" else torch.float32)
     return image_embeds
 
 # 8) Génération
-def generate(face_image, prompt, negative_prompt, identity_strength, adapter_strength, steps, cfg, width, height, seed):
+def generate(face_image, style_image, prompt, negative_prompt,
+             identity_strength, adapter_strength, style_strength,
+             steps, cfg, width, height, seed):
     try:
-        # 0) garde-fous basiques
         if face_image is None:
             return None, "Merci d'ajouter une photo visage.", "\n".join(load_logs)
 
-        # 1) seed
         gen = None if seed is None or int(seed) < 0 else torch.Generator(device=DEVICE).manual_seed(int(seed))
 
-        # 2) préparer l'image visage (carré 512) + landmarks (kps)
+        # 2) préparer visage (carré 512) + landmarks
         face = ImageOps.exif_transpose(face_image).convert("RGB")
-        ms = min(face.size)
-        x = (face.width - ms) // 2
-        y = (face.height - ms) // 2
+        ms = min(face.size); x = (face.width - ms) // 2; y = (face.height - ms) // 2
         face_sq = face.crop((x, y, x + ms, y + ms)).resize((512, 512), Image.Resampling.LANCZOS)
 
         kps_img = extract_kps_image(face_sq)  # -> image landmarks (noir sur blanc)
 
-        # 3) régler la force de l’IP-Adapter (style/détails)
-        if hasattr(pipe, "set_ip_adapter_scale"):
-            pipe.set_ip_adapter_scale(float(adapter_strength))
+        # 3) règles IP-Adapter scales
+        # - adapter_strength = détails anime d’InstantID (son IP-adapter interne)
+        # - style_strength   = force de l’IP-Adapter Style (si présent + image fournie)
+        # On supporte dict (multi-adapters nommés) et fallback simple.
+        set_scale_ok = False
+        try:
+            if HAS_STYLE_ADAPTER and style_image is not None:
+                pipe.set_ip_adapter_scale({"instantid": float(adapter_strength), "style": float(style_strength)})
+            else:
+                # pas de style → ne régler que l’adapter InstantID
+                pipe.set_ip_adapter_scale(float(adapter_strength))
+            set_scale_ok = True
+        except Exception as e:
+            print(f"ℹ️ set_ip_adapter_scale fallback: {e}")
+            try:
+                pipe.set_ip_adapter_scale(float(adapter_strength))
+                set_scale_ok = True
+            except Exception as e2:
+                print(f"⚠️ set_ip_adapter_scale impossible: {e2}")
 
-        # 4) calculer les embeddings d'image pour InstantID (différentes API selon versions)
+        # 4) embeddings InstantID visage
         image_embeds = None
         for m in ("get_image_embeds", "prepare_ip_adapter_image_embeds", "encode_image", "encode_ip_image"):
             fn = getattr(pipe, m, None)
             if callable(fn):
                 try:
-                    image_embeds = fn(face_sq)
-                    break
+                    image_embeds = fn(face_sq); break
                 except Exception as e:
                     print(f"⚠️ {m} a échoué: {e}")
-
         image_embeds = _normalize_image_embeds(image_embeds)
         if image_embeds is None:
             return None, (
                 "La pipeline InstantID SDXL requiert des `image_embeds`, mais aucune méthode compatible n'a été trouvée "
                 "(get_image_embeds / prepare_ip_adapter_image_embeds / encode_image / encode_ip_image). "
-                "Vérifie que tu as bien collé la version SDXL officielle du fichier "
-                "`pipeline_stable_diffusion_xl_instantid.py`."
+                "Vérifie que le fichier `pipeline_stable_diffusion_xl_instantid.py` est bien la version SDXL officielle."
             ), "\n".join(load_logs)
 
-        # 5) compat multi-ControlNet : si la pipeline expose controlnet en liste, il faut des listes
+        # 5) multi-ControlNet compat
         cn = getattr(pipe, "controlnet", None)
         if isinstance(cn, (list, tuple)):
             n_cn = len(cn)
         else:
-            try:
-                n_cn = len(cn)
-            except Exception:
-                n_cn = 1
+            try: n_cn = len(cn)
+            except Exception: n_cn = 1
 
         image_arg = [kps_img] * n_cn if n_cn > 1 else ([kps_img] if isinstance(cn, (list, tuple)) else kps_img)
         scale_val = float(identity_strength)
         scale_arg = [scale_val] * n_cn if n_cn > 1 else ([scale_val] if isinstance(cn, (list, tuple)) else scale_val)
 
-        # 6) appel pipeline
-        images = pipe(
+        # 6) préparer kwargs IP-Adapter Style si utilisé
+        gen_kwargs = dict(
             prompt=prompt.strip(),
             negative_prompt=(negative_prompt or "").strip(),
-            image=image_arg,                              # liste si multi-controlnet
-            image_embeds=image_embeds,                    # embeddings visage (obligatoire pour InstantID SDXL)
-            controlnet_conditioning_scale=scale_arg,      # liste si multi-controlnet
+            image=image_arg,
+            image_embeds=image_embeds,
+            controlnet_conditioning_scale=scale_arg,
             num_inference_steps=int(steps),
             guidance_scale=float(cfg),
             width=int(width),
             height=int(height),
             generator=gen,
-        ).images
+        )
+        # diffusers modernes: ip_adapter_image=style_image
+        if HAS_STYLE_ADAPTER and style_image is not None:
+            try:
+                gen_kwargs["ip_adapter_image"] = ImageOps.exif_transpose(style_image).convert("RGB")
+            except Exception as e:
+                print(f"ℹ️ ip_adapter_image conversion ignorée: {e}")
 
+        # 7) appel pipeline
+        images = pipe(**gen_kwargs).images
         return images[0], "", "\n".join(load_logs)
 
-    except torch.cuda.OutOfMemoryError as oom:
+    except torch.cuda.OutOfMemoryError:
         return None, "CUDA OOM: baisse la résolution ou les steps.", "\n".join(load_logs)
     except Exception:
         return None, "Erreur:\n" + traceback.format_exc(), "\n".join(load_logs)
@@ -251,25 +296,33 @@ def generate(face_image, prompt, negative_prompt, identity_strength, adapter_str
 EX_PROMPT = (
     "one piece style, Eiichiro Oda style, anime portrait, upper body, pirate outfit, straw hat, "
     "clean lineart, cel shading, vibrant colors, expressive eyes, symmetrical face, looking at camera, "
-    "dynamic lighting, simple background, high detail"
+    "dynamic composition, simple background"
 )
 EX_NEG = (
+    "realistic, photo, photorealistic, skin pores, complex lighting, "
     "low quality, worst quality, lowres, blurry, noisy, watermark, text, logo, jpeg artifacts, "
     "bad anatomy, distorted eyes, deformed, multiple faces, nsfw"
 )
 
 with gr.Blocks(css="footer{display:none !important}") as demo:
-    gr.Markdown("# 🏴‍☠️ One Piece – InstantID SDXL (stable)")
+    gr.Markdown("# 🏴‍☠️ One Piece – InstantID SDXL + IP-Adapter Style (2D total)")
 
     with gr.Row():
         with gr.Column():
-            face_image = gr.Image(type="pil", label="Photo visage", height=360)
-            prompt = gr.Textbox(label="Prompt", value=EX_PROMPT, lines=3)
-            negative = gr.Textbox(label="Negative Prompt", value=EX_NEG, lines=3)
-            identity_strength = gr.Slider(0.2, 1.5, 0.95, 0.05, label="Fidélité visage (IdentityNet)")
-            adapter_strength  = gr.Slider(0.2, 1.5, 0.85, 0.05, label="Détails anime (Adapter)")
+            face_image  = gr.Image(type="pil", label="Photo visage (obligatoire)", height=260)
+            style_image = gr.Image(type="pil", label="Image de style (IP-Adapter) — optionnel", height=260)
+            prompt  = gr.Textbox(label="Prompt", value=EX_PROMPT, lines=3)
+            negative= gr.Textbox(label="Negative Prompt", value=EX_NEG, lines=3)
+
+            with gr.Row():
+                identity_strength = gr.Slider(0.2, 1.5, 0.95, 0.05, label="Fidélité visage (IdentityNet)")
+                adapter_strength  = gr.Slider(0.1, 1.5, 0.85, 0.05, label="Détails anime (InstantID IP-Adapter)")
+
+            # Nouveau : force style (IP-Adapter Style)
+            style_strength = gr.Slider(0.1, 1.5, 0.95, 0.05, label="Force style (IP-Adapter Style)")
+
             steps  = gr.Slider(10, 60, 30, 1, label="Steps")
-            cfg    = gr.Slider(0.1, 12.0, 5.5, 0.1, label="CFG")
+            cfg    = gr.Slider(0.1, 12.0, 6.5, 0.1, label="CFG")
             width  = gr.Dropdown(choices=[576, 640, 704, 768, 896], value=704, label="Largeur")
             height = gr.Dropdown(choices=[704, 768, 896, 1024], value=896, label="Hauteur")
             seed   = gr.Number(value=-1, label="Seed (-1 aléatoire)")
@@ -278,7 +331,7 @@ with gr.Blocks(css="footer{display:none !important}") as demo:
         with gr.Column():
             out_image = gr.Image(label="Résultat", interactive=False)
             err_box   = gr.Textbox(label="Erreurs", visible=False)
-            log_box   = gr.Textbox(label="Logs", value="\n".join(load_logs), lines=10)
+            log_box   = gr.Textbox(label="Logs", value="\n".join(load_logs), lines=12)
 
     def wrap(*args):
         img, err, logs = generate(*args)
@@ -286,7 +339,9 @@ with gr.Blocks(css="footer{display:none !important}") as demo:
 
     btn.click(
         wrap,
-        inputs=[face_image, prompt, negative, identity_strength, adapter_strength, steps, cfg, width, height, seed],
+        inputs=[face_image, style_image, prompt, negative,
+                identity_strength, adapter_strength, style_strength,
+                steps, cfg, width, height, seed],
         outputs=[out_image, err_box, log_box],
     )