implement viewpoint filter for Controller and Non-controllers

bordirlines.py

@@ -1,4 +1,5 @@
 import json
+from copy import copy
 from functools import lru_cache
 
 import datasets
@@ -58,6 +59,7 @@ SUPPORTED_LANGUAGES = [
 ]
 SYSTEMS = ["openai", "m3"]
 MODES = ["qlang", "qlang_en", "en", "rel_langs"]
+RELEVANCE_FILTERS = ["all", "relevant", "non-relevant"]
 # # get combination of systems and supported modes
 # SUPPORTED_SOURCES = [f"{system}.{mode}" for system in SYSTEMS for mode in MODES]
 
@@ -83,6 +85,15 @@ def replace_lang_str(path, lang):
     return f"{parent}/{lang}/{lang}_docs.json"
 
 
+def get_label(human_bool, llm_bool, annotation_type):
+    if annotation_type == "human":
+        return human_bool
+    elif annotation_type == "llm":
+        return llm_bool
+    else:
+        return human_bool if human_bool is not None else llm_bool
+
+
 class BordIRLinesDataset(datasets.GeneratorBasedBuilder):
     VERSION = datasets.Version("1.0.0")
 
@@ -95,14 +106,22 @@ class BordIRLinesDataset(datasets.GeneratorBasedBuilder):
         for lang in SUPPORTED_LANGUAGES
     ]
 
-    def __init__(self, *args, relevance_filter="all", annotation_type=None, llm_mode="fewshot", viewpoint_filter=None, **kwargs):
+    def __init__(
+        self,
+        *args,
+        relevance_filter="all",
+        annotation_type=None,
+        llm_mode="fewshot",
+        viewpoint_filter=None,
+        **kwargs,
+    ):
         super().__init__(*args, **kwargs)
-        self.relevance_filter = relevance_filter  # "relevant", "non-relevant", or "all"
+        self.relevance_filter = relevance_filter
+        assert self.relevance_filter in RELEVANCE_FILTERS
         self.annotation_type = annotation_type
         self.llm_mode = llm_mode  # Default to "fewshot"
         self.viewpoint_filter = viewpoint_filter  # Filter for a specific viewpoint
 
