MareArts ANPR V14 Models - Complete Performance Guide & Benchmarks

⚡ MareArts ANPR V14 Models - Performance, Metrics & How to Choose

Choosing the right ANPR model is crucial for your application. Too heavy? Slow performance. Too light? Lower accuracy. In this comprehensive guide, we'll break down all MareArts ANPR V14 models with real benchmarks to help you make the perfect choice.

🎯 Two-Stage Pipeline Architecture

MareArts ANPR uses a two-stage pipeline:

1. Detector - Finds license plates in images (Where is the plate?)
2. OCR - Reads text from detected plates (What does it say?)

You can mix and match models from each stage to optimize for your specific needs!

📊 Detector Models - Find License Plates

Model Sizes Explained

Size	Parameters	Speed	Accuracy	Best For
pico	Smallest	Fast	Good (96-98%)	Mobile, Edge devices
micro	Small	Very Fast	Excellent (97-99%)	🏆 Best overall
small	Medium	Fastest	Excellent (98-99%)	High-speed applications
medium	Large	Fast	Excellent (98-99%)	Balanced
large	Largest	Moderate	Highest (99%+)	Maximum accuracy

Resolution Options

• 320p models (320×320) - 2× faster, 96-98% detection
• 640p models (640×640) - Highest accuracy, 98-99% detection

Precision Options

• FP32 - Fastest on GPU (2× faster than FP16), standard size
• FP16 - 50% smaller file size, same accuracy, slower inference

Complete Detector Performance Table

Model Name	Detection Rate	Speed (GPU)	Size	Recommendation
micro_320p_fp32	97.13%	128 FPS (7.8ms)	83 MB	🏆 Best overall
micro_320p_fp16	97.13%	56 FPS (17.9ms)	42 MB	🏆 Best mobile
small_320p_fp32	98.00%	142 FPS (7.0ms)	114 MB	⚡ Fastest
medium_320p_fp32	98.06%	136 FPS (7.4ms)	153 MB	High detection
large_320p_fp32	98.40%	131 FPS (7.6ms)	164 MB	Strong performance
pico_320p_fp32	96.02%	129 FPS (7.8ms)	75 MB	📱 Smallest + fast
pico_640p_fp32	98.54%	66 FPS (15.2ms)	75 MB	Balanced
small_640p_fp32	99.15%	70 FPS (14.3ms)	114 MB	High detection
medium_640p_fp32	99.21%	66 FPS (15.1ms)	153 MB	Very high
large_640p_fp32	99.31%	60 FPS (16.7ms)	164 MB	🎯 Highest accuracy

Key Findings:

• ✅ 320p models: 2× faster than 640p (96-98% accuracy)
• ✅ 640p models: Highest accuracy (98-99%) for difficult cases
• ✅ FP16 models: 50% smaller, same accuracy, ~50% slower
• ✅ Recommended: micro_320p_fp32 (best speed/accuracy balance)

📖 OCR Models - Read License Plate Text

Two Key Metrics

• Exact Match - Entire plate number is 100% correct
• Character Accuracy - Percentage of individual characters correct

Example: Actual plate: "ABC-1234"

• OCR reads "ABC-1234" → ✅ Exact Match = Yes, Char Accuracy = 100%
• OCR reads "ABC-1235" → ❌ Exact Match = No, Char Accuracy = 87.5% (7/8 correct)

Complete OCR Performance by Region

🌍 Universal (univ) - All Regions

Model	Exact Match	Char Accuracy	FPS	Size
pico_fp32	97.48%	98.87%	264	20 MB
micro_fp32	97.54%	98.86%	260	71 MB
small_fp32	97.51%	98.85%	291	112 MB
medium_fp32	97.57%	98.89%	245	164 MB
large_fp32	97.75%	98.91%	253	179 MB

🇰🇷 Korean (kr) - Best Overall Accuracy

