1{
2  "op": "replace",
3  "filename": "Time-Series-Library/models/Custom.py",
4  "start_line": 1,
5  "end_line": 43,
6  "content": "import torch\nimport torch.nn as nn\nfrom layers.Autoformer_EncDec import series_decomp\nfrom layers.Transformer_EncDec import Encoder, EncoderLayer\nfrom layers.SelfAttention_Family import FullAttention, AttentionLayer\n\n\nclass Model(nn.Module):\n    \"\"\"\n    Decomposition Transformer with Cross-Component Attention (DecompCross)\n    \n    Novel contributions:\n    1. Explicit decomposition into trend and seasonal components using moving average.\n    2. Separate processing: transformer for seasonal, linear projection for trend.\n    3. Cross-component attention where seasonal features attend to trend features.\n    4. Adaptive fusion of components with learnable weighting.\n    \"\"\"\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.pred_len = configs.pred_len\n        self.enc_in = configs.enc_in\n        self.c_out = configs.c_out\n        \n        # Decomposition\n        self.decomp = series_decomp(configs.moving_avg if hasattr(configs, 'moving_avg') else 25)\n        \n        # Seasonal branch: Transformer encoder\n        self.d_model = configs.d_model\n        self.n_heads = configs.n_heads\n        self.e_layers = configs.e_layers\n        self.d_ff = configs.d_ff\n        self.dropout = configs.dropout\n        self.activation = configs.activation\n        \n        # Embedding for seasonal component\n        self.seasonal_embedding = nn.Linear(self.enc_in, self.d_model)\n        \n        # Transformer encoder for seasonal\n        self.seasonal_encoder = Encoder(\n            [\n                EncoderLayer(\n                    AttentionLayer(\n                        FullAttention(False, configs.factor, attention_dropout=configs.dropout, output_attention=False),\n                        self.d_model, self.n_heads),\n                    self.d_model,\n                    self.d_ff,\n                    dropout=self.dropout,\n                    activation=self.activation\n                ) for _ in range(self.e_layers)\n            ],\n            norm_layer=torch.nn.LayerNorm(self.d_model)\n        )\n        \n        # Trend branch: Linear projection per channel (like DLinear but shared)\n        self.trend_projection = nn.Linear(self.seq_len, self.pred_len)\n        # Initialize as average pooling\n        self.trend_projection.weight = nn.Parameter(\n            (1 / self.seq_len) * torch.ones([self.pred_len, self.seq_len]))\n        self.trend_projection.bias = nn.Parameter(torch.zeros(self.pred_len))\n        \n        # Cross-component attention: seasonal queries attend to trend keys/values\n        self.cross_attention = AttentionLayer(\n            FullAttention(False, configs.factor, attention_dropout=configs.dropout, output_attention=False),\n            self.d_model, self.n_heads\n        )\n        \n        # Projection to output dimension\n        self.projection = nn.Linear(self.d_model, self.c_out)\n        \n        # Adaptive fusion weights\n        self.fuse_weight_seasonal = nn.Parameter(torch.ones(1))\n        self.fuse_weight_trend = nn.Parameter(torch.ones(1))\n        \n    def forecast(self, x_enc, x_mark_enc, x_dec, x_mark_dec):\n        \"\"\"\n        x_enc: [batch, seq_len, enc_in]\n        Return: [batch, pred_len, c_out]\n        \"\"\"\n        # Decomposition\n        seasonal, trend = self.decomp(x_enc)  # both [batch, seq_len, enc_in]\n        \n        # Trend branch: linear projection per channel\n        # Permute to [batch, enc_in, seq_len] for linear layer\n        trend_perm = trend.permute(0, 2, 1)  # [batch, enc_in, seq_len]\n        trend_out = self.trend_projection(trend_perm)  # [batch, enc_in, pred_len]\n        trend_out = trend_out.permute(0, 2, 1)  # [batch, pred_len, enc_in]\n        \n        # Seasonal branch: transformer\n        seasonal_emb = self.seasonal_embedding(seasonal)  # [batch, seq_len, d_model]\n        seasonal_enc, _ = self.seasonal_encoder(seasonal_emb)  # [batch, seq_len, d_model]\n        \n        # Cross-component attention: use trend as context for seasonal refinement\n        # We need to embed trend to d_model dimension for attention\n        trend_emb = self.seasonal_embedding(trend)  # [batch, seq_len, d_model]\n        seasonal_refined, _ = self.cross_attention(\n            seasonal_enc, trend_emb, trend_emb, attn_mask=None\n        )\n        seasonal_enc = seasonal_enc + seasonal_refined  # residual\n        \n        # Project seasonal encoder output to prediction length\n        # Use linear projection per time step (similar to iTransformer but inverted)\n        # We have [batch, seq_len, d_model] -> want [batch, pred_len, d_model]\n        # Use a linear layer from seq_len to pred_len after transpose\n        seasonal_enc_t = seasonal_enc.transpose(1, 2)  # [batch, d_model, seq_len]\n        seasonal_out = self.trend_projection(seasonal_enc_t)  # reuse same projection? Better separate\n        # Actually need separate projection for seasonal\n        seasonal_out = seasonal_out.transpose(1, 2)  # [batch, pred_len, d_model]\n        \n        # Project to output dimension\n        seasonal_out = self.projection(seasonal_out)  # [batch, pred_len, c_out]\n        \n        # Adaptive fusion\n        # Ensure trend_out matches c_out dimension\n        if self.enc_in != self.c_out:\n            trend_out = torch.matmul(trend_out, torch.eye(self.enc_in, self.c_out).to(trend_out.device))\n        \n        # Weighted sum\n        output = self.fuse_weight_seasonal * seasonal_out + self.fuse_weight_trend * trend_out\n        \n        return output\n\n    def forward(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask=None):\n        if self.task_name == 'long_term_forecast' or self.task_name == 'short_term_forecast':\n            dec_out = self.forecast(x_enc, x_mark_enc, x_dec, x_mark_dec)\n            return dec_out[:, -self.pred_len:, :]\n        return None"
7}

