第P4周：猴痘病识别

一、导入数据

import torch
import torch.nn as nn
import torchvision.transforms as transforms
import torchvision
from torchvision import transforms, datasets

import os,PIL,pathlib

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

device

import os,PIL,random,pathlib

data_dir = './4-data/'
data_dir = pathlib.Path(data_dir)

data_paths = list(data_dir.glob('*'))
classeNames = [str(path).split("\\")[1] for path in data_paths]
classeNames

total_datadir = 'd:/Desktop/deep_learning/'

# 关于transforms.Compose的更多介绍可以参考：https://blog.csdn.net/qq_38251616/article/details/124878863
train_transforms = transforms.Compose([
    transforms.Resize([224, 224]),  # 将输入图片resize成统一尺寸
    transforms.ToTensor(),          # 将PIL Image或numpy.ndarray转换为tensor，并归一化到[0,1]之间
    transforms.Normalize(           # 标准化处理-->转换为标准正太分布（高斯分布），使模型更容易收敛
        mean=[0.485, 0.456, 0.406], 
        std=[0.229, 0.224, 0.225])  # 其中 mean=[0.485,0.456,0.406]与std=[0.229,0.224,0.225] 从数据集中随机抽样计算得到的。
])

total_data = datasets.ImageFolder(total_datadir,transform=train_transforms)
total_data

total_data.class_to_idx

 1.划分数据集

train_size = int(0.8 * len(total_data))
test_size  = len(total_data) - train_size
train_dataset, test_dataset = torch.utils.data.random_split(total_data, [train_size, test_size])
train_dataset, test_dataset

train_size,test_size

batch_size = 32

train_dl = torch.utils.data.DataLoader(train_dataset,
                                           batch_size=batch_size,
                                           shuffle=True,
                                           num_workers=1)
test_dl = torch.utils.data.DataLoader(test_dataset,
                                          batch_size=batch_size,
                                          shuffle=True,
                                          num_workers=1)

for X, y in test_dl:
    print("Shape of X [N, C, H, W]: ", X.shape)
    print("Shape of y: ", y.shape, y.dtype)
    break

二、构建简单的CNN网络

import torch.nn.functional as F

class Network_bn(nn.Module):
    def __init__(self):
        super(Network_bn, self).__init__()
        """
        nn.Conv2d()函数：
        第一个参数（in_channels）是输入的channel数量
        第二个参数（out_channels）是输出的channel数量
        第三个参数（kernel_size）是卷积核大小
        第四个参数（stride）是步长，默认为1
        第五个参数（padding）是填充大小，默认为0
        """
        self.conv1 = nn.Conv2d(in_channels=3, out_channels=12, kernel_size=5, stride=1, padding=0)
        self.bn1 = nn.BatchNorm2d(12)
        self.conv2 = nn.Conv2d(in_channels=12, out_channels=12, kernel_size=5, stride=1, padding=0)
        self.bn2 = nn.BatchNorm2d(12)
        self.pool = nn.MaxPool2d(2,2)
        self.conv4 = nn.Conv2d(in_channels=12, out_channels=24, kernel_size=5, stride=1, padding=0)
        self.bn4 = nn.BatchNorm2d(24)
        self.conv5 = nn.Conv2d(in_channels=24, out_channels=24, kernel_size=5, stride=1, padding=0)
        self.bn5 = nn.BatchNorm2d(24)
        self.fc1 = nn.Linear(24*50*50, len(classeNames))

    def forward(self, x):
        x = F.relu(self.bn1(self.conv1(x)))      
        x = F.relu(self.bn2(self.conv2(x)))     
        x = self.pool(x)                        
        x = F.relu(self.bn4(self.conv4(x)))     
        x = F.relu(self.bn5(self.conv5(x)))  
        x = self.pool(x)                        
        x = x.view(-1, 24*50*50)
        x = self.fc1(x)

        return x

device = "cuda" if torch.cuda.is_available() else "cpu"
print("Using {} device".format(device))

model = Network_bn().to(device)
model

三、训练模型 

loss_fn    = nn.CrossEntropyLoss() # 创建损失函数
learn_rate = 1e-4 # 学习率
opt        = torch.optim.SGD(model.parameters(),lr=learn_rate)

# 训练循环
def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)  # 训练集的大小，一共60000张图片
    num_batches = len(dataloader)   # 批次数目，1875（60000/32）

    train_loss, train_acc = 0, 0  # 初始化训练损失和正确率
    
    for X, y in dataloader:  # 获取图片及其标签
        X, y = X.to(device), y.to(device)
        
        # 计算预测误差
        pred = model(X)          # 网络输出
        loss = loss_fn(pred, y)  # 计算网络输出和真实值之间的差距，targets为真实值，计算二者差值即为损失
        
        # 反向传播
        optimizer.zero_grad()  # grad属性归零
        loss.backward()        # 反向传播
        optimizer.step()       # 每一步自动更新
        
        # 记录acc与loss
        train_acc  += (pred.argmax(1) == y).type(torch.float).sum().item()
        train_loss += loss.item()
            
    train_acc  /= size
    train_loss /= num_batches

    return train_acc, train_loss

def test (dataloader, model, loss_fn):
    size        = len(dataloader.dataset)  # 测试集的大小，一共10000张图片
    num_batches = len(dataloader)          # 批次数目，313（10000/32=312.5，向上取整）
    test_loss, test_acc = 0, 0
    
    # 当不进行训练时，停止梯度更新，节省计算内存消耗
    with torch.no_grad():
        for imgs, target in dataloader:
            imgs, target = imgs.to(device), target.to(device)
            
            # 计算loss
            target_pred = model(imgs)
            loss        = loss_fn(target_pred, target)
            
            test_loss += loss.item()
            test_acc  += (target_pred.argmax(1) == target).type(torch.float).sum().item()

    test_acc  /= size
    test_loss /= num_batches

    return test_acc, test_loss

