Machine learning · 3D point clouds · status & plan

Teaching a computer to recognise roadside assets in 3D

The 3D segmentation training harness — what it is, what we will run, how long it takes.

2026-08-13 · management overview · navigate with ↓ / ↑ or scroll

TL;DR

Where we stand

Experiment factory: builtAutomated pipeline that trains & evaluates 3D labeling models — reproducibly, with full audit trail.
Proven on real dataRaw scan → trained model → quality report, end to end, every prediction traceable to the original scan point.
54 runs pre-configured14 experiments queued; they start when annotated full-resolution data lands.
Overnight to a few daysPer full training run (30–50 epochs, ~50 segments). Measured anchors, not guesses.
The goal

Label every point along the highway

A survey vehicle laser-scans the road: tens of millions of 3D points per segment. The model assigns each point one of nine classes — automatically.

terrain road · background sign & gantry guardrail pole tree wall / barrier fence structure
8 asset classes + background; unjudgeable points are "void" (excluded from training and scoring). Lane markings stay in our proven 2D pipeline.
The harness

An assembly line for experiments

Training one model is easy. Knowing which of dozens of variants is genuinely better — and proving it months later — is the hard part. The harness automates that:

One config = one experimentData prep, training, model selection, reports — all automatic. Same input → same result, byte for byte.
Fail-closedAnything unexpected stops with a named error — never a silently wrong result.
Full audit trailEvery number traces to exact code, data version, settings, hardware.
Locked exam dataThe final test set can't even be read without explicit authorization — keeps accuracy claims honest.
Own weights onlyDownloaded third-party models are refused by default (license & provenance risk).
Two engines, untouchedSPT (primary, corridor-native) and Pointcept (screening) — pinned versions, not a line of their code modified.
297
automated tests
45
adversarial-review findings, all fixed
9
bugs caught by cheap smokes before any expensive run
100 %
reproducible
Preprocessing

From raw scan to training-ready data

Raw laser scanLAS, full resolution → Label sourcepre-annotated points → Identity join1 mm precision → Canonical tilesone verified format → Framework exportwhat the model trains on
100 %
of points matched labels ↔ geometry at 1 mm (real data)
0.5 mm
worst coordinate error (0.6 mm tolerance)
ID card
every point keeps its source file + row — predictions return to the exact original point
1–3 min
per segment, CPU, once per data version

Three versioned data tiers (raw → canonical → framework-ready); train/validation/test split fixed per corridor before tiling — no leakage possible.

Dividing the cloud · 1/2

Tiling along the road axis

the corridor (road axis) 50 m tile 12.5 m overlap
Tiles are the working unitA whole corridor is far too large for a GPU at once.
Overlaps kill seam errorsNo asset is only ever seen cut in half; overlap predictions are blended later.
Tile size is an experimentE8 sweeps 25–100 m lengths × 0–25 m overlaps.
Dividing the cloud · 2/2

Voxel thinning

full resolution (millions of points) → 3 cm grid laid over space → one point per occupied cube
Point count drops ~10×, shapes stay intact. But a 3 cm cube can swallow a thin sign post — so E2 measures which classes survive at 2 / 3 / 5 cm before we commit.
142
road segments in the current survey sweep
26 M
full-resolution points per segment (~14× the thinned export)
2/3/5 cm
voxel sizes E2 will judge — real experiments refuse pre-thinned input
Training

How the model learns

Guided repetition: label a tile → get scored against human labels → adjust millions of parameters. One pass through all tiles = one epoch; useful models need tens of them.

Config fileone per experiment → Safety gatesdata & policy checks → Framework trainsepoch after epoch → Best state keptcheckpoint selection → Certificationorigin proven & recorded
Scored on unseen dataBest validation snapshot is kept, not the last one — no memorising.
Rare classes weighted upGuardrail points vs endless terrain — the loss compensates.
Checkpoints certifiedEvidence-based proof the weights are our own, plus a fingerprint.
Live telemetry

Watching it learn — TensorBoard

Rendered from the actual telemetry files of our first real training run (3 epochs, one corridor section, laptop GPU). Falling loss = better guesses.

train_batch/loss — error while learning

2.5 1.5 0.5 step 1 · loss 2.21 step 2 · loss 1.73 step 3 · loss 1.48 step 4 · loss 1.26 step 5 · loss 1.13 step 6 · loss 0.94 step 7 · loss 0.89 step 8 · loss 0.94 step 9 · loss 0.77 2.21 0.77

val/loss — error on unseen data

4.5 3.0 1.5 epoch 1 · val loss 4.27 epoch 2 · val loss 1.98 epoch 3 · val loss 1.99 4.27 1.98

val/mIoU — accuracy score (higher = better)

