Nomeroff Net runs YOLOv8 detection with a custom RNN OCR stage

One pipeline call hides a detection network, a pose network and an RNN reader

The README describes Nomeroff Net as an opensource python license plate recognition framework based on YOLOv8 bbox and pose networks and customized OCR-module powered by RNN architecture. Three separate stages are therefore involved before a plate becomes a string of characters, and the project exposes them through a single entry point called number_plate_detection_and_reading.

The return value shows how much state the pipeline keeps. The first example unpacks nine items: images, images_bboxs, images_points, images_zones, region_ids, region_names, count_lines, confidences and texts. Bounding boxes locate plates, the points array is the pose output, the zones and region identifiers attach a country and region reading to each plate, count_lines records how many text rows a plate has, confidences carries a score and texts is the actual transcription.

That width matters when you decide whether to use the raw return value or the helper the project ships for it. A caller who only needs the characters can ignore the rest, but a caller building an access log or a rejection queue needs the region identifiers and the confidence values that sit next to them. The unzip helper from nomeroff_net.tools exists to flatten this structure so a batch of images can be handled as one call.

The short pipeline trades away pose points, regions and confidences

A second pipeline exists for hardware that cannot carry the full model set. It is named number_plate_short_detection_and_reading, and the README is direct about the cost: the example disables some important Nomeroff Net features. The documented behaviour is that it recognises numbers photographed in a horizontal position, so tilted or angled plates are out of scope for this path.

The output contract changes too. The short pipeline returns four values instead of nine: images, images_bboxs, zones and texts. There are no pose points, no region identifiers or names, no line counts and no confidence scores in that tuple. Any code written against the full pipeline has to be rewritten, not merely repointed, if you move to the short one.

The documented print output for the short path is included below. It shows the texts list holding one entry for the first image and two entries for the second, which is consistent with a single plate and a two plate image in the example folder.

from nomeroff_net import pipeline
from nomeroff_net.tools import unzip

number_plate_detection_and_reading = pipeline("number_plate_short_detection_and_reading", 
                                              image_loader="opencv")

(images, images_bboxs,
 zones, texts) = unzip(number_plate_detection_and_reading(['./data/examples/oneline_images/example1.jpeg', 
                                                           './data/examples/oneline_images/example2.jpeg']))
 
print(texts)
# (['AC4921CB'], ['RP70012', 'JJF509'])

Installation is a Linux clone plus a split system and Python dependency install

The README states that Nomeroff Net requires Python >= 3.9, and the installation instructions only cover Linux. The project is cloned first.

git clone https://github.com/ria-com/nomeroff-net.git
cd nomeroff-net

On Centos, Fedora and other RedHat-like systems the README asks for OpenCV support libraries, the Python development headers needed by pycocotools, a compiler and the libjpeg-turbo repository. The compiler is not optional, because two of the Python dependencies are installed from git sources.

# for Opencv
yum install libSM

# for pycocotools install 
yum install python3-devel 

# ensure that you have installed gcc compiler
yum install gcc

yum install git

# Before "yum install ..." download https://libjpeg-turbo.org/pmwiki/uploads/Downloads/libjpeg-turbo.repo to /etc/yum.repos.d/
yum install libjpeg-turbo-official

Ubuntu and other Debian-like systems need the equivalent set, with python3.9-dev for pycocotools and libturbojpeg for image decoding.

# ensure that you have installed gcc compiler
apt-get install gcc

# for opencv install
apt-get install -y libglib2.0
apt-get install -y libgl1-mesa-glx

# for pycocotools install (Check the name of the dev-package for your python3)
apt-get install python3.9-dev

# other packages
apt-get install -y git
apt-get install -y libturbojpeg

Both paths end with the same dependency step.

pip3 install -r requirements.txt 

No install instructions for macOS or Windows appear in the README, so a team on either platform has to reproduce the Linux steps by hand or work in a container.

The country classifier is tuned for Ukrainian plates and asks for help with the rest

The system uses several neural networks, and one of them runs at the post-processing stage. It is a classifier of numbers that decides the country and the type of a license plate, and the README quotes an accuracy of 99% for that categorizer. Those numbers describe the classifier as configured, not as a general promise.

The README then draws the boundary explicitly: the classifier is configured mainly for the definition of Ukrainian numbers, and for other countries it will be necessary to train the classifier with new data. That is the single most important line for an adopter outside Ukraine. A plate from Poland, Germany or the Netherlands is not a supported case out of the box, and no amount of configuration changes that, because the training data behind the categorizer is Ukrainian.

