FIBO-Edit 1.5 turbo — evaluation build

README.md

@@ -1,6 +1,6 @@
 ---
 title: klein
-emoji: "🎨"
+emoji: "🧪"
 colorFrom: gray
 colorTo: gray
 sdk: gradio

app.py

@@ -1,14 +1,17 @@
-# FLUX.2 Klein 9B — reference-image editing with runtime LoRA.
+# FIBO-Edit 1.5 turbo — evaluation build.
 #
-# This is the model that answers both open requests at once. Qwen-Image-Edit
-# holds identity but renders glossy; Z-Image looks photographic but its editing
-# pipeline needs siglip weights Tongyi has not released; neither supports LoRA
-# on our stack. Klein is tagged image-to-image, takes one or more reference
-# images, and Flux2KleinPipeline carries load_lora_weights — so one checkpoint
-# covers generation, editing and per-character LoRA.
+# EVALUATION ONLY. The weights are CC BY-NC 4.0 and the gate form states that
+# commercial use needs a separate agreement with Bria. DressFit is a commercial
+# storefront, so nothing here may be pointed at vdf.tecwyze.lk. The purpose is
+# to find out whether that agreement would be worth buying.
 #
-# Started on the 4B because it is Apache-2.0 and ungated. Its output was not
-# convincing enough, so this runs the 9B — see the note at MODEL below.
+# Why it is interesting for garment fitting specifically:
+#   - 8.3B, so it fits a ZeroGPU slot in bf16 with no FP8 and no torchao pin,
+#     which is the chain that made the 20B Qwen build painful.
+#   - Native multi-reference: image= takes a LIST, which is exactly the
+#     person-plus-garment shape DressFit needs.
+#   - Trained on fully licensed data, which is worth something to a retailer
+#     quite apart from output quality.
 #
 # `import spaces` first and stays first — it patches torch.cuda.*, and once CUDA
 # is initialised in the main process it is too late to intercept.
@@ -22,87 +25,55 @@ from io import BytesIO
 import gradio as gr
 import numpy as np
 import torch
-from diffusers import Flux2KleinPipeline
+from diffusers import BriaFiboEditPipeline
 
-# 9B, not the 4B this started on — the 4B's output was not convincing enough.
-# It is gated behind Black Forest Labs' flux-non-commercial-license, so the
-# account running this Space must accept the terms on the model page first, and
-# the Space needs an HF_TOKEN secret to authenticate the download. Without both,
-# the build dies on a 403 fetching model_index.json.
-MODEL = "black-forest-labs/FLUX.2-klein-9B"
+MODEL = "briaai/Fibo-Edit-1.5-turbo"
 
 dtype = torch.bfloat16
-pipe = Flux2KleinPipeline.from_pretrained(MODEL, torch_dtype=dtype)
+pipe = BriaFiboEditPipeline.from_pretrained(MODEL, torch_dtype=dtype)
 
 # Eagerly at module scope: ZeroGPU intercepts this, packs the weights to disk
-# and streams them into VRAM on the first decorated call. Loading lazily inside
-# the decorator makes every caller pay the cost instead of nobody.
+# and streams them in on the first decorated call.
 pipe = pipe.to("cuda")
 
 MAX_SEED = np.iinfo(np.int32).max
-STEPS = 4          # Klein is distilled; the reference Space defaults to 4
-GUIDANCE = 2.5
-
-# Adapters are cached by name and never re-downloaded. Loading a LoRA per
-# request would re-fetch tens of megabytes every call, and the Space process
-# survives between calls, so the cache is free. Adapters also STACK if you do
-# not manage them — set_adapters replaces the active set, and disable_lora
-# turns them all off, which is what an unadorned request needs.
-LOADED = set()
-
-
-def _apply_loras(specs):
-    """specs is a list of {repo, weight_name, scale}. Empty disables all."""
-    if not specs:
-        pipe.disable_lora()
-        return []
-    names, scales = [], []
-    for i, spec in enumerate(specs):
-        repo = spec.get("repo")
-        if not repo:
-            continue
-        weight_name = spec.get("weight_name") or None
-        name = spec.get("adapter_name") or f"a{abs(hash((repo, weight_name))) % 10**8}"
-        if name not in LOADED:
-            pipe.load_lora_weights(repo, weight_name=weight_name, adapter_name=name)
-            LOADED.add(name)
-        names.append(name)
-        scales.append(float(spec.get("scale", 1.0)))
-    if not names:
-        pipe.disable_lora()
-        return []
-    pipe.set_adapters(names, adapter_weights=scales)
-    return names
+
+# The card is explicit: distilled from 30 steps to 4, and CFG 1.0 because no
+# classifier-free guidance is needed. Raising either is wasted quota.
+STEPS = 4
+GUIDANCE = 1.0
+
+# NOTE ON PROMPTS. Bria's example converts prose into a structured "VGL JSON"
+# prompt using a Gemini-backed VLM block, which needs a GEMINI_API_KEY we do not
+# have. This build passes prose straight through instead. If results look weak,
+# that is a candidate explanation and not proof the model is weak — the JSON
+# path is the one Bria tuned for.
 
 
 def _duration(*a, **k):
-    # ZeroGPU bills the duration REQUESTED but ABORTS anything that overruns,
-    # so one flat number either wastes quota on small images or kills big ones.
     w = int(k.get("width") or 1024)
     h = int(k.get("height") or 1024)
