Datasets:

pyfccc
/

cgeq-image-depth

license: cc-by-nc-sa-3.0
task_categories:
  - depth-estimation
language:
  - en
tags:
  - kitti
  - leres
  - online-calibration
  - risk-control
  - cgeq
size_categories:
  - 1K<n<10K
pretty_name: CGEQ KITTI-derived frozen depth calibration cache

CGEQ image-depth calibration data

Frozen prediction/target/uncertainty data for replaying the CGEQ image-depth experiment without downloading RGB photographs, training LeReS or using a GPU. This is an independently prepared KITTI-derived research cache, not an official release of KITTI or the reference paper's prediction data.

3,000 compressed NPZ files; 3.12 GiB (3,352,874,228 bytes including the manifest). Each image is one online datapoint. Pixels supply within-image coverage feedback. There are no categorical labels. No RGB photographs or model checkpoints are included.

Download and location

python -m pip install "huggingface_hub==1.16.4" "numpy==1.26.4"
hf download pyfccc/cgeq-image-depth --repo-type dataset --local-dir ./cgeq-depth-data
python ./cgeq-depth-data/verify.py --cache ./cgeq-depth-data/frozen_depth

The cache consumed by the experiment is ./cgeq-depth-data/frozen_depth/, not the repository's top-level download directory. The repository is public; an access token is not required to download it. For version-pinned reproduction, add --revision <commit-sha> to hf download. The experiment code package pins the verified release in CGEQ/image_depth/data/huggingface_release.json.

Python alternative, downloading only the cache:

from huggingface_hub import snapshot_download
snapshot_download(
    repo_id="pyfccc/cgeq-image-depth", repo_type="dataset", token=False,
    local_dir="./cgeq-depth-data", allow_patterns=["frozen_depth/*"],
)

Data-only layout:

frozen_depth/
  manifest.json
  t_00007001.npz
  ...
  t_00010000.npz
provenance/
  dataset.json
  frame_sources.json
verify.py

Files are already compressed and can be downloaded individually. Preserve the manifest ordering; do not randomly split adjacent video frames. Download all 3,000 frames to run the supplied exact-reproduction workflow.

Schema and splits

NPZ field	Shape	Type	Meaning
prediction	448×448	float32	Frozen predicted depth, meters
target	448×448	float32	Filled/preprocessed KITTI-derived depth target, meters
scale	448×448	float32	Frozen symmetric uncertainty scale, meters
valid_mask	448×448	bool	Pixels used to compute the image's loss
timestamp	scalar	int64	One-based position in the original ordered stream

Only valid pixels are scored: 82,880 per cached image. target contains dense filled and processed benchmark labels, not independently measured LiDAR ground truth at every pixel. timestamp is a sequence index, not a wall-clock time. The manifest records split, file SHA-256, predictor-update count, and source hash. provenance/frame_sources.json maps each record to its original KITTI RGB/depth relative path and camera/drive/frame identity.

Sequence positions	Purpose	Number
1–6000	Offline predictor training; not in this download	6,000
6001–7000	Online warm-up; not in this download	1,000
7001–8000	Included calibration validation	1,000
8001–10000	Included calibration evaluation	2,000

These are our ordered-stream splits, not the official KITTI benchmark test split.

Sources and preparation

KITTI: dataset and license, raw-data information.
Reference benchmark: Shai Feldman, Liran Ringel, Stephen Bates and Yaniv Romano, Achieving Risk Control in Online Learning Settings.
Reference implementation: Shai128/rrc and Shai128/rrc-old.
Predictor: LeReS ResNeXt101, initialized from the pinned public weight mirror, then trained on this split. We do not redistribute weights here.

The first 10,000 ordered reference annotations are retained. Dense targets are formed with the reference Levin colorization routine and reference loader preprocessing. LeReS is trained for 60 epochs on the first 6,000 images (batch size 1; 360,000 updates), then adapted for 4,000 sequential images. Each saved prediction precedes that image's full-target update. Uncertainty uses five previous residual maps and optical flow. The frozen scale is the mean of lower and upper uncertainty, converted to meters and floored at 0.001.

Reproduction boundaries: the original initializer URL was unavailable, so a pinned public mirror was used; byte identity with the unavailable original could not be established. The original dense-PNG writer was not released. The reference predictor uses 200 sampled known current-image depths and original target-normalization preprocessing; this is not a strictly RGB-only deployment benchmark. Predictions are frozen and shared across calibration algorithms.

Intended use: CGEQ/COCO replay

In the separately supplied experiment code, from CGEQ/image_depth/:

python -m pip install -r requirements.txt
bash scripts/reproduce.sh /absolute/path/to/cgeq-depth-data/frozen_depth results/reproduction 3

The code, final results and high-level setting are in CGEQ/image_depth/ in the CGEQ project; this Hugging Face repository distributes the data only. Its README.md, EXPERIMENT.md, and preparation/README.md describe replay and model preparation. The final comparison uses X=[0,5], L=1, target coverage 80%, relative budget slack 5%, and H=20/50/100, with CGEQ 4+5 (logistic proxy), CGEQ 4+6 and native COCO 10. All 2,000 evaluation images are used.

Intervals are prediction ± x*scale, without clipping the lower endpoint. Per-image loss is mean(abs(target-prediction)/scale > x) over valid pixels; g=0.2-loss and GEQ=abs(cumsum(g))/t. Window budgets are constructed offline from normalized-residual quantiles and revealed to the controller only after choosing x. Data availability must not be confused with information available to an online learner. L=1 is the requested empirical setting and does not bound all original width constraints; the experiment records that limitation explicitly.

Example of reading one image (for inspection, not controller action selection):

import numpy as np
with np.load("cgeq-depth-data/frozen_depth/t_00008001.npz", allow_pickle=False) as z:
    mask = z["valid_mask"]
    scores = np.abs(z["target"][mask].astype(np.float64)
                    - z["prediction"][mask].astype(np.float64)) / z["scale"][mask]
    loss = np.mean(scores > 2.0)  # illustrative x, not the experiment initializer

License and attribution

CC BY-NC-SA 3.0, following the KITTI license. Noncommercial use only; attribute the original work and preserve the license for adaptations. See LICENSE.md. This derived release is maintained by pyfccc; it is not endorsed by the upstream authors.

Please cite the reference risk-control paper above and the KITTI raw-data paper:

@article{Geiger2013IJRR,
  author = {Andreas Geiger and Philip Lenz and Christoph Stiller and Raquel Urtasun},
  title = {Vision meets Robotics: The KITTI Dataset},
  journal = {International Journal of Robotics Research},
  year = {2013}
}

Also reference this dataset repository and the commit SHA used in your experiment.