duplexjev 0.1.0__py3-none-any.whl

duplexjev/__init__.py

@@ -0,0 +1,11 @@
+"""DuplexJev: batched typed speech decisions without decoding.
+
+    from duplexjev import Decider, Question
+    d = Decider.from_pretrained("Qwen/Qwen3-0.6B")          # any causal LM (text), or a speech checkpoint
+    d.decide(["I want to turn on the"], [Question("turn", "Has the user finished?", ["finished", "not finished"])])
+"""
+from .decider import Decider, load_audio
+from .question import Question
+
+__all__ = ["Decider", "Question", "load_audio"]
+__version__ = "0.1.0"

duplexjev/cli.py

@@ -0,0 +1,77 @@
+"""Command line: ``duplexjev decide`` for one-off runs, ``duplexjev serve`` for the tick-batched HTTP server."""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+
+from .question import Question
+
+
+def _questions(args) -> list[Question]:
+    qs = []
+    if args.questions:
+        with open(args.questions, encoding="utf-8") as f:
+            qs += [Question.from_dict(q) for q in json.load(f)]
+    for spec in args.q or []:
+        # "id|question text|opt1,opt2,..."
+        qid, text, opts = spec.split("|", 2)
+        qs.append(Question(qid, text, [o.strip() for o in opts.split(",")], lang=args.lang or "en"))
+    if not qs:
+        sys.exit("give --questions FILE.json or at least one --q 'id|text|opt1,opt2'")
+    return qs
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(prog="duplexjev")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+
+    common = argparse.ArgumentParser(add_help=False)
+    common.add_argument("--model", required=True, help="HF id or path: any causal LM, or an Ultravox/DuplexJev speech checkpoint")
+    common.add_argument("--text-model", help="override the LLM a speech checkpoint points to (e.g. a local path)")
+    common.add_argument("--audio-model", help="override the encoder a speech checkpoint points to")
+    common.add_argument("--device")
+
+    d = sub.add_parser("decide", parents=[common], help="answer questions about audio files or transcripts")
+    d.add_argument("--audio", nargs="*", default=[], help="audio files (one item each)")
+    d.add_argument("--text", nargs="*", default=[], help="transcripts (one item each)")
+    d.add_argument("--context")
+    d.add_argument("--questions", help="JSON list of {id, text, options, lang}")
+    d.add_argument("--q", action="append", help="inline question: 'id|text|opt1,opt2,...' (repeatable)")
+    d.add_argument("--lang", choices=["en", "zh"])
+    d.add_argument("--mode", default="packed", choices=["packed", "batch"])
+    d.add_argument("--n-perm", type=int, default=1)
+
+    s = sub.add_parser("serve", parents=[common], help="HTTP server; batches all requests of each tick")
+    s.add_argument("--host", default="0.0.0.0")
+    s.add_argument("--port", type=int, default=8000)
+    s.add_argument("--tick-ms", type=float, default=160.0)
+    s.add_argument("--max-items", type=int, help="max items per forward pass")
+
+    args = ap.parse_args(argv)
+    from .decider import Decider
+
+    dec = Decider.from_pretrained(args.model, device=args.device, text_model=args.text_model, audio_model=args.audio_model)
+    if args.cmd == "decide":
+        items = [{"audio": a} for a in args.audio] + [{"text": t} for t in args.text]
+        if not items:
+            sys.exit("give --audio and/or --text")
+        for it in items:
+            if args.context:
+                it["context"] = args.context
+            if args.lang:
+                it["lang"] = args.lang
+        res = dec.decide(items, _questions(args), mode=args.mode, n_perm=args.n_perm)
+        names = args.audio + args.text
+        print(json.dumps({"results": [{"input": n, "answers": r} for n, r in zip(names, res)], "pass": dec.last_stats},
+                         ensure_ascii=False, indent=1))
+    else:
+        import uvicorn
+
+        from .server import create_app
+
+        uvicorn.run(create_app(dec, tick_ms=args.tick_ms, max_items=args.max_items), host=args.host, port=args.port)
+
+
+if __name__ == "__main__":
+    main()

duplexjev/decider.py

