1 Introduction↩︎

The ability to accurately and rapidly perceive the 3D environment is a fundamental requirement for autonomous vehicles and intelligent robotic systems. Among various sensor modalities, Light Detection and Ranging (LiDAR) has become indispensable due to its capability to provide precise depth information and its robustness to varying lighting conditions. However, the unstructured, sparse, and unordered nature of LiDAR point clouds poses significant challenges for deep learning architectures, particularly when real-time inference is demanded.

Early approaches to 3D object detection, such as PointNet [1] and PointNet++ [2], process raw point clouds directly but suffer from high computational costs when applied to large-scale scenes. To improve efficiency, voxel-based methods like VoxelNet [3] and SECOND [4] divide the 3D space into volumetric grids and apply 3D sparse convolutions. While these methods achieve high accuracy, the 3D convolutional operations remain computationally expensive, limiting their deployment on resource-constrained embedded systems.

To address the latency bottleneck, PointPillars [5] introduced a paradigm shift by organizing point clouds into vertical columns (pillars) rather than 3D voxels. This allows the network to collapse the height dimension and project the features into a 2D bird’s-eye view (BEV) pseudo-image. Consequently, standard 2D Convolutional Neural Networks (CNNs) can be utilized, leading to dramatic improvements in inference speed. Despite its efficiency, the original PointPillars architecture relies on an older CNN backbone and a conventional anchor-based Single Shot Detector (SSD) head, which limits its ability to capture complex global context and handle dense object scenarios effectively.

Recent advancements in 2D object detection have been driven by two major innovations: the evolution of the You Only Look Once (YOLO) family and the emergence of Detection Transformers (DETR). The YOLOv8 architecture [6] introduced the C2f (Cross Stage Partial Bottleneck with 2 convolutions) module, which significantly enhances gradient flow and feature representation compared to previous iterations. Concurrently, the DETR framework [7] revolutionized object detection by treating it as a direct set prediction problem, eliminating the need for hand-crafted components like anchor generation and non-maximum suppression (NMS). Building upon this, RT-DETR [8] successfully adapted the transformer paradigm for real-time applications by optimizing the encoder-decoder structure.

Motivated by these breakthroughs in 2D vision, we propose PillarDETR, a novel architecture that bridges the gap between efficient LiDAR encoding and state-of-the-art 2D detection mechanisms. PillarDETR leverages the fast pillarization process to generate BEV pseudo-images, but fundamentally redesigns the downstream network. We replace the standard backbone with a YOLOv8-inspired CSP architecture to extract richer multi-scale features. More importantly, we introduce an RT-DETR-based transformer head adapted for 3D bounding box regression. This allows the model to leverage self-attention mechanisms to understand the global spatial relationships between objects in the BEV space, leading to more accurate predictions without the heuristic tuning required by anchor-based methods.

The main contributions of this paper are summarized as follows:

• We introduce PillarDETR, a novel real-time 3D object detection framework that integrates pillar-based LiDAR encoding with modern 2D detection architectures.

• We propose a hybrid network design that utilizes a YOLOv8-based CSP backbone for robust feature extraction from BEV pseudo-images.

• We adapt the RT-DETR transformer decoder for 3D object detection, enabling anchor-free, NMS-free, and context-aware bounding box prediction in the BEV space.

• We provide comprehensive experimental results and ablation studies on the KITTI and nuScenes datasets, demonstrating the effectiveness and efficiency of the proposed architecture compared to strong baselines.

The remainder of this paper is organized as follows. Section 2 reviews related work in 3D object detection and vision transformers. Section 3 details the architecture of PillarDETR. Section 4 describes the experimental setup, and Section 5 presents the results and analysis. Finally, Section 6 concludes the paper.

2 Related Work↩︎

2.1 LiDAR-Based 3D Object Detection↩︎

LiDAR-based 3D object detection methods can be broadly categorized based on their point cloud representation: point-based, voxel-based, and pillar-based methods.

