Upload 10 files

.gitattributes

@@ -57,3 +57,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+datasets/QACandidate_Pool.csv filter=lfs diff=lfs merge=lfs -text

Multi-label_Task/metrics.py

@@ -0,0 +1,85 @@
+import pandas as pd
+import os
+
+impact_columns = [
+    "Infrastructural impact", 
+    "Political impact", 
+    "Economic impact", 
+    "Ecological impact", 
+    "Agricultural impact", 
+    "Human health impact"
+]
+groupby=["Date","Time_Period"]
+gold_data = pd.read_csv("the_path_to_gold_data.csv")
+gold_data.columns = [x.capitalize() for x in gold_data.columns]
+
+def eval_row_wise_acc(data, output_file):
+    data.columns = [x.capitalize() for x in data.columns]
+    models = data['Model_type'].unique()
+
+    gold_grouped = gold_data.groupby(groupby)[impact_columns].max()
+    results = []
+
+    for model in models:
+        model_data = data[data['Model_type'] == model]
+        grouped = model_data.groupby(groupby)[impact_columns].max()
+        merged = grouped.join(gold_grouped, how='inner', lsuffix='_model', rsuffix='_gold')
+
+        all_correct = (merged[[f"{col}_model" for col in impact_columns]].values ==
+                       merged[[f"{col}_gold" for col in impact_columns]].values).all(axis=1)
+
+        accuracy = all_correct.sum() / len(all_correct) if len(all_correct) > 0 else 0
+        results.append({
+            "Model_Type": model,
+            "Row-Wise-Accuracy": round(accuracy, 4)
+        })
+
+    df_result = pd.DataFrame(results)
+    if not os.path.isfile(output_file):
+        df_result.to_csv(output_file, index=False)
+    else:
+        df_result.to_csv(output_file, mode='a', header=False, index=False)
+
+def eval_metrics(data, output_file):
+    data.columns = [x.capitalize() for x in data.columns]
+    models = data["Model_type"].unique()
+    gold_grouped = gold_data.groupby(groupby)[impact_columns].max()
+    results = []
+
+    for model in models:
+        model_data = data[data["Model_type"] == model]
+        grouped = model_data.groupby(groupby)[impact_columns].max()
+        merged = grouped.join(gold_grouped, how="inner", lsuffix="_model", rsuffix="_gold")
+
+        for metric_name in ["Precision", "Recall", "F1", "Accuracy"]:
+            metrics = {"Model_Type": model, "Metric": metric_name}
+            for col in impact_columns:
+                tp = ((merged[f"{col}_model"] == 1) & (merged[f"{col}_gold"] == 1)).sum()
+                tn = ((merged[f"{col}_model"] == 0) & (merged[f"{col}_gold"] == 0)).sum()
+                fp = ((merged[f"{col}_model"] == 1) & (merged[f"{col}_gold"] == 0)).sum()
+                fn = ((merged[f"{col}_model"] == 0) & (merged[f"{col}_gold"] == 1)).sum()
+
+                if metric_name == "Precision":
+                    value = tp / (tp + fp) if (tp + fp) > 0 else 0
+                elif metric_name == "Recall":
+                    value = tp / (tp + fn) if (tp + fn) > 0 else 0
+                elif metric_name == "F1":
+                    precision = tp / (tp + fp) if (tp + fp) > 0 else 0
+                    recall = tp / (tp + fn) if (tp + fn) > 0 else 0
+                    value = 2 * (precision * recall) / (precision + recall) if (precision + recall) > 0 else 0
+                elif metric_name == "Accuracy":
+                    value = (tp + tn) / (tp + tn + fp + fn) if (tp + tn + fp + fn) > 0 else 0
+
+                metrics[col] = round(value, 4)
+            results.append(metrics)
+
+    df_result = pd.DataFrame(results)
+    print(df_result)
+
+    if not os.path.isfile(output_file):
+        df_result.to_csv(output_file, index=False)
+    else:
+        df_result.to_csv(output_file, mode="a", header=False, index=False)
+
+data = pd.read_csv("/content/output_gpt.csv")
+eval_metrics(data, "accuracy_results.csv")

Multi-label_Task/model_eval.py

