血细胞分类项目

数据集：血细胞分类数据集

https://aistudio.baidu.com/datasetdetail/10278

数据处理 dataset.py

from torchvision import transforms
import torchvision
import torch
import matplotlib.pyplot as plt
from PIL import Image
#一、数据转换
train_transformer=transforms.Compose(
[
   transforms.RandomHorizontalFlip(0.2),
   transforms.RandomRotation(68),
   transforms.RandomGrayscale(0.2),
   transforms.Resize((256,256)),
   transforms.ToTensor(),
   transforms.Normalize(mean=[0.5,0.5,0.5],
                std=[0.5,0.5,0.5])
]
)
test_transformer=transforms.Compose(
[
   transforms.Resize((256,256)),
   transforms.ToTensor(),
   transforms.Normalize(mean=[0.5,0.5,0.5],
                std=[0.5,0.5,0.5])
]
)
#二、读入数据
train_dataset=torchvision.datasets.ImageFolder(
  'E:/Jupytercode/血细胞分类/数据/blood-cells/dataset2-master/dataset2-master/images/TRAIN',
    transform=train_transformer
)

test_dataset=torchvision.datasets.ImageFolder(
  'E:/Jupytercode/血细胞分类/数据/blood-cells/dataset2-master/dataset2-master/images/TEST',
   transform=test_transformer
)

#进行编码
#原      {'EOSINOPHIL': 0, 'LYMPHOCYTE': 1, 'MONOCYTE': 2, 'NEUTROPHIL': 3}
#转换后  {0: 'EOSINOPHIL', 1: 'LYMPHOCYTE', 2: 'MONOCYTE', 3: 'NEUTROPHIL'}
id_to_class={}
for k,v in train_dataset.class_to_idx.items():
    #print(k,v)
    id_to_class[v]=k
#id_to_class #查看转换后的格式

#三、批次读入数据，可以作为神经网络的输入  一次性拿多少张图片进行训练
Batch_size=64#一次性训练64张
dl_train=torch.utils.data.DataLoader(
        train_dataset,
        batch_size=Batch_size,
        shuffle=True
)
dl_test=torch.utils.data.DataLoader(
        test_dataset,
        batch_size=Batch_size,
        shuffle=True
)
#取一个批次的数据
# img,label=next(iter(dl_train))
# plt.figure(figsize=(12,8))
# for i,(img,label) in enumerate(zip(img[:8],label[:8])):
#     img=(img.permute(1,2,0).numpy()+1)/2
#     plt.subplot(2,4,i+1)
#     plt.title(id_to_class.get(label.item())) #0: 'EOSINOPHIL', 1: 'LYMPHOCYTE', 2: 'MONOCYTE', 3: 'NEUTROPHIL'
#     plt.imshow(img)
# plt.show() #查看图片

print("数据处理已完成")

网络 net.py

import torch.nn as nn
import torch
#建立神经网络
class Net(nn.Module):  # 模仿VGG
    def __init__(self):
        super(Net, self).__init__()

        self.layer1 = nn.Sequential(
            nn.Conv2d(3, 32, kernel_size=3),
            nn.ReLU(),
            nn.MaxPool2d(2, 2)
        )
        self.layer2 = nn.Sequential(
            nn.Conv2d(32, 64, kernel_size=3),
            nn.ReLU(),
            nn.MaxPool2d(2, 2)
        )
        self.layer3 = nn.Sequential(
            nn.Conv2d(64, 128, kernel_size=3),
            nn.ReLU(),
            nn.MaxPool2d(2, 2)
        )

        self.layer4 = nn.Sequential(
            nn.Conv2d(128, 256, kernel_size=3),
            nn.ReLU(),
            nn.MaxPool2d(2, 2)

        )
        self.fc = nn.Sequential(
            nn.Linear(256 * 14 * 14, 1024),
            nn.ReLU(),
            nn.Linear(1024, 4)
        )

    def forward(self, x):
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)
        #print(x.shape)

        # 将原来的张量 x (四维)重新塑造为一个二维张量。第一个维度的大小由 PyTorch 自动计算，而第二个维度的大小被设置为 256 * 14 * 14
        x = x.view(-1, 256 * 14 * 14)
        x = self.fc(x)

        return x
