Cleanup (#5)

* fix save to local

* remove prefix in utils

* update retrieval with faiss HNSW and better chunking

* save commit

* remove pdf plummer and minimalize requirements.txt

.gitignore

@@ -1,5 +1,7 @@
 .vscode
 pdfs
+app/__pycache__
+
 
 *.png
 *.jpg

README.md

@@ -8,3 +8,8 @@ pinned: false
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+---
+TODO:
++ Apply COhen's Kappa to measure rate of aggreement between human and AI.
+

app.py

@@ -9,6 +9,7 @@ from pydantic import BaseModel
 
 # Import the user's RAGMCQ implementation
 from generator import RAGMCQ
+from utils import log_pipeline
 
 app = FastAPI(title="RAG MCQ Generator API")
 
@@ -36,10 +37,7 @@ def startup_event():
     global rag
 
     # instantiate the heavy object once
-    rag = RAGMCQ(
-        qdrant_url=os.environ['QDRANT_URL'],
-        qdrant_api_key=os.environ['QDRANT_API_KEY']
-    )
+    rag = RAGMCQ()
     print("RAGMCQ instance created on startup.")
 
 @app.get("/health")
@@ -105,8 +103,12 @@ async def generate_saved_endpoint(
             # don't fail the whole request for a validation error — return generator output and note the error
             validation_report = {"error": f"Validation failed: {e}"}
 
+    log_pipeline('test/mcq_output.json', content={"mcqs": mcqs, "validation": validation_report})
+
     return {"mcqs": mcqs, "validation": validation_report}
 
+
+
 @app.post("/generate", response_model=GenerateResponse)
 async def generate_endpoint(
     background_tasks: BackgroundTasks,
@@ -141,7 +143,7 @@ async def generate_endpoint(
 
     background_tasks.add_task(_cleanup, tmp_path)
 
-    # save pdf 
+    # save pdf
     try:
         rag.save_pdf_to_qdrant(tmp_path, filename=qdrant_filename, collection=collection_name, overwrite=True)
     except Exception as e:
@@ -171,6 +173,9 @@ async def generate_endpoint(
             # don't fail the whole request for a validation error — return generator output and note the error
             validation_report = {"error": f"Validation failed: {e}"}
 
+
+    log_pipeline('test/mcq_output.json', content={"mcqs": mcqs, "validation": validation_report})
+
     return {"mcqs": mcqs, "validation": validation_report}
 
 

app/app.py

@@ -9,6 +9,7 @@ from pydantic import BaseModel
 
 # Import the user's RAGMCQ implementation
 from generator import RAGMCQ
+from utils import save_to_local, reset_token_count, get_token_count_record
 
 app = FastAPI(title="RAG MCQ Generator API")
 
@@ -102,6 +103,16 @@ async def generate_saved_endpoint(
             # don't fail the whole request for a validation error — return generator output and note the error
             validation_report = {"error": f"Validation failed: {e}"}
 
+    print("Save result to ../test/mcq_output.json")
+    save_to_local('../test/mcq_output.json', content={"mcqs": mcqs, "validation": validation_report})
+    token_record = get_token_count_record()
+
+    print("Token Record:")
+    for record, value in token_record.items():
+        print(f'{record}:{value}', '\n')
+
+    reset_token_count()
+
     return {"mcqs": mcqs, "validation": validation_report}
 
 @app.post("/generate", response_model=GenerateResponse)
@@ -168,6 +179,17 @@ async def generate_endpoint(
             # don't fail the whole request for a validation error — return generator output and note the error
             validation_report = {"error": f"Validation failed: {e}"}
 
+    print("Save result to ../test/mcq_output.json")
+    save_to_local('../test/mcq_output.json', content={"mcqs": mcqs, "validation": validation_report})
+    token_record = get_token_count_record()
+
+    print("Token Record:")
+    for record, value in token_record.items():
+        print(f'{record}:{value}', '\n')
+
+    reset_token_count()
+    # save_logs(token_record)
+
     return {"mcqs": mcqs, "validation": validation_report}
 
 

app/generator.py

@@ -1,11 +1,13 @@
 import re
 import random
+import fitz
 import numpy as np
-from typing import List, Tuple, Dict, Any, Optional
+import os
+from typing import List, Optional, Tuple, Dict, Any
 from sentence_transformers import SentenceTransformer
 from uuid import uuid4
 import pymupdf4llm
-import pymupdf as fitz
+from utils import save_to_local
 
 try:
     from qdrant_client import QdrantClient
@@ -28,19 +30,19 @@ try:
 except Exception:
     _HAS_FAISS = False
 
-from utils import generate_mcqs_from_text, _post_chat, _safe_extract_json
+from utils import generate_mcqs_from_text, _post_chat, _safe_extract_json, save_to_local
 
 class RAGMCQ:
     def __init__(
         self,
         embedder_model: str = "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2",
-        hf_model: str = "gpt-oss-120b",
-        qdrant_url: str = None,
-        qdrant_api_key: str = None,
+        generation_model: str = "gpt-oss-120b",
+        qdrant_url: str = os.environ.get('QDRANT_URL') or "",
+        qdrant_api_key: str = os.environ.get('QDRANT_API_KEY') or "",
         qdrant_prefer_grpc: bool = False,
     ):
         self.embedder = SentenceTransformer(embedder_model)
-        self.hf_model = hf_model
+        self.generation_model = generation_model
         self.embeddings = None   # np.array of shape (N, D)
         self.texts = []          # list of chunk texts
         self.metadata = []       # list of dicts (page, chunk_id, char_range)
@@ -51,37 +53,45 @@ class RAGMCQ:
         self.qdrant_url = qdrant_url
         self.qdrant_api_key = qdrant_api_key
         self.qdrant_prefer_grpc = qdrant_prefer_grpc
+
         if qdrant_url:
             self.connect_qdrant(qdrant_url, qdrant_api_key, qdrant_prefer_grpc)
 
     def extract_pages(
-        self, 
-        pdf_path: str, 
-        *, 
-        pages: Optional[List[int]] = None,
-        ignore_images: bool = False, 
-        dpi: int = 150
-    ) -> List[str]:
-        doc = fitz.open(pdf_path)
-        try:
-            # request page-wise output (page_chunks=True -> list[dict] per page)
-            page_dicts = pymupdf4llm.to_markdown(
-                doc,
-                pages=pages,
-                ignore_images=ignore_images,
-                dpi=dpi,
-                page_chunks=True,
-            )
+            self,
+            pdf_path: str,
+            *,
+            pages: Optional[List[int]] = None,
+            ignore_images: bool = False,
+            dpi: int = 150
+        ) -> List[str]:
+            doc = fitz.open(pdf_path)
+            try:
+                # request page-wise output (page_chunks=True -> list[dict] per page)
+                page_dicts = pymupdf4llm.to_markdown(
+                    doc,
+                    pages=pages,
+                    ignore_images=ignore_images,
+                    dpi=dpi,
+                    page_chunks=True,
+                )
+
+                # to_markdown(..., page_chunks=True) returns a list of dicts, each has key "text" (markdown)
+                pages_md: List[str] = []
+                for p in page_dicts:
+                    txt = p.get("text", "") or ""
+                    pages_md.append(txt.strip())
 
-            # to_markdown(..., page_chunks=True) returns a list of dicts, each has key "text" (markdown)
-            pages_md: List[str] = []
-            for p in page_dicts:
-                txt = p.get("text", "") or ""
-                pages_md.append(txt.strip())
+                return pages_md
+            finally:
+                doc.close()
 
-            return pages_md
-        finally:
-            doc.close()
+        # pages = []
+        # with pdfplumber.open(pdf_path) as pdf:
+        #     for p in pdf.pages:
+        #         txt = p.extract_text() or ""
+        #         pages.append(txt.strip())
+        # return pages
 
     def chunk_text(self, text: str, max_chars: int = 1200) -> List[str]:
         text = text.strip()
@@ -89,7 +99,7 @@ class RAGMCQ:
             return []
         if len(text) <= max_chars:
             return [text]
-        
+
         # split by sentence-like boundaries
         sentences = re.split(r'(?<=[\.\?\!])\s+', text)
         chunks = []
@@ -116,6 +126,7 @@ class RAGMCQ:
 
     def build_index_from_pdf(self, pdf_path: str, max_chars: int = 1200):
         pages = self.extract_pages(pdf_path)
+
         self.texts = []
         self.metadata = []
 
@@ -128,6 +139,8 @@ class RAGMCQ:
         if not self.texts:
             raise RuntimeError("No text extracted from PDF.")
 
+        save_to_local('../test/text_chunks.md', file_content=self.texts)
+
         # compute embeddings
         emb = self.embedder.encode(self.texts, convert_to_numpy=True, show_progress_bar=True)
         self.embeddings = emb.astype("float32")
@@ -187,7 +200,7 @@ class RAGMCQ:
                 # ask generator
                 try:
                     mcq_block = generate_mcqs_from_text(
-                        chunk_text, n=to_gen, model=self.hf_model, temperature=temperature
+                        chunk_text, n=to_gen, model=self.generation_model, temperature=temperature
                     )
                 except Exception as e:
                     # skip this chunk if generator fails
@@ -199,7 +212,7 @@ class RAGMCQ:
                     output[str(qcount)] = mcq_block[item]
                     if qcount >= n_questions:
                         return output
-                    
+
             return output
 
         elif mode == "rag":
@@ -214,6 +227,10 @@ class RAGMCQ:
                 # create a seed query: pick a random chunk, pick a sentence from it
                 seed_idx = random.randrange(len(self.texts))
                 chunk = self.texts[seed_idx]
+
+                #? Investigate Chunking Strategy
+                with open("chunks.txt", "a", encoding="utf-8") as f: f.write(chunk + "\n")
+
                 sents = re.split(r'(?<=[\.\?\!])\s+', chunk)
                 seed_sent = random.choice([s for s in sents if len(s.strip()) > 20]) if sents else chunk[:200]
                 query = f"Create questions about: {seed_sent}"
@@ -226,12 +243,16 @@ class RAGMCQ:
                     context_parts.append(f"[page {md['page']}] {self.texts[ridx]}")
                 context = "\n\n".join(context_parts)
 
+                save_to_local('../test/context.md', context)
+
+
                 # call generator for 1 question (or small batch) with the retrieved context
                 try:
                     # request 1 question at a time to keep diversity
                     mcq_block = generate_mcqs_from_text(
-                        context, n=1, model=self.hf_model, temperature=temperature
+                        context, n=1, model=self.generation_model, temperature=temperature
                     )
+
                 except Exception as e:
                     print(f"Generator failed during RAG attempt {attempts}: {e}")
                     continue
@@ -242,7 +263,7 @@ class RAGMCQ:
                     output[str(qcount)] = mcq_block[item]
                     if qcount >= n_questions:
                         return output
-                    
+
             return output
         else:
             raise ValueError("mode must be 'per_page' or 'rag'.")
@@ -281,7 +302,7 @@ class RAGMCQ:
             system = {
                 "role": "system",
                 "content": (
-                    "Bạn là một trợ lý đánh giá tính thực chứng của câu hỏi trắc nghiệm dựa trên đoạn văn được cung cấp. "
+                    "Bạn là một trợ lý đánh giá tính thực chứng của câu hỏi trắc nghiệm dựa trên đoạn văn được cung cấp. Luôn trả lời bằng Tiếng Việt"
                     "Hãy trả lời DUY NHẤT bằng JSON hợp lệ (không có văn bản khác) theo schema:\n\n"
                     "{\n"
                     '  "supported": true/false,            # câu trả lời đúng có được nội dung chứng thực không\n'
@@ -303,7 +324,7 @@ class RAGMCQ:
                 )
             }
 
-            raw = _post_chat([system, user], model=self.hf_model, temperature=model_verification_temperature)
+            raw = _post_chat([system, user], model=self.generation_model, temperature=model_verification_temperature)
 
             # parse JSON object in response
             try:
@@ -397,6 +418,7 @@ class RAGMCQ:
 
         # extract pages and chunks (re-using your existing helpers)
         pages = self.extract_pages(pdf_path)
+
         all_chunks = []
         all_meta = []
         for p_idx, page_text in enumerate(pages, start=1):
@@ -406,7 +428,7 @@ class RAGMCQ:
                 all_meta.append({"page": p_idx, "chunk_id": cid, "length": len(ch)})
 
         if not all_chunks:
-            raise RuntimeError("No text extracted from PDF.")
+            raise RuntimeError("No tSext extracted from PDF.")
 
         # ensure collection exists
         self._ensure_collection(collection)
@@ -640,7 +662,7 @@ class RAGMCQ:
                     continue
                 to_gen = questions_per_chunk
                 try:
-                    mcq_block = generate_mcqs_from_text(txt, n=to_gen, model=self.hf_model, temperature=temperature)
+                    mcq_block = generate_mcqs_from_text(txt, n=to_gen, model=self.generation_model, temperature=temperature)
                 except Exception as e:
                     print(f"Generator failed on chunk (index {i}): {e}")
                     continue
@@ -680,7 +702,7 @@ class RAGMCQ:
                 context = "\n\n".join(context_parts)
 
                 try:
-                    mcq_block = generate_mcqs_from_text(context, n=1, model=self.hf_model, temperature=temperature)
+                    mcq_block = generate_mcqs_from_text(context, n=1, model=self.generation_model, temperature=temperature)
                 except Exception as e:
                     print(f"Generator failed during RAG attempt {attempts}: {e}")
                     continue

app/utils.py

@@ -1,88 +0,0 @@
-import re
-import json
-from typing import Dict, Any
-import requests
-import os
-
-#TODO: allow to choose different provider later + dynamic routing when token expired
-API_URL = "https://api.cerebras.ai/v1/chat/completions"
-CEREBRAS_API_KEY = os.environ['CEREBRAS_API_KEY']
-
-HEADERS = {"Authorization": f"Bearer {CEREBRAS_API_KEY}"}
-JSON_OBJ_RE = re.compile(r"(\{[\s\S]*\})", re.MULTILINE)
-
-def _post_chat(messages: list, model: str, temperature: float = 0.2, timeout: int = 60) -> str:
-    payload = {"model": model, "messages": messages, "temperature": temperature}
-    resp = requests.post(API_URL, headers=HEADERS, json=payload, timeout=timeout)
-    resp.raise_for_status()
-    data = resp.json()
-
-    # handle various shapes
-    if "choices" in data and len(data["choices"]) > 0:
-        # prefer message.content
-        ch = data["choices"][0]
-
-        if isinstance(ch, dict) and "message" in ch and "content" in ch["message"]:
-            return ch["message"]["content"]
-
-        if "text" in ch:
-            return ch["text"]
-
-    # final fallback
-    raise RuntimeError("Unexpected HF response shape: " + json.dumps(data)[:200])
-
-def _safe_extract_json(text: str) -> dict:
-    # remove triple backticks
-    text = re.sub(r"```(?:json)?\n?", "", text)
-    m = JSON_OBJ_RE.search(text)
-
-    if not m:
-        raise ValueError("No JSON object found in model output.")
-    js = m.group(1)
-
-    # try load, fix trailing commas
-    try:
-        return json.loads(js)
-    except json.JSONDecodeError:
-        fixed = re.sub(r",\s*([}\]])", r"\1", js)
-        return json.loads(fixed)
-
-def generate_mcqs_from_text(
-    source_text: str,
-    n: int = 3,
-    model: str = "gpt-oss-120b",
-    temperature: float = 0.2,
-) -> Dict[str, Any]:
-    system_message = {
-        "role": "system",
-        "content": (
-            "Bạn là một trợ lý hữu ích chuyên tạo câu hỏi trắc nghiệm. "
-            "Chỉ TRẢ VỀ duy nhất một đối tượng JSON theo đúng schema sau và không có bất kỳ văn bản nào khác:\n\n"
-            "{\n"
-            '  "1": { "câu hỏi": "...", "lựa chọn": {"a":"...","b":"...","c":"...","d":"..."}, "đáp án":"..."},\n'
-            '  "2": { ... }\n'
-            "}\n\n"
-            "Lưu ý:\n"
-            f"- Tạo đúng {n} mục, đánh YOUR_API_KEYsố từ 1 tới {n}.\n"
-            "- Khóa 'lựa chọn' phải có các phím a, b, c, d.\n"
-            "- 'đáp án' phải là toàn văn đáp án đúng (không phải ký tự chữ cái), và giá trị này phải khớp chính xác với một trong các giá trị trong 'lựa chọn'.\n"
-            "- Không kèm giải thích hay trường thêm.\n"
-            "- Các phương án sai (distractors) phải hợp lý và không lặp lại."
-        )
-    }
-    user_message = {
-        "role": "user",
-        "content": (
-            f"Hãy tạo {n} câu hỏi trắc nghiệm từ nội dung dưới đây. Dùng nội dung này làm nguồn duy nhất để trả lời."
-            "Nếu nội dung quá ít để tạo câu hỏi chính xác, hãy tạo các phương án hợp lý nhưng có thể biện minh được.\n\n"
-            f"Nội dung:\n\n{source_text}"
-        )
-    }
-
-    raw = _post_chat([system_message, user_message], model=model, temperature=temperature)
-    parsed = _safe_extract_json(raw)
-
-    # validate structure and length
-    if not isinstance(parsed, dict) or len(parsed) != n:
-        raise ValueError(f"Generator returned invalid structure. Raw:\n{raw}")
-    return parsed

chunks.txt

@@ -0,0 +1,596 @@
+_MỤC LỤC_ _3_
+
+
+2.3 Các công thức tính tích phân mặt loại II . . . . . . . . . . . . . . . . . 153
+
+2.4 Công thức Ostrogradsky . . . . . . . . . . . . . . . . . . . . . . . . . . 157
+
+2.5 Công thức Stokes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
+
+2.6 Công thức liên hệgiữa tích phân mặt loại I và loại II . . . . . . . . . 161
+**Chương 6 . Lý thuyết trường. . . . . . . . . . . . . . . . . . . . . . . . . 165**
+
+
+1 Trường vô hướng . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
+
+1.1 Định nghĩa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
+
+1.2 Đạo hàm theo hướng . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
+
+1.3 Gradient . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
+
+1.4 Bài tập . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
+
+2 Trường véctơ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
+
+2.1 Định nghĩa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
+2.2 Thông lượng, dive, trường ống . . . . . . . . . . . . . . . . . . . . . . . 169
+
+2.3 Hoàn lưu, véctơ xoáy . . . . . . . . . . . . . . .
+**Phương trình tiếp diện của mặt cong cho bởi phương trình tham số**
+
+
+Bài toán: Tìm mặt phẳng tiếp diện của mặt cong S cho bởi phương trình tham số
+
+
+r ( u, v ) = x ( u, v ) . [⃗] i + y ( t ) . [⃗] j + z ( t ) . [⃗] k
+
+
+tại điểm P 0 ứng với u = u 0, v = v 0 . 16
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+x = a sin [2] t
+y = b sin t cos t tại điểm ứng với t = _[π]_ 4 [,] [ (] [a][,][ b][,][ c] [ >] [ 0] [)] [.]
+z = c cos [2] t
+
+
+
+x = [e] [t] [ sin][ t]
+~~√~~ 2
+
+y = 1
+z = [e] [t] [ cos][ t]
+~~√~~ 2
+
+
+
+tại điểm ứng với t = 0. [a]
+
+2 = [y] [−] 2 [b]
+a 0
+
+
+
+2
+
+− c
+
+
+
+_Lời giải_ . a. **–** Phương trình tiếp tuyến: ( d ) : [x] [−] 2 [a]
+
+
+
+0 2 = [z] − [−] c 2 [c]
+
+
+
+**–** Phương trình pháp diện: ( P ) : a �x − 2 [a]
+
+
+
+
+[c] = 0. 2 �
+
+
+
+
+[a] − c z − [c]
+
+2 � � 2
+
+
+
+x = [y] [−] [1]
+
+2 0
+2
+
+
+
+2
+2
+~~√~~ 2
+
+
+
+2 . 2
+
+
+
+b. **–** Phương trình tiếp tuyến: ( d ) : ~~√~~ x
+
+
+
+√
+
+[−] [1] = [z] [−] 2
+
+0 ~~√~~ 2
+
+
+
+**–** Phương trình pháp diện: ( P ) : √
+
+
+
+2 √
+z −
+2 2
+�
+
+
+
+2 √
+2 [x] [ +] 2
+
+
+
+2
+= 0. 2
+�
+
+
+
+**Bài tập 1.6.** Viết phương trình pháp tuyến và tiếp diện của mặt cong:
+
+
+a) x [2] − 4y [2] + 2z [2] = 6 tại điểm ( 2, 2, 3 ) . b) z = 2x [2] + 4y [2] tại điểm ( 2, 1, 12 ) . c) z = ln ( 2x + y ) tại điểm (− 1, 3, 0 )
+
+
+20
+Ta có
+N ⃗ ( t ) = _[γ]_ [′] [(] [t] [)]
+
+| _γ_ ( t )|
+
+
+nên
+N [′] ( t ) =
+
+#### 2.4 Mặt cong trong không gian R [3]
+
+
+Tương tựnhư cách chúng ta biểu diễn đường cong trong không gian bởi một hàm véc tơ
+một tham số r ( t ) = x ( t ) . [⃗] i + y ( t ) . [⃗] j + z ( t ) . [⃗] k, mỗi mặt cong trong không gian được biểu diễn
+tham sốdưới dạng
+r ( u, v ) = x ( u, v ) . [⃗] i + y ( t ) . [⃗] j + z ( t ) . [⃗] k,
+
+
+tức là một hàm véc tơ phụthuộc vào hai tham số u, v. 15
+. . 23
+
+1.1 Định nghĩa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
+
+1.2 Tính tích phân kép trong hệtoạđộDescartes . . . . . . . . . . . . . . 28
+1.3 Phép đổi biến sốtrong tích phân kép . . . . . . . . . . . . . . . . . . . 39
+
+1.4 Bài tập ôn tập . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
+
+2 Tích phân bội ba . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
+2.1 Định nghĩa và tính chất . . . . . . . . . . . . . . . . . . . . . . . . . . 54
+
+2.2 Tính tích phân bội ba trong hệtoạđộDescartes . . . . . . . . . . . . 54
+2.3 Đổi biến sốtrong tích phân bội ba . . . . . . . . . . . . . . . . . . . . . 58
+
+2.4 Bài tập ôn tập . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
+
+3 Các ứng dụng của tích phân bội . . . . . . . . . . . . . . . . . . . . . . . . . . 76
+3.1 Tính diện tích hình phẳng . . . . . . . . . . . . . . . . . . . . . . . . . 76
+3.2 Tính thểtích vật thể . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
+
+3.3 Tính diện tích mặt cong . . . . . . . . . . . . . . . . . . . . . . . . . . 89
+
+
+1
+**AI VIETNAM** **aivietnam.edu.vn**
+
+
+Cảhai biến age ởlần in đầu tiên đều là biến cục bộvì Python sẽưu tiên tìm biến cục bộtrước,
+ởđây là đối số2 truyền vào age. Vì ta không định nghĩa self.age, nên khi gọi, Python sẽtìm đến
+thứtựtiếp theo là biến Class. Chính vì vậy, ta sẽin ra được kết quảage = 1
+
+
+**1.1.2** **Biến toàn cục (Global)**
+
+
+Biến toàn cục được khai báo bên ngoài hàm hoặc class, sửdụng được trên toàn chương trình
+nhưng nên hạn chếđểtránh gây khó kiểm soát. **Không khuyến khích:**
+
+
+1 `counter = 0` `# Global variable`
+
+
+2
+
+
+3 `class MyClass:`
+
+4 `def increment(self):`
+
+
+5 `global counter`
+
+
+6 `counter += 1`
+
+
+**Khuyến khích:**
+
+
+1 `class MyClass:`
+
+
+2 `counter = 0` `# Class attribute`
+
+
+3
+
+
+4 `def increment(self):`
+
+
+5 `MyClass.counter += 1`
+
+### **2 Động lực cho sựra đời của OOP**
+
+
+Trong thực tế, chúng ta luôn tìm cách mô hình hóa các thực thểthực tếthành các đối tượng số
+hóa. Từnhu cầu quản lý và tổchức các thực thểnày, lập trình hướng đối tượng ra đời đểđơn
+giản hóa và tối ưu hóa việc xây dựng phần mềm. Hãy tưởng tượng một thếgiới mạng xã hội, nơi mỗi người dùng chính là một đối tượng (object). Những thông tin như ngày sinh, giới tính, sốđiện thoại...
+ập
+được. - **Biến** **`private`** là thông tin tuyệt mật – chỉlớp khai báo nó mới có quyền truy cập. Lớp
+con không thể“đọc nhật ký” hay can thiệp trực tiếp vào những gì cha mẹkhông cho phép. - **Biến** **`protected`** thì đặc biệt hơn – đây là những “di sản” được truyền lại, chỉdành cho
+các lớp con và không ai khác ngoài hệthống kếthừa được phép sửdụng. Sựphân cấp này giúp bảo vệdữliệu và giữcho hệthống kếthừa hoạt động có tổchức. 7
+**AI VIETNAM** **aivietnam.edu.vn**
+
+
+Cảhai biến age ởlần in đầu tiên đều là biến cục bộvì Python sẽưu tiên tìm biến cục bộtrước,
+ởđây là đối số2 truyền vào age. Vì ta không định nghĩa self.age, nên khi gọi, Python sẽtìm đến
+thứtựtiếp theo là biến Class. Chính vì vậy, ta sẽin ra được kết quảage = 1
+
+
+**1.1.2** **Biến toàn cục (Global)**
+
+
+Biến toàn cục được khai báo bên ngoài hàm hoặc class, sửdụng được trên toàn chương trình
+nhưng nên hạn chếđểtránh gây khó kiểm soát. **Không khuyến khích:**
+
+
+1 `counter = 0` `# Global variable`
+
+
+2
+
+
+3 `class MyClass:`
+
+4 `def increment(self):`
+
+
+5 `global counter`
+
+
+6 `counter += 1`
+
+
+**Khuyến khích:**
+
+
+1 `class MyClass:`
+
+
+2 `counter = 0` `# Class attribute`
+
+
+3
+
+
+4 `def increment(self):`
+
+
+5 `MyClass.counter += 1`
+
+### **2 Động lực cho sựra đời của OOP**
+
+
+Trong thực tế, chúng ta luôn tìm cách mô hình hóa các thực thểthực tếthành các đối tượng số
+hóa. Từnhu cầu quản lý và tổchức các thực thểnày, lập trình hướng đối tượng ra đời đểđơn
+giản hóa và tối ưu hóa việc xây dựng phần mềm. Hãy tưởng tượng một thếgiới mạng xã hội, nơi mỗi người dùng chính là một đối tượng (object). Những thông tin như ngày sinh, giới tính, sốđiện thoại...
+es a function →Output: Hi Alice`
+
+
+2. **Stateful function** : Hàm có thểghi nhớtrạng thái bên trong. 1 `class Counter:`
+
+
+2 `def __init__(self):`
+
+
+3 `self.count = 0`
+
+
+4
+
+
+5 `def __call__(self):`
+
+
+6 `self.count += 1`
+
+
+7 `return self.count`
+
+
+8
+
+
+9 `counter = Counter()`
+
+
+10
+
+
+11 `print(counter())` `# 1`
+
+12 `print(counter())` `# 2`
+
+13 `print(counter())` `# 3`
+
+
+Mỗi lần gọi `counter()` đều ghi nhớtrạng thái trước đó và cộng dồn lên, không giống như
+các phương thức thông thường vốn không lưu trạng thái giữa các lần gọi. 3. **Decorator hoặc Callback handler** : (nâng cao cần tìm hiểu thêm). ## **Phần II: Các tính chất cơ bản trong Object-** **Oriented Programming**
+
+### **5** **Delegation (Ủy quyền)**
+
+
+Delegation (ủy quyền) trong lập trình hướng đối tượng là một kỹthuật trong đó một đối tượng
+ủy thác trách nhiệm thực hiện một hành vi cụthểcho một đối tượng khác. Thay vì kếthừa trực
+
+
+5
+**AI VIETNAM** **aivietnam.edu.vn**
+
+
+Trong Python, `__call__` là một **phương thức đặc biệt** (giống như `__init__`, `__str__`, v.v.)
+được sửdụng khi một đối tượng cần hành xửgiống như một hàm. Nếu một lớp định nghĩa
+`__call__`, thì các _instance_ của lớp đó có thểđược gọi như một hàm thực sự. Phương thức `__call__()` thường được dùng trong ba tình huống phổbiến:
+
+
+1. **Function factory** : Tạo ra các đối tượng có thểxửlý logic như một hàm. 1 `class SayHi:`
+
+2 `def __init__(self, name):`
+
+
+3 `self.name = name`
+
+
+4
+
+
+5 `def hello(self):`
+
+6 `print(f'Hello {self.name}')`
+
+
+7
+
+
+8 `def __call__(self, prefix):`
+
+9 `print(f'{prefix} {self.name}')`
+
+
+10
+
+
+11 `obj = SayHi("Alice")`
+
+12 `obj.hello()`
+
+13 `obj("Hi")` `# __call__ make it becomes a function →Output: Hi Alice`
+
+
+2. **Stateful function** : Hàm có thểghi nhớtrạng thái bên trong.
+### **4.4** **Các lỗhổng được khai thác**
+
+#### **4.4.1 Command injection trong tính năng chuẩn đoán** **ping**
+
+Lỗhổng này có mã CVE là **CVE-2024-51186** [13]. Đây là lỗhổng trong
+dịch vụ **ncc2** của thiết bịnày. Trong dịch vụ **ncc2** này, có một endpoint xử
+lý CGI request là **ping.ccp** . Endpoint này cho phép chuẩn đoán các thiết
+bịqua mạng bằng cách "ping"các thiết bịđó. Dưới đây là ảnh giao diện cho
+phép người dùng tương tác với tính năng này.
+
+
+18
+w.theguardian.com/technology/2017/feb/28/cloudpets-data-breach-leaks-details-of-500000-children-and-adults/)
+[cloudpets-data-breach-leaks-details-of-500000-children-and-adults/.](https://www.theguardian.com/technology/2017/feb/28/cloudpets-data-breach-leaks-details-of-500000-children-and-adults/)
+
+
+33
+# **Chương 2** **Các mối đe dọa vềbảo mật** **trong IoT**
+
+Hệsinh thái IoT đã tạo ra một môi trường đe dọa đa tầng. Các mối đe dọa
+vềmặt bảo mật trong IoT có thểđược được phân loại theo các tầng khác
+nhau trong kiến trúc IoT, đồng thời các phương thức khai thác có thểcó các
+hậu quảkhác nhau.
+
+### **2.1** **Mối đe dọa tầng cảm biến**
+
+#### **2.1.1 Khai thác thiết bịvật lý**
+
+
+Nhiều nhà sản xuất thiết bịIoT thường đểlộchân UART/JTAG hoặc bật
+chếđộconsole gỡlỗi ngay trên thiết bịthương mại. Khi có quyền truy cập vật
+lý, kẻtấn công có thểtrích xuất dữliệu từbộnhớflash, trích xuất firmware,
+chiếm quyền shell root hoặc thậm chí cài đặt firmware có chứa mã độc. [3]
+
+#### **2.1.2 Tấn công side-channel**
+
+
+Bằng cách theo dõi mức tiêu thụđiện năng hay bức xạđiện từcủa thiết bị
+khi thực hiện các phép toán mã hóa và giải mã, người tấn công có thểchiết
+xuất khóa bí mật dùng đểmã hóa/giải mã hoặc trộm cắp dữliệu nhạy cảm
+bên trong. [4]
+
+#### **2.1.3 Chỉnh sửa firmware**
+
+
+Một người tấn công có thểlợi dụng việc thiếu cơ chếxác thực chặt chẽtrong
+quá trình cập nhật firmware qua OTA (Over-The-Air). Họcó thểkhiến thiết
+
+
+6
+w.theguardian.com/technology/2017/feb/28/cloudpets-data-breach-leaks-details-of-500000-children-and-adults/)
+[cloudpets-data-breach-leaks-details-of-500000-children-and-adults/.](https://www.theguardian.com/technology/2017/feb/28/cloudpets-data-breach-leaks-details-of-500000-children-and-adults/)
+
+
+33
+### **4.4** **Các lỗhổng được khai thác**
+
+#### **4.4.1 Command injection trong tính năng chuẩn đoán** **ping**
+
+Lỗhổng này có mã CVE là **CVE-2024-51186** [13]. Đây là lỗhổng trong
+dịch vụ **ncc2** của thiết bịnày. Trong dịch vụ **ncc2** này, có một endpoint xử
+lý CGI request là **ping.ccp** . Endpoint này cho phép chuẩn đoán các thiết
+bịqua mạng bằng cách "ping"các thiết bịđó. Dưới đây là ảnh giao diện cho
+phép người dùng tương tác với tính năng này.
+
+
+18
+### **Ví dụ với đống lớn nhất (max-heap)**
+
+Sau buildHeap() Sau deleteMax() đầu tiên
+### **Ví dụ về sắp xếp trộn (merge sort)**
+
+1 24 26 15 13 2 27 38
+
+
+1 24 26 15 13 2 27 38
+
+
+1 24 26 15 13 2 27 38
+
+
+1 24 26 15 13 2 27 38
+
+
+1 24 15 26 2 13 27 38
+
+
+1 15 24 26 2 13 27 38
+
+
+1 2 13 15 24 26 27 38
+## **Các thuật toán sắp xếp - phần 2**
+
+
+Sắp xếp vun đống (heap sort)
+
+Sắp xếp trộn (merge sort)
+
+Sắp xếp nhanh (quick sort)
+## **Ví dụ về trộn (merge)**
+
+1 15 24 26 2 13 27 38
+
+|1|15|24|26|
+|---|---|---|---|
+|||||
+
+
+|2|13|27|38|
+|---|---|---|---|
+|||||
+
+
+
+1 15 24 26 2 13 27 38 1
+
+|1|15|24|26|
+|---|---|---|---|
+|||||
+
+
+|2|13|27|38|
+|---|---|---|---|
+|||||
+
+
+|1|Col2|Col3|Col4|Col5|Col6|Col7|Col8|
+|---|---|---|---|---|---|---|---|
+|||||||||
+
+
+
+1 15 24 26 2 13 27 38 1 2
+
+|1|15|24|26|
+|---|---|---|---|
+|||||
+
+
+|2|13|27|38|
+|---|---|---|---|
+|||||
+
+
+|1|2|Col3|Col4|Col5|Col6|Col7|Col8|
+|---|---|---|---|---|---|---|---|
+|||||||||
+
+
+
+1 15 24 26 2 13 27 38 1 2 13
+
+
+
+|1|15|24|26|
+|---|---|---|---|
+|||||
+
+Có N bước
+
+
+|2|13|27|38|
+|---|---|---|---|
+|||||
+
+
+|1|2|13|Col4|Col5|Col6|Col7|Col8|
+|---|---|---|---|---|---|---|---|
+|||||||||
+
+Mỗi bước có thể có một phép so sánh và có một phần tử được
+
+chèn vào mảng thứ ba  mỗi bước mất thời gian hằng
+
+ Tổng thời gian là O(N)
+#### **Cài đặt sắp xếp trộn**

generator.py

@@ -1,11 +1,12 @@
 import re
 import random
+import fitz
 import numpy as np
-from typing import List, Tuple, Dict, Any, Optional
+import os
+from typing import List, Optional, Tuple, Dict, Any
 from sentence_transformers import SentenceTransformer
 from uuid import uuid4
 import pymupdf4llm
-import pymupdf as fitz
 
 try:
     from qdrant_client import QdrantClient
@@ -28,19 +29,19 @@ try:
 except Exception:
     _HAS_FAISS = False
 
-from utils import generate_mcqs_from_text, _post_chat, _safe_extract_json
+from utils import generate_mcqs_from_text, _post_chat, _safe_extract_json, save_to_local
 
 class RAGMCQ:
     def __init__(
         self,
         embedder_model: str = "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2",
-        hf_model: str = "gpt-oss-120b",
-        qdrant_url: str = None,
-        qdrant_api_key: str = None,
+        generation_model: str = "gpt-oss-120b",
+        qdrant_url: str = os.environ.get('QDRANT_URL') or "",
+        qdrant_api_key: str = os.environ.get('QDRANT_API_KEY') or "",
         qdrant_prefer_grpc: bool = False,
     ):
         self.embedder = SentenceTransformer(embedder_model)
-        self.hf_model = hf_model
+        self.generation_model = generation_model
         self.embeddings = None   # np.array of shape (N, D)
         self.texts = []          # list of chunk texts
         self.metadata = []       # list of dicts (page, chunk_id, char_range)
@@ -51,56 +52,61 @@ class RAGMCQ:
         self.qdrant_url = qdrant_url
         self.qdrant_api_key = qdrant_api_key
         self.qdrant_prefer_grpc = qdrant_prefer_grpc
+
         if qdrant_url:
             self.connect_qdrant(qdrant_url, qdrant_api_key, qdrant_prefer_grpc)
 
     def extract_pages(
-        self, 
-        pdf_path: str, 
-        *, 
-        pages: Optional[List[int]] = None,
-        ignore_images: bool = False, 
-        dpi: int = 150
-    ) -> List[str]:
-        doc = fitz.open(pdf_path)
-        try:
-            # request page-wise output (page_chunks=True -> list[dict] per page)
-            page_dicts = pymupdf4llm.to_markdown(
-                doc,
-                pages=pages,
-                ignore_images=ignore_images,
-                dpi=dpi,
-                page_chunks=True,
-            )
+            self,
+            pdf_path: str,
+            *,
+            pages: Optional[List[int]] = None,
+            ignore_images: bool = False,
+            dpi: int = 150
+        ) -> List[str]:
+            doc = fitz.open(pdf_path)
+            try:
+                # request page-wise output (page_chunks=True -> list[dict] per page)
+                page_dicts = pymupdf4llm.to_markdown(
+                    doc,
+                    pages=pages,
+                    ignore_images=ignore_images,
+                    dpi=dpi,
+                    page_chunks=True,
+                )
 
-            # to_markdown(..., page_chunks=True) returns a list of dicts, each has key "text" (markdown)
-            pages_md: List[str] = []
-            for p in page_dicts:
-                txt = p.get("text", "") or ""
-                pages_md.append(txt.strip())
+                # to_markdown(..., page_chunks=True) returns a list of dicts, each has key "text" (markdown)
+                pages_md: List[str] = []
+                for p in page_dicts:
+                    txt = p.get("text", "") or ""
+                    pages_md.append(txt.strip())
 
-            return pages_md
-        finally:
-            doc.close()
+                return pages_md
+            finally:
+                doc.close()
 
     def chunk_text(self, text: str, max_chars: int = 1200, overlap: int = 100) -> List[str]:
         text = text.strip()
         if not text:
             return []
+
         if len(text) <= max_chars:
             return [text]
-        
+
         # split by sentence-like boundaries
         sentences = re.split(r'(?<=[\.\?\!])\s+', text)
         chunks = []
         cur = ""
+
         for s in sentences:
             if len(cur) + len(s) + 1 <= max_chars:
                 cur += (" " if cur else "") + s
             else:
                 if cur:
                     chunks.append(cur)
+
                 cur = (cur[-overlap:] + " " + s) if overlap > 0 else s
+
         if cur:
             chunks.append(cur)
 
@@ -112,10 +118,12 @@ class RAGMCQ:
             else:
                 for i in range(0, len(c), max_chars):
                     final.append(c[i:i+max_chars])
+
         return final
 
     def build_index_from_pdf(self, pdf_path: str, max_chars: int = 1200):
         pages = self.extract_pages(pdf_path)
+
         self.texts = []
         self.metadata = []
 
@@ -128,6 +136,8 @@ class RAGMCQ:
         if not self.texts:
             raise RuntimeError("No text extracted from PDF.")
 
+        save_to_local('test/text_chunks.md', content=self.texts)
+
         # compute embeddings
         emb = self.embedder.encode(self.texts, convert_to_numpy=True, show_progress_bar=True)
         self.embeddings = emb.astype("float32")
@@ -188,7 +198,7 @@ class RAGMCQ:
                 # ask generator
                 try:
                     mcq_block = generate_mcqs_from_text(
-                        chunk_text, n=to_gen, model=self.hf_model, temperature=temperature
+                        chunk_text, n=to_gen, model=self.generation_model, temperature=temperature
                     )
                 except Exception as e:
                     # skip this chunk if generator fails
@@ -200,7 +210,7 @@ class RAGMCQ:
                     output[str(qcount)] = mcq_block[item]
                     if qcount >= n_questions:
                         return output
-                    
+
             return output
 
         elif mode == "rag":
@@ -215,13 +225,12 @@ class RAGMCQ:
                 # create a seed query: pick a random chunk, pick a sentence from it
                 seed_idx = random.randrange(len(self.texts))
                 chunk = self.texts[seed_idx]
+
+                #? Investigate Chunking Strategy
+                with open("chunks.txt", "a", encoding="utf-8") as f: f.write(chunk + "\n")
+
                 sents = re.split(r'(?<=[\.\?\!])\s+', chunk)
-                candidate = [s for s in sents if len(s.strip()) > 20]
-                if candidate:
-                    seed_sent = random.choice(candidate)
-                else:
-                    stripped = chunk.strip()
-                    seed_sent = (stripped[:200] if stripped else "[no text available]")
+                seed_sent = random.choice([s for s in sents if len(s.strip()) > 20]) if sents else chunk[:200]
                 query = f"Create questions about: {seed_sent}"
 
                 # retrieve top_k chunks
@@ -232,12 +241,15 @@ class RAGMCQ:
                     context_parts.append(f"[page {md['page']}] {self.texts[ridx]}")
                 context = "\n\n".join(context_parts)
 
+                save_to_local('test/context.md', content=context)
+
                 # call generator for 1 question (or small batch) with the retrieved context
                 try:
                     # request 1 question at a time to keep diversity
                     mcq_block = generate_mcqs_from_text(
-                        context, n=1, model=self.hf_model, temperature=temperature
+                        context, n=1, model=self.generation_model, temperature=temperature
                     )
+
                 except Exception as e:
                     print(f"Generator failed during RAG attempt {attempts}: {e}")
                     continue
@@ -248,7 +260,7 @@ class RAGMCQ:
                     output[str(qcount)] = mcq_block[item]
                     if qcount >= n_questions:
                         return output
-                    
+
             return output
         else:
             raise ValueError("mode must be 'per_page' or 'rag'.")
@@ -287,7 +299,7 @@ class RAGMCQ:
             system = {
                 "role": "system",
                 "content": (
-                    "Bạn là một trợ lý đánh giá tính thực chứng của câu hỏi trắc nghiệm dựa trên đoạn văn được cung cấp. "
+                    "Bạn là một trợ lý đánh giá tính thực chứng của câu hỏi trắc nghiệm dựa trên đoạn văn được cung cấp. Luôn trả lời bằng Tiếng Việt"
                     "Hãy trả lời DUY NHẤT bằng JSON hợp lệ (không có văn bản khác) theo schema:\n\n"
                     "{\n"
                     '  "supported": true/false,            # câu trả lời đúng có được nội dung chứng thực không\n'
@@ -309,7 +321,7 @@ class RAGMCQ:
                 )
             }
 
-            raw = _post_chat([system, user], model=self.hf_model, temperature=model_verification_temperature)
+            raw = _post_chat([system, user], model=self.generation_model, temperature=model_verification_temperature)
 
             # parse JSON object in response
             try:
@@ -403,6 +415,7 @@ class RAGMCQ:
 
         # extract pages and chunks (re-using your existing helpers)
         pages = self.extract_pages(pdf_path)
+
         all_chunks = []
         all_meta = []
         for p_idx, page_text in enumerate(pages, start=1):
@@ -412,7 +425,7 @@ class RAGMCQ:
                 all_meta.append({"page": p_idx, "chunk_id": cid, "length": len(ch)})
 
         if not all_chunks:
-            raise RuntimeError("No text extracted from PDF.")
+            raise RuntimeError("No tSext extracted from PDF.")
 
         # ensure collection exists
         self._ensure_collection(collection)
@@ -646,7 +659,7 @@ class RAGMCQ:
                     continue
                 to_gen = questions_per_chunk
                 try:
-                    mcq_block = generate_mcqs_from_text(txt, n=to_gen, model=self.hf_model, temperature=temperature)
+                    mcq_block = generate_mcqs_from_text(txt, n=to_gen, model=self.generation_model, temperature=temperature)
                 except Exception as e:
                     print(f"Generator failed on chunk (index {i}): {e}")
                     continue
@@ -662,19 +675,19 @@ class RAGMCQ:
             max_attempts = n_questions * 4
             while qcount < n_questions and attempts < max_attempts:
                 attempts += 1
-                # sample a seed sentence from a random chunk of this file
-                seed_idx = random.randrange(len(texts))
-                chunk = texts[seed_idx]
+                # create a seed query: pick a random chunk, pick a sentence from it
+                seed_idx = random.randrange(len(self.texts))
+                chunk = self.texts[seed_idx]
                 sents = re.split(r'(?<=[\.\?\!])\s+', chunk)
-                seed_sent = None
-                for s in sents:
-                    if len(s.strip()) > 20:
-                        seed_sent = s
-                        break
-                if not seed_sent:
-                    seed_sent = chunk[:200]
+                candidate = [s for s in sents if len(s.strip()) > 20]
+                if candidate:
+                    seed_sent = random.choice(candidate)
+                else:
+                    stripped = chunk.strip()
+                    seed_sent = (stripped[:200] if stripped else "[no text available]")
                 query = f"Create questions about: {seed_sent}"
 
+
                 # retrieve top_k chunks from the same file (restricted by filename filter)
                 retrieved = self._retrieve_qdrant(query=query, collection=collection, filename=filename, top_k=top_k)
                 context_parts = []
@@ -686,7 +699,7 @@ class RAGMCQ:
                 context = "\n\n".join(context_parts)
 
                 try:
-                    mcq_block = generate_mcqs_from_text(context, n=1, model=self.hf_model, temperature=temperature)
+                    mcq_block = generate_mcqs_from_text(context, n=1, model=self.generation_model, temperature=temperature)
                 except Exception as e:
                     print(f"Generator failed during RAG attempt {attempts}: {e}")
                     continue

requirements.txt

@@ -1,8 +1,8 @@
 boto3
-pdfplumber
 faiss-cpu
 sentence-transformers
 fastapi[standard]
 uvicorn[standard]
 qdrant-client
 pymupdf4llm
+uuid

test/DeepLearning_mcq_output.json

@@ -0,0 +1,194 @@
+{
+  "mcqs": {
+    "1": {
+      "câu hỏi": "Theo nội dung trên, điểm khác biệt chính của kiến trúc Transformer so với các mô hình trước đó là gì?",
+      "lựa chọn": {
+        "a": "Sử dụng mạng hồi tiếp (recurrent) để mô hình hoá phụ thuộc dài hạn",
+        "b": "Dựa hoàn toàn vào cơ chế attention mà không có bất kỳ thành phần hồi tiếp nào",
+        "c": "Áp dụng các lớp convolution để tính toán các biểu diễn ẩn",
+        "d": "Chỉ sử dụng các lớp feed‑forward điểm‑điểm mà không có attention"
+      },
+      "đáp án": "Dựa hoàn toàn vào cơ chế attention mà không có bất kỳ thành phần hồi tiếp nào"
+    },
+    "2": {
+      "câu hỏi": "Trong quá trình huấn luyện các mô hình được mô tả, thuật toán tối ưu nào đã được sử dụng?",
+      "lựa chọn": {
+        "a": "Adam optimizer",
+        "b": "Stochastic Gradient Descent (SGD)",
+        "c": "RMSprop",
+        "d": "Adagrad"
+      },
+      "đáp án": "Adam optimizer"
+    },
+    "3": {
+      "câu hỏi": "Theo Bảng 3, mô hình Transformer cơ bản (base) đạt điểm BLEU bao nhiêu trên tập phát triển English‑to‑German (newstest2013)?",
+      "lựa chọn": {
+        "a": "25.8",
+        "b": "24.9",
+        "c": "26.4",
+        "d": "23.7"
+      },
+      "đáp án": "25.8"
+    },
+    "4": {
+      "câu hỏi": "Theo mô tả trong tài liệu, số bước warmup (warmup steps) được sử dụng trong quá trình huấn luyện là bao nhiêu?",
+      "lựa chọn": {
+        "a": "2000",
+        "b": "4000",
+        "c": "8000",
+        "d": "10000"
+      },
+      "đáp án": "4000"
+    },
+    "5": {
+      "câu hỏi": "Theo nội dung, mô hình Transformer (big) đạt được điểm BLEU bao nhiêu trên nhiệm vụ dịch tiếng Anh‑tiếng Đức WMT 2014?",
+      "lựa chọn": {
+        "a": "28.4",
+        "b": "30.0",
+        "c": "26.5",
+        "d": "27.0"
+      },
+      "đáp án": "28.4"
+    }
+  },
+  "validation": {
+    "1": {
+      "supported_by_embeddings": true,
+      "max_similarity": 0.7559994459152222,
+      "evidence": [
+        {
+          "idx": 9,
+          "page": 2,
+          "score": 0.7559994459152222,
+          "text": "To the best of our knowledge, however, the Transformer is the first transduction model relying\nentirely on self-attention to compute representations of its input and output without using sequencealigned RNNs or convolution. In the following sections, we will describe the Transformer, motivate\nself-attention and discuss its advantages over models such as [17, 18] and [9]. **3** **Model Architecture**\n\n\nMost competitive neural sequence transduction models have an encoder-decoder structure [ 5, 2, 35 ]. Here, the encoder maps an input sequence of symbol representations ( _x_ 1 _, ..., x_ _n_ ) to a sequence\nof continuous representations **z** = ( _z_ 1 _, ..., z_ _n_ ) . Given **z**, the decoder then generates an output\nsequence ( _y_ 1 _, ..., y_ _m_ ) of symbols one element at a time. At each step the model is auto-regressive\n\n[10], consuming the previously generated symbols as additional input when generating the next. 2"
+        },
+        {
+          "idx": 5,
+          "page": 3,
+          "score": 0.6882933974266052,
+          "text": "Figure 1: The Transformer - model architecture.\n\n\nThe Transformer follows this overall architecture using stacked self-attention and point-wise, fully\nconnected layers for both the encoder and decoder, shown in the left and right halves of Figure 1,\nrespectively.\n\n\n**3.1** **Encoder and Decoder Stacks**\n\nthe two sub-layers, followed by layer normalization [ 1 ]. That is, the output of each sub-layer is\nLayerNorm( _x_ + Sublayer( _x_ )), where Sublayer( _x_ ) is the function implemented by the sub-layer\nitself. To facilitate these residual connections, all sub-layers in the model, as well as the embedding\nlayers, produce outputs of dimension _d_ model = 512.\n\nmasking, combined with fact that the output embeddings are offset by one position, ensures that the\npredictions for position _i_ can depend only on the known outputs at positions less than _i_ .\n\n\n**3.2** **Attention**\n\n\n3"
+        },
+        {
+          "idx": 11,
+          "page": 10,
+          "score": 0.6689025163650513,
+          "text": "We\nplan to extend the Transformer to problems involving input and output modalities other than text and\nto investigate local, restricted attention mechanisms to efficiently handle large inputs and outputs\nsuch as images, audio and video. Making generation less sequential is another research goals of ours. The code we used to train and evaluate our models is available at `[https://github.com/](https://github.com/tensorflow/tensor2tensor)`\n`[tensorflow/tensor2tensor](https://github.com/tensorflow/tensor2tensor)` . **Acknowledgements** We are grateful to Nal Kalchbrenner and Stephan Gouws for their fruitful\ncomments, corrections and inspiration. **References**\n\n\n[1] Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. _arXiv preprint_\n_[arXiv:1607.06450](http://arxiv.org/abs/1607.06450)_, 2016. [2] Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly\nlearning to align and translate. _CoRR_, abs/1409.0473, 2014. [3] Denny Britz, A..."
+        }
+      ],
+      "model_verdict": {
+        "supported": true,
+        "confidence": 0.99,
+        "evidence": "the Transformer is the first transduction model relying entirely on self-attention ... without using sequence‑aligned RNNs or convolution.",
+        "reason": "Context explicitly states Transformer relies fully on attention and has no recurrent components."
+      }
+    },
+    "2": {
+      "supported_by_embeddings": true,
+      "max_similarity": 0.6170728206634521,
+      "evidence": [
+        {
+          "idx": 33,
+          "page": 10,
+          "score": 0.6170728206634521,
+          "text": "Our results in Table 4 show that despite the lack of task-specific tuning our model performs surprisingly well, yielding better results than all previously reported models with the exception of the\nRecurrent Neural Network Grammar [8]. In contrast to RNN sequence-to-sequence models [ 37 ], the Transformer outperforms the BerkeleyParser [29] even when training only on the WSJ training set of 40K sentences. **7** **Conclusion**\n\n\nIn this work, we presented the Transformer, the first sequence transduction model based entirely on\nattention, replacing the recurrent layers most commonly used in encoder-decoder architectures with\nmulti-headed self-attention. For translation tasks, the Transformer can be trained significantly faster than architectures based\non recurrent or convolutional layers. On both WMT 2014 English-to-German and WMT 2014\nEnglish-to-French translation tasks, we achieve a new state of the art. In the former task our best\nmodel outperforms even all previously reported ensembl..."
+        },
+        {
+          "idx": 3,
+          "page": 9,
+          "score": 0.5712530016899109,
+          "text": "This task presents specific challenges: the output is subject to strong structural\nconstraints and is significantly longer than the input. Furthermore, RNN sequence-to-sequence\nmodels have not been able to attain state-of-the-art results in small-data regimes [37]. We trained a 4-layer transformer with _d_ _model_ = 1024 on the Wall Street Journal (WSJ) portion of the\nPenn Treebank [ 25 ], about 40K training sentences. We also trained it in a semi-supervised setting,\nusing the larger high-confidence and BerkleyParser corpora from with approximately 17M sentences\n\n[ 37 ]. We used a vocabulary of 16K tokens for the WSJ only setting and a vocabulary of 32K tokens\nfor the semi-supervised setting. We performed only a small number of experiments to select the dropout, both attention and residual\n(section 5.4), learning rates and beam size on the Section 22 development set, all other parameters\nremained unchanged from the English-to-German base translation model. During inference, we\n\n\n9"
+        },
+        {
+          "idx": 10,
+          "page": 8,
+          "score": 0.5459271669387817,
+          "text": "**Label Smoothing** During training, we employed label smoothing of value _ϵ_ _ls_ = 0 _._ 1 [ 36 ]. This\nhurts perplexity, as the model learns to be more unsure, but improves accuracy and BLEU score. **6** **Results**\n\n\n**6.1** **Machine Translation**\n\n\nOn the WMT 2014 English-to-German translation task, the big transformer model (Transformer (big)\nin Table 2) outperforms the best previously reported models (including ensembles) by more than 2 _._ 0\nBLEU, establishing a new state-of-the-art BLEU score of 28 _._ 4 . The configuration of this model is\nlisted in the bottom line of Table 3. Training took 3 _._ 5 days on 8 P100 GPUs. Even our base model\nsurpasses all previously published models and ensembles, at a fraction of the training cost of any of\nthe competitive models. On the WMT 2014 English-to-French translation task, our big model achieves a BLEU score of 41 _._ 0,\noutperforming all of the previously published single models, at less than 1 _/_ 4 the training cost of the\nprevious..."
+        }
+      ],
+      "model_verdict": {
+        "supported": false,
+        "confidence": 0.99,
+        "evidence": "",
+        "reason": "Trong đoạn văn cung cấp không có thông tin nào đề cập đến thuật toán tối ưu được sử dụng, vì vậy không thể chứng thực đáp án 'Adam optimizer'."
+      }
+    },
+    "3": {
+      "supported_by_embeddings": true,
+      "max_similarity": 0.7403339743614197,
+      "evidence": [
+        {
+          "idx": 24,
+          "page": 8,
+          "score": 0.7403339743614197,
+          "text": "Table 2: The Transformer achieves better BLEU scores than previous state-of-the-art models on the\nEnglish-to-German and English-to-French newstest2014 tests at a fraction of the training cost. BLEU Training Cost (FLOPs)\nModel\n\nEN-DE EN-FR EN-DE EN-FR\nByteNet [18] 23.75\nDeep-Att + PosUnk [39] 39.2 1 _._ 0 _·_ 10 [20]\n\nGNMT + RL [38] 24.6 39.92 2 _._ 3 _·_ 10 [19] 1 _._ 4 _·_ 10 [20]\n\nConvS2S [9] 25.16 40.46 9 _._ 6 _·_ 10 [18] 1 _._ 5 _·_ 10 [20]\n\nMoE [32] 26.03 40.56 2 _._ 0 _·_ 10 [19] 1 _._ 2 _·_ 10 [20]\n\nDeep-Att + PosUnk Ensemble [39] 40.4 8 _._ 0 _·_ 10 [20]\n\nGNMT + RL Ensemble [38] 26.30 41.16 1 _._ 8 _·_ 10 [20] 1 _._ 1 _·_ 10 [21]\n\nConvS2S Ensemble [9] 26.36 **41.29** 7 _._ 7 _·_ 10 [19] 1 _._ 2 _·_ 10 [21]\n\nTransformer (base model) 27.3 38.1 **3** _**.**_ **3** _**·**_ **10** **[18]**\n\nTransformer (big) **28.4** **41.8** 2 _._ 3 _·_ 10 [19]\n\n\n**Residual Dropout** We apply dropout [ 33 ] to the output of each sub-layer, before it is added to the\nsub-layer input and normalized. ..."
+        },
+        {
+          "idx": 1,
+          "page": 9,
+          "score": 0.6753625273704529,
+          "text": "Table 3: Variations on the Transformer architecture. Unlisted values are identical to those of the base\nmodel. All metrics are on the English-to-German translation development set, newstest2013. Listed\nperplexities are per-wordpiece, according to our byte-pair encoding, and should not be compared to\nper-word perplexities. |Col1|train<br>N d d h d d P ϵ<br>model ff k v drop ls steps|PPL BLEU params<br>(dev) (dev) ×106|\n|---|---|---|\n|base|6<br>512<br>2048<br>8<br>64<br>64<br>0.1<br>0.1<br>100K|4.92<br>25.8<br>65|\n|(A)|1<br>512<br>512<br>4<br>128<br>128<br>16<br>32<br>32<br>32<br>16<br>16|5.29<br>24.9<br>5.00<br>25.5<br>4.91<br>25.8<br>5.01<br>25.4|\n|(B)|16<br>32|5.16<br>25.1<br>58<br>5.01<br>25.4<br>60|\n|(C)|2<br>4<br>8<br>256<br>32<br>32<br>1024<br>128<br>128<br>1024<br>4096|6.11<br>23.7<br>36<br>5.19<br>25.3<br>50<br>4.88<br>25.5<br>80<br>5.75<br>24.5<br>28<br>4.66<br>26.0<br>168<br>5.12<br>25.4<br>53<br>4.75<br>26.2<br>90|\n|(D)|0.0<br>0.2<br>0.0<br>0.2|5.77<br>24.6<br>4.95<br>25.5<br..."
+        },
+        {
+          "idx": 9,
+          "page": 2,
+          "score": 0.5718259811401367,
+          "text": "To the best of our knowledge, however, the Transformer is the first transduction model relying\nentirely on self-attention to compute representations of its input and output without using sequencealigned RNNs or convolution. In the following sections, we will describe the Transformer, motivate\nself-attention and discuss its advantages over models such as [17, 18] and [9]. **3** **Model Architecture**\n\n\nMost competitive neural sequence transduction models have an encoder-decoder structure [ 5, 2, 35 ]. Here, the encoder maps an input sequence of symbol representations ( _x_ 1 _, ..., x_ _n_ ) to a sequence\nof continuous representations **z** = ( _z_ 1 _, ..., z_ _n_ ) . Given **z**, the decoder then generates an output\nsequence ( _y_ 1 _, ..., y_ _m_ ) of symbols one element at a time. At each step the model is auto-regressive\n\n[10], consuming the previously generated symbols as additional input when generating the next. 2"
+        }
+      ],
+      "model_verdict": {
+        "supported": true,
+        "confidence": 0.99,
+        "evidence": "base|6 512 2048 8 64 64 0.1 0.1 100K|4.92 25.8 65",
+        "reason": "Bảng 3 liệt kê mô hình Transformer (base) với BLEU = 25.8 trên tập phát triển newstest2013, khớp với đáp án."
+      }
+    },
+    "4": {
+      "supported_by_embeddings": true,
+      "max_similarity": 0.6373076438903809,
+      "evidence": [
+        {
+          "idx": 36,
+          "page": 7,
+          "score": 0.6373076438903809,
+          "text": "Each training\nbatch contained a set of sentence pairs containing approximately 25000 source tokens and 25000\ntarget tokens. **5.2** **Hardware and Schedule**\n\n\nWe trained our models on one machine with 8 NVIDIA P100 GPUs. For our base models using\nthe hyperparameters described throughout the paper, each training step took about 0.4 seconds. We\ntrained the base models for a total of 100,000 steps or 12 hours. For our big models,(described on the\nbottom line of table 3), step time was 1.0 seconds. The big models were trained for 300,000 steps\n(3.5 days). **5.3** **Optimizer**\n\n\nWe used the Adam optimizer [ 20 ] with _β_ 1 = 0 _._ 9, _β_ 2 = 0 _._ 98 and _ϵ_ = 10 _[−]_ [9] . We varied the learning\nrate over the course of training, according to the formula:\n\n\n_lrate_ = _d_ _[−]_ model [0] _[.]_ [5] _[·]_ [ min(] _[step]_ [_] _[num]_ _[−]_ [0] _[.]_ [5] _[, step]_ [_] _[num][ ·][ warmup]_ [_] _[steps]_ _[−]_ [1] _[.]_ [5] [)] (3)\n\n\nThis corresponds to increasing the learning rate linearly f..."
+        }
+      ],
+      "model_verdict": {
+        "supported": true,
+        "confidence": 0.99,
+        "evidence": "We used _warmup_ _ _steps_ = 4000.",
+        "reason": "Context explicitly states that warmup steps were set to 4000, matching the answer."
+      }
+    },
+    "5": {
+      "supported_by_embeddings": true,
+      "max_similarity": 0.7000005841255188,
+      "evidence": [
+        {
+          "idx": 24,
+          "page": 8,
+          "score": 0.7000005841255188,
+          "text": "Table 2: The Transformer achieves better BLEU scores than previous state-of-the-art models on the\nEnglish-to-German and English-to-French newstest2014 tests at a fraction of the training cost. BLEU Training Cost (FLOPs)\nModel\n\nEN-DE EN-FR EN-DE EN-FR\nByteNet [18] 23.75\nDeep-Att + PosUnk [39] 39.2 1 _._ 0 _·_ 10 [20]\n\nGNMT + RL [38] 24.6 39.92 2 _._ 3 _·_ 10 [19] 1 _._ 4 _·_ 10 [20]\n\nConvS2S [9] 25.16 40.46 9 _._ 6 _·_ 10 [18] 1 _._ 5 _·_ 10 [20]\n\nMoE [32] 26.03 40.56 2 _._ 0 _·_ 10 [19] 1 _._ 2 _·_ 10 [20]\n\nDeep-Att + PosUnk Ensemble [39] 40.4 8 _._ 0 _·_ 10 [20]\n\nGNMT + RL Ensemble [38] 26.30 41.16 1 _._ 8 _·_ 10 [20] 1 _._ 1 _·_ 10 [21]\n\nConvS2S Ensemble [9] 26.36 **41.29** 7 _._ 7 _·_ 10 [19] 1 _._ 2 _·_ 10 [21]\n\nTransformer (base model) 27.3 38.1 **3** _**.**_ **3** _**·**_ **10** **[18]**\n\nTransformer (big) **28.4** **41.8** 2 _._ 3 _·_ 10 [19]\n\n\n**Residual Dropout** We apply dropout [ 33 ] to the output of each sub-layer, before it is added to the\nsub-layer input and normalized. ..."
+        },
+        {
+          "idx": 1,
+          "page": 9,
+          "score": 0.5974264144897461,
+          "text": "Table 3: Variations on the Transformer architecture. Unlisted values are identical to those of the base\nmodel. All metrics are on the English-to-German translation development set, newstest2013. Listed\nperplexities are per-wordpiece, according to our byte-pair encoding, and should not be compared to\nper-word perplexities. |Col1|train<br>N d d h d d P ϵ<br>model ff k v drop ls steps|PPL BLEU params<br>(dev) (dev) ×106|\n|---|---|---|\n|base|6<br>512<br>2048<br>8<br>64<br>64<br>0.1<br>0.1<br>100K|4.92<br>25.8<br>65|\n|(A)|1<br>512<br>512<br>4<br>128<br>128<br>16<br>32<br>32<br>32<br>16<br>16|5.29<br>24.9<br>5.00<br>25.5<br>4.91<br>25.8<br>5.01<br>25.4|\n|(B)|16<br>32|5.16<br>25.1<br>58<br>5.01<br>25.4<br>60|\n|(C)|2<br>4<br>8<br>256<br>32<br>32<br>1024<br>128<br>128<br>1024<br>4096|6.11<br>23.7<br>36<br>5.19<br>25.3<br>50<br>4.88<br>25.5<br>80<br>5.75<br>24.5<br>28<br>4.66<br>26.0<br>168<br>5.12<br>25.4<br>53<br>4.75<br>26.2<br>90|\n|(D)|0.0<br>0.2<br>0.0<br>0.2|5.77<br>24.6<br>4.95<br>25.5<br..."
+        },
+        {
+          "idx": 32,
+          "page": 1,
+          "score": 0.5703283548355103,
+          "text": "Experiments on two machine translation tasks show these models to\nbe superior in quality while being more parallelizable and requiring significantly\nless time to train. Our model achieves 28.4 BLEU on the WMT 2014 Englishto-German translation task, improving over the existing best results, including\nensembles, by over 2 BLEU. On the WMT 2014 English-to-French translation task,\nour model establishes a new single-model state-of-the-art BLEU score of 41.8 after\ntraining for 3.5 days on eight GPUs, a small fraction of the training costs of the\nbest models from the literature. We show that the Transformer generalizes well to\nother tasks by applying it successfully to English constituency parsing both with\nlarge and limited training data. _∗_ Equal contribution. Listing order is random. Jakob proposed replacing RNNs with self-attention and started\nthe effort to evaluate this idea. Ashish, with Illia, designed and implemented the first Transformer models and\nhas been crucially involved in eve..."
+        }
+      ],
+      "model_verdict": {
+        "supported": true,
+        "confidence": 0.99,
+        "evidence": "Transformer (big) **28.4** ...; Our model achieves 28.4 BLEU on the WMT 2014 English-to-German translation task",
+        "reason": "Context explicitly states that the Transformer (big) model achieved a BLEU score of 28.4 on the English‑German WMT 2014 task."
+      }
+    }
+  }
+}

test/ML_mcq_output.json

@@ -0,0 +1,206 @@
+{
+  "mcqs": {
+    "1": {
+      "câu hỏi": "Trong thuật toán K-Means, centroid của một cụm được định nghĩa như thế nào?",
+      "lựa chọn": {
+        "a": "Là điểm dữ liệu ngẫu nhiên được chọn làm trung tâm ban đầu của cụm.",
+        "b": "Là trung tâm hình học (geometric center) của tất cả các điểm trong cụm, tính bằng trung bình cộng các điểm thuộc cụm.",
+        "c": "Là điểm dữ liệu có khoảng cách lớn nhất tới các điểm còn lại trong cùng cụm.",
+        "d": "Là vị trí trung bình của các centroid của các cụm khác."
+      },
+      "đáp án": "Là trung tâm hình học (geometric center) của tất cả các điểm trong cụm, tính bằng trung bình cộng các điểm thuộc cụm."
+    },
+    "2": {
+      "câu hỏi": "Trong đoạn triển khai lớp KMeans bằng NumPy, câu lệnh nào sau đây khởi tạo các centroid một cách ngẫu nhiên?",
+      "lựa chọn": {
+        "a": "self.centroids = X[np.random.choice(X.shape[0], self.k, replace=False)]",
+        "b": "self.centroids = np.random.rand(self.k, X.shape[1])",
+        "c": "self.centroids = X[:self.k]",
+        "d": "self.centroids = np.zeros((self.k, X.shape[1]))"
+      },
+      "đáp án": "self.centroids = X[np.random.choice(X.shape[0], self.k, replace=False)]"
+    },
+    "3": {
+      "câu hỏi": "Trong mục \"Các thuộc tính của thuật toán K-means Clustering\" của tài liệu, đâu là mục không được liệt kê là một thuộc tính của thuật toán K-means?",
+      "lựa chọn": {
+        "a": "Thuộc tính thứ nhất của thuật toán K-means",
+        "b": "Thuộc tính thứ hai của thuật toán K-means",
+        "c": "Tại sao chúng ta cần phân cụm?",
+        "d": "Ứng dụng của phân cụm trong thực tế"
+      },
+      "đáp án": "Ứng dụng của phân cụm trong thực tế"
+    },
+    "4": {
+      "câu hỏi": "Trong thuật toán K-Means, bước nào được mô tả là “Mỗi điểm dữ liệu x_i được gán nhãn cụm l_i bằng cách chọn centroid gần nhất”?",
+      "lựa chọn": {
+        "a": "Bước khởi tạo (Initialization Step)",
+        "b": "Bước gán nhãn (Assignment Step)",
+        "c": "Bước cập nhật centroid (Update Step)",
+        "d": "Bước kiểm tra hội tụ (Convergence Check Step)"
+      },
+      "đáp án": "Bước gán nhãn (Assignment Step)"
+    },
+    "5": {
+      "câu hỏi": "Trong đoạn mã triển khai K-Means++, phương thức nào được sử dụng để khởi tạo centroids?",
+      "lựa chọn": {
+        "a": "kmeans_text.fit",
+        "b": "kmeans_plus_plus_init",
+        "c": "np.linalg.norm",
+        "d": "np.array"
+      },
+      "đáp án": "kmeans_plus_plus_init"
+    }
+  },
+  "validation": {
+    "1": {
+      "supported_by_embeddings": true,
+      "max_similarity": 0.6017358303070068,
+      "evidence": [
+        {
+          "idx": 18,
+          "page": 9,
+          "score": 0.6017358303070068,
+          "text": "**AI VIETNAM** **aivietnam.edu.vn**\n\n\nvà nợcao, trong khi cụm xanh có thu nhập cao nhưng nợthấp. Rõ ràng cụm phân chia trong trường\nhợp II hợp lý hơn. Như vậy, các điểm dữliệu từcác cụm khác nhau nên khác biệt nhiều nhất có thểđểtạo thành các\ncụm có ý nghĩa hơn. Thuật toán K-means dùng phương pháp lặp đểtìm phân cụm tối ưu bằng cách\ngiảm thiểu tổng bình phương khoảng cách giữa các điểm và centroid của cụm. **5.3** **Tại sao chúng ta cần phân cụm?**\n\n\nChúng ta đã hiểu phân cụm là gì và các thuộc tính khác nhau của cụm. Vậy tại sao phải dùng phân\ncụm? Phần tiếp theo sẽgiải đáp thắc mắc này và giới thiệu một sốứng dụng thực tế. **6** **Ứng dụng của phân cụm trong thực tế**\n\n\nPhân cụm được sửdụng rộng rãi trong nhiều lĩnh vực, từngân hàng, hệthống đềxuất, đến phân cụm\nvăn bản và phân đoạn ảnh. - **Phân đoạn khách hàng:** Đây là ứng dụng phổbiến nhất của phân cụm, không chỉtrong ngân\nhàng mà còn trong viễn thông, thương mại điện tử, thểthao, quảng cáo, bán hàng,... - **Phân cụm văn bản:** N..."
+        },
+        {
+          "idx": 29,
+          "page": 5,
+          "score": 0.5860570669174194,
+          "text": "**AI VIETNAM** **aivietnam.edu.vn**\n\n\n**4** **Thuật toán K-Means**\n\n\nThuật toán K-Means hoạt động như sau:\n\n\n1. **Đầu vào:** Tập dữliệu _X_ = _{x_ 1 _, x_ 2 _, . . ., x_ _n_ _}_ và sốlượng cụm _k_ .\n\n\n2. **Đầu ra:** Tập các centroid _{c_ 1 _, c_ 2 _, . . ., c_ _k_ _}_ và nhãn cụm tương ứng cho mỗi điểm dữliệu _{l_ 1 _, l_ 2 _, . . ., l_ _n_ _}_ .\n\n\n3. **Khởi tạo:** Chọn ng��u nhiên _k_ centroid ban đầu.\n\n\nHình 1: Chọn k centroid ban đầu\n\n\n4. **Khởi tạo biến** `converged` bằng `false` đểkiểm soát vòng lặp.\n\n\n5. **Lặp cho đến khi hội tụhoặc đạt sốlần lặp tối đa:**\n\n\n    - **Bước gán nhãn (Assignment Step):** Mỗi điểm dữliệu _x_ _i_ được gán nhãn cụm _l_ _i_ bằng\ncách chọn centroid gần nhất:\n_l_ _i_ = arg min _∥x_ _i_ _−_ _c_ _j_ _∥_ [2]\n_j_\n\n\nHình 2: Bước gán nhãn\n\n\n4"
+        },
+        {
+          "idx": 3,
+          "page": 18,
+          "score": 0.5734704732894897,
+          "text": "**AI VIETNAM** **aivietnam.edu.vn**\n\n\n**4** **Bước 4: Triển khai thuật toán K-Means chính**\n\n\nTiếp theo, chúng ta sẽđịnh nghĩa một sốđiều kiện đểtriển khai thuật toán K-Means Clustering."
+        }
+      ],
+      "model_verdict": {
+        "supported": false,
+        "confidence": 0.9,
+        "evidence": "",
+        "reason": "Trong ngữ cảnh không có câu nào mô tả centroid là trung tâm hình học hay tính bằng trung bình cộng các điểm; chỉ đề cập tới việc giảm thiểu khoảng cách và khởi tạo centroid ngẫu nhiên."
+      }
+    },
+    "2": {
+      "supported_by_embeddings": true,
+      "max_similarity": 0.5771877765655518,
+      "evidence": [
+        {
+          "idx": 15,
+          "page": 17,
+          "score": 0.5771877765655518,
+          "text": "**AI VIETNAM** **aivietnam.edu.vn**\n\n\n12 `plt.ylabel(’Loan` `Amount (Thousands) ’)`\n\n13 `plt.show ()`\n\n\nListing 3: Chọn biến và trực quan hóa dữliệu\n\n\n**3** **Bước 3: Chọn sốcụm và khởi tạo centroids**\n\n\nBước 1 và 2 của K-Means là vềviệc chọn sốlượng cụm (k) và chọn các centroids ngẫu nhiên cho mỗi\ncụm. Chúng ta sẽchọn 3 cụm và sau đó chọn các quan sát ngẫu nhiên từdữliệu làm centroids:\n\n\n1 `# Step 1 and 2 - Choose the number of clusters (k) and` `randomly` `select` `centroids` `for`\n\n```\n    each cluster\n\n```\n\n2\n\n\n3 `# number of clusters`\n\n\n4 `K = 3`\n\n\n5\n\n\n6 `# Randomly` `select` `observations as centroids`\n\n7 `Centroids = X.sample(n=K)`\n\n8 `plt.scatter(X[\" ApplicantIncome \"], X[\" LoanAmount \"], c=’black ’)`\n\n9 `plt.scatter(Centroids [\" ApplicantIncome \"], Centroids [\" LoanAmount \"], c=’red ’)`\n\n10 `plt.xlabel(’Annual Income ’)`\n\n11 `plt.ylabel(’Loan` `Amount (Thousands) ’)`\n\n\nListing 4: Chọn sốcụm và khởi tạo centroids\n\n\nỞđây, các chấm đỏđại diện cho 3 centroids của mỗi cụm. Lưu ý rằ..."
+        },
+        {
+          "idx": 20,
+          "page": 18,
+          "score": 0.5511029958724976,
+          "text": "Hãy\n\nxem mã trước:\n\n\n1 `# Step 3 - Assign all points to the` `nearest` `cluster` `centroid`\n\n2 `# Step 4 - Recalculate` `the` `centroids of the newly` `formed` `clusters`\n\n3 `# Step 5 - Repeat` `steps 3 and 4`\n\n\n4\n\n\n5 `diff = 1`\n\n\n6 `j = 0`\n\n\n7\n\n\n8 `while` `diff != 0:`\n\n\n9 `XD = X.copy ()`\n\n\n10 `i = 1`\n\n\n11 `for index1, row_c in Centroids.iterrows ():`\n\n\n12 `ED = []`\n\n\n13 `for index2, row_d in XD.iterrows ():`\n\n14 `d1 = (row_c [\" ApplicantIncome \"] - row_d [\" ApplicantIncome \"]) **2`\n\n15 `d2 = (row_c [\" LoanAmount \"] - row_d [\" LoanAmount \"]) **2`\n\n16 `d = np.sqrt(d1 + d2)`\n\n17 `ED.append(d)`\n\n18 `X[i] = ED`\n\n\n19 `i += 1`\n\n\n20\n\n\n21 `C = []`\n\n\n22 `for index, row in X.iterrows ():`\n\n23 `min_dist = row [1]`\n\n\n24 `pos = 1`\n\n25 `for i in range(K):`\n\n26 `if row[i + 1] < min_dist:`\n\n\n27 `min_dist = row[i + 1]`\n\n\n28 `pos = i + 1`\n\n29 `C.append(pos)`\n\n30 `X[\" Cluster \"] = C`\n\n31 `Centroids_new = X.groupby ([\" Cluster \"]).mean ()[[\" LoanAmount\", \" ApplicantIncome \"]]`\n\n\n32\n\n\n33 `if j == 0:`\n\n\n34..."
+        },
+        {
+          "idx": 30,
+          "page": 15,
+          "score": 0.550550639629364,
+          "text": "**AI VIETNAM** **aivietnam.edu.vn**\n\n\n21 `return np.array(centroids)`\n\n\n22\n\n\n23 `# Using K-Means ++`\n\n24 `class` `KMeansPlusPlus(KMeans):`\n\n\n25 `def fit(self, X):`\n\n\n26 `# Use K-Means ++ initialization`\n\n\n27 `self.centroids = kmeans_plus_plus_init (X, self.k)`\n\n\n28\n\n\n29 `# Continue as in regular K-Means`\n\n30 `for i in range` `(self.max_iters):`\n\n31 `distances = np.linalg.norm(X[:, np.newaxis, :] - self.centroids, axis =2)`\n\n32 `labels = np.argmin(distances, axis =1)`\n\n\n33\n\n\n34 `new_centroids = np.array ([X[labels == j]. mean(axis =0) for j in range` `(self.`\n```\n    k)])\n\n```\n\n35\n\n\n36 `if np.` `all` `(np.` `abs` `(self.centroids - new_centroids ) < 1e-4):`\n\n\n37 `break`\n\n\n38\n\n\n39 `self.centroids = new_centroids`\n\n\n40\n\n\n41 `return` `labels`\n\n\n14"
+        }
+      ],
+      "model_verdict": {
+        "supported": false,
+        "confidence": 0.9,
+        "evidence": "",
+        "reason": "Trong ngữ cảnh chỉ đề cập đến việc chọn centroids ngẫu nhiên bằng X.sample(n=K) hoặc các phương pháp khác, không có câu lệnh self.centroids = X[np.random.choice(...)] được nêu."
+      }
+    },
+    "3": {
+      "supported_by_embeddings": true,
+      "max_similarity": 0.7246736288070679,
+      "evidence": [
+        {
+          "idx": 3,
+          "page": 18,
+          "score": 0.7246736288070679,
+          "text": "**AI VIETNAM** **aivietnam.edu.vn**\n\n\n**4** **Bước 4: Triển khai thuật toán K-Means chính**\n\n\nTiếp theo, chúng ta sẽđịnh nghĩa một sốđiều kiện đểtriển khai thuật toán K-Means Clustering."
+        },
+        {
+          "idx": 13,
+          "page": 4,
+          "score": 0.7182997465133667,
+          "text": "**AI VIETNAM** **aivietnam.edu.vn**\n\n\nBài toán trên là ví dụđiển hình cho việc ứng dụng kỹthuật _clustering_ trong khai phá dữliệu, đặc\nbiệt là thuật toán **K-means clustering**, một trong những phương pháp phân nhóm phổbiến và đơn\ngiản nhất hiện nay. ## **2. Lý thuyết K-Means**\n\n\n**1** **Định nghĩa và Khái niệm cơ bản**\n\n\nK-Means là thuật toán học không giám sát (unsupervised learning) thuộc nhóm phân cụm (clustering),\nnhằm chia tập dữliệu gồm _n_ điểm dữliệu _{x_ 1 _, x_ 2 _, . . ., x_ _n_ _}_ với _x_ _i_ _∈_ R _[d]_ thành _k_ cụm _{C_ 1 _, C_ 2 _, . . ., C_ _k_ _}_\nsao cho:\n\n\n  - **Cohesion (Tính gắn kết)** : Các điểm trong cùng một cụm có độtương tựcao nhất có thể\n\n\n  - **Separation (Tính phân tách)** : Các điểm thuộc cụm khác nhau có độtương tựthấp nhất có\nthể\n\n\n  - **Completeness (Tính đầy đủ)** : Mọi điểm dữliệu đều được gán vào đúng một cụm\n\n\n**2** **Khái niệm Centroid và Cluster**\n\n\n**Centroid** _µ_ _i_ của cụm _C_ _i_ là trung tâm hình học (geometric center) của tất cảcác điể..."
+        },
+        {
+          "idx": 0,
+          "page": 3,
+          "score": 0.6935104727745056,
+          "text": "Đây chính là lúc các thuật toán học máy không giám sát (unsupervised learning) như **K-means**\n**clustering** trởnên rất hữu ích. Thuật toán này cho phép tựđộng phân nhóm dữliệu dựa trên sựtương\nđồng giữa các điểm dữliệu mà không cần thông tin nhãn từtrước. Nhờvậy, K-means giúp phát hiện\ncấu trúc tiềm ẩn trong dữliệu và hỗtrợcác bước phân tích tiếp theo. **2** **Vấn đềcốt lõi**\n\n\nĐểminh họa cho bài toán phân nhóm không giám sát, hãy xem xét một ví dụđơn giản với dữliệu về\ntuổi và chi tiêu hàng tháng của 9 khách hàng như sau:\n\n|Index|Tuổi|Chi tiêu (USD)|\n|---|---|---|\n|1<br>2<br>3<br>4<br>5<br>6<br>7<br>8<br>9|18<br>20<br>22<br>30<br>34<br>40<br>60<br>66<br>70|80<br>90<br>85<br>50<br>64<br>60<br>30<br>40<br>25|\n\n\n\nBảng 1: Dữliệu mẫu vềkhách hàng\n\n\nMục tiêu của bài toán là phân chia tựđộng 9 khách hàng này thành 3 nhóm khác nhau, ví dụnhư\nnhóm _Trẻ_, _Trung niên_ và _Cao tuổi_, dựa trên đặc điểm tuổi tác và chi tiêu, mà không cần biết trước\nnhóm nhãn phân loại. Việc này sẽgiúp doanh nghi..."
+        }
+      ],
+      "model_verdict": {
+        "supported": false,
+        "confidence": 0.9,
+        "evidence": "Context does not contain a list of attributes of K-means nor mention 'Ứng dụng của phân cụm trong thực tế' as an attribute.",
+        "reason": "Không có bằng chứng trong nội dung cung cấp rằng mục này được liệt kê hoặc không được liệt kê; do đó không thể khẳng định đáp án được chứng thực."
+      }
+    },
+    "4": {
+      "supported_by_embeddings": true,
+      "max_similarity": 0.6494988203048706,
+      "evidence": [
+        {
+          "idx": 0,
+          "page": 3,
+          "score": 0.6494988203048706,
+          "text": "Đây chính là lúc các thuật toán học máy không giám sát (unsupervised learning) như **K-means**\n**clustering** trởnên rất hữu ích. Thuật toán này cho phép tựđộng phân nhóm dữliệu dựa trên sựtương\nđồng giữa các điểm dữliệu mà không cần thông tin nhãn từtrước. Nhờvậy, K-means giúp phát hiện\ncấu trúc tiềm ẩn trong dữliệu và hỗtrợcác bước phân tích tiếp theo. **2** **Vấn đềcốt lõi**\n\n\nĐểminh họa cho bài toán phân nhóm không giám sát, hãy xem xét một ví dụđơn giản với dữliệu về\ntuổi và chi tiêu hàng tháng của 9 khách hàng như sau:\n\n|Index|Tuổi|Chi tiêu (USD)|\n|---|---|---|\n|1<br>2<br>3<br>4<br>5<br>6<br>7<br>8<br>9|18<br>20<br>22<br>30<br>34<br>40<br>60<br>66<br>70|80<br>90<br>85<br>50<br>64<br>60<br>30<br>40<br>25|\n\n\n\nBảng 1: Dữliệu mẫu vềkhách hàng\n\n\nMục tiêu của bài toán là phân chia tựđộng 9 khách hàng này thành 3 nhóm khác nhau, ví dụnhư\nnhóm _Trẻ_, _Trung niên_ và _Cao tuổi_, dựa trên đặc điểm tuổi tác và chi tiêu, mà không cần biết trước\nnhóm nhãn phân loại. Việc này sẽgiúp doanh nghi..."
+        },
+        {
+          "idx": 3,
+          "page": 18,
+          "score": 0.6462726593017578,
+          "text": "**AI VIETNAM** **aivietnam.edu.vn**\n\n\n**4** **Bước 4: Triển khai thuật toán K-Means chính**\n\n\nTiếp theo, chúng ta sẽđịnh nghĩa một sốđiều kiện đểtriển khai thuật toán K-Means Clustering."
+        },
+        {
+          "idx": 18,
+          "page": 9,
+          "score": 0.6377543210983276,
+          "text": "**AI VIETNAM** **aivietnam.edu.vn**\n\n\nvà nợcao, trong khi cụm xanh có thu nhập cao nhưng nợthấp. Rõ ràng cụm phân chia trong trường\nhợp II hợp lý hơn. Như vậy, các điểm dữliệu từcác cụm khác nhau nên khác biệt nhiều nhất có thểđểtạo thành các\ncụm có ý nghĩa hơn. Thuật toán K-means dùng phương pháp lặp đểtìm phân cụm tối ưu bằng cách\ngiảm thiểu tổng bình phương khoảng cách giữa các điểm và centroid của cụm. **5.3** **Tại sao chúng ta cần phân cụm?**\n\n\nChúng ta đã hiểu phân cụm là gì và các thuộc tính khác nhau của cụm. Vậy tại sao phải dùng phân\ncụm? Phần tiếp theo sẽgiải đáp thắc mắc này và giới thiệu một sốứng dụng thực tế. **6** **Ứng dụng của phân cụm trong thực tế**\n\n\nPhân cụm được sửdụng rộng rãi trong nhiều lĩnh vực, từngân hàng, hệthống đềxuất, đến phân cụm\nvăn bản và phân đoạn ảnh. - **Phân đoạn khách hàng:** Đây là ứng dụng phổbiến nhất của phân cụm, không chỉtrong ngân\nhàng mà còn trong viễn thông, thương mại điện tử, thểthao, quảng cáo, bán hàng,... - **Phân cụm văn bản:** N..."
+        }
+      ],
+      "model_verdict": {
+        "supported": false,
+        "confidence": 0.9,
+        "evidence": "",
+        "reason": "Trong ngữ cảnh cung cấp không có đoạn nào mô tả bước gán nhãn như “Mỗi điểm dữ liệu x_i được gán nhãn cụm l_i bằng cách chọn centroid gần nhất”, vì vậy không có bằng chứng hỗ trợ đáp án."
+      }
+    },
+    "5": {
+      "supported_by_embeddings": true,
+      "max_similarity": 0.590252161026001,
+      "evidence": [
+        {
+          "idx": 30,
+          "page": 15,
+          "score": 0.590252161026001,
+          "text": "**AI VIETNAM** **aivietnam.edu.vn**\n\n\n21 `return np.array(centroids)`\n\n\n22\n\n\n23 `# Using K-Means ++`\n\n24 `class` `KMeansPlusPlus(KMeans):`\n\n\n25 `def fit(self, X):`\n\n\n26 `# Use K-Means ++ initialization`\n\n\n27 `self.centroids = kmeans_plus_plus_init (X, self.k)`\n\n\n28\n\n\n29 `# Continue as in regular K-Means`\n\n30 `for i in range` `(self.max_iters):`\n\n31 `distances = np.linalg.norm(X[:, np.newaxis, :] - self.centroids, axis =2)`\n\n32 `labels = np.argmin(distances, axis =1)`\n\n\n33\n\n\n34 `new_centroids = np.array ([X[labels == j]. mean(axis =0) for j in range` `(self.`\n```\n    k)])\n\n```\n\n35\n\n\n36 `if np.` `all` `(np.` `abs` `(self.centroids - new_centroids ) < 1e-4):`\n\n\n37 `break`\n\n\n38\n\n\n39 `self.centroids = new_centroids`\n\n\n40\n\n\n41 `return` `labels`\n\n\n14"
+        },
+        {
+          "idx": 29,
+          "page": 5,
+          "score": 0.5836479663848877,
+          "text": "**AI VIETNAM** **aivietnam.edu.vn**\n\n\n**4** **Thuật toán K-Means**\n\n\nThuật toán K-Means hoạt động như sau:\n\n\n1. **Đầu vào:** Tập dữliệu _X_ = _{x_ 1 _, x_ 2 _, . . ., x_ _n_ _}_ và sốlượng cụm _k_ .\n\n\n2. **Đầu ra:** Tập các centroid _{c_ 1 _, c_ 2 _, . . ., c_ _k_ _}_ và nhãn cụm tương ứng cho mỗi điểm dữliệu _{l_ 1 _, l_ 2 _, . . ., l_ _n_ _}_ .\n\n\n3. **Khởi tạo:** Chọn ngẫu nhiên _k_ centroid ban đầu.\n\n\nHình 1: Chọn k centroid ban đầu\n\n\n4. **Khởi tạo biến** `converged` bằng `false` đểkiểm soát vòng lặp.\n\n\n5. **Lặp cho đến khi hội tụhoặc đạt sốlần lặp tối đa:**\n\n\n    - **Bước gán nhãn (Assignment Step):** Mỗi điểm dữliệu _x_ _i_ được gán nhãn cụm _l_ _i_ bằng\ncách chọn centroid gần nhất:\n_l_ _i_ = arg min _∥x_ _i_ _−_ _c_ _j_ _∥_ [2]\n_j_\n\n\nHình 2: Bước gán nhãn\n\n\n4"
+        },
+        {
+          "idx": 32,
+          "page": 2,
+          "score": 0.5471374988555908,
+          "text": ". . . . . . . . . . . . . . . . . . . . . 13\n\n2 K-Means++ Initialization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13\n\n\n**1** **Phần II: Triển khai Thuật toán K-Means từđầu trong Python** **15**\n1 Bước 1: Import các thư viện cần thiết . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15\n2 B��ớc 2: Đọc và khám phá dữliệu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15\n3 Bước 3: Chọn sốcụm và khởi tạo centroids . . . . . . . . . . . . . . . . . . . . . . . . . 16\n4 Bước 4: Triển khai thuật toán K-Means chính . . . . . . . . . . . . . . . . . . . . . . . . 17\n5 Bước 5: Trực quan hóa kết quả . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17\n\n\n1"
+        }
+      ],
+      "model_verdict": {
+        "supported": true,
+        "confidence": 1.0,
+        "evidence": "self.centroids = kmeans_plus_plus_init (X, self.k)",
+        "reason": "Đoạn mã cho thấy centroids được khởi tạo bằng hàm kmeans_plus_plus_init"
+      }
+    }
+  }
+}

test/calculus_mcq_output.json

@@ -0,0 +1,206 @@
+{
+  "mcqs": {
+    "1": {
+      "câu hỏi": "Theo nội dung, khi D là miền hình chữ nhật a ≤ x ≤ b, c ≤ y ≤ d, biểu thức nào sau đây đúng cho tích phân kép \\(\\iint_D f(x,y)\\,dxdy\\)?",
+      "lựa chọn": {
+        "a": "∫_a^b ∫_c^d f(x,y) dy dx",
+        "b": "∫_c^d ∫_a^b f(x,y) dx dy",
+        "c": "∫_a^b ∫_c^d f(x,y) dy dx = ∫_c^d ∫_a^b f(x,y) dx dy",
+        "d": "Không có biểu thức nào đúng"
+      },
+      "đáp án": "∫_a^b ∫_c^d f(x,y) dy dx = ∫_c^d ∫_a^b f(x,y) dx dy"
+    },
+    "2": {
+      "câu hỏi": "Theo Định nghĩa 1.3, một mặt phẳng có phương trình ax + by + cz + d = 0 có thể được biểu diễn tham số như thế nào?",
+      "lựa chọn": {
+        "a": "x = u, y = v, z = -(d + a u + b v)/c",
+        "b": "x = u, y = v, z = d + a u + b v",
+        "c": "x = u, y = v, z = (d - a u - b v)/c",
+        "d": "x = u, y = v, z = (a u + b v - d)/c"
+      },
+      "đáp án": "x = u, y = v, z = -(d + a u + b v)/c"
+    },
+    "3": {
+      "câu hỏi": "Phương trình tiếp tuyến (tangent plane) của mặt cong x² − 4y² + 2z² = 6 tại điểm (2, 2, 3) là:",
+      "lựa chọn": {
+        "a": "x − 4y + 3z = 3",
+        "b": "x + 4y − 3z = 3",
+        "c": "2x − 8y + 6z = 6",
+        "d": "x − 4y + 3z = 0"
+      },
+      "đáp án": "x − 4y + 3z = 3"
+    },
+    "4": {
+      "câu hỏi": "Trong tiêu đề của bài giảng \"GIẢI TÍCH II\" tại Trường Đại học Bách Khoa Hà Nội, các phép tính nào được liệt kê là ứng dụng?",
+      "lựa chọn": {
+        "a": "Các ứng dụng của phép tính vi phân, tích phân bộ, tích phân phụ thuộc tham số, tích phân đường, tích phân mặt, lý thuyết",
+        "b": "Bài giảng về giải tích I",
+        "c": "Giảng viên TS. Bùi Xuân Diệu",
+        "d": "Ngày cập nhật 28 tháng 8 năm 2017"
+      },
+      "đáp án": "Các ứng dụng của phép tính vi phân, tích phân bộ, tích phân phụ thuộc tham số, tích phân đường, tích phân mặt, lý thuyết"
+    },
+    "5": {
+      "câu hỏi": "Khi chia miền R thành m × n hình chữ nhật con có độ dài bằng nhau, ký hiệu của một hình chữ nhật con R_{ij} được cho bởi:",
+      "lựa chọn": {
+        "a": "R_{ij} = [x_i, x_{i+1}] × [y_j, y_{j+1}]",
+        "b": "R_{ij} = [x_{i-1}, x_i] × [y_{j-1}, y_j]",
+        "c": "R_{ij} = [x_{i}, x_{i-1}] × [y_{j}, y_{j-1}]",
+        "d": "R_{ij} = [x_{i-1}, x_{i+1}] × [y_{j-1}, y_{j+1}]"
+      },
+      "đáp án": "R_{ij} = [x_{i-1}, x_i] × [y_{j-1}, y_j]"
+    }
+  },
+  "validation": {
+    "1": {
+      "supported_by_embeddings": true,
+      "max_similarity": 0.8958114981651306,
+      "evidence": [
+        {
+          "idx": 74,
+          "page": 30,
+          "score": 0.8958114981651306,
+          "text": "_28_ _Chương 2. Tích phân bội_\n\n\n**Chú ý 2.3.** Nếu tồn tại tích phân kép f ( x, y ) dxdy thì ta nói hàm số f ( x, y ) khảtích\n��\n\nD\n\ntrong miền D .\n\n\n**Tính chất cơ bản:**\n\n\n  Tính chất tuyến tính:\n\n\n\n��\n\n\n\nf ( x, y ) dxdy +\n��\nD D\n\n\n\n\n[ f ( x, y ) + g ( x, y )] dxdy =\n��\nD D\n\n\n\ng ( x, y ) dxdy\n\nD\n\n\n\n��\n\n\n\nk f ( x, y ) dxdy = k\n��\nD D\n\n\n\nf ( x, y ) dxdy\n\nD\n\n\n\n\n- Tính chất cộng tính: Nếu D = D 1 ∪ D 2, ởđó D 1 và D 2 không \"chồng\" lên nhau (có thể\nngoại trừphần biên) thì\n\n\n\n��\n\n\n\nf ( x, y ) dxdy =\n��\nD D\n\n\n\nf ( x, y ) dxdy.\n\n\n\nD 1\n\n\n\nf ( x, y ) dxdy +\n��\n\nD 2\n\n\n\n\n\n\n\n\n\n\n#### **1.2 Tính tích phân kép trong hệtoạđộDescartes**\n\nĐểtính các tích phân hai lớp, ta cần phải đưa vềtính các tích phân lặp.\n\n\n1. Nếu D là miền hình chữnhật ( D ) : a ⩽ x ⩽ b, c ⩽ y ⩽ d thì ta có thểsửdụng một\ntrong hai tích phân lặp\n\n\n\nd\n\n\ndy\n\n�\n\n\nc\n\n\n\nd\n\n\nf ( x, y ) dx.\n\n�\n\n\nc\n\n\n\nd\n\n\nf ( x, y ) dy =\n\n�\n\n\nc\n\n\n28\n\n\n\nf ( x, y ) dxdy =\n\n��\n\nD\n\n\n\nb\n\n\ndx\n\n�\n\n\na"
+        },
+        {
+          "idx": 50,
+          "page": 30,
+          "score": 0.8958114981651306,
+          "text": "_28_ _Chương 2. Tích phân bội_\n\n\n**Chú ý 2.3.** Nếu tồn tại tích phân kép f ( x, y ) dxdy thì ta nói hàm số f ( x, y ) khảtích\n��\n\nD\n\ntrong miền D .\n\n\n**Tính chất cơ bản:**\n\n\n  Tính chất tuyến tính:\n\n\n\n��\n\n\n\nf ( x, y ) dxdy +\n��\nD D\n\n\n\n\n[ f ( x, y ) + g ( x, y )] dxdy =\n��\nD D\n\n\n\ng ( x, y ) dxdy\n\nD\n\n\n\n��\n\n\n\nk f ( x, y ) dxdy = k\n��\nD D\n\n\n\nf ( x, y ) dxdy\n\nD\n\n\n\n\n- Tính chất cộng tính: Nếu D = D 1 ∪ D 2, ởđó D 1 và D 2 không \"chồng\" lên nhau (có thể\nngoại trừphần biên) thì\n\n\n\n��\n\n\n\nf ( x, y ) dxdy =\n��\nD D\n\n\n\nf ( x, y ) dxdy.\n\n\n\nD 1\n\n\n\nf ( x, y ) dxdy +\n��\n\nD 2\n\n\n\n\n\n\n\n\n\n\n#### **1.2 Tính tích phân kép trong hệtoạđộDescartes**\n\nĐểtính các tích phân hai lớp, ta cần phải đưa vềtính các tích phân lặp.\n\n\n1. Nếu D là miền hình chữnhật ( D ) : a ⩽ x ⩽ b, c ⩽ y ⩽ d thì ta có thểsửdụng một\ntrong hai tích phân lặp\n\n\n\nd\n\n\ndy\n\n�\n\n\nc\n\n\n\nd\n\n\nf ( x, y ) dx.\n\n�\n\n\nc\n\n\n\nd\n\n\nf ( x, y ) dy =\n\n�\n\n\nc\n\n\n28\n\n\n\nf ( x, y ) dxdy =\n\n��\n\nD\n\n\n\nb\n\n\ndx\n\n�\n\n\na"
+        },
+        {
+          "idx": 38,
+          "page": 30,
+          "score": 0.8958114981651306,
+          "text": "_28_ _Chương 2. Tích phân bội_\n\n\n**Chú ý 2.3.** Nếu tồn tại tích phân kép f ( x, y ) dxdy thì ta nói hàm số f ( x, y ) khảtích\n��\n\nD\n\ntrong miền D .\n\n\n**Tính chất cơ bản:**\n\n\n  Tính chất tuyến tính:\n\n\n\n��\n\n\n\nf ( x, y ) dxdy +\n��\nD D\n\n\n\n\n[ f ( x, y ) + g ( x, y )] dxdy =\n��\nD D\n\n\n\ng ( x, y ) dxdy\n\nD\n\n\n\n��\n\n\n\nk f ( x, y ) dxdy = k\n��\nD D\n\n\n\nf ( x, y ) dxdy\n\nD\n\n\n\n\n- Tính chất cộng tính: Nếu D = D 1 ∪ D 2, ởđó D 1 và D 2 không \"chồng\" lên nhau (có thể\nngoại trừphần biên) thì\n\n\n\n��\n\n\n\nf ( x, y ) dxdy =\n��\nD D\n\n\n\nf ( x, y ) dxdy.\n\n\n\nD 1\n\n\n\nf ( x, y ) dxdy +\n��\n\nD 2\n\n\n\n\n\n\n\n\n\n\n#### **1.2 Tính tích phân kép trong hệtoạđộDescartes**\n\nĐểtính các tích phân hai lớp, ta cần phải đưa vềtính các tích phân lặp.\n\n\n1. Nếu D là miền hình chữnhật ( D ) : a ⩽ x ⩽ b, c ⩽ y ⩽ d thì ta có thểsửdụng một\ntrong hai tích phân lặp\n\n\n\nd\n\n\ndy\n\n�\n\n\nc\n\n\n\nd\n\n\nf ( x, y ) dx.\n\n�\n\n\nc\n\n\n\nd\n\n\nf ( x, y ) dy =\n\n�\n\n\nc\n\n\n28\n\n\n\nf ( x, y ) dxdy =\n\n��\n\nD\n\n\n\nb\n\n\ndx\n\n�\n\n\na"
+        }
+      ],
+      "model_verdict": {
+        "supported": true,
+        "confidence": 0.96,
+        "evidence": "Nếu D là miền hình chữ nhật ( D ) : a ≤ x ≤ b, c ≤ y ≤ d thì ta có thể sử dụng một trong hai tích phân lặp ... ∫_a^b ∫_c^d f(x,y) dy dx = ∫_c^d ∫_a^b f(x,y) dx dy",
+        "reason": "Đoạn văn nêu rõ rằng với miền hình chữ nhật, hai dạng tích phân lặp đều đúng và bằng nhau, nên đáp án c được chứng thực."
+      }
+    },
+    "2": {
+      "supported_by_embeddings": true,
+      "max_similarity": 0.7703134417533875,
+      "evidence": [
+        {
+          "idx": 46,
+          "page": 23,
+          "score": 0.7703134417533875,
+          "text": "Vậy:\n\n\n\n12 [−] [1] [=] [y] − [−] 4 [3]\n\n\n\n3\n\n\n\n**–** Phương trình tiếp tuyến ( d ) : [x] 12 [−] [1]\n\n\n\n− [−] 4 [=] [z] [−] 3 [4]\n\n\n\n**–** Phương trình pháp diện ( P ) : 12 ( x − 1 ) − 4 ( y − 3 ) + 3 ( z − 4 ) = 0\n\n\n\nb. Tương tự,\n\n\n\nn f = (− 8, 6, 12 )\n� n g = (− 4, 4, − 1 ) [,][ n] [ f] [ ∧] [n] [g] [ =][ −] [2] [ (] [27, 27, 4] [)] [ nên]\n\n\n\n\n[+] [2] [y] [−] [1]\n\n27 [=] 27\n\n\n\n4\n\n\n\n**–** Phương trình tiếp tuyến ( d ) : [x] 27 [+] [2]\n\n\n\n\n[−] [z] [−] [6]\n\n27 [=] 4\n\n\n\n**–** Phương trình pháp diện ( P ) : 27 ( x + 2 ) + 27 ( y − 1 ) + 4 ( z − 6 ) = 0\n\n\n21"
+        },
+        {
+          "idx": 31,
+          "page": 23,
+          "score": 0.7703134417533875,
+          "text": "Vậy:\n\n\n\n12 [−] [1] [=] [y] − [−] 4 [3]\n\n\n\n3\n\n\n\n**–** Phương trình tiếp tuyến ( d ) : [x] 12 [−] [1]\n\n\n\n− [−] 4 [=] [z] [−] 3 [4]\n\n\n\n**–** Phương trình pháp diện ( P ) : 12 ( x − 1 ) − 4 ( y − 3 ) + 3 ( z − 4 ) = 0\n\n\n\nb. Tương tự,\n\n\n\nn f = (− 8, 6, 12 )\n� n g = (− 4, 4, − 1 ) [,][ n] [ f] [ ∧] [n] [g] [ =][ −] [2] [ (] [27, 27, 4] [)] [ nên]\n\n\n\n\n[+] [2] [y] [−] [1]\n\n27 [=] 27\n\n\n\n4\n\n\n\n**–** Phương trình tiếp tuyến ( d ) : [x] 27 [+] [2]\n\n\n\n\n[−] [z] [−] [6]\n\n27 [=] 4\n\n\n\n**–** Phương trình pháp diện ( P ) : 27 ( x + 2 ) + 27 ( y − 1 ) + 4 ( z − 6 ) = 0\n\n\n21"
+        },
+        {
+          "idx": 23,
+          "page": 23,
+          "score": 0.7703134417533875,
+          "text": "Vậy:\n\n\n\n12 [−] [1] [=] [y] − [−] 4 [3]\n\n\n\n3\n\n\n\n**–** Phương trình tiếp tuyến ( d ) : [x] 12 [−] [1]\n\n\n\n− [−] 4 [=] [z] [−] 3 [4]\n\n\n\n**–** Phương trình pháp diện ( P ) : 12 ( x − 1 ) − 4 ( y − 3 ) + 3 ( z − 4 ) = 0\n\n\n\nb. Tương tự,\n\n\n\nn f = (− 8, 6, 12 )\n� n g = (− 4, 4, − 1 ) [,][ n] [ f] [ ∧] [n] [g] [ =][ −] [2] [ (] [27, 27, 4] [)] [ nên]\n\n\n\n\n[+] [2] [y] [−] [1]\n\n27 [=] 27\n\n\n\n4\n\n\n\n**–** Phương trình tiếp tuyến ( d ) : [x] 27 [+] [2]\n\n\n\n\n[−] [z] [−] [6]\n\n27 [=] 4\n\n\n\n**–** Phương trình pháp diện ( P ) : 27 ( x + 2 ) + 27 ( y − 1 ) + 4 ( z − 6 ) = 0\n\n\n21"
+        }
+      ],
+      "model_verdict": {
+        "supported": false,
+        "confidence": 0.9,
+        "evidence": "",
+        "reason": "Context does not contain any statement about the parametric form of the plane ax + by + cz + d = 0, so the answer is not supported by the given text."
+      }
+    },
+    "3": {
+      "supported_by_embeddings": true,
+      "max_similarity": 0.7455167770385742,
+      "evidence": [
+        {
+          "idx": 160,
+          "page": 12,
+          "score": 0.7455167770385742,
+          "text": "_10_ _Chương 1. Các ứng dụng của phép tính vi phân trong hình học_\n\n\n3. Nếu họđường cong đã cho có điểm kì dịthì hệphương trình (1.2) bao gồm hình bao\n( E ) và quỹtích các điểm kì dịthuộc họcác đường cong đã cho. **Bài tập 1.1.** Viết phương trình tiếp tuyến và pháp tuyến với đường cong:\n\n\na) y = x [3] + 2x [2] − 4x − 3 tại (− 2, 5 ) . Phương trình pháp tuyến x = − 2\n\n\n\n_Lời giải_ . \n\n\n\n\nPhương trình tiếp tuyến y = 5\n\nPhương trình pháp tuyến x =\n\n\n\n\n\nb) y = e [1] [−] [x] [2] tại giao điểm của đường cong với đường thằng y = 1 . Phương trình pháp tuyến x + 2y − 1 = 0\n\n\n\n_Lời giải_ . **–** Tại M 1 (− 1, 1 ),\n\n\n\n\n\n\n\n\nPhương trình tiếp tuyến 2x − y + 3 = 0\n\nPhương trình pháp tuyến x + 2y − 1 =\n\n\n\nPhương trình pháp tuyến x − 2y + 1 = 0\n\n\n\n**–** Tại M 2 (− 1, 1 ),\n\n\n\n\n\n\n\n\nPhương trình tiếp tuyến 2x + y − 3 = 0\n\nPhương trình pháp tuyến x − 2y + 1 =\n\n\n\nc. x = [1] [+] [t]\n\nt [3]\n3\n\n� y = 2t [3]\n\n\n\nt [3]\n3\ny = 2t [3] [+] 2 [1]\n\n\n\ntại A ( 2, 2 ) . [1]\n\n2t\n\n\n\n_Lời giải_ . **–** Phương t..."
+        },
+        {
+          "idx": 108,
+          "page": 12,
+          "score": 0.7455167770385742,
+          "text": "_10_ _Chương 1. Các ứng dụng của phép tính vi phân trong hình học_\n\n\n3. Nếu họđường cong đã cho có điểm kì dịthì hệphương trình (1.2) bao gồm hình bao\n( E ) và quỹtích các điểm kì dịthuộc họcác đường cong đã cho. **Bài tập 1.1.** Viết phương trình tiếp tuyến và pháp tuyến với đường cong:\n\n\na) y = x [3] + 2x [2] − 4x − 3 tại (− 2, 5 ) . Phương trình pháp tuyến x = − 2\n\n\n\n_Lời giải_ . \n\n\n\n\nPhương trình tiếp tuyến y = 5\n\nPhương trình pháp tuyến x =\n\n\n\n\n\nb) y = e [1] [−] [x] [2] tại giao điểm của đường cong với đường thằng y = 1 . Phương trình pháp tuyến x + 2y − 1 = 0\n\n\n\n_Lời giải_ . **–** Tại M 1 (− 1, 1 ),\n\n\n\n\n\n\n\n\nPhương trình tiếp tuyến 2x − y + 3 = 0\n\nPhương trình pháp tuyến x + 2y − 1 =\n\n\n\nPhương trình pháp tuyến x − 2y + 1 = 0\n\n\n\n**–** Tại M 2 (− 1, 1 ),\n\n\n\n\n\n\n\n\nPhương trình tiếp tuyến 2x + y − 3 = 0\n\nPhương trình pháp tuyến x − 2y + 1 =\n\n\n\nc. x = [1] [+] [t]\n\nt [3]\n3\n\n� y = 2t [3]\n\n\n\nt [3]\n3\ny = 2t [3] [+] 2 [1]\n\n\n\ntại A ( 2, 2 ) . [1]\n\n2t\n\n\n\n_Lời giải_ . **–** Phương t..."
+        },
+        {
+          "idx": 106,
+          "page": 12,
+          "score": 0.7455167770385742,
+          "text": "_10_ _Chương 1. Các ứng dụng của phép tính vi phân trong hình học_\n\n\n3. Nếu họđường cong đã cho có điểm kì dịthì hệphương trình (1.2) bao gồm hình bao\n( E ) và quỹtích các điểm kì dịthuộc họcác đường cong đã cho. **Bài tập 1.1.** Viết phương trình tiếp tuyến và pháp tuyến với đường cong:\n\n\na) y = x [3] + 2x [2] − 4x − 3 tại (− 2, 5 ) . Phương trình pháp tuyến x = − 2\n\n\n\n_Lời giải_ . \n\n\n\n\nPhương trình tiếp tuyến y = 5\n\nPhương trình pháp tuyến x =\n\n\n\n\n\nb) y = e [1] [−] [x] [2] tại giao điểm của đường cong với đường thằng y = 1 . Phương trình pháp tuyến x + 2y − 1 = 0\n\n\n\n_Lời giải_ . **–** Tại M 1 (− 1, 1 ),\n\n\n\n\n\n\n\n\nPhương trình tiếp tuyến 2x − y + 3 = 0\n\nPhương trình pháp tuyến x + 2y − 1 =\n\n\n\nPhương trình pháp tuyến x − 2y + 1 = 0\n\n\n\n**–** Tại M 2 (− 1, 1 ),\n\n\n\n\n\n\n\n\nPhương trình tiếp tuyến 2x + y − 3 = 0\n\nPhương trình pháp tuyến x − 2y + 1 =\n\n\n\nc. x = [1] [+] [t]\n\nt [3]\n3\n\n� y = 2t [3]\n\n\n\nt [3]\n3\ny = 2t [3] [+] 2 [1]\n\n\n\ntại A ( 2, 2 ) . [1]\n\n2t\n\n\n\n_Lời giải_ . **–** Phương t..."
+        }
+      ],
+      "model_verdict": {
+        "supported": false,
+        "confidence": 0.9,
+        "evidence": "",
+        "reason": "Trong nội dung cung cấp không có bất kỳ đề cập nào đến mặt cong x² − 4y² + 2z² = 6, điểm (2, 2, 3) hay phương trình tiếp tuyến của nó, vì vậy không thể chứng thực đáp án được."
+      }
+    },
+    "4": {
+      "supported_by_embeddings": true,
+      "max_similarity": 0.552233099937439,
+      "evidence": [
+        {
+          "idx": 160,
+          "page": 12,
+          "score": 0.552233099937439,
+          "text": "_10_ _Chương 1. Các ứng dụng của phép tính vi phân trong hình học_\n\n\n3. Nếu họđường cong đã cho có điểm kì dịthì hệphương trình (1.2) bao gồm hình bao\n( E ) và quỹtích các điểm kì dịthuộc họcác đường cong đã cho. **Bài tập 1.1.** Viết phương trình tiếp tuyến và pháp tuyến với đường cong:\n\n\na) y = x [3] + 2x [2] − 4x − 3 tại (− 2, 5 ) . Phương trình pháp tuyến x = − 2\n\n\n\n_Lời giải_ . \n\n\n\n\nPhương trình tiếp tuyến y = 5\n\nPhương trình pháp tuyến x =\n\n\n\n\n\nb) y = e [1] [−] [x] [2] tại giao điểm của đường cong với đường thằng y = 1 . Phương trình pháp tuyến x + 2y − 1 = 0\n\n\n\n_Lời giải_ . **–** Tại M 1 (− 1, 1 ),\n\n\n\n\n\n\n\n\nPhương trình tiếp tuyến 2x − y + 3 = 0\n\nPhương trình pháp tuyến x + 2y − 1 =\n\n\n\nPhương trình pháp tuyến x − 2y + 1 = 0\n\n\n\n**–** Tại M 2 (− 1, 1 ),\n\n\n\n\n\n\n\n\nPhương trình tiếp tuyến 2x + y − 3 = 0\n\nPhương trình pháp tuyến x − 2y + 1 =\n\n\n\nc. x = [1] [+] [t]\n\nt [3]\n3\n\n� y = 2t [3]\n\n\n\nt [3]\n3\ny = 2t [3] [+] 2 [1]\n\n\n\ntại A ( 2, 2 ) . [1]\n\n2t\n\n\n\n_Lời giải_ . **–** Phương t..."
+        },
+        {
+          "idx": 108,
+          "page": 12,
+          "score": 0.552233099937439,
+          "text": "_10_ _Chương 1. Các ứng dụng của phép tính vi phân trong hình học_\n\n\n3. Nếu họđường cong đã cho có điểm kì dịthì hệphương trình (1.2) bao gồm hình bao\n( E ) và quỹtích các điểm kì dịthuộc họcác đường cong đã cho. **Bài tập 1.1.** Viết phương trình tiếp tuyến và pháp tuyến với đường cong:\n\n\na) y = x [3] + 2x [2] − 4x − 3 tại (− 2, 5 ) . Phương trình pháp tuyến x = − 2\n\n\n\n_Lời giải_ . \n\n\n\n\nPhương trình tiếp tuyến y = 5\n\nPhương trình pháp tuyến x =\n\n\n\n\n\nb) y = e [1] [−] [x] [2] tại giao điểm của đường cong với đường thằng y = 1 . Phương trình pháp tuyến x + 2y − 1 = 0\n\n\n\n_Lời giải_ . **–** Tại M 1 (− 1, 1 ),\n\n\n\n\n\n\n\n\nPhương trình tiếp tuyến 2x − y + 3 = 0\n\nPhương trình pháp tuyến x + 2y − 1 =\n\n\n\nPhương trình pháp tuyến x − 2y + 1 = 0\n\n\n\n**–** Tại M 2 (− 1, 1 ),\n\n\n\n\n\n\n\n\nPhương trình tiếp tuyến 2x + y − 3 = 0\n\nPhương trình pháp tuyến x − 2y + 1 =\n\n\n\nc. x = [1] [+] [t]\n\nt [3]\n3\n\n� y = 2t [3]\n\n\n\nt [3]\n3\ny = 2t [3] [+] 2 [1]\n\n\n\ntại A ( 2, 2 ) . [1]\n\n2t\n\n\n\n_Lời giải_ . **–** Phương t..."
+        },
+        {
+          "idx": 106,
+          "page": 12,
+          "score": 0.552233099937439,
+          "text": "_10_ _Chương 1. Các ứng dụng của phép tính vi phân trong hình học_\n\n\n3. Nếu họđường cong đã cho có điểm kì dịthì hệphương trình (1.2) bao gồm hình bao\n( E ) và quỹtích các điểm kì dịthuộc họcác đường cong đã cho. **Bài tập 1.1.** Viết phương trình tiếp tuyến và pháp tuyến với đường cong:\n\n\na) y = x [3] + 2x [2] − 4x − 3 tại (− 2, 5 ) . Phương trình pháp tuyến x = − 2\n\n\n\n_Lời giải_ . \n\n\n\n\nPhương trình tiếp tuyến y = 5\n\nPhương trình pháp tuyến x =\n\n\n\n\n\nb) y = e [1] [−] [x] [2] tại giao điểm của đường cong với đường thằng y = 1 . Phương trình pháp tuyến x + 2y − 1 = 0\n\n\n\n_Lời giải_ . **–** Tại M 1 (− 1, 1 ),\n\n\n\n\n\n\n\n\nPhương trình tiếp tuyến 2x − y + 3 = 0\n\nPhương trình pháp tuyến x + 2y − 1 =\n\n\n\nPhương trình pháp tuyến x − 2y + 1 = 0\n\n\n\n**–** Tại M 2 (− 1, 1 ),\n\n\n\n\n\n\n\n\nPhương trình tiếp tuyến 2x + y − 3 = 0\n\nPhương trình pháp tuyến x − 2y + 1 =\n\n\n\nc. x = [1] [+] [t]\n\nt [3]\n3\n\n� y = 2t [3]\n\n\n\nt [3]\n3\ny = 2t [3] [+] 2 [1]\n\n\n\ntại A ( 2, 2 ) . [1]\n\n2t\n\n\n\n_Lời giải_ . **–** Phương t..."
+        }
+      ],
+      "model_verdict": {
+        "supported": false,
+        "confidence": 0.9,
+        "evidence": "Ngữ cảnh không chứa tiêu đề 'GIẢI TÍCH II' hay danh sách các phép tính được liệt kê là ứng dụng.",
+        "reason": "Không có bằng chứng trong nội dung cung cấp để xác nhận đáp án."
+      }
+    },
+    "5": {
+      "supported_by_embeddings": true,
+      "max_similarity": 0.789191484451294,
+      "evidence": [
+        {
+          "idx": 156,
+          "page": 26,
+          "score": 0.789191484451294,
+          "text": "Như vậy ta đã chia miền][ R][ thành][ m] [ ×] [ n][ hình chữ]\n\n\n\ncon với độdài bằng nhau và bằng [d] [−] n [c] [. Như vậy ta đã chia miền][ R][ thành][ m] [ ×] [ n][ hình chữ]\n\nnhật con\nR ij = [ x i − 1, x i ] × [ y j − 1, y j ]\n\n\n\n24"
+        },
+        {
+          "idx": 79,
+          "page": 26,
+          "score": 0.789191484451294,
+          "text": "Như vậy ta đã chia miền][ R][ thành][ m] [ ×] [ n][ hình chữ]\n\n\n\ncon với độdài bằng nhau và bằng [d] [−] n [c] [. Như vậy ta đã chia miền][ R][ thành][ m] [ ×] [ n][ hình chữ]\n\nnhật con\nR ij = [ x i − 1, x i ] × [ y j − 1, y j ]\n\n\n\n24"
+        },
+        {
+          "idx": 13,
+          "page": 26,
+          "score": 0.789191484451294,
+          "text": "Như vậy ta đã chia miền][ R][ thành][ m] [ ×] [ n][ hình chữ]\n\n\n\ncon với độdài bằng nhau và bằng [d] [−] n [c] [. Như vậy ta đã chia miền][ R][ thành][ m] [ ×] [ n][ hình chữ]\n\nnhật con\nR ij = [ x i − 1, x i ] × [ y j − 1, y j ]\n\n\n\n24"
+        }
+      ],
+      "model_verdict": {
+        "supported": true,
+        "confidence": 0.99,
+        "evidence": "R ij = [ x i − 1, x i ] × [ y j − 1, y j ]",
+        "reason": "Context explicitly gives the definition matching the answer"
+      }
+    }
+  }
+}

test/cerebras-api.py

@@ -1,6 +1,5 @@
 # import os
 # from cerebras.cloud.sdk import Cerebras
-import tiktoken
 
 # client = Cerebras(
 #     # This is the default and can be omitted
@@ -20,29 +19,14 @@ import tiktoken
 #     temperature=1,
 #     top_p=1
 # )
-import numpy as np
 
-INPUT_TOKEN_COUNT = np.array([], dtype=int)
-OUTPUT_TOKEN_COUNT = np.array([], dtype=int)
+my_dict = {'apple': 1, 'banana': 2, 'cherry': 3}
 
-# for chunk in stream:
-# 	print(chunk.choices[0].delta.content or "", end="")
-with open('../test/mcq_output.json', 'r', encoding='utf-8') as f:
-	text = f.read()
+# Enumerate through both keys and values
+for index, (key, value) in enumerate(my_dict.items()):
+    print(f"Index: {index}, Key: {key}, Value: {value}")
 
-def count_tokens(text: str, model_name='gpt-oss-120b', encoding_name='cl100k_base') -> int:
-    """Look up model encoding; fallback to encoding_name if model not known."""
-    try:
-        # encoding_for_model can raise if model is unknown to tiktoken
-        enc = tiktoken.encoding_for_model(model_name)
-    except Exception:
-        enc = None
-
-    if enc is None:
-        enc = tiktoken.get_encoding(encoding_name)
-
-    return len(enc.encode(text))
-
-c = count_tokens(text)
-INPUT_TOKEN_COUNT = np.append(INPUT_TOKEN_COUNT, c)
-print(INPUT_TOKEN_COUNT)
+# Enumerate only through keys (less common with dictionaries)
+print("\nEnumerate through keys only:")
+for index, key in enumerate(my_dict): # By default, iterating a dict iterates its keys
+    print(f"Index: {index}, Key: {key}")

test/context.md

@@ -0,0 +1,12 @@
+[page 9] #### **Cài đặt sắp xếp trộn**
+
+[page 5] #### **Cài đặt sắp xếp vun đống**
+
+[page 2] ## **Các thuật toán sắp xếp - phần 2**
+
+
+Sắp xếp vun đống (heap sort)
+
+Sắp xếp trộn (merge sort)
+
+Sắp xếp nhanh (quick sort)

test/general_mcq_output.json

@@ -0,0 +1,664 @@
+{
+  "mcqs": {
+    "1": {
+      "câu hỏi": "Theo chứng minh tính chất 2 (Bịchặn) dựa trên bất đẳng thức Cauchy‑Schwarz, khi nào giá trị K cos(x_j , q) bằng -1?",
+      "lựa chọn": {
+        "a": "K cos(x_j , q) = -1 nếu x_j và q vuông góc",
+        "b": "K cos(x_j , q) = -1 nếu x_j và q cùng hướng",
+        "c": "K cos(x_j , q) = -1 nếu x_j và q ngược hướng: x_j = c·q với c < 0",
+        "d": "K cos(x_j , q) = -1 nếu x_j = 0 hoặc q = 0"
+      },
+      "đáp án": "K cos(x_j , q) = -1 nếu x_j và q ngược hướng: x_j = c·q với c < 0"
+    },
+    "2": {
+      "câu hỏi": "Các bước chính trong quy trình xử lý của BERT cho bài toán phân loại tin nhắn spam/ham bao gồm những gì?",
+      "lựa chọn": {
+        "a": "Mã hóa đầu vào, Tạo embedding từ [MASK] và Đánh giá độ chính xác",
+        "b": "Mã hóa đầu vào, Xử lý qua Transformer encoder và Phân loại",
+        "c": "Tiền xử lý dữ liệu, Huấn luyện mô hình CNN và Dự đoán nhãn",
+        "d": "Phân tách token, Áp dụng TF-IDF và Sử dụng Naive Bayes"
+      },
+      "đáp án": "Mã hóa đầu vào, Xử lý qua Transformer encoder và Phân loại"
+    },
+    "3": {
+      "câu hỏi": "Trong hệ thống phân loại spam, loại spam nào được mô tả là nguy hiểm nhất, nhằm lừa đảo người dùng cung cấp thông tin cá nhân?",
+      "lựa chọn": {
+        "a": "Spam khác (Miscellaneous Spam)",
+        "b": "Spam hệ thống/lừa đảo (Phishing/System Spam)",
+        "c": "Spam quảng cáo",
+        "d": "Spam tinh vi (Sophisticated Spam)"
+      },
+      "đáp án": "Spam hệ thống/lừa đảo (Phishing/System Spam)"
+    },
+    "4": {
+      "câu hỏi": "Trong quy trình phân loại spam/ham được mô tả, vector nào được đưa vào lớp tuyến tính để dự đoán nhãn?",
+      "lựa chọn": {
+        "a": "Các embedding của từng token trong câu",
+        "b": "[CLS] vector",
+        "c": "Các trọng số attention",
+        "d": "Đầu ra của mạng FFN"
+      },
+      "đáp án": "[CLS] vector"
+    },
+    "5": {
+      "câu hỏi": "Theo nội dung đã cho, yếu tố nào sau đây được nêu là nhược điểm khi sử dụng mô hình học sâu để tăng cường dataset?",
+      "lựa chọn": {
+        "a": "Yêu cầu tài nguyên tính toán lớn, thời gian và chi phí cao",
+        "b": "Có khả năng hiểu được sự khác biệt tinh tế giữa các cách diễn đạt",
+        "c": "Tạo ra các mẫu mới để mở rộng dữ liệu",
+        "d": "Kết hợp BERT embeddings với nối từ khóa trong phương pháp bán giám sát"
+      },
+      "đáp án": "Yêu cầu tài nguyên tính toán lớn, thời gian và chi phí cao"
+    },
+    "6": {
+      "câu hỏi": "Theo nội dung, nhược điểm nào của mô hình được nêu ra?",
+      "lựa chọn": {
+        "a": "Đòi hỏi tài nguyên tính toán lớn",
+        "b": "Tăng cường dữ liệu",
+        "c": "Phương pháp semi-supervised",
+        "d": "Cải thiện hiệu suất ở k=5"
+      },
+      "đáp án": "Đòi hỏi tài nguyên tính toán lớn"
+    },
+    "7": {
+      "câu hỏi": "Trong hệ thống phân loại tin nhắn, tham số α có vai trò gì?",
+      "lựa chọn": {
+        "a": "Điều chỉnh mức độ ưu tiên của điểm saliency so với độ tương đồng tổng thể của tin nhắn.",
+        "b": "Xác định ngưỡng cho điểm bỏ phiếu.",
+        "c": "Chỉ định loại spam cụ thể.",
+        "d": "Đánh giá độ chính xác của mô hình."
+      },
+      "đáp án": "Điều chỉnh mức độ ưu tiên của điểm saliency so với độ tương đồng tổng thể của tin nhắn."
+    },
+    "8": {
+      "câu hỏi": "Trong hệ thống phân loại spam sử dụng FAISS, chỉ số nào được mô tả là sử dụng phép nhân vô hướng (Inner Product) để cho kết quả tương đương với độ tương đồng cosine?",
+      "lựa chọn": {
+        "a": "IndexFlatIP",
+        "b": "IndexIVFFlat",
+        "c": "IndexHNSW",
+        "d": "IndexPQ"
+      },
+      "đáp án": "IndexFlatIP"
+    },
+    "9": {
+      "câu hỏi": "Trong các loại spam được mô tả, loại nào được mô tả là nguy hiểm nhất, nhằm lừa đảo người dùng cung cấp thông tin cá nhân như mật khẩu, mã OTP hoặc thông tin thẻ tín dụng?",
+      "lựa chọn": {
+        "a": "Spam quảng cáo (Promotional Spam)",
+        "b": "Spam hệ thống/lừa đảo (Phishing/System Spam)",
+        "c": "Spam khác (Miscellaneous Spam)",
+        "d": "Spam không xác định"
+      },
+      "đáp án": "Spam hệ thống/lừa đảo (Phishing/System Spam)"
+    },
+    "10": {
+      "câu hỏi": "Phương pháp semi-supervised sub-category của spam được mô tả trong nội dung sử dụng kỹ thuật nào để tạo biểu diễn văn bản?",
+      "lựa chọn": {
+        "a": "Word2Vec",
+        "b": "BERT embeddings",
+        "c": "TF‑IDF",
+        "d": "LSTM"
+      },
+      "đáp án": "BERT embeddings"
+    },
+    "11": {
+      "câu hỏi": "Theo công thức kết hợp lồi được nêu trong nội dung, trọng số được tính như thế nào khi sử dụng tham số α?",
+      "lựa chọn": {
+        "a": "(1-α) × w_similarity + α × w_saliency",
+        "b": "(1-α) × w_similarity×ICF + α × w_saliency",
+        "c": "w_similarity×ICF + w_saliency",
+        "d": "α × w_similarity×ICF + (1-α) × w_saliency"
+      },
+      "đáp án": "(1-α) × w_similarity×ICF + α × w_saliency"
+    },
+    "12": {
+      "câu hỏi": "Theo bảng so sánh, độ chính xác của mô hình cải tiến với k = 1 tăng bao nhiêu phần trăm so với mô hình gốc?",
+      "lựa chọn": {
+        "a": "4.72%",
+        "b": "0.77%",
+        "c": "92%",
+        "d": "86.96%"
+      },
+      "đáp án": "4.72%"
+    },
+    "13": {
+      "câu hỏi": "Trong công thức trọng số mới đề xuất cho quá trình voting của KNN, yếu tố nào biểu thị tầm quan trọng tinh tế của từng thực thể?",
+      "lựa chọn": {
+        "a": "similarity( x_j , q )",
+        "b": "ICF( y( x_j ) )",
+        "c": "saliency( x_j , q )",
+        "d": "α (tham số cân bằng)"
+      },
+      "đáp án": "saliency( x_j , q )"
+    },
+    "14": {
+      "câu hỏi": "Trong kiến trúc BERT-base, mỗi lớp encoder có bao nhiêu head trong Multi-Head Self-Attention?",
+      "lựa chọn": {
+        "a": "8 head",
+        "b": "12 head",
+        "c": "16 head",
+        "d": "24 head"
+      },
+      "đáp án": "12 head"
+    },
+    "15": {
+      "câu hỏi": "Theo nội dung, BERT được huấn luyện trước bằng hai nhiệm vụ nào?",
+      "lựa chọn": {
+        "a": "Masked Language Modeling và Next Sentence Prediction",
+        "b": "Sentiment Analysis và Text Summarization",
+        "c": "Machine Translation và Question Answering",
+        "d": "Named Entity Recognition và Part-of-Speech Tagging"
+      },
+      "đáp án": "Masked Language Modeling và Next Sentence Prediction"
+    },
+    "16": {
+      "câu hỏi": "Theo bảng tổng hợp, câu nào thuộc nhóm \"lottery_phrases\"?",
+      "lựa chọn": {
+        "a": "“Flash sale ends tonight – 30% of all items!”",
+        "b": "“You’ve been selected for a loyalty reward.”",
+        "c": "“Unusual login detected. Was this you?”",
+        "d": "“Act now to secure your spot in the seminar.”"
+      },
+      "đáp án": "“You’ve been selected for a loyalty reward.”"
+    },
+    "17": {
+      "câu hỏi": "Theo nội dung, một nhược điểm của phương pháp dựa trên từ khóa trong việc phát hiện spam là gì?",
+      "lựa chọn": {
+        "a": "Có thể xử lý linh hoạt các biến thể từ và lỗi chính tả.",
+        "b": "Thiếu linh hoạt, không thể xử lý các biến thể từ và lỗi chính tả.",
+        "c": "Hiểu ngữ cảnh, phân biệt đúng từ 'free' trong các câu khác nhau.",
+        "d": "Sử dụng embedding ngữ cảnh sâu như BERT để nắm bắt ý nghĩa."
+      },
+      "đáp án": "Thiếu linh hoạt, không thể xử lý các biến thể từ và lỗi chính tả."
+    },
+    "18": {
+      "câu hỏi": "Theo nội dung trên, một nhược điểm chính của các mô hình ngôn ngữ lớn là gì?",
+      "lựa chọn": {
+        "a": "Yêu cầu tài nguyên tính toán lớn, bao gồm thời gian và chi phí huấn luyện và fine‑tuning.",
+        "b": "Có khả năng giải thích quyết định dự đoán một cách rõ ràng và trực quan.",
+        "c": "Có thể học được ranh giới phân biệt tốt hơn khi tăng cường dữ liệu.",
+        "d": "Cho phép phân loại nhanh chóng với độ chính xác cao ở k = 1."
+      },
+      "đáp án": "Yêu cầu tài nguyên tính toán lớn, bao gồm thời gian và chi phí huấn luyện và fine‑tuning."
+    },
+    "19": {
+      "câu hỏi": "Trong phương pháp Weighted KNN được mô tả, yếu tố nào được sử dụng làm trọng số để ưu tiên các láng giềng gần hơn?",
+      "lựa chọn": {
+        "a": "Độ lệch chuẩn",
+        "b": "Điểm tương đồng (similarity score)",
+        "c": "Khoảng cách Euclid",
+        "d": "Số lượng láng giềng"
+      },
+      "đáp án": "Điểm tương đồng (similarity score)"
+    },
+    "20": {
+      "câu hỏi": "Trong phương pháp kết hợp điểm ngữ nghĩa BERT và điểm từ khóa để đưa ra quyết định cuối cùng, trọng số được gán cho mỗi loại điểm là bao nhiêu?",
+      "lựa chọn": {
+        "a": "0.5 BERT và 0.5 từ khóa",
+        "b": "0.7 BERT và 0.3 từ khóa",
+        "c": "0.6 BERT và 0.4 từ khóa",
+        "d": "0.8 BERT và 0.2 từ khóa"
+      },
+      "đáp án": "0.7 BERT và 0.3 từ khóa"
+    }
+  },
+  "validation": {
+    "1": {
+      "supported_by_embeddings": true,
+      "max_similarity": 0.9192600250244141,
+      "evidence": [
+        {
+          "idx": 41,
+          "page": 19,
+          "score": 0.7189286947250366,
+          "text": "Đối với điểm truy vấn _q_, KNN truyền thống tính toán:\n\n\nˆ\n_y_ = arg max _c_ _i_ _∈C_ _[|{][x]_ _[j]_ _[ ∈N]_ _[K]_ [(] _[q]_ [) :] _[ y]_ [(] _[x]_ _[j]_ [) =] _[ c]_ _[i]_ _[}|]_ (1)\n\n\n**Phân tích Bias:**\nXác suất đểmột K-neighborhood ngẫu nhiên chứa _k_ thực thểtừlớp _c_ _i_ tuân theo phân phối siêu hình\nhọc:\n\n\n19"
+        },
+        {
+          "idx": 8,
+          "page": 23,
+          "score": 0.7741187810897827,
+          "text": "**Chứng minh tính chất 2 (Bịchặn):**\nTheo bất đẳng thức Cauchy-Schwarz:\n\n\n_|x_ _j_ _· q| ≤∥x_ _j_ _∥× ∥q∥_ (29)\n\n\nChia cảhai vếcho _∥x_ _j_ _∥× ∥q∥_ (giảsử _x_ _j_ _, q ̸_ = 0):\n\n\n\n_x_ _j_ _·_ _q_\n���� _∥x_ _j_ _∥× ∥q∥_\n\n\n\n_≤_ 1 (30)\n����\n\n\n\nĐiều này có nghĩa là:\n\n\nDấu bằng xảy ra khi:\n\n\n\n_−_ 1 _≤_ _K_ cos ( _x_ _j_ _, q_ ) _≤_ 1 (31)\n\n\n\n\n - _K_ cos ( _x_ _j_ _, q_ ) = 1 nếu _x_ _j_ và _q_ cùng hướng: _x_ _j_ = _c · q_ với _c >_ 0\n\n\n - _K_ cos ( _x_ _j_ _, q_ ) = _−_ 1 nếu _x_ _j_ và _q_ ngược hướng: _x_ _j_ = _c · q_ với _c <_ 0\n\n\n - _K_ cos ( _x_ _j_ _, q_ ) = 0 nếu _x_ _j_ và _q_ vuông góc: _x_ _j_ _⊥_ _q_\n\n\n**Chứng minh tính chất 3 (Chuẩn hóa - Không đổi với độlớn vector):**\nXét hai vector _x_ _[′]_ _j_ [=] _[ λx]_ _[j]_ [ và] _[ q]_ _[′]_ [ =] _[ µq]_ [ với] _[ λ, µ >]_ [ 0][:]\n\n\n23"
+        },
+        {
+          "idx": 56,
+          "page": 24,
+          "score": 0.9192600250244141,
+          "text": "**6.4.3** **Trọng sốNội dung dựa trên Saliency**\n\n\n**Định nghĩa 3** (Gradient-based Saliency) **.** _Thành phần saliency nắm bắt_ _**tầm quan trọng cụthể**_\n_**theo đầu vào**_ _dựa trên mô hình explainable AI:_\n\n\n_saliency_ ( _x_ _j_ _, q_ ) = _∥∇_ _x_ _j_ _L_ ( _f_ ( _x_ _j_ ) _,_ ˆ _y_ ) _∥_ 2 (38)\n\n\n**6.4.4** **Kết hợp Lồi và Tham sốCân bằng** _α_\n\n\n**Định lý 6.1** (Tính chất Convex Combination) **.** _Tham số_ _α tạo ra_ _**kết hợp lồi**_ _của hai lược đồtrọng_\n_số:_\n\n_weight_ = (1 _−_ _α_ ) _× w_ _similarity×ICF_ + _α × w_ _saliency_ (39)\n\n_Với α ∈_ [0 _,_ 1] _, kết quảnằm trong convex hull của hai thành phần._\n\n\n**6.5** **Phân tích Lý thuyết: Tại sao Công thức này Hợp lý**\n\n\n**6.5.1** **Phân tích Hiệu chỉnh Bias**\n\n\n**Định lý 6.2** (Bias Correction) **.** _Đối với majority voting truyền thống, ảnh hưởng kỳvọng của lớp c_ _i_ _là:_\n\nE[ _Influence_ _traditional_ ( _c_ _i_ )] = _K × P_ ( _c_ _i_ ) = _K ×_ _N_ _[n]_ _[i]_ (40)\n\n\n_Với phương pháp trọng sốcủa chúng ta:_\n\n\nE[ _Influence..."
+        }
+      ],
+      "model_verdict": null
+    },
+    "2": {
+      "supported_by_embeddings": true,
+      "max_similarity": 0.7949658036231995,
+      "evidence": [
+        {
+          "idx": 21,
+          "page": 15,
+          "score": 0.5949141979217529,
+          "text": "Trong bài toán spam/ham, BERT được tinh\nchỉnh đểtối ưu hóa dựđoán nhãn và tập trung vào các từkhóa quan trọng như “miễn phí” hoặc “quà\ntặng” trong tin nhắn spam. **Ứng dụng** : Trong phân loại tin nhắn spam/ham, BERT chuyển tin nhắn thành vector số, hiểu ngữ\ncảnh sâu sắc (ví dụ: nhận diện ”miễn phí” trong ngữcảnh quảng cáo), và dựđoán nhãn (spam hoặc\nham). **Ưu điểm** :\n\n\n  - Hiểu ngữcảnh hai chiều, vượt trội so với các phương pháp truyền thống như TF-IDF. - Sửdụng vector [CLS] đểtổng hợp thông tin toàn câu, phù hợp cho phân loại. **5.3** **Kiến trúc BERT**\n\n\nQuy trình xửlý của BERT bao gồm ba giai đoạn chính:\n\n\n1. **Mã hóa đầu vào** : Chuyển tin nhắn thành token, embedding, và attention mask. 2. **Xửlý qua Transformer encoder** : Tạo biểu diễn ngữcảnh cho từng token, đặc biệt là vector\n\n[CLS]. 3. **Phân loại** : Sửdụng vector [CLS] đểdựđoán nhãn spam/ham. Phần này trình bày chi tiết từng thành phần của kiến trúc BERT và cách chúng hỗtrợbài toán phân\nloại tin nhắn spam/ham. **5.3.1** *..."
+        },
+        {
+          "idx": 52,
+          "page": 11,
+          "score": 0.7382397651672363,
+          "text": "**AI VIETNAM** **aivietnam.edu.vn**\n\n\n - 2039 mẫu _hard spam_ : được tạo ra đểtăng sốlượng và độphức tạp của các tin nhắn spam, giúp\nmô hình nhận diện tốt hơn các biến thểcủa spam. - 815 mẫu _hard ham_ : là những tin nhắn hợp lệnhưng có chứa từkhóa gần giống spam, buộc mô\nhình phải học cách phân biệt tinh vi hơn giữa hai lớp. - 1053 mẫu được sinh ra bằng kỹthuật _synonym replacement_ (thay thếtừđồng nghĩa), giúp tăng\nsựđa dạng vềmặt ngôn ngữcho cảhai lớp. Kết quảlà một dataset dùng đểphân loại có kích thước 9479 mẫu gồm 6556 mẫu Ham, 2923 mẫu Spam\ncó phân phối cân bằng hơn, tạo nền tảng vững chắc cho việc huấn luyện mô hình phân loại hiệu quả. **Phương pháp**\n\n\nĐểđạt được mục tiêu trên, nhóm mình đã thiết kếmột hệthống data augmentation chuyên biệt, kết\nhợp giữa kỹthuật sinh dữliệu bằng mô hình ngôn ngữlớn (LLM), thay thếtừđồng nghĩa, và khung\nsinh câu theo kịch bản có kiểm soát. Hệthống gồm ba giai đoạn chính:\n\n\n1."
+        },
+        {
+          "idx": 64,
+          "page": 27,
+          "score": 0.7949658036231995,
+          "text": "**AI VIETNAM** **aivietnam.edu.vn**\n\n## **7 Semi-supervised đểphân loại sub-category của spam**\n\n\n**7.1** **Vấn đề”Spam” không chỉlà ”Spam”**\n\n\nKhi đối mặt với vấn đềspam, việc phân loại nhịphân (binary classification) thành hai loại ”spam” và\n”không spam” (ham) là chưa đủđểxây dựng một hệthống phòng chống hiệu quả. Bản chất của tin\nnhắn spam đã thay đổi và trởnên đa dạng hơn rất nhiều. Việc coi tất cảcác tin nhắn spam như nhau sẽ\nbỏqua những sắc thái quan trọng, dẫn đến việc chúng ta không thểđưa ra các biện pháp xửlý phù hợp. Khi phân tích sâu hơn, chúng ta thấy rằng spam có thểđược chia thành nhiều **thểloại con (sub-**\n**category) khác nhau**, mỗi loại có mục tiêu và phương thức hoạt động riêng biệt:\n\n\n **Spam quảng cáo** (Promotional Spam): Nhằm mục đích tiếp thịsản phẩm, dịch vụ, các chương\ntrình khuyến mãi, giảm giá, hoặc các thông báo trúng thưởng. Đặc điểm của loại này là thường\nchứa các từkhóa liên quan đến mua sắm, giá cả, ưu đãi..."
+        }
+      ],
+      "model_verdict": null
+    },
+    "3": {
+      "supported_by_embeddings": true,
+      "max_similarity": 0.5782788991928101,
+      "evidence": [
+        {
+          "idx": 52,
+          "page": 11,
+          "score": 0.5782788991928101,
+          "text": "**AI VIETNAM** **aivietnam.edu.vn**\n\n\n - 2039 mẫu _hard spam_ : được tạo ra đểtăng sốlượng và độphức tạp của các tin nhắn spam, giúp\nmô hình nhận diện tốt hơn các biến thểcủa spam. - 815 mẫu _hard ham_ : là những tin nhắn hợp lệnhưng có chứa từkhóa gần giống spam, buộc mô\nhình phải học cách phân biệt tinh vi hơn giữa hai lớp. - 1053 mẫu được sinh ra bằng kỹthuật _synonym replacement_ (thay thếtừđồng nghĩa), giúp tăng\nsựđa dạng vềmặt ngôn ngữcho cảhai lớp. Kết quảlà một dataset dùng đểphân loại có kích thước 9479 mẫu gồm 6556 mẫu Ham, 2923 mẫu Spam\ncó phân phối cân bằng hơn, tạo nền tảng vững chắc cho việc huấn luyện mô hình phân loại hiệu quả. **Phương pháp**\n\n\nĐểđạt được mục tiêu trên, nhóm mình đã thiết kếmột hệthống data augmentation chuyên biệt, kết\nhợp giữa kỹthuật sinh dữliệu bằng mô hình ngôn ngữlớn (LLM), thay thếtừđồng nghĩa, và khung\nsinh câu theo kịch bản có kiểm soát. Hệthống gồm ba giai đoạn chính:\n\n\n1."
+        }
+      ],
+      "model_verdict": null
+    },
+    "4": {
+      "supported_by_embeddings": true,
+      "max_similarity": 0.7534276247024536,
+      "evidence": [
+        {
+          "idx": 21,
+          "page": 15,
+          "score": 0.7180466651916504,
+          "text": "Trong bài toán spam/ham, BERT được tinh\nchỉnh đểtối ưu hóa dựđoán nhãn và tập trung vào các từkhóa quan trọng như “miễn phí” hoặc “quà\ntặng” trong tin nhắn spam. **Ứng dụng** : Trong phân loại tin nhắn spam/ham, BERT chuyển tin nhắn thành vector số, hiểu ngữ\ncảnh sâu sắc (ví dụ: nhận diện ”miễn phí” trong ngữcảnh quảng cáo), và dựđoán nhãn (spam hoặc\nham). **Ưu điểm** :\n\n\n  - Hiểu ngữcảnh hai chiều, vượt trội so với các phương pháp truyền thống như TF-IDF. - Sửdụng vector [CLS] đểtổng hợp thông tin toàn câu, phù hợp cho phân loại. **5.3** **Kiến trúc BERT**\n\n\nQuy trình xửlý của BERT bao gồm ba giai đoạn chính:\n\n\n1. **Mã hóa đầu vào** : Chuyển tin nhắn thành token, embedding, và attention mask. 2. **Xửlý qua Transformer encoder** : Tạo biểu diễn ngữcảnh cho từng token, đặc biệt là vector\n\n[CLS]. 3. **Phân loại** : Sửdụng vector [CLS] đểdựđoán nhãn spam/ham. Phần này trình bày chi tiết từng thành phần của kiến trúc BERT và cách chúng hỗtrợbài toán phân\nloại tin nhắn spam/ham. **5.3.1** *..."
+        },
+        {
+          "idx": 64,
+          "page": 27,
+          "score": 0.7191596031188965,
+          "text": "**AI VIETNAM** **aivietnam.edu.vn**\n\n## **7 Semi-supervised đểphân loại sub-category của spam**\n\n\n**7.1** **Vấn đề”Spam” không chỉlà ”Spam”**\n\n\nKhi đối mặt với vấn đềspam, việc phân loại nhịphân (binary classification) thành hai loại ”spam” và\n”không spam” (ham) là chưa đủđểxây dựng một hệthống phòng chống hiệu quả. Bản chất của tin\nnhắn spam đã thay đổi và trởnên đa dạng hơn rất nhiều. Việc coi tất cảcác tin nhắn spam như nhau sẽ\nbỏqua những sắc thái quan trọng, dẫn đến việc chúng ta không thểđưa ra các biện pháp xửlý phù hợp. Khi phân tích sâu hơn, chúng ta thấy rằng spam có thểđược chia thành nhiều **thểloại con (sub-**\n**category) khác nhau**, mỗi loại có mục tiêu và phương thức hoạt động riêng biệt:\n\n\n **Spam quảng cáo** (Promotional Spam): Nhằm mục đích tiếp thịsản phẩm, dịch vụ, các chương\ntrình khuyến mãi, giảm giá, hoặc các thông báo trúng thưởng. Đặc điểm của loại này là thường\nchứa các từkhóa liên quan đến mua sắm, giá cả, ưu đãi..."
+        },
+        {
+          "idx": 1,
+          "page": 5,
+          "score": 0.7534276247024536,
+          "text": "Điều này đặc biệt quan trọng\ntrong các hệthống chống spam hiện đại, giúp người dùng hiểu rõ liệu một email nên bịxóa, xem qua\nhay báo cáo. Ngoài ra, nhóm còn hướng đến việc **mởrộng phân loại chi tiết trong nhóm spam**\n(quảng cáo, hệthống, lừa đảo, v.v...) nhằm tăng trải nghiệm và bảo mật cho người dùng. Hệthống phân loại tin nhắn spam/ham được thiết kếvới cơ chếđầu vào – đầu ra như sau:\n\n\n\n\n\n5"
+        }
+      ],
+      "model_verdict": null
+    },
+    "5": {
+      "supported_by_embeddings": true,
+      "max_similarity": 0.7267791032791138,
+      "evidence": [
+        {
+          "idx": 60,
+          "page": 10,
+          "score": 0.6037057638168335,
+          "text": "Đểgiải quyết vấn đềnày, dataset đã được tăng cường đáng kểbằng cách sửdụng một mô hình học sâu\nđểtạo ra các mẫu mới:\n\n\n10"
+        },
+        {
+          "idx": 3,
+          "page": 28,
+          "score": 0.7101945281028748,
+          "text": "**–**\nNhờđó, mô hình có thểhiểu được sựkhác biệt tinh tếgiữa các cách diễn đạt, xửlý được\ncác từđồng nghĩa và các biến thểngôn ngữ. **Nhược điểm:**\n\n\n**– Đòi hỏi tài nguyên tính toán lớn:** Việc huấn luyện và fine-tuning các mô hình này cần\nnhiều thời gian và chi phí. **– Phức tạp:** Việc fine-tuning cho từng tác vụcụthểcó thểphức tạp. Đặc biệt, nếu không có\nđủdữliệu đã được gán nhãn, hiệu quảcủa các mô hình này sẽbịhạn chế. **7.3** **Phương pháp Semi-supervised sub-category của spam**\n\n\nĐểtận dụng ưu điểm của 2 phương pháp phân loại sub-category phần trên. Chúng tôi đềxuất thực\nhiện một phương pháp semi-supervised bằng cách kết hợp bert embeđings với nối từkhóa. Phương pháp này được gọi là ”bán giám sát” vì nó sửdụng một lượng nhỏdữliệu có nhãn (reference_texts\nvà category_keywords) đểphân loại một lượng lớn dữliệu chưa có nhãn (spam_texts). Tiến trình thực hiện của phương pháp như sau:\n\n\n1. **Bước 1: BERT embeddings**\n\n\n  **Tạo Embeddings của Văn bản Spam:** đểbiến mỗi tin nhắn spam ..."
+        },
+        {
+          "idx": 61,
+          "page": 26,
+          "score": 0.7267791032791138,
+          "text": "Những cải thiện này đến từcác yếu tốsau:\n\n\n **Tăng cường dữliệu:** sinh thêm mẫu khó và thay từđồng nghĩa giúp đa dạng hóa ngữcảnh và\nlàm mô hình học được ranh giới phân biệt tốt hơn. **Tập huấn luyện lớn hơn:** từdưới 1.000 mẫu lên hơn 9.000 mẫu giúp mô hình tổng quát hóa\ntốt hơn. **Tập trung vào mẫu khó:** ưu tiên những ví dụgần ranh giới giữa spam/ham nhằm tăng tính\nphân biệt cho mô hình. **Kết luận:** Mô hình mới không chỉđạt hiệu suất cao ở _k_ = 5 mà còn cải thiện đáng kểở _k_ = 1, rất hữu\ních cho các ứng dụng yêu cầu tốc độsuy luận nhanh mà vẫn đảm bảo độchính xác cao. 26"
+        }
+      ],
+      "model_verdict": null
+    },
+    "6": {
+      "supported_by_embeddings": true,
+      "max_similarity": 1.1316804885864258,
+      "evidence": [
+        {
+          "idx": 3,
+          "page": 28,
+          "score": 0.8143035769462585,
+          "text": "**–**\nNhờđó, mô hình có thểhiểu được sựkhác biệt tinh tếgiữa các cách diễn đạt, xửlý được\ncác từđồng nghĩa và các biến thểngôn ngữ. **Nhược điểm:**\n\n\n**– Đòi hỏi tài nguyên tính toán lớn:** Việc huấn luyện và fine-tuning các mô hình này cần\nnhiều thời gian và chi phí. **– Phức tạp:** Việc fine-tuning cho từng tác vụcụthểcó thểphức tạp. Đặc biệt, nếu không có\nđủdữliệu đã được gán nhãn, hiệu quảcủa các mô hình này sẽbịhạn chế. **7.3** **Phương pháp Semi-supervised sub-category của spam**\n\n\nĐểtận dụng ưu điểm của 2 phương pháp phân loại sub-category phần trên. Chúng tôi đềxuất thực\nhiện một phương pháp semi-supervised bằng cách kết hợp bert embeđings với nối từkhóa. Phương pháp này được gọi là ”bán giám sát” vì nó sửdụng một lượng nhỏdữliệu có nhãn (reference_texts\nvà category_keywords) đểphân loại một lượng lớn dữliệu chưa có nhãn (spam_texts). Tiến trình thực hiện của phương pháp như sau:\n\n\n1. **Bước 1: BERT embeddings**\n\n\n  **Tạo Embeddings của Văn bản Spam:** đểbiến mỗi tin nhắn spam ..."
+        },
+        {
+          "idx": 61,
+          "page": 26,
+          "score": 0.9040168523788452,
+          "text": "Những cải thiện này đến từcác yếu tốsau:\n\n\n **Tăng cường dữliệu:** sinh thêm mẫu khó và thay từđồng nghĩa giúp đa dạng hóa ngữcảnh và\nlàm mô hình học được ranh giới phân biệt tốt hơn. **Tập huấn luyện lớn hơn:** từdưới 1.000 mẫu lên hơn 9.000 mẫu giúp mô hình tổng quát hóa\ntốt hơn. **Tập trung vào mẫu khó:** ưu tiên những ví dụgần ranh giới giữa spam/ham nhằm tăng tính\nphân biệt cho mô hình. **Kết luận:** Mô hình mới không chỉđạt hiệu suất cao ở _k_ = 5 mà còn cải thiện đáng kểở _k_ = 1, rất hữu\ních cho các ứng dụng yêu cầu tốc độsuy luận nhanh mà vẫn đảm bảo độchính xác cao. 26"
+        },
+        {
+          "idx": 60,
+          "page": 10,
+          "score": 1.1316804885864258,
+          "text": "Đểgiải quyết vấn đềnày, dataset đã được tăng cường đáng kểbằng cách sửdụng một mô hình học sâu\nđểtạo ra các mẫu mới:\n\n\n10"
+        }
+      ],
+      "model_verdict": null
+    },
+    "7": {
+      "supported_by_embeddings": true,
+      "max_similarity": 0.9357913732528687,
+      "evidence": [
+        {
+          "idx": 18,
+          "page": 7,
+          "score": 0.7424218058586121,
+          "text": "Tham số _α_ là tham sốđiều chỉnh, quyết định mức độưu tiên của điểm saliency so với độ\ntương đồng tổng thểcủa tin nhắn. - **Vote Scores:** Hệthống hiển thịđiểm sốbỏphiếu cho mỗi lớp ( _Ham_ và _Spam_ ). Dựđoán cuối\ncùng sẽlà lớp có điểm sốcao nhất. - **Spam Subcategory:** Nếu tin nhắn được phân loại là _SPAM_, hệthống tiếp tục phân tích đểxác\nđịnh tiểu mục spam cụthể(ví dụ: _spam_quangcao_, _spam_hethong_ ). **Cơ sởgiải thích (Top neighbors):** Hệthống liệt kê một sốhàng xóm gần nhất trong cơ sởdữ\nliệu vector. Mỗi neighbors bao gồm:\n\n\n**–** _Nhãn (Label):_ Nhãn của tin nhắn gốc ( _ham_ hoặc _spam_ ). **–**\n_Độtương đồng (Similarity):_ Giá trịthểhiện mức độtương đồng giữa tin nhắn đầu vào và\nhàng xóm. **–**\n_Nội dung (Message):_ Nội dung của tin nhắn hàng xóm. 7"
+        },
+        {
+          "idx": 11,
+          "page": 29,
+          "score": 0.909127414226532,
+          "text": "**AI VIETNAM** **aivietnam.edu.vn**\n\n\n  **Tính Độtương đồng Ngữnghĩa:** Đối với mỗi tin nhắn spam, thuật toán tính toán độ\ntương đồng cosine giữa embedding của tin nhắn đó và embedding của từng điểm neo tham\nchiếu. Kết quảlà một điểm số( _bert_scores_ ) cho thấy mức độliên quan vềmặt ngữnghĩa\ncủa tin nhắn với từng tiểu thểloại. 2. **Bước 2: Keyword matching**\n\n\n  **Định nghĩa Từkhóa:** tạo một danh sách từkhóa chi tiết cho từng thểloại con. - **Tính Điểm Từkhóa:** Với mỗi tin nhắn, đoạn mã s���đếm sốlượng từkhóa trong danh sách\nxuất hiện. Điểm sốnày được chuẩn hóa.( _keyword_scores_ ) đểso sánh công bằng giữa các thể\nloại con có sốlượng từkhóa khác nhau. 3. **Bước 3: combine và ra quyết định** Đây là bước then chốt của phương pháp lai này. **Kết hợp có trọng số:** Mô hình kết hợp hai điểm sốtrên bằng cách sửdụng trọng số. Với\nđiểm ngữnghĩa của BERT chiếm 70% và điểm từkhóa chiếm 30% (0 _._ 7 _×_ bert_scores +0 _._ 3 _×_\nkeyword_scores). Sựkết hợp này tận dụng khảnăng hiểu ngữnghĩa sâu củ..."
+        },
+        {
+          "idx": 68,
+          "page": 13,
+          "score": 0.9357913732528687,
+          "text": "Trong trường hợp này, phép nhân vô hướng (Inner Product) mà\nIndexFlatIP sửdụng sẽcho kết quảtương đương với độtương đồng cosine. Độtương đồng cosine\nlà thước đo tiêu chuẩn đểđánh giá sựtương đồng ngữnghĩa trong các bài toán NLP. Do đó,\nIndexFlatIP là lựa chọn hoàn hảo đểtruy vấn các tin nhắn có ý nghĩa tương tự, tạo ra một hệ\nthống tìm kiếm ngữnghĩa hiệu quảvà chính xác. ## **4 Explainable AI: Masking-based saliency heat map**\n\n\nNhận thấy rằng toàn bộhệthống phân loại sửdụng mô hình embedding E5 kết hợp với cơ sởdữliệu\nFAISS đểtruy vấn và tìm kiếm `k` tin nhắn gần nhất là một mô hình dạng “hộp đen” (black-box), nên\nnhóm đặt mục tiêu tăng tính giải thích của mô hình bằng cách chỉra cụthểnhững token nào trong\ncâu đầu vào thực sựảnh hưởng đến embedding câu, từđó dẫn đến quyết định phân loại. Ý tưởng cụ\nthểlà trực quan hóa mức độđóng góp của từng token bằng bản đồnhiệt (heatmap) — token nào càng\nđóng góp nhiều thì sẽđược tô màu đậm hơn. Do nhóm tập trung chủyếu vào việc phân loại và giải t..."
+        }
+      ],
+      "model_verdict": null
+    },
+    "8": {
+      "supported_by_embeddings": true,
+      "max_similarity": 0.610893189907074,
+      "evidence": [
+        {
+          "idx": 1,
+          "page": 5,
+          "score": 0.5394615530967712,
+          "text": "Điều này đặc biệt quan trọng\ntrong các hệthống chống spam hiện đại, giúp người dùng hiểu rõ liệu một email nên bịxóa, xem qua\nhay báo cáo. Ngoài ra, nhóm còn hướng đến việc **mởrộng phân loại chi tiết trong nhóm spam**\n(quảng cáo, hệthống, lừa đảo, v.v...) nhằm tăng trải nghiệm và bảo mật cho người dùng. Hệthống phân loại tin nhắn spam/ham được thiết kếvới cơ chếđầu vào – đầu ra như sau:\n\n\n\n\n\n5"
+        },
+        {
+          "idx": 64,
+          "page": 27,
+          "score": 0.5891628265380859,
+          "text": "**AI VIETNAM** **aivietnam.edu.vn**\n\n## **7 Semi-supervised đểphân loại sub-category của spam**\n\n\n**7.1** **Vấn đề”Spam” không chỉlà ”Spam”**\n\n\nKhi đối mặt với vấn đềspam, việc phân loại nhịphân (binary classification) thành hai loại ”spam” và\n”không spam” (ham) là chưa đủđểxây dựng một hệthống phòng chống hiệu quả. Bản chất của tin\nnhắn spam đã thay đổi và trởnên đa dạng hơn rất nhiều. Việc coi tất cảcác tin nhắn spam như nhau sẽ\nbỏqua những sắc thái quan trọng, dẫn đến việc chúng ta không thểđưa ra các biện pháp xửlý phù hợp. Khi phân tích sâu hơn, chúng ta thấy rằng spam có thểđược chia thành nhiều **thểloại con (sub-**\n**category) khác nhau**, mỗi loại có mục tiêu và phương thức hoạt động riêng biệt:\n\n\n **Spam quảng cáo** (Promotional Spam): Nhằm mục đích tiếp thịsản phẩm, dịch vụ, các chương\ntrình khuyến mãi, giảm giá, hoặc các thông báo trúng thưởng. Đặc điểm của loại này là thường\nchứa các từkhóa liên quan đến mua sắm, giá cả, ưu đãi..."
+        },
+        {
+          "idx": 52,
+          "page": 11,
+          "score": 0.610893189907074,
+          "text": "**AI VIETNAM** **aivietnam.edu.vn**\n\n\n - 2039 mẫu _hard spam_ : được tạo ra đểtăng sốlượng và độphức tạp của các tin nhắn spam, giúp\nmô hình nhận diện tốt hơn các biến thểcủa spam. - 815 mẫu _hard ham_ : là những tin nhắn hợp lệnhưng có chứa từkhóa gần giống spam, buộc mô\nhình phải học cách phân biệt tinh vi hơn giữa hai lớp. - 1053 mẫu được sinh ra bằng kỹthuật _synonym replacement_ (thay thếtừđồng nghĩa), giúp tăng\nsựđa dạng vềmặt ngôn ngữcho cảhai lớp. Kết quảlà một dataset dùng đểphân loại có kích thước 9479 mẫu gồm 6556 mẫu Ham, 2923 mẫu Spam\ncó phân phối cân bằng hơn, tạo nền tảng vững chắc cho việc huấn luyện mô hình phân loại hiệu quả. **Phương pháp**\n\n\nĐểđạt được mục tiêu trên, nhóm mình đã thiết kếmột hệthống data augmentation chuyên biệt, kết\nhợp giữa kỹthuật sinh dữliệu bằng mô hình ngôn ngữlớn (LLM), thay thếtừđồng nghĩa, và khung\nsinh câu theo kịch bản có kiểm soát. Hệthống gồm ba giai đoạn chính:\n\n\n1."
+        }
+      ],
+      "model_verdict": null
+    },
+    "9": {
+      "supported_by_embeddings": true,
+      "max_similarity": 0.5543808341026306,
+      "evidence": [
+        {
+          "idx": 39,
+          "page": 4,
+          "score": 0.5543808341026306,
+          "text": "**AI VIETNAM** **aivietnam.edu.vn**\n\n\n\n\n\n**Các lĩnh vực dễbịnhầm lẫn giữa spam và ham**\n\n\nTrong những năm gần đây, sựphát triển của công nghệemail marketing và các hình thức lừa đảo trực\ntuyến đã dẫn đến sựgia tăng mạnh mẽcủa các loại **spam tinh vi** – những tin nhắn rác được _thiết kế_\n_cẩn thận đểvượt qua các bộlọc tựđộng_ . Chúng thường sửdụng ngôn ngữlịch sự, cú pháp tựnhiên như\nemail thật, thậm chí mô phỏng cách viết của email công việc hoặc cá nhân. Cùng lúc đó, cũng tồn tại nhiều email hợp lệ( **ham** ) có chứa các từkhóa như _“transfer”_, _“discount”_,\n_“verify”_ vốn thường xuất hiện trong spam, khiến hệthống nhầm lẫn. Những trường hợp như vậy được\ngọi là **hard ham** – tức là các email hợp pháp nhưng có đặc điểm giống với spam. Vì vậy, các mô hình học máy nếu chỉdựa vào keyword hoặc kỹthuật phân loại đơn giản như TF-IDF,\nNaive Bayes,... sẽkhó đạt hiệu quảcao. Thay vào đó, mô hình cần có khảnăng **hiểu sâu ngữnghĩa**,\nkết hợp thông tin ngữcảnh, cú pháp, và thậm chí cảlịch sửng..."
+        }
+      ],
+      "model_verdict": null
+    },
+    "10": {
+      "supported_by_embeddings": true,
+      "max_similarity": 0.5062772035598755,
+      "evidence": [
+        {
+          "idx": 64,
+          "page": 27,
+          "score": 0.5062772035598755,
+          "text": "**AI VIETNAM** **aivietnam.edu.vn**\n\n## **7 Semi-supervised đểphân loại sub-category của spam**\n\n\n**7.1** **Vấn đề”Spam” không chỉlà ”Spam”**\n\n\nKhi đối mặt với vấn đềspam, việc phân loại nhịphân (binary classification) thành hai loại ”spam” và\n”không spam” (ham) là chưa đủđểxây dựng một hệthống phòng chống hiệu quả. Bản chất của tin\nnhắn spam đã thay đổi và trởnên đa dạng hơn rất nhiều. Việc coi tất cảcác tin nhắn spam như nhau sẽ\nbỏqua những sắc thái quan trọng, dẫn đến việc chúng ta không thểđưa ra các biện pháp xửlý phù hợp. Khi phân tích sâu hơn, chúng ta thấy rằng spam có thểđược chia thành nhiều **thểloại con (sub-**\n**category) khác nhau**, mỗi loại có mục tiêu và phương thức hoạt động riêng biệt:\n\n\n **Spam quảng cáo** (Promotional Spam): Nhằm mục đích tiếp thịsản phẩm, dịch vụ, các chương\ntrình khuyến mãi, giảm giá, hoặc các thông báo trúng thưởng. Đặc điểm của loại này là thường\nchứa các từkhóa liên quan đến mua sắm, giá cả, ưu đãi..."
+        }
+      ],
+      "model_verdict": null
+    },
+    "11": {
+      "supported_by_embeddings": true,
+      "max_similarity": 0.7763429880142212,
+      "evidence": [
+        {
+          "idx": 14,
+          "page": 20,
+          "score": 0.7428227663040161,
+          "text": "**6.1** **Khung Phân loại Trọng sốĐềxuất**\n\n\nVì vậy nhóm đã nghiên cứu và đềxuất áp dụng công thức trọng sốmới trong quá trình voting của KNN\nbằng kết hợp hai yếu tốtương đồng (similarity) và tầm quan trọng tinh tếcủa từng thực thể(saliency). **6.2** **Công thức Cốt lõi**\n\n\nweight( _x_ _j_ _,_ _q_ ) = (1 _−_ _α_ ) _×_ similarity( _x_ _j_ _,_ _q_ ) _×_ ICF( _y_ ( _x_ _j_ )) + _α ×_ saliency( _x_ _j_ _,_ _q_ ) (5)\n\n\nTrong đó:\n\n\n_x_ _j_ _·_ _q_\nsimilarity( _x_ _j_ _, q_ ) = cos( _x_ _j_ _, q_ ) = (6)\n_∥x_ _j_ _∥× ∥q∥_\n\n\n\n_N_\nICF( _c_ _i_ ) =\n_M × n_ _i_\n\n\n\n(7)\n\n\n\nsaliency( _x_ _j_ _, q_ ) = _∥∇_ _x_ _j_ _L_ ( _f_ ( _x_ _j_ ) _,_ ˆ _y_ ) _∥_ 2 (8)\n\n_α ∈_ [0 _,_ 1] (tham sốcân bằng) (9)\n\n\n**6.3** **Quyết định Phân loại Cuối cùng**\n\n\n\nˆ\n_y_ = arg max\n_c_ _i_ _∈C_\n\n\n\n�\n\n_x_ _j_ _∈N_ _K_ ( _q_ )\n_y_ ( _x_ _j_ )= _c_ _i_\n\n\n20\n\n\n\nweight( _x_ _j_ _, q_ ) (10)"
+        },
+        {
+          "idx": 56,
+          "page": 24,
+          "score": 0.7464016675949097,
+          "text": "**6.4.3** **Trọng sốNội dung dựa trên Saliency**\n\n\n**Định nghĩa 3** (Gradient-based Saliency) **.** _Thành phần saliency nắm bắt_ _**tầm quan trọng cụthể**_\n_**theo đầu vào**_ _dựa trên mô hình explainable AI:_\n\n\n_saliency_ ( _x_ _j_ _, q_ ) = _∥∇_ _x_ _j_ _L_ ( _f_ ( _x_ _j_ ) _,_ ˆ _y_ ) _∥_ 2 (38)\n\n\n**6.4.4** **Kết hợp Lồi và Tham sốCân bằng** _α_\n\n\n**Định lý 6.1** (Tính chất Convex Combination) **.** _Tham số_ _α tạo ra_ _**kết hợp lồi**_ _của hai lược đồtrọng_\n_số:_\n\n_weight_ = (1 _−_ _α_ ) _× w_ _similarity×ICF_ + _α × w_ _saliency_ (39)\n\n_Với α ∈_ [0 _,_ 1] _, kết quảnằm trong convex hull của hai thành phần._\n\n\n**6.5** **Phân tích Lý thuyết: Tại sao Công thức này Hợp lý**\n\n\n**6.5.1** **Phân tích Hiệu chỉnh Bias**\n\n\n**Định lý 6.2** (Bias Correction) **.** _Đối với majority voting truyền thống, ảnh hưởng kỳvọng của lớp c_ _i_ _là:_\n\nE[ _Influence_ _traditional_ ( _c_ _i_ )] = _K × P_ ( _c_ _i_ ) = _K ×_ _N_ _[n]_ _[i]_ (40)\n\n\n_Với phương pháp trọng sốcủa chúng ta:_\n\n\nE[ _Influence..."
+        },
+        {
+          "idx": 48,
+          "page": 24,
+          "score": 0.7763429880142212,
+          "text": "]_ (43)\n\n_M_ _[×]_ [ E][[] _[similarity][ ×][ saliency]_ []]\n\n\n24"
+        }
+      ],
+      "model_verdict": null
+    },
+    "12": {
+      "supported_by_embeddings": true,
+      "max_similarity": 0.8878604173660278,
+      "evidence": [
+        {
+          "idx": 47,
+          "page": 26,
+          "score": 0.7113279104232788,
+          "text": "**AI VIETNAM** **aivietnam.edu.vn**\n\n## **Đánh giá và So sánh Mô hình**\n\n\n**Kết quảmô hình gốc (do TA cung cấp)**\n\n\nChúng tôi tiến hành đánh giá mô hình phân loại KNN ban đầu trên tập kiểm tra gồm 884 mẫu, với các\ngiá trị _k_ khác nhau. Kết quảđộchính xác như sau:\n\n|Giá trị k|Độ chính xác|Số mẫu lỗi|\n|---|---|---|\n|1<br>3<br>5|82.24%<br>88.91%<br>92.87%|157/884<br>98/884<br>63/884|\n\n\n\nBảng 3: Hiệu suất mô hình gốc trên tập kiểm tra\n\n\n**Kết quảmô hình cải tiến (do nhóm phát triển)**\n\n\nVới mô hình cải tiến, chúng tôi đã huấn luyện trên một tập dữliệu lớn hơn rất nhiều (9.400 mẫu), được\ntăng cường từtập dữliệu GDrive gốc thông qua kỹthuật tạo mẫu khó và thay thếtừđồng nghĩa. Kết\nquảđạt được như sau:\n\n|Giá trị k|Độ chính xác|\n|---|---|\n|1<br>3<br>5|86.96%<br>89.68%<br>92.20%|\n\n\n\nBảng 4: Hiệu suất mô hình cải tiến trên tập dữliệu mởrộng\n\n\n**Phân tích kết quả**\n\n\nMô hình cải tiến cho thấy sựvượt trội rõ rệt ởmọi mức _k_ :\n\n\n - Với _k_ = 1: tăng từ **82.24%** lên **86.96%** ( **+4.72%** ). - ..."
+        },
+        {
+          "idx": 9,
+          "page": 1,
+          "score": 0.8842895030975342,
+          "text": "25\n\n6.5.4 Phân tích Consistency . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25\n6.6 Kết luận . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25\n\n\n1"
+        },
+        {
+          "idx": 14,
+          "page": 20,
+          "score": 0.8878604173660278,
+          "text": "**6.1** **Khung Phân loại Trọng sốĐềxuất**\n\n\nVì vậy nhóm đã nghiên cứu và đềxuất áp dụng công thức trọng sốmới trong quá trình voting của KNN\nbằng kết hợp hai yếu tốtương đồng (similarity) và tầm quan trọng tinh tếcủa từng thực thể(saliency). **6.2** **Công thức Cốt lõi**\n\n\nweight( _x_ _j_ _,_ _q_ ) = (1 _−_ _α_ ) _×_ similarity( _x_ _j_ _,_ _q_ ) _×_ ICF( _y_ ( _x_ _j_ )) + _α ×_ saliency( _x_ _j_ _,_ _q_ ) (5)\n\n\nTrong đó:\n\n\n_x_ _j_ _·_ _q_\nsimilarity( _x_ _j_ _, q_ ) = cos( _x_ _j_ _, q_ ) = (6)\n_∥x_ _j_ _∥× ∥q∥_\n\n\n\n_N_\nICF( _c_ _i_ ) =\n_M × n_ _i_\n\n\n\n(7)\n\n\n\nsaliency( _x_ _j_ _, q_ ) = _∥∇_ _x_ _j_ _L_ ( _f_ ( _x_ _j_ ) _,_ ˆ _y_ ) _∥_ 2 (8)\n\n_α ∈_ [0 _,_ 1] (tham sốcân bằng) (9)\n\n\n**6.3** **Quyết định Phân loại Cuối cùng**\n\n\n\nˆ\n_y_ = arg max\n_c_ _i_ _∈C_\n\n\n\n�\n\n_x_ _j_ _∈N_ _K_ ( _q_ )\n_y_ ( _x_ _j_ )= _c_ _i_\n\n\n20\n\n\n\nweight( _x_ _j_ _, q_ ) (10)"
+        }
+      ],
+      "model_verdict": null
+    },
+    "13": {
+      "supported_by_embeddings": true,
+      "max_similarity": 0.8059824109077454,
+      "evidence": [
+        {
+          "idx": 14,
+          "page": 20,
+          "score": 0.5798600316047668,
+          "text": "**6.1** **Khung Phân loại Trọng sốĐềxuất**\n\n\nVì vậy nhóm đã nghiên cứu và đềxuất áp dụng công thức trọng sốmới trong quá trình voting của KNN\nbằng kết hợp hai yếu tốtương đồng (similarity) và tầm quan trọng tinh tếcủa từng thực thể(saliency). **6.2** **Công thức Cốt lõi**\n\n\nweight( _x_ _j_ _,_ _q_ ) = (1 _−_ _α_ ) _×_ similarity( _x_ _j_ _,_ _q_ ) _×_ ICF( _y_ ( _x_ _j_ )) + _α ×_ saliency( _x_ _j_ _,_ _q_ ) (5)\n\n\nTrong đó:\n\n\n_x_ _j_ _·_ _q_\nsimilarity( _x_ _j_ _, q_ ) = cos( _x_ _j_ _, q_ ) = (6)\n_∥x_ _j_ _∥× ∥q∥_\n\n\n\n_N_\nICF( _c_ _i_ ) =\n_M × n_ _i_\n\n\n\n(7)\n\n\n\nsaliency( _x_ _j_ _, q_ ) = _∥∇_ _x_ _j_ _L_ ( _f_ ( _x_ _j_ ) _,_ ˆ _y_ ) _∥_ 2 (8)\n\n_α ∈_ [0 _,_ 1] (tham sốcân bằng) (9)\n\n\n**6.3** **Quyết định Phân loại Cuối cùng**\n\n\n\nˆ\n_y_ = arg max\n_c_ _i_ _∈C_\n\n\n\n�\n\n_x_ _j_ _∈N_ _K_ ( _q_ )\n_y_ ( _x_ _j_ )= _c_ _i_\n\n\n20\n\n\n\nweight( _x_ _j_ _, q_ ) (10)"
+        },
+        {
+          "idx": 18,
+          "page": 7,
+          "score": 0.7496178150177002,
+          "text": "Tham số _α_ là tham sốđiều chỉnh, quyết định mức độưu tiên của điểm saliency so với độ\ntương đồng tổng thểcủa tin nhắn. - **Vote Scores:** Hệthống hiển thịđiểm sốbỏphiếu cho mỗi lớp ( _Ham_ và _Spam_ ). Dựđoán cuối\ncùng sẽlà lớp có điểm sốcao nhất. - **Spam Subcategory:** Nếu tin nhắn được phân loại là _SPAM_, hệthống tiếp tục phân tích đểxác\nđịnh tiểu mục spam cụthể(ví dụ: _spam_quangcao_, _spam_hethong_ ). **Cơ sởgiải thích (Top neighbors):** Hệthống liệt kê một sốhàng xóm gần nhất trong cơ sởdữ\nliệu vector. Mỗi neighbors bao gồm:\n\n\n**–** _Nhãn (Label):_ Nhãn của tin nhắn gốc ( _ham_ hoặc _spam_ ). **–**\n_Độtương đồng (Similarity):_ Giá trịthểhiện mức độtương đồng giữa tin nhắn đầu vào và\nhàng xóm. **–**\n_Nội dung (Message):_ Nội dung của tin nhắn hàng xóm. 7"
+        },
+        {
+          "idx": 33,
+          "page": 6,
+          "score": 0.8059824109077454,
+          "text": "**Similarity Search (KNN-Classifier):**\n\n\n **Vấn đềtồn đọng:** Phương pháp bỏphiếu đa số( _majority vote_ ) đơn giản trong KNN bỏqua\nmức độquan trọng của từng hàng xóm, nên các điểm ”xa” nhưng đông vẫn có thểáp đảo những\nđiểm ”gần” và ảnh hưởng sai lệch đến kết quảphân loại. **Giải pháp:** Khi có một tin nhắn mới, hệthống tìm kiếm những tin nhắn tương tựnhất. Quyết\nđịnh phân loại được đưa ra bằng Weighted KNN, sửdụng độtương đồng ( _similarity score_ ) làm\ntrọng sốđểưu tiên các hàng xóm gần hơn. 6"
+        }
+      ],
+      "model_verdict": null
+    },
+    "14": {
+      "supported_by_embeddings": true,
+      "max_similarity": 1.1322075128555298,
+      "evidence": [
+        {
+          "idx": 53,
+          "page": 17,
+          "score": 0.6295226812362671,
+          "text": "**AI VIETNAM** **aivietnam.edu.vn**\n\n\n**Cấu trúc** BERT-base có **12 lớp encoder**, mỗi lớp bao gồm:\n\n\n1. **Multi-Head Self-Attention** : Cho phép mỗi token “chú ý” đến các token khác trong chuỗi để\ncập nhật vector của nó. Công thức:\n\n\n\n_QK_ _T_\nAttention( _Q, K, V_ ) = softmax\n� ~~_√_~~ _d_ _k_\n\n\n\n_V_\n�\n\n\n\n\n  - _Q_, _K_, _V_ : Ma trận query, key, value, được tạo từma trận embedding qua các trọng số _W_ _Q_,\n_W_ _K_, _W_ _V_ . - _d_ _k_ : Kích thước mỗi head (768 / 12 = 64). - Mỗi lớp có **12 head**, mỗi head xửlý một góc nhìn khác của ngữcảnh. Ví dụ: Trong “Nhận ngay quà tặng miễn phí!”, token “miễn” chú ý mạnh đến “quà” và “tặng”,\ntạo ngữcảnh quảng cáo. Attention Mask đảm bảo không chú ý đến [PAD]. Kết quả: Ma trận 16\n_×_ 768, với mỗi token được cập nhật dựa trên ngữcảnh. 2. **Residual Connection và Layer Normalization** : Cộng đầu vào và đầu ra của attention:\n\n\n_x_ + Attention( _x_ )\n\n\nSau đó chuẩn hóa:\nLayerNorm( _x_ + Attention( _x_ ))\n\n\n3. **Feed-Forward Neural Network (FFN)** : ..."
+        },
+        {
+          "idx": 50,
+          "page": 7,
+          "score": 1.0809839963912964,
+          "text": "**AI VIETNAM** **aivietnam.edu.vn**\n\n\n**Explainable AI (XAI) và Classifier:**\n\n\n **Vấn đềtồn đọng:** Mô hình hoạt động như một ”hộp đen”, khó giải thích lý do đưa ra dựđoán. Khảnăng giải thích thường bịtách rời khỏi quá trình phân loại chính. **Giải pháp:** Tích hợp khảnăng giải thích vào lõi của bộphân loại. **–**\n_Masking-based Saliency:_ Phương pháp này xác định các từkhóa quan trọng nhất trong tin\nnhắn. Nói trực quan thì từnào quan trọng trong quyết định spam hơn sẽđược tô đậm hơn. **–**\n_Phân loại có tích hợp Saliency:_ Bộphân loại sửdụng một tham số‘alpha‘ đểđiều chỉnh mức\nđộảnh hưởng của điểm nổi bật (saliency score) vào công thức phân loại cuối cùng, giúp kết\nquảchính xác hơn và có thểgiải thích được. **Đầu ra cuối cùng:** Đầu ra cho mỗi câu gồm thông tin dựđoán và chỉsốgiải thích cho dựđoán đó,\ngiúp người dùng hiểu rõ quyết định của mô hình. Cấu trúc đầu ra bao gồm:\n\n\n - **Lớp dựđoán:** Tin nhắn được gán nhãn dựđoán cuối cùng ( _SPAM_ hoặc _HAM_ ) dựa trên kết quả\nphân loại. *..."
+        },
+        {
+          "idx": 54,
+          "page": 22,
+          "score": 1.1322075128555298,
+          "text": "Lấy ví dụđơn giản, giảsửchúng ta có một mã là một chuỗi nhịphân độdài 5, chẳng hạn như “ `10001` ”. Khi đó, lượng tin của mã này sẽlà 5 bit. Hình 3: Minh họa mối quan hệgiữa nội dung thông tin và tần suất lớp\n\n\nTừlý thuyết thông tin, nội dung thông tin của lớp _c_ _i_ là:\n\n\n\n_n_ _i_\n_I_ ( _c_ _i_ ) = _−_ log 2 ( _P_ ( _c_ _i_ )) = _−_ log 2\n� _N_\n\n\n\n(20)\n�\n\n\n\nICF của chúng ta tỷlệthuận với 2 _[I]_ [(] _[c]_ _[i]_ [)/][ log] [2] [(] _[N]_ [/] _[M]_ [)], có nghĩa là **các lớp hiếm hơn mang nhiều thông**\n**tin hơn** và nên nhận được trọng sốtỷlệcao hơn. **6.4.2** **Trọng sốKhoảng cách dựa trên Similarity**\n\n\n**Định nghĩa 2** (Cosine Similarity Kernel) **.** _Thành phần similarity đảm bảo rằng_ _**láng giềng gần hơn**_\n_**có ảnh hưởng mạnh hơn**_ _:_\n\n\n_x_ _j_ _·_ _q_\n_K_ cos ( _x_ _j_ _, q_ ) = cos( _x_ _j_ _, q_ ) = (21)\n_∥x_ _j_ _∥× ∥q∥_\n\n\n**Mệnh đề2** (Tính chất Kernel) **.** _K_ cos _là một Mercer kernel hợp lệthỏa mãn dựa trên nghiên cứu Ghojogh,_\n_B., Ghodsi, A., Karray, F., & Crowl..."
+        }
+      ],
+      "model_verdict": null
+    },
+    "15": {
+      "supported_by_embeddings": true,
+      "max_similarity": 0.9300246834754944,
+      "evidence": [
+        {
+          "idx": 3,
+          "page": 28,
+          "score": 0.746843695640564,
+          "text": "**–**\nNhờđó, mô hình có thểhiểu được sựkhác biệt tinh tếgiữa các cách diễn đạt, xửlý được\ncác từđồng nghĩa và các biến thểngôn ngữ. **Nhược điểm:**\n\n\n**– Đòi hỏi tài nguyên tính toán lớn:** Việc huấn luyện và fine-tuning các mô hình này cần\nnhiều thời gian và chi phí. **– Phức tạp:** Việc fine-tuning cho từng tác vụcụthểcó thểphức tạp. Đặc biệt, nếu không có\nđủdữliệu đã được gán nhãn, hiệu quảcủa các mô hình này sẽbịhạn chế. **7.3** **Phương pháp Semi-supervised sub-category của spam**\n\n\nĐểtận dụng ưu điểm của 2 phương pháp phân loại sub-category phần trên. Chúng tôi đềxuất thực\nhiện một phương pháp semi-supervised bằng cách kết hợp bert embeđings với nối từkhóa. Phương pháp này được gọi là ”bán giám sát” vì nó sửdụng một lượng nhỏdữliệu có nhãn (reference_texts\nvà category_keywords) đểphân loại một lượng lớn dữliệu chưa có nhãn (spam_texts). Tiến trình thực hiện của phương pháp như sau:\n\n\n1. **Bước 1: BERT embeddings**\n\n\n  **Tạo Embeddings của Văn bản Spam:** đểbiến mỗi tin nhắn spam ..."
+        },
+        {
+          "idx": 2,
+          "page": 15,
+          "score": 0.8782092928886414,
+          "text": "**AI VIETNAM** **aivietnam.edu.vn**\n\n\nmua, thanh toán,.... **Bi-directional (hai chiều):** Ngữnghĩa của một từkhông chỉđược biểu diễn bởi những từliền trước\nmà còn được giải thích bởi toàn bộcác từxung quanh. Luồng giải thích tuân theo đồng thời từtrái\nqua phải và từphải qua trái cùng một lúc. Đại diện cho các phép biểu diễn từnày là những mô hình\nsửdụng kỹthuật transformer ví dụnhư BERT. **5.2** **BERT là gì?**\n\n\nBERT (Bidirectional Encoder Representations from Transformers) là một mô hình học sâu tiên tiến do\nGoogle phát triển, nổi bật với khảnăng hiểu ngữcảnh ngôn ngữtựnhiên theo hai chiều. Trong bài toán\nphân loại tin nhắn spam/ham, BERT chuyển đổi tin nhắn thành biểu diễn số, nắm bắt ngữcảnh sâu sắc,\nvà dựđoán nhãn (spam hoặc ham) với độchính xác cao. Kiến trúc BERT-base gồm **12 lớp encoder**\n**Transformer**, mỗi lớp có **768 chiều ẩn** (hidden size) và **12 head attention**, với tổng cộng khoảng\n**110 triệu tham số** . Mô hình được huấn luyện trước trên dữliệu lớn (Wikipedia, Bo..."
+        },
+        {
+          "idx": 16,
+          "page": 13,
+          "score": 0.9300246834754944,
+          "text": "Nếu có thêm thời gian, nhóm sẽmởrộng phương pháp này đểgiải thích cho cảcác câu được\nphân loại là ham, tuy nhiên cách làm sẽhoàn toàn tương tự. **Ý tưởng thuật toán:** Đầu tiên, ta tính `spam_scores` ban đầu — là tổng điểm tương đồng giữa\nembedding của câu đầu vào với các láng giềng có nhãn “spam” trong tập huấn luyện. Sau đó, ta đo\nmức độgiảm điểm `spam_scores` khi lần lượt che từng token, theo các bước sau:\n\n\n13"
+        }
+      ],
+      "model_verdict": null
+    },
+    "16": {
+      "supported_by_embeddings": true,
+      "max_similarity": 1.2162450551986694,
+      "evidence": [
+        {
+          "idx": 46,
+          "page": 11,
+          "score": 0.9961504340171814,
+          "text": "**Xây dựng tập cụm ngữnghĩa theo chủđề** : Các nhóm cụm từđược phân loại theo 7 chủđề\ndễgây nhầm lẫn giữa spam và ham, bao gồm:\n\n\n  - `financial_phrases` (liên quan đến giao dịch, tiền bạc)\n\n\n  - `promotion_phrases` (quảng cáo, ưu đãi)\n\n  - `lottery_phrases` (trúng thưởng, phần thưởng)\n\n\n  - `scam_alert_phrases` (cảnh báo giảmạo)\n\n\n  - `call_to_action_phrases` (dẫn dụngười dùng hành động)\n\n\n  - `social_engineering_phrases` (lừa đảo cảm xúc)\n\n  - `obfuscated_phrases` (che giấu, tránh bộlọc spam)\n\n\n2. **Sinh dữliệu bằng kịch bản và LLM** :\n\n\n    - Với mỗi nhóm cụm từ, nhóm thiết kếmột tập các kịch bản “base” như: _“Hey, did you hear_\n_about...”_, _“Bro, you should check this out”_ ... - Các cụm spam hoặc ham tương ứng được **chèn vào base**, tạo ra các mẫu dữliệu mới, theo\ncấu trúc _“base + insert”_ hoặc _“insert + base”_ . - Ngoài ra, nhóm chúng mình sửdụng LLM (như GPT hoặc Mixtral) đểsinh các câu mới theo\ntemplate kịch bản thực tế, nhằm tái hiện các loại spam ngụy trang phổbiến."
+        },
+        {
+          "idx": 66,
+          "page": 3,
+          "score": 1.1186320781707764,
+          "text": "**Email Spam là gì?**\n\n\n\n\n\n**Ví dụ(Spam Email):**\n\n\n _“Win a brand new iPhone today! Just click this link to claim!”_\n\n\n _“You’ve been selected for a $1000 Walmart gift card!”_\n\n\n _“Invest in crypto now and double your money overnight!”_\n\n\n**Email Ham là gì?**\n\n\n\n\n\n**Ví dụ(Ham Email):**\n\n\n _“Hi John, just a reminder that your doctor’s appointment is at 3PM today.”_\n\n\n _“Your monthly salary has been transferred to your account.”_\n\n\n _“Please review the attached report before the meeting tomorrow.”_\n\n\n3"
+        },
+        {
+          "idx": 26,
+          "page": 14,
+          "score": 1.2162450551986694,
+          "text": "Các kết quảbiểu diễn từđã\ncó bối cảnh nhưng chỉđược giải thích bởi một chiều từtrái qua phải hoặc từphải qua trái. VD:\n\n\n**Câu C:** Hôm nay tôi mang 200 tỷ[gửi] ởngân hàng. **Câu D:** Hôm nay tôi mang 200 tỷ[gửi] …. Như vậy véc tơ biểu diễn của từ **gửi** được xác định thông qua các từliền trước với nó. Nếu chỉdựa vào\ncác từliền trước Hôm nay tôi mang 200 tỷthì ta có thểnghĩ từphù hợp ởvịtrí hiện tại là cho vay,\n\n\n14"
+        }
+      ],
+      "model_verdict": null
+    },
+    "17": {
+      "supported_by_embeddings": true,
+      "max_similarity": 0.6036962270736694,
+      "evidence": [
+        {
+          "idx": 21,
+          "page": 15,
+          "score": 0.5917988419532776,
+          "text": "Trong bài toán spam/ham, BERT được tinh\nchỉnh đểtối ưu hóa dựđoán nhãn và tập trung vào các từkhóa quan trọng như “miễn phí” hoặc “quà\ntặng” trong tin nhắn spam. **Ứng dụng** : Trong phân loại tin nhắn spam/ham, BERT chuyển tin nhắn thành vector số, hiểu ngữ\ncảnh sâu sắc (ví dụ: nhận diện ”miễn phí” trong ngữcảnh quảng cáo), và dựđoán nhãn (spam hoặc\nham). **Ưu điểm** :\n\n\n  - Hiểu ngữcảnh hai chiều, vượt trội so với các phương pháp truyền thống như TF-IDF. - Sửdụng vector [CLS] đểtổng hợp thông tin toàn câu, phù hợp cho phân loại. **5.3** **Kiến trúc BERT**\n\n\nQuy trình xửlý của BERT bao gồm ba giai đoạn chính:\n\n\n1. **Mã hóa đầu vào** : Chuyển tin nhắn thành token, embedding, và attention mask. 2. **Xửlý qua Transformer encoder** : Tạo biểu diễn ngữcảnh cho từng token, đặc biệt là vector\n\n[CLS]. 3. **Phân loại** : Sửdụng vector [CLS] đểdựđoán nhãn spam/ham. Phần này trình bày chi tiết từng thành phần của kiến trúc BERT và cách chúng hỗtrợbài toán phân\nloại tin nhắn spam/ham. **5.3.1** *..."
+        },
+        {
+          "idx": 1,
+          "page": 5,
+          "score": 0.6036962270736694,
+          "text": "Điều này đặc biệt quan trọng\ntrong các hệthống chống spam hiện đại, giúp người dùng hiểu rõ liệu một email nên bịxóa, xem qua\nhay báo cáo. Ngoài ra, nhóm còn hướng đến việc **mởrộng phân loại chi tiết trong nhóm spam**\n(quảng cáo, hệthống, lừa đảo, v.v...) nhằm tăng trải nghiệm và bảo mật cho người dùng. Hệthống phân loại tin nhắn spam/ham được thiết kếvới cơ chếđầu vào – đầu ra như sau:\n\n\n\n\n\n5"
+        }
+      ],
+      "model_verdict": null
+    },
+    "18": {
+      "supported_by_embeddings": true,
+      "max_similarity": 0.974981427192688,
+      "evidence": [
+        {
+          "idx": 3,
+          "page": 28,
+          "score": 0.5795202255249023,
+          "text": "**–**\nNhờđó, mô hình có thểhiểu được sựkhác biệt tinh tếgiữa các cách diễn đạt, xửlý được\ncác từđồng nghĩa và các biến thểngôn ngữ. **Nhược điểm:**\n\n\n**– Đòi hỏi tài nguyên tính toán lớn:** Việc huấn luyện và fine-tuning các mô hình này cần\nnhiều thời gian và chi phí. **– Phức tạp:** Việc fine-tuning cho từng tác vụcụthểcó thểphức tạp. Đặc biệt, nếu không có\nđủdữliệu đã được gán nhãn, hiệu quảcủa các mô hình này sẽbịhạn chế. **7.3** **Phương pháp Semi-supervised sub-category của spam**\n\n\nĐểtận dụng ưu điểm của 2 phương pháp phân loại sub-category phần trên. Chúng tôi đềxuất thực\nhiện một phương pháp semi-supervised bằng cách kết hợp bert embeđings với nối từkhóa. Phương pháp này được gọi là ”bán giám sát” vì nó sửdụng một lượng nhỏdữliệu có nhãn (reference_texts\nvà category_keywords) đểphân loại một lượng lớn dữliệu chưa có nhãn (spam_texts). Tiến trình thực hiện của phương pháp như sau:\n\n\n1. **Bước 1: BERT embeddings**\n\n\n  **Tạo Embeddings của Văn bản Spam:** đểbiến mỗi tin nhắn spam ..."
+        },
+        {
+          "idx": 61,
+          "page": 26,
+          "score": 0.8431670665740967,
+          "text": "Những cải thiện này đến từcác yếu tốsau:\n\n\n **Tăng cường dữliệu:** sinh thêm mẫu khó và thay từđồng nghĩa giúp đa dạng hóa ngữcảnh và\nlàm mô hình học được ranh giới phân biệt tốt hơn. **Tập huấn luyện lớn hơn:** từdưới 1.000 mẫu lên hơn 9.000 mẫu giúp mô hình tổng quát hóa\ntốt hơn. **Tập trung vào mẫu khó:** ưu tiên những ví dụgần ranh giới giữa spam/ham nhằm tăng tính\nphân biệt cho mô hình. **Kết luận:** Mô hình mới không chỉđạt hiệu suất cao ở _k_ = 5 mà còn cải thiện đáng kểở _k_ = 1, rất hữu\ních cho các ứng dụng yêu cầu tốc độsuy luận nhanh mà vẫn đảm bảo độchính xác cao. 26"
+        },
+        {
+          "idx": 13,
+          "page": 14,
+          "score": 0.974981427192688,
+          "text": "Hiệu quảbiểu thịnội dung và truyền đạt ý nghĩa sẽlớn hơn so với từng từđứng độc lập. Ngữcảnh trong câu có một sựảnh hưởng rất lớn trong việc giải thích ý nghĩa của từ. Hiểu được vai\ntrò mấu chốt đó, các thuật toán NLP SOTA đều cốgắng đưa ngữcảnh vào mô hình nhằm tạo ra sự\nđột phá, giúp mô hình học được thông tin chính xác hơn. Phân cấp mức độphát triển của các phương pháp embedding từtrong NLP có thểbao gồm các nhóm:\n\n\n**Non-context (không bối cảnh):** Là các thuật toán không tồn tại bối cảnh trong biểu diễn từ. Đó là\ncác thuật toán NLP đời đầu như ‘ word2vec, GLoVe, fasttext‘. Chúng ta chỉcó duy nhất một biểu diễn\nvéc tơ cho mỗi một từmà không thay đổi theo bối cảnh. VD:\n\n\n**Câu A:** Cánh [đồng] này sắp được thu hoạch. **Câu B:** Tôi [đồng] ý với ý kiến của anh! Thì từ **đồng** sẽmang 2 ý nghĩa khác nhau nên phải có hai biểu diễn từriêng biệt. Các thuật toán\nnon-context không đáp ứng được sựđa dạng vềngữnghĩa của từtrong NLP. **Uni-directional (một chiều):** Là các thuật toán đã bắt đ..."
+        }
+      ],
+      "model_verdict": null
+    },
+    "19": {
+      "supported_by_embeddings": true,
+      "max_similarity": 0.7636357545852661,
+      "evidence": [
+        {
+          "idx": 14,
+          "page": 20,
+          "score": 0.6900026798248291,
+          "text": "**6.1** **Khung Phân loại Trọng sốĐềxuất**\n\n\nVì vậy nhóm đã nghiên cứu và đềxuất áp dụng công thức trọng sốmới trong quá trình voting của KNN\nbằng kết hợp hai yếu tốtương đồng (similarity) và t���m quan trọng tinh tếcủa từng thực thể(saliency). **6.2** **Công thức Cốt lõi**\n\n\nweight( _x_ _j_ _,_ _q_ ) = (1 _−_ _α_ ) _×_ similarity( _x_ _j_ _,_ _q_ ) _×_ ICF( _y_ ( _x_ _j_ )) + _α ×_ saliency( _x_ _j_ _,_ _q_ ) (5)\n\n\nTrong đó:\n\n\n_x_ _j_ _·_ _q_\nsimilarity( _x_ _j_ _, q_ ) = cos( _x_ _j_ _, q_ ) = (6)\n_∥x_ _j_ _∥× ∥q∥_\n\n\n\n_N_\nICF( _c_ _i_ ) =\n_M × n_ _i_\n\n\n\n(7)\n\n\n\nsaliency( _x_ _j_ _, q_ ) = _∥∇_ _x_ _j_ _L_ ( _f_ ( _x_ _j_ ) _,_ ˆ _y_ ) _∥_ 2 (8)\n\n_α ∈_ [0 _,_ 1] (tham sốcân bằng) (9)\n\n\n**6.3** **Quyết định Phân loại Cuối cùng**\n\n\n\nˆ\n_y_ = arg max\n_c_ _i_ _∈C_\n\n\n\n�\n\n_x_ _j_ _∈N_ _K_ ( _q_ )\n_y_ ( _x_ _j_ )= _c_ _i_\n\n\n20\n\n\n\nweight( _x_ _j_ _, q_ ) (10)"
+        },
+        {
+          "idx": 0,
+          "page": 19,
+          "score": 0.7097625732421875,
+          "text": "**AI VIETNAM** **aivietnam.edu.vn**\n\n## **6 KNN with Weight Voting**\n\n\n**1.6.1 Vấn đềMất cân bằng Lớp trong K-Nearest Neighbors**\n\n\nPhân phối lớp mất cân bằng đại diện cho cảthách thức lý thuyết và thực tiễn trong phân loại KNearest Neighbors, được tài liệu hóa rộng rãi trong văn hệmáy học (A survey on imbalanced learning:\nlatest research, applications and future directions: https://link.springer.com/article/10.1007/s10462024-10759-6). Vấn đềnày trởnên đặc biệt nghiêm trọng trong các lĩnh vực có phân phối lớp bịlệch tự\nnhiên, chẳng hạn như phát hiện gian lận (giao dịch gian lận _∼_ 0 _._ 1%), sàng lọc y tế(tỷlệmắc bệnh\n_∼_ 1 _−_ 5%), và lọc thư rác (tỷlệspam _∼_ 10 _−_ 40%). Vấn đềcơ bản xuất phát từviệc KNN dựa vào **majority voting**, hệthống ưu tiên lớp chiếm ưu thế\nbất kểmức độliên quan ngữnghĩa của từng láng giềng. Hình 2: Enter Caption\n\n\n**1.7.1 Hạn chếcủa Majority Voting trong Môi trường Mất cân bằng**\n\n\n**1.7.1.1 Phân tích Toán học vềBias của Majority Voting**\n\n\nGọi _C_ = _{c_ ..."
+        },
+        {
+          "idx": 33,
+          "page": 6,
+          "score": 0.7636357545852661,
+          "text": "**Similarity Search (KNN-Classifier):**\n\n\n **Vấn đềtồn đọng:** Phương pháp bỏphiếu đa số( _majority vote_ ) đơn giản trong KNN bỏqua\nmức độquan trọng của từng hàng xóm, nên các điểm ”xa” nhưng đông vẫn có thểáp đảo những\nđiểm ”gần” và ảnh hưởng sai lệch đến kết quảphân loại. **Giải pháp:** Khi có một tin nhắn mới, hệthống tìm kiếm những tin nhắn tương tựnhất. Quyết\nđịnh phân loại được đưa ra bằng Weighted KNN, sửdụng độtương đồng ( _similarity score_ ) làm\ntrọng sốđểưu tiên các hàng xóm gần hơn. 6"
+        }
+      ],
+      "model_verdict": null
+    },
+    "20": {
+      "supported_by_embeddings": true,
+      "max_similarity": 1.0194404125213623,
+      "evidence": [
+        {
+          "idx": 41,
+          "page": 19,
+          "score": 0.8875085115432739,
+          "text": "Đối với điểm truy vấn _q_, KNN truyền thống tính toán:\n\n\nˆ\n_y_ = arg max _c_ _i_ _∈C_ _[|{][x]_ _[j]_ _[ ∈N]_ _[K]_ [(] _[q]_ [) :] _[ y]_ [(] _[x]_ _[j]_ [) =] _[ c]_ _[i]_ _[}|]_ (1)\n\n\n**Phân tích Bias:**\nXác suất đểmột K-neighborhood ngẫu nhiên chứa _k_ thực thểtừlớp _c_ _i_ tuân theo phân phối siêu hình\nhọc:\n\n\n19"
+        },
+        {
+          "idx": 28,
+          "page": 16,
+          "score": 1.0129456520080566,
+          "text": "**Position Embedding** : Biểu diễn vịtrí của token (0, 1, 2, ...) đểgiữthông tin thứtự(Trong\nBERT, Position Embedding không sửdụng hàm sin/cosin như Transformer gốc, mà là các\nvector học được (learned embeddings)). **Segment Embedding** : Phân biệt các câu (thường là 0 cho một tin nhắn). Ví dụ: Token “miễn” ởvịtrí 5:\n\n\n   - Token Embedding: `[0.2, 0.1, ..., 0.3]` (768 chiều). - Position Embedding: `[0.01, -0.02, ..., 0.1]` (vịtrí 5). - Segment Embedding: `[0, 0, ..., 0]` (một câu). - Tổng embedding: `[0.21, 0.08, ..., 0.4]` (768 chiều). Kết quả: Ma trận embedding **16** _×_ **768** (16 token _×_ 768 chiều). 4. **Attention Mask** : Vector nhịphân chỉđịnh token nào được xửlý (1 cho token thực, 0 cho [PAD]). Ví dụ: `[1, 1, 1, 1, 1, 1, 1, 1, 1, 0, ..., 0]` (9 token thực, 7 [PAD]). **Liên hệvới spam/ham** Mã hóa đầu vào đảm bảo tin nhắn như “Nhận ngay quà tặng miễn phí!”\nđược chuyển thành ma trận số, với token [CLS] đóng vai trò tổng hợp ngữcảnh (như đặc trưng quảng\ncáo của “miễn phí”) đểhỗ..."
+        },
+        {
+          "idx": 18,
+          "page": 7,
+          "score": 1.0194404125213623,
+          "text": "Tham số _α_ là tham sốđiều chỉnh, quyết định mức độưu tiên của điểm saliency so với độ\ntương đồng tổng thểcủa tin nhắn. - **Vote Scores:** Hệthống hiển thịđiểm sốbỏphiếu cho mỗi lớp ( _Ham_ và _Spam_ ). Dựđoán cuối\ncùng sẽlà lớp có điểm sốcao nhất. - **Spam Subcategory:** Nếu tin nhắn được phân loại là _SPAM_, hệthống tiếp tục phân tích đểxác\nđịnh tiểu mục spam cụthể(ví dụ: _spam_quangcao_, _spam_hethong_ ). **Cơ sởgiải thích (Top neighbors):** Hệthống liệt kê một sốhàng xóm gần nhất trong cơ sởdữ\nliệu vector. Mỗi neighbors bao gồm:\n\n\n**–** _Nhãn (Label):_ Nhãn của tin nhắn gốc ( _ham_ hoặc _spam_ ). **–**\n_Độtương đồng (Similarity):_ Giá trịthểhiện mức độtương đồng giữa tin nhắn đầu vào và\nhàng xóm. **–**\n_Nội dung (Message):_ Nội dung của tin nhắn hàng xóm. 7"
+        }
+      ],
+      "model_verdict": null
+    }
+  }
+}

test/mcq_output.json

@@ -1,162 +1,199 @@
 {
   "mcqs": {
     "1": {
-      "câu hỏi": "Trong lớp Str_OutputParser, biểu thức chính quy nào được sử dụng để trích xuất câu trả lời từ chuỗi phản hồi?",
+      "câu hỏi": "Trong bảng tổng hợp các nhóm nội dung dễ gây nhầm lẫn, nhóm nào liên quan đến giao dịch tiền bạc?",
       "lựa chọn": {
-        "a": "r\"Answer:\\s*(.*)\"",
-        "b": "r\"Respuesta:\\s*(.*)\"",
-        "c": "r\"Answer :\\s*(.*)\"",
-        "d": "r\"Result:\\s*(.*)\""
+        "a": "promotion_phrases",
+        "b": "financial_phrases",
+        "c": "lottery_phrases",
+        "d": "scam_alert_phrases"
       },
-      "đáp án": "r\"Answer :\\s*(.*)\""
+      "đáp án": "financial_phrases"
     },
     "2": {
-      "câu hỏi": "Trong dự án RAG, file nào được dùng để khai báo các hàm load file PDF?",
+      "câu hỏi": "Theo mô tả về kiến trúc BERT‑base trong nội dung, mô hình này có bao nhiêu lớp encoder Transformer?",
       "lựa chọn": {
-        "a": "src/rag/main.py",
-        "b": "src/rag/file_loader.py",
-        "c": "src/rag/offline_rag.py",
-        "d": "src/rag/utils.py"
+        "a": "10",
+        "b": "12",
+        "c": "24",
+        "d": "48"
       },
-      "đáp án": "src/rag/file_loader.py"
+      "đáp án": "12"
     },
     "3": {
-      "câu hỏi": "Trong file src/rag/vectorstore.py, lớp nào được đặt làm giá trị mặc định cho vector database?",
+      "câu hỏi": "Theo Định lý 6.1 (Tính chất Convex Combination), công thức tính trọng số kết hợp bằng tham số α là gì?",
       "lựa chọn": {
-        "a": "FAISS",
-        "b": "Chroma",
-        "c": "Pinecone",
-        "d": "Milvus"
+        "a": "weight = (1 - α) × w_similarity × ICF + α × w_saliency",
+        "b": "weight = α × w_similarity × ICF + (1 - α) × w_saliency",
+        "c": "weight = w_similarity + w_saliency",
+        "d": "weight = α × (w_similarity + w_saliency)"
       },
-      "đáp án": "Chroma"
+      "đáp án": "weight = (1 - α) × w_similarity × ICF + α × w_saliency"
     },
     "4": {
-      "câu hỏi": "Trong đoạn mã được trích dẫn, tham số nào được sử dụng cho kiểu lượng tử (quantization type) trong cấu hình BitsAndBytesConfig?",
+      "câu hỏi": "Theo nội dung, một nhược điểm của phương pháp dựa trên từ khóa trong việc phát hiện spam là gì?",
       "lựa chọn": {
-        "a": "nf4",
-        "b": "int8",
-        "c": "fp16",
-        "d": "int4"
+        "a": "Có thể xử lý các biến thể và lỗi chính tả",
+        "b": "Thiếu linh hoạt khi từ khóa thay đổi",
+        "c": "Không hiểu ngữ cảnh của từ trong các câu",
+        "d": "Đòi hỏi tính toán phức tạp"
       },
-      "đáp án": "nf4"
+      "đáp án": "Không hiểu ngữ cảnh của từ trong các câu"
     },
     "5": {
-      "câu hỏi": "Theo mô tả trong nội dung, bước nào liên quan đến việc tạo cơ sở dữ liệu vector bằng mô hình embedding?",
+      "câu hỏi": "Theo đoạn văn, điều nào sau đây mô tả đúng về mô hình BERT?",
       "lựa chọn": {
-        "a": "Tách danh sách các bài báo khoa học thành các văn bản nhỏ.",
-        "b": "Xây dựng một cơ sở dữ liệu vector từ các văn bản nhỏ bằng mô hình embedding.",
-        "c": "Truy vấn các mẫu văn bản có liên quan đến câu hỏi đầu vào để làm ngữ cảnh.",
-        "d": "Đưa câu prompt (câu hỏi và ngữ cảnh) vào mô hình để nhận câu trả lời."
+        "a": "BERT có 12 lớp encoder, mỗi lớp có kích thước ẩn là 768 và 12 attention head.",
+        "b": "BERT chỉ được huấn luyện bằng nhiệm vụ Dự đoán câu tiếp theo (Next Sentence Prediction - NSP).",
+        "c": "BERT sử dụng kiến trúc một chiều, chỉ xử lý văn bản từ trái sang phải.",
+        "d": "BERT bao gồm 24 lớp encoder và kích thước ẩn là 1024."
       },
-      "đáp án": "Xây dựng một cơ sở dữ liệu vector từ các văn bản nhỏ bằng mô hình embedding."
+      "đáp án": "BERT có 12 lớp encoder, mỗi lớp có kích thước ẩn là 768 và 12 attention head."
     }
   },
   "validation": {
     "1": {
       "supported_by_embeddings": true,
-      "max_similarity": 0.5152225494384766,
+      "max_similarity": 1.0912104845046997,
       "evidence": [
         {
-          "idx": 26,
-          "page": 15,
-          "score": 0.5152225494384766,
-          "text": "Ý nghĩa của phương thức `from_template()` trong class PromptTemplate là? ( _a_ ) Đểkhởi tạo prompt template từmột file. ( _b_ ) Đểkhởi tạo prompt template từmột string. ( _c_ ) Đểkhởi tạo prompt template từmột danh sách các tin nhắn. ( _d_ ) Đểkhởi tạo prompt template từmột prompt template có sẵn. 15"
+          "idx": 27,
+          "page": 4,
+          "score": 0.7866219282150269,
+          "text": "Dưới đây là bảng tổng hợp các nhóm nội dung dễgây nhầm lẫn – xuất hiện trong cảham và spam tinh\nvi, đòi hỏi mô hình phải rất tinh tếmới phân biệt được:\n\n\n\n|Nhóm nội dung|Ví dụ nội dung|Dễ nhầm với|\n|---|---|---|\n|`financial_phrases`|“Please<br>confrm<br>the<br>$200<br>transfer<br>from<br>your<br>account.”<br>“Your invoice for June is now available.”|Scam / Phishing|\n|`promotion_phrases`|“Flash sale ends tonight – 30% of all items!”<br>“Exclusive discount for HUST students.”|Spam quảng cáo|\n|`lottery_phrases`|“You’ve been selected for a loyalty reward.”<br>“You may be eligible for a lucky draw.”|Spam quà tặng /<br>Random Reward|\n|`scam_alert_phrases`|“Unusual login detected. Was this you?”<br>“A payment attempt was blocked on your card.”|Cảnh báo giả/ Giả<br>danh ngân hàng|\n|`call_to_action_phrases`|“Act now to secure your spot in the seminar.”<br>“Verify your email to complete registration.”|Spam ép buộc /<br>Confrmation bait|\n\n\n4"
+        },
+        {
+          "idx": 46,
+          "page": 11,
+          "score": 0.7944862842559814,
+          "text": "**Xây dựng tập cụm ngữnghĩa theo chủđề** : Các nhóm cụm từđược phân loại theo 7 chủđề\ndễgây nhầm lẫn giữa spam và ham, bao gồm:\n\n\n  - `financial_phrases` (liên quan đến giao dịch, tiền bạc)\n\n\n  - `promotion_phrases` (quảng cáo, ưu đãi)\n\n  - `lottery_phrases` (trúng thưởng, phần thưởng)\n\n\n  - `scam_alert_phrases` (cảnh báo giảmạo)\n\n\n  - `call_to_action_phrases` (dẫn dụngười dùng hành động)\n\n\n  - `social_engineering_phrases` (lừa đảo cảm xúc)\n\n  - `obfuscated_phrases` (che giấu, tránh bộlọc spam)\n\n\n2. **Sinh dữliệu bằng kịch bản và LLM** :\n\n\n    - Với mỗi nhóm cụm từ, nhóm thiết kếmột tập các kịch bản “base” như: _“Hey, did you hear_\n_about...”_, _“Bro, you should check this out”_ ... - Các cụm spam hoặc ham tương ứng được **chèn vào base**, tạo ra các mẫu dữliệu mới, theo\ncấu trúc _“base + insert”_ hoặc _“insert + base”_ . - Ngoài ra, nhóm chúng mình sửdụng LLM (như GPT hoặc Mixtral) đểsinh các câu mới theo\ntemplate kịch bản thực tế, nhằm tái hiện các loại spam ngụy trang phổbiến."
+        },
+        {
+          "idx": 44,
+          "page": 12,
+          "score": 1.0912104845046997,
+          "text": "Tuy nhiên sau khi chèn cụm “$200 cashback”, nó trởthành\nmột tin nhắn spam ngụy trang. Những câu như vậy rất khó nhận diện nếu chỉhuấn luyện từtập dữ\nliệu spam kiểu cũ. **Tác dụng**\n\n\nViệc áp dụng data augmentation theo hướng có kiểm soát giúp:\n\n\n **Giảm hiện tượng bias** của mô hình khi gặp spam đời thực, vốn thường mang ngôn ngữtựnhiên\nvà ẩn dụhơn là spam thô sơ kiểu “FREE!!! Click now!!!”\n\n\n **Tăng độrobust** của hệthống khi xửlý các tin nhắn có bềngoài giống ham nhưng nội dung\ntiềm ẩn spam. 12"
         }
       ],
       "model_verdict": {
-        "supported": false,
-        "confidence": 0.9,
-        "evidence": "",
-        "reason": "Context không chứa thông tin về lớp Str_OutputParser hay biểu thức chính quy được sử dụng, vì vậy không thể chứng thực đáp án được đưa ra."
+        "supported": true,
+        "confidence": 0.99,
+        "evidence": "`financial_phrases` (liên quan đến giao dịch, tiền bạc)",
+        "reason": "Context explicitly states that the group 'financial_phrases' is related to transactions and money."
       }
     },
     "2": {
       "supported_by_embeddings": true,
-      "max_similarity": 0.694902777671814,
+      "max_similarity": 1.0187240839004517,
       "evidence": [
         {
-          "idx": 4,
-          "page": 4,
-          "score": 0.694902777671814,
-          "text": "**AI VIETNAM (AIO2024)** **aivietnam.edu.vn**\n\n\n_ **src/rag/:** Thư mục dùng đểlưu trữcác code liên quan đến xây dựng RAG, bao gồm:\n\n\n1. **src/rag/file_loader.py:** File code dùng đểkhai báo các hàm load file pdf (vì tài\nliệu của chúng ta thu thập thuộc file pdf). 2. **src/rag/main.py:** File code dùng đểkhai báo hàm khởi tạo chains. 3. **src/rag/offline_rag.py:** File code dùng đểkhai báo PromptTemplate. 4. **src/rag/utils.py:** File code dùng đểkhai báo hàm tách câu trảlời từmodel. 5. **src/rag/vectorstore.py:** File code dùng đểkhai báo hàm khởi tạo hệcơ sởdữliệu\n\nvector. _ **src/app.py:** File code dùng đểkhởi tạo API. _ **requirements.txt:** File code dùng đểkhai báo các thư viện cần thiết đểsửdụng source\ncode. ## II.2. Cập nhật file requirements.txt\n\n\nĐểbắt đầu, chúng ta sẽliệt kê các gói thư viện cần thiết đểchạy được chương trình này."
+          "idx": 30,
+          "page": 16,
+          "score": 0.6454246044158936,
+          "text": "**5.3.2** **Transformer Encoder**\n\n\n**Mục tiêu** Các lớp Transformer encoder xửlý ma trận embedding đểtạo biểu diễn ngữcảnh sâu sắc\ncho mỗi token, đặc biệt là vector [CLS], giúp nắm bắt mối quan hệgiữa các từtrong tin nhắn. 16"
         },
         {
-          "idx": 28,
-          "page": 16,
-          "score": 0.5763600468635559,
-          "text": "document_loaders` `import` `PyPDFLoader`\n\n\n2\n\n\n3 `pdf_loader = PyPDFLoader(url, extract_images =` `True` `)`\n\n\n4\n\n\n5 `docs = pdf_loader.load ()`\n\n\nTham số `extract_images` tại dòng code 3 có chức năng gì? ( _a_ ) Trảvềtất cảảnh từfile pdf. ( _b_ ) Bỏqua ảnh, chỉload text. ( _c_ ) Phân tích ảnh thành vector. ( _d_ ) Chuyển đổi ảnh trong file pdf thành text. 16"
+          "idx": 53,
+          "page": 17,
+          "score": 0.9272838234901428,
+          "text": "**AI VIETNAM** **aivietnam.edu.vn**\n\n\n**Cấu trúc** BERT-base có **12 lớp encoder**, mỗi lớp bao gồm:\n\n\n1. **Multi-Head Self-Attention** : Cho phép mỗi token “chú ý” đến các token khác trong chuỗi để\ncập nhật vector của nó. Công thức:\n\n\n\n_QK_ _T_\nAttention( _Q, K, V_ ) = softmax\n� ~~_√_~~ _d_ _k_\n\n\n\n_V_\n�\n\n\n\n\n  - _Q_, _K_, _V_ : Ma trận query, key, value, được tạo từma trận embedding qua các trọng số _W_ _Q_,\n_W_ _K_, _W_ _V_ . - _d_ _k_ : Kích thước mỗi head (768 / 12 = 64). - Mỗi lớp có **12 head**, mỗi head xửlý một góc nhìn khác của ngữcảnh. Ví dụ: Trong “Nhận ngay quà tặng miễn phí!”, token “miễn” chú ý mạnh đến “quà” và “tặng”,\ntạo ngữcảnh quảng cáo. Attention Mask đảm bảo không chú ý đến [PAD]. Kết quả: Ma trận 16\n_×_ 768, với mỗi token được cập nhật dựa trên ngữcảnh. 2. **Residual Connection và Layer Normalization** : Cộng đầu vào và đầu ra của attention:\n\n\n_x_ + Attention( _x_ )\n\n\nSau đó chuẩn hóa:\nLayerNorm( _x_ + Attention( _x_ ))\n\n\n3. **Feed-Forward Neural Network (FFN)** : ..."
         },
         {
-          "idx": 16,
-          "page": 9,
-          "score": 0.5420067310333252,
-          "text": "**AI VIETNAM (AIO2024)** **aivietnam.edu.vn**\n\n\n86 `return` `self.load(files, workers=workers)`\n\n## II.6. Cập nhật file src/rag/vectorstore.py\n\n\nTại file này, ta định nghĩa một class đểkhởi tạo hệcơ sởdữliệu vector. Trong project này, chúng\nta sẽsửdụng Chroma. Vềviệc tìm kiếm tài liệu tương đồng, ta sửdụng FAISS. Như vậy, nội\ndung của file như sau:\n\n\nHình 4: Minh họa việc sửdụng vector database Chroma đểtruy vấn các tài liệu có liên quan\n[làm context trong prompt. Ảnh: Link.](https://heidloff.net/article/retrieval-augmented-generation-chroma-langchain/)\n\n\n1 `from` `typing` `import` `Union`\n\n2 `from` `langchain_chroma` `import` `Chroma`\n\n3 `from` `langchain_community .vectorstores` `import` `FAISS`\n\n4 `from` `langchain_community .embeddings` `import` `HuggingFaceEmbeddings`\n\n\n5\n\n\n6 `class` `VectorDB:`\n\n\n7 `def` `__init__(self,`\n\n\n8 `documents = None,`\n\n9 `vector_db: Union[Chroma, FAISS] = Chroma,`\n\n10 `embedding = HuggingFaceEmbeddings (),`\n\n11 `) -> None` `:`\n\n\n12\n\n\n13 `self.vector_db ..."
+          "idx": 32,
+          "page": 28,
+          "score": 1.0187240839004517,
+          "text": "Các chuỗi này đóng vai trò là ”điểm neo” ngữnghĩa cho mỗi loại. Mô hình BERT\ncũng tạo ra một vector nhúng cho mỗi chuỗi này\n\n\n28"
         }
       ],
       "model_verdict": {
         "supported": true,
         "confidence": 0.99,
-        "evidence": "src/rag/file_loader.py: File code dùng để khai báo các hàm load file pdf",
-        "reason": "Context explicitly states that src/rag/file_loader.py declares functions for loading PDF files, matching the answer."
+        "evidence": "BERT-base có **12 lớp encoder**",
+        "reason": "Context explicitly states BERT-base has 12 encoder layers, matching the answer."
       }
     },
     "3": {
       "supported_by_embeddings": true,
-      "max_similarity": 0.579485297203064,
+      "max_similarity": 0.808438777923584,
       "evidence": [
         {
-          "idx": 20,
-          "page": 11,
-          "score": 0.579485297203064,
-          "text": "Cập nhật file src/rag/main.py\n\n\nTại file này, ta khởi tạo toàn bộcác instance của các class, các hàm mà ta đã khai báo trước đó\nvà kết nối chúng vào trong một hàm duy nhất gọi là `build_rag_chain()` :\n\n\n1 `from` `pydantic` `import` `BaseModel, Field`\n\n\n2\n\n\n3 `from src.rag.file_loader` `import` `Loader`\n\n4 `from src.rag.vectorstore` `import` `VectorDB`\n\n5 `from src.rag.offline_rag` `import` `Offline_RAG`\n\n\n6\n\n\n7 `class` `InputQA(BaseModel):`\n\n8 `question: str = Field (..., title=` `\"Question to ask the model\"` `)`\n\n\n9\n\n\n10 `class` `OutputQA(BaseModel):`\n\n11 `answer: str = Field (..., title=` `\"Answer` `from the model\"` `)`\n\n\n12\n\n\n13 `def` `build_rag_chain (llm, data_dir, data_type):`\n\n14 `doc_loaded = Loader(file_type=data_type).load_dir(data_dir, workers=2)`\n\n15 `retriever = VectorDB(documents = doc_loaded).get_retriever ()`\n\n16 `rag_chain = Offline_RAG(llm).get_chain(retriever)`\n\n\n17\n\n\n18 `return` `rag_chain`\n\n\n11"
+          "idx": 14,
+          "page": 20,
+          "score": 0.7317581176757812,
+          "text": "**6.1** **Khung Phân loại Trọng sốĐềxuất**\n\n\nVì vậy nhóm đã nghiên cứu và đềxuất áp dụng công thức trọng sốmới trong quá trình voting của KNN\nbằng kết hợp hai yếu tốtương đồng (similarity) và tầm quan trọng tinh tếcủa từng thực thể(saliency). **6.2** **Công thức Cốt lõi**\n\n\nweight( _x_ _j_ _,_ _q_ ) = (1 _−_ _α_ ) _×_ similarity( _x_ _j_ _,_ _q_ ) _×_ ICF( _y_ ( _x_ _j_ )) + _α ×_ saliency( _x_ _j_ _,_ _q_ ) (5)\n\n\nTrong đó:\n\n\n_x_ _j_ _·_ _q_\nsimilarity( _x_ _j_ _, q_ ) = cos( _x_ _j_ _, q_ ) = (6)\n_∥x_ _j_ _∥× ∥q∥_\n\n\n\n_N_\nICF( _c_ _i_ ) =\n_M × n_ _i_\n\n\n\n(7)\n\n\n\nsaliency( _x_ _j_ _, q_ ) = _∥∇_ _x_ _j_ _L_ ( _f_ ( _x_ _j_ ) _,_ ˆ _y_ ) _∥_ 2 (8)\n\n_α ∈_ [0 _,_ 1] (tham sốcân bằng) (9)\n\n\n**6.3** **Quyết định Phân loại Cuối cùng**\n\n\n\nˆ\n_y_ = arg max\n_c_ _i_ _∈C_\n\n\n\n�\n\n_x_ _j_ _∈N_ _K_ ( _q_ )\n_y_ ( _x_ _j_ )= _c_ _i_\n\n\n20\n\n\n\nweight( _x_ _j_ _, q_ ) (10)"
+        },
+        {
+          "idx": 56,
+          "page": 24,
+          "score": 0.765610933303833,
+          "text": "**6.4.3** **Trọng sốNội dung dựa trên Saliency**\n\n\n**Định nghĩa 3** (Gradient-based Saliency) **.** _Thành phần saliency nắm bắt_ _**tầm quan trọng cụthể**_\n_**theo đầu vào**_ _dựa trên mô hình explainable AI:_\n\n\n_saliency_ ( _x_ _j_ _, q_ ) = _∥∇_ _x_ _j_ _L_ ( _f_ ( _x_ _j_ ) _,_ ˆ _y_ ) _∥_ 2 (38)\n\n\n**6.4.4** **Kết hợp Lồi và Tham sốCân bằng** _α_\n\n\n**Định lý 6.1** (Tính chất Convex Combination) **.** _Tham số_ _α tạo ra_ _**kết hợp lồi**_ _của hai lược đồtrọng_\n_số:_\n\n_weight_ = (1 _−_ _α_ ) _× w_ _similarity×ICF_ + _α × w_ _saliency_ (39)\n\n_Với α ∈_ [0 _,_ 1] _, kết quảnằm trong convex hull của hai thành phần._\n\n\n**6.5** **Phân tích Lý thuyết: Tại sao Công thức này Hợp lý**\n\n\n**6.5.1** **Phân tích Hiệu chỉnh Bias**\n\n\n**Định lý 6.2** (Bias Correction) **.** _Đối với majority voting truyền thống, ảnh hưởng kỳvọng của lớp c_ _i_ _là:_\n\nE[ _Influence_ _traditional_ ( _c_ _i_ )] = _K × P_ ( _c_ _i_ ) = _K ×_ _N_ _[n]_ _[i]_ (40)\n\n\n_Với phương pháp trọng sốcủa chúng ta:_\n\n\nE[ _Influence..."
         },
         {
-          "idx": 16,
-          "page": 9,
-          "score": 0.5778905749320984,
-          "text": "**AI VIETNAM (AIO2024)** **aivietnam.edu.vn**\n\n\n86 `return` `self.load(files, workers=workers)`\n\n## II.6. Cập nhật file src/rag/vectorstore.py\n\n\nTại file này, ta định nghĩa một class đểkhởi tạo hệcơ sởdữliệu vector. Trong project này, chúng\nta sẽsửdụng Chroma. Vềviệc tìm kiếm tài liệu tương đồng, ta sửdụng FAISS. Như vậy, nội\ndung của file như sau:\n\n\nHình 4: Minh họa việc sửdụng vector database Chroma đểtruy vấn các tài liệu có liên quan\n[làm context trong prompt. Ảnh: Link.](https://heidloff.net/article/retrieval-augmented-generation-chroma-langchain/)\n\n\n1 `from` `typing` `import` `Union`\n\n2 `from` `langchain_chroma` `import` `Chroma`\n\n3 `from` `langchain_community .vectorstores` `import` `FAISS`\n\n4 `from` `langchain_community .embeddings` `import` `HuggingFaceEmbeddings`\n\n\n5\n\n\n6 `class` `VectorDB:`\n\n\n7 `def` `__init__(self,`\n\n\n8 `documents = None,`\n\n9 `vector_db: Union[Chroma, FAISS] = Chroma,`\n\n10 `embedding = HuggingFaceEmbeddings (),`\n\n11 `) -> None` `:`\n\n\n12\n\n\n13 `self.vector_db ..."
+          "idx": 41,
+          "page": 19,
+          "score": 0.808438777923584,
+          "text": "Đối với điểm truy vấn _q_, KNN truyền thống tính toán:\n\n\nˆ\n_y_ = arg max _c_ _i_ _∈C_ _[|{][x]_ _[j]_ _[ ∈N]_ _[K]_ [(] _[q]_ [) :] _[ y]_ [(] _[x]_ _[j]_ [) =] _[ c]_ _[i]_ _[}|]_ (1)\n\n\n**Phân tích Bias:**\nXác suất đểmột K-neighborhood ngẫu nhiên chứa _k_ thực thểtừlớp _c_ _i_ tuân theo phân phối siêu hình\nhọc:\n\n\n19"
         }
       ],
       "model_verdict": {
         "supported": true,
-        "confidence": 1.0,
-        "evidence": "vector_db: Union[Chroma, FAISS] = Chroma",
-        "reason": "Mặc định của tham số vector_db trong class VectorDB được đặt là Chroma"
+        "confidence": 0.99,
+        "evidence": "weight = (1 - α) × w_similarity×ICF + α × w_saliency (39)",
+        "reason": "Công thức trong Định lý 6.1 khớp với đáp án đã cho"
       }
     },
     "4": {
-      "supported_by_embeddings": false,
-      "max_similarity": 0.43995893001556396,
-      "evidence": [],
+      "supported_by_embeddings": true,
+      "max_similarity": 0.5541524291038513,
+      "evidence": [
+        {
+          "idx": 21,
+          "page": 15,
+          "score": 0.5191619992256165,
+          "text": "Trong bài toán spam/ham, BERT được tinh\nchỉnh đểtối ưu hóa dựđoán nhãn và tập trung vào các từkhóa quan trọng như “miễn phí” hoặc “quà\ntặng” trong tin nhắn spam. **Ứng dụng** : Trong phân loại tin nhắn spam/ham, BERT chuyển tin nhắn thành vector số, hiểu ngữ\ncảnh sâu sắc (ví dụ: nhận diện ”miễn phí” trong ngữcảnh quảng cáo), và dựđoán nhãn (spam hoặc\nham). **Ưu điểm** :\n\n\n  - Hiểu ngữcảnh hai chiều, vượt trội so với các phương pháp truyền thống như TF-IDF. - Sửdụng vector [CLS] đểtổng hợp thông tin toàn câu, phù hợp cho phân loại. **5.3** **Kiến trúc BERT**\n\n\nQuy trình xửlý của BERT bao gồm ba giai đoạn chính:\n\n\n1. **Mã hóa đầu vào** : Chuyển tin nhắn thành token, embedding, và attention mask. 2. **Xửlý qua Transformer encoder** : Tạo biểu diễn ngữcảnh cho từng token, đặc biệt là vector\n\n[CLS]. 3. **Phân loại** : Sửdụng vector [CLS] đểdựđoán nhãn spam/ham. Phần này trình bày chi tiết từng thành phần của kiến trúc BERT và cách chúng hỗtrợbài toán phân\nloại tin nhắn spam/ham. **5.3.1** *..."
+        },
+        {
+          "idx": 57,
+          "page": 10,
+          "score": 0.5541524291038513,
+          "text": "**AI VIETNAM** **aivietnam.edu.vn**\n\n\n2. **Thiếu dữliệu vềspam tinh vi (Subtle or Obfuscated Spam)** :\n\n\n    - Phần lớn mẫu spam trong tập train có dạng “truyền thống” — sửdụng từkhóa dễnhận\ndiện như _“FREE!!!”_, _“WIN now”_, _“Click here”_,... - Trong khi đó, spam thực tếngày nay ngày càng được thiết kếtinh vi hơn để **bắt chước văn**\n**phong tựnhiên của người thật**, ví dụ:\n\n\n_“Yo, this app gave me $200 cashback instantly, you should try =«”_\n\n\n    - Do thiếu các ví dụkiểu này trong tập huấn luyện, mô hình không có cơ hội học được “ngữ\nnghĩa tiềm ẩn” của chúng, từđó dễbịđánh lừa. **2.2** **Giải pháp: Data Augmentation**\n\n\n**Mục tiêu**\n\n\nTăng độđa dạng của spam, đặc biệt là spam có dạng giống ham, nhằm:\n\n\n - Cân bằng dữliệu một cách hiệu quả\n\n\n - Tăng khảnăng mô hình phát hiện spam ngụy trang và những câu ham dễnhầm thành spam\n\n\n**Mô tảthay đổi của dataset trước và sau Augmentation**\n\n\nDataset gốc là _SMS Spam Collection Dataset_ từKaggle, có tổng cộng 5.572 tin nhắn, trong đó có 4.82..."
+        }
+      ],
       "model_verdict": {
-        "supported": false,
-        "confidence": 0.95,
-        "evidence": "",
-        "reason": "Trong nội dung Context không có bất kỳ đoạn nào đề cập đến BitsAndBytesConfig hay tham số kiểu lượng tử, vì vậy không thể chứng thực đáp án nf4."
+        "supported": true,
+        "confidence": 0.99,
+        "evidence": "Không hiểu ngữcảnh: Không thể phân biệt được ý nghĩa của một từ trong các ngữcảnh khác nhau.",
+        "reason": "Context explicitly lists 'Không hiểu ngữcảnh' as a disadvantage of keyword-based spam detection."
       }
     },
     "5": {
       "supported_by_embeddings": true,
-      "max_similarity": 0.6268875598907471,
+      "max_similarity": 1.0499497652053833,
       "evidence": [
         {
-          "idx": 1,
-          "page": 2,
-          "score": 0.6268875598907471,
-          "text": "**AI VIETNAM (AIO2024)** **aivietnam.edu.vn**\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nHình 2: Tổng quan vềpipeline của project.\n\n\n**Theo đó:**\n\n\n1. Từdanh sách các bài báo khoa học, ta tách thành các văn bản nhỏ. Từđó, xây dựng một\nhệcơ sởdữliệu vector với một embedding model.\n\n\n2. Bên cạnh câu hỏi đầu vào (question), ta truy vấn các mẫu văn bản có liên quan đến đến\ncâu hỏi, dùng làm ngữcảnh (context) trong câu prompt. Đây là nguồn thông tin mà LLMs\ncó thểdựa vào đểtrảlời câu hỏi.\n\n\n3. Đưa câu prompt vào mô hình (question và context) đểnhận câu trảlời từmô hình.\n\n\n2"
+          "idx": 53,
+          "page": 17,
+          "score": 0.7536194324493408,
+          "text": "**AI VIETNAM** **aivietnam.edu.vn**\n\n\n**Cấu trúc** BERT-base có **12 lớp encoder**, mỗi lớp bao gồm:\n\n\n1. **Multi-Head Self-Attention** : Cho phép mỗi token “chú ý” đến các token khác trong chuỗi để\ncập nhật vector của nó. Công thức:\n\n\n\n_QK_ _T_\nAttention( _Q, K, V_ ) = softmax\n� ~~_√_~~ _d_ _k_\n\n\n\n_V_\n�\n\n\n\n\n  - _Q_, _K_, _V_ : Ma trận query, key, value, được tạo từma trận embedding qua các trọng số _W_ _Q_,\n_W_ _K_, _W_ _V_ . - _d_ _k_ : Kích thước mỗi head (768 / 12 = 64). - Mỗi lớp có **12 head**, mỗi head xửlý một góc nhìn khác của ngữcảnh. Ví dụ: Trong “Nhận ngay quà tặng miễn phí!”, token “miễn” chú ý mạnh đến “quà” và “tặng”,\ntạo ngữcảnh quảng cáo. Attention Mask đảm bảo không chú ý đến [PAD]. Kết quả: Ma trận 16\n_×_ 768, với mỗi token được cập nhật dựa trên ngữcảnh. 2. **Residual Connection và Layer Normalization** : Cộng đầu vào và đầu ra của attention:\n\n\n_x_ + Attention( _x_ )\n\n\nSau đó chuẩn hóa:\nLayerNorm( _x_ + Attention( _x_ ))\n\n\n3. **Feed-Forward Neural Network (FFN)** : ..."
+        },
+        {
+          "idx": 50,
+          "page": 7,
+          "score": 1.0445164442062378,
+          "text": "**AI VIETNAM** **aivietnam.edu.vn**\n\n\n**Explainable AI (XAI) và Classifier:**\n\n\n **Vấn đềtồn đọng:** Mô hình hoạt động như một ”hộp đen”, khó giải thích lý do đưa ra dựđoán. Khảnăng giải thích thường bịtách rời khỏi quá trình phân loại chính. **Giải pháp:** Tích hợp khảnăng giải thích vào lõi của bộphân loại. **–**\n_Masking-based Saliency:_ Phương pháp này xác định các từkhóa quan trọng nhất trong tin\nnhắn. Nói trực quan thì từnào quan trọng trong quyết định spam hơn sẽđược tô đậm hơn. **–**\n_Phân loại có tích hợp Saliency:_ Bộphân loại sửdụng một tham số‘alpha‘ đểđiều chỉnh mức\nđộảnh hưởng của điểm nổi bật (saliency score) vào công thức phân loại cuối cùng, giúp kết\nquảchính xác hơn và có thểgiải thích được. **Đầu ra cuối cùng:** Đầu ra cho mỗi câu gồm thông tin dựđoán và chỉsốgiải thích cho dựđoán đó,\ngiúp người dùng hiểu rõ quyết định của mô hình. Cấu trúc đầu ra bao gồm:\n\n\n - **Lớp dựđoán:** Tin nhắn được gán nhãn dựđoán cuối cùng ( _SPAM_ hoặc _HAM_ ) dựa trên kết quả\nphân loại. *..."
         },
         {
-          "idx": 30,
-          "page": 17,
-          "score": 0.5708718299865723,
-          "text": "split_documents (pdf_pages)`\n\n\n18\n\n\n19 _`# Embedding`_ _`model`_\n\n20 `embedding_model = HuggingFaceEmbeddings ()`\n\n\n21\n\n\n22 _`# vector`_ _`store`_\n\n\n23 `chroma_db = Chroma.from_documents(docs, embedding= embedding_model )`\n\n\nNhiệm vụcủa `embedding_model` là gì? ( _a_ ) Dùng biến đổi chuỗi đầu vào thành các vector cho cơ sởdữliệu vector. ( _b_ ) Dùng đểlập chỉmục cho cơ sởdữliệu. ( _c_ ) Dùng đểtìm kiếm tài liệu. ( _d_ ) Dùng đểtính toán độtương đồng. 17"
+          "idx": 42,
+          "page": 18,
+          "score": 1.0499497652053833,
+          "text": "**AI VIETNAM** **aivietnam.edu.vn**\n\n\n**Kết quả** Sau 12 lớp encoder, mỗi token có vector 768 chiều, chứa thông tin ngữcảnh sâu sắc. Vector\n\n[CLS] (hàng đầu tiên của ma trận đầu ra) tổng hợp ngữcảnh toàn tin nhắn, ví dụ: `[0.7, -0.1, ...,`\n`0.5]`, phản ánh đặc trưng spam như “miễn phí”, “quà”. **Liên hệvới spam/ham** Attention giúp BERT nhận diện mối quan hệgiữa các từ(như “miễn phí”\nvà “quà” gợi ý spam). FFN tinh chỉnh vector đểnhấn mạnh đặc trưng riêng của mỗi token, hỗtrợ\nvector [CLS] mang thông tin quảng cáo hoặc giao tiếp tựnhiên. **5.3.3** **Lớp Phân Loại**\n\n\n**Mục tiêu** Sửdụng vector [CLS] đểdựđoán nhãn spam (1) hoặc ham (0) cho tin nhắn. **Quy trình**\n\n\n1. **Lớp tuyến tính** : Vector [CLS] (768 chiều) được đưa qua lớp tuyến tính:\n\n\nlogits = _W_ cls _·_ vector [CLS] + _b_ cls\n\n\n  - _W_ cls : Ma trận 768 _×_ 2 (2 nhãn: spam, ham). - _b_ cls : Bias 2 chiều. Ví dụ: Vector [CLS] `[0.7, -0.1, ..., 0.5]` _→_ Logits `[2.8, -0.7]` . 2. **Softmax** : Chuyển logits thành xác suất:\n\n\nexp(..."
         }
       ],
       "model_verdict": {
         "supported": true,
         "confidence": 0.99,
-        "evidence": "1. Từ danh sách các bài báo khoa học, ta tách thành các văn bản nhỏ. Từ đó, xây dựng một hẹcơ sở dữ liệu vector với một embedding model.",
-        "reason": "Context explicitly states that after splitting documents, a vector database is built using an embedding model, matching the chosen answer."
+        "evidence": "BERT-base có 12 lớp encoder ... Mỗi lớp có 12 head ... mỗi token có vector 768 chiều",
+        "reason": "Context xác nhận BERT-base có 12 lớp encoder, hidden size 768 và 12 attention head, nên đáp án a được chứng thực."
       }
     }
   }

test/oop_mcq_output.json

@@ -0,0 +1,188 @@
+{
+  "mcqs": {
+    "1": {
+      "câu hỏi": "Trong ví dụ minh họa lớp Cat, khi gọi cat.describe(2), dòng lệnh `print(self.age)` sẽ in ra giá trị nào?",
+      "lựa chọn": {
+        "a": "2 (giá trị truyền vào hàm, là biến cục bộ)",
+        "b": "1 (giá trị của biến lớp)",
+        "c": "Lỗi vì self.age không được định nghĩa",
+        "d": "0 (giá trị mặc định của biến toàn cục)"
+      },
+      "đáp án": "1 (giá trị của biến lớp)"
+    },
+    "2": {
+      "câu hỏi": "Theo nội dung trên, biến nào được mô tả là “thông tin tuyệt mật – chỉ lớp khai báo nó mới có quyền truy cập”?",
+      "lựa chọn": {
+        "a": "private",
+        "b": "protected",
+        "c": "public",
+        "d": "static"
+      },
+      "đáp án": "private"
+    },
+    "3": {
+      "câu hỏi": "Biến cục bộ (local variable) trong lập trình hướng đối tượng có đặc điểm nào sau đây?",
+      "lựa chọn": {
+        "a": "Có thể truy cập ở bất kỳ đâu trong chương trình",
+        "b": "Chỉ tồn tại và có thể sử dụng trong một hàm hoặc phương thức cụ thể",
+        "c": "Là biến toàn cục được khai báo bên ngoài hàm",
+        "d": "Biến được tự động khởi tạo giá trị mặc định"
+      },
+      "đáp án": "Chỉ tồn tại và có thể sử dụng trong một hàm hoặc phương thức cụ thể"
+    },
+    "4": {
+      "câu hỏi": "Trong lập trình hướng đối tượng, thuộc tính (attributes) của một đối tượng là gì?",
+      "lựa chọn": {
+        "a": "Các hàm thực hiện hành động của đối tượng",
+        "b": "Các biến lưu trữ dữ liệu mô tả đối tượng",
+        "c": "Các lớp mà đối tượng kế thừa từ chúng",
+        "d": "Các phương thức tĩnh không phụ thuộc vào đối tượng"
+      },
+      "đáp án": "Các biến lưu trữ dữ liệu mô tả đối tượng"
+    },
+    "5": {
+      "câu hỏi": "Trong Python, phương thức đặc biệt nào cho phép một đối tượng được gọi như một hàm?",
+      "lựa chọn": {
+        "a": "__init__",
+        "b": "__str__",
+        "c": "__call__",
+        "d": "__len__"
+      },
+      "đáp án": "__call__"
+    }
+  },
+  "validation": {
+    "1": {
+      "supported_by_embeddings": true,
+      "max_similarity": 1.0644214153289795,
+      "evidence": [
+        {
+          "idx": 1,
+          "page": 1,
+          "score": 0.6182047724723816,
+          "text": "**Biến cục bộ(Local)**\n\n\nBiến cục bộchỉtồn tại và có thểsửdụng trong một hàm hoặc phương thức cụthể. **Quy tắc ưu tiên (Scope resolution):**\n\n\nLocal _>_ Instance _>_ Class _>_ Global (1)\n\n\n**Ví dụminh họa:**\n\n\n1 `class Cat():`\n\n\n2 `age = 1 #Class variabe`\n\n3 `def describe(self, age):`\n\n4 `print(age, age)` `# Ouput: 2,2 (both are local variables)`\n\n5 `print(self.age)` `# Output: 1 (class variable)`\n\n\n6\n\n\n7 `cat = Cat()`\n\n\n8 `cat.describe(2)`\n\n\n1"
+        },
+        {
+          "idx": 2,
+          "page": 2,
+          "score": 0.9349313378334045,
+          "text": "**AI VIETNAM** **aivietnam.edu.vn**\n\n\nCảhai biến age ởlần in đầu tiên đều là biến cục bộvì Python sẽưu tiên tìm biến cục bộtrước,\nởđây là đối số2 truyền vào age. Vì ta không định nghĩa self.age, nên khi gọi, Python sẽtìm đến\nthứtựtiếp theo là biến Class. Chính vì vậy, ta sẽin ra được kết quảage = 1\n\n\n**1.1.2** **Biến toàn cục (Global)**\n\n\nBiến toàn cục được khai báo bên ngoài hàm hoặc class, sửdụng được trên toàn chương trình\nnhưng nên hạn chếđểtránh gây khó kiểm soát. **Không khuyến khích:**\n\n\n1 `counter = 0` `# Global variable`\n\n\n2\n\n\n3 `class MyClass:`\n\n4 `def increment(self):`\n\n\n5 `global counter`\n\n\n6 `counter += 1`\n\n\n**Khuyến khích:**\n\n\n1 `class MyClass:`\n\n\n2 `counter = 0` `# Class attribute`\n\n\n3\n\n\n4 `def increment(self):`\n\n\n5 `MyClass.counter += 1`\n\n### **2 Động lực cho sựra đời của OOP**\n\n\nTrong thực tế, chúng ta luôn tìm cách mô hình hóa các thực thểthực tếthành các đối tượng số\nhóa. Từnhu cầu quản lý và tổchức các thực thểnày, lập trình hướng đối tượng ra đời đểđơn\ngiản hóa và ..."
+        },
+        {
+          "idx": 8,
+          "page": 5,
+          "score": 1.0644214153289795,
+          "text": "es a function →Output: Hi Alice`\n\n\n2. **Stateful function** : Hàm có thểghi nhớtrạng thái bên trong. 1 `class Counter:`\n\n\n2 `def __init__(self):`\n\n\n3 `self.count = 0`\n\n\n4\n\n\n5 `def __call__(self):`\n\n\n6 `self.count += 1`\n\n\n7 `return self.count`\n\n\n8\n\n\n9 `counter = Counter()`\n\n\n10\n\n\n11 `print(counter())` `# 1`\n\n12 `print(counter())` `# 2`\n\n13 `print(counter())` `# 3`\n\n\nMỗi lần gọi `counter()` đều ghi nhớtrạng thái trước đó và cộng dồn lên, không giống như\ncác phương thức thông thường vốn không lưu trạng thái giữa các lần gọi. 3. **Decorator hoặc Callback handler** : (nâng cao cần tìm hiểu thêm). ## **Phần II: Các tính chất cơ bản trong Object-** **Oriented Programming**\n\n### **5** **Delegation (Ủy quyền)**\n\n\nDelegation (ủy quyền) trong lập trình hướng đối tượng là một kỹthuật trong đó một đối tượng\nủy thác trách nhiệm thực hiện một hành vi cụthểcho một đối tượng khác. Thay vì kếthừa trực\n\n\n5"
+        }
+      ],
+      "model_verdict": {
+        "supported": true,
+        "confidence": 0.99,
+        "evidence": "print(self.age) # Output: 1 (class variable)",
+        "reason": "Context explicitly states that print(self.age) outputs 1, the class variable."
+      }
+    },
+    "2": {
+      "supported_by_embeddings": true,
+      "max_similarity": 1.3231226205825806,
+      "evidence": [
+        {
+          "idx": 15,
+          "page": 8,
+          "score": 1.0267785787582397,
+          "text": "p con của nó đều phải **bắt buộc** có phương thức tính diện\ntích. Nếu không, chương trình sẽbáo lỗi. ### **8 Encapsulation (Đóng gói)**\n\n\nTính đóng gói giúp thông tin nội bộcủa đối tượng và chỉcho phép truy cập qua phương thức\ncông khai (public methods). Điều này giúp bảo vệdữliệu và kiểm soát cách dữliệu bịthay đổi. **Ví dụminh họa:**\n\n\n1 `class BankAccount:`\n\n\n2 `def __init__(self, owner, balance):`\n\n\n3 `self.owner = owner`\n\n\n4 `self.__balance = balance` `# \"__\" indicates this is a private attribute`\n\n\n5\n\n\n6 `def deposit(self, amount):`\n\n\n7 `if amount > 0:`\n\n\n8 `self.__balance += amount`\n\n9 `print(f\"Deposited: {amount}\")`\n\n\n10 `else:`\n\n\n11 `print(\"Invalid deposit amount.\")`\n\n\n12\n\n\n13 `def withdraw(self, amount):`\n\n\n14 `if 0 < amount <= self.__balance:`\n\n\n15 `self.__balance -= amount`\n\n\n8"
+        },
+        {
+          "idx": 4,
+          "page": 3,
+          "score": 1.3231226205825806,
+          "text": "**AI VIETNAM** **aivietnam.edu.vn**\n\n\nTương tự:\nGiảsửbạn là một người quản lý thư viện. Trong đó, sách và người đọc chính là những đối tượng\n(objects), còn các quy trình như mượn sách, trảsách, đăng ký thẻđược xem là phương thức\n(methods) – tức là hành vi của các đối tượng. Đểcó thểquản lý hiệu quảtất cảcác đối tượng\nvà hành vi trong hệthống thư viện này, ta cần một cách tổchức logic và linh hoạt. Chính từ\nnhu cầu đó, lập trình hướng đối tượng (OOP) ra đời – như một phương pháp giúp mô hình hóa\nthếgiới thực thành các thành phần trong phần mềm một cách rõ ràng và dễmởrộng.\n\n### **3 Class và Object**\n\n#### **3.1 Class (Lớp)**\n\n\nClass như một bản vẽkỹthuật hoặc template, dùng đểđịnh nghĩa thuộc tính (attributes) và\nphương thức (methods) của các đối tượng.\n\n - **Attributes:** định nghĩa các thông tin, đặc điểm cũng như các thuộc tính của Object.\n\n\n - **Method** : định nghĩa các hành vi, phương thức cũng như các hành động thường có của\nObject\n\n\n3"
+        }
+      ],
+      "model_verdict": {
+        "supported": true,
+        "confidence": 0.99,
+        "evidence": "\"Biến `private` là thông tin tuyệt mật – chỉ lớp khai báo nó mới có quyền truy cập\"",
+        "reason": "Context explicitly mô tả biến private như vậy, nên đáp án private được chứng thực."
+      }
+    },
+    "3": {
+      "supported_by_embeddings": true,
+      "max_similarity": 1.127091884613037,
+      "evidence": [
+        {
+          "idx": 1,
+          "page": 1,
+          "score": 0.8878949880599976,
+          "text": "**Biến cục bộ(Local)**\n\n\nBiến cục bộchỉtồn tại và có thểsửdụng trong một hàm hoặc phương thức cụthể. **Quy tắc ưu tiên (Scope resolution):**\n\n\nLocal _>_ Instance _>_ Class _>_ Global (1)\n\n\n**Ví dụminh họa:**\n\n\n1 `class Cat():`\n\n\n2 `age = 1 #Class variabe`\n\n3 `def describe(self, age):`\n\n4 `print(age, age)` `# Ouput: 2,2 (both are local variables)`\n\n5 `print(self.age)` `# Output: 1 (class variable)`\n\n\n6\n\n\n7 `cat = Cat()`\n\n\n8 `cat.describe(2)`\n\n\n1"
+        },
+        {
+          "idx": 0,
+          "page": 1,
+          "score": 1.107263207435608,
+          "text": "# Tuần 3: Tổng hợp kiến thức buổi học số3 + 4\n\n#### Time-Series Team Ngày 21 tháng 6 năm 2025\n\n\n\n\n## **Phần I: Khái niệm cơ bản vềObject-Oriented** **Programming: Lập tr��nh hướng đối tượng**\n\n### **1** **Giới thiệu vềlập trình hướng đối tượng**\n\nLập trình hướng đối tượng (OOP) là một phương pháp lập trình phổbiến, lấy các đối tượng làm\ntrung tâm đểgiải quyết vấn đềthực tế. Đểhiểu rõ OOP, ta cần nắm các khái niệm cơ bản như\nphạm vi biến, trừu tượng hóa, lớp, đối tượng và các tính chất đặc trưng như kếthừa, đa hình,\nđóng gói và trừu tượng. #### **1.1** **Bước đầu cho OOP - Khái niệm biến local và global (biến cục bộ** **và biến toàn cục)**\n\n\nPhạm vi (scope) biến là yếu tốquan trọng trong lập trình, quyết định nơi một biến có thểtruy\ncập được. **1.1.1** **Biến cục bộ(Local)**\n\n\nBiến cục bộchỉtồn tại và có thểsửdụng trong một hàm hoặc phương thức cụthể."
+        },
+        {
+          "idx": 9,
+          "page": 6,
+          "score": 1.127091884613037,
+          "text": "**AI VIETNAM** **aivietnam.edu.vn**\n\n\ntiếp hoặc xửlý toàn bộlogic nội bộ, đối tượng sẽgọi đến phương thức của một thành phần bên\ntrong đểthực hiện nhiệm vụ. Kỹthuật này giúp tách biệt trách nhiệm giữa các lớp, dễbảo trì\nvà mởrộng hệthống và tăng tính tái sửdụng của mã nguồn."
+        }
+      ],
+      "model_verdict": {
+        "supported": true,
+        "confidence": 0.99,
+        "evidence": "Biến cục bộ chỉ tồn tại và có thể sử dụng trong một hàm hoặc phương thức cụ thể.",
+        "reason": "Câu trả lời khớp với mô tả trong Context về đặc điểm của biến cục bộ."
+      }
+    },
+    "4": {
+      "supported_by_embeddings": true,
+      "max_similarity": 1.02956223487854,
+      "evidence": [
+        {
+          "idx": 5,
+          "page": 4,
+          "score": 0.7977743148803711,
+          "text": "**AI VIETNAM** **aivietnam.edu.vn**\n\n#### **3.2** **Object (Đối tượng)**\n\n\nObject là một thực thểcụthểđược tạo ra từclass, chứa các giá trịthuộc tính cụthểvà khả\nnăng thực hiện các phương thức đã định nghĩa. ### **4 Cách tạo một Class**\n\n\nMột class diagram bao gồm: tên class, attributes, và methods. Sau khi khởi tạo, ta tạo ra một\nobject là instance của class vừa tạo. **Constructor (** **`__init__`** **):** được dùng đểtạo và gán giá trịban đầu cho các thuộc tính (attributes)\ncủa đối tượng.Nói một cách đơn giản, constructor giống như bản thiết kếban đầu giúp ta xác\nđịnh: ”Khi tạo ra một đối tượng mới, nó sẽcó những thông tin gì?”\n\n\n**Self keyword:** Là tham chiếu đến instance cụthểcủa class. **Ví dụ:**\n\n\n1 `class Rectangle:`\n\n2 `def __init__(self, width, height):`\n\n\n3 `self.width = width`\n\n\n4 `self.height = height`\n\n\n5\n\n\n6 `def area(self):`\n\n\n7 `return self.width * self.height`\n\n\n8\n\n\n9 `my_rec = Rectangle(4, 7)`\n\n10 `print(my_rec.area())` `# Output: 28`\n\n\nTa hình dung “self” là một vùn..."
+        },
+        {
+          "idx": 0,
+          "page": 1,
+          "score": 1.02956223487854,
+          "text": "# Tuần 3: Tổng hợp kiến thức buổi học số3 + 4\n\n#### Time-Series Team Ngày 21 tháng 6 năm 2025\n\n\n\n\n## **Phần I: Khái niệm cơ bản vềObject-Oriented** **Programming: Lập trình hướng đối tượng**\n\n### **1** **Giới thiệu vềlập trình hướng đối tượng**\n\nLập trình hướng đối tượng (OOP) là một phương pháp lập trình phổbiến, lấy các đối tượng làm\ntrung tâm đểgiải quyết vấn đềthực tế. Đểhiểu rõ OOP, ta cần nắm các khái niệm cơ bản như\nphạm vi biến, trừu tượng hóa, lớp, đối tượng và các tính chất đặc trưng như kếthừa, đa hình,\nđóng gói và trừu tượng. #### **1.1** **Bước đầu cho OOP - Khái niệm biến local và global (biến cục bộ** **và biến toàn cục)**\n\n\nPhạm vi (scope) biến là yếu tốquan trọng trong lập trình, quyết định nơi một biến có thểtruy\ncập được. **1.1.1** **Biến cục bộ(Local)**\n\n\nBiến cục bộchỉtồn tại và có thểsửdụng trong một hàm hoặc phương thức cụthể."
+        }
+      ],
+      "model_verdict": {
+        "supported": true,
+        "confidence": 0.98,
+        "evidence": "Những thông tin như ngày sinh, giới tính, sốđiện thoại... được xem là thuộc tính (attributes) của người dùng đó.",
+        "reason": "Context mô tả thuộc tính là các thông tin dữ liệu mô tả đối tượng, khớp với đáp án."
+      }
+    },
+    "5": {
+      "supported_by_embeddings": true,
+      "max_similarity": 1.0307352542877197,
+      "evidence": [
+        {
+          "idx": 5,
+          "page": 4,
+          "score": 0.9137221574783325,
+          "text": "**AI VIETNAM** **aivietnam.edu.vn**\n\n#### **3.2** **Object (Đối tượng)**\n\n\nObject là một thực thểcụthểđược tạo ra từclass, chứa các giá trịthuộc tính cụthểvà khả\nnăng thực hiện các phương thức đã định nghĩa. ### **4 Cách tạo một Class**\n\n\nMột class diagram bao gồm: tên class, attributes, và methods. Sau khi khởi tạo, ta tạo ra một\nobject là instance của class vừa tạo. **Constructor (** **`__init__`** **):** được dùng đểtạo và gán giá trịban đầu cho các thuộc tính (attributes)\ncủa đối tượng.Nói một cách đơn giản, constructor giống như bản thiết kếban đầu giúp ta xác\nđịnh: ”Khi tạo ra một đối tượng mới, nó sẽcó những thông tin gì?”\n\n\n**Self keyword:** Là tham chiếu đến instance cụthểcủa class. **Ví dụ:**\n\n\n1 `class Rectangle:`\n\n2 `def __init__(self, width, height):`\n\n\n3 `self.width = width`\n\n\n4 `self.height = height`\n\n\n5\n\n\n6 `def area(self):`\n\n\n7 `return self.width * self.height`\n\n\n8\n\n\n9 `my_rec = Rectangle(4, 7)`\n\n10 `print(my_rec.area())` `# Output: 28`\n\n\nTa hình dung “self” là một vùn..."
+        },
+        {
+          "idx": 3,
+          "page": 2,
+          "score": 1.0307352542877197,
+          "text": "gười dùng chính là một đối tượng (object). Những thông tin như ngày sinh, giới tính, sốđiện thoại... được xem là thuộc tính (attributes)\ncủa người dùng đó. Còn các hành vi như đăng bài, thích (like), chia sẻ(share), bình luận, kết\nbạn... chính là những phương thức (methods) – tức là hành động mà đối tượng đó có thểthực\nhiện. Đây chính là cách mà lập trình hướng đối tượng mô hình hóa và tổchức các thực thểtrong\nthếgiới số. 2"
+        }
+      ],
+      "model_verdict": {
+        "supported": true,
+        "confidence": 0.99,
+        "evidence": "Trong Python, `__call__` là một phương thức đặc biệt ... được sửdụng khi một đối tượng cần hành xử giống như một hàm. Nếu một lớp định nghĩa `__call__`, thì các instance của lớp đó có thể được gọi như một hàm thực sự.",
+        "reason": "Context explicitly states that __call__ is the special method allowing objects to be called like functions."
+      }
+    }
+  }
+}

test/politic_mcq_output.json

@@ -0,0 +1,206 @@
+{
+  "mcqs": {
+    "1": {
+      "câu hỏi": "Theo nội dung, tính chất chính trị của tôn giáo chỉ xuất hiện khi nào?",
+      "lựa chọn": {
+        "a": "Khi xã hội không có giai cấp và không có xung đột lợi ích",
+        "b": "Khi xã hội đã phân chia giai cấp, có sự khác biệt, sự đối kháng về lợi ích",
+        "c": "Khi tôn giáo được nhà nước kiểm soát chặt chẽ",
+        "d": "Khi nền kinh tế phát triển mạnh và không có bất bình xã hội"
+      },
+      "đáp án": "Khi xã hội đã phân chia giai cấp, có sự khác biệt, sự đối kháng về lợi ích"
+    },
+    "2": {
+      "câu hỏi": "Theo nội dung, giai cấp công nhân hiện đại bao gồm những nhóm nào sau đây?",
+      "lựa chọn": {
+        "a": "Là sản phẩm và chủ thể của nền đại công nghiệp.",
+        "b": "Là nguồn nhân lực chủ yếu tham gia phát triển kinh tế thị trường định hướng XHCN.",
+        "c": "Bao gồm giai cấp nông dân và thợ thủ công.",
+        "d": "Được đại diện bởi Đảng Cộng sản."
+      },
+      "đáp án": "Bao gồm giai cấp nông dân và thợ thủ công."
+    },
+    "3": {
+      "câu hỏi": "Theo nội dung trên, yếu tố nào được nêu là một trong những điều kiện kinh tế để chủ nghĩa xã hội ra đời?",
+      "lựa chọn": {
+        "a": "Sự phát triển của công nghiệp cơ khí",
+        "b": "Sự giảm chênh lệch giàu nghèo",
+        "c": "Sự tồn tại của nền kinh tế kế hoạch",
+        "d": "Sự tăng trưởng của nông nghiệp truyền thống"
+      },
+      "đáp án": "Sự phát triển của công nghiệp cơ khí"
+    },
+    "4": {
+      "câu hỏi": "Theo nội dung trên, trong các đặc trưng bản chất của chủ nghĩa xã hội do Mác nêu, đặc điểm nào sau đây không được liệt kê?",
+      "lựa chọn": {
+        "a": "Có nền kinh tế phát triển cao",
+        "b": "Có nhà nước kiểu mới mang bản chất GCCN",
+        "c": "Có nền văn hóa phát triển cao",
+        "d": "Có hệ thống chính trị đa đảng"
+      },
+      "đáp án": "Có hệ thống chính trị đa đảng"
+    },
+    "5": {
+      "câu hỏi": "Theo quan điểm cơ bản của Marx‑Lenin, sứ mệnh lịch sử của Cách mạng xã hội chủ nghĩa (CNXH) là gì?",
+      "lựa chọn": {
+        "a": "Sự phát triển kinh tế nhanh chóng",
+        "b": "Sứ mệnh lịch sử là những nhiệm vụ quan trọng, thiêng liêng buộc phải thực hiện trong một điều kiện, hoàn cảnh lịch sử cụ thể nhất định",
+        "c": "Tăng cường quan hệ quốc tế",
+        "d": "Đảm bảo quyền lợi cá nhân"
+      },
+      "đáp án": "Sứ mệnh lịch sử là những nhiệm vụ quan trọng, thiêng liêng buộc phải thực hiện trong một điều kiện, hoàn cảnh lịch sử cụ thể nhất định"
+    }
+  },
+  "validation": {
+    "1": {
+      "supported_by_embeddings": true,
+      "max_similarity": 0.7614468336105347,
+      "evidence": [
+        {
+          "idx": 45,
+          "page": 23,
+          "score": 0.7614468336105347,
+          "text": "Nguồn gốc nhân thức\nNguồn gốc tâm lí\n\n##### **Tính chất của tôn giáo**\n\n\n  Các điều kiện kinh tế-xã hội là cho các tôn giáo bịphân liệt, chia rẽ\n\n  Các tôn giáo là nơi sinh hoạt văn hóa tinh thần của một cộng đồng\n\n  TÍnh chất chính trịcủa tôn giáo chỉxuất hiện khi xã hội đã phân chia giai cấp,\ncó sựkhác biệt, sựđối kháng vềlợi ích. ##### **Nguyên tắc trong giải quyết vấn đềtôn giáo**\n\n\n  Tôn trọng, đảm bảo quyền tựdo tín ngưỡng và không tín ngưỡng của nhân\n\ndân\n\n  Khắc phục dần những ảnh hưởng tiêu cực của tôn giáo phải gắn liền với quá\ntrình cỉa tạo xã hội cũ, xây dựng xa hội mới."
+        },
+        {
+          "idx": 23,
+          "page": 23,
+          "score": 0.7602448463439941,
+          "text": "Phân biệt hai mặt chính trịvà tư tưởng, tín ngưỡng tôn giáo và lợi dụng tín\nngưỡng tôn giáo\n\n  Quan điểm lịch sửcụthểtrong giải quyết vấn đềtín ngưỡng, tôn giáo\n\n##### **Tác động của tôn giáo**\n\n\n  Khuyến khích đoàn kết, khoan dung giữa các tôn giáo, phát huy các giá trịtốt\nđẹp của tôn giáo\n\n  Có vai trò xây dựng đối với xã hội và đóng góp những giá trịtốt đẹp\n\n  Kênh quan trọng đểthúc đẩy mởrộng đối ngoại\n\n  Phòng chống xung đột, kiến tạo hòa bình, quản trịxã hội\nTác hại tiêu cực của tôn giáo: phương hại đến chính sách tựdo tìn ngưỡng, nhân\nthức thái quá và sai lệch vềĐảng và nhà nước, thu tiền trái phép\n\n##### **Chính sách của Đảng và nhà nước**\n\n\n  - Là nhu cầu tinh thần\n\n  Tôn trọng quyền tựdo, tín ngưỡng, thực hiện chính sách đại đoàn kết là chính\nsách nhất quán, xuyên suốt của Đảng\n\n##### **Phương hướng hoạt động trong thời gian tới**\n\n\n  Một, thực hiện hiệu quảchủtrương, chính sách đầu tư phát triển\n\n  Nâng cao thống nhất quan điểm chỉđạo\n\n  Tăng cường công tác kiểm tra\n\n  Tiếp ..."
+        },
+        {
+          "idx": 30,
+          "page": 24,
+          "score": 0.6624355316162109,
+          "text": "Khi tôn giáo xây dựng thành công CNXH thì còn tôn giáo không? Vẫn có vấn đềkhông giái thích được\n\n  Vẫn có người tin thì vẫn còn tồn tại\n\n  Là một phần trong nhu cầu cơ bản thiết yếu của con người\n\n  Điều kiện tồn tại của tôn giáo còn trên khách quan như cơ chếthịtrường\n(muốn xóa bỏtôn gióa phải xóa bỏdc…)\n\n##### **Sựkhác nhau tín ngưỡng và tôn giáo**\n\n\nTôn giáo phải có hệthống, cơ sởthờtự, tín đồ\nTôn giáo mới là sựpha trộn của ác tôn giáo truyền thống, khi có sựchuyển biến kt, xã\nhội có sựvận động của đời sống sẽxuất hiện nhiều tôn giáo. Hiện tượng chuyển đổi tôn giáo\n\n\n**Cô ôn tập**\nChủnghĩa dân tộc và chủnghĩa dân tộc cực đoan, chủnghĩa ly khai dân tộc\n\n  Chủnghĩa dân tộc cực đoan và chủnghĩa ly khai dân tộc là trào lưu gây ra sự\nchia rẽvà kì thịdân tộc, khoét sâu và cốtình khơi dậy sựbất hòa, kịch động\nlòng thù hận giữa các dân tộc, thổi phồng sựtựcao tựđại vềdân tộc mình\n\n  Hậu quảnghiêm trọng là xung đột, nội chiến thểhiện dưới nhiều hình thức\nchiến tranh lớn, vừa và nhỏ, chiến t..."
+        }
+      ],
+      "model_verdict": {
+        "supported": true,
+        "confidence": 0.99,
+        "evidence": "TÍnh chất chính trịcủa tôn giáo chỉ xuất hiện khi xã hội đã phân chia giai cấp, có sự khác biệt, sự đối kháng về lợi ích.",
+        "reason": "Câu trả lời trùng khớp với nội dung trong Context."
+      }
+    },
+    "2": {
+      "supported_by_embeddings": true,
+      "max_similarity": 0.7629456520080566,
+      "evidence": [
+        {
+          "idx": 34,
+          "page": 20,
+          "score": 0.7629456520080566,
+          "text": "Giai cấp thì có giai cấp công nhân và nông dân\nTầng lớp có tri thức, doanh nhân, thương,\nCơ cấu xã hội thời kì quá độ\n+Công nhân: vai trò nòng cốt trong liên minh, lực lượng đi đầu trong sựnghiệp\n\nCNH-HDH. +Nông dân: cơ sở, lực lương quan trọng phát triển kt-xã hội, giữvững ổn định chính\ntrị\n-Kinh tếcơ bản quy định nhất: xác định đúng cơ cấu\nQuan điểm nhất quán: phát triển nền kinh tếthành phần\n-Chính trị: giữvững lập trường chính trị- tư tưởng của giai cấp công nhân, vai trò\nlãnh đạo của Đảng cộng sản, xây dựng Đảng vững mạnh, xây dựng nhà nước pháp\nquyền vềXHCN của dân, do dân, vì dân\n-Văn hóa, xã hội: gắn tăng trưởng kinh tếvới phát triển văn hóa, phát triển, xây dựng\ncon người và thực hiện tiến bộ. Biến văn hóa trởthành tài sản của xã hội. Văn hóa, xã\nhội của liên minh giai cấp tầng lớp còn được thểhiện qua nâng cao chất lượng\nnguồn nhân lực, dân trí, xóa đói giảm nghèo, thực hiện an sinh xã hội\n\n\nPhương hướng tăng cường\n1. Đẩy mạnh quá trình CNH, HDH, giải quyết tốt mối quan hệgiữ..."
+        },
+        {
+          "idx": 1,
+          "page": 10,
+          "score": 0.5911743640899658,
+          "text": "##### **3.2. THỰC TRẠNG GCCN VIỆT NAM VÀ VẤN ĐỀĐẶT RA HIỆN NAY**\n\nNội dung SMLS hiện nay\nVỀNỘI DUNG KINH TẾ\n\n  - Giai cấp công nhân là nguồn nhân lực chủyếu tham gia phát triển kinh tếthị\ntrường định hướng XHCN;\n\n  - Lực lượng đi đầu trong sựnghiệp đẩy mạnh công nghiệp hóa, hiện đại hóa\n\nđất nước\n\n  - Làm cho nước ta trởthành một nước công nghiệp theo hướng hiện đại, định\nhướng XHCN\nVỀNỘI DUNG CHÍNH TRỊ- XÃ HỘI\n\n  - Giữvững và tăng cường sựlãnh đạo của Đảng,\n\n  - Giữvững bản chất giai cấp công nhân của Đảng, giai cấp công nhân cùng với\nnhân dân lao động dưới sựlãnh đạo của Đảng cộng sản củng cốvà hoàn\nthiện hệthống chính trịXHCN\n\n  - Xây dựng nhà nước của dân, do dân, vì dân, xây dựng nền dân chủXHCN, bảo\nvệchếđộxã hội chủnghĩa. VỀNỘI DUNG TƯ TƯỞNG – VĂN HÓA\n\n  - Xây dựng và phát triển nền văn hóa Việt Nam tiên tiến, đậm đà bản sắc dân\ntộc, nội dung cốt lõi là xây dựng con người mới XHCN. - Bảo vệsựtrong sáng của chủnghĩa Mác – Lê nin và tư tưởng HồChí Minh,\nchống lại những quan điểm s..."
+        },
+        {
+          "idx": 22,
+          "page": 29,
+          "score": 0.5815836191177368,
+          "text": "Công nhân, nông dân, trí thức, thanh niên, doanh nhiên, phụnữ\n\n  Phân tích dc vịtrí, vai trò từng giai cấp, tầng ớp\n\n  Một câu tổng kết với từng vịtrí, vai trò, vì sao phải thực hiện liên minh các giai\ncấp\n\n\n5. **CHƯƠNG 6: VẤN ĐỀDÂN TỘC VÀ TÔN GIÁO**\n\n**TÔN GIÁO** : NẮM nguyên tắc giải quyết vấn đềTG trong thời kì quá độ, đặc điểm tôn\ngiáo ởVN, các chính sách của nhà nước và đảng vềtôn giáo\nLiên hệbản thân, ac nhận thức thếnào vềtôn giáo trong thời kì quá độxây dựng\n\nCNXH\n\n\nCHƯƠNG 7: GIA ĐINH\n\nNhững biến đổi của gia đình VN (3 biến đổi) - AC hãy nêu những biến đổi của gia\nđình VN trong thời kì quá độ, ac hãy nêu những phướng hướng, giái pháp đểxây\ndựng. Là sv, ac làm gì đểxây dựng\n\n\nDownloaded by Adoft Putin (dinhnhatthanh248@gmail.com)"
+        }
+      ],
+      "model_verdict": {
+        "supported": false,
+        "confidence": 0.96,
+        "evidence": "Giai cấp thì có giai cấp công nhân và nông dân",
+        "reason": "Ngữ cảnh chỉ liệt kê giai cấp công nhân và nông dân là hai giai cấp riêng biệt, không nói rằng giai cấp công nhân bao gồm nông dân và thợ thủ công"
+      }
+    },
+    "3": {
+      "supported_by_embeddings": true,
+      "max_similarity": 0.5998344421386719,
+      "evidence": [
+        {
+          "idx": 28,
+          "page": 2,
+          "score": 0.5998344421386719,
+          "text": "=> đây là những con đường không tưởng, muốn đạt được phải qua đấu tranh và cách mạng,\nkhông vạch ra đc giai cấp nào là giai cấp mang sứmệnh lịch sử. **3. Chủnghĩa xã hội khoa học:**\nCũng hướng đến những tựdo, bình đẳng, bác ái,... nhưng đã vạch ra được giai cấp\nmang sứmệnh lịch sửlà giai cấp công nhân\n**Nghĩa rộng: Là CN Mác- Lê nin luận giải từcác góc độTH, KTCT và chính trị- xã**\n**hội vềsựchuyển biến tất yếu của XH loài người từCNTB lên CNXH.**\n**Nghĩa hẹp: là một trong ba bộphận hợp thành của CN Mác- Lenin (triết học, kinh**\n**tếCT và chủnghĩa xã hội khoa học).**\n\n\n**4. Chủnghĩa xã hội lí luận**\nBao gồm chủnghĩa xã hội không tưởng và chủnghĩa xã hội khoa hoc. **5. Chủnghĩa xã hội hiện thực**\nVận dụng các chủnghĩa xã hội vào xây dựng thực tiễn (CMT10 Nga - 1917)\n\n\nDownloaded by Adoft Putin (dinhnhatthanh248@gmail.com)"
+        },
+        {
+          "idx": 5,
+          "page": 5,
+          "score": 0.5852417945861816,
+          "text": "Con đường, cách thức và phương thức đấu tranh nhằm giải phóng con người, giải\nphóng xã hội khỏi tư hữu, áp bức, bóc lột, xây dựng một xã hội mới tiến bộ, công\nbằng, bình đẳng\n**2. Là một chếđộxã hội hiện thức, một mô hinh, một kiểu tổchức xã hội theo**\n**những nguyên tắc của CNXH**\n\n\n**3. Là một phong trào thực tiễn**\n\n### **1.2 Những điều kiện ra đời của CNXH khoa học**\n\n\n1.2.1. Điều kiện khách quan\n1.2.2. Điều kiện chủquan (vai trò của Mac Angghen\n\n### **2.2 VI."
+        },
+        {
+          "idx": 31,
+          "page": 3,
+          "score": 0.576014518737793,
+          "text": "Chủnghĩa xã hội vs Xã hội chủnghĩa\nChủnghĩa xã hội là một danh từ\nXã hội chủnghĩa là một tính từ\n\n\nThếlực thù địch\n+ Phủnhận: 1886 -> Đổi mới\n+ Cho rằng kinh tếthịtrường định hướng xã hội chủnghĩa không có thực\n=> Có thành tựu hay không có thành tựu đều bịcông kích\n\n\n**Vì sao nói chủnghĩa Mác Lênin vừa thống nhất vừa độc lập với nhau?**\n➢ Thống nhất vì nó là những luận điểm khoa học,\n➢ là hệtư tưởng của giai cấp công nhân\n➢ Đều hướng đến những giá trịtựdo,... mà con người đang hướng đến\n\n\nTriết học Mác Lenin: nghiên cứu những quy luật chung nhất của tựnhiên, xã hội, tư\nduy của 5 HTKT-XH\nKT-CT học Mác Lenin: nghiên cứu quy luật kinh tếtrong quá trình SXVC của HTKT-XH\nTBCN và quá độlên CNXH\nChủnghĩa xã hội khoa học: nghiên cứu những quy luật chính trị- xã hội của HTKT\ncộng sản chủnghĩa\n\n### **1.1 Quan niệm vềchủnghĩa xã hội**\n\n\nCNTB →Ra đời vào thời kì chiếm hữu nô lệ: khi xã hội bắt đầu phân chia giai cấp\n(tầng lớp quý tộc, địa chủ,.."
+        }
+      ],
+      "model_verdict": {
+        "supported": false,
+        "confidence": 0.9,
+        "evidence": "Không có đề cập đến \"công nghiệp cơ khí\" trong nội dung cung cấp.",
+        "reason": "Context không chứa thông tin nào về sự phát triển của công nghiệp cơ khí là điều kiện kinh tế để chủ nghĩa xã hội ra đời."
+      }
+    },
+    "4": {
+      "supported_by_embeddings": true,
+      "max_similarity": 0.6957789659500122,
+      "evidence": [
+        {
+          "idx": 47,
+          "page": 18,
+          "score": 0.6957789659500122,
+          "text": "Phương diện tổchức và quản lí xã hội\n\n\nQuan điểm của Đảng cộng sản vềdân chủ(nền dân chủxã hội chủnghĩa)\n\n  - QUyền lực thuộc vềnhân dân\n\n  - Dân chủgắn liền với công bằng xã hội\n\n  - Dân chủđi đôi với kỷluật, kỷcương\n\n  - Dân chủtrên mọi lĩnh vực đời sống\n\n  - Dân chủđược thểhiện bằng pháp luật\n\n\nNền dân chủchủnô và dân chủtư sản đều là quyền lực thuộc vềtay một giai cấp\nchứkhông phải tất cảcác giai cấp - không phải nền dân chủcho đa sốtrong xã hội\n(không có nền dân chủcho tất cảchỉcó cho đại đa số)\n\n\nĐặc điểm của nhà nước pháp quyền XHCN ởViệt Nam (6 nội dung phải nhớ)\n\n  - Bản chất kinh tế\n\n  - Bản chất chính trị\n\n  - Bản chất xã hội - văn hóa\n\n\nPhải lí giải: vd nếu không có đảng thì có thểđảm bảo dân chủcho mọi tầng lớp\ntrong xã hội không\nQuan niệm chung vềnhà nước pháp quyền\n\n\nDownloaded by Adoft Putin (dinhnhatthanh248@gmail.com)"
+        },
+        {
+          "idx": 31,
+          "page": 3,
+          "score": 0.6646752953529358,
+          "text": "Chủnghĩa xã hội vs Xã hội chủnghĩa\nChủnghĩa xã hội là một danh từ\nXã hội chủnghĩa là một tính từ\n\n\nThếlực thù địch\n+ Phủnhận: 1886 -> Đổi mới\n+ Cho rằng kinh tếthịtrường định hướng xã hội chủnghĩa không có thực\n=> Có thành tựu hay không có thành tựu đều bịcông kích\n\n\n**Vì sao nói chủnghĩa Mác Lênin vừa thống nhất vừa độc lập với nhau?**\n➢ Thống nhất vì nó là những luận điểm khoa học,\n➢ là hệtư tưởng của giai cấp công nhân\n➢ Đều hướng đến những giá trịtựdo,... mà con người đang hướng đến\n\n\nTriết học Mác Lenin: nghiên cứu những quy luật chung nhất của tựnhiên, xã hội, tư\nduy của 5 HTKT-XH\nKT-CT học Mác Lenin: nghiên cứu quy luật kinh tếtrong quá trình SXVC của HTKT-XH\nTBCN và quá độlên CNXH\nChủnghĩa xã hội khoa học: nghiên cứu những quy luật chính trị- xã hội của HTKT\ncộng sản chủnghĩa\n\n### **1.1 Quan niệm vềchủnghĩa xã hội**\n\n\nCNTB →Ra đời vào thời kì chiếm hữu nô lệ: khi xã hội bắt đầu phân chia giai cấp\n(tầng lớp quý tộc, địa chủ,.."
+        },
+        {
+          "idx": 10,
+          "page": 13,
+          "score": 0.6248639822006226,
+          "text": "- Mâu thuẫn giữa LLSX và QHSX, mâu thuẫn tư sản và vô sản\n\n\nĐiều kiện chính trị\n\n\n  - GCCN phát triển cảvềsốlượng và chất lượng\n\n\n  - GCCN phải giác ngộcách mạng và tốchức ra chính Đảng của mình\n\n\n  - GCCN phải kiên quyết giành chính quyền từtay GCTS khi có thời cơ cách\n\n\nmạng và muốn giành chính quyền phải thông qua cách mạng vô sản\n\n\n=> Áp lực của phong trào đấu tranh GCCN, áp lực từsựra đời icủa CNXH\n\n##### **1.3 Những đặc trưng bản chất của chủnghĩa xã hội theo quan điểm** **của Mác**\n\n\n1. Giai phóng GC, giải phóng DT, giải phóng XH, giải phóng con người (giải\nphóng toàn bộcác tầng lớp bịáp bức bóc lột khác)\n**2. Là chếđộdo NDLĐ làm chủ(mọi chính sách đều phục vụnhân dân)**\n3. Có nền KT phát triển cao\n4. Có nhà nước kiểu mới mang bản chất GCCN (chương 5)\n5. Có nền văn hóa phát triển cao\n6. Đẩm bảo bình đăng, đoàn kết giữa các dân tộc (VN là nc đa dân tộc, đa văn\nhóa nên xây dựng đn sẽkhó khăn hơn), quan hệhợp tác hữu nghị\n\n### **2."
+        }
+      ],
+      "model_verdict": {
+        "supported": true,
+        "confidence": 0.98,
+        "evidence": "1. Giai phóng GC... 2. Là chế độ... 3. Có nền KT phát triển cao 4. Có nhà nước kiểu mới mang bản chất GCCN 5. Có nền văn hóa phát triển cao 6. Đảm bảo bình đẳng, đoàn kết... (không có mục \"có hệ thống chính trị đa đảng\")",
+        "reason": "Trong danh sách 6 đặc trưng của chủ nghĩa xã hội theo Mác, không có mục nào đề cập đến hệ thống chính trị đa đảng, nên đáp án \"Có hệ thống chính trị đa đảng\" là đúng."
+      }
+    },
+    "5": {
+      "supported_by_embeddings": true,
+      "max_similarity": 0.5826756358146667,
+      "evidence": [
+        {
+          "idx": 3,
+          "page": 3,
+          "score": 0.5826756358146667,
+          "text": "nắm giữtài sản, nô lệlà công cụlao động)\nCNXH không tưởng (trước 1848, trước Mác- Ăngghen)\n**a) Tư tưởng xã hội chủnghĩa trước Mác**\n❖ Tư tưởng XHCN thời cổđại: Phương Đông (địa chủ- phong kiến), phương Tây\n(chủnô, tang lữ- nô lệ) => thểhiện bằng các cuộc đấu tranh của quần chúng\nnhân dân lao động đòi lại quyền dân chủtuy nhiên còn rời rạc (VD khởi nghĩa\nSpartacus). ❖ Tư tưởng XHCN thời trung đại: Phương Tây (đêm trường trung cổ, giáo hội có\nquyền lực hơn cảnhà nước). => thểhiện bằng những câu chuyện, văn thở\nphản ánh ước mơ về“thời đại hoàng kim”\n❖ Tư tưởng XHCN thời cận đại (đầu TK16 - đầu TK19): xuất hiện tầng lớp công\nnhân => tư tưởng CNXH bắt đầu được thành lập. Thểkỷ16 - Thomas More với\ntác phẩm Utopia) - thuật ngữ“Cừu ăn thịt người”. Grachus Babeuf - tuyên\nngôn của những người binh dân\n❖ Thếkỉ19: Tư tưởng XHCN thểhiện dạng học thuyết phê phán: 3 đại diện tiêu\nbiểu (Saint Simon, Charles Fourier, Robert Owen): bước sang giai đoạn mới\n\n\nDownloaded by Adoft Putin (dinhnhatthanh248@g..."
+        },
+        {
+          "idx": 40,
+          "page": 5,
+          "score": 0.5630186796188354,
+          "text": "Lenin bảo vệ, vận dụng và phát triển sáng tạo** **CNXHKH**\n\n\n2.2.2 Thời kì sau CM tháng 10 Nga:\nVềchính trị: vấn đềdân chủvà chuyên chính vô sản\nVềkinh tế: vận hành theo thịtrường, kinh tếNep\n\n##### **_Đối diện: Nhận diện cách mạng màu - Việt Nam có phải đối diện_** **_nguy cơ xảy ra cách mạng màu hay không?_**\n\n+ Biểu hiện của cách mạng màu: các cuộc lật độchếđộhiện tại bằng phương\nthức truyền bá, kích động, lôi kéo người dân tham gia vào các cuộc biểu tình\nkhiến cho các hoạt động xã hội bịngưng trệkhiến cho xung đột người dân và\nchính quyền ngày càng lớn\n+ Bắt nguồn từcáo buộc gian lận bầu cử, nạn tham nhũng, mâu thuẫn lợi ích,\nmâu thuẫn sắc tộc, khó khăn kinh tế… => bịkích động trởthành cách mạng\nhoa nhài, cách mạng hoa tulip,... + Hậu quả: đồng tiền mất giá, cuộc sống đình trệ, kinh tếrơi vào khủng hoảng\ntrầm trọng, đất nước trởthành vùng đệm quốc tế, người dân phải tịnạn, gặp\n\nkhó khăn\n\n+ VN có phải đối mặt với cách mạng màu không? Mục tiêu tấn công nhằm xóa\nbỏCNXH -> VN cũng nằm ..."
+        },
+        {
+          "idx": 28,
+          "page": 2,
+          "score": 0.5546197891235352,
+          "text": "=> đây là những con đường không tưởng, muốn đạt được phải qua đấu tranh và cách mạng,\nkhông vạch ra đc giai cấp nào là giai cấp mang sứmệnh lịch sử. **3. Chủnghĩa xã hội khoa học:**\nCũng hướng đến những tựdo, bình đẳng, bác ái,... nhưng đã vạch ra được giai cấp\nmang sứmệnh lịch sửlà giai cấp công nhân\n**Nghĩa rộng: Là CN Mác- Lê nin luận giải từcác góc độTH, KTCT và chính trị- xã**\n**hội vềsựchuyển biến tất yếu của XH loài người từCNTB lên CNXH.**\n**Nghĩa hẹp: là một trong ba bộphận hợp thành của CN Mác- Lenin (triết học, kinh**\n**tếCT và chủnghĩa xã hội khoa học).**\n\n\n**4. Chủnghĩa xã hội lí luận**\nBao gồm chủnghĩa xã hội không tưởng và chủnghĩa xã hội khoa hoc. **5. Chủnghĩa xã hội hiện thực**\nVận dụng các chủnghĩa xã hội vào xây dựng thực tiễn (CMT10 Nga - 1917)\n\n\nDownloaded by Adoft Putin (dinhnhatthanh248@gmail.com)"
+        }
+      ],
+      "model_verdict": {
+        "supported": false,
+        "confidence": 0.85,
+        "evidence": "Context chỉ đề cập đến giai cấp công nhân là giai cấp mang sứ mệnh lịch sử, nhưng không nêu rõ sứ mệnh lịch sử của Cách mạng xã hội chủ nghĩa là \"những nhiệm vụ quan trọng, thiêng liêng...\"",
+        "reason": "Không có bằng chứng trong nội dung cung cấp xác nhận định nghĩa cụ thể của sứ mệnh lịch sử như trong đáp án"
+      }
+    }
+  }
+}

test/raw_resp.json

@@ -0,0 +1,33 @@
+{
+  "id": "chatcmpl-84e4f53d-9bca-4dd8-89d3-7a4a9b69b860",
+  "choices": [
+    {
+      "finish_reason": "stop",
+      "index": 0,
+      "message": {
+        "content": "{\n  \"supported\": true,\n  \"confidence\": 0.99,\n  \"evidence\": \"BERT-base có 12 lớp encoder ... Mỗi lớp có 12 head ... mỗi token có vector 768 chiều\",\n  \"reason\": \"Context xác nhận BERT-base có 12 lớp encoder, hidden size 768 và 12 attention head, nên đáp án a được chứng thực.\"\n}",
+        "reasoning": "We need to determine if the answer (option a) is supported by the context. The context includes: \"Cấu trúc BERT-base có 12 lớp encoder, mỗi lớp bao gồm: ... Mỗi lớp có 12 head, ... d_k: 768/12=64. ...\". Also earlier: \"BERT-base có 12 lớp encoder\". It mentions hidden size 768. So option a: \"BERT có 12 lớp encoder, mỗi lớp có kích thước ẩn là 768 và 12 attention head.\" This matches. So supported true. Provide confidence maybe 0.99. Evidence: \"BERT-base có 12 lớp encoder\" and \"Mỗi lớp có 12 head\" and hidden size 768 mentioned in description of token vector dimension. Provide short citation. Provide reason.",
+        "role": "assistant"
+      }
+    }
+  ],
+  "created": 1755749149,
+  "model": "gpt-oss-120b",
+  "system_fingerprint": "fp_e25f231b468af246abb0",
+  "object": "chat.completion",
+  "usage": {
+    "prompt_tokens": 1714,
+    "completion_tokens": 265,
+    "total_tokens": 1979,
+    "prompt_tokens_details": {
+      "cached_tokens": 0
+    }
+  },
+  "time_info": {
+    "queue_time": 0.000124009,
+    "prompt_time": 0.063482573,
+    "completion_time": 0.18115486,
+    "total_time": 0.2471165657043457,
+    "created": 1755749149
+  }
+}

test/test-api-key.py

@@ -0,0 +1,79 @@
+import os
+from qdrant_client import QdrantClient
+
+qdrant_client = QdrantClient(
+    url=os.environ.get('QDRANT_URL'),
+    api_key=os.environ.get('QDRANT_API_KEY'),
+)
+print(qdrant_client.get_collections())
+
+# qdrant_client.recreate_collection(
+#     collection_name="programming",
+#     vectors_config={
+#         "my_vector_name": models.VectorParams(size=1536, distance=models.Distance.COSINE),
+#     },
+# )
+print()
+print(os.environ.get('HF_API_KEY'))
+print(os.environ.get('TOGETHER_API_KEY'))
+print(os.environ.get('QDRANT_URL'))
+print(os.environ.get('QDRANT_API_KEY'))
+print(os.environ.get('CEREBRAS_API_KEY'))
+# cerebras API: your_key
+
+
+"""
+Debugging FastAPI:
+uvicorn app.py:app --reload
+
+MacOS:
+export TOGETHER_API_KEY="YOUR_API_KEY"
+
+Windows:
+$env:CEREBRAS_API_KEY = "your_key"
+$env:QDRANT_URL = "your_url"
+$env:QDRANT_API_KEY = "your_key"
+"""
+
+
+"""Token Count Test
+INPUT_token_count:10616
+OUTPUT_token_count:4808
+AVG_INPUT_token_count:1061.6
+AVG_OUTPUT_token_count:480.8
+TOTAL_TOKEN_COUNT:[1717 1743 1417 1419 1483 1630 1516 1619 1580 1300]
+TOKEN_COUNT_PER_GENERATION - :[15424.]
+AVG_TOKEN_COUNT_PER_GENERATION:[np.float64(15424.0), 1]
+
+INPUT_token_count:10299.0
+OUTPUT_token_count:5628.0
+AVG_INPUT_token_count:1029.9
+AVG_OUTPUT_token_count:562.8
+TOTAL_TOKEN_COUNT:[1852. 1520. 1615. 1790. 1539. 1562. 1290. 1686. 1460. 1613.]
+TOKEN_COUNT_PER_GENERATION - :[15424. 15927.]
+AVG_TOKEN_COUNT_PER_GENERATION:[np.float64(15675.5), 2]
+
+INPUT_token_count:9640.0
+OUTPUT_token_count:5576.0
+AVG_INPUT_token_count:964.0
+AVG_OUTPUT_token_count:557.6
+TOTAL_TOKEN_COUNT:[1252. 1835. 1490. 1537. 1394. 1620. 1670. 1707. 1458. 1253.]
+TOKEN_COUNT_PER_GENERATION - :[15424. 15927. 15216.]
+AVG_TOKEN_COUNT_PER_GENERATION:[np.float64(15522.333333333334), 3]
+
+INPUT_token_count:9356.0
+OUTPUT_token_count:5277.0
+AVG_INPUT_token_count:935.6
+AVG_OUTPUT_token_count:527.7
+TOTAL_TOKEN_COUNT:[1368. 1295. 1849. 1523. 1468. 1473. 1486. 1426. 1595. 1150.]
+TOKEN_COUNT_PER_GENERATION - :[15424. 15927. 15216. 14633.]
+AVG_TOKEN_COUNT_PER_GENERATION:[np.float64(15300.0), 4]
+
+INPUT_token_count:9828.0
+OUTPUT_token_count:4758.0
+AVG_INPUT_token_count:982.8
+AVG_OUTPUT_token_count:475.8
+TOTAL_TOKEN_COUNT:[1820. 1235. 1911. 1591. 1312. 1242. 1372. 1533. 1393. 1177.]
+TOKEN_COUNT_PER_GENERATION - :[15424. 15927. 15216. 14633. 14586.]
+AVG_TOKEN_COUNT_PER_GENERATION:[np.float64(15157.2), 5]
+"""

test/text_chunks.md

@@ -0,0 +1 @@
+['# **Các thuật toán sắp xếp (p2)** **(sorting algorithms)**\n\n**Nguyễn Mạnh Hiển**\nKhoa Công nghệ thông tin\n[hiennm@tlu.edu.vn](mailto:hiennm@wru.vn)', '## **Các thuật toán sắp xếp - phần 2**\n\n\nSắp xếp vun đống (heap sort)\n\nSắp xếp trộn (merge sort)\n\nSắp xếp nhanh (quick sort)', '## **Sắp xếp vun đống (heap sort)**\n\n\nĐống nhỏ nhất (min-heap)\n\n\n−\nXây dựng đống: O(N)\n\n−\nThực hiện N phép deleteMin để lấy ra phần tử nhỏ\n\nnhất: O(N log N)\n\n−\nĐộ phức tạp tổng thể: O(N log N)\n\n−\nYêu cầu thêm một mảng nữa để lưu trữ các kết quả\n\nĐống lớn nhất (max-heap):\n\n\n−\nLưu trữ các phần tử bị xóa ở cuối vector đống', '### **Ví dụ với đống lớn nhất (max-heap)**\n\nSau buildHeap() Sau deleteMax() đầu tiên', '#### **Cài đặt sắp xếp vun đống**', '## **Sắp xếp trộn (merge sort)**\n\n\nBan đầu có N phần tử chưa sắp xếp\n\nChia N phần tử thành hai nửa\n\nSắp xếp đệ quy mỗi nửa dùng mergeSort\n\n\n−\nTrường hợp cơ sở: N = 1 (không cần sắp xếp)\n\nTrộn (merge) hai nửa (đã được sắp xếp)', '## **Ví dụ về trộn (merge)**\n\n1 15 24 26 2 13 27 38\n\n|1|15|24|26|\n|---|---|---|---|\n|||||\n\n\n|2|13|27|38|\n|---|---|---|---|\n|||||\n\n\n\n1 15 24 26 2 13 27 38 1\n\n|1|15|24|26|\n|---|---|---|---|\n|||||\n\n\n|2|13|27|38|\n|---|---|---|---|\n|||||\n\n\n|1|Col2|Col3|Col4|Col5|Col6|Col7|Col8|\n|---|---|---|---|---|---|---|---|\n|||||||||\n\n\n\n1 15 24 26 2 13 27 38 1 2\n\n|1|15|24|26|\n|---|---|---|---|\n|||||\n\n\n|2|13|27|38|\n|---|---|---|---|\n|||||\n\n\n|1|2|Col3|Col4|Col5|Col6|Col7|Col8|\n|---|---|---|---|---|---|---|---|\n|||||||||\n\n\n\n1 15 24 26 2 13 27 38 1 2 13\n\n\n\n|1|15|24|26|\n|---|---|---|---|\n|||||\n\nCó N bước\n\n\n|2|13|27|38|\n|---|---|---|---|\n|||||\n\n\n|1|2|13|Col4|Col5|Col6|Col7|Col8|\n|---|---|---|---|---|---|---|---|\n|||||||||\n\nMỗi bước có thể có một phép so sánh và có một phần tử được\n\nchèn vào mảng thứ ba \uf0e0 mỗi bước mất thời gian hằng\n\n\uf0e0 Tổng thời gian là O(N)', '### **Ví dụ về sắp xếp trộn (merge sort)**\n\n1 24 26 15 13 2 27 38\n\n\n1 24 26 15 13 2 27 38\n\n\n1 24 26 15 13 2 27 38\n\n\n1 24 26 15 13 2 27 38\n\n\n1 24 15 26 2 13 27 38\n\n\n1 15 24 26 2 13 27 38\n\n\n1 2 13 15 24 26 27 38', '#### **Cài đặt sắp xếp trộn**']

utils.py

@@ -3,19 +3,37 @@ import json
 from typing import Dict, Any
 import requests
 import os
+import numpy as np
+import uuid
+import datetime
+import pathlib
 
+#TODO: allow to choose different provider later + dynamic routing when token expired
 API_URL = "https://api.cerebras.ai/v1/chat/completions"
-# HF_KEY = os.environ['HF_API_KEY']
 CEREBRAS_API_KEY = os.environ['CEREBRAS_API_KEY']
+
 HEADERS = {"Authorization": f"Bearer {CEREBRAS_API_KEY}", "Content-Type": "application/json"}
 JSON_OBJ_RE = re.compile(r"(\{[\s\S]*\})", re.MULTILINE)
 
+INPUT_TOKEN_COUNT = np.array([], dtype=int)
+OUTPUT_TOKEN_COUNT = np.array([], dtype=int)
+TOTAL_TOKEN_COUNT = np.array([], dtype=int)
+TOTAL_TOKEN_COUNT_EACH_GENERATION = np.array([])
+TIME_INFOs = {}
+
+
 def _post_chat(messages: list, model: str, temperature: float = 0.2, timeout: int = 60) -> str:
     payload = {"model": model, "messages": messages, "temperature": temperature}
     resp = requests.post(API_URL, headers=HEADERS, json=payload, timeout=timeout)
     resp.raise_for_status()
     data = resp.json()
 
+    save_to_local('test/raw_resp.json', content=data)
+
+    #? Must update within _post_chat because it the original function for LLM generation
+    update_token_count(token_usage=data['usage']) # get data['usages']['prompt_tokens'] & data['usages']['completion_tokens']
+    update_time_info(time_info=data['time_info'])
+
     # handle various shapes
     if "choices" in data and len(data["choices"]) > 0:
         # prefer message.content
@@ -23,13 +41,15 @@ def _post_chat(messages: list, model: str, temperature: float = 0.2, timeout: in
 
         if isinstance(ch, dict) and "message" in ch and "content" in ch["message"]:
             return ch["message"]["content"]
-        
+
         if "text" in ch:
             return ch["text"]
-        
+
+    print(f'Generation Time: {data["time_info"]}')
     # final fallback
     raise RuntimeError("Unexpected HF response shape: " + json.dumps(data)[:200])
 
+
 def _safe_extract_json(text: str) -> dict:
     # remove triple backticks
     text = re.sub(r"```(?:json)?\n?", "", text)
@@ -46,6 +66,7 @@ def _safe_extract_json(text: str) -> dict:
         fixed = re.sub(r",\s*([}\]])", r"\1", js)
         return json.loads(fixed)
 
+
 def generate_mcqs_from_text(
     source_text: str,
     n: int = 3,
@@ -85,3 +106,126 @@ def generate_mcqs_from_text(
     if not isinstance(parsed, dict) or len(parsed) != n:
         raise ValueError(f"Generator returned invalid structure. Raw:\n{raw}")
     return parsed
+
+
+# helpers to read/reset token counts
+def get_token_count_record():
+    global TOTAL_TOKEN_COUNT_EACH_GENERATION
+    TOTAL_TOKEN_COUNT_EACH_GENERATION = np.append(TOTAL_TOKEN_COUNT_EACH_GENERATION, np.sum(TOTAL_TOKEN_COUNT))
+
+    token_record = {
+        'INPUT_token_count': np.sum(INPUT_TOKEN_COUNT),
+        'OUTPUT_token_count': np.sum(OUTPUT_TOKEN_COUNT),
+        'AVG_INPUT_token_count': np.average(INPUT_TOKEN_COUNT),
+        'AVG_OUTPUT_token_count': np.average(OUTPUT_TOKEN_COUNT),
+        'TOTAL_token_count': TOTAL_TOKEN_COUNT,
+        'TOTAL_token_count_PER_GENERATION - ': TOTAL_TOKEN_COUNT_EACH_GENERATION,
+        'AVG_TOTAL_token_count_PER_GENERATION': [np.average(TOTAL_TOKEN_COUNT_EACH_GENERATION), len(TOTAL_TOKEN_COUNT_EACH_GENERATION)],
+    }
+
+    return token_record
+
+
+def reset_token_count(reset_all=None):
+    """Call in app.py. For Reset Token Count after 1 Generation Session"""
+    global INPUT_TOKEN_COUNT, OUTPUT_TOKEN_COUNT, TOTAL_TOKEN_COUNT, TOTAL_TOKEN_COUNT_EACH_GENERATION
+
+    INPUT_TOKEN_COUNT = np.array([])
+    OUTPUT_TOKEN_COUNT = np.array([])
+    TOTAL_TOKEN_COUNT = np.array([])
+
+    if reset_all:
+        TOTAL_TOKEN_COUNT_EACH_GENERATION = np.array([])
+
+
+def update_token_count(token_usage):
+    """Update Token Count for each generation
+    "usage": {
+        "prompt_tokens": 1209,
+        "completion_tokens": 313,
+        "total_tokens": 1522,
+        "prompt_tokens_details": {
+        "cached_tokens": 0
+    }
+    """
+    global INPUT_TOKEN_COUNT, OUTPUT_TOKEN_COUNT, TOTAL_TOKEN_COUNT # get value from global
+    prompt_tokens = token_usage['prompt_tokens'] # INPUT token
+    completion_tokens = token_usage['completion_tokens'] # OUTPUT token
+    total_tokens = token_usage['total_tokens'] # TOTAL token
+
+    INPUT_TOKEN_COUNT = np.append(INPUT_TOKEN_COUNT, prompt_tokens)
+    OUTPUT_TOKEN_COUNT = np.append(OUTPUT_TOKEN_COUNT, completion_tokens)
+    TOTAL_TOKEN_COUNT = np.append(TOTAL_TOKEN_COUNT, total_tokens)
+
+    # print("Input Token Increase:", INPUT_TOKEN_COUNT)
+    # print("Output Token Increase:", OUTPUT_TOKEN_COUNT)
+
+
+def save_logs(record: dict, log_path:str = "logs/generation_log.jsonl"):
+    """
+    Append log to log_path
+    record: dict with keys you want to store (e.g. filename, input/output token_count, collection, etc..)
+    """
+    # create file if not exist
+    p = pathlib.Path(log_path)
+    p.parent.mkdir(parents=True, exist_ok=True)
+
+    # add id/timestampt if missing
+    record.setdefault('id', str(uuid.uuid4()))
+    record.setdefault('timestamp_utc', datetime.datetime.now(datetime.timezone.utc).isoformat() + "Z") # get current time at timezone
+
+    # append as 1 json file for each generation
+    with open(p, "a", encoding='utf-8') as f:
+        f.write(json.dumps(record, ensure_ascii=False) + "\n")
+
+
+def update_time_info(time_info):
+    """
+    "time_info": {
+        "queue_time": 0.000600429,
+        "prompt_time": 0.052739054,
+        "completion_time": 0.15692187,
+        "total_time": 0.2117476463317871,
+        "created": 1755599458
+    }
+    """
+    time_info['created'] = time_info
+    time_info['created'].pop('created')
+
+
+def get_time_info():
+    global TIME_INFOs
+    return TIME_INFOs
+    # token_record = {
+    #     'completion_time': np.sum(INPUT_TOKEN_COUNT),
+    #     'total_time': np.sum(OUTPUT_TOKEN_COUNT),
+    # }
+
+def log_pipeline(path, content):
+    print("Save result to test/mcq_output.json")
+    save_to_local(path=path, content=content)
+    token_record = get_token_count_record()
+
+    print("Token Record:")
+    for record, value in token_record.items():
+        print(f'{record}:{value}', '\n')
+
+    reset_token_count()
+
+def save_to_local(path, content):
+    """
+        path = 'test/raw_data.json'
+        path = 'test/mcq_output.json'
+        path = 'test/extract_output.md'
+
+    """
+    p = pathlib.Path(path)
+    p.parent.mkdir(parents=True, exist_ok=True) # create folder if missing
+    p.touch(exist_ok=True) # create file if missing
+
+    if path.lower().endswith('.json'):
+        with open(path, 'w', encoding='utf-8') as f:
+            f.write(json.dumps(content, ensure_ascii=False, indent=2))
+    else:
+        with open(path, 'w', encoding='utf-8') as f:
+            f.write(f'{content}') # md, txt