Create codekaggle/ .qa_generator_BSE_C1_C2

codekaggle/ .qa_generator_BSE_C1_C2

@@ -0,0 +1,323 @@
+# =============================================================================
+# INDO-BLOOM LOCAL QA GENERATOR v1.0 — KAGGLE GPU (NO API KEY)
+#
+# Model  : Qwen/Qwen2.5-3B-Instruct (lokal, gratis, tanpa rate limit)
+# GPU    : Kaggle T4 (16GB VRAM) — aktifkan di Settings → Accelerator → GPU T4
+# Input  : CSV hasil IBEX (kolom 'context')
+# Output : CSV QA pairs C1 + C2 siap pakai sebagai Indo-Bloom corpus
+#
+# CARA PAKAI:
+#   1. Buka Kaggle Notebook → Settings → Accelerator → pilih "GPU T4 x2" atau "GPU T4"
+#   2. Upload CSV hasil IBEX sebagai dataset input
+#   3. Jalankan cell ini — model otomatis diunduh (~6GB, sekali saja)
+#   4. Selesai! Tidak ada API key, tidak ada rate limit.
+# =============================================================================
+
+import subprocess, sys
+
+# Install transformasi yang dibutuhkan
+subprocess.run([sys.executable, "-m", "pip", "install", "-q",
+                "transformers", "accelerate", "torch"], check=False)
+
+import os, json, re, hashlib, time
+import pandas as pd
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+
+# ══════════════════════════════════════════════════════════════════════════════
+# KONFIGURASI
+# ══════════════════════════════════════════════════════════════════════════════
+
+MODEL_NAME  = "Qwen/Qwen2.5-3B-Instruct"
+FILE_PATH   = "/kaggle/input/datasets/baimfirmansyah/sosiologi-bs-kls-x11-fulhalaman/IBEX_Sosiologi_BS_KLS_XII_hal15-240_chunk150_noise2_FULL.csv"
+OUTPUT_FILE = "/kaggle/working/IndoBloom_QA_Local_Final.csv"
+ERROR_FILE  = "/kaggle/working/IndoBloom_QA_Local_Errors.csv"
+
+N_C1_PER_CHUNK = 2   # jumlah QA C1 per chunk
+N_C2_PER_CHUNK = 2   # jumlah QA C2 per chunk
+MAX_NEW_TOKENS = 600
+TEMPERATURE    = 0.7
+
+# ══════════════════════════════════════════════════════════════════════════════
+# LOAD MODEL
+# ══════════════════════════════════════════════════════════════════════════════
+
+print("=" * 60)
+print(f"🤖 Memuat model: {MODEL_NAME}")
+print("   (proses ini ~2-5 menit pertama kali, lalu cached)")
+print("=" * 60)
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+print(f"⚙️  Device: {device.upper()}")
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, trust_remote_code=True)
+model     = AutoModelForCausalLM.from_pretrained(
+    MODEL_NAME,
+    torch_dtype=torch.float16 if device == "cuda" else torch.float32,
+    device_map="auto",
+    trust_remote_code=True,
+)
+model.eval()
+print(f"✅ Model siap di {device.upper()}")
+
+# ══════════════════════════════════════════════════════════════════════════════
+# PROMPT TEMPLATES
+# ══════════════════════════════════════════════════════════════════════════════
+
+SYSTEM_MSG = (
+    "Anda adalah pakar pembuatan soal Taksonomi Bloom Bahasa Indonesia. "
+    "Tugas Anda membuat soal yang tepat sesuai level kognitif yang diminta. "
+    "Selalu kembalikan output dalam format JSON yang valid."
+)
+
+def prompt_c1(konteks: str, n: int) -> str:
+    return (
+        f"Bacalah teks berikut:\n\"\"\"{konteks}\"\"\"\n\n"
+        f"Buat {n} pasang soal-jawaban level C1 (Mengingat).\n"
+        "Ketentuan C1:\n"
+        "- Pertanyaan diawali: apa, siapa, kapan, di mana, atau berapa\n"
+        "- Jawaban berupa fakta eksplisit dari teks (maks 15 kata)\n\n"
+        f"Output JSON (tanpa teks lain):\n"
+        '{"c1": [{"question": "...", "answer": "..."}, ...]}'
+    )
+
+def prompt_c2(konteks: str, n: int) -> str:
+    return (
+        f"Bacalah teks berikut:\n\"\"\"{konteks}\"\"\"\n\n"
+        f"Buat {n} pasang soal-jawaban level C2 (Memahami).\n"
+        "Ketentuan C2:\n"
+        "- Pertanyaan WAJIB diawali: mengapa atau bagaimana\n"
+        "- Jawaban menjelaskan sebab-akibat/proses, min 20 kata\n"
+        "- Jawaban HARUS mengandung kata: karena/sehingga/mengakibatkan/berdampak\n"
+        "- Jawaban dengan bahasa sendiri, BUKAN copy-paste teks\n\n"
+        f"Output JSON (tanpa teks lain):\n"
+        '{"c2": [{"question": "...", "answer": "..."}, ...]}'
+    )
+
+# ═════════════════════════════════════���════════════════════════════════════════
+# FUNGSI GENERATE
+# ══════════════════════════════════════════════════════════════════════════════
+
+def generate_json(user_prompt: str) -> dict | None:
+    """Panggil model lokal dan parse JSON dari output."""
+    messages = [
+        {"role": "system", "content": SYSTEM_MSG},
+        {"role": "user",   "content": user_prompt},
+    ]
+
+    text = tokenizer.apply_chat_template(
+        messages, tokenize=False, add_generation_prompt=True
+    )
+    inputs = tokenizer([text], return_tensors="pt").to(device)
+
+    with torch.no_grad():
+        outputs = model.generate(
+            **inputs,
+            max_new_tokens=MAX_NEW_TOKENS,
+            temperature=TEMPERATURE,
+            do_sample=True,
+            pad_token_id=tokenizer.eos_token_id,
+        )
+
+    # Ambil hanya bagian yang digenerate (bukan prompt)
+    generated = outputs[0][inputs["input_ids"].shape[-1]:]
+    raw = tokenizer.decode(generated, skip_special_tokens=True).strip()
+
+    # Extract JSON
+    s = raw.find('{')
+    e = raw.rfind('}') + 1
+    if s == -1:
+        return None
+
+    try:
+        return json.loads(raw[s:e])
+    except json.JSONDecodeError:
+        # Coba bersihkan trailing comma umum di LLM output
+        cleaned = re.sub(r',\s*([}\]])', r'\1', raw[s:e])
+        try:
+            return json.loads(cleaned)
+        except Exception:
+            return None
+
+
+def validasi_c1(q: str, a: str) -> tuple[bool, str]:
+    starters = ["apa", "siapa", "kapan", "di mana", "dimana", "berapa"]
+    if not any(q.lower().startswith(s) for s in starters):
+        return False, f"Tidak diawali kata tanya C1 (mulai: '{q[:30]}')"
+    if len(a.split()) > 20:
+        return False, f"Jawaban C1 terlalu panjang ({len(a.split())} kata)"
+    if len(a.split()) < 2:
+        return False, "Jawaban terlalu pendek"
+    return True, "OK"
+
+
+def validasi_c2(q: str, a: str) -> tuple[bool, str]:
+    if not any(q.lower().startswith(k) for k in ["mengapa", "bagaimana"]):
+        return False, f"Tidak diawali 'Mengapa'/'Bagaimana' (mulai: '{q[:30]}')"
+    if len(a.split()) < 20:
+        return False, f"Jawaban terlalu pendek ({len(a.split())} kata, min 20)"
+    kausal = ['karena', 'sehingga', 'mengakibatkan', 'berdampak',
+              'akibatnya', 'dampaknya', 'disebabkan', 'mendorong', 'menyebabkan']
+    if not any(k in a.lower() for k in kausal):
+        return False, "Tidak ada penanda kausal"
+    return True, "OK"
+
+
+def proses_chunk(chunk_id: str, konteks: str) -> tuple[list, list]:
+    """
+    Generate C1 + C2 untuk satu chunk.
+    Return: (valid_rows, error_rows)
+    """
+    uid       = hashlib.md5(konteks.encode()).hexdigest()[:8]
+    valid     = []
+    errors    = []
+
+    # ── C1 ────────────────────────────────────────────────────────────────
+    data_c1 = generate_json(prompt_c1(konteks, N_C1_PER_CHUNK))
+    if data_c1 and "c1" in data_c1:
+        for item in data_c1["c1"]:
+            q = item.get("question", "").strip()
+            a = item.get("answer", "").strip()
+            ok, alasan = validasi_c1(q, a)
+            if ok:
+                valid.append({
+                    "id"            : f"BSE-SOS-12-{chunk_id}-{uid}-C1",
+                    "chunk_id"      : chunk_id,
+                    "bloom_level"   : "C1",
+                    "bloom_label"   : "Mengingat (Remembering)",
+                    "answer_type"   : "extractive",
+                    "question"      : q,
+                    "answer"        : a,
+                    "answer_words"  : len(a.split()),
+                    "context"       : konteks,
+                })
+            else:
+                errors.append({"chunk_id": chunk_id, "level": "C1",
+                               "alasan": alasan, "q": q[:100], "a": a[:100]})
+    else:
+        errors.append({"chunk_id": chunk_id, "level": "C1",
+                       "alasan": "Gagal parse JSON atau key 'c1' tidak ada", "q": "", "a": ""})
+
+    # ── C2 ────────────────────────────────────────────────────────────────
+    data_c2 = generate_json(prompt_c2(konteks, N_C2_PER_CHUNK))
+    if data_c2 and "c2" in data_c2:
+        for item in data_c2["c2"]:
+            q = item.get("question", "").strip()
+            a = item.get("answer", "").strip()
+            ok, alasan = validasi_c2(q, a)
+            if ok:
+                valid.append({
+                    "id"            : f"BSE-SOS-12-{chunk_id}-{uid}-C2",
+                    "chunk_id"      : chunk_id,
+                    "bloom_level"   : "C2",
+                    "bloom_label"   : "Memahami (Understanding)",
+                    "answer_type"   : "abstractive",
+                    "question"      : q,
+                    "answer"        : a,
+                    "answer_words"  : len(a.split()),
+                    "context"       : konteks,
+                })
+            else:
+                errors.append({"chunk_id": chunk_id, "level": "C2",
+                               "alasan": alasan, "q": q[:100], "a": a[:100]})
+    else:
+        errors.append({"chunk_id": chunk_id, "level": "C2",
+                       "alasan": "Gagal parse JSON atau key 'c2' tidak ada", "q": "", "a": ""})
+
+    return valid, errors
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# BACA INPUT & RESUME
+# ══════════════════════════════════════════════════════════════════════════════
+
+assert os.path.exists(FILE_PATH), f"File tidak ditemukan: {FILE_PATH}"
+df_input = pd.read_csv(FILE_PATH)
+print(f"\n✅ {len(df_input)} chunk dimuat dari {os.path.basename(FILE_PATH)}")
+
+# Resume
+def muat_output(path):
+    if not os.path.exists(path) or os.path.getsize(path) == 0:
+        return set(), []
+    try:
+        df = pd.read_csv(path)
+        if df.empty or "chunk_id" not in df.columns:
+            return set(), []
+        ids = set(df["chunk_id"].tolist())
+        print(f"♻️  Resume: {len(ids)} chunk sudah ada.")
+        return ids, df.to_dict("records")
+    except Exception:
+        return set(), []
+
+processed_ids, all_rows = muat_output(OUTPUT_FILE)
+error_rows = []
+
+# ══════════════════════════════════════════════════════════════════════════════
+# LOOP UTAMA
+# ══════════════════════════════════════════════════════════════════════════════
+
+sisa = len(df_input) - len(processed_ids)
+print(f"⏱️  Estimasi: ~{sisa * 30 // 60} menit untuk {sisa} chunk "
+      f"(~30s/chunk di GPU T4)")
+print("\n" + "=" * 60)
+print("🚀 Memulai generate QA (lokal, tanpa API key)")
+print("=" * 60)
+
+for idx, row in df_input.iterrows():
+    chunk_id = str(row["chunk_id"])
+    konteks  = str(row["context"])
+
+    if chunk_id in processed_ids:
+        print(f"[{idx+1}/{len(df_input)}] {chunk_id} — dilewati.")
+        continue
+
+    print(f"\n[{idx+1}/{len(df_input)}] {chunk_id}...")
+    t0 = time.time()
+
+    valid, errors = proses_chunk(chunk_id, konteks)
+    elapsed = time.time() - t0
+
+    all_rows.extend(valid)
+    error_rows.extend(errors)
+    processed_ids.add(chunk_id)
+
+    # Log hasil
+    c1_ok = sum(1 for r in valid if r["bloom_level"] == "C1")
+    c2_ok = sum(1 for r in valid if r["bloom_level"] == "C2")
+    c1_err = sum(1 for e in errors if e["level"] == "C1")
+    c2_err = sum(1 for e in errors if e["level"] == "C2")
+
+    print(f"  ✅ C1: {c1_ok} valid, {c1_err} ditolak | "
+          f"C2: {c2_ok} valid, {c2_err} ditolak | {elapsed:.0f}s")
+
+    for r in valid:
+        print(f"     [{r['bloom_level']}] Q: {r['question'][:80]}")
+        print(f"           A: {r['answer'][:80]}{'...' if len(r['answer'])>80 else ''}")
+
+    # Checkpoint setiap 5 chunk
+    if len(processed_ids) % 5 == 0:
+        pd.DataFrame(all_rows).to_csv(OUTPUT_FILE, index=False, encoding="utf-8-sig")
+        print(f"  💾 Checkpoint: {len(all_rows)} QA disimpan.")
+
+# ══════════════════════════════════════════════════════════════════════════════
+# SIMPAN & LAPORAN AKHIR
+# ══════════════════════════════════════════════════════════════════════════════
+
+df_out = pd.DataFrame(all_rows)
+df_out.to_csv(OUTPUT_FILE, index=False, encoding="utf-8-sig")
+
+if error_rows:
+    pd.DataFrame(error_rows).to_csv(ERROR_FILE, index=False, encoding="utf-8-sig")
+
+print("\n" + "=" * 60)
+print("✅ SELESAI!")
+print(f"   Total QA valid    : {len(all_rows)}")
+if not df_out.empty:
+    c1_total = len(df_out[df_out["bloom_level"] == "C1"])
+    c2_total = len(df_out[df_out["bloom_level"] == "C2"])
+    print(f"   • C1 (Mengingat)  : {c1_total}")
+    print(f"   • C2 (Memahami)   : {c2_total}")
+    print(f"   Rata-rata jawaban : {df_out['answer_words'].mean():.1f} kata")
+print(f"   Error/ditolak     : {len(error_rows)}")
+print(f"   Output            : {OUTPUT_FILE}")
+print("=" * 60)