Hugging Face's logo

Datasets:
Dhi-Technologies
/
causal-predictive-alerting-benchmark

Tasks:
Time Series Forecasting
Size:
n<1K
Tags:
anticipation
causal-inference
anomaly-detection
counterfactual
falsification-ledger
Synthetic
License:
Dataset card Data Studio Files
xet
 Community

Acknowledge the terms to access this dataset

This repository is publicly accessible, but you have to accept the conditions to access its files and content.

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.

Log in or Sign Up to review the conditions and access this dataset content.

Causal Predictive Alerting Benchmark

Product: causal-predictive-alerting ("precausal"): predicts an incident seconds before it happens from kinematic trajectories, and proves why via ablation-replay counterfactuals and a falsification ledger (every prediction is later graded fulfilled or falsified against what actually happened).

Synthetic data, real-data validation in progress

All scenarios are seeded, procedurally generated kinematic trajectories (zone-entry, convergence, crowd-buildup, and several designed negative and edge cases), run through the actual production code (precausal.state.WorldState, precausal.predict.Predictor, precausal.grounding.FalsificationLedger, precausal.counterfactual.explain), not a reimplementation. CPU-only, no GPU, no external data. Real-camera and real-incident validation has not been performed on this product.

What's in this dataset

Two batteries, from two different harness runs, kept separate rather than merged, so the numbers below are not mixed:

  • battery_200.jsonl (201 lines, about 66 KB: 200 scenario rows plus 1 trailing summary row): the earlier, simpler 200-scenario battery: zone_entry, convergence, crowd_buildup, no_incident, 50 each. Real measured summary (embedded as the last line of the file):

    • 200 scenarios, 150 alerts fired (75%)
    • Ledger verdicts: 63 fulfilled, 87 falsified, 50 no-alert (63 + 87 + 50 = 200; 63 + 87 = 150, reconciles with alerts fired)
    • Outcome base rate 0.34 (68 of 200 scenarios actually reached the hazard)
    • Mean predicted lead time: 4.688 s (median 4.5 s)

  • scenario_battery_rows.jsonl (210 rows, about 170 KB) plus scenario_battery_summary.json (about 3 KB): the current, larger 210-scenario battery (adds convergence_multi, departing, stationary, out_of_horizon as harder positive and negative cases). Each row also carries the counterfactual explanation (would_not_fire_if, still_fires_despite, necessity_by_entity per-entity ablation replay result). Real measured per-kind precision from scenario_battery_summary.json:

    kind n precision recall mean abs lead error (s)
    zone_entry 45 0.667 1.0 0.403
    convergence 35 0.657 1.0 1.349
    convergence_multi 10 0.5 1.0 0.430
    crowd_buildup 45 0.356 1.0 1.343

    False-positive rate on the 75 negative scenarios: 8.0% overall (0% for no_incident and departing, 20% for stationary, 13.3% for out_of_horizon, the two hardest edge cases). Counterfactual stability: for zone_entry and convergence, removing the causal entity eliminates the prediction 100% of the time (pct_remove_necessary); for crowd_buildup only 21.7% of the time, because a crowd above threshold genuinely does not depend on any single occupant.

How to load it

Verified against the actual files in this repository (prints 201 for the battery file, 210 scenario rows, and the summary's n_scenarios):

import json
from huggingface_hub import hf_hub_download

repo_id = "Dhi-Technologies/causal-predictive-alerting-benchmark"
battery_path = hf_hub_download(repo_id, "battery_200.jsonl", repo_type="dataset")
rows_path = hf_hub_download(repo_id, "scenario_battery_rows.jsonl", repo_type="dataset")
summary_path = hf_hub_download(repo_id, "scenario_battery_summary.json", repo_type="dataset")

battery = [json.loads(line) for line in open(battery_path)]  # last line is a summary, not a scenario
rows = [json.loads(line) for line in open(rows_path)]
summary = json.load(open(summary_path))

print(len(battery), "battery_200 lines (200 scenarios + 1 summary)")
print(len(rows), "scenario_battery rows")
print(summary["n_scenarios"])

Measured result

Precision below 1.0 is disclosed, not hidden: this is an early-warning system trading some false alarms for lead time, and the ledger plus counterfactuals exist specifically so that trade-off is measurable per scenario kind rather than asserted.

Reproduce with:

PYTHONPATH=src .venv/bin/python experiments/scenario_battery.py --seed 0 \
  --out evidence/scenario_battery_rows.jsonl \
  --summary-out evidence/scenario_battery_summary.json

The product repository's own reproduction of this exact command produced files byte-identical to the ones checked into this dataset (verified by diff against the checked-in evidence files).

Schema notes

  • battery_200.jsonl rows and scenario_battery_rows.jsonl rows use different schemas (the newer battery adds counterfactual, occurred_at_t, and zone fields); do not concatenate them without normalizing.
  • predicted_lead_s is the lead time the predictor claimed at alert time; actual_lead_s (newer battery only) is the lead time actually measured once the ledger resolved the prediction as fulfilled.
  • ledger_fulfillment has exactly two terminal values, fulfilled and falsified, plus no_alert for scenarios where nothing fired; nothing else is invented by the ledger.

Method card, no trained weights

No trained model or weights. Predictions come from kinematic short-horizon extrapolation run through the real production code; every prediction is graded fulfilled or falsified against what actually happened (the falsification ledger), and every alert carries an ablation-replay counterfactual. Precision below 1.0 is disclosed per scenario kind, not hidden.

Limitations

  • Kinematics is constant-velocity in this version; every designed hazard scenario begins with a straight-line approach before any abort, which is an easier case for a constant-velocity predictor by construction. recall = 1.0 in both batteries is scenario-generator-shaped, not a claim of perfect real-world detection: erratic or curved early trajectories are not stress-tested by either battery.
  • crowd_buildup precision (0.356) is genuinely the weakest of the three core alert kinds, a reproducible property of trend-slope extrapolation over a short occupancy history, not a scenario-generation artifact.
  • False positives at high observation noise combined with a short sample interval are a known, reproducible edge case (stationary and out_of_horizon rows above): a median-of-differences velocity estimate with only a few warm-up observations can read an apparent speed well above the track's true speed from jitter alone.
  • All scenarios in this dataset, and in the product's own test suite, are seeded synthetic kinematic trajectories. There is no real-world camera or tracker validation of this product to date.

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.

Try it

Source & research context

Downloads last month
10
Total file size:
257 kB

Space using Dhi-Technologies/causal-predictive-alerting-benchmark 1

Collections including Dhi-Technologies/causal-predictive-alerting-benchmark