klein9 refmods

klein9/comfyui/custom_nodes/ComfyUI-Flux2Klein9Mod/README.md

@@ -0,0 +1,74 @@
+# ComfyUI-Flux2Klein9Mod
+
+**No-training "RefMod" reference adapters for FLUX.2 and Klein9.**
+
+RefMods pre-encode reference images and datasets into compact, reusable `.safetensors` adapters stored in `models/refmods-klein9/`. Rather than loading and VAE-encoding raw 4K/1024px image files on every generation run (which adds 4096+ tokens and heavy attention latency), RefMods inject pre-computed reference latents directly into the FLUX.2 / Klein9 2D RoPE sequence with instant loading, zero VAE overhead, and full multi-character scaling.
+
+---
+
+## 📦 Features
+
+- **Pre-encoded Latent Storage:** Stored in `ComfyUI/models/refmods-klein9/`.
+- **Zero VAE Generation Latency:** Latents are loaded directly from disk without runtime VAE encoding.
+- **Configurable Token Budgets:** Native resolution or spatial pooling to target budgets (e.g. 512, 1024, 2048 tokens).
+- **Multi-Subject Scaling:** Load up to 8 distinct RefMods simultaneously (`mod_1` through `mod_8`) with independent strengths.
+- **Manifold Blending:** Smooth weakening and strength attenuation using spatial low-pass filtering along the latent manifold instead of noise degradation.
+- **Universal Compatibility:** Works with any standard ComfyUI `CONDITIONING` graph for FLUX.2, Klein 4B, Klein 8B, and Klein 9B models.
+
+---
+
+## 🚀 Installation
+
+1. Navigate to your ComfyUI `custom_nodes` folder:
+   ```bash
+   cd ComfyUI/custom_nodes
+   ```
+2. Clone or place this repository:
+   ```bash
+   git clone https://github.com/malcolmrey/ComfyUI-Flux2Klein9Mod.git
+   ```
+3. Ensure the model folder exists:
+   ```text
+   ComfyUI/models/refmods-klein9/
+   ```
+4. Restart ComfyUI.
+
+---
+
+## 🧩 Nodes
+
+| Node Name | Category | Description |
+| :--- | :--- | :--- |
+| **`Load Klein9 RefMods (FLUX.2)`** (`Klein9RefModsLoader`) | `model/conditioning/klein9` | Loads 1–8 RefMod `.safetensors` files from `models/refmods-klein9/` with individual strengths (0.0–3.0) and repeat counts. |
+| **`Apply Klein9 RefMods (FLUX.2)`** (`Klein9RefModApply`) | `model/conditioning/klein9` | Injects the loaded RefMod bundle into standard ComfyUI `CONDITIONING` (`reference_latents`). |
+| **`Extract Klein9 RefMod (FLUX.2)`** (`Klein9RefModExtract`) | `model/conditioning/klein9` | In-graph VAE encode & token compression of input images directly into a saved `.safetensors` file in `models/refmods-klein9/`. |
+| **`Load RefMod Folder (Images)`** (`Klein9RefModFolderLoader`) | `model/conditioning/klein9` | Batch loads an entire folder of reference images for extraction. |
+
+---
+
+## 🛠️ Graph Wiring
+
+```text
+[ CLIPTextEncode ] (Prompt) 
+         │
+         ▼
+[ Apply Klein9 RefMods (FLUX.2) ] ◄── [ Load Klein9 RefMods (FLUX.2) ]
+         │ (conditioning out)          (Selects models from models/refmods-klein9/)
+         ▼
+[ CFGGuider / SamplerCustomAdvanced ]
+```
+
+---
+
+## 💻 CLI Extraction Tool
+
+You can also pre-encode image datasets using the CLI:
+
+```bash
+python custom_nodes/ComfyUI-Flux2Klein9Mod/extract_klein9_mod.py \
+  --name fk9_aneta_v1_refmod \
+  --dataset-dir C:/Development/ai-toolkit/datasets/aneta \
+  --concept-type identity \
+  --token-budget 1024 \
+  --output-dir C:/Development/ComfyUI/models/refmods-klein9/
+```

klein9/comfyui/custom_nodes/ComfyUI-Flux2Klein9Mod/__init__.py

