le723z/rearank_12k

Reranking dataset built from only 179 annotated queries with random sampling technique to increase final sample amount. This dataset is used to train Rearank model in the paper - REARANK: Reasoning Re-ranking Agent via Reinforcement Learning

Below are the data generation code

# Preprocess dataset for countdown task - given a target number and N numbers, generate equations to reach target

import re
import os
from datasets import Dataset, load_dataset
from random import randint, seed, choice
from typing import List, Tuple
from tqdm import tqdm
from hdfs_io import copy, makedirs
import argparse
import sys
from trec_eval import eval_rerank


def make_prefix(dp, template_type):
    query = dp['query']
    hits = dp['hits']
    num_hits = len(hits)
    # NOTE: also need to change reward_score/countdown.py
    if template_type == 'base':
        raise NotImplementedError
    elif template_type == 'qwen-instruct':
        """This works for Qwen Instruct Models"""

        prefix = (
            f"I will provide you with passages, each indicated by number identifier []. Rank the passages based on their relevance to the search query."
            f"Search Query: {query}. \nRank the {num_hits} passages above based on their relevance to the search query."
            f"The passages should be listed in descending order using identifiers. The most relevant passages should be listed first. The output format should be <answer> [] > [] </answer>, e.g., <answer> [1] > [2] </answer>."
        )
    
        return prefix



raw_dataset = load_dataset('le723z/DeepRerank', split='train')
all_metric, scores = eval_rerank('combined_qrels.txt', raw_dataset)
unsolvable_qids = []
for qid, metrics in scores.items():
    if metrics['ndcg_cut_10'] == 0:
        unsolvable_qids.append(qid)
unsolvable_qids, len(unsolvable_qids)
# Filter out samples with qids in unsolvable_qids
filtered_dataset = raw_dataset.filter(lambda x: str(x['hits'][0]['qid']) not in unsolvable_qids)
print(len(filtered_dataset))

def make_map_fn(split):
    def process_fn(example, idx):
        question = make_prefix(example, template_type="qwen-instruct")
        messages = [
                {"role": "system", "content": "You are DeepRerank, an intelligent assistant that can rank passages based on their relevancy to the search query. You first thinks about the reasoning process in the mind and then provides the user with the answer."},
                {"role": "user","content": question},
                {"role": "assistant", "content": "Okay, please provide the passages."}
            ]
        rank = 0
        for hit in example['hits']:
            rank += 1
            content = hit['content']
            content = content.replace('Title: Content: ', '')
            content = content.strip()
            content = ' '.join(content.split()[:int(300)]) # max token fea each passage is 300
            messages.append({"role": "user", "content": f"[{rank}] {content}"})
            messages.append({"role": "assistant", "content": f"Received passage [{rank}]."})
            
        messages.append({
            "role": "user",
           "content": f"""Please rank these passages according to their relevance to the search query: "{example['query']}"
                Follow these steps exactly:
                1. First, within <think> tags, analyze EACH passage individually:
                - Evaluate how well it addresses the query
                - Note specific relevant information or keywords

                2. Then, within <answer> tags, provide ONLY the final ranking in descending order of relevance using the format: [X] > [Y] > [Z]"""
        })

        

        data = {
            "data_source": "TREC-DL-TOP100",
            "prompt": messages,
            "ability": "rerank",
            "reward_model": {
                "style": "rule",
                "ground_truth": ""
            },
            "extra_info": {
                'split': split,
                'index': idx,
            }
        }
        return data
    return process_fn

train_dataset = filtered_dataset.map(function=make_map_fn('train'), with_indices=True)

local_dir = './'
hdfs_dir = None

train_dataset.to_parquet(os.path.join(local_dir, 'filtered_train.parquet'))

if hdfs_dir is not None:
    makedirs(hdfs_dir)
    copy(src=local_dir, dst=hdfs_dir)

Then filter out the dataset

from multiprocessing import Pool
from functools import partial

