Upload app.py with huggingface_hub

app.py

@@ -6,8 +6,25 @@ import gradio as gr
 from transformers import AutoModelForCausalLM, AutoTokenizer
 from peft import PeftModel
 
-BASE_MODEL = "Qwen/Qwen3-8B"
-ADAPTER = "hikewa/dialectic-qwen3-8b-lora"
+MODELS = {
+    "Qwen3-8B (best)": {
+        "base": "Qwen/Qwen3-8B",
+        "adapter": "hikewa/dialectic-qwen3-8b-lora",
+    },
+    "Qwen3-4B": {
+        "base": "Qwen/Qwen3-4B",
+        "adapter": "hikewa/dialectic-qwen3-4b-lora",
+    },
+    "Qwen2.5-1.5B": {
+        "base": "Qwen/Qwen2.5-1.5B-Instruct",
+        "adapter": "hikewa/dialectic-qwen2.5-1.5b-lora",
+    },
+    "Qwen2.5-0.5B": {
+        "base": "Qwen/Qwen2.5-0.5B-Instruct",
+        "adapter": "hikewa/dialectic-qwen2.5-0.5b-lora",
+    },
+}
+
 SYSTEM_PROMPT = (
     "You reason carefully through problems by considering competing "
     "perspectives before reaching a conclusion. You identify genuine "
@@ -15,30 +32,40 @@ SYSTEM_PROMPT = (
     "integrate insights rather than picking sides or hedging."
 )
 
-model = None
-tokenizer = None
+loaded = {"name": None, "model": None, "tokenizer": None}
 
 
-def load_model():
-    global model, tokenizer
-    if model is not None:
-        return
+def load_model(model_name):
+    global loaded
+    if loaded["name"] == model_name:
+        return loaded["model"], loaded["tokenizer"]
 
-    tokenizer = AutoTokenizer.from_pretrained(ADAPTER, trust_remote_code=True)
+    # Free previous model
+    if loaded["model"] is not None:
+        del loaded["model"]
+        loaded["model"] = None
+        torch.cuda.empty_cache()
 
+    cfg = MODELS[model_name]
+    tokenizer = AutoTokenizer.from_pretrained(
+        cfg["adapter"], trust_remote_code=True
+    )
     base = AutoModelForCausalLM.from_pretrained(
-        BASE_MODEL,
-        torch_dtype=torch.float16,
-        trust_remote_code=True,
+        cfg["base"], torch_dtype=torch.float16, trust_remote_code=True
     )
-    model = PeftModel.from_pretrained(base, ADAPTER)
+    model = PeftModel.from_pretrained(base, cfg["adapter"])
     model = model.to("cuda")
     model.eval()
 
+    loaded["name"] = model_name
+    loaded["model"] = model
+    loaded["tokenizer"] = tokenizer
+    return model, tokenizer
+
 
 @spaces.GPU
-def respond(message, history):
-    load_model()
+def respond(message, history, model_name):
+    model, tokenizer = load_model(model_name)
 
     messages = [{"role": "system", "content": SYSTEM_PROMPT}]
     for msg in history:
@@ -72,16 +99,22 @@ def respond(message, history):
 
 demo = gr.ChatInterface(
     respond,
-    title="Dialectic Reasoning Model",
+    additional_inputs=[
+        gr.Dropdown(
+            choices=list(MODELS.keys()),
+            value="Qwen3-8B (best)",
+            label="Model",
+        ),
+    ],
+    title="Dialectic Reasoning Models",
     description=(
-        "A Qwen3-8B model fine-tuned on 510 dialectic reasoning traces. "
-        "It considers competing perspectives, identifies genuine tensions, "
-        "and integrates insights rather than picking sides."
+        "Fine-tuned on 510 dialectic reasoning traces. "
+        "Pick a model size and ask a question involving competing perspectives."
     ),
     examples=[
-        "Should AI systems be transparent about their reasoning, even when transparency reduces performance?",
-        "Is it better to optimize for individual freedom or collective wellbeing?",
-        "When does pragmatic compromise become unprincipled capitulation?",
+        ["Should AI systems be transparent about their reasoning, even when transparency reduces performance?"],
+        ["Is it better to optimize for individual freedom or collective wellbeing?"],
+        ["When does pragmatic compromise become unprincipled capitulation?"],
     ],
 )