lowdown-labs/fela-pdm

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:

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:

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
  • Data: NASA Prognostics Center of Excellence (PCoE) data repository, NASA 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 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. 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, which references the CWRU site wide legal notice: 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 (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
• 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
• PyTorch: training and inference framework. Paszke, A., et al. (2019). NeurIPS. arXiv:1912.01703
• ONNX Runtime / TFLite: the on device export and runtime path (opset 17). onnxruntime.ai, 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

@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.