Upload model.py

model.py

@@ -0,0 +1,151 @@
+import torch
+import torch.nn as nn
+import torch.nn.init as init
+import warnings
+
+import torch.nn.functional as F
+warnings.filterwarnings('ignore')
+
+
+class CAFN(nn.Module):
+    def __init__(self, input_dim=46, num_classes=4, hidden_size=128): # --- 新增了 hidden_size 参数 ---
+        super(CAFN, self).__init__()
+
+        self.conv_layer11 = nn.Sequential(
+            nn.Conv1d(in_channels=1, out_channels=32, kernel_size=3),
+            nn.ReLU(),
+            nn.MaxPool1d(kernel_size=2)
+        )
+        self.conv_layer12 = nn.Sequential(
+            nn.Conv1d(in_channels=3, out_channels=32, kernel_size=5),
+            nn.ReLU(),
+            nn.MaxPool1d(kernel_size=2)
+        )
+
+        self.conv_layer1 = nn.Sequential(
+            nn.Conv1d(in_channels=64, out_channels=64, kernel_size=3),
+            nn.ReLU(),
+            nn.MaxPool1d(kernel_size=2)
+        )
+        self.conv_layer2 = nn.Sequential(
+            nn.Conv1d(in_channels=64, out_channels=64, kernel_size=3),
+            nn.ReLU(),
+            nn.MaxPool1d(kernel_size=2)
+        )
+        self.conv_layer3 = nn.Sequential(
+            nn.Conv1d(in_channels=64, out_channels=64, kernel_size=3),
+            nn.ReLU(),
+            nn.MaxPool1d(kernel_size=2)
+        )
+
+        # --- 删除了原有的分类头 ---
+        # self.conv_layer_w = nn.Sequential(...)
+        # self.flatten = nn.Flatten()
+        # self.fc_layer = nn.Sequential(...)
+
+        # --- 新增 biGRU 层 ---
+        self.hidden_size = 64
+        self.biGRU = nn.GRU(
+            input_size=64,           # 输入特征维度，即CNN输出的通道数
+            hidden_size=hidden_size, # GRU隐藏层维度，可调超参
+            num_layers=1,            # GRU层数，增加层数可以学习更复杂的模式
+            bidirectional=True,      # 开启双向
+            batch_first=True,        # 输入数据格式为 (batch, seq, feature)
+        )
+
+        # --- 新增一个全连接层，用于最终分类 ---
+        self.dropout_gru = nn.Dropout(0.15)
+        self.fc_gru = nn.Linear(hidden_size * 2, num_classes) # *2 是因为双向
+
+        self.apply(self.init_weights)
+        self.Residual = MSRN()
+
+    def init_weights(self, m):
+        if type(m) == nn.Conv1d or type(m) == nn.Linear:
+            init.xavier_uniform_(m.weight)
+            if m.bias is not None:
+                init.constant_(m.bias, 0.0)
+        # --- 新增对GRU权重的初始化（可选，但推荐） ---
+        elif type(m) == nn.GRU:
+            for name, param in m.named_parameters():
+                if 'weight_ih' in name:
+                    init.xavier_uniform_(param.data)
+                elif 'weight_hh' in name:
+                    init.orthogonal_(param.data)
+                elif 'bias' in name:
+                    param.data.fill_(0)
+
+
+    def forward(self, x1, x2):
+        '''
+        x1: PSTAAP
+        x2: PhysicoChemical
+        '''
+        device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+        x1 = x1.to(device)
+        x1 = x1.unsqueeze(1)
+        x1 = self.conv_layer11(x1)
+        _, w1 = self.Residual(x1)  # (batch_size, 64, 4)
+
+        x2 = x2.to(device)
+        x2 = x2.transpose(1, 2)
+        x2 = self.conv_layer12(x2)
+        _, w2 = self.Residual(x2)  # (batch_size, 64, 4)
+
+        w = torch.cat((w1, w2), dim=2)  # (batch_size, 64, 8)
+
+        x = w.permute(0, 2, 1)
+        self.biGRU.flatten_parameters()
+        output, _ = self.biGRU(x) # output shape: (batch, seq_len, hidden_size * 2)
+
+        forward_out = output[:, -1, :self.hidden_size]
+        backward_out = output[:, 0, self.hidden_size:]
+        x = torch.cat((forward_out, backward_out), dim=1) # (batch, hidden_size * 2)
+        x = self.dropout_gru(x)
+        x = self.fc_gru(x) # (batch, num_classes)
+
+        return x
+
+
+
+class MSRN(nn.Module):
+    def __init__(self, input_dim=46, num_classes=4):
+        super(MSRN, self).__init__()
+
+        self.conv_layer1 = nn.Sequential(
+            nn.Conv1d(in_channels=32, out_channels=32, kernel_size=3),
+            nn.ReLU(),
+            nn.Dropout(0.2),
+            nn.MaxPool1d(kernel_size=2)
+        )
+
+        self.conv_layer2 = nn.Sequential(
+            nn.Conv1d(in_channels=32, out_channels=64, kernel_size=3),
+            nn.ReLU(),
+            nn.Dropout(0.2),
+            nn.MaxPool1d(kernel_size=2)
+        )
+
+        self.conv_layer3 = nn.Sequential(
+            nn.Conv1d(in_channels=64, out_channels=64, kernel_size=3),
+            nn.ReLU(),
+            nn.Dropout(0.2),
+            nn.MaxPool1d(kernel_size=2)
+        )
+
+        self.apply(self.init_weights)
+
+    def init_weights(self, m):
+        if type(m) == nn.Conv1d or type(m) == nn.Linear:
+
+            init.xavier_uniform_(m.weight)
+            if m.bias is not None:
+
+                init.constant_(m.bias, 0.0)
+
+    def forward(self, x):
+        x1 = self.conv_layer1(x)  # (64,10)
+        x2 = self.conv_layer2(x1)  # (64,4)
+        w1 = x2
+        x3 = self.conv_layer3(x2)  # (64,1)
+        return x3, w1