tessss

app.py

@@ -80,11 +80,11 @@ SUBJECTS: Dict[str, Dict[str, str]] = {
     }
 }
 
-# Threshold & parameter cepat
+# ======= Threshold & parameter cepat (sudah dilonggarkan & adaptif) =======
 TOP_K_FAISS   = int(os.environ.get("TOP_K_FAISS", 15))
 TOP_K_FINAL   = int(os.environ.get("TOP_K_FINAL", 10))
-MIN_COSINE    = float(os.environ.get("MIN_COSINE", 0.83))  # sedikit lebih longgar biar jarang fallback
-MIN_LEXICAL   = float(os.environ.get("MIN_LEXICAL", 0.8))
+MIN_COSINE    = float(os.environ.get("MIN_COSINE", 0.83))  # dulu 0.83
+MIN_LEXICAL   = float(os.environ.get("MIN_LEXICAL", 0.10))  # dulu 0.8 → terlalu ketat utk query pendek
 FALLBACK_TEXT = os.environ.get("FALLBACK_TEXT", "maap pengetahuan tidak ada dalam database")
 GUARDRAIL_BLOCK_TEXT = os.environ.get("GUARDRAIL_BLOCK_TEXT", "maap, pertanyaan ditolak oleh guardrail")
 ENABLE_PROFILING = os.environ.get("ENABLE_PROFILING", "false").lower() == "true"
@@ -125,11 +125,10 @@ TOKEN_RE = re.compile(r"[A-Za-zÀ-ÖØ-öø-ÿ]+", re.UNICODE)
 
 @lru_cache(maxsize=4096)
 def _tok_cached(word: str) -> str:
-    # cache lowercase
     return word.lower()
 
 def tok_id(text: str) -> List[str]:
-    return [tw for w in TOKEN_RE.findall(text or "") if (tw:=_tok_cached(w)) not in STOPWORDS_ID]
+    return [tw for w in TOKEN_RE.findall(text or "") if (tw := _tok_cached(w)) not in STOPWORDS_ID]
 
 def lexical_overlap(query: str, sent: str) -> float:
     q = set(tok_id(query)); s = set(tok_id(sent))
@@ -138,7 +137,9 @@ def lexical_overlap(query: str, sent: str) -> float:
     return len(q & s) / max(1, len(q | s))
 
 QUESTION_LIKE_RE = re.compile(r"(^\s*(apa|mengapa|bagaimana|sebutkan|jelaskan)\b|[?]$)", re.IGNORECASE)
