| """AUBIN Engine — katmanlı Sistem-1 / Sistem-2 karar motoru. |
| |
| Laya tek katmanlıdır (her istek küçük bir kodlayıcıya). AUBIN Engine isteği EN UCUZ yeterli katmanda bitirir: |
| |
| K0 öğrenilmiş beceriler + bellek (AubinLearning: acquire_skill / learn) — milisaniye, yalnız kanıtlanmış soru tiplerinde |
| K1 hızlı model (ör. AUBIN-E4B, ~0.25 s/karar) |
| K2 güçlü model (ör. AUBIN-12B / 31B; isteğe bağlı akıl yürütme geçişi) |
| |
| Her katmanın kalibre güveni o katmanın eşiğini geçerse karar orada verilir; geçmezse bir üst katmana çıkılır. Son katmanda |
| da eşik tutmazsa ve `abstain=True` ise cevap "çekimser" (null) döner — yanlış ama emin cevap yerine "emin değilim". |
| Yanıt biçimi Laya/Jev istemcileriyle uyumludur: {"answers": {qid: {"choice"|"score"|"noul", "confidence", ...}}, "routing": {...}}. |
| |
| eng = AubinEngine([("fast", Aubin("emrevrg/AUBIN-E4B-Control"), 0.85), ("strong", Aubin("emrevrg/AUBIN-12B"), 0.0)]) |
| eng.predict(state, questions) |
| """ |
| from __future__ import annotations |
|
|
| import time |
|
|
| from .core import options |
|
|
|
|
| def _answer_field(q, key, probs): |
| """Laya/Jev alan adları: choice → "choice", score → "score" (seviye indeksi), noul → "noul" (evet olasılığı).""" |
| t = q.get("type", "choice") |
| if t == "noul": |
| return {"noul": round(float(probs.get("true", 0.0)), 4)} |
| if t == "score": |
| keys = list(probs) |
| return {"score": keys.index(key) if key in keys else None, "label": key} |
| return {"choice": key} |
|
|
|
|
| class AubinEngine: |
| def __init__(self, tiers, abstain=False, learner=None): |
| """tiers: [(ad, model, eşik)] ucuzdan pahalıya; model .decide(state, questions) sunar (Aubin, AubinEnsemble, |
| AubinLearning). eşik: o katmanda kararı kabul etmek için gereken kalibre güven (son katmanda genelde 0). |
| learner: isteğe bağlı AubinLearning — K0 olarak en başta denenir (öğrenilmiş beceri/bellek).""" |
| self.tiers = list(tiers) |
| if learner is not None: |
| self.tiers.insert(0, ("learned", learner, getattr(learner, "engine_threshold", 0.9))) |
| self.abstain = abstain |
| self.stats = {name: 0 for name, _, _ in self.tiers} |
| self.stats["abstained"] = 0 |
|
|
| def predict(self, state, questions, min_confidence=None): |
| t0 = time.perf_counter() |
| pending, answers, route, tier_ms = dict(questions), {}, {}, {} |
| for li, (name, model, thr) in enumerate(self.tiers): |
| if not pending: |
| break |
| last = li == len(self.tiers) - 1 |
| thr = max(thr, min_confidence or 0.0) if not last or self.abstain else thr |
| t1 = time.perf_counter() |
| res = model.decide(state, pending) |
| tier_ms[name] = round((time.perf_counter() - t1) * 1e3, 1) |
| for qid, r in res.items(): |
| conf = float(r["confidence"]) |
| if conf >= thr or (last and not self.abstain): |
| answers[qid] = {**_answer_field(questions[qid], r["answer"], r["probabilities"]), |
| "confidence": round(conf, 4), "probabilities": r["probabilities"], "tier": name} |
| route[qid] = name; self.stats[name] += 1 |
| pending.pop(qid) |
| if last: |
| for qid in list(pending): |
| keys, _ = options(questions[qid]) |
| answers[qid] = {"choice": None, "abstained": True, "tier": name, "confidence": None} |
| route[qid] = "abstained"; self.stats["abstained"] += 1 |
| pending.pop(qid) |
| return {"answers": answers, "routing": {"per_question": route, "tier_ms": tier_ms, |
| "total_ms": round((time.perf_counter() - t0) * 1e3, 1)}} |
|
|
| def learn(self, state, questions, answers): |
| """Geri bildirim K0'a (varsa) gider: bir sonraki benzer istek pahalı katmana hiç çıkmadan çözülebilir.""" |
| for name, model, _ in self.tiers: |
| if hasattr(model, "learn"): |
| return model.learn(state, questions, answers) |
| return None |
|
|
