Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+inference.pdiparams filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,3 +1,165 @@
----
-license: mit
----
+# Khmer OCR Recognition Model
+
+🇰🇭 **High-accuracy OCR model for Khmer text recognition using PaddleOCR framework**
+
+## Model Overview
+
+This CRNN-based OCR model is specifically trained for Khmer (Cambodian) text recognition, achieving **98.45% accuracy** on validation data. The model is optimized for recognizing short text segments (3-5 words) commonly found in documents, signs, and printed materials.
+
+## 🏗️ Model Architecture
+
+- **Framework**: PaddleOCR 2.7+
+- **Algorithm**: CRNN (Convolutional Recurrent Neural Network)
+- **Backbone**: ResNet34
+- **Neck**: SequenceEncoder with RNN (hidden_size: 256)
+- **Head**: CTCHead with CTC Loss
+- **Input Shape**: `[3, 32, 320]` (channels, height, width)
+- **Max Text Length**: 25 characters
+
+## 📝 Supported Characters
+
+The model recognizes **188 characters** including:
+
+- **Khmer Consonants**: ក ខ គ ឃ ង ច ឆ ជ ឈ ញ ដ ឋ ឌ ឍ ណ ត ថ ទ ធ ន ប ផ ព ភ ម យ រ ល វ ស ហ ឡ អ
+- **Khmer Vowels**: ា ិ ី ឹ ឺ ុ ូ ួ ើ ឿ ៀ េ ែ ៃ ោ ៅ ំ ះ ៈ
+- **Khmer Numerals**: ០ ១ ២ ៣ ៤ ៥ ៦ ៧ ៨ ៩
+- **Latin Characters**: A-Z, a-z, 0-9
+- **Punctuation**: . , ! ? - ( ) [ ] « » ™ ® etc.
+- **Khmer Symbols**: ។ ៕ ៖ ៗ ៉ ៊ ់ ៌ ៍ ៏ ័ ្
+
+## 🚀 Quick Start
+
+### Installation
+
+```bash
+pip install paddlepaddle paddleocr opencv-python
+```
+
+### Basic Usage
+
+```python
+from paddleocr import PaddleOCR
+import cv2
+
+# Initialize OCR with custom Khmer model
+ocr = PaddleOCR(
+    use_angle_cls=True,
+    lang='ch',  # Use Chinese as base language
+    rec_model_dir='path/to/model',  # Directory containing inference files
+    rec_char_dict_path='khmer_char_dict.txt',
+    show_log=False
+)
+
+# Process image
+result = ocr.ocr('khmer_text_image.jpg', cls=True)
+
+# Extract results
+for idx in range(len(result)):
+    res = result[idx]
+    if res is None:
+        continue
+    for line in res:
+        text = line[1][0]  # Recognized text
+        confidence = line[1][1]  # Confidence score
+        print(f'Text: {text}, Confidence: {confidence:.3f}')
+```
+
+### Command Line Usage
+
+```bash
+# Download model files to a directory
+# Then use PaddleOCR tools:
+
+python tools/infer/predict_rec.py \
+    --image_dir="your_khmer_image.png" \
+    --rec_model_dir="path/to/model" \
+    --rec_char_dict_path="khmer_char_dict.txt"
+```
+
+## 📁 Files Included
+
+| File | Size | Description |
+|------|------|-------------|
+| `inference.pdiparams` | ~106MB | Main model weights |
+| `inference.yml` | ~2KB | Model configuration |
+| `inference.json` | ~1KB | Model metadata |
+| `khmer_char_dict.txt` | ~2KB | Character dictionary (188 characters) |
+| `training_config.yml` | ~2KB | Original training configuration |
+
+## 🔧 Training Details
+
+### Dataset Characteristics
+- **Text Length**: 3-5 words per image (optimized for short segments)
+- **Image Size**: 600×80 pixels (training), resized to 320×32 for inference
+- **Font**: KhmerOS TTF
+- **Background**: White background with black text
+- **Augmentation**: Clean, blurred, noisy, and noise+blur variants
+
+### Training Configuration
+- **Epochs**: 30 (best model at epoch 29)
+- **Optimizer**: Adam with β₁=0.9, β₂=0.999
+- **Learning Rate**: Cosine scheduling (initial: 0.001)
+- **Batch Size**: 32
+- **Loss Function**: CTC Loss
+- **Regularization**: L2 (factor: 4e-05)
+
+## 💡 Usage Tips
+
+### Best Practices
+1. **Image Quality**: Use high-contrast images with clear text
+2. **Text Length**: Optimal for 3-5 word segments (model's training focus)
+3. **Resolution**: Images should be reasonably sized (not too small)
+4. **Preprocessing**: Consider using text detection for full documents
+
+### For Long Text Documents
+Since this model is optimized for short segments, for full documents:
+
+1. **Use Text Detection**: Combine with PaddleOCR's detection model
+2. **Segment Text**: Break long lines into 3-5 word chunks
+3. **Post-process**: Combine results from multiple segments
+
+```python
+# Example for full document processing
+ocr = PaddleOCR(
+    use_angle_cls=True,
+    lang='ch',
+    det_model_dir='path/to/detection/model',  # Add detection model
+    rec_model_dir='path/to/this/model',       # This Khmer recognition model
+    rec_char_dict_path='khmer_char_dict.txt'
+)
+
+# This will detect text regions AND recognize them
+result = ocr.ocr('full_document.jpg', cls=True)
+```
+
+
+## 🔄 Model Conversion
+
+This model was exported from PaddlePaddle training format to inference format:
+
+```bash
+# Original export command used:
+python tools/export_model.py \
+    -c pretrainoutput/config.yml \
+    -o Global.pretrained_model=pretrainoutput/best_accuracy.pdparams \
+    Global.save_inference_dir=pretrainoutput/inference
+```
+
+## 🛠️ Requirements
+
+```
+paddlepaddle>=2.4.0
+opencv-python>=4.5.0
+numpy>=1.19.0
+pillow>=8.0.0
+```
+
+```bibtex
+@misc{khmer-ocr-2025,
+  title={Khmer OCR Recognition Model},
+  author={[Your Name]},
+  year={2025},
+  publisher={Hugging Face},
+  howpublished={\url{https://huggingface.co/[your-username]/khmer-ocr}}
+}
+```

example_usage.py

@@ -0,0 +1,213 @@
+#!/usr/bin/env python3
+"""
+Example usage of the Khmer OCR Recognition Model
+Demonstrates how to use the model for Khmer text recognition
+"""
+
+from paddleocr import PaddleOCR
+import cv2
+import os
+import json
+
+def khmer_ocr_example(image_path, model_dir="."):
+    """
+    Example function showing how to use the Khmer OCR model
+    
+    Args:
+        image_path (str): Path to the image containing Khmer text
+        model_dir (str): Directory containing the model files
+    
+    Returns:
+        list: OCR results with text, confidence, and bounding boxes
+    """
+    
+    print(f"🔍 Processing: {image_path}")
+    print("=" * 50)
+    
+    # Initialize PaddleOCR with custom Khmer model
+    try:
+        ocr = PaddleOCR(
+            use_angle_cls=True,
+            lang='ch',  # Use Chinese as base language
+            rec_model_dir=model_dir,  # Directory with inference files
+            rec_char_dict_path=os.path.join(model_dir, 'khmer_char_dict.txt'),
+            show_log=False
+        )
+        print("✅ Model loaded successfully")
+    except Exception as e:
+        print(f"❌ Error loading model: {e}")
+        return None
+    
+    # Check if image exists
+    if not os.path.exists(image_path):
+        print(f"❌ Image file not found: {image_path}")
+        return None
+    
+    # Process the image
+    try:
+        result = ocr.ocr(image_path, cls=True)
+        print("✅ OCR processing completed")
+    except Exception as e:
+        print(f"❌ Error processing image: {e}")
+        return None
+    
+    # Extract and display results
+    if result[0] is None:
+        print("⚠️ No text detected in the image.")
+        return []
+    
+    all_results = []
+    total_confidence = 0
+    
+    print(f"\n📝 Detected Text Regions: {len(result[0])}")
+    print("-" * 50)
+    
+    for idx, line in enumerate(result[0]):
+        box = line[0]  # Bounding box coordinates [[x1,y1], [x2,y2], [x3,y3], [x4,y4]]
+        text = line[1][0]  # Recognized text
+        confidence = line[1][1]  # Confidence score
+        
+        # Store result
+        result_item = {
+            'region_id': idx + 1,
+            'text': text,
+            'confidence': confidence,
+            'bounding_box': box
+        }
+        all_results.append(result_item)
+        total_confidence += confidence
+        
+        # Display result
+        print(f"Region {idx + 1}:")
+        print(f"  📄 Text: {text}")
+        print(f"  🎯 Confidence: {confidence:.3f}")
+        print(f"  📍 Box: [{box[0][0]:.0f},{box[0][1]:.0f}] → [{box[2][0]:.0f},{box[2][1]:.0f}]")
+        print()
+    
+    # Summary
+    avg_confidence = total_confidence / len(result[0]) if result[0] else 0
+    print("📊 Summary:")
+    print(f"  Total regions: {len(result[0])}")
+    print(f"  Average confidence: {avg_confidence:.3f}")
+    
+    # Combine all text
+    full_text = " ".join([item['text'] for item in all_results])
+    print(f"  📝 Full text: {full_text}")
+    
+    return all_results
+
+def batch_process_images(image_dir, model_dir=".", output_file="ocr_results.json"):
+    """
+    Process multiple images in a directory
+    
+    Args:
+        image_dir (str): Directory containing images
+        model_dir (str): Directory containing model files
+        output_file (str): Output JSON file for results
+    """
+    
+    print(f"🔄 Batch processing images from: {image_dir}")
+    
+    # Find image files
+    image_extensions = ['.jpg', '.jpeg', '.png', '.bmp', '.tiff']
+    image_files = []
+    
+    if os.path.isdir(image_dir):
+        for file in os.listdir(image_dir):
+            if any(file.lower().endswith(ext) for ext in image_extensions):
+                image_files.append(os.path.join(image_dir, file))
+    
+    if not image_files:
+        print(f"❌ No image files found in {image_dir}")
+        return
+    
+    print(f"📁 Found {len(image_files)} images")
+    
+    all_results = {}
+    
+    for image_path in image_files:
+        print(f"\n🖼️ Processing: {os.path.basename(image_path)}")
+        results = khmer_ocr_example(image_path, model_dir)
+        if results:
+            all_results[image_path] = results
+    
+    # Save results to JSON
+    try:
+        with open(output_file, 'w', encoding='utf-8') as f:
+            json.dump(all_results, f, ensure_ascii=False, indent=2)
+        print(f"\n💾 Results saved to: {output_file}")
+    except Exception as e:
+        print(f"❌ Error saving results: {e}")
+
+def main():
+    """Main function with example usage"""
+    
+    print("🇰🇭 Khmer OCR Recognition Model - Example Usage")
+    print("=" * 60)
+    
+    # Example 1: Single image processing
+    print("\n📖 Example 1: Single Image Processing")
+    print("-" * 40)
+    
+    # You can replace this with your actual image path
+    example_image = "sample_khmer_image.jpg"
+    
+    if os.path.exists(example_image):
+        results = khmer_ocr_example(example_image)
+        if results:
+            print("✅ Single image processing completed successfully!")
+    else:
+        print(f"ℹ️ Example image '{example_image}' not found.")
+        print("   Please provide your own Khmer text image.")
+    
+    # Example 2: Batch processing
+    print("\n📖 Example 2: Batch Processing")
+    print("-" * 40)
+    
+    sample_dir = "sample_images"
+    if os.path.exists(sample_dir):
+        batch_process_images(sample_dir)
+    else:
+        print(f"ℹ️ Sample directory '{sample_dir}' not found.")
+        print("   Create a directory with Khmer images to test batch processing.")
+    
+    # Example 3: Model info
+    print("\n📖 Example 3: Model Information")
+    print("-" * 40)
+    
+    model_files = [
+        'inference.pdiparams',
+        'inference.yml', 
+        'inference.json',
+        'khmer_char_dict.txt'
+    ]
+    
+    print("📁 Required model files:")
+    for file in model_files:
+        if os.path.exists(file):
+            size = os.path.getsize(file) / (1024*1024)  # MB
+            print(f"  ✅ {file} ({size:.1f}MB)")
+        else:
+            print(f"  ❌ {file} - Missing!")
+    
+    # Load character dictionary info
+    char_dict_path = 'khmer_char_dict.txt'
+    if os.path.exists(char_dict_path):
+        try:
+            with open(char_dict_path, 'r', encoding='utf-8') as f:
+                chars = f.read().strip().split('\n')
+            print(f"\n📝 Character Dictionary: {len(chars)} characters supported")
+            print(f"   Sample characters: {' '.join(chars[:20])}...")
+        except Exception as e:
+            print(f"❌ Error reading character dictionary: {e}")
+    
+    print("\n🎯 Usage Tips:")
+    print("  • Best for 3-5 word text segments")
+    print("  • Use high-contrast, clear images")
+    print("  • Combine with text detection for full documents")
+    print("  • Model supports 188 Khmer and Latin characters")
+    
+    print("\n✨ Happy OCR-ing with Khmer text!")
+
+if __name__ == "__main__":
+    main()

inference.pdiparams

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1fbdcb5dc3814d9253fd917a9b123ad36398c76906f86e34e63180109cb72aa5
+size 98271715

inference.yml

@@ -0,0 +1,187 @@
+PreProcess:
+  transform_ops:
+  - DecodeImage:
+      channel_first: false
+      img_mode: BGR
+  - CTCLabelEncode: null
+  - RecResizeImg:
+      image_shape:
+      - 3
+      - 32
+      - 320
+  - KeepKeys:
+      keep_keys:
+      - image
+      - label
+      - length
+PostProcess:
+  name: CTCLabelDecode
+  character_dict:
+  - ' '
+  - '!'
+  - '%'
+  - '&'
+  - (
+  - )
+  - +
+  - ','
+  - '-'
+  - .
+  - /
+  - '0'
+  - '1'
+  - '2'
+  - '3'
+  - '4'
+  - '5'
+  - '6'
+  - '7'
+  - '8'
+  - '9'
+  - ':'
+  - '?'
+  - A
+  - B
+  - C
+  - D
+  - E
+  - F
+  - G
+  - H
+  - I
+  - J
+  - K
+  - L
+  - M
+  - N
+  - O
+  - P
+  - R
+  - S
+  - T
+  - U
+  - V
+  - W
+  - X
+  - Y
+  - Z
+  - '['
+  - ']'
+  - a
+  - b
+  - c
+  - d
+  - e
+  - f
+  - g
+  - h
+  - i
+  - j
+  - k
+  - l
+  - m
+  - n
+  - o
+  - p
+  - q
+  - r
+  - s
+  - t
+  - u
+  - v
+  - w
+  - x
+  - y
+  - z
+  - «
+  - ®
+  - »
+  - ក
+  - ខ
+  - គ
+  - ឃ
+  - ង
+  - ច
+  - ឆ
+  - ជ
+  - ឈ
+  - ញ
+  - ដ
+  - ឋ
+  - ឌ
+  - ឍ
+  - ណ
+  - ត
+  - ថ
+  - ទ
+  - ធ
+  - ន
+  - ប
+  - ផ
+  - ព
+  - ភ
+  - ម
+  - យ
+  - រ
+  - ល
+  - វ
+  - ស
+  - ហ
+  - ឡ
+  - អ
+  - ឥ
+  - ឧ
+  - ឫ
+  - ឬ
+  - ឭ
+  - ឯ
+  - ឱ
+  - ឲ
+  - ា
+  - ិ
+  - ី
+  - ឹ
+  - ឺ
+  - ុ
+  - ូ
+  - ួ
+  - ើ
+  - ឿ
+  - ៀ
+  - េ
+  - ែ
+  - ៃ
+  - ោ
+  - ៅ
+  - ំ
+  - ះ
+  - ៈ
+  - ៉
+  - ៊
+  - ់
+  - ៌
+  - ៍
+  - ៏
+  - ័
+  - ្
+  - ។
+  - ៕
+  - ៖
+  - ៗ
+  - ០
+  - ១
+  - ២
+  - ៣
+  - ៤
+  - ៥
+  - ៦
+  - ៧
+  - ៨
+  - ៩
+  - –
+  - —
+  - ‘
+  - ’
+  - “
+  - ”
+  - ™

khmer_char_dict.txt

@@ -0,0 +1,168 @@
+ 
+!
+%
+&
+(
+)
++
+,
+-
+.
+/
+0
+1
+2
+3
+4
+5
+6
+7
+8
+9
+:
+?
+A
+B
+C
+D
+E
+F
+G
+H
+I
+J
+K
+L
+M
+N
+O
+P
+R
+S
+T
+U
+V
+W
+X
+Y
+Z
+[
+]
+a
+b
+c
+d
+e
+f
+g
+h
+i
+j
+k
+l
+m
+n
+o
+p
+q
+r
+s
+t
+u
+v
+w
+x
+y
+z
+«
+®
+»
+ក
+ខ
+គ
+ឃ
+ង
+ច
+ឆ
+ជ
+ឈ
+ញ
+ដ
+ឋ
+ឌ
+ឍ
+ណ
+ត
+ថ
+ទ
+ធ
+ន
+ប
+ផ
+ព
+ភ
+ម
+យ
+រ
+ល
+វ
+ស
+ហ
+ឡ
+អ
+ឥ
+ឧ
+ឫ
+ឬ
+ឭ
+ឯ
+ឱ
+ឲ
+ា
+ិ
+ី
+ឹ
+ឺ
+ុ
+ូ
+ួ
+ើ
+ឿ
+ៀ
+េ
+ែ
+ៃ
+ោ
+ៅ
+ំ
+ះ
+ៈ
+៉
+៊
+់
+៌
+៍
+៏
+័
+្
+។
+៕
+៖
+ៗ
+០
+១
+២
+៣
+៤
+៥
+៦
+៧
+៨
+៩
+–
+—
+‘
+’
+“
+”
+™

model_info.json

@@ -0,0 +1,84 @@
+{
+  "model_name": "Khmer OCR Recognition Model",
+  "description": "CRNN-based OCR model specifically trained for Khmer text recognition",
+  "framework": "PaddleOCR",
+  "architecture": {
+    "algorithm": "CRNN",
+    "backbone": "ResNet34",
+    "neck": "SequenceEncoder (RNN)",
+    "head": "CTCHead",
+    "loss": "CTCLoss"
+  },
+  "performance": {
+    "accuracy": 98.45,
+    "normalized_edit_distance": 99.90,
+    "inference_speed_fps": 326,
+    "best_epoch": 29,
+    "total_epochs": 30
+  },
+  "training_data": {
+    "training_images": 13253,
+    "validation_images": 4315,
+    "total_images": 17568,
+    "text_length_range": "3-5 words",
+    "image_size": "600x80 pixels (training), 320x32 (inference)",
+    "font": "KhmerOS",
+    "augmentation": ["clean", "blurred", "noisy", "noise_blur"]
+  },
+  "model_specifications": {
+    "input_shape": [3, 32, 320],
+    "max_text_length": 25,
+    "character_count": 188,
+    "supported_languages": ["Khmer", "Latin"],
+    "model_size_mb": 106
+  },
+  "character_set": {
+    "khmer_consonants": "ក ខ គ ឃ ង ច ឆ ជ ឈ ញ ដ ឋ ឌ ឍ ណ ត ថ ទ ធ ន ប ផ ព ភ ម យ រ ល វ ស ហ ឡ អ",
+    "khmer_vowels": "ា ិ ី ឹ ឺ ុ ូ ួ ើ ឿ ៀ េ ែ ៃ ោ ៅ ំ ះ ៈ",
+    "khmer_numerals": "០ ១ ២ ៣ ៤ ៥ ៦ ៧ ៨ ៩",
+    "latin_characters": "A-Z, a-z, 0-9",
+    "punctuation": ". , ! ? - ( ) [ ] « » ™ ® etc.",
+    "khmer_symbols": "។ ៕ ៖ ៗ ៉ ៊ ់ ៌ ៍ ៏ ័ ្"
+  },
+  "training_config": {
+    "optimizer": "Adam",
+    "learning_rate": "Cosine scheduling (initial: 0.001)",
+    "batch_size": 32,
+    "regularization": "L2 (4e-05)",
+    "image_augmentation": true,
+    "data_variants": 4
+  },
+  "usage_recommendations": {
+    "optimal_text_length": "3-5 words",
+    "image_quality": "High contrast, clear text",
+    "use_cases": ["Road signs", "Document snippets", "Menu items", "Form fields"],
+    "preprocessing": "Consider text detection for full documents"
+  },
+  "files": {
+    "inference.pdiparams": "Main model weights (106MB)",
+    "inference.yml": "Model configuration",
+    "inference.json": "Model metadata",
+    "khmer_char_dict.txt": "Character dictionary (188 characters)",
+    "training_config.yml": "Original training configuration"
+  },
+  "requirements": [
+    "paddlepaddle>=2.4.0",
+    "opencv-python>=4.5.0", 
+    "numpy>=1.19.0",
+    "pillow>=8.0.0"
+  ],
+  "limitations": [
+    "Optimized for short text segments (3-5 words)",
+    "Best performance on clean, printed text",
+    "May need segmentation for longer text",
+    "Trained primarily on synthetic data"
+  ],
+  "license": "Specify your license",
+  "created_date": "2025-09-25",
+  "version": "1.0",
+  "contact": {
+    "author": "Your Name",
+    "email": "your.email@example.com",
+    "repository": "https://huggingface.co/your-username/khmer-ocr"
+  }
+}

requirements.txt

@@ -0,0 +1,5 @@
+paddlepaddle>=2.4.0
+opencv-python>=4.5.0
+numpy>=1.19.0
+pillow>=8.0.0
+pyclipper>=1.3.0

training_config.yml

@@ -0,0 +1,104 @@
+Global:
+  use_gpu: true
+  epoch_num: 30
+  log_smooth_window: 20
+  print_batch_step: 10
+  save_model_dir: pretrainoutput
+  save_epoch_step: 5
+  eval_batch_step:
+  - 0
+  - 2000
+  cal_metric_during_train: true
+  pretrained_model: ../source/model/best_accuracy.pdparams
+  checkpoints: null
+  save_inference_dir: ../source/infer
+  use_visualdl: false
+  character_dict_path: ../OCR/output_images/khmer_char_dict.txt
+  character_type: ch
+  max_text_length: 25
+  infer_mode: false
+  use_space_char: true
+  save_res_path: ../output/predicts_khmer_lite.txt
+Optimizer:
+  name: Adam
+  beta1: 0.9
+  beta2: 0.999
+  lr:
+    name: Cosine
+    learning_rate: 0.001
+  regularizer:
+    name: L2
+    factor: 4.0e-05
+Architecture:
+  model_type: rec
+  algorithm: CRNN
+  Transform: null
+  Backbone:
+    name: ResNet
+    layers: 34
+  Neck:
+    name: SequenceEncoder
+    encoder_type: rnn
+    hidden_size: 256
+  Head:
+    name: CTCHead
+    fc_decay: 4.0e-05
+Loss:
+  name: CTCLoss
+PostProcess:
+  name: CTCLabelDecode
+Metric:
+  name: RecMetric
+  main_indicator: acc
+Train:
+  dataset:
+    name: SimpleDataSet
+    data_dir: ../OCR/output_images
+    label_file_list: ../OCR/output_images/train_rec.txt
+    transforms:
+    - DecodeImage:
+        img_mode: BGR
+        channel_first: false
+    - RecAug: null
+    - CTCLabelEncode: null
+    - RecResizeImg:
+        image_shape:
+        - 3
+        - 32
+        - 320
+    - KeepKeys:
+        keep_keys:
+        - image
+        - label
+        - length
+  loader:
+    shuffle: true
+    batch_size_per_card: 32
+    drop_last: true
+    num_workers: 8
+Eval:
+  dataset:
+    name: SimpleDataSet
+    data_dir: ../OCR/output_images
+    label_file_list: ../OCR/output_images/val_rec.txt
+    transforms:
+    - DecodeImage:
+        img_mode: BGR
+        channel_first: false
+    - CTCLabelEncode: null
+    - RecResizeImg:
+        image_shape:
+        - 3
+        - 32
+        - 320
+    - KeepKeys:
+        keep_keys:
+        - image
+        - label
+        - length
+  loader:
+    shuffle: false
+    drop_last: false
+    batch_size_per_card: 32
+    num_workers: 8
+profiler_options: null