Initial Space demo

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+examples/cats.jpg filter=lfs diff=lfs merge=lfs -text
+examples/voice.flac filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,13 +1,19 @@
 ---
-title: Open D1
-emoji: 🏆
-colorFrom: blue
-colorTo: indigo
+title: Open d1
+emoji: ⚖️
+colorFrom: yellow
+colorTo: red
 sdk: gradio
-sdk_version: 6.30.0
-python_version: '3.13'
+sdk_version: "6.30.0"
 app_file: app.py
 pinned: false
+license: other
+short_description: Liquid AI d1 decision models (3B and omni-600M)
+models:
+  - LiquidAI/d1-3B
+  - LiquidAI/d1-omni-600M
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Demo of Liquid AI's open d1 decision models. A state (text, JSON, an image or a voice clip) and a set of
+typed questions (`choice`, `noul` yes/no, `score`) go in; calibrated answers come out of one forward pass,
+with zero generated tokens.

app.py

@@ -0,0 +1,280 @@
+import html
+import json
+import time
+
+import gradio as gr
+import numpy as np
+import spaces
+import torch
+from transformers import AutoModel
+
+D1_3B = "LiquidAI/d1-3B"
+D1_OMNI = "LiquidAI/d1-omni-600M"
+MODELS = {"d1-3B": D1_3B, "d1-omni-600M": D1_OMNI}
+
+# Both models are loaded once at startup and stay resident.
+model_3b = AutoModel.from_pretrained(D1_3B, trust_remote_code=True, dtype=torch.bfloat16).to("cuda")
+engine_3b = model_3b.engine  # builds the tokenizer now rather than on the first request
+engine_3b.device = torch.device("cuda")
+engine_3b.processor = engine_3b._load_processor()
+# fp16 keeps d1-omni's float32 answers; bf16 does not (model card).
+model_omni = AutoModel.from_pretrained(D1_OMNI, trust_remote_code=True, dtype=torch.float16).to("cuda")
+_ = model_omni.tokenizer
+
+TYPES = ["choice", "noul", "score"]
+HEADERS = ["name", "type", "question", "options"]
+
+
+def parse_questions(rows):
+    """Table rows -> {name: Decision Index question}.
+
+    options: choice  `name: description | name: description`
+             score   `lowest level | ... | highest level`
+             noul    optional `yes means ... | no means ...`
+    """
+    if rows is None:
+        rows = []
+    if hasattr(rows, "values"):
+        rows = rows.values.tolist()
+    questions = {}
+    for i, row in enumerate(rows):
+        row = [("" if c is None else str(c)).strip() for c in list(row) + [""] * 4][:4]
+        name, kind, text, opts = row
+        if not (name or text):
+            continue
+        name = name or f"q{i + 1}"
+        kind = kind.lower() or "choice"
+        if kind not in TYPES:
+            raise gr.Error(f"Question '{name}': type must be one of {', '.join(TYPES)}.")
+        if not text:
+            raise gr.Error(f"Question '{name}' has no question text.")
+        parts = [p.strip() for p in opts.split("|") if p.strip()]
+        q = {"type": kind, "instructions": text}
+        if kind == "choice":
+            crit = {}
+            for p in parts:
+                key, _, desc = p.partition(":")
+                crit[key.strip()] = desc.strip() or key.strip()
+            if len(crit) < 2:
+                raise gr.Error(f"Question '{name}': a choice needs at least two options, e.g. `a: ... | b: ...`.")
+            q["criteria"] = crit
+        elif kind == "score":
+            if not 2 <= len(parts) <= 10:
+                raise gr.Error(f"Question '{name}': a score needs 2 to 10 levels, lowest first, split by `|`.")
+            q["criteria"] = parts
+        elif len(parts) == 2:
+            q["criteria"] = {"true": parts[0], "false": parts[1]}
+        if name in questions:
+            raise gr.Error(f"Two questions are named '{name}'.")
+        questions[name] = q
+    if not questions:
+        raise gr.Error("Add at least one question.")
+    return questions
+
+
+def parse_state(text):
+    text = (text or "").strip()
+    if not text:
+        return None
+    if text[0] in "{[":
+        try:
+            return json.loads(text)
+        except json.JSONDecodeError:
+            pass
+    return text
+
+
+def to_16k_mono(audio):
+    sr, data = audio
+    x = np.asarray(data)
+    if x.dtype == np.int16:
+        x = x.astype(np.float32) / 32768.0
+    elif x.dtype == np.int32:
+        x = x.astype(np.float32) / 2147483648.0
+    else:
+        x = x.astype(np.float32)
+    if x.ndim == 2:
+        x = x.mean(axis=1) if x.shape[1] <= 8 else x.mean(axis=0)
+    if sr != 16000:
+        from scipy.signal import resample_poly
+
+        g = np.gcd(int(sr), 16000)
+        x = resample_poly(x, 16000 // g, int(sr) // g).astype(np.float32)
+    return np.clip(x[: 30 * 16000], -1.0, 1.0)
+
+
+@spaces.GPU(duration=20)
+def _decide(model_name, state, questions, image, audio):
+    t0 = time.perf_counter()
+    with torch.inference_mode():
+        if model_name == "d1-3B":
+            out = model_3b.system_one(state, questions, images=[image] if image is not None else None)
+        else:
+            out = model_omni.system_one(state, questions, images=[image] if image is not None else None, audio=audio)
+    torch.cuda.synchronize()
+    return out, time.perf_counter() - t0
+
+
+def render(questions, out, seconds):
+    cards = []
+    for name, ans in out["answers"].items():
+        q = questions[name]
+        if ans["type"] == "noul":
+            p = float(ans["noul"])
+            headline = "yes" if p >= 0.5 else "no"
+            conf = max(p, 1 - p)
+            rows = [("yes", p), ("no", 1 - p)]
+            top = headline
+        elif ans["type"] == "choice":
+            headline = ans["choice"]
+            conf = float(ans["confidence"])
+            rows = list(ans["probabilities"].items())
+            top = headline
+        else:
+            headline = f"{ans['score']:.2f}"
+            conf = float(ans["confidence"])
+            legend = ans["legend"]
+            rows = [(f"{k} · {legend[k]}", v) for k, v in ans["probabilities"].items()]
+            best = max(ans["probabilities"], key=ans["probabilities"].get)
+            top = f"{best} · {legend[best]}"
+        bars = "".join(
+            f'<div class="d1-row{" d1-top" if label == top else ""}">'
+            f'<span class="d1-label">{html.escape(str(label))}</span>'
+            f'<span class="d1-track"><span class="d1-fill" style="width:{100 * float(v):.1f}%"></span></span>'
+            f'<span class="d1-pct">{100 * float(v):.1f}%</span></div>'
+            for label, v in rows
+        )
+        sub = "expected level" if ans["type"] == "score" else f"{100 * conf:.1f}% confident"
+        cards.append(
+            f'<div class="d1-card"><div class="d1-head"><span class="d1-name">{html.escape(name)}</span>'
+            f'<span class="d1-q">{html.escape(q["instructions"])}</span></div>'
+            f'<div class="d1-answer">{html.escape(headline)} <span class="d1-sub">{sub}</span></div>'
+            f"{bars}</div>"
+        )
+    return '<div class="d1-cards">' + "".join(cards) + f'</div><div class="d1-took">took {seconds:.2f} s</div>'
+
+
+def decide(model_name, state_text, image, audio, rows):
+    questions = parse_questions(rows)
+    state = parse_state(state_text)
+    if model_name == "d1-3B":
+        audio = None
+    if image is not None and audio is not None:
+        raise gr.Error("d1-omni takes an image or a voice clip in one request, not both. Clear one of them.")
+    clip = to_16k_mono(audio) if audio is not None else None
+    if state is None and image is None and clip is None:
+        raise gr.Error("Give the model something to look at: a state, an image or a voice clip.")
+    if image is not None:
+        image = image.convert("RGB")
+    t0 = time.perf_counter()
+    out, _ = _decide(model_name, state, questions, image, clip)
+    seconds = time.perf_counter() - t0
+    return render(questions, out, seconds), out
+
+
+def on_model(model_name):
+    omni = model_name == "d1-omni-600M"
+    return gr.update(visible=omni, value=None) if not omni else gr.update(visible=True)
+
+
+SUPPORT_ROUTING = [
+    ["refund", "noul", "Is the customer asking for a refund?", ""],
+    ["team", "choice", "Which team should handle this?",
+     "billing: Charges, refunds, invoices | technical: App or site faults | fraud: Suspected unauthorised use"],
+    ["urgency", "score", "How urgent is this?", "Can wait | Today | Blocking the customer now"],
+]
+CATS = [
+    ["cats", "choice", "How many cats are there?", "one: One | two: Two | more: Three or more"],
+    ["remote", "noul", "Is there a remote control in the picture?", ""],
+    ["mood", "choice", "What are the cats doing?",
+     "sleeping: Lying down, resting or asleep | playing: Playing or fighting | eating: Eating or drinking"],
+]
+VOICE = [
+    ["topic", "choice", "What is the speaker talking about?",
+     "food: Food and meals | travel: Travel and transport | weather: The weather"],
+    ["question", "noul", "Is the speaker asking a question?", ""],
+]
+MODERATION = [
+    ["toxic", "noul", "Is this comment insulting or abusive?", ""],
+    ["action", "choice", "What should a moderator do?",
+     "keep: Leave it up | warn: Leave it, warn the author | remove: Take it down"],
+]
+JUDGE = [
+    ["correct", "noul", "Does the answer correctly answer the question?", ""],
+    ["quality", "score", "Rate the answer's helpfulness.",
+     "Useless | Poor | Okay | Good | Excellent"],
+]
+
+EXAMPLES = [
+    ["d1-3B", "I was charged twice this month, please refund one of them.", None, None, SUPPORT_ROUTING],
+    ["d1-omni-600M", "", "examples/cats.jpg", None, CATS],
+    ["d1-omni-600M", "Voice note from a user.", None, "examples/voice.flac", VOICE],
+    ["d1-3B", "You are honestly the dumbest person on this forum, log off.", None, None, MODERATION],
+    ["d1-3B", '{"question": "What is the boiling point of water at sea level in Fahrenheit?", '
+              '"answer": "Water boils at 212 °F at sea level."}', None, None, JUDGE],
+    ["d1-3B", "", "examples/cats.jpg", None, CATS],
+]
+
+CSS = """
+.d1-cards {display:flex; flex-direction:column; gap:10px;}
+.d1-card {border:1px solid var(--border-color-primary); border-radius:8px; padding:12px 14px;
+  background:var(--block-background-fill);}
+.d1-head {display:flex; gap:10px; align-items:baseline; flex-wrap:wrap; margin-bottom:4px;}
+.d1-name {font-family:var(--font-mono); font-size:12px; color:var(--body-text-color-subdued);}
+.d1-q {font-size:14px; color:var(--body-text-color);}
+.d1-answer {font-size:22px; font-weight:600; margin:2px 0 8px; color:#b4532a;}
+.d1-sub {font-size:13px; font-weight:400; color:var(--body-text-color-subdued); margin-left:6px;}
+.d1-row {display:grid; grid-template-columns:minmax(80px, 38%) 1fr 56px; gap:10px; align-items:center;
+  font-size:13px; padding:2px 0; color:var(--body-text-color-subdued);}
+.d1-row.d1-top {color:var(--body-text-color); font-weight:600;}
+.d1-label {overflow:hidden; text-overflow:ellipsis; white-space:nowrap;}
+.d1-track {height:8px; background:var(--border-color-primary); border-radius:4px; overflow:hidden;}
+.d1-fill {display:block; height:100%; background:#8a8a80;}
+.d1-top .d1-fill {background:#b4532a;}
+.d1-pct {text-align:right; font-variant-numeric:tabular-nums;}
+.d1-took {font-size:12px; color:var(--body-text-color-subdued); margin-top:8px;}
+"""
+
+with gr.Blocks(title="Open d1") as demo:
+    gr.Markdown(
+        "# Open d1\n"
+        "Liquid AI's decision models: give a state and some typed questions, get calibrated answers "
+        "in one forward pass, with no generated text.  \n"
+        f"[d1-3B](https://huggingface.co/{D1_3B}) (text + images) · "
+        f"[d1-omni-600M](https://huggingface.co/{D1_OMNI}) (text + images or voice)"
+    )
+    with gr.Row():
+        with gr.Column(scale=1):
+            model_name = gr.Radio(list(MODELS), value="d1-3B", label="Model")
+            state = gr.Textbox(label="State", lines=4, value="I was charged twice this month, please refund one of them.",
+                               placeholder="Text or JSON the questions are about. Can be empty when an image or clip is the whole state.")
+            with gr.Row():
+                image = gr.Image(label="Image", type="pil", height=220)
+                audio = gr.Audio(label="Voice clip (d1-omni, up to 30 s)", type="numpy",
+                                 sources=["upload", "microphone"], visible=False)
+            questions = gr.Dataframe(
+                headers=HEADERS, datatype=["str", "str", "str", "str"], value=SUPPORT_ROUTING,
+                column_count=(4, "fixed"), row_count=(3, "dynamic"), label="Questions", interactive=True,
+                wrap=True, column_widths=["14%", "12%", "34%", "40%"],
+            )
+            gr.Markdown(
+                "**type** is `choice`, `noul` (yes/no) or `score`. **options**: for a choice "
+                "`name: description | name: description`; for a score the levels, lowest first, split by `|`; "
+                "for a yes/no, optionally `what yes means | what no means`.",
+                elem_classes="d1-help",
+            )
+            run = gr.Button("Decide", variant="primary")
+        with gr.Column(scale=1):
+            result = gr.HTML('<div class="d1-took">Answers appear here.</div>')
+            with gr.Accordion("Raw output", open=False):
+                raw = gr.JSON(label="system_one(...)")
+
+    gr.Examples(EXAMPLES, inputs=[model_name, state, image, audio, questions], label="Examples")
+    gr.Markdown("[Twitter / X](https://x.com/realmrfakename)")
+
+    model_name.change(on_model, model_name, audio)
+    run.click(decide, [model_name, state, image, audio, questions], [result, raw])
+
+
+if __name__ == "__main__":
+    demo.queue().launch(css=CSS)

examples/voice.flac

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:30885601173f96b0d8ddd020dc959b055c6c1582b85a33e3fcab8c4b08ed94c2
+size 183318

requirements.txt

@@ -0,0 +1,6 @@
+transformers>=5.15
+torchvision==0.28.0
+accelerate
+scipy
+soundfile
+pillow