Fixed critical bug in average pooling convertion.

Author: gmalivenko

README.md

@@ -60,7 +60,7 @@ from converter import pytorch_to_keras
 k_model = pytorch_to_keras(model, input_var, (10, 32, 32,), verbose=True)  #we should specify shape of the input tensor
 ```
 
-That's all! If all is ok, the Keras model was stored to the `k_model` variable.
+That's all! If all is ok, the Keras model stores to the `k_model` variable.
 
 ## Supported layers
 

pytorch2keras/layers.py

@@ -229,20 +229,17 @@ def convert_avgpool(params, w_name, scope_name, inputs, layers, weights):
     padding_h, padding_w, _, _ = params['pads']
 
     input_name = inputs[0]
+    padding = 'valid'
     if padding_h > 0 and padding_w > 0:
-        padding_name = tf_name + '_pad'
-        padding_layer = keras.layers.ZeroPadding2D(
-            padding=(padding_h, padding_w),
-            name=padding_name
-        )
-        layers[padding_name] = padding_layer(layers[inputs[0]])
-        input_name = padding_name
+        if padding_h == height // 2 and padding_w == width // 2:
+            padding = 'same'
+        else:
+            raise AssertionError('Custom padding isnt supported')
 
-    # Pooling type
     pooling = keras.layers.AveragePooling2D(
         pool_size=(height, width),
         strides=(stride_height, stride_width),
-        padding='valid',
+        padding=padding,
         name=tf_name
     )
 

tests/inceptionA.py

@@ -0,0 +1,81 @@
+import keras  # work around segfault
+import sys
+import numpy as np
+
+import torch
+from torch import nn
+import torch.nn.functional  as F
+import torchvision
+from torch.autograd import Variable
+
+sys.path.append('../pytorch2keras')
+from converter import pytorch_to_keras
+
+
+class BasicConv2d(nn.Module):
+
+    def __init__(self, in_channels, out_channels, **kwargs):
+        super(BasicConv2d, self).__init__()
+        self.conv = nn.Conv2d(in_channels, out_channels, bias=False, **kwargs)
+        self.bn = nn.BatchNorm2d(out_channels, eps=0.001)
+
+    def forward(self, x):
+        x = self.conv(x)
+        x = self.bn(x)
+        return F.relu(x, inplace=True)
+
+
+class InceptionA(nn.Module):
+
+    def __init__(self, in_channels, pool_features):
+        super(InceptionA, self).__init__()
+        self.branch1x1 = BasicConv2d(in_channels, 64, kernel_size=1)
+
+        self.branch5x5_1 = BasicConv2d(in_channels, 48, kernel_size=1)
+        self.branch5x5_2 = BasicConv2d(48, 64, kernel_size=5, padding=2)
+
+        self.branch3x3dbl_1 = BasicConv2d(in_channels, 64, kernel_size=1)
+        self.branch3x3dbl_2 = BasicConv2d(64, 96, kernel_size=3, padding=1)
+        self.branch3x3dbl_3 = BasicConv2d(96, 96, kernel_size=3, padding=1)
+
+        self.branch_pool = BasicConv2d(in_channels, pool_features, kernel_size=1)
+
+    def forward(self, x):
+        branch1x1 = self.branch1x1(x)
+
+        branch5x5 = self.branch5x5_1(x)
+        branch5x5 = self.branch5x5_2(branch5x5)
+
+        branch3x3dbl = self.branch3x3dbl_1(x)
+        branch3x3dbl = self.branch3x3dbl_2(branch3x3dbl)
+        branch3x3dbl = self.branch3x3dbl_3(branch3x3dbl)
+
+        branch_pool = F.avg_pool2d(x, kernel_size=3, stride=1, padding=1)
+
+        branch_pool = self.branch_pool(branch_pool)
+
+        outputs = [branch1x1, branch5x5, branch3x3dbl, branch_pool]
+        return torch.cat(outputs, 1)
+
+
+if __name__ == '__main__':
+    max_error = 0
+    for i in range(10):
+        model = InceptionA(192, pool_features=32)
+        model.eval()
+
+        input_np = np.random.uniform(0, 1, (1, 192, 32, 32))
+        input_var = Variable(torch.FloatTensor(input_np))
+        output = model(input_var)
+
+        k_model = pytorch_to_keras(model, input_var, (192, 32, 32,), 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))