Model	Exact Match	Char Accuracy	FPS
pico_fp32	98.99%	99.77%	272
micro_fp32	99.21%	99.80%	250
small_fp32	99.19%	99.80%	295
medium_fp32	99.21%	99.80%	267
large_fp32	99.27%	99.82%	265

🇪🇺 Europe+ (eup) - EU + Additional Countries

Model	Exact Match	Char Accuracy	FPS
pico_fp32	94.98%	97.39%	280
micro_fp32	95.07%	97.46%	266
small_fp32	94.98%	97.43%	304
medium_fp32	95.03%	97.46%	278
large_fp32	95.32%	97.54%	260

🇺🇸 North America (na) - USA, Canada, Mexico

Model	Exact Match	Char Accuracy	FPS
pico_fp32	71.21%	88.43%	268
micro_fp32	71.21%	87.67%	269
small_fp32	69.70%	88.27%	311
medium_fp32	63.64%	87.24%	284
large_fp32	69.70%	86.25%	271

🇨🇳 China (cn)

Model	Exact Match	Char Accuracy	FPS
pico_fp32	96.24%	98.82%	268
micro_fp32	96.30%	98.74%	265
small_fp32	96.36%	98.88%	301
medium_fp32	96.36%	98.89%	276
large_fp32	96.49%	98.87%	262

OCR Model Averages (All Regions)

Model	Avg Exact Match	Avg Char Accuracy	Avg FPS	Size
small_fp32	91.54%	96.64%	300 FPS	112 MB
pico_fp32	91.78%	96.65%	270 FPS	20 MB
micro_fp32	91.86%	96.50%	262 FPS	71 MB
medium_fp32	90.36%	96.45%	270 FPS	164 MB
large_fp32	91.70%	96.27%	262 FPS	179 MB

🌍 Regional Vocabulary Support

Region	Code	Coverage	Character Sets
Universal	univ	All regions (default)	All character sets
Korea	kr	South Korea	Hangul + Latin + Digits
Europe+	eup	EU + UK, Switzerland, Norway	Latin + Cyrillic + Special
North America	na	USA, Canada, Mexico	Latin + Digits
China	cn	China	Chinese + Latin + Digits

Pro Tip: Always use specific regions for best accuracy. Only use univ when the region is unknown!

🎯 How to Choose the Right Models

Use Case 1: Parking Management

Requirements: Good accuracy, real-time performance, cost-effective

# Recommended Configuration
detector = ma_anpr_detector_v14(
    "micro_320p_fp32",  # 97% detection, 128 FPS
    user, key, sig,
    backend="cuda",
    conf_thres=0.25
)

ocr = ma_anpr_ocr_v14(
    "small_fp32",       # 95%+ exact match, 300 FPS
    "eup",              # Specific region
    user, key, sig
)

Why: Excellent balance of speed and accuracy. Handles 90%+ of plates easily.

Use Case 2: Security Checkpoint (Critical)

Requirements: Maximum accuracy, can't miss plates

# Recommended Configuration
detector = ma_anpr_detector_v14(
    "large_640p_fp32",  # 99.31% detection (highest!)
    user, key, sig,
    backend="cuda",
    conf_thres=0.20     # Lower threshold for more detections
)

ocr = ma_anpr_ocr_v14(
    "large_fp32",       # 95%+ exact match, best accuracy
    "kr",               # Specific region for your area
    user, key, sig
)

Why: Maximum detection and recognition accuracy. No compromises.

Use Case 3: Traffic Monitoring (High Volume)

Requirements: Maximum speed, process many cameras

# Recommended Configuration
detector = ma_anpr_detector_v14(
    "small_320p_fp32",  # 98% detection, 142 FPS (fastest!)
    user, key, sig,
    backend="cuda",
    conf_thres=0.25
)

ocr = ma_anpr_ocr_v14(
    "small_fp32",       # 300 FPS (fastest OCR!)
    "univ",             # Universal for mixed traffic
    user, key, sig
)

Why: Fastest processing for high-volume applications. Can handle multiple streams.

Use Case 4: Mobile/Edge Device

Requirements: Small size, low power, on-device processing

# Recommended Configuration
detector = ma_anpr_detector_v14(
    "micro_320p_fp16",  # 97% detection, 42 MB (50% smaller!)
    user, key, sig,
    backend="cpu",      # CPU for mobile
    conf_thres=0.25
)

ocr = ma_anpr_ocr_v14(
    "pico_fp32",        # 20 MB, 270 FPS
    "kr",               # Specific region
    user, key, sig
)

Why: Smallest models, excellent for mobile/edge. Total size: 62 MB.

Use Case 5: Law Enforcement (Difficult Conditions)

Requirements: Works in poor lighting, angles, damaged plates

# Recommended Configuration
detector = ma_anpr_detector_v14(
    "medium_640p_fp32", # 99.21% detection
    user, key, sig,
    backend="cuda",
    conf_thres=0.15     # Very low threshold for difficult cases
)

ocr = ma_anpr_ocr_v14(
    "large_fp32",       # Best OCR accuracy
    "na",               # Specific region
    user, key, sig
)

Why: Handles difficult conditions better. Lower threshold catches more plates.

📈 Performance Comparison Chart

Detector Models: Speed vs Accuracy

Category	Fastest	Balanced	Most Accurate
320p	small_320p_fp32 142 FPS, 98.00%	micro_320p_fp32 128 FPS, 97.13%	large_320p_fp32 131 FPS, 98.40%
640p	small_640p_fp32 70 FPS, 99.15%	medium_640p_fp32 66 FPS, 99.21%	large_640p_fp32 60 FPS, 99.31%
Mobile	pico_320p_fp16 50+ FPS, 37 MB	micro_320p_fp16 56 FPS, 42 MB	small_320p_fp16 70+ FPS, 57 MB

OCR Models: Speed vs Accuracy

Priority	Smallest	Fastest	Most Accurate
Choice	pico_fp32 20 MB, 270 FPS 91.78% exact	small_fp32 112 MB, 300 FPS 91.54% exact	large_fp32 179 MB, 262 FPS 91.70% exact

💡 Performance Tips

1. GPU Acceleration is Essential

# CPU: ~1-2 FPS (slow!)
detector = ma_anpr_detector_v14(..., backend="cpu")

# CUDA (NVIDIA GPU): ~100+ FPS (fast!)
detector = ma_anpr_detector_v14(..., backend="cuda")

# DirectML (Windows GPU): ~50+ FPS
detector = ma_anpr_detector_v14(..., backend="directml")

Result: GPU is 50-100× faster than CPU!

2. Use Batch Processing

# Slow: Process one by one
for img in images:
    text, conf = ocr.predict(img)

# Fast: Process in batch (3-5× faster!)
results = ocr.predict(images)  # Pass list

3. Choose Resolution Wisely

• 320p: Good quality images, controlled environment → Use 320p (2× faster)
• 640p: Poor lighting, far distance, damaged plates → Use 640p (higher accuracy)

4. Tune Confidence Thresholds

# High precision (fewer false positives)
detector = ma_anpr_detector_v14(..., conf_thres=0.50)

# Balanced (recommended)
detector = ma_anpr_detector_v14(..., conf_thres=0.25)

# High recall (catch more plates, more false positives)
detector = ma_anpr_detector_v14(..., conf_thres=0.15)

5. Use Specific Regions

# ❌ Less accurate (universal)
ocr = ma_anpr_ocr_v14("small_fp32", "univ", ...)  # ~92% exact match

# ✅ More accurate (specific region)
ocr = ma_anpr_ocr_v14("small_fp32", "kr", ...)    # ~99% exact match!

🚀 Quick Decision Guide

