Robot Pointcloud CUDA Lab

A CUDA-focused robotics portfolio project for one practical question:

How do we turn raw pointclouds into useful robot-learning features fast enough to matter?

This repo is built to be interview-friendly. It does not stop at "I wrote a CUDA kernel." It shows why the kernel exists, what robotics problem it serves, how it is benchmarked, and how to explain the engineering tradeoff.

Why this repo

Your background is already close to this problem:

• pointcloud processing
• industrial perception
• geometric heuristics
• robot-learning observation design

So this repo takes the shortest path from your past projects into CUDA:

1. rasterize pointclouds into BEV feature maps
2. compute height, density, and roughness statistics per cell
3. score the cells for grasping or terrain observation
4. benchmark a custom CUDA path against a plain reference implementation

That is much more credible than a generic CUDA toy project.

What is inside

• csrc/pointcloud_ops.cpp: PyTorch extension bindings
• csrc/pointcloud_ops_kernel.cu: custom CUDA rasterization kernel
• src/robot_pointcloud_cuda_lab/ops.py: high-level BEV API
• src/robot_pointcloud_cuda_lab/reference.py: pure reference implementation
• src/robot_pointcloud_cuda_lab/grasp.py: grasp-cell scoring logic inspired by real pointcloud workflows
• src/robot_pointcloud_cuda_lab/synthetic.py: synthetic pointcloud generators for demos and benchmarks
• src/robot_pointcloud_cuda_lab/benchmark.py: repeatable benchmark helpers
• scripts/build_extension.py: compile the CUDA extension through PyTorch JIT
• scripts/run_bev_benchmark.py: export local benchmark results
• scripts/run_grasp_demo.py: generate a grasp-score heatmap and summary
• docs/learning_path.md: fast learning path for CUDA beginners
• results/: benchmark tables and demo artifacts

Why this matches robotics RL

Pointcloud BEV features are a practical bridge between perception and control:

• for manipulation, they make grasp scoring easier to explain and debug
• for locomotion, they are a reasonable terrain observation format
• for sim-to-real work, they are easier to stabilize than raw pointcloud policies

That makes this repo a good companion to a locomotion portfolio.

Quickstart

python -m venv .venv
.\.venv\Scripts\Activate.ps1
python -m pip install --upgrade pip
python -m pip install -e .[dev]
python scripts/build_extension.py
pytest
python scripts/run_bev_benchmark.py
python scripts/run_grasp_demo.py

Core story for interviews

1. I translated pointcloud intuition into a custom GPU preprocessing path.
2. I kept a plain reference implementation for correctness checks.
3. I benchmarked the kernel instead of stopping at successful compilation.
4. I framed the output around robot-learning observations and grasp selection, not just raw throughput.

Current artifacts

• results/bev_benchmark.md: local benchmark table for the custom CUDA path
• results/bev_benchmark.csv: raw benchmark values
• results/grasp_demo.md: grasp scoring summary on a synthetic pile
• results/grasp_heatmap.png: heatmap for quick visual inspection

License

MIT