-INSTRUCTION_RE   = re.compile(r"\b(jelaskan|sebutkan|uraikan|kerjakan|diskusikan|tugas|latihan|menurut\s+pendapatmu)\b", re.IGNORECASE)
+# Relaksasi filter instruksi: hanya pola yang benar-benar instruksi tugas di awal kalimat
+INSTRUCTION_RE   = re.compile(r"^\s*(kerjakan|tugas\s*:|diskusikan|latihan\s*:)\b", re.IGNORECASE)
+
 META_PREFIX_PATTERNS = [
     r"berdasarkan\s+(?:kalimat|sumber|teks|konten|informasi)(?:\s+(?:di\s+atas|tersebut))?",
     r"menurut\s+(?:sumber|teks|konten)",
@@ -168,14 +169,14 @@ def strip_meta_sentence(s: str) -> str:
 SENT_SPLIT_RE = re.compile(r"(?<=[.!?])\s+")
 
 def split_sentences_fast(text: str) -> List[str]:
-    # tanpa encoding per-kalimat
     outs = []
     for p in SENT_SPLIT_RE.split(text or ""):
         s = clean_prefix((p or "").strip())
         if not s:
             continue
-        if s[-1] not in ".!?":
-            s += "."
+        # Opsi: jika dataset kamu sering tanpa tanda akhir, boleh aktifkan ini:
+        # if s and s[-1] not in ".!?":
+        #     s += "."
         if QUESTION_LIKE_RE.search(s):
             continue
         if INSTRUCTION_RE.search(s):
@@ -186,7 +187,6 @@ def split_sentences_fast(text: str) -> List[str]:
     return outs
 
 # ========= MODEL WARMUP =========
-
 def warmup_models():
     global ENCODER_TOKENIZER, ENCODER_MODEL, LLM
     if ENCODER_TOKENIZER is None or ENCODER_MODEL is None:
@@ -198,7 +198,6 @@ def warmup_models():
         LLM = load_model(MODEL_PATH, n_ctx=CTX_WINDOW, n_gpu_layers=N_GPU_LAYERS, n_threads=N_THREADS)
 
 # ========= ASSETS =========
-
 @lru_cache(maxsize=8)
 def load_subject_assets(subject_key: str) -> "SubjectAssets":
     if subject_key not in SUBJECTS:
@@ -220,7 +219,6 @@ def load_subject_assets(subject_key: str) -> "SubjectAssets":
     return SubjectAssets(index=index, texts=texts, embs=embs)
 
 # ========= ENCODER =========
-
 @torch.inference_mode()
 @lru_cache(maxsize=1024)
 def encode_query_exact(text: str) -> np.ndarray:
@@ -235,7 +233,6 @@ def cosine_sim(a: np.ndarray, b: np.ndarray) -> float:
     return float(np.dot(a, b) / denom)
 
 # ========= RETRIEVAL CEPAT =========
-
 def best_cosine_from_faiss(query: str, subject_key: str) -> float:
     assets = load_subject_assets(subject_key)
     q = encode_query_exact(query)
@@ -254,24 +251,35 @@ def retrieve_top_chunks(query: str, subject_key: str) -> List[str]:
     idxs = [i for i in idx[0] if 0 <= i < len(assets.texts)]
     return [assets.texts[i] for i in idxs[:TOP_K_FINAL]]
 
+# ======= Seleksi kalimat dua-fase (ketat → longgar) =======
 def pick_best_sentences_fast(query: str, chunks: List[str], top_k: int = 4) -> List[str]:
-    # Tanpa encode per kalimat — hanya lexical overlap + panjang wajar
+    """
+    Fase-1: ambil kalimat dg overlap >= MIN_LEXICAL
+    Fase-2 (fallback): kalau hasil < top_k, ambil kalimat skor tertinggi meski < MIN_LEXICAL
+    """
     cands: List[Tuple[float, str]] = []
     for ch in chunks:
         for s in split_sentences_fast(ch):
             ovl = lexical_overlap(query, s)
-            if ovl < MIN_LEXICAL:
-                continue
-            # bonus sedikit kalau kalimat panjang wajar (50–220 char)
             L = len(s)
             len_bonus = 0.05 if 50 <= L <= 220 else 0.0
             score = ovl + len_bonus
-            cands.append((score, s))
+            cands.append((score, clean_prefix(s)))
+
+    if not cands:
+        log.info("[RAG] Tidak ada kandidat kalimat (split_sentences menghasilkan 0).")
+        return []
+
     cands.sort(key=lambda x: x[0], reverse=True)
+
+    strict = [s for sc, s in cands if sc + 1e-6 >= MIN_LEXICAL]
+    if len(strict) >= top_k:
+        return strict[:top_k]
+
+    log.info(f"[RAG] Kalimat relevan < {top_k} pada MIN_LEXICAL={MIN_LEXICAL}; fallback longgar dipakai.")
     return [s for _, s in cands[:top_k]]
 
 # ========= PROMPT =========
-
 def build_prompt(user_query: str, sentences: List[str]) -> str:
     block = "\n".join(f"- {clean_prefix(s)}" for s in sentences)
     system = (
@@ -518,14 +526,18 @@ def ask(subject_key: str):
     best = best_cosine_from_faiss(query, subject_key)
     log.info(f"[RAG] Subject={subject_key.upper()} | Best cosine={best:.3f}")
     if best < MIN_COSINE:
+        log.info(f"[RAG] Fallback by cosine: {best:.3f} < {MIN_COSINE}")
         return jsonify({"ok": True, "answer": FALLBACK_TEXT})
 
     chunks = retrieve_top_chunks(query, subject_key)
     if not chunks:
+        log.info("[RAG] Fallback by chunks=0")
         return jsonify({"ok": True, "answer": FALLBACK_TEXT})
 
     sentences = pick_best_sentences_fast(query, chunks, top_k=5)
+    log.info(f"[RAG] sentences_selected={len(sentences)} (min_lex={MIN_LEXICAL}, top_k={5})")
     if not sentences:
+        log.info("[RAG] Fallback by sentences=0")
         return jsonify({"ok": True, "answer": FALLBACK_TEXT})
 
     prompt = build_prompt(query, sentences)
@@ -543,9 +555,10 @@ def ask(subject_key: str):
         raw_answer = raw_answer.strip()
         log.info(f"[LLM] Raw answer repr (pass1): {repr(raw_answer)}")
 
-        text = re.sub(r"<think\\b[^>]*>.*?</think>", "", raw_answer, flags=re.DOTALL | re.IGNORECASE).strip()
-        text = re.sub(r"</?think\\b[^>]*>", "", text, flags=re.IGNORECASE).strip()
-        m_final = re.search(r"<final>\\s*(.+)$", text, flags=re.IGNORECASE | re.DOTALL)
+        # Bersihkan tag <think> dan ambil isi <final>
+        text = re.sub(r"<think\b[^>]*>.*?</think>", "", raw_answer, flags=re.DOTALL | re.IGNORECASE).strip()
+        text = re.sub(r"</?think\b[^>]*>", "", text, flags=re.IGNORECASE).strip()
+        m_final = re.search(r"<final>\s*(.+)$", text, flags=re.IGNORECASE | re.DOTALL)
         cleaned = (m_final.group(1).strip() if m_final else re.sub(r"<[^>]+>", "", text).strip())
 
         def _alpha_tokens(s: str) -> List[str]:
@@ -555,14 +568,11 @@ def ask(subject_key: str):
             s2 = (s or "").strip()
             if not s2:
                 return True
-            # nolak placeholder/ellipsis saja
             if s2 in {"...", ".", "..", "…"}:
                 return True
             toks = _alpha_tokens(s2)
-            # cukup 4 token alfabetik untuk lolos (lebih toleran utk jawaban singkat)
             if len(toks) >= 4:
                 return False
-            # pengecualian: fakta pendek dengan unit/istilah umum tetap lolos
             if any(t.lower() in {"newton","n","kg","m","s"} for t in toks) and len(toks) >= 3:
                 return False
             return True
@@ -593,13 +603,13 @@ def ask(subject_key: str):
             cleaned = cleaned2 or cleaned
 
         answer = cleaned
-                
+
     except Exception as e:
         log.exception(f"[LLM] generate error: {e}")
         return jsonify({"ok": True, "answer": FALLBACK_TEXT})
 
     # Ambil 1 kalimat pertama saja
-    m = re.search(r"(.+?[.!?])(\\s|$)", answer)
+    m = re.search(r"(.+?[.!?])(\s|$)", answer)
     answer = (m.group(1) if m else answer).strip()
     answer = strip_meta_sentence(answer)
 
@@ -700,7 +710,6 @@ def admin_history():
     } for r in rows]
     return render_template("admin_history.html", items=items, subjects=SUBJECTS, q=q, username=username, subject=subject, role=role, page=page, per_page=per_page, total=total)
 
-
 def _is_last_admin(s: Session) -> bool:
     return (s.query(func.count(User.id)).filter(User.is_admin.is_(True)).scalar() or 0) <= 1