wikillm

Paper · 2021-09-06 · cs.CV

Pyramid R-CNN: Towards Better Performance and Adaptability for 3D Object Detection

Pyramid R-CNN is a second-stage head for LiDAR 3D detection. It samples grid points inside and outside each RoI at several scales, pools neighbouring points with learned gates, and predicts each RoI's search radius from local point density. Author-reported: 76.30 LEVEL_1 mAP on Waymo validation (PV-RCNN quoted at 70.30) and 82.08 moderate-car AP3D on KITTI test.

Object detectionProposal refinementAttention mechanism3d-object-detectionlidarpoint-cloudtwo-stage-detectionattention

arXivPDFCodeMarkdown16 min read

AI-compiled by claude-haiku-5-5 on 2026-11-12, not yet reviewed by a human. Every claim cites its source; check it when a detail matters.

In plain words

Self-driving cars find other vehicles in laser scans, which are clouds of dots in 3D. A common two-stage detector first proposes rough boxes around possible objects, then looks at the dots near each box to tighten it and decide what it is. The trouble is that a distant or partly hidden car may have only a handful of dots, and the dots are unevenly spread. The dots inside the box then say little on their own.

Pyramid R-CNN gives the second stage more to work with. For each box it places sample points not only inside the box but also in progressively larger boxes around it, so the model sees the neighbouring road, signs and parked cars that give context. Each sample point gathers nearby dots with an attention-style operation that learns which dots matter. The search radius around each sample point is also learned, and it adapts to how densely the scene is covered.

The idea works with several existing detector backbones, which is why it is described as a plug-in head. The authors report better accuracy than the detectors they build on, on two public driving datasets.

TL;DR

Pyramid R-CNN replaces the RoI feature-extraction step of two-stage LiDAR detectors with a pyramid RoI head. The head builds grid points at five scales, aggregates nearby points of interest with an attention-style operator that has learned gates, and predicts each RoI's search radius with a density-aware module. The authors report state-of-the-art vehicle AP on KITTI test and Waymo validation. Results are author-reported, and the repository ships no checkpoints.

Problem

Two-stage 3D detectors refine each proposal using points of interest near it, such as raw points, upsampled voxels or keypoints §1. These points are sparse and unevenly distributed. On KITTI, more than 7% of objects have fewer than 10 points, the object point count ranges from under 10 to over 500, and the points of interest are a small share of the input (about 2k keypoints against 15k input points in the cited PV-RCNN setting) §1 fig. 1. The authors argue that fixed-radius, RoI-bounded pooling cannot handle these conditions §1 §3.4. The method assumes a two-stage detector whose first stage gives 3D proposals and points of interest, and it is evaluated on point-based, voxel-based and point-voxel backbones §3.1 §4.1.

Method

