README.md

---
license: other
license_name: lowdown-labs-lovely-license-1.0
license_link: LICENSE
tags:
  - fela
  - fourier-neural-operator
  - fno
  - cpu
  - on-device
  - predictive-maintenance
  - time-series
  - anomaly-detection
library_name: transformers
pipeline_tag: time-series-forecasting
---

# DISCLAIMER

This model is a research preview. The CWRU bearing dataset publishes no explicit license and
grants no commercial use rights, so respect that before any commercial use. Lowdown Labs has
put together this model in the interest of advancing public science.

# FELA-PdM: on device predictive maintenance for rotating machines

FELA-PdM watches the raw signal from a vibration or sensor stream on a machine (a bearing,
motor, pump, gearbox, or engine) and tells a maintenance team two things: what is wrong, and
how much longer the machine is likely to keep running. 

It is small enough to run on a
$3 to $10 microcontroller sitting next to the sensor, so a plant does not have to stream raw
data to the cloud.

# What goes in, what comes out

There are two trained tasks. Pick by the question you are asking. The bearing fault task ships as
one head (CWRU); the remaining useful life task ships as four heads, one per C-MAPSS subset
(FD001 to FD004).

- Bearing fault classification (trained on CWRU): in is a window of vibration samples from an
  accelerometer, shape `(1, 2048, 1)` (2048 raw samples, one channel, sampled at 12 kHz).
  Out is a fault class, one of healthy, inner race defect, rolling element (ball) defect, or
  outer race defect, at one of three defect sizes (0.007, 0.014, 0.021 inch); 10 classes
  total. In plain terms: "this bearing has an inner race defect" or "this bearing is healthy."
- Remaining useful life (trained on NASA C-MAPSS turbofan): in is a short history of per cycle
  sensor readings, shape `(1, 30, 14)` (30 cycles, 14 sensors). Out is an estimate of how many
  operating cycles remain before failure. A reliability engineer reads it as "this unit has
  roughly N cycles left, plan the swap."

# Why we built it this way

The sequence mixer is a Fourier Neural Operator, a filter the model learns and applies in the
frequency domain. A failing bearing or gear shows up as periodic, high frequency vibration, and
reading frequencies is exactly what this kind of operator does well, so it fits the problem. There
is no all pairs attention, so the working memory stays small and fixed however long the machine
runs. That is what lets it sit on a cheap microcontroller next to the sensor, on a battery or
panel powered node, with no cloud connection.

# Performance

Speed and footprint, measured on CPU (AMD EPYC 9555, batch size 1, median of 20 runs).

## Bearing fault (CWRU), input `(1, 2048, 1)`

| Format | Size on disk | Peak working RAM | Latency 1 core | Latency 4 core | Device class |
|---|---|---|---|---|---|
| fp32 | 0.53 MB | 0 MB | 2.358 ms | 2.955 ms | Microcontroller (STM32H7 / ESP32-S3) class |

## Remaining useful life (C-MAPSS FD001), input `(1, 30, 14)`

| Format | Size on disk | Peak working RAM | Latency 1 core | Latency 4 core | Device class |
|---|---|---|---|---|---|
| fp32 | 0.5 MB | 0 MB | 0.405 ms | 0.722 ms | Microcontroller (STM32H7 / ESP32-S3) class |


int8 here compresses about 2.5 to 2.8x rather than the full 4x, because the learned Fourier
filters are kept in fp32 and only the linear layers are quantized. We expect that
quantizing the spectral filters hurts accuracy for little size gain at this scale.

# Accuracy

Numbers below are from our own training runs on the public datasets, on CPU. The "published
range" column is the typical range reported in the literature for the same protocol, given for
context, not as a controlled head to head.

## Bearing fault classification (CWRU, 12 kHz drive end)

Protocol: 10 class problem (healthy plus inner race, ball, and outer race faults at three
defect diameters), all four motor loads pooled, raw vibration windows of 2048 samples with
50 percent overlap, random 75/25 train/test split, per signal normalization. This is the
common CWRU window split protocol.

| Model | Metric | This model | Published range | Source |
|---|---|---|---|---|
| FELA-PdM (pure FNO) | test accuracy | 100.0% | 98 to 100% | measured (ours) |
| FELA-PdM (FNO + GLA) | test accuracy | 100.0% | 98 to 100% | measured (ours) |

