Update app.py

app.py

@@ -1,12 +1,12 @@
-# app.py — InstantID SDXL + (optionnel) IP-Adapter Style pour rendu 2D
-# HF Space ready
+# app.py — InstantID SDXL + (optionnel) IP-Adapter Style (2D total)
+# Hugging Face Space – prêt à déployer
 
 # 0) Environnement AVANT TOUT IMPORT
 import os, sys
-os.environ["OMP_NUM_THREADS"] = "4"  # valeur safe pour libgomp
+os.environ["OMP_NUM_THREADS"] = "4"  # safe pour libgomp
 os.environ.setdefault("HF_HUB_ENABLE_HF_TRANSFER", "1")
 
-# rendre importable ./instantid/ip_adapter
+# rendre importable ./instantid (où se trouve pipeline_stable_diffusion_xl_instantid_full.py)
 sys.path.insert(0, os.path.abspath("./instantid"))
 
 # 1) Imports
@@ -20,21 +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"  # poids InstantID (ControlNet + ip-adapter instantid)
+ASSETS_REPO = "InstantX/InstantID"  # poids InstantID: IdentityNet + 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)
+# IP-Adapter Style (SDXL) — pour forcer le rendu 2D
+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")
 
 # 3) Téléchargements sûrs (détecte fichiers vides)
 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 if subfolder is None else os.path.basename(filename))
+    local_path = os.path.join(local_dir, 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)
@@ -57,35 +57,34 @@ def safe_download(repo, filename, local_dir, min_bytes, label, subfolder=None):
 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)
+    # IdentityNet (ControlNet) + 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 (InstantID)")
+    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)
+# 4) Import dynamique de la pipeline InstantID SDXL (officielle)
 def import_pipeline_or_fail():
     candidates = [
-        "./instantid/pipeline_stable_diffusion_xl_instantid.py",
         "./instantid/pipeline_stable_diffusion_xl_instantid_full.py",
+        "./instantid/pipeline_stable_diffusion_xl_instantid.py",
     ]
     pipeline_file = next((p for p in candidates if os.path.exists(p)), None)
     if pipeline_file is None:
-        raise RuntimeError("❌ Fichier pipeline manquant : place l’un de ces fichiers dans ./instantid/")
-
+        raise RuntimeError("❌ Fichier pipeline manquant.\nPlace `pipeline_stable_diffusion_xl_instantid_full.py` dans ./instantid/")
     if os.path.getsize(pipeline_file) < 1024:
-        raise RuntimeError("❌ Fichier pipeline trop petit (vide ?). Colle le contenu depuis GitHub InstantID.")
+        raise RuntimeError("❌ Fichier pipeline trop petit (vide ?). Colle la version SDXL officielle.")
 
     spec = importlib.util.spec_from_file_location("instantid_pipeline", pipeline_file)
     mod  = importlib.util.module_from_spec(spec)
     spec.loader.exec_module(mod)
+    # Chercher la classe SDXL officielle
     for name, obj in vars(mod).items():
         if isinstance(obj, type) and "InstantID" in name and hasattr(obj, "from_pretrained"):
             print(f"✅ Pipeline trouvée : {name}")
@@ -93,7 +92,7 @@ def import_pipeline_or_fail():
     avail = [n for n, o in vars(mod).items() if isinstance(o, type)]
     raise RuntimeError("❌ Aucune classe pipeline InstantID trouvée. Classes dispo: " + ", ".join(avail))
 
-# 5) draw_kps local (remplace la dépendance au draw_kps du fichier)
+# 5) draw_kps local (remplace la dépendance draw_kps du repo)
 def draw_kps_local(img_pil, kps):
     w, h = img_pil.size
     out = Image.new("RGB", (w, h), "white")
@@ -103,8 +102,9 @@ def draw_kps_local(img_pil, kps):
         d.ellipse((x - r, y - r, x + r, y + r), fill="black")
     return out
 
-# 6) Chargement pipeline (ControlNet en OBJET, pas liste)
+# 6) Chargement pipeline (ControlNet = objet unique)
 load_logs = []
+HAS_STYLE_ADAPTER = False
 try:
     SDXLInstantID = import_pipeline_or_fail()
     ensure_assets_or_download()
@@ -116,19 +116,16 @@ try:
 
     pipe = SDXLInstantID.from_pretrained(
         BASE_MODEL,
-        controlnet=controlnet_identitynet,  # objet unique
+        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)
+    # Charger l’IP-Adapter InstantID (identité)
     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.
+    # Charger (optionnel) un IP-Adapter Style SDXL, nommé "style"
     try:
         pipe.load_ip_adapter(
             IP_STYLE_REPO,
@@ -139,7 +136,7 @@ try:
         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}")
+        load_logs.append(f"ℹ️ IP-Adapter Style non chargé: {e}")
         HAS_STYLE_ADAPTER = False
 
     if DEVICE == "cuda":
@@ -150,12 +147,11 @@ 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))
 
