1. What is YOLO Methodology?

YOLO (You Only Look Once) is an advanced real-time object detection algorithm designed for speed and accuracy. Unlike traditional methods, YOLO processes an entire image in a single pass, making it highly efficient for vehicle detection.

1.1 Why YOLO for Car Number Plate Detection?

• Processes real-time video frames—ideal for highway monitoring.
• Detects multiple objects in a single pass, including vehicles and number plates.
• Ensures high accuracy in varying environments, such as low light or fast motion.

1.2 How YOLO Works?

Image 1: oblassification, localization and detection.

Image classification assigns images to categories by identifying the main object, while object localization determines both the object's presence and location. Object detection goes further by identifying multiple objects in an image and marking them with bounding boxes. Real-time object detection, like in self-driving cars, detects vehicles, pedestrians, and traffic signs to enhance safety. 🚗📸

YOLO divides an image into a grid, predicting bounding boxes and class probabilities for each section.

Image 2: Convolutional layer process.

The convolutional layer in a CNN applies a filter (kernel) to an input image, sliding across regions (receptive fields) with a defined stride. Each filter, matching the input depth, performs element-wise multiplications, summing the values into a feature map. This process, similar to cross-correlation, helps detect edges, blurs, or sharpens images. Larger filters capture broader patterns, while smaller ones focus on local details. Multiple layers work together to recognize complex features like a cat’s nose and ears. 🐱📸

1.2.1 Advancements in YOLO Versions

Image 3: Yolo versions

• YOLOv3 & YOLOv4: Improved feature extraction for better accuracy.
• YOLOv5 & YOLOv6: Lightweight and optimized for deployment.
• YOLOv7 & YOLOv8: High-resolution image detection.
• YOLOv11: Latest version with advanced deep learning enhancements.

Image 4: Efficiencies of Yolov11 comparing with other versions

1.2.2 Implementation in This Project

We use YOLOv11 with Ultralytics and OpenCV for real-time detection:

• Training YOLO on a custom dataset of vehicle plates.
• Using PaddleOCR for alphanumeric text recognition.
• Integrating OpenCV & MySQL for data storage.

2. Use of YOLOv11 for Object Detection

3. OpenCV Python for Image Processing

OpenCV (Open Source Computer Vision Library) is a powerful open-source library for computer vision and image processing. It is widely used in various domains such as robotics, artificial intelligence, medical imaging, and object detection.

3.1 Key Features of OpenCV for Image Processing:

• Image Manipulation: Resize, crop, rotate, and filter images.
• Edge Detection: Identify object boundaries using techniques like Canny edge detection.
• Color Space Conversion: Convert between color models like RGB, HSV, and Grayscale.
• Feature Detection: Detect key points using algorithms like SIFT, ORB, and FAST.
• Object Detection: Use pre-trained models for face detection, pedestrian detection, etc.
• Video Processing: Read, write, and manipulate video streams in real-time.

3.2 Example: Loading and Displaying an Image using OpenCV in Python

    
        pip install opencv-python

        import cv2

        image = cv2.imread('car.jpg') # Load an image
        gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # Convert to grayscale
        cv2.imshow('Original Image', image)    # Display the images
        cv2.imshow('Grayscale Image', gray_image)
        cv2.waitKey(0)     # Wait for a key press and close windows

        cv2.destroyAllWindows()
    
  

3.3 Why Use OpenCV for Image Processing?

• Fast and Efficient: Optimized for real-time applications.
• Cross-Platform: Works on Windows, Linux, macOS, and mobile platforms.
• Integration with AI: Can be combined with deep learning frameworks like TensorFlow and PyTorch.
• Large Community Support: Extensive documentation and community-driven development.

4. 🚀 Ultralytics in License Plate Detection

4.1 Introduction

License Plate Detection (LPD) is a crucial technology in smart surveillance and traffic management. Using Ultralytics YOLO, an advanced object detection framework, enhances speed, accuracy, and efficiency in real-time license plate recognition.

🛠️4.2 Why Use Ultralytics for License Plate Detection?

• ✅ Real-Time Performance – Fast detection for instant vehicle tracking.
• ✅ High Accuracy – Detects plates in low-light or high-speed conditions.
• ✅ Scalability – Works on edge devices, cloud, or embedded systems.
• ✅ Pre-Trained Models – Reduces development time with fine-tuned detection models.

🔍4.3 How Ultralytics YOLO Works for License Plate Detection

1. Image Acquisition: Captures frames from CCTV, drones, or dashcams.
2. Preprocessing: Enhances image quality for better recognition.
3. YOLO Model Inference: Detects and extracts plate regions.
4. OCR Integration: Reads and interprets plate numbers.
5. Data Logging & Analytics: Stores records for security or law enforcement.

