Parallel Neural Computing for Scene Understanding from LiDAR Perception in Autonomous Racing

Suwesh Prasad Sah

REVIEW 3 major objections 4 minor 23 references

Parallel Neural Computing for Scene Understanding from LiDAR Perception in Autonomous Racing

T0 review · 3 major / 4 minor · reviewed 2026-08-11 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read Two independent LiDAR networks running in parallel on separate GPUs cut perception latency in half for autonomous racing.

desk verdict The perception evaluation is circular because the reconstruction network's ground truth is the output of an untrained segmentation network, leaving only an expected 2x multi-GPU speedup that lacks measurement detail. read the letter →

arxiv 2412.18165 v1 pith:EIEFOSSS submitted 2024-12-24 cs.CV

Suwesh Prasad Sah This is my paper · ORCID

classification cs.CV

keywords autonomousracingLiDARperceptionbird'seyeviewparallelneuralnetworksencoder-decoderGPUaccelerationsceneunderstandingpointcloud

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper proposes a baseline architecture for hardware-enabled parallel neural computing in autonomous racing, where LiDAR perception must keep up with vehicles moving at up to 274 km/h. The Parallel Perception Network (PPN) splits scene understanding into two independent encoder-decoder networks—segmentation and reconstruction—that run concurrently on separate GPUs, converting raw 3D point clouds into 2D bird's-eye-view maps before inference. The authors report a 2x speedup in inference time (0.075–0.091 s vs 0.162–0.205 s) when the two networks run in parallel on two NVIDIA T4 GPUs compared with running them sequentially on one GPU. If the speedup holds, it shows that multi-task perception can be made faster without redesigning the networks, simply by exploiting available parallel hardware.

What carries the argument

The central object is the Parallel Perception Network (PPN), a pair of encoder-decoder CNNs: a segmentation network with skip connections and a reconstruction network without them. Both take a stack of 16 consecutive binary bird's-eye-view maps generated from LiDAR point clouds by voxelization and max-pooling along the z-axis. The temporal dimension is processed by a pseudo-1D convolution with kernel size $T \times 1 \times 1$ on the input, and each network runs on its own NVIDIA T4 GPU; because the networks are independent and never share activations during inference, running them on separate devices halves the latency of the combined perception step. The reconstruction network is trained with a combined Mean Square Smooth Canny Edge (MSSCE) loss that blends MSE, SmoothL1, and an edge-preserving term based on Canny edge detection.

What would settle it

Run the same two networks with identical batch sizes and input sizes on one NVIDIA T4 GPU in sequence and on two T4 GPUs in parallel, measuring wall-clock latency over many trials; if the parallel configuration does not show roughly a 2x speedup, the central performance claim is refuted.

Watch

Extended reading notes

Core claim

The central discovery is that two independent convolutional networks—one with skip connections for segmentation, one without for reconstruction—can be trained and deployed in parallel on separate GPUs, yielding a roughly two-fold reduction in wall-clock inference time (0.075–0.091 s versus 0.162–0.205 s) with no change to the per-network architecture. The segmentation network produces space-time segmentations of a sequence of LiDAR-derived BEV maps without any training on labeled data; its output is then used as ground truth to train the reconstruction network, which lacks skip connections and must learn to reproduce the input scenes. The authors present this 'true hardware-enabled parallelism' as a scalable baseline for multi-network, multi-sensor perception in high-speed autonomous driving.

Load-bearing premise

The load-bearing premise is that the untrained segmentation network's output is a valid ground truth for training and evaluating the reconstruction network; if that output does not reflect the actual scene structure, the reported reconstruction accuracies do not measure real-world performance.

Editorial extensions

If this is right

Multi-network perception models can be accelerated by assigning each independent network to a separate GPU, without altering the network designs.
A LiDAR perception pipeline that previously ran at roughly 5–6 Hz on one GPU could run at roughly 11–13 Hz in the parallel configuration, closer to the sensor's 10–30 Hz frame rate.
The architecture can be extended to additional independent networks (e.g., one per sensor modality) and still maintain per-network inference latency, provided each has dedicated hardware.
The untrained segmentation network's output can serve as training targets for a sibling reconstruction network, removing the need for hand-labeled annotations in the RACECAR dataset.
Using the edge-preserving MSSCE loss produces sharper reconstructions than IoU loss, though with a lower IoU score (61% vs 99%).

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

