from __future__ import annotations import argparse import hashlib import json import os import re import shutil import sys import tempfile import threading import warnings from pathlib import Path from typing import Any os.environ.setdefault("TOKENIZERS_PARALLELISM", "false") if os.environ.get("PYTORCH_CUDA_ALLOC_CONF") == "expandable_segments:True": os.environ.pop("PYTORCH_CUDA_ALLOC_CONF", None) os.environ.setdefault("TRANSFORMERS_NO_ADVISORY_WARNINGS", "1") warnings.filterwarnings("ignore", message=r"You are using the default legacy behaviour.*") warnings.filterwarnings("ignore", message=r"Special tokens have been added.*") def raise_missing_dependency_error(exc: ModuleNotFoundError) -> None: raise SystemExit(f"Thiếu thư viện Python: {exc.name}") from exc try: import torch from transformers import AutoModelForSeq2SeqLM, AutoTokenizer from transformers import logging as transformers_logging from transformers.utils import is_torch_available except ModuleNotFoundError as exc: raise_missing_dependency_error(exc) transformers_logging.set_verbosity_error() if not is_torch_available(): raise SystemExit("Transformers không nhận PyTorch trong môi trường hiện tại.") APP_TITLE = "Hệ thống sinh câu hỏi" TASK_PREFIX = "sinh câu hỏi" QUESTION_LIMIT = 100 TOKENIZER_FILES = ( "config.json", "special_tokens_map.json", "spiece.model", "tokenizer.json", "tokenizer_config.json", "added_tokens.json", ) GENERATION_PASSES = ( (0.9, 0.95, None, 1, 4), (1.0, 0.97, 16, 1, 5), (1.08, 0.99, 8, 2, 6), ) def normalize_text(text: Any) -> str: return " ".join(str(text or "").split()) def unique_text(items: list[str]) -> list[str]: seen: set[str] = set() output: list[str] = [] for item in items: value = normalize_text(item) key = value.lower() if key and key not in seen: seen.add(key) output.append(value) return output def parse_question_count(value: Any, default: int = 5) -> int: try: parsed = int(value) except (TypeError, ValueError): parsed = default return max(1, min(parsed, QUESTION_LIMIT)) def format_questions(items: list[str]) -> str: if not items: return "Không sinh được câu hỏi phù hợp." return "\n".join(f"{index}. {item}" for index, item in enumerate(items, 1)) def as_bool(value: str | None, default: bool = False) -> bool: if value is None: return default return value.strip().lower() in {"1", "true", "yes", "y", "on"} def resolve_model_dir(model_dir: str | Path, prefer_nested_model: bool = True) -> Path: model_root = Path(model_dir).expanduser().resolve() nested_candidates = [model_root / "best-model", model_root / "final-model"] candidates = [*nested_candidates, model_root] if prefer_nested_model else [model_root, *nested_candidates] for candidate in candidates: if candidate.is_dir() and (candidate / "config.json").exists(): return candidate raise FileNotFoundError(f"Không tìm thấy thư mục mô hình hợp lệ: {model_root}") def path_needs_ascii_mirror(path: Path) -> bool: try: str(path).encode("ascii") except UnicodeEncodeError: return True return False def resolve_tokenizer_dir(model_dir: Path) -> Path: if not path_needs_ascii_mirror(model_dir): return model_dir digest = hashlib.sha1(str(model_dir).encode("utf-8")).hexdigest()[:16] cache_base = Path(os.getenv("LOCALAPPDATA") or tempfile.gettempdir()) tokenizer_dir = cache_base / "HVU_QA" / "tokenizer_cache" / digest tokenizer_dir.mkdir(parents=True, exist_ok=True) copied = False for filename in TOKENIZER_FILES: source = model_dir / filename if not source.exists(): continue destination = tokenizer_dir / filename if destination.exists() and destination.stat().st_size == source.stat().st_size: continue shutil.copy2(source, destination) copied = True if copied: marker = tokenizer_dir / "source_model_dir.txt" marker.write_text(str(model_dir), encoding="utf-8") return tokenizer_dir def parse_dtype(value: str) -> torch.dtype: normalized = value.strip().lower() mapping = { "float16": torch.float16, "fp16": torch.float16, "float32": torch.float32, "fp32": torch.float32, "bfloat16": torch.bfloat16, "bf16": torch.bfloat16, } if normalized not in mapping: raise ValueError(f"Không hỗ trợ gpu_dtype={value}") return mapping[normalized] class QuestionGenerator: def __init__( self, model_dir: str | Path = "t5-viet-qg-finetuned", task_prefix: str = TASK_PREFIX, max_source_length: int = 512, max_new_tokens: int = 64, device: str = "auto", cpu_threads: int | None = None, gpu_dtype: str = "auto", prefer_nested_model: bool = True, ) -> None: self.model_root = Path(model_dir).expanduser().resolve() self.model_dir = resolve_model_dir(model_dir, prefer_nested_model=prefer_nested_model) self.task_prefix = task_prefix self.max_source_length = max_source_length self.max_new_tokens = max_new_tokens self.requested_device = device self.cpu_threads = cpu_threads self.gpu_dtype = gpu_dtype self.prefer_nested_model = prefer_nested_model self.device: torch.device | None = None self.dtype: torch.dtype | None = None self.tokenizer = None self.model = None self._load_lock = threading.Lock() def _resolve_device(self) -> torch.device: requested = self.requested_device.lower() if requested == "cpu": return torch.device("cpu") if requested == "cuda": if not torch.cuda.is_available(): raise RuntimeError("Bạn đã chọn device=cuda nhưng máy hiện tại không có CUDA.") return torch.device("cuda") return torch.device("cuda" if torch.cuda.is_available() else "cpu") def _resolve_dtype(self) -> torch.dtype: if self.device is None or self.device.type != "cuda": return torch.float32 if self.gpu_dtype == "auto": if hasattr(torch.cuda, "is_bf16_supported") and torch.cuda.is_bf16_supported(): return torch.bfloat16 return torch.float16 return parse_dtype(self.gpu_dtype) def _configure_runtime(self) -> None: if self.device is None: return if self.device.type == "cpu": if self.cpu_threads: torch.set_num_threads(max(1, int(self.cpu_threads))) if hasattr(torch, "set_num_interop_threads"): torch.set_num_interop_threads(max(1, min(int(self.cpu_threads), 4))) return if hasattr(torch.backends, "cuda") and hasattr(torch.backends.cuda, "matmul"): torch.backends.cuda.matmul.allow_tf32 = True if hasattr(torch.backends, "cudnn"): torch.backends.cudnn.allow_tf32 = True torch.backends.cudnn.benchmark = True def _load_tokenizer(self): use_fast = as_bool(os.getenv("HVU_USE_FAST_TOKENIZER"), default=False) tokenizer_dir = resolve_tokenizer_dir(self.model_dir) try: return AutoTokenizer.from_pretrained(str(tokenizer_dir), use_fast=use_fast) except Exception: if use_fast: return AutoTokenizer.from_pretrained(str(tokenizer_dir), use_fast=False) if (tokenizer_dir / "tokenizer.json").exists(): try: return AutoTokenizer.from_pretrained(str(tokenizer_dir), use_fast=True) except Exception: pass return AutoTokenizer.from_pretrained(str(tokenizer_dir), use_fast=False) def load(self) -> None: if self.model is not None and self.tokenizer is not None: return with self._load_lock: if self.model is not None and self.tokenizer is not None: return self.device = self._resolve_device() self.dtype = self._resolve_dtype() self._configure_runtime() model_kwargs: dict[str, Any] = {} if self.device.type == "cuda": model_kwargs["torch_dtype"] = self.dtype model_kwargs["low_cpu_mem_usage"] = True self.tokenizer = self._load_tokenizer() self.model = AutoModelForSeq2SeqLM.from_pretrained(str(self.model_dir), **model_kwargs) self.model.to(self.device) self.model.eval() def metadata(self) -> dict[str, Any]: active_device = self.device.type if self.device is not None else None predicted_device = "cuda" if torch.cuda.is_available() and self.requested_device != "cpu" else "cpu" return { "title": APP_TITLE, "model_root": str(self.model_root), "model_dir": str(self.model_dir), "requested_device": self.requested_device, "active_device": active_device, "predicted_device": predicted_device, "loaded": self.model is not None, "gpu_available": torch.cuda.is_available(), "gpu_dtype": None if self.dtype is None else str(self.dtype).replace("torch.", ""), "cpu_threads": torch.get_num_threads(), } def _candidate_answers(self, text: str, limit: int) -> list[str]: text = normalize_text(text) if not text: return [] candidates: list[str] = [] split_pattern = r"(?<=[.!?])\s+|\n+" for sentence in [normalize_text(part) for part in re.split(split_pattern, text) if normalize_text(part)]: if 3 <= len(sentence.split()) <= 30: candidates.append(sentence) for clause in (normalize_text(part) for part in re.split(r"\s*[,;:]\s*", sentence)): if 3 <= len(clause.split()) <= 20: candidates.append(clause) if not candidates: words = text.split() candidates = [" ".join(words[: min(12, len(words))])] if words else [text] ranked = sorted(unique_text(candidates), key=lambda item: (abs(len(item.split()) - 10), len(item))) return ranked[:limit] def _build_prompt(self, context: str, answer: str) -> str: return f"{self.task_prefix}:\nngữ cảnh: {context}\nđáp án: {answer}" @torch.inference_mode() def _sample(self, context: str, answer: str, count: int, temperature: float, top_p: float) -> list[str]: if self.tokenizer is None or self.model is None or self.device is None: raise RuntimeError("Model chưa được load.") inputs = self.tokenizer( self._build_prompt(context, answer), return_tensors="pt", truncation=True, max_length=self.max_source_length, ).to(self.device) outputs = self.model.generate( **inputs, max_new_tokens=self.max_new_tokens, do_sample=True, temperature=temperature, top_p=top_p, num_return_sequences=count, no_repeat_ngram_size=3, repetition_penalty=1.1, ) questions: list[str] = [] for token_ids in outputs: question = normalize_text(self.tokenizer.decode(token_ids, skip_special_tokens=True)) if question: questions.append(question if question.endswith("?") else f"{question}?") return [question for question in unique_text(questions) if len(question.split()) >= 3] @torch.inference_mode() def _beam_search(self, context: str, answer: str, count: int) -> list[str]: if self.tokenizer is None or self.model is None or self.device is None: raise RuntimeError("Model chưa được load.") inputs = self.tokenizer( self._build_prompt(context, answer), return_tensors="pt", truncation=True, max_length=self.max_source_length, ).to(self.device) outputs = self.model.generate( **inputs, max_new_tokens=self.max_new_tokens, num_beams=max(4, count), num_return_sequences=min(count, 4), early_stopping=True, no_repeat_ngram_size=3, repetition_penalty=1.1, ) questions: list[str] = [] for token_ids in outputs: question = normalize_text(self.tokenizer.decode(token_ids, skip_special_tokens=True)) if question: questions.append(question if question.endswith("?") else f"{question}?") return [question for question in unique_text(questions) if len(question.split()) >= 3] def generate(self, text: str, count: int = 5) -> list[str]: self.load() context = normalize_text(text) if not context: raise ValueError("Vui lòng nhập đoạn văn.") count = parse_question_count(count) pool = unique_text( self._candidate_answers(context, max(32, count * 5)) + [context[:180], context[:280], context] ) output: list[str] = [] seen: set[str] = set() for temperature, top_p, limit, rounds, floor in GENERATION_PASSES: answers = pool[:limit] if limit else pool for _ in range(rounds): for answer in answers: remaining = count - len(output) if remaining <= 0: return output[:count] sample_count = min(8, max(floor, remaining * 2)) for question in self._sample(context, answer, sample_count, temperature, top_p): key = question.lower() if key not in seen: seen.add(key) output.append(question) if len(output) >= count: return output[:count] for answer in pool[: min(8, len(pool))]: remaining = count - len(output) if remaining <= 0: break for question in self._beam_search(context, answer, remaining): key = question.lower() if key not in seen: seen.add(key) output.append(question) if len(output) >= count: break return output[:count] def read_input_text(args: argparse.Namespace) -> str: if args.text: return args.text if args.input_file: return Path(args.input_file).read_text(encoding="utf-8") if sys.stdin.isatty(): return input("Nhập đoạn văn cần sinh câu hỏi:\n").strip() return sys.stdin.read().strip() def read_question_count(args: argparse.Namespace) -> int: if args.num_questions is not None: return parse_question_count(args.num_questions) if args.text or args.input_file or not sys.stdin.isatty(): return parse_question_count(None) while True: raw_value = input(f"Nhập số lượng câu hỏi cần sinh (1-{QUESTION_LIMIT}): ").strip() if not raw_value: print("Vui lòng nhập số lượng câu hỏi cần sinh.") continue try: parsed = int(raw_value) except ValueError: print("Vui lòng nhập một số nguyên.") continue if 1 <= parsed <= QUESTION_LIMIT: return parsed print(f"Số lượng câu hỏi phải nằm trong khoảng 1 đến {QUESTION_LIMIT}.") def build_parser() -> argparse.ArgumentParser: parser = argparse.ArgumentParser() parser.add_argument("--model_dir", default="t5-viet-qg-finetuned") parser.add_argument("--task_prefix", default=TASK_PREFIX) parser.add_argument("--max_source_length", type=int, default=512) parser.add_argument("--max_new_tokens", type=int, default=64) parser.add_argument("--num_questions", type=int, default=None) parser.add_argument("--device", choices=["auto", "cpu", "cuda"], default="auto") parser.add_argument("--cpu_threads", type=int, default=None) parser.add_argument("--gpu_dtype", default="auto") parser.add_argument("--text", default=None) parser.add_argument("--input_file", default=None) parser.add_argument("--output_format", choices=["text", "json"], default="text") return parser def main() -> None: if hasattr(sys.stdout, "reconfigure"): sys.stdout.reconfigure(encoding="utf-8") if hasattr(sys.stderr, "reconfigure"): sys.stderr.reconfigure(encoding="utf-8") args = build_parser().parse_args() generator = QuestionGenerator( model_dir=args.model_dir, task_prefix=args.task_prefix, max_source_length=args.max_source_length, max_new_tokens=args.max_new_tokens, device=args.device, cpu_threads=args.cpu_threads, gpu_dtype=args.gpu_dtype, prefer_nested_model=True, ) text = read_input_text(args) question_count = read_question_count(args) questions = generator.generate(text, question_count) payload = { "text": normalize_text(text), "questions": questions, "formatted": format_questions(questions), "meta": generator.metadata(), } if args.output_format == "json": print(json.dumps(payload, ensure_ascii=False, indent=2)) return print(payload["formatted"]) if __name__ == "__main__": main()