HVU_QA

HVU_QA/generate_question.py

@@ -1,4 +1,5 @@
-import json
+import re
+import torch
 from difflib import SequenceMatcher
 from transformers import T5Tokenizer, T5ForConditionalGeneration
 from transformers.utils import logging as hf_logging
@@ -6,134 +7,152 @@ from transformers.utils import logging as hf_logging
 hf_logging.set_verbosity_error()
 
 MODEL_DIR = "t5-viet-qg-finetuned"
-DATA_PATH = "39k_train.json"
 
-tokenizer = T5Tokenizer.from_pretrained(MODEL_DIR)
-model = T5ForConditionalGeneration.from_pretrained(MODEL_DIR)
+PATTERN = re.compile(
+    r"""
+    “([^”]{3,120})”
+  | "([^"]{3,120})"
+  | \b(?:là|gồm|do|theo)\s+([^,.;:\n]{3,120})
+  | \b\d{4}\b
+  | \b(?:Điều|Khoản)\s+\d+\b
+    """,
+    re.VERBOSE | re.IGNORECASE,
+)
 
-def find_best_match_from_context(user_context, squad_data):
-    best_score, best_entry = 0.0, None
-    ui = user_context.lower()
 
-    for article in squad_data.get("data", []):
-        context_title = article.get("title", "")
-        score_title = SequenceMatcher(None, ui, context_title.lower()).ratio()
+def norm(s: str) -> str:
+    return re.sub(r"\s+", " ", s).strip()
 
-        for paragraph in article.get("paragraphs", []):
-            context = paragraph.get("context", "")
-            for qa in paragraph.get("qas", []):
-                answers = qa.get("answers", [])
-                if not answers:
-                    continue
-                answer_text = answers[0].get("text", "").strip()
-                question_text = qa.get("question", "").strip()
-
-                score = score_title
-                if score > best_score:
-                    best_score = score
-                    best_entry = (context, answer_text, question_text)
 
-    return best_entry
-
-def _near_duplicate(q, seen, thr=0.90):
-    for s in seen:
-        if SequenceMatcher(None, q, s).ratio() >= thr:
+def is_dup(q: str, qs: list[str], thr: float = 0.85) -> bool:
+    ql = q.lower()
+    for x in qs:
+        if SequenceMatcher(None, ql, x.lower()).ratio() >= thr:
             return True
     return False
 
-def generate_questions(user_context,
-                       total_questions=20,
-                       batch_size=10,
-                       top_k=60,
-                       top_p=0.95,
-                       temperature=0.9,  
-                       max_input_len=512,
-                       max_new_tokens=64):
-    with open(DATA_PATH, "r", encoding="utf-8") as f:
-        squad_data = json.load(f)
-
-    best_entry = find_best_match_from_context(user_context, squad_data)
-    if best_entry is None:
-        print("Không tìm thấy dữ liệu phù hợp trong file JSON.")
-        return
-
-    context, answer, _ = best_entry
-
-   
-    input_text = f"answer: {answer}\ncontext: {context}\nquestion:"
-    inputs = tokenizer(
-        input_text,
-        return_tensors="pt",
-        truncation=True,
-        max_length=max_input_len
-    )
 
-    unique_questions = []
-    remaining = total_questions
-
-    while remaining > 0:
-        n = min(batch_size, remaining)
-        outputs = model.generate(
-            **inputs,
-            do_sample=True,
-            top_k=top_k,  
-            top_p=top_p,  
-            temperature=temperature,  
-            max_new_tokens=max_new_tokens,
-            num_return_sequences=n,
-            no_repeat_ngram_size=3,
-            repetition_penalty=1.12
-        )
-
-        for out in outputs:
-            q = tokenizer.decode(out, skip_special_tokens=True).strip()
-            if len(q) < 5:
+def extract_answers(ctx: str, max_n: int = 60) -> list[str]:
+    ctx = norm(ctx)
+    answers, seen = [], set()
+
+    for m in PATTERN.finditer(ctx):
+        for g in m.groups():
+            if not g:
                 continue