The head sits on top of a backbone. The backbone produces 3D proposals and points of interest, and the pyramid RoI head refines each proposal with a classification and a regression branch §3.1 fig. 2.

  1. RoI-grid Pyramid. Each RoI gets a grid of points, as in standard RoI-grid pooling. The standard grid lies inside the RoI, with N points per side on an axis-aligned lattice eq. 1. The pyramid repeats this at several levels. Level k enlarges the RoI by ρ_w and ρ_l (ρ_h = 1) and uses N′ points per side, so grid points can fall outside the box eq. 2 §3.2 fig. 3. ρ starts at 1 at the bottom level and grows upward; N′ starts at N and shrinks upward to save compute §3.2. The five levels, their sizes and ratios are in the hyperparameter table §4.1.

  2. RoI-grid Attention. Pooling operators (max over MLP-embedded neighbours) keep only the largest channel response eq. 3 §3.3. Graph operators weight each neighbour by an embedding of its offset eq. 4. Standard attention uses the product of the offset and key embeddings in its weight eq. 5. Point Transformer adds the offset embedding to the key in the weight and to the value eq. 6. The paper merges these into one form with four learned gates σ_k, σ_q, σ_qk and σ_v, each a sigmoid of a linear map of the matching embedding. The score combines a gated key term, a gated offset term and a gated offset-key product, and the value combines the value embedding with a gated offset term eq. 7 §3.3 fig. 4. Setting the gates to particular values recovers the graph operator (σ_q = 1, others 0), standard attention (σ_qk = 1, others 0) and Point Transformer (σ_q = σ_k = σ_v = 1, σ_qk = 0) §3.3. The paper leaves the normalisation function W(·) implicit in Eq. 7; it names softmax for the attention case §3.3.

  3. Density-Aware Radius Prediction (DARP). The neighbourhood of a grid point is a hard ball: a neighbour inside radius r has weight 1, and one outside has weight 0 eq. 8. The paper takes the expected value of the attention output under this distribution eq. 9. To make r differentiable, it replaces the hard indicator by a soft weight s(i|r) = 1 − sigmoid((d_i − r)/τ), where d_i is the distance and τ a temperature eq. 10 §3.4. The gradient with respect to r is taken by reparameterisation, which samples from a uniform distribution over a sphere of radius r + 5τ instead of over all space eq. 11 eq. 12 §3.4. The final RoI-grid Attention multiplies each neighbour's term by s(i, r) and uses the wider sampling range eq. 13 §3.4.

  4. Predicting the radius. The radius is r + Δr, where r is a predefined radius per level and Δr is predicted per RoI app. B. The context is a summary of the points of interest inside two spheres centred on the RoI, of radii 2.4 and 4.8 app. B §4.1. A small MLP maps the context to Δr. All grid points of one level share the same radius app. B. The temperature τ starts at 0.02 and decays exponentially to 0.0001 during training §4.1 app. A.

  5. Output. The features from all pyramid levels are concatenated and passed to two heads, one for classification and one for box regression §3.1 §3.2.

The three backbone variants are: Pyramid-P on PointRCNN (point-based), Pyramid-V on Part-A² (voxel-based) and Pyramid-PV on PV-RCNN (point-voxel), each keeping the baseline's backbone and replacing its RoI head §4.1.

Pseudocode
# Pyramid RoI head for one RoI  [§3.1] [fig. 2]
# Input:  roi (centre, size, yaw); points of interest (xyz, features)
# Output: one feature per grid point, all levels concatenated

def pyramid_roi_head(roi, points, temperature):
    # Context from points of interest in two spheres around the RoI  [app. B]
    context = roi_context(roi, points, radii=(2.4, 4.8))
    level_features = []
    for level in pyramid_levels:
        # Grid of N' points per side over the RoI enlarged by rho  [eq. 2]
        grid = pyramid_grid(roi, level.grid_size, level.rho)
        # One radius per RoI and level, shared by its grid points  [app. B]
        radius = predicted_radius(context, level)
        # Neighbours within r + 5 tau, at most max_points per grid point  [§3.4]
        neighbours = points_in_range(
            points,
            grid,
            radius + 5 * temperature,
            level.max_points,
        )
        # Soft in-radius weight s(i, r) for each neighbour  [eq. 10]
        weight = soft_weight(neighbours.distance, radius, temperature)
        # RoI-grid Attention at each grid point  [eq. 13] [§3.3]
        level_features.append(roi_grid_attention(neighbours, weight))
    return concatenate(level_features)
Pseudocode
# RoI-grid Attention for one grid point  [eq. 7] [eq. 13] [§3.3]
# Input:  offsets (N, 3) from the grid point to each neighbour,
#         keys (N, C), values (N, C), soft weights (N,)
# Output: grid feature (C,)

