【PyTorch】PyTorch进阶教程二

上一节简单的构造了一个CNN网络，这一节，来构建一个复杂的网络resnet-50。

在开始介绍之前先简单属性下输入数据的一下处理方法。

torchvision.transforms

class torchvision.transforms.Compose(transforms)

• 将多个图像变换组合在一起。

举例：

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

class torchvision.transforms.Resize(size, interpolation=2)

• size resize PIL图像，如果size为一个sequence （h, w），则将图像resize成这个尺寸；如果size为一个int值，则将短边resize成这个尺寸，长边安装对应比例进行缩放，比如 (size * height / width, size)。
• interpolation 采用何种插值方法，默认为双线性。

class torchvision.transforms.RandomCrop(size, padding=0)

• size 同上。
• padding 是否将图像加上padding之后再crop，默认不加，否则需要提供4个数的sequence。

class torchvision.transforms.RandomHorizontalFlip

• 以概率0.5随机水平翻转图像

class torchvision.transforms.RandomVerticalFlip

• 以概率0.5随机垂直翻转图像

class torchvision.transforms.Grayscale(num_output_channels=1)

• 将图像转化为灰度图，若num_output_channels=3，则输出图像r=g=b。

class torchvision.transforms.ColorJitter(brightness=0, contrast=0, saturation=0, hue=0)

• 图像增强。
• brightness 调整亮度，调整范围为[max(0, 1 - brightness), 1 + brightness]。
• contrast 调整对比度，调整范围为[max(0, 1 - contrast), 1 + contrast]。
• saturation 调整饱和度，调整范围为[max(0, 1 - saturation), 1 + saturation]。

首先是加载数据，并对数据进行相应的变换。

import torch 
import torch.nn as nn
import torchvision.datasets as dsets
import torchvision.transforms as transforms
from torch.autograd import Variable
import math
import time

lr = 0.001
batch_size = 100
num_epochs = 80
#输入数据变换操作
transform_list = [
                transforms.Resize(40),
                transforms.RandomHorizontalFlip(),
                transforms.RandomCrop(32),
                transforms.ToTensor()
                ]
transform = transforms.Compose(transform_list)

# CIFAR10 Dataset
train_dataset = dsets.CIFAR10(root='./data/',
                            train=True, 
                            transform=transform,
                            download=True)

test_dataset = dsets.CIFAR10(root='./data/',
                           train=False, 
                           transform=transforms.ToTensor())

# Data Loader (Input Pipeline)
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
                                           batch_size=batch_size, 
                                           shuffle=True,
                                           num_workers = 4)

test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
                                          batch_size=batch_size, 
                                          shuffle=False,
                                          num_workers = 4)

定义一个3x3的卷积层。

def conv3x3(in_planes, out_planes, stride=1):
    """3x3 convolution with padding"""
    return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
                     padding=1, bias=False)

定义一个最简单的Block模块。

class BasicBlock(nn.Module):
    expansion = 1

    def __init__(self, inplanes, planes, stride=1, downsample=None):
        super(BasicBlock, self).__init__()
        self.conv1 = conv3x3(inplanes, planes, stride)
        self.bn1 = nn.BatchNorm2d(planes)
        self.relu = nn.ReLU(inplace=True)
        self.conv2 = conv3x3(planes, planes)
        self.bn2 = nn.BatchNorm2d(planes)
        self.downsample = downsample
        self.stride = stride

    def forward(self, x):
        residual = x

        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)

        out = self.conv2(out)
        out = self.bn2(out)

        #根据输入通道与输出通道是否相等来判断一个分支是否需要加卷积操作
        if self.downsample is not None:
            residual = self.downsample(x)

        out += residual
        out = self.relu(out)

        return out

定义resnet网络。

class ResNet(nn.Module):

    def __init__(self, block, layers, num_classes=1000):
        self.inplanes = 64
        super(ResNet, self).__init__()
        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3,
                               bias=False)
        self.bn1 = nn.BatchNorm2d(64)
        self.relu = nn.ReLU(inplace=True)
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        self.layer1 = self._make_layer(block, 64, layers[0])
        self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
        self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
        self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
        self.avgpool = nn.AvgPool2d(7, stride=1)
        self.fc = nn.Linear(512 * block.expansion, num_classes)

        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
                m.weight.data.normal_(0, math.sqrt(2. / n))
            elif isinstance(m, nn.BatchNorm2d):
                m.weight.data.fill_(1)
                m.bias.data.zero_()

    def _make_layer(self, block, planes, blocks, stride=1):
        downsample = None
        #判断一个分支上是否需要加卷积层
        if stride != 1 or self.inplanes != planes * block.expansion:
            downsample = nn.Sequential(
                nn.Conv2d(self.inplanes, planes * block.expansion,
                          kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(planes * block.expansion),
            )

        layers = []
        layers.append(block(self.inplanes, planes, stride, downsample))
        self.inplanes = planes * block.expansion
        for i in range(1, blocks):
            layers.append(block(self.inplanes, planes))

        return nn.Sequential(*layers)

    def forward(self, x):
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)
        x = self.maxpool(x)

        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)

        x = self.avgpool(x)
        x = x.view(x.size(0), -1)
        x = self.fc(x)

        return x


resnet18 = ResNet(BasicBlock, [2, 2, 2, 2])
resnet18.cuda()

训练与测试和前面章节一样，这里不再赘述。