torch 心电图分类

心电图分类是通过对心电图数据进行分析和处理，将其归类为不同的心脏疾病类型。使用深度学习算法，如卷积神经网络（CNN）可以很好地处理这种分类问题。

在使用PyTorch进行心电图分类时，可以将数据集加载到PyTorch中，并使用CNN模型进行训练和测试。下面是一个简单的心电图分类示例：

import torch
import torch.nn as nn
from torch.utils.data import DataLoader, Dataset

# 加载数据集
class ECGDataset(Dataset):
    def __init__(self, data, labels):
        self.data = data
        self.labels = labels

    def __len__(self):
        return len(self.labels)

    def __getitem__(self, index):
        x = self.data[index]
        y = self.labels[index]
        return x, y

# 定义CNN模型
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv1d(in_channels=1, out_channels=32, kernel_size=5, stride=1, padding=2)
        self.pool = nn.MaxPool1d(2, 2)
        self.conv2 = nn.Conv1d(32, 64, 5, 1, 2)
        self.fc1 = nn.Linear(64 * 125, 1024)
        self.fc2 = nn.Linear(1024, 512)
        self.fc3 = nn.Linear(512, 2)

    def forward(self, x):
        x = self.pool(torch.relu(self.conv1(x)))
        x = self.pool(torch.relu(self.conv2(x)))
        x = x.view(-1, 64 * 125)
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = self.fc3(x)
        return x

# 定义训练函数
def train(model, train_loader, optimizer, criterion, device):
    model.train()
    train_loss = 0.0
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = data.to(device), target.to(device)
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()
        train_loss += loss.item() * len(data)
    return train_loss / len(train_loader.dataset)

# 定义测试函数
def test(model, test_loader, criterion, device):
    model.eval()
    test_loss = 0.0
    correct = 0
    with torch.no_grad():
        for data, target in test_loader:
            data, target = data.to(device), target.to(device)
            output = model(data)
            test_loss += criterion(output, target).item() * len(data)
            pred = output.argmax(dim=1, keepdim=True)
            correct += pred.eq(target.view_as(pred)).sum().item()

    test_loss /= len(test_loader.dataset)
    accuracy = 100.0 * correct / len(test_loader.dataset)
    return test_loss, accuracy

# 训练模型
def main():
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    train_data = torch.tensor(train_data)
    train_labels = torch.tensor(train_labels)
    test_data = torch.tensor(test_data)
    test_labels = torch.tensor(test_labels)
    train_dataset = ECGDataset(train_data, train_labels)
    test_dataset = ECGDataset(test_data, test_labels)
    train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
    test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)

    model = Net().to(device)
    optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
    criterion = nn.CrossEntropyLoss()

    for epoch in range(10):
        train_loss = train(model, train_loader, optimizer, criterion, device)
        test_loss, accuracy = test(model, test_loader, criterion, device)
        print('Epoch: {}, Train Loss: {:.6f}, Test Loss: {:.6f}, Accuracy: {:.2f}%'.format(
            epoch + 1, train_loss, test_loss, accuracy))

if __name__ == '__main__':
    main()

在这个示例中，我们使用了一个具有两个卷积层和三个全连接层的CNN模型，并使用Adam优化器和交叉熵损失函数进行训练。通过在训练集和测试集上进行训练和评估，我们可以获得模型的准确性并进行心电图分类。