def roi_grid_attention(offsets, keys, values, weights):
    # Position embedding of each neighbour's offset  [§3.3]
    position = linear_position(offsets)
    # Four learned gates, each a sigmoid of a linear map  [§3.3]
    gate_key = sigmoid(linear_key(keys))
    gate_query = sigmoid(linear_query(position))
    gate_pair = sigmoid(linear_pair(position * keys))
    gate_value = sigmoid(linear_value(position))
    # Score: gated key, gated offset and gated offset-key terms  [eq. 7]
    scores = (
        gate_key * keys
        + gate_query * position
        + gate_pair * position * keys
    )
    # Normalise over neighbours: projection then softmax, W(.)  [§3.3]
    attention = softmax(project(scores), axis=neighbours)
    # Value with gated offset term, scaled by the soft weight  [eq. 13]
    messages = (values + gate_value * position) * weights
    return sum(attention * messages, axis=neighbours)
Pseudocode
# Predicted radius for one RoI and pyramid level  [§3.4] [app. B]
# Input:  context embedding of the RoI, level settings
# Output: radius shared by all grid points of this level

def predicted_radius(context, level):
    # Predefined radius for the level, e.g. 0.8 for the first level  [app. B]
    base = level.predefined_radius
    # Small MLP maps the context to one offset per RoI  [app. B]
    offset = level.radius_mlp(context)
    # Effective radius is r + delta_r, shared across the level  [app. B]
    return base + offset

Hyperparameters

Values are for the Waymo Pyramid-PV model unless stated. Code values are from the shipped configuration and were not stated in the paper unless marked.

NameValueWhereNotes
Pyramid levels5§4.1
Grid points per side N′6, 4, 4, 4, 1§4.1 pyramid_rcnn_pv.yaml6³ + 3·4³ + 1 = 409 points per RoI §4.4
Enlarging ratio ρ_w, ρ_l1, 1, 1.5, 2, 4§4.1 pyramid_rcnn_pv.yamlρ_h = 1 at every level §4.1
Max neighbours per grid point8, 16, 16, 16, 32§4.1 pyramid_rcnn_pv.yamlCode keeps the first in-range points in storage order ball_query_deform_gpu.cu
Attention heads4§4.1 pyramid_rcnn_pv.yaml
Channels per head16§4.1 pyramid_rcnn_pv.yamlOutput width 64 per grid point
Predefined radius r per level0.8, 1.6, 2.4, 3.2, 6.4app. B pyramid_rcnn_pv.yamlKITTI-V config uses 0.2, 0.4, 0.6, 1.2, 1.6 pyramid_rcnn_v.yaml
Context spheres2.4 and 4.8§4.1 app. B pyramid_rcnn_pv.yamlNeighbours per sphere: 32 in code, not stated in paper pyramid_rcnn_pv.yaml
Temperature τ0.02 decaying exponentially to 0.0001§4.1 app. A pyramid_rcnn_pv.yamlCode reaches 0.0001 at epoch 30 of 40 and uses it at test time train_utils.py eval_utils.py
Explore windowr + 5τ§3.4 app. B pointnet2_modules.py
Radius-offset scale and clampnot statedpointnet2_modules.pyCode divides Δr by 25 and clamps r + Δr to 0.5× to 2× the predefined radius per level pyramid_rcnn_pv.yaml
Points of interest, Pyramid-PVnot stated for Pyramid-PV§1 pyramid_rcnn_pv.yamlIntro cites about 2k keypoints for PV-RCNN; Waymo config uses 4096
OptimiserAdam, trained from scratch§4.1Code uses one-cycle Adam with weight decay 0.001 pyramid_rcnn_pv.yaml; the first momentum cycles 0.95 → 0.85 → 0.95 with the schedule pyramid_rcnn_pv.yaml learning_schedules_fastai.py
Learning rateWaymo 0.01; KITTI Pyramid-P and -V 0.01, Pyramid-PV 0.005§4.1Code: pyramid_rcnn_pv.yaml pyramid_rcnn_pv.yaml
Learning-rate scheduleCosine annealing§4.1Code adds a warm-up: over the first 40% of steps the rate rises from LR/10 to LR, then cosine-decays to LR/10⁵ pyramid_rcnn_pv.yaml learning_schedules_fastai.py
Batch sizeWaymo 32; KITTI 16§4.1Config is 4 per GPU (Waymo) and 2 per GPU (KITTI), on 8 GPUs pyramid_rcnn_pv.yaml pyramid_rcnn_pv.yaml [README]
EpochsWaymo 40; KITTI 80§4.1pyramid_rcnn_pv.yaml
Waymo training frames20% of frames, uniformly sampled§4.1Code takes every fifth frame for training and testing waymo_dataset.yaml
Gradient clippingnot statedCode clips the norm at 10 pyramid_rcnn_pv.yaml
RoI samplingnot statedCode: 128 RoIs per image, 50% foreground, foreground IoU 0.75, background 0.25 to 0.1, regression foreground 0.55 pyramid_rcnn_pv.yaml
Loss weightsnot statedCode: classification 1, regression 1, corner 1 pyramid_rcnn_pv.yaml

