Upload 4 files

README.md

@@ -1,3 +1,52 @@
----
-license: apache-2.0
----
+---
+license: apache-2.0
+task_categories:
+- automatic-speech-recognition
+language:
+- en
+tags:
+- benchmark
+- deterministic
+- audio-to-text
+- codec
+pretty_name: loomspeech
+size_categories:
+- n<1K
+---
+
+# loomspeech — a decode benchmark
+
+**Can a model listen to deterministically-encoded audio and recover the text it came from?**
+
+loom is a ~10KB, model-free codec: it turns text into sung audio by mapping each **word to a fixed
+musical motif** (1-3 notes on a pentatonic scale) sung on the word's own vowels. Same word -> same
+sound, forever, on any machine. So `(text -> audio)` labels are **free and unlimited** — this repo
+is a *generator-backed* benchmark, not a static dump.
+
+## The task
+Given a `.wav`, predict the source `text`. Metrics: exact-line accuracy and position-wise word
+accuracy (`score.py`).
+
+## What's here
+- `data/` — a playable sample (`metadata.jsonl` + wavs: `file_name`, `text`, `motif`).
+- `encode.py` — the encoder. Mint more: `python encode.py --builtin --n 5000 --out data`.
+- `baseline.py` — a non-ML floor: pitch-only, vocabulary-aware (~43% word accuracy). Beat it.
+- `score.py` — the scorer.
+
+```python
+from datasets import load_dataset
+ds = load_dataset("asleepyhimiko/loomspeech")   # audio + text + motif
+```
+
+## Baseline & headroom
+Pitch-only + known lexicon ~= **43% word / 20% exact-line.** It throws the **vowels** away (which
+carry out-of-vocabulary words), assumes the lexicon, and dies under noise. A real model should beat
+all three.
+
+## The question
+Near-100% decode proves a **lossless, model-free code** — meaning survives sound and returns.
+Whether a recoverable code is a **language** (human-learnable, conventional, productive) is the open
+question, not the claim. This benchmark measures the necessary condition.
+
+- Hear it: <https://asleepyhimiko-loom.static.hf.space/booth.html> (set *pitch -> word = note*)
+- Source: <https://github.com/evengineer1ng/loom>

baseline.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+"""A non-ML baseline decoder for loomspeech — pitch-only, vocabulary-aware (the FLOOR).
+
+Reads each audio file, splits it into note segments by silence, detects each note's pitch (FFT),
+snaps to a scale degree, then greedily segments the degree sequence into words using the known
+lexicon. It ignores vowels and timbre entirely — so the vowel signal (which carries out-of-
+vocabulary words) is thrown away. The open challenge: beat this with a model that needs no
+lexicon, survives noise, and recovers words this baseline can't.
+
+    python bench/encode.py --builtin --n 300 --out data/ls
+    python bench/baseline.py data/ls/manifest.jsonl data/ls > preds.jsonl
+    python bench/score.py data/ls/manifest.jsonl preds.jsonl
+"""
+import json
+import os
+import sys
+
+import numpy as np
+
+try:
+    import soundfile as sf
+except ImportError:
+    raise SystemExit("needs soundfile: pip install soundfile numpy")
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from encode import SCALE_HZ, WORDS, word_motif  # noqa: E402
+
+VOCAB = {}
+for _w in WORDS:
+    VOCAB.setdefault(tuple(word_motif(_w)), _w)   # motif -> word (first wins on collision)
+
+
+def segments(audio, sr, thr=0.02, min_s=0.05):
+    env = np.abs(audio).astype(np.float64)
+    win = max(1, int(0.006 * sr))
+    env = np.convolve(env, np.ones(win) / win, "same")
+    voiced = env > thr
+    segs, i, n = [], 0, len(audio)
+    while i < n:
+        if voiced[i]:
+            j = i
+            while j < n and voiced[j]:
+                j += 1
+            if j - i >= int(min_s * sr):
+                segs.append((i, j))
+            i = j
+        else:
+            i += 1
+    return segs
+
+
+def degree(seg, sr):
+    a = seg * np.hanning(len(seg))
+    spec = np.abs(np.fft.rfft(a))
+    fr = np.fft.rfftfreq(len(a), 1.0 / sr)
+    band = (fr >= 200) & (fr <= 560)
+    if not band.any() or not spec[band].size:
+        return 0
+    f = fr[band][int(np.argmax(spec[band]))]
+    return min(range(len(SCALE_HZ)), key=lambda d: abs(SCALE_HZ[d] - f))
+
+
+def decode(audio, sr):
+    degs = [degree(audio[a:b], sr) for a, b in segments(audio, sr)]
+    out, i = [], 0
+    while i < len(degs):
+        hit = None
+        for length in (3, 2, 1):
+            t = tuple(degs[i:i + length])
+            if len(t) == length and t in VOCAB:
+                hit = (VOCAB[t], length)
+                break
+        if hit:
+            out.append(hit[0])
+            i += hit[1]
+        else:
+            i += 1
+    return " ".join(out)
+
+
+def main():
+    if len(sys.argv) < 3:
+        raise SystemExit("usage: baseline.py <manifest.jsonl> <data_dir>  > preds.jsonl")
+    manifest, root = sys.argv[1], sys.argv[2]
+    for line in open(manifest, encoding="utf-8"):
+        line = line.strip()
+        if not line:
+            continue
+        d = json.loads(line)
+        audio, sr = sf.read(os.path.join(root, d["wav"]))
+        if getattr(audio, "ndim", 1) > 1:
+            audio = audio.mean(axis=1)
+        print(json.dumps({"id": d["id"], "text": decode(np.asarray(audio, dtype=np.float64), sr)}))
+
+
+if __name__ == "__main__":
+    main()