A natural extension is to benchmark the same two networks on a single GPU as one multi-task network with a shared encoder; a speedup that is purely proportional to added hardware says little about model efficiency, only about resource allocation.
Because the reconstruction network is trained against the untrained segmentation outputs, the reported 99% and 61% accuracies should be read as measures of self-consistency between the two networks, not as agreement with human-annotated scene labels; a labeled evaluation set would be needed to establish external validity.
The parallel scheme could be tested for synchronization overhead at higher input frame rates or with networks that must exchange intermediate features, where the clean 2x speedup would likely degrade.
If the same parallel design is applied to camera and LiDAR networks, the speedup may differ because of varying input sizes and preprocessing costs; measuring this would reveal whether the 2x result generalizes beyond the specific setting.

Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

Colleague, here's my read on arXiv:2412.18165.

The paper's only concrete result is that running two independent networks on two GPUs halves inference time compared to running them sequentially on one GPU. That is true but trivially expected; it is not a contribution. The scene-understanding claims do not hold up. The authors train the reconstruction network to reproduce the segmentation network's output, and the segmentation network is never trained; it has random weights and skip connections. Section IV-B states this explicitly. So Table I's 99% and 61% accuracies measure agreement with a pseudo-label, not any external truth. The segmentation network's 98.2% figure is also undefined: it comes from a separately trained future-prediction head, not from the untrained segmentation, and no metric or data split is given.

What is genuinely good: the paper is clear about what it does, and it releases code and pretrained weights. The MSSCE loss is a sensible combination of existing losses, though not novel. The authors also acknowledge the hardware cost of parallelism in Table III. But none of that rescues the central evaluation.

The timing measurement in Table II lacks run counts, variance, warm-up, and any statistical treatment. Given the expected result, this is a minor issue compared to the circularity.

Whom is this for? A reader who wants a minimal example of multi-GPU inference with BEV maps might find the code useful. As a scientific claim about scene understanding, it should not be taken seriously. The paper would not pass peer review in its current form; the evaluation design would need external ground truth (e.g., hand-labeled segmentation or a real reconstruction error against LiDAR occupancy). I would not cite it. I would not bring it to reading group. A desk reject is appropriate.

Referee Report

3 major / 4 minor

Summary. The paper proposes a Parallel Perception Network (PPN) for autonomous racing, consisting of two independent encoder-decoder convolutional networks — a 'segmentation' network with skip connections and a 'reconstruction' network without them — that run concurrently on two separate NVIDIA T4 GPUs. The input is a sequence of 2D Bird's Eye View (BEV) maps converted from LiDAR point clouds. The authors claim a 2x inference-time speedup relative to a sequential configuration, and report reconstruction accuracies of 99% and 61% under IoU and MSSCE losses, respectively, plus a 98.2% accuracy for the segmentation network. The paper also introduces the MSSCE loss, which combines MSE, SmoothL1, and Canny-edge-preserving terms. Training and evaluation are carried out on a single RACECAR scenario (PoliMove Multi-Agent Slow on LVMS), with 7,150 LiDAR sweeps.

Significance. If the system-level result held, the paper would offer a simple, reproducible demonstration that two independent perception networks can be placed on separate GPUs to reduce inference latency — a modest but useful contribution for latency-sensitive autonomous racing. The authors also make code and learned parameters publicly available, which is commendable and improves reproducibility of the systems part. However, the scene-understanding claims are not supported by the evaluation: the reconstruction network is trained and tested against the output of an untrained, randomly initialized segmentation network, making the reported accuracies measures of agreement with a pseudo-label rather than with any ground-truth scene structure. The segmentation network's own accuracy is undefined (no metric, split, or repetitions), and the only quantitative evidence that survives this criticism is the latency comparison, which is itself underreported and partially inconsistent with the 'at least two times' claim in Section IV-D. The paper's central title claim about scene understanding therefore rests on a circular benchmark.

major comments (3)

