bug fix

absa_evaluator.py

@@ -171,29 +171,42 @@ class AbsaEvaluator(evaluate.Metric):
             "relevant": relevant,
         }
         
-def adjust_predictions(refs, preds, choices):
+def adjust_predictions(
+    refs: List[List[Any]], preds: List[List[Any]], choices: List[Any]
+) -> List[List[Any]]:
     """Adjust predictions to match the length of references with either a special token or random choice."""
     adjusted_preds = []
     for ref, pred in zip(refs, preds):
         if len(pred) < len(ref):
             missing_count = len(ref) - len(pred)
             pred.extend([choice(choices) for _ in range(missing_count)])
+        elif len(pred) > len(ref):
+            pred = pred[:len(ref)]
         adjusted_preds.append(pred)
     return adjusted_preds
 
 
-def extract_aspects(data, specific_key, specific_val):
+def extract_aspects(
+    data: List[Dict[str, Dict[str, Any]]], specific_key: str, specific_val: str
+) -> List[List[Any]]:
     """Extracts and returns a list of specified aspect details from the nested 'aspects' data."""
     return [item[specific_key][specific_val] for item in data]
 
 
-def absa_term_preprocess(references, predictions, subtask_key, subtask_value):
+def absa_term_preprocess(
+    references: List[Dict[str, Any]],
+    predictions: List[Dict[str, Any]],
+    subtask_key: str,
+    subtask_value: str,
+) -> Tuple[List[str], List[str], List[str], List[str]]:
     """
     Preprocess the terms and polarities for aspect-based sentiment analysis.
 
     Args:
         references (List[Dict]): A list of dictionaries containing the actual terms and polarities under 'aspects'.
         predictions (List[Dict]): A list of dictionaries containing predicted aspect categories to terms and their sentiments.
+        subtask_key (str): The key under which aspects are stored.
+        subtask_value (str): The specific aspect value to extract.
 
     Returns:
         Tuple[List[str], List[str], List[str], List[str]]: A tuple containing lists of true aspect terms,
@@ -208,12 +221,7 @@ def absa_term_preprocess(references, predictions, subtask_key, subtask_value):
 
     # Define adjustment parameters
     special_token = "NONE"  # For missing aspect terms
-    sentiment_choices = [
-        "positive",
-        "negative",
-        "neutral",
-        "conflict",
-    ]  # For missing polarities
+    sentiment_choices = unique_strings(flatten_list(truth_polarities))    
 
     # Adjust the predictions to match the length of references
     adjusted_pred_terms = adjust_predictions(
@@ -235,48 +243,20 @@ def flatten_list(nested_list):
     """Flatten a nested list into a single-level list."""
     return list(chain.from_iterable(nested_list))
 
+def unique_strings(strings: List[str]) -> List[str]:
+    """
+    Convert a list of strings to a list of unique strings, preserving the original order.
 
-def extract_pred_terms(
-    all_predictions: List[Dict[str, Dict[str, str]]]
-) -> List[List]:
-    """Extract and organize predicted terms from the sentiment analysis results."""
-    pred_aspect_terms = []
-    for pred in all_predictions:
-        terms = [term for cat in pred.values() for term in cat.keys()]
-        pred_aspect_terms.append(terms)
-    return pred_aspect_terms
-
-
-def merge_aspects_and_categories(aspects, categories):
-    result = []
-
-    # Assuming both lists are of the same length and corresponding indices match
-    for aspect, category in zip(aspects, categories):
-        combined_entry = {
-            "aspects": {"term": [], "polarity": []},
-            "category": {"category": [], "polarity": []},
-        }
-
-        # Process aspect entries
-        for cat_key, terms_dict in aspect.items():
-            for term, polarity in terms_dict.items():
-                combined_entry["aspects"]["term"].append(term)
-                combined_entry["aspects"]["polarity"].append(polarity)
-
-                # Add category details based on the aspect's key if available in categories
-                if cat_key in category:
-                    combined_entry["category"]["category"].append(cat_key)
-                    combined_entry["category"]["polarity"].append(
-                        category[cat_key]
-                    )
-
-        # Ensure all keys in category are accounted for
-        for cat_key, polarity in category.items():
-            if cat_key not in combined_entry["category"]["category"]:
-                combined_entry["category"]["category"].append(cat_key)
-                combined_entry["category"]["polarity"].append(polarity)
-
-        result.append(combined_entry)
-
-    return result
+    Args:
+        strings (List[str]): The input list of strings.
 
+    Returns:
+        List[str]: A list of unique strings in the order of their first occurrence.
+    """
+    seen = set()
+    unique_list = []
+    for string in strings:
+        if string not in seen:
+            seen.add(string)
+            unique_list.append(string)
+    return unique_list