1{
2  "start_line": 1,
3  "op": "replace",
4  "filename": "models/Custom.py",
5  "end_line": 45,
6  "content": "import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom layers.Embed import PatchEmbedding\n\nclass FourierMixerBlock(nn.Module):\n    \"\"\"\n    Applies a Global Fourier Neural Operator over the sequence of patches,\n    acting as a sequence-length independent, highly expressive temporal mixer.\n    \"\"\"\n    def __init__(self, d_model, num_patches, d_ff, dropout=0.1):\n        super().__init__()\n        self.norm1 = nn.LayerNorm(d_model)\n        self.freq_len = num_patches // 2 + 1\n        \n        # Learnable complex global filter in the frequency domain\n        self.filter_real = nn.Parameter(torch.randn(1, d_model, self.freq_len, dtype=torch.float32) * 0.02)\n        self.filter_imag = nn.Parameter(torch.randn(1, d_model, self.freq_len, dtype=torch.float32) * 0.02)\n        \n        self.dropout1 = nn.Dropout(dropout)\n        \n        self.norm2 = nn.LayerNorm(d_model)\n        self.mlp = nn.Sequential(\n            nn.Linear(d_model, d_ff),\n            nn.GELU(),\n            nn.Dropout(dropout),\n            nn.Linear(d_ff, d_model),\n            nn.Dropout(dropout)\n        )\n    \n    def forward(self, x):\n        # x: [B*V, P, d_model]\n        res = x\n        x = self.norm1(x)\n        \n        # Move to frequency domain over the patch sequence\n        x_t = x.transpose(1, 2) # [B*V, d_model, P]\n        x_f = torch.fft.rfft(x_t, dim=-1) # [B*V, d_model, P/2+1]\n        \n        # Perform dynamic spectral-temporal gating/mixing\n        weight = torch.complex(self.filter_real, self.filter_imag)\n        x_f = x_f * weight\n        \n        # Inverse FFT to time domain\n        x_out = torch.fft.irfft(x_f, n=x_t.shape[-1], dim=-1) # [B*V, d_model, P]\n        x_out = x_out.transpose(1, 2) # [B*V, P, d_model]\n        \n        x = res + self.dropout1(x_out)\n        x = x + self.mlp(self.norm2(x))\n        return x\n\n\nclass Model(nn.Module):\n    \"\"\"\n    Fourier-Gated Context-Modulated Patch Network (FGC-Net).\n    A novel algorithmic architecture for TS classification integrating:\n    1. Independent patch extraction.\n    2. Global Fourier temporal operator for scale-robust mixing.\n    3. Cross-variable context modulation via query-pooled summary variables.\n    \"\"\"\n    def __init__(self, configs):\n        super(Model, self).__init__()\n        self.task_name = configs.task_name\n        self.seq_len = configs.seq_len\n        self.enc_in = configs.enc_in\n        self.num_class = configs.num_class\n        \n        # Extracted configurations\n        self.patch_len = 16\n        self.stride = 8\n        self.d_model = getattr(configs, 'd_model', 128)\n        self.d_ff = getattr(configs, 'd_ff', 256)\n        self.e_layers = getattr(configs, 'e_layers', 2)\n        self.dropout = getattr(configs, 'dropout', 0.1)\n        self.n_heads = getattr(configs, 'n_heads', 4)\n        \n        self.num_patches = int((self.seq_len - self.patch_len) / self.stride + 2)\n        \n        # 1. Patch Embedding (Channel Independent)\n        self.patch_embedding = PatchEmbedding(\n            self.d_model, self.patch_len, self.stride, self.stride, self.dropout\n        )\n        \n        # 2. Sequential Temporal Processing\n        self.temporal_blocks = nn.ModuleList([\n            FourierMixerBlock(self.d_model, self.num_patches, self.d_ff, self.dropout)\n            for _ in range(self.e_layers)\n        ])\n        \n        # 3. Variable Summary Extraction (Attentional Query Pooling)\n        self.summary_query = nn.Parameter(torch.randn(1, 1, self.d_model) * 0.02)\n        self.pool_attn = nn.MultiheadAttention(self.d_model, self.n_heads, batch_first=True, dropout=self.dropout)\n        \n        # 4. Cross-Variable Modulation\n        self.var_embed = nn.Parameter(torch.randn(1, self.enc_in, self.d_model) * 0.02)\n        self.var_attn = nn.MultiheadAttention(self.d_model, self.n_heads, batch_first=True, dropout=self.dropout)\n        self.var_norm = nn.LayerNorm(self.d_model)\n        \n        self.gamma = nn.Parameter(torch.zeros(1))\n        \n        # 5. Readout Classifier\n        self.head = nn.Sequential(\n            nn.Flatten(start_dim=1),\n            nn.Dropout(self.dropout),\n            nn.Linear(self.enc_in * self.d_model * self.num_patches, self.num_class)\n        )\n        \n    def classification(self, x_enc, x_mark_enc):\n        B, L, V = x_enc.shape\n        \n        # Channel-wise sequence normalization (InstanceNorm variant)\n        means = x_enc.mean(1, keepdim=True).detach()\n        x_enc = x_enc - means\n        stdev = torch.sqrt(torch.var(x_enc, dim=1, keepdim=True, unbiased=False) + 1e-5).detach()\n        x_enc = x_enc / stdev\n\n        # Sub-sequence patching\n        x_enc_p = x_enc.permute(0, 2, 1) # [B, V, L]\n        enc_out, _ = self.patch_embedding(x_enc_p) # [B*V, P, d_model]\n        \n        # Sequence robust mixing over patches\n        for block in self.temporal_blocks:\n            enc_out = block(enc_out)\n        \n        # Abstract temporal patterns into a single representation per variable\n        query = self.summary_query.expand(B * V, -1, -1) # [B*V, 1, d_model]\n        summary, _ = self.pool_attn(query, enc_out, enc_out) # [B*V, 1, d_model]\n        summary = summary.squeeze(1) # [B*V, d_model]\n        \n        # Global context formulation: attend across variables\n        summary = summary.view(B, V, self.d_model)\n        summary = summary + self.var_embed\n        \n        res = summary\n        summary = self.var_norm(summary)\n        var_out, _ = self.var_attn(summary, summary, summary)\n        var_out = res + var_out # [B, V, d_model]\n        \n        # Context-Modulated fine-grained temporal features\n        var_mod = var_out.view(B * V, 1, self.d_model)\n        enc_out = enc_out + self.gamma * var_mod # Broadcast global contextual modulation to all patches [B*V, P, d_model]\n        \n        enc_out = enc_out.view(B, V, self.num_patches, self.d_model)\n        \n        # Flatten [B, V, P, d_model] to [B, V * P * d_model] for un-pooled classification\n        logits = self.head(enc_out)\n        return logits\n\n    def forward(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask=None):\n        if self.task_name == 'classification':\n            dec_out = self.classification(x_enc, x_mark_enc)\n            return dec_out\n        return None"
7}