[Section IV-B and Table I] The evaluation of the reconstruction network is circular. Section IV-B states: 'Due to the lack of hand-labelled annotations in the RACECAR dataset, we employ the segmentation network's output as ground truths for the corresponding input sequence to train the reconstruction network.' However, the segmentation network is never trained for segmentation; Sections III and IV-C explicitly state that it segments 'without any training required.' A randomly initialized encoder-decoder with skip connections produces an arbitrary function of the input and random weights, not a meaningful scene representation. Therefore, Table I's 99% and 61% reconstruction accuracies merely quantify how well the reconstruction network reproduces this pseudo-target, and the qualitative comparison between IoU and MSSCE losses (Fig. 7) cannot support any claim about scene reconstruction or scene understanding. Since the input BEV maps themselves could have served as ground truth for the autoencoder-style reconstruction task, this is not a fundamental data-annotation limitation but a methodological choice that invalidates the reported perception metrics.
[Section IV-C and Table I] The segmentation network's reported accuracy of 98.2% is undefined and unsupported. No metric (e.g., IoU, pixel accuracy) is specified, no data split or number of repetitions is reported, and no comparison against manually annotated or otherwise validated ground truth is provided. Furthermore, the benchmark described in Section IV-B — training a modified version of the segmentation network to predict future BEV maps — is a different task from segmenting the current scene; the 98.2% figure cannot be the accuracy of the untrained segmentation network on that task, because Table I's row for 'Segmentation Net' is listed after training. The text also does not explain how the untrained network could yield any quantitative accuracy without a defined target. This row of Table I should be removed or replaced with a clearly specified evaluation protocol.
[Table II and Section IV-D] The latency measurement is underreported and the 'at least two times' speedup claim is contradicted by the table's own numbers. Section IV-D says the parallel configuration 'reveal[s] a speedup of at least two times,' but Table II lists sequential min/max of 0.162/0.205 seconds and parallel min/max of 0.075/0.091 seconds. The worst-case speedup is 0.162/0.091 ≈ 1.78×, which is below 2×. Additionally, the measurement protocol is not described: no number of runs, no variance, no warm-up, no explanation of whether BEV conversion and data transfer are included, and no specification of whether the sequential configuration ran both networks on one GPU or on two GPUs time-shared. Without this information, the 2× claim is plausible but not established. The paper should report mean, standard deviation, and the exact measurement methodology, and the 'at least' qualification should be corrected.

minor comments (4)

[Throughout] There are several typographical errors, including 'infernece' in the Table II caption, 'comparision' in the Section IV-E heading, and 'seperate' in Table II. These should be corrected.
[Figure 6] Figure 6 is described as showing 'PPN model's input and outputs without training,' but the caption does not state which panels correspond to which network or how the blank reconstruction output is produced. Please clarify the figure legend and refer to it explicitly in the text.
[Section IV-A] The BEV conversion parameters are incompletely specified: the paper mentions a 1000×1000 grid and a voxel 'resolution/voxel size' in Algorithm 1 but does not give the numerical voxel size or the LiDAR range used for cropping. Please provide these values for reproducibility.
[Equation (5)] The definition of MSSCE as simply the sum LMSE+Canny + LSmoothL1+Canny means each pixel is counted twice, and it is unclear whether the authors intended a weighted average. If the two terms are equally weighted, this should be stated explicitly; if not, the formula is ambiguous.

Circularity Check

1 steps flagged · score 6.0 of 10

Scene-understanding evaluation is circular: the reconstruction network's ground truth is the untrained segmentation network's own output, so the reported reconstruction accuracies reduce to self-generated pseudo-labels; only the measured 2x parallel speedup is independent.

self definitional [Section IV-B (Training Details); Table I]
"Due to the lack of hand-labelled annotations in the RACECAR dataset, we employ the segmentation network's output as ground truths for the corresponding input sequence to train the reconstruction network to demonstrate said parallel neural computing baseline."

Section III and Section IV-C state that the segmentation network produces segmentations 'without any training required,' so its output is a fixed, unvalidated function of the input LiDAR sequence through random weights and skip connections. The reconstruction network is trained with LMSSCE to match this pseudo-ground truth, and Table I reports reconstruction accuracy (99% with IoU loss, 61% with MSSCE) against that same pseudo-ground truth. Consequently, those numbers measure only how well the reconstruction network reproduces the segmentation network's output; they do not measure reconstruction of the physical scene. The target variable is defined by the model itself, so the scene-understanding and reconstruction-accuracy claims reduce to self-generated labels by construction.

full rationale

