yolov8-license-plate-detection

License Plate Detection Model (YOLOv8)

A custom-trained YOLOv8 model for license plate detection, trained on a dataset from Roboflow with 100 epochs on CPU.

Model Details

• Model Type: YOLOv8 Nano (yolov8n)
• Task: Object Detection
• Classes: License Plates, Vehicles
• Training Epochs: 100
• Device: CPU (Lenovo ThinkPad)
• Image Size: 640x640
• Batch Size: 16
• Dataset Source: Roboflow
• Model Size: 72 layers, 3,006,038 parameters
• Computational Cost: 8.1 GFLOPs

Performance Metrics

Based on validation results on 70 images with 218 instances:

Overall Performance

• [email protected]: 0.865
• [email protected]:0.95: 0.669
• Precision: 0.855
• Recall: 0.824

Class-Specific Performance

License Plates (84 instances)

• [email protected]: 0.913
• [email protected]:0.95: 0.701
• Precision: 0.923
• Recall: 0.856

Vehicles (134 instances)

• [email protected]: 0.818
• [email protected]:0.95: 0.638
• Precision: 0.787
• Recall: 0.791

Installation

Using pip

pip install ultralytics

Using conda

conda install -c conda-forge ultralytics

Usage

Basic Detection

from ultralytics import YOLO

# Load the trained model
model = YOLO('best.pt')

# Run inference on an image
results = model('path/to/your/image.jpg')

# Display results
results[0].show()

# Save results
results[0].save('output.jpg')

Batch Processing

from ultralytics import YOLO
import os

# Load the model
model = YOLO('best.pt')

# Process multiple images
input_dir = 'path/to/input/images'
output_dir = 'path/to/output'

for filename in os.listdir(input_dir):
    if filename.lower().endswith(('.jpg', '.jpeg', '.png')):
        image_path = os.path.join(input_dir, filename)
        results = model(image_path)
        results[0].save(os.path.join(output_dir, f'detected_{filename}'))

Video Processing

from ultralytics import YOLO

# Load the model
model = YOLO('best.pt')

# Process video file
results = model('path/to/video.mp4')

# Process webcam stream
results = model(source=0, show=True)

Custom Configuration

from ultralytics import YOLO

# Load model with custom settings
model = YOLO('best.pt')

# Run inference with custom parameters
results = model(
    'image.jpg',
    conf=0.5,        # Confidence threshold
    iou=0.7,         # IoU threshold for NMS
    max_det=300,     # Maximum detections
    show=True,       # Display results
    save=True,       # Save results
    save_txt=True    # Save results in YOLO format
)

Getting Detection Data

from ultralytics import YOLO

model = YOLO('best.pt')
results = model('image.jpg')

# Extract detection information
for result in results:
    boxes = result.boxes  # Boxes object for bbox outputs
    masks = result.masks  # Masks object for segmentation masks outputs
    keypoints = result.keypoints  # Keypoints object for pose outputs
    probs = result.probs  # Probs object for classification outputs
    
    # Get bounding boxes coordinates
    if boxes is not None:
        for box in boxes:
            # Get coordinates
            x1, y1, x2, y2 = box.xyxy[0].tolist()
            confidence = box.conf[0].item()
            class_id = int(box.cls[0].item())
            
            print(f"License Plate detected at: ({x1:.2f}, {y1:.2f}, {x2:.2f}, {y2:.2f})")
            print(f"Confidence: {confidence:.2f}")

Training Configuration

The model was trained with the following parameters:

# Key training parameters
epochs: 100
batch: 16
imgsz: 640
device: cpu
workers: 8
lr0: 0.01
lrf: 0.01
momentum: 0.937
weight_decay: 0.0005
warmup_epochs: 3.0
patience: 100

# Data augmentation
hsv_h: 0.015
hsv_s: 0.7
hsv_v: 0.4
degrees: 0.0
translate: 0.1
scale: 0.5
shear: 0.0
perspective: 0.0
flipud: 0.0
fliplr: 0.5
mosaic: 1.0
mixup: 0.0
cutmix: 0.0

Model Files

• best.pt: Best model weights based on validation metrics
• last.pt: Last epoch model weights
• args.yaml: Training configuration file

Hardware Requirements

• Minimum: CPU with 4+ cores
• Recommended: GPU for faster inference
• Memory: 4GB+ RAM
• Storage: 500MB+ for model and dependencies

Limitations

• Model was trained on CPU, which may affect performance compared to GPU-trained models
• Accuracy may vary depending on image quality, lighting conditions, and plate types
• Model is optimized for the specific dataset used in training

Citation

If you use this model in your research, please cite:

@software{yolov8_license_plates,
  title={License Plate Detection using YOLOv8},
  author={Your Name},
  year={2024},
  url={https://huggingface.co/your-username/yolo-plates-detection}
}

License

This model is available under the MIT License. See LICENSE file for details.

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

Contact

For questions and support, please open an issue in the repository.