1{
2  "content": "import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom layers.Embed import PatchEmbedding\n\nclass FourierMixerBlock(nn.Module):\n    \"\"\"\n    Applies a Global Fourier Neural Operator over the sequence of patches,\n    acting as a sequence-length independent, highly expressive temporal mixer.\n    \"\"\"\n    def __init__(self, d_model, num_patches, d_ff, dropout=0.1):\n        super().__init__()\n        self.norm1 = nn.LayerNorm(d_model)\n        self.freq_len = num_patches // 2 + 1\n        \n        # Learnable complex global filter in the frequency domain\n        self.filter_real = nn.Parameter(torch.randn(1, d_model, self.freq_len, dtype=torch.float32) * 0.02)\n        self.filter_imag = nn.Parameter(torch.randn(1, d_model, self.freq_len, dtype=torch.float32) * 0.02)\n        \n        self.dropout1 = nn.Dropout(dropout)\n        \n        self.norm2 = nn.LayerNorm(d_model)\n        self.mlp = nn.Sequential(\n            nn.Linear(d_model, d_ff),\n            nn.GELU(),\n            nn.Dropout(dropout),\n            nn.Linear(d_ff, d_model),\n            nn.Dropout(dropout)\n        )\n    \n    def forward(self, x):\n        # x: [B*V, P, d_model]\n        res = x\n        x = self.norm1(x)\n        \n        # Move to frequency domain over the patch sequence\n        x_t = x.transpose(1, 2) # [B*V, d_model, P]\n        x_f = torch.fft.rfft(x_t, dim=-1) # [B*V, d_model, P/2+1]\n        \n        # Perform dynamic spectral-temporal gating/mixing\n        weight = torch.complex(self.filter_real, self.filter_imag)\n        x_f = x_f * weight\n        \n        # Inverse FFT to time domain\n        x_out = torch.fft.irfft(x_f, n=x_t.shape[-1], dim=-1) # [B*V, d_model, P]\n        x_out = x_out.transpose(1, 2) # [B*V, P, d_model]\n        \n        x = res + self.dropout1(x_out)\n        x = x + self.mlp(self.norm2(x))\n        return x\n\n\nclass Model(nn.Module):\n    \"\"\"\n    Fourier-Gated Context-Modulated Patch Network (FGC-Net).\n    A novel algorithmic architecture for TS classification integrating:\n    1. Independent patch extraction.\n    2. Global Fourier temporal operator for scale-robust mixing.\n    3. Cross-variable context modulation via query-pooled summary variables.\n    \"\"\"\n    def __init__(self, configs):\n        super(Model, self).__init__()\n        self.task_name = configs.task_name\n        self.seq_len = configs.seq_len\n        self.enc_in = configs.enc_in\n        self.num_class = configs.num_class\n        \n        # Extracted configurations\n        self.patch_len = 16\n        self.stride = 8\n        self.d_model = getattr(configs, 'd_model', 128)\n        self.d_ff = getattr(configs, 'd_ff', 256)\n        self.e_layers = getattr(configs, 'e_layers', 2)\n        self.dropout = getattr(configs, 'dropout', 0.1)\n        self.n_heads = getattr(configs, 'n_heads', 4)\n        \n        self.num_patches = int((self.seq_len - self.patch_len) / self.stride + 2)\n        \n        # 1. Patch Embedding (Channel Independent)\n        self.patch_embedding = PatchEmbedding(\n            self.d_model, self.patch_len, self.stride, self.stride, self.dropout\n        )\n        \n        # 2. Sequential Temporal Processing\n        self.temporal_blocks = nn.ModuleList([\n            FourierMixerBlock(self.d_model, self.num_patches, self.d_ff, self.dropout)\n            for _ in range(self.e_layers)\n        ])\n        \n        # 3. Variable Summary Extraction (Attentional Query Pooling)\n        self.summary_query = nn.Parameter(torch.randn(1, 1, self.d_model) * 0.02)\n        self.pool_attn = nn.MultiheadAttention(self.d_model, self.n_heads, batch_first=True, dropout=self.dropout)\n        \n        # 4. Cross-Variable Modulation\n        self.var_embed = nn.Parameter(torch.randn(1, self.enc_in, self.d_model) * 0.02)\n        self.var_attn = nn.MultiheadAttention(self.d_model, self.n_heads, batch_first=True, dropout=self.dropout)\n        self.var_norm = nn.LayerNorm(self.d_model)\n        \n        self.gamma = nn.Parameter(torch.zeros(1))\n        \n        # 5. Readout Classifier\n        self.head = nn.Sequential(\n            nn.Flatten(start_dim=1),\n            nn.Dropout(self.dropout),\n            nn.Linear(self.enc_in * self.d_model * self.num_patches, self.num_class)\n        )\n        \n    def classification(self, x_enc, x_mark_enc):\n        B, L, V = x_enc.shape\n        \n        # Channel-wise sequence normalization (InstanceNorm variant)\n        means = x_enc.mean(1, keepdim=True).detach()\n        x_enc = x_enc - means\n        stdev = torch.sqrt(torch.var(x_enc, dim=1, keepdim=True, unbiased=False) + 1e-5).detach()\n        x_enc = x_enc / stdev\n\n        # Sub-sequence patching\n        x_enc_p = x_enc.permute(0, 2, 1) # [B, V, L]\n        enc_out, _ = self.patch_embedding(x_enc_p) # [B*V, P, d_model]\n        \n        # Sequence robust mixing over patches\n        for block in self.temporal_blocks:\n            enc_out = block(enc_out)\n        \n        # Abstract temporal patterns into a single representation per variable\n        query = self.summary_query.expand(B * V, -1, -1) # [B*V, 1, d_model]\n        summary, _ = self.pool_attn(query, enc_out, enc_out) # [B*V, 1, d_model]\n        summary = summary.squeeze(1) # [B*V, d_model]\n        \n        # Global context formulation: attend across variables\n        summary = summary.view(B, V, self.d_model)\n        summary = summary + self.var_embed\n        \n        res = summary\n        summary = self.var_norm(summary)\n        var_out, _ = self.var_attn(summary, summary, summary)\n        var_out = res + var_out # [B, V, d_model]\n        \n        # Context-Modulated fine-grained temporal features\n        var_mod = var_out.view(B * V, 1, self.d_model)\n        enc_out = enc_out + self.gamma * var_mod # Broadcast global contextual modulation to all patches [B*V, P, d_model]\n        \n        enc_out = enc_out.view(B, V, self.num_patches, self.d_model)\n        \n        # Flatten [B, V, P, d_model] to [B, V * P * d_model] for un-pooled classification\n        logits = self.head(enc_out)\n        return logits\n\n    def forward(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask=None):\n        if self.task_name == 'classification':\n            dec_out = self.classification(x_enc, x_mark_enc)\n            return dec_out\n        return None",
3  "op": "replace",
4  "filename": "Time-Series-Library/models/Custom.py",
5  "end_line": 45,
6  "start_line": 1
7}

