add filter script

filter_correct_answer.py

@@ -0,0 +1,346 @@
+#!/usr/bin/env python3
+"""
+HF dataset temizleyici: Çoktan seçmeli sorulardan doğru cevap dışındaki şıkları siler.
+
+Hazırlayan: Behlül
+
+Desteklenen dataset formatları (fizik, tarih, matematik için aynı script):
+  - conversations: [{"from": "human/gpt", "value": "..."}]
+  - messages:      [{"role": "user/assistant", "content": "..."}]
+
+Desteklenen cevap prefixleri (asistan mesajından doğru harf çıkarılır):
+  - Türkçe: "Cevap: B)" / "Cevap: **B**" / "Doğru cevap: B"
+  - İngilizce: "Answer: B" / "**Answer:** B" / "The answer is B"
+  - Sondaki tek harf: "...\nB"
+
+Kullanım:
+  # HF'ten indir + filtrele (3 split birlikte)
+  python filter_correct_answer.py --hf mrbe-share/fizik80k --outdir ./out/fizik
+
+  # Tek dosya
+  python filter_correct_answer.py --file train.jsonl --output train_clean.jsonl
+
+  # Çoktan seçmeli olmayanları at
+  python filter_correct_answer.py --hf mrbe-share/fizik80k --outdir ./out/fizik --drop-non-mc
+"""
+
+import argparse
+import json
+import os
+import re
+import sys
+import urllib.request
+from pathlib import Path
+
+
+# ---------- Regex ----------
+
+# Sorudaki seçenek satırı:  "A) ...", "A. ...", "A- ...", "**A)** ..."
+OPTION_LINE_RE = re.compile(
+    r'^\s*\*{0,2}\s*([A-Z])\s*\*{0,2}\s*[\)\.\-]\s*\S',
+    re.MULTILINE,
+)
+
+# Cevap harfini çıkarmak için pattern'lar (öncelik sırasına göre)
+ANSWER_PATTERNS = [
+    # "Cevap: B)" / "Cevap: **B**" / "Cevap : B."
+    re.compile(r'[Cc]evap\s*[:\-]\s*\*{0,2}\s*([A-Z])\b'),
+    # "Doğru cevap: B"
+    re.compile(r'[Dd]o[ğg]ru\s+cevap\s*[:\-]\s*\*{0,2}\s*([A-Z])\b'),
+    # "**Answer:** B" / "Answer: B"
+    re.compile(r'\*{0,2}\s*[Aa]nswer\s*\*{0,2}\s*[:\-]\s*\*{0,2}\s*([A-Z])\b'),
+    # "The answer is B" / "the correct answer is B"
+    re.compile(r'[Tt]he\s+(?:correct\s+)?answer\s+is\s*[:\-]?\s*\*{0,2}\s*([A-Z])\b'),
+    # "**B** is correct" / "B is the correct answer"
+    re.compile(r'\*{0,2}([A-Z])\*{0,2}\s+is\s+(?:the\s+)?correct'),
+    # Son çare: metin sonunda tek başına duran tek büyük harf
+    re.compile(r'(?:^|\n)\s*\*{0,2}([A-Z])\*{0,2}\s*\.?\s*$'),
+]
+
+
+def extract_correct_letter(answer_text: str) -> str | None:
+    """Asistan cevabından doğru seçeneğin harfini çıkarır (A-Z)."""
+    if not answer_text:
+        return None
+    for pat in ANSWER_PATTERNS:
+        m = pat.search(answer_text)
+        if m:
+            return m.group(1).upper()
+    return None
+
+
+def find_option_letters(question: str) -> set[str]:
+    """Sorudaki seçenek harflerini bulur (ör. {'A','B','C','D'})."""
+    return {m.upper() for m in OPTION_LINE_RE.findall(question)}
+
+
+def strip_distractors(question: str, correct_letter: str) -> tuple[str, bool]:
+    """
+    Sorudan doğru şık dışındaki bütün seçenek satırlarını siler.
+    Aynı seçenek birden fazla satıra yayılabileceği için "bu seçenek bloğu
+    hangi harfle başladı" state'ini takip ediyoruz.
+    """
+    lines = question.split('\n')
+    out = []
+    current_letter = None  # şu anda hangi şıkkın içindeyiz
+    removed_any = False
+    kept_correct = False
+
+    for line in lines:
+        m = re.match(r'^\s*\*{0,2}\s*([A-Z])\s*\*{0,2}\s*[\)\.\-]\s*', line)
+        if m:
+            current_letter = m.group(1).upper()
+            if current_letter == correct_letter:
+                out.append(line)
+                kept_correct = True
+            else:
+                removed_any = True
+                # skip (doğru şık değil)
+        else:
+            # devam satırı mı yoksa normal soru metni mi?
+            is_blank = line.strip() == ''
+            if current_letter is None:
+                # soru gövdesi — her zaman tut
+                out.append(line)
+            else:
+                # bir şıkkın devamı
+                if is_blank:
+                    # boş satır şıkkın bittiğini gösterir
+                    current_letter = None
+                    out.append(line)
+                elif current_letter == correct_letter:
+                    out.append(line)
+                # else: yanlış şıkkın devam satırı — at
+                # Cevap: / Answer: gibi ipuçları gelirse şıkkı bitir
+                if re.match(r'^\s*\*{0,2}\s*(Cevap|Answer|Doğru cevap)\b', line, re.IGNORECASE):
+                    current_letter = None
+
+    return '\n'.join(out), (removed_any and kept_correct)
+
+
+# ---------- Kayıt işleme ----------
+
+def _get_msg_iface(rec: dict):
+    """Kaydın mesaj yapısını tespit eder, (msgs_list, role_key, content_key, user_roles, assistant_roles) döner."""
+    if 'conversations' in rec and isinstance(rec['conversations'], list):
+        return rec['conversations'], 'from', 'value', ('human', 'user'), ('gpt', 'assistant')
+    if 'messages' in rec and isinstance(rec['messages'], list):
+        return rec['messages'], 'role', 'content', ('user',), ('assistant',)
+    return None
+
+
+def process_record(rec: dict) -> tuple[dict, bool, str]:
+    """
+    Bir kaydı işler.
+    Dönüş: (yeni_kayıt, filtrelendi_mi, sebep_etiketi)
+    """
+    iface = _get_msg_iface(rec)
+    if iface is None:
+        return rec, False, 'unknown_format'
+    msgs, role_key, content_key, user_roles, asst_roles = iface
+
+    # Son user/assistant çiftini bul
+    user_idx = None
+    for i, m in enumerate(msgs):
+        if m.get(role_key) in user_roles:
+            user_idx = i
+    if user_idx is None:
+        return rec, False, 'no_user_msg'
+
+    asst_idx = None
+    for j in range(user_idx + 1, len(msgs)):
+        if msgs[j].get(role_key) in asst_roles:
+            asst_idx = j
+            break
+    if asst_idx is None:
+        return rec, False, 'no_assistant_msg'
+
+    question = msgs[user_idx].get(content_key, '')
+    answer = msgs[asst_idx].get(content_key, '')
+
+    if not isinstance(question, str) or not isinstance(answer, str):
+        return rec, False, 'non_string_content'
+
+    option_letters = find_option_letters(question)
+    if len(option_letters) < 2:
+        return rec, False, 'not_multichoice'
+
+    correct_letter = extract_correct_letter(answer)
+    if not correct_letter:
+        return rec, False, 'no_correct_letter'
+
+    if correct_letter not in option_letters:
+        return rec, False, f'answer_letter_{correct_letter}_not_in_options'
+
+    new_question, changed = strip_distractors(question, correct_letter)
+    if not changed:
+        return rec, False, 'no_distractors_stripped'
+
+    # Immutable kopya
+    new_rec = dict(rec)
+    new_msgs = [dict(m) for m in msgs]
+    new_msgs[user_idx] = dict(new_msgs[user_idx])
+    new_msgs[user_idx][content_key] = new_question
+
+    if 'conversations' in rec:
+        new_rec['conversations'] = new_msgs
+    else:
+        new_rec['messages'] = new_msgs
+
+    return new_rec, True, 'filtered'
+
+
+# ---------- I/O ----------
+
+def download_hf_file(repo_id: str, path: str, out_path: Path, token: str | None = None) -> None:
+    url = f'https://huggingface.co/datasets/{repo_id}/resolve/main/{path}'
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    req = urllib.request.Request(url)
+    if token:
+        req.add_header('Authorization', f'Bearer {token}')
+    sys.stderr.write(f'[indir] {url}\n')
+    with urllib.request.urlopen(req) as resp, open(out_path, 'wb') as f:
+        size = 0
+        while True:
+            chunk = resp.read(1024 * 1024)
+            if not chunk:
+                break
+            f.write(chunk)
+            size += len(chunk)
+            sys.stderr.write(f'\r  {size/1024/1024:.1f} MB')
+            sys.stderr.flush()
+    sys.stderr.write(f'\n[hazır] {out_path} ({out_path.stat().st_size/1024/1024:.1f} MB)\n')
+
+
+def list_hf_files(repo_id: str, token: str | None = None) -> list[str]:
+    url = f'https://huggingface.co/api/datasets/{repo_id}/tree/main?recursive=true'
+    req = urllib.request.Request(url)
+    if token:
+        req.add_header('Authorization', f'Bearer {token}')
+    with urllib.request.urlopen(req) as resp:
+        data = json.loads(resp.read().decode('utf-8'))
+    return [d['path'] for d in data if d.get('type') == 'file' and d['path'].endswith('.jsonl')]
+
+
+def process_file(in_path: Path, out_path: Path, drop_non_mc: bool = False) -> dict:
+    stats = {
+        'total': 0,
+        'filtered': 0,
+        'kept_unchanged': 0,
+        'dropped': 0,
+        'parse_errors': 0,
+        'reasons': {},
+    }
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    with open(in_path, encoding='utf-8') as fin, open(out_path, 'w', encoding='utf-8') as fout:
+        for line in fin:
+            line = line.rstrip('\n')
+            if not line.strip():
+                continue
+            stats['total'] += 1
+            try:
+                rec = json.loads(line)
+            except json.JSONDecodeError:
+                stats['parse_errors'] += 1
+                continue
+
+            new_rec, was_filtered, reason = process_record(rec)
+
+            if was_filtered:
+                stats['filtered'] += 1
+                fout.write(json.dumps(new_rec, ensure_ascii=False) + '\n')
+            else:
+                stats['reasons'][reason] = stats['reasons'].get(reason, 0) + 1
+                if drop_non_mc and reason == 'not_multichoice':
+                    stats['dropped'] += 1
+                    continue
+                stats['kept_unchanged'] += 1
+                fout.write(json.dumps(rec, ensure_ascii=False) + '\n')
+    return stats
+
+
+def print_stats(label: str, stats: dict) -> None:
+    print(f'\n=== {label} ===')
+    print(f'Toplam satır       : {stats["total"]}')
+    print(f'Filtrelendi        : {stats["filtered"]}  (yanlış şıklar silindi)')
+    print(f'Değişmeden geçti   : {stats["kept_unchanged"]}')
+    if stats.get('dropped'):
+        print(f'Atıldı             : {stats["dropped"]}')
+    if stats.get('parse_errors'):
+        print(f'Parse hatası       : {stats["parse_errors"]}')
+    if stats['reasons']:
+        print('Atlama nedenleri:')
+        for r, c in sorted(stats['reasons'].items(), key=lambda x: -x[1]):
+            print(f'  {r:<40} {c}')
+
+
+# ---------- CLI ----------
+
+def main():
+    p = argparse.ArgumentParser(
+        description='Çoktan seçmeli HF dataset\'lerinden yanlış şıkları siler, doğru cevabı bırakır.',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=__doc__.split('Kullanım:')[1] if 'Kullanım:' in __doc__ else '',
+    )
+    src = p.add_mutually_exclusive_group(required=True)
+    src.add_argument('--hf', help='HF dataset id (ör. mrbe-share/fizik80k)')
+    src.add_argument('--file', help='Lokal .jsonl dosya yolu')
+
+    p.add_argument('--split-path', action='append', default=None,
+                   help='HF içindeki belirli dosya yolu (birden fazla kez verilebilir). Boş bırakılırsa tüm .jsonl dosyaları işlenir.')
+    p.add_argument('--output', help='Tek dosya modu için çıkış yolu (--file ile)')
+    p.add_argument('--outdir', help='Çoklu dosya modu için çıkış dizini (--hf ile)')
+    p.add_argument('--token', default=os.environ.get('HF_TOKEN'), help='HF API token (özel dataset için gerekli)')
+    p.add_argument('--cache-dir', default='/tmp/hf_dataset_cache', help='İndirilen dosyaların cache dizini')
+    p.add_argument('--drop-non-mc', action='store_true', help='Çoktan seçmeli olmayan kayıtları at')
+    p.add_argument('--force-download', action='store_true', help='Cache\'i yok say, yeniden indir')
+
+    args = p.parse_args()
+
+    if args.file:
+        if not args.output:
+            p.error('--file ile birlikte --output zorunlu')
+        stats = process_file(Path(args.file), Path(args.output), drop_non_mc=args.drop_non_mc)
+        print_stats(args.file, stats)
+        print(f'\nÇıktı: {args.output}')
+        return
+
+    # --hf modu
+    if not args.outdir:
+        p.error('--hf ile birlikte --outdir zorunlu')
+
+    splits = args.split_path
+    if not splits:
+        print(f'[info] {args.hf} için tüm .jsonl dosyaları listeleniyor...')
+        splits = list_hf_files(args.hf, token=args.token)
+        if not splits:
+            print('HATA: dataset\'te .jsonl dosyası bulunamadı', file=sys.stderr)
+            sys.exit(1)
+        print(f'[info] {len(splits)} dosya bulundu: {splits}')
+
+    cache_base = Path(args.cache_dir) / args.hf.replace('/', '_')
+    outdir = Path(args.outdir)
+    outdir.mkdir(parents=True, exist_ok=True)
+
+    grand_total = {'total': 0, 'filtered': 0, 'kept_unchanged': 0, 'dropped': 0, 'parse_errors': 0}
+    for sp in splits:
+        cache_path = cache_base / sp
+        if args.force_download or not cache_path.exists():
+            download_hf_file(args.hf, sp, cache_path, token=args.token)
+
+        # Düz dosya adı: splits/train.jsonl → splits__train.jsonl
+        safe_name = sp.replace('/', '__')
+        out_path = outdir / safe_name
+
+        stats = process_file(cache_path, out_path, drop_non_mc=args.drop_non_mc)
+        print_stats(f'{args.hf} / {sp}', stats)
+        print(f'Çıktı: {out_path}')
+        for k in grand_total:
+            grand_total[k] += stats.get(k, 0)
+
+    if len(splits) > 1:
+        print_stats(f'TOPLAM ({args.hf})', {**grand_total, 'reasons': {}})
+
+
+if __name__ == '__main__':
+    main()