@@ -0,0 +1,151 @@
+from typing import List
+import requests
+import re
+import random
+import time
+import json
+from openai import OpenAI
+import os
+import dotenv
+import csv
+import transformers
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+import torch
+dotenv.load_dotenv()
+client = OpenAI(
+    api_key=os.environ.get("OPENAI_API_KEY")
+)
+
+API_KEY=""
+from huggingface_hub import login
+login(token=API_KEY)
+huggingface_models=["meta-llama/Meta-Llama-3-8B-Instruct","Qwen/Qwen2.5-7B-Instruct","mistralai/Mixtral-8x7B-Instruct-v0.1","Qwen/Qwen2.5-14B-Instruct","Qwen/Qwen2.5-7B-Instruct","google/gemma-2-9b-it","mistralai/Mistral-Small-24B-Instruct-2501"]
+model_name = "model_name" #Change here for testing your model
+
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+config = BitsAndBytesConfig(
+    load_in_4bit=True,
+    bnb_4bit_compute_dtype=torch.float16, 
+    bnb_4bit_use_double_quant=True,
+    llm_int8_enable_fp32_cpu_offload=True 
+)
+model = AutoModelForCausalLM.from_pretrained(
+    model_name,
+    cache_dir=YOUR_CACHE_DIR,
+    device_map={"": 0}, 
+    quantization_config=config  
+)
+model.gradient_checkpointing_enable()
+
+def extract_answer(full_text):
+    pattern = (
+        r"(Infrastructural|"
+        r"Agricultural|"
+        r"Ecological|"
+        r"Financial|"
+        r"Human Health|"
+        r"Political):\s*(true|false)"
+    )
+    answers = re.findall(pattern, full_text)
+    result = {key: 1 if value.lower() == "true" else 0 for key, value in answers}
+    return result
+
+def inference(input_text, prompt=None, typ="hf"):
+    default_prompt = """
+        Given the following historical newspaper text:
+        "{input_text}"
+        
+        Analyze the text and provide a binary classification (respond ONLY with 'true' or 'false') for each impact category based on explicit mentions in the text. Follow these specific guidelines:
+        1. ***Infrastructural Impact***: Classify as 'true' if the text mentions any damage or disruption to physical infrastructure and essential services. This includes structural damage to buildings, roads, or bridges; any disruptions to transportation systems such as railway cancellations or road closures; interruptions to public utilities including power and water supply; any failures in communication networks; or damage to industrial facilities. Consider only explicit mentions of physical damage or service disruptions in your classification.
+        2. ***Agricultural Impact***: Classify as 'true' if the text mentions any weather-related effects on farming and livestock management operations. This includes yield variations in crops and animal products; direct damage to crops, timber resources, or livestock; modifications to agricultural practices or schedules; disruptions to food production or supply chains; impacts on farming equipment and resources; or effects on agricultural inputs including soil conditions, water availability for farming, and essential materials such as seedlings, fertilizers, or animal feed.
+        3. ***Ecological Impact***: Classify as 'true' if the text mentions any effects on natural environments and ecosystems. This includes alterations to local environments and biodiversity; impacts on wildlife populations and behavior patterns; effects on non-agricultural plant life and vegetation; modifications to natural habitats including water bodies, forests, and wetlands; changes in hydrological systems such as river levels and lake conditions; or impacts on urban plant life.
+        4. ***Financial Impact***: Classify as 'true' if the text explicitly mentions economic consequences of weather events. This includes direct monetary losses; business disruptions or closures requiring financial intervention; market price fluctuations or demand changes for specific goods; impacts on tourism and local economic activities; or insurance claims or economic relief measures. Focus only on explicit mentions of financial losses or fluctuations.
+        5. ***Human Health Impact***: Classify as 'true' if the text mentions physical or mental health effects of weather events on populations. This includes direct injuries or fatalities (including cases where zero or more casualties are explicitly mentioned); elevated risks of weather-related or secondary illnesses; mental health consequences such as stress or anxiety; impacts on healthcare service accessibility; or long-term health implications.
+        6. ***Political Impact***: Classify as 'true' if the text mentions governmental and policy responses to weather events. This includes government decision-making and policy modifications in response to events; changes in public opinion or political discourse; effects on electoral processes or outcomes; international relations and aid responses; or debates surrounding disaster preparedness and response capabilities.
+        
+        Note: 
+        - Return 'false' for any impact category that is either not present in the text or not related to weather events
+        - Base classifications on explicit mentions in the text
+        - Focus on direct impacts rather than implications
+        - Consider immediate and direct effects
+
+        Answer only once in the following format:
+        Infrastructural: true/false
+        Agricultural: true/false
+        Ecological: true/false
+        Financial: true/false
+        Human Health: true/false
+        Political: true/false
+    """
+    prompt = prompt or default_prompt
+    formatted_prompt = prompt.format(input_text=input_text)
+    if typ=="gpt":
+        try:
+            response = client.chat.completions.create(
+                model=model_name,
+                messages=[
+                    {"role": "system", "content": "You are an assistant specialized in analyzing historical weather event impacts from historical newspaper."},
+                    {"role": "user", "content": prompt}
+                ],
+                temperature=0,
+                top_p=0,
+                frequency_penalty=0,
+                presence_penalty=0
+            )
+            print(response.choices[0].message.content)
+            result = response.choices[0].message.content.strip()
+        except Exception as e:
+            print(f"Error: {e}")
+    else:
+        inputs = tokenizer(formatted_prompt, return_tensors="pt").to("cuda")
+        with torch.no_grad():
+            outputs = model.generate(**inputs,max_new_tokens=120)
+        result=tokenizer.decode(outputs[0], skip_special_tokens=True)
+        result=result[len(prompt):].strip()
+
+    return result, extract_answer(result)
+
+def process_csv(input_csv, output_csv, prompt=None,typ="hf"):
+    count = 1
+    with open(output_csv, mode='w', encoding='utf-8', newline='') as csv_file:
+        fieldnames = [
+            "ID", "Date", "Time_Period", "Model_Type", "Infrastructural impact", 
+            "Agricultural impact", "Ecological impact", "Financial impact", 
+            "Human Health impact", "Political impact"
+        ]
+        writer = csv.DictWriter(csv_file, fieldnames=fieldnames)
+        writer.writeheader()
+
+        with open(input_csv, mode='r', encoding='utf-8') as input_file:
+            csv_reader = csv.DictReader(input_file)
+            for row in csv_reader:
+                original_text = row.get("Article", "")
+                date = row.get("Date", "")
+                type_row = row.get("Time_Period", "")
+                id_row = row.get("ID", "")
+
+                original_response, extracted_response = inference(original_text,typ=typ)
+
+                result = {
+                    "ID": id_row,
+                    "Date": date,
+                    "Time_Period": type_row,
+                    "Model_Type": model_name,
+                    "Infrastructural impact": extracted_response.get("Infrastructural", ""),
+                    "Agricultural impact": extracted_response.get("Agricultural", ""),
+                    "Ecological impact": extracted_response.get("Ecological", ""),
+                    "Financial impact": extracted_response.get("Financial", ""),
+                    "Human Health impact": extracted_response.get("Human Health", ""),
+                    "Political impact": extracted_response.get("Political", ""),
+                }
+
+                writer.writerow(result)
+                    
+                print(f'Finished {count}')
+                count += 1
+
+
+input_csv = "your-input.csv" # Change here for your input file name
+out_csv = "your-output.csv" # Change here for your output file name
+process_csv(input_csv,out_csv)
+print(f"Results written to {out_csv}")