The window split CWRU benchmark is close to saturated in the literature; strong models
routinely report 99 to 100 percent. FELA-PdM reaches the ceiling with a 132.6 thousand
parameter model. This protocol is known to be optimistic, because windows from the same
recording can land in both the train and the test set. Harder cross load and
cross fault size protocols were not run and are listed under Limitations.

## Remaining useful life (NASA C-MAPSS turbofan)

Protocol: 14 informative sensors, min max normalized on the training set, sliding window of
30 cycles, piecewise linear remaining useful life target capped at 125 cycles (the common
Heimes convention). Metric is RMSE in cycles on the official test set (one prediction per
test engine at its last available cycle), and the NASA PHM08 asymmetric score (lower is
better, late predictions penalized more).

| Subset | Metric | FELA-PdM RMSE | FELA-PdM score | Published RMSE range | Source |
|---|---|---|---|---|---|
| FD001 | RMSE / PHM08 score | 11.16 | 192 | 11 to 18 (CNN ~18.4, LSTM ~16.1, recent transformers ~11 to 13) | measured (ours) |
| FD002 | RMSE / PHM08 score | 19.64 | 2041 | 17 to 24 | measured (ours) |
| FD003 | RMSE / PHM08 score | 11.68 | 357 | 12 to 17 | measured (ours) |
| FD004 | RMSE / PHM08 score | 19.45 | 2217 | 19 to 25 | measured (ours) |

FD001 (single operating condition, single fault mode) is the canonical benchmark. FELA-PdM
reaches 11.16 RMSE, at the strong end of the published range and ahead of the classic CNN and
LSTM baselines, with a 124.5 thousand parameter model. FD003 (single condition) matches that
strong result. FD002 and FD004 (six operating conditions) are harder; those numbers sit inside
the published band rather than ahead of it. The FD002 to FD004 numbers were measured with the
same recipe as FD001 (pure FNO, 40 epochs, seed 0). All four C-MAPSS heads (FD001 to FD004) ship
as separate safetensors files, so every row above loads and reproduces from the shipped weights.

# How to run it

See `quickstart/` for a runnable example. The short version:

```python
from modeling import load_model
# a directory holding <variant>.safetensors + config.json (or a Hugging Face repo id):
m = load_model("/path/to/weights_dir", variant="cmapss_FD001")
window = ...                              # (1, 30 cycles, 14 sensors); see modeling.preprocess_cmapss
remaining_cycles = m.predict(window)     # remaining useful life estimate
```

Pass `variant="cwru"` instead to load the bearing fault head, or `variant="cmapss_FD002"` (through
`FD004`) for the other C-MAPSS subsets. The weights ship one safetensors file per head
(`cmapss_FD001.safetensors` through `cmapss_FD004.safetensors`, and `cwru.safetensors`) beside
`config.json`. For an interactive playground, see the Hugging Face Space in `space/`.

## Formats

- fp32: reference and CPU.
- int8: on device deployment format (AVX512-VNNI on x86, NEON dot product on ARM, and the
  only realistic format on a microcontroller). About 0.21 MB (bearing) and 0.18 MB (RUL).
- bf16: server and GPU inference only; most commodity ARM and microcontroller CPUs lack
  native bf16, so it is not the on device format.

# Training data

- CWRU bearing dataset (Case Western Reserve University Bearing Data Center): 12 kHz
  drive end vibration recordings, four motor loads, used for the fault classifier. Public
  research dataset.
- NASA C-MAPSS turbofan degradation simulation (Saxena et al. 2008), subsets FD001 to FD004,
  used for the remaining useful life regressor. Public NASA dataset.
- MIMII (Purohit et al. 2019), machine sound, valve 6 dB subset: loader implemented, acoustic
  head not shipped and not measured.

## Training data, splits and licensing

The training and evaluation splits are defined in `train.py` in this repo, which covers all five
trained variants (C-MAPSS FD001 to FD004 plus CWRU). Both loaders and the exact split boundaries
are reproduced there, and a `--smoke` flag rebuilds each split, asserts the audited window count,
and exits before training.