-    return min(120, max(30, round((w * h) / 40000)))
+    return min(120, max(30, round((w * h) / 50000)))
 
 
 @spaces.GPU(duration=_duration)
 def infer(image_1, image_2, prompt, seed=0, randomize_seed=True,
           guidance_scale=GUIDANCE, num_inference_steps=STEPS,
-          width=1024, height=1024, loras=None,
+          width=1024, height=1024,
           progress=gr.Progress(track_tqdm=True)):
-    """Edit one or two reference images according to a prompt."""
+    """Edit one or more reference images according to a prompt."""
     if randomize_seed:
         seed = random.randint(0, MAX_SEED)
 
-    _apply_loras(loras or [])
-
     images = [im for im in (image_1, image_2) if im is not None]
     if not images:
         raise gr.Error("At least one reference image is required.")
 
     out = pipe(
+        # A LIST is multi-reference, not a batch — the card is explicit that
+        # several references combine into one result.
         image=images if len(images) > 1 else images[0],
         prompt=prompt,
-        width=int(width),
-        height=int(height),
         num_inference_steps=int(num_inference_steps),
         guidance_scale=float(guidance_scale),
         generator=torch.Generator("cuda").manual_seed(int(seed)),
@@ -113,11 +84,6 @@ def infer(image_1, image_2, prompt, seed=0, randomize_seed=True,
 
 with gr.Blocks(delete_cache=(3600, 86400)) as demo:
     with gr.Column():
-        # No public interface. This is a backend for one application, and a
-        # landing page only attracts traffic that spends the ZeroGPU quota. The
-        # controls below still exist, hidden, because hiding them removes the
-        # interface without removing the event registration that publishes the
-        # API — delete the components and the endpoint goes with them.
         gr.HTML(
             """
             <div style="text-align:center;padding:4rem 1rem;
@@ -126,6 +92,8 @@ with gr.Blocks(delete_cache=(3600, 86400)) as demo:
             </div>
             """
         )
+        # Hidden, but present: removing the components removes the event
+        # registration that publishes the API with them.
         with gr.Row(visible=False):
             image_1 = gr.Image(label="Image 1", type="pil")
             image_2 = gr.Image(label="Image 2", type="pil")
@@ -133,7 +101,7 @@ with gr.Blocks(delete_cache=(3600, 86400)) as demo:
             seed = gr.Slider(label="Seed", minimum=0, maximum=MAX_SEED, step=1, value=0)
             randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
             guidance = gr.Slider(label="Guidance", minimum=0.0, maximum=10.0, step=0.1, value=GUIDANCE)
-            steps = gr.Slider(label="Steps", minimum=1, maximum=50, step=1, value=STEPS)
+            steps = gr.Slider(label="Steps", minimum=1, maximum=40, step=1, value=STEPS)
             run = gr.Button("Edit")
             result = gr.Image(label="Result")
             out_seed = gr.Number(label="Seed used")
@@ -147,7 +115,8 @@ with gr.Blocks(delete_cache=(3600, 86400)) as demo:
 
 
 # ============================================================
-# API
+# API — same positional contract as the other edit Spaces, so the existing
+# client can call this one by changing a URL and nothing else.
 # ============================================================
 def _load(src):
     """Fetch an https URL or decode a data URL into a PIL image."""
@@ -165,32 +134,24 @@ def _load(src):
     return _Image.open(BytesIO(raw)).convert("RGB")
 
 
-# Named dressfit_tryon because the existing client already calls that with this
-# positional order. A tidier name would break every caller for no gain.
 def dressfit_tryon(person: str, garment: str = "", prompt: str = "",
                    steps: float = STEPS, guidance: float = GUIDANCE,
-                   seed: float = 0, randomize: bool = True,
-                   loras: list | None = None) -> dict:
+                   seed: float = 0, randomize: bool = True) -> dict:
     """Edit an image. person is the image to edit, garment is an optional second
-    image, prompt says what to change, loras is an optional list of
-    {repo, weight_name, scale}. Images are https or data URLs."""
+    reference, prompt says what to change. Both are https or data URLs."""
     try:
         first = _load(person)
         second = _load(garment) if garment else None
-        # Match the reference's own aspect. The pipeline draws a fresh canvas at
-        # whatever size it is given, so forcing a square distorts a portrait.
         w, h = first.size
         w = max(256, min(2048, round(w / 32) * 32))
         h = max(256, min(2048, round(h / 32) * 32))
         out, used = infer(first, second, prompt, int(seed), bool(randomize),
-                          float(guidance), int(steps), w, h, loras or [])
+                          float(guidance), int(steps), w, h)
         buf = BytesIO()
         out.save(buf, format="PNG")
         return {"status": "success", "seed": int(used),
                 "image": "data:image/png;base64," + base64.b64encode(buf.getvalue()).decode()}
     except Exception as exc:
-        # Return the traceback to the caller, not only the logs — the client is
-        # the only thing watching and each log round trip costs an attempt.
         return {"status": "error", "message": "".join(traceback.format_exception(exc))[-2500:]}
 
 

requirements.txt

@@ -3,4 +3,3 @@ transformers
 accelerate
 safetensors
 sentencepiece
-peft