1{
2  "op": "replace",
3  "filename": "Time-Series-Library/models/Custom.py",
4  "start_line": 1,
5  "end_line": 45,
6  "content": "import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport math\n\n\nclass MultiScaleConv(nn.Module):\n    \"\"\"\n    Multi-scale 1D convolutional block with residual connection.\n    Uses parallel convs with different kernel sizes, then combines.\n    \"\"\"\n    def __init__(self, in_channels, out_channels, kernel_sizes=[3, 5, 7], dropout=0.1):\n        super(MultiScaleConv, self).__init__()\n        self.convs = nn.ModuleList()\n        for ks in kernel_sizes:\n            padding = (ks // 2)\n            self.convs.append(\n                nn.Sequential(\n                    nn.Conv1d(in_channels, out_channels, kernel_size=ks, padding=padding),\n                    nn.BatchNorm1d(out_channels),\n                    nn.GELU(),\n                    nn.Dropout(dropout)\n                )\n            )\n        # If in_channels != out_channels, need projection\n        if in_channels != out_channels:\n            self.residual_proj = nn.Conv1d(in_channels, out_channels, kernel_size=1)\n        else:\n            self.residual_proj = None\n        self.out_channels = out_channels\n        \n    def forward(self, x):\n        # x shape: [batch, channels, length]\n        residual = x\n        out = 0\n        for conv in self.convs:\n            out = out + conv(x)\n        out = out / len(self.convs)\n        if self.residual_proj is not None:\n            residual = self.residual_proj(residual)\n        # residual and out have same channels now\n        return F.gelu(out + residual)\n\n\nclass TemporalSelfAttention(nn.Module):\n    \"\"\"\n    Simple temporal self-attention without multi-head to keep params low.\n    \"\"\"\n    def __init__(self, d_model, dropout=0.1):\n        super(TemporalSelfAttention, self).__init__()\n        self.d_model = d_model\n        self.qkv = nn.Linear(d_model, d_model * 3)\n        self.dropout = nn.Dropout(dropout)\n        self.scale = 1.0 / math.sqrt(d_model)\n        \n    def forward(self, x):\n        # x shape: [batch, length, d_model]\n        B, L, D = x.shape\n        qkv = self.qkv(x).reshape(B, L, 3, D).permute(2, 0, 1, 3)  # [3, B, L, D]\n        q, k, v = qkv[0], qkv[1], qkv[2]\n        attn = torch.matmul(q, k.transpose(-2, -1)) * self.scale  # [B, L, L]\n        attn = F.softmax(attn, dim=-1)\n        attn = self.dropout(attn)\n        out = torch.matmul(attn, v)  # [B, L, D]\n        return out + x  # residual\n\n\nclass ChannelAttention(nn.Module):\n    \"\"\"\n    Channel attention across variables (squeeze-and-excitation style).\n    \"\"\"\n    def __init__(self, num_channels, reduction=4):\n        super(ChannelAttention, self).__init__()\n        self.avg_pool = nn.AdaptiveAvgPool1d(1)\n        self.fc = nn.Sequential(\n            nn.Linear(num_channels, num_channels // reduction, bias=False),\n            nn.ReLU(inplace=True),\n            nn.Linear(num_channels // reduction, num_channels, bias=False),\n            nn.Sigmoid()\n        )\n        \n    def forward(self, x):\n        # x shape: [batch, channels, length]\n        B, C, L = x.shape\n        y = self.avg_pool(x).squeeze(-1)  # [B, C]\n        y = self.fc(y).unsqueeze(-1)  # [B, C, 1]\n        return x * y.expand_as(x)\n\n\nclass Model(nn.Module):\n    \"\"\"\n    Custom model for time series classification.\n    Multi-scale convolutional encoder + temporal attention + channel attention.\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        # Use config parameters if available, else defaults\n        d_model = getattr(configs, 'd_model', 128)\n        d_ff = getattr(configs, 'd_ff', 256)\n        n_heads = getattr(configs, 'n_heads', 4)\n        e_layers = getattr(configs, 'e_layers', 2)\n        dropout = getattr(configs, 'dropout', 0.1)\n        \n        # Initial projection to d_model\n        self.input_proj = nn.Linear(self.enc_in, d_model)\n        \n        # Multi-scale convolutional layers\n        self.conv_layers = nn.ModuleList()\n        for i in range(e_layers):\n            self.conv_layers.append(\n                MultiScaleConv(d_model, d_model, kernel_sizes=[3, 5, 7], dropout=dropout)\n            )\n        \n        # Temporal self-attention layer\n        self.temp_attention = TemporalSelfAttention(d_model, dropout=dropout)\n        \n        # Channel attention (applied to transposed view)\n        self.channel_attention = ChannelAttention(d_model, reduction=4)\n        \n        # Adaptive pooling\n        self.adaptive_pool = nn.AdaptiveAvgPool1d(1)\n        \n        # Classification head\n        self.dropout = nn.Dropout(dropout)\n        self.classifier = nn.Sequential(\n            nn.Linear(d_model, d_ff),\n            nn.GELU(),\n            nn.Dropout(dropout),\n            nn.Linear(d_ff, self.num_class)\n        )\n        \n    def classification(self, x_enc, x_mark_enc):\n        \"\"\"\n        Classification: assign a label to the input time series.\n        Input: x_enc [batch, seq_len, enc_in]\n        x_mark_enc: [batch, seq_len] padding mask\n        Output: [batch, num_class] logits\n        \"\"\"\n        batch_size = x_enc.shape[0]\n        \n        # Apply padding mask if provided (zero out padded positions)\n        if x_mark_enc is not None:\n            mask = x_mark_enc.unsqueeze(-1)  # [batch, seq_len, 1]\n            x_enc = x_enc * mask\n        \n        # Project input [batch, seq_len, enc_in] -> [batch, seq_len, d_model]\n        x = self.input_proj(x_enc)\n        \n        # Transpose for conv layers: [batch, d_model, seq_len]\n        x = x.transpose(1, 2)\n        \n        # Apply multi-scale convolutional layers\n        for conv in self.conv_layers:\n            x = conv(x)\n        \n        # Apply channel attention\n        x = self.channel_attention(x)\n        \n        # Transpose back for temporal attention: [batch, seq_len, d_model]\n        x = x.transpose(1, 2)\n        \n        # Apply temporal self-attention\n        x = self.temp_attention(x)\n        \n        # Apply padding mask again before pooling\n        if x_mark_enc is not None:\n            mask = x_mark_enc.unsqueeze(-1)  # [batch, seq_len, 1]\n            x = x * mask\n        \n        # Adaptive average pooling over time dimension\n        # Transpose to [batch, d_model, seq_len] for pooling\n        x = x.transpose(1, 2)\n        x = self.adaptive_pool(x)  # [batch, d_model, 1]\n        x = x.squeeze(-1)  # [batch, d_model]\n        \n        # Classification\n        x = self.dropout(x)\n        logits = self.classifier(x)\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  "op": "replace",
3  "filename": "Time-Series-Library/models/Custom.py",
4  "start_line": 1,
5  "end_line": 190,
6  "content": "import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport math\n\n\nclass DilatedConvBlock(nn.Module):\n    \"\"\"\n    Dilated convolutional block with multiple parallel dilation rates.\n    Each branch: Conv1d with dilation, BatchNorm, GELU, Dropout.\n    \"\"\"\n    def __init__(self, in_channels, out_channels, dilation_rates=[1, 2, 4, 8], kernel_size=3, dropout=0.1):\n        super(DilatedConvBlock, self).__init__()\n        self.branches = nn.ModuleList()\n        for dilation in dilation_rates:\n            padding = (kernel_size - 1) * dilation // 2\n            self.branches.append(\n                nn.Sequential(\n                    nn.Conv1d(in_channels, out_channels, kernel_size=kernel_size, \n                              padding=padding, dilation=dilation),\n                    nn.BatchNorm1d(out_channels),\n                    nn.GELU(),\n                    nn.Dropout(dropout)\n                )\n            )\n        # Residual projection if needed\n        if in_channels != out_channels:\n            self.residual_proj = nn.Conv1d(in_channels, out_channels, kernel_size=1)\n        else:\n            self.residual_proj = None\n        self.out_channels = out_channels\n        \n    def forward(self, x):\n        residual = x\n        out = 0\n        for branch in self.branches:\n            out = out + branch(x)\n        out = out / len(self.branches)\n        if self.residual_proj is not None:\n            residual = self.residual_proj(residual)\n        return F.gelu(out + residual)\n\n\nclass MultiHeadTemporalAttention(nn.Module):\n    \"\"\"\n    Multi-head temporal self-attention with residual and layer norm.\n    \"\"\"\n    def __init__(self, d_model, n_heads, dropout=0.1):\n        super(MultiHeadTemporalAttention, self).__init__()\n        assert d_model % n_heads == 0\n        self.d_model = d_model\n        self.n_heads = n_heads\n        self.head_dim = d_model // n_heads\n        self.scale = 1.0 / math.sqrt(self.head_dim)\n        \n        self.qkv = nn.Linear(d_model, d_model * 3)\n        self.proj = nn.Linear(d_model, d_model)\n        self.dropout = nn.Dropout(dropout)\n        self.norm = nn.LayerNorm(d_model)\n        \n    def forward(self, x, mask=None):\n        # x shape: [batch, length, d_model]\n        B, L, D = x.shape\n        residual = x\n        \n        # Compute Q, K, V\n        qkv = self.qkv(x).reshape(B, L, 3, self.n_heads, self.head_dim).permute(2, 0, 3, 1, 4)\n        q, k, v = qkv[0], qkv[1], qkv[2]  # each [B, n_heads, L, head_dim]\n        \n        # Attention scores\n        attn = torch.matmul(q, k.transpose(-2, -1)) * self.scale  # [B, n_heads, L, L]\n        if mask is not None:\n            # mask shape [B, L] -> [B, 1, 1, L] for broadcasting\n            mask = mask.unsqueeze(1).unsqueeze(2)\n            attn = attn.masked_fill(mask == 0, float('-inf'))\n        attn = F.softmax(attn, dim=-1)\n        attn = self.dropout(attn)\n        \n        # Weighted sum\n        out = torch.matmul(attn, v)  # [B, n_heads, L, head_dim]\n        out = out.transpose(1, 2).reshape(B, L, D)  # [B, L, D]\n        out = self.proj(out)\n        out = self.dropout(out)\n        out = self.norm(out + residual)\n        return out\n\n\nclass CrossChannelAttention(nn.Module):\n    \"\"\"\n    Attention across channels (variables) using linear projection.\n    \"\"\"\n    def __init__(self, d_model, reduction=4, dropout=0.1):\n        super(CrossChannelAttention, self).__init__()\n        self.d_model = d_model\n        self.reduction = reduction\n        self.avg_pool = nn.AdaptiveAvgPool1d(1)\n        \n        # Two-layer MLP for channel attention\n        self.mlp = nn.Sequential(\n            nn.Linear(d_model, d_model // reduction),\n            nn.GELU(),\n            nn.Dropout(dropout),\n            nn.Linear(d_model // reduction, d_model),\n            nn.Sigmoid()\n        )\n        \n    def forward(self, x):\n        # x shape: [batch, d_model, length]\n        B, C, L = x.shape\n        # Compute channel-wise statistics\n        y = self.avg_pool(x).squeeze(-1)  # [B, C]\n        y = self.mlp(y).unsqueeze(-1)  # [B, C, 1]\n        return x * y.expand_as(x)\n\n\nclass Model(nn.Module):\n    \"\"\"\n    Custom model for time series classification.\n    Uses dilated convolutions for multi-scale temporal patterns,\n    multi-head temporal attention, and cross-channel attention.\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        # Use config parameters\n        d_model = configs.d_model\n        d_ff = configs.d_ff\n        n_heads = configs.n_heads\n        e_layers = configs.e_layers\n        dropout = configs.dropout\n        \n        # Input projection\n        self.input_proj = nn.Linear(self.enc_in, d_model)\n        \n        # Dilated convolutional layers\n        self.dilated_convs = nn.ModuleList()\n        for i in range(e_layers):\n            self.dilated_convs.append(\n                DilatedConvBlock(d_model, d_model, dilation_rates=[1, 2, 4, 8], \n                                 kernel_size=3, dropout=dropout)\n            )\n        \n        # Temporal multi-head attention\n        self.temp_attention = MultiHeadTemporalAttention(d_model, n_heads, dropout)\n        \n        # Cross-channel attention\n        self.channel_attention = CrossChannelAttention(d_model, reduction=4, dropout=dropout)\n        \n        # Adaptive pooling\n        self.adaptive_pool = nn.AdaptiveAvgPool1d(1)\n        \n        # Classification head\n        self.classifier = nn.Sequential(\n            nn.Linear(d_model, d_ff),\n            nn.GELU(),\n            nn.Dropout(dropout),\n            nn.Linear(d_ff, self.num_class)\n        )\n        \n    def classification(self, x_enc, x_mark_enc):\n        \"\"\"\n        Classification: assign a label to the input time series.\n        Input: x_enc [batch, seq_len, enc_in]\n        x_mark_enc: [batch, seq_len] padding mask\n        Output: [batch, num_class] logits\n        \"\"\"\n        batch_size = x_enc.shape[0]\n        \n        # Apply padding mask if provided\n        if x_mark_enc is not None:\n            mask = x_mark_enc.unsqueeze(-1)  # [batch, seq_len, 1]\n            x_enc = x_enc * mask\n        \n        # Project input [batch, seq_len, enc_in] -> [batch, seq_len, d_model]\n        x = self.input_proj(x_enc)\n        \n        # Transpose for conv layers: [batch, d_model, seq_len]\n        x = x.transpose(1, 2)\n        \n        # Apply dilated convolutional layers\n        for conv in self.dilated_convs:\n            x = conv(x)\n        \n        # Apply cross-channel attention\n        x = self.channel_attention(x)\n        \n        # Transpose back for temporal attention: [batch, seq_len, d_model]\n        x = x.transpose(1, 2)\n        \n        # Apply temporal attention with mask\n        attn_mask = x_mark_enc if x_mark_enc is not None else None\n        x = self.temp_attention(x, mask=attn_mask)\n        \n        # Apply padding mask again before pooling\n        if x_mark_enc is not None:\n            mask = x_mark_enc.unsqueeze(-1)  # [batch, seq_len, 1]\n            x = x * mask\n        \n        # Adaptive average pooling over time dimension\n        x = x.transpose(1, 2)  # [batch, d_model, seq_len]\n        x = self.adaptive_pool(x)  # [batch, d_model, 1]\n        x = x.squeeze(-1)  # [batch, d_model]\n        \n        # Classification\n        logits = self.classifier(x)\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  "op": "replace",
3  "filename": "Time-Series-Library/models/Custom.py",
4  "start_line": 1,
5  "end_line": 216,
6  "content": "import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport math\nimport torch.fft\n\n\nclass FrequencyAttention(nn.Module):\n    \"\"\"\n    Frequency-domain attention: FFT -> learnable weighting -> inverse FFT.\n    \"\"\"\n    def __init__(self, d_model, seq_len, dropout=0.1):\n        super(FrequencyAttention, self).__init__()\n        self.d_model = d_model\n        self.seq_len = seq_len\n        # Number of frequency bins (real FFT)\n        self.n_freq = seq_len // 2 + 1\n        \n        # Learnable weight for each frequency bin\n        self.freq_weight = nn.Parameter(torch.ones(1, d_model, self.n_freq))\n        self.dropout = nn.Dropout(dropout)\n        \n    def forward(self, x):\n        # x shape: [batch, d_model, seq_len]\n        B, C, L = x.shape\n        # Apply FFT along the time dimension\n        x_freq = torch.fft.rfft(x, dim=-1)  # [B, C, n_freq] complex\n        \n        # Separate magnitude and phase\n        mag = torch.abs(x_freq)\n        phase = torch.angle(x_freq)\n        \n        # Learnable scaling of magnitude\n        weight = self.freq_weight  # [1, C, n_freq]\n        mag = mag * weight\n        \n        # Reconstruct complex numbers\n        real = mag * torch.cos(phase)\n        imag = mag * torch.sin(phase)\n        x_freq_weighted = torch.complex(real, imag)\n        \n        # Inverse FFT\n        x_time = torch.fft.irfft(x_freq_weighted, n=L, dim=-1)  # [B, C, L]\n        \n        # Residual connection\n        out = x + self.dropout(x_time)\n        return out\n\n\nclass DilatedConvBlock(nn.Module):\n    \"\"\"\n    Dilated convolutional block with multiple parallel dilation rates.\n    Each branch: Conv1d with dilation, BatchNorm, GELU, Dropout.\n    \"\"\"\n    def __init__(self, in_channels, out_channels, dilation_rates=[1, 2, 4, 8], kernel_size=3, dropout=0.1):\n        super(DilatedConvBlock, self).__init__()\n        self.branches = nn.ModuleList()\n        for dilation in dilation_rates:\n            padding = (kernel_size - 1) * dilation // 2\n            self.branches.append(\n                nn.Sequential(\n                    nn.Conv1d(in_channels, out_channels, kernel_size=kernel_size, \n                              padding=padding, dilation=dilation),\n                    nn.BatchNorm1d(out_channels),\n                    nn.GELU(),\n                    nn.Dropout(dropout)\n                )\n            )\n        # Residual projection if needed\n        if in_channels != out_channels:\n            self.residual_proj = nn.Conv1d(in_channels, out_channels, kernel_size=1)\n        else:\n            self.residual_proj = None\n        self.out_channels = out_channels\n        \n    def forward(self, x):\n        residual = x\n        out = 0\n        for branch in self.branches:\n            out = out + branch(x)\n        out = out / len(self.branches)\n        if self.residual_proj is not None:\n            residual = self.residual_proj(residual)\n        return F.gelu(out + residual)\n\n\nclass MultiHeadTemporalAttention(nn.Module):\n    \"\"\"\n    Multi-head temporal self-attention with residual and layer norm.\n    \"\"\"\n    def __init__(self, d_model, n_heads, dropout=0.1):\n        super(MultiHeadTemporalAttention, self).__init__()\n        assert d_model % n_heads == 0\n        self.d_model = d_model\n        self.n_heads = n_heads\n        self.head_dim = d_model // n_heads\n        self.scale = 1.0 / math.sqrt(self.head_dim)\n        \n        self.qkv = nn.Linear(d_model, d_model * 3)\n        self.proj = nn.Linear(d_model, d_model)\n        self.dropout = nn.Dropout(dropout)\n        self.norm = nn.LayerNorm(d_model)\n        \n    def forward(self, x, mask=None):\n        # x shape: [batch, length, d_model]\n        B, L, D = x.shape\n        residual = x\n        \n        # Compute Q, K, V\n        qkv = self.qkv(x).reshape(B, L, 3, self.n_heads, self.head_dim).permute(2, 0, 3, 1, 4)\n        q, k, v = qkv[0], qkv[1], qkv[2]  # each [B, n_heads, L, head_dim]\n        \n        # Attention scores\n        attn = torch.matmul(q, k.transpose(-2, -1)) * self.scale  # [B, n_heads, L, L]\n        if mask is not None:\n            # mask shape [B, L] -> [B, 1, 1, L] for broadcasting\n            mask = mask.unsqueeze(1).unsqueeze(2)\n            attn = attn.masked_fill(mask == 0, float('-inf'))\n        attn = F.softmax(attn, dim=-1)\n        attn = self.dropout(attn)\n        \n        # Weighted sum\n        out = torch.matmul(attn, v)  # [B, n_heads, L, head_dim]\n        out = out.transpose(1, 2).reshape(B, L, D)  # [B, L, D]\n        out = self.proj(out)\n        out = self.dropout(out)\n        out = self.norm(out + residual)\n        return out\n\n\nclass CrossChannelAttention(nn.Module):\n    \"\"\"\n    Attention across channels (variables) using linear projection.\n    \"\"\"\n    def __init__(self, d_model, reduction=4, dropout=0.1):\n        super(CrossChannelAttention, self).__init__()\n        self.d_model = d_model\n        self.reduction = reduction\n        self.avg_pool = nn.AdaptiveAvgPool1d(1)\n        \n        # Two-layer MLP for channel attention\n        self.mlp = nn.Sequential(\n            nn.Linear(d_model, d_model // reduction),\n            nn.GELU(),\n            nn.Dropout(dropout),\n            nn.Linear(d_model // reduction, d_model),\n            nn.Sigmoid()\n        )\n        \n    def forward(self, x):\n        # x shape: [batch, d_model, length]\n        B, C, L = x.shape\n        # Compute channel-wise statistics\n        y = self.avg_pool(x).squeeze(-1)  # [B, C]\n        y = self.mlp(y).unsqueeze(-1)  # [B, C, 1]\n        return x * y.expand_as(x)\n\n\nclass Model(nn.Module):\n    \"\"\"\n    Custom model for time series classification.\n    Combines frequency-domain attention, dilated convolutions for multi-scale temporal patterns,\n    multi-head temporal attention, and cross-channel attention.\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        # Use config parameters\n        d_model = configs.d_model\n        d_ff = configs.d_ff\n        n_heads = configs.n_heads\n        e_layers = configs.e_layers\n        dropout = configs.dropout\n        \n        # Input projection\n        self.input_proj = nn.Linear(self.enc_in, d_model)\n        \n        # Frequency attention branch\n        self.freq_attention = FrequencyAttention(d_model, self.seq_len, dropout)\n        \n        # Dilated convolutional layers\n        self.dilated_convs = nn.ModuleList()\n        for i in range(e_layers):\n            self.dilated_convs.append(\n                DilatedConvBlock(d_model, d_model, dilation_rates=[1, 2, 4, 8], \n                                 kernel_size=3, dropout=dropout)\n            )\n        \n        # Temporal multi-head attention\n        self.temp_attention = MultiHeadTemporalAttention(d_model, n_heads, dropout)\n        \n        # Cross-channel attention\n        self.channel_attention = CrossChannelAttention(d_model, reduction=4, dropout=dropout)\n        \n        # Adaptive pooling\n        self.adaptive_pool = nn.AdaptiveAvgPool1d(1)\n        \n        # Classification head\n        self.classifier = nn.Sequential(\n            nn.Linear(d_model, d_ff),\n            nn.GELU(),\n            nn.Dropout(dropout),\n            nn.Linear(d_ff, self.num_class)\n        )\n        \n    def classification(self, x_enc, x_mark_enc):\n        \"\"\"\n        Classification: assign a label to the input time series.\n        Input: x_enc [batch, seq_len, enc_in]\n        x_mark_enc: [batch, seq_len] padding mask\n        Output: [batch, num_class] logits\n        \"\"\"\n        batch_size = x_enc.shape[0]\n        \n        # Apply padding mask if provided\n        if x_mark_enc is not None:\n            mask = x_mark_enc.unsqueeze(-1)  # [batch, seq_len, 1]\n            x_enc = x_enc * mask\n        \n        # Project input [batch, seq_len, enc_in] -> [batch, seq_len, d_model]\n        x = self.input_proj(x_enc)\n        \n        # Transpose for conv layers: [batch, d_model, seq_len]\n        x = x.transpose(1, 2)\n        \n        # Apply frequency attention\n        x = self.freq_attention(x)\n        \n        # Apply dilated convolutional layers\n        for conv in self.dilated_convs:\n            x = conv(x)\n        \n        # Apply cross-channel attention\n        x = self.channel_attention(x)\n        \n        # Transpose back for temporal attention: [batch, seq_len, d_model]\n        x = x.transpose(1, 2)\n        \n        # Apply temporal attention with mask\n        attn_mask = x_mark_enc if x_mark_enc is not None else None\n        x = self.temp_attention(x, mask=attn_mask)\n        \n        # Apply padding mask again before pooling\n        if x_mark_enc is not None:\n            mask = x_mark_enc.unsqueeze(-1)  # [batch, seq_len, 1]\n            x = x * mask\n        \n        # Adaptive average pooling over time dimension\n        x = x.transpose(1, 2)  # [batch, d_model, seq_len]\n        x = self.adaptive_pool(x)  # [batch, d_model, 1]\n        x = x.squeeze(-1)  # [batch, d_model]\n        \n        # Classification\n        logits = self.classifier(x)\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}