fix: Information Integration evaluation - handle multiple answer variants with pipe-separated format

src/data_loader.py

@@ -83,10 +83,26 @@ class RGBDataLoader:
         return data
     
     def _format_answer(self, answer: Any) -> str:
-        """Format answer to string for comparison."""
+        """
+        Format answer to string for comparison.
+        For nested lists (information integration), flatten to list of alternatives.
+        For simple lists (noise robustness), take first or join.
+        """
         if isinstance(answer, list):
-            # Join list answers with comma
-            return ", ".join(str(a) for a in answer)
+            # Check if it's a nested list (from en_int.json with answer variants)
+            if answer and isinstance(answer[0], list):
+                # Flatten nested list: [['variant1', 'variant2'], 'other_answer'] → all variants
+                variants = []
+                for item in answer:
+                    if isinstance(item, list):
+                        variants.extend(item)
+                    else:
+                        variants.append(str(item))
+                # Return as pipe-separated alternatives for matching
+                return "|".join(variants)
+            else:
+                # Simple list: join with pipe as alternatives
+                return "|".join(str(a) for a in answer)
         return str(answer)
     
     def load_noise_robustness(

src/evaluator.py

@@ -143,6 +143,7 @@ class RGBEvaluator:
         """
         Normalize an answer for comparison.
         Removes punctuation, extra whitespace, and converts to lowercase.
+        Also removes commas from dates for consistent matching.
         """
         if not answer:
             return ""
@@ -153,6 +154,9 @@ class RGBEvaluator:
         # Remove common punctuation at the end
         answer = re.sub(r'[.!?,;:]+$', '', answer)
         
+        # Remove all commas within the text (helps with date matching like "Jan, 2, 2022" -> "jan 2 2022")
+        answer = answer.replace(',', '')
+        
         # Remove extra whitespace
         answer = ' '.join(answer.split())
         
@@ -187,19 +191,54 @@ class RGBEvaluator:
     def is_correct(self, response: str, ground_truth: str, strict: bool = False) -> bool:
         """
         Check if the response matches the ground truth answer.
+        Supports pipe-separated alternatives (for information integration with variants).
         
         Args:
             response: The model's response.
-            ground_truth: The correct answer.
+            ground_truth: The correct answer (can be pipe-separated alternatives).
             strict: If True, requires exact match. If False, allows partial match.
             
         Returns:
             True if the answer is correct, False otherwise.
         """
         norm_response = self.normalize_answer(response)
+        
+        if not norm_response:
+            return False
+        
+        # Handle pipe-separated alternatives (information integration with answer variants)
+        if "|" in ground_truth:
+            alternatives = [self.normalize_answer(alt.strip()) for alt in ground_truth.split("|")]
+            # Check if response matches ANY of the alternatives
+            for alternative in alternatives:
+                if not alternative:
+                    continue
+                
+                # Check each matching strategy for this alternative
+                if strict:
+                    if norm_response == alternative:
+                        return True
+                else:
+                    # Substring match
+                    if alternative in norm_response:
+                        return True
+                    # Short answer in long answer
+                    if len(norm_response) < len(alternative) and norm_response in alternative:
+                        return True
+                    # Token overlap
+                    truth_tokens = set(alternative.split())
+                    response_tokens = set(norm_response.split())
+                    if len(truth_tokens) > 0:
+                        overlap = len(truth_tokens & response_tokens) / len(truth_tokens)
+                        if overlap >= 0.8:
+                            return True
+            
+            return False
+        
+        # Single answer (original logic)
         norm_truth = self.normalize_answer(ground_truth)
         
-        if not norm_response or not norm_truth:
+        if not norm_truth:
             return False
         
         if strict: