血细胞分类项目

- 数据集：血细胞分类数据集
- 数据处理 dataset.py
- 网络 net.py
- 训练 train.py
- 拿训练集的几张图进行预测

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

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):  # 模仿VGGdef __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 * 14x = 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]=kBatch_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 = 0total = 0running_loss = 0model.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 / totaltest_correct = 0test_total = 0test_running_loss = 0model.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_totalif 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 = 20train_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') #保存模型训练权重

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

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

model.train()

验证/测试模式（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)/2plt.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()