Upload folder using huggingface_hub

app.py

@@ -1,4 +1,4 @@
-"""Nawah-ASR-50M demo.
+"""Nawah-ASR demo — pick between the 89M and 157M models.
 
 The browser does all audio handling: decodeAudioData accepts wav/mp3/m4a/webm, resamples to
 16 kHz mono and posts raw float32 samples. So this server needs no ffmpeg, no soundfile, and no
@@ -7,8 +7,12 @@ format guessing -- it only ever sees the array the model wants.
 The audio token count is per-clip, not fixed: `<audio>` is repeated exactly
 `_get_feat_extract_output_lengths(...)` times, which is 25 per second. A 3-second clip costs 75
 tokens rather than the 375 a fixed 30-second window would spend on silence.
+
+Models load LAZILY and are cached. Only the default is loaded at boot, so adding the second one
+costs nothing in start-up time or RAM until somebody actually selects it -- these are fp32 CPU
+weights (356 MB + 627 MB) and this Space has no GPU to hide the cost.
 """
-import os, time
+import os, threading, time
 
 import numpy as np
 import torch
@@ -19,20 +23,47 @@ from pydantic import BaseModel
 from transformers import (AutoTokenizer, Qwen2AudioForConditionalGeneration,
                           WhisperFeatureExtractor)
 
-REPO = os.environ.get("ASR_MODEL", "oddadmix/Nawah-ASR-89M-v1")
+MODELS = {
+    "89m": {"repo": os.environ.get("ASR_MODEL", "oddadmix/Nawah-ASR-89M-v1"),
+            "label": "Nawah-ASR-89M-v1 · Whisper-base · 89M",
+            "note": "MASC + WorldSpeech (1681 h) · MASC WER 0.3372"},
+    "157m": {"repo": os.environ.get("ASR_MODEL_SMALL", "oddadmix/Nawah-ASR-50M-v2"),
+             "label": "Nawah-ASR-50M-v2 · Whisper-small · 157M",
+             "note": "MASC (866 h) · MASC WER 0.3614"},
+}
+DEFAULT = os.environ.get("ASR_DEFAULT", "89m")
+if DEFAULT not in MODELS:
+    DEFAULT = "89m"
 TOKEN = os.environ.get("MODEL_HF_TOKEN") or os.environ.get("HF_TOKEN")
 SR, MAX_SEC = 16000, 30
 
-print(f"[*] loading {REPO}", flush=True)
-tok = AutoTokenizer.from_pretrained(REPO, token=TOKEN)
-fe = WhisperFeatureExtractor.from_pretrained(REPO, token=TOKEN)
-model = Qwen2AudioForConditionalGeneration.from_pretrained(REPO, token=TOKEN,
-                                                           dtype=torch.float32).eval()
 torch.set_num_threads(int(os.environ.get("OMP_NUM_THREADS", 4)))
-CV = tok.convert_tokens_to_ids
-AUDIO, A_START, A_END = CV("<audio>"), CV("<|audio_start|>"), CV("<|audio_end|>")
-PARAMS = sum(p.numel() for p in model.parameters())
-print(f"[+] {PARAMS/1e6:.1f}M params ready", flush=True)
+_loaded, _lock = {}, threading.Lock()
+
+
+def get_model(key: str):
+    """Load-and-cache. The lock matters: FastAPI runs sync endpoints in a threadpool, so two
+    first-requests for the same model would otherwise both pay the load."""
+    key = key if key in MODELS else DEFAULT
+    with _lock:
+        if key not in _loaded:
+            repo = MODELS[key]["repo"]
+            print(f"[*] loading {repo}", flush=True)
+            tok = AutoTokenizer.from_pretrained(repo, token=TOKEN)
+            fe = WhisperFeatureExtractor.from_pretrained(repo, token=TOKEN)
+            model = Qwen2AudioForConditionalGeneration.from_pretrained(
+                repo, token=TOKEN, dtype=torch.float32).eval()
+            cv = tok.convert_tokens_to_ids
+            _loaded[key] = {
+                "tok": tok, "fe": fe, "model": model, "repo": repo,
+                "audio": cv("<audio>"), "start": cv("<|audio_start|>"), "end": cv("<|audio_end|>"),
+                "params": sum(p.numel() for p in model.parameters()),
+            }
+            print(f"[+] {repo} ready ({_loaded[key]['params']/1e6:.1f}M params)", flush=True)
+    return _loaded[key]
+
+
+get_model(DEFAULT)          # warm the default so the first request is not a cold load
 
 app = FastAPI()
 
@@ -40,15 +71,18 @@ app = FastAPI()
 class Req(BaseModel):
     samples: list[float] = []
     max_new: int = 96
+    model: str = DEFAULT
 
 
 @torch.no_grad()
-def run(wav: np.ndarray, max_new: int):
+def run(wav: np.ndarray, max_new: int, key: str):
+    b = get_model(key)
+    tok, fe, model = b["tok"], b["fe"], b["model"]
     wav = wav[: SR * MAX_SEC]
     feats = fe([wav], sampling_rate=SR, return_attention_mask=True, return_tensors="pt")
     _, n = model.model.audio_tower._get_feat_extract_output_lengths(feats.attention_mask.sum(-1))
     n = int(n[0])
-    ids = torch.tensor([[tok.bos_token_id, A_START] + [AUDIO] * n + [A_END]])
+    ids = torch.tensor([[tok.bos_token_id, b["start"]] + [b["audio"]] * n + [b["end"]]])
     t0 = time.perf_counter()
     out = model.generate(input_ids=ids, attention_mask=torch.ones_like(ids),
                          input_features=feats.input_features,
@@ -60,7 +94,8 @@ def run(wav: np.ndarray, max_new: int):
     dur = len(wav) / SR
     return {"text": text, "audio_tokens": n, "duration": round(dur, 2),
             "ms": round(ms), "rtf": round(dur * 1000 / max(ms, 1), 1),
-            "new_tokens": int(out.shape[1] - ids.shape[1])}
+            "new_tokens": int(out.shape[1] - ids.shape[1]),
+            "model": b["repo"], "params": b["params"]}
 
 
 @app.get("/")
@@ -70,7 +105,11 @@ def index():
 
 @app.get("/api/ready")
 def ready():
-    return {"ready": True, "model": REPO, "params": PARAMS, "max_sec": MAX_SEC}
+    return {"ready": True, "default": DEFAULT, "max_sec": MAX_SEC,
+            "models": [{"key": k, "label": v["label"], "repo": v["repo"], "note": v["note"],
+                        "loaded": k in _loaded,
+                        "params": _loaded[k]["params"] if k in _loaded else None}
+                       for k, v in MODELS.items()]}
 
 
 @app.post("/api/asr")
@@ -80,7 +119,7 @@ def asr(req: Req):
     wav = np.asarray(req.samples, dtype=np.float32)
     if wav.size < SR // 4:
         return JSONResponse({"error": "clip too short"}, status_code=400)
-    return JSONResponse(run(wav, max(8, min(req.max_new, 200))))
+    return JSONResponse(run(wav, max(8, min(req.max_new, 200)), req.model))
 
 
 app.mount("/static", StaticFiles(directory="static"), name="static")

static/app.js

@@ -38,7 +38,7 @@ async function send(samples) {
   try {
     const r = await fetch("/api/asr", {
       method: "POST", headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ samples: Array.from(samples) })
+      body: JSON.stringify({ samples: Array.from(samples), model: $("model").value })
     });
     const d = await r.json();
     if (d.error) { $("hint").textContent = d.error; return; }
@@ -52,6 +52,7 @@ async function send(samples) {
           <span>اتولد <b>${d.new_tokens}</b> token</span>
           <span>الموديل <b>${d.ms}ms</b> (${d.rtf}× realtime)</span>
           <span>كلي <b>${wall}ms</b></span>
+          <span>الموديل <b>${(d.model || "").split("/").pop()}</b></span>
         </div>
       </div>`);
     $("hint").textContent = "جاهز";
@@ -83,7 +84,21 @@ $("rec").addEventListener("click", async () => {
   $("hint").textContent = "بيسجّل… اتكلم بالعربي";
 });
 
+function describe(m) {
+  // A model not yet loaded says so: it is lazy, so the first request that picks it pays a
+  // one-off CPU load of several hundred MB and would otherwise just look like a hang.
+  return m.loaded ? m.note : m.note + " · بيتحمّل عند أول استخدام";
+}
+
 fetch("/api/ready").then(r => r.json()).then(d => {
-  $("meta").textContent = `${d.model} · ${(d.params / 1e6).toFixed(1)}M params · CPU · لحد ${d.max_sec}s`;
+  const sel = $("model");
+  sel.innerHTML = d.models.map(m =>
+    `<option value="${m.key}" ${m.key === d.default ? "selected" : ""}>${m.label}</option>`).join("");
+  const meta = () => {
+    const m = d.models.find(x => x.key === sel.value) || d.models[0];
+    $("meta").textContent = `${m.repo} · ${describe(m)} · CPU · لحد ${d.max_sec}s`;
+  };
+  sel.addEventListener("change", meta);
+  meta();
   $("hint").textContent = "اضغط سجّل أو ارفع ملف";
 }).catch(() => { $("hint").textContent = "الموديل لسه بيحمّل…"; });

static/index.html

@@ -9,6 +9,7 @@
     <div class="bar">
       <button class="go" id="rec" type="button">🎙️ سجّل</button>
       <label class="up">📂 ارفع ملف صوت<input id="file" type="file" accept="audio/*" hidden></label>
+      <select class="sel" id="model" title="اختار الموديل"></select>
       <span class="hint" id="hint">اضغط سجّل أو ارفع ملف (لحد ٣٠ ثانية)</span>
     </div>
     <div class="wave" id="wave"></div>
@@ -17,8 +18,9 @@
   <section id="out"></section>
 
   <section class="note">
-    <b>ملاحظة:</b> ده v1، متدرب على ٦٠ ساعة بس — الـ WER ٠٫٦١ وده أضعف من Whisper المتدرب.
-    الهدف إثبات إن LLM صغير بالعربي يقدر يقرا صوت. نسخة ٣٠٠ ساعة تحت التدريب.
+    <b>ملاحظة:</b> فيه موديلين تقدر تختار بينهم من فوق. الـ <b>89M</b> أصغر وأحسن — متدرب على
+    ١٦٨١ ساعة (MASC + WorldSpeech) و الـ WER بتاعه ٠٫٣٣٧ على MASC، مقابل ٠٫٣٦١ للـ <b>157M</b>
+    اللي متدرب على ٨٦٦ ساعة MASC بس. اللهجات المحكية لسه صعبة على الاتنين.
   </section>
 </div>
 <script src="/static/app.js"></script></body></html>

static/style.css

@@ -24,3 +24,11 @@ button,.up{font:inherit;border-radius:10px;padding:9px 16px;cursor:pointer;
        font-family:ui-monospace,monospace;border-top:1px solid var(--rule);padding-top:10px}
 .stats b{color:var(--ink);font-weight:600}
 .note{color:var(--dim);font-size:13px;border-right:3px solid var(--warn);padding:2px 12px}
+
+/* model picker sits in the same bar as record/upload */
+.sel {
+  font: inherit; padding: .55rem .7rem; border-radius: 10px;
+  border: 1px solid rgba(255, 255, 255, .18);
+  background: rgba(255, 255, 255, .06); color: inherit; cursor: pointer; max-width: 100%;
+}
+.sel:hover { border-color: rgba(255, 255, 255, .32); }