TypeError: Error while converting op of type: ReduceMean. Error message: Unable to translate axes attribute to CoreML axis parameter for range(0, 4)

Traceback (most recent call last):
  File "onnx2coreml.py", line 13, in <module>
    mlmodel = convert(model_in)
  File "hoge/lib/python3.6/site-packages/onnx_coreml/converter.py", line 449, in convert
    _check_unsupported_ops(graph.nodes)
  File "hoge/lib/python3.6/site-packages/onnx_coreml/converter.py", line 140, in _check_unsupported_ops
    ','.join(unsupported_op_types)))
NotImplementedError: Unsupported ONNX ops of type: Gather,Tile

import onnx

model_in = "Generetaor.onnx"
model_out = "Generator.mlmodel"

model = onnx.load(model_in)
print(onnx.helper.printable_graph(model.graph))
mlmodel = convert(model_in)

graph torch-jit-export (
  %0[FLOAT, 16x3x256x256]
  %1[FLOAT, 16x10]
) initializers (
  %2[FLOAT, 64x13x7x7]
  %3[FLOAT, 64]
  %4[FLOAT, 64]
  %5[FLOAT, 64]
  %6[FLOAT, 64]
  %7[INT64, scalar]
  %8[FLOAT, 128x64x4x4]
  %9[FLOAT, 128]
  %10[FLOAT, 128]
  %11[FLOAT, 128]
  %12[FLOAT, 128]
  %13[INT64, scalar]
  %14[FLOAT, 256x128x4x4]
  %15[FLOAT, 256]
  %16[FLOAT, 256]
  %17[FLOAT, 256]
  %18[FLOAT, 256]
  %19[INT64, scalar]
  %20[FLOAT, 256x256x3x3]
  %21[FLOAT, 256]
  %22[FLOAT, 256]
  %23[FLOAT, 256]
  %24[FLOAT, 256]
  %25[INT64, scalar]
  %26[FLOAT, 256x256x3x3]
  %27[FLOAT, 256]
  %28[FLOAT, 256]
  %29[FLOAT, 256]
  %30[FLOAT, 256]
  %31[INT64, scalar]
  %32[FLOAT, 256x256x3x3]
  %33[FLOAT, 256]
  %34[FLOAT, 256]
  %35[FLOAT, 256]
  %36[FLOAT, 256]
  %37[INT64, scalar]
  %38[FLOAT, 256x256x3x3]
  %39[FLOAT, 256]
  %40[FLOAT, 256]
  %41[FLOAT, 256]
  %42[FLOAT, 256]
  %43[INT64, scalar]
  %44[FLOAT, 256x256x3x3]
  %45[FLOAT, 256]
  %46[FLOAT, 256]
  %47[FLOAT, 256]
  %48[FLOAT, 256]
  %49[INT64, scalar]
  %50[FLOAT, 256x256x3x3]
  %51[FLOAT, 256]
  %52[FLOAT, 256]
  %53[FLOAT, 256]
  %54[FLOAT, 256]
  %55[INT64, scalar]
  %56[FLOAT, 256x256x3x3]
  %57[FLOAT, 256]
  %58[FLOAT, 256]
  %59[FLOAT, 256]
  %60[FLOAT, 256]
  %61[INT64, scalar]
  %62[FLOAT, 256x256x3x3]
  %63[FLOAT, 256]
  %64[FLOAT, 256]
  %65[FLOAT, 256]
  %66[FLOAT, 256]
  %67[INT64, scalar]
  %68[FLOAT, 256x256x3x3]
  %69[FLOAT, 256]
  %70[FLOAT, 256]
  %71[FLOAT, 256]
  %72[FLOAT, 256]
  %73[INT64, scalar]
  %74[FLOAT, 256x256x3x3]
  %75[FLOAT, 256]
  %76[FLOAT, 256]
  %77[FLOAT, 256]
  %78[FLOAT, 256]
  %79[INT64, scalar]
  %80[FLOAT, 256x256x3x3]
  %81[FLOAT, 256]
  %82[FLOAT, 256]
  %83[FLOAT, 256]
  %84[FLOAT, 256]
  %85[INT64, scalar]
  %86[FLOAT, 256x256x3x3]
  %87[FLOAT, 256]
  %88[FLOAT, 256]
  %89[FLOAT, 256]
  %90[FLOAT, 256]
  %91[INT64, scalar]
  %92[FLOAT, 256x128x4x4]
  %93[FLOAT, 128]
  %94[FLOAT, 128]
  %95[FLOAT, 128]
  %96[FLOAT, 128]
  %97[INT64, scalar]
  %98[FLOAT, 128x64x4x4]
  %99[FLOAT, 64]
  %100[FLOAT, 64]
  %101[FLOAT, 64]
  %102[FLOAT, 64]
  %103[INT64, scalar]
  %104[FLOAT, 3x64x7x7]
) {
  %105 = Constant[value = <Scalar Tensor []>]()
  %106 = Shape(%1)
  %107 = Gather[axis = 0](%106, %105)
  %108 = Constant[value = <Scalar Tensor []>]()
  %109 = Shape(%1)
  %110 = Gather[axis = 0](%109, %108)
  %111 = Constant[value = <Scalar Tensor []>]()
  %112 = Constant[value = <Scalar Tensor []>]()
  %113 = Unsqueeze[axes = [0]](%107)
  %114 = Unsqueeze[axes = [0]](%110)
  %115 = Unsqueeze[axes = [0]](%111)
  %116 = Unsqueeze[axes = [0]](%112)
  %117 = Concat[axis = 0](%113, %114, %115, %116)
  %118 = Reshape(%1, %117)
  %119 = Constant[value = <Scalar Tensor []>]()
  %120 = Shape(%0)
  %121 = Gather[axis = 0](%120, %119)
  %122 = Constant[value = <Scalar Tensor []>]()
  %123 = Shape(%0)
  %124 = Gather[axis = 0](%123, %122)
  %125 = Constant[value = <Scalar Tensor []>]()
  %126 = Constant[value = <Scalar Tensor []>]()
  %127 = Unsqueeze[axes = [0]](%125)
  %128 = Unsqueeze[axes = [0]](%126)
  %129 = Unsqueeze[axes = [0]](%121)
  %130 = Unsqueeze[axes = [0]](%124)
  %131 = Concat[axis = 0](%127, %128, %129, %130)
  %132 = Tile(%118, %131)
  %133 = Concat[axis = 1](%0, %132)
  %134 = Conv[dilations = [1, 1], group = 1, kernel_shape = [7, 7], pads = [3, 3, 3, 3], strides = [1, 1]](%133, %2)
  %135 = InstanceNormalization[epsilon = 9.99999974737875e-06](%134, %3, %4)
  %136 = Relu(%135)
  %137 = Conv[dilations = [1, 1], group = 1, kernel_shape = [4, 4], pads = [1, 1, 1, 1], strides = [2, 2]](%136, %8)
  %138 = InstanceNormalization[epsilon = 9.99999974737875e-06](%137, %9, %10)
  %139 = Relu(%138)
  %140 = Conv[dilations = [1, 1], group = 1, kernel_shape = [4, 4], pads = [1, 1, 1, 1], strides = [2, 2]](%139, %14)
  %141 = InstanceNormalization[epsilon = 9.99999974737875e-06](%140, %15, %16)
  %142 = Relu(%141)
  %143 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%142, %20)
  %144 = InstanceNormalization[epsilon = 9.99999974737875e-06](%143, %21, %22)
  %145 = Relu(%144)
  %146 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%145, %26)
  %147 = InstanceNormalization[epsilon = 9.99999974737875e-06](%146, %27, %28)
  %148 = Add(%142, %147)
  %149 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%148, %32)
  %150 = InstanceNormalization[epsilon = 9.99999974737875e-06](%149, %33, %34)
  %151 = Relu(%150)
  %152 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%151, %38)
  %153 = InstanceNormalization[epsilon = 9.99999974737875e-06](%152, %39, %40)
  %154 = Add(%148, %153)
  %155 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%154, %44)
  %156 = InstanceNormalization[epsilon = 9.99999974737875e-06](%155, %45, %46)
  %157 = Relu(%156)
  %158 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%157, %50)
  %159 = InstanceNormalization[epsilon = 9.99999974737875e-06](%158, %51, %52)
  %160 = Add(%154, %159)
  %161 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%160, %56)
  %162 = InstanceNormalization[epsilon = 9.99999974737875e-06](%161, %57, %58)
  %163 = Relu(%162)
  %164 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%163, %62)
  %165 = InstanceNormalization[epsilon = 9.99999974737875e-06](%164, %63, %64)
  %166 = Add(%160, %165)
  %167 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%166, %68)
  %168 = InstanceNormalization[epsilon = 9.99999974737875e-06](%167, %69, %70)
  %169 = Relu(%168)
  %170 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%169, %74)
  %171 = InstanceNormalization[epsilon = 9.99999974737875e-06](%170, %75, %76)
  %172 = Add(%166, %171)
  %173 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%172, %80)
  %174 = InstanceNormalization[epsilon = 9.99999974737875e-06](%173, %81, %82)
  %175 = Relu(%174)
  %176 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%175, %86)
  %177 = InstanceNormalization[epsilon = 9.99999974737875e-06](%176, %87, %88)
  %178 = Add(%172, %177)
  %179 = ConvTranspose[dilations = [1, 1], group = 1, kernel_shape = [4, 4], pads = [1, 1, 1, 1], strides = [2, 2]](%178, %92)
  %180 = InstanceNormalization[epsilon = 9.99999974737875e-06](%179, %93, %94)
  %181 = Relu(%180)
  %182 = ConvTranspose[dilations = [1, 1], group = 1, kernel_shape = [4, 4], pads = [1, 1, 1, 1], strides = [2, 2]](%181, %98)
  %183 = InstanceNormalization[epsilon = 9.99999974737875e-06](%182, %99, %100)
  %184 = Relu(%183)
  %185 = Conv[dilations = [1, 1], group = 1, kernel_shape = [7, 7], pads = [3, 3, 3, 3], strides = [1, 1]](%184, %104)
  %186 = Tanh(%185)
  return %186
}