Your Priority	Detector	OCR
Best Overall	micro_320p_fp32	small_fp32
Fastest	small_320p_fp32	small_fp32
Most Accurate	large_640p_fp32	large_fp32
Smallest	pico_320p_fp16	pico_fp32
Mobile	micro_320p_fp16	pico_fp32
Balanced	medium_320p_fp32	medium_fp32

📊 Benchmark Environment

• GPU: NVIDIA RTX 3060 (CUDA 11.8)
• CPU: Intel Core i7
• Dataset: Real-world license plate images
• Test Size: 1000+ images per region
• Updated: December 2025

🎓 Key Takeaways

• ✅ Two-stage pipeline: Detector → OCR
• ✅ Mix and match models for your needs
• ✅ 320p models: 2× faster, excellent for most uses
• ✅ 640p models: Highest accuracy for difficult cases
• ✅ GPU acceleration: 50-100× faster than CPU
• ✅ Specific regions: Much better accuracy than universal
• ✅ Batch processing: 3-5× faster for multiple images
• ✅ Best overall: micro_320p_fp32 + small_fp32

💻 Example Configuration

from marearts_anpr import ma_anpr_detector_v14, ma_anpr_ocr_v14
from marearts_anpr import marearts_anpr_from_image_file

# Initialize models (one time)
detector = ma_anpr_detector_v14(
    "micro_320p_fp32",      # 97% detection, 128 FPS
    user_name, serial_key, signature,
    backend="cuda",          # GPU acceleration
    conf_thres=0.25          # Balanced threshold
)

ocr = ma_anpr_ocr_v14(
    "small_fp32",            # 95%+ accuracy, 300 FPS
    "eup",                   # Specific region for best accuracy
    user_name, serial_key, signature
)

# Process image
result = marearts_anpr_from_image_file(detector, ocr, "plate.jpg")
print(result)

# Output:
# {
#   "results": [
#     {
#       "ocr": "AB-123-CD",
#       "ocr_conf": 98.5,
#       "ltrb": [120, 230, 380, 290],
#       "ltrb_conf": 95
#     }
#   ],
#   "ltrb_proc_sec": 0.008,  # Detection time
#   "ocr_proc_sec": 0.003     # OCR time
# }

🔗 Resources

• 📊 Full Benchmarks: See detailed results in GitHub docs
• 📚 Model Guide: Complete model documentation
• 🧪 Try Free: ma-anpr test-api image.jpg
• 🛒 Get License: MareArts ANPR

🎯 Conclusion

MareArts ANPR V14 offers 11 detector models and 5 OCR models, giving you 55+ possible combinations! The right choice depends on your specific requirements:

• Speed-critical? → small_320p_fp32 + small_fp32
• Accuracy-critical? → large_640p_fp32 + large_fp32
• Balanced? → micro_320p_fp32 + small_fp32 (recommended!)
• Mobile? → micro_320p_fp16 + pico_fp32

Start with the recommended configuration and tune based on your results. Happy optimizing! ⚡🚗

---

Labels: ANPR, MachineLearning, ComputerVision, Performance, Benchmarks, Models, Metrics, DeepLearning, Optimization, GPU

MareArts ANPR V14 - Advanced Manual Processing & Performance Tuning

 

⚡ MareArts ANPR V14 - Advanced Manual Processing

Ready to take control? In this advanced guide, I'll show you how to manually process detections, measure performance, and optimize for your specific use case.

🎯 Why Manual Processing?

• Full control over detection pipeline
• Custom filtering and post-processing
• Performance measurement and optimization
• Integration with existing computer vision pipelines
• Custom confidence thresholds per stage

🔧 Manual Detection & OCR Pipeline

from marearts_anpr import ma_anpr_detector_v14, ma_anpr_ocr_v14
import cv2
from PIL import Image
import time

# Initialize models
detector = ma_anpr_detector_v14(
    "medium_640p_fp32",
    user_name, serial_key, signature,
    backend="cpu",
    conf_thres=0.25,
    iou_thres=0.5
)

