Integer type question evaluation fixed

data/metadata.jsonl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:da12c6171e65130835ea5f3985bc1d144548c2c0b114614e472c542b3199d1ce
-size 130971
+oid sha256:8f388b32c0d64c519aebdd23349f51f9bd9ae96977d26a2cb8a9d00192224cec
+size 130978

jee-neet-benchmark.py

@@ -63,7 +63,7 @@ class JeeNeetBenchmark(datasets.GeneratorBasedBuilder):
                 "exam_code": datasets.Value("string"), # Will provide default if missing in source
                 "subject": datasets.Value("string"),
                 "question_type": datasets.Value("string"),
-                "correct_answer": datasets.Sequence(datasets.Value("string")), # List of strings
+                "correct_answer": datasets.Value("string"), # Store as JSON string
             }
         )
         return datasets.DatasetInfo(
@@ -163,5 +163,5 @@ class JeeNeetBenchmark(datasets.GeneratorBasedBuilder):
                     "exam_code": row.get("exam_code", "N/A"), # Provide "N/A" if exam_code is missing
                     "subject": row.get("subject", ""),
                     "question_type": row.get("question_type", ""),
-                    "correct_answer": row.get("correct_answer", []),
+                    "correct_answer": json.dumps(row.get("correct_answer", [])),
                 }

src/benchmark_runner.py