input_names=['ip1', 'ip2', 'ip3' , 'ip4' ]
output_names=['preds']
coreml_model = convert(
    model,
    None,
    image_input_names=input_names,
    image_output_names=output_names,
)
coreml_model.save('mvdepth.mlmodel')

spec = coreml_model.get_spec()

spec - 

input {
  name: "ip1"
  type {
    imageType {
      width: 320
      height: 256
      colorSpace: RGB
    }
  }
}
input {
  name: "ip2"
  type {
    imageType {
      width: 320
      height: 256
      colorSpace: RGB
    }
  }
}
input {
  name: "ip3"
  type {
    imageType {
      width: 81920
      height: 3
      colorSpace: GRAYSCALE
    }
  }
}
input {
  name: "ip4"
  type {
    imageType {
      width: 1
      height: 3
      colorSpace: GRAYSCALE
    }
  }
}
output {
  name: "preds"
  type {
    imageType {
      width: 320
      height: 256
      colorSpace: GRAYSCALE
    }
  }
}

from torch import nn, zeros, LongTensor, FloatTensor, onnx
from torch.autograd import Variable
import torch.nn.functional as F
from onnx_coreml import convert

class SimpleNet(nn.Module):
    def __init__(self, input_size):
        super(SimpleNet, self).__init__()
        
        self.embedd = nn.Embedding(input_size, 100)
        self.fc1 = nn.Linear(100, 200)
        self.fc2 = nn.Linear(200, 200)
        self.fc3 = nn.Linear(200, 300)
                
    def forward(self, input):
        r_0 = input.mm(self.embedd.weight)
        r_1 = F.tanh(self.fc1(r_0).div(10.))
        r_2 = F.tanh(self.fc2(r_1).div(10.)) + r_1
        r_3 = F.tanh(self.fc3(r_2).div(10.))
        return r_3

