Object Detection
Transformers
ONNX
Safetensors
d-fine
cctv
fall-detection
person-on-floor
synthetic-data
Instructions to use Simuletic/fall-detector with libraries, inference providers, notebooks, and local apps. Follow these links to get started.
- Libraries
- Transformers
How to use Simuletic/fall-detector with Transformers:
# Use a pipeline as a high-level helper from transformers import pipeline pipe = pipeline("object-detection", model="Simuletic/fall-detector")# pip install -U transformers accelerate # Load model directly from transformers import AutoModel model = AutoModel.from_pretrained("Simuletic/fall-detector", device_map="auto") - Notebooks
- Google Colab
- Kaggle
File size: 9,767 Bytes
754de50 64fefca 8a615c2 754de50 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 | ---
license: cc-by-nc-4.0
library_name: transformers
pipeline_tag: object-detection
tags:
- object-detection
- d-fine
- cctv
- fall-detection
- person-on-floor
- synthetic-data
- onnx
datasets:
- Simuletic/CCTV_Incident_Dataset_Fall_Lying_Down_Detection
base_model:
- ustc-community/dfine-small-coco
- ustc-community/dfine-nano-coco
---
# Simuletic Fall Detector
**Detects a person lying on the floor after a fall, with a 2-second stays-down alarm.**
The model finds a **person lying on the ground or floor** (fallen, collapsed) in CCTV-style frames and tells them apart from
people who are standing, sitting, bending, kneeling or crouching. **Trained only on synthetic images.** No real
people or real footage were used for training. Tested on real, staged footage from two homes the model has never seen.

*The release model on **real** test footage it never saw in training (GMDCSA-24, MIT; CAUCAFall, CC BY 4.0). Model: Nano (recommended). Clips are chosen by a fixed rule (the median-scoring fall in each test set, an everyday pick-up, and the hardest look-alike in the tests: a deep bend held for more than 2 s, which Nano correctly ignores and Small does not). Full video: [validation.mp4](assets/validation.mp4).*

