深度学习CV学习笔记（Lenet）

Posted 2022-01-07 蜡笔ting新

文章目录

• 前言
• 图像分类篇
• • Lenet
  • • model.py
    • train.py
    • • 导入训练数据
      • 导入测试数据
      • 关于损失的计算
    • predict.py

前言

之前苦于CV不知道具体怎么入手，在看完cs231n的课程之后，算是对整体的套路和方法有了大概的认识，但是牵扯但具体的代码，感觉还是处于一个非常懵的状态，好在突然发现了一个大佬github仓库，讲的正好是CV很经典的论文和具体的代码实现，因此我决定写一个笔记追踪我的学习过程。
下面给上大佬的仓库链接: https://github.com/WZMIAOMIAO/deep-learning-for-image-processing
再贴上另一位大佬的csdn博客，他也跟踪学习了这个仓库：https://blog.csdn.net/m0_37867091

图像分类篇

Lenet

这个网络的代码放在
deep-learning-for-image-processing-master\\pytorch_classification\\Test1_official_demo文件目录下
model .py
predict.py
train.py

model.py

先贴上代码和模型
模型结构:

代码：

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

class LeNet(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)		#把32*5*5，全连接到120个输出
        self.fc2 = nn.Linear(120,84)			
        self.fc3 = nn.Linear(84,10)				#全连接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))                 # input(32*5*5) output(120)
        x = F.relu(self.fc2(x))                 # output(84)
        x = self.fc3(x)                         # output(10)
        return x 

tensor.view() 则是调整tensor的形状，为全连接做准备，此处就是做了展平，当某个维度是-1，就是自动计算大小
此处则是会自动计算batch的大小。因为图片都是一批一批计算的，我们的tensor其实有四个维度[batch,channel,height,width]
可以看他的解释代码：

import torch as t
a=t.arange(0,6).view(2,3)
print(a)
 
b=a.view(-1,2)  #当某一维是-1时，会自动计算它的大小
print(b)
 
#输出
tensor([[0, 1, 2],
        [3, 4, 5]])
tensor([[0, 1],
        [2, 3],
        [4, 5]])

下面贴上 nn.Conv2d()的构造函数

def __init__(
        self,
        in_channels: int,									#输入维度指定为int型
        out_channels: int,									#输出维度指定为int型
        kernel_size: _size_2_t,								#卷积核大小，可以为int或者tuple型
        stride: _size_2_t = 1,								#可选参数，卷积步长可以为int或者tuple默认为1
        padding: Union[str, _size_2_t] = 0,					#可选参数，padding大小，可以为int，string或者tuple，默认为0
        dilation: _size_2_t = 1,
        groups: int = 1,
        bias: bool = True,									#是否有偏置项，默认为True
        padding_mode: str = 'zeros',  						# TODO: refine this type
        device=None,
        dtype=None
    ) -> None:
    '''Args:
        in_channels (int): Number of channels in the input image
        out_channels (int): Number of channels produced by the convolution
        kernel_size (int or tuple): Size of the convolving kernel
        stride (int or tuple, optional): Stride of the convolution. Default: 1
        padding (int, tuple or str, optional): Padding added to all four sides of
            the input. Default: 0
        padding_mode (string, optional): ``'zeros'``, ``'reflect'``,
            ``'replicate'`` or ``'circular'``. Default: ``'zeros'``
        dilation (int or tuple, optional): Spacing between kernel elements. Default: 1
        groups (int, optional): Number of blocked connections from input
            channels to output channels. Default: 1
        bias (bool, optional): If ``True``, adds a learnable bias to the
            output. Default: ``True``  '''           

关于padding: Union[str, _size_2_t] = 0的解释，联合体union在内存中只占有一块内存空间，空间大小由union中占位最多的数据类型决定，union在初始化的时候，union的值，由最后一个有效参数决定，因此在此处即指str类型参数或_size_2_t 仅有一个有效值，默认值为0.

