#!/usr/bin/env python3 """ Trajectory evaluation script - BookWriter-A2A project Evaluates 6 trajectory metrics: 1. Exact match 2. In-order match 3. Any-order match 4. Precision 5. Recall 6. Single-tool use """ import os import re import yaml from pathlib import Path from typing import List, Dict, Tuple, Set from collections import defaultdict import pandas as pd import math from itertools import permutations, product class TrajectoryParser: """Parse an execution_path.md file and extract the full execution trajectory.""" def __init__(self, md_file_path: str, extract_types: List[str] = None): """ Args: md_file_path: Path to execution_path.md extract_types: Node types to extract. Default: ['Tool']. Supported: 'SPAN', 'Chain', 'Tool', 'AGENT', 'LLM', 'Task Created', 'Crew Created' """ self.md_file_path = md_file_path self.extract_types = extract_types or ["Tool"] self.trajectory = [] def parse(self) -> List[str]: """Parse the file and return the action sequence.""" if not os.path.exists(self.md_file_path): return [] with open(self.md_file_path, "r", encoding="utf-8") as f: content = f.read() # Extract the "Execution Path Tree" section (inside the code block) tree_match = re.search( r"## Execution Path Tree.*?```\n(.*?)```", content, re.DOTALL ) if not tree_match: return [] tree_content = tree_match.group(1) trajectory = [] for line in tree_content.split("\n"): # Remove tree drawing characters while keeping node content clean_line = re.sub(r"^[│├└─\s]+", "", line).strip() if not clean_line: continue # Remove error marker ❌ clean_line = re.sub(r"^❌\s+", "", clean_line) # Remove retry markers: (retry N) and [RETRYN] clean_line = re.sub(r"\s*\(retry\s+\d+\)", "", clean_line) clean_line = re.sub(r"\s*\[RETRY\d+\]", "", clean_line) # Remove ERROR details (keep node type/name, drop the [ERROR:...] part) clean_line = re.sub(r"\s*\[ERROR:[^\]]*\]", "", clean_line) # Extract node info node_info = self._extract_node_info(clean_line) if node_info and node_info["type"] in self.extract_types: trajectory.append(node_info["action"]) self.trajectory = trajectory return trajectory def _extract_node_info(self, line: str) -> dict: """Extract node info from a line. Note: the input line should have already removed ❌, retry markers, and ERROR details. Returns: {'type': str, 'action': str} or None """ # SPAN node: [SPAN] span_name [stats] # In A2A, SPAN names may include chapter titles (e.g., a2a_call_chapter_writer_(chapter_title)). # Use wildcard matching. span_match = re.match(r"\[SPAN\]\s+([^\[]+?)(?:\s+\[.*?\])*\s*$", line) if span_match: span_name = span_match.group(1).strip() # Wildcard: a2a_call_chapter_writer_(any title) -> a2a_call_chapter_writer_* span_name = re.sub( r"a2a_call_chapter_writer_\([^)]+\)", "a2a_call_chapter_writer_*", span_name, ) return {"type": "SPAN", "action": f"SPAN: {span_name}"} # Chain node: [Chain] chain_name [stats] [optional extras] # For Crew_xxx.kickoff, use wildcard Crew***.kickoff # Note: in A2A, Chain lines may contain BATCH markers (e.g., 📚BATCH1 (chapter title)) chain_match = re.match(r"\[Chain\]\s+([^\[\s]+(?:\.[^\[\s]+)?)", line) if chain_match: chain_name = chain_match.group(1).strip() # Wildcard: Crew_UUID.kickoff -> Crew***.kickoff chain_name = re.sub( r"Crew_[a-f0-9\-]+\.kickoff", "Crew***.kickoff", chain_name ) return {"type": "Chain", "action": f"Chain: {chain_name}"} # Agent node: [AGENT] agent_name._execute_core [stats] agent_match = re.match(r"\[AGENT\]\s+([^\[]+?)(?:\s+\[.*?\])*\s*$", line) if agent_match: agent_name = agent_match.group(1).strip() # Remove ._execute_core suffix agent_name = re.sub(r"\._execute_core$", "", agent_name) return {"type": "Agent", "action": f"Agent: {agent_name}"} # Tool node: [Tool] tool_name._use [time] tool_match = re.match( r"\[Tool\]\s+([^\[\]]+?)(?:\s+\[[\d.]+(?:ms|s)\])?(?:\s*@@@)?\s*$", line ) if tool_match: tool_name = tool_match.group(1).strip() # Remove ._use suffix tool_name = re.sub(r"\._use$", "", tool_name) return {"type": "Tool", "action": f"Tool: {tool_name}"} # LLM node: [LLM] model_name (tokens) [time] llm_match = re.match(r"\[LLM\]\s+([^\(\[]+)", line) if llm_match: model_name = llm_match.group(1).strip() return {"type": "LLM", "action": f"LLM: {model_name}"} # Task Created node: [Task Created] [time] task_match = re.match(r"\[Task Created\]", line) if task_match: return {"type": "Task Created", "action": "Task Created"} # Crew Created node: [Crew Created] [time] crew_match = re.match(r"\[Crew Created\]", line) if crew_match: return {"type": "Crew Created", "action": "Crew Created"} return None class TrajectoryEvaluator: """Trajectory evaluator - implements 6 evaluation metrics.""" def __init__( self, reference_trajectory: List[str], repeatable_patterns: List[Dict] = None, actual_chapter_count: int = None, ): """ Args: reference_trajectory: Base reference trajectory (ground truth, includes a single-chapter pattern) repeatable_patterns: Repeatable patterns list; each has start, end, min, max actual_chapter_count: Actual chapter count. If provided, a dynamic reference will be built. """ self.base_reference = reference_trajectory # Keep the original base reference self.repeatable_patterns = repeatable_patterns or [] self.use_simple_matching = False # Build a dynamic reference when chapter count is available if actual_chapter_count is not None and self.repeatable_patterns: self.reference = self._build_dynamic_reference(actual_chapter_count) # When using a dynamic reference, disable special repeatable-pattern matching, # because the dynamic reference already contains the correct number of chapters. self.use_simple_matching = True else: self.reference = reference_trajectory self.use_simple_matching = False @staticmethod def detect_chapter_count(predicted: List[str]) -> int: """ Detect the actual number of chapters executed. Uses the number of "Chain: Crew***.kickoff" occurrences within the write_chapters SPAN. Args: predicted: The predicted (actual) execution trajectory Returns: Chapter count. If detection fails, returns 4 as the default. """ # Locate the write_chapters SPAN write_chapters_idx = -1 review_book_idx = -1 for i, step in enumerate(predicted): if step == "SPAN: write_chapters": write_chapters_idx = i elif step == "SPAN: review_book": review_book_idx = i break if write_chapters_idx == -1: # write_chapters SPAN not found; return default return 4 # Define the search range if review_book_idx != -1: search_end = review_book_idx else: search_end = len(predicted) # Count occurrences of Chain: Crew***.kickoff chapter_count = 0 for i in range(write_chapters_idx + 1, search_end): if predicted[i] == "Chain: Crew***.kickoff": chapter_count += 1 # If detection fails (0 chapters), return the default (4) return chapter_count if chapter_count > 0 else 4 def _build_dynamic_reference(self, chapter_count: int) -> List[str]: """ Build a reference trajectory dynamically based on the detected chapter count. Args: chapter_count: Chapter count Returns: The dynamically generated reference trajectory """ if not self.repeatable_patterns: return self.base_reference pattern = self.repeatable_patterns[0] pattern_start = pattern["start"] pattern_end = pattern["end"] # Split the base reference trajectory before_pattern = self.base_reference[:pattern_start] pattern_steps = self.base_reference[pattern_start : pattern_end + 1] after_pattern = self.base_reference[pattern_end + 1 :] # Repeat the chapter pattern based on the detected chapter count. # If chapter_count is outside 3-5, fall back to 4. if chapter_count < 3 or chapter_count > 5: repeat_count = 4 else: repeat_count = chapter_count # Build the dynamic reference dynamic_reference = before_pattern.copy() for _ in range(repeat_count): dynamic_reference.extend(pattern_steps) dynamic_reference.extend(after_pattern) return dynamic_reference def _match_action(self, predicted_action: str, reference_action: str) -> bool: """ Match two actions, with wildcard support. Args: predicted_action: Actual executed action reference_action: Reference action (may contain wildcards) Returns: True if match, False otherwise """ # Exact match if predicted_action == reference_action: return True # Wildcard: LLM: * matches any LLM: if reference_action == "LLM: *" and predicted_action.startswith("LLM: "): return True # Wildcard: SPAN: a2a_call_chapter_writer_* matches any chapter title if ( reference_action == "SPAN: a2a_call_chapter_writer_*" and predicted_action.startswith("SPAN: a2a_call_chapter_writer_") ): return True return False def exact_match(self, predicted: List[str]) -> int: """ Exact match: predicted trajectory must be identical to the reference (wildcards supported). Returns: 1 if exact match, 0 otherwise """ if len(predicted) != len(self.reference): return 0 for i in range(len(predicted)): if not self._match_action(predicted[i], self.reference[i]): return 0 return 1 def in_order_match(self, predicted: List[str]) -> int: """ In-order match: the reference must be a subsequence of the predicted trajectory (wildcards supported). Extra actions are allowed, but core steps must appear in order. Supports repeatable patterns (e.g., per-chapter repetition). Returns: 1 if in-order match, 0 otherwise """ if not self.reference: return 1 # Empty reference always matches # If using simple matching (dynamic reference already has correct chapter count), use simple logic if self.use_simple_matching or not self.repeatable_patterns: ref_idx = 0 for pred_action in predicted: if ref_idx < len(self.reference) and self._match_action( pred_action, self.reference[ref_idx] ): ref_idx += 1 return 1 if ref_idx == len(self.reference) else 0 # Matching logic with repeatable patterns # Currently only a single repeatable pattern is supported pattern = self.repeatable_patterns[0] pattern_start = pattern["start"] pattern_end = pattern["end"] # Split the reference trajectory into 3 parts before_pattern = self.reference[:pattern_start] pattern_steps = self.reference[pattern_start : pattern_end + 1] after_pattern = self.reference[pattern_end + 1 :] pred_idx = 0 # 1) Match the part before the pattern for ref_action in before_pattern: while pred_idx < len(predicted): if self._match_action(predicted[pred_idx], ref_action): pred_idx += 1 break pred_idx += 1 else: return 0 # No match found # 2) Match the repeatable pattern (at least min times, at most max times) pattern_matches = 0 while pattern_matches < pattern["max"]: # Try to match one full pattern pattern_idx = 0 start_pred_idx = pred_idx for pattern_action in pattern_steps: while pred_idx < len(predicted): if self._match_action(predicted[pred_idx], pattern_action): pred_idx += 1 pattern_idx += 1 break pred_idx += 1 else: # No match found break # Check whether one full pattern was matched if pattern_idx == len(pattern_steps): pattern_matches += 1 else: # Restore to the position before this attempt pred_idx = start_pred_idx break # Check whether the repetition count meets the requirement if pattern_matches < pattern["min"]: return 0 # 3) Match the part after the pattern for ref_action in after_pattern: while pred_idx < len(predicted): if self._match_action(predicted[pred_idx], ref_action): pred_idx += 1 break pred_idx += 1 else: return 0 # No match found return 1 def diagnose_any_order_match_failure(self, predicted: List[str]) -> dict: """ Diagnose why any_order_match fails. Returns: { 'match': bool, 'failure_stage': str ('before_pattern', 'pattern', 'after_pattern', None), 'missing_steps': [str], 'missing_details': str } """ if not self.reference: return { "match": True, "failure_stage": None, "missing_steps": [], "missing_details": "", } # If using simple matching (dynamic reference already has correct chapter count), use simple logic if self.use_simple_matching or not self.repeatable_patterns: pred_remaining = predicted.copy() missing_steps = [] for ref_action in self.reference: matched = False for i, pred_action in enumerate(pred_remaining): if self._match_action(pred_action, ref_action): pred_remaining.pop(i) matched = True break if not matched: missing_steps.append(ref_action) if missing_steps: return { "match": False, "failure_stage": "simple_match", "missing_steps": missing_steps, "missing_details": f"Missing {len(missing_steps)} required steps", } return { "match": True, "failure_stage": None, "missing_steps": [], "missing_details": "", } # Matching logic with repeatable patterns pattern = self.repeatable_patterns[0] pattern_start = pattern["start"] pattern_end = pattern["end"] before_pattern = self.reference[:pattern_start] pattern_steps = self.reference[pattern_start : pattern_end + 1] after_pattern = self.reference[pattern_end + 1 :] pred_remaining = predicted.copy() # 1) Check the part before the pattern missing_before = [] for ref_action in before_pattern: matched = False for i, pred_action in enumerate(pred_remaining): if self._match_action(pred_action, ref_action): pred_remaining.pop(i) matched = True break if not matched: missing_before.append(ref_action) if missing_before: return { "match": False, "failure_stage": "before_pattern", "missing_steps": missing_before, "missing_details": f"Missing {len(missing_before)} steps in the outline stage", } # 2) Check the repeatable pattern part pattern_missing = [] for ref_action in pattern_steps: required_count = pattern["min"] found_count = 0 i = 0 while i < len(pred_remaining) and found_count < required_count: if self._match_action(pred_remaining[i], ref_action): pred_remaining.pop(i) found_count += 1 else: i += 1 if found_count < required_count: pattern_missing.append( f"{ref_action} (required {required_count}, found {found_count})" ) if pattern_missing: return { "match": False, "failure_stage": "pattern", "missing_steps": pattern_missing, "missing_details": f"Missing {len(pattern_missing)} steps in the chapter pattern (min {pattern['min']} per chapter)", } # 3) Check the part after the pattern missing_after = [] for ref_action in after_pattern: matched = False for i, pred_action in enumerate(pred_remaining): if self._match_action(pred_action, ref_action): pred_remaining.pop(i) matched = True break if not matched: missing_after.append(ref_action) if missing_after: return { "match": False, "failure_stage": "after_pattern", "missing_steps": missing_after, "missing_details": f"Missing {len(missing_after)} steps in the review stage", } return { "match": True, "failure_stage": None, "missing_steps": [], "missing_details": "", } def any_order_match(self, predicted: List[str]) -> int: """ Any-order match: predicted must contain all required actions (wildcards supported). Order does not matter; extra actions are allowed. Supports repeatable patterns (e.g., per-chapter repetition). Returns: 1 if any-order match, 0 otherwise """ diagnosis = self.diagnose_any_order_match_failure(predicted) return 1 if diagnosis["match"] else 0 def precision(self, predicted: List[str]) -> float: """ Precision: fraction of predicted actions that are considered correct by the reference (wildcards supported). Precision = TP / (TP + FP) TP: Number of correct actions in the prediction FP: Number of incorrect/extra actions in the prediction Returns: precision value (0.0 - 1.0) """ if not predicted: return 1.0 # No predictions, therefore no false predictions if not self.reference: return 0.0 # Reference is empty but predictions exist: all are incorrect # Copy reference actions for matching ref_remaining = self.reference.copy() tp = 0 # True Positives for pred_action in predicted: # Try to find a match in the reference for i, ref_action in enumerate(ref_remaining): if self._match_action(pred_action, ref_action): tp += 1 ref_remaining.pop(i) # Remove matched item break fp = len(predicted) - tp # False Positives return tp / (tp + fp) if (tp + fp) > 0 else 0.0 def recall(self, predicted: List[str]) -> float: """ Recall: fraction of reference actions that are covered by the predicted trajectory (wildcards supported). Recall = TP / (TP + FN) TP: Number of required actions covered by the prediction FN: Number of required actions missing from the prediction Returns: recall value (0.0 - 1.0) """ if not self.reference: return 1.0 # Empty reference, nothing to recall if not predicted: return 0.0 # No predictions -> recall is 0 # Copy predicted actions for matching pred_remaining = predicted.copy() tp = 0 # True Positives for ref_action in self.reference: # Try to find a match in the predictions for i, pred_action in enumerate(pred_remaining): if self._match_action(pred_action, ref_action): tp += 1 pred_remaining.pop(i) # Remove matched item break fn = len(self.reference) - tp # False Negatives return tp / (tp + fn) if (tp + fn) > 0 else 0.0 def single_tool_use(self, predicted: List[str], tool_name: str) -> int: """ Single-tool use: check whether a specific tool appears in the trajectory (wildcards supported). Args: predicted: Predicted trajectory tool_name: Target tool name Returns: 1 if tool is used, 0 otherwise """ # Check if any predicted action matches the target tool for pred_action in predicted: if self._match_action(pred_action, tool_name): return 1 return 0 def evaluate_all( self, predicted: List[str], target_tools: List[str] = None ) -> Dict[str, float]: """ Evaluate all metrics. Args: predicted: Predicted trajectory target_tools: Tools to check for usage (for single-tool use) Returns: Dictionary containing all metric values """ results = { "exact_match": self.exact_match(predicted), "in_order_match": self.in_order_match(predicted), "any_order_match": self.any_order_match(predicted), "precision": self.precision(predicted), "recall": self.recall(predicted), } # Single-tool use: compute overall usage rate (average over all target tools) if target_tools: tool_usage_count = sum( self.single_tool_use(predicted, tool) for tool in target_tools ) results["single_tool_use"] = ( tool_usage_count / len(target_tools) if target_tools else 0.0 ) return results class DatasetEvaluator: """Dataset-level evaluator.""" def __init__(self, config_file: str): """ Args: config_file: Path to YAML config file that defines the reference trajectory """ self.config_file = config_file self.config = self._load_config() self.reference_trajectory = self.config.get("reference_trajectory", []) self.target_tools = self.config.get("target_tools", []) self.models = self.config.get("models", []) self.project_name = self.config.get("project_name", "BookWriter-A2A") # Trajectory extraction types: default extracts Tool only; can be configured to include others. self.extract_types = self.config.get("extract_types", ["Tool"]) # Repeatable pattern config (for handling varying chapter counts) self.repeatable_patterns = self.config.get("repeatable_patterns", []) # Permutable tool group config (used to generate multiple candidate references) self.permutable_tool_groups = self.config.get("permutable_tool_groups", {}) def _load_config(self) -> Dict: """Load YAML config file.""" if not os.path.exists(self.config_file): print(f"⚠️ Config file not found: {self.config_file}") return {} with open(self.config_file, "r", encoding="utf-8") as f: return yaml.safe_load(f) def _generate_permuted_trajectories( self, base_trajectory: List[str] ) -> List[List[str]]: """ Generate all possible permuted tool-order trajectories based on permutable_tool_groups. Args: base_trajectory: Base reference trajectory Returns: All possible permuted trajectories (including the original) """ if not self.permutable_tool_groups: # No permutable groups configured; return the original trajectory return [base_trajectory] # Collect permutable tool groups and their positions in the trajectory tool_groups_positions = [] for group_name, tools in self.permutable_tool_groups.items(): # Find positions of this group in the base trajectory positions = [] tool_indices = {} for i, action in enumerate(base_trajectory): for tool in tools: if action == tool: positions.append(i) tool_indices[i] = tool break # Only permute when all tools in the group are found if len(positions) == len(tools): # Record positions and tools tools_at_positions = [tool_indices[pos] for pos in positions] tool_groups_positions.append((positions, tools_at_positions)) if not tool_groups_positions: # No complete permutable groups found return [base_trajectory] # Generate all possible permutation combinations all_trajectories = [] # Generate permutations for each tool group group_permutations = [] for positions, tools in tool_groups_positions: # Generate all permutations of this group perms = list(permutations(tools)) group_permutations.append([(positions, perm) for perm in perms]) # Cartesian product: combine permutations across groups all_group_combinations = list(product(*group_permutations)) # Build a new trajectory for each combination for combination in all_group_combinations: new_trajectory = base_trajectory.copy() # Apply the tool ordering for this combination for positions, perm in combination: for pos, tool in zip(positions, perm): new_trajectory[pos] = tool all_trajectories.append(new_trajectory) return all_trajectories def _find_best_reference_trajectory( self, predicted: List[str], candidate_references: List[List[str]] ) -> Tuple[List[str], Dict[str, float]]: """ Choose the best reference trajectory among multiple candidates. Strategy: compute a weighted score for each candidate against the prediction: exact_match * 3 + in_order_match * 2 + any_order_match * 1 Args: predicted: Predicted trajectory candidate_references: Candidate reference trajectories Returns: (best reference trajectory, its key match metrics) """ best_reference = candidate_references[0] best_score = -1 best_metrics = {} for ref_trajectory in candidate_references: evaluator = TrajectoryEvaluator(ref_trajectory) # Compute key match metrics exact = evaluator.exact_match(predicted) in_order = evaluator.in_order_match(predicted) any_order = evaluator.any_order_match(predicted) # Weighted score: exact_match has the highest weight, followed by in_order_match score = exact * 3 + in_order * 2 + any_order * 1 if score > best_score: best_score = score best_reference = ref_trajectory best_metrics = { "exact_match": exact, "in_order_match": in_order, "any_order_match": any_order, } return best_reference, best_metrics def collect_execution_paths( self, model_name: str, base_dir: str ) -> List[Tuple[str, List[str]]]: """ Collect and parse all execution_path.md files for a given model. Args: model_name: Model name base_dir: RESULTS directory path Returns: List of (session_id, trajectory) """ model_dir = Path(base_dir) / model_name / self.project_name / "test_results" if not model_dir.exists(): print(f"⚠️ Model directory not found: {model_dir}") return [] results = [] # Iterate over all session subdirectories for session_dir in sorted(model_dir.iterdir()): if not session_dir.is_dir(): continue exec_path_file = session_dir / "execution_path.md" if not exec_path_file.exists(): continue # Parse trajectory using configured extraction types parser = TrajectoryParser( str(exec_path_file), extract_types=self.extract_types ) trajectory = parser.parse() results.append((session_dir.name, trajectory)) return results def evaluate_model( self, model_name: str, base_dir: str, collect_failure_reasons: bool = False ) -> Dict[str, float]: """ Evaluate a single model across all samples. Args: model_name: Model name base_dir: RESULTS directory path collect_failure_reasons: Whether to collect any_order_match failure reasons Returns: Average metrics dictionary """ trajectories = self.collect_execution_paths(model_name, base_dir) if not trajectories: print(f"⚠️ No trajectory data found for model {model_name}") return {} # Aggregate metrics over all samples all_metrics = defaultdict(list) # Store failure reasons (optional) if collect_failure_reasons: if not hasattr(self, "failure_reasons"): self.failure_reasons = [] for session_id, predicted in trajectories: # Detect chapter count for this sample chapter_count = TrajectoryEvaluator.detect_chapter_count(predicted) # Step 1: build dynamic reference based on chapter count (handles repeatable patterns) base_evaluator = TrajectoryEvaluator( self.reference_trajectory, self.repeatable_patterns, actual_chapter_count=chapter_count, ) dynamic_reference = base_evaluator.reference # Step 2: generate all permuted reference trajectories candidate_references = self._generate_permuted_trajectories( dynamic_reference ) # Step 3: choose the best reference trajectory among candidates if len(candidate_references) > 1: best_reference, best_match_metrics = ( self._find_best_reference_trajectory( predicted, candidate_references ) ) else: # No permutations produced; use the original dynamic reference best_reference = dynamic_reference # Step 4: evaluate using the chosen best reference evaluator = TrajectoryEvaluator( best_reference, # Note: repeatable_patterns is not needed here since it has already been applied. repeatable_patterns=None, actual_chapter_count=None, ) metrics = evaluator.evaluate_all(predicted, self.target_tools) for key, value in metrics.items(): all_metrics[key].append(value) # Collect any_order_match failure reasons if collect_failure_reasons and metrics["any_order_match"] == 0: diagnosis = evaluator.diagnose_any_order_match_failure(predicted) self.failure_reasons.append( { "model": model_name, "session": session_id, "chapter_count": chapter_count, "failure_stage": diagnosis["failure_stage"], "missing_steps_count": len(diagnosis["missing_steps"]), "missing_details": diagnosis["missing_details"], "first_missing_step": ( diagnosis["missing_steps"][0] if diagnosis["missing_steps"] else "N/A" ), } ) # Compute averages avg_metrics = {} for key, values in all_metrics.items(): avg_metrics[key] = sum(values) / len(values) if values else 0.0 num_samples = len(trajectories) if num_samples > 0: path_counter = defaultdict(int) for session_id, predicted in trajectories: path_key = tuple(predicted) path_counter[path_key] += 1 unique_paths = len(path_counter) unique_path_ratio = unique_paths / num_samples if num_samples > 0 else 0.0 probs = [count / num_samples for count in path_counter.values()] H = -sum(p * math.log(p) for p in probs if p > 0) if len(probs) > 1: path_entropy = H / math.log(len(probs)) else: path_entropy = 0.0 else: unique_path_ratio = 0.0 path_entropy = 0.0 avg_metrics["unique_path_ratio"] = unique_path_ratio avg_metrics["path_entropy"] = path_entropy # Add sample count avg_metrics["num_samples"] = num_samples return avg_metrics def evaluate_all_models( self, base_dir: str = None, collect_failure_reasons: bool = False ) -> pd.DataFrame: """ Evaluate all models and return a summary table. Args: base_dir: RESULTS directory path (default: two levels above this script) collect_failure_reasons: Whether to collect any_order_match failure reasons Returns: DataFrame containing evaluation results for all models """ if base_dir is None: # Default path: two levels above the script directory base_dir = Path(__file__).parent.parent.parent results = [] # Initialize failure reasons list if collect_failure_reasons: self.failure_reasons = [] for model_name in self.models: print(f"\n📊 Evaluating model: {model_name}") metrics = self.evaluate_model( model_name, str(base_dir), collect_failure_reasons ) if metrics: metrics["model"] = model_name results.append(metrics) print(f" ✅ Done. Samples: {metrics['num_samples']}") else: print(" ❌ Skipped (no data)") if not results: print("\n❌ No model data available") return pd.DataFrame() # Create DataFrame df = pd.DataFrame(results) # Reorder columns: put model first cols = [ "model", "num_samples", "exact_match", "in_order_match", "any_order_match", "precision", "recall", "single_tool_use", "unique_path_ratio", "path_entropy", ] # Keep only existing columns cols = [col for col in cols if col in df.columns] df = df[cols] return df def save_failure_reasons(self, output_file: str = "any_order_match_failures.csv"): """ Save any_order_match failure reasons to a CSV file. Args: output_file: Output CSV filename """ if not hasattr(self, "failure_reasons") or not self.failure_reasons: print("\n⚠️ No failure-reason data collected") return output_path = Path(__file__).parent / output_file # Create DataFrame df = pd.DataFrame(self.failure_reasons) # Save as CSV df.to_csv(output_path, index=False, encoding="utf-8") print(f"\n✅ any_order_match failure reasons saved: {output_path}") # Summary print("\n📊 Failure reason summary:") print(f" Total failed samples: {len(self.failure_reasons)}") # By model print("\n By model:") model_counts = df["model"].value_counts() for model, count in model_counts.items(): print(f" {model}: {count} failed samples") # By failure stage print("\n By failure stage:") stage_counts = df["failure_stage"].value_counts() for stage, count in stage_counts.items(): stage_name = { "before_pattern": "Outline stage", "pattern": "Chapter pattern stage", "after_pattern": "Review stage", "simple_match": "Simple match", }.get(stage, stage) print(f" {stage_name}: {count}") # Intentionally do not generate any Markdown files. def main(): """Main entry point.""" import argparse parser = argparse.ArgumentParser( description="Evaluate trajectory metrics for the BookWriter-A2A project" ) parser.add_argument( "--config", type=str, default="reference_trajectory.yaml", help="Path to the reference trajectory YAML config file", ) parser.add_argument( "--base-dir", type=str, default=None, help="RESULTS directory path (default: two levels above this script)", ) parser.add_argument( "--output", type=str, default="evaluation_results.csv", help="Output CSV file path", ) parser.add_argument( "--format", type=str, choices=["csv", "markdown", "both"], default="both", help="Output format: csv, markdown, or both (Markdown is ignored; no .md files are generated)", ) parser.add_argument( "--diagnose-failures", action="store_true", help="Diagnose any_order_match failures (CSV only; no .md files are generated)", ) args = parser.parse_args() # If config is a relative path, resolve it relative to this script config_path = args.config if not os.path.isabs(config_path): config_path = os.path.join(os.path.dirname(__file__), config_path) print("=" * 80) print("Trajectory Evaluation Tool - BookWriter-A2A") print("=" * 80) print(f"\n📁 Config: {config_path}") # Create evaluator evaluator = DatasetEvaluator(config_path) print(f"📋 Project: {evaluator.project_name}") print(f"🎯 Reference trajectory: {evaluator.reference_trajectory}") print(f"🔧 Target tools: {evaluator.target_tools}") print(f"🤖 Models: {evaluator.models}") if args.diagnose_failures: print("🔍 Failure diagnosis enabled") # Evaluate all models df = evaluator.evaluate_all_models( args.base_dir, collect_failure_reasons=args.diagnose_failures ) if df.empty: print("\n❌ Evaluation failed: no data") return print("\n" + "=" * 80) print("📊 Summary") print("=" * 80) # Display formatting pd.set_option("display.max_columns", None) pd.set_option("display.width", None) pd.set_option("display.float_format", lambda x: f"{x:.4f}") print("\n" + df.to_string(index=False)) # Save results output_dir = os.path.dirname(args.output) or "." os.makedirs(output_dir, exist_ok=True) if args.format in ["csv", "both"]: csv_file = args.output df.to_csv(csv_file, index=False) print(f"\n✅ CSV saved: {csv_file}") if args.format in ["markdown", "both"]: print( "⚠️ Markdown output is disabled by design. " "Use --format csv to save results." ) # Save failure reasons (if enabled) if args.diagnose_failures: evaluator.save_failure_reasons() print("\n" + "=" * 80) print("✅ Done") print("=" * 80) if __name__ == "__main__": main()