多特征融合深度学习模型用于八分类任务

本项目使用CNN和BiGRU模型并行作为特征提取器，提取特征并进行融合，最终使用全连接层进行八分类。

数据集格式:

在训练集、验证集和测试集三个txt文件夹中有如上格式的数据集，每条样本前23位为特征值，最后一位为分类标签，标签共有8个类别。

7,7,183,233,10,10,3,10,3,10,0,25,21,0,0,2,78,2,1,0,0,86.6685638427734,1.25,4
7,7,183,233,10,10,3,10,3,10,0,25,21,90,80,20,10,2,1,0,0,86.4980087280273,1.10,0
7,0,183,0,9,0,3,10,3,0,0,25,123,90,80,20,10,0,1,0,1,0,1.00,7

模型结构:

CNN模型:
- 使用二维卷积层提取图像特征。
- 使用最大池化层降维。
- 使用全连接层将特征映射到128维。
BiGRU模型:
- 使用双向GRU模型提取序列特征。
- 使用最后一层的输出作为特征。
特征融合:
- 将CNN和BiGRU提取的特征进行拼接。
- 使用全连接层对融合后的特征进行八分类。

代码:

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, Dataset
from torchvision import transforms
import numpy as np

# 定义CNN模型
class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1)
        self.relu = nn.ReLU()
        self.maxpool = nn.MaxPool2d(kernel_size=2, stride=2)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1)
        self.fc = nn.Linear(64 * 7 * 7, 128)
        
    def forward(self, x):
        x = self.conv1(x)
        x = self.relu(x)
        x = self.maxpool(x)
        x = self.conv2(x)
        x = self.relu(x)
        x = self.maxpool(x)
        x = x.view(x.size(0), -1)
        x = self.fc(x)
        return x

# 定义BiGRU模型
class BiGRU(nn.Module):
    def __init__(self):
        super(BiGRU, self).__init__()
        self.gru = nn.GRU(input_size=23, hidden_size=64, num_layers=2, bidirectional=True, batch_first=True)
        
    def forward(self, x):
        output, _ = self.gru(x)
        return output[:, -1, :]

# 定义特征融合模型
class FusionNet(nn.Module):
    def __init__(self):
        super(FusionNet, self).__init__()
        self.cnn = CNN()
        self.gru = BiGRU()
        self.fc = nn.Linear(128 + 64 * 2, 8)
        
    def forward(self, x_cnn, x_gru):
        out_cnn = self.cnn(x_cnn)
        out_gru = self.gru(x_gru)
        out = torch.cat((out_cnn, out_gru), dim=1)
        out = self.fc(out)
        return out

# 定义自定义数据集类
class CustomDataset(Dataset):
    def __init__(self, file_path):
        self.data = np.loadtxt(file_path, delimiter=',')
        self.transform = transforms.Compose([transforms.ToTensor()])
        
    def __getitem__(self, index):
        features = self.data[index, :-1]
        label = self.data[index, -1]
        features = self.transform(features)
        return features, label
    
    def __len__(self):
        return len(self.data)

# 定义训练函数
def train(model, train_loader, criterion, optimizer):
    model.train()
    train_loss = 0
    correct = 0
    total = 0
    for inputs, labels in train_loader:
        optimizer.zero_grad()
        outputs = model(inputs, inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        
        train_loss += loss.item()
        _, predicted = outputs.max(1)
        total += labels.size(0)
        correct += predicted.eq(labels).sum().item()
    
    train_loss /= len(train_loader)
    accuracy = 100. * correct / total
    
    return train_loss, accuracy

# 定义验证函数
def validate(model, val_loader, criterion):
    model.eval()
    val_loss = 0
    correct = 0
    total = 0
    with torch.no_grad():
        for inputs, labels in val_loader:
            outputs = model(inputs, inputs)
            loss = criterion(outputs, labels)
            
            val_loss += loss.item()
            _, predicted = outputs.max(1)
            total += labels.size(0)
            correct += predicted.eq(labels).sum().item()
    
    val_loss /= len(val_loader)
    accuracy = 100. * correct / total
    
    return val_loss, accuracy

# 定义测试函数
def test(model, test_loader, criterion):
    model.eval()
    test_loss = 0
    correct = 0
    total = 0
    with torch.no_grad():
        for inputs, labels in test_loader:
            outputs = model(inputs, inputs)
            loss = criterion(outputs, labels)
            
            test_loss += loss.item()
            _, predicted = outputs.max(1)
            total += labels.size(0)
            correct += predicted.eq(labels).sum().item()
    
    test_loss /= len(test_loader)
    accuracy = 100. * correct / total
    
    return test_loss, accuracy

# 设置超参数
batch_size = 32
learning_rate = 0.001
num_epochs = 10

# 加载数据集
train_dataset = CustomDataset('train.txt')
val_dataset = CustomDataset('val.txt')
test_dataset = CustomDataset('test.txt')

train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)

# 创建模型和优化器
model = FusionNet()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

# 训练模型
for epoch in range(num_epochs):
    train_loss, train_accuracy = train(model, train_loader, criterion, optimizer)
    val_loss, val_accuracy = validate(model, val_loader, criterion)
    print('Epoch [{}/{}], Train Loss: {:.4f}, Train Accuracy: {:.2f}%, Val Loss: {:.4f}, Val Accuracy: {:.2f}%'
          .format(epoch+1, num_epochs, train_loss, train_accuracy, val_loss, val_accuracy))

# 测试模型
test_loss, test_accuracy = test(model, test_loader, criterion)
print('Test Loss: {:.4f}, Test Accuracy: {:.2f}%'.format(test_loss, test_accuracy))

运行步骤:

将数据集保存为三个txt文件，分别命名为train.txt, val.txt, test.txt。
将代码保存为python文件。
运行python文件。

注意:

输入CNN模型的数据需要将其转化为图片格式，输入BiGRU的数据为原始数据的23位特征值。
训练过程有训练、验证和测试。
代码使用PyTorch编写。
代码中包含中文注释内容。