From 0e9e83b7ead009ff8661f1bd0b7a0f0ca0e5875d Mon Sep 17 00:00:00 2001 From: "claude[bot]" <41898282+claude[bot]@users.noreply.github.com> Date: Sun, 30 Nov 2025 11:17:45 +0000 Subject: [PATCH] Add OCR benchmark test feature MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Implemented a comprehensive OCR benchmark testing framework that can test different OCR open source SDKs like PaddleOCR, Tesseract OCR, and provides a placeholder for DeepSeek OCR. Features: - Base classes for OCR models and results - Support for PaddleOCR with Chinese/English language support - Support for Tesseract OCR with multiple languages - Extensible architecture for adding custom OCR models - Benchmark framework with performance metrics - Ground truth comparison for accuracy measurement - Batch processing support - Model registry for easy access - Comprehensive documentation and examples Files added: - src/ragent_lab/ocr_benchmark/: Core OCR benchmark module - docs/ocr_benchmark.md: Detailed documentation - examples/ocr_benchmark_example.py: Usage examples - tests/test_ocr_benchmark.py: Test suite - requirements-ocr.txt: Optional OCR dependencies Resolves #4 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-authored-by: square --- README.md | 48 ++- docs/ocr_benchmark.md | 426 +++++++++++++++++++++ examples/ocr_benchmark_example.py | 227 +++++++++++ requirements-ocr.txt | 13 + src/ragent_lab/ocr_benchmark/__init__.py | 40 ++ src/ragent_lab/ocr_benchmark/base.py | 142 +++++++ src/ragent_lab/ocr_benchmark/benchmark.py | 248 ++++++++++++ src/ragent_lab/ocr_benchmark/registry.py | 115 ++++++ src/ragent_lab/ocr_benchmark/strategies.py | 259 +++++++++++++ tests/test_ocr_benchmark.py | 135 +++++++ 10 files changed, 1652 insertions(+), 1 deletion(-) create mode 100644 docs/ocr_benchmark.md create mode 100644 examples/ocr_benchmark_example.py create mode 100644 requirements-ocr.txt create mode 100644 src/ragent_lab/ocr_benchmark/__init__.py create mode 100644 src/ragent_lab/ocr_benchmark/base.py create mode 100644 src/ragent_lab/ocr_benchmark/benchmark.py create mode 100644 src/ragent_lab/ocr_benchmark/registry.py create mode 100644 src/ragent_lab/ocr_benchmark/strategies.py create mode 100644 tests/test_ocr_benchmark.py diff --git a/README.md b/README.md index b9bf7a6..e44a156 100644 --- a/README.md +++ b/README.md @@ -15,6 +15,11 @@ ragent-lab/ │ │ ├── base.py # 基础嵌入类和工具 │ │ ├── strategies.py # 嵌入模型实现 │ │ └── registry.py # 模型注册和管理 +│ ├── ocr_benchmark/ # OCR 基准测试 +│ │ ├── base.py # 基础OCR类和工具 +│ │ ├── strategies.py # OCR模型实现 +│ │ ├── registry.py # 模型注册和管理 +│ │ └── benchmark.py # 基准测试框架 │ ├── config/ # 配置模块 │ │ └── settings.py # 应用配置 │ ├── utils/ # 工具函数 @@ -27,7 +32,8 @@ ragent-lab/ │ └── __init__.py ├── main.py # 主入口文件 ├── streamlit_app.py # Streamlit应用入口 -└── requirements.txt # 依赖文件 +├── requirements.txt # 依赖文件 +└── requirements-ocr.txt # OCR可选依赖 ``` ## 功能特性 @@ -46,6 +52,17 @@ ragent-lab/ - **子文档分块**: 提取包含特定关键词的子文档 - **混合分块**: 组合多种分块策略 +### OCR 基准测试 (NEW!) + +- **多引擎支持**: 支持 PaddleOCR、Tesseract OCR、DeepSeek OCR 等 +- **性能对比**: 自动测试和比较不同 OCR 引擎的性能 +- **准确度评估**: 支持与真实文本对比，计算识别准确度 +- **详细指标**: 处理时间、置信度、成功率等综合指标 +- **批量处理**: 支持批量图像识别和测试 +- **可扩展架构**: 轻松添加自定义 OCR 模型 + +详细文档请参考: [OCR Benchmark 文档](docs/ocr_benchmark.md) + ## 安装和使用 ### 环境要求 @@ -58,6 +75,9 @@ ragent-lab/ # 安装依赖 pip install -r requirements.txt +# 安装 OCR 功能依赖（可选） +pip install -r requirements-ocr.txt + # 配置环境变量（可选） cp env.example .env # 编辑 .env 文件，填入你的 OpenAI API Key @@ -113,6 +133,32 @@ for name, info in models.items(): print(f"{name}: {info['desc']}") ``` +#### OCR 基准测试 +```python +from ragent_lab.ocr_benchmark import OCRBenchmark, list_ocr_models + +# 列出可用的 OCR 模型 +print(list_ocr_models()) + +# 创建基准测试实例 +benchmark = OCRBenchmark(models=['paddleocr', 'tesseract']) + +# 运行基准测试 +image_paths = ['image1.jpg', 'image2.png'] +results = benchmark.benchmark_all(image_paths) + +# 打印结果 +benchmark.print_results(results) + +# 单独使用 OCR 模型 +from ragent_lab.ocr_benchmark import PaddleOCRModel + +model = PaddleOCRModel(lang='ch') +result = model.recognize('document.jpg') +print(f"识别文本: {result.text}") +print(f"置信度: {result.confidence:.2%}") +``` + ## Docker 部署 ### 使用 Docker Compose（推荐） diff --git a/docs/ocr_benchmark.md b/docs/ocr_benchmark.md new file mode 100644 index 0000000..2cf427e --- /dev/null +++ b/docs/ocr_benchmark.md @@ -0,0 +1,426 @@ +# OCR Benchmark Feature + +OCR (Optical Character Recognition) Benchmark is a comprehensive testing framework for evaluating and comparing different OCR engines. + +## Overview + +The OCR Benchmark module provides a unified interface for testing various OCR SDKs including: + +- **PaddleOCR**: Fast and accurate OCR with excellent Chinese language support +- **Tesseract OCR**: Open-source OCR engine with broad language support +- **DeepSeek OCR**: Advanced OCR model (placeholder for future implementation) +- **Custom OCR models**: Extensible framework for adding your own OCR implementations + +## Features + +- **Multi-model support**: Test and compare multiple OCR engines simultaneously +- **Performance metrics**: Track processing time, confidence scores, and success rates +- **Ground truth comparison**: Measure accuracy against known text +- **Batch processing**: Process multiple images efficiently +- **Extensible architecture**: Easy to add new OCR models +- **Detailed reporting**: Comprehensive benchmark results with visualizations + +## Installation + +### Basic Installation + +```bash +# Install the main package +pip install -r requirements.txt +``` + +### OCR Dependencies + +Install OCR-specific dependencies: + +```bash +# Install all OCR dependencies +pip install -r requirements-ocr.txt +``` + +Or install specific OCR engines: + +```bash +# PaddleOCR +pip install paddleocr paddlepaddle + +# Tesseract OCR +pip install pytesseract Pillow + +# Additional image processing +pip install opencv-python +``` + +### System Requirements + +**For Tesseract OCR**, you also need to install the Tesseract engine: + +- **Ubuntu/Debian**: `sudo apt-get install tesseract-ocr` +- **macOS**: `brew install tesseract` +- **Windows**: Download from [GitHub releases](https://github.com/UB-Mannheim/tesseract/wiki) + +## Quick Start + +### Basic Usage + +```python +from ragent_lab.ocr_benchmark import OCRBenchmark, list_ocr_models + +# List available models +print(list_ocr_models()) + +# Create benchmark with specific models +benchmark = OCRBenchmark(models=['paddleocr', 'tesseract']) + +# Benchmark on images +image_paths = ['image1.jpg', 'image2.png'] +results = benchmark.benchmark_all(image_paths) + +# Print results +benchmark.print_results(results) +``` + +### Single Model Usage + +```python +from ragent_lab.ocr_benchmark import PaddleOCRModel + +# Create a model instance +model = PaddleOCRModel(lang='ch', use_gpu=False) + +# Recognize text from an image +result = model.recognize('document.jpg') + +print(f"Text: {result.text}") +print(f"Confidence: {result.confidence:.2%}") +print(f"Processing time: {result.processing_time:.3f}s") +``` + +### With Ground Truth + +```python +from ragent_lab.ocr_benchmark import OCRBenchmark + +# Define ground truth +ground_truth = { + 'invoice1.jpg': 'Invoice #12345', + 'receipt.jpg': 'Total: $99.99' +} + +benchmark = OCRBenchmark(models=['paddleocr']) +results = benchmark.benchmark_all( + image_paths=list(ground_truth.keys()), + ground_truth=ground_truth +) + +# Check accuracy +for model_name, result in results.items(): + for ocr_result in result.results: + accuracy = ocr_result.metadata.get('accuracy', 0) + print(f"Accuracy: {accuracy:.2%}") +``` + +## Available Models + +### PaddleOCR + +```python +from ragent_lab.ocr_benchmark import PaddleOCRModel + +# Chinese + English (default) +model = PaddleOCRModel(lang='ch') + +# English only +model = PaddleOCRModel(lang='en') + +# With GPU support +model = PaddleOCRModel(lang='ch', use_gpu=True) + +# Disable angle classification (faster but less accurate) +model = PaddleOCRModel(lang='ch', use_angle_cls=False) +``` + +**Supported languages**: Chinese, English, Korean, Japanese, French, German + +### Tesseract OCR + +```python +from ragent_lab.ocr_benchmark import TesseractOCRModel + +# English + Simplified Chinese +model = TesseractOCRModel(lang='eng+chi_sim') + +# English only +model = TesseractOCRModel(lang='eng') + +# Traditional Chinese +model = TesseractOCRModel(lang='chi_tra') +``` + +**Supported languages**: English, Chinese (Simplified/Traditional), Japanese, Korean, and [many more](https://github.com/tesseract-ocr/tessdata) + +### Using Registry + +```python +from ragent_lab.ocr_benchmark import get_ocr_model, list_ocr_models + +# List all registered models +models = list_ocr_models() +# ['paddleocr', 'paddleocr_en', 'tesseract', 'tesseract_en', 'deepseek_ocr'] + +# Get a model by name +model = get_ocr_model('paddleocr') +result = model.recognize('image.jpg') +``` + +## Benchmark Metrics + +The benchmark provides comprehensive metrics: + +- **Total Images**: Number of images processed +- **Successful**: Number of successfully processed images +- **Failed**: Number of failed images +- **Success Rate**: Percentage of successful recognitions +- **Average Confidence**: Mean confidence score across all results +- **Average Processing Time**: Mean time per image +- **Total Time**: Total benchmark duration + +### Example Output + +``` +================================================================================ +OCR BENCHMARK RESULTS +================================================================================ + +PaddleOCR (ch): + Total Images: 10 + Successful: 10 + Failed: 0 + Success Rate: 100.00% + Average Confidence: 0.9234 + Average Processing Time: 0.3421s + Total Time: 3.4567s + +Tesseract (eng+chi_sim): + Total Images: 10 + Successful: 9 + Failed: 1 + Success Rate: 90.00% + Average Confidence: 0.8567 + Average Processing Time: 0.5123s + Total Time: 5.2345s + +-------------------------------------------------------------------------------- + +Performance Summary: + Fastest: PaddleOCR (ch) (0.3421s) + Most Confident: PaddleOCR (ch) (0.9234) + Highest Success Rate: PaddleOCR (ch) (100.00%) +================================================================================ +``` + +## Creating Custom OCR Models + +Extend the framework with your own OCR implementation: + +```python +from ragent_lab.ocr_benchmark import OCRModel, OCRResult +import time + +class CustomOCRModel(OCRModel): + def __init__(self): + super().__init__( + name="Custom OCR", + description="My custom OCR implementation", + supports_batch=False, + supports_languages=['en', 'zh'] + ) + # Initialize your model here + + def recognize(self, image_path, **kwargs): + start_time = time.time() + + # Your OCR logic here + text = self._your_ocr_function(image_path) + confidence = self._calculate_confidence() + + processing_time = time.time() - start_time + + return OCRResult( + text=text, + confidence=confidence, + model_name=self.name, + processing_time=processing_time, + metadata={'custom_field': 'value'} + ) + +# Register your model +from ragent_lab.ocr_benchmark import register_ocr_model + +register_ocr_model( + name='custom_ocr', + factory=lambda: CustomOCRModel(), + description='My custom OCR model', + requires=['your_dependencies'] +) +``` + +## Advanced Usage + +### Batch Processing + +```python +model = PaddleOCRModel() + +# Process multiple images +image_paths = ['img1.jpg', 'img2.jpg', 'img3.jpg'] +results = model.recognize_batch(image_paths) + +for result in results: + print(f"Text: {result.text[:50]}...") +``` + +### Comparing Models + +```python +benchmark = OCRBenchmark(models=['paddleocr', 'tesseract']) +results = benchmark.benchmark_all(image_paths) + +# Get comparison statistics +comparison = benchmark.compare_models(results) + +# Access specific metrics +fastest = comparison['metrics']['fastest'] +most_confident = comparison['metrics']['most_confident'] + +print(f"Fastest model: {fastest['name']}") +print(f"Most confident: {most_confident['name']}") +``` + +### Accessing Bounding Boxes + +```python +model = PaddleOCRModel() +result = model.recognize('document.jpg') + +# Access bounding boxes (if available) +if result.bounding_boxes: + for bbox in result.bounding_boxes: + print(f"Text: {bbox['text']}") + print(f"Confidence: {bbox['confidence']:.2%}") + print(f"Box: {bbox['box']}") +``` + +## Performance Tips + +1. **Use GPU acceleration** for PaddleOCR when processing many images: + ```python + model = PaddleOCRModel(use_gpu=True) + ``` + +2. **Choose appropriate language models** to improve accuracy: + ```python + # For English documents only + model = PaddleOCRModel(lang='en') + ``` + +3. **Disable angle classification** if images are already properly oriented: + ```python + model = PaddleOCRModel(use_angle_cls=False) + ``` + +4. **Batch processing** when supported: + ```python + results = model.recognize_batch(image_paths) + ``` + +## Troubleshooting + +### PaddleOCR Issues + +**Import Error**: Install PaddleOCR and PaddlePaddle: +```bash +pip install paddleocr paddlepaddle +``` + +**GPU Error**: Ensure CUDA is properly installed or use CPU: +```python +model = PaddleOCRModel(use_gpu=False) +``` + +### Tesseract Issues + +**Tesseract not found**: Install the Tesseract engine system-wide: +```bash +# Ubuntu/Debian +sudo apt-get install tesseract-ocr + +# macOS +brew install tesseract +``` + +**Language data missing**: Install language packs: +```bash +# Ubuntu/Debian +sudo apt-get install tesseract-ocr-chi-sim tesseract-ocr-chi-tra +``` + +## Examples + +See the `examples/ocr_benchmark_example.py` file for comprehensive examples: + +```bash +python examples/ocr_benchmark_example.py +``` + +## Testing + +Run the test suite: + +```bash +python -m pytest tests/test_ocr_benchmark.py -v +``` + +Or using unittest: + +```bash +python tests/test_ocr_benchmark.py +``` + +## API Reference + +### Classes + +- `OCRModel`: Abstract base class for OCR models +- `OCRResult`: Result of OCR operation +- `BenchmarkResult`: Result of benchmark test +- `PaddleOCRModel`: PaddleOCR implementation +- `TesseractOCRModel`: Tesseract OCR implementation +- `OCRBenchmark`: Benchmark testing framework + +### Functions + +- `list_ocr_models()`: List all registered models +- `get_ocr_model(name)`: Get a model by name +- `register_ocr_model(name, factory, ...)`: Register a custom model + +## Contributing + +To add a new OCR engine: + +1. Create a new class inheriting from `OCRModel` +2. Implement the `recognize()` method +3. Add factory function in `strategies.py` +4. Register in `registry.py` +5. Add tests in `tests/test_ocr_benchmark.py` +6. Update documentation + +## License + +MIT License + +## Support + +For issues and questions: +- GitHub Issues: [Project Issues](https://github.com/squarezw/ragent-lab/issues) +- Documentation: `docs/ocr_benchmark.md` diff --git a/examples/ocr_benchmark_example.py b/examples/ocr_benchmark_example.py new file mode 100644 index 0000000..07b64df --- /dev/null +++ b/examples/ocr_benchmark_example.py @@ -0,0 +1,227 @@ +""" +Example usage of OCR benchmark feature. + +This script demonstrates how to use the OCR benchmark module to test +different OCR engines on a set of images. +""" + +import sys +from pathlib import Path + +# Add src directory to Python path +src_path = Path(__file__).parent.parent / "src" +sys.path.insert(0, str(src_path)) + +from ragent_lab.ocr_benchmark import ( + OCRBenchmark, + PaddleOCRModel, + TesseractOCRModel, + get_ocr_model, + list_ocr_models +) + + +def example_basic_usage(): + """Example: Basic OCR benchmark usage.""" + print("="*80) + print("Example 1: Basic OCR Benchmark") + print("="*80) + + # List available OCR models + print("\nAvailable OCR models:") + for model_name in list_ocr_models(): + print(f" - {model_name}") + + # Create benchmark with specific models + # Note: These models require installation of their dependencies + try: + benchmark = OCRBenchmark(models=['paddleocr', 'tesseract']) + print(f"\nCreated benchmark with {len(benchmark.models)} models") + except Exception as e: + print(f"\nNote: Some models may not be available: {e}") + print("Install required packages:") + print(" - PaddleOCR: pip install paddleocr paddlepaddle") + print(" - Tesseract: pip install pytesseract Pillow") + + +def example_single_model(): + """Example: Test a single OCR model.""" + print("\n" + "="*80) + print("Example 2: Testing a Single OCR Model") + print("="*80) + + try: + # Create a single model instance + model = PaddleOCRModel(lang='ch', use_gpu=False) + print(f"\nCreated model: {model.name}") + print(f"Supports languages: {model.supports_languages}") + + # Example: Recognize text from an image + # image_path = "path/to/your/image.jpg" + # result = model.recognize(image_path) + # print(f"Recognized text: {result.text}") + # print(f"Confidence: {result.confidence:.4f}") + # print(f"Processing time: {result.processing_time:.4f}s") + + print("\nTo use this model, provide an image path:") + print(" result = model.recognize('path/to/image.jpg')") + + except ImportError as e: + print(f"\nModel dependencies not installed: {e}") + + +def example_benchmark_comparison(): + """Example: Compare multiple OCR models.""" + print("\n" + "="*80) + print("Example 3: Comparing Multiple OCR Models") + print("="*80) + + # Sample image paths (replace with your actual images) + sample_images = [ + # "path/to/image1.jpg", + # "path/to/image2.png", + # "path/to/image3.jpg", + ] + + if not sample_images: + print("\nTo run a benchmark comparison:") + print("1. Prepare a set of test images") + print("2. Add image paths to the sample_images list") + print("3. Run the benchmark:") + print("\n benchmark = OCRBenchmark(models=['paddleocr', 'tesseract'])") + print(" results = benchmark.benchmark_all(sample_images)") + print(" benchmark.print_results(results)") + return + + try: + # Create benchmark with multiple models + benchmark = OCRBenchmark(models=['paddleocr', 'tesseract']) + + # Run benchmark on all images + results = benchmark.benchmark_all(sample_images) + + # Print formatted results + benchmark.print_results(results) + + # Compare models + comparison = benchmark.compare_models(results) + print("\nModel Comparison:") + for model_info in comparison['models']: + print(f" {model_info['name']}:") + print(f" Success Rate: {model_info['success_rate']:.2%}") + print(f" Avg Confidence: {model_info['average_confidence']:.4f}") + print(f" Avg Time: {model_info['average_processing_time']:.4f}s") + + except Exception as e: + print(f"\nError running benchmark: {e}") + + +def example_with_ground_truth(): + """Example: Benchmark with ground truth for accuracy measurement.""" + print("\n" + "="*80) + print("Example 4: Benchmark with Ground Truth") + print("="*80) + + # Sample images with expected text + ground_truth = { + # "path/to/image1.jpg": "Expected text for image 1", + # "path/to/image2.jpg": "Expected text for image 2", + } + + if not ground_truth: + print("\nTo measure OCR accuracy against ground truth:") + print("1. Prepare test images with known text") + print("2. Create a ground_truth dictionary:") + print(" ground_truth = {") + print(" 'image1.jpg': 'Expected text',") + print(" 'image2.jpg': 'Another text',") + print(" }") + print("3. Run benchmark with ground truth:") + print(" results = benchmark.benchmark_all(image_paths, ground_truth=ground_truth)") + return + + try: + benchmark = OCRBenchmark(models=['paddleocr']) + image_paths = list(ground_truth.keys()) + + # Run benchmark with ground truth + results = benchmark.benchmark_all(image_paths, ground_truth=ground_truth) + + # Check accuracy in results + for model_name, result in results.items(): + print(f"\n{model_name} Results:") + for ocr_result in result.results: + accuracy = ocr_result.metadata.get('accuracy', 0.0) + print(f" Image: {ocr_result.metadata.get('image_path', 'unknown')}") + print(f" Accuracy: {accuracy:.2%}") + + except Exception as e: + print(f"\nError: {e}") + + +def example_custom_model(): + """Example: Create and use a custom OCR model.""" + print("\n" + "="*80) + print("Example 5: Creating a Custom OCR Model") + print("="*80) + + print("\nTo create a custom OCR model, inherit from OCRModel:") + print(""" + from ragent_lab.ocr_benchmark import OCRModel, OCRResult + import time + + class CustomOCRModel(OCRModel): + def __init__(self): + super().__init__( + name="Custom OCR", + description="My custom OCR implementation", + supports_batch=False + ) + + def recognize(self, image_path, **kwargs): + start_time = time.time() + # Your OCR implementation here + text = "recognized text" + confidence = 0.95 + processing_time = time.time() - start_time + + return OCRResult( + text=text, + confidence=confidence, + model_name=self.name, + processing_time=processing_time, + metadata={} + ) + + # Use the custom model + model = CustomOCRModel() + result = model.recognize("image.jpg") + """) + + +def main(): + """Run all examples.""" + print("\n" + "="*80) + print("OCR BENCHMARK EXAMPLES") + print("="*80) + + example_basic_usage() + example_single_model() + example_benchmark_comparison() + example_with_ground_truth() + example_custom_model() + + print("\n" + "="*80) + print("Examples completed!") + print("="*80) + print("\nFor more information, see the documentation:") + print(" - src/ragent_lab/ocr_benchmark/") + print(" - tests/test_ocr_benchmark.py") + print("\nRequired dependencies:") + print(" - PaddleOCR: pip install paddleocr paddlepaddle") + print(" - Tesseract: pip install pytesseract Pillow") + print("="*80 + "\n") + + +if __name__ == "__main__": + main() diff --git a/requirements-ocr.txt b/requirements-ocr.txt new file mode 100644 index 0000000..db7be54 --- /dev/null +++ b/requirements-ocr.txt @@ -0,0 +1,13 @@ +# Optional OCR dependencies for OCR benchmark feature +# Install with: pip install -r requirements-ocr.txt + +# PaddleOCR - Fast and accurate OCR with Chinese support +paddleocr>=2.7.0 +paddlepaddle>=2.5.0 + +# Tesseract OCR +pytesseract>=0.3.10 +Pillow>=10.0.0 + +# Additional image processing libraries +opencv-python>=4.8.0 diff --git a/src/ragent_lab/ocr_benchmark/__init__.py b/src/ragent_lab/ocr_benchmark/__init__.py new file mode 100644 index 0000000..7acce64 --- /dev/null +++ b/src/ragent_lab/ocr_benchmark/__init__.py @@ -0,0 +1,40 @@ +""" +OCR Benchmark module for testing different OCR SDKs. + +This module provides a comprehensive benchmarking framework for various OCR +(Optical Character Recognition) engines including PaddleOCR, DeepSeek OCR, +Tesseract, and others. +""" + +from .base import OCRModel, OCRResult, BenchmarkResult +from .strategies import ( + PaddleOCRModel, + TesseractOCRModel, +) +from .registry import ( + register_ocr_model, + get_ocr_model, + get_all_ocr_models, + list_ocr_models +) +from .benchmark import OCRBenchmark + +__all__ = [ + # Base classes + 'OCRModel', + 'OCRResult', + 'BenchmarkResult', + + # OCR models + 'PaddleOCRModel', + 'TesseractOCRModel', + + # Registry functions + 'register_ocr_model', + 'get_ocr_model', + 'get_all_ocr_models', + 'list_ocr_models', + + # Benchmark + 'OCRBenchmark', +] diff --git a/src/ragent_lab/ocr_benchmark/base.py b/src/ragent_lab/ocr_benchmark/base.py new file mode 100644 index 0000000..c657f2b --- /dev/null +++ b/src/ragent_lab/ocr_benchmark/base.py @@ -0,0 +1,142 @@ +""" +Base classes and utilities for OCR benchmark testing. +""" + +from typing import List, Dict, Any, Optional, Union +from dataclasses import dataclass, field +from abc import ABC, abstractmethod +from pathlib import Path +import time + + +@dataclass +class OCRResult: + """Result of OCR operation on a single image.""" + text: str + confidence: float + model_name: str + processing_time: float # in seconds + metadata: Dict[str, Any] = field(default_factory=dict) + bounding_boxes: Optional[List[Dict[str, Any]]] = None + + def __post_init__(self): + """Validate OCR result after initialization.""" + if self.confidence < 0 or self.confidence > 1: + raise ValueError("Confidence must be between 0 and 1") + if self.processing_time < 0: + raise ValueError("Processing time cannot be negative") + + +@dataclass +class BenchmarkResult: + """Result of OCR benchmark test.""" + model_name: str + total_images: int + successful: int + failed: int + average_confidence: float + average_processing_time: float + total_time: float + results: List[OCRResult] + errors: List[Dict[str, Any]] = field(default_factory=list) + + @property + def success_rate(self) -> float: + """Calculate success rate.""" + if self.total_images == 0: + return 0.0 + return self.successful / self.total_images + + @property + def error_rate(self) -> float: + """Calculate error rate.""" + return 1.0 - self.success_rate + + def to_dict(self) -> Dict[str, Any]: + """Convert benchmark result to dictionary.""" + return { + 'model_name': self.model_name, + 'total_images': self.total_images, + 'successful': self.successful, + 'failed': self.failed, + 'success_rate': self.success_rate, + 'error_rate': self.error_rate, + 'average_confidence': self.average_confidence, + 'average_processing_time': self.average_processing_time, + 'total_time': self.total_time, + 'errors': self.errors + } + + +class OCRModel(ABC): + """Abstract base class for OCR models.""" + + def __init__(self, name: str, description: str, + supports_batch: bool = False, + supports_languages: Optional[List[str]] = None): + """ + Initialize OCR model. + + Args: + name: Model name + description: Model description + supports_batch: Whether model supports batch processing + supports_languages: List of supported language codes + """ + self.name = name + self.description = description + self.supports_batch = supports_batch + self.supports_languages = supports_languages or ['en', 'zh'] + + @abstractmethod + def recognize(self, image_path: Union[str, Path], **kwargs) -> OCRResult: + """ + Recognize text from an image. + + Args: + image_path: Path to the image file + **kwargs: Additional model-specific parameters + + Returns: + OCRResult containing recognized text and metadata + """ + pass + + def recognize_batch(self, image_paths: List[Union[str, Path]], + **kwargs) -> List[OCRResult]: + """ + Recognize text from multiple images. + + Args: + image_paths: List of paths to image files + **kwargs: Additional model-specific parameters + + Returns: + List of OCRResult for each image + """ + if self.supports_batch: + # Override in subclass for optimized batch processing + return self._recognize_batch_optimized(image_paths, **kwargs) + else: + # Fallback to sequential processing + return [self.recognize(img, **kwargs) for img in image_paths] + + def _recognize_batch_optimized(self, image_paths: List[Union[str, Path]], + **kwargs) -> List[OCRResult]: + """ + Optimized batch processing (to be implemented in subclass). + + Args: + image_paths: List of paths to image files + **kwargs: Additional model-specific parameters + + Returns: + List of OCRResult for each image + """ + raise NotImplementedError("Batch processing not implemented for this model") + + def __str__(self) -> str: + return f"{self.name}" + + def __repr__(self) -> str: + return f"OCRModel(name='{self.name}', supports_batch={self.supports_batch})" diff --git a/src/ragent_lab/ocr_benchmark/benchmark.py b/src/ragent_lab/ocr_benchmark/benchmark.py new file mode 100644 index 0000000..43ba403 --- /dev/null +++ b/src/ragent_lab/ocr_benchmark/benchmark.py @@ -0,0 +1,248 @@ +""" +OCR Benchmark testing framework. +""" + +from typing import List, Dict, Union, Optional +from pathlib import Path +import time +from dataclasses import dataclass + +from .base import OCRModel, OCRResult, BenchmarkResult +from .registry import get_ocr_model, list_ocr_models + + +class OCRBenchmark: + """OCR Benchmark testing framework.""" + + def __init__(self, models: Optional[List[Union[str, OCRModel]]] = None): + """ + Initialize OCR benchmark. + + Args: + models: List of model names or OCRModel instances to benchmark. + If None, all registered models will be used. + """ + self.models = [] + + if models is None: + # Use all registered models + model_names = list_ocr_models() + for name in model_names: + try: + self.models.append(get_ocr_model(name)) + except Exception as e: + print(f"Warning: Could not load model '{name}': {e}") + else: + # Use specified models + for model in models: + if isinstance(model, str): + self.models.append(get_ocr_model(model)) + elif isinstance(model, OCRModel): + self.models.append(model) + else: + raise ValueError(f"Invalid model type: {type(model)}") + + def benchmark_single_model(self, model: OCRModel, + image_paths: List[Union[str, Path]], + ground_truth: Optional[Dict[str, str]] = None, + **kwargs) -> BenchmarkResult: + """ + Benchmark a single OCR model on a set of images. + + Args: + model: OCR model to benchmark + image_paths: List of image file paths + ground_truth: Optional dictionary mapping image paths to expected text + **kwargs: Additional parameters for OCR recognition + + Returns: + BenchmarkResult containing benchmark statistics + """ + results = [] + errors = [] + total_confidence = 0.0 + total_processing_time = 0.0 + successful = 0 + failed = 0 + + start_time = time.time() + + for image_path in image_paths: + try: + result = model.recognize(image_path, **kwargs) + results.append(result) + total_confidence += result.confidence + total_processing_time += result.processing_time + successful += 1 + + # Check accuracy against ground truth if provided + if ground_truth: + expected_text = ground_truth.get(str(image_path)) + if expected_text: + accuracy = self._calculate_text_similarity( + result.text, expected_text + ) + result.metadata['accuracy'] = accuracy + + except Exception as e: + failed += 1 + errors.append({ + 'image_path': str(image_path), + 'error': str(e) + }) + + total_time = time.time() - start_time + total_images = len(image_paths) + + avg_confidence = total_confidence / successful if successful > 0 else 0.0 + avg_processing_time = total_processing_time / successful if successful > 0 else 0.0 + + return BenchmarkResult( + model_name=model.name, + total_images=total_images, + successful=successful, + failed=failed, + average_confidence=avg_confidence, + average_processing_time=avg_processing_time, + total_time=total_time, + results=results, + errors=errors + ) + + def benchmark_all(self, image_paths: List[Union[str, Path]], + ground_truth: Optional[Dict[str, str]] = None, + **kwargs) -> Dict[str, BenchmarkResult]: + """ + Benchmark all models on a set of images. + + Args: + image_paths: List of image file paths + ground_truth: Optional dictionary mapping image paths to expected text + **kwargs: Additional parameters for OCR recognition + + Returns: + Dictionary mapping model names to BenchmarkResult + """ + results = {} + + for model in self.models: + print(f"Benchmarking {model.name}...") + try: + result = self.benchmark_single_model( + model, image_paths, ground_truth, **kwargs + ) + results[model.name] = result + except Exception as e: + print(f"Error benchmarking {model.name}: {e}") + + return results + + def compare_models(self, benchmark_results: Dict[str, BenchmarkResult]) -> Dict[str, Any]: + """ + Compare benchmark results across models. + + Args: + benchmark_results: Dictionary of benchmark results from benchmark_all() + + Returns: + Dictionary containing comparison statistics + """ + comparison = { + 'models': [], + 'metrics': {} + } + + for model_name, result in benchmark_results.items(): + comparison['models'].append({ + 'name': model_name, + 'success_rate': result.success_rate, + 'average_confidence': result.average_confidence, + 'average_processing_time': result.average_processing_time, + 'total_time': result.total_time + }) + + # Find best performing models + if comparison['models']: + comparison['metrics']['fastest'] = min( + comparison['models'], + key=lambda x: x['average_processing_time'] + ) + comparison['metrics']['most_confident'] = max( + comparison['models'], + key=lambda x: x['average_confidence'] + ) + comparison['metrics']['highest_success_rate'] = max( + comparison['models'], + key=lambda x: x['success_rate'] + ) + + return comparison + + @staticmethod + def _calculate_text_similarity(text1: str, text2: str) -> float: + """ + Calculate similarity between two text strings. + + Args: + text1: First text string + text2: Second text string + + Returns: + Similarity score between 0 and 1 + """ + # Simple character-level similarity + # For more advanced comparison, consider using libraries like difflib or nltk + text1 = text1.strip().lower() + text2 = text2.strip().lower() + + if not text1 and not text2: + return 1.0 + if not text1 or not text2: + return 0.0 + + # Calculate Levenshtein distance ratio + from difflib import SequenceMatcher + return SequenceMatcher(None, text1, text2).ratio() + + def print_results(self, benchmark_results: Dict[str, BenchmarkResult]): + """ + Print benchmark results in a formatted way. + + Args: + benchmark_results: Dictionary of benchmark results + """ + print("\n" + "="*80) + print("OCR BENCHMARK RESULTS") + print("="*80) + + for model_name, result in benchmark_results.items(): + print(f"\n{model_name}:") + print(f" Total Images: {result.total_images}") + print(f" Successful: {result.successful}") + print(f" Failed: {result.failed}") + print(f" Success Rate: {result.success_rate:.2%}") + print(f" Average Confidence: {result.average_confidence:.4f}") + print(f" Average Processing Time: {result.average_processing_time:.4f}s") + print(f" Total Time: {result.total_time:.4f}s") + + if result.errors: + print(f" Errors:") + for error in result.errors[:3]: # Show first 3 errors + print(f" - {error['image_path']}: {error['error']}") + + # Print comparison + print("\n" + "-"*80) + comparison = self.compare_models(benchmark_results) + if 'metrics' in comparison and comparison['metrics']: + print("\nPerformance Summary:") + if 'fastest' in comparison['metrics']: + fastest = comparison['metrics']['fastest'] + print(f" Fastest: {fastest['name']} ({fastest['average_processing_time']:.4f}s)") + if 'most_confident' in comparison['metrics']: + confident = comparison['metrics']['most_confident'] + print(f" Most Confident: {confident['name']} ({confident['average_confidence']:.4f})") + if 'highest_success_rate' in comparison['metrics']: + success = comparison['metrics']['highest_success_rate'] + print(f" Highest Success Rate: {success['name']} ({success['success_rate']:.2%})") + + print("="*80 + "\n") diff --git a/src/ragent_lab/ocr_benchmark/registry.py b/src/ragent_lab/ocr_benchmark/registry.py new file mode 100644 index 0000000..c596493 --- /dev/null +++ b/src/ragent_lab/ocr_benchmark/registry.py @@ -0,0 +1,115 @@ +""" +Registry for OCR models. +""" + +from typing import Dict, List, Optional, Callable +from .base import OCRModel +from .strategies import ( + PaddleOCRModel, + TesseractOCRModel, + DeepSeekOCRModel, + paddleocr_model, + tesseract_ocr_model, + deepseek_ocr_model +) + + +# Global registry for OCR models +_OCR_REGISTRY: Dict[str, Dict] = {} + + +def register_ocr_model(name: str, factory: Callable, description: str = "", + requires: Optional[List[str]] = None): + """ + Register an OCR model in the registry. + + Args: + name: Model name/identifier + factory: Factory function that creates the model + description: Model description + requires: List of required packages + """ + _OCR_REGISTRY[name] = { + 'factory': factory, + 'description': description, + 'requires': requires or [] + } + + +def get_ocr_model(name: str, **kwargs) -> OCRModel: + """ + Get an OCR model by name. + + Args: + name: Model name/identifier + **kwargs: Additional parameters for the model factory + + Returns: + OCRModel instance + + Raises: + ValueError: If model not found in registry + """ + if name not in _OCR_REGISTRY: + available = ', '.join(_OCR_REGISTRY.keys()) + raise ValueError(f"OCR model '{name}' not found. Available models: {available}") + + model_info = _OCR_REGISTRY[name] + return model_info['factory'](**kwargs) + + +def get_all_ocr_models() -> Dict[str, Dict]: + """ + Get all registered OCR models. + + Returns: + Dictionary of all registered models with their metadata + """ + return _OCR_REGISTRY.copy() + + +def list_ocr_models() -> List[str]: + """ + List all registered OCR model names. + + Returns: + List of model names + """ + return list(_OCR_REGISTRY.keys()) + + +# Register default OCR models +register_ocr_model( + name='paddleocr', + factory=paddleocr_model, + description='PaddleOCR - Fast and accurate OCR with Chinese support', + requires=['paddleocr', 'paddlepaddle'] +) + +register_ocr_model( + name='paddleocr_en', + factory=lambda **kwargs: paddleocr_model(lang='en', **kwargs), + description='PaddleOCR - English language model', + requires=['paddleocr', 'paddlepaddle'] +) + +register_ocr_model( + name='tesseract', + factory=tesseract_ocr_model, + description='Tesseract OCR - Open source OCR engine', + requires=['pytesseract', 'Pillow'] +) + +register_ocr_model( + name='tesseract_en', + factory=lambda **kwargs: tesseract_ocr_model(lang='eng', **kwargs), + description='Tesseract OCR - English only', + requires=['pytesseract', 'Pillow'] +) + +register_ocr_model( + name='deepseek_ocr', + factory=deepseek_ocr_model, + description='DeepSeek OCR - Advanced OCR model (placeholder)', + requires=['deepseek'] # Placeholder +) diff --git a/src/ragent_lab/ocr_benchmark/strategies.py b/src/ragent_lab/ocr_benchmark/strategies.py new file mode 100644 index 0000000..ce94994 --- /dev/null +++ b/src/ragent_lab/ocr_benchmark/strategies.py @@ -0,0 +1,259 @@ +""" +OCR model implementations for various OCR engines. +""" + +from typing import List, Union, Optional, Dict, Any +from pathlib import Path +import time + +from .base import OCRModel, OCRResult + + +class PaddleOCRModel(OCRModel): + """PaddleOCR model wrapper.""" + + def __init__(self, lang: str = 'ch', use_angle_cls: bool = True, + use_gpu: bool = False): + """ + Initialize PaddleOCR model. + + Args: + lang: Language code ('ch', 'en', etc.) + use_angle_cls: Whether to use angle classification + use_gpu: Whether to use GPU + """ + super().__init__( + name=f"PaddleOCR ({lang})", + description=f"PaddleOCR model with {lang} language support", + supports_batch=False, + supports_languages=['ch', 'en', 'korean', 'japan', 'french', 'german'] + ) + self.lang = lang + self.use_angle_cls = use_angle_cls + self.use_gpu = use_gpu + self._ocr = None + + def _get_ocr(self): + """Get or initialize PaddleOCR instance.""" + if self._ocr is None: + try: + from paddleocr import PaddleOCR + self._ocr = PaddleOCR( + lang=self.lang, + use_angle_cls=self.use_angle_cls, + use_gpu=self.use_gpu, + show_log=False + ) + except ImportError: + raise ImportError( + "PaddleOCR is not installed. " + "Please install it with: pip install paddleocr" + ) + return self._ocr + + def recognize(self, image_path: Union[str, Path], **kwargs) -> OCRResult: + """ + Recognize text from an image using PaddleOCR. + + Args: + image_path: Path to the image file + **kwargs: Additional parameters for PaddleOCR + + Returns: + OCRResult containing recognized text and metadata + """ + ocr = self._get_ocr() + image_path = str(image_path) + + start_time = time.time() + try: + result = ocr.ocr(image_path, cls=self.use_angle_cls) + processing_time = time.time() - start_time + + if not result or not result[0]: + return OCRResult( + text="", + confidence=0.0, + model_name=self.name, + processing_time=processing_time, + metadata={ + 'lang': self.lang, + 'use_angle_cls': self.use_angle_cls, + 'use_gpu': self.use_gpu, + 'status': 'no_text_found' + } + ) + + # Extract text and confidence from result + texts = [] + confidences = [] + bounding_boxes = [] + + for line in result[0]: + box, (text, confidence) = line + texts.append(text) + confidences.append(confidence) + bounding_boxes.append({ + 'box': box, + 'text': text, + 'confidence': confidence + }) + + full_text = '\n'.join(texts) + avg_confidence = sum(confidences) / len(confidences) if confidences else 0.0 + + return OCRResult( + text=full_text, + confidence=avg_confidence, + model_name=self.name, + processing_time=processing_time, + metadata={ + 'lang': self.lang, + 'use_angle_cls': self.use_angle_cls, + 'use_gpu': self.use_gpu, + 'num_lines': len(texts) + }, + bounding_boxes=bounding_boxes + ) + + except Exception as e: + processing_time = time.time() - start_time + raise RuntimeError(f"PaddleOCR recognition failed: {e}") + + +class TesseractOCRModel(OCRModel): + """Tesseract OCR model wrapper.""" + + def __init__(self, lang: str = 'eng+chi_sim'): + """ + Initialize Tesseract OCR model. + + Args: + lang: Language code(s) (e.g., 'eng', 'chi_sim', 'eng+chi_sim') + """ + super().__init__( + name=f"Tesseract ({lang})", + description=f"Tesseract OCR with {lang} language support", + supports_batch=False, + supports_languages=['eng', 'chi_sim', 'chi_tra', 'jpn', 'kor'] + ) + self.lang = lang + + def recognize(self, image_path: Union[str, Path], **kwargs) -> OCRResult: + """ + Recognize text from an image using Tesseract. + + Args: + image_path: Path to the image file + **kwargs: Additional parameters for pytesseract + + Returns: + OCRResult containing recognized text and metadata + """ + try: + import pytesseract + from PIL import Image + except ImportError: + raise ImportError( + "pytesseract or Pillow is not installed. " + "Please install with: pip install pytesseract Pillow" + ) + + image_path = str(image_path) + start_time = time.time() + + try: + # Open image + image = Image.open(image_path) + + # Perform OCR + text = pytesseract.image_to_string(image, lang=self.lang, **kwargs) + + # Get detailed data for confidence + data = pytesseract.image_to_data(image, lang=self.lang, output_type=pytesseract.Output.DICT) + + # Calculate average confidence (filter out -1 values) + confidences = [conf for conf in data['conf'] if conf != -1] + avg_confidence = sum(confidences) / len(confidences) / 100.0 if confidences else 0.0 + + processing_time = time.time() - start_time + + return OCRResult( + text=text.strip(), + confidence=avg_confidence, + model_name=self.name, + processing_time=processing_time, + metadata={ + 'lang': self.lang, + 'num_words': len([w for w in data['text'] if w.strip()]), + } + ) + + except Exception as e: + processing_time = time.time() - start_time + raise RuntimeError(f"Tesseract OCR recognition failed: {e}") + + +class DeepSeekOCRModel(OCRModel): + """DeepSeek OCR model wrapper (placeholder for future implementation).""" + + def __init__(self, model_path: Optional[str] = None): + """ + Initialize DeepSeek OCR model. + + Args: + model_path: Path to the DeepSeek OCR model + """ + super().__init__( + name="DeepSeek OCR", + description="DeepSeek OCR model", + supports_batch=True, + supports_languages=['en', 'zh'] + ) + self.model_path = model_path + self._model = None + + def _get_model(self): + """Get or load DeepSeek OCR model.""" + if self._model is None: + # TODO: Implement DeepSeek OCR model loading + # This is a placeholder for future implementation + raise NotImplementedError( + "DeepSeek OCR is not yet implemented. " + "Please check the DeepSeek documentation for installation instructions." + ) + return self._model + + def recognize(self, image_path: Union[str, Path], **kwargs) -> OCRResult: + """ + Recognize text from an image using DeepSeek OCR. + + Args: + image_path: Path to the image file + **kwargs: Additional parameters + + Returns: + OCRResult containing recognized text and metadata + """ + # TODO: Implement DeepSeek OCR recognition + raise NotImplementedError( + "DeepSeek OCR recognition is not yet implemented. " + "This is a placeholder for future development." + ) + + +# Factory functions for creating OCR models +def paddleocr_model(lang: str = 'ch', use_angle_cls: bool = True, + use_gpu: bool = False) -> PaddleOCRModel: + """Create PaddleOCR model.""" + return PaddleOCRModel(lang=lang, use_angle_cls=use_angle_cls, use_gpu=use_gpu) + + +def tesseract_ocr_model(lang: str = 'eng+chi_sim') -> TesseractOCRModel: + """Create Tesseract OCR model.""" + return TesseractOCRModel(lang=lang) + + +def deepseek_ocr_model(model_path: Optional[str] = None) -> DeepSeekOCRModel: + """Create DeepSeek OCR model.""" + return DeepSeekOCRModel(model_path=model_path) diff --git a/tests/test_ocr_benchmark.py b/tests/test_ocr_benchmark.py new file mode 100644 index 0000000..4b1d814 --- /dev/null +++ b/tests/test_ocr_benchmark.py @@ -0,0 +1,135 @@ +""" +Tests for OCR benchmark functionality. +""" + +import sys +from pathlib import Path +import unittest +from unittest.mock import Mock, patch, MagicMock + +# Add src directory to Python path +src_path = Path(__file__).parent.parent / "src" +sys.path.insert(0, str(src_path)) + +from ragent_lab.ocr_benchmark import ( + OCRModel, + OCRResult, + BenchmarkResult, + PaddleOCRModel, + TesseractOCRModel, + OCRBenchmark, + get_ocr_model, + list_ocr_models +) + + +class TestOCRBase(unittest.TestCase): + """Test cases for OCR base classes.""" + + def test_ocr_result_creation(self): + """Test OCR result creation.""" + result = OCRResult( + text="Hello World", + confidence=0.95, + model_name="TestModel", + processing_time=0.5, + metadata={"key": "value"} + ) + self.assertEqual(result.text, "Hello World") + self.assertEqual(result.confidence, 0.95) + self.assertEqual(result.processing_time, 0.5) + + def test_ocr_result_validation(self): + """Test OCR result validation.""" + with self.assertRaises(ValueError): + OCRResult( + text="Test", + confidence=1.5, # Invalid confidence > 1 + model_name="Test", + processing_time=0.5 + ) + + def test_benchmark_result_metrics(self): + """Test benchmark result metrics calculation.""" + result = BenchmarkResult( + model_name="TestModel", + total_images=10, + successful=8, + failed=2, + average_confidence=0.9, + average_processing_time=0.5, + total_time=5.0, + results=[] + ) + self.assertEqual(result.success_rate, 0.8) + self.assertEqual(result.error_rate, 0.2) + + +class TestOCRRegistry(unittest.TestCase): + """Test cases for OCR model registry.""" + + def test_list_ocr_models(self): + """Test listing OCR models.""" + models = list_ocr_models() + self.assertIsInstance(models, list) + self.assertGreater(len(models), 0) + self.assertIn('paddleocr', models) + self.assertIn('tesseract', models) + + def test_get_ocr_model(self): + """Test getting OCR model from registry.""" + # This should work without actually loading the model + # since we're just checking the registry + models = list_ocr_models() + self.assertIn('paddleocr', models) + + +class TestOCRBenchmark(unittest.TestCase): + """Test cases for OCR benchmark.""" + + def test_benchmark_initialization(self): + """Test benchmark initialization.""" + # Create a mock model + mock_model = Mock(spec=OCRModel) + mock_model.name = "MockModel" + + benchmark = OCRBenchmark(models=[mock_model]) + self.assertEqual(len(benchmark.models), 1) + self.assertEqual(benchmark.models[0].name, "MockModel") + + def test_text_similarity(self): + """Test text similarity calculation.""" + similarity = OCRBenchmark._calculate_text_similarity( + "Hello World", + "Hello World" + ) + self.assertEqual(similarity, 1.0) + + similarity = OCRBenchmark._calculate_text_similarity( + "Hello World", + "Hello" + ) + self.assertLess(similarity, 1.0) + self.assertGreater(similarity, 0.0) + + @patch('ragent_lab.ocr_benchmark.strategies.PaddleOCR') + def test_paddleocr_model(self, mock_paddleocr): + """Test PaddleOCR model wrapper.""" + # Mock PaddleOCR instance + mock_ocr_instance = MagicMock() + mock_paddleocr.return_value = mock_ocr_instance + + # Mock OCR result + mock_ocr_instance.ocr.return_value = [[ + [[[0, 0], [10, 0], [10, 10], [0, 10]], ("Hello", 0.95)], + [[[0, 10], [10, 10], [10, 20], [0, 20]], ("World", 0.98)] + ]] + + model = PaddleOCRModel() + # We can't actually test recognition without a real image, + # but we can test model creation + self.assertEqual(model.name, "PaddleOCR (ch)") + + +if __name__ == "__main__": + unittest.main()