# Create fake one-hot encoded input
indices = [1,2,3,4,5]
input = zeros(1000).type(FloatTensor)

# create one-hot encoded input
for i in indices:
    input[i] = 1
    
input = Variable(input)
input = input.view(1, -1)

# forward pass with fake input
simple_net = SimpleNet(1000)
out = simple_net(input)

torch_out = onnx._export(simple_net,
                                           input,
                                           "test_simple_net.onnx",
                                            export_params=True,
                                             verbose=True
                                           )

graph(%0 : Float(1, 1000)
      %1 : Float(1000, 100)
      %2 : Float(200, 100)
      %3 : Float(200)
      %4 : Float(200, 200)
      %5 : Float(200)
      %6 : Float(300, 200)
      %7 : Float(300)) {
  %8 : UNKNOWN_TYPE = Constant[value={0}](), scope: SimpleNet
  %9 : Float(1, 100) = Gemm[alpha=1, beta=0, broadcast=1](%0, %1, %8), scope: SimpleNet
  %10 : Float(1, 200) = Gemm[alpha=1, beta=1, broadcast=1, transB=1](%9, %2, %3), scope: SimpleNet/Linear[fc1]
  %11 : UNKNOWN_TYPE = Constant[value={10}](), scope: SimpleNet
  %12 : Float(1, 200) = Div[broadcast=1](%10, %11), scope: SimpleNet
  %13 : Float(1, 200) = Tanh(%12), scope: SimpleNet
  %14 : Float(1, 200) = Gemm[alpha=1, beta=1, broadcast=1, transB=1](%13, %4, %5), scope: SimpleNet/Linear[fc2]
  %15 : UNKNOWN_TYPE = Constant[value={10}](), scope: SimpleNet
  %16 : Float(1, 200) = Div[broadcast=1](%14, %15), scope: SimpleNet
  %17 : Float(1, 200) = Tanh(%16), scope: SimpleNet
  %18 : Float(1, 200) = Add(%17, %13), scope: SimpleNet
  %19 : Float(1, 300) = Gemm[alpha=1, beta=1, broadcast=1, transB=1](%18, %6, %7), scope: SimpleNet/Linear[fc3]
  %20 : UNKNOWN_TYPE = Constant[value={10}](), scope: SimpleNet
  %21 : Float(1, 300) = Div[broadcast=1](%19, %20), scope: SimpleNet
  %22 : Float(1, 300) = Tanh(%21), scope: SimpleNet
  return (%22);
}

