Pytorch学习笔记

我就是叫小M

于 2021-01-31 14:43:12 发布

阅读量408

点赞数

分类专栏：个人文章标签： python 深度学习神经网络 pytorch

本文链接：https://blog.csdn.net/LittlelittleSir/article/details/113446196

版权

个人专栏收录该内容

7 篇文章 0 订阅

订阅专栏

典型的训练过程

典型的训练过程

一个典型的训练过程可以概述为以下几个步骤

定义一个有着可学习的参数（或者权重）的神经网络
输入数据集
用神经网络对输入进行处理
计算代价值 (即对输出值的修正到底有多少)，将梯度传播回神经网络的参数中
更新网络中的权重，通常使用简单的更新规则: weight = weight + learning_rate * gradient

1. 网络结构设置

1.1 定义网络结构

通常会定义一个继承自torch.nn.Module的Net类，在Net类中定义网络结构。

# VDSR Network
# 结构为input - residual - output
# 其中input为输入一通道，输出64通道的卷积层 + relu；output为输入64通道，输出一通道的卷积层；residual是18个卷积加Relu层

class Conv_ReLU_Block(nn.Module):
    def __init__(self):
        super(Conv_ReLU_Block, self).__init__()
        self.conv = nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, stride=1, padding=1, bias=False)
        self.relu = nn.ReLU(inplace=True)

    def forward(self, x):
        return self.relu(self.conv(x))


class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.residual_layer = self.make_layer(Conv_ReLU_Block, 18)
        self.input = nn.Conv2d(in_channels=1, out_channels=64, kernel_size=3, stride=1, padding=1, bias=False)
        self.output = nn.Conv2d(in_channels=64, out_channels=1, kernel_size=3, stride=1, padding=1, bias=False)
        self.relu = nn.ReLU(inplace=True)

        for m in self.modules(): # modules()表示遍历所有层
            if isinstance(m, nn.Conv2d):
                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
                m.weight.data.normal_(0, sqrt(2. / n)) # 权重初始化

    def make_layer(self, block, num_of_layer):
        layers = []
        for _ in range(num_of_layer):
            layers.append(block())
        return nn.Sequential(*layers)

    def forward(self, x):
        residual = x
        out = self.relu(self.input(x))
        out = self.residual_layer(out)
        out = self.output(out)
        out = torch.add(out, residual)
        return out

可以简单的理解为在__init__定义各层信息，在forward方法中把网络中各层之间的结构说清楚（即输入是如何经过这个网络前向传播的）。

再看一个LeNet的定义过程

# LeNet结构 layer1 - layer2 - layer3
# layer1包括一个卷积+池化，layer2包括卷积+池化，layer3中有三个全连接层，nn.Linear表示全连接层

class LeNet(nn.Module):
    def __init__(self):
        super(LeNet, self).__init__()
 
		layer1 = nn.Sequential()
		layer1.add_module('conv1', nn.Conv(1, 6, 3, padding=1))
		layer1.add_moudle('pool1', nn.MaxPool2d(2, 2))
		self.layer1 = layer1
	 
		layer2 = nn.Sequential()
		layer2.add_module('conv2', nn.Conv(6, 16, 5))
		layer2.add_moudle('pool2', nn.MaxPool2d(2, 2))
		self.layer2 = layer2
	 
		layer3 = nn.Sequential()
		layer3.add_module('fc1', nn.Linear(400, 120))
		layer3.add_moudle('fc2', nn.Linear(120, 84))
		layer3.add_moudle('fc3', nn.Linear(84, 10))
		self.layer3 = layer3
	
    def forward(self, x):
		x = self.layer1(x)
		x = self.layer2(x)
		x = x.view(x.size(0), -1) # 相当于resize，其中-1参数表示该值通过前一个参数确定。这样做意思是结果转换为一维
		x = self.layer3(x)
		return x

参考：PyTorch之前向传播函数forward
x = x.view(x.size(0), -1) 的理解

1.2 权重初始化

对网络的初始化也是很关键的，好的初始化能有效避免梯度爆炸/消失等问题.

2. 数据集

2.0 参数处理

为了方便参数设置，通常在程序的开头会使用argparse对输入参数进行处理设置。argparse是python的命令行解析标准模块，是内置于python的，无需安装。

import argparse

# 创建一个argparser
parser = argparse.ArgumentParser(description="PyTorch VDSR")

# 添加默认参数 --表示可选参数  default设置默认参数  required=True表示必需参数
parser.add_argument("--batchSize", type=int, default=128, help="Training batch size") 
parser.add_argument("--nEpochs", type=int, default=50, help="Number of epochs to train for")

# 解析参数
opt = parser.parse_args()
print(opt) # will print "Namespace(batchSize=128, clip=0.4, cuda=True, ......)"

# 使用参数
opt.batchSize

参考：argparse模块用法实例详解

2.1 输入数据集

使用DataLoader完成数据加载

from torch.utils.data import DataLoader

train_set = DatasetFromHdf5("data/train.h5")
training_data_loader = DataLoader(dataset=train_set, num_workers=opt.threads, batch_size=opt.batchSize, shuffle=True)

可以看到，先从Hdf5格式读取到DataSet中，再把Dataset传递给DataLoader。DataLoader中num_worker表示启动多线程读取数据，shuffle置为True表示打乱顺序，batchSize表示单次批处理数量

关于pytorch的数据加载更多的可参考Pytorch数据读取(Dataset, DataLoader, DataLoaderIter)

2.1 典型数据集

针对不同的任务有不同的典型数据集，最近在看的视频插帧的数据集，目前用Vimeo90k、UCF101比较多

2.2 数据集的格式

2.3 通常到哪里寻找数据集？

paperswithcode网站

3. 迭代训练

3.1 训练

# 训练要进行epoch次，下面代码中每次循环除了进行一次训练还保存了模型。
for epoch in range(opt.start_epoch, opt.nEpochs + 1):
    train(training_data_loader, optimizer, model, criterion, epoch)
    save_checkpoint(model, epoch)

def train(training_data_loader, optimizer, model, criterion, epoch):
    # 训练语句
    model.train()

	# 这一段即分批次处理数据，
    for iteration, batch in enumerate(training_data_loader, 1):
        input, target = Variable(batch[0]), Variable(batch[1], requires_grad=False)

        if opt.cuda:
            input = input.cuda()
            target = target.cuda()
		
		# 计算Loss函数并反向传播
        loss = criterion(model(input), target)
        optimizer.zero_grad() # 清除梯度
        loss.backward() # 反向传播
        nn.utils.clip_grad_norm(model.parameters(), opt.clip) # 进行梯度裁剪
        optimizer.step() # 步进优化器

        if iteration % 100 == 0:
            print("===> Epoch[{}]({}/{}): Loss: {:.10f}".format(epoch, iteration, len(training_data_loader),
                                                                loss.data[0]))