QA-ranking_Task/GPT_eval.py

@@ -0,0 +1,193 @@
+import pandas as pd
+import random
+import copy
+from tqdm import tqdm
+import time
+import json
+from openai import OpenAI
+import os
+import dotenv
+import tempfile
+import numpy as np
+import pytrec_eval
+from typing import List, Dict, Any, Optional
+from dataclasses import dataclass
+from concurrent.futures import ThreadPoolExecutor
+
+dotenv.load_dotenv()
+
+@dataclass
+class RankingResult:
+    query: str
+    correct_passage: str
+    ranking: str
+    correct_idx: int
+    passages: List[str]
+    ranks: List[int]
+
+class GPTReranker:
+    def __init__(self, api_key: str, model: str = "gpt-4o"):
+        self.client = OpenAI(api_key=api_key)
+        self.model = model
+        
+    def _create_messages(self, query: str, passages: List[str], start_idx: int) -> List[Dict[str, str]]:
+        messages = [
+            {
+                "role": "system",
+                "content": "You are an expert that ranks passages based on their relevance to a given query. The most relevant passage should answer the query"
+            },
+            {
+                "role": "user",
+                "content": f"Query: {query}\n\nRank the following passages [{start_idx+1} to {start_idx+len(passages)}] by relevance."
+            }
+        ]
+        
+        for i, passage in enumerate(passages):
+            messages.extend([
+                {"role": "user", "content": f"[{start_idx+i+1}] {passage}"},
+                {"role": "assistant", "content": f"Received passage [{start_idx+i+1}]."}
+            ])
+            
+        messages.append({
+            "role": "user",
+            "content": "Provide ranking as numbers separated by '>', e.g., [3] > [1] > [2] > [5] > [4]. No explanation needed."
+        })
+        
+        return messages
+
+    def get_ranking(self, query: str, passages: List[str], start_idx: int = 0, max_retries: int = 3) -> str:
+        messages = self._create_messages(query, passages, start_idx)
+        for attempt in range(max_retries):
+            try:
+                response = self.client.chat.completions.create(
+                    model=self.model,
+                    messages=messages,
+                    temperature=0,
+                    max_tokens=150,
+                    timeout=30
+                )
+                return response.choices[0].message.content.strip()
+            except Exception as e:
+                print(f"Attempt {attempt + 1} failed: {str(e)}")
+                if attempt == max_retries - 1:
+                    raise
+                time.sleep(5)
+
+@dataclass
+class RankingResult:
+    query: str
+    correct_passage: str
+    ranking: str
+    correct_idx: int
+    passages: List[str]
+    ranks: List[int]
+
+class Evaluator:
+    @staticmethod
+    def clean_ranking_response(response: str) -> List[int]:
+        return [int(num) for num in ''.join(c if c.isdigit() else ' ' for c in response).split()]
+    
+    @staticmethod
+    def write_trec_files(results: List[RankingResult]) -> tuple[str, str]:
+        run_file = tempfile.NamedTemporaryFile(delete=False).name
+        qrels_file = tempfile.NamedTemporaryFile(delete=False).name
+        
+        with open(run_file, 'w') as f_run, open(qrels_file, 'w') as f_qrel:
+            for i, result in enumerate(results):
+                qid = str(i)
+                correct_docid = f"passage_{result.correct_idx}"
+                f_qrel.write(f"{qid} 0 {correct_docid} 1\n")
+                seen_ranks = set()
+                adjusted_ranks = []
+                
+                for rank in result.ranks:
+                    # If we've seen this rank before, increment until we find an unused rank
+                    while rank in seen_ranks:
+                        rank += 1
+                    seen_ranks.add(rank)
+                    adjusted_ranks.append(rank)
+                
+                for rank_position, passage_num in enumerate(adjusted_ranks, 1):
+                    docid = f"passage_{passage_num+1}"  # Convert to 1-based passage numbering
+                    score = 1.0/rank_position
+                    f_run.write(f"{qid} Q0 {docid} {rank_position} {score:.4f} run\n")
+                    
+        return qrels_file, run_file
+    
+    @staticmethod
+    def calculate_metrics(qrels_file: str, run_file: str) -> Dict[str, float]:
+        with open(qrels_file) as f_qrel, open(run_file) as f_run:
+            qrel = pytrec_eval.parse_qrel(f_qrel)
+            run = pytrec_eval.parse_run(f_run)
+        
+        evaluator = pytrec_eval.RelevanceEvaluator(qrel, {'ndcg_cut.1', 'ndcg_cut.5', 'ndcg_cut.10'})
+        scores = evaluator.evaluate(run)
+        
+        metrics = {'NDCG@1': 0.0, 'NDCG@5': 0.0, 'NDCG@10': 0.0}
+        for query_scores in scores.values():
+            metrics['NDCG@1'] += query_scores['ndcg_cut_1']
+            metrics['NDCG@5'] += query_scores['ndcg_cut_5']
+            metrics['NDCG@10'] += query_scores['ndcg_cut_10']
+        
+        return {k: round(v / len(scores), 4) for k, v in metrics.items()}
+    
+def process_query(row: pd.Series, reranker: GPTReranker) -> Optional[RankingResult]:
+    try:
+        query = row['query']
+        correct_passage_idx = int(row['correct_passage_index'])
+        passages = [row[f'passage_{i}'] for i in range(1, 101)]
+        
+        ranking_response = reranker.get_ranking(query, passages)
+        ranks = [i-1 for i in Evaluator.clean_ranking_response(ranking_response)]
+        
+        return RankingResult(
+            query=query,
+            correct_passage=passages[correct_passage_idx - 1],
+            ranking=ranking_response,
+            correct_idx=correct_passage_idx,
+            passages=passages,
+            ranks=ranks
+        )
+    except Exception as e:
+        print(f"Error processing query: {str(e)}")
+        return None
+
+def main():
+    api_key = os.environ.get("OPENAI_API_KEY")
+    if not api_key:
+        raise ValueError("OpenAI API key not found")
+    
+    df = pd.read_csv('./ranking/candidate_pool_query_passage.csv')
+    reranker = GPTReranker(api_key)
+
+    results = []
+    for _, row in tqdm(df.iterrows()):
+        if result := process_query(row, reranker):
+            print(f"\nQuery: {result.query}")
+            print(f"Correct index: {result.correct_idx}")
+            print(f"Ranks: {result.ranks[:10]}")  # Show first 10 ranks
+            results.append(result)
+            time.sleep(1) 
+
+    qrels_file, run_file = Evaluator.write_trec_files(results)
+    
+    print("\nQRELS file contents:")
+    with open(qrels_file, 'r') as f:
+        print(f.read())
+    
+    print("\nRun file contents:")
+    with open(run_file, 'r') as f:
+        print(f.read())
+    
+    metrics = Evaluator.calculate_metrics(qrels_file, run_file)
+    
+    print("\nEvaluation Results:")
+    for metric, score in metrics.items():
+        print(f"{metric}: {score:.4f}")
+    
+    os.unlink(qrels_file)
+    os.unlink(run_file)
+    results_df = pd.DataFrame([vars(r) for r in results])
+    results_df.to_csv('reranking_100_passages_GPT_4o.csv', index=False)
+
+main()