-            if not _near_duplicate(q, unique_questions, thr=0.90):
-                unique_questions.append(q)
+            g = norm(g)
+            k = g.lower()
+            if 3 <= len(g) <= 120 and k not in seen:
+                seen.add(k)
+                answers.append(g)
+                if len(answers) >= max_n:
+                    return answers
+
+    if len(answers) < 8:
+        for i in range(0, min(len(ctx), 500), 60):
+            ch = norm(ctx[i : i + 60])
+            k = ch.lower()
+            if len(ch) >= 15 and k not in seen:
+                seen.add(k)
+                answers.append(ch)
+            if len(answers) >= max_n:
+                break
+
+    if not answers and ctx:
+        answers = [ctx[:120]]
+
+    return answers
+
+
+def load_model():
+    tok = T5Tokenizer.from_pretrained(MODEL_DIR)
+    mdl = T5ForConditionalGeneration.from_pretrained(MODEL_DIR)
+
+    dev = "cuda" if torch.cuda.is_available() else "cpu"
+    try:
+        mdl = mdl.to(dev)
+    except RuntimeError:
+        dev = "cpu"
+        try:
+            torch.cuda.empty_cache()
+        except Exception:
+            pass
+        mdl = mdl.to(dev)
 
-        remaining = total_questions - len(unique_questions)
-        if remaining <= 0:
-            break
+    mdl.eval()
+    return tok, mdl, dev
 
-    unique_questions = unique_questions[:total_questions]
 
-    
-    print("Các câu hỏi mới được sinh ra:")
-    for i, q in enumerate(unique_questions, 1):
-        if not q.endswith("?"):
-            q += "?"  
-        print(f"{i}. {q}")
+tokenizer, model, device = load_model()
 
-if __name__ == "__main__":
-    user_context = input("\nNhập đoạn văn bản:\n ").strip()
 
-    raw_n = input("\nNhập vào số lượng câu hỏi bạn cần:").strip()
-    if raw_n == "":
-        total_questions = 20
-    else:
-        try:
-            total_questions = int(raw_n)
-        except ValueError:
-            print("Giá trị không hợp lệ. Dùng mặc định 20.")
-            total_questions = 20
-
-    if total_questions < 1:
-        total_questions = 1
-    if total_questions > 200:
-        total_questions = 200
-
-    batch_size = 20 if total_questions >= 30 else min(20, total_questions)
-
-    print("\nĐang phân tích dữ liệu...\n")
-
-    generate_questions(
-        user_context=user_context,
-        total_questions=total_questions,
-        batch_size=batch_size,
-        top_k=60,
-        top_p=0.95,  
-        temperature=0.9,  
-        max_input_len=512,
-        max_new_tokens=64
+def generate_questions(context: str, n: int = 20) -> list[str]:
+    ctx = norm(context)
+    answers = extract_answers(ctx, max_n=80)
+    questions = []
+
+    gen_cfg = dict(
+        do_sample=True,
+        top_k=80,
+        top_p=0.98,
+        temperature=1.05,
+        max_new_tokens=72,
+        no_repeat_ngram_size=3,
+        repetition_penalty=1.08,
     )
+
+    num_ret = 8 if n <= 20 else 10
+
+    def run_prompt(ans: str, rounds: int):
+        nonlocal gen_cfg
+        prompt = f"answer: {ans}\ncontext: {ctx}\nquestion:"
+        inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=512).to(device)
+
+        for _ in range(rounds):
+            outs = model.generate(**inputs, num_return_sequences=num_ret, **gen_cfg)
+            added = 0
+            for o in outs:
+                q = norm(tokenizer.decode(o, skip_special_tokens=True))
+                if not q:
+                    continue
+                if not q.endswith("?"):
+                    q += "?"
+                if len(q) >= 6 and not is_dup(q, questions, thr=0.85):
+                    questions.append(q)
+                    added += 1
+                if len(questions) >= n:
+                    return
+            if added == 0:
+                gen_cfg["temperature"] = min(1.25, gen_cfg["temperature"] + 0.05)
+                gen_cfg["top_p"] = min(0.995, gen_cfg["top_p"] + 0.005)
+
+    with torch.inference_mode():
+        for ans in answers:
+            if len(questions) >= n:
+                break
+            run_prompt(ans, rounds=6)
+
+        if len(questions) < n:
+            run_prompt(ctx[:120], rounds=12)
+
+    return questions[:n]
+
+
+if __name__ == "__main__":
+    print("\nNhập đoạn văn bản: ")
+    lines = []
+    while True:
+        line = input()
+        if line == "":
+            break
+        lines.append(line)
+    ctx = "\n".join(lines)
+
+    n = int(input("\nNhập số lượng câu hỏi cần sinh: "))
+    n = max(1, min(n, 200))
+
+    qs = generate_questions(ctx, n)
+
+    print("\nCác câu hỏi sinh ra:")
+    for i, q in enumerate(qs, 1):
+        print(f"{i}. {q}")