Point-based methods directly process raw point clouds. PointNet [1] pioneered this approach by using symmetric functions to aggregate features from unordered points. PointRCNN [9] utilizes PointNet++ [2] for bottom-up 3D proposal generation. While these methods preserve precise spatial information, their reliance on neighborhood sampling (e.g., ball query) makes them computationally intensive for large-scale outdoor scenes.

Voxel-based methods discretize the point cloud into a 3D grid. VoxelNet [3] introduced the Voxel Feature Encoding (VFE) layer to extract features within each voxel, followed by 3D convolutions. SECOND [4] significantly improved the efficiency of this approach by introducing sparse 3D convolutions, which only operate on non-empty voxels. While highly accurate, the 3D convolutions still pose a bottleneck for real-time performance.

Pillar-based methods aim to maximize efficiency by avoiding 3D convolutions entirely. PointPillars [5] organizes points into vertical pillars and uses a simplified PointNet to generate a 2D BEV pseudo-image. This allows the use of highly optimized 2D CNNs for the remaining pipeline. Our work, PillarDETR, builds upon the PointPillars paradigm but modernizes the 2D backbone and detection head to achieve higher accuracy without sacrificing the inherent speed advantages of pillarization.

2.2 Advances in 2D Object Detection↩︎

The field of 2D object detection has witnessed rapid progress, heavily influencing 3D detection architectures. The YOLO series has long dominated real-time detection. Recent iterations, such as YOLOv8 [6], have introduced anchor-free decoupled heads and the C2f module in the backbone, which optimizes gradient flow and feature aggregation. Several works have attempted to adapt YOLO for 3D tasks. For instance, Complex-YOLO [10] projected point clouds to BEV and applied YOLOv2, while recent studies have explored YOLOv8 backbones for LiDAR data [11].

Simultaneously, the DETR (DEtection TRansformer) [7] framework shifted the paradigm by treating detection as a set prediction problem using bipartite matching, eliminating NMS. However, the original DETR suffered from slow convergence and high computational complexity. Deformable DETR [12] addressed this by using sparse attention. More recently, RT-DETR [8] achieved real-time performance by designing an efficient hybrid encoder and a streamlined decoder. Our PillarDETR architecture is the first to systematically integrate the RT-DETR decoder with a YOLOv8 backbone specifically for LiDAR-based 3D detection in the BEV space.

2.3 Transformers in 3D Perception↩︎

Transformers have increasingly been adopted for 3D perception tasks. CenterPoint [13] popularized center-based detection, which simplifies tracking and orientation estimation. Building on this, several works have integrated attention mechanisms. TransFusion [14] proposed a robust LiDAR-camera fusion model using a transformer decoder, where LiDAR features act as queries to interact with image features. BEVFusion [15] unified multi-modal features in a shared BEV space, demonstrating the power of BEV representations for task-agnostic learning. While these methods achieve state-of-the-art performance, they often require heavy computational resources. PillarDETR focuses on a lightweight, LiDAR-only architecture that leverages the RT-DETR transformer head for efficient global reasoning in the BEV domain.

3 Methodology↩︎

The PillarDETR architecture is designed to efficiently process 3D LiDAR point clouds and output accurate 3D bounding boxes. The pipeline consists of three main components: (1) a Pillar Feature Net (PFN) that converts the raw point cloud into a 2D pseudo-image; (2) a YOLOv8-based CSP backbone that extracts multi-scale features from the pseudo-image; and (3) an RT-DETR-based transformer decoder that predicts the final 3D bounding boxes. The overall architecture is illustrated in Fig. 1.

3.1 Architecture Overview↩︎

3.2 Pillar Feature Net (PFN)↩︎

The first stage of our pipeline follows the pillarization process introduced in [5]. Given a 3D point cloud, we discretize the space in the \(x\)-\(y\) plane into a grid of evenly spaced pillars, ignoring the \(z\) (height) dimension. Each point \(p\) in a pillar is augmented with additional features, resulting in a 9-dimensional vector: \[D = [x, y, z, r, x_c, y_c, z_c, x_p, y_p]\] where \(x, y, z\) are the spatial coordinates, \(r\) is the reflectance (intensity), \(x_c, y_c, z_c\) are the distances to the arithmetic mean of all points in the pillar, and \(x_p, y_p\) are the offsets from the pillar’s center.

