initial commit

.gitattributes

@@ -0,0 +1 @@
+*.safetensors filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,6 @@
+.ruff_cache/
+.venv/
+__pycache__/
+*.swp
+*.kate-swp
+*~

LICENSE

@@ -0,0 +1,474 @@
+Lowdown Labs Lovely License 1.0 (LLLL-1.0)
+
+Everything in this repository (the model weights, the configuration, and the code) is
+released by Lowdown Labs under two licenses that apply at the same time. To use this work
+you must comply with BOTH of them. Where a term in one is stricter than the other, the
+stricter term controls. "Lowdown Labs Lovely License 1.0" is a convenience name for this
+exact pair; it is not a new legal instrument.
+
+SPDX-License-Identifier: CC-BY-NC-4.0 AND LicenseRef-Hippocratic-3.0
+
+Commercial licensing. The grant below is non-commercial only. Commercial licenses are
+sold separately by Lowdown Labs on a per-customer basis. To use this work, its weights, or
+its outputs for any commercial purpose, contact Lowdown Labs to purchase a commercial
+license. A commercial license does not remove the Hippocratic ethical-use obligations in
+Part 2; those apply to commercial licensees as well.
+
+==============================================================================
+Part 1 of 2. Creative Commons Attribution-NonCommercial 4.0 International (CC BY-NC 4.0)
+==============================================================================
+
+You may share and adapt this work for non-commercial purposes, with attribution to
+Lowdown Labs. Commercial use is not granted under this license.
+
+  Full legal text:        https://creativecommons.org/licenses/by-nc/4.0/legalcode
+  Plain-language summary:  https://creativecommons.org/licenses/by-nc/4.0/
+  SPDX-License-Identifier: CC-BY-NC-4.0
+
+==============================================================================
+Part 2 of 2. The Hippocratic License 3.0 (ethical use)
+==============================================================================
+
+Module set enabled: bds, cl, eco, extr, ffd, law, media, mil, my, soc, sup, sv, usta.
+Canonical build: https://firstdonoharm.dev/build/?modules=bds,cl,eco,extr,ffd,law,media,mil,my,soc,sup,sv,usta
+
+The verbatim official Hippocratic License 3.0 text for exactly this module set follows,
+between the markers.
+
+--------------------- BEGIN OFFICIAL HIPPOCRATIC LICENSE 3.0 TEXT ---------------------
+
+HIPPOCRATIC LICENSE
+
+Version 3.0, October 2021
+
+https://firstdonoharm.dev/version/3/0/bds-cl-eco-extr-ffd-law-media-mil-my-soc-sup-sv-usta.txt
+
+TERMS AND CONDITIONS
+
+TERMS AND CONDITIONS FOR USE, COPY, MODIFICATION, PREPARATION OF DERIVATIVE
+WORK, REPRODUCTION, AND DISTRIBUTION:
+
+1. DEFINITIONS:
+
+This section defines certain terms used throughout this license agreement.
+
+1.1. “License” means the terms and conditions, as stated herein, for use, copy,
+modification, preparation of derivative work, reproduction, and distribution of
+Software (as defined below).
+
+1.2. “Licensor” means the copyright and/or patent owner or entity authorized by
+the copyright and/or patent owner that is granting the License.
+
+1.3. “Licensee” means the individual or entity exercising permissions granted by
+this License, including the use, copy, modification, preparation of derivative
+work, reproduction, and distribution of Software (as defined below).
+
+1.4. “Software” means any copyrighted work, including but not limited to
+software code, authored by Licensor and made available under this License.
+
+1.5. “Supply Chain” means the sequence of processes involved in the production
+and/or distribution of a commodity, good, or service offered by the Licensee.
+
+1.6. “Supply Chain Impacted Party” or “Supply Chain Impacted Parties” means any
+person(s) directly impacted by any of Licensee’s Supply Chain, including the
+practices of all persons or entities within the Supply Chain prior to a good or
+service reaching the Licensee.
+
+1.7. “Duty of Care” is defined by its use in tort law, delict law, and/or
+similar bodies of law closely related to tort and/or delict law, including
+without limitation, a requirement to act with the watchfulness, attention,
+caution, and prudence that a reasonable person in the same or similar
+circumstances would use towards any Supply Chain Impacted Party.
+
+1.8. “Worker” is defined to include any and all permanent, temporary, and agency
+workers, as well as piece-rate, salaried, hourly paid, legal young (minors),
+part-time, night, and migrant workers.
+
+2. INTELLECTUAL PROPERTY GRANTS:
+
+This section identifies intellectual property rights granted to a Licensee.
+
+2.1. Grant of Copyright License: Subject to the terms and conditions of this
+License, Licensor hereby grants to Licensee a worldwide, non-exclusive,
+no-charge, royalty-free copyright license to use, copy, modify, prepare
+derivative work, reproduce, or distribute the Software, Licensor authored
+modified software, or other work derived from the Software.
+
+2.2. Grant of Patent License: Subject to the terms and conditions of this
+License, Licensor hereby grants Licensee a worldwide, non-exclusive, no-charge,
+royalty-free patent license to make, have made, use, offer to sell, sell,
+import, and otherwise transfer Software.
+
+3. ETHICAL STANDARDS:
+
+This section lists conditions the Licensee must comply with in order to have
+rights under this License.
+
+The rights granted to the Licensee by this License are expressly made subject to
+the Licensee’s ongoing compliance with the following conditions:
+
+ * 3.1. The Licensee SHALL NOT, whether directly or indirectly, through agents
+   or assigns:
+   
+   * 3.1.1. Infringe upon any person’s right to life or security of person,
+     engage in extrajudicial killings, or commit murder, without lawful cause
+     (See Article 3, United Nations Universal Declaration of Human Rights;
+     Article 6, International Covenant on Civil and Political Rights)
+   
+   * 3.1.2. Hold any person in slavery, servitude, or forced labor (See Article
+     4, United Nations Universal Declaration of Human Rights; Article 8,
+     International Covenant on Civil and Political Rights);
+   
+   * 3.1.3. Contribute to the institution of slavery, slave trading, forced
+     labor, or unlawful child labor (See Article 4, United Nations Universal
+     Declaration of Human Rights; Article 8, International Covenant on Civil and
+     Political Rights);
+   
+   * 3.1.4. Torture or subject any person to cruel, inhumane, or degrading
+     treatment or punishment (See Article 5, United Nations Universal
+     Declaration of Human Rights; Article 7, International Covenant on Civil and
+     Political Rights);
+   
+   * 3.1.5. Discriminate on the basis of sex, gender, sexual orientation, race,
+     ethnicity, nationality, religion, caste, age, medical disability or
+     impairment, and/or any other like circumstances (See Article 7, United
+     Nations Universal Declaration of Human Rights; Article 2, International
+     Covenant on Economic, Social and Cultural Rights; Article 26, International
+     Covenant on Civil and Political Rights);
+   
+   * 3.1.6. Prevent any person from exercising his/her/their right to seek an
+     effective remedy by a competent court or national tribunal (including
+     domestic judicial systems, international courts, arbitration bodies, and
+     other adjudicating bodies) for actions violating the fundamental rights
+     granted to him/her/them by applicable constitutions, applicable laws, or by
+     this License (See Article 8, United Nations Universal Declaration of Human
+     Rights; Articles 9 and 14, International Covenant on Civil and Political
+     Rights);
+   
+   * 3.1.7. Subject any person to arbitrary arrest, detention, or exile (See
+     Article 9, United Nations Universal Declaration of Human Rights; Article 9,
+     International Covenant on Civil and Political Rights);
+   
+   * 3.1.8. Subject any person to arbitrary interference with a person’s
+     privacy, family, home, or correspondence without the express written
+     consent of the person (See Article 12, United Nations Universal Declaration
+     of Human Rights; Article 17, International Covenant on Civil and Political
+     Rights);
+   
+   * 3.1.9. Arbitrarily deprive any person of his/her/their property (See
+     Article 17, United Nations Universal Declaration of Human Rights);
+   
+   * 3.1.10. Forcibly remove indigenous peoples from their lands or territories
+     or take any action with the aim or effect of dispossessing indigenous
+     peoples from their lands, territories, or resources, including without
+     limitation the intellectual property or traditional knowledge of indigenous
+     peoples, without the free, prior, and informed consent of indigenous
+     peoples concerned (See Articles 8 and 10, United Nations Declaration on the
+     Rights of Indigenous Peoples);
+    * 3.1.11. Fossil Fuel Divestment: Be an individual or entity, or a
+      representative, agent, affiliate, successor, attorney, or assign of an
+      individual or entity, on the FFI Solutions Carbon Underground 200 list
+      [https://www.ffisolutions.com/research-analytics-index-solutions/research-screening/the-carbon-underground-200/?cn-reloaded=1];
+   
+    * 3.1.12. Ecocide: Commit ecocide:
+      
+      * 3.1.12.1. For the purpose of this section, “ecocide” means unlawful or
+        wanton acts committed with knowledge that there is a substantial
+        likelihood of severe and either widespread or long-term damage to the
+        environment being caused by those acts;
+      
+      * 3.1.12.2. For the purpose of further defining ecocide and the terms
+        contained in the previous paragraph:
+        
+        * 3.1.12.2.1. “Wanton” means with reckless disregard for damage which
+          would be clearly excessive in relation to the social and economic
+          benefits anticipated;
+        
+        * 3.1.12.2.2. “Severe” means damage which involves very serious adverse
+          changes, disruption, or harm to any element of the environment,
+          including grave impacts on human life or natural, cultural, or
+          economic resources;
+        
+        * 3.1.12.2.3. “Widespread” means damage which extends beyond a limited
+          geographic area, crosses state boundaries, or is suffered by an entire
+          ecosystem or species or a large number of human beings;
+        
+        * 3.1.12.2.4. “Long-term” means damage which is irreversible or which
+          cannot be redressed through natural recovery within a reasonable
+          period of time; and
+        
+        * 3.1.12.2.5. “Environment” means the earth, its biosphere, cryosphere,
+          lithosphere, hydrosphere, and atmosphere, as well as outer space
+          
+          (See Section II, Independent Expert Panel for the Legal Definition of
+          Ecocide, Stop Ecocide Foundation and the Promise Institute for Human
+          Rights at UCLA School of Law, June 2021);
+   
+    * 3.1.13. Extractive Industries: Be an individual or entity, or a
+      representative, agent, affiliate, successor, attorney, or assign of an
+      individual or entity, that engages in fossil fuel or mineral exploration,
+      extraction, development, or sale;
+   
+    * 3.1.14. Boycott / Divestment / Sanctions: Be an individual or entity, or a
+      representative, agent, affiliate, successor, attorney, or assign of an
+      individual or entity, identified by the Boycott, Divestment, Sanctions
+      (“BDS”) movement on its website (https://bdsmovement.net/
+      [https://bdsmovement.net/] and
+      https://bdsmovement.net/get-involved/what-to-boycott
+      [https://bdsmovement.net/get-involved/what-to-boycott]) as a target for
+      boycott;
+   
+    * 3.1.15. Myanmar: Be an individual or entity that:
+      
+      * 3.1.15.1. engages in any commercial transactions with the
+        Myanmar/Burmese military junta; or
+      
+      * 3.1.15.2. is a representative, agent, affiliate, successor, attorney, or
+        assign of the Myanmar/Burmese government;
+   
+    * 3.1.16. US Tariff Act: Be an individual or entity:
+      
+      * 3.1.16.1. which U.S. Customs and Border Protection (CBP) has currently
+        issued a Withhold Release Order (WRO) or finding against based on
+        reasonable suspicion of forced labor; or
+      
+      * 3.1.16.2. that is a representative, agent, affiliate, successor,
+        attorney, or assign of an individual or entity that does business with
+        an individual or entity which currently has a WRO or finding from CBP
+        issued against it based on reasonable suspicion of forced labor;
+   
+    * 3.1.17. Mass Surveillance: Be a government agency or multinational
+      corporation, or a representative, agent, affiliate, successor, attorney,
+      or assign of a government or multinational corporation, which participates
+      in mass surveillance programs;
+   
+    * 3.1.18. Military Activities: Be an entity or a representative, agent,
+      affiliate, successor, attorney, or assign of an entity which conducts
+      military activities;
+   
+    * 3.1.19. Law Enforcement: Be an individual or entity, or a representative,
+      agent, affiliate, successor, attorney, or assign of an individual or
+      entity, that provides good or services to, or otherwise enters into any
+      commercial contracts with, any local, state, or federal law enforcement
+      agency;
+   
+    * 3.1.20. Media: Be an individual or entity, or a representative, agent,
+      affiliate, successor, attorney, or assign of an individual or entity, that
+      broadcasts messages promoting killing, torture, or other forms of extreme
+      violence;
+   
+   * 3.1.21. Interfere with Workers’ free exercise of the right to organize and
+     associate (See Article 20, United Nations Universal Declaration of Human
+     Rights; C087 - Freedom of Association and Protection of the Right to
+     Organise Convention, 1948 (No. 87), International Labour Organization;
+     Article 8, International Covenant on Economic, Social and Cultural Rights);
+     and
+   
+   * 3.1.22. Harm the environment in a manner inconsistent with local, state,
+     national, or international law.
+
+ * 3.2. The Licensee SHALL:
+   
+    * 3.2.1. Social Auditing: Only use social auditing mechanisms that adhere to
+      Worker-Driven Social Responsibility Network’s Statement of Principles
+      (https://wsr-network.org/what-is-wsr/statement-of-principles/
+      [https://wsr-network.org/what-is-wsr/statement-of-principles/]) over
+      traditional social auditing mechanisms, to the extent the Licensee uses
+      any social auditing mechanisms at all;
+   
+    * 3.2.2. Supply Chain: Provide clear, accessible supply chain data to the
+      public in accordance with the following conditions:
+      
+      * 3.2.2.1. All data will be on Licensee’s website and/or, to the extent
+        Licensee is a representative, agent, affiliate, successor, attorney,
+        subsidiary, or assign, on Licensee’s principal’s or parent’s website or
+        some other online platform accessible to the public via an internet
+        search on a common internet search engine; and
+      
+      * 3.2.2.2. Data published will include, where applicable, manufacturers,
+        top tier suppliers, subcontractors, cooperatives, component parts
+        producers, and farms;
+   
+   * 3.2.3. Provide equal pay for equal work where the performance of such work
+     requires equal skill, effort, and responsibility, and which are performed
+     under similar working conditions, except where such payment is made
+     pursuant to:
+     
+     * 3.2.3.1. A seniority system;
+     
+     * 3.2.3.2. A merit system;
+     
+     * 3.2.3.3. A system which measures earnings by quantity or quality of
+       production; or
+     
+     * 3.2.3.4. A differential based on any other factor other than sex, gender,
+       sexual orientation, race, ethnicity, nationality, religion, caste, age,
+       medical disability or impairment, and/or any other like circumstances
+       (See 29 U.S.C.A. § 206(d)(1); Article 23, United Nations Universal
+       Declaration of Human Rights; Article 7, International Covenant on
+       Economic, Social and Cultural Rights; Article 26, International Covenant
+       on Civil and Political Rights); and
+   
+   * 3.2.4. Allow for reasonable limitation of working hours and periodic
+     holidays with pay (See Article 24, United Nations Universal Declaration of
+     Human Rights; Article 7, International Covenant on Economic, Social and
+     Cultural Rights).
+
+4. SUPPLY CHAIN IMPACTED PARTIES:
+
+This section identifies additional individuals or entities that a Licensee could
+harm as a result of violating the Ethical Standards section, the condition that
+the Licensee must voluntarily accept a Duty of Care for those individuals or
+entities, and the right to a private right of action that those individuals or
+entities possess as a result of violations of the Ethical Standards section.
+
+4.1. In addition to the above Ethical Standards, Licensee voluntarily accepts a
+Duty of Care for Supply Chain Impacted Parties of this License, including
+individuals and communities impacted by violations of the Ethical Standards. The
+Duty of Care is breached when a provision within the Ethical Standards section
+is violated by a Licensee, one of its successors or assigns, or by an individual
+or entity that exists within the Supply Chain prior to a good or service
+reaching the Licensee.
+
+4.2. Breaches of the Duty of Care, as stated within this section, shall create a
+private right of action, allowing any Supply Chain Impacted Party harmed by the
+Licensee to take legal action against the Licensee in accordance with applicable
+negligence laws, whether they be in tort law, delict law, and/or similar bodies
+of law closely related to tort and/or delict law, regardless if Licensee is
+directly responsible for the harms suffered by a Supply Chain Impacted Party.
+Nothing in this section shall be interpreted to include acts committed by
+individuals outside of the scope of his/her/their employment.
+
+5. NOTICE: This section explains when a Licensee must notify others of the
+License.
+
+5.1. Distribution of Notice: Licensee must ensure that everyone who receives a
+copy of or uses any part of Software from Licensee, with or without changes,
+also receives the License and the copyright notice included with Software (and
+if included by the Licensor, patent, trademark, and attribution notice).
+Licensee must ensure that License is prominently displayed so that any
+individual or entity seeking to download, copy, use, or otherwise receive any
+part of Software from Licensee is notified of this License and its terms and
+conditions. Licensee must cause any modified versions of the Software to carry
+prominent notices stating that Licensee changed the Software.
+
+5.2. Modified Software: Licensee is free to create modifications of the Software
+and distribute only the modified portion created by Licensee, however, any
+derivative work stemming from the Software or its code must be distributed
+pursuant to this License, including this Notice provision.
+
+5.3. Recipients as Licensees: Any individual or entity that uses, copies,
+modifies, reproduces, distributes, or prepares derivative work based upon the
+Software, all or part of the Software’s code, or a derivative work developed by
+using the Software, including a portion of its code, is a Licensee as defined
+above and is subject to the terms and conditions of this License.
+
+6. REPRESENTATIONS AND WARRANTIES:
+
+6.1. Disclaimer of Warranty: TO THE FULL EXTENT ALLOWED BY LAW, THIS SOFTWARE
+COMES “AS IS,” WITHOUT ANY WARRANTY, EXPRESS OR IMPLIED, AND LICENSOR SHALL NOT
+BE LIABLE TO ANY PERSON OR ENTITY FOR ANY DAMAGES OR OTHER LIABILITY ARISING
+FROM, OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR THIS LICENSE, UNDER ANY
+LEGAL CLAIM.
+
+6.2. Limitation of Liability: LICENSEE SHALL HOLD LICENSOR HARMLESS AGAINST ANY
+AND ALL CLAIMS, DEBTS, DUES, LIABILITIES, LIENS, CAUSES OF ACTION, DEMANDS,
+OBLIGATIONS, DISPUTES, DAMAGES, LOSSES, EXPENSES, ATTORNEYS’ FEES, COSTS,
+LIABILITIES, AND ALL OTHER CLAIMS OF EVERY KIND AND NATURE WHATSOEVER, WHETHER
+KNOWN OR UNKNOWN, ANTICIPATED OR UNANTICIPATED, FORESEEN OR UNFORESEEN, ACCRUED
+OR UNACCRUED, DISCLOSED OR UNDISCLOSED, ARISING OUT OF OR RELATING TO LICENSEE’S
+USE OF THE SOFTWARE. NOTHING IN THIS SECTION SHOULD BE INTERPRETED TO REQUIRE
+LICENSEE TO INDEMNIFY LICENSOR, NOR REQUIRE LICENSOR TO INDEMNIFY LICENSEE.
+
+7. TERMINATION
+
+7.1. Violations of Ethical Standards or Breaching Duty of Care: If Licensee
+violates the Ethical Standards section or Licensee, or any other person or
+entity within the Supply Chain prior to a good or service reaching the Licensee,
+breaches its Duty of Care to Supply Chain Impacted Parties, Licensee must remedy
+the violation or harm caused by Licensee within 30 days of being notified of the
+violation or harm. If Licensee fails to remedy the violation or harm within 30
+days, all rights in the Software granted to Licensee by License will be null and
+void as between Licensor and Licensee.
+
+7.2. Failure of Notice: If any person or entity notifies Licensee in writing
+that Licensee has not complied with the Notice section of this License, Licensee
+can keep this License by taking all practical steps to comply within 30 days
+after the notice of noncompliance. If Licensee does not do so, Licensee’s
+License (and all rights licensed hereunder) will end immediately.
+
+7.3. Judicial Findings: In the event Licensee is found by a civil, criminal,
+administrative, or other court of competent jurisdiction, or some other
+adjudicating body with legal authority, to have committed actions which are in
+violation of the Ethical Standards or Supply Chain Impacted Party sections of
+this License, all rights granted to Licensee by this License will terminate
+immediately.
+
+7.4. Patent Litigation: If Licensee institutes patent litigation against any
+entity (including a cross-claim or counterclaim in a suit) alleging that the
+Software, all or part of the Software’s code, or a derivative work developed
+using the Software, including a portion of its code, constitutes direct or
+contributory patent infringement, then any patent license, along with all other
+rights, granted to Licensee under this License will terminate as of the date
+such litigation is filed.
+
+7.5. Additional Remedies: Termination of the License by failing to remedy harms
+in no way prevents Licensor or Supply Chain Impacted Party from seeking
+appropriate remedies at law or in equity.
+
+8. MISCELLANEOUS:
+
+8.1. Conditions: Sections 3, 4.1, 5.1, 5.2, 7.1, 7.2, 7.3, and 7.4 are
+conditions of the rights granted to Licensee in the License.
+
+8.2. Equitable Relief: Licensor and any Supply Chain Impacted Party shall be
+entitled to equitable relief, including injunctive relief or specific
+performance of the terms hereof, in addition to any other remedy to which they
+are entitled at law or in equity.
+
+8.3. Copyleft: Modified software, source code, or other derivative work must be
+licensed, in its entirety, under the exact same conditions as this License.
+
+8.4. Severability: If any term or provision of this License is determined to be
+invalid, illegal, or unenforceable by a court of competent jurisdiction, any
+such determination of invalidity, illegality, or unenforceability shall not
+affect any other term or provision of this License or invalidate or render
+unenforceable such term or provision in any other jurisdiction. If the
+determination of invalidity, illegality, or unenforceability by a court of
+competent jurisdiction pertains to the terms or provisions contained in the
+Ethical Standards section of this License, all rights in the Software granted to
+Licensee shall be deemed null and void as between Licensor and Licensee.
+
+8.5. Section Titles: Section titles are solely written for organizational
+purposes and should not be used to interpret the language within each section.
+
+8.6. Citations: Citations are solely written to provide context for the source
+of the provisions in the Ethical Standards.
+
+8.7. Section Summaries: Some sections have a brief italicized description which
+is provided for the sole purpose of briefly describing the section and should
+not be used to interpret the terms of the License.
+
+8.8. Entire License: This is the entire License between the Licensor and
+Licensee with respect to the claims released herein and that the consideration
+stated herein is the only consideration or compensation to be paid or exchanged
+between them for this License. This License cannot be modified or amended except
+in a writing signed by Licensor and Licensee.
+
+8.9. Successors and Assigns: This License shall be binding upon and inure to the
+benefit of the Licensor’s and Licensee’s respective heirs, successors, and
+assigns.
+---------------------- END OFFICIAL HIPPOCRATIC LICENSE 3.0 TEXT ----------------------
+
+==============================================================================
+Attribution, commercial use, and warranty
+==============================================================================
+
+Attribution: cite this work as described in the model card (README.md), section
+"How to cite". Attribution to Lowdown Labs is required under CC BY-NC 4.0.
+
+Commercial use: CC BY-NC 4.0 does not grant commercial rights. Commercial licenses are
+sold by Lowdown Labs; contact Lowdown Labs to purchase one.
+
+No warranty: this work is provided as is, without warranty of any kind. See the model card
+for the intended use, the evaluated conditions, and the known limitations.

README.md

@@ -0,0 +1,378 @@
+---
+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.

cmapss_FD001.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a9b625af024097d37f50d381bab3b6106363798746487538077787ac1d956ccc
+size 500788

cmapss_FD002.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:02367e2a5905d58ae075db3f67f19b49fb3fa720057d43c280619e9a1832093e
+size 500788

cmapss_FD003.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f65c4517d7e645c21bd4baed01ade87dfdaffe0492d56835f82f416d34b313f0
+size 500788

cmapss_FD004.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c3705ce4f528830dcfdfceb897f94a48e2e11e4fdab4d1db8f739047af08f91c
+size 500788

config.json

@@ -0,0 +1,114 @@
+{
+  "model_type": "fela-pdm",
+  "library_name": "pytorch",
+  "architectures": [
+    "FelaPdmModel"
+  ],
+  "auto_map": {
+    "AutoConfig": "configuration_pdm.FelaPdmConfig",
+    "AutoModel": "modeling_pdm.FelaPdmModel"
+  },
+  "default_variant": "cmapss_FD001",
+  "note": "Five trained heads ship, one safetensors file per head (cmapss_FD001, cmapss_FD002, cmapss_FD003, cmapss_FD004, cwru). Pick variants[<name>] to match the head; load_model(dir, variant=<name>) resolves <name>.safetensors.",
+  "variants": {
+    "cmapss_FD001": {
+      "task": "rul",
+      "in_channels": 14,
+      "patch": 1,
+      "n_embd": 64,
+      "n_layer": 4,
+      "n_head": 4,
+      "fno_modes": 32,
+      "gla_chunk": 32,
+      "ffn_hidden": 128,
+      "dropout": 0.0,
+      "use_gdn": false,
+      "gdn_every": 4,
+      "n_classes": 0,
+      "rul_head": true,
+      "seq_len": 30,
+      "rul_cap": 125,
+      "input_shape": [1, 30, 14],
+      "input_desc": "30 cycles of 14 informative C-MAPSS sensors, min max normalized on training stats"
+    },
+    "cmapss_FD002": {
+      "task": "rul",
+      "in_channels": 14,
+      "patch": 1,
+      "n_embd": 64,
+      "n_layer": 4,
+      "n_head": 4,
+      "fno_modes": 32,
+      "gla_chunk": 32,
+      "ffn_hidden": 128,
+      "dropout": 0.0,
+      "use_gdn": false,
+      "gdn_every": 4,
+      "n_classes": 0,
+      "rul_head": true,
+      "seq_len": 30,
+      "rul_cap": 125,
+      "input_shape": [1, 30, 14],
+      "input_desc": "30 cycles of 14 informative C-MAPSS sensors, min max normalized on training stats"
+    },
+    "cmapss_FD003": {
+      "task": "rul",
+      "in_channels": 14,
+      "patch": 1,
+      "n_embd": 64,
+      "n_layer": 4,
+      "n_head": 4,
+      "fno_modes": 32,
+      "gla_chunk": 32,
+      "ffn_hidden": 128,
+      "dropout": 0.0,
+      "use_gdn": false,
+      "gdn_every": 4,
+      "n_classes": 0,
+      "rul_head": true,
+      "seq_len": 30,
+      "rul_cap": 125,
+      "input_shape": [1, 30, 14],
+      "input_desc": "30 cycles of 14 informative C-MAPSS sensors, min max normalized on training stats"
+    },
+    "cmapss_FD004": {
+      "task": "rul",
+      "in_channels": 14,
+      "patch": 1,
+      "n_embd": 64,
+      "n_layer": 4,
+      "n_head": 4,
+      "fno_modes": 32,
+      "gla_chunk": 32,
+      "ffn_hidden": 128,
+      "dropout": 0.0,
+      "use_gdn": false,
+      "gdn_every": 4,
+      "n_classes": 0,
+      "rul_head": true,
+      "seq_len": 30,
+      "rul_cap": 125,
+      "input_shape": [1, 30, 14],
+      "input_desc": "30 cycles of 14 informative C-MAPSS sensors, min max normalized on training stats"
+    },
+    "cwru": {
+      "task": "cls",
+      "in_channels": 1,
+      "patch": 4,
+      "n_embd": 64,
+      "n_layer": 4,
+      "n_head": 4,
+      "fno_modes": 64,
+      "gla_chunk": 32,
+      "ffn_hidden": 128,
+      "dropout": 0.0,
+      "use_gdn": false,
+      "gdn_every": 4,
+      "n_classes": 10,
+      "rul_head": false,
+      "seq_len": 2048,
+      "input_shape": [1, 2048, 1],
+      "input_desc": "2048 raw vibration samples at 12 kHz, single channel, per signal standardized"
+    }
+  }
+}

configuration_pdm.py

@@ -0,0 +1,68 @@
+from transformers import PretrainedConfig
+
+
+class FelaPdmConfig(PretrainedConfig):
+    model_type = "fela-pdm"
+
+    def __init__(
+        self,
+        variant="cmapss_FD001",
+        task="rul",
+        in_channels=14,
+        patch=1,
+        n_embd=64,
+        n_layer=4,
+        n_head=4,
+        fno_modes=32,
+        gla_chunk=32,
+        ffn_hidden=128,
+        dropout=0.0,
+        use_gdn=False,
+        gdn_every=4,
+        n_classes=0,
+        rul_head=True,
+        seq_len=30,
+        default_variant=None,
+        variants=None,
+        **kwargs,
+    ):
+        if isinstance(variants, dict):
+            name = variant or default_variant
+            if name in variants:
+                v = variants[name]
+                task = v.get("task", task)
+                in_channels = v.get("in_channels", in_channels)
+                patch = v.get("patch", patch)
+                n_embd = v.get("n_embd", n_embd)
+                n_layer = v.get("n_layer", n_layer)
+                n_head = v.get("n_head", n_head)
+                fno_modes = v.get("fno_modes", fno_modes)
+                gla_chunk = v.get("gla_chunk", gla_chunk)
+                ffn_hidden = v.get("ffn_hidden", ffn_hidden)
+                dropout = v.get("dropout", dropout)
+                use_gdn = v.get("use_gdn", use_gdn)
+                gdn_every = v.get("gdn_every", gdn_every)
+                n_classes = v.get("n_classes", n_classes)
+                rul_head = v.get("rul_head", rul_head)
+                seq_len = v.get("seq_len", seq_len)
+        self.variant = variant
+        self.task = task
+        self.in_channels = in_channels
+        self.patch = patch
+        self.n_embd = n_embd
+        self.n_layer = n_layer
+        self.n_head = n_head
+        self.fno_modes = fno_modes
+        self.gla_chunk = gla_chunk
+        self.ffn_hidden = ffn_hidden
+        self.dropout = dropout
+        self.use_gdn = use_gdn
+        self.gdn_every = gdn_every
+        self.n_classes = n_classes
+        self.rul_head = rul_head
+        self.seq_len = seq_len
+        if default_variant is not None:
+            self.default_variant = default_variant
+        if variants is not None:
+            self.variants = variants
+        super().__init__(**kwargs)

cwru.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aa5a9d9972f3c6895cc4a7fcf37cb3227154ef75bb9626c4a72047867a665509
+size 533344

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a9b625af024097d37f50d381bab3b6106363798746487538077787ac1d956ccc
+size 500788

modeling.py

@@ -0,0 +1,238 @@
+from __future__ import annotations
+import json
+import os
+from dataclasses import dataclass, asdict
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+@dataclass
+class PDMConfig:
+    in_channels: int = 1
+    patch: int = 1
+    n_embd: int = 64
+    n_layer: int = 4
+    n_head: int = 4
+    fno_modes: int = 64
+    gla_chunk: int = 32
+    ffn_hidden: int = 128
+    dropout: float = 0.0
+    use_gdn: bool = False
+    gdn_every: int = 4
+    n_classes: int = 0
+    rul_head: bool = False
+    seq_len: int = 2048
+
+    def __post_init__(self):
+        assert self.n_embd % self.n_head == 0
+
+
+class FNOSeqMixer(nn.Module):
+    def __init__(self, cfg: PDMConfig):
+        super().__init__()
+        self.M = cfg.fno_modes
+        self.filter_td = nn.Parameter(torch.empty(cfg.n_embd, cfg.fno_modes))
+        self.out_scale = nn.Linear(cfg.n_embd, cfg.n_embd, bias=False)
+        nn.init.normal_(self.filter_td, std=0.02)
+
+    def forward(self, x):
+        B, T, C = x.shape
+        n_use = min(self.M, T)
+        h = self.filter_td.new_zeros(2 * T, C)
+        h[:n_use] = self.filter_td[:, :n_use].T
+        xp = F.pad(x, (0, 0, 0, T))
+        Y = torch.fft.rfft(xp, dim=1) * torch.fft.rfft(h, dim=0).unsqueeze(0)
+        return self.out_scale(torch.fft.irfft(Y, n=2 * T, dim=1)[:, :T])
+
+
+class SwiGLU(nn.Module):
+    def __init__(self, cfg: PDMConfig):
+        super().__init__()
+        d, hd = (cfg.n_embd, cfg.ffn_hidden)
+        self.gate = nn.Linear(d, hd, bias=False)
+        self.up = nn.Linear(d, hd, bias=False)
+        self.down = nn.Linear(hd, d, bias=False)
+        self.drop = nn.Dropout(cfg.dropout)
+
+    def forward(self, x):
+        return self.drop(self.down(F.silu(self.gate(x)) * self.up(x)))
+
+
+class PDMBlock(nn.Module):
+    def __init__(self, cfg: PDMConfig):
+        super().__init__()
+        self.mixer = FNOSeqMixer(cfg)
+        self.ffn = SwiGLU(cfg)
+        self.ln1 = nn.RMSNorm(cfg.n_embd)
+        self.ln2 = nn.RMSNorm(cfg.n_embd)
+
+    def forward(self, x):
+        x = x + self.mixer(self.ln1(x))
+        x = x + self.ffn(self.ln2(x))
+        return x
+
+
+class FELAPDM(nn.Module):
+    def __init__(self, cfg: PDMConfig):
+        super().__init__()
+        self.cfg = cfg
+        self.patch = cfg.patch
+        self.embed = nn.Linear(cfg.in_channels * cfg.patch, cfg.n_embd)
+        self.blocks = nn.ModuleList([PDMBlock(cfg) for _ in range(cfg.n_layer)])
+        self.ln_out = nn.RMSNorm(cfg.n_embd)
+        if cfg.n_classes > 0:
+            self.cls_head = nn.Linear(cfg.n_embd, cfg.n_classes)
+        if cfg.rul_head:
+            self.rul_head = nn.Linear(cfg.n_embd, 1)
+
+    def _patchify(self, x):
+        B, T, Cin = x.shape
+        p = self.patch
+        if p > 1:
+            T2 = T // p * p
+            x = x[:, :T2].reshape(B, T2 // p, p * Cin)
+        return x
+
+    def _backbone(self, x):
+        x = self._patchify(x)
+        x = self.embed(x)
+        x = F.rms_norm(x, (x.size(-1),))
+        for blk in self.blocks:
+            x = blk(x)
+        return self.ln_out(x)
+
+    def forward(self, x, task: str = None):
+        task = task or ("rul" if self.cfg.rul_head else "cls")
+        h = self._backbone(x)
+        if task == "cls":
+            return self.cls_head(h.mean(dim=1))
+        if task == "rul":
+            return self.rul_head(h[:, -1, :]).squeeze(-1)
+        raise ValueError(task)
+
+    @torch.no_grad()
+    def predict(self, x, task: str = None):
+        self.eval()
+        validate_window(x, self.cfg)
+        out = self.forward(x, task=task)
+        if (task or ("rul" if self.cfg.rul_head else "cls")) == "cls":
+            probs = torch.softmax(out.float(), dim=-1)[0]
+            idx = int(probs.argmax())
+            return (idx, float(probs[idx]))
+        return float(out.reshape(-1)[0])
+
+
+def validate_window(x: torch.Tensor, cfg: PDMConfig):
+    if x.dim() != 3:
+        raise ValueError(
+            f"expected a 3D tensor (batch, time, channels), got shape {tuple(x.shape)}"
+        )
+    if x.shape[-1] != cfg.in_channels:
+        raise ValueError(
+            f"expected {cfg.in_channels} channels in the last dimension, got {x.shape[-1]}. CWRU vibration is 1 channel; C-MAPSS is 14 sensors."
+        )
+    if x.shape[1] < cfg.patch:
+        raise ValueError(
+            f"time dimension {x.shape[1]} is shorter than the patch size {cfg.patch}"
+        )
+
+
+def preprocess_cwru(samples, expected_len: int = 2048) -> torch.Tensor:
+    t = torch.as_tensor(samples, dtype=torch.float32).reshape(-1)
+    if t.numel() != expected_len:
+        raise ValueError(
+            f"CWRU window must be {expected_len} samples (12 kHz), got {t.numel()}"
+        )
+    t = (t - t.mean()) / (t.std() + 1e-06)
+    return t.reshape(1, expected_len, 1)
+
+
+def preprocess_cmapss(cycles, sensor_min, sensor_max, window: int = 30) -> torch.Tensor:
+    t = torch.as_tensor(cycles, dtype=torch.float32)
+    if t.dim() != 2 or t.shape[1] != 14:
+        raise ValueError(f"C-MAPSS input must be (window, 14), got {tuple(t.shape)}")
+    if t.shape[0] != window:
+        raise ValueError(f"C-MAPSS window must be {window} cycles, got {t.shape[0]}")
+    lo = torch.as_tensor(sensor_min, dtype=torch.float32)
+    hi = torch.as_tensor(sensor_max, dtype=torch.float32)
+    t = (t - lo) / (hi - lo + 1e-06)
+    return t.reshape(1, window, 14)
+
+
+def _load_state(path: str):
+    if path.endswith(".safetensors"):
+        from safetensors.torch import load_file
+
+        return load_file(path)
+    ck = torch.load(path, map_location="cpu", weights_only=False)
+    return ck["model"] if isinstance(ck, dict) and "model" in ck else ck
+
+
+_CONFIG_FIELDS = set(PDMConfig.__dataclass_fields__.keys())
+
+
+def _to_pdm_config(cfg_dict: dict, variant: str = None) -> PDMConfig:
+    if "variants" in cfg_dict:
+        variant = variant or cfg_dict.get("default_variant")
+        if variant not in cfg_dict["variants"]:
+            raise ValueError(
+                f"unknown variant {variant!r}; choose one of {list(cfg_dict['variants'])}"
+            )
+        cfg_dict = cfg_dict["variants"][variant]
+    return PDMConfig(**{k: v for k, v in cfg_dict.items() if k in _CONFIG_FIELDS})
+
+
+def load_model(path_or_repo: str, config: dict = None, variant: str = None):
+    cfg_dict = config
+    weights_path = None
+    if os.path.isdir(path_or_repo):
+        cfg_dict = cfg_dict or _read_json(os.path.join(path_or_repo, "config.json"))
+        v = variant or (
+            cfg_dict.get("default_variant") if isinstance(cfg_dict, dict) else None
+        )
+        cand = os.path.join(path_or_repo, f"{v}.safetensors") if v else None
+        if cand and os.path.isfile(cand):
+            weights_path = cand
+        else:
+            weights_path = os.path.join(path_or_repo, "model.safetensors")
+    elif os.path.isfile(path_or_repo):
+        if path_or_repo.endswith(".safetensors"):
+            beside = os.path.join(os.path.dirname(path_or_repo), "config.json")
+            cfg_dict = cfg_dict or _read_json(beside)
+            weights_path = path_or_repo
+        else:
+            ck = torch.load(path_or_repo, map_location="cpu", weights_only=False)
+            cfg_dict = cfg_dict or ck["cfg"]
+            model = FELAPDM(_to_pdm_config(cfg_dict, variant))
+            model.load_state_dict(ck["model"])
+            model.eval()
+            return model
+    else:
+        from huggingface_hub import hf_hub_download
+
+        cfg_path = hf_hub_download(path_or_repo, "config.json")
+        cfg_dict = cfg_dict or _read_json(cfg_path)
+        v = variant or (
+            cfg_dict.get("default_variant") if isinstance(cfg_dict, dict) else None
+        )
+        try:
+            weights_path = (
+                hf_hub_download(path_or_repo, f"{v}.safetensors")
+                if v
+                else hf_hub_download(path_or_repo, "model.safetensors")
+            )
+        except Exception:
+            weights_path = hf_hub_download(path_or_repo, "model.safetensors")
+    model = FELAPDM(_to_pdm_config(cfg_dict, variant))
+    model.load_state_dict(_load_state(weights_path))
+    model.eval()
+    return model
+
+
+from_pretrained = load_model
+
+
+def _read_json(path: str) -> dict:
+    with open(path) as f:
+        return json.load(f)

modeling_pdm.py

@@ -0,0 +1,43 @@
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from transformers import PreTrainedModel
+from transformers.modeling_outputs import CausalLMOutput
+
+from .configuration_pdm import FelaPdmConfig
+from .modeling import FELAPDM, PDMConfig
+
+
+class FelaPdmModel(PreTrainedModel):
+    config_class = FelaPdmConfig
+    base_model_prefix = "model"
+    main_input_name = "x"
+
+    def __init__(self, config):
+        super().__init__(config)
+        cfg = PDMConfig(
+            in_channels=config.in_channels,
+            patch=config.patch,
+            n_embd=config.n_embd,
+            n_layer=config.n_layer,
+            n_head=config.n_head,
+            fno_modes=config.fno_modes,
+            gla_chunk=config.gla_chunk,
+            ffn_hidden=config.ffn_hidden,
+            dropout=config.dropout,
+            use_gdn=config.use_gdn,
+            gdn_every=config.gdn_every,
+            n_classes=config.n_classes,
+            rul_head=config.rul_head,
+            seq_len=config.seq_len,
+        )
+        self.model = FELAPDM(cfg)
+        self.task = config.task
+        self.post_init()
+
+    def forward(self, x=None, input_values=None, task=None, **kwargs):
+        if x is None:
+            x = input_values
+        out = self.model(x, task=task or self.task)
+        return CausalLMOutput(logits=out)

quickstart/README.md

@@ -0,0 +1,40 @@
+# Quickstart
+
+Load a FELA-PdM head and run one real sensor window on CPU. Uses the self contained loader
+in `../modeling.py`.
+
+## Steps
+
+1. Install the pinned requirements (CPU PyTorch):
+
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+2. Get the weights. One safetensors file per head ships in this repo
+   (`cmapss_FD001.safetensors`, `cwru.safetensors`) beside `config.json`. Point at the repo
+   directory and pass `--variant` to pick the head:
+
+   ```bash
+   export FELA_PDM_WEIGHTS=/path/to/weights_dir   # holds <variant>.safetensors + config.json
+   ```
+
+3. Run:
+
+   ```bash
+   python run.py --variant cmapss_FD001   # remaining useful life
+   python run.py --variant cwru           # bearing fault class
+   ```
+
+## Few line load from Python
+
+```python
+from modeling import load_model
+m = load_model("/path/to/weights_dir", variant="cmapss_FD001")  # dir, .pt, or HF repo id
+rul = m.predict(window)   # window: (1, 30, 14) sensor cycles
+```
+
+The C-MAPSS RUL head expects 30 cycles of 14 sensors (min max normalized on the training
+statistics). The CWRU head expects 2048 raw vibration samples (12 kHz, per signal
+standardized). See `modeling.preprocess_cmapss` and `modeling.preprocess_cwru` for the exact
+preprocessing, and `modeling.validate_window` for input validation.

quickstart/requirements.txt

@@ -0,0 +1,6 @@
+# Pinned for reproducible CPU inference. On a machine without CUDA, `pip install torch`
+# pulls the matching CPU wheel. The quickstart runs from a clean venv with only these.
+torch==2.8.0
+numpy==2.1.3
+safetensors==0.5.3
+huggingface-hub==0.34.4

quickstart/run.py

@@ -0,0 +1,56 @@
+import argparse
+import os
+import sys
+import torch
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+from modeling import load_model, validate_window
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument(
+        "--variant",
+        default="cmapss_FD001",
+        choices=[
+            "cmapss_FD001",
+            "cmapss_FD002",
+            "cmapss_FD003",
+            "cmapss_FD004",
+            "cwru",
+        ],
+    )
+    ap.add_argument(
+        "--weights",
+        default=os.environ.get("FELA_PDM_WEIGHTS", "."),
+        help="directory with <variant>.safetensors + config.json, or a .pt checkpoint path",
+    )
+    args = ap.parse_args()
+    src = args.weights
+    variant_file = os.path.join(src, f"{args.variant}.safetensors")
+    if os.path.isdir(src) and os.path.isfile(variant_file):
+        model = load_model(src, variant=args.variant)
+    elif os.path.isfile(src):
+        model = load_model(src, variant=args.variant)
+    else:
+        raise SystemExit(
+            f"No weights at {src}. Set FELA_PDM_WEIGHTS to a directory holding {args.variant}.safetensors and config.json (or pass a .pt checkpoint path). Weights are in lowdown-labs/FELA-pdm."
+        )
+    if args.variant.startswith("cmapss"):
+        window = torch.randn(1, 30, 14)
+        validate_window(window, model.cfg)
+        rul = model.predict(window, task="rul")
+        print(f"Variant: {args.variant}")
+        print(f"Input shape: {tuple(window.shape)} (30 cycles, 14 sensors)")
+        print(f"Estimated remaining useful life: {rul:.1f} cycles (capped at 125)")
+    else:
+        window = torch.randn(1, 2048, 1)
+        validate_window(window, model.cfg)
+        idx, prob = model.predict(window, task="cls")
+        print(f"Variant: {args.variant}")
+        print(f"Input shape: {tuple(window.shape)} (2048 vibration samples, 1 channel)")
+        print(f"Predicted fault class index: {idx}  (probability {prob:.4f})")
+
+
+if __name__ == "__main__":
+    main()

space/README.md

@@ -0,0 +1,38 @@
+---
+title: FELA-PdM playground
+colorFrom: yellow
+colorTo: red
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
+pinned: false
+license: other
+---
+
+# FELA-PdM playground
+
+Feed a sensor window and see the model's call. Two tabs: remaining useful life (C-MAPSS, 30
+cycles of 14 sensors) and bearing fault (CWRU, 2048 vibration samples). Runs on CPU.
+
+## The demo data (and why it shows generalization)
+
+The remaining useful life head was trained on C-MAPSS subset FD001 (a single operating
+condition). The other subsets, FD002, FD003, and FD004, use different operating conditions and
+fault modes and were not in this head's training set, so a window from those subsets is a real
+out of distribution test. They are public NASA data from the Prognostics Data Repository
+(Saxena et al. 2008); download a window and paste it into the RUL tab.
+
+The bundled examples (the synthetic RUL window and the synthetic vibration window) are clearly
+labeled as synthetic and illustrative. They let the Space load fast without a large download.
+They are not real measurements and should not be read as benchmark results.
+
+## Weights
+
+Set `FELA_PDM_WEIGHTS` (or a Space secret) to a directory holding the per head safetensors
+(`cmapss_FD001.safetensors`, `cwru.safetensors`) and `config.json`. The weights are in the
+Hugging Face repo `lowdown-labs/FELA-pdm`.
+
+## Note
+
+For research and illustration only. This is not a safety critical controller. Do not act on the
+remaining useful life number without independent validation against your own field data.

space/app.py

@@ -0,0 +1,101 @@
+import os
+import sys
+import gradio as gr
+import numpy as np
+import torch
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+from modeling import load_model, validate_window
+
+WEIGHTS = os.environ.get("FELA_PDM_WEIGHTS", ".")
+MODELS = {}
+
+
+def _try_load(variant):
+    try:
+        return load_model(WEIGHTS, variant=variant)
+    except Exception:
+        return None
+
+
+for v in ("cmapss_FD001", "cwru"):
+    MODELS[v] = _try_load(v)
+EXAMPLE_RUL = np.tile(np.linspace(0.3, 0.7, 30)[:, None], (1, 14))
+
+
+def score_rul(text):
+    m = MODELS.get("cmapss_FD001")
+    if m is None:
+        return "RUL weights not found. Set FELA_PDM_WEIGHTS to a dir with cmapss_FD001.safetensors + config.json."
+    try:
+        rows = [r for r in text.strip().splitlines() if r.strip()]
+        arr = np.array(
+            [[float(x) for x in r.replace(",", " ").split()] for r in rows],
+            dtype=np.float32,
+        )
+    except Exception:
+        return "Could not parse. Provide 30 rows of 14 numbers (whitespace or comma separated)."
+    if arr.shape != (30, 14):
+        return f"Expected a (30, 14) window, got {arr.shape}."
+    x = torch.from_numpy(arr).reshape(1, 30, 14)
+    validate_window(x, m.cfg)
+    rul = m.predict(x, task="rul")
+    return f"estimated remaining useful life: {rul:.1f} cycles (capped at 125)"
+
+
+def load_rul_example():
+    return "\n".join((" ".join((f"{v:.3f}" for v in row)) for row in EXAMPLE_RUL))
+
+
+def score_cwru(text, use_synth):
+    m = MODELS.get("cwru")
+    if m is None:
+        return "Bearing weights not found. Set FELA_PDM_WEIGHTS to a dir with cwru.safetensors + config.json."
+    if use_synth or not text.strip():
+        t = np.linspace(0, 1, 2048)
+        sig = np.sin(2 * np.pi * 120 * t) + 0.2 * np.random.randn(2048)
+    else:
+        try:
+            sig = np.array(
+                [float(x) for x in text.replace(",", " ").split()], dtype=np.float32
+            )
+        except Exception:
+            return (
+                "Could not parse. Provide 2048 whitespace- or comma-separated samples."
+            )
+        if sig.size != 2048:
+            return f"Expected 2048 samples, got {sig.size}."
+    sig = (sig - sig.mean()) / (sig.std() + 1e-06)
+    x = torch.from_numpy(sig.astype(np.float32)).reshape(1, 2048, 1)
+    validate_window(x, m.cfg)
+    idx, prob = m.predict(x, task="cls")
+    return f"predicted fault class index: {idx}  (probability {prob:.4f})"
+
+
+with gr.Blocks(title="FELA-PdM playground") as demo:
+    gr.Markdown(
+        "# FELA-PdM playground\nOn-device predictive maintenance. Feed a sensor window and see the model's call. For research and illustration only, not a safety-critical controller; do not act on the remaining-useful-life number without independent validation."
+    )
+    with gr.Tab("Remaining useful life (C-MAPSS)"):
+        gr.Markdown(
+            "Paste 30 cycles of 14 normalized sensor values (30 rows, 14 numbers each). The FD001 head was not trained on FD002/FD003/FD004, so a window from those public NASA subsets is a real out-of-distribution test. The example below is synthetic and illustrative."
+        )
+        rul_in = gr.Textbox(label="sensor window (30 x 14)", lines=8)
+        rul_out = gr.Textbox(label="result")
+        with gr.Row():
+            gr.Button("Load synthetic example").click(load_rul_example, outputs=rul_in)
+            gr.Button("Score").click(score_rul, inputs=rul_in, outputs=rul_out)
+    with gr.Tab("Bearing fault (CWRU)"):
+        gr.Markdown(
+            "Paste 2048 raw vibration samples (12 kHz), or tick the box to score a synthetic illustrative window. The output is a fault-class index (10 classes)."
+        )
+        cwru_in = gr.Textbox(label="vibration window (2048 samples)", lines=4)
+        cwru_synth = gr.Checkbox(
+            label="use a synthetic illustrative window", value=True
+        )
+        cwru_out = gr.Textbox(label="result")
+        gr.Button("Score").click(
+            score_cwru, inputs=[cwru_in, cwru_synth], outputs=cwru_out
+        )
+if __name__ == "__main__":
+    demo.launch()

space/requirements.txt

@@ -0,0 +1,5 @@
+torch==2.8.0
+numpy==2.1.3
+safetensors==0.5.3
+huggingface-hub==0.34.4
+gradio==4.44.0

streaming/cmapss_FD001_fp16.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b605009813d95d5e4f4994e7dc878a70774bbce0ebbdb1ac1405f31b94a4b65b
+size 251818

streaming/cmapss_FD002_fp16.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:16c15598bee3e12b1784c8fccbaeaa3b95fe90ed23154f3f737e5b26b5aabc28
+size 251818

streaming/cmapss_FD003_fp16.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aec256a567108ee5a5b3aa4cdda5c94bfa674b1ec7e5f38c9c2c93e9868a2642
+size 251818

streaming/cmapss_FD004_fp16.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c98243efa2b098460503f98081fb6c09025db71af5119a93b734db109060b95c
+size 251818

streaming/cwru_fp16.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:35a2536bf6d03672e1c828d69e71bbdca935058a29e7e0aaad9ee705c9418add
+size 268100

streaming/manifest.json

@@ -0,0 +1,49 @@
+{
+  "model": "predictive-maintenance",
+  "format": "fp16-streaming",
+  "note": "load order is smallest-first for progressive/streaming load",
+  "files": [
+    {
+      "file": "cmapss_FD001_fp16.safetensors",
+      "source": "cmapss_FD001.safetensors",
+      "dtype": "fp16",
+      "bytes": 251818,
+      "approx_mb": 0.24
+    },
+    {
+      "file": "cmapss_FD002_fp16.safetensors",
+      "source": "cmapss_FD002.safetensors",
+      "dtype": "fp16",
+      "bytes": 251818,
+      "approx_mb": 0.24
+    },
+    {
+      "file": "cmapss_FD003_fp16.safetensors",
+      "source": "cmapss_FD003.safetensors",
+      "dtype": "fp16",
+      "bytes": 251818,
+      "approx_mb": 0.24
+    },
+    {
+      "file": "cmapss_FD004_fp16.safetensors",
+      "source": "cmapss_FD004.safetensors",
+      "dtype": "fp16",
+      "bytes": 251818,
+      "approx_mb": 0.24
+    },
+    {
+      "file": "model_fp16.safetensors",
+      "source": "model.safetensors",
+      "dtype": "fp16",
+      "bytes": 251818,
+      "approx_mb": 0.24
+    },
+    {
+      "file": "cwru_fp16.safetensors",
+      "source": "cwru.safetensors",
+      "dtype": "fp16",
+      "bytes": 268100,
+      "approx_mb": 0.256
+    }
+  ]
+}

streaming/model_fp16.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b605009813d95d5e4f4994e7dc878a70774bbce0ebbdb1ac1405f31b94a4b65b
+size 251818

train.py

@@ -0,0 +1,280 @@
+import argparse, glob, os, time
+import numpy as np, torch, torch.nn as nn, torch.nn.functional as F
+import scipy.io as sio
+from modeling import FELAPDM, PDMConfig
+
+cwru_classes = [
+    "Normal",
+    "IR007",
+    "B007",
+    "OR007",
+    "IR014",
+    "B014",
+    "OR014",
+    "IR021",
+    "B021",
+    "OR021",
+]
+cwru_idx = {c: i for i, c in enumerate(cwru_classes)}
+sensor_cols = [6, 7, 8, 11, 12, 13, 15, 16, 17, 18, 19, 21, 24, 25]
+rul_cap = 125
+
+
+def cwru_label(f):
+    b = os.path.basename(f).split("_")[0]
+    if b in cwru_idx:
+        return cwru_idx[b]
+    raise ValueError(f)
+
+
+def load_cwru(d, win=2048, stride=1024, loads=("0", "1", "2", "3"), seed=0):
+    rng = np.random.default_rng(seed)
+    xs, ys = ([], [])
+    for f in sorted(glob.glob(os.path.join(d, "*.mat"))):
+        load = os.path.basename(f).split("_")[1].replace(".mat", "")
+        if load not in loads:
+            continue
+        m = sio.loadmat(f)
+        de = [k for k in m if k.endswith("DE_time")]
+        if not de:
+            continue
+        sig = m[de[0]].ravel().astype(np.float32)
+        sig = (sig - sig.mean()) / (sig.std() + 1e-08)
+        lab = cwru_label(f)
+        for s in range(0, len(sig) - win + 1, stride):
+            xs.append(sig[s : s + win])
+            ys.append(lab)
+    x = np.stack(xs).astype(np.float32)[..., None]
+    y = np.array(ys, np.int64)
+    idx = rng.permutation(len(x))
+    return (x[idx], y[idx])
+
+
+def cwru_split(x, y, test_frac=0.25, seed=0):
+    rng = np.random.default_rng(seed)
+    n = len(x)
+    perm = rng.permutation(n)
+    nte = int(n * test_frac)
+    te, tr = (perm[:nte], perm[nte:])
+    return (x[tr], y[tr], x[te], y[te])
+
+
+def read_cmapss(p):
+    return np.loadtxt(p)
+
+
+def load_cmapss(d, subset="FD001", win=30, cap=rul_cap):
+    train = read_cmapss(os.path.join(d, f"train_{subset}.txt"))
+    test = read_cmapss(os.path.join(d, f"test_{subset}.txt"))
+    truth = read_cmapss(os.path.join(d, f"RUL_{subset}.txt")).ravel()
+    s = sensor_cols
+    tr_s = train[:, s]
+    smin, smax = (tr_s.min(0), tr_s.max(0))
+    rng = smax - smin
+    rng[rng == 0] = 1.0
+
+    def norm(a):
+        return (a[:, s] - smin) / rng
+
+    xtr, ytr = ([], [])
+    for u in np.unique(train[:, 0]):
+        eng = train[train[:, 0] == u]
+        feats = norm(eng).astype(np.float32)
+        L = len(feats)
+        mc = eng[:, 1].max()
+        for e in range(win, L + 1):
+            xtr.append(feats[e - win : e])
+            ytr.append(min(mc - eng[e - 1, 1], cap))
+        if L < win:
+            pad = np.zeros((win - L, len(s)), np.float32)
+            xtr.append(np.concatenate([pad, feats], 0))
+            ytr.append(min(mc - eng[-1, 1], cap))
+    xtr = np.stack(xtr).astype(np.float32)
+    ytr = np.array(ytr, np.float32)
+    xte, yte = ([], [])
+    for i, u in enumerate(np.unique(test[:, 0])):
+        eng = test[test[:, 0] == u]
+        feats = norm(eng).astype(np.float32)
+        L = len(feats)
+        if L >= win:
+            w = feats[L - win :]
+        else:
+            pad = np.zeros((win - L, len(s)), np.float32)
+            w = np.concatenate([pad, feats], 0)
+        xte.append(w)
+        yte.append(min(truth[i], cap))
+    return (xtr, ytr, np.stack(xte).astype(np.float32), np.array(yte, np.float32))
+
+
+def cmapss_score(yt, yp):
+    d = yp - yt
+    s = np.where(d < 0, np.exp(-d / 13.0) - 1.0, np.exp(d / 10.0) - 1.0)
+    return (float(np.sqrt(np.mean(d**2))), float(np.sum(s)))
+
+
+def batches(x, y, bs, seed=0):
+    idx = np.arange(len(x))
+    np.random.default_rng(seed).shuffle(idx)
+    for i in range(0, len(x), bs):
+        j = idx[i : i + bs]
+        yield (x[j], y[j])
+
+
+def cfg_cwru(**kw):
+    c = PDMConfig(
+        in_channels=1,
+        patch=4,
+        n_embd=64,
+        n_layer=4,
+        n_head=4,
+        fno_modes=64,
+        ffn_hidden=128,
+        n_classes=10,
+        seq_len=2048,
+    )
+    for k, v in kw.items():
+        setattr(c, k, v)
+    return c
+
+
+def cfg_cmapss(**kw):
+    c = PDMConfig(
+        in_channels=14,
+        patch=1,
+        n_embd=64,
+        n_layer=4,
+        n_head=4,
+        fno_modes=32,
+        ffn_hidden=128,
+        rul_head=True,
+        seq_len=64,
+    )
+    for k, v in kw.items():
+        setattr(c, k, v)
+    return c
+
+
+def train_cwru(a):
+    dev = torch.device(a.device)
+    x, y = load_cwru(a.data, win=2048, stride=a.stride, seed=a.seed)
+    xtr, ytr, xte, yte = cwru_split(x, y, test_frac=0.25, seed=a.seed)
+    assert len(x) == 5886
+    if a.smoke:
+        print(
+            f"Cwru total {len(x)} train {len(xtr)} test {len(xte)} classes {len(set(y.tolist()))}"
+        )
+        return
+    cfg = cfg_cwru(dropout=a.dropout)
+    m = FELAPDM(cfg).to(dev)
+    opt = torch.optim.AdamW(m.parameters(), lr=a.lr, weight_decay=0.0001)
+    sch = torch.optim.lr_scheduler.CosineAnnealingLR(opt, a.epochs)
+    xte_t = torch.from_numpy(xte).to(dev)
+    yte_t = torch.from_numpy(yte).to(dev)
+    best = 0.0
+    for ep in range(a.epochs):
+        m.train()
+        for xb, yb in batches(xtr, ytr, a.bs, seed=a.seed + ep):
+            xb = torch.from_numpy(xb).to(dev)
+            yb = torch.from_numpy(yb).to(dev)
+            loss = F.cross_entropy(m(xb, task="cls"), yb)
+            opt.zero_grad()
+            loss.backward()
+            nn.utils.clip_grad_norm_(m.parameters(), 1.0)
+            opt.step()
+        sch.step()
+        m.eval()
+        with torch.no_grad():
+            pr = torch.cat(
+                [
+                    m(xte_t[i : i + 256], task="cls").argmax(-1)
+                    for i in range(0, len(xte_t), 256)
+                ]
+            )
+            acc = (pr == yte_t).float().mean().item()
+        if acc > best:
+            best = acc
+            torch.save(
+                {"cfg": cfg.__dict__, "model": m.state_dict(), "classes": cwru_classes},
+                a.out,
+            )
+        print(f"Ep {ep:02d} acc {acc * 100:.2f} best {best * 100:.2f}")
+
+
+def train_cmapss(a):
+    dev = torch.device(a.device)
+    xtr, ytr, xte, yte = load_cmapss(a.data, subset=a.subset, win=a.win)
+    if a.subset == "FD001":
+        assert len(xtr) == 17731
+    if a.smoke:
+        print(f"Cmapss {a.subset} train {xtr.shape} test {xte.shape}")
+        return
+    cfg = cfg_cmapss(dropout=a.dropout, seq_len=a.win)
+    m = FELAPDM(cfg).to(dev)
+    opt = torch.optim.AdamW(m.parameters(), lr=a.lr, weight_decay=0.0001)
+    sch = torch.optim.lr_scheduler.CosineAnnealingLR(opt, a.epochs)
+    cap = 125.0
+    xte_t = torch.from_numpy(xte).to(dev)
+    best = 1000000000.0
+    for ep in range(a.epochs):
+        m.train()
+        for xb, yb in batches(xtr, ytr / cap, a.bs, seed=a.seed + ep):
+            xb = torch.from_numpy(xb).to(dev)
+            yb = torch.from_numpy(yb).to(dev)
+            loss = F.mse_loss(m(xb, task="rul"), yb)
+            opt.zero_grad()
+            loss.backward()
+            nn.utils.clip_grad_norm_(m.parameters(), 1.0)
+            opt.step()
+        sch.step()
+        m.eval()
+        with torch.no_grad():
+            pr = np.clip(
+                torch.cat(
+                    [
+                        m(xte_t[i : i + 256], task="rul")
+                        for i in range(0, len(xte_t), 256)
+                    ]
+                )
+                .cpu()
+                .numpy()
+                * cap,
+                0,
+                cap,
+            )
+        rmse, score = cmapss_score(yte, pr)
+        if rmse < best:
+            best = rmse
+            torch.save(
+                {"cfg": cfg.__dict__, "model": m.state_dict(), "rul_cap": cap}, a.out
+            )
+        print(f"Ep {ep:02d} RMSE {rmse:.2f} score {score:.0f} best {best:.2f}")
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--task", choices=["cwru", "cmapss"], required=True)
+    ap.add_argument("--data", default=None)
+    ap.add_argument("--subset", default="FD001")
+    ap.add_argument("--out", default=None)
+    ap.add_argument("--epochs", type=int, default=40)
+    ap.add_argument("--bs", type=int, default=64)
+    ap.add_argument("--lr", type=float, default=0.002)
+    ap.add_argument("--win", type=int, default=30)
+    ap.add_argument("--stride", type=int, default=1024)
+    ap.add_argument("--dropout", type=float, default=0.0)
+    ap.add_argument("--device", default="cpu")
+    ap.add_argument("--seed", type=int, default=0)
+    ap.add_argument("--smoke", action="store_true")
+    a = ap.parse_args()
+    if a.task == "cwru":
+        a.data = a.data or "../data/cwru"
+        a.out = a.out or "./pdm_cwru_fno.pt"
+        train_cwru(a)
+    else:
+        a.data = a.data or "../data/cmapss"
+        a.out = a.out or f"./pdm_cmapss_{a.subset}_fno.pt"
+        train_cmapss(a)
+
+
+if __name__ == "__main__":
+    main()

verify.py

@@ -0,0 +1,71 @@
+import argparse
+import os
+import sys
+import torch
+
+sys.path.insert(0, os.path.dirname(__file__))
+from modeling import load_model
+
+SAMPLES = {
+    "cmapss_FD001": torch.full((1, 30, 14), 0.5),
+    "cmapss_FD002": torch.full((1, 30, 14), 0.5),
+    "cmapss_FD003": torch.full((1, 30, 14), 0.5),
+    "cmapss_FD004": torch.full((1, 30, 14), 0.5),
+    "cwru": torch.linspace(-1, 1, 2048).reshape(1, 2048, 1),
+}
+VERIFICATION = {
+    "cmapss_FD001": {"value": 0.390998, "tol": 0.001},
+    "cmapss_FD002": {"value": 0.038257, "tol": 0.001},
+    "cmapss_FD003": {"value": 0.788864, "tol": 0.001},
+    "cmapss_FD004": {"value": 0.414077, "tol": 0.001},
+    "cwru": {"value": 0, "tol": 0.001},
+}
+EXPECTED_SHAPE = {
+    "cmapss_FD001": (1,),
+    "cmapss_FD002": (1,),
+    "cmapss_FD003": (1,),
+    "cmapss_FD004": (1,),
+    "cwru": (1, 10),
+}
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--variant", default="cmapss_FD001", choices=list(SAMPLES))
+    ap.add_argument("--weights", default=os.environ.get("FELA_PDM_WEIGHTS", "."))
+    args = ap.parse_args()
+    model = load_model(args.weights, variant=args.variant)
+    x = SAMPLES[args.variant]
+    with torch.no_grad():
+        out = model(x)
+    exp = EXPECTED_SHAPE[args.variant]
+    if tuple(out.shape) != exp:
+        print(f"Fail: output shape {tuple(out.shape)} != expected {exp}")
+        sys.exit(1)
+    print(f"Shape OK: {tuple(out.shape)}")
+    g = VERIFICATION[args.variant]
+    if g["value"] is None:
+        if args.variant.startswith("cmapss"):
+            captured = float(out.reshape(-1)[0])
+        else:
+            captured = int(out.argmax(-1).item())
+        print(f"Captured output: {captured}")
+        print(
+            "Verification value is a placeholder. Paste this captured value into VERIFICATION and re-run to enable the check. Shape check passed."
+        )
+        return
+    if args.variant.startswith("cmapss"):
+        got = float(out.reshape(-1)[0])
+        if abs(got - g["value"]) > g["tol"]:
+            print(f"Fail: RUL {got} vs verification {g['value']} (tol {g['tol']})")
+            sys.exit(1)
+    else:
+        got = int(out.argmax(-1).item())
+        if got != g["value"]:
+            print(f"Fail: class {got} vs verification {g['value']}")
+            sys.exit(1)
+    print("Verification check OK")
+
+
+if __name__ == "__main__":
+    main()