pytorch——官网入门demo——实现一个图像分类器

目录

demo的流程

1. model.py

 卷积 Conv2d

 公式

 池化 MaxPool2d

特点如果输入是三维的,那么输出也是三维的

Tensor的展平:view()

全连接 Linear

2. train.py

导包

下载数据集:

导入、加载 训练集 

导入、加载 测试集

类别

开始训练

 名词解释 ​

训练结果 

 3. predict.py

 预测结果​


pytorch官网:Training a Classifier — PyTorch Tutorials 1.10.1+cu102 documentation

宝藏博主:霹雳吧啦Wz_太阳花的小绿豆_CSDN博客-深度学习,Tensorflow,软件安装领域博主

demo的流程

  1. model.py ——定义LeNet网络模型
  2. train.py ——加载数据集并训练,训练集计算loss(损失值),测试集计算accuracy,保存训练好的网络参数
  3. predict.py——得到训练好的网络参数后,用自己找的图像进行分类测试

1. model.py

先给出代码,模型是基于LeNet做简单修改,很容易理解:

 

import torch.nn as nn
import torch.nn.functional as F


class LeNet(nn.Module):                    # 继承于nn.Module这个父类
    def __init__(self):
        super(LeNet, self).__init__()
        self.conv1 = nn.Conv2d(3, 16, 5)
        self.pool1 = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(16, 32, 5)
        self.pool2 = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(32*5*5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = F.relu(self.conv1(x))    # input(3, 32, 32) output(16, 28, 28)
        x = self.pool1(x)            # output(16, 14, 14)
        x = F.relu(self.conv2(x))    # output(32, 10, 10)
        x = self.pool2(x)            # output(32, 5, 5)
        x = x.view(-1, 32*5*5)       # output(32*5*5)
        x = F.relu(self.fc1(x))      # output(120)
        x = F.relu(self.fc2(x))      # output(84)
        x = self.fc3(x)              # output(10)
        return x


过程如下 

在这里插入图片描述 

 

  • pytorch 中 tensor(也就是输入输出层)的 通道排序为:[batch, channel, height, width]

nn.Conv2d 卷积层

nn.MaxPool2d 下采样层

nn.Linear 全连接层

 卷积 Conv2d


我们常用的卷积(Conv2d)在pytorch中对应的函数是:

torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros')



一般使用时关注以下几个参数即可:

in_channels:输入特征矩阵的深度。如输入一张RGB彩色图像,那in_channels=3(三通道)
 

out_channels输入特征矩阵的深度。也等于卷积核的个数,使用n个卷积核输出的特征矩阵深度就是n
 

kernel_size:卷积核的尺寸(大小)。可以是int类型,如3 代表卷积核的height=width=3,也可以是tuple类型如(3, 5)代表卷积核的height=3,width=5
 

stride:卷积核的步长。默认为1,和kernel_size一样输入可以是int型,也可以是tuple类型
 

padding:补零操作,默认为0。可以为int型如1即补一圈0,如果输入为tuple型如(2, 1) 代表在上下补2行,左右补1列。

pytorch——官网入门demo——实现一个图像分类器_第1张图片 

 公式


 

输入图片大小 W×W(一般情况下Width=Height)
Filter大小 F×F
步长 S
padding的像素数 P
参考:pytorch中的卷积操作详解_霹雳吧啦Wz-CSDN博客_pytorch 卷积

 池化 MaxPool2d

最大池化(MaxPool2d)的意思就是卷积网络也经常使用池化层来缩减模型的大小,提高计算速度,同时提高所提取特征的鲁棒性

self.pool1 = nn.MaxPool2d(2, 2)

特点如果输入是三维的,那么输出也是三维的

参考卷积神经网络——池化层学习——最大池化_Alex-CSDN博客_最大池化

Tensor的展平:view()

注意到,在经过第二个池化层后,数据还是一个三维的Tensor (32, 5, 5),需要先经过展平后(32*5*5)再传到全连接层:

  x = self.pool2(x)            # output(32, 5, 5)
  x = x.view(-1, 32*5*5)       # output(32*5*5)
  

全连接 Linear

全连接( Linear)在 pytorch 中对应的函数是:

bias 偏置

Linear(in_features, out_features, bias=True)

2. train.py

导包

import torch
import torchvision
import torch.nn as nn
from model import LeNet
import torch.optim as optim
import torchvision.transforms as transforms

下载数据集:

CIFAR-10 数据集可视化详细讲解(附代码)_G果的博客-CSDN博客_cifar10数据集

 

导入、加载 训练集 

def main():
    transform = transforms.Compose(
        [transforms.ToTensor(),
         transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

   # 50000张训练图片
     # 第一次使用时要将download设置为True才会自动去下载数据集
    train_set = torchvision.datasets.CIFAR10(root='./data', train=True,
                                              download=False, transform=transform)

    train_loader = torch.utils.data.DataLoader(train_set, batch_size=36,
                                                shuffle=True, num_workers=0)

导入、加载 测试集

# 10000张验证图片
     # 第一次使用时要将download设置为True才会自动去下载数据集
    val_set = torchvision.datasets.CIFAR10(root='./data', train=False,
                                           download=False, transform=transform)
    val_loader = torch.utils.data.DataLoader(val_set, batch_size=5000,
                                              shuffle=False, num_workers=0)
    
# 获取测试集中的图像和标签,用于accuracy计算
    val_data_iter = iter(val_loader)
    val_image, val_label = val_data_iter.next()

类别

classes = ('plane', 'car', 'bird', 'cat',
                'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

开始训练

net = LeNet()
    loss_function = nn.CrossEntropyLoss()
    optimizer = optim.Adam(net.parameters(), lr=0.001)

    for epoch in range(5):  # loop over the dataset multiple times

        running_loss = 0.0
        for step, data in enumerate(train_loader, start=0):
            # get the inputs; data is a list of [inputs, labels]
            inputs, labels = data

            # zero the parameter gradients
            optimizer.zero_grad()
            # forward + backward + optimize
            outputs = net(inputs)
            loss = loss_function(outputs, labels)
            loss.backward()
            optimizer.step()

            # print statistics
            running_loss += loss.item()
            if step % 500 == 499:    # print every 500 mini-batches
                with torch.no_grad():
                    outputs = net(val_image)  # [batch, 10]
                    predict_y = torch.max(outputs, dim=1)[1]
                    accuracy = torch.eq(predict_y, val_label).sum().item() / val_label.size(0)

                    print('[%d, %5d] train_loss: %.3f  test_accuracy: %.3f' %
                          (epoch + 1, step + 1, running_loss / 500, accuracy))
                    running_loss = 0.0

    print('Finished Training')

    save_path = './Lenet.pth'
    torch.save(net.state_dict(), save_path)


if __name__ == '__main__':
    main()

 名词解释 pytorch——官网入门demo——实现一个图像分类器_第2张图片

训练结果 

pytorch——官网入门demo——实现一个图像分类器_第3张图片

这个是我们看我们的目录多出个pth文件类型(这个就是我们的模型)

pytorch——官网入门demo——实现一个图像分类器_第4张图片

 

 

 3. predict.py

用来预测,根据训练的模型预测东西

import torch
import torchvision.transforms as transforms
from PIL import Image

from model import LeNet


def main():   #我们首先需resize成跟训练集图像一样的大小
    transform = transforms.Compose(
        [transforms.Resize((32, 32)),
         transforms.ToTensor(),
         transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

    classes = ('plane', 'car', 'bird', 'cat',
               'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
# 实例化网络,加载训练好的模型参数
    net = LeNet()
    net.load_state_dict(torch.load('Lenet.pth'))

# 导入要测试的图像(自己找的,不在数据集中),放在源文件目录下
    im = Image.open('3.jpeg')
    im = transform(im)  # [C, H, W]
    im = torch.unsqueeze(im, dim=0)  '''对数据增加一个新维度,因为tensor的参数是[batch,         
                                         channel, height, width]'''
     
#预测
    with torch.no_grad():
        outputs = net(im)
        predict = torch.max(outputs, dim=1)[1].data.numpy()
    print(classes[int(predict)])


if __name__ == '__main__':
    main()

图片3.jepgpytorch——官网入门demo——实现一个图像分类器_第5张图片

 

 预测结果pytorch——官网入门demo——实现一个图像分类器_第6张图片

 

你可能感兴趣的:(深度学习,pytorch,深度学习,机器学习)