Upload folder using huggingface_hub

README.md

@@ -9,9 +9,5 @@ app_file: app.py
 pinned: false
 ---
 
-一個**小型 LLM（Phi-2 / Phi-3-mini）+ SymPy** 的數學混合推理 Space：  
-- LLM：把**文字題**解析為可計算的數學式或步驟  
-- SymPy：遇到**可符號計算**的部分（方程、微積分、因式分解…）直接算出精準解  
-- 自動偵測：若輸入就是算式/方程 → 直接 SymPy；否則走 LLM→SymPy 流程
-
-> 預設模型：`microsoft/phi-2`（可在 app.py 換成你喜歡的小型模型）
+混合路線：**先用 SymPy 嘗試直接解/化簡**（極快）；必要時再用 **Phi-2** 做文字→步驟→答案補齊。  
+若延遲偏高，可在介面取消勾選「啟用 LLM」，就只走 SymPy（即時回覆）。

app.py

@@ -1,181 +1,141 @@
-import os, sys, re, json
+import os, re, torch
 import gradio as gr
 import sympy as sp
-
-from transformers import (
-    AutoTokenizer, AutoModelForCausalLM, pipeline
-)
-
-TITLE = "LanguageBridge — Math Hybrid (Phi + SymPy)"
-MODEL_ID = "microsoft/phi-2"
-MAX_NEW_TOKENS = 512
-
-def try_sympy_direct(q: str):
-    """若使用者輸入就是算式/方程，走 SymPy 精準計算。支援多行 / 分號分隔 / 聯立。"""
-    q = (q or "").strip()
-    if not q:
-        return None
-
-    # 粗略偵測：若含 = 或 明顯算式符號
-    if any(s in q for s in ["=", "+", "-", "*", "/", "^", "sin", "cos", "tan", "log", "sqrt", "∫", "d/dx"]):
+from functools import lru_cache
+
+# 允許用環境變數覆蓋
+MODEL_ID = os.getenv("MODEL_ID", "microsoft/phi-2")
+
+USE_CUDA = torch.cuda.is_available()
+DTYPE    = torch.float16 if USE_CUDA else torch.float32
+
+model = None
+tok   = None
+
+def _load_model_once():
+    global model, tok
+    if model is not None:
+        return
+    from transformers import AutoTokenizer, AutoModelForCausalLM
+    kwargs = dict(torch_dtype=DTYPE, low_cpu_mem_usage=True, trust_remote_code=False)
+    if USE_CUDA:
+        kwargs["device_map"] = "auto"
+        kwargs["attn_implementation"] = "sdpa"
+        # 優先嘗試 4bit（若後端不支援會自動回退）
         try:
-            # 支援多式/聯立：以分號或換行切
-            parts = [s.strip() for seg in q.split(";") for s in seg.split("\n")]
-            eqs, syms = [], set()
-            for s in parts:
-                if not s: 
-                    continue
-                if "=" in s:
-                    left, right = s.split("=", 1)
-                    eq = sp.Eq(sp.sympify(left), sp.sympify(right))
-                    eqs.append(eq)
-                    syms |= eq.free_symbols
-                    syms |= eq.rhs.free_symbols if hasattr(eq, "rhs") else set()
-                else:
-                    # 非方程，當作一般表達式，做一輪常見操作
-                    expr = sp.sympify(s)
-                    tips = []
-                    try:
-                        tips.append(f"簡化：{sp.simplify(expr)}")
-                    except Exception:
-                        pass
-                    try:
-                        x = list(expr.free_symbols)[0] if expr.free_symbols else sp.symbols("x")
-                        tips.append(f"對 {x} 微分：{sp.diff(expr, x)}")
-                        tips.append(f"對 {x} 積分：{sp.integrate(expr, x)}")
-                    except Exception:
-                        pass
-                    if tips:
-                        return "\n".join(tips)  # 只要有一行就回傳
-                    else:
-                        return f"結果：{expr}"
-
-            if eqs:
-                if not syms:
-                    x = sp.symbols("x")
-                    syms = {x}
-                sol = sp.solve(eqs, list(syms), dict=True)
-                if not sol:
-                    return "SymPy：無解或需要更多條件。"
-                lines = []
-                for i, sdict in enumerate(sol, 1):
-                    lines.append("解 {}: ".format(i) + ", ".join([f"{k} = {sp.simplify(v)}" for k, v in sdict.items()]))
-                return "\n".join(lines)
-
-        except Exception as e:
-            # 交給 LLM 流程
-            return None
-
-    return None
-
-
-def build_llm():
-    """嘗試以 4-bit 啟動（有 CUDA 時），否則退回 CPU。"""
-    import torch
-    has_cuda = torch.cuda.is_available()
-    load_kwargs = {"device_map":"auto"}
-
-    if has_cuda:
-        try:
-            import bitsandbytes as bnb  # 檢查有無 bnb
-            load_kwargs.update({"load_in_4bit": True})
+            kwargs.update(dict(
+                load_in_4bit=True,
+                bnb_4bit_compute_dtype=torch.float16,
+                bnb_4bit_quant_type="nf4",
+                bnb_4bit_use_double_quant=True,
+            ))
         except Exception:
