CIFAR-10 數據集實戰——構建ResNet18神經網路

  • 2020 年 1 月 22 日
  • 筆記

如果不了解ResNet的同學可以先看我的這篇部落格ResNet論文閱讀

首先實現一個Residual Block

import torch  from torch import nn  from torch.nn import functional as F    class ResBlk(nn.Module):      def __init__(self, ch_in, ch_out, stride=1):          super(ResBlk, self).__init__()          self.conv1 = nn.Conv2d(ch_in, ch_out, kernel_size=3, stride=stride, padding=1)          self.bn1 = nn.BatchNorm2d(ch_out)            self.conv2 = nn.Conv2d(ch_out, ch_out, kernel_size=3, stride=1, padding=1)          self.bn2 = nn.BatchNorm2d(ch_out)            if ch_out == ch_in:              self.extra = nn.Sequential()          else:              self.extra = nn.Sequential(                    # 1×1的卷積作用是修改輸入x的channel                  # [b, ch_in, h, w] => [b, ch_out, h, w]                  nn.Conv2d(ch_in, ch_out, kernel_size=1, stride=stride),                  nn.BatchNorm2d(ch_out),              )        def forward(self, x):          out = F.relu(self.bn1(self.conv1(x)))          out = self.bn2(self.conv2(out))            # short cut          out = self.extra(x) + out          out = F.relu(out)            return out

Block中進行了正則化處理，以使train過程更快更穩定。同時要考慮，如果兩元素的ch_in和ch_out不匹配，進行加法時會報錯，因此需要判斷一下，如果不想等，就用1×1的卷積調整一下

測試一下

blk = ResBlk(64, 128, stride=2)  tmp = torch.randn(2, 64, 32, 32)  out = blk(tmp)  print(out.shape)

輸出的shape大小是torch.Size([2, 128, 16, 16])

這裡解釋一下，為什麼有的層要專門設置stride。先不考慮別的層，對於一個Residual block，channel從64增大到128，如果所有的stride都是1，padding也是1，那麼圖片的w和h也不會變，但是channel增大了，此時就會導致整個網路的參數增多。而這才僅僅一個Block，更不用說後面的FC以及更多Block了，所以stride不能全部設置為1，不要讓網路的參數一直增大

然後我們搭建完整的ResNet-18

class ResNet18(nn.Module):      def __init__(self):          super(ResNet18, self).__init__()            self.conv1 = nn.Sequential(              nn.Conv2d(3, 64, kernel_size=3, stride=3, padding=0),              nn.BatchNorm2d(64),          )          # followed 4 blocks            # [b, 64, h, w] => [b, 128, h, w]          self.blk1 = ResBlk(64, 128, stride=2)          # [b, 128, h, w] => [b, 256, h, w]          self.blk2 = ResBlk(128, 256, stride=2)          # [b, 256, h, w] => [h, 512, h, w]          self.blk3 = ResBlk(256, 512, stride=2)          # [b, 512, h, w] => [h, 1024, h, w]          self.blk4 = ResBlk(512, 512, stride=2)            self.outlayer = nn.Linear(512*1*1, 10)        def forward(self, x):          x = F.relu(self.conv1(x))            # 經過四個blk以後 [b, 64, h, w] => [b, 1024, h, w]          x = self.blk1(x)          x = self.blk2(x)          x = self.blk3(x)          x = self.blk4(x)            x = self.outlayer(x)            return x

測試一下

x = torch.randn(2, 3, 32, 32)  model = ResNet18()  out = model(x)  print("ResNet:", out.shape)

結果報錯了，錯誤資訊如下

size mismatch, m1: [2048 x 2], m2: [512 x 10] at /pytorch/aten/src/TH/generic/THTensorMath.cpp:961

問題在於我們最後定義線性層的輸入維度，和上一層Block的輸出維度不匹配，在ResNet18的最後一個Block運行結束後列印一下當前x的shape，結果是torch.Size([2, 512, 2, 2])

解決辦法有很多，可以修改線性層的輸入進行匹配，也可以在最後一層Block後面再進行一些操作，使其與512匹配

先給出修改後的程式碼，在做解釋

class ResNet18(nn.Module):      def __init__(self):          super(ResNet18, self).__init__()            self.conv1 = nn.Sequential(              nn.Conv2d(3, 64, kernel_size=3, stride=3, padding=0),              nn.BatchNorm2d(64),          )          # followed 4 blocks            # [b, 64, h, w] => [b, 128, h, w]          self.blk1 = ResBlk(64, 128, stride=2)          # [b, 128, h, w] => [b, 256, h, w]          self.blk2 = ResBlk(128, 256, stride=2)          # [b, 256, h, w] => [h, 512, h, w]          self.blk3 = ResBlk(256, 512, stride=2)          # [b, 512, h, w] => [h, 1024, h, w]          self.blk4 = ResBlk(512, 512, stride=2)            self.outlayer = nn.Linear(512*1*1, 10)        def forward(self, x):          x = F.relu(self.conv1(x))            # 經過四個blk以後 [b, 64, h, w] => [b, 1024, h, w]          x = self.blk1(x)          x = self.blk2(x)          x = self.blk3(x)          x = self.blk4(x)            # print("after conv:", x.shape) # [b, 512, 2, 2]            # [b, 512, h, w] => [b, 512, 1, 1]          x = F.adaptive_avg_pool2d(x, [1, 1])            x = x.view(x.size(0), -1) # [b, 512, 1, 1] => [b, 512*1*1]          x = self.outlayer(x)            return x

這裡我採用的是第二種方法，在最後一個Block結束以後，接了一個自適應的pooling層，這個pooling的作用是將不論輸入的寬高是多少，全部輸出稱寬高都是1的tensor，其他維度保持不變。然後再做一個reshape操作，將[batchsize, 512, 1, 1]reshape成[batchsize, 512*1*1]大小的tensor，這樣就和接下來的線性層對上了，線性層的輸入大小是512，輸出是10。因此整個網路最終輸出的shape就是[batchsize, 10]

最後我們把之前訓練LeNet5的程式碼拷貝過來，將裡面的model=LeNet5()改為model=ResNet18()就行了。完整程式碼如下

import torch  from torch import nn, optim  import torch.nn.functional as F  from torch.utils.data import DataLoader  from torchvision import datasets, transforms      batch_size=32  cifar_train = datasets.CIFAR10(root='cifar', train=True, transform=transforms.Compose([      transforms.Resize([32, 32]),      transforms.ToTensor(),  ]), download=True)    cifar_train = DataLoader(cifar_train, batch_size=batch_size, shuffle=True)    cifar_test = datasets.CIFAR10(root='cifar', train=False, transform=transforms.Compose([      transforms.Resize([32, 32]),      transforms.ToTensor(),  ]), download=True)    cifar_test = DataLoader(cifar_test, batch_size=batch_size, shuffle=True)    class ResBlk(nn.Module):      def __init__(self, ch_in, ch_out, stride=1):          super(ResBlk, self).__init__()          self.conv1 = nn.Conv2d(ch_in, ch_out, kernel_size=3, stride=stride, padding=1)          self.bn1 = nn.BatchNorm2d(ch_out)            self.conv2 = nn.Conv2d(ch_out, ch_out, kernel_size=3, stride=1, padding=1)          self.bn2 = nn.BatchNorm2d(ch_out)            if ch_out == ch_in:              self.extra = nn.Sequential()          else:              self.extra = nn.Sequential(                    # 1×1的卷積作用是修改輸入x的channel                  # [b, ch_in, h, w] => [b, ch_out, h, w]                  nn.Conv2d(ch_in, ch_out, kernel_size=1, stride=stride),                  nn.BatchNorm2d(ch_out),              )        def forward(self, x):          out = F.relu(self.bn1(self.conv1(x)))          out = self.bn2(self.conv2(out))            # short cut          out = self.extra(x) + out          out = F.relu(out)            return out    class ResNet18(nn.Module):      def __init__(self):          super(ResNet18, self).__init__()            self.conv1 = nn.Sequential(              nn.Conv2d(3, 64, kernel_size=3, stride=3, padding=0),              nn.BatchNorm2d(64),          )          # followed 4 blocks            # [b, 64, h, w] => [b, 128, h, w]          self.blk1 = ResBlk(64, 128, stride=2)          # [b, 128, h, w] => [b, 256, h, w]          self.blk2 = ResBlk(128, 256, stride=2)          # [b, 256, h, w] => [h, 512, h, w]          self.blk3 = ResBlk(256, 512, stride=2)          # [b, 512, h, w] => [h, 1024, h, w]          self.blk4 = ResBlk(512, 512, stride=2)            self.outlayer = nn.Linear(512*1*1, 10)        def forward(self, x):          x = F.relu(self.conv1(x))            # 經過四個blk以後 [b, 64, h, w] => [b, 1024, h, w]          x = self.blk1(x)          x = self.blk2(x)          x = self.blk3(x)          x = self.blk4(x)            # print("after conv:", x.shape) # [b, 512, 2, 2]            # [b, 512, h, w] => [b, 512, 1, 1]          x = F.adaptive_avg_pool2d(x, [1, 1])            x = x.view(x.size(0), -1) # [b, 512, 1, 1] => [b, 512*1*1]          x = self.outlayer(x)            return x    def main():        ##########  train  ##########      #device = torch.device('cuda')      #model = ResNet18().to(device)      criteon = nn.CrossEntropyLoss()      model = ResNet18()      optimizer = optim.Adam(model.parameters(), 1e-3)      for epoch in range(1000):          model.train()          for batchidx, (x, label) in enumerate(cifar_train):              #x, label = x.to(device), label.to(device)              logits = model(x)              # logits: [b, 10]              # label:  [b]              loss = criteon(logits, label)                # backward              optimizer.zero_grad()              loss.backward()              optimizer.step()            print('train:', epoch, loss.item())            ########## test  ##########          model.eval()          with torch.no_grad():              total_correct = 0              total_num = 0              for x, label in cifar_test:                  # x, label = x.to(device), label.to(device)                    # [b]                  logits = model(x)                  # [b]                  pred = logits.argmax(dim=1)                  # [b] vs [b]                  total_correct += torch.eq(pred, label).float().sum().item()                  total_num += x.size(0)              acc = total_correct / total_num              print('test:', epoch, acc)    if __name__ == '__main__':      main()

ResNet和LeNet相比，準確率提升的很快，但是由於層數增加，不可避免的會導致運行時間增加，如果沒有GPU，運行一個epoch大概要15分鐘。讀者同樣可以在此基礎上修改網路結構，運用一些tricks，比方說一開始就對圖片做一個Normalize等

Tags:

VirMach 便宜 VPS