Text Classification
syfox
decision-engine
decision-making
decision-model
structured-prediction
system-one
si-substrate
intent-classification
routing
abstention
uncertainty-quantification
selective-prediction
hebbian
energy-based-model
associative-memory
no-transformer
no-neural-network
no-pattern-matching
moderation
spam-detection
multilingual
| #!/usr/bin/env python3 | |
| """Thin inference wrapper for the SyFox giant model (HuggingFace layout). | |
| from inference import SyFox | |
| m = SyFox() # loads model/giant-<script> | |
| m.decide("I was charged twice on my invoice") # router only | |
| m.decide("...") # router + domain question | |
| The Python layer only speaks JSON; every decision is made by the C++ SI | |
| substrate (energy injection -> settle -> resonance readout -> honest | |
| silence). Requires build/libsyfox_core.so (see Dockerfile or `make`). | |
| """ | |
| import json | |
| import sys | |
| from pathlib import Path | |
| _HERE = Path(__file__).resolve().parent | |
| sys.path.insert(0, str(_HERE / "server")) | |
| from syfox_bridge import SyFoxEngine, detect_script # noqa: E402 | |
| _SCHEMAS = json.load(open(_HERE / "datasets" / "schemas.json")) | |
| _DOMAINS = _SCHEMAS["domains"] | |
| _ROUTER_CRITERIA = _DOMAINS["_router"]["criteria"] | |
| class SyFox: | |
| """Auto-routing handle over the per-script giant substrates.""" | |
| def __init__(self, base: str = str(_HERE / "model" / "giant")): | |
| self.base = base | |
| self._engines: dict[str, SyFoxEngine] = {} | |
| def _engine(self, text: str) -> tuple[SyFoxEngine, str]: | |
| slug = detect_script(text) | |
| if slug in ("unknown", ""): | |
| slug = "latin" | |
| cand = Path(f"{self.base}-{slug}") | |
| if not cand.exists(): | |
| slug = "latin" | |
| cand = Path(f"{self.base}-latin") | |
| if slug not in self._engines: | |
| eng = SyFoxEngine(str(cand)) | |
| eng.set_energy_norm(True) # M1 gain: mandatory at corpus scale | |
| self._engines[slug] = eng | |
| return self._engines[slug], slug | |
| def router_question() -> dict: | |
| return {"type": "choice", "instructions": "", | |
| "criteria": _ROUTER_CRITERIA} | |
| def domain_question(domain: str) -> dict: | |
| d = _DOMAINS[domain] | |
| return {"type": "choice", "instructions": "", | |
| "criteria": d["criteria"]} | |
| def domains(self) -> list: | |
| return [d for d in _DOMAINS | |
| if not d.startswith("_") | |
| and _DOMAINS[d].get("type") != "noul_multi"] | |
| def decide(self, state: str, domain: str | None = None) -> dict: | |
| """Ask the router always; ask the domain's class question when | |
| `domain` is given. NOTE (measured): the router-only estimate is | |
| the blind condition (0.400 hidden accuracy) — naming the domain | |
| anchors the field and gives the class numbers.""" | |
| eng, slug = self._engine(state) | |
| questions = {"domain": self.router_question()} | |
| if domain: | |
| questions[_DOMAINS[domain]["qkey"]] = self.domain_question(domain) | |
| answers, usage, _ = eng.decide(state, questions, {"energy_norm": True}) | |
| out = {"script": slug, "answers": answers, | |
| "settled_energy": usage.get("settled_energy")} | |
| if domain is None and not answers["domain"].get("deferred"): | |
| chosen = answers["domain"]["choice"] | |
| for d, meta in _DOMAINS.items(): | |
| if meta.get("router_anchor") == chosen: | |
| out["suggested_domain"] = d | |
| break | |
| return out | |
| if __name__ == "__main__": | |
| m = SyFox() | |
| for s in ["I was charged twice on my last invoice, please refund.", | |
| "বাংলা সাপোর্ট প্রশ্ন: কার্ড থেকে দুইবার টাকা কেটেছে।", | |
| "The quarterback threw five touchdowns in the opener."]: | |
| r = m.decide(s) | |
| a = r["answers"]["domain"] | |
| print(f"[{r['script']:9s}] {a.get('choice')} " | |
| f"(conf {a.get('confidence', 0):.3f}" | |
| f"{', deferred' if a.get('deferred') else ''}) {s[:60]}") | |