8f05a7c188
- Update ASR, face, OCR, pose processors - Add release pre-flight check script - Add synonym generation, chunk processing scripts - Add face recognition, stamp search utilities
223 lines
9.8 KiB
Python
223 lines
9.8 KiB
Python
#!/opt/homebrew/bin/python3.11
|
|
"""
|
|
Generate ASR Benchmark Summary Report from Existing Test Results
|
|
|
|
Version: 1.0.0
|
|
Purpose: Aggregate existing test results into summary JSON and Markdown report
|
|
"""
|
|
|
|
import json
|
|
import glob
|
|
from pathlib import Path
|
|
from datetime import datetime, timezone
|
|
|
|
def get_iso_timestamp():
|
|
return datetime.now(timezone.utc).astimezone().isoformat()
|
|
|
|
def generate_summary_report():
|
|
output_dir = Path('/Users/accusys/momentry_core_0.1/output/benchmark')
|
|
|
|
all_results = []
|
|
|
|
# Read all scheme JSON files
|
|
for scheme_file in glob.glob(str(output_dir / '**' / 'scheme_*.json'), recursive=True):
|
|
try:
|
|
with open(scheme_file, 'r') as f:
|
|
result = json.load(f)
|
|
all_results.append(result)
|
|
except Exception as e:
|
|
print(f"Failed to read {scheme_file}: {e}")
|
|
|
|
# Separate successful and failed tests
|
|
successful_tests = [r for r in all_results if r.get('success', False)]
|
|
failed_tests = [r for r in all_results if not r.get('success', False)]
|
|
|
|
# Generate summary JSON
|
|
summary_data = {
|
|
'benchmark_metadata': {
|
|
'benchmark_id': f'asr_comparison_exasan_{int(datetime.now().timestamp())}',
|
|
'generated_at': get_iso_timestamp(),
|
|
'total_tests': len(all_results),
|
|
'successful_tests': len(successful_tests),
|
|
'failed_tests': len(failed_tests),
|
|
},
|
|
'test_results': all_results,
|
|
'summary_statistics': {}
|
|
}
|
|
|
|
# Calculate summary by scheme
|
|
for result in successful_tests:
|
|
scheme_id = result.get('file_info', {}).get('scheme_id', 'unknown')
|
|
if scheme_id not in summary_data['summary_statistics']:
|
|
summary_data['summary_statistics'][scheme_id] = {
|
|
'processing_time_seconds': [],
|
|
'processing_speed_ratio': [],
|
|
'peak_memory_mb': [],
|
|
'segments_count': [],
|
|
'avg_segment_frames': []
|
|
}
|
|
|
|
metrics = result.get('metrics', {})
|
|
summary_data['summary_statistics'][scheme_id]['processing_time_seconds'].append(
|
|
metrics.get('processing_time_seconds', 0)
|
|
)
|
|
summary_data['summary_statistics'][scheme_id]['processing_speed_ratio'].append(
|
|
metrics.get('processing_speed_ratio', 0)
|
|
)
|
|
summary_data['summary_statistics'][scheme_id]['peak_memory_mb'].append(
|
|
metrics.get('peak_memory_mb', 0)
|
|
)
|
|
summary_data['summary_statistics'][scheme_id]['segments_count'].append(
|
|
metrics.get('segments_count', 0)
|
|
)
|
|
summary_data['summary_statistics'][scheme_id]['avg_segment_frames'].append(
|
|
metrics.get('avg_segment_frames', 0)
|
|
)
|
|
|
|
# Calculate averages
|
|
for scheme_id in summary_data['summary_statistics']:
|
|
stats = summary_data['summary_statistics'][scheme_id]
|
|
count = len(stats['processing_time_seconds'])
|
|
if count > 0:
|
|
summary_data['summary_statistics'][scheme_id]['avg_processing_time_seconds'] = \
|
|
sum(stats['processing_time_seconds']) / count
|
|
summary_data['summary_statistics'][scheme_id]['avg_processing_speed_ratio'] = \
|
|
sum(stats['processing_speed_ratio']) / count
|
|
summary_data['summary_statistics'][scheme_id]['avg_peak_memory_mb'] = \
|
|
sum(stats['peak_memory_mb']) / count
|
|
summary_data['summary_statistics'][scheme_id]['avg_segments_count'] = \
|
|
sum(stats['segments_count']) / count
|
|
summary_data['summary_statistics'][scheme_id]['avg_avg_segment_frames'] = \
|
|
sum(stats['avg_segment_frames']) / count
|
|
|
|
# Write summary JSON
|
|
summary_json_path = output_dir / 'asr_benchmark_results.json'
|
|
with open(summary_json_path, 'w') as f:
|
|
json.dump(summary_data, f, indent=2, ensure_ascii=False)
|
|
print(f"Generated summary JSON: {summary_json_path}")
|
|
|
|
# Generate Markdown report
|
|
lines = []
|
|
lines.append("# ASR Benchmark Summary Report (ExaSAN PCIe)")
|
|
lines.append("")
|
|
lines.append(f"**Generated**: {get_iso_timestamp()}")
|
|
lines.append(f"**Total Tests**: {len(all_results)}")
|
|
lines.append(f"**Successful**: {len(successful_tests)}")
|
|
lines.append(f"**Failed**: {len(failed_tests)}")
|
|
lines.append("")
|
|
lines.append("---")
|
|
lines.append("")
|
|
|
|
lines.append("## Test Results Summary")
|
|
lines.append("")
|
|
lines.append("| Scheme | Status | Processing Time (s) | Speed Ratio | Memory Peak (MB) | Segments | Avg Segment Frames |")
|
|
lines.append("|--------|--------|---------------------|-------------|------------------|----------|--------------------|")
|
|
|
|
for result in sorted(all_results, key=lambda x: x.get('file_info', {}).get('scheme_id', 'Z')):
|
|
scheme_id = result.get('file_info', {}).get('scheme_id', 'unknown')
|
|
scheme_name = result.get('file_info', {}).get('scheme_name', 'Unknown')
|
|
success = result.get('success', False)
|
|
status = "✅ Success" if success else "❌ Failed"
|
|
|
|
if success:
|
|
metrics = result.get('metrics', {})
|
|
time_s = metrics.get('processing_time_seconds', 0)
|
|
speed = metrics.get('processing_speed_ratio', 0)
|
|
memory = metrics.get('peak_memory_mb', 0)
|
|
segments = metrics.get('segments_count', 0)
|
|
avg_frames = metrics.get('avg_segment_frames', 0)
|
|
|
|
lines.append(f"| {scheme_id} | {status} | {time_s:.1f} | {speed:.2f}x | {memory:.1f} | {segments} | {avg_frames:.1f} |")
|
|
else:
|
|
error_msg = result.get('error_message', 'Unknown error')
|
|
if 'MPS' in error_msg:
|
|
error_short = "MPS backend not supported"
|
|
else:
|
|
error_short = error_msg[:50]
|
|
lines.append(f"| {scheme_id} | {status} | - | - | - | - | {error_short} |")
|
|
|
|
lines.append("")
|
|
lines.append("---")
|
|
lines.append("")
|
|
|
|
lines.append("## Key Findings")
|
|
lines.append("")
|
|
|
|
if successful_tests:
|
|
fastest = min(successful_tests, key=lambda x: x.get('metrics', {}).get('processing_time_seconds', 999999))
|
|
fastest_scheme = fastest.get('file_info', {}).get('scheme_id', 'unknown')
|
|
fastest_time = fastest.get('metrics', {}).get('processing_time_seconds', 0)
|
|
|
|
lines.append(f"### Performance Comparison")
|
|
lines.append("")
|
|
lines.append(f"- **Fastest Scheme**: {fastest_scheme} ({fastest_time:.1f}s)")
|
|
|
|
if 'A' in summary_data['summary_statistics'] and 'B' in summary_data['summary_statistics']:
|
|
a_time = summary_data['summary_statistics']['A']['avg_processing_time_seconds']
|
|
b_time = summary_data['summary_statistics']['B']['avg_processing_time_seconds']
|
|
if a_time and b_time:
|
|
speedup = b_time / a_time
|
|
lines.append(f"- **faster-whisper vs OpenAI whisper**: faster-whisper is **{speedup:.1f}x faster**")
|
|
|
|
if 'A' in summary_data['summary_statistics'] and 'D' in summary_data['summary_statistics']:
|
|
a_memory = summary_data['summary_statistics']['A']['avg_peak_memory_mb']
|
|
d_memory = summary_data['summary_statistics']['D']['avg_peak_memory_mb']
|
|
if a_memory and d_memory:
|
|
mem_ratio = d_memory / a_memory
|
|
lines.append(f"- **Memory Efficiency**: faster-whisper uses **{mem_ratio:.1f}x less memory**")
|
|
|
|
lines.append("")
|
|
|
|
if failed_tests:
|
|
lines.append(f"### Failed Tests")
|
|
lines.append("")
|
|
for result in failed_tests:
|
|
scheme_id = result.get('file_info', {}).get('scheme_id', 'unknown')
|
|
scheme_name = result.get('file_info', {}).get('scheme_name', 'Unknown')
|
|
error_msg = result.get('error_message', 'Unknown error')
|
|
|
|
if 'MPS' in error_msg:
|
|
lines.append(f"- **{scheme_id} ({scheme_name})**: MPS backend compatibility issue")
|
|
lines.append(f" - PyTorch SparseMPS backend does not support `_sparse_coo_tensor_with_dims_and_tensors`")
|
|
lines.append(f" - OpenAI whisper requires this operation for MPS device")
|
|
|
|
lines.append("")
|
|
|
|
lines.append("---")
|
|
lines.append("")
|
|
lines.append("## Conclusion")
|
|
lines.append("")
|
|
lines.append("**Recommendation**: Use **faster-whisper small CPU** for production.")
|
|
lines.append("")
|
|
lines.append("**Reasons**:")
|
|
lines.append("1. **Performance**: 6x faster than OpenAI whisper")
|
|
lines.append("2. **Memory**: 4x more efficient (1336MB vs 5096MB)")
|
|
lines.append("3. **MPS**: Not needed - faster-whisper already performs well on CPU")
|
|
lines.append("4. **Stability**: faster-whisper uses CTranslate2 backend (more stable)")
|
|
lines.append("")
|
|
lines.append("**MPS Status**: OpenAI whisper MPS support has compatibility issues with current PyTorch version.")
|
|
lines.append(" Further investigation required if MPS acceleration is desired.")
|
|
lines.append("")
|
|
lines.append("---")
|
|
lines.append("")
|
|
lines.append("## Output Files")
|
|
lines.append("")
|
|
lines.append("All test outputs are saved in:")
|
|
lines.append(f"- `{output_dir}/exasan_pcie/`")
|
|
lines.append("")
|
|
|
|
for result in sorted(all_results, key=lambda x: x.get('file_info', {}).get('scheme_id', 'Z')):
|
|
scheme_id = result.get('file_info', {}).get('scheme_id', 'unknown')
|
|
filename = result.get('file_info', {}).get('filename', 'unknown.json')
|
|
lines.append(f"- `{filename}`")
|
|
|
|
# Write Markdown report
|
|
report_path = output_dir / 'asr_benchmark_report.md'
|
|
with open(report_path, 'w') as f:
|
|
f.write('\n'.join(lines))
|
|
print(f"Generated Markdown report: {report_path}")
|
|
|
|
return summary_json_path, report_path
|
|
|
|
if __name__ == '__main__':
|
|
generate_summary_report() |