import json import random import os import argparse import torch import numpy as np from pathlib import Path from datasets import load_dataset from tqdm import tqdm from pyserini.search.lucene import LuceneSearcher from sentence_transformers import CrossEncoder # ========================================== # CONFIGURATION # ========================================== # OPTION A: The Modern SOTA (Recommended) - ~2.2GB VRAM CROSS_ENCODER_MODEL = "BAAI/bge-reranker-v2-m3" # Target samples per language MARGINMSE_SAMPLES = { "ara": 32_000, "dan": 32_000, "deu": 96_000, "eng": 128_000, "fas": 64_000, "fra": 96_000, "hin": 32_000, "ind": 32_000, "ita": 96_000, "jpn": 96_000, "kor": 32_000, "nld": 96_000, "pol": 64_000, "por": 64_000, "rus": 96_000, "spa": 96_000, "swe": 32_000, "tur": 32_000, "vie": 32_000, "zho": 32_000, } # Pyserini Language Codes LANG_MAP = { "ara": "ar", "dan": "da", "deu": "de", "eng": "en", "fas": "fa", "fra": "fr", "hin": "hi", "ind": "id", "ita": "it", "jpn": "ja", "kor": "ko", "nld": "nl", "pol": "pl", "por": "pt", "rus": "ru", "spa": "es", "swe": "sv", "tur": "tr", "vie": "vi", "zho": "zh" } def build_index(language: str, corpus: dict, temp_dir: Path): """ Builds a temporary Lucene index for BM25 retrieval. """ iso_lang = LANG_MAP.get(language, "en") input_dir = temp_dir / language / "corpus_jsonl" index_dir = temp_dir / language / "index" if index_dir.exists(): return index_dir print(f" [{language}] Preparing docs for indexing...") input_dir.mkdir(parents=True, exist_ok=True) jsonl_file = input_dir / "docs.jsonl" with open(jsonl_file, "w", encoding="utf-8") as f: for cid, text in corpus.items(): f.write(json.dumps({"id": str(cid), "contents": text}, ensure_ascii=False) + "\n") print(f" [{language}] Building BM25 Index (Analyzer: {iso_lang})...") # Using os.system to call the Pyserini JVM wrapper cmd = (f"python -m pyserini.index.lucene " f"--collection JsonCollection " f"--input {input_dir} " f"--index {index_dir} " f"--generator DefaultLuceneDocumentGenerator " f"--threads 8 " f"--language {iso_lang} " f"--storeRaw") os.system(cmd) return index_dir def process_language_mining_and_scoring(lang, n_samples, output_path, repo_id, k_negatives, scorer_model, batch_size): print(f"\n{'='*60}\nProcessing {lang} (Samples: {n_samples})\n{'='*60}") # 1. Load Data try: q_ds = load_dataset(repo_id, f"{lang}-queries", split='train') c_ds = load_dataset(repo_id, f"{lang}-corpus", split='corpus') qr_ds = load_dataset(repo_id, f"{lang}-qrels", split='train') except Exception as e: print(f" [ERROR] Could not load {lang}: {e}") return queries = {item['_id']: item['text'] for item in q_ds} corpus = {item['_id']: item['text'] for item in c_ds} qrels_all = [(item['query-id'], item['corpus-id']) for item in qr_ds] # 2. Sample Subset random.seed(42) if len(qrels_all) > n_samples: sampled_qrels = random.sample(qrels_all, n_samples) else: sampled_qrels = qrels_all # 3. Build/Load Index idx_path = build_index(lang, corpus, Path("./temp_indices")) searcher = LuceneSearcher(str(idx_path)) searcher.set_language(LANG_MAP.get(lang, "en")) # 4. Mine AND Score final_output = [] print(f" [{lang}] Mining {k_negatives} negatives & Reranking with {CROSS_ENCODER_MODEL}...") for qid, pos_doc_id in tqdm(sampled_qrels, desc=f" Distilling {lang}"): query_text = queries.get(qid) pos_text = corpus.get(pos_doc_id) if not query_text or not pos_text: continue # A. BM25 Retrieval hits = searcher.search(query_text, k=k_negatives + 20) neg_candidates = [] for hit in hits: if hit.docid != str(pos_doc_id) and len(neg_candidates) < k_negatives: neg_text = corpus.get(hit.docid) if neg_text: neg_candidates.append(neg_text) # B. Cross-Encoder Scoring # We score [Positive, Neg1, Neg2, ..., Neg200] texts_to_score = [pos_text] + neg_candidates pairs = [[query_text, doc] for doc in texts_to_score] # Predict returns raw logits scores = scorer_model.predict(pairs, batch_size=batch_size, show_progress_bar=False) pos_score = float(scores[0]) neg_scores = [float(s) for s in scores[1:]] final_output.append({ "query": query_text, "positive": pos_text, "positive_score": pos_score, "negatives": neg_candidates, "negative_scores": neg_scores }) # 5. Save save_dir = Path(output_path) / lang save_dir.mkdir(parents=True, exist_ok=True) outfile = save_dir / "train_marginmse.jsonl" with open(outfile, "w", encoding="utf-8") as f: for item in final_output: f.write(json.dumps(item, ensure_ascii=False) + "\n") print(f" [{lang}] Saved {len(final_output)} examples to {outfile}") def main(): parser = argparse.ArgumentParser() parser.add_argument("--repo-id", default="PaDaS-Lab/webfaq-retrieval") parser.add_argument("--output-dir", default="./data/distilled_data") parser.add_argument("--k-negatives", type=int, default=200) parser.add_argument("--batch-size", type=int, default=16, help="Lower this if OOM") args = parser.parse_args() # Initialize Teacher device = "cuda" if torch.cuda.is_available() else "cpu" print(f"Loading Teacher: {CROSS_ENCODER_MODEL}") print(f"Device: {device}") scorer_model = CrossEncoder( CROSS_ENCODER_MODEL, device=device, automodel_args={"torch_dtype": torch.float16} if device == "cuda" else {} ) for lang, n_samples in MARGINMSE_SAMPLES.items(): # === RESUME LOGIC === # If the output file already exists, we assume this language is done. output_file = Path(args.output_dir) / lang / "train_marginmse.jsonl" if output_file.exists(): # Optional: Check file size to ensure it's not empty/corrupted if output_file.stat().st_size > 1000: print(f" [RESUME] Output found for {lang}. Skipping...") continue else: print(f" [RESUME] Found empty file for {lang}. Re-processing...") process_language_mining_and_scoring( lang, n_samples, args.output_dir, args.repo_id, args.k_negatives, scorer_model, args.batch_size ) if __name__ == "__main__": main()