Upload folder using huggingface_hub

README.md

@@ -9,5 +9,4 @@ app_file: app.py
 pinned: false
 ---
 
-混合路線：**先用 SymPy 嘗試直接解/化簡**（極快）；必要時再用 **Phi-2** 做文字→步驟→答案補齊。  
-若延遲偏高，可在介面取消勾選「啟用 LLM」，就只走 SymPy（即時回覆）。
+混合路線：先用 SymPy 精準解（代數 / 化簡 / 微積分），必要時用 Phi LLM 補步驟與敘述。

app.py

@@ -1,141 +1,123 @@
-import os, re, torch
+
+import os, re
 import gradio as gr
 import sympy as sp
-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
+TITLE    = "LanguageBridge — Math Hybrid (Phi + SymPy)"
+MODEL_ID = "microsoft/phi-2"
 
-model = None
-tok   = None
+_pipe = 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:
-            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:
-            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()
+def lazy_load_llm():
+    global _pipe
+    if _pipe is not None:
+        return _pipe
     try:
-        _ = infer_llm("Solve: 2x+5=11 → x = ?", max_new_tokens=8)
+        import torch
+        from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
+        use_cuda = torch.cuda.is_available()
+        tok = AutoTokenizer.from_pretrained(MODEL_ID, trust_remote_code=True)
+        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,
+            torch_dtype=torch.float32,
+            device_map="cuda" if use_cuda else "cpu"
+        )
+        _pipe = pipeline(
+            "text-generation",
+            model=model,
+            tokenizer=tok,
+            device=0 if use_cuda else -1
+        )
+        return _pipe
     except Exception:
-        pass
-
-@lru_cache(maxsize=64)
-def _looks_like_math(s: str) -> bool:
-    return bool(re.search(r"[=+\-*/^()]|sin|cos|tan|sqrt|\^|\d", s or ""))
+        return None
 
-def _try_sympy_first(q: str):
+def solve_with_sympy(q: str) -> str:
     q = (q or "").strip()
     if not q:
-        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:
+        return "請輸入算式或方程，例如：2x+5=11；或：sin(x)**2 + cos(x)**2；或：factor(x**2-9)"
+    try:
+        if "=" in q:
+            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
+                left, right = s.split("=", 1)
+                eq = sp.Eq(sp.sympify(left), sp.sympify(right))
+                eqs.append(eq)
+                syms |= eq.free_symbols
+                if hasattr(eq, "rhs"):
+                    syms |= eq.rhs.free_symbols
+            if not syms:
+                syms = {sp.symbols("x")}
+            sols = sp.solve(eqs, list(syms), dict=True)
+            if not sols:
+                return "（SymPy）無解或需要更多條件。"
             lines = []
-            for i, s in enumerate(sol, 1):
-                lines.append("解 {}: ".format(i) + ", ".join([f"{k} = {sp.simplify(v)}" for k, v in s.items()]))
+            for i, s in enumerate(sols, 1):
+                lines.append(f"解 {i}: " + ", ".join([f"{k} = {sp.simplify(v)}" for k, v in s.items()]))
             return "\n".join(lines)
-        return "無解或需要更多條件。"
 
-    # 非方程：嘗試化簡 / 微分 / 積分建議
-    try:
         expr = sp.sympify(q)
-        tips = []
+        out = []
         try:
-            tips.append(f"簡化：{sp.simplify(expr)}")
+            out.append(f"簡化：{sp.simplify(expr)}")
+        except Exception:
+            pass
+        try:
+            fctr = sp.factor(expr)
+            if fctr != expr:
+                out.append(f"因式分解：{fctr}")
         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)}")
+            out.append(f"對 {x} 微分：{sp.diff(expr, x)}")
+            out.append(f"對 {x} 積分：{sp.integrate(expr, x)}")
         except Exception:
             pass
-        if tips:
-            return "\n".join(tips)
-    except Exception:
-        pass
-    return None
+        return "\n".join(out) if out else f"結果：{expr}"
+    except Exception as e:
+        return f"(SymPy 解析失敗) {e}"
 
-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 hybrid_solve(q: str, max_new_tokens: int, temperature: float, top_p: float):
+    q = (q or "").strip()
+    sym = solve_with_sympy(q)
+    if sym and not sym.startswith("(SymPy 解析失敗)"):
+        return sym
 
-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)
+    pipe = lazy_load_llm()
+    if pipe is None:
+        return sym + "\n\n(提示) LLM 尚未就緒或未安裝 torch/transformers，僅回傳 SymPy 嘗試結果。"
 
-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()
+    prompt = f"請閱讀題目並用中文說明步驟，最後給出答案。\n題目：{q}\n"
+    outs = pipe(
+        prompt,
+        max_new_tokens=max_new_tokens,
+        do_sample=True if temperature>0 else False,
+        top_p=top_p,
+        temperature=temperature,
+        repetition_penalty=1.05,
+        pad_token_id=pipe.tokenizer.eos_token_id,
+    )
+    txt = outs[0]["generated_text"]
+    return txt[len(prompt):].strip()
 
-with gr.Blocks(title="LanguageBridge — Math Hybrid (Phi + SymPy)") as demo:
-    gr.Markdown("貼上文字或算式：LLM 解析 → SymPy 寫算（可聯立）")
-    q = gr.Textbox(lines=6, label="題目 / 算式（可含聯立）")
+with gr.Blocks(title=TITLE) as demo:
+    gr.Markdown(f"## {TITLE}\n貼上文字題或算式：LLM 解析 → SymPy 精算（可聯立）")
     with gr.Row():
-        use_llm = gr.Checkbox(value=True, label="啟用 LLM（慢時可關，只走 SymPy）")
-        mx_tok  = gr.Slider(16, 128, value=64, step=8, label="max_new_tokens")
+        q = gr.Textbox(lines=7, label="題目 / 算式（可含聯立方程）",
+                       placeholder="例如：一個數加 5 等於 11，求此數；\n或：2x+5=11；或：sin(x)**2+cos(x)**2")
+    with gr.Accordion("進階（LLM 生成）", open=False):
+        mx_tok = gr.Slider(32, 256, value=128, step=8, label="max_new_tokens")
+        temp   = gr.Slider(0.0, 1.2, value=0.3, step=0.05, label="temperature")
+        top_p  = gr.Slider(0.1, 1.0, value=0.9, step=0.05, label="top_p")
     out = gr.Textbox(lines=12, label="輸出")
     btn = gr.Button("送出 🚀")
-    btn.click(hybrid_solve, inputs=[q, use_llm, mx_tok], outputs=out)
-    gr.Markdown("**小秘訣**：短提示、明確格式、能用等號就用等號（SymPy 快很多）。")
+    btn.click(hybrid_solve, inputs=[q, mx_tok, temp, top_p], outputs=out)
+    gr.Markdown("**小技巧**：先輸入方程/算式讓 SymPy 直接求；純文字題會呼叫 LLM 先轉譯再解。")
 
-# queue 可同時處理 2 個請求；Spaces 後端較慢時可調小
-demo.queue(concurrency_count=2).launch()
+demo.queue(concurrency_count=1).launch()

requirements.txt

@@ -1,4 +1,8 @@
 gradio==4.44.1
 sympy>=1.12
-huggingface_hub==0.24.0
-transformers==4.44.2
+torch==2.1.2
+transformers==4.41.2
+accelerate==0.31.0
+safetensors>=0.4.3
+sentencepiece>=0.1.99
+huggingface_hub>=0.24.0