Results

Author-reported. Setup: Waymo Open validation has 202 sequences, and the paper samples 20% of training frames §4.1. KITTI test uses 40 recall positions and KITTI validation uses 11 §4.1. Baselines are the detectors each variant replaces, plus other published methods. In Table 1, starred baselines are the authors' re-implementations with the official code tab. 1; Table 2 stars baselines that are modified versions of the original architectures tab. 2. KITTI hardware is 8 V100 GPUs §4.1. Waymo hardware is not stated. Speed is measured on one V100 with batch 1 on KITTI validation §4.4.

Waymo validation tab. 1. Values are mAP/mAPH.

MethodLEVEL_1LEVEL_20–30 m30–50 m> 50 m
PointPillars63.3/62.755.2/54.784.9/84.459.2/58.635.8/35.2
MVF62.93/--86.30/-60.02/-36.02/-
Pillar-OD69.8/--88.5/-66.5/-42.9/-
AFDet63.69/--87.38/-62.19/-29.27/-
LaserNet52.1/50.1-70.9/68.752.9/51.429.6/28.6
CVCNet65.2/--86.80/-62.19/-29.27/-
StarNet64.7/56.345.5/39.683.3/82.458.8/53.234.3/25.7
RCD69.0/68.5-87.2/86.866.5/66.144.5/44.0
Voxel R-CNN75.59/-66.59/-92.49/-74.09/-53.15/-
PointRCNN*45.05/44.2537.41/36.7472.24/71.3131.21/30.4123.77/23.15
Pyramid-P47.02/46.5839.10/38.7674.24/73.7832.49/31.9625.68/25.24
Part-A² Net*71.69/71.1664.21/63.7091.83/91.3769.99/69.3746.26/45.41
Pyramid-V75.83/75.2966.77/66.2892.63/92.2074.46/73.8453.40/52.44
PV-RCNN70.3/69.765.4/64.891.9/91.369.2/68.542.2/41.3
Pyramid-PV76.30/75.6867.23/66.6892.67/92.2074.91/74.2154.54/53.45

Waymo test leaderboard tab. 2. Test-server numbers, with the baselines modified as noted in the table caption and one variant using two frames and a larger voxel backbone. Not comparable with the validation table.

MethodLEVEL_1LEVEL_20–30 m30–50 m> 50 m
CenterPoint*81.05/80.5973.42/72.9992.52/92.1379.94/79.4361.06/60.42
PV-RCNN*81.06/80.5773.69/73.2393.40/92.9880.12/79.5761.22/60.47
Pyramid-PV (two frames, larger backbone)81.77/81.3274.87/74.4393.19/92.8080.53/80.0464.55/63.84

KITTI test, car AP3D (%), 40 recall positions tab. 3. Modality: R+L is RGB plus point cloud, L is LiDAR only.

