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: a fall raises the 2-second alarm, a pick-up does not, and a long, deep bend correctly does not](assets/validation.webp)

*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: fallen people (red) and look-alikes such as bending, kneeling and sitting (blue), day and night infrared](assets/hero_synthetic_grid.jpg)

*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}
}
```