import torch.nn as nn import math from torch.autograd import Variable import torch import torch.onnx as onnx import os def conv_bn(inp, oup, stride): return nn.Sequential( nn.Conv2d(inp, oup, 3, stride, 1, bias=True), nn.BatchNorm2d(oup), nn.ReLU(inplace=True) ) def conv_1x1_bn(inp, oup): return nn.Sequential( nn.Conv2d(inp, oup, 1, 1, 0, bias=False), nn.BatchNorm2d(oup), nn.ReLU(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] self.use_res_connect = self.stride == 1 and inp == oup self.conv = nn.Sequential( # pw nn.Conv2d(inp, inp * expand_ratio, 1, 1, 0, bias=False), nn.BatchNorm2d(inp * expand_ratio), nn.ReLU(inplace=True), # dw nn.Conv2d(inp * expand_ratio, inp * expand_ratio, 3, stride, 1, groups=inp * expand_ratio, bias=True), nn.BatchNorm2d(inp * expand_ratio), nn.ReLU(inplace=True), # pw-linear nn.Conv2d(inp * expand_ratio, oup, 1, 1, 0, bias=False), nn.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__() # setting of inverted residual blocks self.interverted_residual_setting = [ # t, c, n, s [1, 16, 1, 1], [6, 24, 2, 2], [6, 32, 3, 2], [6, 64, 4, 2], [6, 96, 3, 1], [6, 160, 3, 2], [6, 320, 1, 1], ] # building first layer assert input_size % 32 == 0 input_channel = int(32 * width_mult) self.last_channel = int(1280 * width_mult) if width_mult > 1.0 else 1280 self.features = [conv_bn(3, input_channel, 2)] # building inverted residual blocks for t, c, n, s in self.interverted_residual_setting: output_channel = int(c * width_mult) for i in range(n): if i == 0: self.features.append(InvertedResidual(input_channel, output_channel, s, t)) else: self.features.append(InvertedResidual(input_channel, output_channel, 1, t)) input_channel = output_channel # building last several layers self.features.append(conv_1x1_bn(input_channel, self.last_channel)) self.features.append(nn.AvgPool2d(int(input_size/32))) # make it nn.Sequential self.features = nn.Sequential(*self.features) # building classifier self.classifier = nn.Sequential( nn.Dropout(), nn.Linear(self.last_channel, n_class), ) self._initialize_weights() def forward(self, x): x = self.features(x) x = x.view(-1, self.last_channel) 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, nn.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 export(dir): dummy_input = Variable(torch.randn(1, 3, 224, 224)) model = MobileNetV2() model.eval() torch.save(model.state_dict(),os.path.join(dir,"MobileNetV2.pth")) onnx.export(model, dummy_input,os.path.join(dir,"MobileNetV2.onnx"), verbose=True) def get_model_and_input(model_save_dir): model = MobileNetV2() model.cpu() model_path = os.path.join(model_save_dir,'MobileNetV2.pth') model.load_state_dict(torch.load(model_path)) model.cpu() model.eval() batch_size = 1 channels = 3 height = 224 width = 224 images = Variable(torch.ones(batch_size, channels, height, width)) return images,model