@@ -295,7 +295,7 @@ def run_benchmark(
         # Explicitly specify data_files and data_dir for local loading.
         # data_dir should be the project root ('.') when loading a local script,
         # as the script is copied to a cache and needs to know where the actual data is.
-        dataset = load_dataset(dataset_path, split='test', data_files={'test': 'data/metadata.jsonl'}, data_dir=os.getcwd(), trust_remote_code=True)
+        dataset = load_dataset(dataset_path, split='test', data_files={'test': 'data/metadata.jsonl'}, data_dir=os.getcwd(), trust_remote_code=True, download_mode="force_redownload")
         dataset = dataset.cast_column("image", HFImage(decode=True)) # Ensure images are loaded as PIL
         logging.info(f"Dataset loaded successfully from path: {dataset_path}. Original number of questions: {len(dataset)}")
     except Exception as e:
@@ -390,7 +390,7 @@ def run_benchmark(
             exam_name_from_data = example.get("exam_name", "UNKNOWN_EXAM") # Get exam_name from data
             question_type_from_data = example.get("question_type", "MCQ_SINGLE_CORRECT") # Get question_type
             image: PILImage.Image = example["image"]
-            truth = example["correct_answer"]
+            truth = json.loads(example["correct_answer"]) # Parse the JSON string back to a list/list of lists
 
             result_data = {
                 "question_id": question_id,

src/evaluation.py

@@ -69,6 +69,21 @@ def get_subject_as_section(subject: str, question_num_for_log: int) -> Optional[
         logging.warning(f"Invalid or missing subject ('{subject}') for question_num '{question_num_for_log}'. Cannot determine section.")
         return None
 
+def is_within_range(predicted_value_str: str, lower_bound_str: str, upper_bound_str: str) -> bool:
+    """
+    Checks if a predicted numerical value (as a string) falls within a specified range.
+    The comparison is inclusive.
+    """
+    try:
+        predicted_value = float(predicted_value_str)
+        lower_bound = float(lower_bound_str)
+        upper_bound = float(upper_bound_str)
+    except ValueError:
+        logging.debug(f"Could not convert predicted value '{predicted_value_str}' or bounds ('{lower_bound_str}', '{upper_bound_str}') to numbers.")
+        return False
+
+    return lower_bound <= predicted_value <= upper_bound
+
 
 def calculate_single_question_score_details(result_item: Dict[str, Any]) -> Dict[str, Any]:
     """
@@ -99,25 +114,23 @@ def calculate_single_question_score_details(result_item: Dict[str, Any]) -> Dict
     # Ensure truth is a set of uppercase strings for consistent processing.
     # Ground truth from metadata.jsonl is expected to be a list of strings.
     # e.g., ["1"], ["A"], ["12.75"], ["A", "C"]
-    truth_set: set
-    if isinstance(truth, str): 
-        # This case might occur if metadata had a single string instead of list for some reason,
-        # or if an old format slips through. Convert to a set of one uppercase string.
-        logging.warning(f"Ground truth for {question_id} is a single string: '{truth}'. Converting to set.")
-        truth_set = {truth.upper()}
-    elif isinstance(truth, list) and all(isinstance(t, str) for t in truth): 
-        truth_set = {s.upper() for s in truth}
-    # Deprecated int/List[int] handling, as metadata should now be List[str]
-    elif isinstance(truth, list) and any(isinstance(t, int) for t in truth): 
-        logging.warning(f"Ground truth for {question_id} contains integers: {truth}. Converting all to strings.")
-        truth_set = {str(s).upper() for s in truth}
-    elif isinstance(truth, int): 
-        logging.warning(f"Ground truth for {question_id} is int: {truth}. Converting to string set.")
-        truth_set = {str(truth).upper()}
+    # For integer ranges, it will be like [["0.7", "0.8"]]
+    truth_processed: List[Union[str, List[str]]] = []
+    if isinstance(truth, list):
+        for t_item in truth:
+            if isinstance(t_item, str):
+                truth_processed.append(t_item.upper())
+            elif isinstance(t_item, list) and len(t_item) == 2 and all(isinstance(x, str) for x in t_item):
+                truth_processed.append([x.upper() for x in t_item]) # Store range as list of uppercase strings
+            else:
+                logging.error(f"Invalid item in ground_truth list for {question_id}: {t_item}. Skipping.")
+    elif isinstance(truth, str):
+        truth_processed.append(truth.upper())
     else:
         logging.error(f"Invalid ground_truth format for {question_id}: {truth} (type: {type(truth)}). Assigning 0 marks.")
         return {"marks_awarded": 0, "evaluation_status": "error_bad_ground_truth"}
 
+
     if not api_success or pred is None: # pred is None means our internal parsing failed
         evaluation_status = "failure_api_or_parse"
         current_score_change = -1
@@ -140,7 +153,8 @@ def calculate_single_question_score_details(result_item: Dict[str, Any]) -> Dict
             is_correct = False
             if len(pred_set) == 1: # Ensure prediction is indeed a single option
                 single_pred_answer = list(pred_set)[0] # Get the single predicted option
-                if single_pred_answer in truth_set: # Check if this predicted option is in the set of true answers
+                # Check against all processed truths (which are single strings for MCQ)
+                if single_pred_answer in truth_processed: 
                     is_correct = True
             
             if is_correct:
@@ -157,23 +171,49 @@ def calculate_single_question_score_details(result_item: Dict[str, Any]) -> Dict
                 else: current_score_change = 0 # Default no penalty
 
         elif exam_name == "JEE_MAIN" and question_type == "INTEGER": # Integer answers are now strings in a list e.g. ["14"]
-            if len(pred_set) == 1 and list(pred_set)[0] in truth_set: # Compare the single string prediction
+            # For JEE_MAIN INTEGER, we expect truth_processed to contain single strings
+            is_correct = False
+            if len(pred_set) == 1:
+                predicted_answer_str = list(pred_set)[0]
+                if predicted_answer_str in truth_processed: # Check against single string truths
+                    is_correct = True
+            
+            if is_correct:
                 current_score_change = 4; evaluation_status = "correct"
             else:
                 current_score_change = 0; evaluation_status = "incorrect"
         
         elif exam_name == "JEE_ADVANCED":
             # Note: MCQ_SINGLE_CORRECT for JEE_ADVANCED is handled by the common block above
-            if question_type == "INTEGER": # Integer answers are now strings in a list e.g. ["12"]
-                if len(pred_set) == 1 and list(pred_set)[0] in truth_set: # Compare the single string prediction
+            if question_type == "INTEGER":
+                is_correct = False
+                if len(pred_set) == 1:
+                    predicted_answer_str = list(pred_set)[0] # Get the single predicted string
+
+                    # Iterate through each ground truth entry in the 'truth_processed' list
+                    for gt_entry in truth_processed:
+                        if isinstance(gt_entry, list) and len(gt_entry) == 2: # This is a range [lower, upper]
+                            lower_bound_str, upper_bound_str = gt_entry[0], gt_entry[1]
+                            if is_within_range(predicted_answer_str, lower_bound_str, upper_bound_str):
+                                is_correct = True
+                                break # Found a matching range, no need to check others
+                        elif isinstance(gt_entry, str): # This is an exact integer match
+                            if predicted_answer_str == gt_entry: # gt_entry is already uppercase
+                                is_correct = True
+                                break # Found an exact match, no need to check others
+                
+                if is_correct:
                     current_score_change = 4; evaluation_status = "correct"
                 else:
                     current_score_change = 0; evaluation_status = "incorrect"
             elif question_type == "MCQ_MULTIPLE_CORRECT":
-                num_correct_options_in_truth = len(truth_set)
+                # For MCQ_MULTIPLE_CORRECT, truth_processed contains single strings
+                truth_set_mcq = set(truth_processed) # Convert to set for intersection operations
+
+                num_correct_options_in_truth = len(truth_set_mcq)
                 num_chosen_options = len(pred_set)
-                correct_chosen_options = pred_set.intersection(truth_set)
-                incorrect_chosen_options = pred_set.difference(truth_set)
+                correct_chosen_options = pred_set.intersection(truth_set_mcq)
+                incorrect_chosen_options = pred_set.difference(truth_set_mcq)
                 num_correct_chosen = len(correct_chosen_options)
                 num_incorrect_chosen = len(incorrect_chosen_options)