HVU_QA

HVU_QA/fine_tune_qg.py

@@ -1,104 +1,153 @@
-import json
-from datasets import Dataset
-from sklearn.model_selection import train_test_split
-from transformers import (
-    T5Tokenizer,
-    T5ForConditionalGeneration,
-    TrainingArguments,
-    Trainer
-)
-
-def load_squad_data(file_path):
-    
-    with open(file_path, "r", encoding="utf-8") as f:
-        squad_data = json.load(f)
-
-    data = []
-    for article in squad_data["data"]:
-        for paragraph in article["paragraphs"]:
-            context = paragraph.get("context", "")
-            for qa in paragraph["qas"]:
-                if not qa.get("is_impossible", False) and qa.get("answers"):
-                    answer = qa["answers"][0]["text"]
-                    question = qa["question"]
-                    input_text = f"answer: {answer} context: {context}"
-                    data.append({"input": input_text, "target": question})
-    return data
-
-def preprocess_function(example, tokenizer, max_input_length=512, max_target_length=64):
-    
-    model_inputs = tokenizer(
-        example["input"],
-        max_length=max_input_length,
-        padding="max_length",
-        truncation=True,
-    )
-    labels = tokenizer(
-        text_target=example["target"],
-        max_length=max_target_length,
-        padding="max_length",
-        truncation=True,
-    )
-    model_inputs["labels"] = labels["input_ids"]
-    return model_inputs
-
-def main():
-    data_path = "30ktrain.json"  
-    output_dir = "t5-viet-qg-finetuned"
-    logs_dir = "logs"
-    model_name = "VietAI/vit5-base"
-
-    print("Tải mô hình và tokenizer...")
-    tokenizer = T5Tokenizer.from_pretrained(model_name)
-    model = T5ForConditionalGeneration.from_pretrained(model_name)
-
-    print("Đọc và chia dữ liệu...")
-    raw_data = load_squad_data(data_path)  
-    train_data, val_data = train_test_split(raw_data, test_size=0.2, random_state=42)
-
-    train_dataset = Dataset.from_list(train_data)
-    val_dataset = Dataset.from_list(val_data)
-
-    tokenized_train = train_dataset.map(
-        lambda x: preprocess_function(x, tokenizer),
-        batched=True,
-        remove_columns=["input", "target"]
-    )
-    tokenized_val = val_dataset.map(
-        lambda x: preprocess_function(x, tokenizer),
-        batched=True,
-        remove_columns=["input", "target"]
-    )
-
-    print("Cấu hình huấn luyện...")
-    training_args = TrainingArguments(
-        output_dir=output_dir,
-        overwrite_output_dir=True,
-        per_device_train_batch_size=1,
-        gradient_accumulation_steps=1,
-        num_train_epochs=3,
-        learning_rate=2e-4,
-        weight_decay=0.01,
-        warmup_steps=0,
-        logging_dir=logs_dir,
-        logging_steps=10,
-        fp16=False
-    )
-
-    print("Huấn luyện mô hình...")
-    trainer = Trainer(
-        model=model,
-        args=training_args,
-        train_dataset=tokenized_train,
-        eval_dataset=tokenized_val,
-        tokenizer=tokenizer,
-    )
-    trainer.train()
-
-    print("Lưu mô hình...")
-    model.save_pretrained(output_dir)
-    tokenizer.save_pretrained(output_dir)
-    print("Huấn luyện hoàn tất!")
-
-if __name__ == "__main__":
-    main()
+import re
+import torch
+from difflib import SequenceMatcher
+from transformers import T5Tokenizer, T5ForConditionalGeneration
+from transformers.utils import logging as hf_logging
+
+hf_logging.set_verbosity_error()
+
+MODEL_DIR = "t5-viet-qg-finetuned"
+
+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 norm(s: str) -> str:
+    return re.sub(r"\s+", " ", s).strip()
+
+
+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 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
+            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)
+
+    mdl.eval()
+    return tok, mdl, dev
+
+
+tokenizer, model, device = load_model()
+
+
+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__":
+    ctx = input("\nNhập đoạn văn bản:\n").strip()
+    try:
+        n = int((input("\nNhập số lượng câu hỏi cần sinh: ").strip() or "20"))
+    except ValueError:
+        n = 20
+
+    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}")