HVU_QA

.gitattributes

@@ -0,0 +1 @@
+HVU_QA/30ktrain.json filter=lfs diff=lfs merge=lfs -text

HVU_QA/30ktrain.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:87143be92ee93e76f4e4b6ccfee58da6970b70a80bbc3606fbecdec518b01921
+size 218169057

HVU_QA/fine_tune_qg.py

@@ -0,0 +1,102 @@
+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"]:
+        context = article.get("title", "")
+        for paragraph in article["paragraphs"]:
+            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()

HVU_QA/generate_question.py

@@ -0,0 +1,134 @@
+import json
+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"
+DATA_PATH = "30ktrain.json"
+
+tokenizer = T5Tokenizer.from_pretrained(MODEL_DIR)
+model = T5ForConditionalGeneration.from_pretrained(MODEL_DIR)
+
+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()
+
+        for paragraph in article.get("paragraphs", []):
+            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_title, 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:
+            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
+
+    _, answer, _ = best_entry
+
+    input_text = f"answer: {answer} context: {user_context}"
+    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:
+                continue
+            if not _near_duplicate(q, unique_questions, thr=0.90):
+                unique_questions.append(q)
+
+        remaining = total_questions - len(unique_questions)
+        if remaining <= 0:
+            break
+
+    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):
+        print(f"{i}. {q}")
+
+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
+    )

README.md