model_filename = "test_simple_net.onnx"
converted = convert(model_filename)

TypeError                                 Traceback (most recent call last)
<ipython-input-7-15e4a0f3784e> in <module>()
----> 1 converted = convert(model_filename)

/home/d.parpulov/env/venv2/local/lib/python2.7/site-packages/onnx_coreml/_onnx_converter.pyc in convert(model, mode, image_input_names, preprocessing_args, image_output_names, deprocessing_args, class_labels, predicted_feature_name)
    217 
    218     for node in graph.nodes:
--> 219         _convert_node(builder, node)
    220 
    221     if add_deprocess:

/home/d.parpulov/env/venv2/local/lib/python2.7/site-packages/onnx_coreml/_layers.pyc in _convert_node(builder, node)
    388 
    389 def _convert_node(builder, node):
--> 390     converter_fn = _get_node_converter_fn(node)
    391     return converter_fn(builder, node)

/home/d.parpulov/env/venv2/local/lib/python2.7/site-packages/onnx_coreml/_layers.pyc in _get_node_converter_fn(node)
    383     else:
    384         raise TypeError(
--> 385             "ONNX node of type {} is not supported.".format(op_type,)
    386         )
    387 

TypeError: ONNX node of type Constant is not supported.

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-2-3393594cc401> in <module>()
      6             deprocessing_args={},
      7             class_labels=None,
----> 8             predicted_feature_name='classLabel')

/Users/mikhail/anaconda/envs/p2/lib/python2.7/site-packages/onnx_coreml/_onnx_converter.pyc in convert(model, mode, image_input_names, preprocessing_args, image_output_names, deprocessing_args, class_labels, predicted_feature_name)
    217 
    218     for node in graph.nodes:
--> 219         _convert_node(builder, node)
    220 
    221     if add_deprocess:

/Users/mikhail/anaconda/envs/p2/lib/python2.7/site-packages/onnx_coreml/_layers.pyc in _convert_node(builder, node)
    394     print('------------------')
    395     converter_fn = _get_node_converter_fn(node)
--> 396     return converter_fn(builder, node)

/Users/mikhail/anaconda/envs/p2/lib/python2.7/site-packages/onnx_coreml/_layers.pyc in _convert_gemm(builder, node)
    304 def _convert_gemm(builder, node):
    305     print(node.attrs)
