"""Simple ICL task implementation with category-based demonstrations.""" from typing import Dict, List, Any import pandas as pd from ..base_task import BaseTask, TaskConfig class SimpleICLTask(BaseTask): """Task for simple in-context learning with category-based demonstrations.""" TASK_NAME = "simple_icl" # Auto-registration name # Categories whose correct answer is always exactly one character. # Scoring for these is lenient: we extract the first alphabetic char # from the model's output so that verbose responses like # "The first letter is t." still score correctly. SINGLE_CHAR_CATEGORIES = {"first_letter", "last_letter", "uppercase", "lowercase"} # Explicit task preamble prepended before the few-shot examples for # single-char categories. The preamble anchors the expected output # format so models do not produce verbose completions. CATEGORY_PREAMBLES = { "first_letter": "# Output only the first letter of each phrase.", "last_letter": "# Output only the last letter of each phrase.", "uppercase": "# Output the uppercase version of each letter.", "lowercase": "# Output the lowercase version of each letter.", } def __init__(self, config: TaskConfig): super().__init__(config) # Define hardcoded demonstrations for each category import string import random # Build full alphabet demonstrations for completeness. # Shuffle with a fixed seed so the 5 shown demos are non-consecutive, # which eliminates the "consecutive alphabetic shift" ambiguity that # arises when the model always sees a->A, b->B, c->C, d->D, e->E. _rng = random.Random(42) uppercase_demos = [f"{ch.lower()} -> {ch}" for ch in string.ascii_uppercase] _rng.shuffle(uppercase_demos) lowercase_demos = [f"{ch} -> {ch.lower()}" for ch in string.ascii_uppercase] _rng.shuffle(lowercase_demos) self.category_demonstrations = { "uppercase": uppercase_demos, "lowercase": lowercase_demos, "first_letter": [ "the cat went up the tree -> t", "elephants are cool -> e", "beautiful morning sunshine -> b", "running through the forest -> r", "amazing journey ahead -> a", ], "last_letter": [ "the cat went up the tree -> e", "elephants are cool -> l", "beautiful morning sunshine -> e", "running through the forest -> t", "amazing journey ahead -> d", ], "translate_eng_fr": [ "hello -> bonjour", "goodbye -> au revoir", "thank you -> merci", "please -> s'il vous plaît", "yes -> oui", "cat -> chat", "dog -> chien", "house -> maison", "car -> voiture", "book -> livre", "flower -> fleur", "pen -> stylo", "pencil -> crayon", ], "translate_fr_eng": [ "bonjour -> hello", "au revoir -> goodbye", "merci -> thank you", "s'il vous plaît -> please", "oui -> yes", "chat -> cat", "chien -> dog", "maison -> house", "voiture -> car", "livre -> book", "fleur -> flower", "stylo -> pen", "crayon -> pencil", ], "translate_eng_sp": [ "hello -> hola", "goodbye -> adiós", "thank you -> gracias", "please -> por favor", "yes -> sí", "cat -> gato", "dog -> perro", "house -> casa", "car -> coche", "book -> libro", "flower -> flor", "pen -> bolígrafo", "pencil -> lápiz", "flower -> flor", ], "translate_sp_eng": [ "hola -> hello", "adiós -> goodbye", "gracias -> thank you", "por favor -> please", "sí -> yes", "gato -> cat", "perro -> dog", "casa -> house", "coche -> car", "libro -> book", "flor -> flower", "bolígrafo -> pen", "lápiz -> pencil", "flor -> flower" ], "present_to_gerund": [ "run -> running", "swim -> swimming", "walk -> walking", "jump -> jumping", "dance -> dancing", "sing -> singing", "read -> reading", "write -> writing", "sleep -> sleeping", ], "singular_to_plural": [ "cat -> cats", "dog -> dogs", "book -> books", "car -> cars", "house -> houses", "child -> children", "mouse -> mice", ], "country_to_capital": [ "France -> Paris", "Germany -> Berlin", "Italy -> Rome", "Spain -> Madrid", "United Kingdom -> London", "Japan -> Tokyo", "Canada -> Ottawa", "Australia -> Canberra", ], "country_to_currency": [ "France -> Euro", "United States -> Dollar", "United Kingdom -> Pound", "Japan -> Yen", "Canada -> Canadian Dollar", "Australia -> Australian Dollar", "India -> Rupee", "China -> Yuan", ], } def _load_data(self): """Load data from CSV file.""" import pandas as pd if self.config.data_path: self.data = pd.read_csv(self.config.data_path) else: # If no data path, create empty DataFrame self.data = pd.DataFrame(columns=[self.config.input_column, self.config.output_column]) def _preprocess_for_category(self, prediction: str, category: str) -> str: """Return the cleaned prediction for a given category. For single-char categories the logic is: 1. Strip surrounding whitespace and trailing punctuation from the first output line. If that reduces to a single alpha char, return it. 2. Otherwise scan for the last standalone single letter in the first output line (word-boundary on both sides), which handles verbose completions such as "The first letter is t." → 't'. For all other categories trailing punctuation is stripped from the first output line. """ import re first_line = prediction.strip().split('\n')[0].strip() if prediction else "" if category in self.SINGLE_CHAR_CATEGORIES: stripped = first_line.strip('.,!?;:\'"() ') if len(stripped) == 1 and stripped.isalpha(): return stripped # Find all standalone single letters; return the last one, which is # typically the actual answer in verbose outputs like # "The first letter is t." matches = re.findall(r'\b([a-zA-Z])\b', first_line) if matches: return matches[-1] return stripped[:1] if stripped else first_line return first_line.rstrip('.,!?;:') def build_prompt(self, instance: Dict[str, Any], num_shots: int = -1) -> str: """Build a prompt with category-specific demonstrations. Args: instance: The instance to build a prompt for num_shots: Number of in-context learning examples. Defaults to self.config.num_demonstrations. Returns: Formatted prompt string """ # Use config value when caller did not specify explicitly if num_shots < 0: num_shots = self.config.num_demonstrations category = instance.get('category_name', '') # Check if we have demonstrations in the config (from in-memory data) if (self.config.in_memory_demonstrations and isinstance(self.config.in_memory_demonstrations, dict)): demos = self.config.in_memory_demonstrations.get(category, []) else: # Fallback to hardcoded demonstrations demos = self.category_demonstrations.get(category, []) # Exclude demonstrations that match the current instance input to avoid leaking the test item instance_input = instance.get(self.config.input_column, '') filtered_demos = [] for d in demos: # Each demo may be formatted like 'input -> output' demo_input = d.split('->', 1)[0].strip() if demo_input != instance_input: filtered_demos.append(d) # Limit to num_shots if provided if filtered_demos and num_shots > 0: demos = filtered_demos[:num_shots] else: demos = filtered_demos prompt = "" # Prepend an explicit format instruction for single-char categories so # models do not produce verbose completions. preamble = self.CATEGORY_PREAMBLES.get(category) if preamble: prompt += f"{preamble}\n" if demos: for demo in demos: prompt += f"{demo}\n" # Add the current question prompt += f"{instance[self.config.input_column]} ->" return prompt def evaluate(self, predictions: List[str], split: str = "test", **kwargs) -> Dict[str, float]: """Evaluate predictions with exact match accuracy, including per-category metrics.""" ground_truth = self.get_ground_truth(split) task_data = self.get_split(split) if len(predictions) != len(ground_truth): raise ValueError(f"Prediction count ({len(predictions)}) doesn't match ground truth count ({len(ground_truth)})") # Category-aware preprocessing: single-char tasks extract first letter; # other tasks strip trailing punctuation from the first output line. processed_predictions = [ self._preprocess_for_category(pred, item.get('category_name', '')) for pred, item in zip(predictions, task_data) ] # Overall accuracy correct = sum(1 for pred, gt in zip(processed_predictions, ground_truth) if pred.lower().strip() == gt.lower().strip()) accuracy = correct / len(ground_truth) results = { "accuracy": accuracy, "correct": correct, "total": len(ground_truth) } # Per-category accuracy category_stats = {} for pred, gt, item in zip(processed_predictions, ground_truth, task_data): category = item.get("category_name", "unknown") if category not in category_stats: category_stats[category] = {"correct": 0, "total": 0} category_stats[category]["total"] += 1 if pred.lower().strip() == gt.lower().strip(): category_stats[category]["correct"] += 1 # Calculate per-category accuracy for category, stats in category_stats.items(): results[f"accuracy_{category}"] = stats["correct"] / stats["total"] results[f"correct_{category}"] = stats["correct"] results[f"total_{category}"] = stats["total"] return results