epochs     = 20
train_loss = []
train_acc  = []
test_loss  = []
test_acc   = []

for epoch in range(epochs):
    model.train()
    epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, opt)
    
    model.eval()
    epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)
    
    train_acc.append(epoch_train_acc)
    train_loss.append(epoch_train_loss)
    test_acc.append(epoch_test_acc)
    test_loss.append(epoch_test_loss)
    
    template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%，Test_loss:{:.3f}')
    print(template.format(epoch+1, epoch_train_acc*100, epoch_train_loss, epoch_test_acc*100, epoch_test_loss))
print('Done')

Epoch: 1, Train_acc:60.2%, Train_loss:0.709, Test_acc:55.0%，Test_loss:0.849
cpu
cpu
Epoch: 2, Train_acc:67.4%, Train_loss:0.604, Test_acc:66.4%，Test_loss:0.586
cpu
cpu
Epoch: 3, Train_acc:69.4%, Train_loss:0.592, Test_acc:68.3%，Test_loss:0.629
cpu
cpu
Epoch: 4, Train_acc:75.0%, Train_loss:0.519, Test_acc:68.5%，Test_loss:0.588
cpu
cpu
Epoch: 5, Train_acc:76.9%, Train_loss:0.491, Test_acc:64.3%，Test_loss:0.727
cpu
cpu
Epoch: 6, Train_acc:79.3%, Train_loss:0.457, Test_acc:76.5%，Test_loss:0.513
cpu
cpu
Epoch: 7, Train_acc:82.0%, Train_loss:0.421, Test_acc:70.6%，Test_loss:0.585
cpu
cpu
Epoch: 8, Train_acc:83.0%, Train_loss:0.407, Test_acc:68.3%，Test_loss:0.601
cpu
cpu
Epoch: 9, Train_acc:84.6%, Train_loss:0.394, Test_acc:71.1%，Test_loss:0.548
cpu
cpu
Epoch:10, Train_acc:86.1%, Train_loss:0.370, Test_acc:76.9%，Test_loss:0.467
cpu
cpu
Epoch:11, Train_acc:87.2%, Train_loss:0.353, Test_acc:77.4%，Test_loss:0.469
cpu
cpu
Epoch:12, Train_acc:88.3%, Train_loss:0.338, Test_acc:79.5%，Test_loss:0.450
cpu
cpu
Epoch:13, Train_acc:89.5%, Train_loss:0.324, Test_acc:80.9%，Test_loss:0.438
cpu
cpu
Epoch:14, Train_acc:90.7%, Train_loss:0.311, Test_acc:82.3%，Test_loss:0.430
cpu
cpu
Epoch:15, Train_acc:90.7%, Train_loss:0.305, Test_acc:83.4%，Test_loss:0.429
cpu
cpu
Epoch:16, Train_acc:91.2%, Train_loss:0.290, Test_acc:83.4%，Test_loss:0.422
cpu
cpu
Epoch:17, Train_acc:92.4%, Train_loss:0.276, Test_acc:82.1%，Test_loss:0.430
cpu
cpu
Epoch:18, Train_acc:92.6%, Train_loss:0.267, Test_acc:82.5%，Test_loss:0.417
cpu
cpu
Epoch:19, Train_acc:92.4%, Train_loss:0.264, Test_acc:83.2%，Test_loss:0.412
cpu
cpu
Epoch:20, Train_acc:93.5%, Train_loss:0.247, Test_acc:81.6%，Test_loss:0.424
Done

Process finished with exit code 0

这个图这么崎岖的原因可能是测试集的样本量太少？

四、指定图片进行预测

from PIL import Image 

classes = list(total_data.class_to_idx)

def predict_one_image(image_path, model, transform, classes):
    
    test_img = Image.open(image_path).convert('RGB')
    # plt.imshow(test_img)  # 展示预测的图片

    test_img = transform(test_img)
    img = test_img.to(device).unsqueeze(0)
    
    model.eval()
    output = model(img)

    _,pred = torch.max(output,1)
    pred_class = classes[pred]
    print(f'预测结果是：{pred_class}')

# 预测训练集中的某张照片
predict_one_image(image_path='./4-data/Monkeypox/M01_01_00.jpg', 
                  model=model, 
                  transform=train_transforms, 
                  classes=classes)

 

五、保存并加载模型

# 模型保存
PATH = './model.pth'  # 保存的参数文件名
torch.save(model.state_dict(), PATH)

# 将参数加载到model当中
model.load_state_dict(torch.load(PATH, map_location=device))

六、个人总结

本节的要求是保存效果最好的模型，由于我在我的小小笔记本跑这个深度学习，内存不太够，而且还没有GPU，只能用CPU跑，汗颜……

所以只换了一个参数，分别是learn_rate=1e-3，optimizer_type = torch.optim.Adam，这个搭配的效果更好一些（但是咩有截图，再次流汗黄豆……），以上展示的是learn_rate=1e-4，optimizer_type = torch.optim.sdg，准确率稍微低一点点吧。

本节学会了如何调整模型的参数，观察不同参数会使模型的准确率发生什么样的变化，还是挺有趣的。

此外，还学会了如何保存效果最好的参数，并如何将参数加载到模型中！