Upload folder using huggingface_hub

README.md

@@ -1,10 +1,12 @@
 ---
-title: LanguageBridge — Math Hybrid (Phi + SymPy)
+title: LanguageBridge — Math Fast Agent (SymPy)
 emoji: 🧮
 colorFrom: yellow
-colorTo: blue
+colorTo: gray
 sdk: gradio
 sdk_version: "4.44.1"
 app_file: app.py
 pinned: false
 ---
+
+純 SymPy 的數學推理代理（不依賴 LLM），支援一次貼上長式、簡化、解一元/聯立方程。

app.py

@@ -1,136 +1,68 @@
-
-import os, re, time
+\
 import gradio as gr
 import sympy as sp
 
-TITLE = "LanguageBridge — Math Hybrid (Phi + SymPy)"
-
-DEFAULT_MODEL_ID = os.environ.get("MODEL_ID", "microsoft/phi-2")
-MAX_NEW_TOKENS   = int(os.environ.get("MAX_NEW_TOKENS", "96"))
+TITLE = "LanguageBridge — Math Fast Agent (SymPy)"
 
-_llm = None
-_tok = None
-
-def _try_load_llm():
-    global _llm, _tok
-    if _llm is not None:
-        return True
-    try:
-        import torch
-        from transformers import AutoModelForCausalLM, AutoTokenizer
-        _tok = AutoTokenizer.from_pretrained(DEFAULT_MODEL_ID, use_fast=True)
-        _llm = AutoModelForCausalLM.from_pretrained(
-            DEFAULT_MODEL_ID,
-            torch_dtype=torch.float32,
-            device_map="auto"
-        )
-        return True
-    except Exception:
-        _llm = None
-        _tok = None
-        return False
-
-def _llm_parse_to_math(text):
-    # Rewrite user text to algebraic expression(s); fallback to original text
-    if not _try_load_llm():
-        return text
-    import torch
-    from transformers import AutoTokenizer
-    prompt = (
-        "Rewrite the following math question as a pure algebraic expression "
-        "or semicolon-separated equations suitable for SymPy. "
-        "Return only the expression/equations without explanations.\n\n"
-        f"Question:\n{text}\n\nExpression:\n"
-    )
-    ids = _tok(prompt, return_tensors="pt").input_ids.to(_llm.device)
-    gen = _llm.generate(
-        ids,
-        max_new_tokens=MAX_NEW_TOKENS,
-        do_sample=False,
-        pad_token_id=_tok.eos_token_id
-    )
-    out = _tok.decode(gen[0], skip_special_tokens=True)
-    if "Expression:" in out:
-        out = out.split("Expression:", 1)[-1].strip()
-    out = out.replace("^", "**").strip()
-    return out or text
-
-def _solve_with_sympy(q):
+def solve_math(q: str):
     q = (q or "").strip()
     if not q:
-        return "Please enter an expression or equations. Example: 2*x + 5 = 11; or: sin(x)**2 + cos(x)**2"
-
-    if "=" in q:
-        parts = []
-        for seg in q.split(";"):
-            parts.extend([s for s in seg.split("\n")])
-        eqs = []
-        syms = set()
-        for s in [p.strip() for p in parts if p.strip()]:
-            if "=" not in s:
-                expr = sp.sympify(s)
-                eqs.append(sp.Eq(expr, 0))
-                syms |= expr.free_symbols
-                continue
-            left, right = s.split("=", 1)
-            L = sp.sympify(left)
-            R = sp.sympify(right)
-            eqs.append(sp.Eq(L, R))
-            syms |= L.free_symbols
-            syms |= R.free_symbols
-        if not syms:
-            syms = {sp.symbols("x")}
-        sol = sp.solve(eqs, list(syms), dict=True)
-        if not sol:
-            return "No solution or more conditions are required."
-        lines = []
-        for i, d in enumerate(sol, 1):
-            pretty = ", ".join([f"{k} = {sp.simplify(v)}" for k, v in d.items()])
-            lines.append(f"Solution {i}: {pretty}")
-        return "\n".join(lines)
-
+        return "請輸入算式或方程，例如：2x+3=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
+                if "=" not in 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:
+                x = sp.symbols("x")
+                syms = {x}
+            sol = sp.solve(eqs, list(syms), dict=True)
+            if not sol:
+                return "無解或需要更多條件。"
+            lines = []
+            for i, s in enumerate(sol, 1):
+                lines.append(f"解 {i}: " + ", ".join([f"{k} = {sp.simplify(v)}" for k, v in s.items()]))
+            return "\n".join(lines)
+
+        # 非方程：做一輪常見操作
         expr = sp.sympify(q)
+        tips = []
+        try:
+            tips.append(f"簡化：{sp.simplify(expr)}")
+        except Exception:
+            tips.append(f"簡化：{expr}")
+        try:
+            fact = sp.factor(expr)
+            if fact != expr:
+                tips.append(f"因式分解：{fact}")
+        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
+        return "\n".join(tips) if tips else f"結果：{expr}"
     except Exception as e:
-        return f"SymPy parse failed: {e}"
-
-    tips = []
-    try:
-        tips.append(f"Simplify: {sp.simplify(expr)}")
-    except Exception:
-        pass
-    try:
-        fac = sp.factor(expr)
-        if fac != expr:
-            tips.append(f"Factor: {fac}")
-    except Exception:
-        pass
-    try:
-        x = list(expr.free_symbols)[0] if expr.free_symbols else sp.symbols("x")
-        tips.append(f"d/d{x}: {sp.diff(expr, x)}")
-        tips.append(f"integrate wrt {x}: {sp.integrate(expr, x)}")
-    except Exception:
-        pass
-    return "\n".join(tips) if tips else f"Result: {expr}"
-
-def hybrid_solve(user_text, use_llm):
-    text = (user_text or "").strip()
-    if not text:
-        return "Please enter an expression or problem statement."
-    if use_llm:
-        normalized = _llm_parse_to_math(text)
-        header = f"LLM normalized -> {normalized}\n---\n"
-        return header + _solve_with_sympy(normalized)
-    else:
-        return _solve_with_sympy(text)
+        return f"解析失敗：{e}"
 
 with gr.Blocks(title=TITLE) as demo:
-    gr.Markdown(f"## {TITLE}\nPaste text or math: LLM helps rewrite -> SymPy solves (optional).")
-    q = gr.Textbox(lines=6, label="Problem / Expression (semicolon or newline for systems)")
-    use_llm = gr.Checkbox(value=False, label="Use Phi-2 to normalize text first (optional)")
-    out = gr.Textbox(lines=12, label="Output")
-    btn = gr.Button("Solve", variant="primary")
-    btn.click(hybrid_solve, inputs=[q, use_llm], outputs=out, concurrency_limit=1)
+    gr.Markdown(f"## {TITLE}\n貼上算式（可多行 / 用分號 `;` 分隔）：")
+    q = gr.Textbox(lines=6, label="題目 / 算式（可含聯立方程）")
+    out = gr.Textbox(lines=10, label="輸出")
+    gr.Button("送出 🚀").click(fn=solve_math, inputs=q, outputs=out)
 
 if __name__ == "__main__":
     demo.launch()

requirements.txt

@@ -1,7 +1,3 @@
 gradio==4.44.1
-huggingface_hub==0.23.5
 sympy>=1.12
-torch==2.4.1
-transformers==4.44.2
-accelerate==0.34.2
-safetensors>=0.4.4
+huggingface_hub==0.23.4