Video Analytics for Traffic Monitoring: YOLO & ByteTracker

At a busy intersection, manual vehicle counting yields up to 30% error, and loop detectors break every six months. Video analytics based on YOLO and ByteTracker solves both problems: counting accuracy reaches 95–98%, and incident detection takes less than 5 seconds. By ordering such a turnkey system, you get monitoring of traffic volume by direction, flow speed, density, vehicle classification, and detection of accidents, stopped cars, and violations. Our engineers have over 10 years of experience in industrial computer vision — this guarantees stable operation in any weather. On one project for an intersection in Minsk, the system replaced 12 loop detectors, reducing maintenance costs by 60%.

How YOLO and ByteTracker ensure accurate traffic counting?

We use YOLO (You Only Look Once) — a family of neural networks for real-time object detection. Compared to classical methods (OpenCV + HOG), YOLO is 2–3 times more accurate and faster. Our base model is YOLOv8, trained on the COCO dataset and fine-tuned on recordings from city intersections. This gives classification accuracy of 92–96% and recall of 95–98%. The Ultralytics article confirms that YOLOv8 achieves mAP 0.53 on COCO — a benchmark for real-time detection. To improve robustness to weather conditions, we apply data augmentation: rain, fog, lighting changes.

Why is ByteTracker important?

To track each vehicle across frames, we implement ByteTracker. It works effectively under occlusions (when one car blocks another) and false positives. Without a tracker, correct counting and speed measurement are impossible. ByteTracker uses low-threshold detections, reducing track breaks by 30% compared to simple IoU tracking.

How do we estimate speed from video stream?

Below is the SpeedEstimator implementation, which calculates speed through position change over 5 frames. Error is ±5–10 km/h, sufficient for detecting violations and analyzing congestion.

class SpeedEstimator: def __init__(self, fps: float = 30.0, pixels_per_meter: float = 50.0): self.fps = fps self.ppm = pixels_per_meter self.track_positions = {} self.track_speeds = {} def estimate(self, track_id: int, position: tuple) -> float: """Speed in km/h through position change""" if track_id not in self.track_positions: self.track_positions[track_id] = [] self.track_positions[track_id].append(position) history = self.track_positions[track_id] if len(history) < 5: return 0.0 # Average displacement over last 5 frames recent = history[-5:] total_dist_px = sum( np.linalg.norm(np.array(recent[i]) - np.array(recent[i-1])) for i in range(1, len(recent)) ) avg_dist_px_per_frame = total_dist_px / (len(recent) - 1) dist_m_per_frame = avg_dist_px_per_frame / self.ppm speed_ms = dist_m_per_frame * self.fps speed_kmh = speed_ms * 3.6 self.track_speeds[track_id] = speed_kmh return round(speed_kmh, 1) 

Camera calibration is performed once: we measure the real distance between two points on the road and compute the pixels_per_meter coefficient. If the camera angle changes, recalibration is needed, but for stationary cameras this is a one-time procedure.

Incident Detection

The system automatically detects stopped vehicles (speed threshold <2 km/h for more than 30 seconds), hard braking, accidents, and improper pedestrian behavior. Example detector below.

class IncidentDetector: def __init__(self, stopped_threshold_sec: float = 30.0): self.stopped_vehicles = {} self.stopped_threshold = stopped_threshold_sec self.incident_cooldown = {} def check_incidents(self, vehicles: list[dict], timestamp: float) -> list[dict]: incidents = [] for vehicle in vehicles: tid = vehicle['track_id'] speed = vehicle.get('speed_kmh', 0) pos = vehicle['center'] if speed < 2: if tid not in self.stopped_vehicles: self.stopped_vehicles[tid] = (pos, timestamp) else: stopped_pos, first_seen = self.stopped_vehicles[tid] duration = timestamp - first_seen if duration > self.stopped_threshold: if tid not in self.incident_cooldown or \ timestamp - self.incident_cooldown[tid] > 120: incidents.append({ 'type': 'stopped_vehicle', 'vehicle_id': tid, 'class': vehicle['class'], 'position': pos, 'duration_sec': duration }) self.incident_cooldown[tid] = timestamp else: self.stopped_vehicles.pop(tid, None) return incidents 

Any vehicle stopped for more than 30 seconds (configurable) is logged as an incident. This helps prevent secondary accidents and optimize tow truck dispatch. By analyzing abrupt changes in speed and position, the system can detect collisions. Additional rules can detect wrong-way driving or shoulder driving.

Vehicle Classification and Traffic Metrics

Output metrics for transportation authorities:

• PCE (Passenger Car Equivalent): truck = 2.0 PCE, bus = 1.5 PCE, motorcycle = 0.5 PCE
• LOS (Level of Service): V/C ratio → level A–F
• Speed distribution: speed histogram
• Headway: time gap between vehicles

What is included in our work?

1. Site analysis — on-site visit, assessment of camera placement, lighting, infrastructure requirements.
2. Design — model selection, processing architecture, tracker tuning, speed calibration.
3. Development and training — fine-tune YOLO for the specific site, integrate ByteTracker, create web interface.
4. Testing — run on historical recordings, measure accuracy, performance stress test.
5. Deployment and integration — install on server, connect to your software, configure alerts.
6. Documentation and training — provide instructions, train operators, 12-month warranty support.

We also version models with MLflow and monitor data drift to maintain accuracy over time. All components are licensed and compatible with traffic control systems.

Estimated Timeline

Budget savings on monitoring reach up to 50% compared to loop detectors. Get an engineer consultation and a live demo using your data. Contact us — we'll assess your project and provide a custom commercial proposal. Order a 2-week pilot project to confirm the system's effectiveness.