feat(models): add plain channel-independent MLP forecaster

MLP applies the same input_len->output_len network to every channel with no
normalization, no residual block, and no linear shortcut. Configurable via
--hidden_dim (128), --n_layers (2), --dropout (0). Added to docs/models.md
(table row, cited Rumelhart et al. 1986 - the OG MLP); README count 77 -> 78.

Author: neko941

README.md

@@ -50,7 +50,7 @@ Get started with FedProC in just a few steps:
 - **[Usage](docs/usage.md)** - Basic usage and examples
 - **[Strategies](docs/strategies.md)** - Available federated learning strategies (55 strategies)
 - **[Datasets](docs/datasets.md)** - Supported datasets and data preparation (31 datasets)
-- **[Models](docs/models.md)** - Available models and architectures (77 models)
+- **[Models](docs/models.md)** - Available models and architectures (78 models)
 - **[Augmentations](docs/augs.md)** - Custom GPU-native PyTorch augmentations (8 augmentations)
 - **[Losses](docs/losses.md)** - Loss functions and metrics (19 losses)
 - **[Optimizers](docs/optimizers.md)** - Optimization methods (9 optimizers)

docs/models.md

@@ -9,6 +9,7 @@ Auxiliary (eg: static time-varying features, future time-varying features, etc)
 | Sonnet | Wavelet + Koopman + Attention | Multivariate | AAAI (Oral) | 2026 | Sonnet: Spectral Operator Neural Network for Multivariable Time Series Forecasting | [Arxiv](https://arxiv.org/abs/2505.15312) - [GitHub](https://github.com/ClaudiaShu/Sonnet) |
 | SimTS | Causal CNN (contrastive pre-training) | Multivariate | ICASSP | 2024 | SimTS: Rethinking Contrastive Representation Learning for Time Series Forecasting | [Arxiv](https://arxiv.org/abs/2303.18205) - [IEEE](https://ieeexplore.ieee.org/document/10446875) - [GitHub](https://github.com/xingyu617/SimTS_Representation_Learning) |
 | Amplifier | MLP | Multivariate | AAAI | 2025 | Amplifier: Bringing Attention to Neglected Low-Energy Components in Time Series Forecasting | [Arxiv](https://arxiv.org/abs/2501.17216) - [REF](https://github.com/aikunyi/Amplifier/blob/main/models/Amplifier.py) |
+| MLP | MLP | Univariate | Nature | 1986 | Learning representations by back-propagating errors | [Nature](https://www.nature.com/articles/323533a0) |
 | Linear | MLP | Univariate | AAAI | 2023 | Are Transformers Effective for Time Series Forecasting? | [Arxiv](https://arxiv.org/abs/2205.13504) - [REF](https://github.com/cure-lab/LTSF-Linear/blob/main/models/Linear.py) |
 | LinearIC | MLP | Univariate | AAAI | 2023 | Are Transformers Effective for Time Series Forecasting? | [Arxiv](https://arxiv.org/abs/2205.13504) - [REF](https://github.com/cure-lab/LTSF-Linear/blob/main/models/Linear.py) |
 | NLinear | MLP | Univariate | AAAI | 2023 | Are Transformers Effective for Time Series Forecasting? | [Arxiv](https://arxiv.org/abs/2205.13504) - [REF](https://github.com/cure-lab/LTSF-Linear/blob/main/models/NLinear.py) |

models/MLP.py

@@ -0,0 +1,50 @@
+import torch.nn as nn
+
+
+class MLP(nn.Module):
+    """Plain channel-independent MLP forecaster.
+
+    Minimal over-parameterizable nonlinear baseline. Unlike TiDE there is no
+    normalization, no residual block, and no linear shortcut, so the
+    memorize -> plateau -> generalize (grokking) dynamics are not damped by an
+    auxiliary linear path. The same MLP is applied to every channel
+    (input_len -> output_len), keeping the parameter count small and the
+    capacity/data ratio easy to control.
+    """
+
+    optional = {
+        "hidden_dim": 128,
+        "n_layers": 2,
+        "dropout": 0.0,
+    }
+
+    @classmethod
+    def args_update(cls, parser):
+        parser.add_argument("--hidden_dim", type=int, default=None)
+        parser.add_argument("--n_layers", type=int, default=None)
+        parser.add_argument("--dropout", type=float, default=None)
+
+    def __init__(self, configs):
+        super().__init__()
+        in_dim = configs.input_len
+        out_dim = configs.output_len
+        h = configs.hidden_dim
+        n = configs.n_layers
+        dropout = configs.dropout
+
+        dims = [in_dim] + [h] * n
+        layers = []
+        for a, b in zip(dims[:-1], dims[1:]):
+            layers.append(nn.Linear(a, b))
+            layers.append(nn.ReLU())
+            if dropout and dropout > 0:
+                layers.append(nn.Dropout(dropout))
+        layers.append(nn.Linear(dims[-1], out_dim))
+        self.net = nn.Sequential(*layers)
+
+    def forward(self, x, **kwargs):
+        # x: [batch, input_len, channels]
+        x = x.permute(0, 2, 1)  # [batch, channels, input_len]
+        x = self.net(x)  # [batch, channels, output_len]
+        x = x.permute(0, 2, 1)  # [batch, output_len, channels]
+        return x