--> 306     if node.attrs["broadcast"].i != 1 or node.attrs["transB"].i != 1:
    307         raise ValueError(
    308             "Gemm is supported only for inner_product layer"

KeyError: 'transB'

$ git clone --recursive https://github.com/onnx/onnx-coreml.git

Cloning into 'onnx-coreml'...
remote: Counting objects: 1717, done.
remote: Compressing objects: 100% (47/47), done.
remote: Total 1717 (delta 15), reused 34 (delta 1), pack-reused 1669
Receiving objects: 100% (1717/1717), 326.54 KiB | 411.00 KiB/s, done.
Resolving deltas: 100% (877/877), done.
Checking connectivity... done.
......
Cloning into 'third_party/eigen'...
Username for 'https://github.com': naruya
Password for 'https://[email protected]': 
remote: Repository not found.
fatal: repository 'https://github.com/RLovelett/eigen.git/' not found
fatal: clone of 'https://github.com/RLovelett/eigen.git' into submodule path 'third_party/eigen' failed
Failed to recurse into submodule path 'third_party/pytorch'

        mlmodel = convert(args.onnxsavename,
                          image_input_names=['0'],
                          preprocessing_args={'is_bgr':args.bgr,
                                              'blue_bias':args.mean[0],
                                              'green_bias':args.mean[1],
                                              'red_bias':args.mean[2],
                                              'image_scale': args.scale},
                          image_output_names=args.outputnames,
                          deprocessing_args={'is_bgr':args.bgr,
                                             'blue_bias':-1.0*args.mean[0],
                                             'green_bias':-1.0*args.mean[1],
                                             'red_bias':-1.0*args.mean[2],
                                             'image_scale': 1.0/args.scale}
                          )

bgr=True, 
channels=3, 
height=28, 
width=28,
inputmodels=[],
mean=[0.0, 0.0, 0.0],
onnxsavename='/tmp/tmp.onnx', 
outputnames=['decodedimages'], 
scale=0.00392156862745098

graph(%0 : Float(1, 3, 28, 28)
      %1 : Float(16, 3, 3, 3)
      %2 : Float(16)
      %3 : Float(8, 16, 3, 3)
      %4 : Float(8)
      %5 : Float(8, 16, 3, 3)
      %6 : Float(16)
      %7 : Float(16, 8, 5, 5)
      %8 : Float(8)
      %9 : Float(8, 3, 2, 2)
      %10 : Float(3)) {
  %11 : Float(1, 16, 10, 10) = onnx::Conv[dilations=[1, 1], group=1, kernel_shape=[3, 3], pads=[1, 1, 1, 1], strides=[3, 3]](%0, %1, %2), scope: autoencoder/Sequential[encoder]/Conv2d[0]
  %12 : Float(1, 16, 10, 10) = onnx::Relu(%11), scope: autoencoder/Sequential[encoder]/ReLU[1]
  %13 : Float(1, 16, 5, 5) = onnx::MaxPool[kernel_shape=[2, 2], pads=[0, 0, 0, 0], strides=[2, 2]](%12), scope: autoencoder/Sequential[encoder]/MaxPool2d[2]
  %14 : Float(1, 8, 3, 3) = onnx::Conv[dilations=[1, 1], group=1, kernel_shape=[3, 3], pads=[1, 1, 1, 1], strides=[2, 2]](%13, %3, %4), scope: autoencoder/Sequential[encoder]/Conv2d[3]
  %15 : Float(1, 8, 3, 3) = onnx::Relu(%14), scope: autoencoder/Sequential[encoder]/ReLU[4]
  %16 : Float(1, 8, 2, 2) = onnx::MaxPool[kernel_shape=[2, 2], pads=[0, 0, 0, 0], strides=[1, 1]](%15), scope: autoencoder/Sequential[encoder]/MaxPool2d[5]
  %17 : Float(1, 16, 5, 5) = onnx::ConvTranspose[dilations=[1, 1], group=1, kernel_shape=[3, 3], pads=[0, 0, 0, 0], strides=[2, 2]](%16, %5, %6), scope: autoencoder/Sequential[decoder]/ConvTranspose2d[0]
  %18 : Float(1, 16, 5, 5) = onnx::Relu(%17), scope: autoencoder/Sequential[decoder]/ReLU[1]
  %19 : Float(1, 8, 15, 15) = onnx::ConvTranspose[dilations=[1, 1], group=1, kernel_shape=[5, 5], pads=[1, 1, 1, 1], strides=[3, 3]](%18, %7, %8), scope: autoencoder/Sequential[decoder]/ConvTranspose2d[2]
  %20 : Float(1, 8, 15, 15) = onnx::Relu(%19), scope: autoencoder/Sequential[decoder]/ReLU[3]
  %21 : Float(1, 3, 28, 28) = onnx::ConvTranspose[dilations=[1, 1], group=1, kernel_shape=[2, 2], pads=[1, 1, 1, 1], strides=[2, 2]](%20, %9, %10), scope: autoencoder/Sequential[decoder]/ConvTranspose2d[4]
  %22 : Float(1, 3, 28, 28) = onnx::Tanh(%21), scope: autoencoder/Sequential[decoder]/Tanh[5]
  return (%22);
}

1/12: Converting Node Type Conv
2/12: Converting Node Type Relu
3/12: Converting Node Type MaxPool
4/12: Converting Node Type Conv
5/12: Converting Node Type Relu
6/12: Converting Node Type MaxPool
7/12: Converting Node Type ConvTranspose
8/12: Converting Node Type Relu
9/12: Converting Node Type ConvTranspose
10/12: Converting Node Type Relu
11/12: Converting Node Type ConvTranspose
12/12: Converting Node Type Tanh
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-8-933176c8e46b> in <module>()
     12 args.savename = 'autoencoder_img_out.mlmodel'
     13 print(args)
---> 14 coreml_convert.convert_model(model, args)

~/TRASH-INC/Otto/pytrain/coreml_convert.py in convert_model(torch_model, args)
     94                                              'green_bias':-1.0*args.mean[1],
     95                                              'red_bias':-1.0*args.mean[2],
---> 96                                              'image_scale': 1.0/args.scale}
     97                           )
     98     else:

