>>> import torch
>>> torch.__version__
'1.10.0+cu102'
>>> import onnx2pytorch
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<...>/lib/python3.9/site-packages/onnx2pytorch/__init__.py", line 1, in <module>
    from .convert import ConvertModel
  File "<...>/lib/python3.9/site-packages/onnx2pytorch/convert/__init__.py", line 1, in <module>
    from .model import ConvertModel
  File "<...>/lib/python3.9/site-packages/onnx2pytorch/convert/model.py", line 14, in <module>
    from onnx2pytorch.constants import (
  File "<...>/lib/python3.9/site-packages/onnx2pytorch/constants.py", line 4, in <module>
    from onnx2pytorch.operations import (
  File "<...>/lib/python3.9/site-packages/onnx2pytorch/operations/__init__.py", line 2, in <module>
    from .batchnorm import BatchNormWrapper
  File "<...>/lib/python3.9/site-packages/onnx2pytorch/operations/batchnorm.py", line 4, in <module>
    from torch.nn.modules.batchnorm import _BatchNorm, _LazyBatchNorm
ImportError: cannot import name '_LazyBatchNorm' from 'torch.nn.modules.batchnorm' (<...>/lib/python3.9/site-packages/torch/nn/modules/batchnorm.py)

UserWarning: The given NumPy array is not writeable, and PyTorch does not support non-writeable tensors. This means you can write to the underlying (supposedly non-writeable) NumPy array using the tensor. You may want to copy the array to protect its data or make it writeable before converting it to a tensor

# Build the model
import tensorflow as tf
import tf2onnx
x = tf.keras.layers.Input((32, 32, 3))
y = tf.keras.layers.GlobalMaxPooling2D()(x)
model = tf.keras.Model(x, y)
model.summary()
# Convert the model
input_shape = model.layers[0].input_shape[0]
spec = (tf.TensorSpec(input_shape, tf.float32, name="input"),)
_, _ = tf2onnx.convert.from_keras(model, input_signature=spec, \
        opset=15, output_path="temp.onnx")
from onnx2pytorch import ConvertModel
import onnx
onnx_model = onnx.load("temp.onnx")
torch_model = ConvertModel(onnx_model, experimental=True)

# Predict
import torch
import numpy as np
input = np.random.rand(10, *input_shape[1:])
input = torch.from_numpy(input)
torch_model.double()
pred = torch_model(input)
pred = pred.detach().numpy()
print("The prediction is: ", pred.shape)

/usr/local/lib/python3.7/dist-packages/onnx2pytorch/convert/model.py in forward(self, *input_list, **input_dict)
    222                     activations[out_op_id] = output
    223             else:
--> 224                 activations[out_op_id] = op(*in_activations)
    225 
    226             # Remove activations that are no longer needed

TypeError: max() received an invalid combination of arguments - got (Tensor, dim=tuple, keepdim=bool), but expected one of:
 * (Tensor input)
 * (Tensor input, Tensor other, *, Tensor out)
 * (Tensor input, int dim, bool keepdim, *, tuple of Tensors out)
 * (Tensor input, name dim, bool keepdim, *, tuple of Tensors out)

200         elif node.op_type == "ReduceMax":
201             kwargs = dict(keepdim=True)
202             kwargs.update(extract_attributes(node))
+ 203             if isinstance(kwargs["dim"], (tuple, list)) and len(kwargs["dim"]) > 1: 
+ 204                 op = partial(torch.amax, **kwargs)
+ 205             else:
206                 op = partial(torch.max, **kwargs)

 
layer.weight.data = torch.from_numpy(numpy_helper.to_array(weight))
Traceback (most recent call last):
 File "/Users/fotech/Onnx-pytorch.py", line 7, in <module>
 pytorch_model = ConvertModel(onnx_model)
 File "/Users/fotech/opt/anaconda3/envs/onnx_ML/lib/python3.9/site-packages/onnx2pytorch/convert/model.py", line 122, in __init__
    for op_id, op_name, op in convert_operations(
 File "/Users/fotech/opt/anaconda3/envs/onnx_ML/lib/python3.9/site-packages/onnx2pytorch/convert/operations.py", line 190, in convert_operations
    op = Pad(**extract_attributes(node))
TypeError: __init__() got an unexpected keyword argument 'constant'

Python 3.9.7 | packaged by conda-forge | (default, Sep 29 2021, 19:23:11) 
[GCC 9.4.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import onnx2pytorch
>>> onnx2pytorch.__version__
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: module 'onnx2pytorch' has no attribute '__version__'
>>> 

_________________________________________________________________
Layer (type)                 Output Shape              Param #
=================================================================
input_1 (InputLayer)         [(None, 32, 3)]           0
_________________________________________________________________
global_max_pooling1d         (None, 3)                 0
_________________________________________________________________
dense (Dense)                (None, 96)                384
_________________________________________________________________
reshape (Reshape)            (None, 32, 3)             0
=================================================================
Total params: 384
Trainable params: 384
Non-trainable params: 0
_________________________________________________________________

# Build the model
import tensorflow as tf
import tf2onnx
x = tf.keras.layers.Input((32,3))
in1 = tf.keras.layers.GlobalMaxPooling1D()(x)
in2 = tf.keras.layers.Dense(96)(in1)
y = tf.keras.layers.Reshape((32,3))(in2)
model = tf.keras.Model(x, y)
model.summary()

# Convert the model
input_shape = model.layers[0].input_shape[0]
spec = (tf.TensorSpec(input_shape, tf.float32, name="input"),)
_, _ = tf2onnx.convert.from_keras(model, input_signature=spec, \
        opset=15, output_path="temp.onnx")
from onnx2pytorch import ConvertModel
import onnx
onnx_model = onnx.load("temp.onnx")
torch_model = ConvertModel(onnx_model, experimental=True)

# Predict
import torch
import numpy as np
input = np.random.rand(10, *input_shape[1:])
input = torch.from_numpy(input)
torch_model.double()
pred = torch_model(input)
pred = pred.detach().numpy()
print("The prediction is: ", pred.shape)

/usr/local/lib/python3.7/dist-packages/torch/nn/functional.py in linear(input, weight, bias)
   1846     if has_torch_function_variadic(input, weight, bias):
   1847         return handle_torch_function(linear, (input, weight, bias), input, weight, bias=bias)
-> 1848     return torch._C._nn.linear(input, weight, bias)
   1849 
   1850 

TypeError: linear(): argument 'input' (position 1) must be Tensor, not torch.return_types.max

/usr/local/lib/python3.7/dist-packages/onnx2pytorch/convert/operations.py in convert_operations(onnx_graph, opset_version, batch_dim, enable_pruning)
    157 
    158                 # check if next node Add to add bias
--> 159                 next_node = onnx_graph.node[i + 1]
    160                 next_params = [
    161                     weights[par_name]

IndexError: list index (74) out of range

onnx_model = onnx.load(load_model_path)
torch_model = ConvertModel(onnx_model)

    result = self.forward(*input, **kwargs)
onnx2pytorch/operations/resize.py:61: in forward
    return super().forward(inp, torch.tensor([]), scales, torch.tensor([]))
onnx2pytorch/operations/resize.py:48: in forward
    return F.interpolate(
...
        if input.dim() == 3 and mode == "nearest":
            return torch._C._nn.upsample_nearest1d(input, output_size, scale_factors)
        if input.dim() == 4 and mode == "nearest":
>           return torch._C._nn.upsample_nearest2d(input, output_size, scale_factors)
E           TypeError: upsample_nearest2d() received an invalid combination of arguments - got (Tensor, NoneType, list), but expected one of:
E            * (Tensor input, tuple of ints output_size, tuple of floats scale_factors)
E                 didn't match because some of the arguments have invalid types: (Tensor, !NoneType!, !list!)
E            * (Tensor input, tuple of ints output_size, float scales_h, float scales_w, *, Tensor out)
.tox/py38/lib/python3.8/site-packages/torch/nn/functional.py:3535: TypeError

!pip install tensorflow==2.6.4 onnx==1.12.0 onnx2pytorch git+https://github.com/onnx/tensorflow-onnx

import tensorflow as tf
import onnx

from onnx2pytorch import ConvertModel

with tf.device("/cpu:0"):
    tf_model = tf.keras.Sequential()
    tf_model.add(tf.keras.layers.Input((123,)))
    tf_model.add(tf.keras.layers.LayerNormalization())
    tf.keras.models.save_model(
        tf_model,
        "model.tf",
        overwrite=True,
        include_optimizer=False,
        save_format=None,
        signatures=None,
        options=None,
        save_traces=True
    )
!python -m tf2onnx.convert --saved-model model.tf --output model.onnx --opset 11 --verbose
onnx_model = onnx.load("model.onnx")
encoder_pth = ConvertModel(onnx_model)

---------------------------------------------------------------------------
NotImplementedError                       Traceback (most recent call last)
[<ipython-input-3-a685e6e12ecf>](https://localhost:8080/#) in <module>()
     22 get_ipython().system('python -m tf2onnx.convert --saved-model model.tf --output model.onnx --opset 11 --verbose')
     23 onnx_model = onnx.load("model.onnx")
---> 24 encoder_pth = ConvertModel(onnx_model)

1 frames
[/usr/local/lib/python3.7/dist-packages/onnx2pytorch/convert/operations.py](https://localhost:8080/#) in convert_operations(onnx_graph, opset_version, batch_dim, enable_pruning)
    278             if op is None:
    279                 raise NotImplementedError(
--> 280                     "Conversion not implemented for op_type={}.".format(node.op_type)
    281                 )
    282             else:

NotImplementedError: Conversion not implemented for op_type=ReduceSumSquare.

layer_stack = [
    keras.layers.MaxPooling2D(pool_size=(2,1), strides=1, padding='same'),
    keras.layers.Flatten(),
    keras.layers.Dense(100)
]

/usr/local/lib/python3.7/dist-packages/torch/nn/functional.py in linear(input, weight, bias)
   1846     if has_torch_function_variadic(input, weight, bias):
   1847         return handle_torch_function(linear, (input, weight, bias), input, weight, bias=bias)
-> 1848     return torch._C._nn.linear(input, weight, bias)
   1849 
   1850 

RuntimeError: mat1 and mat2 shapes cannot be multiplied (1x3069 and 3072x100)

# generate model
import keras
x = keras.layers.Input((32,32,3))
layer_stack = [
    keras.layers.MaxPooling2D(pool_size=(2,1), strides=1, padding='same'),
]
layer_input = x
for layer in layer_stack:
  y = layer(layer_input)
  layer_input = y
model = keras.Model(x, y)
model.summary()

# convert model to onnx
import tensorflow as tf
import tf2onnx
# transform model
input_shape = model.layers[0].input_shape[0]
spec = (tf.TensorSpec(input_shape, tf.float32, name="input"),)
model, _ = tf2onnx.convert.from_keras(model, input_signature=spec, \
    opset=15, output_path="temp.onnx")

# load onnx to pytorch using onnx2pytorch
import onnx
from onnx2pytorch import ConvertModel
import numpy as np
import torch
onnx_model = onnx.load("temp.onnx")
model = ConvertModel(onnx_model)
input = np.random.rand(1, 32, 32, 3)
torch_input = torch.from_numpy(input)
model.double()
res = model(torch_input)
res.size()

import onnxruntime as ort
session = ort.InferenceSession("temp.onnx")
input_name = session.get_inputs()[0].name
output_name = session.get_outputs()[0].name
input = np.random.rand(1, 32, 32, 3).astype('float32')
result = session.run([output_name], {input_name: input})
print(result[0].shape)

ConvertModel(
  (Transpose_max_pooling2d_1/MaxPool__6:0): Transpose()
  (MaxPool_max_pooling2d_1/MaxPool_raw_output___4:0): Sequential(
    (0): ConstantPad2d(padding=(0, 1, 0, 0), value=0)
    (1): MaxPool2d(kernel_size=(2, 1), stride=(1, 1), padding=0, dilation=1, ceil_mode=False)
  )
  (Transpose_max_pooling2d_1): Transpose()
)

model = torch.load(" .pkl")
model.eval()
for epoch in range(1) :
    testing_loss = 0.0
    testing_correct = 0.0
    zpred, ztrue = [], []
    for test_inputs, test_labels in test_data :
        test_inputs, test_labels = test_inputs.to(device), test_labels.to(device)
        output = model(test_inputs)    #error poit
        loss = criterion(output, test_labels)
        _, pred = torch.max(output.data, 1)
        testing_loss += loss.item() 
        testing_correct += torch.sum(pred == test_labels.data)
        output = (torch.max(torch.exp(output), 1)[1]).data.cpu().numpy()
        zpred.extend(output)
        testlabel = test_labels.data.cpu().numpy()
        ztrue.extend(testlabel)
    test_loss = testing_loss / len(test_loader)
    test_acc = 100 * testing_correct.cpu().numpy() / len(test_loader)

    print('Epoch is : {}, Test Loss is : {:.4f} Test Accuracy is :{:.4f}%'.format(epoch + 1, test_loss, test_acc))

sum() received an invalid combination of arguments - got (Tensor, Tensor), but expected one of :
 * (Tensor input, *, torch.dtype dtype)
 * (Tensor input, tuple of ints dim, bool keepdim, *, torch.dtype dtype, Tensor out)
 * (Tensor input, tuple of names dim, bool keepdim, *, torch.dtype dtype, Tensor out)

Traceback (most recent call last):
  File "onnx2pytorch.py", line 2, in <module>
    from onnx2pytorch import ConvertModel
  File "D:\机器学习\Onnx\onnx2pytorch.py", line 2, in <module>
    from onnx2pytorch import ConvertModel
ImportError: cannot import name 'ConvertModel'

import onnx
from onnx2pytorch import ConvertModel
import numpy as np
import torch
input = np.random.rand(1,3,3,3)
onnx_model = onnx.load("incon.onnx")
torch_model = ConvertModel(onnx_model, experimental=True)
torch_input = torch.from_numpy(input)
torch_model.double()
torch_pred = torch_model(torch_input)


import onnxruntime as ort
providers = [
    ('CUDAExecutionProvider', {
        'device_id': 0,
        'arena_extend_strategy': 'kNextPowerOfTwo',
        'gpu_mem_limit': 10 * 1024 * 1024 * 1024,  # 10G
        'cudnn_conv_algo_search': 'EXHAUSTIVE',
        'do_copy_in_default_stream': True,
    }),
    'CPUExecutionProvider',
]
onnx_path = "incon.onnx"
onnx_model = ort.InferenceSession(onnx_path, providers=providers)

input_name = onnx_model.get_inputs()[0].name
output_name = onnx_model.get_outputs()[0].name
input = input.astype('float32')
onnx_pred = onnx_model.run([output_name], {input_name: input})[0]
print("When running on CPU: ", onnx_pred[0])

tensor([[[[ 0.8651,  0.4476,  1.0992],
          [-1.4390, -1.9661,  0.6654],
          [-0.0661,  0.8117,  0.4977]],

         [[ 1.4929, -1.0736, -1.8301],
          [-0.3819,  0.1353, -1.3534],
          [-0.5915,  1.0055,  0.1152]],

         [[ 1.4507,  0.9089,  0.7818],
          [-0.2749,  0.6187,  0.7877],
          [-1.0552, -0.8879, -0.7635]]]], dtype=torch.float64,
       grad_fn=<PermuteBackward0>)

[[[0.6175244  0.7708563  0.99578035]
  [0.06858005 0.03348556 0.86044073]
  [0.39565903 0.8820858  0.8081321 ]]

 [[0.7670855  0.30615166 0.08200629]
  [0.32042617 0.6754674  0.2307212 ]
  [0.27048445 0.94129366 0.6888292 ]]

 [[0.75703746 0.9117755  0.89674425]
  [0.3459281  0.8231245  0.89860445]
  [0.16000679 0.3628597  0.41474345]]]