上一節簡單的構造了一個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()

訓練與測試和前面章節一樣，這裡不再贅述。