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

Sure! Here's an example of how you can implement the CNN-BiGRU model for feature extraction and classification using PyTorch:

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torch.utils.data.dataset import Dataset

# Define the CNN-BiGRU model
class CNNBiGRU(nn.Module):
    def __init__(self):
        super(CNNBiGRU, self).__init__()
        self.cnn = nn.Sequential(
            nn.Conv2d(1, 16, kernel_size=3, stride=1, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2),
            nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2)
        )
        self.bigru = nn.GRU(input_size=23, hidden_size=64, batch_first=True, bidirectional=True)
        self.fc = nn.Linear(32 + 128, 8)
    
    def forward(self, x_cnn, x_bigru):
        cnn_out = self.cnn(x_cnn)
        cnn_out = cnn_out.view(cnn_out.size(0), -1)
        bigru_out, _ = self.bigru(x_bigru)
        bigru_out = bigru_out[:, -1, :]
        combined = torch.cat((cnn_out, bigru_out), dim=1)
        out = self.fc(combined)
        return out

# Define the dataset class
class CustomDataset(Dataset):
    def __init__(self, data_path):
        self.data = []
        with open(data_path, 'r') as file:
            lines = file.readlines()
            for line in lines:
                line = line.strip().split(',')
                features = [float(x) for x in line[:-1]]
                label = int(line[-1])
                self.data.append((features, label))
    
    def __getitem__(self, index):
        features, label = self.data[index]
        return torch.tensor(features), torch.tensor(label)
    
    def __len__(self):
        return len(self.data)

# Define training parameters
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
batch_size = 64
lr = 0.001
num_epochs = 10

# Load the datasets
train_dataset = CustomDataset('train.txt')
valid_dataset = CustomDataset('valid.txt')
test_dataset = CustomDataset('test.txt')

train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
valid_loader = DataLoader(valid_dataset, batch_size=batch_size)
test_loader = DataLoader(test_dataset, batch_size=batch_size)

# Initialize the model
model = CNNBiGRU().to(device)

# Define loss function and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=lr)

# Training loop
for epoch in range(num_epochs):
    train_loss = 0.0
    valid_loss = 0.0
    correct = 0
    total = 0

    # Training
    model.train()
    for features, labels in train_loader:
        features = features.view(features.size(0), 1, 1, -1).to(device)
        labels = labels.to(device)

        optimizer.zero_grad()
        
        outputs = model(features, features)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        train_loss += loss.item() * features.size(0)

    # Validation
    model.eval()
    with torch.no_grad():
        for features, labels in valid_loader:
            features = features.view(features.size(0), 1, 1, -1).to(device)
            labels = labels.to(device)

            outputs = model(features, features)
            loss = criterion(outputs, labels)

            valid_loss += loss.item() * features.size(0)

            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()

    train_loss = train_loss / len(train_loader.dataset)
    valid_loss = valid_loss / len(valid_loader.dataset)
    accuracy = correct / total * 100

    print(f'Epoch {epoch+1}/{num_epochs}, '
          f'Train Loss: {train_loss:.4f}, '
          f'Valid Loss: {valid_loss:.4f}, '
          f'Accuracy: {accuracy:.2f}%')

# Testing
model.eval()
test_loss = 0.0
correct = 0
total = 0

with torch.no_grad():
    for features, labels in test_loader:
        features = features.view(features.size(0), 1, 1, -1).to(device)
        labels = labels.to(device)

        outputs = model(features, features)
        loss = criterion(outputs, labels)

        test_loss += loss.item() * features.size(0)

        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

test_loss = test_loss / len(test_loader.dataset)
accuracy = correct / total * 100

print(f'Test Loss: {test_loss:.4f}, Accuracy: {accuracy:.2f}%')

Note that you may need to adjust the model architecture, hyperparameters, and file paths based on your specific requirements.