Added Transpose layer support. A Linear layers with bias=False is converting normally for now.

Author: gmalivenko

README.md

@@ -75,6 +75,7 @@ Layers:
 Reshape:
 
 * View (only with 0.2)
+* Transpose (only with 0.4)
 
 Activations:
 

pytorch2keras/layers.py

@@ -528,6 +528,63 @@ def convert_tanh(params, w_name, scope_name, inputs, layers, weights):
     layers[scope_name] = tanh(layers[inputs[0]])
 
 
+def convert_transpose(params, w_name, scope_name, inputs, layers, weights):
+    """
+    Convert tanh 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 transpose ...')
+    if params['perm'][0] != 0:
+        # raise AssertionError('Cannot permute batch dimension')
+        print('!!! Cannot permute batch dimension. Result may be wrong !!!')
+        layers[scope_name] = layers[inputs[0]]
+    else:
+        tf_name = w_name + str(random.random())
+        permute = keras.layers.Permute(params['perm'][1:], name=tf_name)
+        layers[scope_name] = permute(layers[inputs[0]])
+
+
+def convert_matmul(params, w_name, scope_name, inputs, layers, weights):
+    """
+    Convert tanh 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 matmul ...')
+
+    tf_name = w_name + str(random.random())
+
+    if len(inputs) == 1:
+        weights_name = '{0}.weight'.format(w_name)
+
+        W = weights[weights_name].numpy().transpose()
+        input_channels, output_channels = W.shape
+
+        keras_weights = [W]
+
+        print(layers[inputs[0]])
+        dense = keras.layers.Dense(
+            output_channels,
+            weights=keras_weights, use_bias=False, name=tf_name
+        )
+        layers[scope_name] = dense(layers[inputs[0]])
+    else:
+        raise AssertionError('Cannot convert matmul layer')
+
+
 AVAILABLE_CONVERTERS = {
     'Conv': convert_conv,
     'ConvTranspose': convert_convtranspose,
@@ -546,4 +603,6 @@ def convert_tanh(params, w_name, scope_name, inputs, layers, weights):
     'Sigmoid': convert_sigmoid,
     'Softmax': convert_softmax,
     'Tanh': convert_tanh,
+    'Transpose': convert_transpose,
+    'MatMul': convert_matmul,
 }

tests/dense.py

@@ -16,7 +16,7 @@ class TestDense(nn.Module):
 
     def __init__(self, inp=10, out=16, bias=True):
         super(TestDense, self).__init__()
-        self.linear = nn.Linear(inp, out, bias=True)
+        self.linear = nn.Linear(inp, out, bias=False)
 
     def forward(self, x):
         x = self.linear(x)

tests/transpose.py

@@ -0,0 +1,51 @@
+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 TestTranspose(nn.Module):
+    """Module for Transpose conversion testing
+    """
+
+    def __init__(self, inp=10, out=16, kernel_size=3, bias=True):
+        super(TestTranspose, self).__init__()
+        self.conv2d = nn.Conv2d(inp, out, kernel_size=kernel_size, bias=bias)
+
+    def forward(self, x):
+        x = self.conv2d(x)
+        x = torch.transpose(x, 2, 3)
+        x = torch.nn.Tanh()(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 = TestTranspose(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))