def process_example(example, idx):
    all_metric, scores = eval_rerank('combined_qrels.txt', example)
    example['metrics'] = all_metric
    if all_metric['NDCG@10'] < 0.1:
        print(f"Discarding example {idx} with metrics: {all_metric}")
        return None
    return example

def filter_dataset_parallel(dataset, num_processes=8):
    with Pool(processes=num_processes) as pool:
        results = list(pool.starmap(process_example, [(example, idx) for idx, example in enumerate(dataset)]))
    
    # Filter out None values and create new dataset
    filtered_examples = [ex for ex in results if ex is not None]
    filtered_dataset = dataset.from_list(filtered_examples)
    
    print(f"\nKept {len(filtered_dataset)} examples")
    return filtered_dataset

filtered_dataset = filter_dataset_parallel(dataset)

We also add possible best scores for each passages list

from datasets import load_dataset
from multiprocessing import Pool
from functools import partial
import copy
import random   
import sys
sys.path.append('/home/mila/l/le.zhang/scratch/DeepRerank')
from trec_eval import EvalFunction, eval_rerank, trec_eval
qrels = EvalFunction.load_qrels('combined_qrels.txt')
dataset = load_dataset("parquet", data_files='filtered_train_high_ndcg.parquet')["train"]

def convert_to_trec_format(rank_dict):
    """Convert rank_results directly to the format needed for pytrec_eval"""
    run_dict = {}
    for index, hit in enumerate(rank_dict):
        qid = str(hit['qid'])  # Ensure qid is a string
        docid = str(hit['docid'])  # Ensure docid is a string
        score = float(hit['score'])  # Ensure score is a float
        if qid not in run_dict:
            run_dict[qid] = {}
        run_dict[qid][docid] = score
    
    return run_dict

def add_best_metrics(dataset_example, qrels):
    """
    Adds the best possible metrics to a dataset example by reordering hits based on relevance scores.
    
    Args:
        dataset_example: A single example from the dataset
        qrels: The relevance judgments dictionary
        
    Returns:
        The dataset example with added best_hits and metrics
    """
    # Get the query ID from the first hit
    qid = dataset_example['hits'][0]['qid']
    corresponding_qrels = qrels[str(qid)]
    hits = dataset_example['hits']
    
    # Get relevance scores for each hit
    hit_scores = []
    for hit in hits:
        docid = hit['docid']
        rel_score = corresponding_qrels.get(docid, 0)  # Default to 0 if not found
        # Create a deep copy of the hit to avoid modifying the original
        hit_copy = dict(hit)
        hit_scores.append((hit_copy, rel_score))
    
    # Sort hits by relevance score in descending order
    sorted_hits = sorted(hit_scores, key=lambda x: x[1], reverse=True)
    best_hits = [h[0] for h in sorted_hits]

    # Update the score of the best_hits without affecting original hits
    for org_idx, hit in enumerate(best_hits):
        best_hits[org_idx]['score'] = 20-org_idx

    # Get indices of where each original rank ended up after sorting
    original_ranks = [h[0]['rank'] for h in hit_scores]
    new_rank = [original_ranks.index(h[0]['rank']) for h in sorted_hits]

    results = convert_to_trec_format(best_hits)
    best_metric, _ = trec_eval(qrels, results, k_values=(1, 5, 10))
    
    # Store the best hits separately from the original hits
    dataset_example['best_metrics'] = best_metric
    dataset_example['new_rank'] = new_rank
    # Optionally store the best_hits if needed
    # dataset_example['best_hits'] = best_hits

    return dataset_example

map_fn = partial(add_best_metrics, qrels=qrels)
dataset = dataset.map(map_fn, num_proc=32)

and finally

import os
filtered_dataset = dataset.filter(lambda x: x['best_metrics']['NDCG@10'] > x['metrics']['NDCG@10'])
# upload to huggingface hub
filtered_dataset.push_to_hub('le723z/rearank_12k', 'filtered_train_high_ndcg_ideal')