MethodModalityEasyModerateHard
MV3DR+L74.9763.6354.00
AVOD-FPNR+L83.0771.7665.73
F-PointNetR+L82.1969.7960.59
MMFR+L88.4077.4370.22
3D-CVFR+L89.2080.0573.11
CLOCsR+L88.9480.6777.15
ContFuseR+L83.6868.7861.67
VoxelNetL77.4765.1157.73
PointPillarsL82.5874.3168.99
SECONDL84.6575.9668.71
STDL87.9579.7175.09
PatchesL88.6777.2071.82
3DSSDL88.3679.5774.55
SA-SSDL88.7579.7974.16
TANetL85.9475.7668.32
Voxel R-CNNL90.9081.6277.06
HVNetL87.2177.5871.79
PointGNNL88.3379.4772.29
PointRCNNL86.9675.6470.70
Pyramid-PL87.0380.3076.48
Part-A² NetL87.8178.4973.51
Pyramid-VL87.0681.2876.85
PV-RCNNL90.2581.4376.82
Pyramid-PVL88.3982.0877.49

KITTI validation, car AP3D (%), 11 recall positions tab. 4.

MethodEasyModerateHard
PointRCNN88.8878.6377.38
Pyramid-P88.4783.1078.44
Part-A² Net89.4779.4778.54
Pyramid-V88.4483.1478.61
PV-RCNN89.3583.6978.70
Pyramid-PV89.3784.3878.84

Component ablation, Waymo validation, Pyramid-PV, LEVEL_1 mAP tab. 5. Ticks mark which of the three modules are switched on: the grid pyramid, the radius predictor and the attention operator. The starred row is the authors' re-run.

ConfigurationGrid pyramidRadius predictorAttention operatorLEVEL_1 mAP
PV-RCNN (as quoted)70.30
PV-RCNN* (re-run)74.06
(a)yes75.26
(b)yesyes75.63
(c)yesyes75.77
(d)yesyesyes76.30

Pyramid configurations, Waymo validation, Pyramid-PV, LEVEL_1 mAP tab. 6.

ConfigurationGrid sizesρ_w, ρ_lLEVEL_1 mAP
PV-RCNN (standard grid)6, 61, 174.06
(a)6, 4, 41, 1, 274.55
(b)6, 4, 4, 41, 1, 2, 474.71
(c)6, 4, 4, 4, 11, 1, 1.5, 2, 475.26

Inference speed, KITTI validation, one V100, batch 1 tab. 7. Converted to milliseconds per frame by us, from Hz.

MethodSpeed (Hz)ms per frame (derived)
PointRCNN10.0899.2
Pyramid-P8.92112.1
Part-A² Net11.7585.1
Pyramid-V9.68103.3
PV-RCNN9.25108.1
Pyramid-PV7.86127.2

Paper vs code

