Access is granted for non-commercial research and evaluation use only. By requesting access you agree not to redistribute this dataset or any derivative data, to cite Dhi Technologies in any publication or output that uses it, and to obtain a separate commercial license via dhi-tech.com before any commercial use. Access requests are reviewed manually by Dhi Technologies.

Thermal Perception Sample Corpus

Product: thermal-perception ("thermalcore"): perception with no visible light. A radiometric data engine, self-supervised pretraining harness, and evaluation protocols for thermal-native models, validated with CPU-only math (no trained checkpoints, no GPU required for what is in this repo today).

Synthetic data, real-data validation in progress

These are physics-flavored synthetic 16-bit radiometric frames (a microbolometer-style model: cool background with spatial gradients, warm bodies at realistic body and vehicle temperatures, per-column fixed-pattern noise, NETD temporal noise, hot-pixel defects), built so the engine's normalization, dedup, and self-supervised math can be verified against exact physics, independent of any real sensor. No real thermal camera footage is included in this dataset, and real-sensor validation on this exact corpus has not been performed; that is explicitly what the repo's emit-recipe GPU-phase step is for.

What's in this dataset

sample_corpus_raw_uint16.npz (about 3.5 MB): 30 synthetic radiometric frames, a single array under key frames, shape (30, 240, 320), dtype uint16. Verified directly: values in this file range from 13,812 to 47,324 raw counts. The generator's configured sensor span is roughly 253 K to 393 K, mapped to raw counts linearly; see the repo's synth.temperature_to_raw for the exact conversion.
manifest.jsonl (30 rows, about 9.8 KB): one row per frame: seed, n_people and n_vehicles (ground truth), boxes_xyxy (warm-body ground-truth boxes), perceptual_hash plus activity_score and activity_bucket (empty/sparse/busy, computed by the repo's real corpus-builder functions, thermalcore.corpus.perceptual_hash / activity_score), ambient_k, netd_k.
selfcheck_results.json (about 225 bytes): output of thermalcore.cli selfcheck --seed 0.

Of these 30 sample frames: 2 empty, 6 sparse, 22 busy by the corpus builder's own activity bucketing; this sample was not curated to look good, it is an unfiltered draw.

How to load it

Verified against the actual files in this repository (prints the frame array shape and dtype, the number of manifest rows, and the first row's activity bucket):

import json
import numpy as np
from huggingface_hub import hf_hub_download

repo_id = "Dhi-Technologies/thermal-perception-benchmark"
npz_path = hf_hub_download(repo_id, "sample_corpus_raw_uint16.npz", repo_type="dataset")
manifest_path = hf_hub_download(repo_id, "manifest.jsonl", repo_type="dataset")

frames = np.load(npz_path)["frames"]
manifest = [json.loads(line) for line in open(manifest_path)]

print(frames.shape, frames.dtype)          # (30, 240, 320) uint16
print(len(manifest), "manifest rows")      # 30
print(manifest[0]["activity_bucket"])

Measured result (from this repo, `thermalcore.cli selfcheck --seed 0`)

{
  "passed": true,
  "agc.minmax": true, "agc.percentile": true, "agc.plateau": true, "agc.tile_clahe": true,
  "ssl.zero_loss_on_perfect_reconstruction": true,
  "probe.separable_accuracy": 0.94,
  "probe.ok": true
}

This validates the math (AGC normalization variants, SSL loss correctness, a linear-probe separability sanity check on synthetic classes); it is not a real-world thermal perception accuracy number. The repo's own test suite (99 tests as of the last verified run) is CPU-only and green; no GPU pretraining has been run to completion at scale.

Reproduce with: PYTHONPATH=src .venv/bin/python -m thermalcore.cli selfcheck --seed 0

Real-world evidence (attributed to the product repo, not re-run for this card)

The product repository documents two short GPU pilots of its trainer script on a rented RTX 5060 Ti, reported in TRAINING_RESULTS.md and REAL_DATA_RESULTS.md. These numbers were not rerun for this card; they are repo-stated leads, included here for context, not as a validated benchmark:

A synthetic-data pilot: 2,503 frames (deduped from 4,096 generated), 32 minutes wall clock, masked-patch reconstruction loss reported around 0.92 down to 0.69.
A real-data pilot on LLVIP infrared (a public, non-commercial-license academic dataset, no login gate): 15,488 frames, 40 minutes wall clock, loss reported around 0.98 down to 0.65.
Both pilots are far below the repo's own hard-coded pretraining floor, PretrainRecipe.min_corpus_frames = 200,000; both documents state explicitly that neither pilot is evidence of learned-feature quality, only trainer-mechanics checks. LLVIP frames are also 8-bit AGC-processed JPEG, not the 16-bit radiometric format the rest of this pipeline is built for.

Method card, no trained weights

There is deliberately no trained checkpoint here. This product is the data engine, pretraining harness, and eval protocols, with the math validated CPU-only. The GPU pretraining run is emitted as a recipe (thermalcore emit-recipe), not a model, so nothing on this org implies a thermal foundation model exists when it does not. When compute is connected and a checkpoint is actually trained past the corpus floor, it will be published separately and labeled as such.

Limitations

All 30 frames in this sample are synthetic; no real sensor capture is part of this dataset.
The only pilot training so far on genuine sensor data used a small public academic dataset (LLVIP, 15,488 frames), which is 8-bit processed JPEG, not the 16-bit radiometric data this pipeline is designed around, and it sits far below the pretraining corpus floor.
The native zero-training detector (hotspot.py) is a threshold and connected-component method, not a learned model; the learned detector referenced elsewhere is a recipe, not a shipped artifact.
selfcheck_results.json's probe.separable_accuracy (0.94) is a linear-probe sanity check on synthetic classes, not an accuracy number on any real perception task.
The actual hardware sensor decision for real-world capture is still open and not resolved by anything in this repository.

License

This dataset is released under CC BY-NC 4.0 (non-commercial). Access is gated and requires manual approval: it is provided for non-commercial research and evaluation only, redistribution is not permitted, and any publication or output using it should cite Dhi Technologies. Commercial use requires a separate agreement; contact dhi-tech.com.