import argparse import json from pathlib import Path from src.utils import read_file, check_data_validity, preprocess_merged_tables from src.layout_evaluation import evaluate_layout from src.table_evaluation import evaluate_table def parse_args(): parser = argparse.ArgumentParser(description="Arguments for evaluation") parser.add_argument( "--ref-path", type=str, required=True, help="Path to the ground truth file" ) parser.add_argument( "--pred-path", type=str, required=True, help="Path to the prediction file" ) parser.add_argument( "--ignore-classes-for-layout", type=list, default=["figure", "table", "chart"], help="List of layout classes to ignore. This is used only for layout evaluation." ) parser.add_argument( "--filter-by-gt-area", action=argparse.BooleanOptionalAction, default=True, help="Filter out prediction text within GT ignored regions (default: True). Use --no-filter-by-gt-area to disable." ) parser.add_argument( "--mode", type=str, default="all", choices=["layout", "table", "all", "speed"], help="Mode for evaluation (layout/table/all/speed). 'all' runs both layout and table evaluations. 'speed' evaluates latency and throughput." ) parser.add_argument( "--min-match-score", type=float, default=0.1, help="Minimum match score for table evaluation" ) parser.add_argument( "--max-workers", type=int, default=8, help="Maximum number of workers for table evaluation" ) parser.add_argument( "--evaluate-merged-table", action=argparse.BooleanOptionalAction, default=False, help="Enable merged table evaluation mode. When enabled, tables specified in 'merged_tables' will be preprocessed and merged before evaluation (default: False)." ) return parser.parse_args() def main(): args = parse_args() print("Arguments:") for k, v in vars(args).items(): print(f" {k}: {v}") print("-" * 50) label_data = read_file(args.ref_path) pred_data = read_file(args.pred_path) # Apply merged table preprocessing if enabled if args.evaluate_merged_table: print("Merged table evaluation mode enabled") print("Preprocessing ground truth data (merging tables)...") label_data = preprocess_merged_tables(label_data) # Check if prediction data has merged_tables key has_merged_tables_in_pred = any( isinstance(doc, dict) and "merged_tables" in doc for doc in pred_data.values() ) if has_merged_tables_in_pred: print("Preprocessing prediction data (merging tables)...") pred_data = preprocess_merged_tables(pred_data) else: print("Prediction data does not contain 'merged_tables' key - skipping preprocessing (assuming already merged)") valid_keys, error_keys, missing_keys = check_data_validity(label_data, pred_data) # Report data quality statistics total_gt_samples = len(label_data) print(f"Total GT samples: {total_gt_samples}") print(f"Valid predictions: {len(valid_keys)}") print(f"Predictions with errors: {len(error_keys)}") print(f"Missing predictions: {len(missing_keys)}") if error_keys: print(f"\nSkipping {len(error_keys)} samples with errors:") for key in error_keys[:5]: # Show first 5 print(f" - {key}") if len(error_keys) > 5: print(f" ... and {len(error_keys) - 5} more") if missing_keys: print(f"\nWarning: {len(missing_keys)} samples missing from predictions") if not valid_keys: raise ValueError("No valid predictions found. Cannot perform evaluation.") print("-" * 50) # Filter data to only include valid keys filtered_label_data = {k: label_data[k] for k in valid_keys} filtered_pred_data = {k: pred_data[k] for k in valid_keys} # Prepare output file path pred_path_obj = Path(args.pred_path) eval_output_path = pred_path_obj.with_suffix(".eval.json") # Collect evaluation results eval_results = { "ref_path": args.ref_path, "pred_path": args.pred_path, "mode": args.mode, "evaluate_merged_table": args.evaluate_merged_table, "data_statistics": { "total_gt_samples": total_gt_samples, "valid_predictions": len(valid_keys), "error_predictions": len(error_keys), "missing_predictions": len(missing_keys), }, "per_image_results": {} } if args.mode == "layout" or args.mode == "all": if args.mode == "all": print("=" * 50) print("Layout Evaluation") print("=" * 50) score, per_image_layout_scores = evaluate_layout( filtered_label_data, filtered_pred_data, ignore_classes=args.ignore_classes_for_layout, filter_by_gt_area=args.filter_by_gt_area, ) print(f"NID Score: {score:.4f}") eval_results["layout"] = { "nid_score": score, "ignore_classes": args.ignore_classes_for_layout, "filter_by_gt_area": args.filter_by_gt_area, } # Merge per-image layout scores into per_image_results for image_key, scores_dict in per_image_layout_scores.items(): if image_key not in eval_results["per_image_results"]: eval_results["per_image_results"][image_key] = {} eval_results["per_image_results"][image_key]["layout"] = scores_dict if args.filter_by_gt_area: print("Note: Spatial filtering by GT area is enabled (predictions within GT ignored regions are filtered)") if args.mode == "all": print() if args.mode == "table" or args.mode == "all": if args.mode == "all": print("=" * 50) print("Table Evaluation") print("=" * 50) table_f1_score, teds_score, teds_s_score, per_image_table_scores = evaluate_table( filtered_label_data, filtered_pred_data, min_match_score=args.min_match_score, max_workers=args.max_workers, ) print(f"Table F1 Score: {table_f1_score:.4f}") print(f"TEDS-S Score: {teds_s_score:.4f}") print(f"TEDS Score: {teds_score:.4f}") eval_results["table"] = { "table_f1_score": table_f1_score, "teds_score": teds_score, "teds_s_score": teds_s_score, "min_match_score": args.min_match_score, } # Merge per-image table scores into per_image_results for image_key, scores_dict in per_image_table_scores.items(): if image_key not in eval_results["per_image_results"]: eval_results["per_image_results"][image_key] = {} eval_results["per_image_results"][image_key]["table"] = scores_dict if args.mode == "speed" or args.mode == "all": if args.mode == "all": print("=" * 50) print("Speed Evaluation") print("=" * 50) # Calculate latency and throughput from time_sec fields (including errors) total_time = 0.0 count = 0 for image_key, image_data in pred_data.items(): if image_key == "_metadata": continue # Skip metadata entry if isinstance(image_data, dict) and "time_sec" in image_data: total_time += image_data["time_sec"] count += 1 if count > 0: avg_latency = total_time / count sequential_throughput = 60.0 / avg_latency if avg_latency > 0 else 0.0 print(f"Average Latency: {avg_latency:.4f} sec/image") print(f"Sequential Throughput: {sequential_throughput:.2f} images/min (based on avg latency)") print(f"Total Images: {count}") print(f"Sum of Latencies: {total_time:.2f} sec") eval_results["speed"] = { "avg_latency_sec": avg_latency, "sequential_throughput_per_minute": sequential_throughput, "total_images": count, "sum_of_latencies_sec": total_time, } # Report concurrent throughput from inference metadata if available metadata = pred_data.get("_metadata") if metadata and "total_elapsed_time_sec" in metadata: elapsed_time = metadata["total_elapsed_time_sec"] concurrent_limit = metadata.get("concurrent_limit") num_files = metadata.get("num_files", count) concurrent_throughput = (num_files / elapsed_time) * 60 if elapsed_time > 0 else 0.0 print(f"\nConcurrent Throughput: {concurrent_throughput:.2f} images/min (wall-clock time)") print(f" - Elapsed Time: {elapsed_time:.2f} sec") if concurrent_limit: print(f" - Concurrency: {concurrent_limit}") eval_results["speed"]["concurrent_throughput_per_minute"] = concurrent_throughput eval_results["speed"]["elapsed_time_sec"] = elapsed_time eval_results["speed"]["concurrent_limit"] = concurrent_limit else: print("Warning: No time_sec fields found in prediction data") eval_results["speed"] = { "avg_latency_sec": None, "sequential_throughput_per_minute": None, "total_images": 0, "sum_of_latencies_sec": 0.0, } # Save evaluation results to JSON file with open(eval_output_path, "w", encoding="utf-8") as f: json.dump(eval_results, f, indent=2, ensure_ascii=False) print(f"\nEvaluation results saved to: {eval_output_path}") if __name__ == "__main__": main()