*Synthetic training data (Simuletic). Red = `fallen_person`, blue = `person`.*
| | Small | **Nano (recommended)** |
|---|---|---|
| Architecture | D-FINE S | D-FINE N |
| Parameters | 10.2 M | 3.7 M |
| Input | 640 Γ 640 | 640 Γ 640 |
| Speed, Apple M4 Pro, batch 1, PyTorch incl. pre/post-processing | GPU 22 ms, CPU 132 ms | GPU 16 ms, CPU 94 ms |
| Files | `small/model.safetensors`, `small/model.onnx` | `nano/model.safetensors`, `nano/model.onnx` |
| Classes | 0 `person` (upright), 1 `fallen_person` (on the floor, not holding themselves up) | same |
**Licence: CC BY-NC 4.0, for non-commercial research and evaluation only.** For commercial use, see
[Commercial use and the Pro model](#commercial-use-and-the-pro-model).
## Results on real footage
Every number is the **mean of 2 training seeds** (range in brackets), never the best seed. The model has seen
no frame from either test set.
**Test 1: CAUCAFall**, subjects 6 to 10. One home, single frames; the person is scored once they are on the floor.
| | Small | Nano |
|---|---|---|
| Frame AP | 0.975 (0.970β0.979) | 0.995 (0.994β0.997) |
| Lying frames caught, 5% of other frames alarming | 99.8% (99.7β100.0%) | 99.3% (99.0β99.7%) |
| Lying frames caught, 1% of other frames alarming | 79.8% (74.2β85.5%) | 95.6% (94.8β96.1%) |
| End-on lying (head or feet towards the camera), 5% | 100.0% | 100.0% |
**Test 2: GMDCSA-24.** A different home and different people, scored per clip.
| | Small | Nano |
|---|---|---|
| Clip AP | 0.981 (0.977β0.985) | 0.987 (0.986β0.989) |
| Falls caught, 10% of everyday clips alarming | 96.8% (96.2β97.5%) | 94.5% (93.7β96.2%) |
**"Stays down for 2 seconds" alarm** (Test 1). The alarm fires only when every frame in the last 2 s agrees.
| | Small | Nano |
|---|---|---|
| Falls caught with 0 false-alarm events | 60.4% (37.5β83.3%) | 100.0% |
| Falls caught with 1 false-alarm event | 100.0% | 100.0% |
### Why synthetic
Trained on real footage from one home, the same detector (D-FINE Nano) is perfect on more footage from that home, but in
the second home it catches only **24%** of falls. Trained only on synthetic images, it catches **94.5% (93.7β96.2%)** (Small: **96.8% (96.2β97.5%)**). Real footage from one place teaches that place; synthetic data can cover rooms, cameras, lighting,
people and look-alikes that no single recording has.
## Use
```python
from PIL import Image
from transformers import AutoImageProcessor, AutoModelForObjectDetection
repo = "Simuletic/fall-detector"
processor = AutoImageProcessor.from_pretrained(repo, subfolder="nano")
model = AutoModelForObjectDetection.from_pretrained(repo, subfolder="nano").eval()
image = Image.open("frame.jpg").convert("RGB")
outputs = model(**processor(images=image, return_tensors="pt"))
result = processor.post_process_object_detection(outputs, target_sizes=[(image.height, image.width)], threshold=0.5)[0]
for score, label, box in zip(result["scores"], result["labels"], result["boxes"]):
print(model.config.id2label[int(label)], round(float(score), 2), box.tolist())
```
The helper package has the "stays down" alarm, video, ONNX and the evaluation scripts:
[github.com/Simuletic/fall-detector](https://github.com/Simuletic/fall-detector).
Try it in the
[Kaggle notebook](https://www.kaggle.com/code/simuletic/fall-detection-on-real-footage-synthetic-trained).
**ONNX:** input `pixel_values` [1, 3, 640, 640], RGB, resized to 640 Γ 640 and scaled to 0β1 (no mean/std).
The outputs are `logits` [1, 300, 2] (apply a sigmoid per class) and `pred_boxes` [1, 300, 4] (cx, cy, w, h, normalised).
**Thresholds:** 0.5 is a starting point. Choose your own on footage from your cameras.
## How the numbers were measured
- **Test 1, CAUCAFall** (CC BY 4.0), subjects 6 to 10:
- Positives are frames from 1 s after the fall onset, with the person on the floor.
- Negatives are walking, hopping, sitting down, kneeling and picking up an object, plus the fall clips before the onset.
- The second either side of the onset (mid-fall) is left out.
- 1,923 frames, 615 lying.
- **Test 2, GMDCSA-24** (MIT), a different home with 4 people:
- 2 frames per second; a clip's score is its second-highest frame score.
- Lying in bed or on a sofa is out of scope, so those 41 clips are left out.
- **Stays down:** persistent score = lowest frame score over the last 2 s. Test 1 has 24 fall events and 34 negative
events, so one event is about 4 points.
- **Seeds:** 2 for Small and 3 for Nano, same recipe. We report the mean and the range, not the best seed.
- Scripts: [eval/](https://github.com/Simuletic/fall-detector/tree/main/eval).
## Training
- **Data: synthetic only, about 1,580 images.**
- Simuletic's [CCTV Fall Detection dataset](https://simuletic.com/datasets?utm_source=huggingface&utm_medium=model_card&utm_campaign=fall-detector) (1,000 images).
- A 438-image top-up: people lying end-on to the camera, partly hidden by furniture, curled and slumped; chair, sit-down, bend and kneel negatives.
- A 138-image round of look-alikes: deep bends to pick something up, squatting, kneeling on all fours, reaching under furniture, crouching to tie shoes. About half are night infrared, in homes, care homes, shops, car parks and corridors.
- Fixed CCTV-style cameras 2.5β7 m high.
- **Recipe:**
- Starts from the D-FINE COCO checkpoints.
- 60 epochs at 640 px, batch 8, AdamW.
- Learning rate 2.5e-4, 10Γ lower for the pretrained feature extractor; one-cycle schedule.
- Trained on an Apple M4 Pro.
## Limitations
- **Small, staged, indoor tests.** CAUCAFall has 5 test people in one home; GMDCSA-24 has 4 people in one home. Both are
staged. We have **not measured** public spaces, crowds, long distances or real night-time infrared CCTV.
- **Out of scope:** lying in bed or on a sofa, and the falling motion itself (the model scores single frames).
- **Hardest look-alike:** a long, deep bend to pick something up off the floor. On Test 1, one person bends double for more than 4 s with the head towards the camera. Nano keeps this below the alarm on all 3 seeds (single frames peak around 0.8, never for 2 s). **Small still alarms on it** on both seeds, so prefer Nano where look-alikes matter. Long, deep bends in other homes and camera angles are untested.
- **People partly out of frame or heavily occluded** were only covered up to about half of the body.
- **Not a medical device or a safety system.** Do not rely on it to protect anyone.
- **Fairness:** the training images vary age, gender, build and skin tone by design, but the real test sets are too small
to measure differences between groups.
## Commercial use and the Pro model
These weights are licensed for **non-commercial research and evaluation** only (CC BY-NC 4.0). Products, pilots, paid
services and any other commercial use need a licence.
**Simuletic Pro** is trained on request for your product:
- 10k+ training images (more night infrared, camera heights and angles, look-alikes);
- edge builds;
- a commercial licence and support;
- optional fine-tuning on your own camera views.
Contact: [simuletic.com/contact](https://simuletic.com/contact?utm_source=huggingface&utm_medium=model_card&utm_campaign=fall-detector).
## Credits and licences
- **Model:** D-FINE (Apache-2.0), via Hugging Face `transformers`, fine-tuned from `ustc-community/dfine-small-coco` and
`ustc-community/dfine-nano-coco` (COCO pretraining).
- **Training images:** fully synthetic, made by Simuletic.
- **Test sets, used for evaluation only (no frames used for training):**
- CAUCAFall: Eraso Guerrero et al., *Data in Brief* 2022, [doi:10.17632/7w7fccy7ky](https://data.mendeley.com/datasets/7w7fccy7ky), CC BY 4.0.
- GMDCSA-24: Alam et al., [GitHub](https://github.com/ekramalam/GMDCSA24-A-Dataset-for-Human-Fall-Detection-in-Videos), MIT.
- **Weights:** Β© Simuletic, CC BY-NC 4.0.
## Citation
```bibtex
@misc{simuletic_fall_detector_2026,
title = {Simuletic Fall Detector: a person-on-the-floor detector trained only on synthetic CCTV images},
author = {{Simuletic}},
year = {2026},
url = {https://huggingface.co/Simuletic/fall-detector}
}
```
|