Flow Diagram

Image: Number plate detection flow diagram curtesy researchgate.net

Real Detection Example

Image: Automatic number plate recognition (ANPR) Courtesy: ultralytics

🚦4.4 Applications of Ultralytics in License Plate Recognition

• 🔹 Traffic Monitoring: Tracks vehicle movement for congestion analysis.
• 🔹 Automated Toll Collection: Enables cashless toll payments.
• 🔹 Parking Management: Automates entry/exit systems.
• 🔹 Law Enforcement: Identifies stolen or suspicious vehicles.

💡4.5 Implementation: Running Ultralytics YOLO for LPD

Below is a Python implementation of Ultralytics YOLO for License Plate Detection:

    
      pip install ultralytics

      from ultralytics import YOLO
      
      # Load YOLO model pre-trained on license plates
      model = YOLO("yolov8n.pt")
      
      # Perform detection on an image
      results = model("car_with_plate.jpg", conf=0.5)
      
      # Display results
      results.show()
    
  

📂4.6 Download Pretrained Models & Datasets

To get started, download the necessary models and datasets:

Download YOLOv8 License Plate Datasets

🔥4.7 Why Ultralytics Stands Out?

• 🔹 Lightweight Yet Powerful: Works on low-power devices.
• 🔹 Open-Source & Extensible: Customizable for different regions.
• 🔹 Seamless Deployment: Integrates with Flask, FastAPI, or cloud services.

🌍 Summary

Ultralytics YOLO revolutionizes License Plate Detection by offering real-time, high-accuracy solutions for traffic systems, security monitoring, and automation. Whether for law enforcement, toll collection, or smart parking, it ensures precision and efficiency in plate recognition.

5. Using PaddlePaddle in YOLO

5.1 Installation of PaddlePaddle

To install PaddlePaddle on your system, use the following command:

  pip install paddlepaddle

For GPU acceleration, install the GPU version:

  pip install paddlepaddle-gpu

5.2 What is PaddlePaddle?

PaddlePaddle (Parallel Distributed Deep Learning) is an open-source deep learning framework developed by Baidu. It is used for **computer vision, natural language processing (NLP), and speech recognition**.

5.3 How PaddlePaddle Achieves Superior Speed

PaddlePaddle achieves superior benchmark speed using techniques as:

1. Data Parallelism
2. Model Parallelism
3. TensorRTs
4. Supported Models

5.3.1 Data Parallelism

Data parallelism in deep learning involves splitting the training data across multiple devices or machines, enabling parallel computation and faster training by independently processing subsets of data and aggregating gradients for updating shared model parameters.

Image: data parallelism, three GPUs. Courtesy https://learnopencv.com/

5.3.2 Model Parallelism

Model parallelism in deep learning involves dividing a single model across multiple devices or machines, enabling parallel computation by splitting different parts of the model across devices to handle larger models or memory constraints efficiently.

Image: Model Parallelism across two different GPUs. Courtesy https://learnopencv.com/

5.3.3 TensorRT

TensorRT is a high-performance deep learning inference optimizer and runtime library developed by NVIDIA. It is helpful for deep learning as it optimizes and accelerates inference tasks by optimizing network architectures, reducing precision, layer fusion, and leveraging GPU-specific optimizations, resulting in faster and more efficient execution of deep learning models on NVIDIA GPUs.

Image: TensorRT different processes involved. Courtesy https://learnopencv.com/

5.3.4 Supported Models

• More than 400 models are available on PaddlePaddle from different fields of AI.
• PaddlePaddle has started integrating its libraries with Huggingface; however, as of January 2023, 75 of the 400+ models have been implemented.
• Thus let us use models available directly from PaddlePaddle

5.4 How PaddlePaddle Works with YOLO?

• Model Training: Provides pre-trained YOLO models for custom datasets.
• Optimized Inference: Uses Paddle Lite & Paddle Inference for deployment.
• PaddleOCR Integration: Extracts text from license plates after YOLO detects them.
• Flexible APIs: Supports Python & C++ APIs for real-time object detection.

5.5 Example Use Case: License Plate Recognition

YOLO detects vehicles and localizes license plates → PaddleOCR extracts text → Paddle Serving processes in real-time.

Image: PaddlePaddle image procssing. Courtesy https://learnopencv.com/

5.6 Why Use PaddlePaddle for YOLO?

• ✅ Optimized Training: Distributed computing for faster training
• ✅ Real-Time Deployment: Supports **CPU, GPU, and edge AI accelerators**
• ✅ OCR Integration: Works with **PaddleOCR** for automatic text extraction
• ✅ Edge AI Ready: Runs on **Raspberry Pi, Jetson Nano, and cloud servers**

