神经网络在医疗诊断中的应用实践

    import torch.nn as nn
    import torch.optim as optim
    from torchvision.models import resnet18
    from torchvision import transforms
    from torch.utils.data import DataLoader
    from dataset import LungCTDataset
    
    # 数据预处理
    transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
    ])
    
    # 加载数据集
    train_set = LungCTDataset('train_data', transform=transform)
    val_set = LungCTDataset('val_data', transform=transform)
    train_loader = DataLoader(train_set, batch_size=32, shuffle=True)
    val_loader = DataLoader(val_set, batch_size=32, shuffle=False)
    
    # 定义模型
    model = resnet18(pretrained=True)
    model.fc = nn.Linear(model.fc.in_features, 2)
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    model = model.to(device)
    
    # 训练模型
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=1e-4)
    
    for epoch in range(50):
    running_loss = 0.0
    for i, data in enumerate(train_loader, 0):
        inputs, labels = data
        inputs, labels = inputs.to(device), labels.to(device)
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
    print(f'Epoch {epoch + 1} loss: {running_loss / len(train_loader)}')
    
    # 评估模型
    correct = 0
    total = 0
    with torch.no_grad():
    for data in val_loader:
        images, labels = data
        images, labels = images.to(device), labels.to(device)
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()
    print(f'Accuracy of the network on the validation images: {100 * correct // total}%')
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-12/U6dJORrVNu3hKD4YkX9lF7cZ5Cez.png)

    import torch.nn as nn
    import torch.optim as optim
    from torch.utils.data import DataLoader
    from dataset import ECGDataset
    
    # 数据预处理
    train_set = ECGDataset('train_data')
    val_set = ECGDataset('val_data')
    train_loader = DataLoader(train_set, batch_size=32, shuffle=True, num_workers=4)
    val_loader = DataLoader(val_set, batch_size=32, shuffle=False, num_workers=4)
    
    # 定义模型
    class ECGClassifier(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, num_classes):
        super(ECGClassifier, self).__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
        self.fc = nn.Linear(hidden_size, num_classes)
    
    def forward(self, x):
        h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(device)
        c0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(device)
        out, _ = self.lstm(x, (h0, c0))
        out = self.fc(out[:, -1, :])
        return out
    
    model = ECGClassifier(input_size=12, hidden_size=64, num_layers=2, num_classes=2)
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    model = model.to(device)
    
    # 训练模型
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=1e-3)
    
    for epoch in range(50):
    running_loss = 0.0
    for i, data in enumerate(train_loader, 0):
        inputs, labels = data
        inputs, labels = inputs.to(device), labels.to(device)
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
    print(f'Epoch {epoch + 1} loss: {running_loss / len(train_loader)}')
    
    # 评估模型
    correct = 0
    total = 0
    with torch.no_grad():
    for data in val_loader:
        ecg, labels = data
        ecg, labels = ecg.to(device), labels.to(device)
        outputs = model(ecg)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()
    print(f'Accuracy of the network on the validation data: {100 * correct // total}%')
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-12/W9TvfnZY0ROXLpoc8jkrdzMuQBgN.png)