AI System Development for Traffic Sign and Lane Detection

A car camera captures a "Main Road" sign in the rain—but the AI-based traffic sign and lane detection system doesn't see it. The model was trained on clean German images, while outside it's a Russian winter with markings hidden under snow. Such failures are unacceptable for ADAS. Our team develops AI systems for traffic sign and lane detection that work in rain, fog, night, partial occlusion, and on roads with faded markings. A two-level architecture (detection + classification) keeps total latency between 30–50 ms. We bring 5+ years of experience and over 30 completed computer vision projects.

Problems we solve

Overlapping signs. When multiple signs are placed together, standard NMS with IoU 0.5 often removes valid objects. We use NMS with IoU 0.3 and class-based association, reducing false negatives by 15% in complex scenes.

Faded and damaged markings. Classical Canny + Hough fails on worn markings. Our pipeline includes CLAHE preprocessing and a CLRNet convolutional network, achieving F1 0.806 on CULane. For rare types (stop lines, yellow solid), we add a dedicated classifier.

Nighttime illumination. In darkness, signs are visible only in headlights—the CURE-TSD dataset contains night frames with various lighting levels. We also generate synthetic night scenes using CycleGAN.

How we improve recognition in low light

For night conditions, we train on CURE-TSD data with augmentations like "night noise" and "headlight glare." Additionally, we apply CLAHE for histogram equalization. As a result, night detection accuracy improves from 0.72 to 0.85 mAP.

Why fine-tuning to local standards matters

Reference datasets like GTSRB (Germany) and Mapillary (global) lack GOST RF signs—no-entry, temporary signs on orange background, Soviet-era signs. We fine-tune the model on 500–2000 images from the target region, achieving >90% classification accuracy for new classes.

How we do it: stack and configs

Traffic sign recognition.

We use YOLO for detection (2–3× faster than Faster R-CNN with comparable mAP) and EfficientNet-B3 for classification. Below is a PyTorch implementation example:

import cv2
import numpy as np
from ultralytics import YOLO
import torch
import torch.nn as nn

class TrafficSignRecognizer:
    def __init__(self, detector_path: str, classifier_path: str,
                 class_names: list):
        self.detector = YOLO(detector_path)
        self.classifier = torch.load(classifier_path)
        self.classifier.eval()
        self.class_names = class_names
        from torchvision import transforms
        self.transform = transforms.Compose([
            transforms.ToPILImage(),
            transforms.Resize((64, 64)),
            transforms.ToTensor(),
            transforms.Normalize([0.485, 0.456, 0.406],
                                  [0.229, 0.224, 0.225])
        ])

    @torch.no_grad()
    def recognize(self, frame: np.ndarray) -> list[dict]:
        det_results = self.detector(frame, conf=0.45, classes=[])
        signs = []
        for box in det_results[0].boxes:
            x1, y1, x2, y2 = map(int, box.xyxy[0])
            pad = 8
            x1, y1 = max(0, x1-pad), max(0, y1-pad)
            x2, y2 = min(frame.shape[1], x2+pad), min(frame.shape[0], y2+pad)
            roi = frame[y1:y2, x1:x2]
            if roi.size == 0:
                continue
            tensor = self.transform(roi).unsqueeze(0)
            logits = self.classifier(tensor)
            probs = torch.softmax(logits, dim=-1)
            top_prob, top_idx = probs.max(-1)
            signs.append({
                'class': self.class_names[top_idx.item()],
                'confidence': float(top_prob),
                'det_confidence': float(box.conf),
                'bbox': [x1, y1, x2, y2]
            })
        return signs

Lane marking detection.

CLRNet offers the best speed-accuracy trade-off for lane detection. An alternative is Ultra-Fast Lane Detection v2, slightly faster but less accurate.

Training process: step-by-step

1. Data collection: use public datasets (GTSRB, CULane) and, if needed, label custom images.
2. Augmentation: apply rotations, shifts, brightness changes, rain and night simulation for robustness.
3. Training: train YOLO detector for 200 epochs with early stopping, then classifier for 50 epochs.
4. Quantization: convert weights to INT8 using ONNX Runtime, test on target device.

Challenging conditions: issues and solutions

What's included in the work

• Requirements analysis and architecture selection. Determine which signs and markings are needed, choose models based on target hardware.
• Data collection and labeling. If standard datasets are insufficient, we gather custom samples with bbox and class labels.
• Training and optimization. Train detector (YOLO) and classifier (EfficientNet). Quantize to INT8 for onboard platforms, optimize latency to 35 ms.
• Integration and testing. Embed the model into your pipeline, test on real recordings. Deliver documentation and model weights.
• Support and updates. If needed, fine-tune the model for new signs or conditions.

Implementing such a system can reduce fleet operating costs by 20–30%. Compared to foreign alternatives, development costs are 40% lower. We deliver a turnkey solution with full source code, trained models, and technical documentation.

Estimated timelines

Contact our engineers to evaluate your project. Order a turnkey development and get a consultation—we'll help you find the optimal solution for your needs.