Spaces:
Running
Running
| #!/usr/bin/env python | |
| # -*- encoding: utf-8 -*- | |
| """ | |
| @Author : Peike Li | |
| @Contact : [email protected] | |
| @File : mobilenetv2.py | |
| @Time : 8/4/19 3:35 PM | |
| @Desc : | |
| @License : This source code is licensed under the license found in the | |
| LICENSE file in the root directory of this source tree. | |
| """ | |
| import torch.nn as nn | |
| import math | |
| import functools | |
| from modules import InPlaceABN, InPlaceABNSync | |
| BatchNorm2d = functools.partial(InPlaceABNSync, activation='none') | |
| __all__ = ['mobilenetv2'] | |
| def conv_bn(inp, oup, stride): | |
| return nn.Sequential( | |
| nn.Conv2d(inp, oup, 3, stride, 1, bias=False), | |
| BatchNorm2d(oup), | |
| nn.ReLU6(inplace=True) | |
| ) | |
| def conv_1x1_bn(inp, oup): | |
| return nn.Sequential( | |
| nn.Conv2d(inp, oup, 1, 1, 0, bias=False), | |
| BatchNorm2d(oup), | |
| nn.ReLU6(inplace=True) | |
| ) | |
| class InvertedResidual(nn.Module): | |
| def __init__(self, inp, oup, stride, expand_ratio): | |
| super(InvertedResidual, self).__init__() | |
| self.stride = stride | |
| assert stride in [1, 2] | |
| hidden_dim = round(inp * expand_ratio) | |
| self.use_res_connect = self.stride == 1 and inp == oup | |
| if expand_ratio == 1: | |
| self.conv = nn.Sequential( | |
| # dw | |
| nn.Conv2d(hidden_dim, hidden_dim, 3, stride, 1, groups=hidden_dim, bias=False), | |
| BatchNorm2d(hidden_dim), | |
| nn.ReLU6(inplace=True), | |
| # pw-linear | |
| nn.Conv2d(hidden_dim, oup, 1, 1, 0, bias=False), | |
| BatchNorm2d(oup), | |
| ) | |
| else: | |
| self.conv = nn.Sequential( | |
| # pw | |
| nn.Conv2d(inp, hidden_dim, 1, 1, 0, bias=False), | |
| BatchNorm2d(hidden_dim), | |
| nn.ReLU6(inplace=True), | |
| # dw | |
| nn.Conv2d(hidden_dim, hidden_dim, 3, stride, 1, groups=hidden_dim, bias=False), | |
| BatchNorm2d(hidden_dim), | |
| nn.ReLU6(inplace=True), | |
| # pw-linear | |
| nn.Conv2d(hidden_dim, oup, 1, 1, 0, bias=False), | |
| BatchNorm2d(oup), | |
| ) | |
| def forward(self, x): | |
| if self.use_res_connect: | |
| return x + self.conv(x) | |
| else: | |
| return self.conv(x) | |
| class MobileNetV2(nn.Module): | |
| def __init__(self, n_class=1000, input_size=224, width_mult=1.): | |
| super(MobileNetV2, self).__init__() | |
| block = InvertedResidual | |
| input_channel = 32 | |
| last_channel = 1280 | |
| interverted_residual_setting = [ | |
| # t, c, n, s | |
| [1, 16, 1, 1], | |
| [6, 24, 2, 2], # layer 2 | |
| [6, 32, 3, 2], # layer 3 | |
| [6, 64, 4, 2], | |
| [6, 96, 3, 1], # layer 4 | |
| [6, 160, 3, 2], | |
| [6, 320, 1, 1], # layer 5 | |
| ] | |
| # building first layer | |
| assert input_size % 32 == 0 | |
| input_channel = int(input_channel * width_mult) | |
| self.last_channel = int(last_channel * width_mult) if width_mult > 1.0 else last_channel | |
| self.features = [conv_bn(3, input_channel, 2)] | |
| # building inverted residual blocks | |
| for t, c, n, s in interverted_residual_setting: | |
| output_channel = int(c * width_mult) | |
| for i in range(n): | |
| if i == 0: | |
| self.features.append(block(input_channel, output_channel, s, expand_ratio=t)) | |
| else: | |
| self.features.append(block(input_channel, output_channel, 1, expand_ratio=t)) | |
| input_channel = output_channel | |
| # building last several layers | |
| self.features.append(conv_1x1_bn(input_channel, self.last_channel)) | |
| # make it nn.Sequential | |
| self.features = nn.Sequential(*self.features) | |
| # building classifier | |
| self.classifier = nn.Sequential( | |
| nn.Dropout(0.2), | |
| nn.Linear(self.last_channel, n_class), | |
| ) | |
| self._initialize_weights() | |
| def forward(self, x): | |
| x = self.features(x) | |
| x = x.mean(3).mean(2) | |
| x = self.classifier(x) | |
| return x | |
| def _initialize_weights(self): | |
| 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)) | |
| if m.bias is not None: | |
| m.bias.data.zero_() | |
| elif isinstance(m, BatchNorm2d): | |
| m.weight.data.fill_(1) | |
| m.bias.data.zero_() | |
| elif isinstance(m, nn.Linear): | |
| n = m.weight.size(1) | |
| m.weight.data.normal_(0, 0.01) | |
| m.bias.data.zero_() | |
| def mobilenetv2(pretrained=False, **kwargs): | |
| """Constructs a MobileNet_V2 model. | |
| Args: | |
| pretrained (bool): If True, returns a model pre-trained on ImageNet | |
| """ | |
| model = MobileNetV2(n_class=1000, **kwargs) | |
| if pretrained: | |
| model.load_state_dict(load_url(model_urls['mobilenetv2']), strict=False) | |
| return model | |