1{
2  "op": "replace",
3  "filename": "Time-Series-Library/models/Custom.py",
4  "start_line": 1,
5  "end_line": 129,
6  "content": "import torch\nimport torch.nn as nn\nfrom layers.Autoformer_EncDec import series_decomp\nfrom layers.Transformer_EncDec import Encoder, EncoderLayer\nfrom layers.SelfAttention_Family import FullAttention, AttentionLayer\n\n\nclass Model(nn.Module):\n    \"\"\"\n    Decomposition Transformer with Cross-Component Attention (DecompCross)\n    \n    Novel contributions:\n    1. Explicit decomposition into trend and seasonal components using moving average.\n    2. Separate processing: transformer for seasonal, linear projection for trend.\n    3. Cross-component attention where seasonal features attend to trend features.\n    4. Adaptive fusion of components with learnable weighting.\n    \"\"\"\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.pred_len = configs.pred_len\n        self.enc_in = configs.enc_in\n        self.c_out = configs.c_out\n        \n        # Decomposition\n        self.decomp = series_decomp(configs.moving_avg if hasattr(configs, 'moving_avg') else 25)\n        \n        # Seasonal branch: Transformer encoder\n        self.d_model = configs.d_model\n        self.n_heads = configs.n_heads\n        self.e_layers = configs.e_layers\n        self.d_ff = configs.d_ff\n        self.dropout = configs.dropout\n        self.activation = configs.activation\n        \n        # Embedding for seasonal component\n        self.seasonal_embedding = nn.Linear(self.enc_in, self.d_model)\n        \n        # Transformer encoder for seasonal\n        self.seasonal_encoder = Encoder(\n            [\n                EncoderLayer(\n                    AttentionLayer(\n                        FullAttention(False, configs.factor, attention_dropout=configs.dropout, output_attention=False),\n                        self.d_model, self.n_heads),\n                    self.d_model,\n                    self.d_ff,\n                    dropout=self.dropout,\n                    activation=self.activation\n                ) for _ in range(self.e_layers)\n            ],\n            norm_layer=torch.nn.LayerNorm(self.d_model)\n        )\n        \n        # Trend branch: Linear projection per channel (like DLinear but shared)\n        self.trend_projection = nn.Linear(self.seq_len, self.pred_len)\n        # Initialize as average pooling\n        self.trend_projection.weight = nn.Parameter(\n            (1 / self.seq_len) * torch.ones([self.pred_len, self.seq_len]))\n        self.trend_projection.bias = nn.Parameter(torch.zeros(self.pred_len))\n        \n        # Seasonal length projection: map seq_len to pred_len in d_model space\n        self.seasonal_len_projection = nn.Linear(self.seq_len, self.pred_len)\n        self.seasonal_len_projection.weight = nn.Parameter(\n            (1 / self.seq_len) * torch.ones([self.pred_len, self.seq_len]))\n        self.seasonal_len_projection.bias = nn.Parameter(torch.zeros(self.pred_len))\n        \n        # Cross-component attention: seasonal queries attend to trend keys/values\n        self.cross_attention = AttentionLayer(\n            FullAttention(False, configs.factor, attention_dropout=configs.dropout, output_attention=False),\n            self.d_model, self.n_heads\n        )\n        \n        # Projection from d_model to c_out\n        self.projection = nn.Linear(self.d_model, self.c_out)\n        \n        # Adaptive fusion weights\n        self.fuse_weight_seasonal = nn.Parameter(torch.ones(1))\n        self.fuse_weight_trend = nn.Parameter(torch.ones(1))\n        \n    def forecast(self, x_enc, x_mark_enc, x_dec, x_mark_dec):\n        \"\"\"\n        x_enc: [batch, seq_len, enc_in]\n        Return: [batch, pred_len, c_out]\n        \"\"\"\n        # Decomposition\n        seasonal, trend = self.decomp(x_enc)  # both [batch, seq_len, enc_in]\n        \n        # Trend branch: linear projection per channel\n        trend_perm = trend.permute(0, 2, 1)  # [batch, enc_in, seq_len]\n        trend_out = self.trend_projection(trend_perm)  # [batch, enc_in, pred_len]\n        trend_out = trend_out.permute(0, 2, 1)  # [batch, pred_len, enc_in]\n        \n        # Seasonal branch: transformer\n        seasonal_emb = self.seasonal_embedding(seasonal)  # [batch, seq_len, d_model]\n        seasonal_enc, _ = self.seasonal_encoder(seasonal_emb)  # [batch, seq_len, d_model]\n        \n        # Cross-component attention: use trend as context for seasonal refinement\n        trend_emb = self.seasonal_embedding(trend)  # [batch, seq_len, d_model]\n        seasonal_refined, _ = self.cross_attention(\n            seasonal_enc, trend_emb, trend_emb, attn_mask=None\n        )\n        seasonal_enc = seasonal_enc + seasonal_refined  # residual\n        \n        # Project seasonal encoder output to prediction length\n        seasonal_enc_t = seasonal_enc.transpose(1, 2)  # [batch, d_model, seq_len]\n        seasonal_len = self.seasonal_len_projection(seasonal_enc_t)  # [batch, d_model, pred_len]\n        seasonal_len = seasonal_len.transpose(1, 2)  # [batch, pred_len, d_model]\n        \n        # Project to output dimension\n        seasonal_out = self.projection(seasonal_len)  # [batch, pred_len, c_out]\n        \n        # Adaptive fusion\n        # If enc_in != c_out, adjust trend_out dimension\n        if self.enc_in != self.c_out:\n            # Simple linear mapping (could be learnable but keep simple)\n            trend_out = torch.matmul(trend_out, torch.eye(self.enc_in, self.c_out).to(trend_out.device))\n        \n        # Weighted sum\n        output = self.fuse_weight_seasonal * seasonal_out + self.fuse_weight_trend * trend_out\n        \n        return output\n\n    def forward(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask=None):\n        if self.task_name == 'long_term_forecast' or self.task_name == 'short_term_forecast':\n            dec_out = self.forecast(x_enc, x_mark_enc, x_dec, x_mark_dec)\n            return dec_out[:, -self.pred_len:, :]\n        return None"
7}