@@ -0,0 +1,20 @@
+"""
+ComfyUI-Flux2Klein9Mod — No-training "RefMod" reference adapters for FLUX.2 & Klein9
+
+FLUX.2 and Klein9 accept reference image tokens directly within the packed sequence.
+RefMods compress reference datasets/images into compact, pre-encoded latents (.safetensors)
+stored in models/refmods-klein9/.
+
+Nodes:
+  Klein9RefModsLoader       — Load 1-8 pre-extracted RefMods from models/refmods-klein9/
+  Klein9RefModApply         — Inject RefMods bundle into standard ComfyUI CONDITIONING
+  Klein9RefModExtract       — In-graph VAE encode & compression -> saved .safetensors in models/refmods-klein9/
+  Klein9RefModFolderLoader  — Batch load reference images from a disk folder
+"""
+
+__author__ = "malcolmrey"
+__version__ = "1.0.0"
+
+from .nodes import NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS
+
+__all__ = ["NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS"]

klein9/comfyui/custom_nodes/ComfyUI-Flux2Klein9Mod/common.py

@@ -0,0 +1,49 @@
+"""Shared helpers for the Klein9 RefMod pack: media loading and models/refmods-klein9 folder."""
+
+from __future__ import annotations
+
+import os
+from typing import List, Optional, Tuple
+
+import torch
+
+IMAGE_EXTS = {".png", ".jpg", ".jpeg", ".webp", ".bmp", ".gif"}
+
+
+def refmods_klein9_dir() -> str:
+    """ComfyUI models/refmods-klein9 — the mod storage folder for Flux2 / Klein9.
+
+    Sits next to loras/, unet/, checkpoints/, and refmods/.
+    """
+    import folder_paths
+    d = os.path.join(folder_paths.models_dir, "refmods-klein9")
+    os.makedirs(d, exist_ok=True)
+    return d
+
+
+def list_media_files(folder: str) -> List[str]:
+    """List image files directly under folder (top level only), sorted by name."""
+    images = []
+    if os.path.isdir(folder):
+        for fn in sorted(os.listdir(folder)):
+            ext = os.path.splitext(fn)[1].lower()
+            p = os.path.join(folder, fn)
+            if os.path.isfile(p) and ext in IMAGE_EXTS:
+                images.append(p)
+    return images
+
+
+def load_image_file(path: str, max_edge: Optional[int] = None) -> torch.Tensor:
+    """Load one image file -> [1, H, W, 3] float32 in [0, 1]."""
+    import numpy as np
+    from PIL import Image
+    with Image.open(path) as img:
+        img = img.convert("RGB")
+        w, h = img.size
+        if max_edge is not None:
+            scale = min(1.0, max_edge / max(w, h))
+            if scale < 1.0:
+                img = img.resize((max(1, round(w * scale)), max(1, round(h * scale))),
+                                 Image.LANCZOS)
+        arr = torch.from_numpy(np.asarray(img).copy()).float() / 255.0
+    return arr.unsqueeze(0)  # [1, H, W, 3]

klein9/comfyui/custom_nodes/ComfyUI-Flux2Klein9Mod/core.py