### CWRU bearing fault (classifier)

- Dataset: Case Western Reserve University Bearing Data Center, 12 kHz Drive End (DE_time)
  vibration recordings. Version: the standard 40 file, 10 class, four motor load collection
  (Normal plus inner race, ball, and outer race faults at 0.007 / 0.014 / 0.021 inch).
- Source: https://engineering.case.edu/bearingdatacenter
- Split: sliding windows of 2048 samples, stride 1024, per signal z normalization, all four
  loads pooled; random 75/25 train/test split, seed 0. Total 5886 windows to 4415 train /
  1471 test, 10 classes. Split defined in train.py line 106 (the assertion `len(x) == 5886`
  after `cwru_split`).
- License: NO explicit license is published by CWRU for this data. It is widely used and freely
  downloadable, but the Bearing Data Center pages and the CWRU site wide legal notice grant no
  reuse or commercial use rights.
- Commercial verdict: UNCLEAR / UNSTATED, no license grant. For commercial use, obtain
  written permission from the Case School of Engineering. Third party mirrors (Kaggle, Zenodo)
  do not establish CWRU's terms.

### NASA C-MAPSS turbofan (remaining useful life regressor, FD001 to FD004)

- Dataset: NASA C-MAPSS Turbofan Engine Degradation Simulation Data Set (Saxena & Goebel 2008),
  subsets FD001 to FD004, from the NASA Prognostics Center of Excellence (PCoE) data repository.
- Source: https://www.nasa.gov/intelligent-systems-division/discovery-and-systems-health/pcoe/pcoe-data-set-repository/
- Split: 14 informative sensors, min max normalized on the training set, sliding window of 30
  cycles, piecewise linear RUL capped at 125 (Heimes convention). Train = all overlapping
  30 cycle windows per engine; test = the last window per engine scored against the official
  provided RUL truth (NASA test protocol). FD001 train has 17731 windows (test 100 engines).
  Split defined in train.py line 135 (the assertion `len(xtr) == 17731` for FD001 after
  `load_cmapss`). Metric: RMSE and NASA PHM08 asymmetric score.
- License: no explicit license line on the PCoE repository. The data is a NASA authored
  simulation (a US Government work), which under 17 U.S.C. section 105 is not protected
  by US copyright and may be used, including commercially, without permission. Attribution to
  NASA / Saxena & Goebel (2008) is requested.
- Commercial verdict: ALLOWED (US Government public domain work; attribution requested). Note:
  US only public domain status; outside the US it is not guaranteed.

### MIMII (acoustic head, not shipped)

- Dataset: MIMII (Purohit et al. 2019), valve 6 dB subset. Loader implemented; acoustic head
  not shipped and not measured, so no split or license verdict is claimed for a released model
  here.

## Loading with standard tooling

The repo ships `config.json` (architecture hyperparameters for all five heads) and a
self contained `modeling.py` with a `load_model` / `from_pretrained` entry point. A few lines
load the model from a Hugging Face repo, a local directory, or a checkpoint:

```python
from huggingface_hub import hf_hub_download
from modeling import load_model
# from a local dir holding model.safetensors + config.json:
m = load_model("/path/to/weights_dir", variant="cmapss_FD001")
# or straight from a HF repo id (downloads config.json + model.safetensors):
m = load_model("lowdown-labs/fela-pdm", variant="cwru")
```

The weights are shipped one safetensors file per head (`cmapss_FD001.safetensors` through
`cmapss_FD004.safetensors`, and `cwru.safetensors`; not pickle); pass `variant=` to pick the
head. The preprocessing the model
expects, and input validation that fails clearly on the wrong shape or channel count, are in
`modeling.py` (`preprocess_cwru`, `preprocess_cmapss`, `validate_window`).

## Serving artifacts

- `cmapss_FD001.safetensors` through `cmapss_FD004.safetensors` and `cwru.safetensors`, plus
  `config.json`, for the safetensors load path (fp32).
- `verify.py` runs a fixed sample input and checks the output shape and a verification value.