Since pillars contain a variable number of points, we sample or pad each pillar to contain exactly \(N\) points. A simplified PointNet [1] consisting of a linear layer followed by Batch Normalization and ReLU is applied to each point. A max-pooling operation over the \(N\) points yields a single feature vector of dimension \(C\) for each pillar. Finally, these pillar features are scattered back to their original grid locations, forming a 2D pseudo-image of size \(C \times H \times W\), where \(H\) and \(W\) represent the grid height and width.

Table 1 summarizes the key hyperparameters for the PFN module used in our experiments on the KITTI dataset.

3.3 YOLOv8-Based CSP Backbone↩︎

The original PointPillars architecture utilizes a standard CNN backbone with multiple downsampling blocks followed by transposed convolutions for upsampling. To enhance feature representation and gradient flow, PillarDETR replaces this with a modern backbone inspired by YOLOv8 [6].

The core of our backbone is the Cross Stage Partial Bottleneck with 2 convolutions (C2f) module. The C2f module improves upon previous CSP designs by splitting the base feature map into two parts, processing one part through a series of bottlenecks, and concatenating the results. This allows the network to learn richer gradient combinations while maintaining computational efficiency. The output of a C2f module can be formulated as: \[y = \text{Concat}(x_1, \mathcal{B}_1(x_2), \mathcal{B}_2(\mathcal{B}_1(x_2)), \dots)\] where \(x_1\) and \(x_2\) are the split feature maps, and \(\mathcal{B}_i\) represents the \(i\)-th bottleneck block.

The pseudo-image is processed through a series of convolutional layers and C2f blocks, progressively downsampling the spatial resolution while increasing the channel dimension. Table 2 details the layer configuration of our YOLOv8m-based backbone.

The multi-scale feature maps from layers 4, 6, and 9 are then fused using a Path Aggregation Network (PANet) [16] style neck, ensuring that semantic information from deeper layers is effectively combined with spatial information from shallower layers.

3.4 RT-DETR Transformer Head↩︎

The most significant departure from traditional 3D detectors is our RT-DETR-based prediction head. Instead of relying on predefined anchors or center heatmaps, we formulate 3D object detection as a direct set prediction problem.

