我的环境：

言语环境：Python3.10.11
编译器：Jupyter Notebook
深度学习结构：Pytorch 2.0.1+cu118
显卡（GPU）：NVIDIA GeForce RTX 4070

相关教程：

编译器教程：【新手入门深度学习 | 1-2：编译器Jupyter Notebook】
深度学习环境配置教程：【新手入门深度学习 | 1-1：配置深度学习环境】
一个深度学习小白需求的一切资料我都放这儿了：【新手入门深度学习 | 目录】

主张你学习本文之前先看看下面这篇入门文章，以便你能够更好的理解本文：新手入门深度学习 | 2-1：图画数据建模流程示例

强烈主张我们运用Jupyter Notebook编译器翻开源码，你接下来的操作将会非常便捷的！

如果你是深度学习小白，阅览本文前主张先学习一下 《新手入门深度学习》
如果你有必定根底，可是缺少实战经验，可通过 《深度学习100例》 补齐根底
别的，我们正在通过 365天深度学习练习营 抱团学习，营内为我们提供体系的学习教案与专业的辅导、非常良好的学习气氛，欢迎你的参加

要求：

练习过程中保存作用最好的模型参数。

加载最佳模型参数辨认本地的一张图片。

调整网络结构使测验集accuracy到达88%（要点）。

拔高（可选）：

调整模型参数并调查测验集的准确率改变。

尝试设置动态学习率。

测验集accuracy到达90%。

一、前期准备

1. 设置GPU

如果设备上支持GPU就运用GPU,否则运用CPU

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

device(type='cuda')

2. 导入数据

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

['Monkeypox', 'Others']

total_datadir = './4-data/'
# 关于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

Dataset ImageFolder
    Number of datapoints: 2142
    Root location: ./4-data/
    StandardTransform
Transform: Compose(
               Resize(size=[224, 224], interpolation=bilinear, max_size=None, antialias=None)
               ToTensor()
               Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
           )

total_data.class_to_idx

{'Monkeypox': 0, 'Others': 1}

3. 区分数据集

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

(<torch.utils.data.dataset.Subset at 0x16dac6e3fd0>,
 <torch.utils.data.dataset.Subset at 0x16dac6e3e50>)

train_size,test_size

(1713, 429)

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

Shape of X [N, C, H, W]:  torch.Size([32, 3, 224, 224])
Shape of y:  torch.Size([32]) torch.int64

二、构建简单的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

