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,340 @@
+---
+license: other
+license_name: lowdown-labs-lovely-license-1.0
+license_link: LICENSE
+tags:
+  - fela
+  - fourier-neural-operator
+  - fno
+  - cpu
+  - on-device
+  - energy-forecasting
+  - solar-power
+  - wind-power
+  - probabilistic-forecasting
+  - quantile-regression
+library_name: transformers
+pipeline_tag: time-series-forecasting
+---
+
+# DISCLAIMER
+
+This model is a research preview. GEFCom2014 is competition data with no stated reuse or
+commercial use grant (citation only), so respect that before any commercial use. Lowdown Labs
+has put together this model in the interest of advancing public science.
+
+# FELA Power Grid: on station probabilistic solar and wind power forecasting
+
+This model forecasts how much power a solar farm or a wind farm will produce in the
+coming hours, and it gives a full range of outcomes (not just a single guess) so a grid
+operator can plan for the good case and the bad case. It is small enough to fit the
+envelope of a cheap microcontroller right at the station, with no cloud and no network
+connection, running there through an ONNX or TFLite export.
+
+# What goes in, what comes out
+
+- Input: a short window of weather forecast numbers for the site (numerical weather
+  prediction, or NWP, covariates such as forecast irradiance for solar or forecast wind
+  speed and direction for wind). Solar input shape is (1, 6, 20): 6 time steps, 20
+  weather features. Wind input shape is (1, 12, 15): 12 time steps, 15 weather features.
+- Output: 99 numbers per forecast hour, the 1 percent through 99 percent quantiles of
+  power output, normalized to the site's rated capacity (0 to 1). A quantile is a "what
+  if" level: the 10 percent quantile (P10) is a low estimate that power should exceed
+  90 percent of the time, the 90 percent quantile (P90) is a high estimate. The gap
+  between P10 and P90 is the uncertainty band the operator plans against.
+- This lets a grid or plant operator schedule reserves, bid into a market, and manage
+  ramps with a calibrated sense of risk, using a device that sits on the station and
+  keeps working when the network is down.
+
+# Why we built it this way
+
+The model is a dual path Fourier Neural Operator, or FNO. The main path mixes information in the
+frequency domain: a fast Fourier transform, a learned filter on the frequencies, then a transform
+back. Weather and power move on daily and seasonal cycles, which is cheap to capture this way.
+Alongside it runs a small local mixer for the short range detail.
+
+Everything is kept deliberately small: 136,780 parameters for solar, 311,554 for wind. Quantized to
+8 bit integers each track is under a megabyte, and a single hourly forecast takes under a
+millisecond on one CPU core (measured on an x86 server CPU). That is small enough to sit on a
+microcontroller at the station, running through the ONNX or TFLite export. Because it runs there
+offline, the site's operational data never leaves the premises.
+
+# Performance
+
+Speed and footprint, measured on CPU (AMD EPYC 9555, batch size 1, median of 20 runs).
+
+| Track | Parameters | fp32 size | int8 size | Latency, 1 core |
+|---|---|---|---|---|
+| Solar, input (1, 6, 20) | 136,780 | 0.74 MB | 504 KB | 0.386 ms |
+| Wind, input (1, 12, 15) | 311,554 | 1.91 MB | 1472 KB | 0.375 ms |
+
+The int8 weights are the on device deploy size. The int8 pinball loss is essentially
+unchanged from fp32 (see Accuracy), so quantization is effectively lossless here.
+
+# Accuracy
+
+The benchmark is GEFCom2014, the standard Global Energy Forecasting Competition dataset
+(Hong et al. 2016). The protocol is the final task (Task 15): train on all data before the
+held out test month and forecast that month from weather inputs only, with no test period
+power used (so there is no leakage). 
+
+Solar is 3 zones (test month June 2014), wind is 10
+zones (test month December 2013). The metric is pinball loss averaged over the 1 to 99
+percent quantiles, with power normalized to site capacity, exactly as in the competition.
+Lower pinball loss is better. "Skill" is the percent reduction in pinball loss against a
+named reference forecast.
+
+| Benchmark | Metric | This model | Baseline (named) | Source |
+|---|---|---|---|---|
+| GEFCom2014 solar | pinball (norm.) | 0.01308 (int8 0.01328) | competition benchmark 0.0285 | measured (ours) |
+| GEFCom2014 solar | skill vs competition benchmark | +54.1 percent | competition benchmark | measured (ours) |
+| GEFCom2014 solar | skill vs diurnal persistence | +32.1 percent | diurnal persistence | measured (ours) |
+| GEFCom2014 solar | pinball (norm.) | 0.01308 | our LightGBM quantile baseline 0.01232 | measured (ours) |
+| GEFCom2014 solar | pinball (norm.) | 0.01308 | published LSTM/quantile NN 0.0143 | published |
+| GEFCom2014 wind | pinball (norm.) | 0.04690 (int8 0.04692) | competition benchmark 0.0792 | measured (ours) |
+| GEFCom2014 wind | skill vs competition benchmark | +40.8 percent | competition benchmark | measured (ours) |
+| GEFCom2014 wind | skill vs diurnal persistence | +47.5 percent | diurnal persistence | measured (ours) |
+| GEFCom2014 wind | pinball (norm.) | 0.04690 | our LightGBM quantile baseline 0.04547 | measured (ours) |
+| GEFCom2014 wind | pinball (norm.) | 0.04690 | published GAN / normalizing flow / VAE / DDPM | published |
+
+The model wins the official GEFCom2014 benchmark on both tracks, and it beats
+the competition benchmark by wide margins (skill +54.1 percent on solar, +40.8 percent on wind).
+What it is not is a new raw pinball record. 
+
+On the identical pipeline it ties our own LightGBM
+gradient boosted baseline (solar 0.01308 vs 0.01232, wind 0.04690 vs 0.04547). It beats a
+published LSTM/quantile NN on solar and a published GAN on wind, sits level with a published
+normalizing flow, and lands a few percent behind the best published diffusion model (VAE/DDPM)
+on wind. 
+
+So - the accuracy is competitive but with given resources, not chart topping. The real edge is where it delivers
+that accuracy: 136,780 and 311,554 parameters, under a megabyte in int8, sub millisecond on a
+CPU, running on station with the network gapped - which we feel is a great domain adaptation for our methodologies.
+
+# How to run it
+
+See `quickstart/` for a runnable example. The model loads in a few lines with the bundled
+`modeling.py` plus `config.json`, from the safe `safetensors` weight file (no pickle):
+
+```python
+from huggingface_hub import hf_hub_download
+import modeling  # bundled in this repo
+
+path = hf_hub_download("lowdown-labs/fela-power-grid", "solar.safetensors")
+model = modeling.load_model(path, track="solar")
+
+# Preprocess a raw NWP window (shape (6, 20) for solar), then forecast.
+x = modeling.preprocess_nwp(raw_window, track="solar")  # validates shape, standardizes
+import torch
+with torch.no_grad():
+    quantiles = model(x)  # (1, 99): the P1..P99 power quantiles for the center forecast hour
+
+# A P10 to P90 band for the center forecast hour:
+p10 = quantiles[0, 9].item()
+p90 = quantiles[0, 89].item()
+print("Center hour P10..P90 (fraction of capacity):", p10, p90)
+```
+
+The `modeling.preprocess_nwp` helper standardizes the weather window and validates its
+shape (it fails clearly on the wrong shape or units). For an interactive playground, see
+the Hugging Face Space linked in this repo.
+
+## Formats
+
+This model is CPU native: no GPU is required to run it, in any format. The fp32 and int8
+formats run on a plain CPU.
+
+- fp32: reference and CPU.
+- int8: on device deployment format (AVX512-VNNI on x86, NEON dot product on ARM). The
+  int8 pinball loss is essentially unchanged (solar 0.01328 vs 0.01308, wind 0.04692 vs
+  0.04690), so on device quantization is effectively lossless here.
+- bf16: an optional format for server or GPU inference, not required and not the on device
+  format. Most commodity ARM and microcontroller CPUs lack native bf16, so use fp32 or int8
+  there. You never need a GPU; bf16 is only a convenience when one happens to be present.
+
+## Serving
+
+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.
+
+# Training data
+
+- GEFCom2014 (Global Energy Forecasting Competition 2014), public competition data
+  released with the competition. Used for both training and the held out evaluation, under
+  the GEFCom2014 Task 15 protocol described above. Solar and wind tracks. Citation: Hong,
+  Pinson, Fan, Zareipour, Troccoli, Hyndman (2016), "Probabilistic energy forecasting:
+  Global Energy Forecasting Competition 2014 and beyond," International Journal of
+  Forecasting 32(3). The dataset is the public competition release; check the competition
+  terms for the exact redistribution conditions before rehosting it.
+
+No proprietary or customer data was used. The model takes only numerical weather
+prediction covariates as input.
+
+## Training data, splits and licensing
+
+The training and held out evaluation splits are defined in `train.py` in this repo. A `--smoke`
+flag rebuilds the split, asserts the audited held out window count per track, and exits before
+training.
+
+- Dataset: GEFCom2014 (Global Energy Forecasting Competition 2014), solar and wind tracks.
+  Version: the Task 15 (final task) public release, as distributed with the paper. The solar
+  track has 3 zones with 12 NWP predictors; the wind track has 10 zones with 4 NWP predictors.
+- Source: the data was released as the appendix of the GEFCom2014 paper and mirrored by the
+  competition General Chair at http://blog.drhongtao.com/2017/03/gefcom2014-load-forecasting-data.html
+  (and via ScienceDirect, DOI 10.1016/j.ijforecast.2016.02.001). Citation: Hong, Pinson, Fan,
+  Zareipour, Troccoli, Hyndman (2016), International Journal of Forecasting 32(3), 896-913.
+- Split: GEFCom2014 Task 15 protocol, a fixed calendar held out month, not a random split.
+  Solar test month is June 2014 (2014-06-01 01:00 to 2014-07-01 00:00); wind test month is
+  December 2013. Training uses all prior data; the test month is forecast from NWP only (no
+  test period power, so no autoregressive leakage). The held out and train membership is the
+  `is_test` flag defined in `train.py`, and `train.py --smoke` asserts the audited held out
+  counts: solar 2154 windows over 3 zones, wind 7390 windows over 10 zones. A 6 percent tail
+  of the training rows is held out as a validation set for early stopping (deterministic tail
+  slice).
+- License: NO license is stated for GEFCom2014. The data is competition data delivered as an
+  appendix to a copyrighted (all rights reserved) Elsevier / International Journal of
+  Forecasting article; the author distribution page states only a citation requirement, with no
+  reuse or commercial use grant. Underlying source data (e.g. ISO New England for the extended
+  load track) may carry its own upstream terms, and the distributor warns against combining the
+  datasets.
+- Commercial verdict: UNCLEAR and UNSTATED. Competition data, no license grant, the highest risk
+  of the family. Citation alone is not a commercial use grant. For any commercial or
+  redistribution use, obtain written permission from the organizers (Tao Hong / International
+  Institute of Forecasters) and verify the upstream source terms first.
+
+# 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
+
+- **GEFCom2014 (Global Energy Forecasting Competition 2014)**: solar and wind tracks, the
+  Task 15 protocol used for both training and the held out evaluation.
+  - Reference: Hong, T., Pinson, P., Fan, S., Zareipour, H., Troccoli, A., & Hyndman, R. J.
+    (2016). Probabilistic energy forecasting: Global Energy Forecasting Competition 2014 and
+    beyond. *International Journal of Forecasting*, 32(3), 896-913.
+    DOI: [10.1016/j.ijforecast.2016.02.001](https://doi.org/10.1016/j.ijforecast.2016.02.001)
+  - Data and terms: released as the appendix of the paper and mirrored by the competition General
+    Chair at
+    [blog.drhongtao.com/2017/03/gefcom2014-load-forecasting-data.html](http://blog.drhongtao.com/2017/03/gefcom2014-load-forecasting-data.html).
+    The paper itself is (c) Elsevier / International Journal of Forecasting (all rights reserved):
+    [ScienceDirect article page](https://www.sciencedirect.com/science/article/pii/S0169207016000133).
+  - **License: NO reuse or commercial use grant is stated, COMPETITION TERMS.** The distribution
+    page states only a citation requirement; the data is delivered as an appendix to a copyrighted
+    Elsevier article, and underlying source data (e.g. ISO New England for the extended load track)
+    may carry its own upstream terms. Citation is not a commercial use grant. For any commercial or
+    redistribution use, obtain written permission from the organizers (Tao Hong / International
+    Institute of Forecasters) and verify the upstream source terms first. See the fuller caveat under
+    "Training data, splits and licensing" above.
+
+## Methods and code
+
+- **Fourier Neural Operator (FNO)**: the sequence mixer at the core of both tracks.
+  Li, Z., Kovachki, N., Azizzadenesheli, K., Liu, B., Bhattacharya, K., Stuart, A., & Anandkumar, A.
+  (2021). Fourier Neural Operator for Parametric Partial Differential Equations. *ICLR*.
+  [arXiv:2010.08895](https://arxiv.org/abs/2010.08895)
+- **PyTorch**: training and inference framework. Paszke, A., et al. (2019). PyTorch: An
+  Imperative Style, High-Performance Deep Learning Library. *NeurIPS*.
+  [arXiv:1912.01703](https://arxiv.org/abs/1912.01703)
+- **LightGBM**: the reference gradient boosted quantile baseline. Ke, G., et al. (2017).
+  LightGBM: A Highly Efficient Gradient Boosting Decision Tree. *NeurIPS*.
+  [proceedings](https://papers.nips.cc/paper_files/paper/2017/hash/6449f44a102fde848669bdd9eb6b76fa-Abstract.html)
+- **NumPy / SciPy**: used in the data preparation and evaluation pipeline; standard scientific
+  Python stack. Harris et al. (2020), [Nature 585, 357-362](https://doi.org/10.1038/s41586-020-2649-2);
+  Virtanen et al. (2020), [Nature Methods 17, 261-272](https://doi.org/10.1038/s41592-019-0686-2).
+- **ONNX Runtime / TFLite**: the on device export and runtime path.
+  [onnxruntime.ai](https://onnxruntime.ai/),
+  [ai.google.dev/edge/litert](https://ai.google.dev/edge/litert).
+
+This model does not use Gated Linear Attention, Gated DeltaNet, or Landmark Attention: both
+tracks are pure FNO (see `modeling.py` and `train.py`).
+
+# Intended use, limitations, and safety
+
+What it is for:
+
+- Short horizon probabilistic power forecasting at a solar or wind site, driven by a
+  numerical weather prediction feed, on station or on device.
+
+What it is not for:
+
+- It is not a single point guarantee of output and not a replacement for a grid operator's
+  judgment. The quantile band is a planning aid, not a control signal.
+- It is not validated for direct, unsupervised use in a safety critical or
+  protection critical control loop. Do not wire its output into automated dispatch,
+  protection, or curtailment that affects grid stability without independent validation and
+  a human or rule based check in the loop.
+
+Evaluated conditions and known limits:
+
+- Evaluated only on GEFCom2014 (3 solar zones, 10 wind zones) under the Task 15 protocol.
+  Performance on other sites, climates, turbine types, or NWP feeds is not characterized
+  here and should be validated before operational use.
+- The model is a tie with a gradient boosted (LightGBM) baseline on raw accuracy and is a
+  few percent behind the best published diffusion/VAE on wind. If raw pinball loss is the
+  only thing that matters and device size does not, those baselines are reasonable
+  alternatives. The reason to choose this model is the on station, sub megabyte,
+  sub millisecond, network gapped deployment.
+- A separate test on SDWPF (Baidu KDD Cup 2022), a harder modern wind farm benchmark, did
+  not transfer well and is not claimed here. The genuine climate win is GEFCom2014.
+- The quantile outputs are calibrated against the GEFCom2014 evaluation only. Verify
+  calibration on your own data before relying on the P10 to P90 band for reserve sizing.
+
+Privacy:
+
+- The model runs on station and offline. When deployed on device, the site's operational
+  and weather data does not leave the device, so there is no cloud round trip and no data
+  shared with Lowdown Labs or any third party.
+
+# How to cite
+
+Model and technical note:
+
+```
+@misc{lowdownlabs_grid_renewable,
+  title  = {FELA Grid Renewable: on station probabilistic solar and wind power forecasting},
+  author = {Lowdown Labs},
+  year   = {2026},
+  note   = {Model card}
+}
+```
+
+You must also cite the benchmark dataset and the core libraries:
+
+- Hong, T., Pinson, P., Fan, S., Zareipour, H., Troccoli, A., Hyndman, R. J. (2016).
+  Probabilistic energy forecasting: Global Energy Forecasting Competition 2014 and beyond.
+  International Journal of Forecasting, 32(3), 896 to 913.
+- Li, Z., Kovachki, N., Azizzadenesheli, K., Liu, B., Bhattacharya, K., Stuart, A.,
+  Anandkumar, A. (2021). Fourier Neural Operator for Parametric Partial Differential
+  Equations. International Conference on Learning Representations (ICLR).
+- Paszke, A. et al. (2019). PyTorch: An Imperative Style, High-Performance Deep Learning
+  Library. NeurIPS.
+
+# Acknowledgements and references
+
+- GEFCom2014: Hong et al. (2016), International Journal of Forecasting 32(3), 896 to 913.
+- Fourier Neural Operator: Li et al. (2021), ICLR. The architecture is built on the FNO.
+- LightGBM (our reference quantile baseline): Ke, G. et al. (2017). LightGBM: A Highly
+  Efficient Gradient Boosting Decision Tree. NeurIPS.
+- 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-power-grid`. The sibling repos are:
+
+- `lowdown-labs/fela-genomics`: DNA sequence classification.
+- `lowdown-labs/fela-pdm`: rotating machinery and turbofan health.
+- `lowdown-labs/fela-power-grid` (this repo): 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.

config.json

@@ -0,0 +1,38 @@
+{
+  "model_type": "fela_grid_renewable",
+  "description": "Dual path FNO probabilistic power forecaster for solar and wind, trained on GEFCom2014. Outputs 99 quantiles per hour from weather covariates.",
+  "architecture": "fno_dual_path",
+  "framework": "pytorch",
+  "architectures": [
+    "FelaGridModel"
+  ],
+  "auto_map": {
+    "AutoConfig": "configuration_grid.FelaGridConfig",
+    "AutoModel": "modeling_grid.FelaGridModel"
+  },
+  "default_track": "solar",
+  "tracks": {
+    "solar": {
+      "params": 136780,
+      "input_steps": 6,
+      "input_features": 20,
+      "input_shape": [1, 6, 20],
+      "weights_safetensors": "solar.safetensors",
+      "dims": {"Fin": 20, "L": 6, "D": 64, "modes": 3, "nblk": 4, "nq": 99, "arch": "dual"}
+    },
+    "wind": {
+      "params": 311554,
+      "input_steps": 12,
+      "input_features": 15,
+      "input_shape": [1, 12, 15],
+      "weights_safetensors": "wind.safetensors",
+      "dims": {"Fin": 15, "L": 12, "D": 96, "modes": 6, "nblk": 3, "nq": 99, "arch": "dual"}
+    }
+  },
+  "num_quantiles": 99,
+  "quantile_levels_percent": "1..99",
+  "output_shape": "[batch, 99]",
+  "output_units": "power as fraction of site rated capacity (0 to 1), 99 monotone quantiles for the center forecast hour",
+  "preprocessing": "standardize the NWP window per feature; RevIN runs inside the model. See modeling.preprocess_nwp",
+  "license": "lowdown-labs-lovely-license-1.0"
+}

configuration_grid.py

@@ -0,0 +1,39 @@
+from transformers import PretrainedConfig
+
+
+class FelaGridConfig(PretrainedConfig):
+    model_type = "fela_grid_renewable"
+
+    def __init__(
+        self,
+        track="solar",
+        Fin=20,
+        L=6,
+        D=64,
+        modes=3,
+        nblk=4,
+        nq=99,
+        arch="dual",
+        tracks=None,
+        **kwargs,
+    ):
+        if isinstance(tracks, dict) and track in tracks:
+            dims = tracks[track].get("dims", {})
+            Fin = dims.get("Fin", Fin)
+            L = dims.get("L", L)
+            D = dims.get("D", D)
+            modes = dims.get("modes", modes)
+            nblk = dims.get("nblk", nblk)
+            nq = dims.get("nq", nq)
+            arch = dims.get("arch", arch)
+        self.track = track
+        self.Fin = Fin
+        self.L = L
+        self.D = D
+        self.modes = modes
+        self.nblk = nblk
+        self.nq = nq
+        self.arch = arch
+        if tracks is not None:
+            self.tracks = tracks
+        super().__init__(**kwargs)

model.safetensors

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

modeling.py

@@ -0,0 +1,185 @@
+import json
+import os
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+CONFIG = None
+
+
+def _config():
+    global CONFIG
+    if CONFIG is None:
+        here = os.path.dirname(os.path.abspath(__file__))
+        with open(os.path.join(here, "config.json")) as f:
+            CONFIG = json.load(f)
+    return CONFIG
+
+
+class RevIN(nn.Module):
+    def __init__(self, C):
+        super().__init__()
+        self.g = nn.Parameter(torch.ones(C))
+        self.b = nn.Parameter(torch.zeros(C))
+
+    def norm(self, x):
+        self.m = x.mean(1, keepdim=True)
+        self.s = x.std(1, keepdim=True) + 1e-05
+        return (x - self.m) / self.s * self.g + self.b
+
+
+class FNO1D(nn.Module):
+    def __init__(self, D, modes):
+        super().__init__()
+        self.modes = modes
+        s = 1 / (D * D)
+        self.w = nn.Parameter(s * torch.rand(modes, D, D, dtype=torch.cfloat))
+
+    def forward(self, x):
+        P = x.shape[1]
+        xf = torch.fft.rfft(x, dim=1)
+        m = min(self.modes, xf.shape[1])
+        o = torch.zeros_like(xf)
+        o[:, :m] = torch.einsum("bpd,pde->bpe", xf[:, :m], self.w[:m])
+        return torch.fft.irfft(o, n=P, dim=1)
+
+
+class Block(nn.Module):
+    def __init__(self, D, modes, ff=2, drop=0.0):
+        super().__init__()
+        self.n1 = nn.LayerNorm(D)
+        self.fno = FNO1D(D, modes)
+        self.d1 = nn.Dropout(drop)
+        self.n2 = nn.LayerNorm(D)
+        self.ff = nn.Sequential(
+            nn.Linear(D, D * ff), nn.GELU(), nn.Dropout(drop), nn.Linear(D * ff, D)
+        )
+
+    def forward(self, x):
+        x = x + self.d1(self.fno(self.n1(x)))
+        return x + self.ff(self.n2(x))
+
+
+class FELA_Grid(nn.Module):
+    def __init__(self, Fin, L, D=96, modes=6, nblk=3, nq=99, arch="dual"):
+        super().__init__()
+        self.L = L
+        self.arch = arch
+        self.center = L // 2
+        self.nq = nq
+        self.revin = RevIN(Fin)
+        self.embed = nn.Linear(Fin, D)
+        self.pos = nn.Parameter(0.02 * torch.randn(1, L, D))
+        self.blocks = nn.ModuleList([Block(D, modes) for _ in range(nblk)])
+        self.norm = nn.LayerNorm(D)
+        if arch == "dual":
+            self.direct = nn.Sequential(
+                nn.Linear(Fin, D), nn.GELU(), nn.Linear(D, D), nn.GELU()
+            )
+            fuse_in = 2 * D
+        else:
+            fuse_in = D
+        self.med = nn.Linear(fuse_in, 1)
+        self.spread = nn.Linear(fuse_in, nq)
+        self.register_buffer("qidx", torch.arange(nq))
+
+    def forward(self, x):
+        xc = x[:, self.center]
+        xn = self.revin.norm(x)
+        h = self.embed(xn) + self.pos
+        for b in self.blocks:
+            h = b(h)
+        ctx = self.norm(h)[:, self.center]
+        if self.arch == "dual":
+            z = torch.cat([ctx, self.direct(xc)], dim=1)
+        else:
+            z = ctx
+        med = torch.sigmoid(self.med(z))
+        w = F.softplus(self.spread(z))
+        half = self.nq // 2
+        below = -torch.flip(torch.cumsum(torch.flip(w[:, :half], [1]), 1), [1])
+        above = torch.cumsum(w[:, half + 1 :], 1)
+        offs = (
+            torch.cat([below, torch.zeros_like(w[:, half : half + 1]), above], dim=1)
+            * 0.05
+        )
+        return torch.clamp(med + offs, 0, 1)
+
+
+def expected_shape(track):
+    t = _config()["tracks"][track]
+    return (t["input_steps"], t["input_features"])
+
+
+def validate_input(x, track):
+    steps, feats = expected_shape(track)
+    if not isinstance(x, torch.Tensor):
+        raise TypeError(f"Expected a torch.Tensor, got {type(x)}")
+    if x.dim() != 3:
+        raise ValueError(
+            f"{track}: expected a 3-D tensor (batch, steps, features), got shape {tuple(x.shape)}"
+        )
+    if x.shape[1] != steps or x.shape[2] != feats:
+        raise ValueError(
+            f"{track}: expected window (batch, {steps}, {feats}), got {tuple(x.shape)}. Solar windows are (.,6,20); wind windows are (.,12,15)."
+        )
+    return x
+
+
+def preprocess_nwp(raw_window, track, mean=None, std=None):
+    x = torch.as_tensor(raw_window, dtype=torch.float32)
+    if x.dim() == 2:
+        x = x.unsqueeze(0)
+    if mean is not None and std is not None:
+        mean = torch.as_tensor(mean, dtype=torch.float32)
+        std = torch.as_tensor(std, dtype=torch.float32)
+        x = (x - mean) / torch.clamp(std, min=1e-06)
+    else:
+        m = x.mean(dim=(0, 1), keepdim=True)
+        s = x.std(dim=(0, 1), keepdim=True)
+        x = (x - m) / torch.clamp(s, min=1e-06)
+    return validate_input(x, track)
+
+
+def _build_from_state(state, track):
+    dims = _config()["tracks"][track]["dims"]
+    model = FELA_Grid(
+        dims["Fin"],
+        dims["L"],
+        D=dims["D"],
+        modes=dims["modes"],
+        nblk=dims["nblk"],
+        nq=dims["nq"],
+        arch=dims.get("arch", "dual"),
+    )
+    ref = model.state_dict()
+    fixed = {}
+    for k, v in state.items():
+        t = ref.get(k)
+        if t is not None and t.is_complex() and (not v.is_complex()):
+            v = torch.view_as_complex(v.contiguous())
+        fixed[k] = v
+    fixed["qidx"] = model.qidx.clone()
+    model.load_state_dict(fixed, strict=True)
+    return model
+
+
+def load_model(path_or_repo, track="solar", filename=None):
+    path = path_or_repo
+    fname = filename or _config()["tracks"][track]["weights_safetensors"]
+    if os.path.isdir(path):
+        path = os.path.join(path, fname)
+    elif not os.path.exists(path):
+        from huggingface_hub import hf_hub_download
+
+        path = hf_hub_download(path_or_repo, fname)
+    from safetensors.torch import load_file
+
+    state = load_file(path)
+    model = _build_from_state(state, track)
+    model.eval()
+    return model
+
+
+def from_pretrained(repo_id, track="solar"):
+    return load_model(repo_id, track=track)

modeling_grid.py

@@ -0,0 +1,56 @@
+import os
+import sys
+import types
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import torch
+import torch.nn as nn
+from transformers import PreTrainedModel
+from transformers.modeling_outputs import CausalLMOutput
+
+from .configuration_grid import FelaGridConfig
+from .modeling import FELA_Grid, FNO1D
+
+
+def _fno1d_forward(self, x):
+    w = torch.view_as_complex(self.w)
+    P = x.shape[1]
+    xf = torch.fft.rfft(x, dim=1)
+    mm = min(self.modes, xf.shape[1])
+    o = torch.zeros_like(xf)
+    o[:, :mm] = torch.einsum("bpd,pde->bpe", xf[:, :mm], w[:mm])
+    return torch.fft.irfft(o, n=P, dim=1)
+
+
+def _realify(model):
+    for m in model.modules():
+        if isinstance(m, FNO1D):
+            m.w = nn.Parameter(torch.view_as_real(m.w.detach()).contiguous())
+            m.forward = types.MethodType(_fno1d_forward, m)
+
+
+class FelaGridModel(PreTrainedModel):
+    config_class = FelaGridConfig
+    base_model_prefix = "model"
+    main_input_name = "x"
+
+    def __init__(self, config):
+        super().__init__(config)
+        self.model = FELA_Grid(
+            config.Fin,
+            config.L,
+            D=config.D,
+            modes=config.modes,
+            nblk=config.nblk,
+            nq=config.nq,
+            arch=config.arch,
+        )
+        self.model._non_persistent_buffers_set.add("qidx")
+        _realify(self.model)
+        self.post_init()
+
+    def forward(self, x=None, input_values=None, **kwargs):
+        if x is None:
+            x = input_values
+        out = self.model(x)
+        return CausalLMOutput(logits=out)

quickstart/README.md

@@ -0,0 +1,45 @@
+# Quickstart: FELA Grid Renewable
+
+A minimal example that loads the forecaster, runs one weather input window, and prints the
+P10 to P90 power band for the first forecast hour. It runs on CPU; no GPU is required.
+
+## Install
+
+Pinned versions, runs from a clean virtual environment:
+
+```
+pip install -r requirements.txt
+```
+
+## Get the weights
+
+The safetensors weights ship in the model repo (`solar.safetensors`, `wind.safetensors`).
+`--weights` defaults to the track's safetensors file, or point it at a local path.
+
+## Run
+
+Solar (default):
+
+```
+python run.py --track solar --weights /path/to/solar.safetensors
+```
+
+Wind:
+
+```
+python run.py --track wind --weights /path/to/wind.safetensors
+```
+
+The script loads with the bundled `modeling.load_model` (a few line load) and preprocesses
+the window with `modeling.preprocess_nwp`, which standardizes it and validates the shape
+(it fails clearly on the wrong shape).
+
+## What you should see
+
+The script prints the output shape `(1, 99)` and, for the center forecast hour,
+the P10 (low), P50 (median), and P90 (high) power levels as a fraction of site capacity,
+plus the width of the P10 to P90 uncertainty band. Input shapes are solar `(1, 6, 20)`,
+wind `(1, 12, 15)`.
+
+The example uses a random input window so it runs without a data download. Replace it with
+a real NWP window (the same shape) to get a real forecast.

quickstart/requirements.txt

@@ -0,0 +1,4 @@
+torch==2.3.1
+numpy==1.26.4
+safetensors==0.4.3
+huggingface_hub==0.23.4

quickstart/run.py

@@ -0,0 +1,41 @@
+import argparse
+import os
+import sys
+import torch
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+import modeling
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--track", choices=["solar", "wind"], default="solar")
+    ap.add_argument(
+        "--weights",
+        default=None,
+        help="path to the track's safetensors (defaults to <track>.safetensors)",
+    )
+    args = ap.parse_args()
+    weights = args.weights or f"{args.track}.safetensors"
+    steps, feats = modeling.expected_shape(args.track)
+    raw_window = torch.randn(steps, feats)
+    nwp = modeling.preprocess_nwp(raw_window, track=args.track)
+    model = modeling.load_model(weights, track=args.track)
+    with torch.no_grad():
+        quantiles = model(nwp)
+    p10 = quantiles[0, 9].item()
+    p50 = quantiles[0, 49].item()
+    p90 = quantiles[0, 89].item()
+    print(f"Track: {args.track}")
+    print(
+        f"Output shape: {tuple(quantiles.shape)}  (batch, 99 quantiles for the center hour)"
+    )
+    print("Center forecast hour, power as fraction of site capacity:")
+    print(f"  P10 (low):    {p10:.4f}")
+    print(f"  P50 (median): {p50:.4f}")
+    print(f"  P90 (high):   {p90:.4f}")
+    print(f"  P10..P90 uncertainty band width: {p90 - p10:.4f}")
+
+
+if __name__ == "__main__":
+    main()

solar.safetensors

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

space/README.md

@@ -0,0 +1,42 @@
+---
+title: FELA Grid Renewable
+emoji: power
+colorFrom: green
+colorTo: gray
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
+pinned: false
+license: other
+---
+
+# FELA Grid Renewable playground
+
+Pick solar or wind, pick a sample weather window, and see the model's probabilistic power
+forecast: the P10 low estimate, the P50 median, and the P90 high estimate, all as a
+fraction of the site's rated capacity. The gap between P10 and P90 is the uncertainty band
+a grid operator plans against.
+
+## Play data
+
+The sample weather windows are a small GEFCom2014 style set of numerical weather
+prediction (NWP) inputs. GEFCom2014 is the public Global Energy Forecasting Competition
+2014 dataset (Hong, Pinson, Fan, Zareipour, Troccoli, Hyndman, 2016, International Journal
+of Forecasting 32(3)). It is the public competition release; check the competition terms
+before rehosting it. The samples are kept small so the Space loads fast.
+
+If the bundled sample (`solar_demo.json`, `wind_demo.json`) is not present, the app falls
+back to synthetic NWP windows of the correct shape so the Space still runs. The synthetic
+fallback shows the input and output shapes working, not a real site forecast.
+
+Input shapes are solar `(1, 6, 20)`, wind `(1, 12, 15)`.
+
+## Weights
+
+The safetensors weight files (`solar.safetensors`, `wind.safetensors`) ship with the model
+and load through the bundled `modeling.load_model`. If they are absent the app shows a notice.
+
+## License
+
+Released under the Lowdown Labs Lovely License 1.0. See the model repo for the
+full license text.

space/app.py

@@ -0,0 +1,95 @@
+import json
+import os
+import sys
+import gradio as gr
+import numpy as np
+import torch
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, os.path.join(HERE, ".."))
+SHAPES = {"solar": (6, 20), "wind": (12, 15)}
+WEIGHTS_SAFE = {
+    "solar": os.path.join(HERE, "solar.safetensors"),
+    "wind": os.path.join(HERE, "wind.safetensors"),
+}
+WEIGHTS_PT = {
+    "solar": os.path.join(HERE, "solar.pt"),
+    "wind": os.path.join(HERE, "wind.pt"),
+}
+SAMPLES = {
+    "solar": os.path.join(HERE, "solar_demo.json"),
+    "wind": os.path.join(HERE, "wind_demo.json"),
+}
+_models = {}
+
+
+def load_model(track):
+    if track not in _models:
+        if os.path.exists(WEIGHTS_SAFE[track]):
+            import modeling
+
+            m = modeling.load_model(WEIGHTS_SAFE[track], track=track)
+            m.eval()
+            _models[track] = m
+        elif os.path.exists(WEIGHTS_PT[track]):
+            m = torch.load(WEIGHTS_PT[track], map_location="cpu", weights_only=False)
+            m.eval()
+            _models[track] = m
+        else:
+            _models[track] = None
+    return _models[track]
+
+
+def load_sample_windows(track):
+    path = SAMPLES[track]
+    steps, feats = SHAPES[track]
+    if os.path.exists(path):
+        with open(path) as f:
+            data = json.load(f)
+        windows = data.get("windows", data) if isinstance(data, dict) else data
+        return [np.asarray(w, dtype=np.float32).reshape(steps, feats) for w in windows]
+    rng = np.random.default_rng(0)
+    return [rng.standard_normal((steps, feats)).astype(np.float32) for _ in range(8)]
+
+
+def forecast(track, sample_idx):
+    steps, feats = SHAPES[track]
+    windows = load_sample_windows(track)
+    sample_idx = int(sample_idx) % len(windows)
+    nwp = torch.from_numpy(windows[sample_idx]).unsqueeze(0)
+    model = load_model(track)
+    if model is None:
+        return "Weights are not found in this Space. Ensure solar.safetensors / wind.safetensors are present next to app.py."
+    with torch.no_grad():
+        q = model(nwp)
+    q = q[0].cpu().numpy()
+    p10, p50, p90 = (q[9], q[49], q[89])
+    lines = [
+        f"Track: {track}",
+        f"Sample window {sample_idx} of {len(windows)}",
+        "First forecast hour (power as a fraction of site capacity, 0 to 1):",
+        f"  P10 (low estimate):    {p10:.4f}",
+        f"  P50 (median forecast): {p50:.4f}",
+        f"  P90 (high estimate):   {p90:.4f}",
+        f"  P10 to P90 band width: {p90 - p10:.4f}",
+        "",
+        "The P10 to P90 band is the range the actual output should fall in most of the",
+        "time. A wide band means the weather input is uncertain for this hour.",
+    ]
+    return "\n".join(lines)
+
+
+with gr.Blocks(title="FELA Grid Renewable") as demo:
+    gr.Markdown(
+        "# FELA Grid Renewable\nProbabilistic solar and wind power forecasting that runs on a microcontroller at the station. Pick a track and a sample weather window to see the forecast range (P10 low, P50 median, P90 high), as a fraction of the site's rated capacity.\n\nPlay data is a small GEFCom2014-style sample of numerical weather prediction windows (public competition data, Hong et al. 2016). See the Space README."
+    )
+    with gr.Row():
+        track = gr.Radio(["solar", "wind"], value="solar", label="Track")
+        sample_idx = gr.Slider(0, 7, value=0, step=1, label="Sample weather window")
+    out = gr.Textbox(label="Forecast", lines=12)
+    btn = gr.Button("Forecast")
+    btn.click(forecast, inputs=[track, sample_idx], outputs=out)
+    track.change(forecast, inputs=[track, sample_idx], outputs=out)
+    sample_idx.change(forecast, inputs=[track, sample_idx], outputs=out)
+if __name__ == "__main__":
+    demo.launch()

space/requirements.txt

@@ -0,0 +1,3 @@
+torch>=2.0
+numpy
+gradio>=4.0

streaming/manifest.json

@@ -0,0 +1,28 @@
+{
+  "model": "grid-renewable",
+  "format": "fp16-streaming",
+  "note": "load order is smallest-first for progressive/streaming load",
+  "files": [
+    {
+      "file": "model_fp16.safetensors",
+      "source": "model.safetensors",
+      "dtype": "fp16",
+      "bytes": 375928,
+      "approx_mb": 0.359
+    },
+    {
+      "file": "solar_fp16.safetensors",
+      "source": "solar.safetensors",
+      "dtype": "fp16",
+      "bytes": 375928,
+      "approx_mb": 0.359
+    },
+    {
+      "file": "wind_fp16.safetensors",
+      "source": "wind.safetensors",
+      "dtype": "fp16",
+      "bytes": 958228,
+      "approx_mb": 0.914
+    }
+  ]
+}

streaming/model_fp16.safetensors

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

streaming/solar_fp16.safetensors

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

streaming/wind_fp16.safetensors

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

train.py

@@ -0,0 +1,283 @@
+import sys, time, os, numpy as np, pandas as pd, torch, torch.nn as nn, torch.nn.functional as F
+
+dev = "cuda" if torch.cuda.is_available() else "cpu"
+torch.manual_seed(2024)
+np.random.seed(2024)
+if dev == "cpu" and os.environ.get("OMP_NUM_THREADS"):
+    torch.set_num_threads(int(os.environ["OMP_NUM_THREADS"]))
+valflags = {"--save", "--arch", "--lr"}
+pos = []
+av = sys.argv[1:]
+i = 0
+while i < len(av):
+    if av[i] in valflags:
+        i += 2
+        continue
+    if av[i].startswith("--"):
+        i += 1
+        continue
+    pos.append(av[i])
+    i += 1
+track = pos[0]
+dL, dm, dD, dn = {"solar": (6, 3, 64, 4), "wind": (12, 6, 96, 3)}[track]
+L = int(pos[1]) if len(pos) > 1 else dL
+modes = int(pos[2]) if len(pos) > 2 else dm
+D = int(pos[3]) if len(pos) > 3 else dD
+nblk = int(pos[4]) if len(pos) > 4 else dn
+ep = int(pos[5]) if len(pos) > 5 else 80
+save = sys.argv[sys.argv.index("--save") + 1] if "--save" in sys.argv else None
+arch = sys.argv[sys.argv.index("--arch") + 1] if "--arch" in sys.argv else "dual"
+lr = float(sys.argv[sys.argv.index("--lr") + 1]) if "--lr" in sys.argv else 0.002
+smoke = "--smoke" in sys.argv
+prep = "/workspace/gefcom/prep"
+qs = np.arange(1, 100) / 100.0
+nwp = {
+    "solar": [
+        "VAR78",
+        "VAR79",
+        "VAR134",
+        "VAR157",
+        "VAR164",
+        "VAR165",
+        "VAR166",
+        "VAR167",
+        "VAR169",
+        "VAR175",
+        "VAR178",
+        "VAR228",
+    ],
+    "wind": ["U10", "V10", "U100", "V100"],
+}[track]
+
+
+def build():
+    df = (
+        pd.read_parquet(f"{prep}/{track}.parquet")
+        .sort_values(["ZONEID", "TIMESTAMP"])
+        .reset_index(drop=True)
+    )
+    df["hour"] = df.TIMESTAMP.dt.hour
+    df["doy"] = df.TIMESTAMP.dt.dayofyear
+    df["hsin"] = np.sin(2 * np.pi * df.hour / 24)
+    df["hcos"] = np.cos(2 * np.pi * df.hour / 24)
+    df["dsin"] = np.sin(2 * np.pi * df.doy / 365.25)
+    df["dcos"] = np.cos(2 * np.pi * df.doy / 365.25)
+    feats = list(nwp) + ["hsin", "hcos", "dsin", "dcos"]
+    if track == "wind":
+        df["ws10"] = np.hypot(df.U10, df.V10)
+        df["ws100"] = np.hypot(df.U100, df.V100)
+        df["wd100"] = np.arctan2(df.V100, df.U100)
+        df["wds"] = np.sin(df.wd100)
+        df["wdc"] = np.cos(df.wd100)
+        df["ws100_2"] = df.ws100**2
+        df["ws100_3"] = df.ws100**3
+        df["shear"] = df.ws100 - df.ws10
+        feats += ["ws10", "ws100", "wds", "wdc", "ws100_2", "ws100_3", "shear"]
+    else:
+        df["csi"] = df.VAR169 / (df.VAR178 + 1000.0)
+        df["cloud2"] = df.VAR164**2
+        df["temp_c"] = df.VAR167 - 273.15
+        df["daylight"] = (df.VAR178 > 10000.0).astype(np.float32)
+        feats += ["csi", "cloud2", "temp_c", "daylight"]
+    tr = df.is_test == 0
+    mu = df.loc[tr, feats].mean()
+    sd = df.loc[tr, feats].std() + 1e-06
+    df[feats] = (df[feats] - mu) / sd
+    df["y"] = df["y"].fillna(0.0)
+    X, Y, M = ([], [], [])
+    half = L // 2
+    for z, g in df.groupby("ZONEID"):
+        g = g.reset_index(drop=True)
+        fv = g[feats].values.astype(np.float32)
+        powr = g["y"].values.astype(np.float32)
+        iste = g["is_test"].values
+        T = len(g)
+        for i in range(T):
+            a = i - half
+            b = i - half + L
+            if a < 0 or b > T:
+                continue
+            X.append(fv[a:b])
+            Y.append(powr[i])
+            M.append(iste[i])
+    X = torch.tensor(np.array(X, dtype=np.float32))
+    Y = torch.tensor(np.array(Y, dtype=np.float32))
+    return (X, Y, np.array(M), df, feats)
+
+
+class RevIN(nn.Module):
+    def __init__(self, C):
+        super().__init__()
+        self.g = nn.Parameter(torch.ones(C))
+        self.b = nn.Parameter(torch.zeros(C))
+
+    def norm(self, x):
+        self.m = x.mean(1, keepdim=True)
+        self.s = x.std(1, keepdim=True) + 1e-05
+        return (x - self.m) / self.s * self.g + self.b
+
+
+class FNO1D(nn.Module):
+    def __init__(self, D, modes):
+        super().__init__()
+        self.modes = modes
+        s = 1 / (D * D)
+        self.w = nn.Parameter(s * torch.rand(modes, D, D, dtype=torch.cfloat))
+
+    def forward(self, x):
+        P = x.shape[1]
+        xf = torch.fft.rfft(x, dim=1)
+        m = min(self.modes, xf.shape[1])
+        o = torch.zeros_like(xf)
+        o[:, :m] = torch.einsum("bpd,pde->bpe", xf[:, :m], self.w[:m])
+        return torch.fft.irfft(o, n=P, dim=1)
+
+
+class Block(nn.Module):
+    def __init__(self, D, modes, ff=2, drop=0.1):
+        super().__init__()
+        self.n1 = nn.LayerNorm(D)
+        self.fno = FNO1D(D, modes)
+        self.d1 = nn.Dropout(drop)
+        self.n2 = nn.LayerNorm(D)
+        self.ff = nn.Sequential(
+            nn.Linear(D, D * ff), nn.GELU(), nn.Dropout(drop), nn.Linear(D * ff, D)
+        )
+
+    def forward(self, x):
+        x = x + self.d1(self.fno(self.n1(x)))
+        return x + self.ff(self.n2(x))
+
+
+class FELA_Grid(nn.Module):
+    def __init__(self, Fin, L, D=96, modes=6, nblk=3, nq=99, arch="dual"):
+        super().__init__()
+        self.L = L
+        self.arch = arch
+        self.center = L // 2
+        self.nq = nq
+        self.revin = RevIN(Fin)
+        self.embed = nn.Linear(Fin, D)
+        self.pos = nn.Parameter(0.02 * torch.randn(1, L, D))
+        self.blocks = nn.ModuleList([Block(D, modes) for _ in range(nblk)])
+        self.norm = nn.LayerNorm(D)
+        if arch == "dual":
+            self.direct = nn.Sequential(
+                nn.Linear(Fin, D), nn.GELU(), nn.Linear(D, D), nn.GELU()
+            )
+            fuse_in = 2 * D
+        else:
+            fuse_in = D
+        self.med = nn.Linear(fuse_in, 1)
+        self.spread = nn.Linear(fuse_in, nq)
+        self.register_buffer("qidx", torch.arange(nq))
+
+    def forward(self, x):
+        xc = x[:, self.center]
+        xn = self.revin.norm(x)
+        h = self.embed(xn) + self.pos
+        for b in self.blocks:
+            h = b(h)
+        ctx = self.norm(h)[:, self.center]
+        z = torch.cat([ctx, self.direct(xc)], dim=1) if self.arch == "dual" else ctx
+        med = torch.sigmoid(self.med(z))
+        w = F.softplus(self.spread(z))
+        half = self.nq // 2
+        below = -torch.flip(torch.cumsum(torch.flip(w[:, :half], [1]), 1), [1])
+        above = torch.cumsum(w[:, half + 1 :], 1)
+        offs = (
+            torch.cat([below, torch.zeros_like(w[:, half : half + 1]), above], dim=1)
+            * 0.05
+        )
+        return torch.clamp(med + offs, 0, 1)
+
+
+def pinball(pred, y, qs):
+    y = y[:, None]
+    e = y - pred
+    return torch.maximum(qs[None, :] * e, (qs[None, :] - 1) * e).mean()
+
+
+def main():
+    X, Y, M, df, feats = build()
+    Fin = X.shape[2]
+    tr_idx = np.where(M == 0)[0]
+    te_idx = np.where(M == 1)[0]
+    yte = Y[te_idx].numpy()
+    keep = ~np.isnan(yte)
+    te_idx = te_idx[keep]
+    nval = int(len(tr_idx) * 0.06)
+    va_idx = tr_idx[-nval:]
+    tr_idx = tr_idx[:-nval]
+    assert len(te_idx) == {"solar": 2154, "wind": 7390}[track]
+    if smoke:
+        print(
+            f"{track} Test_windows {len(te_idx)} train {len(tr_idx)} val {len(va_idx)} zones {df.ZONEID.nunique()}"
+        )
+        return
+    qst = torch.tensor(qs, dtype=torch.float32, device=dev)
+    Xtr, Ytr = (X[tr_idx].to(dev), Y[tr_idx].to(dev))
+    Xva, Yva = (X[va_idx].to(dev), Y[va_idx].to(dev))
+    Xte, Yte = (X[te_idx].to(dev), Y[te_idx].to(dev))
+    m = FELA_Grid(Fin, L, D=D, modes=modes, nblk=nblk, arch=arch).to(dev)
+    npar = sum((p.numel() for p in m.parameters()))
+    print(
+        f"[{track}] arch={arch} L={L} modes={modes} D={D} nblk={nblk} Fin={Fin} | train {len(Xtr)} val {len(Xva)} test {len(Xte)} | {npar / 1000.0:.0f}K"
+    )
+    opt = torch.optim.Adam(m.parameters(), lr=lr, weight_decay=1e-05)
+    sched = torch.optim.lr_scheduler.CosineAnnealingLR(opt, ep)
+    bs = 512
+
+    def ev(Xs, Ys):
+        m.eval()
+        with torch.no_grad():
+            ps = [m(Xs[i : i + 8192]) for i in range(0, len(Xs), 8192)]
+            p = torch.cat(ps)
+            return (pinball(p, Ys, qst).item(), p)
+
+    best = 1000000000.0
+    bstate = None
+    bad = 0
+    for e in range(ep):
+        m.train()
+        perm = torch.randperm(len(Xtr), device=dev)
+        for i in range(0, len(Xtr) - bs, bs):
+            idx = perm[i : i + bs]
+            loss = pinball(m(Xtr[idx]), Ytr[idx], qst)
+            opt.zero_grad()
+            loss.backward()
+            opt.step()
+        sched.step()
+        vpb, _ = ev(Xva, Yva)
+        if vpb < best:
+            best = vpb
+            bstate = {k: v.detach().clone() for k, v in m.state_dict().items()}
+            bad = 0
+        else:
+            bad += 1
+        if bad >= 15:
+            break
+    m.load_state_dict(bstate)
+    tpb, _ = ev(Xte, Yte)
+    bench = {"solar": 0.0285, "wind": 0.0792}[track]
+    print(
+        f"RESULT {track} pinball {tpb:.5f} (off.bench {bench}) | {npar / 1000.0:.0f}K"
+    )
+    if save:
+        torch.save(
+            {
+                "state": m.state_dict(),
+                "cfg": dict(Fin=Fin, L=L, D=D, modes=modes, nblk=nblk),
+                "feats": feats,
+                "track": track,
+                "test_pinball": tpb,
+                "off_bench": bench,
+                "npar": npar,
+            },
+            save,
+        )
+        print(f"SAVED {save}")
+
+
+if __name__ == "__main__":
+    main()

verify.py

@@ -0,0 +1,44 @@
+import argparse
+import os
+import sys
+import torch
+
+sys.path.insert(0, os.path.dirname(__file__))
+from modeling import load_model
+
+SHAPES = {"solar": (1, 6, 20), "wind": (1, 12, 15)}
+VERIFICATION = {"solar": 1e-06, "wind": 0.446117}
+TOL = 0.001
+
+
+def fixed_input(track):
+    torch.manual_seed(0)
+    return torch.randn(*SHAPES[track])
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--track", choices=["solar", "wind"], required=True)
+    ap.add_argument("--weights", default=".")
+    args = ap.parse_args()
+    model = load_model(args.weights, track=args.track)
+    x = fixed_input(args.track)
+    with torch.no_grad():
+        out = model(x)
+    if out.dim() != 2 or out.shape[0] != 1 or out.shape[-1] != 99:
+        print(f"Fail: unexpected output shape {tuple(out.shape)}, expected (1, 99)")
+        sys.exit(1)
+    p50 = out[0, 49].item()
+    print(f"Captured first-hour P50 for {args.track}: {p50:.6f}")
+    ref = VERIFICATION[args.track]
+    if abs(p50 - ref) > TOL:
+        print(
+            f"Fail: P50 {p50:.6f} differs from verification {ref:.6f} by more than {TOL}"
+        )
+        sys.exit(1)
+    print(f"Verification check OK (P50 within {TOL} of {ref:.6f})")
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

wind.safetensors

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