AI-Based Trailer Identification

A machine learning system for automated truck trailer identification through barcode and sticker detection, designed for real-time edge inference on NVIDIA Jetson hardware. Developed as a Bachelor's thesis project within the TIDA5G initiative at Krone Business Center GmbH.

Problem Statement

During storage operations at Krone Business Center GmbH, trailers are occasionally lost or their positions are incorrectly entered into the existing software by Terberg drivers. These discrepancies lead to time-consuming search processes, delays, and increased operating costs. Manual inventory of trailers on storage yards is error-prone, costly, and disrupts the logistics chain.

The goal was to develop an automated, AI-powered solution that identifies trailers via their barcodes and stickers, even under varying lighting conditions, angles, and weather, and deploys directly on edge hardware mounted on yard vehicles.

System Architecture

Camera (Terberg / Drone)
        │
        ▼
┌─────────────────────────────┐
│   NVIDIA Jetson Orin Nano   │
│         (8GB)               │
│                             │
│  ┌───────────────────────┐  │
│  │   TensorRT Engine     │  │
│  │   (Optimized Model)   │  │
│  └───────────┬───────────┘  │
│              │              │
│  ┌───────────▼───────────┐  │
│  │   Object Detection    │  │
│  │   Trailer + Barcode   │  │
│  └───────────┬───────────┘  │
│              │              │
│  ┌───────────▼───────────┐  │
│  │   Barcode Sequence    │  │
│  │   Extraction          │  │
│  └───────────────────────┘  │
└─────────────────────────────┘
        │
        ▼
  Inventory System

Model Selection & Comparison

Three major object detection architectures were evaluated for suitability:

YOLO was selected as the primary architecture due to its real-time processing capability, critical for the Krone use case where trailers must be identified quickly without disrupting yard operations. Faster R-CNN was implemented as a secondary model for comparison.

Implementation

Three Model Approaches

1. Custom YOLOv8 (from scratch): Full implementation of the YOLOv8 architecture in PyTorch, including backbone (CSPDarknet-inspired), neck (PANet), head, and custom loss functions (CIoU + Distribution Focal Loss). This approach encountered challenges with tensor shape alignment and loss function implementation.

2. YOLOv8 Ultralytics: Using the Ultralytics library with pretrained weights and fine-tuning on custom datasets. This was the most successful approach, achieving >90% mAP.

3. Faster R-CNN (ResNet-50 + FPN): Using torchvision's pretrained Faster R-CNN with a custom classification head, fine-tuned on trailer and sticker datasets.

Custom YOLOv8 Architecture

The from-scratch implementation included these key components:

Input Image (416×416)
    │
    ▼
┌─────────────────────────────┐
│      YOLOv8 Backbone        │
│  Conv → Conv → Conv → Conv  │
│  (3→64→128→256→512→1024)    │
│           │                 │
│      SPPF Layer             │
│  (Multi-scale pooling)      │
└─────────────┬───────────────┘
              │
              ▼
┌─────────────────────────────┐
│       YOLOv8 Head           │
│  Upsample + C2f blocks     │
│  Multi-scale detection      │
│  (P3, P4, P5)              │
└─────────────┬───────────────┘
              │
              ▼
  [bbox, objectness, class]
  per grid cell at 3 scales

Key architectural components:

• Conv: 2D Convolution + BatchNorm + SiLU activation
• Bottleneck: 1×1 reduction → 3×3 expansion with residual connections
• C2f: Cross-Stage Partial blocks with multiple Bottleneck layers
• SPPF: Spatial Pyramid Pooling Fast for multi-scale feature extraction

Loss Function Evolution

The initial MSE + BCE loss function suffered from underfitting. It was replaced with:

• CIoU Loss: Complete Intersection over Union, accounting for centroid distance and aspect ratio
• Distribution Focal Loss (DFL): Focusing on hard-to-classify examples with a γ parameter

Datasets

Six dataset configurations were tested:

• Trailer dataset: Trailer images only
• Sticker dataset: Sticker/barcode images only
• Combined dataset: Both merged
• Combined (no trailer subclasses): Removed Trailer_2, Trailer_3, Trailer_4
• Combined (no stickers): Removed sticker images
• Trailer (Trailer_1 + stickers only): Simplified classes

NVIDIA Jetson Platform

Hardware Journey

The project went through several hardware iterations:

1. Jetson Nano 2GB: Hit End-of-Life status, boot failures after dependency installation, abandoned
2. Jetson AGX Orin: Initial development platform, pre-installed OS
3. Jetson Orin Nano 8GB: Final deployment target, reflashed with JetPack 6.x

Model Deployment Pipeline

PyTorch (.pth) → ONNX (.onnx) → TensorRT (.trt)

The conversion pipeline enables significant inference speedups on NVIDIA GPUs:

1. PyTorch → ONNX: Export with torch.onnx.export(), opset version 11
2. ONNX → TensorRT: Parse and build optimized CUDA engine
3. Inference: Real-time camera feed processing with PyCUDA memory management

Results

The YOLOv8 medium model trained on the combined dataset without sticker images achieved the best overall performance with 98.9% precision and 97.1% mAP50.

Key Challenges & Learnings

• Tensor shape alignment in custom YOLOv8, getting all model components to produce compatible tensor dimensions was the most difficult technical challenge
• Loss function implementation: transitioning from MSE/BCE to CIoU + DFL required careful mathematical implementation
• Jetson platform setup: multiple hardware iterations, boot failures, dependency conflicts, and JetPack version incompatibilities
• Custom vs. library trade-off: the from-scratch YOLOv8 implementation provided deep architectural understanding but the Ultralytics library delivered production-ready results

Context

This project was developed as a Bachelor's thesis at the University of Applied Sciences Osnabrück (Campus Lingen), Institute for Management and Technology, in collaboration with Krone Business Center GmbH as part of the TIDA5G research initiative for automated yard inventory management.