|
|
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 "")) |
|
|
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}") |
|
|
|