ocr = ma_anpr_ocr_v14("medium_fp32", "eup", user_name, serial_key, signature)

# Load image
img = cv2.imread("plate.jpg")

# Step 1: Detect license plates
start = time.time()
detections = detector.detector(img)
detection_time = time.time() - start

print(f"Detection time: {detection_time:.4f}s")
print(f"Found {len(detections)} plate(s)")

# Step 2: Process each detection
results = []
ocr_time = 0

for i, box_info in enumerate(detections):
    # Get bounding box
    bbox = box_info['bbox']  # [x1, y1, x2, y2]
    score = box_info['score']  # Detection confidence
    
    # Crop plate region
    x1, y1, x2, y2 = int(bbox[0]), int(bbox[1]), int(bbox[2]), int(bbox[3])
    crop = img[y1:y2, x1:x2]
    
    if crop.size == 0:
        continue
    
    # Convert to PIL for OCR
    pil_img = Image.fromarray(crop)
    if pil_img.mode != "RGB":
        pil_img = pil_img.convert("RGB")
    
    # Run OCR
    start = time.time()
    text, confidence = ocr.predict(pil_img)
    elapsed = time.time() - start
    ocr_time += elapsed
    
    print(f"Plate {i+1}: {text} ({confidence}%) - {elapsed:.4f}s")
    
    results.append({
        "ocr": text,
        "ocr_conf": confidence,
        "bbox": [x1, y1, x2, y2],
        "det_conf": int(score * 100)
    })

print(f"\nTotal time: {detection_time + ocr_time:.4f}s")

📊 Detection Object Structure

# detector.detector(img) returns list of dictionaries:
[
    {
        'bbox': [x1, y1, x2, y2],  # Bounding box coordinates
        'score': 0.95,              # Detection confidence (0-1)
        'class': 'license_plate'    # Object class
    },
    ...
]

# ocr.predict(pil_image) returns tuple:
("ABC1234", 98.5)  # (text, confidence_percentage)

🚀 Backend Performance Comparison

backends = ["cpu", "cuda"]  # Add "directml" on Windows

for backend_name in backends:
    try:
        print(f"\n🔧 Testing {backend_name}...")
        
        # Initialize with specific backend
        test_detector = ma_anpr_detector_v14(
            "medium_640p_fp32",
            user_name, serial_key, signature,
            backend=backend_name,
            conf_thres=0.25
        )
        
        # Measure performance
        start = time.time()
        detections = test_detector.detector(img)
        elapsed = time.time() - start
        
        print(f"Detected {len(detections)} plates in {elapsed:.4f}s")
        print(f"Speed: {1/elapsed:.1f} FPS")
        
    except Exception as e:
        print(f"⚠️ {backend_name} not available: {e}")

⚙️ Performance Results (Typical)

Backend	Detection	OCR	Total	FPS
CPU (i7)	~0.15s	~0.03s	~0.18s	~5.5
CUDA (RTX 3060)	~0.008s	~0.002s	~0.01s	~100

Result: GPU acceleration = 18x faster! 🚀

🎛️ Custom Filtering

# Filter detections by confidence
min_detection_conf = 0.50
min_ocr_conf = 80.0

filtered_results = []

for box_info in detections:
    if box_info['score'] < min_detection_conf:
        continue  # Skip low confidence detections
    
    # Process with OCR...
    text, conf = ocr.predict(plate_crop)
    
    if conf < min_ocr_conf:
        continue  # Skip low confidence OCR
    
    filtered_results.append({
        "text": text,
        "confidence": conf,
        "bbox": bbox
    })

print(f"After filtering: {len(filtered_results)} high-confidence plates")

🎨 Custom Visualization

import cv2