The load-bearing perception claims rest on Section IV-B, where the reconstruction network is trained and scored against the output of the segmentation network, which Sections III and IV-C describe as requiring no training. Because that segmentation output is an unvalidated deterministic function of the same LiDAR input, the reported reconstruction accuracies and the qualitative 'sharper reconstruction' comparison only quantify agreement with the model's own pseudo-labels, not with any externally meaningful scene state. This is a genuine self-definitional circularity for the scene-understanding portion of the paper. The 2x inference speedup in Table II is a measured systems result and is not circular. There are no load-bearing self-citations or imported uniqueness theorems; the circularity is the pseudo-label ground truth, not citation practice. A score of 6 reflects that one central class of predictions reduces by construction, while the independent hardware-parallelism speedup remains standing.

Assumptions & free parameters 5 free parameters · 4 assumptions · 0 invented entities

The ledger counts the hand-chosen hyperparameters (λ, β, T, 700 iterations) and the domain assumptions about BEV representation and the RACECAR data. The most consequential item is the ad hoc use of the untrained segmentation network's output as ground truth, which drives the circular training loop. No new physical entities are introduced.

free parameters (5)

lambda (λ) = 0.85
Weights the pixel-wise losses against the edge-preserving term in equations (3) and (4); chosen by hand, no sensitivity analysis.
beta (β) = 1
Transition point for SmoothL1 loss in equation (1); set without justification.
input time window T = 16 (current + 15 past scans)
Chosen from LiDAR frame rate and vehicle speed, but no ablation or comparison.
training iterations = 700
Termination point for training; no convergence criterion or validation-based early stopping reported.
BEV resolution/voxel size = unspecified
Algorithm 1 requires resolution, height, width, depth size, but numeric values are not given, making the conversion non-reproducible from the text.

assumptions (4)

domain assumption 2D convolutions on stacked BEV maps capture space-time relationships
Assumed in Section III when applying 2D convolutions along the time-stacked input channels; no experimental validation.
domain assumption Binary BEV maps preserve sufficient information for scene understanding
The projection and binarization in Algorithm 1 discard intensity and z-continuity information, yet the paper uses them as the sole input representation.
ad hoc to paper The untrained segmentation network's output is a valid target for the reconstruction network
Section IV-B uses this output as ground truth, which creates the circular evaluation loop.
domain assumption RACECAR's pre-aligned LiDAR sweeps are directly stackable without ego-motion compensation
The methodology stacks scans along time without aligning them to a common coordinate frame, assuming pre-alignment is sufficient.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Parallel Neural Computing for Scene Understanding from LiDAR Perception in Autonomous Racing." pith.science (2026). https://pith.science/paper/EIEFOSSS

@misc{pith2026241218165,
  author       = {Pith},
  title        = {Pith review of: Parallel Neural Computing for Scene Understanding from LiDAR Perception in Autonomous Racing},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/EIEFOSSS}},
  note         = {Machine review of arXiv:2412.18165}
}

read the original abstract

Autonomous driving in high-speed racing, as opposed to urban environments, presents significant challenges in scene understanding due to rapid changes in the track environment. Traditional sequential network approaches may struggle to meet the real-time knowledge and decision-making demands of an autonomous agent covering large displacements in a short time. This paper proposes a novel baseline architecture for developing sophisticated models capable of true hardware-enabled parallelism, achieving neural processing speeds that mirror the agent's high velocity. The proposed model (Parallel Perception Network (PPN)) consists of two independent neural networks, segmentation and reconstruction networks, running parallelly on separate accelerated hardware. The model takes raw 3D point cloud data from the LiDAR sensor as input and converts it into a 2D Bird's Eye View Map on both devices. Each network independently extracts its input features along space and time dimensions and produces outputs parallelly. The proposed method's model is trained on a system with two NVIDIA T4 GPUs, using a combination of loss functions, including edge preservation, and demonstrates a 2x speedup in model inference time compared to a sequential configuration. Implementation is available at: https://github.com/suwesh/Parallel-Perception-Network. Learned parameters of the trained networks are provided at: https://huggingface.co/suwesh/ParallelPerceptionNetwork.

Figures

Figures reproduced from arXiv: 2412.18165 by the authors.

**Figure 1.** Conversion of 3D point clouds into 2D BEV map. This process involves: (a) Point clouds in 3D space. (b) Voxelization, where the 3D space is divided into discrete voxels and each voxel holds the max z-axis value. (c) 2D BEV map obtained by projecting 3D voxels onto a 2D plane by taking the maximum along z-axis. coordinates and intensity values for each laser scan, covering a 360◦ field of view with a range of 120m as… view at source ↗