/usr/local/lib/python3.6/site-packages/onnx_coreml/converter.py in convert(model, mode, image_input_names, preprocessing_args, image_output_names, deprocessing_args, class_labels, predicted_feature_name, add_custom_layers, custom_conversion_functions)
    444                     builder.spec.description.output[i].shortDescription = 'This output is a sequence'
    445 
--> 446     mlmodel = MLModel(builder.spec)
    447 
    448     # print information about all ops for which custom layers have been added

/usr/local/lib/python3.6/site-packages/coremltools/models/model.py in __init__(self, model)
    213             filename = _tempfile.mktemp(suffix = '.mlmodel')
    214             _save_spec(model, filename)
--> 215             self.__proxy__ = _get_proxy_from_spec(filename)
    216         else:
    217             raise TypeError("Expected model to be a .mlmodel file or a Model_pb2 object")

/usr/local/lib/python3.6/site-packages/coremltools/models/model.py in _get_proxy_from_spec(filename)
    101             return None
    102         try:
--> 103             return _MLModelProxy(filename)
    104         except RuntimeError as e:
    105             warnings.warn(

IndexError: map::at:  key not found

def forward(self, x, y):
    ...
    y_hat = torch.squeeze(torch.bmm(y_hat, y), 2)
    ...

from torchvision import transforms


IMAGE_NET_MEAN = [0.485, 0.456, 0.406]
IMAGE_NET_STD = [0.229, 0.224, 0.225]

class Transform:
    def __init__(self):
        normalize = transforms.Normalize(
            mean=IMAGE_NET_MEAN,
            std=IMAGE_NET_STD)

        self._val_transform = transforms.Compose([
            transforms.Resize((224, 224)),
            transforms.ToTensor(),
            normalize])

@property
    def val_transform(self):
    return self._val_transform

...

and before feeding the model

from nima.common import Transform

...

   image = self.transform(image)
    
    image = image.unsqueeze_(0)
    
    image = image.to(device)

python (3.5.2)
Click (7.0)
numpy (1.15.2)
onnx (1.3.0)
onnx-coreml (0.3.0)

import onnx
import onnx_coreml

import torch
from torch import nn


class Dummy(nn.Module):

    def __init__(self):
        super().__init__()

    def forward(self, inp):
        a, b = inp

        result = b + nn.functional.interpolate(a, scale_factor=2, mode="nearest")
        return result


def main(device='cuda:0'):
    model = Dummy()
    model = model.to(device)
    dummy_input = [torch.randn(1, 128, 32, 32).to(device), torch.randn(1, 128, 64, 64).to(device)]

    onnx_path = '/tmp/dummy.onnx'
    coreml_path = '/tmp/dummy.mlmodel'
    torch.onnx.export(model,
                      dummy_input,
                      f=onnx_path,
                      input_names=['input'],
                      output_names=['output'],
                      verbose=False,
                      export_params=True,
                      )
    onnx_model = onnx.load(onnx_path)
    coreml_model = onnx_coreml.convert(onnx_model)
    coreml_model.save(coreml_path)


if __name__ == '__main__':
    main()

class SampleModule(torch.nn.Module):
    def __init__(self):
        super(SampleModule, self).__init__()
        self.ones = torch.nn.Parameter(torch.ones(2, 3))

    def forward(self, x):
        return self.ones+x


def convert_sample():
    inpt = torch.rand(2,3)
    net = SampleModule()

    torch.onnx.export(net, inpt, '/tmp/sample.onnx', verbose=True)
    convert('/tmp/sample.onnx')

graph(%0 : Float(2, 3)
      %1 : Float(2, 3)) {
  %2 : Float(2, 3) = onnx::Add(%1, %0), scope: SampleModule
  return (%2);
}

1/1: Converting Node Type Add
Traceback (most recent call last):
  File "prepare_coreml.py", line 117, in <module>
    convert_sample()
  File "prepare_coreml.py", line 110, in convert_sample
    mlmodel = convert('/tmp/sample.onnx')
  File "site-packages/onnx_coreml/converter.py", line 446, in convert
    mlmodel = MLModel(builder.spec)
  File "/site-packages/coremltools/models/model.py", line 153, in __init__
    self.__proxy__ = _get_proxy_from_spec(filename)
  File "site-packages/coremltools/models/model.py", line 77, in _get_proxy_from_spec
    return _MLModelProxy(filename)
RuntimeError: Error compiling model: "Error reading protobuf spec. validator error: Layer '2' consumes a layer named '1' which is not present in this network.".

File "/home/gen/.envs/otto/lib/python3.6/site-packages/onnx_coreml/converter.py", line 499, in convert
    predicted_feature_name=predicted_feature_name
  File "/home/gen/.envs/otto/lib/python3.6/site-packages/coremltools/models/neural_network/builder.py", line 337, in set_class_labels
    nn_spec.ClearField('stringClassLabels')
ValueError: Protocol message has no "stringClassLabels" field.

        mlmodel = convert(args.onnxsavename,
                          image_input_names=['0'],
                          preprocessing_args={'is_bgr':args.bgr,
                                              'blue_bias':args.mean[0],
                                              'green_bias':args.mean[1],
                                              'red_bias':args.mean[2],
                                              'image_scale': args.scale},
                          predicted_feature_name='classLabel', #default variable name for layer containing predicted class labels
                          class_labels=args.labels_fname
        )

Traceback (most recent call last):
  File "onnx_to_coreml.py", line 15, in <module>
    deprocessing_args={'image_scale': 255})
  File "/foo/lib/python3.6/site-packages/onnx_coreml/converter.py", line 458, in convert
    _convert_node(builder, node, graph, err)
  File "/foo/lib/python3.6/site-packages/onnx_coreml/_operators.py", line 1755, in _convert_node
    return converter_fn(builder, node, graph, err)
  File "/foo/lib/python3.6/site-packages/onnx_coreml/_operators.py", line 443, in _convert_reshape
    "CoreML only supports Reshape layer when the target shape is static and known apriori")
  File "/foo/lib/python3.6/site-packages/onnx_coreml/_error_utils.py", line 71, in missing_initializer
    format(node.op_type, node.inputs[0], node.outputs[0], err_message)
