读取训练集、验证集和测试集的三个csv数据集每条数据集共43个特征前42位为特征值最后1位为类别标签标签共有10个类别分别是0129现使用CNN和BiGRU模型并行分别做为特征提取器其中输入CNN的数据需先将原始数据的1维特征转换为2维特征输入BiGRU的数据为原始数据的42位特征并且两特征提取器的输出维度是相同然后将两提取器的结果进行contact特征融合最后使用全连接层softmax对融合的结

以下是使用PyTorch编写的代码示例：

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torch.utils.data import Dataset, DataLoader

# 定义CNN模型
class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 16, kernel_size=3)
        self.conv2 = nn.Conv2d(16, 32, kernel_size=3)
        self.fc1 = nn.Linear(32 * 9 * 9, 128)
        
    def forward(self, x):
        x = F.relu(self.conv1(x))
        x = F.relu(self.conv2(x))
        x = x.view(-1, 32 * 9 * 9)
        x = F.relu(self.fc1(x))
        return x

# 定义BiGRU模型
class BiGRU(nn.Module):
    def __init__(self):
        super(BiGRU, self).__init__()
        self.gru = nn.GRU(42, 64, bidirectional=True, batch_first=True)
        
    def forward(self, x):
        _, x = self.gru(x)
        x = x.view(-1, 128)
        return x

# 定义特征融合模型
class FusionModel(nn.Module):
    def __init__(self):
        super(FusionModel, self).__init__()
        self.cnn = CNN()
        self.bigru = BiGRU()
        self.fc = nn.Linear(256, 10)
        
    def forward(self, x1, x2):
        x1 = self.cnn(x1)
        x2 = self.bigru(x2)
        x = torch.cat((x1, x2), dim=1)
        x = self.fc(x)
        return x

# 定义自定义数据集类
class CustomDataset(Dataset):
    def __init__(self, data, transform=None):
        self.data = data
        self.transform = transform
        
    def __len__(self):
        return len(self.data)
    
    def __getitem__(self, index):
        features = self.data[index, :42]
        label = self.data[index, 42]
        
        if self.transform:
            features = self.transform(features)
        
        return features, label

# 转换1维特征为2维特征
def transform(features):
    return torch.unsqueeze(features, 0)

# 加载训练集、验证集和测试集数据
train_data = torch.tensor(train_data)  # 训练集数据
val_data = torch.tensor(val_data)      # 验证集数据
test_data = torch.tensor(test_data)    # 测试集数据

# 定义训练集、验证集和测试集的数据加载器
train_dataset = CustomDataset(train_data, transform=transform)
val_dataset = CustomDataset(val_data, transform=transform)
test_dataset = CustomDataset(test_data, transform=transform)

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

# 创建模型实例
model = FusionModel()

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练模型
def train(model, dataloader, optimizer, criterion):
    model.train()
    total_loss = 0.0
    correct = 0
    total = 0
    
    for features, labels in dataloader:
        optimizer.zero_grad()
        outputs = model(features, features)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        
        total_loss += loss.item()
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()
        
    return total_loss / len(dataloader), correct / total

# 验证模型
def validate(model, dataloader, criterion):
    model.eval()
    total_loss = 0.0
    correct = 0
    total = 0
    
    with torch.no_grad():
        for features, labels in dataloader:
            outputs = model(features, features)
            loss = criterion(outputs, labels)
            
            total_loss += loss.item()
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
            
    return total_loss / len(dataloader), correct / total

# 测试模型
def test(model, dataloader):
    model.eval()
    predictions = []
    
    with torch.no_grad():
        for features, _ in dataloader:
            outputs = model(features, features)
            _, predicted = torch.max(outputs.data, 1)
            predictions.extend(predicted.tolist())
    
    return predictions

# 开始训练
num_epochs = 10

for epoch in range(num_epochs):
    train_loss, train_acc = train(model, train_loader, optimizer, criterion)
    val_loss, val_acc = validate(model, val_loader, criterion)
    
    print(f"Epoch {epoch+1}/{num_epochs}")
    print(f"Train Loss: {train_loss:.4f} - Train Acc: {train_acc:.4f}")
    print(f"Val Loss: {val_loss:.4f} - Val Acc: {val_acc:.4f}")
    print()
    
# 在测试集上进行测试
predictions = test(model, test_loader)
print(predictions)

请注意，上述代码中的train_data、val_data和test_data是训练集、验证集和测试集的数据，需要根据实际情况进行替换。此外，代码中的模型结构、超参数、优化器等也可以根据需要进行调整。