Update app.py

app.py

@@ -1,5 +1,4 @@
 import spaces
-
 import os
 import json
 import random
@@ -41,6 +40,20 @@ MODEL_DISPLAY: Dict[str, str] = {
     "HuggingFaceTB/SmolLM2-135M-Instruct": "SmolLM2-135M-Instruct",
 }
 
+BASE_MODEL_IDS: List[str] = [
+    "fromziro/Zero-v0.1-150M",
+    "AxiomicLabs/GPT-X2.5-135M",
+    "BananaMind/BananaMind-2-Pro",
+    "HuggingFaceTB/SmolLM2-135M",
+]
+
+BASE_MODEL_DISPLAY: Dict[str, str] = {
+    "fromziro/Zero-v0.1-150M": "Zero-v0.1-150M",
+    "AxiomicLabs/GPT-X2.5-135M": "GPT-X2.5-135M",
+    "BananaMind/BananaMind-2-Pro": "BananaMind-2-Pro",
+    "HuggingFaceTB/SmolLM2-135M": "SmolLM2-135M",
+}
+
 FALLBACK_IDS: Dict[str, str] = {}
 
 INIT_RATING = 1000
@@ -74,11 +87,11 @@ def get_data_dir() -> Path:
         pass
     return local
 
-def get_elo_file() -> Path:
-    return get_data_dir() / "elo.json"
+def get_elo_file(name: str = "elo") -> Path:
+    return get_data_dir() / f"{name}.json"
 
-def get_chat_file() -> Path:
-    return get_data_dir() / "chats.jsonl"
+def get_chat_file(name: str = "chats") -> Path:
+    return get_data_dir() / f"{name}.jsonl"
 
 # Keep legacy globals for backwards compat (now dynamic via functions)
 DATA_DIR = get_data_dir()