ValueError: Missing initializer error in op of type Reshape, with input name = 40, output name = 68. Error message: CoreML only supports Reshape layer when the target shape is static and known apriori

onnx==1.3.0
onnx-coreml==0.3.0

graph torch-jit-export (
  %input_image[FLOAT, 1x3x100x100]
) initializers (
  %learned_0[FLOAT, 56x3x5x5]
  %learned_1[FLOAT, 56]
  %learned_2[FLOAT, 1]
  %learned_3[FLOAT, 12x56x1x1]
  %learned_4[FLOAT, 12]
  %learned_5[FLOAT, 1]
  %learned_6[FLOAT, 12x12x3x3]
  %learned_7[FLOAT, 12]
  %learned_8[FLOAT, 1]
  %learned_9[FLOAT, 12x12x3x3]
  %learned_10[FLOAT, 12]
  %learned_11[FLOAT, 1]
  %learned_12[FLOAT, 12x12x3x3]
  %learned_13[FLOAT, 12]
  %learned_14[FLOAT, 1]
  %learned_15[FLOAT, 12x12x3x3]
  %learned_16[FLOAT, 12]
  %learned_17[FLOAT, 1]
  %learned_18[FLOAT, 12x12x1x1]
  %learned_19[FLOAT, 12]
  %learned_20[FLOAT, 1]
) {
  %22 = Pad[mode = 'reflect', pads = [0, 0, 2, 2, 0, 0, 2, 2]](%input_image)
  %23 = Conv[dilations = [1, 1], group = 1, kernel_shape = [5, 5], pads = [0, 0, 0, 0], strides = [1, 1]](%22, %learned_0, %learned_1)
  %24 = PRelu(%23, %learned_2)
  %25 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%24, %learned_3, %learned_4)
  %26 = PRelu(%25, %learned_5)
  %27 = Pad[mode = 'reflect', pads = [0, 0, 1, 1, 0, 0, 1, 1]](%26)
  %28 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [0, 0, 0, 0], strides = [1, 1]](%27, %learned_6, %learned_7)
  %29 = PRelu(%28, %learned_8)
  %30 = Pad[mode = 'reflect', pads = [0, 0, 1, 1, 0, 0, 1, 1]](%29)
  %31 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [0, 0, 0, 0], strides = [1, 1]](%30, %learned_9, %learned_10)
  %32 = PRelu(%31, %learned_11)
  %33 = Pad[mode = 'reflect', pads = [0, 0, 1, 1, 0, 0, 1, 1]](%32)
  %34 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [0, 0, 0, 0], strides = [1, 1]](%33, %learned_12, %learned_13)
  %35 = PRelu(%34, %learned_14)
  %36 = Pad[mode = 'reflect', pads = [0, 0, 1, 1, 0, 0, 1, 1]](%35)
  %37 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [0, 0, 0, 0], strides = [1, 1]](%36, %learned_15, %learned_16)
  %38 = PRelu(%37, %learned_17)
  %39 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%38, %learned_18, %learned_19)
  %40 = PRelu(%39, %learned_20)
  %41 = Shape(%40)
  %42 = Slice[axes = [0], ends = [1], starts = [0]](%41)
  %43 = Squeeze[axes = [0]](%42)
  %44 = Shape(%40)
  %45 = Slice[axes = [0], ends = [2], starts = [1]](%44)
  %46 = Squeeze[axes = [0]](%45)
  %47 = Shape(%40)
  %48 = Slice[axes = [0], ends = [3], starts = [2]](%47)
  %49 = Squeeze[axes = [0]](%48)
  %50 = Shape(%40)
  %51 = Slice[axes = [0], ends = [4], starts = [3]](%50)
  %52 = Squeeze[axes = [0]](%51)
  %53 = Constant[value = <Scalar Tensor []>]()
  %54 = Div[broadcast = 1](%46, %53)
  %55 = Constant[value = <Scalar Tensor []>]()
  %56 = Mul[broadcast = 1](%49, %55)
  %57 = Constant[value = <Scalar Tensor []>]()
  %58 = Mul[broadcast = 1](%52, %57)
  %59 = Constant[value = <Scalar Tensor []>]()
  %60 = Constant[value = <Scalar Tensor []>]()
  %61 = Unsqueeze[axes = [0]](%43)
  %62 = Unsqueeze[axes = [0]](%54)
  %63 = Unsqueeze[axes = [0]](%59)
  %64 = Unsqueeze[axes = [0]](%60)
  %65 = Unsqueeze[axes = [0]](%49)
  %66 = Unsqueeze[axes = [0]](%52)
  %67 = Concat[axis = 0](%61, %62, %63, %64, %65, %66)
  %68 = Reshape(%40, %67)
  %69 = Transpose[perm = [0, 1, 4, 2, 5, 3]](%68)
  %70 = Unsqueeze[axes = [0]](%43)
  %71 = Unsqueeze[axes = [0]](%54)
  %72 = Unsqueeze[axes = [0]](%56)
  %73 = Unsqueeze[axes = [0]](%58)
  %74 = Concat[axis = 0](%70, %71, %72, %73)
  %output_image = Reshape(%69, %74)
  return %output_image
}