{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Filter DPO Dataset Pairs by Reward Margins\n", "\n", "This notebook analyzes cached reward model outputs and filters dataset pairs based on configurable margin thresholds.\n", "\n", "**What it does:**\n", "- Loads cached reward files from multiple models\n", "- Computes margin = chosen_reward - rejected_reward for each pair\n", "- Defines exclusion window: [-std_threshold * std, +std_threshold * std] centered at 0\n", "- REMOVES pairs that fall in the window for ALL models (ambiguous)\n", "- KEEPS pairs that are outside the window for at least ONE model\n", "- Saves filtered indices to JSON for use in training\n" ] }, { "cell_type": "code", "execution_count": 92, "metadata": {}, "outputs": [], "source": [ "import json\n", "import os\n", "from typing import Dict, List, Set, Tuple\n", "\n", "import matplotlib.pyplot as plt\n", "import numpy as np" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Configuration\n", "\n", "Set your cached reward files and filtering parameters here:\n" ] }, { "cell_type": "code", "execution_count": 93, "metadata": {}, "outputs": [], "source": [ "test_version = \"v59\"\n", "data_dir = f\"crow_t1_{test_version}\"\n", "\n", "# List of cached reward files to compare (2+ models)\n", "cached_reward_files = [\n", " # f\"/app2/suno/data/dpo/{data_dir}/reward_2025-11-10_10-10-52_{test_version}_cached_reward.json\",\n", " f\"/app2/suno/data/dpo/{data_dir}/reward_2025-11-10_10-10-52_cached_reward.json\",\n", " f\"/app2/suno/data/dpo/{data_dir}/reward_2025-11-09_22-27-28_cached_reward.json\",\n", "]\n", "\n", "# Output directory\n", "output_base_dir = \"./reward_filter_results\"\n", "\n", "# Filtering strategy:\n", "# For each model, compute margin = chosen_reward - rejected_reward\n", "# Define exclusion window: [-std_threshold * std, +std_threshold * std] centered at 0\n", "# REMOVE pairs that fall in the window for BOTH models (ambiguous for both)\n", "# KEEP pairs that are outside the window for at least ONE model\n", "#\n", "# Examples:\n", "# std_threshold=1.0 -> exclude [-1*std, +1*std] (wider window, less aggressive)\n", "# std_threshold=0.5 -> exclude [-0.5*std, +0.5*std] (narrower window, more aggressive)\n", "std_threshold = 0.2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Helper Functions\n" ] }, { "cell_type": "code", "execution_count": 94, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "✓ Helper functions defined\n" ] } ], "source": [ "def load_cached_rewards(cache_path: str) -> Dict:\n", " \"\"\"Load cached rewards from JSON.\n", "\n", " Args:\n", " cache_path: Path to cached_reward.json file\n", "\n", " Returns:\n", " Dict with 'train' and 'val' splits, each mapping idx -> {'reward': float}\n", " \"\"\"\n", " with open(cache_path) as f:\n", " return json.load(f)\n", "\n", "\n", "def compute_margins_and_pair_ids(\n", " rewards: Dict, split: str\n", ") -> Tuple[List[float], List[int]]:\n", " \"\"\"Compute margin for each pair.\n", "\n", " Args:\n", " rewards: Cached rewards dict\n", " split: 'train' or 'val'\n", "\n", " Returns:\n", " margins: List of margins (chosen - rejected)\n", " pair_ids: List of pair IDs (each pair has ID = even_idx // 2)\n", " \"\"\"\n", " margins = []\n", " pair_ids = []\n", "\n", " # Process pairs: even idx = rejected, odd idx = chosen\n", " for k, v in sorted(rewards[split].items(), key=lambda x: int(x[0])):\n", " idx = int(k)\n", " if idx % 2 == 0: # rejected sample\n", " chosen_idx = idx + 1\n", " if str(chosen_idx) in rewards[split]:\n", " rejected_reward = v[\"reward\"]\n", " chosen_reward = rewards[split][str(chosen_idx)][\"reward\"]\n", " margin = chosen_reward - rejected_reward\n", " margins.append(margin)\n", " pair_ids.append(idx // 2)\n", "\n", " return margins, pair_ids\n", "\n", "\n", "def find_excluded_pairs(\n", " margins: List[float], pair_ids: List[int], std_threshold: float\n", ") -> Tuple[Set[int], float, float]:\n", " \"\"\"Find pairs to exclude based on margin within window.\n", "\n", " Args:\n", " margins: List of margins\n", " pair_ids: List of corresponding pair IDs\n", " std_threshold: Multiplier for std to define window\n", "\n", " Returns:\n", " excluded_pairs: Set of pair IDs to exclude\n", " lower_bound: Lower bound of exclusion window\n", " upper_bound: Upper bound of exclusion window\n", " \"\"\"\n", " margin_std = np.std(margins)\n", " lower_bound = -std_threshold * margin_std\n", " upper_bound = std_threshold * margin_std\n", "\n", " excluded_pairs = set()\n", " for pair_id, margin in zip(pair_ids, margins):\n", " if lower_bound <= margin <= upper_bound:\n", " excluded_pairs.add(pair_id)\n", "\n", " return excluded_pairs, lower_bound, upper_bound\n", "\n", "\n", "print(\"✓ Helper functions defined\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Multi-Model Filtering Analysis\n", "\n", "For each model:\n", "1. Compute margins (chosen - rejected) \n", "2. Define exclusion window: [-std_threshold * std, +std_threshold * std] \n", "3. Mark pairs within the window as excluded for that model\n", "\n", "Final filtering:\n", "- REMOVE pairs excluded by ALL models (ambiguous for all) \n", "- KEEP pairs where at least ONE model thinks it's clear\n" ] }, { "cell_type": "code", "execution_count": 95, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "✓ Multi-model filtering function defined\n" ] } ], "source": [ "def filter_by_multi_model_agreement(\n", " cached_reward_files: List[str], split: str, std_threshold: float\n", ") -> Dict:\n", " \"\"\"Filter pairs based on agreement across multiple reward models.\n", "\n", " Args:\n", " cached_reward_files: List of paths to cached reward JSON files\n", " split: 'train' or 'val'\n", " std_threshold: Multiplier for std to define exclusion window\n", "\n", " Returns:\n", " Dict with filtering results\n", " \"\"\"\n", " # Load all models\n", " model_data = []\n", " for cache_path in cached_reward_files:\n", " if not os.path.exists(cache_path):\n", " print(f\"⚠ Skipping missing file: {cache_path}\")\n", " continue\n", "\n", " rewards = load_cached_rewards(cache_path)\n", " margins, pair_ids = compute_margins_and_pair_ids(rewards, split)\n", " model_name = os.path.basename(cache_path).replace(\"_cached_reward.json\", \"\")\n", "\n", " model_data.append(\n", " {\n", " \"name\": model_name,\n", " \"margins\": margins,\n", " \"pair_ids\": pair_ids,\n", " }\n", " )\n", "\n", " if len(model_data) < 2:\n", " print(f\"⚠ Need at least 2 models, got {len(model_data)}\")\n", " return None\n", "\n", " # Find excluded pairs for each model\n", " all_excluded_pairs = []\n", " model_stats = []\n", "\n", " print(f\"\\n{'='*80}\")\n", " print(f\"MULTI-MODEL FILTERING ({len(model_data)} models, {split} split)\")\n", " print(f\"{'='*80}\\n\")\n", "\n", " for data in model_data:\n", " excluded_pairs, lower_bound, upper_bound = find_excluded_pairs(\n", " data[\"margins\"], data[\"pair_ids\"], std_threshold\n", " )\n", " all_excluded_pairs.append(excluded_pairs)\n", "\n", " mean_margin = np.mean(data[\"margins\"])\n", " std_margin = np.std(data[\"margins\"])\n", " n_pairs = len(data[\"margins\"])\n", "\n", " model_stats.append(\n", " {\n", " \"name\": data[\"name\"],\n", " \"mean\": mean_margin,\n", " \"std\": std_margin,\n", " \"lower_bound\": lower_bound,\n", " \"upper_bound\": upper_bound,\n", " \"excluded_count\": len(excluded_pairs),\n", " \"total_pairs\": n_pairs,\n", " \"margins\": data[\"margins\"],\n", " }\n", " )\n", "\n", " print(f\"Model: {data['name']}\")\n", " print(f\" Mean margin: {mean_margin:.4f}\")\n", " print(f\" Std margin: {std_margin:.4f}\")\n", " print(f\" Exclusion window: [{lower_bound:.4f}, {upper_bound:.4f}]\")\n", " print(\n", " f\" Pairs in window: {len(excluded_pairs)}/{n_pairs} \"\n", " f\"({len(excluded_pairs)/n_pairs*100:.1f}%)\\n\"\n", " )\n", "\n", " # Find pairs excluded by ALL models (intersection)\n", " excluded_by_all = set.intersection(*all_excluded_pairs)\n", "\n", " # Find pairs kept (not excluded by all)\n", " total_pairs = len(model_data[0][\"pair_ids\"])\n", " all_pair_ids = set(model_data[0][\"pair_ids\"])\n", " kept_pairs = all_pair_ids - excluded_by_all\n", "\n", " # Compute overlap statistics\n", " print(f\"{'='*80}\")\n", " print(\"OVERLAP ANALYSIS\")\n", " print(f\"{'='*80}\\n\")\n", " print(f\"Total pairs: {total_pairs}\\n\")\n", "\n", " if len(model_data) == 2:\n", " excluded_0_only = all_excluded_pairs[0] - all_excluded_pairs[1]\n", " excluded_1_only = all_excluded_pairs[1] - all_excluded_pairs[0]\n", "\n", " print(\n", " f\"Excluded by {model_stats[0]['name']} only: {len(excluded_0_only)} \"\n", " f\"({len(excluded_0_only)/total_pairs*100:.1f}%)\"\n", " )\n", " print(\n", " f\"Excluded by {model_stats[1]['name']} only: {len(excluded_1_only)} \"\n", " f\"({len(excluded_1_only)/total_pairs*100:.1f}%)\"\n", " )\n", "\n", " print(\n", " f\"Excluded by ALL models: {len(excluded_by_all)} \"\n", " f\"({len(excluded_by_all)/total_pairs*100:.1f}%)\"\n", " )\n", " print(\n", " f\"KEPT (≥1 model confident): {len(kept_pairs)} \"\n", " f\"({len(kept_pairs)/total_pairs*100:.1f}%)\\n\"\n", " )\n", "\n", " return {\n", " \"model_stats\": model_stats,\n", " \"excluded_by_all\": excluded_by_all,\n", " \"kept_pairs\": kept_pairs,\n", " \"total_pairs\": total_pairs,\n", " }\n", "\n", "\n", "print(\"✓ Multi-model filtering function defined\")" ] }, { "cell_type": "code", "execution_count": 96, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "================================================================================\n", "MULTI-MODEL FILTERING (2 models, train split)\n", "================================================================================\n", "\n", "Model: reward_2025-11-10_10-10-52\n", " Mean margin: 0.1271\n", " Std margin: 0.4574\n", " Exclusion window: [-0.0915, 0.0915]\n", " Pairs in window: 46516/183493 (25.4%)\n", "\n", "Model: reward_2025-11-09_22-27-28\n", " Mean margin: 0.0292\n", " Std margin: 0.4686\n", " Exclusion window: [-0.0937, 0.0937]\n", " Pairs in window: 51768/183493 (28.2%)\n", "\n", "================================================================================\n", "OVERLAP ANALYSIS\n", "================================================================================\n", "\n", "Total pairs: 183493\n", "\n", "Excluded by reward_2025-11-10_10-10-52 only: 31153 (17.0%)\n", "Excluded by reward_2025-11-09_22-27-28 only: 36405 (19.8%)\n", "Excluded by ALL models: 15363 (8.4%)\n", "KEPT (≥1 model confident): 168130 (91.6%)\n", "\n", "\n", "\n", "\n", "================================================================================\n", "MULTI-MODEL FILTERING (2 models, val split)\n", "================================================================================\n", "\n", "Model: reward_2025-11-10_10-10-52\n", " Mean margin: 0.1132\n", " Std margin: 0.4295\n", " Exclusion window: [-0.0859, 0.0859]\n", " Pairs in window: 431/1854 (23.2%)\n", "\n", "Model: reward_2025-11-09_22-27-28\n", " Mean margin: 0.0264\n", " Std margin: 0.4244\n", " Exclusion window: [-0.0849, 0.0849]\n", " Pairs in window: 442/1854 (23.8%)\n", "\n", "================================================================================\n", "OVERLAP ANALYSIS\n", "================================================================================\n", "\n", "Total pairs: 1854\n", "\n", "Excluded by reward_2025-11-10_10-10-52 only: 302 (16.3%)\n", "Excluded by reward_2025-11-09_22-27-28 only: 313 (16.9%)\n", "Excluded by ALL models: 129 (7.0%)\n", "KEPT (≥1 model confident): 1725 (93.0%)\n", "\n" ] } ], "source": [ "# Run filtering analysis\n", "results_train = filter_by_multi_model_agreement(\n", " cached_reward_files, split=\"train\", std_threshold=std_threshold\n", ")\n", "print(\"\\n\")\n", "results_val = filter_by_multi_model_agreement(\n", " cached_reward_files, split=\"val\", std_threshold=std_threshold\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Visualize Margin Distributions\n", "\n", "Plot margin distributions for each model with exclusion windows:\n" ] }, { "cell_type": "code", "execution_count": 97, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "\n", "✓ Margin distribution plot complete\n" ] } ], "source": [ "# Plot margin distributions\n", "if results_train is not None:\n", " model_stats = results_train[\"model_stats\"]\n", " n_models = len(model_stats)\n", "\n", " fig, axes = plt.subplots(1, n_models, figsize=(7 * n_models, 5))\n", " if n_models == 1:\n", " axes = [axes]\n", "\n", " for idx, stats in enumerate(model_stats):\n", " ax = axes[idx]\n", "\n", " # Plot histogram\n", " ax.hist(\n", " stats[\"margins\"],\n", " bins=50,\n", " alpha=0.7,\n", " edgecolor=\"black\",\n", " color=\"steelblue\",\n", " )\n", "\n", " # Shade exclusion window\n", " ax.axvspan(\n", " stats[\"lower_bound\"],\n", " stats[\"upper_bound\"],\n", " alpha=0.3,\n", " color=\"red\",\n", " label=f\"Exclusion: [{stats['lower_bound']:.3f}, {stats['upper_bound']:.3f}]\",\n", " )\n", "\n", " # Mark zero and mean\n", " ax.axvline(\n", " x=0,\n", " color=\"black\",\n", " linestyle=\"-\",\n", " linewidth=2,\n", " alpha=0.7,\n", " label=\"Zero (ambiguous)\",\n", " )\n", " ax.axvline(\n", " x=stats[\"mean\"],\n", " color=\"green\",\n", " linestyle=\"--\",\n", " linewidth=1.5,\n", " alpha=0.7,\n", " label=f\"Mean: {stats['mean']:.3f}\",\n", " )\n", "\n", " # Labels\n", " ax.set_xlabel(\"Margin (chosen - rejected)\", fontsize=11)\n", " ax.set_ylabel(\"Count\", fontsize=11)\n", " ax.set_title(\n", " f\"{stats['name']}\\nMean={stats['mean']:.3f}, Std={stats['std']:.3f}\",\n", " fontsize=11,\n", " fontweight=\"bold\",\n", " )\n", " ax.legend(fontsize=9)\n", " ax.grid(True, alpha=0.3)\n", "\n", " plt.tight_layout()\n", " plt.show()\n", "\n", " print(\"\\n✓ Margin distribution plot complete\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Save Filtered Results\n", "\n", "Save indices of kept pairs (excluded by none or only some models):\n" ] }, { "cell_type": "code", "execution_count": 98, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "✓ Saved filtered indices to ./reward_filter_results/crow_t1_v59_m_std0.2.json\n", "\n", "📊 KEPT PAIRS (at least one model confident):\n", " Train: 336260 indices (168130 pairs = 91.6% of 183493)\n", " Val: 3450 indices (1725 pairs = 93.0% of 1854)\n" ] } ], "source": [ "# Save filtered indices\n", "if results_train is not None and results_val is not None:\n", " output_dir = output_base_dir\n", " os.makedirs(output_dir, exist_ok=True)\n", "\n", " # Convert pair IDs to dataset indices (each pair has even=rejected, odd=chosen)\n", " train_kept_indices = []\n", " for pair_id in sorted(results_train[\"kept_pairs\"]):\n", " train_kept_indices.append(pair_id * 2) # rejected (even)\n", " train_kept_indices.append(pair_id * 2 + 1) # chosen (odd)\n", "\n", " val_kept_indices = []\n", " for pair_id in sorted(results_val[\"kept_pairs\"]):\n", " val_kept_indices.append(pair_id * 2) # rejected (even)\n", " val_kept_indices.append(pair_id * 2 + 1) # chosen (odd)\n", "\n", " # Save to JSON\n", " output_json = os.path.join(output_dir, f\"{data_dir}_m_std{std_threshold:.1f}.json\")\n", " output = {\n", " \"train\": train_kept_indices,\n", " \"val\": val_kept_indices,\n", " \"config\": {\n", " \"std_threshold\": std_threshold,\n", " \"models\": [s[\"name\"] for s in results_train[\"model_stats\"]],\n", " \"filter_logic\": (\n", " f\"Exclude pairs within [-{std_threshold}*std, +{std_threshold}*std] \"\n", " f\"for ALL models. Keep pairs where at least ONE model is confident.\"\n", " ),\n", " },\n", " }\n", "\n", " with open(output_json, \"w\") as f:\n", " json.dump(output, f, indent=2)\n", "\n", " # Calculate statistics\n", " train_total = results_train[\"total_pairs\"]\n", " val_total = results_val[\"total_pairs\"]\n", " train_kept = len(results_train[\"kept_pairs\"])\n", " val_kept = len(results_val[\"kept_pairs\"])\n", "\n", " train_pct = train_kept / train_total * 100\n", " val_pct = val_kept / val_total * 100\n", "\n", " print(f\"\\n✓ Saved filtered indices to {output_json}\")\n", " print(f\"\\n📊 KEPT PAIRS (at least one model confident):\")\n", " print(\n", " f\" Train: {len(train_kept_indices)} indices \"\n", " f\"({train_kept} pairs = {train_pct:.1f}% of {train_total})\"\n", " )\n", " print(\n", " f\" Val: {len(val_kept_indices)} indices \"\n", " f\"({val_kept} pairs = {val_pct:.1f}% of {val_total})\"\n", " )" ] }, { "cell_type": "markdown", "metadata": {}, "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "language_info": { "name": "python" } }, "nbformat": 4, "nbformat_minor": 5 }