**Figure 2.** Overview of PPN. The segmentation network with skip connections is a spatio-temporal pyramid network, and the reconstruction network is an autoencoder. III. METHODOLOGY This section elaborates on system methodology, see [PITH_FULL_IMAGE:figures/full_fig_p002_2.png] view at source ↗

**Figure 3.** Architecture of Parallel Perception Network. The RACECAR dataset already has all LiDAR sweeps prealigned to the viewpoint of the ego vehicle. Now to learn the relationship across space and time, 2D convolutions can be applied to the BEV maps with the initial number of input channels corresponding to the number of input scans stacked along the time dimension. In Parallel Perception Network, input to each parallel ne… view at source ↗

Figures from the paper (3 more)

**Figure 4.** Figure 4: PPN model’s experimental setup on parallel accelerated hardware. This retains elevations at each pixel location in the 2D representation of 3D data. To capture the temporal dynamics of the environment we ingest a set of 15 consecutive past scans in addition to the curr…

**Figure 7.** Figure 7: Qualitative Results of trained PPN model. Top to bottom: Inputs and outputs at various time frames corresponding to t = 15, t = 4500 and t = 7100. Left to Right: (a) Current scans from input sequences at different time steps, (b) Segmentation Network outputs i.e. scene…

**Figure 6.** Figure 6: PPN model’s input and outputs without training. Left to Right: Current scan from Input Sequence, Segmentation network output, Reconstruction network output. C. Results and Analysis To show that our model’s segmentation network accurately segments the scene along space-…

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

23 extracted references · 18 canonical work pages

[1]

nuscenes: A multimodal dataset for autonomous driving

Holger Caesar, Varun Bankiti, Alex H Lang, Sourabh V ora, Venice Erin Liong, Qiang Xu, Anush Krishnan, Yu Pan, Giancarlo Baldan, and Oscar Beijbom. nuscenes: A multimodal dataset for autonomous driving. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition , pages 11621–11631, 2020

2020
[2]

Bevmap: Map-aware bev modeling for 3d perception

Mincheol Chang, Seokha Moon, Reza Mahjourian, and Jinkyu Kim. Bevmap: Map-aware bev modeling for 3d perception. In Proceedings of the IEEE/CVF Winter Conference on Applications of Computer Vision, pages 7419–7428, 2024

work page 2024
[3]

Lookout: Diverse multi-future prediction and planning for self-driving

Alexander Cui, Sergio Casas, Abbas Sadat, Renjie Liao, and Raquel Urtasun. Lookout: Diverse multi-future prediction and planning for self-driving. In Proceedings of the IEEE/CVF International Conference on Computer Vision , pages 16107–16116, 2021

2021
[4]

Gpu computing revolution: Cuda

Ramandeep Singh Dehal, Chirag Munjal, Arquish Ali Ansari, and Anup Singh Kushwaha. Gpu computing revolution: Cuda. In 2018 International Conference on Advances in Computing, Communication Control and Networking (ICACCCN) , pages 197–201. IEEE, 2018

work page 2018
[5]

Carla: An open urban driving simulator

Alexey Dosovitskiy, German Ros, Felipe Codevilla, Antonio Lopez, and Vladlen Koltun. Carla: An open urban driving simulator. In Conference on robot learning , pages 1–16. PMLR, 2017

work page 2017
[6]

Probabilistic future prediction for video scene understanding

Anthony Hu, Fergal Cotter, Nikhil Mohan, Corina Gurau, and Alex Kendall. Probabilistic future prediction for video scene understanding. In Computer Vision–ECCV 2020: 16th European Conference, Glasgow, UK, August 23–28, 2020, Proceedings, Part XVI 16 , pages 767–785. Springer, 2020

work page 2020
[7]

Expert human-level driving in gran turismo sport using deep reinforcement learning with image-based representation

Ryuji Imamura, Takuma Seno, Kenta Kawamoto, and Michael Spranger. Expert human-level driving in gran turismo sport using deep reinforcement learning with image-based representation. arXiv preprint arXiv:2111.06449, 2021

arXiv 2021
[8]

Stfp: Simultaneous traffic scene forecasting and planning for au- tonomous driving

