Self-supervised pre-training and the TREND test bed

Two stages, one without manual labels

Labelled 3D boxes are expensive. Raw driving sequences are not. Self-supervised pre-training uses that asymmetry: first train the encoder on a task whose answer is already contained in the sensor data, then fine-tune on the small labelled subset that is actually available.

The task in the first stage is called a pretext task. It exists to force the encoder to learn something structural, and it is discarded once it has done so. Nothing in the pretext task is required to be useful at inference, and in a rendering-based method almost none of it is.

1. Stage one, no labelsPre-trainingUnlabelled driving sequences. The target is constructed from the sensor data itself, so this stage does not require manually annotated boxes.
2. What carries overEncoder weightsThe encoder's learned parameters. The extra modules used only for the pretext task are discarded at this point.
3. Stage two, labelsFine-tuningA small labelled subset, used to train the detector end to end. Pre-training is worth something if it lets this stage reach further with the same labels.

Observation space

Predict what the sensor recorded

The loss compares a decoded quantity with a measurement: pixels, points, occupancy, or here a distance along a ray. The target is exact and needs no second network, but the model has to spend capacity on sensor detail that the downstream task may not want.

TREND, and every arm in this study

Feature space

Predict a target representation

The loss compares latent features against features produced by a teacher network. Raw sensor detail never has to be decoded, and the target moves during training, which brings its own failure modes.

Not run here. Listed as a direction, not a result

Two properties of this arrangement matter for everything that follows. The first is that the pretext task usually needs extra machinery: a head, a decoder, a renderer, something that turns a latent representation into whatever the loss compares. The second is that this machinery is deleted before fine-tuning. Whatever it contributed has to be visible in the encoder weights, or it is not visible at all.

What TREND asks the encoder to do

TREND is a future-predictive LiDAR pre-training method, published at NeurIPS 2025 as a Spotlight. It is used here as a test bed rather than as a subject: it is a recent, clearly specified instance of the design under examination, and it has a public implementation that a controlled scaffold can be built on.

The pretext task is neural rendering of range measurements. A sweep is voxelized and heavily masked, the encoder produces a latent volume from what is left, a recurrent transformation conditioned on the ego vehicle’s recorded motion rolls that volume forward in time, and a neural field is queried along sampled rays to predict how far away the first surface is. The loss compares those predicted distances with the distances the sensor recorded.

A LiDAR sweep is masked and encoded. The encoder feeds a latent transformation, which feeds a neural field renderer, which produces a present-frame and a future-frame range loss. A separate branch takes the encoder weights to a 3D object detector, and the transformation and renderer are discarded at that point.

1. LiDAR sweepTen aggregated sweeps on nuScenes, a single 0.1-second scan on ONCE. Points are voxelized before anything else happens.
2. MaskingMost of the voxel grid is hidden from the encoder. The hidden geometry is what the reconstruction target is built from, so the task is not solvable by copying the input.
3. EncoderA sparse 3D backbone turns the visible voxels into a latent feature volume. This is the only module that reaches the detector.
4. Latent transformationA recurrent step, conditioned on the ego vehicle's recorded motion between the two frames, that rolls the latent volume forward in time.
5. Ray queryRays are sampled from the sensor origin in known directions. Each ray is a question: how far to the first surface along this direction?
6. Neural field rendererA signed-distance field, read at sample points along each ray, is integrated into one predicted distance per ray.
7. Range lossesPredicted distances are compared with the distances the sweep recorded. Present-frame rays always; under the full objective, future-frame rays as well.
8. TransferPre-training ends. The encoder weights initialise a detector; the transformation and the renderer are deleted and never run again.

A range target is one number per ray. The ray leaves the sensor in a known direction, the renderer returns the distance at which it expects to meet a surface, and the loss is the gap between that number and the distance the sweep actually measured. A future range target is the same quantity measured from a later position of the same vehicle, which is why the ego motion between the two frames has to be applied before the comparison means anything.

The transformation is the part that makes the objective temporal: it advances a latent state under a known action before the future-frame loss is read. Where the present-frame loss reads from is a separate routing choice, examined on the next page.

Why a module that gets thrown away can still matter

A head between the representation and the loss is one of the better-documented devices in self-supervised learning, and the effect it produces has nothing to do with time.

• SimCLR (Chen et al., ICML 2020) introduced a learned nonlinear projection before the contrastive loss and kept the representation from before it. The layer that is discarded improves the layer that is retained.
• Guillotine regularization (Bordes et al., 2022) frames this as a general phenomenon: where the best downstream representation sits inside a trained network depends on how much pretext-specific pressure the last layers absorbed.
• Xue et al. (ICLR 2024) give conditions under which lower layers stay less specialised than the layers the loss is attached to.
• UniPAD (Yang et al., CVPR 2024) also separates a rendering pretext from the features transferred downstream. The detailed comparison with UniPAD and PonderV2 is left for future work; neither is a controlled arm in this study.

None of this is a claim about who proposed what. It is the reason a future-prediction result needs a control. If adding a temporal head changes the encoder the way any sufficiently expressive discarded head would, then the reported benefit is not evidence about the future.

What TREND reports

The published result is broad rather than narrow, which is part of why it is worth taking apart. TREND reports gains over the strongest prior LiDAR self-supervised method under each of its own protocols, across nuScenes detection, ONCE detection at three label fractions, ONCE-to-Waymo transfer and SemanticKITTI segmentation.

• Best prior LiDAR SSL
• TREND

Paired bars for six benchmarks. TREND’s reported gain over random initialisation exceeds the best prior self-supervised method in every one: 1.77 against 0.16 on ONCE 5 percent, 1.45 against 0.71 on ONCE 20 percent, 1.06 against 0.22 on ONCE 100 percent, 2.11 against 1.10 on nuScenes, 0.77 against minus 0.03 transferring to Waymo, and 2.89 against 1.75 on SemanticKITTI.

Show the numbers

Setting	Metric	Best prior	TREND
ONCE 5%	mAP	+0.16 (UniPAD)	+1.77
ONCE 20%, five repeats	mAP	+0.71 (UniPAD)	+1.45
ONCE 20%, single seed	mAP	+0.40 (UniPAD)	+1.25
ONCE 100%	mAP	+0.22 (T-MAE)	+1.06
nuScenes D160	mAP	+1.10 (UniPAD)	+2.11
ONCE to Waymo	mean Δ	−0.03 (UniPAD)	+0.77
SemanticKITTI	mIoU	+1.75 (UniPAD)	+2.89

Two of those settings anchor the rest of this study, because they are the two reproduced here. Absolute values rather than gains:

Next The comparison assumes the released objective computes what the paper describes. What the future objective actually sees is where that assumption is checked.