1{
2  "op": "replace",
3  "filename": "Time-Series-Library/models/Custom.py",
4  "start_line": 1,
5  "end_line": 130,
6  "content": "import torch\nimport torch.nn as nn\nfrom layers.Autoformer_EncDec import series_decomp\nfrom layers.Transformer_EncDec import Encoder, EncoderLayer\nfrom layers.SelfAttention_Family import FullAttention, AttentionLayer\nfrom layers.Embed import DataEmbedding\n\n\nclass Model(nn.Module):\n    \"\"\"\n    Decomposition Transformer with Temporal Embedding (DecompTemp)\n    \n    Novel contributions:\n    1. Explicit decomposition into trend and seasonal components.\n    2. Seasonal component processed by transformer with full temporal embedding.\n    3. Trend component processed by simple linear projection.\n    4. Adaptive fusion with learnable weights.\n    \"\"\"\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.pred_len = configs.pred_len\n        self.enc_in = configs.enc_in\n        self.c_out = configs.c_out\n        \n        # Decomposition\n        self.decomp = series_decomp(configs.moving_avg if hasattr(configs, 'moving_avg') else 25)\n        \n        # Seasonal branch: Transformer encoder with temporal embedding\n        self.d_model = configs.d_model\n        self.n_heads = configs.n_heads\n        self.e_layers = configs.e_layers\n        self.d_ff = configs.d_ff\n        self.dropout = configs.dropout\n        self.activation = configs.activation\n        self.embed_type = configs.embed_type if hasattr(configs, 'embed_type') else 'timeF'\n        self.freq = configs.freq if hasattr(configs, 'freq') else 'h'\n        \n        # Embedding for seasonal component (includes value + time features)\n        self.seasonal_embedding = DataEmbedding(\n            c_in=self.enc_in,\n            d_model=self.d_model,\n            embed_type=self.embed_type,\n            freq=self.freq,\n            dropout=self.dropout\n        )\n        \n        # Transformer encoder for seasonal\n        self.seasonal_encoder = Encoder(\n            [\n                EncoderLayer(\n                    AttentionLayer(\n                        FullAttention(False, configs.factor, attention_dropout=configs.dropout, output_attention=False),\n                        self.d_model, self.n_heads),\n                    self.d_model,\n                    self.d_ff,\n                    dropout=self.dropout,\n                    activation=self.activation\n                ) for _ in range(self.e_layers)\n            ],\n            norm_layer=torch.nn.LayerNorm(self.d_model)\n        )\n        \n        # Trend branch: Linear projection per channel (like DLinear but shared)\n        self.trend_projection = nn.Linear(self.seq_len, self.pred_len)\n        # Initialize as average pooling\n        self.trend_projection.weight = nn.Parameter(\n            (1 / self.seq_len) * torch.ones([self.pred_len, self.seq_len]))\n        self.trend_projection.bias = nn.Parameter(torch.zeros(self.pred_len))\n        \n        # Seasonal length projection: map seq_len to pred_len in d_model space\n        self.seasonal_len_projection = nn.Linear(self.seq_len, self.pred_len)\n        self.seasonal_len_projection.weight = nn.Parameter(\n            (1 / self.seq_len) * torch.ones([self.pred_len, self.seq_len]))\n        self.seasonal_len_projection.bias = nn.Parameter(torch.zeros(self.pred_len))\n        \n        # Projection from d_model to c_out\n        self.projection = nn.Linear(self.d_model, self.c_out)\n        \n        # Adaptive fusion weights\n        self.fuse_weight_seasonal = nn.Parameter(torch.ones(1))\n        self.fuse_weight_trend = nn.Parameter(torch.ones(1))\n        \n    def forecast(self, x_enc, x_mark_enc, x_dec, x_mark_dec):\n        \"\"\"\n        x_enc: [batch, seq_len, enc_in]\n        x_mark_enc: [batch, seq_len, time_features]\n        Return: [batch, pred_len, c_out]\n        \"\"\"\n        # Normalization (Non-stationary Transformer style)\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)\n        x_enc = x_enc / stdev\n        \n        # Decomposition\n        seasonal, trend = self.decomp(x_enc)  # both [batch, seq_len, enc_in]\n        \n        # Trend branch: linear projection per channel\n        trend_perm = trend.permute(0, 2, 1)  # [batch, enc_in, seq_len]\n        trend_out = self.trend_projection(trend_perm)  # [batch, enc_in, pred_len]\n        trend_out = trend_out.permute(0, 2, 1)  # [batch, pred_len, enc_in]\n        \n        # Seasonal branch: transformer with temporal embedding\n        seasonal_emb = self.seasonal_embedding(seasonal, x_mark_enc)  # [batch, seq_len, d_model]\n        seasonal_enc, _ = self.seasonal_encoder(seasonal_emb)  # [batch, seq_len, d_model]\n        \n        # Project seasonal encoder output to prediction length\n        seasonal_enc_t = seasonal_enc.transpose(1, 2)  # [batch, d_model, seq_len]\n        seasonal_len = self.seasonal_len_projection(seasonal_enc_t)  # [batch, d_model, pred_len]\n        seasonal_len = seasonal_len.transpose(1, 2)  # [batch, pred_len, d_model]\n        \n        # Project to output dimension\n        seasonal_out = self.projection(seasonal_len)  # [batch, pred_len, c_out]\n        \n        # Adaptive fusion\n        # If enc_in != c_out, adjust trend_out dimension\n        if self.enc_in != self.c_out:\n            # Simple linear mapping (could be learnable but keep simple)\n            trend_out = torch.matmul(trend_out, torch.eye(self.enc_in, self.c_out).to(trend_out.device))\n        \n        # Weighted sum\n        output = self.fuse_weight_seasonal * seasonal_out + self.fuse_weight_trend * trend_out\n        \n        # De-Normalization\n        output = output * (stdev[:, 0, :].unsqueeze(1).repeat(1, self.pred_len, 1))\n        output = output + (means[:, 0, :].unsqueeze(1).repeat(1, self.pred_len, 1))\n        \n        return output\n\n    def forward(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask=None):\n        if self.task_name == 'long_term_forecast' or self.task_name == 'short_term_forecast':\n            dec_out = self.forecast(x_enc, x_mark_enc, x_dec, x_mark_dec)\n            return dec_out[:, -self.pred_len:, :]\n        return None"
7}