-            # 沒有 bnb 就用 fp16
-            load_kwargs.update({"torch_dtype": torch.float16})
-    else:
-        # CPU：讓 transformers 自行決定 dtype
-        pass
-
-    tok = AutoTokenizer.from_pretrained(MODEL_ID, trust_remote_code=True)
+            pass
+    tok = AutoTokenizer.from_pretrained(MODEL_ID)
     if tok.pad_token_id is None and tok.eos_token_id is not None:
         tok.pad_token = tok.eos_token
+    model = AutoModelForCausalLM.from_pretrained(MODEL_ID, **kwargs)
+    model.eval()
+    try:
+        _ = infer_llm("Solve: 2x+5=11 → x = ?", max_new_tokens=8)
+    except Exception:
+        pass
 
-    mdl = AutoModelForCausalLM.from_pretrained(
-        MODEL_ID,
-        trust_remote_code=True,
-        **load_kwargs
-    )
-
-    pipe = pipeline(
-        "text-generation",
-        model=mdl,
-        tokenizer=tok,
-        do_sample=False,
-        max_new_tokens=MAX_NEW_TOKENS,
-        temperature=0.2,
-        top_p=0.9
-    )
-    return pipe
-
-LLM = None
-
-SYSTEM_PROMPT = (
-    "You are a math teacher. When the user asks a word problem,\n"
-    "1) parse it into a clean mathematical expression or a system of equations;\n"
-    "2) if it is solvable by SymPy, output a single line starting with 'SymPy:' followed by a Python/SymPy expression;\n"
-    "3) then give a concise final answer on the next line starting with 'Answer:'."
-)
-
-def llm_to_sympy_and_answer(pipe, q: str):
-    prompt = (
-        f"<s>System:\n{SYSTEM_PROMPT}\n</s>\n"
-        f"User: {q}\n"
-        f"Assistant:"
-    )
-    out = pipe(prompt, pad_token_id=pipe.tokenizer.eos_token_id)[0]["generated_text"]
-    # 嘗試抓 SymPy: 行
-    sym_line = None
-    ans_line = None
-    for line in out.splitlines():
-        if line.strip().startswith("SymPy:"):
-            sym_line = line.split("SymPy:",1)[-1].strip()
-        if line.strip().startswith("Answer:"):
-            ans_line = line.split("Answer:",1)[-1].strip()
-
-    checked = ""
-    if sym_line:
-        try:
-            val = eval(sym_line, {"sp": sp, "sympy": sp})
-            # 若是可列印的結果（非方程），試著數值化或簡化
-            if isinstance(val, (int, float, sp.Basic)):
-                checked = f"SymPy 檢算：{sp.simplify(val)}"
-        except Exception as e:
-            checked = f"SymPy 檢算失敗：{e}"
-
-    merge = []
-    if sym_line: merge.append(f"SymPy: {sym_line}")
-    if ans_line: merge.append(f"Answer: {ans_line}")
-    if checked:  merge.append(checked)
-    return "\n".join(merge) if merge else out
-
+@lru_cache(maxsize=64)
+def _looks_like_math(s: str) -> bool:
+    return bool(re.search(r"[=+\-*/^()]|sin|cos|tan|sqrt|\^|\d", s or ""))
 
-def solve(q: str):
-    global LLM
+def _try_sympy_first(q: str):
     q = (q or "").strip()
     if not q:
-        return "請輸入題目或算式。"
-
-    # 1) 先嘗試 SymPy 直接處理
-    direct = try_sympy_direct(q)
-    if direct:
-        return direct
-
-    # 2) 走 LLM → SymPy
-    if LLM is None:
-        LLM = build_llm()
+        return None
+    # 先處理「聯立/多行」：分號或換行分割
+    parts = [p.strip() for seg in q.split(";") for p in seg.split("\n")]
+    eqs, syms = [], set()
+    for s in parts:
+        if not s:
+            continue
+        if "=" in s:
+            L, R = s.split("=", 1)
+            eq = sp.Eq(sp.sympify(L), sp.sympify(R))
+            eqs.append(eq)
+            syms |= eq.free_symbols
+            if hasattr(eq, "rhs"):
+                syms |= eq.rhs.free_symbols
+    if eqs:
+        if not syms:
+            syms = {sp.symbols("x")}
+        sol = sp.solve(eqs, list(syms), dict=True)
+        if sol:
+            lines = []
+            for i, s in enumerate(sol, 1):
+                lines.append("解 {}: ".format(i) + ", ".join([f"{k} = {sp.simplify(v)}" for k, v in s.items()]))
+            return "\n".join(lines)
+        return "無解或需要更多條件。"
+
+    # 非方程：嘗試化簡 / 微分 / 積分建議
     try:
-        return llm_to_sympy_and_answer(LLM, q)
-    except Exception as e:
-        return f"[LLM流程失敗] {e}"
+        expr = sp.sympify(q)
+        tips = []
+        try:
+            tips.append(f"簡化：{sp.simplify(expr)}")
+        except Exception:
+            pass
+        try:
+            x = list(expr.free_symbols)[0] if expr.free_symbols else sp.symbols("x")
+            tips.append(f"對 {x} 微分：{sp.diff(expr, x)}")
+            tips.append(f"對 {x} 積分：{sp.integrate(expr, x)}")
+        except Exception:
+            pass
+        if tips:
+            return "\n".join(tips)
+    except Exception:
+        pass
+    return None
 
-with gr.Blocks(title=TITLE) as demo:
-    gr.Markdown(f"## {TITLE}\n貼上文字題或算式：LLM 解析 → SymPy 精算（可聯立）")
-    with gr.Row():
-        q = gr.Textbox(label="題目 / 算式", lines=8, placeholder="例如：一個數加上 5 等於 11，求這個數。\n或：2*x + 5 = 11；或：sin(x)**2 + cos(x)**2")
+SYS = "You are a concise math parser. Return minimal steps and a final boxed answer."
+def build_prompt(q: str):
+    return f"{SYS}\nQuestion: {q}\nAnswer:"
+
+def infer_llm(prompt: str, max_new_tokens=64):
+    _load_model_once()
+    inputs = tok(prompt, return_tensors="pt").to(model.device)
+    with torch.inference_mode():
+        out = model.generate(
+            **inputs,
+            max_new_tokens=max_new_tokens,
+            do_sample=False,
+            temperature=0.2,
+            top_p=0.9,
+            repetition_penalty=1.05,
+            use_cache=True,
+            eos_token_id=tok.eos_token_id,
+            pad_token_id=tok.eos_token_id,
+        )
+    return tok.decode(out[0], skip_special_tokens=True)
+
+def hybrid_solve(q, use_llm=True, max_new_tokens=64):
+    # 1) 先試 SymPy（極快）
+    ans = _try_sympy_first(q)
+    if ans is not None:
+        return ans
+    # 2) 再用 LLM（需要算力）
+    if not use_llm:
+        return "（已關閉 LLM）請提供可由 SymPy 直接處理的算式/方程。"
+    if not _looks_like_math(q):
+        return "請貼數學���或方程；一般文字可能造成延遲。"
+    return infer_llm(build_prompt(q), max_new_tokens=max_new_tokens).strip()
+
+with gr.Blocks(title="LanguageBridge — Math Hybrid (Phi + SymPy)") as demo:
+    gr.Markdown("貼上文字或算式：LLM 解析 → SymPy 寫算（可聯立）")
+    q = gr.Textbox(lines=6, label="題目 / 算式（可含聯立）")
     with gr.Row():
-        out = gr.Textbox(label="輸出", lines=12)
+        use_llm = gr.Checkbox(value=True, label="啟用 LLM（慢時可關，只走 SymPy）")
+        mx_tok  = gr.Slider(16, 128, value=64, step=8, label="max_new_tokens")
+    out = gr.Textbox(lines=12, label="輸出")
     btn = gr.Button("送出 🚀")
-    btn.click(fn=solve, inputs=q, outputs=out)
+    btn.click(hybrid_solve, inputs=[q, use_llm, mx_tok], outputs=out)
+    gr.Markdown("**小秘訣**：短提示、明確格式、能用等號就用等號（SymPy 快很多）。")
 
-if __name__ == "__main__":
-    demo.launch()
+# queue 可同時處理 2 個請求；Spaces 後端較慢時可調小
+demo.queue(concurrency_count=2).launch()

requirements.txt

@@ -1,10 +1,4 @@
 gradio==4.44.1
-transformers==4.44.2
-accelerate>=0.31.0
-bitsandbytes==0.43.3
-sentencepiece
 sympy>=1.12
-huggingface_hub>=0.24.0
-safetensors
-einops
-numpy<2
+huggingface_hub==0.24.0
+transformers==4.44.2