1{
2  "filename": "Time-Series-Library/models/Custom.py",
3  "content": "import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom layers.Embed import PatchEmbedding\n\nclass TemporalMixer(nn.Module):\n    \"\"\"\n    Mixes information across the temporal patch dimension.\n    \"\"\"\n    def __init__(self, d_model, num_patches, dropout=0.1):\n        super().__init__()\n        self.norm = nn.LayerNorm(d_model)\n        self.mlp = nn.Sequential(\n            nn.Linear(num_patches, num_patches * 2),\n            nn.GELU(),\n            nn.Dropout(dropout),\n            nn.Linear(num_patches * 2, num_patches),\n            nn.Dropout(dropout)\n        )\n        \n    def forward(self, x):\n        # x: [B, V, P, d_model]\n        res = x\n        x = self.norm(x)\n        # Mix across patches (P)\n        x = x.transpose(-1, -2) # [B, V, d_model, P]\n        x = self.mlp(x)\n        x = x.transpose(-1, -2) # [B, V, P, d_model]\n        return res + x\n\n\nclass VariableMixer(nn.Module):\n    \"\"\"\n    Mixes information across the channels/variables.\n    \"\"\"\n    def __init__(self, num_vars, d_model, dropout=0.1):\n        super().__init__()\n        self.norm = nn.LayerNorm(d_model)\n        hidden_dim = max(num_vars * 2, 16) # Safely handle num_vars=1\n        self.mlp = nn.Sequential(\n            nn.Linear(num_vars, hidden_dim),\n            nn.GELU(),\n            nn.Dropout(dropout),\n            nn.Linear(hidden_dim, num_vars),\n            nn.Dropout(dropout)\n        )\n        \n    def forward(self, x):\n        # x: [B, V, P, d_model]\n        res = x\n        x = self.norm(x)\n        # Mix across variables (V)\n        x = x.permute(0, 2, 3, 1) # [B, P, d_model, V]\n        x = self.mlp(x)\n        x = x.permute(0, 3, 1, 2) # [B, V, P, d_model]\n        return res + x\n\n\nclass FeatureMixer(nn.Module):\n    \"\"\"\n    Mixes information within features/channels mappings.\n    \"\"\"\n    def __init__(self, d_model, d_ff, dropout=0.1):\n        super().__init__()\n        self.norm = nn.LayerNorm(d_model)\n        self.mlp = nn.Sequential(\n            nn.Linear(d_model, d_ff),\n            nn.GELU(),\n            nn.Dropout(dropout),\n            nn.Linear(d_ff, d_model),\n            nn.Dropout(dropout)\n        )\n        \n    def forward(self, x):\n        # x: [B, V, P, d_model]\n        return x + self.mlp(self.norm(x))\n\n\nclass TVMixerBlock(nn.Module):\n    def __init__(self, num_vars, num_patches, d_model, d_ff, dropout=0.1):\n        super().__init__()\n        self.temporal_mixer = TemporalMixer(d_model, num_patches, dropout)\n        self.variable_mixer = VariableMixer(num_vars, d_model, dropout)\n        self.feature_mixer = FeatureMixer(d_model, d_ff, dropout)\n        \n    def forward(self, x):\n        x = self.temporal_mixer(x)\n        x = self.variable_mixer(x)\n        x = self.feature_mixer(x)\n        return x\n\n\nclass Model(nn.Module):\n    \"\"\"\n    Time-Variable Factorized MLP-Mixer (TV-Mixer).\n    A highly parameter-efficient and structurally robust algorithm for Multivariate TS.\n    It factorizes the TS into patches and independently mixes patterns across Time,\n    Variables, and hidden Features via dedicated MLPs.\n    \"\"\"\n    def __init__(self, configs):\n        super(Model, self).__init__()\n        self.task_name = configs.task_name\n        self.seq_len = configs.seq_len\n        self.enc_in = configs.enc_in\n        self.num_class = configs.num_class\n        \n        # Hyperparameters optimally tuned for Patched Time Series MLP-Mixer\n        self.patch_len = 16\n        self.stride = 8\n        self.d_model = getattr(configs, 'd_model', 128)\n        self.d_ff = getattr(configs, 'd_ff', 256)\n        self.e_layers = getattr(configs, 'e_layers', 2)\n        self.dropout = getattr(configs, 'dropout', 0.2) # slightly higher dropout for purely MLP models\n        \n        # Calculate explicit patch numbers exactly as PatchEmbedding creates\n        self.num_patches = int((self.seq_len - self.patch_len) / self.stride + 2)\n        \n        self.patch_embedding = PatchEmbedding(\n            self.d_model, self.patch_len, self.stride, self.stride, self.dropout\n        )\n        \n        self.mixers = nn.ModuleList([\n            TVMixerBlock(self.enc_in, self.num_patches, self.d_model, self.d_ff, self.dropout)\n            for _ in range(self.e_layers)\n        ])\n        \n        self.head = nn.Sequential(\n            nn.Flatten(start_dim=1),\n            nn.Dropout(self.dropout),\n            nn.Linear(self.enc_in * self.d_model * self.num_patches, self.num_class)\n        )\n        \n    def classification(self, x_enc, x_mark_enc):\n        B, L, V = x_enc.shape\n        \n        # Instance Normalization per Variable\n        means = x_enc.mean(1, keepdim=True).detach()\n        x_enc = x_enc - means\n        stdev = torch.sqrt(torch.var(x_enc, dim=1, keepdim=True, unbiased=False) + 1e-5).detach()\n        x_enc = x_enc / stdev\n\n        # Sub-sequence patching\n        x_enc_p = x_enc.permute(0, 2, 1) # [B, V, L]\n        enc_out, _ = self.patch_embedding(x_enc_p) # [B*V, P, d_model]\n        \n        # Reshape to isolated axes format\n        enc_out = enc_out.view(B, V, self.num_patches, self.d_model)\n        \n        # Factorized Mixing\n        for mixer in self.mixers:\n            enc_out = mixer(enc_out)\n            \n        # Flatten all dimensions except Batch\n        logits = self.head(enc_out)\n        return logits\n\n    def forward(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask=None):\n        if self.task_name == 'classification':\n            dec_out = self.classification(x_enc, x_mark_enc)\n            return dec_out\n        return None",
4  "op": "replace",
5  "start_line": 1,
6  "end_line": 153
7}