@@ -90,6 +103,10 @@ GEN_DEFAULTS: Dict[str, dict] = {
     "SupraLabs/Supra2-100M-Instruct": {"max_new_tokens": 64, "temperature": 0.7, "top_p": 0.9, "top_k": 25, "repetition_penalty": 1.1, "do_sample": True, "no_repeat_ngram_size": 3},
     "BananaMind/BananaMind-2-Medium-Chat": {"max_new_tokens": 64, "temperature": 0.7, "top_p": 0.9, "repetition_penalty": 1.1, "do_sample": True},
     "CodeSoft/MetaDiffusion-150M-ChatBase": {"max_new_tokens": 96, "num_steps": 128, "temperature": 0.7, "top_p": 0.9, "repetition_penalty": 1.5},
+    "fromziro/Zero-v0.1-150M": {"max_new_tokens": 64, "temperature": 0.8, "top_p": 0.95, "repetition_penalty": 1.1, "do_sample": True},
+    "AxiomicLabs/GPT-X2.5-135M": {"max_new_tokens": 64, "temperature": 0.8, "top_p": 0.95, "repetition_penalty": 1.1, "do_sample": True},
+    "BananaMind/BananaMind-2-Pro": {"max_new_tokens": 64, "temperature": 0.8, "top_p": 0.95, "repetition_penalty": 1.1, "do_sample": True},
+    "HuggingFaceTB/SmolLM2-135M": {"max_new_tokens": 64, "temperature": 0.8, "top_p": 0.95, "repetition_penalty": 1.1, "do_sample": True},
 }
 
 MODEL_CONTEXT: Dict[str, int] = {
@@ -97,11 +114,30 @@ MODEL_CONTEXT: Dict[str, int] = {
     "SupraLabs/Supra2-100M-Instruct": 1024,
     "BananaMind/BananaMind-2-Medium-Chat": 3072,
     "CodeSoft/MetaDiffusion-150M-ChatBase": 5120,
+    "fromziro/Zero-v0.1-150M": 2048,
+    "AxiomicLabs/GPT-X2.5-135M": 2048,
+    "BananaMind/BananaMind-2-Pro": 3072,
+    "HuggingFaceTB/SmolLM2-135M": 2048,
 }
 
+
+@dataclass
+class ArenaSpec:
+    key: str
+    model_ids: List[str]
+    display: Dict[str, str]
+    elo_name: str
+    chat_name: str
+    arena_title: str
+    lb_title: str
+
+
+MAIN_ARENA = ArenaSpec("main", MODEL_IDS, MODEL_DISPLAY, "elo", "chats", "Arena", "Leaderboard")
+BASE_ARENA = ArenaSpec("base", BASE_MODEL_IDS, BASE_MODEL_DISPLAY, "base_elo", "base_chats", "Base Arena", "Base Leaderboard")
+
 # ZeroGPU: CUDA is emulated at startup so models load onto cuda at module level;
 # real GPU is only mounted inside @spaces.GPU-decorated calls.
-DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+DEVICE = os.environ.get("SLM_ARENA_DEVICE", "") or ("cuda" if torch.cuda.is_available() else "cpu")
 
 @dataclass
 class MetaDiffusionConfig:
@@ -396,15 +432,15 @@ def _diff_generate_response(model, tokenizer, prompt_ids, gen_len, num_steps, te
 # ---------------------------------------------------------------------------
 # ELO persistence
 # ---------------------------------------------------------------------------
-def init_elo_state() -> Dict[str, dict]:
-    return {mid: {"rating": float(INIT_RATING), "wins": 0, "losses": 0, "battles": 0, "ties": 0, "both_bad": 0} for mid in MODEL_IDS}
+def init_elo_state(spec: ArenaSpec) -> Dict[str, dict]:
+    return {mid: {"rating": float(INIT_RATING), "wins": 0, "losses": 0, "battles": 0, "ties": 0, "both_bad": 0} for mid in spec.model_ids}
 
-def load_elo() -> Dict[str, dict]:
-    if get_elo_file().exists():
+def load_elo(spec: ArenaSpec) -> Dict[str, dict]:
+    if get_elo_file(spec.elo_name).exists():
         try:
-            with open(get_elo_file(), "r") as f:
+            with open(get_elo_file(spec.elo_name), "r") as f:
                 data = json.load(f)
-            for mid in MODEL_IDS:
+            for mid in spec.model_ids:
                 if mid not in data:
                     data[mid] = {"rating": float(INIT_RATING), "wins": 0, "losses": 0, "battles": 0, "ties": 0, "both_bad": 0}
                 else:
@@ -417,12 +453,12 @@ def load_elo() -> Dict[str, dict]:
             return data
         except Exception as e:
             logger.warning(f"Failed to load ELO file: {e}, resetting")
-    return init_elo_state()
+    return init_elo_state(spec)
 
-def save_elo(state: Dict[str, dict]):
+def save_elo(state: Dict[str, dict], spec: ArenaSpec):
     try:
         get_data_dir().mkdir(parents=True, exist_ok=True)
-        with open(get_elo_file(), "w") as f:
+        with open(get_elo_file(spec.elo_name), "w") as f:
             json.dump(state, f, indent=2)
     except Exception as e:
         logger.error(f"Failed to save ELO: {e}")
@@ -430,7 +466,7 @@ def save_elo(state: Dict[str, dict]):
 def expected_score(ra: float, rb: float) -> float:
     return 1.0 / (1.0 + BASE ** ((rb - ra) / SCALE))
 
-def update_elo(state: Dict[str, dict], model_a: str, model_b: str, winner: Optional[str]) -> Dict[str, dict]:
+def update_elo(state: Dict[str, dict], model_a: str, model_b: str, winner: Optional[str], spec: ArenaSpec) -> Dict[str, dict]:
     if model_a not in state or model_b not in state:
         logger.warning(f"Unknown models in ELO update: {model_a}, {model_b}")
         return state
@@ -465,17 +501,17 @@ def update_elo(state: Dict[str, dict], model_a: str, model_b: str, winner: Optio
         state[model_a]["both_bad"] = state[model_a].get("both_bad", 0) + 1
         state[model_b]["both_bad"] = state[model_b].get("both_bad", 0) + 1
 
-    save_elo(state)
+    save_elo(state, spec)
     return state
 
-def leaderboard_dataframe(state: Optional[Dict[str, dict]] = None) -> pd.DataFrame:
+def leaderboard_dataframe(state: Optional[Dict[str, dict]] = None, spec: ArenaSpec = MAIN_ARENA) -> pd.DataFrame:
     if state is None:
-        state = load_elo()
+        state = load_elo(spec)
     rows = []
-    for mid in MODEL_IDS:
+    for mid in spec.model_ids:
         info = state.get(mid, {"rating": INIT_RATING, "wins": 0, "losses": 0, "battles": 0, "ties": 0})
         rows.append({
-            "Model": MODEL_DISPLAY.get(mid, mid),
+            "Model": spec.display.get(mid, mid),
             "Model ID": mid,
             "ELO": round(float(info["rating"]), 1),
             "Battles": int(info["battles"]),
@@ -492,7 +528,7 @@ def leaderboard_dataframe(state: Optional[Dict[str, dict]] = None) -> pd.DataFra
 # ---------------------------------------------------------------------------
 # Chat logging to data/chats.jsonl
 # ---------------------------------------------------------------------------
-def log_battle(prompt: str, model_a: str, model_b: str, response_a: str, response_b: str, chosen: str, winner_model: str):
+def log_battle(spec: ArenaSpec, prompt: str, model_a: str, model_b: str, response_a: str, response_b: str, chosen: str, winner_model: str):
     """
     Append one battle record to data/chats.jsonl.
     Fields: prompt, response_a, response_b, model_a, model_b, chosen (A/B/tie/both_bad), winner_model, timestamp
@@ -511,7 +547,7 @@ def log_battle(prompt: str, model_a: str, model_b: str, response_a: str, respons
             "winner_model": winner_model,
             "chosen_response": response_a if chosen == "A" else response_b if chosen == "B" else "",
         }
-        with open(get_chat_file(), "a", encoding="utf-8") as f:
+        with open(get_chat_file(spec.chat_name), "a", encoding="utf-8") as f:
             f.write(json.dumps(record, ensure_ascii=False) + "\n")
     except Exception as e:
         logger.error(f"Failed to log battle: {e}")
@@ -584,18 +620,18 @@ def load_models():
     global models, tokenizers, model_load_errors
     # If already populated (including diffusion manual), return
     # But we want to ensure all 5 attempted
-    if models and len(models) >= 3:
+    if models and len(models) >= len(MODEL_IDS) + len(BASE_MODEL_IDS) - 1:
         # Already loaded, but ensure diffusion tried
         if "CodeSoft/MetaDiffusion-150M-ChatBase" not in models:
             load_diffusion_manual()
         return models, tokenizers
 
-    logger.info(f"Loading {len(MODEL_IDS)} models on {DEVICE} ...")
+    logger.info(f"Loading {len(MODEL_IDS) + len(BASE_MODEL_IDS)} models on {DEVICE} ...")
     # Try diffusion manual first (bypass HF Auto which fails on unknown type)
     if "CodeSoft/MetaDiffusion-150M-ChatBase" not in models:
         load_diffusion_manual()
 
-    for mid in MODEL_IDS:
+    for mid in MODEL_IDS + BASE_MODEL_IDS:
         if mid in models:
             continue  # already loaded (diffusion)
         load_id = LOCAL_PATHS.get(mid, mid) if os.path.exists(LOCAL_PATHS.get(mid, "")) else mid
@@ -773,22 +809,24 @@ CSS = """
 .gradio-container {max-width: 1450px !important; width: 95% !important;}
 .vote-btn {font-weight: 700 !important;}
 /* Leaderboard: prevent ELO wrapping, give it fixed width */
-#leaderboard { overflow-x: auto; }
-#leaderboard table { table-layout: auto; width: 100%; }
-#leaderboard th:nth-child(4), #leaderboard td:nth-child(4) {
+#leaderboard, #base_leaderboard { overflow-x: auto; }
+#leaderboard table, #base_leaderboard table { table-layout: auto; width: 100%; }
+#leaderboard th:nth-child(4), #leaderboard td:nth-child(4),
+#base_leaderboard th:nth-child(4), #base_leaderboard td:nth-child(4) {
     min-width: 95px;
     width: 95px;
     white-space: nowrap;
     text-align: center;
     font-variant-numeric: tabular-nums;
 }
-#leaderboard th:nth-child(1), #leaderboard td:nth-child(1) { min-width: 55px; width: 55px; text-align: center; }
-#leaderboard td { white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+#leaderboard th:nth-child(1), #leaderboard td:nth-child(1),
+#base_leaderboard th:nth-child(1), #base_leaderboard td:nth-child(1) { min-width: 55px; width: 55px; text-align: center; }
+#leaderboard td, #base_leaderboard td { white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
 """
 
-def pick_random_pair(exclude_pair: Optional[Tuple[str, str]] = None) -> Tuple[str, str]:
-    state = load_elo()
-    models_list = MODEL_IDS[:]
+def pick_random_pair(spec: ArenaSpec, exclude_pair: Optional[Tuple[str, str]] = None) -> Tuple[str, str]:
+    state = load_elo(spec)
+    models_list = spec.model_ids[:]
     weights = []
     C = 5
     K = 100
@@ -801,13 +839,10 @@ def pick_random_pair(exclude_pair: Optional[Tuple[str, str]] = None) -> Tuple[st
     remaining_weights = [w for m, w in zip(models_list, weights) if m != a]
     b = random.choices(remaining, weights=remaining_weights, k=1)[0]
     if exclude_pair and set((a, b)) == set(exclude_pair):
-        a, b = random.sample(MODEL_IDS, 2)
+        a, b = random.sample(spec.model_ids, 2)
     return a, b
 
 def create_demo() -> gr.Blocks:
-    state_init = load_elo()
-    df_init = leaderboard_dataframe(state_init)
-
     with gr.Blocks(title="SLM Arena") as demo:
         gr.Markdown(
             """
@@ -815,10 +850,8 @@ def create_demo() -> gr.Blocks:
             """
         )
 
-        last_pair = gr.State(None)
-
-        with gr.Tabs():
-            with gr.Tab("Arena", id=0):
+        def make_arena_tab(spec: ArenaSpec) -> dict:
+            with gr.Tab(spec.arena_title, id=0 if spec.key == "main" else 2):
                 prompt = gr.Textbox(
                     label="Your prompt",
                     placeholder="Ask anything... e.g. 'Explain quantum computing in simple terms' or 'Write a haiku about rain'",
@@ -855,25 +888,53 @@ def create_demo() -> gr.Blocks:
                 voted_state = gr.State(False)
                 prompt_state = gr.State("")
 
-            leaderboard_tab = gr.Tab("Leaderboard", id=1)
-            with leaderboard_tab:
+                return {
+                    "prompt": prompt,
+                    "submit_btn": submit_btn,
+                    "clear_btn": clear_btn,
+                    "response_a": response_a,
+                    "response_b": response_b,
+                    "reveal_a": reveal_a,
+                    "reveal_b": reveal_b,
+                    "vote_a": vote_a,
+                    "vote_tie": vote_tie,
+                    "vote_both_bad": vote_both_bad,
+                    "vote_b": vote_b,
+                    "status": status,
+                    "new_round_btn": new_round_btn,
+                    "model_a_state": model_a_state,
+                    "model_b_state": model_b_state,
+                    "voted_state": voted_state,
+                    "prompt_state": prompt_state,
+                    "last_pair": gr.State(None),
+                }
+
+        def make_leaderboard_tab(spec: ArenaSpec, elem_id: str, tab_id: int) -> dict:
+            with gr.Tab(spec.lb_title, id=tab_id) as tab:
                 gr.Markdown("### 🏆 ELO Leaderboard")
                 leaderboard = gr.Dataframe(
-                    value=df_init,
+                    value=leaderboard_dataframe(load_elo(spec), spec),
                     headers=["Rank", "Model", "Model ID", "ELO", "Battles", "Wins", "Losses", "Ties", "Both Bad"],
                     datatype=["number", "str", "str", "number", "number", "number", "number", "number", "number"],
                     interactive=False,
                     wrap=False,
                     column_widths=["5%", "15%", "25%", "12%", "7%", "7%", "7%", "7%", "7%"],
-                    elem_id="leaderboard",
+                    elem_id=elem_id,
                 )
-                with gr.Row():
-                    refresh_btn = gr.Button("🔄 Refresh", variant="secondary")
+                refresh_btn = gr.Button("🔄 Refresh", variant="secondary")
+                return {"tab": tab, "leaderboard": leaderboard, "refresh_btn": refresh_btn}
+
+        with gr.Tabs():
+            ui = {}
+            lb = {}
+            for spec, lb_elem, lb_tab in ((MAIN_ARENA, "leaderboard", 1), (BASE_ARENA, "base_leaderboard", 3)):
+                ui[spec.key] = make_arena_tab(spec)
+                lb[spec.key] = make_leaderboard_tab(spec, lb_elem, lb_tab)
 
         # -------------------------------------------------------------------
         # Event handlers
         # -------------------------------------------------------------------
-        def on_submit(user_prompt: str, last_pair_val):
+        def on_submit(spec: ArenaSpec, user_prompt: str, last_pair_val):
             user_prompt = (user_prompt or "").strip()
             if not user_prompt:
                 return (
@@ -888,9 +949,9 @@ def create_demo() -> gr.Blocks:
                     gr.update(interactive=False),
                     gr.update(visible=False),
                     "", "", False, user_prompt, last_pair_val,
-                    leaderboard_dataframe(load_elo())
+                    leaderboard_dataframe(load_elo(spec), spec)
                 )
-            a, b = pick_random_pair(exclude_pair=last_pair_val)
+            a, b = pick_random_pair(spec, exclude_pair=last_pair_val)
             if random.random() < 0.5:
                 a, b = b, a
             ensure_models_loaded()
@@ -912,10 +973,10 @@ def create_demo() -> gr.Blocks:
                 gr.update(interactive=True),
                 gr.update(visible=False),
                 a, b, False, user_prompt, (a, b),
-                leaderboard_dataframe(load_elo())
+                leaderboard_dataframe(load_elo(spec), spec)
             )
 
-        def on_vote(choice: str, model_a: str, model_b: str, resp_a: str, resp_b: str, user_prompt: str, voted: bool):
+        def on_vote(spec: ArenaSpec, choice: str, model_a: str, model_b: str, resp_a: str, resp_b: str, user_prompt: str, voted: bool):
             if voted or not model_a or not model_b:
                 return (
                     gr.update(visible=False),
@@ -927,7 +988,7 @@ def create_demo() -> gr.Blocks:
                     gr.update(interactive=False),
                     gr.update(visible=False),
                     voted,
-                    leaderboard_dataframe(load_elo())
+                    leaderboard_dataframe(load_elo(spec), spec)
                 )
             if choice == "A":
                 winner = model_a
@@ -949,37 +1010,37 @@ def create_demo() -> gr.Blocks:
                 winner = model_b
                 win_label = "B"
                 chosen = "B"
-            state = load_elo()
+            state = load_elo(spec)
             ra_before = state[model_a]["rating"]
             rb_before = state[model_b]["rating"]
-            update_elo(state, model_a, model_b, winner)
+            update_elo(state, model_a, model_b, winner, spec)
             ra_after = state[model_a]["rating"]
             rb_after = state[model_b]["rating"]
             delta_a = ra_after - ra_before
             delta_b = rb_after - rb_before
-            reveal_a_text = f"**Model A:** `{model_a}` ({MODEL_DISPLAY.get(model_a, model_a)}) — ELO {ra_after:.1f} ({delta_a:+.1f})"
-            reveal_b_text = f"**Model B:** `{model_b}` ({MODEL_DISPLAY.get(model_b, model_b)}) — ELO {rb_after:.1f} ({delta_b:+.1f})"
+            reveal_a_text = f"**Model A:** `{model_a}` ({spec.display.get(model_a, model_a)}) — ELO {ra_after:.1f} ({delta_a:+.1f})"
+            reveal_b_text = f"**Model B:** `{model_b}` ({spec.display.get(model_b, model_b)}) — ELO {rb_after:.1f} ({delta_b:+.1f})"
             if choice == "Tie":
                 status_text = (
                     f"You voted **Tie**: no winner\n\n"
-                    f"**ELO update:** {MODEL_DISPLAY.get(model_a, model_a)} {ra_before:.1f} → {ra_after:.1f} ({delta_a:+.1f}) | "
-                    f"{MODEL_DISPLAY.get(model_b, model_b)} {rb_before:.1f} → {rb_after:.1f} ({delta_b:+.1f})"
+                    f"**ELO update:** {spec.display.get(model_a, model_a)} {ra_before:.1f} → {ra_after:.1f} ({delta_a:+.1f}) | "
+                    f"{spec.display.get(model_b, model_b)} {rb_before:.1f} → {rb_after:.1f} ({delta_b:+.1f})"
                 )
             elif choice == "Both Bad":
                 status_text = (
                     f"You voted **Both Bad**: no winner\n\n"
-                    f"**ELO update:** {MODEL_DISPLAY.get(model_a, model_a)} {ra_before:.1f} → {ra_after:.1f} ({delta_a:+.1f}) | "
-                    f"{MODEL_DISPLAY.get(model_b, model_b)} {rb_before:.1f} → {rb_after:.1f} ({delta_b:+.1f})"
+                    f"**ELO update:** {spec.display.get(model_a, model_a)} {ra_before:.1f} → {ra_after:.1f} ({delta_a:+.1f}) | "
+                    f"{spec.display.get(model_b, model_b)} {rb_before:.1f} → {rb_after:.1f} ({delta_b:+.1f})"
                 )
             else:
                 status_text = (
                     f"You voted **{win_label}**: the winner is `{winner}`\n\n"
-                    f"**ELO update:** {MODEL_DISPLAY.get(model_a, model_a)} {ra_before:.1f} → {ra_after:.1f} ({delta_a:+.1f}) | "
-                    f"{MODEL_DISPLAY.get(model_b, model_b)} {rb_before:.1f} → {rb_after:.1f} ({delta_b:+.1f})"
+                    f"**ELO update:** {spec.display.get(model_a, model_a)} {ra_before:.1f} → {ra_after:.1f} ({delta_a:+.1f}) | "
+                    f"{spec.display.get(model_b, model_b)} {rb_before:.1f} → {rb_after:.1f} ({delta_b:+.1f})"
                 )
             # Log chat to data/chats.jsonl
-            log_battle(user_prompt, model_a, model_b, resp_a, resp_b, chosen, winner)
-            df = leaderboard_dataframe(state)
+            log_battle(spec, user_prompt, model_a, model_b, resp_a, resp_b, chosen, winner)
+            df = leaderboard_dataframe(state, spec)
             return (
                 gr.update(value=reveal_a_text, visible=True),
                 gr.update(value=reveal_b_text, visible=True),
@@ -1024,67 +1085,40 @@ def create_demo() -> gr.Blocks:
                 "", "", False, ""
             )
 
-        def on_refresh():
-            return leaderboard_dataframe(load_elo())
-
-        submit_btn.click(
-            fn=on_submit,
-            inputs=[prompt, last_pair],
-            outputs=[response_a, response_b, reveal_a, reveal_b, status, vote_a, vote_tie, vote_both_bad, vote_b, new_round_btn, model_a_state, model_b_state, voted_state, prompt_state, last_pair, leaderboard],
-        )
+        def on_refresh(spec: ArenaSpec):
+            return leaderboard_dataframe(load_elo(spec), spec)
 
-        prompt.submit(
-            fn=on_submit,
-            inputs=[prompt, last_pair],
-            outputs=[response_a, response_b, reveal_a, reveal_b, status, vote_a, vote_tie, vote_both_bad, vote_b, new_round_btn, model_a_state, model_b_state, voted_state, prompt_state, last_pair, leaderboard],
-        )
+        for spec in (MAIN_ARENA, BASE_ARENA):
+            u, b = ui[spec.key], lb[spec.key]
+            round_outputs = [u["response_a"], u["response_b"], u["reveal_a"], u["reveal_b"], u["status"], u["vote_a"], u["vote_tie"], u["vote_both_bad"], u["vote_b"], u["new_round_btn"], u["model_a_state"], u["model_b_state"], u["voted_state"], u["prompt_state"]]
+            submit_outputs = round_outputs + [u["last_pair"], b["leaderboard"]]
+            vote_outputs = [u["reveal_a"], u["reveal_b"], u["status"], u["vote_a"], u["vote_tie"], u["vote_both_bad"], u["vote_b"], u["new_round_btn"], u["voted_state"], b["leaderboard"]]
 
-        vote_a.click(
-            fn=lambda ma, mb, ra, rb, pr, vd: on_vote("A", ma, mb, ra, rb, pr, vd),
-            inputs=[model_a_state, model_b_state, response_a, response_b, prompt_state, voted_state],
-            outputs=[reveal_a, reveal_b, status, vote_a, vote_tie, vote_both_bad, vote_b, new_round_btn, voted_state, leaderboard],
-        )
-        vote_tie.click(
-            fn=lambda ma, mb, ra, rb, pr, vd: on_vote("Tie", ma, mb, ra, rb, pr, vd),
-            inputs=[model_a_state, model_b_state, response_a, response_b, prompt_state, voted_state],
-            outputs=[reveal_a, reveal_b, status, vote_a, vote_tie, vote_both_bad, vote_b, new_round_btn, voted_state, leaderboard],
-        )
-        vote_both_bad.click(
-            fn=lambda ma, mb, ra, rb, pr, vd: on_vote("Both Bad", ma, mb, ra, rb, pr, vd),
-            inputs=[model_a_state, model_b_state, response_a, response_b, prompt_state, voted_state],
-            outputs=[reveal_a, reveal_b, status, vote_a, vote_tie, vote_both_bad, vote_b, new_round_btn, voted_state, leaderboard],
-        )
-        vote_b.click(
-            fn=lambda ma, mb, ra, rb, pr, vd: on_vote("B", ma, mb, ra, rb, pr, vd),
-            inputs=[model_a_state, model_b_state, response_a, response_b, prompt_state, voted_state],
-            outputs=[reveal_a, reveal_b, status, vote_a, vote_tie, vote_both_bad, vote_b, new_round_btn, voted_state, leaderboard],
-        )
-
-        new_round_btn.click(
-            fn=on_new_round,
-            inputs=[],
-            outputs=[response_a, response_b, reveal_a, reveal_b, status, vote_a, vote_tie, vote_both_bad, vote_b, new_round_btn, model_a_state, model_b_state, voted_state, prompt_state],
-        )
-        clear_btn.click(
-            fn=on_clear,
-            inputs=[],
-            outputs=[prompt, response_a, response_b, reveal_a, reveal_b, status, vote_a, vote_tie, vote_both_bad, vote_b, new_round_btn, model_a_state, model_b_state, voted_state, prompt_state],
-        )
-
-        refresh_btn.click(fn=on_refresh, inputs=[], outputs=[leaderboard])
+            u["submit_btn"].click(
+                fn=lambda p, lp, s=spec: on_submit(s, p, lp),
+                inputs=[u["prompt"], u["last_pair"]],
+                outputs=submit_outputs,
+            )
+            u["prompt"].submit(
+                fn=lambda p, lp, s=spec: on_submit(s, p, lp),
+                inputs=[u["prompt"], u["last_pair"]],
+                outputs=submit_outputs,
+            )
+            for btn, choice in ((u["vote_a"], "A"), (u["vote_tie"], "Tie"), (u["vote_both_bad"], "Both Bad"), (u["vote_b"], "B")):
+                btn.click(
+                    fn=lambda ma, mb, ra, rb, pr, vd, c=choice, s=spec: on_vote(s, c, ma, mb, ra, rb, pr, vd),
+                    inputs=[u["model_a_state"], u["model_b_state"], u["response_a"], u["response_b"], u["prompt_state"], u["voted_state"]],
+                    outputs=vote_outputs,
+                )
+            u["new_round_btn"].click(fn=on_new_round, inputs=[], outputs=round_outputs)
+            u["clear_btn"].click(fn=on_clear, inputs=[], outputs=[u["prompt"]] + round_outputs)
+            b["refresh_btn"].click(fn=lambda s=spec: on_refresh(s), inputs=[], outputs=[b["leaderboard"]])
+            b["tab"].select(fn=lambda s=spec: on_refresh(s), inputs=[], outputs=[b["leaderboard"]])
 
-        # Refresh when Leaderboard tab is selected (fixes stale df_init)
-        # Also refresh on page load but without global spinner (demo.load caused "loading..." until refresh when bucket slow)
         try:
-            leaderboard_tab.select(fn=on_refresh, inputs=[], outputs=[leaderboard])
+            demo.load(fn=lambda: on_refresh(MAIN_ARENA), inputs=[], outputs=[lb["main"]["leaderboard"]], show_progress="hidden")
         except Exception:
             pass
-        # Page-load refresh without blocking UI (hidden progress)
-        try:
-            demo.load(fn=on_refresh, inputs=[], outputs=[leaderboard], show_progress="hidden")
-        except Exception:
-            # Fallback: no page-load auto-refresh, rely on tab select + initial df_init (now dynamic via get_data_dir)
-            pass
 
     return demo
 
@@ -1093,8 +1127,8 @@ def create_demo() -> gr.Blocks:
 # ---------------------------------------------------------------------------
 if __name__ == "__main__":
     print("=" * 60)
-    print("SLM Arena starting, attempting to load 4 models...")
-    print(f"Models: {MODEL_IDS}")
+    print(f"SLM Arena starting, attempting to load {len(MODEL_IDS) + len(BASE_MODEL_IDS)} models on {DEVICE}...")
+    print(f"Models: {MODEL_IDS + BASE_MODEL_IDS}")
     print(f"Data dir: {get_data_dir().resolve()} (bucket /data if mounted)")
     print("=" * 60)
     try:
@@ -1102,12 +1136,16 @@ if __name__ == "__main__":
     except Exception as e:
         logger.error(f"Model loading encountered error: {e}")
     try:
-        df = leaderboard_dataframe(load_elo())
-        print(df.to_string(index=False))
-        print(f"\nChat log: {get_chat_file().resolve()} (exists={get_chat_file().exists()})")
-        if get_chat_file().exists():
-            with open(get_chat_file()) as f:
-                lines = sum(1 for _ in f)
+        for spec in (MAIN_ARENA, BASE_ARENA):
+            df = leaderboard_dataframe(load_elo(spec), spec)
+            print(df.to_string(index=False))
+            chat_path = get_chat_file(spec.chat_name)
+            print(f"\nChat log: {chat_path.resolve()} (exists={chat_path.exists()})")
+            if chat_path.exists():
+                with open(chat_path) as f:
+                    lines = sum(1 for _ in f)
+            else:
+                lines = 0
             print(f"Previous battles logged: {lines}")
     except Exception as e:
         logger.warning(f"Leaderboard preview failed: {e}")