@@ -0,0 +1,439 @@
+"""Batched typed decisions from one forward pass, with exact prefix sharing.
+
+Two layouts give the same answers (up to floating-point noise):
+
+* ``mode="packed"`` (default): for every item, the shared prefix (chat template, context, audio) is encoded once and
+  all of that item's question suffixes are packed into one row under a block-diagonal mask, with position ids
+  restarting at the prefix length. All items of a call are processed together: one prefill for the prefixes, one
+  forward for all suffixes. KV memory grows with ``P + sum(L_i)`` per item instead of ``N * (P + L)``.
+* ``mode="batch"``: every (item, question) pair is its own row. Simpler, slower; kept as a reference.
+
+The answer to a question is the next-token softmax restricted to its option letters at the last prompt position.
+No tokens are generated.
+"""
+from __future__ import annotations
+
+import time
+from typing import Any, Iterable, Sequence
+
+import numpy as np
+import torch
+
+from .question import Question, as_questions
+
+SAMPLE_RATE = 16000
+_SENTINEL = "⁣QUESTION⁣"
+
+PROMPTS = {
+    "en": {"context": "Context:\n{c}", "transcript": "The user said: {t}", "audio": "The user said: <|audio|>"},
+    "zh": {"context": "上下文：\n{c}", "transcript": "用户说：{t}", "audio": "用户说：<|audio|>"},
+}
+
+
+# ---------------------------------------------------------------------------------------------------------- inputs
+def load_audio(x: Any) -> np.ndarray:
+    """Accept a 16 kHz float array, a (array, sample_rate) tuple or a file path; return 16 kHz mono float32."""
+    sr = SAMPLE_RATE
+    if isinstance(x, (str, bytes)) or hasattr(x, "__fspath__"):
+        import soundfile as sf
+
+        x, sr = sf.read(x, dtype="float32")
+    elif isinstance(x, tuple):
+        x, sr = x
+    a = np.asarray(x, dtype=np.float32)
+    if a.ndim > 1:
+        a = a.mean(axis=1) if a.shape[1] <= 8 else a.mean(axis=0)
+    if sr != SAMPLE_RATE:  # polyphase resampling: fast and without a one-off JIT warm-up
+        from math import gcd
+
+        from scipy.signal import resample_poly
+
+        g = gcd(int(sr), SAMPLE_RATE)
+        a = resample_poly(a, SAMPLE_RATE // g, int(sr) // g).astype(np.float32)
+    return a
+
+
+def as_item(x: Any) -> dict:
+    """An item is a dict with any of: ``audio``, ``text`` (transcript), ``context``, ``questions``, ``lang``."""
+    if isinstance(x, dict):
+        return x
+    if isinstance(x, str):
+        return {"text": x}
+    return {"audio": x}
+
+
+# ---------------------------------------------------------------------------------------------------------- engine
+class Decider:
+    """Answer typed closed-set questions about speech (or text) with zero decode steps.
+
+    Create with :meth:`from_pretrained`. The same object serves text-only LLMs (inputs are transcripts) and
+    Ultravox-format speech checkpoints, including the DuplexJev adapters.
+    """
+
+    def __init__(self, model, tokenizer, processor=None, *, device=None, is_audio: bool = False):
+        self.model = model.eval()
+        self.tok = tokenizer
+        self.processor = processor
+        self.is_audio = is_audio
+        if device is None or str(device) == "auto":  # sharded model: inputs go where the embeddings live
+            device = model.get_input_embeddings().weight.device if not is_audio else model.language_model.get_input_embeddings().weight.device
+        self.device = torch.device(device)
+        self.lm = model.language_model if is_audio else model
+        self.base = getattr(self.lm, self.lm.base_model_prefix)
+        self.head = self.lm.get_output_embeddings()
+        self.pad_id = tokenizer.pad_token_id if tokenizer.pad_token_id is not None else tokenizer.eos_token_id
+        self._letter_ids: dict[str, int] = {}
+        self._tail_cache: dict[tuple, tuple[str, str]] = {}
+        self.last_stats: dict = {}
+
+    # ------------------------------------------------------------------ loading
+    @classmethod
+    def from_pretrained(
+        cls,
+        name_or_path: str,
+        *,
+        device: str | None = None,
+        dtype: torch.dtype | None = None,
+        text_model: str | None = None,
+        audio_model: str | None = None,
+        **kwargs,
+    ) -> "Decider":
+        """Load a text LLM (any causal LM on the Hugging Face hub) or an Ultravox-format speech checkpoint.
+
+        ``device="auto"`` shards the model over all visible GPUs (needs ``accelerate``).
+        ``text_model`` / ``audio_model`` override the LLM and encoder a speech checkpoint points to (e.g. a local
+        copy of Qwen3-32B). Remaining kwargs go to ``from_pretrained`` of the model.
+        """
+        import transformers
+
+        dkw = "dtype" if tuple(int(x) for x in transformers.__version__.split(".")[:2]) >= (4, 56) else "torch_dtype"
+        if device is None:
+            device = "cuda" if torch.cuda.is_available() else "cpu"
+        if dtype is None:
+            dtype = torch.bfloat16 if str(device).startswith("cuda") or device == "auto" else torch.float32
+        dmap = "auto" if device == "auto" else {"": device}
+        cfg = transformers.AutoConfig.from_pretrained(name_or_path, trust_remote_code=True)
+        if getattr(cfg, "model_type", "") == "ultravox":
+            if dkw == "dtype":
+                import warnings
+
+                warnings.warn(
+                    "Ultravox-format checkpoints ship remote code written for transformers 4.51-4.55; with "
+                    f"transformers {transformers.__version__} loading can be extremely slow (weights built on CPU). "
+                    'Install with `pip install "duplexjev[speech]"` to get a compatible version.'
+                )
+            if text_model:
+                cfg.text_model_id = text_model
+            if audio_model:
+                cfg.audio_model_id = audio_model
+            model = transformers.AutoModel.from_pretrained(
+                name_or_path, config=cfg, trust_remote_code=True, device_map=dmap, **{dkw: dtype}, **kwargs
+            )
+            processor = transformers.AutoProcessor.from_pretrained(name_or_path, trust_remote_code=True)
+            if not hasattr(processor, "audio_processor"):  # e.g. a stray preprocessor_config.json took precedence
+                from transformers.dynamic_module_utils import get_class_from_dynamic_module
+
+                cls_ = get_class_from_dynamic_module(cfg.auto_map["AutoProcessor"], name_or_path)
+                processor = cls_.from_pretrained(name_or_path)
+            ap = processor.audio_processor
+            if isinstance(ap, transformers.WhisperFeatureExtractor) and not hasattr(ap, "feature_extractor"):
+                processor.audio_processor = transformers.WhisperProcessor(
+                    feature_extractor=ap, tokenizer=processor.tokenizer
+                )
+            return cls(model, processor.tokenizer, processor, device=None if device == "auto" else device, is_audio=True)
+        tok = transformers.AutoTokenizer.from_pretrained(name_or_path, **{k: v for k, v in kwargs.items() if k == "revision"})
+        if device == "auto":
+            model = transformers.AutoModelForCausalLM.from_pretrained(name_or_path, device_map="auto", **{dkw: dtype}, **kwargs)
+        else:
+            model = transformers.AutoModelForCausalLM.from_pretrained(name_or_path, **{dkw: dtype}, **kwargs).to(device)
+        return cls(model, tok, device=None if device == "auto" else device, is_audio=False)
+
+    # ------------------------------------------------------------------ prompt pieces
+    def _head_tail(self, context: str | None, content: str, lang: str) -> tuple[str, str]:
+        """Split the chat-formatted prompt into the shared head (up to the question) and the fixed tail."""
+        key = (context, content, lang)
+        if key in self._tail_cache:
+            return self._tail_cache[key]
+        parts = []
+        if context:
+            parts.append(PROMPTS[lang]["context"].format(c=context))
+        parts.append(content)
+        parts.append(_SENTINEL)
+        user = "\n\n".join(parts)
+        if getattr(self.tok, "chat_template", None):
+            full = self.tok.apply_chat_template(
+                [{"role": "user", "content": user}], add_generation_prompt=True, tokenize=False, enable_thinking=False
+            )
+        else:
+            full = user + "\n\nAnswer: "
+        head, tail = full.split(_SENTINEL)
+        if len(self._tail_cache) < 4096:
+            self._tail_cache[key] = (head, tail)
+        return head, tail
+
+    def _letter_id(self, letter: str) -> int:
+        if letter not in self._letter_ids:
+            ids = self.tok.encode(letter, add_special_tokens=False)
+            if len(ids) != 1:
+                raise RuntimeError(f"option letter {letter!r} is not a single token for this tokenizer: {ids}")
+            self._letter_ids[letter] = ids[0]
+        return self._letter_ids[letter]
+
+    def _align(self, a: np.ndarray) -> np.ndarray:
+        """Left-pad with silence to a whole number of audio tokens.
+
+        The projector stacks ``stack_factor`` encoder frames per LLM token. If the last group is partial, it is filled
+        with whatever follows in the padded batch tensor, so the same clip would read differently depending on its
+        batch neighbours. Aligning every clip to full groups (160 ms for Whisper and Qwen3-ASR encoders at stack 8
+        and 2) makes every answer independent of batch composition.
+        """
+        hop = 160 * int(getattr(self.processor, "encoder_ds_factor", 2)) * int(getattr(self.processor, "stack_factor", 8))
+        r = (-len(a)) % hop
+        return np.concatenate([np.zeros(r, dtype=np.float32), a]) if r else a
+
+    def _encode_prefix(self, item: dict, lang: str) -> dict:
+        audio = item.get("audio")
+        text = item.get("text")
+        if audio is not None and not self.is_audio:
+            raise ValueError("this model is text-only; pass `text` (a transcript) instead of `audio`")
+        if audio is not None:
+            content = PROMPTS[lang]["audio"]
+            if text:
+                content = PROMPTS[lang]["transcript"].format(t=text) + "\n" + content
+        elif text is not None:
+            content = PROMPTS[lang]["transcript"].format(t=text)
+        else:
+            raise ValueError("each item needs `audio` or `text`")
+        head, tail = self._head_tail(item.get("context"), content, lang)
+        if audio is not None:
+            p = self.processor(text=head, audio=self._align(load_audio(audio)), sampling_rate=SAMPLE_RATE, return_tensors="pt")
+            ids = p["input_ids"][0].tolist()
+            aud = {k: p[k] for k in ("audio_values", "audio_lens", "audio_token_len", "audio_token_start_idx", "audio_batch_size") if k in p}
+            if "audio_batch_size" not in aud:
+                aud["audio_batch_size"] = torch.tensor([p["audio_values"].shape[0]])
+        else:
+            ids = self.tok(head, add_special_tokens=False)["input_ids"]
+            aud = None
+        return {"ids": ids, "audio": aud, "tail": tail}
+
+    def _suffixes(self, qs: list[Question], tail: str, n_perm: int, seed: int):
+        """Token ids of every (question, permutation) suffix, with the letter ids to read."""
+        out = []
+        for qi, q in enumerate(qs):
+            for k in range(n_perm):
+                perm = q.permutation(seed + k)
+                ids = self.tok(q.render(perm) + tail, add_special_tokens=False)["input_ids"]
+                letters = [self._letter_id(c) for c in q.letters()]
+                out.append({"q": qi, "perm": perm, "ids": ids, "letters": letters})
+        return out
+
+    # ------------------------------------------------------------------ collation
+    def _collate(self, rows: list[tuple[list[int], dict | None]]) -> dict:
+        """Left-pad token rows; stack audio (right-padded) and shift audio start indices by the left padding."""
+        L = max(len(r[0]) for r in rows)
+        ids = torch.full((len(rows), L), self.pad_id, dtype=torch.long)
+        mask = torch.zeros((len(rows), L), dtype=torch.long)
+        for i, (r, _) in enumerate(rows):
+            ids[i, L - len(r):] = torch.tensor(r)
+            mask[i, L - len(r):] = 1
+        batch = {"input_ids": ids, "attention_mask": mask}
+        if any(a is not None for _, a in rows):
+            vals, lens, tlen, start, bs = [], [], [], [], []
+            for r, a in rows:
+                if a is None:
+                    raise ValueError("cannot mix items with and without audio in one call")
+                shift = L - len(r)
+                vals += list(a["audio_values"])
+                lens.append(a["audio_lens"])
+                tlen.append(a["audio_token_len"])
+                start.append(a["audio_token_start_idx"] + shift)
+                bs.append(a["audio_batch_size"].view(-1))
+            T = max(v.shape[-1] for v in vals)
+            batch["audio_values"] = torch.stack([torch.nn.functional.pad(v, (0, T - v.shape[-1])) for v in vals])
+            batch["audio_lens"] = torch.cat(lens)
+            batch["audio_token_len"] = torch.cat(tlen)
+            batch["audio_token_start_idx"] = torch.cat(start)
+            batch["audio_batch_size"] = torch.cat(bs)
+        out = {k: v.to(self.device) for k, v in batch.items()}
+        if "audio_values" in out:
+            out["audio_values"] = out["audio_values"].to(self.model.dtype)
+        return out
+
+    def _letter_logits(self, h: torch.Tensor, letters: Sequence[int]) -> torch.Tensor:
+        """Logits of the option letters only, from final hidden states ``h`` [..., d]."""
+        W = self.head.weight[list(letters)]
+        z = h.to(W.dtype) @ W.T
+        if getattr(self.head, "bias", None) is not None:
+            z = z + self.head.bias[list(letters)]
+        return z.float()
+
+    # ------------------------------------------------------------------ public API
+    @torch.no_grad()
+    def decide(
+        self,
+        items: Iterable[Any],
+        questions: Sequence[Question | dict] | None = None,
+        *,
+        mode: str = "packed",
+        n_perm: int = 1,
+        seed: int = 0,
+        lang: str | None = None,
+        max_items: int | None = None,
+        max_tokens: int | None = None,
+    ) -> list[dict]:
+        """Answer every question about every item in one batched pass.
+
+        Args:
+            items: audio arrays / file paths, transcript strings, or dicts with ``audio`` and/or ``text``, optional
+                ``context`` and optional per-item ``questions``.
+            questions: questions asked of every item (unless an item brings its own).
+            mode: ``"packed"`` (prefix sharing, default) or ``"batch"`` (one row per question; reference).
+            n_perm: average over this many option orders (reduces position bias; costs more suffix tokens).
+            seed: selects the option orders.
+            lang: language of the fixed prompt words; defaults to each item's ``lang`` or the first question's.
+            max_items: split into forward passes of at most this many items.
+            max_tokens: split so that each pass holds at most this many prompt tokens (prefixes + all suffixes).
+                Bounds activation memory; an item larger than the budget still runs, alone.
+
+        Returns:
+            one dict per item: ``{question_id: {"answer": option, "confidence": p, "probs": {option: p}}}``.
+        """
+        items = [as_item(x) for x in items]
+        if not items:
+            return []
+        t0 = time.perf_counter()
+        plans = []
+        for it in items:
+            qs = as_questions(it.get("questions") or questions or [])
+            if not qs:
+                raise ValueError("no questions given")
+            lg = lang or it.get("lang") or qs[0].lang
+            pre = self._encode_prefix(it, lg)
+            plans.append({"qs": qs, "pre": pre, "sufs": self._suffixes(qs, pre["tail"], n_perm, seed)})
+        t_enc = time.perf_counter()
+        if mode not in ("packed", "batch"):
+            raise ValueError("mode must be 'packed' or 'batch'")
+        run = self._run_packed if mode == "packed" else self._run_batch
+        n_pass = 0
+        for with_audio in (True, False):  # speech and text-only items go in separate passes
+            group = [p for p in plans if (p["pre"]["audio"] is not None) == with_audio]
+            for chunk in _chunks(group, max_items, max_tokens, packed=mode == "packed"):
+                run(chunk)
+                n_pass += 1
+        if self.device.type == "cuda":
+            torch.cuda.synchronize(self.device)
+        t_fwd = time.perf_counter()
+        results = [self._collect(p) for p in plans]
+        self.last_stats = {
+            "mode": mode,
+            "items": len(items),
+            "questions": sum(len(p["qs"]) for p in plans),
+            "prefix_tokens": sum(len(p["pre"]["ids"]) for p in plans),
+            "suffix_tokens": sum(len(s["ids"]) for p in plans for s in p["sufs"]),
+            "prepare_ms": round((t_enc - t0) * 1000, 2),
+            "forward_ms": round((t_fwd - t_enc) * 1000, 2),
+            "batches": n_pass,
+            "decode_steps": 0,
+        }
+        return results
+
+    def _run_batch(self, plans):
+        rows, where = [], []
+        for pi, p in enumerate(plans):
+            for si, s in enumerate(p["sufs"]):
+                rows.append((p["pre"]["ids"] + s["ids"], p["pre"]["audio"]))
+                where.append((pi, si))
+        batch = self._collate(rows)
+        if self.is_audio:  # Ultravox merges audio inside its own forward; read last-position logits
+            last = self.model(**batch, use_cache=False, logits_to_keep=1).logits[:, -1].float()
+            for r, (pi, si) in enumerate(where):
+                s = plans[pi]["sufs"][si]
+                s["z"] = last[r, torch.tensor(s["letters"], device=last.device)]
+            return
+        h = self.base(input_ids=batch["input_ids"], attention_mask=batch["attention_mask"], use_cache=False)
+        h = h.last_hidden_state[:, -1]
+        for r, (pi, si) in enumerate(where):
+            s = plans[pi]["sufs"][si]
+            s["z"] = self._letter_logits(h[r], s["letters"])
+
+    def _run_packed(self, plans):
+        # 1) prefill all prefixes together (left-padded); keep the KV cache
+        batch = self._collate([(p["pre"]["ids"], p["pre"]["audio"]) for p in plans])
+        P = batch["input_ids"].shape[1]
+        if self.is_audio:
+            out = self.model(**batch, use_cache=True, logits_to_keep=1)
+        else:
+            out = self.base(input_ids=batch["input_ids"], attention_mask=batch["attention_mask"], use_cache=True)
+        cache = out.past_key_values
+        # 2) all suffixes of an item in one row; block-diagonal causal mask over the suffix part
+        B = len(plans)
+        lens = [[len(s["ids"]) for s in p["sufs"]] for p in plans]
+        T = max(sum(l) for l in lens)
+        dt = self.model.dtype
+        neg = torch.finfo(dt).min
+        ids = torch.full((B, T), self.pad_id, dtype=torch.long)
+        pos = torch.full((B, T), P, dtype=torch.long)
+        mask = torch.full((B, 1, T, P + T), neg, dtype=dt)
+        mask[:, 0, :, :P] = torch.where(batch["attention_mask"].cpu()[:, None, :].bool(), 0.0, neg).to(dt)
+        last = []
+        for b, p in enumerate(plans):
+            o, lb = 0, []
+            for s in p["sufs"]:
+                n = len(s["ids"])
+                ids[b, o:o + n] = torch.tensor(s["ids"])
+                pos[b, o:o + n] = P + torch.arange(n)
+                mask[b, 0, o:o + n, P + o:P + o + n] = torch.triu(torch.full((n, n), neg, dtype=dt), 1)
+                lb.append(o + n - 1)
+                o += n
+            for t in range(o, T):  # padding rows: attend to themselves only (never read)
+                mask[b, 0, t, P + t] = 0
+            last.append(lb)
+        out2 = self.base(
+            input_ids=ids.to(self.device),
+            attention_mask=mask.to(self.device),
+            position_ids=pos.to(self.device),
+            past_key_values=cache,
+            use_cache=False,
+        )
+        h = out2.last_hidden_state
+        for b, p in enumerate(plans):
+            hb = h[b, torch.tensor(last[b], device=h.device)]
+            for s, hv in zip(p["sufs"], hb):
+                s["z"] = self._letter_logits(hv, s["letters"])
+
+    def _collect(self, plan) -> dict:
+        res = {}
+        for qi, q in enumerate(plan["qs"]):
+            acc = np.zeros(len(q.options))
+            sufs = [s for s in plan["sufs"] if s["q"] == qi]
+            for s in sufs:
+                z = s["z"]
+                p = torch.softmax(z.float(), -1).cpu().numpy()
+                for i, j in enumerate(s["perm"]):
+                    acc[j] += p[i]
+            acc /= len(sufs)
+            k = int(acc.argmax())
+            res[q.id] = {
+                "answer": q.options[k],
+                "confidence": round(float(acc[k]), 6),
+                "probs": {o: round(float(v), 6) for o, v in zip(q.options, acc)},
+            }
+        return res
+
+
+def _chunks(plans, max_items, max_tokens, packed=True):
+    """Split plans into passes bounded by item count and by prompt tokens."""
+    def cost(p):
+        pre, suf = len(p["pre"]["ids"]), [len(s["ids"]) for s in p["sufs"]]
+        return pre + sum(suf) if packed else len(suf) * pre + sum(suf)
+
+    cur, tok = [], 0
+    for p in plans:
+        c = cost(p)
+        if cur and ((max_items and len(cur) >= max_items) or (max_tokens and tok + c > max_tokens)):
+            yield cur
+            cur, tok = [], 0
+        cur.append(p)
+        tok += c
+    if cur:
+        yield cur

duplexjev/question.py

@@ -0,0 +1,95 @@
+"""Typed closed-set questions and how they are rendered into a prompt suffix."""
+from __future__ import annotations
+
+import hashlib
+import random
+from dataclasses import dataclass, field
+from typing import Sequence
+
+LETTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+
+TEMPLATES = {
+    "en": {
+        "question": "Question: {q}",
+        "options": "Options:",
+        "instruction": "Answer with only the letter of the correct option.",
+    },
+    "zh": {
+        "question": "问题：{q}",
+        "options": "选项：",
+        "instruction": "请只回答正确选项的字母。",
+    },
+}
+
+
+@dataclass(frozen=True)
+class Question:
+    """One runtime-declared decision.
+
+    Args:
+        id: key used in the result (e.g. ``"turn"``).
+        text: the question as the model should read it.
+        options: 2–26 answer options; the result is a probability for each.
+        lang: prompt language for the fixed words (``"en"`` or ``"zh"``).
+    """
+
+    id: str
+    text: str
+    options: Sequence[str]
+    lang: str = "en"
+    _options: tuple = field(init=False, repr=False, compare=False)
+
+    def __post_init__(self):
+        opts = tuple(str(o) for o in self.options)
+        if not self.id:
+            raise ValueError("Question.id must be non-empty")
+        if not self.text:
+            raise ValueError(f"Question {self.id!r}: text must be non-empty")
+        if not 2 <= len(opts) <= len(LETTERS):
+            raise ValueError(f"Question {self.id!r}: needs 2..{len(LETTERS)} options, got {len(opts)}")
+        if len(set(opts)) != len(opts):
+            raise ValueError(f"Question {self.id!r}: options must be distinct")
+        if self.lang not in TEMPLATES:
+            raise ValueError(f"Question {self.id!r}: lang must be one of {sorted(TEMPLATES)}")
+        object.__setattr__(self, "_options", opts)
+        object.__setattr__(self, "options", opts)
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "Question":
+        return cls(id=d["id"], text=d["text"], options=d["options"], lang=d.get("lang", "en"))
+
+    def to_dict(self) -> dict:
+        return {"id": self.id, "text": self.text, "options": list(self.options), "lang": self.lang}
+
+    # ------------------------------------------------------------------ rendering
+    def permutation(self, seed: int = 0) -> list[int]:
+        """Deterministic option order for this question: letter i shows option perm[i].
+
+        Options are shown under permuted letters so that no option is tied to a fixed position. The order depends
+        only on (question id, options, seed), so results are reproducible and identical across batch layouts.
+        """
+        key = "\x1f".join([self.id, "\x1e".join(self.options), str(seed)]).encode()
+        rng = random.Random(int.from_bytes(hashlib.blake2b(key, digest_size=8).digest(), "big"))
+        perm = list(range(len(self.options)))
+        rng.shuffle(perm)
+        return perm
+
+    def render(self, perm: Sequence[int]) -> str:
+        t = TEMPLATES[self.lang]
+        lines = [t["question"].format(q=self.text), "", t["options"]]
+        lines += [f"{LETTERS[i]}. {self.options[j]}" for i, j in enumerate(perm)]
+        lines += ["", t["instruction"]]
+        return "\n".join(lines)
+
+    def letters(self) -> str:
+        return LETTERS[: len(self.options)]
+
+
+def as_questions(qs) -> list[Question]:
+    out = []
+    for q in qs:
+        out.append(q if isinstance(q, Question) else Question.from_dict(q))
+    ids = [q.id for q in out]
+    if len(set(ids)) != len(ids):
+        raise ValueError(f"duplicate question ids: {ids}")
+    return out

duplexjev/server.py

@@ -0,0 +1,131 @@
+"""HTTP server that batches every request arriving within one tick into a single decision pass.
+
+    duplexjev serve --model Qwen/Qwen3-8B --tick-ms 160
+
+Clients POST to ``/v1/decide``; the server collects all pending requests every ``tick_ms`` milliseconds (e.g. the
+latest audio window of every live call), answers all of their questions in one batched pass, and returns each
+request's own answers. Latency per request is at most one tick of waiting plus one pass.
+"""
+from __future__ import annotations
+
+import asyncio
+import base64
+import io
+import time
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any, List, Optional
+
+from .decider import Decider
+
+
+def _decode_audio(b64: str):
+    import soundfile as sf
+
+    a, sr = sf.read(io.BytesIO(base64.b64decode(b64)), dtype="float32")
+    return (a, sr)
+
+
+class TickBatcher:
+    """Collect requests and run them together once per tick on a single worker thread."""
+
+    def __init__(self, decider: Decider, tick_ms: float = 160.0, max_items: Optional[int] = None, mode: str = "packed"):
+        self.d = decider
+        self.tick = tick_ms / 1000.0
+        self.max_items = max_items
+        self.mode = mode
+        self.pending: list[tuple[dict, asyncio.Future, float]] = []
+        self.pool = ThreadPoolExecutor(max_workers=1)
+        self.ticks = 0
+        self._task: Optional[asyncio.Task] = None
+
+    def start(self):
+        self._task = asyncio.get_running_loop().create_task(self._loop())
+
+    async def submit(self, item: dict) -> dict:
+        fut = asyncio.get_running_loop().create_future()
+        self.pending.append((item, fut, time.perf_counter()))
+        return await fut
+
+    async def _loop(self):
+        loop = asyncio.get_running_loop()
+        nxt = loop.time()
+        while True:
+            nxt += self.tick
+            await asyncio.sleep(max(0.0, nxt - loop.time()))
+            if not self.pending:
+                continue
+            batch, self.pending = self.pending, []
+            self.ticks += 1
+            tick_id, t0 = self.ticks, time.perf_counter()
+            try:
+                res = await loop.run_in_executor(
+                    self.pool, lambda: self.d.decide([b[0] for b in batch], mode=self.mode, max_items=self.max_items)
+                )
+                stats = dict(self.d.last_stats)
+                for (item, fut, t_in), r in zip(batch, res):
+                    if not fut.done():
+                        fut.set_result({
+                            "answers": r,
+                            "tick": tick_id,
+                            "batch_items": len(batch),
+                            "wait_ms": round((t0 - t_in) * 1000, 1),
+                            "pass_ms": round((time.perf_counter() - t0) * 1000, 1),
+                            "pass": stats,
+                        })
+            except Exception as e:  # report the error to every request of this tick
+                for _, fut, _ in batch:
+                    if not fut.done():
+                        fut.set_exception(e)
+            if loop.time() > nxt:  # a long pass: start the next tick now instead of catching up
+                nxt = loop.time()
+
+
+def create_app(decider: Decider, tick_ms: float = 160.0, max_items: Optional[int] = None):
+    from fastapi import FastAPI, HTTPException
+    from pydantic import BaseModel
+
+    class QuestionIn(BaseModel):
+        id: str
+        text: str
+        options: List[str]
+        lang: str = "en"
+
+    class DecideIn(BaseModel):
+        questions: List[QuestionIn]
+        audio_b64: Optional[str] = None  # WAV/FLAC bytes, base64
+        text: Optional[str] = None       # transcript (text-only models, or extra context for speech models)
+        context: Optional[str] = None
+        lang: Optional[str] = None
+
+    app = FastAPI(title="DuplexJev decider", version="0.1.0")
+    batcher = TickBatcher(decider, tick_ms=tick_ms, max_items=max_items)
+
+    @app.on_event("startup")
+    async def _start():
+        batcher.start()
+
+    @app.get("/health")
+    async def health() -> dict[str, Any]:
+        return {"ok": True, "speech": decider.is_audio, "tick_ms": tick_ms, "ticks": batcher.ticks}
+
+    @app.post("/v1/decide")
+    async def decide(req: DecideIn) -> dict[str, Any]:
+        item: dict[str, Any] = {"questions": [q.model_dump() for q in req.questions]}
+        if req.audio_b64:
+            if not decider.is_audio:
+                raise HTTPException(400, "this server runs a text-only model; send `text`")
+            item["audio"] = _decode_audio(req.audio_b64)
+        if req.text is not None:
+            item["text"] = req.text
+        if "audio" not in item and "text" not in item:
+            raise HTTPException(400, "send `audio_b64` or `text`")
+        if req.context:
+            item["context"] = req.context
+        if req.lang:
+            item["lang"] = req.lang
+        try:
+            return await batcher.submit(item)
+        except ValueError as e:
+            raise HTTPException(400, str(e))
+
+    return app

duplexjev-0.1.0.dist-info/METADATA

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: duplexjev
+Version: 0.1.0
+Summary: Batched typed speech decisions without decoding: one forward pass answers many closed-set questions about many calls.
+Author: Adventists.ai
+License: Apache-2.0
+Project-URL: Homepage, https://adventists-ai.github.io/duplexjev/
+Project-URL: Repository, https://github.com/adventists-ai/duplexjev
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: torch>=2.1
+Requires-Dist: transformers<4.58,>=4.51
+Requires-Dist: numpy
+Requires-Dist: soundfile
+Requires-Dist: scipy
+Provides-Extra: speech
+Requires-Dist: accelerate; extra == "speech"
+Requires-Dist: peft; extra == "speech"
+Requires-Dist: transformers<4.56,>=4.51; extra == "speech"
+Provides-Extra: server
+Requires-Dist: fastapi; extra == "server"
+Requires-Dist: uvicorn; extra == "server"
+Requires-Dist: pydantic>=2; extra == "server"
+Provides-Extra: all
+Requires-Dist: accelerate; extra == "all"
+Requires-Dist: peft; extra == "all"
+Requires-Dist: transformers<4.56,>=4.51; extra == "all"
+Requires-Dist: fastapi; extra == "all"
+Requires-Dist: uvicorn; extra == "all"
+Requires-Dist: pydantic>=2; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: httpx; extra == "dev"
+Dynamic: license-file
+
+# duplexjev
+
+Batched typed speech decisions without decoding. Every question — *has the user finished? which filler? which intent?*
+— is answered as a probability over its options from a **single forward pass**, with no ASR or text decoding. Many
+questions about many calls share one pass, with exact prefix sharing.
+
+```bash
+pip install duplexjev            # text models
+pip install "duplexjev[all]"     # + speech checkpoints and the HTTP server
+```
+
+```python
+from duplexjev import Decider, Question
+
+d = Decider.from_pretrained("Qwen/Qwen3-8B")        # any causal LM; or a speech checkpoint (see below)
+qs = [Question("turn", "Has the user finished the turn?", ["finished", "not finished"]),
+      Question("intent", "What does the user want?", ["climate", "media", "navigation", "phone"])]
+d.decide(["Turn on the air conditioning", "Navigate to the"], qs)
+# [{'turn': {'answer': 'finished', 'confidence': 0.97, 'probs': {...}}, 'intent': {...}}, {...}]
+```
+
+Speech checkpoints (Ultravox format, including the DuplexJev adapters) take audio directly:
+`Decider.from_pretrained("fixie-ai/ultravox-v0_6-qwen-3-32b").decide(["call1.wav", "call2.wav"], qs)`.
+
+Serve with tick batching: `duplexjev serve --model <id> --tick-ms 160`.
+
+Project: https://github.com/adventists-ai/duplexjev · License: Apache-2.0

duplexjev-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+duplexjev/__init__.py,sha256=0DMWmoPp6gCKLW7LvhcKx2MLgio773IWERWkKXKUyG0,478
+duplexjev/cli.py,sha256=7UuUTP4xRQtFM5Z3OdK7CI2DiCJ5ON05dd2Odw2yblU,3422
+duplexjev/decider.py,sha256=n0NGL7PZ9FGKZYYYxcEZxMkicDFW-HUE4HPVu8xVE7g,21449
+duplexjev/question.py,sha256=UGpAt0iRVRD0ktAYJ81t9ZMzNhkrvJX6gI7oRhiOqcI,3564
+duplexjev/server.py,sha256=YeKTbTfdqb-pd9-LiRkp4DsxBoFqFW3rFCbwUVoYyVQ,5004
+duplexjev-0.1.0.dist-info/licenses/LICENSE,sha256=gy3Z4Apo3YOzw_ufVYja19zzN6DbUPfZSD8xDNKS6S4,11343
+duplexjev-0.1.0.dist-info/licenses/NOTICE,sha256=76RaOn2q4eZLBnS3RPnh9yBNJzvvq97TOQwsZRUAKxA,1331
+duplexjev-0.1.0.dist-info/METADATA,sha256=YoVUD5hiHaILdEedrdjhriUAsQy28sRqKn4bQPImdQI,2859
+duplexjev-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+duplexjev-0.1.0.dist-info/entry_points.txt,sha256=2A-uIDgP-5sswzVt1vRmsiUP5DTsdYkgt2VdfrbwR78,49
+duplexjev-0.1.0.dist-info/top_level.txt,sha256=uEOPsH-VnHYzHmQT4-TiPMeUEbC40Tm-AGmZAA68RDI,10
+duplexjev-0.1.0.dist-info/RECORD,,

duplexjev-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

duplexjev-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+duplexjev = duplexjev.cli:main

duplexjev-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2024 Alibaba Cloud
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

duplexjev-0.1.0.dist-info/licenses/NOTICE

@@ -0,0 +1,19 @@
+DuplexJev
+Copyright 2026 Adventists.ai and the DuplexJev authors.
+
+Licensed under the Apache License, Version 2.0 (see LICENSE), except where noted below.
+
+Third-party components
+- Ultravox (https://github.com/fixie-ai/ultravox), MIT License, Copyright (c) 2023 Fixie.ai.
+  Training code in training/ patches and extends Ultravox; the projector design follows Ultravox.
+- Qwen3 / Qwen3-ASR (https://github.com/QwenLM), Apache License 2.0. duplexjev/encoder/ is derived from the
+  Qwen3-ASR encoder implementation.
+- Model weights released with this project contain only the trained fusion and projector parameters; the frozen
+  Qwen3-ASR-0.6B encoder and Qwen3-32B LLM must be obtained from their original sources under their licenses.
+
+Datasets
+- qa100 (https://huggingface.co/datasets/adventists-ai/qa100): created by the authors, released under CC-BY-4.0. Audio synthesised with VoxCPM2.
+- Training data (Ultravox v0.6 mixture: WenetSpeech, GigaSpeech, Common Voice 17, People's Speech, LibriSpeech,
+  Multilingual LibriSpeech, CoVoST 2, MUSAN) is NOT redistributed; see each dataset's license.
+- ZJU audio-gender-benchmark (https://github.com/Vsky-morigen/audio-gender-benchmark) is used for evaluation only and
+  is NOT redistributed here. Its main-language subset includes ODSQA audio whose redistribution terms are unclear.

duplexjev-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+duplexjev