QA-ranking_Task/Generate_Pool.py

@@ -0,0 +1,38 @@
+import pandas as pd
+import random
+
+RANDOM_SEED = 1510
+random.seed(RANDOM_SEED)
+
+input_file = "passages_and_queries.csv"
+output_file = "query_and_100_passages.csv"
+
+data = pd.read_csv(input_file)
+output_data = []
+
+for idx, row in data.iterrows():
+    correct_passage = row['Text']
+    query = row['Generated_Query']
+
+    all_passages = data['Text'].tolist()
+    all_passages.remove(correct_passage)
+    distractors = random.sample(all_passages, 99)
+    
+    passages = distractors + [correct_passage]
+    random.shuffle(passages)
+    
+    correct_index = passages.index(correct_passage) + 1
+    
+    new_row = {
+        "id": idx + 1,
+        "query": query,
+        "correct_passage_index": correct_index
+    }
+    for i, passage in enumerate(passages):
+        new_row[f"passage_{i+1}"] = passage
+    
+    output_data.append(new_row)
+
+
+output_df = pd.DataFrame(output_data)
+output_df.to_csv(output_file, index=False)

QA-ranking_Task/Generate_Query.py

@@ -0,0 +1,76 @@
+import pandas as pd
+from openai import OpenAI
+import os
+import dotenv
+import time
+from tqdm import tqdm
+
+dotenv.load_dotenv()
+
+client = OpenAI(
+    api_key=os.environ.get("OPENAI_API_KEY")
+)
+def create_prompt(row):
+    impacts = []
+    if row['Infrastructural Impact'] > 0:
+        impacts.append('infrastructure')
+    if row['Political Impact'] > 0:
+        impacts.append('political')
+    if row['Economic Impact'] > 0:
+        impacts.append('economic')
+    if row['Ecological Impact'] > 0:
+        impacts.append('ecological')
+    if row['Agricultural Impact'] > 0:
+        impacts.append('agricultural')
+    if row['Human Health Impact'] > 0:
+        impacts.append('human health')
+    
+    impact_str = ', '.join(impacts) if impacts else 'general'
+    
+    prompt = f"""Given the following passage about {row['Weather']}, generate a specific question that:
+    1. Can be answered using ONLY the information in this passage
+    2. Focuses on the {impact_str} impacts mentioned
+    3. Is detailed and specific to this exact situation
+    4. Requires understanding the passage's unique context
+    5. Cannot be answered by other similar passages about {row['Weather']}
+
+    Passage:
+    {row['Text']}
+
+    Generate a single, focused question that meets these criteria."""
+
+    return prompt
+
+def generate_query(prompt, max_retries=3):
+    """Generate a query using GPT-4 with retry logic."""
+    for attempt in range(max_retries):
+        try:
+            response = client.chat.completions.create(
+                model="gpt-4o",
+                messages=[
+                    {"role": "system", "content": "You are a helpful assistant that generates specific, focused questions about weather-related passages. Your questions should be answerable using only the information in the given passage."},
+                    {"role": "user", "content": prompt}
+                ],
+                temperature=0.7,
+                max_tokens=400
+            )
+            return response.choices[0].message.content.strip()
+        except Exception as e:
+            if attempt == max_retries - 1:
+                print(f"Error after {max_retries} attempts: {e}")
+                return "Error generating query"
+            time.sleep(5)
+
+
+df = pd.read_csv('datasets/context_data/reranking_passage.csv')
+df['Generated_Query'] = ''
+for idx in tqdm(df.index):
+    if df.loc[idx, 'Remove'] == 0:  
+        prompt = create_prompt(df.loc[idx])
+        query = generate_query(prompt)
+        df.loc[idx, 'Generated_Query'] = query
+        time.sleep(1) 
+output_file = 'reranking_passage_with_queries.csv'
+df.to_csv(output_file, index=False)
+print(f"Results saved to {output_file}")
+

