Upload TransformerSinglestep.py

TransformerSinglestep.py

@@ -0,0 +1,50 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class LearnablePositionalEncoding(nn.Module):
+    def __init__(self, d_model, max_len=10000000):
+        super().__init__()
+        self.pos_embedding = nn.Embedding(max_len, d_model)
+        self._init_weights()
+        
+    def _init_weights(self):
+        #  initialization ที่เหมาะสมสำหรับ positional encoding
+        nn.init.uniform_(self.pos_embedding.weight, -0.1, 0.1)
+        
+    def forward(self, x):
+        # x.shape = [batch_size, seq_len, d_model]
+        seq_len = x.size(1)
+        pos = torch.arange(0, seq_len, device=x.device).unsqueeze(0)  # [1, seq_len]
+        pos_embed = self.pos_embedding(pos)  # [1, seq_len, d_model]
+        return x + pos_embed
+
+
+class TransformerSingleStep(nn.Module):
+    def __init__(self, input_size, d_model=64, nhead=4, num_layers=2, dropout=0.1, max_len=500):
+        super().__init__()
+        self.input_fc = nn.Linear(input_size, d_model)
+        self.tanh = nn.Tanh()
+        self.pos_encoder = LearnablePositionalEncoding(d_model, max_len=max_len)
+        
+        encoder_layer = nn.TransformerEncoderLayer(d_model, nhead, dim_feedforward=128, 
+                                                   dropout=dropout, batch_first=True)
+        self.transformer = nn.TransformerEncoder(encoder_layer, num_layers)
+        self.output = nn.Linear(d_model, 2)
+
+    def forward(self, x):
+        # x.shape = [batch_size, seq_len, input_size]
+        x = self.input_fc(x)
+        x = self.tanh(x)
+        x = self.pos_encoder(x)
+        x = self.transformer(x)  # [B, seq_len, d_model]
+        
+        # ใช้เฉพาะ output ของ time step สุดท้าย
+        last_output = x[:, -1, :]  # [B, d_model]
+        
+        # output layer แบ่ง high/low
+        out = self.output(last_output)  # [B, 2] → col0=high, col1=low
+        pred_high = out[:, 0].unsqueeze(1)  # [B,1]
+        pred_low  = out[:, 1].unsqueeze(1)  # [B,1]
+        
+        return pred_high, pred_low