Upload 4 files

fusion.py

@@ -0,0 +1,40 @@
+import torch
+import torch.nn as nn
+
+class GatedFusion(nn.Module):
+    """
+    Gated fusion for two or more modalities.
+    """
+    def __init__(self, input_dims, output_dim):
+        super().__init__()
+        self.gates = nn.ModuleList([nn.Linear(d, output_dim) for d in input_dims])
+        self.fcs = nn.ModuleList([nn.Linear(d, output_dim) for d in input_dims])
+
+    def forward(self, features):
+        # features: list of tensors [batch, dim]
+        gated = []
+        for i, feat in enumerate(features):
+            gate = torch.sigmoid(self.gates[i](feat))
+            proj = self.fcs[i](feat)
+            gated.append(gate * proj)
+        return sum(gated)
+
+class CrossModalAttention(nn.Module):
+    """
+    Cross-modal attention for two modalities.
+    """
+    def __init__(self, dim_q, dim_kv, dim_out):
+        super().__init__()
+        self.query = nn.Linear(dim_q, dim_out)
+        self.key = nn.Linear(dim_kv, dim_out)
+        self.value = nn.Linear(dim_kv, dim_out)
+        self.softmax = nn.Softmax(dim=-1)
+
+    def forward(self, q, kv):
+        # q: (batch, dim_q), kv: (batch, dim_kv)
+        Q = self.query(q).unsqueeze(1)  # (batch, 1, dim_out)
+        K = self.key(kv).unsqueeze(1)   # (batch, 1, dim_out)
+        V = self.value(kv).unsqueeze(1) # (batch, 1, dim_out)
+        attn = self.softmax(torch.bmm(Q, K.transpose(1,2)))
+        out = torch.bmm(attn, V).squeeze(1)
+        return out

requirements.txt

@@ -0,0 +1,6 @@
+torch>=2.0.0
+transformers>=4.40.0
+scikit-learn
+pandas
+numpy
+tqdm

time_series_encoder.py

@@ -0,0 +1,17 @@
+import torch
+import torch.nn as nn
+
+class TimeSeriesEncoder(nn.Module):
+    """
+    Simple time series encoder using LSTM.
+    """
+    def __init__(self, input_dim, hidden_dim, output_dim, num_layers=1):
+        super().__init__()
+        self.lstm = nn.LSTM(input_dim, hidden_dim, num_layers, batch_first=True)
+        self.fc = nn.Linear(hidden_dim, output_dim)
+
+    def forward(self, x):
+        # x: (batch, seq_len, input_dim)
+        _, (h_n, _) = self.lstm(x)
+        out = self.fc(h_n[-1])
+        return out

training_utils.py

@@ -0,0 +1,29 @@
+import torch
+
+class EarlyStopping:
+    """
+    Early stops the training if validation loss doesn't improve after a given patience.
+    """
+    def __init__(self, patience=5, delta=0):
+        self.patience = patience
+        self.delta = delta
+        self.counter = 0
+        self.best_loss = None
+        self.early_stop = False
+
+    def __call__(self, val_loss):
+        if self.best_loss is None or val_loss < self.best_loss - self.delta:
+            self.best_loss = val_loss
+            self.counter = 0
+        else:
+            self.counter += 1
+            if self.counter >= self.patience:
+                self.early_stop = True
+
+def get_scheduler(optimizer, scheduler_type='plateau', **kwargs):
+    if scheduler_type == 'plateau':
+        return torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, **kwargs)
+    elif scheduler_type == 'step':
+        return torch.optim.lr_scheduler.StepLR(optimizer, **kwargs)
+    else:
+        raise ValueError(f"Unknown scheduler type: {scheduler_type}")