For more details, visit PaddlePaddle Official Site

6. PaddleOCR for Number Recognition

🚀6.1 PaddleOCR: An Overview

6.1.1 What is PaddleOCR?

PaddleOCR is an advanced Optical Character Recognition (OCR) tool developed by PaddlePaddle, an open-source deep learning framework by Baidu. It is widely used for extracting text from images and scanned documents, supporting multiple languages, handwritten text, and complex layouts.

6.2 Why is PaddleOCR Important?

• High Accuracy: Uses deep learning models for text detection and recognition.
• Multilingual Support: Recognizes text in over 80+ languages.
• Fast & Lightweight: Optimized for CPU and GPU performance.
• Flexible & Scalable: Ideal for license plate recognition, document scanning, ID verification, etc.
• End-to-End Pipeline: Handles text detection, recognition, and post-processing.

6.3 How PaddleOCR Works for Number Recognition?

1. Image Preprocessing: Convert image to grayscale, enhance contrast, and remove noise.
2. Text Detection: Uses DBNet or EAST to detect text regions.
3. Character Recognition: Extracts and recognizes numbers using CRNN (Convolutional Recurrent Neural Network).
4. Post-Processing: Corrects errors and structures extracted data.

6.4 Installing PaddleOCR

To install PaddleOCR, follow these steps:

Step 1: Install PaddlePaddle

    
      pip install paddlepaddle
    
  

Step 2: Install PaddleOCR

    
      pip install paddleocr
    
  

Step 3: Verify Installation

    
      from paddleocr import PaddleOCR
      ocr = PaddleOCR()
      result = ocr.ocr('car_plate.jpg', cls=True)
      print(result)
    
  

6.5 Examples of PaddleOCR in Action

Serial No	Application	Example
1️⃣	License Plate Recognition 🚗 - Extracts car plate numbers from images/videos.
2️⃣	ID Card Scanning 🆔 - Recognizes names, dates, and ID numbers.
3️⃣	Bank Cheque Processing 🏦 - Extracts handwritten amounts for banking automation.
4️⃣	Medical Reports 🏥 - Digitizes doctor prescriptions for patient records.
5️⃣	Invoice Data Extraction 🧾 - Automates receipt scanning for businesses.

Summary

PaddleOCR is a powerful AI-based text recognition tool that enhances automation in license plate recognition, document scanning, and digital transformation. It is fast, accurate, and easy to integrate into various AI applications.

7. Connecting to MySQL Database

7.1 Connecting to MySQL for Automatic License Plate Recognition

Flow Diagram

Image: Number plate detection flow diagram. Drawn by Hoque

Real Detection Example

Image: Automatic number plate recognition (ANPR)

7.2 Overview

This system automatically detects vehicles, extracts license plate numbers, estimates speed, and saves data in a MySQL database.

7.3 Creating the MySQL Database

    
        CREATE DATABASE vehicle_db;
        USE vehicle_db;
        CREATE TABLE vehicles (
          id INT AUTO_INCREMENT PRIMARY KEY,
          date DATE NOT NULL,
          time TIME NOT NULL,
          track_id INT NOT NULL,
          plate_number VARCHAR(20) NOT NULL,
          vehicle_class VARCHAR(50),
          speed FLOAT NOT NULL,
          location VARCHAR(100),
          entry_timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP
        );
    
  

7.4 Installing Dependencies

    
      pip install mysql-connector-python
    
  

7.4.1 Python Code for MySQL Connection

    
      import mysql.connector
      from datetime import datetime

      def connect_to_db():
        try:
            connection = mysql.connector.connect(
                host="localhost",
                user="root",
                password="yourpassword",
                database="vehicle_db"
            )
            return connection
        except mysql.connector.Error as e:
            print("Error connecting to MySQL:", e)
            return None
    
  

7.4.2 Saving Data to MySQL

    
      def save_to_database(date, time, track_id, plate_number, vehicle_class, speed, location):
        connection = connect_to_db()
        if connection:
            cursor = connection.cursor()
            sql_query = """
                INSERT INTO vehicles (date, time, track_id, plate_number, vehicle_class, speed, location)
                VALUES (%s, %s, %s, %s, %s, %s, %s)
            """
            values = (date, time, track_id, plate_number, vehicle_class, speed, location)
            cursor.execute(sql_query, values)
            connection.commit()
            print("Data inserted successfully")
            cursor.close()
            connection.close()
    
  