The project handles this by asking for help. It invites contributors who are interested in helping with the formation of a dataset for their country, and it names VGG Image Annotator as the recommended marking tool for new plate images. The upstream data comes from RIA.com and is published as the AUTO.RIA Numberplate Dataset, with a separate options dataset feeding the post-processing classifier.

So the realistic adoption path for a non Ukrainian fleet is: take the framework, collect and label local plates with VIA, retrain the classifier and the OCR, and accept that work as part of the project rather than as a configuration step.

Four OCR datasets and an options dataset live outside the repository

The training corpus is not stored in the Git repository. The README links to downloadable archives hosted on the project site, and it names several of them. The OCR stage uses a specialised implementation of a neural network with RNN layers, and four OCR datasets were created for it: an Ukrainian dataset, an Ukrainian dataset with the old design, a European dataset and a Russian dataset.

That dataset list is the clearest statement of the intended operating range. Ukrainian plates are covered by two sets, which suggests the older plate design was a separate recognition problem. European and Russian plates are covered by one set each, which is enough for a baseline rather than for a well matched recogniser.

The post-processing classifier has its own dataset, the AUTO.RIA Numberplate Options Dataset, described as the source for the network that classifies numbers at the post-processing stage.

For a new user this has a practical consequence. Cloning the repository gives you code and configuration, not data. The datasets sit on the project site as zip archives and are large enough that they are not something you want to fetch by accident. Budget for the download, and note that the README points to the same archives for every region, so picking the right one per country is a manual step.

Small GPUs push you toward a hosted commercial API instead of a local install

The README addresses hardware limits directly. It points at the Numplate RIAder API, a commercial service from RIA.com that runs recognition remotely on RIA.com servers, for readers who cannot install and configure Nomeroff Net themselves or whose client hardware cannot run a service requiring ML computing.

The service is described as based on the open source Nomeroff Net engine with commercial modifications aimed mainly at using improved models that can produce better results in photos with poor image quality. That is an important distinction for cost comparisons. The hosted product is not the open source engine running on better hardware, it is a modified variant with different model weights, and the open source path does not ship those weights.

The README also mentions an online form at nomeroff.net.ua/onlinedemo.html where you can upload a photo and get a recognition result, and it describes the hosted demo as free to try. For an engineer this is the cheapest way to find out whether the approach fits a problem before committing a machine to it.

Note the licensing consequence of that route. The engine is GPL-3.0, so the hosted service is the vendor's commercial option; if you want the open source code in your own stack you are on the hook for the local install path and its dependency chain.

setup.py pulls four dependencies straight from git and pins an old Lightning release

The packaging file reveals how the install works under the hood. setup.py reads the version out of nomeroff_net/__init__.py with a regular expression, and it reads requirements.txt, splitting that file on the marker # git repos. The text before the marker becomes the package list and the text after it becomes the repository list. The four git sources are the upscaler and craft_text_detector projects from ria-com, PyTurboJPEG from lilohuang, and modelhub_client from ria-com.

Two of those four are not published on PyPI, so a pip install of the project reaches outside the package index and pulls code from GitHub branches that can change without any version marker. For a deployment you control, pin those commits yourself.

The pinned Python stack is the other point of friction. The requirements list asks for torch>=1.12 and torchvision>=0.13, while pytorch_lightning is fixed at exactly 1.8.6, a release from the 2.0 era, and ultralytics is asked for at 8.3.12 or newer. A strict Lightning pin next to open ended torch and ultralytics requirements is a realistic source of resolver conflicts, and the README does not document an upgrade procedure.

On maintenance, the repository is not archived and the last push was on 2026-09-10. The most recent tagged release is v4.0.0, dated 2024-12-04, and the README itself refers to version 4.0.0. So commits continue to land on master while the released line lags behind, which is normal for a research project but means pip installs and a cloned checkout can behave differently. The licence is GPL-3.0, and setup.py classifies the package under the GNU General Public License v3.

Editorial conclusion

Nomeroff Net suits teams already working with Ukrainian vehicles and willing to train their own data, and it suits anyone who wants a readable pipeline to fork. It does not suit a team expecting a plug and play recogniser for European plates, and it should not be adopted before you confirm that the pinned pytorch_lightning release still installs against the torch version on your machine, since the README does not document a supported upgrade path.

Frequently asked questions

Official sources

1. Issues
2. License: GPL-3.0
3. README
4. Releases
5. ria-com/nomeroff-net on GitHub