-# 7) InsightFace (robuste : essaie antelopev2 puis buffalo_l)
+# 7) InsightFace (robuste : antelopev2 → buffalo_l)
 from insightface.app import FaceAnalysis
 def load_face_analyser():
     errors = []
@@ -172,32 +168,23 @@ def load_face_analyser():
 
 fa = load_face_analyser()
 
-def extract_kps_image(pil_img):
+# — util pour extraire embedding visage + landmarks (kps) depuis la photo
+def extract_face_embed_and_kps(pil_img):
     import numpy as np, cv2
     img_cv2 = cv2.cvtColor(np.array(pil_img.convert("RGB")), cv2.COLOR_RGB2BGR)
     faces = fa.get(img_cv2)
     if not faces:
         raise ValueError("Aucun visage détecté dans la photo.")
     face = faces[-1]
-    return draw_kps_local(pil_img, face["kps"])
-
-# --- util: normaliser image_embeds quelle que soit la forme renvoyée
-def _normalize_image_embeds(image_embeds):
-    import numpy as np
-    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
-    if isinstance(image_embeds, (tuple, list)):
-        if len(image_embeds) == 0: return None
-        image_embeds = image_embeds[0] if image_embeds[0] is not None else image_embeds[-1]
-    if isinstance(image_embeds, np.ndarray):
-        image_embeds = torch.from_numpy(image_embeds)
-    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
+    face_emb = face["embedding"]              # <— Embedding InsightFace attendu par la pipeline SDXL officielle
+    kps_img  = draw_kps_local(pil_img, face["kps"])
+    # Convertir en torch tensor si besoin (la pipeline accepte souvent ndarray directement)
+    if isinstance(face_emb, (list, tuple)):
+        import numpy as np
+        face_emb = np.array(face_emb)
+    return face_emb, kps_img
+
+# 8) Génération (Option A : on passe l’embedding InsightFace -> image_embeds)
 def generate(face_image, style_image, prompt, negative_prompt,
              identity_strength, adapter_strength, style_strength,
              steps, cfg, width, height, seed):
@@ -207,51 +194,24 @@ def generate(face_image, style_image, prompt, negative_prompt,
 
         gen = None if seed is None or int(seed) < 0 else torch.Generator(device=DEVICE).manual_seed(int(seed))
 
-        # 2) préparer visage (carré 512) + landmarks
+        # Préparer visage carré (512) pour détection consistante
         face = ImageOps.exif_transpose(face_image).convert("RGB")
         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)
+        # Embedding InsightFace + landmarks (kps)
+        face_emb, kps_img = extract_face_embed_and_kps(face_sq)
 
-        # 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
+        # Régler l’échelle des IP-Adapters (identité & style)
         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) 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
-                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 le fichier `pipeline_stable_diffusion_xl_instantid.py` est bien la version SDXL officielle."
-            ), "\n".join(load_logs)
-
-        # 5) multi-ControlNet compat
+            print(f"ℹ️ set_ip_adapter_scale ignoré: {e}")
+
+        # Compat multi-ControlNet
         cn = getattr(pipe, "controlnet", None)
         if isinstance(cn, (list, tuple)):
             n_cn = len(cn)
@@ -263,12 +223,12 @@ def generate(face_image, style_image, prompt, negative_prompt,
         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) préparer kwargs IP-Adapter Style si utilisé
+        # Préparer kwargs (NOTE: image_embeds = face_emb)
         gen_kwargs = dict(
             prompt=prompt.strip(),
             negative_prompt=(negative_prompt or "").strip(),
-            image=image_arg,
-            image_embeds=image_embeds,
+            image=image_arg,                             # IdentityNet (landmarks)
+            image_embeds=face_emb,                       # <— embedding InsightFace
             controlnet_conditioning_scale=scale_arg,
             num_inference_steps=int(steps),
             guidance_scale=float(cfg),
@@ -276,14 +236,14 @@ def generate(face_image, style_image, prompt, negative_prompt,
             height=int(height),
             generator=gen,
         )
-        # diffusers modernes: ip_adapter_image=style_image
+
+        # Fournir l’image de style à l’IP-Adapter Style si dispo
         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}")
+                print(f"ℹ️ ip_adapter_image ignoré: {e}")
 
-        # 7) appel pipeline
         images = pipe(**gen_kwargs).images
         return images[0], "", "\n".join(load_logs)
 
@@ -305,7 +265,7 @@ EX_NEG = (
 )
 
 with gr.Blocks(css="footer{display:none !important}") as demo:
-    gr.Markdown("# 🏴‍☠️ One Piece – InstantID SDXL + IP-Adapter Style (2D total)")
+    gr.Markdown("# 🏴‍☠️ One Piece – InstantID SDXL + IP-Adapter Style (2D total) — Option A officielle")
 
     with gr.Row():
         with gr.Column():
@@ -318,7 +278,6 @@ with gr.Blocks(css="footer{display:none !important}") as demo:
                 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")