7.4.3 Example Usage

    
      from datetime import datetime
      save_to_database(
        date=datetime.today().strftime('%Y-%m-%d'),
        time=datetime.now().strftime('%H:%M:%S'),
        track_id=101,
        plate_number="ABC-1234",
        vehicle_class="Sedan",
        speed=65.2,
        location="Highway 401"
      )
    
  

7.5 Flow Diagram (Recommended)

Consider adding a flowchart to visualize the process:

• 📷 Camera Captures Video
• 🛑 YOLO Detects Vehicles
• 🔠 OCR Extracts License Plate Number
• 🚗 Speed is Estimated
• 📡 Data Sent to MySQL Database
• 💾 Stored for Analysis & Reporting

8. Database Structure & MySQL Tables

8.1 Database Structure & MySQL Tables

To store and manage the detected license plate information along with speed and other details, we will use a MySQL database named numberplates_speed.

8.1.2 Database Name: numberplates_speed

This database is designed to store real-time vehicle detection and tracking data.

8.1.3 Table Name: my_data

This table will store vehicle detection data, including license plate numbers, timestamps, vehicle speed, and classification.

8.1.4 Table Schema

    
      CREATE DATABASE numberplates_speed;

      USE numberplates_speed;

      CREATE TABLE my_data (
          id INT AUTO_INCREMENT PRIMARY KEY,
          date DATE NOT NULL,
          time TIME NOT NULL,
          track_id INT NOT NULL,
          class_name VARCHAR(255) NOT NULL,
          speed FLOAT NULL,
          numberplate TEXT NULL
      );

      #NOTE: Sometime, the system may not be able to retrieve registration numberplate 
      due to poor visibility, physical obstructions by other vehicles or some other reasons. Similarly 
      conditions may apply to speed also. Therefore, these fields are allowed to cantain null values.
    
  

8.1.5 Explanation of Table Columns

8.2 How It Works Automatically

• License Plate Detection: The system captures images/videos of moving vehicles using a camera. The YOLO object detection model identifies vehicles and their license plates.
• OCR Processing: The detected license plate region is extracted and converted to text using PaddleOCR.
• Speed Estimation: The system calculates the vehicle’s speed based on timestamps and frame analysis.
• Data Storage in MySQL: The extracted information is automatically inserted into the my_data table in the numberplates_speed database.

8.3 Example: Inserting Data into the Table

    
      INSERT INTO my_data (date, time, track_id, class_name, speed, numberplate)
      VALUES ('2025-02-26', '14:30:00', 101, 'Car', 72.5, 'ABC-1234');
    
  

8.4 Retrieving Data from the Table

    
      SELECT * FROM my_data ORDER BY id DESC LIMIT 10;
    
  

10. Using PyTorch (.pt files) for Deep Learning

10.1 What is PyTorch and .pt Files?

PyTorch is an open-source deep learning framework developed by Facebook AI. It is widely used for machine learning and deep learning tasks, including image recognition, NLP, and reinforcement learning.

A .pt file is a PyTorch model file that stores trained model parameters. These files are used to save and load deep learning models efficiently, enabling model deployment without retraining.

10.2 Why is PyTorch (.pt Files) Important?

• ✅ Efficient Model Storage: `.pt` files store trained model weights, reducing computational overhead.
• ✅ Easy Deployment: Pre-trained models can be loaded and used without re-training.
• ✅ Flexible: Works with both CPU and GPU acceleration, making it ideal for deep learning applications.
• ✅ Supports Transfer Learning: You can fine-tune pre-trained models for specific tasks like license plate recognition.

10.3 How PyTorch (.pt Files) Works in License Plate Recognition?

1. Train a YOLO or CNN Model: A PyTorch-based deep learning model (YOLO, CNN, or a custom network) is trained using images of license plates.
2. Save Model Weights as .pt File: After training, model weights are stored in a .pt file.
3. Load Pre-trained Model: During plate recognition, the `.pt` file is loaded into PyTorch for inference.
4. Detect and Recognize Plate Numbers: The model processes input images, detects plates, and extracts the text using OCR tools like PaddleOCR.
5. Post-processing: The detected plate numbers are cleaned and formatted for display or database storage.

10.4 How to Install PyTorch?

10.4.1 Using pip (Recommended)

    
      pip install torch torchvision torchaudio
    
  

10.4.2 For CUDA (GPU Acceleration)

    
      pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
    
  

10.5 Example: Using PyTorch (.pt) File for License Plate Recognition

1️⃣ Load a Pre-trained Model

    
      import torch
      import cv2
      import numpy as np

      # Load the trained PyTorch model (.pt file)
      model = torch.hub.load('ultralytics/yolov5', 'custom', path='plate_detector.pt')

      # Set the model to evaluation mode
      model.eval()
    
  