0.20 0.10 0 epoch 1 · mIoU 0.135 epoch 2 · mIoU 0.166 — best, checkpoint kept epoch 3 · mIoU 0.126 0.166 ← best epoch kept

machinery proof, not accuracy claims  ·  in development visual check-ins: every couple of epochs, top-down images of predictions vs ground truth rendered straight into TensorBoard.

Inference

Running a trained model on new data

New corridor scan → Same prep & tiling → Model scores tilesseconds per tile on GPU → Overlap blendingweighted vote → Back onto raw pointsvia the ID card → Labeled LAS + reports
Full-resolution deliverableThe customer's own point cloud with a label column — on the exact original scan rows.
No seam artefactsConfidences blended across overlaps; reports even measure quality by distance to tile edge.
Asset-level reportsPer-class scores, false alarms per km, continuity: "92 % of guardrail covered, 3 gaps, largest 2 m."

Measured: predictions ~1–2 min per small corridor; full report stage ~72 min single-core today — optimisation planned (precedent: ~4.5 h → ~7 min).

The plan

The experiment queue (E1–E14)

PhaseExperimentQuestion
first E2 · Voxel oracleWhich resolution keeps thin assets visible? (analysis, no training)
Split decisionWhich corridors are train / validation / final exam — frozen once. (pending)
E1 · SPT pilotThe deciding baseline, on the Azure GPU cluster.
E9 · Challenger screenDo alternative models beat it? Cheap, local, already proven.
after baseline E3–E6 · AblationsWhich ingredients earn their keep: features, losses, imbalance handling, head design.
E8 · Tiling studyBest tile length & overlap.
later E7 · Scale-upFaster variant for production throughput.
E10–E14 · Label leveragePseudo-labels, weak supervision, self-supervised pretraining, active learning.
The plan · how many runs?

54 runs configured across the campaign

Each experiment expands into "cells" — one run per model, loss function, feature set, … as frozen in the configs today. 51 training runs + 3 analysis cells:

E1 pilot
1
E2 voxel oracle
3
E3 features
4
E4 loss functions
6
E5 imbalance 2×2
4
E6 head design
2
E7 scale-up
2
E8 tiling 3×3−1
8
E9 challengers
3
E10–12 labels
7
E13 self-supervised
5
E14 active learning
9

Lighter bar = analysis only, no training. First wave (E2 + E1 + E9) = 7 cells; the rest unlock as the baseline and label pipelines mature. Statistical repeats add on top.

Timescale

30–50 epochs over ~50 segments

Measured anchor (4 verified runs): one epoch over one segment = 16–20 s train + 12–25 s validation on a laptop GPU. Scaled linearly to 50 segments, per 50-epoch run:

Thinned data · local GPU
Thinned data · Azure T4
Full-res, 3 cm · T4
01 day2 days3 days4 days5 days
overnight
screening runs, thinned data, local GPU (~13–17 h / 50 epochs)
1–2 days
same on the Azure T4 cluster
days,
not weeks
full-resolution at 3 cm voxels (~2–5 days / 50 epochs)
  • Upside: measured runs used only 3.6 of 16 GB GPU memory — larger batches should cut these times substantially. Early stopping ends plateaued runs sooner.
  • The primary SPT model (E1) is the one unmeasured item — it will be timed in the pilot before we promise numbers.
Proof

The proof run behind these numbers

5.1 M
points prepared, 100 % identity join, 2 m 43 s
0.5 mm
worst coordinate error (0.6 mm tolerance)
~5–6 min
full 3-epoch training dispatch, laptop GPU, ×4 verified
=
harness-recomputed accuracy exactly matches the framework's own
9
integration bugs caught before they could cost a real run

caveat Quality metrics from this run (guardrail IoU 0.37, terrain 0.53 after 3 epochs) are code-path proof, not model-quality claims: draft labels, thinned data, smoke-only split.

Next steps

What's next

1 · E2voxel resolution verdict → 2 · Splits + annotationfreeze corridors, human labels → 3 · E1 pilot on Azure+ E9 screening locally → 4 · Ablations & label leverageE3–E8, then E10+

Deliberately not claimed yet: final data splits, the E1 pilot, the E2 verdict, human-quality annotations.

Appendix

Glossary

Point cloudMillions of 3D dots from a laser scanner; our raw material. LossThe training error signal; lower = better guesses.
SegmentationAssigning a class label to every point. IoU / mIoUOverlap between predicted and true regions (0–1); mIoU averages over classes. The standard score.
EpochOne complete pass of the training data through the model. CheckpointA saved snapshot of the model's learned parameters.
VoxelA small cube of space; "one point per cube" thins the cloud without losing shape. InferenceRunning a trained model on new data.
TensorBoardThe live dashboard charting a training run as it happens. HarnessOur automation around all of the above: configs, gates, provenance, reports.
1 / 16