QA-ranking_Task/metrics.py

@@ -0,0 +1,131 @@
+import pandas as pd
+import random
+import copy
+from tqdm import tqdm
+import time
+import json
+from openai import OpenAI
+import os
+import dotenv
+import tempfile
+import numpy as np
+import pytrec_eval
+from typing import List, Dict, Any, Optional
+from dataclasses import dataclass
+from concurrent.futures import ThreadPoolExecutor
+
+dotenv.load_dotenv()
+
+@dataclass
+class RankingResult:
+    query: str
+    correct_passage: str
+    ranking: str
+    correct_idx: int
+    passages: List[str]
+    ranks: List[int]
+
+class Evaluator:
+    @staticmethod
+    def clean_ranking_response(response: str) -> List[int]:
+        return [int(num) for num in ''.join(c if c.isdigit() else ' ' for c in response).split()]
+    
+    @staticmethod
+    def write_trec_files(results: List[RankingResult]) -> tuple[str, str]:
+        run_file = tempfile.NamedTemporaryFile(delete=False).name
+        qrels_file = tempfile.NamedTemporaryFile(delete=False).name
+        
+        with open(run_file, 'w') as f_run, open(qrels_file, 'w') as f_qrel:
+            for i, result in enumerate(results):
+                qid = str(i)
+                correct_docid = f"passage_{result.correct_idx}"
+                f_qrel.write(f"{qid} 0 {correct_docid} 1\n")
+                seen_ranks = set()
+                adjusted_ranks = []
+                
+                for rank in result.ranks:
+                    while rank in seen_ranks:
+                        rank += 1
+                    seen_ranks.add(rank)
+                    adjusted_ranks.append(rank)
+                
+                for rank_position, passage_num in enumerate(adjusted_ranks, 1):
+                    docid = f"passage_{passage_num+1}"  # Convert to 1-based passage numbering
+                    score = 1.0/rank_position
+                    f_run.write(f"{qid} Q0 {docid} {rank_position} {score:.4f} run\n")
+                    
+        return qrels_file, run_file
+    
+    @staticmethod
+    def calculate_metrics(qrels_file: str, run_file: str) -> Dict[str, float]:
+        with open(qrels_file) as f_qrel, open(run_file) as f_run:
+            qrel = pytrec_eval.parse_qrel(f_qrel)
+            run = pytrec_eval.parse_run(f_run)
+        
+        evaluator = pytrec_eval.RelevanceEvaluator(
+            qrel, 
+            {'ndcg_cut.1', 'ndcg_cut.5', 'ndcg_cut.10', 'recip_rank', 'recall.5'}
+        )
+        scores = evaluator.evaluate(run)
+        
+        metrics = {
+            'NDCG@1': 0.0, 
+            'NDCG@5': 0.0, 
+            'NDCG@10': 0.0,
+            'MRR': 0.0,
+            'Recall@5': 0.0
+        }
+        
+        for query_scores in scores.values():
+            metrics['NDCG@1'] += query_scores['ndcg_cut_1']
+            metrics['NDCG@5'] += query_scores['ndcg_cut_5']
+            metrics['NDCG@10'] += query_scores['ndcg_cut_10']
+            metrics['MRR'] += query_scores['recip_rank']
+            metrics['Recall@5'] += query_scores['recall_5']
+        
+        num_queries = len(scores)
+        return {k: round(v / num_queries, 4) for k, v in metrics.items()}
+    
+
+def load_results(filename: str) -> List[RankingResult]:
+    with open(filename, 'r', encoding='utf-8') as f:
+        results_data = json.load(f)
+    
+    results = []
+    for data in results_data:
+        result = RankingResult(
+            query=data['query'],
+            correct_passage=data['correct_passage'],
+            ranking=data['ranking'],
+            correct_idx=data['correct_idx'],
+            passages=data['passages'],
+            ranks=data['ranks']
+        )
+        results.append(result)
+    
+    return results
+
+def main():
+    loaded_results = load_results('./your-output.json') # Change here when you have your output from QA ranking json
+    qrels_file, run_file = Evaluator.write_trec_files(loaded_results)
+    
+    print("\nQRELS file contents:")
+    with open(qrels_file, 'r') as f:
+        print(f.read())
+    
+    print("\nRun file contents:")
+    with open(run_file, 'r') as f:
+        print(f.read())
+    
+    metrics = Evaluator.calculate_metrics(qrels_file, run_file)
+    
+    print("\nEvaluation Results:")
+    for metric, score in metrics.items():
+        print(f"{metric}: {score:.4f}")
+    
+    os.unlink(qrels_file)
+    os.unlink(run_file)
+    results_df = pd.DataFrame([vars(r) for r in loaded_results])
+    results_df.to_csv('ranking-results.csv', index=False) # Change here to save your final results
+    
+main()