2️⃣ Run Plate Detection on an Image

    
        # Load image
        image_path = 'car_plate.jpg'
        image = cv2.imread(image_path)

        # Convert image to RGB (PyTorch models usually expect RGB)
        image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

        # Perform inference
        results = model(image_rgb)

        # Show results
        results.show()
    
  

3️⃣ Extract Plate Numbers Using PaddleOCR

    
        from paddleocr import PaddleOCR
        ocr = PaddleOCR()
        plate_text = ocr.ocr(image_path)
        
        print("Detected Plate Number:", plate_text)
    
  

Summary

Using PyTorch (.pt) files enables efficient license plate recognition by allowing quick model loading and inference. Combining PyTorch with YOLO, OpenCV, and PaddleOCR makes license plate detection highly accurate and deployable in real-world applications. 🚗🔍

11. MP4 Video Demonstrations

11.1 MP4 Video Demonstrations for Automatic License Plate Recognition

In this section, we explain how to run a video demonstration where the YOLO-based system detects vehicle types, speed, and license plates automatically.

1️⃣ Running the Video and Starting Automatic Recognition

To execute the program and process an MP4 video file, follow these steps:

1. Ensure that the main.py file and the pretrained YOLO model (.onnx or .pt) are stored in the same directory as the video file.
2. Open Windows Command Prompt or Anaconda Command Prompt and navigate to the project folder: cd D:\YOLOV11
3. Run the following command to start processing the video and detect vehicles and their details:

Storing data into my_data table:

After opening MySql database table, detection information are stored as:

Image: Records in MySql database table

2️⃣ How YOLO Recognizes Vehicles, Speed, and Number Plates

The system uses YOLO (You Only Look Once) for object detection and PaddleOCR for text recognition. The process follows these steps:

• Frame Processing: The system extracts frames from the video and processes them for object detection.
• Vehicle Recognition: The YOLO model detects different vehicle types such as Car, Truck, Bus, Motorcycle.
• Speed Estimation: The system tracks vehicle movement across frames and estimates speed.
• License Plate Detection & OCR: The license plate region is extracted and converted into readable text using PaddleOCR.
• Database Entry: Extracted details (date, time, vehicle type, speed, number plate) are stored in a MySQL database.

3️⃣ Example of Output in Command Prompt

        
          [INFO] Loading YOLO model from yolo11n.onnx...
          [INFO] Processing video file: car.mp4
          [INFO] Detected Vehicle: Car | ID: 101 | Speed: 72.5 km/h | Plate: ABC-1234
          [INFO] Detected Vehicle: Truck | ID: 102 | Speed: 55.0 km/h | Plate: XYZ-5678
          [INFO] Data saved to MySQL database successfully.
        
      

4️⃣ Running the Program with a Live Camera

Instead of using an MP4 video file, you can process a live camera feed by running:

python main.py --model yolo11n.onnx --source 0

Note: Here, 0 represents the default webcam connected to your system.

5️⃣ Summary of the Process

• Runs an MP4 video or live camera feed
• Detects different vehicle types using YOLO
• Estimates speed based on frame timestamps
• Extracts license plate text using PaddleOCR
• Stores data in a MySQL database

13. Conclusion

This project successfully implements an Automatic License Plate Recognition (ALPR) system using YOLO v11 to detect and recognize vehicle license plates in real-time. From the initial setup to final execution, the system follows a structured pipeline:

1. Installing Dependencies

We installed essential Python libraries such as OpenCV, Ultralytics, PaddlePaddle, PaddleOCR, and MySQL Connector to facilitate image processing, YOLO-based detection, OCR, and database storage.

2. Data Processing & Model Integration

The system processes input video feeds and leverages YOLO v11 to detect vehicles and their license plates. The detected plates are then processed using PaddleOCR for text recognition.

3. Database Storage & Analytics

Recognized license plates, along with additional data such as vehicle speed and classification, are stored in a MySQL database, allowing structured retrieval and analysis.

4. Live Demonstration & Results

The system can be tested using a video feed (MP4), with command-line execution ensuring automatic recognition, tracking, and storage of results.

5. Scalability & Future Enhancements

This project provides a scalable framework that can be extended to real-time traffic monitoring, law enforcement applications, and smart city infrastructure. Future enhancements could include:

• Deep learning improvements for higher accuracy
• Cloud-based processing for large-scale deployment
• AI-powered analytics for better performance

By leveraging YOLO v11 and OCR technologies, this project demonstrates an efficient and automated license plate recognition system, offering practical applications in vehicle tracking, security, and transportation management. 🚀

14. References