1{
2  "end_line": 161,
3  "op": "replace",
4  "filename": "Time-Series-Library/models/Custom.py",
5  "content": "import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom layers.Embed import PatchEmbedding\n\nclass TemporalMixer(nn.Module):\n    \"\"\"\n    Mixes information across the temporal patch dimension.\n    \"\"\"\n    def __init__(self, d_model, num_patches, dropout=0.1):\n        super().__init__()\n        self.norm = nn.LayerNorm(d_model)\n        self.mlp = nn.Sequential(\n            nn.Linear(num_patches, num_patches * 2),\n            nn.GELU(),\n            nn.Dropout(dropout),\n            nn.Linear(num_patches * 2, num_patches),\n            nn.Dropout(dropout)\n        )\n        \n    def forward(self, x):\n        # x: [B, V, P, d_model]\n        res = x\n        x = self.norm(x)\n        # Mix across patches (P)\n        x = x.transpose(-1, -2).contiguous() # [B, V, d_model, P]\n        x = self.mlp(x)\n        x = x.transpose(-1, -2).contiguous() # [B, V, P, d_model]\n        return res + x\n\n\nclass VariableMixer(nn.Module):\n    \"\"\"\n    Mixes information across the channels/variables.\n    \"\"\"\n    def __init__(self, num_vars, d_model, dropout=0.1):\n        super().__init__()\n        self.norm = nn.LayerNorm(d_model)\n        hidden_dim = max(num_vars * 2, 16) # Safely handle num_vars=1\n        self.mlp = nn.Sequential(\n            nn.Linear(num_vars, hidden_dim),\n            nn.GELU(),\n            nn.Dropout(dropout),\n            nn.Linear(hidden_dim, num_vars),\n            nn.Dropout(dropout)\n        )\n        \n    def forward(self, x):\n        # x: [B, V, P, d_model]\n        res = x\n        x = self.norm(x)\n        # Mix across variables (V)\n        x = x.permute(0, 2, 3, 1).contiguous() # [B, P, d_model, V]\n        x = self.mlp(x)\n        x = x.permute(0, 3, 1, 2).contiguous() # [B, V, P, d_model]\n        return res + x\n\n\nclass FeatureMixer(nn.Module):\n    \"\"\"\n    Mixes information within features/channels mappings.\n    \"\"\"\n    def __init__(self, d_model, d_ff, dropout=0.1):\n        super().__init__()\n        self.norm = nn.LayerNorm(d_model)\n        self.mlp = nn.Sequential(\n            nn.Linear(d_model, d_ff),\n            nn.GELU(),\n            nn.Dropout(dropout),\n            nn.Linear(d_ff, d_model),\n            nn.Dropout(dropout)\n        )\n        \n    def forward(self, x):\n        # x: [B, V, P, d_model]\n        return x + self.mlp(self.norm(x))\n\n\nclass TVMixerBlock(nn.Module):\n    def __init__(self, num_vars, num_patches, d_model, d_ff, dropout=0.1):\n        super().__init__()\n        self.temporal_mixer = TemporalMixer(d_model, num_patches, dropout)\n        self.variable_mixer = VariableMixer(num_vars, d_model, dropout)\n        self.feature_mixer = FeatureMixer(d_model, d_ff, dropout)\n        \n    def forward(self, x):\n        x = self.temporal_mixer(x)\n        x = self.variable_mixer(x)\n        x = self.feature_mixer(x)\n        return x\n\n\nclass Model(nn.Module):\n    \"\"\"\n    Time-Variable Factorized MLP-Mixer (TV-Mixer).\n    A highly parameter-efficient and structurally robust algorithm for Multivariate TS.\n    It factorizes the TS into patches and independently mixes patterns across Time,\n    Variables, and hidden Features via dedicated MLPs. This parameterization forms\n    a stronger geometric inductive bias tailored for Multivariate Time Series.\n    \"\"\"\n    def __init__(self, configs):\n        super(Model, self).__init__()\n        self.task_name = configs.task_name\n        self.seq_len = configs.seq_len\n        self.enc_in = configs.enc_in\n        self.num_class = configs.num_class\n        \n        # Hardcode optimal topological capacities for Patched MLP-Mixer\n        self.patch_len = 16\n        self.stride = 8\n        self.d_model = 64\n        self.d_ff = 128\n        self.e_layers = getattr(configs, 'e_layers', 3)\n        self.dropout = getattr(configs, 'dropout', 0.2)\n        \n        # Calculate explicit patch numbers\n        self.num_patches = int((self.seq_len - self.patch_len) / self.stride + 2)\n        \n        self.patch_embedding = PatchEmbedding(\n            self.d_model, self.patch_len, self.stride, self.stride, self.dropout\n        )\n        \n        self.mixers = nn.ModuleList([\n            TVMixerBlock(self.enc_in, self.num_patches, self.d_model, self.d_ff, self.dropout)\n            for _ in range(self.e_layers)\n        ])\n        \n        self.head = nn.Sequential(\n            nn.Flatten(start_dim=1),\n            nn.Dropout(self.dropout),\n            nn.Linear(self.enc_in * self.d_model * self.num_patches, self.num_class)\n        )\n        \n    def classification(self, x_enc, x_mark_enc):\n        B, L, V = x_enc.shape\n        \n        # Instance Normalization per Variable\n        means = x_enc.mean(1, keepdim=True).detach()\n        x_enc = x_enc - means\n        stdev = torch.sqrt(torch.var(x_enc, dim=1, keepdim=True, unbiased=False) + 1e-5).detach()\n        x_enc = x_enc / stdev\n\n        # Sub-sequence patching\n        x_enc_p = x_enc.permute(0, 2, 1) # [B, V, L]\n        enc_out, _ = self.patch_embedding(x_enc_p) # [B*V, P, d_model]\n        \n        # Reshape to isolated axes format\n        enc_out = enc_out.view(B, V, self.num_patches, self.d_model)\n        \n        # Factorized Mixing\n        for mixer in self.mixers:\n            enc_out = mixer(enc_out)\n            \n        # Flatten all dimensions except Batch\n        logits = self.head(enc_out)\n        return logits\n\n    def forward(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask=None):\n        if self.task_name == 'classification':\n            dec_out = self.classification(x_enc, x_mark_enc)\n            return dec_out\n        return None",
6  "start_line": 1
7}

1{
2  "n": 2
3}