modify guide training

Author: nowgood

graffiti/float32touint8.py

@@ -0,0 +1,11 @@
+import torch
+from net import net_quantize_guide
+from torchvision import models
+
+# coding=utf-8
+model = net_quantize_guide.resnet18()
+print(model.state_dict().keys())
+model = models.resnet18(pretrained=True)
+state_dict = model.state_dict()
+state_dict = {k: v.to(torch.uint8) for k, v in state_dict.items()}
+torch.save(state_dict, "nowgood.pth")

graffiti/merge_conv_bn.py

@@ -0,0 +1,75 @@
+# coding=utf-8
+import torch
+from torchvision import models
+import numpy as np
+import os
+from net import net_bn_conv_merge, net_bn_conv_merge_quantize
+from utils.data_loader import load_val_data
+from utils.train_val import validate
+
+epsilon = 1e-5
+data = "/media/wangbin/8057840b-9a1e-48c9-aa84-d353a6ba1090/ImageNet_ILSVRC2012/ILSVRC2012"
+
+model = models.resnet18(pretrained=True)
+# merge_model = net_bn_conv_merge.resnet18()
+merge_model = net_bn_conv_merge_quantize.resnet18()
+state_dict = model.state_dict()
+merge_state_dict = merge_model.state_dict()
+
+# for name in state_dict:
+#     print(name)
+
+merge_state_dict.update({"fc.weight": state_dict["fc.weight"],
+                        "fc.bias": state_dict["fc.bias"]})
+del state_dict["fc.weight"]
+del state_dict["fc.bias"]
+params = np.array(list(state_dict.keys()))
+
+params = params.reshape((-1, 5))
+for index in range(params.shape[0]):
+    weight = state_dict[params[index][0]]
+    gamma = state_dict[params[index][1]]
+    beta = state_dict[params[index][2]]
+    running_mean = state_dict[params[index][3]]
+    running_var = state_dict[params[index][4]]
+    delta = gamma/(torch.sqrt(running_var+epsilon))
+    weight = weight * delta.view(-1, 1, 1, 1)
+    bias = (0-running_mean) * delta + beta
+    merge_state_dict.update({params[index][0]: weight,
+                             params[index][0][:-6] + "bias": bias})
+merge_model.load_state_dict(merge_state_dict)
+merge_model_name = "resnet18_merge_bn_conv.pth.tar"
+torch.save(merge_model.state_dict(), merge_model_name)
+
+"""
+    conv1.weight
+    bn1.weight
+    bn1.bias
+    bn1.running_mean
+    bn1.running_var
+    layer1.0.conv1.weight
+    layer1.0.bn1.weight
+    layer1.0.bn1.bias
+    layer1.0.bn1.running_mean
+    layer1.0.bn1.running_var
+"""
+
+# print("bn1.weight: \n", len(state_dict["bn1.weight"]), state_dict["bn1.weight"])
+# print("bn1.bias: \n", len(state_dict["bn1.bias"]), state_dict["bn1.bias"])
+# print("bn1.running_mean: \n", state_dict["bn1.running_mean"])
+# print("bn1.running_val: \n", state_dict["bn1.running_var"])
+
+val_loader = load_val_data(data)
+evaluate = merge_model_name
+if os.path.isfile(evaluate):
+    print("Loading evaluate model '{}'".format(evaluate))
+    checkpoint = torch.load(evaluate)
+    merge_model.load_state_dict(checkpoint)
+    print("Loaded evaluate model '{}'".format(evaluate))
+else:
+    print("No evaluate mode found at '{}'".format(evaluate))
+
+merge_model.cuda()
+merge_model.eval()
+criterion = torch.nn.CrossEntropyLoss().cuda()
+validate(merge_model, val_loader, criterion)

graffiti/nowgood.py

@@ -2,9 +2,10 @@
 from net import net_quantize_guide
 from torchvision import models
 
-model = net_quantize_guide.resnet18()
-print(model.state_dict().keys())
-model = models.resnet18(pretrained=True)
-state_dict = model.state_dict()
-state_dict = {k: v.to(torch.uint8) for k, v in state_dict.items()}
-torch.save(state_dict, "nowgood.pth")
+
+x = torch.ones(5, 3)
+bias = torch.ones(5, 1)
+bias[0][0] = 4
+bias[3][0] = 3
+y = x * bias
+print(y)

net/net_bn_conv_merge.py

@@ -0,0 +1,206 @@
+# coding=utf-8
+import torch.nn as nn
+import math
+import torch.utils.model_zoo as model_zoo
+
+"""
+网络修改步骤;
+    1. 将卷积层的 bias 设置为 True
+    2. 将 bn 层删掉
+"""
+
+__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',
+}
+
+
+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=True)
+
+
+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.relu = nn.ReLU(inplace=True)
+        self.conv2 = conv3x3(planes, planes)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        residual = x
+
+        out = self.conv1(x)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+
+        if self.downsample is not None:
+            residual = self.downsample(x)
+
+        out += residual
+        out = self.relu(out)
+
+        return out
+
+
+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=True)
+        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride,
+                               padding=1, bias=True)
+        self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=True)
+        self.relu = nn.ReLU(inplace=True)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        residual = x
+
+        out = self.conv1(x)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.relu(out)
+
+        out = self.conv3(out)
+
+        if self.downsample is not None:
+            residual = self.downsample(x)
+
+        out += residual
+        out = self.relu(out)
+
+        return out
+
+
+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=True)
+        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=True),
+            )
+
+        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.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
+
+
+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 resnet34(pretrained=False, **kwargs):
+    """Constructs a ResNet-34 model.
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = ResNet(BasicBlock, [3, 4, 6, 3], **kwargs)
+    if pretrained:
+        model.load_state_dict(model_zoo.load_url(model_urls['resnet34']))
+    return model
+
+
+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
+
+
+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
+
+
+def resnet152(pretrained=False, **kwargs):
+    """Constructs a ResNet-152 model.
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = ResNet(Bottleneck, [3, 8, 36, 3], **kwargs)
+    if pretrained:
+        model.load_state_dict(model_zoo.load_url(model_urls['resnet152']))
+    return model