@@ -0,0 +1,195 @@
+"""
+core.py — "RefMod" reference adapter engine for FLUX.2 and Klein9
+
+FLUX.2 / Klein9 injects reference image tokens directly into the joint sequence:
+the reference image is VAE-encoded, patchified (patch_size=2), and positioned on
+the 2D RoPE coordinate grid alongside text tokens and noisy latent tokens.
+
+Standard reference workflows encode raw high-resolution images live on every run,
+which generates thousands of tokens (e.g. 1024x1024 -> 4096 tokens) per reference image,
+causing high VRAM consumption and quadratic self-attention latency.
+
+A Klein9 RefMod pre-encodes reference imagery once into a compact, pre-computed
+latent adapter (.safetensors) stored in models/refmods-klein9/:
+  * The reference is VAE-encoded to its latent representation [B, C, H, W].
+  * Optionally, the latent is spatial-pooled/compressed to a targeted token budget
+    (e.g., 512, 1024, 2048 tokens, or native full resolution).
+  * At inference time, the pre-computed latents are injected into CONDITIONING
+    under the model's native reference_latents key instantly with zero VAE latency.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+import os
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple
+
+import torch
+import torch.nn.functional as F
+from safetensors import safe_open
+from safetensors.torch import load_file, save_file
+
+META_KEY = "klein9_refmod_meta"
+
+CONCEPT_TYPES = (
+    "identity",      # a specific person/character face/body
+    "style",         # artistic style, color grading, illustration aesthetic
+    "character",     # fictional character, costume, anatomy
+    "clothing",      # specific outfit, garment, textures
+    "background",    # environment, lighting, backdrop plate
+    "generic",       # mixed / multi-concept
+)
+
+TOKEN_BUDGETS = (
+    "native",        # full uncompressed VAE resolution
+    "4096",          # ~1024x1024 equivalent
+    "2048",          # ~724x724 equivalent
+    "1024",          # ~512x512 equivalent (fast & high fidelity)
+    "512",           # ~362x362 equivalent (ultra lightweight)
+    "256",           # ~256x256 equivalent
+)
+
+
+@dataclass
+class Klein9RefMod:
+    name: str
+    samples: torch.Tensor                     # [B, C, H, W]
+    concept_type: str = "identity"
+    mode: str = "encode"                      # "encode" (native) or "pooled"
+    resolution: int = 1024
+    token_budget: int = 1024
+    meta: Dict = field(default_factory=dict)
+
+    @property
+    def token_count(self) -> int:
+        """Approximate patchified token count (assuming patch_size=2)."""
+        if self.samples.dim() == 4:
+            b, c, h, w = self.samples.shape
+            return (h // 2) * (w // 2) * b
+        return self.samples.numel() // (16 * 4)
+
+
+def _blur_latent(z: torch.Tensor, factor: int = 8) -> torch.Tensor:
+    """Spatial low-pass filter (downsample then upsample) on the latent manifold.
+
+    Used when applying reference strength < 1.0. Mixing toward a blurred copy
+    preserves smooth latent correlations rather than injecting Gaussian noise artifacts.
+    """
+    if z.dim() != 4:
+        return z
+    b, c, h, w = z.shape
+    sh, sw = max(1, h // factor), max(1, w // factor)
+    down = F.adaptive_avg_pool2d(z.float(), (sh, sw))
+    up = F.interpolate(down, size=(h, w), mode="bilinear", align_corners=False)
+    return up.to(z.dtype)
+
+
+def pool_latent_to_budget(z: torch.Tensor, target_tokens: int, patch_size: int = 2) -> torch.Tensor:
+    """Adaptively downsample latent spatial dimensions to match a target token budget."""
+    if z.dim() != 4:
+        return z
+    b, c, h, w = z.shape
+    current_tokens = (h // patch_size) * (w // patch_size)
+    if current_tokens <= target_tokens or target_tokens <= 0:
+        return z
+
+    aspect = w / max(1, h)
+    # target_tokens = (th / 2) * (tw / 2) = (th / 2) * (th * aspect / 2) = th^2 * aspect / 4
+    th = max(patch_size, int(round(math.sqrt((target_tokens * (patch_size ** 2)) / aspect))))
+    tw = max(patch_size, int(round(th * aspect)))
+
+    # Ensure divisible by patch_size
+    th = max(patch_size, (th // patch_size) * patch_size)
+    tw = max(patch_size, (tw // patch_size) * patch_size)
+
+    down = F.adaptive_avg_pool2d(z.float(), (th, tw))
+    return down.to(z.dtype)
+
+
+def fit_token_budget(z: torch.Tensor, budget_str: str, patch_size: int = 2) -> torch.Tensor:
+    """Pool or keep latent according to the specified token budget setting."""
+    if budget_str == "native" or not budget_str:
+        return z
+    try:
+        budget_int = int(budget_str)
+        return pool_latent_to_budget(z, budget_int, patch_size=patch_size)
+    except (ValueError, TypeError):
+        return z
+
+
+def read_refmod_meta(path_no_ext: str) -> Optional[Dict]:
+    """Read metadata block from a .safetensors file without loading tensor payloads."""
+    path = path_no_ext if path_no_ext.endswith(".safetensors") else path_no_ext + ".safetensors"
+    if not os.path.isfile(path):
+        return None
+    try:
+        with safe_open(path, framework="pt", device="cpu") as f:
+            raw_meta = f.metadata()
+            if raw_meta and META_KEY in raw_meta:
+                try:
+                    return json.loads(raw_meta[META_KEY])
+                except Exception:
+                    pass
+    except Exception:
+        pass
+    return None
+
+
+def save_refmod(mod: Klein9RefMod, out_path: str) -> str:
+    """Save a Klein9RefMod to a .safetensors file with embedded JSON metadata."""
+    if not out_path.endswith(".safetensors"):
+        out_path += ".safetensors"
+    os.makedirs(os.path.dirname(os.path.abspath(out_path)), exist_ok=True)
+
+    header_meta = {
+        "name": mod.name,
+        "concept_type": mod.concept_type,
+        "mode": mod.mode,
+        "resolution": mod.resolution,
+        "token_budget": mod.token_budget,
+        "token_count": mod.token_count,
+        "channels": mod.samples.shape[1] if mod.samples.dim() >= 2 else 16,
+        "shape": list(mod.samples.shape),
+        "generator": "ComfyUI-Flux2Klein9Mod",
+    }
+    if mod.meta:
+        header_meta.update(mod.meta)
+
+    tensors = {
+        "samples": mod.samples.contiguous().to(torch.bfloat16 if torch.cuda.is_bf16_supported() else torch.float16)
+    }
+
+    save_file(tensors, out_path, metadata={META_KEY: json.dumps(header_meta)})
+    return out_path
+
+
+def load_refmod(path: str, device: str = "cpu") -> Klein9RefMod:
+    """Load a Klein9RefMod from a .safetensors file."""
+    if not path.endswith(".safetensors"):
+        path += ".safetensors"
+    if not os.path.isfile(path):
+        raise FileNotFoundError(f"Klein9 RefMod file not found: {path}")
+
+    meta = read_refmod_meta(path) or {}
+    tensors = load_file(path, device=device)
+    samples = tensors.get("samples")
+    if samples is None:
+        raise ValueError(f"Invalid RefMod: 'samples' tensor missing in {path}")
+
+    name = meta.get("name", os.path.splitext(os.path.basename(path))[0])
+    concept_type = meta.get("concept_type", "identity")
+    mode = meta.get("mode", "encode")
+    resolution = meta.get("resolution", 1024)
+    token_budget = meta.get("token_budget", 1024)
+
+    return Klein9RefMod(
+        name=name,
+        samples=samples,
+        concept_type=concept_type,
+        mode=mode,
+        resolution=resolution,
+        token_budget=token_budget,
+        meta=meta
+    )

klein9/comfyui/custom_nodes/ComfyUI-Flux2Klein9Mod/extract_klein9_mod.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+"""
+extract_klein9_mod.py — CLI tool to extract FLUX.2 / Klein9 RefMod (.safetensors) from reference images.
+
+Usage:
+  python extract_klein9_mod.py \
+    --vae path/to/flux2_vae.safetensors \
+    --name fk9_aneta_v1_refmod \
+    --dataset-dir C:/Development/ai-toolkit/datasets/aneta \
+    --concept-type identity \
+    --token-budget 1024 \
+    --output-dir C:/Development/ComfyUI/models/refmods-klein9/
+"""
+
+import argparse
+import glob
+import os
+import sys
+import time
+
+# Ensure ComfyUI and custom_nodes in sys.path
+COMFY_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+if COMFY_ROOT not in sys.path:
+    sys.path.insert(0, COMFY_ROOT)
+
+import torch
+from PIL import Image
+
+try:
+    import comfy.sd
+    import comfy.utils
+    import comfy.model_management
+except ImportError:
+    print("[Warning] Running outside ComfyUI root; ensure ComfyUI dependencies are installed.")
+
+from core import (
+    CONCEPT_TYPES,
+    TOKEN_BUDGETS,
+    Klein9RefMod,
+    fit_token_budget,
+    save_refmod,
+)
+from common import load_image_file, list_media_files, refmods_klein9_dir
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Extract FLUX.2 / Klein9 RefMod reference adapter from images")
+    parser.add_argument("--vae", type=str, default=None, help="Path to FLUX.2 / Klein VAE .safetensors file")
+    parser.add_argument("--name", type=str, required=True, help="RefMod output name (e.g. fk9_aneta_v1_refmod)")
+    parser.add_argument("--dataset-dir", type=str, default=None, help="Directory containing reference images")
+    parser.add_argument("--images", nargs="+", default=None, help="Explicit list of image paths")
+    parser.add_argument("--concept-type", type=str, default="identity", choices=CONCEPT_TYPES, help="Mod concept type")
+    parser.add_argument("--token-budget", type=str, default="1024", choices=TOKEN_BUDGETS, help="Target token budget per image")
+    parser.add_argument("--resolution", type=int, default=1024, help="Max image edge resolution")
+    parser.add_argument("--max-images", type=int, default=16, help="Max images to encode from dataset")
+    parser.add_argument("--output-dir", type=str, default=None, help="Output folder (defaults to models/refmods-klein9/)")
+    args = parser.parse_args()
+
+    # 1. Collect images
+    image_paths = []
+    if args.images:
+        image_paths.extend(args.images)
+    if args.dataset_dir:
+        image_paths.extend(list_media_files(args.dataset_dir))
+
+    if not image_paths:
+        print(f"[Error] No images found. Provide --dataset-dir or --images.")
+        sys.exit(1)
+
+    image_paths = image_paths[:args.max_images]
+    print(f"Found {len(image_paths)} reference images for RefMod '{args.name}'.")
+
+    # 2. Setup output path
+    out_dir = args.output_dir or refmods_klein9_dir()
+    os.makedirs(out_dir, exist_ok=True)
+    out_path = os.path.join(out_dir, f"{args.name}.safetensors")
+
+    # 3. Load VAE
+    device = comfy.model_management.get_torch_device() if hasattr(comfy, "model_management") else torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    vae_path = args.vae
+
+    if not vae_path:
+        # Search for default Flux2 / Klein VAE in models/vae
+        default_vae_dir = os.path.join(COMFY_ROOT, "models", "vae")
+        candidates = glob.glob(os.path.join(default_vae_dir, "*flux*.safetensors")) + glob.glob(os.path.join(default_vae_dir, "*klein*.safetensors")) + glob.glob(os.path.join(default_vae_dir, "*.safetensors"))
+        if candidates:
+            vae_path = candidates[0]
+            print(f"Auto-selected VAE: {vae_path}")
+        else:
+            print("[Error] No VAE path provided and none found in models/vae/.")
+            sys.exit(1)
+
+    print(f"Loading VAE from {vae_path}...")
+    vae = comfy.sd.VAE(sd=comfy.utils.load_torch_file(vae_path))
+
+    # 4. Load and process images
+    print("Loading and preprocessing images...")
+    loaded_tensors = []
+    for p in image_paths:
+        t = load_image_file(p, max_edge=args.resolution)
+        loaded_tensors.append(t)
+
+    # 5. VAE Encode (One by one to avoid VRAM OOM)
+    print(f"Encoding {len(loaded_tensors)} images through VAE on {device}...")
+    encoded_latents = []
+    for idx, img_t in enumerate(loaded_tensors):
+        with torch.no_grad():
+            encoded = vae.encode(img_t[:, :, :, :3])
+            lat = encoded["samples"] if isinstance(encoded, dict) else encoded
+            # Token Budget Compression per image
+            if args.token_budget != "native":
+                lat = fit_token_budget(lat, args.token_budget, patch_size=2)
+            encoded_latents.append(lat)
+    
+    samples = torch.cat(encoded_latents, dim=0)
+
+    # 7. Construct & Save RefMod
+    mod = Klein9RefMod(
+        name=args.name,
+        samples=samples,
+        concept_type=args.concept_type,
+        mode="pooled" if args.token_budget != "native" else "encode",
+        resolution=args.resolution,
+        token_budget=int(args.token_budget) if args.token_budget != "native" else samples.shape[-2] * samples.shape[-1] // 4,
+        meta={
+            "source_images_count": len(image_paths),
+            "created_at": time.strftime("%Y-%m-%d %H:%M:%S"),
+            "vae_source": os.path.basename(vae_path)
+        }
+    )
+
+    final_path = save_refmod(mod, out_path)
+    file_size_kb = os.path.getsize(final_path) / 1024
+    print(f"\n=======================================================")
+    print(f"FLUX.2 / Klein9 RefMod Extracted Successfully!")
+    print(f"File: {final_path}")
+    print(f"Size: {file_size_kb:.1f} KB")
+    print(f"Latent Shape: {list(mod.samples.shape)}")
+    print(f"Tokens: {mod.token_count} tokens")
+    print(f"Concept Type: {mod.concept_type}")
+    print(f"=======================================================\n")
+
+
+if __name__ == "__main__":
+    main()

klein9/comfyui/custom_nodes/ComfyUI-Flux2Klein9Mod/nodes.py

@@ -0,0 +1,362 @@
+"""
+nodes.py — ComfyUI nodes for FLUX.2 & Klein9 "RefMod" reference adapters
+
+Nodes:
+  Klein9RefModsLoader       — Load 1-8 pre-extracted RefMods from models/refmods-klein9/
+  Klein9RefModApply         — Inject RefMods bundle into standard ComfyUI CONDITIONING
+  Klein9RefModExtract       — In-graph VAE encode & compression -> saved .safetensors in models/refmods-klein9/
+  Klein9RefModFolderLoader  — Batch load reference images from a disk folder
+"""
+
+from __future__ import annotations
+
+import os
+import time
+from typing import Dict, List, Optional, Tuple
+
+import torch
+import torch.nn.functional as F
+
+import folder_paths
+import node_helpers
+from comfy_api.latest import io
+
+from .common import (
+    list_media_files,
+    load_image_file,
+    refmods_klein9_dir,
+)
+from .core import (
+    CONCEPT_TYPES,
+    TOKEN_BUDGETS,
+    Klein9RefMod,
+    _blur_latent,
+    fit_token_budget,
+    load_refmod,
+    read_refmod_meta,
+    save_refmod,
+)
+
+# Register models/refmods-klein9 with ComfyUI's model path system
+try:
+    folder_paths.add_model_folder_path("refmods-klein9", refmods_klein9_dir())
+except Exception:
+    pass
+
+_MOD_CACHE: Dict[str, Klein9RefMod] = {}
+_MOD_CACHE_MAX = 32
+
+
+def _list_klein9_mod_names() -> List[str]:
+    """List all .safetensors mod files available in models/refmods-klein9/."""
+    mods_dir = refmods_klein9_dir()
+    if not os.path.isdir(mods_dir):
+        return ["none"]
+    files = []
+    for fn in sorted(os.listdir(mods_dir)):
+        if fn.lower().endswith(".safetensors"):
+            files.append(os.path.splitext(fn)[0])
+    return ["none"] + files if files else ["none"]
+
+
+def _get_or_load_mod(mod_name: str) -> Optional[Klein9RefMod]:
+    """Retrieve mod from in-memory cache or load from models/refmods-klein9/."""
+    if not mod_name or mod_name == "none":
+        return None
+    if mod_name in _MOD_CACHE:
+        return _MOD_CACHE[mod_name]
+
+    mods_dir = refmods_klein9_dir()
+    path = os.path.join(mods_dir, mod_name + ".safetensors")
+    if not os.path.isfile(path):
+        return None
+
+    mod = load_refmod(path)
+    if len(_MOD_CACHE) >= _MOD_CACHE_MAX:
+        # Simple FIFO eviction
+        oldest_key = next(iter(_MOD_CACHE))
+        _MOD_CACHE.pop(oldest_key, None)
+
+    _MOD_CACHE[mod_name] = mod
+    return mod
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 1. Klein9RefModsLoader
+# ═══════════════════════════════════════════════════════════════════════════
+
+class Klein9RefModsLoader:
+    """Load up to 8 pre-encoded FLUX.2 / Klein9 RefMods with individual strength dials."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        mod_choices = _list_klein9_mod_names()
+        inputs = {
+            "required": {
+                "mod_1": (mod_choices, {"default": mod_choices[0] if mod_choices else "none"}),
+                "strength_1": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 3.0, "step": 0.05}),
+                "copies_1": ("INT", {"default": 1, "min": 1, "max": 8, "step": 1}),
+            },
+            "optional": {}
+        }
+        for i in range(2, 9):
+            inputs["optional"][f"mod_{i}"] = (mod_choices, {"default": "none"})
+            inputs["optional"][f"strength_{i}"] = ("FLOAT", {"default": 1.0, "min": 0.0, "max": 3.0, "step": 0.05})
+            inputs["optional"][f"copies_{i}"] = ("INT", {"default": 1, "min": 1, "max": 8, "step": 1})
+
+        return inputs
+
+    RETURN_TYPES = ("KLEIN9_REFMODS", "STRING")
+    RETURN_NAMES = ("klein9_refmods", "prompt_hint")
+    FUNCTION = "load_mods"
+    CATEGORY = "model/conditioning/klein9"
+
+    def load_mods(self, **kwargs):
+        bundle = []
+        hint_parts = []
+
+        for i in range(1, 9):
+            mod_name = kwargs.get(f"mod_{i}", "none")
+            strength = float(kwargs.get(f"strength_{i}", 1.0))
+            copies = int(kwargs.get(f"copies_{i}", 1))
+
+            if mod_name and mod_name != "none":
+                mod = _get_or_load_mod(mod_name)
+                if mod is not None:
+                    bundle.append((mod, strength, copies))
+                    hint_parts.append(f"[{mod.concept_type}: {mod.name} @ {strength:.2f}x ({mod.token_count} tokens)]")
+
+        prompt_hint = " • ".join(hint_parts) if hint_parts else "No Klein9 RefMods loaded"
+        return (bundle, prompt_hint)
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 2. Klein9RefModApply
+# ════════════════════════════════════��══════════════════════════════════════
+
+class Klein9RefModApply:
+    """Inject pre-encoded Klein9 RefMod reference latents into standard ComfyUI CONDITIONING."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "conditioning": ("CONDITIONING",),
+                "klein9_refmods": ("KLEIN9_REFMODS",),
+                "retention": ([
+                    "fully_preserved (1.0)",
+                    "partially_preserved (0.7)",
+                    "attribute_transfer (0.4)",
+                    "weak_reference (0.2)",
+                    "custom_multiplier",
+                ], {"default": "fully_preserved (1.0)"}),
+                "custom_retention": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 2.0, "step": 0.05}),
+                "ref_method": (["default", "index", "uxo", "index_timestep_zero"], {"default": "default"}),
+                "blend_mode": (["manifold_blur", "direct_scale"], {"default": "manifold_blur"}),
+            }
+        }
+
+    RETURN_TYPES = ("CONDITIONING",)
+    RETURN_NAMES = ("conditioning",)
+    FUNCTION = "apply_mods"
+    CATEGORY = "model/conditioning/klein9"
+
+    def apply_mods(self, conditioning, klein9_refmods, retention, custom_retention=1.0,
+                   ref_method="default", blend_mode="manifold_blur"):
+        if not klein9_refmods:
+            return (conditioning,)
+
+        # Parse master retention factor
+        if "1.0" in retention:
+            master_mult = 1.0
+        elif "0.7" in retention:
+            master_mult = 0.7
+        elif "0.4" in retention:
+            master_mult = 0.4
+        elif "0.2" in retention:
+            master_mult = 0.2
+        else:
+            master_mult = float(custom_retention)
+
+        extracted_latents = []
+
+        for mod, row_strength, copies in klein9_refmods:
+            effective_strength = float(row_strength) * master_mult
+            if effective_strength <= 0.001:
+                continue
+
+            raw_samples = mod.samples.clone() # [B, C, H, W]
+
+            # Apply strength weighting along latent manifold
+            if effective_strength < 0.999:
+                if blend_mode == "manifold_blur":
+                    # Blur factor proportional to weakening
+                    blur_factor = max(2, int(round(8.0 * (1.0 - effective_strength) + 2.0)))
+                    blurred = _blur_latent(raw_samples, factor=blur_factor)
+                    scaled_samples = (effective_strength * raw_samples) + ((1.0 - effective_strength) * blurred)
+                else:
+                    scaled_samples = raw_samples * effective_strength
+            elif effective_strength > 1.001:
+                scaled_samples = raw_samples * effective_strength
+            else:
+                scaled_samples = raw_samples
+
+            # Append samples (unroll batch if multiple images inside one mod)
+            for _ in range(copies):
+                if scaled_samples.dim() == 4:
+                    for b in range(scaled_samples.shape[0]):
+                        extracted_latents.append(scaled_samples[b:b+1])
+                else:
+                    extracted_latents.append(scaled_samples)
+
+        if not extracted_latents:
+            return (conditioning,)
+
+        # Inject into conditioning dictionary
+        cond_values = {"reference_latents": extracted_latents}
+        if ref_method != "default":
+            cond_values["reference_latents_method"] = ref_method
+
+        updated_cond = node_helpers.conditioning_set_values(conditioning, cond_values, append=True)
+        return (updated_cond,)
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 3. Klein9RefModExtract
+# ═══════════════════════════════════════════════════════════════════════════
+
+class Klein9RefModExtract:
+    """Encode reference images with FLUX.2/Klein VAE and save pre-computed RefMod (.safetensors)."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "images": ("IMAGE",),
+                "vae": ("VAE",),
+                "mod_name": ("STRING", {"default": "fk9_character_v1_refmod"}),
+                "concept_type": (list(CONCEPT_TYPES), {"default": "identity"}),
+                "token_budget": (list(TOKEN_BUDGETS), {"default": "1024"}),
+                "mode": (["encode", "pooled"], {"default": "encode"}),
+            },
+            "optional": {
+                "save_to_disk": ("BOOLEAN", {"default": True}),
+                "overwrite": ("BOOLEAN", {"default": True}),
+            }
+        }
+
+    RETURN_TYPES = ("KLEIN9_REFMODS", "LATENT", "STRING")
+    RETURN_NAMES = ("klein9_refmods", "latent", "saved_path")
+    FUNCTION = "extract_mod"
+    CATEGORY = "model/conditioning/klein9"
+
+    def extract_mod(self, images, vae, mod_name, concept_type="identity",
+                    token_budget="1024", mode="encode", save_to_disk=True, overwrite=True):
+        clean_name = mod_name.strip()
+        if not clean_name:
+            clean_name = f"fk9_refmod_{int(time.time())}"
+
+        # 1. VAE Encode
+        # images is [B, H, W, 3] in [0, 1]
+        latent_dict = vae.encode(images[:, :, :, :3])
+        samples = latent_dict["samples"] # [B, C, H, W]
+
+        # 2. Token Budget Compression / Pooling
+        if mode == "pooled" or token_budget != "native":
+            samples = fit_token_budget(samples, token_budget, patch_size=2)
+
+        mod = Klein9RefMod(
+            name=clean_name,
+            samples=samples,
+            concept_type=concept_type,
+            mode=mode,
+            resolution=max(images.shape[1], images.shape[2]),
+            token_budget=int(token_budget) if token_budget != "native" else samples.shape[-2] * samples.shape[-1] // 4,
+            meta={"extracted_with": "Klein9RefModExtract", "source_batch_size": images.shape[0]}
+        )
+
+        saved_path = ""
+        if save_to_disk:
+            out_dir = refmods_klein9_dir()
+            target_path = os.path.join(out_dir, f"{clean_name}.safetensors")
+            if os.path.exists(target_path) and not overwrite:
+                target_path = os.path.join(out_dir, f"{clean_name}_{int(time.time())}.safetensors")
+
+            saved_path = save_refmod(mod, target_path)
+            # Update cache
+            _MOD_CACHE[clean_name] = mod
+            print(f"[Klein9RefModExtract] Successfully saved RefMod to {saved_path} ({mod.token_count} tokens)")
+
+        bundle = [(mod, 1.0, 1)]
+        return (bundle, {"samples": samples}, saved_path)
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 4. Klein9RefModFolderLoader
+# ═══════════════════════════════════════════════════════════════════════════
+
+class Klein9RefModFolderLoader:
+    """Load an entire folder of reference stills as a batch for RefMod extraction."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "folder_path": ("STRING", {"default": "C:/Development/ai-toolkit/datasets/aneta"}),
+                "max_images": ("INT", {"default": 16, "min": 1, "max": 128, "step": 1}),
+                "max_edge": ("INT", {"default": 1024, "min": 256, "max": 2048, "step": 64}),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE", "INT")
+    RETURN_NAMES = ("images", "count")
+    FUNCTION = "load_folder"
+    CATEGORY = "model/conditioning/klein9"
+
+    def load_folder(self, folder_path, max_images=16, max_edge=1024):
+        image_paths = list_media_files(folder_path)
+        if not image_paths:
+            raise ValueError(f"No image files found in folder: {folder_path}")
+
+        image_paths = image_paths[:max_images]
+        loaded_tensors = []
+        for p in image_paths:
+            t = load_image_file(p, max_edge=max_edge)
+            loaded_tensors.append(t)
+
+        # Pad / batch images if dimensions vary
+        max_h = max(t.shape[1] for t in loaded_tensors)
+        max_w = max(t.shape[2] for t in loaded_tensors)
+
+        padded = []
+        for t in loaded_tensors:
+            h, w = t.shape[1], t.shape[2]
+            if h != max_h or w != max_w:
+                pad_h = max_h - h
+                pad_w = max_w - w
+                t_pad = F.pad(t.permute(0, 3, 1, 2), (0, pad_w, 0, pad_h), mode="replicate").permute(0, 2, 3, 1)
+                padded.append(t_pad)
+            else:
+                padded.append(t)
+
+        batch = torch.cat(padded, dim=0)
+        return (batch, len(padded))
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Class & Display Mappings
+# ═══════════════════════════════════════════════════════════════════════════
+
+NODE_CLASS_MAPPINGS = {
+    "Klein9RefModsLoader": Klein9RefModsLoader,
+    "Klein9RefModApply": Klein9RefModApply,
+    "Klein9RefModExtract": Klein9RefModExtract,
+    "Klein9RefModFolderLoader": Klein9RefModFolderLoader,
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "Klein9RefModsLoader": "Load Klein9 RefMods (FLUX.2)",
+    "Klein9RefModApply": "Apply Klein9 RefMods (FLUX.2)",
+    "Klein9RefModExtract": "Extract Klein9 RefMod (FLUX.2)",
+    "Klein9RefModFolderLoader": "Load RefMod Folder (Images)",
+}

klein9/comfyui/custom_nodes/ComfyUI-Flux2Klein9Mod/requirements.txt

@@ -0,0 +1,4 @@
+torch>=2.0.0
+safetensors>=0.4.0
+Pillow>=9.0.0
+numpy