Datasets:

upstage
/

dp-bench

ArXiv:

Tags:

nlp

Image-to-Text

License:

Dataset card Files Files and versions

xet

Community

dp-bench / evaluate.py

mer9ury

refactor: Sync evaluation pipeline, scripts, and docs from private repo

1e9a6e5 6 months ago

Raw History Blame

10.1 kB

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()

	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()