# Draw boxes and text on image
for result in results:
    x1, y1, x2, y2 = result['bbox']
    text = result['ocr']
    conf = result['ocr_conf']
    
    # Draw rectangle
    cv2.rectangle(img, (x1, y1), (x2, y2), (0, 255, 0), 2)
    
    # Draw text
    label = f"{text} ({conf}%)"
    cv2.putText(img, label, (x1, y1-10), 
                cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)

cv2.imwrite("result.jpg", img)

📹 Video Processing Pipeline

import cv2

# Open video
cap = cv2.VideoCapture("traffic.mp4")

frame_count = 0
plate_history = {}

while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break
    
    frame_count += 1
    
    # Process every N frames (skip frames for speed)
    if frame_count % 5 != 0:
        continue
    
    # Detect plates
    detections = detector.detector(frame)
    
    for det in detections:
        bbox = det['bbox']
        x1, y1, x2, y2 = int(bbox[0]), int(bbox[1]), int(bbox[2]), int(bbox[3])
        crop = frame[y1:y2, x1:x2]
        
        if crop.size == 0:
            continue
        
        # OCR
        pil_crop = Image.fromarray(cv2.cvtColor(crop, cv2.COLOR_BGR2RGB))
        text, conf = ocr.predict(pil_crop)
        
        # Track plates (simple tracking by position)
        plate_id = f"{x1//50}_{y1//50}"
        
        if plate_id not in plate_history:
            plate_history[plate_id] = []
        plate_history[plate_id].append(text)
        
        # Draw
        cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
        cv2.putText(frame, text, (x1, y1-10), 
                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
    
    cv2.imshow('ANPR', frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

# Print detected plates
print("\nDetected plates:")
for plate_id, texts in plate_history.items():
    # Most common text for this plate
    most_common = max(set(texts), key=texts.count)
    print(f"  {most_common} (seen {len(texts)} times)")

💾 Batch Processing from Directory

import os
from pathlib import Path

image_dir = Path("./images")
results_all = {}

for img_path in image_dir.glob("*.jpg"):
    print(f"Processing {img_path.name}...")
    
    img = cv2.imread(str(img_path))
    detections = detector.detector(img)
    
    plates = []
    for det in detections:
        bbox = det['bbox']
        x1, y1, x2, y2 = int(bbox[0]), int(bbox[1]), int(bbox[2]), int(bbox[3])
        crop = img[y1:y2, x1:x2]
        
        if crop.size > 0:
            pil_crop = Image.fromarray(cv2.cvtColor(crop, cv2.COLOR_BGR2RGB))
            text, conf = ocr.predict(pil_crop)
            plates.append({"text": text, "conf": conf})
    
    results_all[img_path.name] = plates

# Save results
import json
with open("results.json", "w") as f:
    json.dump(results_all, f, indent=2)

print(f"\nProcessed {len(results_all)} images")

🎓 Advanced Tips

• GPU Memory: Use cuda backend for 10-100x speedup
• Confidence Tuning: Lower conf_thres to 0.15-0.20 for difficult images
• IOU Threshold: Increase iou_thres to reduce duplicate detections
• Batch Processing: Process multiple crops at once with ocr.predict([img1, img2, ...])
• Frame Skipping: Process every Nth frame in videos for speed
• Multi-threading: Run detector and OCR in separate threads

🔍 Troubleshooting

No detections?

• Lower conf_thres to 0.15
• Try larger model (large_640p_fp32)
• Check image quality and resolution

Wrong OCR results?

• Verify correct region (kr, eup, na, cn)
• Try larger OCR model (large_fp32)
• Check plate crop quality

Slow performance?

• Use GPU backend (cuda or directml)
• Use smaller models (small_640p_fp32, small_fp32)
• Skip video frames
• Batch process multiple images

💡 Conclusion

Manual processing gives you complete control over the ANPR pipeline. Use it for:

• ✅ Custom filtering and validation
• ✅ Performance optimization
• ✅ Video stream processing
• ✅ Integration with existing CV pipelines
• ✅ Advanced visualization and tracking

Happy optimizing! ⚡🚗

---