---
license: cc-by-4.0
task_categories:
  - object-detection
tags:
  - ground-penetrating-radar
  - gpr
  - subsurface
  - synthetic-data
  - civil-engineering
  - remote-sensing
size_categories:
  - 10K<n<100K
---

# Synthetic GPR Radargrams with Object Labels

Labelled ground-penetrating-radar sections for training subsurface object detectors.
Every label is exact, because every object was placed by the generator rather than
drawn by a person.

![five classes and empty ground, with the labels drawn on](https://huggingface.co/datasets/bitztedder/gpr-synth-v1/resolve/main/preview/classes.png)

*One tile per class, boxes drawn straight from the label files — nothing tidied for
the picture. Bottom right is empty ground, a third of the dataset.*

Generated with **[gprsynth](https://github.com/Bitztedder/gprsynth)** (MIT). No real
survey data is included — the background is synthesised, so this dataset carries no
third-party rights.

## What's in it

| | surveys | tiles | empty tiles |
|---|---|---|---|
| train | 240 | 21,006 | 6,902 (33%) |
| val | 60 | 5,528 | 1,565 (28%) |

40,558 boxes over 26,534 tiles, near-even across the five classes (19–22% each).
Tiles are 512 traces wide, 256 samples tall.

A third of the tiles carry no object at all, and that is deliberate. Most real road is
empty; a detector trained only on ground that contains something learns to always find
something.

## Why this exists

Detecting voids under a road from GPR means finding hyperbolas in thousands of traces.
Training a detector needs labelled radargrams, and there are almost none: labelling
takes an expert, and the expert is the bottleneck you were trying to remove. This
dataset sidesteps the bottleneck instead of paying it.

## Classes

| id | class | polarity | note |
|---|---|---|---|
| 0 | `cavity` | −1 | air is slower than soil, so a void inverts the reflection |
| 1 | `pipe` | +1 | line source — one scatterer, no cross-track extent |
| 2 | `manhole` | +1 | shallow, wide, strong; rim rings louder than the middle |
| 3 | `box` | +1 | buried structure |
| 4 | `patch` | +1 | resurfaced cut — very shallow, flat, no thickness echo |

## Acquisition model

A generic 24-channel road array: 0.150 ns sampling, 0.080 m channel pitch, 0.050 m
trace pitch, 2 m depth window, 256 samples per trace. These are round defaults for a
system of this kind, not the calibration of a particular cart — nothing in the model
depends on the exact values, and `gprsynth/spec.py` is where you put your own.

Each channel sees a target at its true slant range, so the hyperbola sits **deeper**
the further that channel is from the object — that arrival-time shift, not amplitude,
is what recovers cross-track position.

## Format

YOLO. `images/{train,val}` + `labels/{train,val}` + `data.yaml`. Point ultralytics
at `data.yaml` and train — no conversion step.

```
images/train/0000/s0007_c11_512-1024.png
labels/train/0000/s0007_c11_512-1024.txt
```

Filenames are `s{survey}_c{channel}_{t0}-{t1}`, so any tile traces back to the survey,
the array channel, and the trace range it came from.

Tiles sit in subfolders of 50 surveys each rather than one flat directory — 26k files
in a single folder is past what most git hosts allow. Ultralytics globs recursively and
mirrors the subpath from `images/` to `labels/`, so the nesting costs you nothing.

**The split is by survey, never by tile.** Tiles from one survey overlap and share
ground; splitting by tile leaks and reports a score the field will not reproduce.

## What the box covers

The box is the apex plus a fixed slice of the limbs — **not** the full extent of the
visible hyperbola. You can see this in the figure above: the limbs run outside the box,
clearest on `box` and `pipe`.

That is deliberate, and it is the convention hyperbola detectors are normally trained
against. A limb asymptotes and stays faintly visible for as far as the section is wide,
so "everything you can see" is not a box anyone can draw — for a loud shallow target it
would be the whole tile. But it does mean a detector trained here learns the apex
signature rather than the whole V, and you should know that before you compare its
output against boxes somebody drew by hand to a different rule.

The slice is a constant (18 samples), chosen ahead of time. The separate decision of
*whether* a target is labelled at all in a given channel is measured off the rendered
section instead. If you want box extent measured the same way, `_label_box` in
`synth.py` is the one function to change.

## Honest limits — read before using

- **The surveys are interchangeable, and that is measurable.** Train a detector with a
  deliberately leaky tile-level split and its reported score comes out 0.002 mAP50 above
  what it scores on surveys it has never seen — that is, the leak buys nothing. Leakage
  pays only when there is something recording-specific to memorise, and this generator
  draws every survey from one distribution: same clutter statistics, same layering, same
  wave, only the seed changes. Real surveys differ in soil, moisture, pavement and
  backfill; this data has none of that between-survey variation, so a model trained here
  has never had to cope with it. Worked through in
  [this notebook](https://www.kaggle.com/code/bitztedder/leakage-needs-something-to-memorise).
- **`cavity` and `pipe` are solid.** Geometry and polarity match what a void and a
  pipe actually do.
- **`manhole`, `box`, `patch` are plausible approximations that have NOT been
  validated** against labelled real examples.
- The background is **not** a soil simulation. It reproduces correlated clutter,
  layering, and the direct wave — the three things a detector keys on — and nothing else.
- **No real survey has been compared against this data.** If you have field data,
  measure the domain gap before trusting a model trained here.
- Synthetic data is a starting point, not a substitute for field validation.

## Licence

CC BY 4.0. Generator is MIT.