Upload train_reranker.py with huggingface_hub

train_reranker.py

@@ -0,0 +1,360 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#     "sentence-transformers[train]>=4.0",
+#     "datasets",
+#     "torch>=2.4",
+#     "transformers>=4.48",
+#     "trackio",
+#     "scipy",
+#     "numpy",
+# ]
+# ///
+"""
+Soft-Label Cross-Encoder Reranker Training
+
+Trains a reranker using continuous relevance scores (soft labels).
+Dataset format: {"query": "...", "text": "...", "score": 0.0-1.0}
+"""
+
+import logging
+import os
+import math
+from collections import defaultdict
+import trackio
+import numpy as np
+from datasets import load_dataset
+from sentence_transformers.cross_encoder import (
+    CrossEncoder,
+    CrossEncoderTrainer,
+    CrossEncoderTrainingArguments,
+)
+from sentence_transformers.cross_encoder.evaluation import CrossEncoderNanoBEIREvaluator
+from scipy.stats import spearmanr
+from transformers import TrainerCallback, EarlyStoppingCallback
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Configuration
+DATASET_NAME = os.environ.get("DATASET_NAME", "amanwithaplan/arcade-reranker-data")
+HUB_MODEL_ID = os.environ.get("HUB_MODEL_ID", "idqo/arcade-reranker")
+BASE_MODEL = os.environ.get("BASE_MODEL", "Alibaba-NLP/gte-reranker-modernbert-base")
+NUM_EPOCHS = int(os.environ.get("NUM_EPOCHS", "3"))
+BATCH_SIZE = int(os.environ.get("BATCH_SIZE", "16"))
+LEARNING_RATE = float(os.environ.get("LEARNING_RATE", "1e-5"))
+MAX_SEQ_LENGTH = int(os.environ.get("MAX_SEQ_LENGTH", "1024"))
+RUN_NAME = os.environ.get("RUN_NAME", "reranker-1024-v1")
+SPACE_ID = os.environ.get("TRACKIO_SPACE_ID", "amanwithaplan/trackio")
+
+
+def dcg_at_k(relevances, k):
+    """Compute DCG@k."""
+    relevances = np.array(relevances)[:k]
+    if len(relevances) == 0:
+        return 0.0
+    # DCG = sum of rel_i / log2(i+2) for i in 0..k-1
+    discounts = np.log2(np.arange(len(relevances)) + 2)
+    return np.sum(relevances / discounts)
+
+
+def ndcg_at_k(predicted_order, true_relevances, k):
+    """
+    Compute NDCG@k.
+
+    predicted_order: indices of docs sorted by model score (descending)
+    true_relevances: ground truth relevance scores for each doc
+    """
+    # Get relevances in predicted order
+    predicted_relevances = [true_relevances[i] for i in predicted_order]
+
+    # Ideal order: sort by true relevance descending
+    ideal_relevances = sorted(true_relevances, reverse=True)
+
+    dcg = dcg_at_k(predicted_relevances, k)
+    idcg = dcg_at_k(ideal_relevances, k)
+
+    if idcg == 0:
+        return 0.0
+    return dcg / idcg
+
+
+def mrr(predicted_order, true_relevances, threshold=0.5):
+    """
+    Compute MRR (Mean Reciprocal Rank).
+
+    Returns 1/rank of first relevant doc (relevance > threshold).
+    """
+    for rank, idx in enumerate(predicted_order, start=1):
+        if true_relevances[idx] > threshold:
+            return 1.0 / rank
+    return 0.0
+
+
+def evaluate_ranking(model, eval_dataset):
+    """
+    Proper ranking evaluation: group by query, compute NDCG and MRR.
+
+    This measures what we actually care about:
+    "Given a query with multiple docs, does the model rank them correctly?"
+    """
+    # Group samples by query
+    query_groups = defaultdict(list)
+    for item in eval_dataset:
+        query_groups[item["sentence1"]].append({
+            "text": item["sentence2"],
+            "label": item["label"]
+        })
+
+    # Filter to queries with multiple docs (need at least 2 to rank)
+    query_groups = {q: docs for q, docs in query_groups.items() if len(docs) >= 2}
+
+    if not query_groups:
+        return {"ndcg@3": 0.0, "ndcg@5": 0.0, "mrr": 0.0, "n_queries": 0}
+
+    ndcg_3_scores = []
+    ndcg_5_scores = []
+    mrr_scores = []
+    rank_correlations = []
+
+    for query, docs in query_groups.items():
+        # Get model predictions for this query's docs
+        pairs = [(query, d["text"]) for d in docs]
+        predictions = model.predict(pairs, show_progress_bar=False)
+
+        true_relevances = [d["label"] for d in docs]
+
+        # Get predicted order: indices sorted by prediction descending
+        predicted_order = np.argsort(predictions)[::-1].tolist()
+
+        # Compute metrics
+        ndcg_3_scores.append(ndcg_at_k(predicted_order, true_relevances, k=3))
+        ndcg_5_scores.append(ndcg_at_k(predicted_order, true_relevances, k=5))
+        mrr_scores.append(mrr(predicted_order, true_relevances, threshold=0.5))
+
+        # Rank correlation within this query
+        if len(set(true_relevances)) > 1:  # Need variance
+            corr = spearmanr(predictions, true_relevances).correlation
+            if not math.isnan(corr):
+                rank_correlations.append(corr)
+
+    return {
+        "ndcg@3": np.mean(ndcg_3_scores),
+        "ndcg@5": np.mean(ndcg_5_scores),
+        "mrr": np.mean(mrr_scores),
+        "rank_corr": np.mean(rank_correlations) if rank_correlations else 0.0,
+        "n_queries": len(query_groups),
+    }
+
+
+class DomainEvalCallback(TrainerCallback):
+    """Callback to log proper ranking metrics during training."""
+
+    def __init__(self, model, eval_dataset_full):
+        self.model = model
+        self.eval_dataset_full = eval_dataset_full
+
+    def on_evaluate(self, args, state, control, **kwargs):
+        """Run after each evaluation step."""
+        metrics = evaluate_ranking(self.model, self.eval_dataset_full)
+
+        # Log to trackio
+        trackio.log({
+            "domain/ndcg@3": metrics["ndcg@3"],
+            "domain/ndcg@5": metrics["ndcg@5"],
+            "domain/mrr": metrics["mrr"],
+            "domain/rank_corr": metrics["rank_corr"],
+        })
+
+        logger.info(
+            f"Domain eval - NDCG@3: {metrics['ndcg@3']:.4f}, "
+            f"NDCG@5: {metrics['ndcg@5']:.4f}, "
+            f"MRR: {metrics['mrr']:.4f}, "
+            f"RankCorr: {metrics['rank_corr']:.4f} "
+            f"(n={metrics['n_queries']} queries)"
+        )
+
+
+def evaluate_by_type(model, eval_dataset, type_column="type"):
+    """Evaluate ranking metrics per content type."""
+    if type_column not in eval_dataset.column_names:
+        return {}
+
+    # Group by type first
+    by_type = defaultdict(list)
+    for item in eval_dataset:
+        by_type[item[type_column]].append(item)
+
+    results = {}
+    for content_type, items in by_type.items():
+        # Create a mini dataset for this type
+        class TypeDataset:
+            def __init__(self, items):
+                self.items = items
+            def __iter__(self):
+                return iter(self.items)
+            @property
+            def column_names(self):
+                return ["sentence1", "sentence2", "label"]
+
+        type_metrics = evaluate_ranking(model, TypeDataset(items))
+
+        if type_metrics["n_queries"] >= 2:
+            results[f"{content_type}_ndcg@5"] = type_metrics["ndcg@5"]
+            results[f"{content_type}_mrr"] = type_metrics["mrr"]
+            results[f"{content_type}_n_queries"] = type_metrics["n_queries"]
+
+    return results
+
+
+def main():
+    # Initialize trackio with full config
+    trackio.init(
+        project="arcade-reranker",
+        name=RUN_NAME,
+        space_id=SPACE_ID,
+        config={
+            "model": BASE_MODEL,
+            "dataset": DATASET_NAME,
+            "learning_rate": LEARNING_RATE,
+            "num_epochs": NUM_EPOCHS,
+            "batch_size": BATCH_SIZE,
+            "max_seq_length": MAX_SEQ_LENGTH,
+        }
+    )
+
+    logger.info(f"Configuration:")
+    logger.info(f"  Dataset: {DATASET_NAME}")
+    logger.info(f"  Base model: {BASE_MODEL}")
+    logger.info(f"  Epochs: {NUM_EPOCHS}")
+    logger.info(f"  Run name: {RUN_NAME}")
+    logger.info(f"  Trackio space: {SPACE_ID}")
+
+    model = CrossEncoder(BASE_MODEL, max_length=MAX_SEQ_LENGTH)
+
+    logger.info(f"Loading dataset: {DATASET_NAME}")
+    dataset = load_dataset(DATASET_NAME, split="train")
+
+    # Log dataset composition
+    type_counts = defaultdict(int)
+    if "type" in dataset.column_names:
+        for item in dataset:
+            type_counts[item["type"]] += 1
+        logger.info(f"Dataset composition: {dict(type_counts)}")
+
+        # Log to trackio
+        for content_type, count in type_counts.items():
+            trackio.log({f"data/{content_type}_count": count})
+
+    trackio.log({"data/total_examples": len(dataset)})
+    logger.info(f"Total examples: {len(dataset)}")
+
+    # Rename columns for CrossEncoderTrainer
+    dataset = dataset.rename_columns({
+        "query": "sentence1",
+        "text": "sentence2",
+        "score": "label"
+    })
+
+    # Split for evaluation (before removing extra columns so we keep type for eval)
+    eval_size = min(400, int(len(dataset) * 0.15))
+    splits = dataset.train_test_split(test_size=eval_size, seed=42)
+
+    # Keep full eval dataset with type column for per-type evaluation
+    eval_dataset_full = splits["test"]
+
+    # Remove extra columns for training (CrossEncoderTrainer only wants sentence1, sentence2, label)
+    train_dataset = splits["train"].select_columns(["sentence1", "sentence2", "label"])
+    eval_dataset = splits["test"].select_columns(["sentence1", "sentence2", "label"])
+
+    trackio.log({
+        "data/train_size": len(train_dataset),
+        "data/eval_size": len(eval_dataset),
+    })
+    logger.info(f"Train: {len(train_dataset)}, Eval: {len(eval_dataset)}")
+
+    # Evaluate base model before training with proper ranking metrics
+    logger.info("Evaluating base model on eval set...")
+    base_metrics = evaluate_ranking(model, eval_dataset_full)
+    for key, value in base_metrics.items():
+        trackio.log({f"base_model/{key}": value})
+    logger.info(f"Base model metrics: {base_metrics}")
+
+    # NanoBEIR for benchmark comparison
+    evaluator = CrossEncoderNanoBEIREvaluator(
+        dataset_names=["msmarco", "nfcorpus", "nq"],
+        batch_size=BATCH_SIZE,
+    )
+
+    args = CrossEncoderTrainingArguments(
+        output_dir="models/reranker",
+        num_train_epochs=NUM_EPOCHS,
+        per_device_train_batch_size=BATCH_SIZE,
+        per_device_eval_batch_size=BATCH_SIZE,
+        learning_rate=LEARNING_RATE,
+        warmup_ratio=0.1,
+        bf16=True,
+        eval_strategy="steps",
+        eval_steps=25,
+        save_strategy="steps",
+        save_steps=25,
+        save_total_limit=5,
+        logging_steps=25,
+        logging_first_step=True,
+        load_best_model_at_end=True,
+        metric_for_best_model="eval_loss",
+        greater_is_better=False,
+        push_to_hub=True,
+        hub_model_id=HUB_MODEL_ID,
+        hub_strategy="every_save",
+        report_to="trackio",
+        run_name=RUN_NAME,
+    )
+
+    # Custom callback to log domain-specific ranking metrics during training
+    domain_callback = DomainEvalCallback(model, eval_dataset_full)
+
+    # Early stopping to prevent overfitting
+    early_stopping = EarlyStoppingCallback(early_stopping_patience=3)
+
+    trainer = CrossEncoderTrainer(
+        model=model,
+        args=args,
+        train_dataset=train_dataset,
+        eval_dataset=eval_dataset,
+        evaluator=evaluator,
+        callbacks=[domain_callback, early_stopping],
+    )
+
+    logger.info("Starting training...")
+    trainer.train()
+
+    # Final evaluation with proper ranking metrics
+    logger.info("Running final ranking evaluation...")
+    final_metrics = evaluate_ranking(model, eval_dataset_full)
+    for key, value in final_metrics.items():
+        trackio.log({f"final/{key}": value})
+    logger.info(f"Final metrics: {final_metrics}")
+
+    # Per-type evaluation
+    logger.info("Evaluating by content type...")
+    type_metrics = evaluate_by_type(model, eval_dataset_full)
+    for key, value in type_metrics.items():
+        trackio.log({f"final/by_type/{key}": value})
+    logger.info(f"Per-type metrics: {type_metrics}")
+
+    # Log improvement
+    trackio.log({
+        "improvement/ndcg5_delta": final_metrics["ndcg@5"] - base_metrics["ndcg@5"],
+        "improvement/mrr_delta": final_metrics["mrr"] - base_metrics["mrr"],
+    })
+
+    logger.info(f"Pushing final model to {HUB_MODEL_ID}")
+    model.push_to_hub(HUB_MODEL_ID, exist_ok=True)
+
+    trackio.finish()
+    logger.info("Done!")
+
+
+if __name__ == "__main__":
+    main()