Added ConvTranspose2D support for the new converter.

Author: gmalivenko

README.md

@@ -68,7 +68,7 @@ Layers:
 
 * Linear
 * Conv2d
-* ConvTranspose2d (only with 0.2)
+* ConvTranspose2d
 * MaxPool2d
 * AvgPool2d
 

pytorch2keras/layers.py

@@ -96,6 +96,65 @@ def convert_conv(params, w_name, scope_name, inputs, layers, weights):
         layers[scope_name] = conv(layers[input_name])
 
 
+def convert_convtranspose(params, w_name, scope_name, inputs, layers, weights):
+    """
+    Convert transposed convolution layer.
+
+    Args:
+        params: dictionary with layer parameters
+        w_name: name prefix in state_dict
+        scope_name: pytorch scope name
+        inputs: pytorch node inputs
+        layers: dictionary with keras tensors
+        weights: pytorch state_dict
+    """
+    print('Converting transposed convolution ...')
+
+    tf_name = w_name + str(random.random())
+    bias_name = '{0}.bias'.format(w_name)
+    weights_name = '{0}.weight'.format(w_name)
+
+    if len(weights[weights_name].numpy().shape) == 4:
+        W = weights[weights_name].numpy().transpose(2, 3, 1, 0)
+        height, width, n_filters, channels = W.shape
+
+        if bias_name in weights:
+            biases = weights[bias_name].numpy()
+            has_bias = True
+        else:
+            biases = None
+            has_bias = False
+
+        padding_name = tf_name + '_pad'
+        padding_layer = keras.layers.ZeroPadding2D(
+            padding=(params['pads'][0], params['pads'][1]),
+            name=padding_name
+        )
+        layers[padding_name] = padding_layer(layers[inputs[0]])
+        input_name = padding_name
+
+        weights = None
+        if has_bias:
+            weights = [W, biases]
+        else:
+            weights = [W]
+
+        conv = keras.layers.Conv2DTranspose(
+            filters=n_filters,
+            kernel_size=(height, width),
+            strides=(params['strides'][0], params['strides'][1]),
+            padding='valid',
+            weights=weights,
+            use_bias=has_bias,
+            activation=None,
+            dilation_rate=params['dilations'][0],
+            name=tf_name
+        )
+        layers[scope_name] = conv(layers[input_name])
+    else:
+        raise AssertionError('Layer is not supported for now')
+
+
 def convert_flatten(params, w_name, scope_name, inputs, layers, weights):
     """
     Convert reshape(view).
@@ -471,6 +530,7 @@ def convert_tanh(params, w_name, scope_name, inputs, layers, weights):
 
 AVAILABLE_CONVERTERS = {
     'Conv': convert_conv,
+    'ConvTranspose': convert_convtranspose,
     'Flatten': convert_flatten,
     'Gemm': convert_gemm,
     'MaxPool': convert_maxpool,

tests/convtranspose2d.py

@@ -0,0 +1,49 @@
+import keras  # work around segfault
+import sys
+import numpy as np
+
+import torch
+import torch.nn as nn
+from torch.autograd import Variable
+
+sys.path.append('../pytorch2keras')
+from converter import pytorch_to_keras
+
+
+class TestConvTranspose2d(nn.Module):
+    """Module for ConvTranspose2d conversion testing
+    """
+
+    def __init__(self, inp=10, out=16, kernel_size=3, bias=True):
+        super(TestConvTranspose2d, self).__init__()
+        self.conv2d = nn.ConvTranspose2d(inp, out, kernel_size=kernel_size, bias=bias)
+
+    def forward(self, x):
+        x = self.conv2d(x)
+        return x
+
+
+if __name__ == '__main__':
+    max_error = 0
+    for i in range(100):
+        kernel_size = np.random.randint(1, 7)
+        inp = np.random.randint(kernel_size + 1, 100)
+        out = np.random.randint(1, 100)
+
+        model = TestConvTranspose2d(inp, out, kernel_size, inp % 2)
+
+        input_np = np.random.uniform(0, 1, (1, inp, inp, inp))
+        input_var = Variable(torch.FloatTensor(input_np))
+        output = model(input_var)
+
+        k_model = pytorch_to_keras(model, input_var, (inp, inp, inp,), 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))