The official repository is PointsCoder/Pyramid-RCNN, cloned at commit 47492d5806169ed63c27b82820657a6f54174211. Its owner account carries the display name of the first author, Jiageng Mao. The README links PointsCoder/Pyramid_R-CNN, which is the same owner's repository under a different name [README]. The repository is built on OpenPCDet, has no LICENSE file, and setup.py declares "Apache License 2.0" setup.py. We therefore record code_license as "not stated", and no code is quoted. The README says checkpoints are not released [README]. The repository ships configurations for Pyramid-V and Pyramid-PV only; there is no Pyramid-P configuration [README] cfgs. The paper and code differ in these places:

  • Radius-weighting placement. Eq. 13 applies s(i, r) to each neighbour's term after the attention weighting eq. 13 §3.4. The code multiplies the grouped features by the weight before the key and value projections, so the nonlinear projections see weighted inputs. This is switched on in the Waymo config pointnet2_modules.py pyramid_rcnn_pv.yaml.
  • Gate inputs. The paper defines each gate as a sigmoid of a linear projection of the matching embedding §3.3. The code computes the gates from the mean over each grid point's neighbours and broadcasts them to all neighbours pointnet2_modules.py.
  • Projections. The paper gives the position term as a linear map of the offset and the key as a linear map of the feature §3.3. The code adds ReLU to both and uses a two-layer batch-normalised MLP for values pointnet2_modules.py.
  • Layers not in the paper. The code adds, per level, a single transformer encoder layer (4 heads, feed-forward width 64, dropout 0.1, post-norm), a learned per-grid-point position embedding initialised to zero, and sigmoid-gated classification and regression weights on the output pointnet2_modules.py pointnet2_modules.py.
  • Grid rotation. Eq. 1 and Eq. 2 place grid points on an axis-aligned lattice §3.2. The code rotates the grid by the RoI heading about the RoI centre pyramid_head.py.
  • Point score scaling. The code multiplies each point feature by its foreground score before pooling pyramid_head.py. The paper does not mention this.
  • Neighbour selection. The ball query keeps the first in-range points in storage order, not the nearest, and pads missing slots with the first found neighbour ball_query_deform_gpu.cu. The paper does not state either rule.
  • Radius predictor. The paper describes an MLP on the context app. B. The code max-pools 32 neighbours in each of the two spheres, passes the result through a conv MLP, then a two-layer linear head. It divides the offset by 25 and clamps the radius per level pointnet2_modules.py.
  • Temperature schedule. The paper says τ decays exponentially to 0.0001 "in the end" §4.1. The code decays it over epochs 0 to 30 of 40 and then holds it at 0.0001 train_utils.py pyramid_rcnn_pv.yaml.
  • Learning-rate schedule. The paper says cosine annealing §4.1. The code uses a one-cycle schedule with a 40% warm-up from LR/10 learning_schedules_fastai.py pyramid_rcnn_pv.yaml.
  • Per-variant settings. The appendix gives one set of predefined radii app. B. The KITTI Pyramid-V config uses different radii pyramid_rcnn_v.yaml. The KITTI Pyramid-PV config uses 16 as the first-level neighbour cap, where Waymo uses 8 pyramid_rcnn_pv.yaml, and 2048 keypoints, where Waymo uses 4096 pyramid_rcnn_pv.yaml pyramid_rcnn_pv.yaml.
  • Consistency. The grid total of 409 §4.4, the grid sizes and enlargement ratios §4.1, the neighbour caps for Waymo Pyramid-PV §4.1, the 4 heads of 16 channels §4.1, the context spheres §4.1, the learning rates §4.1, the epochs §4.1, the batch sizes (8 GPUs) §4.1 and the 20% frame sampling §4.1 all match the shipped Waymo configs pyramid_rcnn_pv.yaml waymo_dataset.yaml. We did not run the code, so these are read-only checks.