For serving at scale, use the separate CPU native FELA server (https://github.com/Lowdown-Labs/fela_server). It
runs this model on CPU with no GPU required. The quickstart in this repo is the minimal
single process path; the FELA server is the production serving path. On a microcontroller or
Pi the deploy path is an ONNX or TFLite export of the model.

# Citations and licenses

This section consolidates the formal references and the direct links to the real license
text for every dataset and method used, verified from source.

## Datasets

- **NASA C-MAPSS Turbofan Engine Degradation Simulation Data Set** (FD001 to FD004): the
  remaining useful life regressor.
  - Reference: Saxena, A., Goebel, K., Simon, D., & Eklund, N. (2008). Damage propagation
    modeling for aircraft engine run-to-failure simulation. *International Conference on
    Prognostics and Health Management (PHM08)*, 1 to 9.
    DOI: [10.1109/PHM.2008.4711414](https://doi.org/10.1109/PHM.2008.4711414)
  - Data: NASA Prognostics Center of Excellence (PCoE) data repository,
    [NASA PCoE data set repository](https://www.nasa.gov/intelligent-systems-division/discovery-and-systems-health/pcoe/pcoe-data-set-repository/).
  - **License: NASA data policy, US Government work, PUBLIC DOMAIN.** As a NASA authored
    simulation, the data is a US Government work and under
    [17 U.S.C. § 105](https://www.copyright.gov/title17/92chap1.html#105) is not protected by US
    copyright; NASA's open data terms permit use, including commercial use, without permission.
    See NASA's data usage guidelines:
    [nasa.gov/nasa-open-data-and-usage-guidelines](https://www.nasa.gov/nasa-open-data-and-usage-guidelines/).
    Attribution to NASA / Saxena & Goebel (2008) is requested. Public domain status is US only;
    outside the US it is not guaranteed.
- **CWRU bearing dataset (Case Western Reserve University Bearing Data Center)**: 12 kHz
  drive end vibration recordings, the bearing fault classifier.
  - Data / use terms: [Case Western Reserve University Bearing Data Center](https://engineering.case.edu/bearingdatacenter),
    which references the CWRU site wide legal notice:
    [case.edu/utilities/privacy-legal](https://case.edu/utilities/privacy-legal).
  - **License: NO explicit license or use terms grant is published by CWRU.** The data is freely
    downloadable and widely used, but the Bearing Data Center pages and the CWRU legal notice grant
    no reuse or commercial use rights. Commercial verdict UNCLEAR/UNSTATED; for commercial use,
    obtain written permission from the Case School of Engineering. Third party mirrors (Kaggle,
    Zenodo) do not establish CWRU's terms.
- **MIMII** (acoustic head: loader only, no weights shipped, no released model license claimed).
  Purohit, H., Tanabe, R., Ichige, K., et al. (2019). MIMII Dataset: Sound Dataset for
  Malfunctioning Industrial Machine Investigation and Inspection. *DCASE Workshop*.
  [arXiv:1909.09347](https://arxiv.org/abs/1909.09347) (dataset is CC BY-SA 4.0 on Zenodo, cited
  here for completeness only).

## Methods and code

- **Fourier Neural Operator (FNO)**: the sequence mixer at the core of both heads.
  Li, Z., et al. (2021). Fourier Neural Operator for Parametric Partial Differential Equations.
  *ICLR*. [arXiv:2010.08895](https://arxiv.org/abs/2010.08895)
- **Gated Linear Attention (GLA)**: the optional gated recall mixer in the FNO+GLA variant
  (`gla_chunk` in `config.json` / `modeling.py`). Yang, S., Wang, B., Shen, Y., Panda, R., & Kim, Y.
  (2024). Gated Linear Attention Transformers with Hardware-Efficient Training.
  [arXiv:2312.06635](https://arxiv.org/abs/2312.06635)
- **PyTorch**: training and inference framework. Paszke, A., et al. (2019). *NeurIPS*.
  [arXiv:1912.01703](https://arxiv.org/abs/1912.01703)
- **ONNX Runtime / TFLite**: the on device export and runtime path (opset 17).
  [onnxruntime.ai](https://onnxruntime.ai/),
  [ai.google.dev/edge/litert](https://ai.google.dev/edge/litert).

The deployable default is the pure FNO head; the FNO+GLA variant is the one that additionally
uses Gated Linear Attention. Landmark Attention and Gated DeltaNet are not used in this model.

# Intended use, limitations, and safety

What it is for: on device predictive maintenance running on a PLC, a sensor gateway, or an
industrial IoT node, with no dependence on the cloud. Typical buyers are equipment makers who
sell machines with downtime guarantees, and plants that cannot or will not stream raw
vibration data off site.

What it is not for: this is not a safety critical controller and not a substitute for a
certified protection system. The remaining useful life number is a planning aid. Do not use it
as the sole basis for a safety critical decision (for example deciding a machine is safe to
keep running) without independent validation against your own field data and your existing
condition monitoring practice.

Privacy: the model runs on the device next to the sensor. Raw vibration and sensor data do not
have to leave the device, which is the point for plants that cannot send data off site.

Evaluated conditions and known failure modes:

- The CWRU window split protocol is optimistic: windows from one recording can appear in both
  train and test, so 100 percent accuracy reflects an easy protocol, not a solved problem.
  Cross load and cross fault size generalization (train on one motor load, test on another) is
  the honest next test and is not yet reported.
- The C-MAPSS multi condition subsets FD002 and FD004 are not ahead of the literature; they sit
  inside the published band. FD001 and FD003 (single condition) are the strong results.
- Remaining useful life is only as good as the run to failure data it was trained on. C-MAPSS
  is simulated. Real machines fail in ways the training distribution may not cover.
- The MIMII acoustic head is not shipped; the path exists but the AUC is not measured.
- Quantization was dynamic int8 on linear layers only. A true microcontroller deployment needs
  a fixed point FFT (for example CMSIS-DSP on Cortex-M) and on target validation, which is not
  done here. Latency and size were measured on an x86 server CPU; the microcontroller claim is
  the size plus compute envelope, run there via the ONNX or TFLite export.
- No real world field data was used. All benchmarks are public research datasets.

# How to cite

```bibtex
@misc{lowdownlabs_felapdm,
  title  = {FELA-PdM: on-device Fourier Neural Operator models for predictive maintenance},
  author = {Lowdown Labs},
  year   = {2026},
  note   = {Model card}
}
```

You must also cite the datasets used:

- Saxena, A., Goebel, K., Simon, D., Eklund, N. (2008). Damage propagation modeling for
  aircraft engine run-to-failure simulation (C-MAPSS / NASA turbofan). International
  Conference on Prognostics and Health Management.
- Case Western Reserve University Bearing Data Center (CWRU bearing dataset).
- Purohit, H., Tanabe, R., Ichige, K., et al. (2019). MIMII Dataset: Sound Dataset for
  Malfunctioning Industrial Machine Investigation and Inspection. DCASE Workshop.

# Acknowledgements and references

- C-MAPSS / NASA turbofan: Saxena et al. (2008).
- CWRU bearing dataset: Case Western Reserve University Bearing Data Center.
- MIMII: Purohit et al. (2019), DCASE.
- Fourier Neural Operator: Li, Z., Kovachki, N., Azizzadenesheli, K., et al. (2021). Fourier
  Neural Operator for Parametric Partial Differential Equations. ICLR.
- PyTorch: Paszke et al. (2019), NeurIPS.

# Model family

This is part of the FELA family from Lowdown Labs: one FNO architecture across many
modalities, all CPU native and subquadratic. This repo is published as
`lowdown-labs/fela-pdm`. The sibling repos are:

- `lowdown-labs/fela-genomics`: DNA sequence classification.
- `lowdown-labs/fela-pdm` (this repo): rotating machinery and turbofan health.
- `lowdown-labs/fela-power-grid`: probabilistic solar and wind power forecasting.
- `lowdown-labs/fela-video`: video moment retrieval and temporal grounding.
- `lowdown-labs/fela-streaming-asr`: streaming CPU speech recognition.

These are grouped under the FELA Collection on Hugging Face. The models are independently
trained per modality and do not share weights, so none carries a `base_model` link.

# License

Released under the Lowdown Labs Lovely License 1.0 (CC BY-NC 4.0 plus Hippocratic License 3.0). See LICENSE. For most LL models, a commercial license may be available; contact Lowdown Labs.