Chan Kim, Hyung-Suk Yoon, Seung-Woo Seo, and Seong-Woo Kim. Stfp: Simultaneous traffic scene forecasting and planning for au- tonomous driving. In 2021 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS) , pages 6016–6022. IEEE, 2021

work page 2021

Show all 23 references

[9]

Racecar-the dataset for high-speed autonomous racing

Amar Kulkarni, John Chrosniak, Emory Ducote, Florian Sauerbeck, Andrew Saba, Utkarsh Chirimar, John Link, Madhur Behl, and Mar- cello Cellina. Racecar-the dataset for high-speed autonomous racing. In 2023 IEEE/RSJ International Conference on Intelligent Robots and Systems (IRO...

2023
[10]

Feature pyramid networks for object detection

Tsung-Yi Lin, Piotr Doll ´ar, Ross Girshick, Kaiming He, Bharath Hariharan, and Serge Belongie. Feature pyramid networks for object detection. In Proceedings of the IEEE conference on computer vision and pattern recognition , pages 2117–2125, 2017

2017
[11]

Learning to overtake in torcs using simple reinforcement learning

Daniele Loiacono, Alessandro Prete, Pier Luca Lanzi, and Luigi Cardamone. Learning to overtake in torcs using simple reinforcement learning. In IEEE Congress on Evolutionary Computation , pages 1–8. IEEE, 2010

2010
[12]

Predicting future instance segmentation by forecasting convolutional features

Pauline Luc, Camille Couprie, Yann Lecun, and Jakob Verbeek. Predicting future instance segmentation by forecasting convolutional features. In Proceedings of the European Conference on computer vision (ECCV) , pages 584–599, 2018

2018
[13]

Gpu accelerated computing–from hype to mainstream, the rebirth of vector computing

Satoshi Matsuoka, Takayuki Aoki, Toshio Endo, Akira Nukada, Toshi- hiro Kato, and Atushi Hasegawa. Gpu accelerated computing–from hype to mainstream, the rebirth of vector computing. In Journal of Physics: Conference Series, volume 180, page 012043. IOP Publishing, 2009

2009
[14]

Vision-based semantic segmentation in scene understanding for autonomous driving: Recent achievements, challenges, and outlooks

Khan Muhammad, Tanveer Hussain, Hayat Ullah, Javier Del Ser, Mahdi Rezaei, Neeraj Kumar, Mohammad Hijji, Paolo Bellavista, and Victor Hugo C de Albuquerque. Vision-based semantic segmentation in scene understanding for autonomous driving: Recent achievements, challenges, and o...

2022
[15]

Msce: An edge-preserving robust loss function for improving super-resolution algorithms

Ram Krishna Pandey, Nabagata Saha, Samarjit Karmakar, and AG Ra- makrishnan. Msce: An edge-preserving robust loss function for improving super-resolution algorithms. In Neural Information Pro- cessing: 25th International Conference, ICONIP 2018, Siem Reap, Cambodia, December 1...

2018
[16]

U-net: Con- volutional networks for biomedical image segmentation

Olaf Ronneberger, Philipp Fischer, and Thomas Brox. U-net: Con- volutional networks for biomedical image segmentation. In Medical image computing and computer-assisted intervention–MICCAI 2015: 18th international conference, Munich, Germany, October 5-9, 2015, proceedings, par...

2015
[17]

Airsim: High-fidelity visual and physical simulation for autonomous vehicles

Shital Shah, Debadeepta Dey, Chris Lovett, and Ashish Kapoor. Airsim: High-fidelity visual and physical simulation for autonomous vehicles. In Field and Service Robotics: Results of the 11th Interna- tional Conference, pages 621–635. Springer, 2018

2018
[18]

Predicting future instance segmentation with contextual pyramid convlstms

Jiangxin Sun, Jiafeng Xie, Jian-Fang Hu, Zihang Lin, Jianhuang Lai, Wenjun Zeng, and Wei-shi Zheng. Predicting future instance segmentation with contextual pyramid convlstms. In Proceedings of the 27th acm international conference on multimedia , pages 2043–2051, 2019

2019
[19]

Insmos: Instance-aware moving object segmen- tation in lidar data

Neng Wang, Chenghao Shi, Ruibin Guo, Huimin Lu, Zhiqiang Zheng, and Xieyuanli Chen. Insmos: Instance-aware moving object segmen- tation in lidar data. In 2023 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS) , pages 7598–7605. IEEE, 2023

