README.md

---
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

```bash
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:

```python
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:

```text
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](https://www.cvlibs.net/datasets/kitti/),
  [raw-data information](https://www.cvlibs.net/datasets/kitti/raw_data.php).
- **Reference benchmark**: Shai Feldman, Liran Ringel, Stephen Bates and Yaniv
  Romano, [Achieving Risk Control in Online Learning Settings](https://arxiv.org/abs/2205.09095).
- **Reference implementation**:
  [Shai128/rrc](https://github.com/Shai128/rrc/tree/744422a85bcead54816be2310080be1729c517f6) and
  [Shai128/rrc-old](https://github.com/Shai128/rrc-old/tree/fa45ebb045c270216b87c3fc3e2f15e81158a3d0).
- **Predictor**: LeReS ResNeXt101, initialized from the
  [pinned public weight mirror](https://huggingface.co/lllyasviel/Annotators/blob/850be791e8f704b2fa2e55ec9cc33a6ae3e28832/res101.pth),
  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/`**:

```bash
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):

```python
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](https://www.cvlibs.net/datasets/kitti/).
Noncommercial use only; attribute the original work and preserve the license for
adaptations. See [LICENSE.md](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:

```bibtex
@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.