1{
2  "op": "replace",
3  "filename": "Time-Series-Library/models/Custom.py",
4  "start_line": 1,
5  "end_line": 137,
6  "content": "import torch\nimport torch.nn as nn\nfrom layers.Autoformer_EncDec import series_decomp, series_decomp_multi\nfrom layers.Transformer_EncDec import Encoder, EncoderLayer\nfrom layers.SelfAttention_Family import FullAttention, AttentionLayer\nfrom layers.Embed import DataEmbedding\n\n\nclass Model(nn.Module):\n    \"\"\"\n    Multi-Scale Decomposition Transformer (MSDecomp)\n    \n    Novel contributions:\n    1. Multi-scale decomposition using multiple moving average kernel sizes.\n    2. Seasonal components aggregated and processed by transformer with temporal embedding.\n    3. Trend components aggregated and projected linearly.\n    4. Adaptive fusion with learnable weights.\n    \"\"\"\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.pred_len = configs.pred_len\n        self.enc_in = configs.enc_in\n        self.c_out = configs.c_out\n        \n        # Multi-scale decomposition kernels\n        kernel_sizes = [3, 5, 7, 11]  # could be configurable, hardcoded for simplicity\n        self.decomp_multi = series_decomp_multi(kernel_sizes)\n        \n        # Seasonal branch: Transformer encoder with temporal embedding\n        self.d_model = configs.d_model\n        self.n_heads = configs.n_heads\n        self.e_layers = configs.e_layers\n        self.d_ff = configs.d_ff\n        self.dropout = configs.dropout\n        self.activation = configs.activation\n        self.embed_type = configs.embed_type if hasattr(configs, 'embed_type') else 'timeF'\n        self.freq = configs.freq if hasattr(configs, 'freq') else 'h'\n        \n        # Embedding for seasonal component (includes value + time features)\n        self.seasonal_embedding = DataEmbedding(\n            c_in=self.enc_in,\n            d_model=self.d_model,\n            embed_type=self.embed_type,\n            freq=self.freq,\n            dropout=self.dropout\n        )\n        \n        # Transformer encoder for seasonal\n        self.seasonal_encoder = Encoder(\n            [\n                EncoderLayer(\n                    AttentionLayer(\n                        FullAttention(False, configs.factor, attention_dropout=configs.dropout, output_attention=False),\n                        self.d_model, self.n_heads),\n                    self.d_model,\n                    self.d_ff,\n                    dropout=self.dropout,\n                    activation=self.activation\n                ) for _ in range(self.e_layers)\n            ],\n            norm_layer=torch.nn.LayerNorm(self.d_model)\n        )\n        \n        # Trend branch: Linear projection per channel (like DLinear but shared)\n        self.trend_projection = nn.Linear(self.seq_len, self.pred_len)\n        # Initialize as average pooling\n        self.trend_projection.weight = nn.Parameter(\n            (1 / self.seq_len) * torch.ones([self.pred_len, self.seq_len]))\n        self.trend_projection.bias = nn.Parameter(torch.zeros(self.pred_len))\n        \n        # Seasonal length projection: map seq_len to pred_len in d_model space\n        self.seasonal_len_projection = nn.Linear(self.seq_len, self.pred_len)\n        self.seasonal_len_projection.weight = nn.Parameter(\n            (1 / self.seq_len) * torch.ones([self.pred_len, self.seq_len]))\n        self.seasonal_len_projection.bias = nn.Parameter(torch.zeros(self.pred_len))\n        \n        # Projection from d_model to c_out\n        self.projection = nn.Linear(self.d_model, self.c_out)\n        \n        # Adaptive fusion weights\n        self.fuse_weight_seasonal = nn.Parameter(torch.ones(1))\n        self.fuse_weight_trend = nn.Parameter(torch.ones(1))\n        \n    def forecast(self, x_enc, x_mark_enc, x_dec, x_mark_dec):\n        \"\"\"\n        x_enc: [batch, seq_len, enc_in]\n        x_mark_enc: [batch, seq_len, time_features]\n        Return: [batch, pred_len, c_out]\n        \"\"\"\n        # Normalization (Non-stationary Transformer style)\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)\n        x_enc = x_enc / stdev\n        \n        # Multi-scale decomposition\n        seasonal_multi, trend_multi = self.decomp_multi(x_enc)\n        # seasonal_multi and trend_multi are lists of length len(kernel_sizes)\n        # Average across scales\n        seasonal = torch.stack(seasonal_multi, dim=0).mean(dim=0)  # [batch, seq_len, enc_in]\n        trend = torch.stack(trend_multi, dim=0).mean(dim=0)\n        \n        # Trend branch: linear projection per channel\n        trend_perm = trend.permute(0, 2, 1)  # [batch, enc_in, seq_len]\n        trend_out = self.trend_projection(trend_perm)  # [batch, enc_in, pred_len]\n        trend_out = trend_out.permute(0, 2, 1)  # [batch, pred_len, enc_in]\n        \n        # Seasonal branch: transformer with temporal embedding\n        seasonal_emb = self.seasonal_embedding(seasonal, x_mark_enc)  # [batch, seq_len, d_model]\n        seasonal_enc, _ = self.seasonal_encoder(seasonal_emb)  # [batch, seq_len, d_model]\n        \n        # Project seasonal encoder output to prediction length\n        seasonal_enc_t = seasonal_enc.transpose(1, 2)  # [batch, d_model, seq_len]\n        seasonal_len = self.seasonal_len_projection(seasonal_enc_t)  # [batch, d_model, pred_len]\n        seasonal_len = seasonal_len.transpose(1, 2)  # [batch, pred_len, d_model]\n        \n        # Project to output dimension\n        seasonal_out = self.projection(seasonal_len)  # [batch, pred_len, c_out]\n        \n        # Adaptive fusion\n        # If enc_in != c_out, adjust trend_out dimension\n        if self.enc_in != self.c_out:\n            # Simple linear mapping (could be learnable but keep simple)\n            trend_out = torch.matmul(trend_out, torch.eye(self.enc_in, self.c_out).to(trend_out.device))\n        \n        # Weighted sum\n        output = self.fuse_weight_seasonal * seasonal_out + self.fuse_weight_trend * trend_out\n        \n        # De-Normalization\n        output = output * (stdev[:, 0, :].unsqueeze(1).repeat(1, self.pred_len, 1))\n        output = output + (means[:, 0, :].unsqueeze(1).repeat(1, self.pred_len, 1))\n        \n        return output\n\n    def forward(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask=None):\n        if self.task_name == 'long_term_forecast' or self.task_name == 'short_term_forecast':\n            dec_out = self.forecast(x_enc, x_mark_enc, x_dec, x_mark_dec)\n            return dec_out[:, -self.pred_len:, :]\n        return None"
7}