We adapt the efficient transformer decoder from RT-DETR [8] to operate on the BEV feature maps. The decoder takes a fixed number of learned object queries \(Q \in \mathbb{R}^{N_q \times d}\) and interacts with the multi-scale BEV features \(F\) through cross-attention mechanisms. The attention formulation is given by: \[\text{Attention}(Q, K, V) = \text{Softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V\] where \(Q\) represents the object queries, and \(K, V\) are derived from the BEV features \(F\).

Our decoder consists of \(L=6\) transformer layers. Each layer includes self-attention among queries, cross-attention between queries and BEV features, and a feed-forward network. We initialize \(N_q = 300\) queries. To provide spatial awareness, we add 2D sinusoidal positional encodings to the BEV features.

For 3D detection, the prediction feed-forward networks (FFNs) attached to the decoder are modified to output 3D bounding box parameters. Each query predicts a class probability \(\hat{p}\) and a bounding box vector: \[\hat{b} = [x, y, z, w, l, h, \theta, v_x, v_y]\] representing the 3D center coordinates, dimensions, heading angle, and velocity (if applicable, e.g., in nuScenes).

3.5 Loss Function↩︎

Following the DETR paradigm, we use bipartite matching to find the optimal assignment between the predicted set of boxes \(\hat{\mathcal{Y}} = \{(\hat{p}_i, \hat{b}_i)\}_{i=1}^{N_q}\) and the ground truth objects \(\mathcal{Y} = \{(p_j, b_j)\}_{j=1}^{M}\). The matching cost \(\mathcal{C}_{match}\) is computed using the Hungarian algorithm: \[\mathcal{C}_{match} = \lambda_{cls} \mathcal{L}_{cls}(\hat{p}_i, p_j) + \lambda_{reg} \mathcal{L}_{reg}(\hat{b}_i, b_j)\]

For classification, we employ Focal Loss [17] to handle the severe class imbalance typical in autonomous driving datasets: \[\mathcal{L}_{cls} = -\alpha (1 - \hat{p}_i)^\gamma \log(\hat{p}_i)\]

For bounding box regression, we use an L1 loss for the center coordinates and dimensions, and a specialized sine-cosine loss for the heading angle \(\theta\) to resolve angular periodicity issues: \[\mathcal{L}_{reg} = \|\hat{b}_i^{(xyz, wlh)} - b_j^{(xyz, wlh)}\|_1 + \mathcal{L}_{ang}(\hat{\theta}_i, \theta_j)\] \[\mathcal{L}_{ang} = \sin(\hat{\theta}_i - \theta_j)^2\]

The total loss is the sum of the matching costs for the optimal assignment, scaled by hyper-parameters \(\lambda_{cls} = 2.0\), \(\lambda_{reg} = 5.0\), and \(\lambda_{ang} = 2.0\).

4 Experimental Setup↩︎

4.1 Datasets↩︎

We evaluate PillarDETR on two widely used autonomous driving benchmarks: KITTI [18] and nuScenes [19].

KITTI Dataset: The KITTI 3D object detection dataset contains 7,481 training samples and 7,518 testing samples. Following the standard protocol, we split the training data into a training set (3,712 samples) and a validation set (3,769 samples). The dataset evaluates three categories: Car, Pedestrian, and Cyclist. Results are reported based on three difficulty levels: Easy, Moderate, and Hard.

nuScenes Dataset: The nuScenes dataset is a large-scale autonomous driving dataset featuring 1000 scenes, each 20 seconds long. It provides annotations for 10 object classes with a full 360-degree field of view. The dataset contains 28,130 training samples and 6,019 validation samples. Unlike KITTI, nuScenes evaluates velocity and attribute estimation in addition to 3D bounding box detection.

Waymo Open Dataset: The Waymo Open Dataset (WOD) [20] is one of the most comprehensive autonomous driving benchmarks, comprising 798 training sequences and 202 validation sequences. Evaluation is based on mean Average Precision (mAP) and mAP weighted by heading accuracy (mAPH), categorized into LEVEL_1 (L1, \(>5\) LiDAR points) and LEVEL_2 (L2, \(1 \sim 5\) LiDAR points).

SUN RGB-D Dataset: To evaluate the generalizability of PillarDETR to indoor environments, we use the SUN RGB-D dataset [21], which contains 10,335 single-view RGB-D images annotated with 3D bounding boxes for 37 object categories. We follow the standard protocol, evaluating on the 10 most common categories using mAP at IoU thresholds of 0.25 and 0.5.

4.2 Evaluation Metrics↩︎

For the KITTI dataset, the primary evaluation metric is the mean Average Precision (mAP) calculated using 40 recall positions. We use an Intersection over Union (IoU) threshold of 0.7 for Cars and 0.5 for Pedestrians and Cyclists.

For the nuScenes dataset, we use the official evaluation metrics: mean Average Precision (mAP) and the nuScenes Detection Score (NDS). The NDS is a weighted sum of mAP and several True Positive (TP) metrics, including translation, scale, orientation, velocity, and attribute errors.

To assess real-time capabilities, we report the inference latency (measured in milliseconds) and Frames Per Second (FPS) on a single NVIDIA A100 GPU. We also report the number of model parameters and GPU memory consumption.

4.3 Implementation Details↩︎

PillarDETR is implemented using the OpenPCDet framework [22] and PyTorch.

Network Architecture: The Pillar Feature Net uses a pillar size of \(0.16m \times 0.16m\) for KITTI and \(0.2m \times 0.2m\) for nuScenes. The YOLOv8-based CSP backbone employs three C2f modules, outputting feature maps at downsampling strides of 2, 4, and 8 relative to the pseudo-image. The RT-DETR head uses 300 object queries and 6 transformer decoder layers.

Training Strategy: The model is trained from scratch using the AdamW optimizer with a weight decay of 0.01. We employ a one-cycle learning rate schedule with a maximum learning rate of \(3 \times 10^{-3}\). For KITTI, the model is trained for 80 epochs with a batch size of 16 across 4 GPUs. For nuScenes, the model is trained for 20 epochs with a batch size of 32.

Data Augmentation: We apply standard 3D data augmentation techniques, including random flipping along the x-axis, global scaling (with scale factors drawn from \([0.95, 1.05]\)), and global rotation (with angles drawn from \([-\pi/4, \pi/4]\)). We also utilize the GT-AUG [4] strategy, which pastes ground truth objects from other scenes into the current point cloud to increase object density during training.

5 Results and Discussion↩︎

In this section, we present the quantitative results of our experiments on the KITTI validation set.

5.1 Main Results on KITTI↩︎

Table 3 presents the performance of PillarDETR compared to the PointPillars baseline and other state-of-the-art methods on the KITTI validation set.

As shown in Table 3, PillarDETR significantly outperforms the PointPillars baseline across all classes and difficulty levels on KITTI. The most notable improvement is observed in the Pedestrian class (+4.46% in moderate difficulty), which demonstrates the RT-DETR head’s superior ability to handle small, occluded, and dense objects without relying on hand-crafted anchor boxes. The overall moderate mAP improves from 62.78% to 66.57%, a substantial gain of 3.79%.

5.2 Performance on Large-Scale and Indoor Datasets↩︎

To validate scalability, we evaluate PillarDETR on the large-scale nuScenes and Waymo Open Datasets. As shown in Table 4, PillarDETR achieves 46.8% mAP and 56.2% NDS on nuScenes, significantly outperforming the standard PointPillars (30.5% mAP) and remaining highly competitive with CenterPoint (43.1% mAP). On the Waymo dataset (Table 5), PillarDETR demonstrates robust performance across both L1 and L2 difficulty levels, achieving 64.5% mAPH for L1 vehicles, demonstrating the efficacy of the YOLOv8 CSP backbone in extracting rich features from high-density LiDAR sweeps.

To assess the architecture’s versatility beyond autonomous driving, we evaluated PillarDETR on the indoor SUN RGB-D benchmark (Table 6). Despite being primarily designed for BEV LiDAR data, adapting the pillarization for indoor point clouds allowed PillarDETR to achieve 64.8% mAP@0.25, surpassing classical indoor detectors like VoteNet (57.7%) and remaining competitive with state-of-the-art indoor transformer models.

5.3 Ablation Studies↩︎

To validate the effectiveness of the proposed components, we conduct an ablation study by systematically adding the YOLOv8 backbone and RT-DETR head to the PointPillars baseline.

Table 7 confirms that both components contribute to the final performance. The YOLOv8m CSP backbone alone provides a +2.52% mAP boost by extracting richer multi-scale features. The RT-DETR head alone yields a +2.05% mAP improvement by eliminating NMS and leveraging global attention. Combining both yields the best result, showing that the high-quality features from the YOLOv8 backbone are effectively utilized by the transformer decoder.

5.4 Inference Speed and Efficiency↩︎

A critical requirement for autonomous driving is real-time performance. Table 8 compares the inference speed (FPS) and parameter count of our proposed model against the baseline.

While the addition of the YOLOv8m backbone and RT-DETR head increases the parameter count from 4.8M to 12.4M, the model still achieves an inference speed of 41.2 FPS (24.3 ms latency) on an NVIDIA A100 GPU. Since typical LiDAR sensors operate at 10-20 Hz, PillarDETR comfortably satisfies the real-time requirements for autonomous driving while delivering significantly higher accuracy.

6 Conclusion↩︎

In this paper, we presented PillarDETR, a novel end-to-end 3D object detection architecture that modernizes the pillar-based paradigm. By replacing the traditional CNN backbone with a YOLOv8-inspired CSP network and substituting the anchor-based head with an RT-DETR transformer decoder, PillarDETR achieves a highly effective balance between detection accuracy and inference speed. The hybrid design enables the network to extract richer multi-scale features and leverage global context for accurate, NMS-free bounding box prediction. [Concluding remarks on performance improvements will be added based on final results.]

References↩︎