Using cuda device
Network_bn(
  (conv1): Conv2d(3, 12, kernel_size=(5, 5), stride=(1, 1))
  (bn1): BatchNorm2d(12, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (conv2): Conv2d(12, 12, kernel_size=(5, 5), stride=(1, 1))
  (bn2): BatchNorm2d(12, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv4): Conv2d(12, 24, kernel_size=(5, 5), stride=(1, 1))
  (bn4): BatchNorm2d(24, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (conv5): Conv2d(24, 24, kernel_size=(5, 5), stride=(1, 1))
  (bn5): BatchNorm2d(24, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (fc1): Linear(in_features=60000, out_features=2, bias=True)
)

三、练习模型

1. 设置超参数

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

2. 编写练习函数

# 练习循环
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

3. 编写测验函数

测验函数和练习函数大致相同，可是由于不进行梯度下降对网络权重进行更新，所以不需求传入优化器

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

4. 正式练习

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.8%, Train_loss:0.655, Test_acc:60.6%，Test_loss:0.668
Epoch: 2, Train_acc:70.2%, Train_loss:0.575, Test_acc:72.7%，Test_loss:0.560
Epoch: 3, Train_acc:74.5%, Train_loss:0.527, Test_acc:71.3%，Test_loss:0.549
Epoch: 4, Train_acc:78.4%, Train_loss:0.483, Test_acc:73.4%，Test_loss:0.519
....
Epoch:18, Train_acc:91.4%, Train_loss:0.271, Test_acc:83.0%，Test_loss:0.382
Epoch:19, Train_acc:92.6%, Train_loss:0.260, Test_acc:83.7%，Test_loss:0.381
Epoch:20, Train_acc:92.1%, Train_loss:0.260, Test_acc:82.3%，Test_loss:0.396
Done

四、成果可视化

1. Loss与Accuracy图

import matplotlib.pyplot as plt
#隐藏警告
import warnings
warnings.filterwarnings("ignore")               #忽略警告信息
plt.rcParams['font.sans-serif']    = ['SimHei'] # 用来正常显现中文标签
plt.rcParams['axes.unicode_minus'] = False      # 用来正常显现负号
plt.rcParams['figure.dpi']         = 100        #分辨率
epochs_range = range(epochs)
plt.figure(figsize=(12, 3))
plt.subplot(1, 2, 1)
plt.plot(epochs_range, train_acc, label='Training Accuracy')
plt.plot(epochs_range, test_acc, label='Test Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')
plt.subplot(1, 2, 2)
plt.plot(epochs_range, train_loss, label='Training Loss')
plt.plot(epochs_range, test_loss, label='Test Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()

2. 指定图片进行猜测

⭐torch.squeeze()详解

对数据的维度进行压缩，去掉维数为1的的维度

函数原型：

torch.squeeze(input, dim=None, *, out=None)

要害参数阐明：

input (Tensor)：输入Tensor

dim (int, optional)：如果给定，输入将只在这个维度上被压缩

实战事例：

>>> x = torch.zeros(2, 1, 2, 1, 2)
>>> x.size()
torch.Size([2, 1, 2, 1, 2])
>>> y = torch.squeeze(x)
>>> y.size()
torch.Size([2, 2, 2])
>>> y = torch.squeeze(x, 0)
>>> y.size()
torch.Size([2, 1, 2, 1, 2])
>>> y = torch.squeeze(x, 1)
>>> y.size()
torch.Size([2, 2, 1, 2])

⭐torch.unsqueeze()

对数据维度进行扩大。给指定方位加上维数为一的维度

函数原型：

torch.unsqueeze(input, dim)

要害参数阐明：

input (Tensor)：输入Tensor

dim (int)：刺进单例维度的索引

实战事例：

>>> x = torch.tensor([1, 2, 3, 4])
>>> torch.unsqueeze(x, 0)
tensor([[ 1,  2,  3,  4]])
>>> torch.unsqueeze(x, 1)
tensor([[ 1],
        [ 2],
        [ 3],
        [ 4]])

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)

猜测成果是：Monkeypox

五、保存并加载模型

# 模型保存
PATH = './model.pth'  # 保存的参数文件名
torch.save(model.state_dict(), PATH)
# 将参数加载到model傍边
model.load_state_dict(torch.load(PATH, map_location=device))

<All keys matched successfully>

Pytorch实战 | 第4天：猴痘病识别

一、前期准备

1. 设置GPU

2. 导入数据

3. 区分数据集

二、构建简单的CNN网络

三、练习模型

1. 设置超参数

2. 编写练习函数

3. 编写测验函数

4. 正式练习

四、成果可视化

1. Loss与Accuracy图

2. 指定图片进行猜测

五、保存并加载模型

作者信息

推广

Pytorch实战 | 第4天：猴痘病识别

一、 前期准备

1. 设置GPU

2. 导入数据

3. 区分数据集

二、构建简单的CNN网络

三、 练习模型

1. 设置超参数

2. 编写练习函数

3. 编写测验函数

4. 正式练习

四、 成果可视化

1. Loss与Accuracy图

2. 指定图片进行猜测

五、保存并加载模型

相关文章

Stable Diffusion 玩出新花样 | 人工智能周刊第23期

大语言模型的开发利器langchain

超好用的官方core-ktx库，了解一下(终)~

大屏经典组件：“无限滚动” 从分析到开发

作者信息

推广

一、前期准备

三、练习模型

四、成果可视化