KEEP Listen: English UI, modern design, SVG icons, 10 words only

app.py

@@ -1,4 +1,4 @@
-import os, json, sys, numpy as np, gradio as gr, torch
+import os, json, sys, numpy as np, gradio as gr
 import matplotlib; matplotlib.use("Agg"); import matplotlib.pyplot as plt
 from huggingface_hub import snapshot_download
 
@@ -10,12 +10,37 @@ cfg = json.load(open(os.path.join(d, "config.json"))) if os.path.exists(os.path.
 R = K.Recognizer(os.path.join(d, "audio2b_KEEP_graine0.pt"), os.path.join(d, "audio2b_normalisation.pt"), gain=cfg.get("gain", "peak"))
 TAU, MIN_FRAME = 0.95, 10
 
-# ─── onglet 1 : les 10 mots appris à l'entraînement ───
-def ecoute(audio, gain_choisi):
-    R.gain = gain_choisi
-    if audio is None: return None, None, "Enregistrez ou chargez un mot d'abord."
+CSS = """
+@import url('https://fonts.googleapis.com/css2?family=Cormorant+Garamond:wght@600;700&family=Space+Grotesk:wght@400;500;600&display=swap');
+.gradio-container { max-width: 920px !important; margin: auto !important; background: #F5F4F0 !important; font-family: 'Space Grotesk', system-ui, sans-serif !important; }
+.hero { background: linear-gradient(135deg, #0D1B2A 0%, #1B3A5C 100%); border-radius: 22px; padding: 34px 32px 26px; color: #fff; margin-bottom: 22px; box-shadow: 0 12px 40px rgba(13,27,42,.25); }
+.hero .hero-top { display: flex; gap: 18px; align-items: flex-start; }
+.hero .hero-icon { flex: 0 0 auto; width: 56px; height: 56px; border-radius: 16px; background: rgba(201,162,39,.18); border: 1px solid rgba(201,162,39,.5); display: flex; align-items: center; justify-content: center; color: #C9A227; }
+.hero h1 { font-family: 'Cormorant Garamond', Georgia, serif; font-size: 46px; margin: 0 0 6px; font-weight: 700; letter-spacing: -.5px; line-height: 1.05; }
+.hero .tagline { font-size: 16.5px; opacity: .92; margin: 0 0 16px; line-height: 1.5; }
+.hero .pills { display: flex; flex-wrap: wrap; gap: 8px; }
+.hero .pill { background: rgba(255,255,255,.10); border: 1px solid rgba(255,255,255,.22); border-radius: 999px; padding: 6px 14px; font-size: 13.5px; }
+.hero .pill b { color: #C9A227; }
+button.primary { background: #0D1B2A !important; border-radius: 12px !important; }
+.footnote { color: #64748b; font-size: 13.5px; line-height: 1.55; margin-top: 18px; }
+"""
+
+MIC_SVG = """<svg width="28" height="28" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="9" y="2" width="6" height="12" rx="3"/><path d="M5 10a7 7 0 0 0 14 0"/><path d="M12 19v3"/></svg>"""
+
+HERO = f"""<div class="hero"><div class="hero-top"><div class="hero-icon">{MIC_SVG}</div><div>
+<h1>KEEP Listen</h1>
+<p class="tagline">A small AMEFORGE model (about 265,000 parameters) that recognizes <b>10 spoken English words</b> as it listens, over time.</p>
+</div></div><div class="pills">
+<span class="pill"><b>10</b> known words</span>
+<span class="pill"><b>~97%</b> on never-heard voices</span>
+<span class="pill">Runs on CPU</span>
+</div></div>"""
+
+def listen(audio, gain_choice):
+    R.gain = gain_choice
+    if audio is None: return None, None, "Record or upload a word first."
     sr, wav = audio
-    _, P = R(wav, sr)                                    # P : [101 instants (10 ms), 10 mots]
+    _, P = R(wav, sr)                                    # P : [101 steps (10 ms), 10 words]
     final = P[-1]; top = final.argsort()[::-1][:3]
     lab = {K.WORDS[i]: float(final[i]) for i in range(len(K.WORDS))}
     sure = np.where(P[MIN_FRAME:].max(1) >= TAU)[0]
@@ -25,78 +50,31 @@ def ecoute(audio, gain_choisi):
     ax.axhline(TAU, color="gray", ls=":", lw=1)
     if len(sure):
         td = (sure[0] + MIN_FRAME) * 10; ax.axvline(td, color="black", ls="--", lw=1)
-    ax.set_xlabel("temps écouté (ms)"); ax.set_ylabel("confiance"); ax.set_ylim(0, 1.02); ax.legend(loc="upper left"); ax.grid(alpha=.3)
+    ax.set_xlabel("listened time (ms)"); ax.set_ylabel("confidence"); ax.set_ylim(0, 1.02); ax.legend(loc="upper left"); ax.grid(alpha=.3)
     fig.tight_layout()
     w = K.WORDS[int(final.argmax())]
     if final.max() < 0.6:
-        msg = f"**Pas sûr** (meilleure hypothèse : « {w} », {final.max():.0%}). Dites clairement un des 10 mots."
+        msg = f"**Not sure** (best guess: “{w}”, {final.max():.0%}). Say one of the 10 words clearly."
     elif len(sure):
         w0 = K.WORDS[int(P[sure[0] + MIN_FRAME].argmax())]
-        msg = f"Mot reconnu : **{w}** ({final.max():.0%}). Il était déjà sûr de « {w0} » après **{(sure[0] + MIN_FRAME) * 10} ms** d'écoute."
+        msg = f"Word recognized: **{w}** ({final.max():.0%}). It was already sure of “{w0}” after **{(sure[0] + MIN_FRAME) * 10} ms** of listening."
     else:
-        msg = f"Mot reconnu : **{w}** ({final.max():.0%}), à la fin de l'écoute."
+        msg = f"Word recognized: **{w}** ({final.max():.0%}), at the end of listening."
     return lab, fig, msg
 
-# ─── onglet 2 : apprendre un mot NOUVEAU en direct (aucun ré-entraînement : on garde l'empreinte des exemples) ───
-def resume(mem):
-    if not mem: return "_Aucun mot appris pour l'instant._"
-    return "**Mots appris :** " + " · ".join(f"{w} ({len(v)} exemple{'s' if len(v) > 1 else ''})" for w, v in mem.items())
-
-def ajoute(nom, audio, gain_choisi, mem):
-    mem = dict(mem or {}); nom = (nom or "").strip().lower()
-    if not nom: return mem, resume(mem), "Écrivez d'abord le nom du mot.", gr.update()
-    if audio is None: return mem, resume(mem), "Enregistrez le mot d'abord.", gr.update()
-    R.gain = gain_choisi; sr, wav = audio
-    mem[nom] = list(mem.get(nom, [])) + [R.embedding(wav, sr).tolist()]
-    n = len(mem[nom]); conseil = " Ajoutez encore 1 ou 2 exemples pour qu'il soit plus sûr." if n < 3 else ""
-    return mem, resume(mem), f"Exemple n° {n} de « {nom} » mémorisé.{conseil}", None
-
-def oublie(): return {}, resume({}), "Tout est oublié.", None
-
-def reconnait(audio, gain_choisi, mem):
-    if not mem or len(mem) < 2: return None, "Apprenez-lui au moins **2 mots** d'abord (champ du haut)."
-    if audio is None: return None, "Dites un des mots appris."
-    R.gain = gain_choisi; sr, wav = audio; q = R.embedding(wav, sr)
-    noms = list(mem); P = torch.nn.functional.normalize(torch.stack([torch.tensor(mem[w]).mean(0) for w in noms]), dim=-1)
-    sim = (P @ q).numpy(); p = np.exp(20 * (sim - sim.max())); p = p / p.sum()
-    i = int(sim.argmax()); j = np.argsort(-sim)[1] if len(sim) > 1 else i
-    ecart = sim[i] - sim[j]
-    msg = (f"J'ai entendu : **{noms[i]}**." if ecart > 0.05 else f"J'hésite… plutôt **{noms[i]}**, mais ça ressemble aussi à « {noms[j]} ». Ajoutez des exemples.")
-    return {w: float(x) for w, x in zip(noms, p)}, msg
-
-with gr.Blocks(title="KEEP écoute") as demo:
-    gr.Markdown("# KEEP écoute\nUn petit modèle AMEFORGE (environ 265 000 paramètres) qui écoute le son au fil du temps.")
-    gain_radio = gr.Radio(["peak", "none"], value=cfg.get("gain", "peak"), label="Réglage du volume (peak = automatique, none = brut)")
-    mem = gr.State({})
-    with gr.Tab("Les 10 mots qu'il connaît"):
-        gr.Markdown("**Mots connus :** yes · no · up · down · left · right · on · off · stop · go — dites un seul mot, près du micro. "
-                    "La courbe montre comment sa confiance monte pendant l'écoute.")
-        with gr.Row():
-            a = gr.Audio(sources=["microphone", "upload"], type="numpy", label="Votre mot (environ 1 seconde)")
-            lab = gr.Label(num_top_classes=3, label="Ce que KEEP a entendu")
-        msg = gr.Markdown(); plot = gr.Plot(label="Confiance au fil de l'écoute")
-        gr.Button("Écouter", variant="primary").click(ecoute, [a, gain_radio], [lab, plot, msg])
-    with gr.Tab("Apprends-lui un mot nouveau"):
-        gr.Markdown("Apprenez à KEEP des mots **qu'il n'a jamais entendus** (n'importe quelle langue), **sans le ré-entraîner** : "
-                    "il garde l'empreinte de vos exemples, puis reconnaît par ressemblance.\n\n"
-                    "**1.** Écrivez un nom, enregistrez le mot (1 à 3 fois) et cliquez « Mémoriser ». Faites-le pour 2 à 5 mots.  \n"
-                    "**2.** Plus bas, redites un des mots : KEEP dit lequel il reconnaît.")
-        with gr.Row():
-            nom = gr.Textbox(label="Nom du mot", placeholder="ex. : bonjour")
-            ex_audio = gr.Audio(sources=["microphone", "upload"], type="numpy", label="Dites ce mot")
-        with gr.Row():
-            b_add = gr.Button("Mémoriser cet exemple", variant="primary"); b_forget = gr.Button("Tout oublier")
-        info = gr.Markdown(); appris = gr.Markdown(resume({}))
-        b_add.click(ajoute, [nom, ex_audio, gain_radio, mem], [mem, appris, info, ex_audio])
-        b_forget.click(oublie, None, [mem, appris, info, ex_audio])
-        gr.Markdown("---")
-        with gr.Row():
-            q_audio = gr.Audio(sources=["microphone", "upload"], type="numpy", label="Redites un des mots appris")
-            q_lab = gr.Label(label="Ressemblance avec chaque mot appris")
-        q_msg = gr.Markdown()
-        gr.Button("Qu'ai-je dit ?", variant="primary").click(reconnait, [q_audio, gain_radio, mem], [q_lab, q_msg])
-        gr.Markdown("_Expérimental : ce qu'il apprend ici est oublié quand vous fermez la page. "
-                    "Ça marche le mieux avec la même voix que les exemples, et 2 à 3 exemples par mot._")
-    gr.Markdown("**Limites.** Onglet 1 : il ne connaît que ces 10 mots (environ 97 % sur des voix jamais entendues). "
-                "Un micro bruyant ou un accent très différent peut faire baisser ces chiffres. Il reconnaît des sons de mots, il ne comprend pas la parole.")
+with gr.Blocks(title="KEEP Listen", css=CSS) as demo:
+    gr.HTML(HERO)
+    gr.Markdown("**Known words:** yes · no · up · down · left · right · on · off · stop · go — say a single word, close to the microphone. "
+                "The curve shows how its confidence rises while listening.")
+    with gr.Row():
+        a = gr.Audio(sources=["microphone", "upload"], type="numpy", label="Your word (about 1 second)")
+        lab = gr.Label(num_top_classes=3, label="What KEEP heard")
+    msg = gr.Markdown(); plot = gr.Plot(label="Confidence over listening time")
+    gain_radio = gr.Radio(["peak", "none"], value=cfg.get("gain", "peak"),
+        label="Volume setting (peak = automatic, none = raw)")
+    gr.Button("Listen", variant="primary").click(listen, [a, gain_radio], [lab, plot, msg])
+    gr.Markdown("**Limits.** It only knows these 10 words: any other sound will be classified as one of them. "
+                "Tested at about 97% on never-heard voices (Speech Commands test set); a noisy microphone or a very "
+                "different accent can lower that number. It recognizes words, it does not understand speech.",
+                elem_classes=["footnote"])
 demo.launch()