PyTorch中torchvision.models的示例分析

這篇文章主要為大家展示了“PyTorch中torchvision.models的示例分析”，內容簡而易懂，條理清晰，希望能夠幫助大家解決疑惑，下面讓小編帶領大家一起研究并學習一下“PyTorch中torchvision.models的示例分析”這篇文章吧。

PyTorch框架中有一個非常重要且好用的包：torchvision，該包主要由3個子包組成，分別是：torchvision.datasets、torchvision.models、torchvision.transforms。

這3個子包的具體介紹可以參考官網：

http://pytorch.org/docs/master/torchvision/index.html。

具體代碼可以參考github：

https://github.com/pytorch/vision/tree/master/torchvision。

介紹torchvision.models。torchvision.models這個包中包含alexnet、densenet、inception、resnet、squeezenet、vgg等常用的網絡結構，并且提供了預訓練模型，可以通過簡單調用來讀取網絡結構和預訓練模型。

使用例子：

import torchvision
model = torchvision.models.resnet50(pretrained=True)

這樣就導入了resnet50的預訓練模型了。如果只需要網絡結構，不需要用預訓練模型的參數來初始化，那么就是：

model = torchvision.models.resnet50(pretrained=False)

如果要導入densenet模型也是同樣的道理，比如導入densenet169，且不需要是預訓練的模型：

model = torchvision.models.densenet169(pretrained=False)

由于pretrained參數默認是False，所以等價于：

model = torchvision.models.densenet169()

不過為了代碼清晰，最好還是加上參數賦值。

接下來以導入resnet50為例介紹具體導入模型時候的源碼。運行model = torchvision.models.resnet50(pretrained=True)的時候，是通過models包下的resnet.py腳本進行的，源碼如下：

首先是導入必要的庫，其中model_zoo是和導入預訓練模型相關的包，另外all變量定義了可以從外部import的函數名或類名。這也是前面為什么可以用torchvision.models.resnet50()來調用的原因。model_urls這個字典是預訓練模型的下載地址。

import torch.nn as nn
import math
import torch.utils.model_zoo as model_zoo

__all__ = ['ResNet', 'resnet18', 'resnet34', 'resnet50', 'resnet101',
  'resnet152']

model_urls = {
 'resnet18': 'https://download.pytorch.org/models/resnet18-5c106cde.pth',
 'resnet34': 'https://download.pytorch.org/models/resnet34-333f7ec4.pth',
 'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth',
 'resnet101': 'https://download.pytorch.org/models/resnet101-5d3b4d8f.pth',
 'resnet152': 'https://download.pytorch.org/models/resnet152-b121ed2d.pth',
}

接下來就是resnet50這個函數了，參數pretrained默認是False。首先model = ResNet(Bottleneck, [3, 4, 6, 3], **kwargs)是構建網絡結構，Bottleneck是另外一個構建bottleneck的類，在ResNet網絡結構的構建中有很多重復的子結構，這些子結構就是通過Bottleneck類來構建的，后面會介紹。然后如果參數pretrained是True，那么就會通過model_zoo.py中的load_url函數根據model_urls字典下載或導入相應的預訓練模型。最后通過調用model的load_state_dict方法用預訓練的模型參數來初始化你構建的網絡結構，這個方法就是PyTorch中通用的用一個模型的參數初始化另一個模型的層的操作。load_state_dict方法還有一個重要的參數是strict，該參數默認是True，表示預訓練模型的層和你的網絡結構層嚴格對應相等（比如層名和維度）。

def resnet50(pretrained=False, **kwargs):
 """Constructs a ResNet-50 model.

 Args:
 pretrained (bool): If True, returns a model pre-trained on ImageNet
 """
 model = ResNet(Bottleneck, [3, 4, 6, 3], **kwargs)
 if pretrained:
 model.load_state_dict(model_zoo.load_url(model_urls['resnet50']))
 return model

其他resnet18、resnet101等函數和resnet50基本類似，差別主要是在：

1、構建網絡結構的時候block的參數不一樣，比如resnet18中是[2, 2, 2, 2]，resnet101中是[3, 4, 23, 3]。

2、調用的block類不一樣，比如在resnet50、resnet101、resnet152中調用的是Bottleneck類，而在resnet18和resnet34中調用的是BasicBlock類，這兩個類的區別主要是在residual結果中卷積層的數量不同，這個是和網絡結構相關的，后面會詳細介紹。

3、如果下載預訓練模型的話，model_urls字典的鍵不一樣，對應不同的預訓練模型。因此接下來分別看看如何構建網絡結構和如何導入預訓練模型。

def resnet18(pretrained=False, **kwargs):
 """Constructs a ResNet-18 model.

 Args:
 pretrained (bool): If True, returns a model pre-trained on ImageNet
 """
 model = ResNet(BasicBlock, [2, 2, 2, 2], **kwargs)
 if pretrained:
 model.load_state_dict(model_zoo.load_url(model_urls['resnet18']))
 return model

def resnet101(pretrained=False, **kwargs):
 """Constructs a ResNet-101 model.

 Args:
 pretrained (bool): If True, returns a model pre-trained on ImageNet
 """
 model = ResNet(Bottleneck, [3, 4, 23, 3], **kwargs)
 if pretrained:
 model.load_state_dict(model_zoo.load_url(model_urls['resnet101']))
 return model