if __name__ == '__main__':
    x = torch.rand([8, 3, 256, 256])
    model = Net()
    y = model(x)

训练 train.py

import torch as t
import torch.nn as nn
from tqdm import tqdm  #进度条
import net
from dataset import *


device = t.device("cuda") if t.cuda.is_available() else t.device("cpu")
train_dataset=torchvision.datasets.ImageFolder(
  'E:/Jupytercode/血细胞分类/数据/blood-cells/dataset2-master/dataset2-master/images/TRAIN',
    transform=train_transformer
)
test_dataset=torchvision.datasets.ImageFolder(
  'E:/Jupytercode/血细胞分类/数据/blood-cells/dataset2-master/dataset2-master/images/TEST',
   transform=test_transformer
)

id_to_class={}
for k,v in train_dataset.class_to_idx.items():
    #print(k,v)
    id_to_class[v]=k

Batch_size=64#一次性训练64张
dl_train=torch.utils.data.DataLoader(
        train_dataset,
        batch_size=Batch_size,
        shuffle=True
)
dl_test=torch.utils.data.DataLoader(
        test_dataset,
        batch_size=Batch_size,
        shuffle=True
)
model=net.Net()
model = model.to(device)
optim=torch.optim.Adam(model.parameters(),lr=0.001)
loss_fn=nn.CrossEntropyLoss()


def fit(epoch, model, trainloader, testloader):
    correct = 0
    total = 0
    running_loss = 0
    model.train()  # 训练模式下  识别normalize层
    for x, y in tqdm(trainloader):
        x, y = x.to('cuda'), y.to('cuda')
        y_pred = model(x)
        loss = loss_fn(y_pred, y)
        optim.zero_grad()
        loss.backward()
        optim.step()

        with torch.no_grad():
            y_pred = torch.argmax(y_pred, dim=1)
            correct += (y_pred == y).sum().item()
            total += y.size(0)
            running_loss += loss.item()

    epoch_loss = running_loss / len(trainloader.dataset)
    epoch_acc = correct / total

    test_correct = 0
    test_total = 0
    test_running_loss = 0
    model.eval()  # 验证模式下   不识别normalize层
    with torch.no_grad():
        for x, y in tqdm(testloader):
            x, y = x.to('cuda'), y.to('cuda')
            y_pred = model(x)
            loss = loss_fn(y_pred, y)
            y_pred = torch.argmax(y_pred, dim=1)
            test_correct += (y_pred == y).sum().item()
            test_total += y.size(0)
            test_running_loss += loss.item()

    epoch_test_loss = test_running_loss / len(testloader.dataset)
    epoch_test_acc = test_correct / test_total

    if epoch_acc > 0.95:
        model_state_dict = model.state_dict()
        torch.save(model_state_dict, './{}{}.pth'.format(epoch_acc, epoch_test_acc))

    print('epoch: ', epoch,
          'loss： ', round(epoch_loss, 3),
          'accuracy:', round(epoch_acc, 3),
          'test_loss： ', round(epoch_test_loss, 3),
          'test_accuracy:', round(epoch_test_acc, 3)
          )

    return epoch_loss, epoch_acc, epoch_test_loss, epoch_test_acc