QA-ranking_Task/model_eval.py

@@ -0,0 +1,205 @@
+import pandas as pd
+import random
+import copy
+from tqdm import tqdm
+import time
+import json
+from openai import OpenAI
+import os
+import dotenv
+import tempfile
+import numpy as np
+
+from typing import List, Dict, Any, Optional
+from dataclasses import dataclass
+from concurrent.futures import ThreadPoolExecutor
+from huggingface_hub import login
+from transformers import AutoModelForCausalLM, AutoTokenizer
+dotenv.load_dotenv()
+
+API_KEY = ""
+login(token=API_KEY)
+huggingface_models=["meta-llama/Llama-3.1-8B-Instruct","Qwen/Qwen2.5-7B-Instruct","Qwen/Qwen2.5-14B-Instruct","Qwen/Qwen2.5-7B-Instruct"]
+model_name = "Model_name" # Change here for testing your model
+
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+
+class GPTReranker:
+    def __init__(self, api_key: str, model_name: str = model_name, window_size: int = 30, overlap: int = 10):
+        if window_size <= overlap:
+            raise ValueError("Window size must be greater than overlap")
+        if overlap < 0:
+            raise ValueError("Overlap must be non-negative")
+            
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = AutoModelForCausalLM.from_pretrained(
+            model_name,
+            torch_dtype=torch.float16,
+            device_map="auto"
+        )
+        self.model.gradient_checkpointing_enable()
+        self.model.eval()  # Set to evaluation mode
+        
+        self.window_size = window_size
+        self.overlap = overlap
+        
+    def _create_messages(self, query: str, passages: List[str], start_idx: int) -> str:
+        prompt = f"""<s>[INST] You are an expert that ranks passages based on their relevance to a given query. 
+The most relevant passage should be ranked first. 
+Important: Do not just sort the passage numbers. Evaluate each passage's content for relevance.
+
+Query: {query}
+
+I will give you passages numbered from {start_idx+1} to {start_idx+len(passages)}. Rank them by relevance to the query, with the most relevant first.
+
+"""
+        for i, passage in enumerate(passages):
+            prompt += f"[{start_idx+i+1}] {passage}\n"
+        
+        prompt += """
+Based on the content of each passage (not just their numbers), rank them from most to least relevant. 
+Format: [most_relevant] > [next] > [next]. No explanation needed.[/INST]"""
+        
+        return prompt
+
+    def get_ranking_for_group(self, query: str, passages: List[str], start_idx: int = 0, max_retries: int = 3) -> List[int]:
+        prompt = self._create_messages(query, passages, start_idx)
+        
+        for attempt in range(max_retries):
+            try:
+                inputs = self.tokenizer(prompt, return_tensors="pt").to(self.model.device)
+                
+                with torch.no_grad():
+                    outputs = self.model.generate(
+                        **inputs,
+                        max_new_tokens=150,
+                        temperature=0.0,
+                        do_sample=False,
+                        pad_token_id=self.tokenizer.eos_token_id
+                    )
+                ranking_str = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+                ranking_str = ranking_str[len(prompt):]
+                
+                raw_ranks = Evaluator.clean_ranking_response(ranking_str)
+                global_ranks = []
+                for rank in raw_ranks:
+                    local_idx = rank - (start_idx + 1)
+                    if 0 <= local_idx < len(passages):
+                        global_idx = start_idx + local_idx
+                        global_ranks.append(global_idx)
+                
+                return global_ranks
+                
+            except Exception as e:
+                print(f"Attempt {attempt + 1} failed: {str(e)}")
+                if attempt == max_retries - 1:
+                    raise
+                time.sleep(5)
+
+    def get_ranking(self, query: str, passages: List[str]) -> str:
+        if not passages:
+            raise ValueError("No passages provided")
+        
+        first_group = passages[:40]
+        second_group = passages[40:80]
+        third_group = passages[80:]
+        
+        first_ranks = self.get_ranking_for_group(query, first_group, 0)
+        print(f"First group top 10: {first_ranks[:10]}")
+        second_ranks = self.get_ranking_for_group(query, second_group, 40)
+        print(f"Second group top 10: {second_ranks[:10]}")
+        third_ranks = self.get_ranking_for_group(query, third_group, 80)
+        print(f"Third group top 10: {third_ranks[:10]}")
+        
+        top_30_indices = []
+        if first_ranks:
+            top_30_indices.extend(first_ranks[:10])
+        if second_ranks:
+            top_30_indices.extend(second_ranks[:10])
+        if third_ranks:
+            top_30_indices.extend(third_ranks[:10])
+        top_30_passages = [passages[i] for i in top_30_indices]
+        
+        final_local_ranks = self.get_ranking_for_group(query, top_30_passages, 0)
+        
+        final_indices = []
+        for rank in final_local_ranks:
+            if rank < len(top_30_indices):
+                final_indices.append(top_30_indices[rank])
+        
+        remaining_top = [idx for idx in top_30_indices if idx not in final_indices]
+        final_indices.extend(remaining_top)
+        
+        all_other_indices = [i for i in range(len(passages)) if i not in top_30_indices]
+        final_indices.extend(all_other_indices)
+        
+        ranking_str = " > ".join(f"[{r+1}]" for r in final_indices)
+        return ranking_str
+@dataclass
+class RankingResult:
+    query: str
+    correct_passage: str
+    ranking: str
+    correct_idx: int
+    passages: List[str]
+    ranks: List[int]
+
+class Evaluator:
+    @staticmethod
+    def clean_ranking_response(response: str) -> List[int]:
+        return [int(num) for num in ''.join(c if c.isdigit() else ' ' for c in response).split()]
+
+def process_query(row: pd.Series, reranker: GPTReranker) -> Optional[RankingResult]:
+    try:
+        query = row['query']
+        correct_passage_idx = int(row['correct_passage_index'])
+        passages = [row[f'passage_{i}'] for i in range(1, 101)]
+        
+        ranking_response = reranker.get_ranking(query, passages)
+        ranks = [i-1 for i in Evaluator.clean_ranking_response(ranking_response)]
+        
+        return RankingResult(
+            query=query,
+            correct_passage=passages[correct_passage_idx - 1],
+            ranking=ranking_response,
+            correct_idx=correct_passage_idx,
+            passages=passages,
+            ranks=ranks
+        )
+    except Exception as e:
+        print(f"Error processing query: {str(e)}")
+        return None
+
+def save_results(results: List[RankingResult], filename: str):
+    results_data = []
+    for result in results:
+        results_data.append({
+            'query': result.query,
+            'correct_passage': result.correct_passage,
+            'ranking': result.ranking,
+            'correct_idx': result.correct_idx,
+            'passages': result.passages,
+            'ranks': result.ranks
+        })
+    
+    with open(filename, 'w', encoding='utf-8') as f:
+        json.dump(results_data, f, ensure_ascii=False, indent=2)
+
+
+def main():
+    df = pd.read_csv('./datasets/QACandidate_Pool.csv')
+    reranker = GPTReranker(API_KEY)
+    results = []
+    for _, row in tqdm(df.iterrows()):
+        if result := process_query(row, reranker):
+            print(f"\nQuery: {result.query}") # Show the query sentence
+            print(f"Correct index: {result.correct_idx}") # Show the correct index
+            print(f"Ranks: {result.ranks[:10]}")  # Show first 10 ranks
+            results.append(result)
+            time.sleep(1) 
+
+            save_results(results, 'output.json') # Change here for your output file name
+            time.sleep(1)
+    
+main()

datasets/QACandidate_Pool.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9f04bd606ccd1b4f4aafd8879f7e0a51f01ab0514604a820413363e0d117cb22
+size 36352782