2023
[20]

Deepracing: A framework for au- tonomous racing

Trent Weiss and Madhur Behl. Deepracing: A framework for au- tonomous racing. In 2020 Design, automation & test in Europe conference & Exhibition (DATE) , pages 1163–1168. IEEE, 2020

2020
[21]

Motionnet: Joint perception and motion prediction for autonomous driving based on bird’s eye view maps

Pengxiang Wu, Siheng Chen, and Dimitris N Metaxas. Motionnet: Joint perception and motion prediction for autonomous driving based on bird’s eye view maps. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition , pages 11385–11395, 2020

2020
[22]

Torcs, the open racing car simulator

Bernhard Wymann, Eric Espi ´e, Christophe Guionneau, Christos Dim- itrakakis, R ´emi Coulom, and Andrew Sumner. Torcs, the open racing car simulator. Software available at http://torcs. sourceforge. net , 4(6):2, 2000

2000
[23]

Scene understanding in deep learning-based end-to-end controllers for au- tonomous vehicles

Shun Yang, Wenshuo Wang, Chang Liu, and Weiwen Deng. Scene understanding in deep learning-based end-to-end controllers for au- tonomous vehicles. IEEE Transactions on Systems, Man, and Cyber- netics: Systems , 49(1):53–63, 2018

2018

Pith tools

Reviewed August 11, 2026 · model on record in the stance chip above.

[1] [1]

nuscenes: A multimodal dataset for autonomous driving

Holger Caesar, Varun Bankiti, Alex H Lang, Sourabh V ora, Venice Erin Liong, Qiang Xu, Anush Krishnan, Yu Pan, Giancarlo Baldan, and Oscar Beijbom. nuscenes: A multimodal dataset for autonomous driving. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition , pages 11621–11631, 2020

2020

[2] [2]

Bevmap: Map-aware bev modeling for 3d perception

Mincheol Chang, Seokha Moon, Reza Mahjourian, and Jinkyu Kim. Bevmap: Map-aware bev modeling for 3d perception. In Proceedings of the IEEE/CVF Winter Conference on Applications of Computer Vision, pages 7419–7428, 2024

work page 2024

[3] [3]

Lookout: Diverse multi-future prediction and planning for self-driving

Alexander Cui, Sergio Casas, Abbas Sadat, Renjie Liao, and Raquel Urtasun. Lookout: Diverse multi-future prediction and planning for self-driving. In Proceedings of the IEEE/CVF International Conference on Computer Vision , pages 16107–16116, 2021

2021

[4] [4]

Gpu computing revolution: Cuda

Ramandeep Singh Dehal, Chirag Munjal, Arquish Ali Ansari, and Anup Singh Kushwaha. Gpu computing revolution: Cuda. In 2018 International Conference on Advances in Computing, Communication Control and Networking (ICACCCN) , pages 197–201. IEEE, 2018

work page 2018

[5] [5]

Carla: An open urban driving simulator

Alexey Dosovitskiy, German Ros, Felipe Codevilla, Antonio Lopez, and Vladlen Koltun. Carla: An open urban driving simulator. In Conference on robot learning , pages 1–16. PMLR, 2017

work page 2017

[6] [6]

Probabilistic future prediction for video scene understanding

Anthony Hu, Fergal Cotter, Nikhil Mohan, Corina Gurau, and Alex Kendall. Probabilistic future prediction for video scene understanding. In Computer Vision–ECCV 2020: 16th European Conference, Glasgow, UK, August 23–28, 2020, Proceedings, Part XVI 16 , pages 767–785. Springer, 2020

work page 2020

[7] [7]

Expert human-level driving in gran turismo sport using deep reinforcement learning with image-based representation

Ryuji Imamura, Takuma Seno, Kenta Kawamoto, and Michael Spranger. Expert human-level driving in gran turismo sport using deep reinforcement learning with image-based representation. arXiv preprint arXiv:2111.06449, 2021

arXiv 2021

[8] [8]

Stfp: Simultaneous traffic scene forecasting and planning for au- tonomous driving

Chan Kim, Hyung-Suk Yoon, Seung-Woo Seo, and Seong-Woo Kim. Stfp: Simultaneous traffic scene forecasting and planning for au- tonomous driving. In 2021 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS) , pages 6016–6022. IEEE, 2021

work page 2021