encode.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python3
+"""loomspeech benchmark — the ENCODER. Deterministic text -> sung audio.
+
+Each word hashes to a short musical MOTIF (1-3 notes) on a fixed pentatonic scale, sung on the
+word's own vowels. Same word -> same motif -> same sound, forever. That makes (text, audio) an
+*unlimited, free, perfectly-labeled* dataset — no human, no licensing, no model.
+
+THE TASK (see README): given the audio, recover the text. If a model can, the codec carries the
+meaning losslessly — it is a language. Generate as much as you want:
+
+    python bench/encode.py --builtin --n 2000 --out data/loomspeech
+    python bench/encode.py --corpus my_lines.txt --out data/loomspeech
+
+Writes <out>/*.wav + <out>/manifest.jsonl  ({id, text, wav, motif}).
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import random
+import sys
+
+import numpy as np
+
+sys.path.insert(0, os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "..")))
+import voicesynth  # noqa: E402  (repo root)
+
+try:
+    import soundfile as sf
+except ImportError:
+    raise SystemExit("loomspeech encode needs soundfile:  pip install soundfile numpy")
+
+SCALE_HZ = [220.00, 261.63, 293.66, 329.63, 392.00, 440.00, 523.25]  # A-minor pentatonic
+VOWELS = set("aeiou")
+# a small built-in lexicon so anyone can mint data with zero input.
+WORDS = ("the a red fast car heart beats high low you move stop go win lose three dunk lap race "
+         "night city loom echo brah turn brake speed lead fall rise hold open close left right up "
+         "down now then fan rival crew pit fastest clean sharp gap apex throttle").split()
+
+
+def word_motif(word: str) -> list:
+    """A word -> a deterministic 1..3 note motif (degrees into SCALE_HZ). Clean uint32 hash —
+    this is the canonical benchmark mapping (booth.html is its interactive cousin)."""
+    h = 2166136261
+    for c in word.lower():
+        h = ((h ^ ord(c)) * 16777619) & 0xFFFFFFFF
+    n = 1 + (len(word) % 3)
+    out = []
+    for _ in range(n):
+        out.append(h % len(SCALE_HZ))
+        h = (h * 16777619 + 2654435761) & 0xFFFFFFFF
+    return out
+
+
+def _words(text: str) -> list:
+    return ["".join(c for c in w if c.isalpha()) for w in text.lower().split() if any(ch.isalpha() for ch in w)]
+
+
+def encode_line(text: str, *, dur: float = 0.26, gap: float = 0.05, sr: int = 22050):
+    notes, motifs = [], []
+    for w in _words(text):
+        deg = word_motif(w)
+        motifs.append(deg)
+        vs = [c for c in w if c in VOWELS] or ["a"]
+        for i, d in enumerate(deg):
+            notes.append({"hz": SCALE_HZ[d], "dur": dur, "vowel": vs[i % len(vs)]})
+    audio = voicesynth.render_tape(notes, sr=sr, gap=gap) if notes else np.zeros(1, dtype=np.float32)
+    return audio, motifs
+
+
+def builtin_corpus(n: int, seed: int = 0) -> list:
+    rng = random.Random(seed)
+    return [" ".join(rng.choice(WORDS) for _ in range(rng.randint(2, 6))) for _ in range(n)]
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description="loomspeech encoder — text to sung audio")
+    ap.add_argument("--corpus", help="text file, one line per utterance")
+    ap.add_argument("--builtin", action="store_true", help="mint random utterances from the built-in lexicon")
+    ap.add_argument("--n", type=int, default=500)
+    ap.add_argument("--seed", type=int, default=0)
+    ap.add_argument("--out", default="data/loomspeech")
+    ap.add_argument("--sr", type=int, default=22050)
+    args = ap.parse_args()
+
+    if args.corpus:
+        lines = [ln.strip() for ln in open(args.corpus, encoding="utf-8") if ln.strip()]
+    else:
+        lines = builtin_corpus(args.n, args.seed)
+
+    os.makedirs(args.out, exist_ok=True)
+    with open(os.path.join(args.out, "manifest.jsonl"), "w", encoding="utf-8") as man:
+        for i, line in enumerate(lines):
+            audio, motifs = encode_line(line, sr=args.sr)
+            wav = f"{i:06d}.wav"
+            sf.write(os.path.join(args.out, wav), audio, args.sr)
+            man.write(json.dumps({"id": i, "text": line, "wav": wav, "motif": motifs}) + "\n")
+
+    print(f"wrote {len(lines)} (text,audio) pairs -> {args.out}/  (sr={args.sr})")
+    print("task: predict 'text' from 'wav'.  score:  python bench/score.py "
+          f"{args.out}/manifest.jsonl preds.jsonl")
+
+
+if __name__ == "__main__":
+    main()

score.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python3
+"""Score a decoder against the loomspeech benchmark.
+
+    python bench/score.py <manifest.jsonl> <predictions.jsonl>
+
+predictions.jsonl: one {"id": N, "text": "..."} per line. Reports exact-line accuracy and
+position-wise word accuracy. The task: recover the source text from the audio alone.
+"""
+from __future__ import annotations
+
+import json
+import sys
+
+
+def load(path: str) -> dict:
+    out = {}
+    for line in open(path, encoding="utf-8"):
+        line = line.strip()
+        if not line:
+            continue
+        d = json.loads(line)
+        out[d["id"]] = d.get("text", "")
+    return out
+
+
+def norm(text: str) -> list:
+    return ["".join(c for c in w if c.isalpha()) for w in str(text).lower().split() if any(ch.isalpha() for ch in w)]
+
+
+def main() -> None:
+    if len(sys.argv) < 3:
+        raise SystemExit("usage: score.py <manifest.jsonl> <predictions.jsonl>")
+    gold, pred = load(sys.argv[1]), load(sys.argv[2])
+    n, exact, w_tot, w_ok = len(gold), 0, 0, 0
+    for i, g in gold.items():
+        gw, pw = norm(g), norm(pred.get(i, ""))
+        if gw == pw:
+            exact += 1
+        w_tot += len(gw)
+        w_ok += sum(1 for a, b in zip(gw, pw) if a == b)
+    print(f"pairs:               {n}")
+    print(f"exact-line accuracy: {exact}/{n} = {100 * exact / max(1, n):.1f}%")
+    print(f"word accuracy:       {w_ok}/{w_tot} = {100 * w_ok / max(1, w_tot):.1f}%")
+
+
+if __name__ == "__main__":
+    main()