Added SENet support.

Author: gmalivenko

README.md

@@ -79,6 +79,7 @@ Layers:
 * ConvTranspose2d
 * MaxPool2d
 * AvgPool2d
+* Global average pooling (as special case of AdaptiveAvgPool2d)
 * Embedding
 * UpsamplingNearest2d
 
@@ -118,11 +119,13 @@ Misc:
 ## Models converted with pytorch2keras
 
 * ResNet18
+* ResNet34
 * ResNet50
 * SqueezeNet (with ceil_mode=False)
 * DenseNet
 * AlexNet
 * Inception (v4 only)
+* SeNet
 
 ## Usage
 Look at the `tests` directory.

setup.py

@@ -16,9 +16,15 @@
 reqs = [str(ir.req) for ir in install_reqs]
 
 
+with open('README.md') as f:
+  long_description = f.read()
+
+
 setup(name='pytorch2keras',
-      version='0.1.1',
+      version='0.1.3',
       description='The deep learning models convertor',
+      long_description=long_description,
+      long_description_content_type='text/markdown',
       url='https://github.com/nerox8664/pytorch2keras',
       author='Grigory Malivenko',
       author_email='[email protected]',

tests/senet.py

@@ -0,0 +1,280 @@
+import numpy as np
+import torch
+from torch import nn
+from torch.autograd import Variable
+from torchvision.models import ResNet
+from pytorch2keras.converter import pytorch_to_keras
+
+
+class SELayer(nn.Module):
+    def __init__(self, channel, reduction=16):
+        super(SELayer, self).__init__()
+        self.avg_pool = nn.AdaptiveAvgPool2d(1)
+        self.fc = nn.Sequential(
+                nn.Linear(channel, channel // reduction),
+                nn.ReLU(inplace=True),
+                nn.Linear(channel // reduction, channel),
+                nn.Sigmoid()
+        )
+
+    def forward(self, x):
+        b, c, _, _ = x.size()
+        y = self.avg_pool(x).view(b, c)
+        y = self.fc(y).view(b, c, 1, 1)
+        return x * y
+
+
+def conv3x3(in_planes, out_planes, stride=1):
+    return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride, padding=1, bias=False)
+
+
+class SEBasicBlock(nn.Module):
+    expansion = 1
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None, reduction=16):
+        super(SEBasicBlock, self).__init__()
+        self.conv1 = conv3x3(inplanes, planes, stride)
+        self.bn1 = nn.BatchNorm2d(planes)
+        self.relu = nn.ReLU(inplace=True)
+        self.conv2 = conv3x3(planes, planes, 1)
+        self.bn2 = nn.BatchNorm2d(planes)
+        self.se = SELayer(planes, reduction)
+        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.se(out)
+
+        if self.downsample is not None:
+            residual = self.downsample(x)
+
+        out += residual
+        out = self.relu(out)
+
+        return out
+
+
+class SEBottleneck(nn.Module):
+    expansion = 4
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None, reduction=16):
+        super(SEBottleneck, 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.se = SELayer(planes * 4, reduction)
+        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)
+        out = self.se(out)
+
+        if self.downsample is not None:
+            residual = self.downsample(x)
+
+        out += residual
+        out = self.relu(out)
+
+        return out
+
+
+def se_resnet18(num_classes):
+    """Constructs a ResNet-18 model.
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = ResNet(SEBasicBlock, [2, 2, 2, 2], num_classes=num_classes)
+    model.avgpool = nn.AdaptiveAvgPool2d(1)
+    return model
+
+
+def se_resnet34(num_classes):
+    """Constructs a ResNet-34 model.
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = ResNet(SEBasicBlock, [3, 4, 6, 3], num_classes=num_classes)
+    model.avgpool = nn.AdaptiveAvgPool2d(1)
+    return model
+
+
+def se_resnet50(num_classes):
+    """Constructs a ResNet-50 model.
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = ResNet(SEBottleneck, [3, 4, 6, 3], num_classes=num_classes)
+    model.avgpool = nn.AdaptiveAvgPool2d(1)
+    return model
+
+
+def se_resnet101(num_classes):
+    """Constructs a ResNet-101 model.
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = ResNet(SEBottleneck, [3, 4, 23, 3], num_classes=num_classes)
+    model.avgpool = nn.AdaptiveAvgPool2d(1)
+    return model
+
+
+def se_resnet152(num_classes):
+    """Constructs a ResNet-152 model.
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = ResNet(SEBottleneck, [3, 8, 36, 3], num_classes=num_classes)
+    model.avgpool = nn.AdaptiveAvgPool2d(1)
+    return model
+
+
+class CifarSEBasicBlock(nn.Module):
+    def __init__(self, inplanes, planes, stride=1, reduction=16):
+        super(CifarSEBasicBlock, 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.se = SELayer(planes, reduction)
+        if inplanes != planes:
+            self.downsample = nn.Sequential(nn.Conv2d(inplanes, planes, kernel_size=1, stride=stride, bias=False),
+                                            nn.BatchNorm2d(planes))
+        else:
+            self.downsample = lambda x: x
+        self.stride = stride
+
+    def forward(self, x):
+        residual = self.downsample(x)
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+        out = self.se(out)
+
+        out += residual
+        out = self.relu(out)
+
+        return out
+
+
+class CifarSEResNet(nn.Module):
+    def __init__(self, block, n_size, num_classes=10, reduction=16):
+        super(CifarSEResNet, self).__init__()
+        self.inplane = 16
+        self.conv1 = nn.Conv2d(3, self.inplane, kernel_size=3, stride=1, padding=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(self.inplane)
+        self.relu = nn.ReLU(inplace=True)
+        self.layer1 = self._make_layer(block, 16, blocks=n_size, stride=1, reduction=reduction)
+        self.layer2 = self._make_layer(block, 32, blocks=n_size, stride=2, reduction=reduction)
+        self.layer3 = self._make_layer(block, 64, blocks=n_size, stride=2, reduction=reduction)
+        self.avgpool = nn.AdaptiveAvgPool2d(1)
+        self.fc = nn.Linear(64, num_classes)
+        self.initialize()
+
+    def initialize(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal(m.weight)
+            elif isinstance(m, nn.BatchNorm2d):
+                nn.init.constant(m.weight, 1)
+                nn.init.constant(m.bias, 0)
+
+    def _make_layer(self, block, planes, blocks, stride, reduction):
+        strides = [stride] + [1] * (blocks - 1)
+        layers = []
+        for stride in strides:
+            layers.append(block(self.inplane, planes, stride, reduction))
+            self.inplane = planes
+
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        x = self.conv1(x)
+        x = self.bn1(x)
+        x = self.relu(x)
+
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.layer3(x)
+
+        x = self.avgpool(x)
+        x = x.view(x.size(0), -1)
+        x = self.fc(x)
+
+        return x
+
+
+class CifarSEPreActResNet(CifarSEResNet):
+    def __init__(self, block, n_size, num_classes=10, reduction=16):
+        super(CifarSEPreActResNet, self).__init__(block, n_size, num_classes, reduction)
+        self.bn1 = nn.BatchNorm2d(self.inplane)
+        self.initialize()
+
+    def forward(self, x):
+        x = self.conv1(x)
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.layer3(x)
+
+        x = self.bn1(x)
+        x = self.relu(x)
+
+        x = self.avgpool(x)
+        x = x.view(x.size(0), -1)
+        x = self.fc(x)
+
+
+if __name__ == '__main__':
+    max_error = 0
+    for i in range(10):
+        model = CifarSEResNet(CifarSEBasicBlock, 3)
+        for m in model.modules():
+            m.training = False
+
+        input_np = np.random.uniform(0, 1, (1, 3, 224, 224))
+        input_var = Variable(torch.FloatTensor(input_np))
+        output = model(input_var)
+
+        k_model = pytorch_to_keras(model, input_var, (3, 224, 224,), verbose=True)
+
+        pytorch_output = output.data.numpy()
+        keras_output = k_model.predict(input_np)
+
+        error = np.max(pytorch_output - keras_output)
+        print(error)
+        if max_error < error:
+            max_error = error
+
+    print('Max error: {0}'.format(max_error))