@@ -0,0 +1,285 @@
+# HVU_QA
+
+**HVU_QA** is a project dedicated to sharing datasets and tools for **Question Generation Processing (NLP)**, developed and maintained by the research team at **Hung Vuong University (HVU), Phu Tho, Vietnam**.  
+This project is supported by **Hung Vuong University, Phu Tho, Vietnam**, with the aim of advancing research and applications in low-resource language processing, particularly for the Vietnamese language.
+
+---
+
+## 📚 Overview
+
+This repository enables you to:
+
+1. Fine-tune the [VietAI/vit5-base](https://huggingface.co/datasets/DANGDOCAO/GeneratingQuestions) model on your own GQ dataset.
+2. Generate multiple, diverse questions given a user-provided text passage (context).
+
+---
+
+## 📁 Datasets
+
+* Built following the **SQuAD v2.0 standard**, ensuring compatibility with NLP pipelines.
+* Includes tens of thousands of high-quality **Question–Context–Answer triples (QCA)**.
+* Suitable for both **training** and **evaluation**.
+
+---
+
+## 📁 Vietnamese Question Generation Tool
+
+A **command-line tool** for:
+
+* **Fine-tuning** a question generation model.
+* **Automatically generating questions** from Vietnamese text.
+
+Built on **Hugging Face Transformers (VietAI/vit5-base)** and **PyTorch**.
+
+---
+
+## Features
+
+* Fine-tune a question generation model with SQuAD v2.0 format data.
+* Generate diverse and creative questions from text passages.
+* Flexible generation parameters (`top-k`, `top-p`, `temperature`, etc.).
+* Simple command-line usage.
+* GPU support if available.
+
+---
+
+## 📊 Evaluation Results
+
+We conducted both **manual evaluation** (500 samples) and **automatic evaluation** (1,000 samples).
+
+| Evaluation Type  | Precision | Recall | F1-Score |
+|------------------|-----------|--------|----------|
+| Automatic (1000) | 0.85      | 0.83   | 0.84     |
+| Manual (500)     | 0.88      | 0.86   | 0.87     |
+
+➡️ The model generates diverse, grammatically correct, and contextually appropriate questions.
+
+---
+
+## Creation Process
+
+The dataset was built using a **4-stage automated pipeline**:
+
+1. Select relevant QA websites from trusted sources.
+2. Automatic crawling to collect raw QA pages.
+3. Semantic tag extraction to obtain clean Question–Context–Answer triples.
+4. AI-assisted filtering to remove noisy or inconsistent samples.
+
+---
+
+## 📝 Quality Evaluation
+
+A fine-tuned model trained on **HVU_QA (VietAI/vit5-base)** achieved:
+
+* **BLEU Score**: 90.61
+* **Semantic similarity**: 97.0% (cosine ≥ 0.8)
+* **Human evaluation**:
+  * Grammar: **4.58 / 5**
+  * Usefulness: **4.29 / 5**
+
+➡️ These results confirm that **HVU_QA is a high-quality resource** for developing robust FAQ-style question generation models.
+
+---
+
+## 📂 Project Structure
+
+```
+.HVU_QA
+├── t5-viet-qg-finetuned/
+├── fine_tune_qg.py
+├── generate_question.py
+├── 30ktrain.json
+└── README.md
+```
+> All data files are UTF-8 encoded and ready for use in NLP pipelines.
+
+---
+
+## 🛠️ Requirements
+
+* Python 3.8+
+* PyTorch >= 1.9
+* Transformers >= 4.30
+* scikit-learn
+* Fine-tuned model (download at: [link](https://huggingface.co/datasets/DANGDOCAO/GeneratingQuestions/tree/main))
+
+---
+
+## ⚙️ Setup
+
+### 🛠️ Step 1: Download and Extract
+
+1. Download `HVU_QA.zip`
+2. Extract into a folder, e.g.:
+
+   ```
+   D:\your\HVU_QA
+   ```
+
+### 🛠️ Step 2: Add to Environment Path (if needed)
+
+1. Open **System Properties → Environment Variables**
+2. Select `Path` → **Edit** → **New**
+3. Add the path, e.g.:
+
+   ```
+   D:\your\HVU_QA
+   ```
+
+### 🛠️ Step 3: Open in Visual Studio Code
+
+```
+File > Open Folder > D:\HVU_QA
+```
+
+### 🛠️ Step 4: Install Required Libraries
+
+Open **Terminal** and run:
+
+#### Windows (PowerShell)
+
+**Required only**
+
+```powershell
+python -m pip install --upgrade pip
+pip install torch transformers datasets scikit-learn sentencepiece safetensors
+```
+
+**Required + Optional**
+
+```powershell
+python -m pip install --upgrade pip
+pip install torch transformers datasets scikit-learn sentencepiece safetensors accelerate tensorboard evaluate sacrebleu rouge-score nltk
+```
+
+#### Linux / macOS (bash/zsh)
+
+**Required only**
+
+```bash
+python3 -m pip install --upgrade pip
+pip install torch transformers datasets scikit-learn sentencepiece safetensors
+```
+
+**Required + Optional**
+
+```bash
+python3 -m pip install --upgrade pip
+pip install torch transformers datasets scikit-learn sentencepiece safetensors accelerate tensorboard evaluate sacrebleu rouge-score nltk
+```
+
+✅ Verify installation:
+
+* Windows (PowerShell)
+
+```powershell
+python -c "import torch, transformers, datasets, sklearn, sentencepiece, safetensors, accelerate, tensorboard, evaluate, sacrebleu, rouge_score, nltk; print('✅ All dependencies installed correctly!')"
+```
+
+* Linux/macOS
+
+```bash
+python3 -c "import torch, transformers, datasets, sklearn, sentencepiece, safetensors, accelerate, tensorboard, evaluate, sacrebleu, rouge_score, nltk; print('✅ All dependencies installed correctly!')"
+```
+
+---
+
+## Usage
+
+* Train and evaluate a question generation model.
+* Develop Vietnamese NLP tools.
+* Conduct linguistic research.
+
+### Training (Fine-tuning)
+
+When you run `fine_tune_qg.py`, the script will:
+
+1. Load the dataset from **`30ktrain.json`**
+2. Fine-tune the `VietAI/vit5-base` model
+3. Save the trained model into a new folder named **`t5-viet-qg-finetuned/`**
+
+Run:
+
+```bash
+python fine_tune_qg.py
+```
+
+### Generating Questions
+
+```bash
+python generate_question.py
+```
+
+**Example:**
+
+```
+Input passage:
+Iced milk coffee (Cà phê sữa đá) is a famous drink in Vietnam.
+
+Number of questions: 5
+```
+
+✅ Output:
+
+1. What type of coffee is famous in Vietnam?
+2. Why is iced milk coffee popular?
+3. What ingredients are included in iced milk coffee?
+4. Where does iced milk coffee originate from?
+5. How is Vietnamese iced milk coffee prepared?
+
+---
+
+## ⚙️ Generation Settings
+
+In `generate_question.py`, you can adjust:
+
+* `top_k`, `top_p`, `temperature`, `no_repeat_ngram_size`, `repetition_penalty`
+
+---
+
+## 🤝 Contribution
+
+We welcome contributions:
+
+* Open issues
+* Submit pull requests
+* Suggest improvements or add datasets
+
+---
+
+## 📄 Citation
+
+If you use this repository or datasets in research, please cite:
+
+**Ha Nguyen-Tien, Phuc Le-Hong, Dang Do-Cao, Cuong Nguyen-Hung, Chung Mai-Van. 2025. A Method to Build QA Corpora for Low-Resource Languages. Proceedings of KSE 2025. ACM TALLIP.**
+
+### 📚 BibTeX
+
+```bibtex
+@inproceedings{nguyen2025hvuqa,
+  title={A Method to Build QA Corpora for Low-Resource Languages},
+  author={Ha Nguyen-Tien and Phuc Le-Hong and Dang Do-Cao and Cuong Nguyen-Hung and Chung Mai-Van},
+  booktitle={Proceedings of KSE 2025},
+  year={2025}
+}
+```
+
+---
+
+## 📬 Contact
+
+* **Ha Nguyen-Tien** (Corresponding author)  
+  📧 [[email protected]](mailto:[email protected])
+
+* **Phuc Le-Hong**  
+  📧 [[email protected]](mailto:[email protected])
+
+* **Dang Do-Cao**  
+  📧 [[email protected]](mailto:[email protected])
+
+📍 Faculty of Engineering and Technology, Hung Vuong University, Phu Tho, Vietnam  
+🌐 [https://hvu.edu.vn](https://hvu.edu.vn)
+
+---
+
+*This repository is part of our ongoing effort to support Vietnamese NLP and make language technology more accessible for low-resource and underrepresented languages.*