x = x.view(-1,32*5*5) 则是把tensor展平，并自动计算batch的大小

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


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)
   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()                            #将累计的梯度清零，如果不清零会累加batch，能够实现一个大的batch
           # 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()

with torch.no_grad():被这个语句包裹的部分不会自动计算每个结点的损失和梯度并进行保存，在预测和验证的时候要进来，不然容易发生内存问题。详细的可以看 这篇博客
transforms.Compose（） 是pytorch给出的组合函数，他能把多个transform组合到一起，他的实现是靠遍历list，因此中括号一定要加，
下面贴上transform.Compose()函数的内部实现函数方便理解。
example:

  transforms.Compose([
         			transforms.CenterCrop(10),
        			transforms.ToTensor(),
     ])

内部实现：

    def __init__(self, transforms):
        self.transforms = transforms

    def __call__(self, img):
        for t in self.transforms:	#在此处的for循环中调用多个transform函数操作img图片
            img = t(img)
        return img					#最后把处理好的图片返回

transforms.ToTensor()函数先把PIL.Image或者numpy.ndarray转换成tensor类型，内部主要做了两个操作：1.把[0,255]的数据转换到[0.0, 1.0]之间。2.交换了数据的维度PIL.Image和numpy.ndarray是（H, W, C),H：height，W：width，C：channel，而tensor是（C, H, W)。

导入训练数据

# 导入50000张训练图片
train_set = torchvision.datasets.CIFAR10(root='./data', 	 # 数据集存放目录
										 train=True,		 # 表示是数据集中的训练集
                                        download=True,  	 # 第一次运行时为True，下载数据集，下载完成后改为False
                                        transform=transform) # 预处理过程
# 加载训练集，实际过程需要分批次（batch）训练                                        
train_loader = torch.utils.data.DataLoader(train_set, 	  # 导入的训练集
										   batch_size=50, # 每批训练的样本数
                                          shuffle=False,  # 是否打乱训练集
                                          num_workers=0)  # 使用线程数，在windows下设置为0

导入测试数据

# 导入10000张测试图片
test_set = torchvision.datasets.CIFAR10(root='./data', 
										train=False,	# 表示是数据集中的测试集
                                        download=False,transform=transform)
# 加载测试集
test_loader = torch.utils.data.DataLoader(test_set, 
										  batch_size=10000, # 每批用于验证的样本数
										  shuffle=False, num_workers=0)
# 获取测试集中的图像和标签，用于accuracy计算
test_data_iter = iter(test_loader)
test_image, test_label = test_data_iter.next()

关于损失的计算

optimizer.zero_grad()
loss.backward()
optimizer.step()
这三个函数请参考这篇博文：损失计算

predict.py

代码：

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

from model import LeNet


def main():
    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'))	#传入权重文件Lenet.pth

    im = Image.open('1.jpg')						#PIL包读入图片
    im = transform(im)  # [C, H, W]
    im = torch.unsqueeze(im, dim=0)  # [N, C, H, W] 对数据维度进行扩充，因为现在的图片是3维度，
 	#但是我们网络的输入是四维的，最前面还有batch维度

    with torch.no_grad(): #torch.no_grad() 是一个上下文管理器，被该语句 wrap 起来的部分将不会track 梯度。
        outputs = net(im)
        predict = torch.max(outputs, dim=1)[1].data.numpy() #获取最大的输出的index并从tensor转换成numpy
    print(classes[int(predict)])  					#把numpy类型数组转换成int类型，只能是一个元素的numpy

if __name__ == '__main__':
    main()

预测代码中transforms.Compose（）函数中比train文件中多了个resize函数，transforms.Resize((32, 32)是为了把图片重新定义为32*32的大小，因为我们下载的图片大小不一样的，无法传入网络训练。
torch.unsqueeze(im, dim=0)对im的维度进行扩充，dim=0在最前面增加一列。
im[C, H, W]，扩充后[B, C, H, W]
Lenet.ph文件是在我们运行完train.py之后生成的权重文件，会生成在和train.py相同的文件目录下，用于预测。
刚刚入门，如有错误，谢谢指出。