Pitfalls

  • Eq. 2 without heading. An implementation that follows Eq. 2 literally builds axis-aligned grids. The official code rotates each grid by the RoI yaw pyramid_head.py. The two differ for any RoI with nonzero heading.
  • Gate scope. The paper gates per neighbour, the code gates per grid point from the neighbour mean §3.3 pointnet2_modules.py. Results may differ.
  • Normalisation under Eq. 13. It is not stated whether the softmax in W sees s(i, r). In the code, s reaches the softmax only indirectly, through the key projection of the weighted features pointnet2_modules.py.
  • Hard-to-soft gap. Eq. 10 approximates a hard ball with a sigmoid. The paper says the approximations "didn't hamper the training" but gives no ablation of the 5τ window or of the sampling approximation §3.4 app. A. As τ approaches 0.0001, the window 5τ shrinks to about 0.0005 in the units of r. Inferred from Eq. 10, not stated in the paper: the gradient with respect to r then comes almost only from neighbours near the boundary.
  • Which τ at test time. The paper does not say. The code evaluates with the final value, 0.0001 eval_utils.py.
  • Radius clamp. The code bounds r + Δr to between 0.5 and 2 times the predefined radius at each level, using per-level min and max values pyramid_rcnn_pv.yaml. The paper states neither the clamp nor the division by 25, so an implementer who follows the paper alone will get different radii.
  • Neighbour selection. Under the code's rule, the chosen neighbours depend on the order of points in the input tensor, and a missing slot repeats the first neighbour, which then gets extra softmax weight ball_query_deform_gpu.cu. Both matter for reproducibility.
  • Text-table mismatch on >50 m. The text says Pyramid-V beats PV-RCNN by 12.3% mAP on objects beyond 50 m §4.2. Table 1 gives 53.40 against 42.2 for Pyramid-V, a gap of 11.2 points. The 12.3 gap matches Pyramid-PV, at 54.54 tab. 1.
  • Baseline choice. The "6.0%" gain for Pyramid-PV is measured against PV-RCNN as quoted (70.30). Against the authors' own re-run (74.06), the gain is 2.24 points tab. 1 tab. 5. The 2.0% and 4.1% gains for Pyramid-P and Pyramid-V use the starred re-runs tab. 1.
  • Where the KITTI gains are. The text says the KITTI gains are "mainly from the hard cases" §4.3. Table 4 shows larger gains in the Moderate column (Pyramid-V +3.67 Moderate, +0.07 Hard) tab. 4. The paper does not define "hard cases" for KITTI.
  • Latency. The text calls the added latency "little" §4.4. Table 7 converts to about 19 ms more per frame for Pyramid-PV (127.2 against 108.1 ms), about 18% slower tab. 7. The Pyramid-V overhead is about 18 ms.
  • Naming in the appendix. Appendix C calls the larger backbone Pyramid-PV†, but Table 2 labels the same model with ‡ app. C tab. 2.
  • Reproduction. There are no checkpoints. The README targets an environment of Python 3.6, PyTorch 1.5, CUDA 10.1, OpenPCDet v0.3.0 and spconv v1.2.1, and training uses 8 V100 GPUs [README]. Table 2 cannot be reproduced from the shipped configs: the test-server setup with modified baselines and two frames is not in the repository.
  • Costs the abstract hides. Each RoI carries 409 grid points at 64 channels, and each point attends over up to 32 neighbours §4.1 §4.4. Attention and the radius predictor add parameters and memory beyond the baseline heads.

Lineage

  • Builds on: PointRCNN (point-based backbone, Pyramid-P), Part-A² Net (voxel-based, Pyramid-V) and PV-RCNN (point-voxel, Pyramid-PV), whose RoI heads the pyramid head replaces §4.1. The pyramid grid is an extension of the RoI-grid pooling that PV-RCNN uses, which the paper replaces §3.2 §4.1. The DARP gradient uses the reparameterisation trick the paper cites §3.4.
  • Compared against: PointPillars, MVF, Pillar-OD, AFDet, LaserNet, CVCNet, StarNet, RCD, Voxel R-CNN, CenterPoint, STD, Patches, 3DSSD, SA-SSD, TANet, HVNet, PointGNN, MMF, 3D-CVF, CLOCs and ContFuse tab. 1 tab. 2 tab. 3.
  • Superseded by: not stated.

Source and license

Adapted from “Pyramid R-CNN: Towards Better Performance and Adaptability for 3D Object Detection” by Jiageng Mao, Minzhe Niu, Haoyue Bai, Xiaodan Liang, Hang Xu, Chunjing Xu (arXiv:2109.02499), used under CC BY-SA 4.0. Changes: condensed and restructured for implementation, with tables, equations and algorithms taken from the paper and its code, each cited to its source. Not affiliated with or endorsed by the authors. This page is licensed under CC BY-SA 4.0. Code citations refer to https://github.com/PointsCoder/Pyramid-RCNN at commit 47492d580616 (not stated). Any quoted code is shown under that license.