if __name__ == '__main__':
    epochs = 20
    train_loss = []
    train_acc = []
    test_loss = []
    test_acc = []

    for epoch in range(epochs):
        epoch_loss, epoch_acc, epoch_test_loss, epoch_test_acc = fit(epoch,
                                                                     model,
                                                                     dl_train,
                                                                     dl_test)
        train_loss.append(epoch_loss)
        train_acc.append(epoch_acc)
        test_loss.append(epoch_test_loss)
        test_acc.append(epoch_test_acc)

    plt.plot(range(1, epochs + 1), train_loss, label='train_loss')# 绘制训练损失曲线，使用range(1, epochs+1)生成横坐标轴上的点，train_loss为纵坐标轴上的点
    plt.plot(range(1, epochs + 1), test_loss, label='test_loss')# 绘制验证损失曲线，使用range(1, epochs+1)生成横坐标轴上的点，val_loss为纵坐标轴上的点
    plt.legend()# 添加图例，label参数在前面的plot中设置，用于区分不同曲线
    plt.xlabel('Epochs')  # 设置横坐标轴的标签为'Epochs'
    plt.ylabel('Loss')  # 设置纵坐标轴的标签为'Loss'
    plt.savefig('loss.png')
    plt.show()

    plt.plot(range(1, epochs + 1), train_acc, label='train_acc')
    plt.plot(range(1, epochs + 1), test_acc, label='test_acc')
    plt.title('Training and Validation Accuracy')  # 可以添加标题
    plt.xlabel('Epochs')  # 为x轴添加标签
    plt.ylabel('Accuracy')
    plt.legend()
    plt.savefig('acc.png')
    plt.show()
    torch.save(model,'Bloodcell.pkl') #保存模型训练权重

在深度学习中，模型通常具有两种运行模式：训练模式和验证/测试模式。这两种模式的主要区别在于模型的行为和参数更新方式。

1. 训练模式（Training Mode）：
   在训练模式下，模型会执行以下操作：
   ①梯度计算： 计算模型参数关于损失函数的梯度，以便进行反向传播。
   ②参数更新： 根据梯度和优化算法，更新模型的参数以最小化损失函数。
   ③Dropout生效： 如果模型中使用了 Dropout 层，那么在训练模式下，Dropout 会生效，即在前向传播过程中会随机舍弃一些神经元，以防止过拟合。
   在 PyTorch 中，通过 model.train() 将模型设置为训练模式：

model.train()

2. 验证/测试模式（Validation/Testing Mode）：
   在验证/测试模式下，模型会执行以下操作：
   ①梯度计算： 不计算梯度，因为在验证/测试过程中不需要更新模型参数。
   ②Dropout不生效： 如果使用了 Dropout 层，那么在验证/测试模式下，Dropout 不生效，所有神经元都参与前向传播。
   ③评估模型性能： 使用模型进行预测，并评估模型在验证集或测试集上的性能。
   在 PyTorch 中，通过 model.eval() 将模型设置为验证/测试模式：

model.eval()

切换模型的运行模式是为了确保在不同阶段使用正确的行为。在训练模式下，模型需要进行梯度计算和参数更新，而在验证/测试模式下，模型不需要进行参数更新，而是专注于性能评估。

拿训练集的几张图进行预测

预测pred.py

from dataset import *

model=torch.load('Bloodcell.pkl')
img,label=next(iter(dl_test)) #选取一些图片进行预测
img=img.to('cuda')
model.eval()
pred=model(img)
pred_re=torch.argmax(pred, dim=1)

pred_re=pred_re.cpu().numpy()
pred_re=pred_re.tolist()

for i in pred_re[0:8]:
    print(id_to_class[i])
id_to_class[pred_re[0:8][1]]

plt.figure(figsize=(16,8))
img=img.cpu()#把图片重新放到CPU上
for i,(img,label) in enumerate(zip(img[:8],label[:8])):
    img=(img.permute(1,2,0).numpy()+1)/2
    plt.subplot(2,4,i+1)
    pred_title=id_to_class[pred_re[0:8][i]]
    plt.title('R:{},P:{}'.format(id_to_class.get(label.item()),pred_title))
    plt.imshow(img)
plt.show()