-
     def _info(self):
         return datasets.DatasetInfo(
             description="IR Dataset for BordIRLines paper.",
@@ -129,7 +148,9 @@ class BordIRLinesDataset(datasets.GeneratorBasedBuilder):
         base_url = self.config.data_root_dir
         queries_path = f"{base_url}/queries.tsv"
         docs_path = dl_manager.download_and_extract(f"{base_url}/all_docs.json")
-        human_annotations_path = dl_manager.download_and_extract(f"{base_url}/human_annotations.tsv")
+        human_annotations_path = dl_manager.download_and_extract(
+            f"{base_url}/human_annotations.tsv"
+        )
         llm_annotations_path = dl_manager.download_and_extract(f"{base_url}/llm_annotations.tsv")
 
         lang = self.config.language
@@ -164,11 +185,12 @@ class BordIRLinesDataset(datasets.GeneratorBasedBuilder):
 
         return splits
 
-    def _generate_examples(self, hits_path, docs_path, queries_path, human_annotations_path, llm_annotations_path):
+    def _generate_examples(
+        self, hits_path, docs_path, queries_path, human_annotations_path, llm_annotations_path
+    ):
         n_hits = self.config.n_hits
-        queries_df = pd.read_csv(queries_path, sep="\t")
-        query_map = dict(zip(queries_df["query_id"], queries_df["query_text"]))
-        query_to_lang_map = dict(zip(queries_df["query_id"], queries_df["language"]))
+        queries_df = pd.read_csv(queries_path, sep="\t").set_index("query_id")
+        queries_df["Claimants"] = queries_df["Claimants"].str.split(";").map(set)
         counter = 0
 
         docs = load_json(docs_path)
@@ -176,7 +198,7 @@ class BordIRLinesDataset(datasets.GeneratorBasedBuilder):
         hits = pd.read_csv(hits_path, sep="\t")
         human_annotations = pd.read_csv(human_annotations_path, sep="\t")
         llm_annotations = pd.read_csv(llm_annotations_path, sep="\t")
-        
+
         if n_hits:
             hits = hits.groupby("query_id").head(n_hits)
 
@@ -192,40 +214,62 @@ class BordIRLinesDataset(datasets.GeneratorBasedBuilder):
             doc_id = row["doc_id"]
             doc_lang = row["doc_lang"]
             query_id = row["query_id"]
-            query_text = query_map[query_id]
-            query_lang = query_to_lang_map[query_id]
+            query_entry = queries_df.loc[query_id]
+            query_text = query_entry["query_text"]
+            query_lang = query_entry["language"]
 
             # Get Human Data
             human_data = human_map.get((query_id, doc_id), {})
 
-            relevant_human = human_data.get("relevant", False)
-            viewpoint_human = human_data.get("territory", "")
+            relevant_human = human_data.get("relevant", None)
+            viewpoint_human = human_data.get("territory", None)
 
             # Get LLM Data
             llm_data = llm_map.get((query_id, doc_id), {})
             relevant_llm = (
-                llm_data.get("relevant_fewshot", None)
+                llm_data["relevant_fewshot"]
                 if self.llm_mode == "fewshot"
-                else llm_data.get("relevant_zeroshot", None)
+                else llm_data["relevant_zeroshot"]
             )
-            viewpoint = viewpoint_human
-            if self.viewpoint_filter and self.viewpoint_filter not in viewpoint:
-                continue  
-            # Filtering logic based on relevance preference
-            if self.relevance_filter == "relevant":
-                if self.annotation_type == "human" and not relevant_human:
+            viewpoint_llm = (
+                llm_data["territory_fewshot"]
+                if self.llm_mode == "fewshot"
+                else llm_data["territory_zeroshot"]
+            )
+
+            # Filtering logic based on viewpoint preference
+            viewpoint_llm = viewpoint_llm.split(") ", 1)[-1] if not pd.isna(viewpoint_llm) else None
+
+            viewpoint = get_label(viewpoint_human, viewpoint_llm, self.annotation_type)
+            if viewpoint is None:
+                continue
+
+            if self.viewpoint_filter == "Non-controllers":
+                controller = query_entry["Controller"]
+                if controller == "Unknown":
                     continue
-                elif self.annotation_type == "llm" and not (relevant_llm is True):
+                claimants = copy(query_entry["Claimants"])
+                claimants.remove(controller)
+                if not len(claimants) or viewpoint not in claimants:
                     continue
-                elif not relevant_human and not (relevant_llm is True):
+            else:
+                if self.viewpoint_filter == "Controller":
+                    controller = query_entry["Controller"]
+                    target_viewpoint = controller
+                else:
+                    target_viewpoint = self.viewpoint_filter
+
+                if target_viewpoint and viewpoint != target_viewpoint:
                     continue
 
-            elif self.relevance_filter == "non-relevant":
-                if self.annotation_type == "human" and relevant_human:
-                    continue
-                elif self.annotation_type == "llm" and relevant_llm is True:
+            # Filtering logic based on relevance preference
+            relevant = get_label(relevant_human, relevant_llm, self.annotation_type)
+            if self.relevance_filter == "relevant":
+                if not relevant:
                     continue
-                elif relevant_human or relevant_llm is True:
+
+            elif self.relevance_filter == "non-relevant":
+                if relevant:
                     continue
 
             # If "all", do not filter anything
@@ -244,8 +288,8 @@ class BordIRLinesDataset(datasets.GeneratorBasedBuilder):
                     "doc_lang": doc_lang,
                     "relevant_human": relevant_human,
                     "viewpoint": viewpoint,
-                    "relevant_llm_zeroshot": llm_data.get("relevant_zeroshot", None),
-                    "relevant_llm_fewshot": llm_data.get("relevant_fewshot", None),
+                    "relevant_llm_zeroshot": llm_data["relevant_zeroshot"],
+                    "relevant_llm_fewshot": llm_data["relevant_fewshot"],
                 },
             )
             counter += 1