構建ResNet網絡是通過ResNet這個類進行的。首先還是繼承PyTorch中網絡的基類：torch.nn.Module，其次主要的是重寫初始化__init__和forward方法。在初始化__init__中主要是定義一些層的參數。forward方法中主要是定義數據在層之間的流動順序，也就是層的連接順序。另外還可以在類中定義其他私有方法用來模塊化一些操作，比如這里的_make_layer方法是用來構建ResNet網絡中的4個blocks。_make_layer方法的第一個輸入block是Bottleneck或BasicBlock類，第二個輸入是該blocks的輸出channel，第三個輸入是每個blocks中包含多少個residual子結構，因此layers這個列表就是前面resnet50的[3, 4, 6, 3]。

_make_layer方法中比較重要的兩行代碼是：1、layers.append(block(self.inplanes, planes, stride, downsample))，該部分是將每個blocks的第一個residual結構保存在layers列表中。2、 for i in range(1, blocks): layers.append(block(self.inplanes, planes))，該部分是將每個blocks的剩下residual 結構保存在layers列表中，這樣就完成了一個blocks的構造。這兩行代碼中都是通過Bottleneck這個類來完成每個residual的構建，接下來介紹Bottleneck類。

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

從前面的ResNet類可以看出，在構造ResNet網絡的時候，最重要的是Bottleneck這個類，因為ResNet是由residual結構組成的，而Bottleneck類就是完成residual結構的構建。同樣Bottlenect還是繼承了torch.nn.Module類，且重寫了__init__和forward方法。從forward方法可以看出，bottleneck就是我們熟悉的3個主要的卷積層、BN層和激活層，最后的out += residual就是element-wise add的操作。

class Bottleneck(nn.Module):
 expansion = 4

 def __init__(self, inplanes, planes, stride=1, downsample=None):
 super(Bottleneck, self).__init__()
 self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
 self.bn1 = nn.BatchNorm2d(planes)
 self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride,
    padding=1, bias=False)
 self.bn2 = nn.BatchNorm2d(planes)
 self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False)
 self.bn3 = nn.BatchNorm2d(planes * 4)
 self.relu = nn.ReLU(inplace=True)
 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)
 out = self.relu(out)

 out = self.conv3(out)
 out = self.bn3(out)

 if self.downsample is not None:
  residual = self.downsample(x)

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

 return out

BasicBlock類和Bottleneck類類似，前者主要是用來構建ResNet18和ResNet34網絡，因為這兩個網絡的residual結構只包含兩個卷積層，沒有Bottleneck類中的bottleneck概念。因此在該類中，第一個卷積層采用的是kernel_size=3的卷積，如conv3x3函數所示。

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)

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

介紹完如何構建網絡，接下來就是如何獲取預訓練模型。前面提到這一行代碼：if pretrained: model.load_state_dict(model_zoo.load_url(model_urls['resnet50']))，主要就是通過model_zoo.py中的load_url函數根據model_urls字典導入相應的預訓練模型，models_zoo.py腳本的github地址：

https://github.com/pytorch/pytorch/blob/master/torch/utils/model_zoo.py。

load_url函數源碼如下。

首先model_dir是下載下來的模型的保存地址，如果沒有指定的話就會保存在項目的.torch目錄下，最好指定。cached_file是保存模型的路徑加上模型名稱。接下來的 if not os.path.exists(cached_file)語句用來判斷是否指定目錄下已經存在要下載模型，如果已經存在，就直接調用torch.load接口導入模型，如果不存在，則從網上下載，下載是通過_download_url_to_file(url, cached_file, hash_prefix, progress=progress)進行的，不再細講。重點在于模型導入是通過torch.load()接口來進行的，不管你的模型是從網上下載的還是本地已有的。

def load_url(url, model_dir=None, map_location=None, progress=True):
 r"""Loads the Torch serialized object at the given URL.

 If the object is already present in `model_dir`, it's deserialized and
 returned. The filename part of the URL should follow the naming convention
 ``filename-<sha256>.ext`` where ``<sha256>`` is the first eight or more
 digits of the SHA256 hash of the contents of the file. The hash is used to
 ensure unique names and to verify the contents of the file.

 The default value of `model_dir` is ``$TORCH_HOME/models`` where
 ``$TORCH_HOME`` defaults to ``~/.torch``. The default directory can be
 overriden with the ``$TORCH_MODEL_ZOO`` environment variable.

 Args:
 url (string): URL of the object to download
 model_dir (string, optional): directory in which to save the object
 map_location (optional): a function or a dict specifying how to remap storage locations (see torch.load)
 progress (bool, optional): whether or not to display a progress bar to stderr

 Example:
 >>> state_dict = torch.utils.model_zoo.load_url('https://s3.amazonaws.com/pytorch/models/resnet18-5c106cde.pth')

 """
 if model_dir is None:
 torch_home = os.path.expanduser(os.getenv('TORCH_HOME', '~/.torch'))
 model_dir = os.getenv('TORCH_MODEL_ZOO', os.path.join(torch_home, 'models'))
 if not os.path.exists(model_dir):
 os.makedirs(model_dir)
 parts = urlparse(url)
 filename = os.path.basename(parts.path)
 cached_file = os.path.join(model_dir, filename)
 if not os.path.exists(cached_file):
 sys.stderr.write('Downloading: "{}" to {}\n'.format(url, cached_file))
 hash_prefix = HASH_REGEX.search(filename).group(1)
 _download_url_to_file(url, cached_file, hash_prefix, progress=progress)
 return torch.load(cached_file, map_location=map_location)

以上是“PyTorch中torchvision.models的示例分析”這篇文章的所有內容，感謝各位的閱讀！相信大家都有了一定的了解，希望分享的內容對大家有所幫助，如果還想學習更多知識，歡迎關注億速云行業資訊頻道！