ERROR: Network must have at least one output

Hi Dear,

I am using TensorRT and meet some issues. pls help. thanks.    

Ubuntu 16.04 LTS
GPU type:V100
CUDA version:10.2
Python version:3.6
TensorRT version: 5.0.0.10
TensorFlow: 1.15.0

My model is trained by TF and converted to uff file. When I useed parser to build cuda engine ,the error appeared:
[TensorRT] ERROR: UffParser: Validator error: truediv_14/Cast: Unsupported operation _Cast
[TensorRT] ERROR: Network must have at least one output

here is the convert-to-uff outputs info

UFF Version 0.6.3
=== Automatically deduced input nodes ===
[name: “input”
op: “Placeholder”
attr {
key: “dtype”
value {
type: DT_FLOAT
}
}
attr {
key: “shape”
value {
shape {
dim {
size: -1
}
dim {
size: -1
}
dim {
size: -1
}
dim {
size: 3
}
}
}
}
]

=== Automatically deduced output nodes ===
[name: “output/boxes”
op: “Identity”
input: “combined_non_max_suppression/CombinedNonMaxSuppression”
attr {
key: “T”
value {
type: DT_FLOAT
}
}
, name: “output/scores”
op: “Identity”
input: “combined_non_max_suppression/CombinedNonMaxSuppression:1”
attr {
key: “T”
value {
type: DT_FLOAT
}
}
, name: “output/labels”
op: “Identity”
input: “combined_non_max_suppression/CombinedNonMaxSuppression:2”
attr {
key: “T”
value {
type: DT_FLOAT
}
}
, name: “output/num_detections”
op: “Identity”
input: “combined_non_max_suppression/CombinedNonMaxSuppression:3”
attr {
key: “T”
value {
type: DT_INT32
}
}
]

Hi,
The model files has “Cast” operations which is not supported in UFF parser.
Please find the below link:
https://docs.nvidia.com/deeplearning/sdk/tensorrt-api/python_api/uff/Operators.html

You can try tf2onnx + ONNX parser as an alternative.
https://github.com/onnx/tensorflow-onnx

Thanks

Hi,

Thanks for your reply. however, tf2onnx is not works in this case with error as belows;

python -m tf2onnx.convert --input output_frozen_model.pb --output frozon_model.onnx --inputs input:0 --outputs output/boxes:0,output/labels:0,output/scores:0,output/num_detections:0
WARNING:tensorflow:From /home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tensorflow_core/init.py:1467: The name tf.estimator.inputs is deprecated. Please use tf.compat.v1.estimator.inputs instead.

WARNING:tensorflow:From /home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tf2onnx/verbose_logging.py:72: The name tf.logging.set_verbosity is deprecated. Please use tf.compat.v1.logging.set_verbosity instead.

2020-01-16 06:33:23,624 - WARNING - From /home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tf2onnx/verbose_logging.py:72: The name tf.logging.set_verbosity is deprecated. Please use tf.compat.v1.logging.set_verbosity instead.

2020-01-16 06:33:29,099 - INFO - Using tensorflow=1.15.0, onnx=1.6.0, tf2onnx=1.5.4/ee756a
2020-01-16 06:33:29,099 - INFO - Using opset <onnx, 8>
2020-01-16 06:33:29,193 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,193 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_1/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_1/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,193 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_2/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_2/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,194 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_3/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_3/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,194 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_4/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_4/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,194 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_5/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_5/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,194 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_6/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_6/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,194 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_7/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_7/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,194 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_8/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_8/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,194 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_9/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_9/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,194 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_10/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_10/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,194 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_11/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_11/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,194 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_12/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_12/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,194 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_13/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_13/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,194 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_14/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_14/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,194 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_15/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_15/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,194 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_16/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_16/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,194 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_17/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_17/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,194 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_18/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_18/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,194 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_19/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_19/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,195 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_20/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_20/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,195 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_21/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_21/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,195 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_22/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_22/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,195 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_23/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_23/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,195 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_24/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_24/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,195 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_25/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_25/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,195 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_26/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_26/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,195 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_27/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_27/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,195 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_28/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_28/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,195 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_29/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_29/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,195 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_30/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_30/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,195 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_31/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_31/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,195 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_32/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_32/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,195 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_33/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_33/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,195 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_34/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_34/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,195 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_35/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_35/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,195 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_36/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_36/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,196 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_37/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_37/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,196 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_38/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_38/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,196 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_39/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_39/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,196 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_40/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_40/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,196 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_41/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_41/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,196 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_42/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_42/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,196 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_43/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_43/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,196 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_44/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_44/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,196 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_45/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_45/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,196 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_46/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_46/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,196 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_47/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_47/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,196 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_48/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_48/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,196 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_49/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_49/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,196 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_50/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_50/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,196 - WARNING - Cannot infer shape for yolov3/darknet53_body/Conv_51/BatchNorm/FusedBatchNormV3: yolov3/darknet53_body/Conv_51/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,196 - WARNING - Cannot infer shape for yolov3/yolov3_head/Conv/BatchNorm/FusedBatchNormV3: yolov3/yolov3_head/Conv/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,196 - WARNING - Cannot infer shape for yolov3/yolov3_head/Conv_1/BatchNorm/FusedBatchNormV3: yolov3/yolov3_head/Conv_1/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,196 - WARNING - Cannot infer shape for yolov3/yolov3_head/Conv_2/BatchNorm/FusedBatchNormV3: yolov3/yolov3_head/Conv_2/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,197 - WARNING - Cannot infer shape for yolov3/yolov3_head/Conv_3/BatchNorm/FusedBatchNormV3: yolov3/yolov3_head/Conv_3/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,197 - WARNING - Cannot infer shape for yolov3/yolov3_head/Conv_4/BatchNorm/FusedBatchNormV3: yolov3/yolov3_head/Conv_4/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,197 - WARNING - Cannot infer shape for yolov3/yolov3_head/Conv_5/BatchNorm/FusedBatchNormV3: yolov3/yolov3_head/Conv_5/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,197 - WARNING - Cannot infer shape for yolov3/yolov3_head/Conv_7/BatchNorm/FusedBatchNormV3: yolov3/yolov3_head/Conv_7/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,197 - WARNING - Cannot infer shape for yolov3/yolov3_head/Conv_8/BatchNorm/FusedBatchNormV3: yolov3/yolov3_head/Conv_8/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,197 - WARNING - Cannot infer shape for yolov3/yolov3_head/Conv_9/BatchNorm/FusedBatchNormV3: yolov3/yolov3_head/Conv_9/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,197 - WARNING - Cannot infer shape for yolov3/yolov3_head/Conv_10/BatchNorm/FusedBatchNormV3: yolov3/yolov3_head/Conv_10/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,197 - WARNING - Cannot infer shape for yolov3/yolov3_head/Conv_11/BatchNorm/FusedBatchNormV3: yolov3/yolov3_head/Conv_11/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,197 - WARNING - Cannot infer shape for yolov3/yolov3_head/Conv_12/BatchNorm/FusedBatchNormV3: yolov3/yolov3_head/Conv_12/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,197 - WARNING - Cannot infer shape for yolov3/yolov3_head/Conv_13/BatchNorm/FusedBatchNormV3: yolov3/yolov3_head/Conv_13/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,197 - WARNING - Cannot infer shape for yolov3/yolov3_head/Conv_15/BatchNorm/FusedBatchNormV3: yolov3/yolov3_head/Conv_15/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,197 - WARNING - Cannot infer shape for yolov3/yolov3_head/Conv_16/BatchNorm/FusedBatchNormV3: yolov3/yolov3_head/Conv_16/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,197 - WARNING - Cannot infer shape for yolov3/yolov3_head/Conv_17/BatchNorm/FusedBatchNormV3: yolov3/yolov3_head/Conv_17/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,197 - WARNING - Cannot infer shape for yolov3/yolov3_head/Conv_18/BatchNorm/FusedBatchNormV3: yolov3/yolov3_head/Conv_18/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,197 - WARNING - Cannot infer shape for yolov3/yolov3_head/Conv_19/BatchNorm/FusedBatchNormV3: yolov3/yolov3_head/Conv_19/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,197 - WARNING - Cannot infer shape for yolov3/yolov3_head/Conv_20/BatchNorm/FusedBatchNormV3: yolov3/yolov3_head/Conv_20/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:29,197 - WARNING - Cannot infer shape for yolov3/yolov3_head/Conv_21/BatchNorm/FusedBatchNormV3: yolov3/yolov3_head/Conv_21/BatchNorm/FusedBatchNormV3:5
2020-01-16 06:33:35,271 - ERROR - Failed to convert node yolov3/yolov3_head/upsampled
OP=Upsample
Name=yolov3/yolov3_head/upsampled
Inputs:
yolov3/yolov3_head/Conv_7/LeakyRelu:0=LeakyRelu, [-1, -1, -1, 256], 1
yolov3/yolov3_head/upsampled/size_Concat__735:0=Concat, [2], 6
Outpus:
yolov3/yolov3_head/upsampled:0=[-1, -1, -1, 256], 1
Traceback (most recent call last):
File “/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tf2onnx/tfonnx.py”, line 354, in tensorflow_onnx_mapping
func(g, node, **kwargs)
File “/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tf2onnx/onnx_opset/nn.py”, line 640, in version_7
target_shape = node.inputs[1].get_tensor_value()
File “/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tf2onnx/graph.py”, line 260, in get_tensor_value
raise ValueError(“get tensor value: {} must be Const”.format(self.name))
ValueError: get tensor value: yolov3/yolov3_head/upsampled/size_Concat__735 must be Const
2020-01-16 06:33:35,479 - ERROR - Failed to convert node yolov3/yolov3_head/upsampled_1
OP=Upsample
Name=yolov3/yolov3_head/upsampled_1
Inputs:
yolov3/yolov3_head/Conv_15/LeakyRelu:0=LeakyRelu, [-1, -1, -1, 128], 1
yolov3/yolov3_head/upsampled_1/size_Concat__461:0=Concat, [2], 6
Outpus:
yolov3/yolov3_head/upsampled_1:0=[-1, -1, -1, 128], 1
Traceback (most recent call last):
File “/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tf2onnx/tfonnx.py”, line 354, in tensorflow_onnx_mapping
func(g, node, **kwargs)
File “/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tf2onnx/onnx_opset/nn.py”, line 640, in version_7
target_shape = node.inputs[1].get_tensor_value()
File “/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tf2onnx/graph.py”, line 260, in get_tensor_value
raise ValueError(“get tensor value: {} must be Const”.format(self.name))
ValueError: get tensor value: yolov3/yolov3_head/upsampled_1/size_Concat__461 must be Const
2020-01-16 06:33:36,324 - ERROR - Failed to convert node strided_slice_44
OP=StridedSlice
Name=strided_slice_44
Inputs:
Cast_4:0=Cast, [2], 1
strided_slice_44/stack:0=Const, [1], 6
strided_slice_44/stack_1:0=Const, [1], 6
strided_slice_44/stack_2:0=Const, [1], 6
Outpus:
strided_slice_44:0=[2], 1
Traceback (most recent call last):
File “/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tf2onnx/tfonnx.py”, line 354, in tensorflow_onnx_mapping
func(g, node, **kwargs)
File “/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tf2onnx/onnx_opset/tensor.py”, line 656, in version_1
raise ValueError(“StridedSlice: only strides=1 is supported”)
ValueError: StridedSlice: only strides=1 is supported
2020-01-16 06:33:36,325 - ERROR - Failed to convert node strided_slice_43
OP=StridedSlice
Name=strided_slice_43
Inputs:
Cast_4:0=Cast, [2], 1
strided_slice_43/stack:0=Const, [1], 6
strided_slice_43/stack_1:0=Const, [1], 6
strided_slice_43/stack_2:0=Const, [1], 6
Outpus:
strided_slice_43:0=[2], 1
Traceback (most recent call last):
File “/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tf2onnx/tfonnx.py”, line 354, in tensorflow_onnx_mapping
func(g, node, **kwargs)
File “/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tf2onnx/onnx_opset/tensor.py”, line 656, in version_1
raise ValueError(“StridedSlice: only strides=1 is supported”)
ValueError: StridedSlice: only strides=1 is supported
2020-01-16 06:33:36,480 - ERROR - Failed to convert node strided_slice_29
OP=StridedSlice
Name=strided_slice_29
Inputs:
Cast_2:0=Cast, [2], 1
strided_slice_29/stack:0=Const, [1], 6
strided_slice_29/stack_1:0=Const, [1], 6
strided_slice_29/stack_2:0=Const, [1], 6
Outpus:
strided_slice_29:0=[2], 1
Traceback (most recent call last):
File “/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tf2onnx/tfonnx.py”, line 354, in tensorflow_onnx_mapping
func(g, node, **kwargs)
File “/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tf2onnx/onnx_opset/tensor.py”, line 656, in version_1
raise ValueError(“StridedSlice: only strides=1 is supported”)
ValueError: StridedSlice: only strides=1 is supported
2020-01-16 06:33:36,481 - ERROR - Failed to convert node strided_slice_28
OP=StridedSlice
Name=strided_slice_28
Inputs:
Cast_2:0=Cast, [2], 1
strided_slice_28/stack:0=Const, [1], 6
strided_slice_28/stack_1:0=Const, [1], 6
strided_slice_28/stack_2:0=Const, [1], 6
Outpus:
strided_slice_28:0=[2], 1
Traceback (most recent call last):
File “/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tf2onnx/tfonnx.py”, line 354, in tensorflow_onnx_mapping
func(g, node, **kwargs)
File “/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tf2onnx/onnx_opset/tensor.py”, line 656, in version_1
raise ValueError(“StridedSlice: only strides=1 is supported”)
ValueError: StridedSlice: only strides=1 is supported
2020-01-16 06:33:36,685 - ERROR - Failed to convert node strided_slice_14
OP=StridedSlice
Name=strided_slice_14
Inputs:
Cast:0=Cast, [2], 1
strided_slice_14/stack:0=Const, [1], 6
strided_slice_14/stack_1:0=Const, [1], 6
strided_slice_14/stack_2:0=Const, [1], 6
Outpus:
strided_slice_14:0=[2], 1
Traceback (most recent call last):
File “/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tf2onnx/tfonnx.py”, line 354, in tensorflow_onnx_mapping
func(g, node, **kwargs)
File “/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tf2onnx/onnx_opset/tensor.py”, line 656, in version_1
raise ValueError(“StridedSlice: only strides=1 is supported”)
ValueError: StridedSlice: only strides=1 is supported
2020-01-16 06:33:36,685 - ERROR - Failed to convert node strided_slice_13
OP=StridedSlice
Name=strided_slice_13
Inputs:
Cast:0=Cast, [2], 1
strided_slice_13/stack:0=Const, [1], 6
strided_slice_13/stack_1:0=Const, [1], 6
strided_slice_13/stack_2:0=Const, [1], 6
Outpus:
strided_slice_13:0=[2], 1
Traceback (most recent call last):
File “/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tf2onnx/tfonnx.py”, line 354, in tensorflow_onnx_mapping
func(g, node, **kwargs)
File “/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tf2onnx/onnx_opset/tensor.py”, line 656, in version_1
raise ValueError(“StridedSlice: only strides=1 is supported”)
ValueError: StridedSlice: only strides=1 is supported
2020-01-16 06:33:36,701 - ERROR - Tensorflow op [combined_non_max_suppression/CombinedNonMaxSuppression: CombinedNonMaxSuppression] is not supported
2020-01-16 06:33:36,702 - ERROR - Unsupported ops: Counter({‘CombinedNonMaxSuppression’: 1})
Traceback (most recent call last):
File “/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/runpy.py”, line 193, in _run_module_as_main
main”, mod_spec)
File “/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/runpy.py”, line 85, in _run_code
exec(code, run_globals)
File “/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tf2onnx/convert.py”, line 161, in
main()
File “/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tf2onnx/convert.py”, line 145, in main
inputs_as_nchw=args.inputs_as_nchw)
File “/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tf2onnx/tfonnx.py”, line 577, in process_tf_graph
raise exceptions[0]
File “/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tf2onnx/tfonnx.py”, line 354, in tensorflow_onnx_mapping
func(g, node, **kwargs)
File “/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tf2onnx/onnx_opset/nn.py”, line 640, in version_7
target_shape = node.inputs[1].get_tensor_value()
File “/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tf2onnx/graph.py”, line 260, in get_tensor_value
raise ValueError(“get tensor value: {} must be Const”.format(self.name))
ValueError: get tensor value: yolov3/yolov3_head/upsampled/size_Concat__735 must be Const

Hi,

Could you please share the script and model file so we can help better?

Thanks

Hi SunijJB,

I re-trained a yolo3 with pytorch, still has error. 

Thx.
Michael

[TensorRT] ERROR: Network must have at least one output
Traceback (most recent call last):
File “run_onnx.py”, line 81, in
main()
File “run_onnx.py”, line 64, in main
with build_engine_onnx(onnx_model_file) as engine:
AttributeError: enter

@SunilJB,

Any updates?

BR,
Michael

Hi,

I am not able to access the code and model files, could you please send that as zip file attachment?

Thanks

@SunilJB

Hi, Could you download below code and onnx model? it is trained by pytorch & yolov3.when execute the inference code, error occur.
[TensorRT] ERROR: Network must have at least one output
Traceback (most recent call last):
File “run_onnx.py”, line 81, in
main()
File “run_onnx.py”, line 66, in main
with build_engine_onnx(onnx_model_file) as engine:
AttributeError: enter

https://michael.s3.cn-north-1.amazonaws.com.cn/run_onnx.py
https://michael.s3.cn-north-1.amazonaws.com.cn/michael_export.onnx

Hi,

I am getting “UnauthorizedAccess” error while accessing the above links.
Could you please upload your model and script file as zip file or to some third party drive so that it’s easily accessible?

Thanks

Hi @SunilJB, The graph can be printed as below:

graph torch-jit-export (
%input.1[FLOAT, 1x3x320x192]
) initializers (
%module_list.0.BatchNorm2d.bias[FLOAT, 32]
%module_list.0.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.0.BatchNorm2d.running_mean[FLOAT, 32]
%module_list.0.BatchNorm2d.running_var[FLOAT, 32]
%module_list.0.BatchNorm2d.weight[FLOAT, 32]
%module_list.0.Conv2d.weight[FLOAT, 32x3x3x3]
%module_list.1.BatchNorm2d.bias[FLOAT, 64]
%module_list.1.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.1.BatchNorm2d.running_mean[FLOAT, 64]
%module_list.1.BatchNorm2d.running_var[FLOAT, 64]
%module_list.1.BatchNorm2d.weight[FLOAT, 64]
%module_list.1.Conv2d.weight[FLOAT, 64x32x3x3]
%module_list.10.BatchNorm2d.bias[FLOAT, 128]
%module_list.10.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.10.BatchNorm2d.running_mean[FLOAT, 128]
%module_list.10.BatchNorm2d.running_var[FLOAT, 128]
%module_list.10.BatchNorm2d.weight[FLOAT, 128]
%module_list.10.Conv2d.weight[FLOAT, 128x64x3x3]
%module_list.100.Conv2d.bias[FLOAT, 18]
%module_list.100.Conv2d.weight[FLOAT, 18x512x1x1]
%module_list.103.BatchNorm2d.bias[FLOAT, 128]
%module_list.103.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.103.BatchNorm2d.running_mean[FLOAT, 128]
%module_list.103.BatchNorm2d.running_var[FLOAT, 128]
%module_list.103.BatchNorm2d.weight[FLOAT, 128]
%module_list.103.Conv2d.weight[FLOAT, 128x256x1x1]
%module_list.106.BatchNorm2d.bias[FLOAT, 128]
%module_list.106.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.106.BatchNorm2d.running_mean[FLOAT, 128]
%module_list.106.BatchNorm2d.running_var[FLOAT, 128]
%module_list.106.BatchNorm2d.weight[FLOAT, 128]
%module_list.106.Conv2d.weight[FLOAT, 128x384x1x1]
%module_list.107.BatchNorm2d.bias[FLOAT, 256]
%module_list.107.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.107.BatchNorm2d.running_mean[FLOAT, 256]
%module_list.107.BatchNorm2d.running_var[FLOAT, 256]
%module_list.107.BatchNorm2d.weight[FLOAT, 256]
%module_list.107.Conv2d.weight[FLOAT, 256x128x3x3]
%module_list.108.BatchNorm2d.bias[FLOAT, 128]
%module_list.108.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.108.BatchNorm2d.running_mean[FLOAT, 128]
%module_list.108.BatchNorm2d.running_var[FLOAT, 128]
%module_list.108.BatchNorm2d.weight[FLOAT, 128]
%module_list.108.Conv2d.weight[FLOAT, 128x256x1x1]
%module_list.109.BatchNorm2d.bias[FLOAT, 256]
%module_list.109.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.109.BatchNorm2d.running_mean[FLOAT, 256]
%module_list.109.BatchNorm2d.running_var[FLOAT, 256]
%module_list.109.BatchNorm2d.weight[FLOAT, 256]
%module_list.109.Conv2d.weight[FLOAT, 256x128x3x3]
%module_list.110.BatchNorm2d.bias[FLOAT, 128]
%module_list.110.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.110.BatchNorm2d.running_mean[FLOAT, 128]
%module_list.110.BatchNorm2d.running_var[FLOAT, 128]
%module_list.110.BatchNorm2d.weight[FLOAT, 128]
%module_list.110.Conv2d.weight[FLOAT, 128x256x1x1]
%module_list.111.BatchNorm2d.bias[FLOAT, 256]
%module_list.111.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.111.BatchNorm2d.running_mean[FLOAT, 256]
%module_list.111.BatchNorm2d.running_var[FLOAT, 256]
%module_list.111.BatchNorm2d.weight[FLOAT, 256]
%module_list.111.Conv2d.weight[FLOAT, 256x128x3x3]
%module_list.112.Conv2d.bias[FLOAT, 18]
%module_list.112.Conv2d.weight[FLOAT, 18x256x1x1]
%module_list.12.BatchNorm2d.bias[FLOAT, 256]
%module_list.12.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.12.BatchNorm2d.running_mean[FLOAT, 256]
%module_list.12.BatchNorm2d.running_var[FLOAT, 256]
%module_list.12.BatchNorm2d.weight[FLOAT, 256]
%module_list.12.Conv2d.weight[FLOAT, 256x128x3x3]
%module_list.13.BatchNorm2d.bias[FLOAT, 128]
%module_list.13.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.13.BatchNorm2d.running_mean[FLOAT, 128]
%module_list.13.BatchNorm2d.running_var[FLOAT, 128]
%module_list.13.BatchNorm2d.weight[FLOAT, 128]
%module_list.13.Conv2d.weight[FLOAT, 128x256x1x1]
%module_list.14.BatchNorm2d.bias[FLOAT, 256]
%module_list.14.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.14.BatchNorm2d.running_mean[FLOAT, 256]
%module_list.14.BatchNorm2d.running_var[FLOAT, 256]
%module_list.14.BatchNorm2d.weight[FLOAT, 256]
%module_list.14.Conv2d.weight[FLOAT, 256x128x3x3]
%module_list.16.BatchNorm2d.bias[FLOAT, 128]
%module_list.16.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.16.BatchNorm2d.running_mean[FLOAT, 128]
%module_list.16.BatchNorm2d.running_var[FLOAT, 128]
%module_list.16.BatchNorm2d.weight[FLOAT, 128]
%module_list.16.Conv2d.weight[FLOAT, 128x256x1x1]
%module_list.17.BatchNorm2d.bias[FLOAT, 256]
%module_list.17.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.17.BatchNorm2d.running_mean[FLOAT, 256]
%module_list.17.BatchNorm2d.running_var[FLOAT, 256]
%module_list.17.BatchNorm2d.weight[FLOAT, 256]
%module_list.17.Conv2d.weight[FLOAT, 256x128x3x3]
%module_list.19.BatchNorm2d.bias[FLOAT, 128]
%module_list.19.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.19.BatchNorm2d.running_mean[FLOAT, 128]
%module_list.19.BatchNorm2d.running_var[FLOAT, 128]
%module_list.19.BatchNorm2d.weight[FLOAT, 128]
%module_list.19.Conv2d.weight[FLOAT, 128x256x1x1]
%module_list.2.BatchNorm2d.bias[FLOAT, 32]
%module_list.2.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.2.BatchNorm2d.running_mean[FLOAT, 32]
%module_list.2.BatchNorm2d.running_var[FLOAT, 32]
%module_list.2.BatchNorm2d.weight[FLOAT, 32]
%module_list.2.Conv2d.weight[FLOAT, 32x64x1x1]
%module_list.20.BatchNorm2d.bias[FLOAT, 256]
%module_list.20.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.20.BatchNorm2d.running_mean[FLOAT, 256]
%module_list.20.BatchNorm2d.running_var[FLOAT, 256]
%module_list.20.BatchNorm2d.weight[FLOAT, 256]
%module_list.20.Conv2d.weight[FLOAT, 256x128x3x3]
%module_list.22.BatchNorm2d.bias[FLOAT, 128]
%module_list.22.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.22.BatchNorm2d.running_mean[FLOAT, 128]
%module_list.22.BatchNorm2d.running_var[FLOAT, 128]
%module_list.22.BatchNorm2d.weight[FLOAT, 128]
%module_list.22.Conv2d.weight[FLOAT, 128x256x1x1]
%module_list.23.BatchNorm2d.bias[FLOAT, 256]
%module_list.23.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.23.BatchNorm2d.running_mean[FLOAT, 256]
%module_list.23.BatchNorm2d.running_var[FLOAT, 256]
%module_list.23.BatchNorm2d.weight[FLOAT, 256]
%module_list.23.Conv2d.weight[FLOAT, 256x128x3x3]
%module_list.25.BatchNorm2d.bias[FLOAT, 128]
%module_list.25.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.25.BatchNorm2d.running_mean[FLOAT, 128]
%module_list.25.BatchNorm2d.running_var[FLOAT, 128]
%module_list.25.BatchNorm2d.weight[FLOAT, 128]
%module_list.25.Conv2d.weight[FLOAT, 128x256x1x1]
%module_list.26.BatchNorm2d.bias[FLOAT, 256]
%module_list.26.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.26.BatchNorm2d.running_mean[FLOAT, 256]
%module_list.26.BatchNorm2d.running_var[FLOAT, 256]
%module_list.26.BatchNorm2d.weight[FLOAT, 256]
%module_list.26.Conv2d.weight[FLOAT, 256x128x3x3]
%module_list.28.BatchNorm2d.bias[FLOAT, 128]
%module_list.28.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.28.BatchNorm2d.running_mean[FLOAT, 128]
%module_list.28.BatchNorm2d.running_var[FLOAT, 128]
%module_list.28.BatchNorm2d.weight[FLOAT, 128]
%module_list.28.Conv2d.weight[FLOAT, 128x256x1x1]
%module_list.29.BatchNorm2d.bias[FLOAT, 256]
%module_list.29.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.29.BatchNorm2d.running_mean[FLOAT, 256]
%module_list.29.BatchNorm2d.running_var[FLOAT, 256]
%module_list.29.BatchNorm2d.weight[FLOAT, 256]
%module_list.29.Conv2d.weight[FLOAT, 256x128x3x3]
%module_list.3.BatchNorm2d.bias[FLOAT, 64]
%module_list.3.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.3.BatchNorm2d.running_mean[FLOAT, 64]
%module_list.3.BatchNorm2d.running_var[FLOAT, 64]
%module_list.3.BatchNorm2d.weight[FLOAT, 64]
%module_list.3.Conv2d.weight[FLOAT, 64x32x3x3]
%module_list.31.BatchNorm2d.bias[FLOAT, 128]
%module_list.31.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.31.BatchNorm2d.running_mean[FLOAT, 128]
%module_list.31.BatchNorm2d.running_var[FLOAT, 128]
%module_list.31.BatchNorm2d.weight[FLOAT, 128]
%module_list.31.Conv2d.weight[FLOAT, 128x256x1x1]
%module_list.32.BatchNorm2d.bias[FLOAT, 256]
%module_list.32.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.32.BatchNorm2d.running_mean[FLOAT, 256]
%module_list.32.BatchNorm2d.running_var[FLOAT, 256]
%module_list.32.BatchNorm2d.weight[FLOAT, 256]
%module_list.32.Conv2d.weight[FLOAT, 256x128x3x3]
%module_list.34.BatchNorm2d.bias[FLOAT, 128]
%module_list.34.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.34.BatchNorm2d.running_mean[FLOAT, 128]
%module_list.34.BatchNorm2d.running_var[FLOAT, 128]
%module_list.34.BatchNorm2d.weight[FLOAT, 128]
%module_list.34.Conv2d.weight[FLOAT, 128x256x1x1]
%module_list.35.BatchNorm2d.bias[FLOAT, 256]
%module_list.35.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.35.BatchNorm2d.running_mean[FLOAT, 256]
%module_list.35.BatchNorm2d.running_var[FLOAT, 256]
%module_list.35.BatchNorm2d.weight[FLOAT, 256]
%module_list.35.Conv2d.weight[FLOAT, 256x128x3x3]
%module_list.37.BatchNorm2d.bias[FLOAT, 512]
%module_list.37.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.37.BatchNorm2d.running_mean[FLOAT, 512]
%module_list.37.BatchNorm2d.running_var[FLOAT, 512]
%module_list.37.BatchNorm2d.weight[FLOAT, 512]
%module_list.37.Conv2d.weight[FLOAT, 512x256x3x3]
%module_list.38.BatchNorm2d.bias[FLOAT, 256]
%module_list.38.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.38.BatchNorm2d.running_mean[FLOAT, 256]
%module_list.38.BatchNorm2d.running_var[FLOAT, 256]
%module_list.38.BatchNorm2d.weight[FLOAT, 256]
%module_list.38.Conv2d.weight[FLOAT, 256x512x1x1]
%module_list.39.BatchNorm2d.bias[FLOAT, 512]
%module_list.39.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.39.BatchNorm2d.running_mean[FLOAT, 512]
%module_list.39.BatchNorm2d.running_var[FLOAT, 512]
%module_list.39.BatchNorm2d.weight[FLOAT, 512]
%module_list.39.Conv2d.weight[FLOAT, 512x256x3x3]
%module_list.41.BatchNorm2d.bias[FLOAT, 256]
%module_list.41.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.41.BatchNorm2d.running_mean[FLOAT, 256]
%module_list.41.BatchNorm2d.running_var[FLOAT, 256]
%module_list.41.BatchNorm2d.weight[FLOAT, 256]
%module_list.41.Conv2d.weight[FLOAT, 256x512x1x1]
%module_list.42.BatchNorm2d.bias[FLOAT, 512]
%module_list.42.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.42.BatchNorm2d.running_mean[FLOAT, 512]
%module_list.42.BatchNorm2d.running_var[FLOAT, 512]
%module_list.42.BatchNorm2d.weight[FLOAT, 512]
%module_list.42.Conv2d.weight[FLOAT, 512x256x3x3]
%module_list.44.BatchNorm2d.bias[FLOAT, 256]
%module_list.44.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.44.BatchNorm2d.running_mean[FLOAT, 256]
%module_list.44.BatchNorm2d.running_var[FLOAT, 256]
%module_list.44.BatchNorm2d.weight[FLOAT, 256]
%module_list.44.Conv2d.weight[FLOAT, 256x512x1x1]
%module_list.45.BatchNorm2d.bias[FLOAT, 512]
%module_list.45.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.45.BatchNorm2d.running_mean[FLOAT, 512]
%module_list.45.BatchNorm2d.running_var[FLOAT, 512]
%module_list.45.BatchNorm2d.weight[FLOAT, 512]
%module_list.45.Conv2d.weight[FLOAT, 512x256x3x3]
%module_list.47.BatchNorm2d.bias[FLOAT, 256]
%module_list.47.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.47.BatchNorm2d.running_mean[FLOAT, 256]
%module_list.47.BatchNorm2d.running_var[FLOAT, 256]
%module_list.47.BatchNorm2d.weight[FLOAT, 256]
%module_list.47.Conv2d.weight[FLOAT, 256x512x1x1]
%module_list.48.BatchNorm2d.bias[FLOAT, 512]
%module_list.48.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.48.BatchNorm2d.running_mean[FLOAT, 512]
%module_list.48.BatchNorm2d.running_var[FLOAT, 512]
%module_list.48.BatchNorm2d.weight[FLOAT, 512]
%module_list.48.Conv2d.weight[FLOAT, 512x256x3x3]
%module_list.5.BatchNorm2d.bias[FLOAT, 128]
%module_list.5.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.5.BatchNorm2d.running_mean[FLOAT, 128]
%module_list.5.BatchNorm2d.running_var[FLOAT, 128]
%module_list.5.BatchNorm2d.weight[FLOAT, 128]
%module_list.5.Conv2d.weight[FLOAT, 128x64x3x3]
%module_list.50.BatchNorm2d.bias[FLOAT, 256]
%module_list.50.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.50.BatchNorm2d.running_mean[FLOAT, 256]
%module_list.50.BatchNorm2d.running_var[FLOAT, 256]
%module_list.50.BatchNorm2d.weight[FLOAT, 256]
%module_list.50.Conv2d.weight[FLOAT, 256x512x1x1]
%module_list.51.BatchNorm2d.bias[FLOAT, 512]
%module_list.51.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.51.BatchNorm2d.running_mean[FLOAT, 512]
%module_list.51.BatchNorm2d.running_var[FLOAT, 512]
%module_list.51.BatchNorm2d.weight[FLOAT, 512]
%module_list.51.Conv2d.weight[FLOAT, 512x256x3x3]
%module_list.53.BatchNorm2d.bias[FLOAT, 256]
%module_list.53.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.53.BatchNorm2d.running_mean[FLOAT, 256]
%module_list.53.BatchNorm2d.running_var[FLOAT, 256]
%module_list.53.BatchNorm2d.weight[FLOAT, 256]
%module_list.53.Conv2d.weight[FLOAT, 256x512x1x1]
%module_list.54.BatchNorm2d.bias[FLOAT, 512]
%module_list.54.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.54.BatchNorm2d.running_mean[FLOAT, 512]
%module_list.54.BatchNorm2d.running_var[FLOAT, 512]
%module_list.54.BatchNorm2d.weight[FLOAT, 512]
%module_list.54.Conv2d.weight[FLOAT, 512x256x3x3]
%module_list.56.BatchNorm2d.bias[FLOAT, 256]
%module_list.56.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.56.BatchNorm2d.running_mean[FLOAT, 256]
%module_list.56.BatchNorm2d.running_var[FLOAT, 256]
%module_list.56.BatchNorm2d.weight[FLOAT, 256]
%module_list.56.Conv2d.weight[FLOAT, 256x512x1x1]
%module_list.57.BatchNorm2d.bias[FLOAT, 512]
%module_list.57.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.57.BatchNorm2d.running_mean[FLOAT, 512]
%module_list.57.BatchNorm2d.running_var[FLOAT, 512]
%module_list.57.BatchNorm2d.weight[FLOAT, 512]
%module_list.57.Conv2d.weight[FLOAT, 512x256x3x3]
%module_list.59.BatchNorm2d.bias[FLOAT, 256]
%module_list.59.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.59.BatchNorm2d.running_mean[FLOAT, 256]
%module_list.59.BatchNorm2d.running_var[FLOAT, 256]
%module_list.59.BatchNorm2d.weight[FLOAT, 256]
%module_list.59.Conv2d.weight[FLOAT, 256x512x1x1]
%module_list.6.BatchNorm2d.bias[FLOAT, 64]
%module_list.6.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.6.BatchNorm2d.running_mean[FLOAT, 64]
%module_list.6.BatchNorm2d.running_var[FLOAT, 64]
%module_list.6.BatchNorm2d.weight[FLOAT, 64]
%module_list.6.Conv2d.weight[FLOAT, 64x128x1x1]
%module_list.60.BatchNorm2d.bias[FLOAT, 512]
%module_list.60.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.60.BatchNorm2d.running_mean[FLOAT, 512]
%module_list.60.BatchNorm2d.running_var[FLOAT, 512]
%module_list.60.BatchNorm2d.weight[FLOAT, 512]
%module_list.60.Conv2d.weight[FLOAT, 512x256x3x3]
%module_list.62.BatchNorm2d.bias[FLOAT, 1024]
%module_list.62.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.62.BatchNorm2d.running_mean[FLOAT, 1024]
%module_list.62.BatchNorm2d.running_var[FLOAT, 1024]
%module_list.62.BatchNorm2d.weight[FLOAT, 1024]
%module_list.62.Conv2d.weight[FLOAT, 1024x512x3x3]
%module_list.63.BatchNorm2d.bias[FLOAT, 512]
%module_list.63.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.63.BatchNorm2d.running_mean[FLOAT, 512]
%module_list.63.BatchNorm2d.running_var[FLOAT, 512]
%module_list.63.BatchNorm2d.weight[FLOAT, 512]
%module_list.63.Conv2d.weight[FLOAT, 512x1024x1x1]
%module_list.64.BatchNorm2d.bias[FLOAT, 1024]
%module_list.64.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.64.BatchNorm2d.running_mean[FLOAT, 1024]
%module_list.64.BatchNorm2d.running_var[FLOAT, 1024]
%module_list.64.BatchNorm2d.weight[FLOAT, 1024]
%module_list.64.Conv2d.weight[FLOAT, 1024x512x3x3]
%module_list.66.BatchNorm2d.bias[FLOAT, 512]
%module_list.66.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.66.BatchNorm2d.running_mean[FLOAT, 512]
%module_list.66.BatchNorm2d.running_var[FLOAT, 512]
%module_list.66.BatchNorm2d.weight[FLOAT, 512]
%module_list.66.Conv2d.weight[FLOAT, 512x1024x1x1]
%module_list.67.BatchNorm2d.bias[FLOAT, 1024]
%module_list.67.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.67.BatchNorm2d.running_mean[FLOAT, 1024]
%module_list.67.BatchNorm2d.running_var[FLOAT, 1024]
%module_list.67.BatchNorm2d.weight[FLOAT, 1024]
%module_list.67.Conv2d.weight[FLOAT, 1024x512x3x3]
%module_list.69.BatchNorm2d.bias[FLOAT, 512]
%module_list.69.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.69.BatchNorm2d.running_mean[FLOAT, 512]
%module_list.69.BatchNorm2d.running_var[FLOAT, 512]
%module_list.69.BatchNorm2d.weight[FLOAT, 512]
%module_list.69.Conv2d.weight[FLOAT, 512x1024x1x1]
%module_list.7.BatchNorm2d.bias[FLOAT, 128]
%module_list.7.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.7.BatchNorm2d.running_mean[FLOAT, 128]
%module_list.7.BatchNorm2d.running_var[FLOAT, 128]
%module_list.7.BatchNorm2d.weight[FLOAT, 128]
%module_list.7.Conv2d.weight[FLOAT, 128x64x3x3]
%module_list.70.BatchNorm2d.bias[FLOAT, 1024]
%module_list.70.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.70.BatchNorm2d.running_mean[FLOAT, 1024]
%module_list.70.BatchNorm2d.running_var[FLOAT, 1024]
%module_list.70.BatchNorm2d.weight[FLOAT, 1024]
%module_list.70.Conv2d.weight[FLOAT, 1024x512x3x3]
%module_list.72.BatchNorm2d.bias[FLOAT, 512]
%module_list.72.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.72.BatchNorm2d.running_mean[FLOAT, 512]
%module_list.72.BatchNorm2d.running_var[FLOAT, 512]
%module_list.72.BatchNorm2d.weight[FLOAT, 512]
%module_list.72.Conv2d.weight[FLOAT, 512x1024x1x1]
%module_list.73.BatchNorm2d.bias[FLOAT, 1024]
%module_list.73.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.73.BatchNorm2d.running_mean[FLOAT, 1024]
%module_list.73.BatchNorm2d.running_var[FLOAT, 1024]
%module_list.73.BatchNorm2d.weight[FLOAT, 1024]
%module_list.73.Conv2d.weight[FLOAT, 1024x512x3x3]
%module_list.75.BatchNorm2d.bias[FLOAT, 512]
%module_list.75.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.75.BatchNorm2d.running_mean[FLOAT, 512]
%module_list.75.BatchNorm2d.running_var[FLOAT, 512]
%module_list.75.BatchNorm2d.weight[FLOAT, 512]
%module_list.75.Conv2d.weight[FLOAT, 512x1024x1x1]
%module_list.76.BatchNorm2d.bias[FLOAT, 1024]
%module_list.76.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.76.BatchNorm2d.running_mean[FLOAT, 1024]
%module_list.76.BatchNorm2d.running_var[FLOAT, 1024]
%module_list.76.BatchNorm2d.weight[FLOAT, 1024]
%module_list.76.Conv2d.weight[FLOAT, 1024x512x3x3]
%module_list.77.BatchNorm2d.bias[FLOAT, 512]
%module_list.77.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.77.BatchNorm2d.running_mean[FLOAT, 512]
%module_list.77.BatchNorm2d.running_var[FLOAT, 512]
%module_list.77.BatchNorm2d.weight[FLOAT, 512]
%module_list.77.Conv2d.weight[FLOAT, 512x1024x1x1]
%module_list.84.BatchNorm2d.bias[FLOAT, 512]
%module_list.84.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.84.BatchNorm2d.running_mean[FLOAT, 512]
%module_list.84.BatchNorm2d.running_var[FLOAT, 512]
%module_list.84.BatchNorm2d.weight[FLOAT, 512]
%module_list.84.Conv2d.weight[FLOAT, 512x2048x1x1]
%module_list.85.BatchNorm2d.bias[FLOAT, 1024]
%module_list.85.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.85.BatchNorm2d.running_mean[FLOAT, 1024]
%module_list.85.BatchNorm2d.running_var[FLOAT, 1024]
%module_list.85.BatchNorm2d.weight[FLOAT, 1024]
%module_list.85.Conv2d.weight[FLOAT, 1024x512x3x3]
%module_list.86.BatchNorm2d.bias[FLOAT, 512]
%module_list.86.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.86.BatchNorm2d.running_mean[FLOAT, 512]
%module_list.86.BatchNorm2d.running_var[FLOAT, 512]
%module_list.86.BatchNorm2d.weight[FLOAT, 512]
%module_list.86.Conv2d.weight[FLOAT, 512x1024x1x1]
%module_list.87.BatchNorm2d.bias[FLOAT, 1024]
%module_list.87.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.87.BatchNorm2d.running_mean[FLOAT, 1024]
%module_list.87.BatchNorm2d.running_var[FLOAT, 1024]
%module_list.87.BatchNorm2d.weight[FLOAT, 1024]
%module_list.87.Conv2d.weight[FLOAT, 1024x512x3x3]
%module_list.88.Conv2d.bias[FLOAT, 18]
%module_list.88.Conv2d.weight[FLOAT, 18x1024x1x1]
%module_list.9.BatchNorm2d.bias[FLOAT, 64]
%module_list.9.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.9.BatchNorm2d.running_mean[FLOAT, 64]
%module_list.9.BatchNorm2d.running_var[FLOAT, 64]
%module_list.9.BatchNorm2d.weight[FLOAT, 64]
%module_list.9.Conv2d.weight[FLOAT, 64x128x1x1]
%module_list.91.BatchNorm2d.bias[FLOAT, 256]
%module_list.91.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.91.BatchNorm2d.running_mean[FLOAT, 256]
%module_list.91.BatchNorm2d.running_var[FLOAT, 256]
%module_list.91.BatchNorm2d.weight[FLOAT, 256]
%module_list.91.Conv2d.weight[FLOAT, 256x512x1x1]
%module_list.94.BatchNorm2d.bias[FLOAT, 256]
%module_list.94.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.94.BatchNorm2d.running_mean[FLOAT, 256]
%module_list.94.BatchNorm2d.running_var[FLOAT, 256]
%module_list.94.BatchNorm2d.weight[FLOAT, 256]
%module_list.94.Conv2d.weight[FLOAT, 256x768x1x1]
%module_list.95.BatchNorm2d.bias[FLOAT, 512]
%module_list.95.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.95.BatchNorm2d.running_mean[FLOAT, 512]
%module_list.95.BatchNorm2d.running_var[FLOAT, 512]
%module_list.95.BatchNorm2d.weight[FLOAT, 512]
%module_list.95.Conv2d.weight[FLOAT, 512x256x3x3]
%module_list.96.BatchNorm2d.bias[FLOAT, 256]
%module_list.96.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.96.BatchNorm2d.running_mean[FLOAT, 256]
%module_list.96.BatchNorm2d.running_var[FLOAT, 256]
%module_list.96.BatchNorm2d.weight[FLOAT, 256]
%module_list.96.Conv2d.weight[FLOAT, 256x512x1x1]
%module_list.97.BatchNorm2d.bias[FLOAT, 512]
%module_list.97.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.97.BatchNorm2d.running_mean[FLOAT, 512]
%module_list.97.BatchNorm2d.running_var[FLOAT, 512]
%module_list.97.BatchNorm2d.weight[FLOAT, 512]
%module_list.97.Conv2d.weight[FLOAT, 512x256x3x3]
%module_list.98.BatchNorm2d.bias[FLOAT, 256]
%module_list.98.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.98.BatchNorm2d.running_mean[FLOAT, 256]
%module_list.98.BatchNorm2d.running_var[FLOAT, 256]
%module_list.98.BatchNorm2d.weight[FLOAT, 256]
%module_list.98.Conv2d.weight[FLOAT, 256x512x1x1]
%module_list.99.BatchNorm2d.bias[FLOAT, 512]
%module_list.99.BatchNorm2d.num_batches_tracked[INT64, scalar]
%module_list.99.BatchNorm2d.running_mean[FLOAT, 512]
%module_list.99.BatchNorm2d.running_var[FLOAT, 512]
%module_list.99.BatchNorm2d.weight[FLOAT, 512]
%module_list.99.Conv2d.weight[FLOAT, 512x256x3x3]
) {
%445 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%input.1, %module_list.0.Conv2d.weight)
%446 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%445, %module_list.0.BatchNorm2d.weight, %module_list.0.BatchNorm2d.bias, %module_list.0.BatchNorm2d.running_mean, %module_list.0.BatchNorm2d.running_var)
%447 = LeakyRelualpha = 0.100000001490116
%448 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [2, 2]](%447, %module_list.1.Conv2d.weight)
%449 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%448, %module_list.1.BatchNorm2d.weight, %module_list.1.BatchNorm2d.bias, %module_list.1.BatchNorm2d.running_mean, %module_list.1.BatchNorm2d.running_var)
%450 = LeakyRelualpha = 0.100000001490116
%451 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%450, %module_list.2.Conv2d.weight)
%452 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%451, %module_list.2.BatchNorm2d.weight, %module_list.2.BatchNorm2d.bias, %module_list.2.BatchNorm2d.running_mean, %module_list.2.BatchNorm2d.running_var)
%453 = LeakyRelualpha = 0.100000001490116
%454 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%453, %module_list.3.Conv2d.weight)
%455 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%454, %module_list.3.BatchNorm2d.weight, %module_list.3.BatchNorm2d.bias, %module_list.3.BatchNorm2d.running_mean, %module_list.3.BatchNorm2d.running_var)
%456 = LeakyRelualpha = 0.100000001490116
%457 = Add(%456, %450)
%458 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [2, 2]](%457, %module_list.5.Conv2d.weight)
%459 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%458, %module_list.5.BatchNorm2d.weight, %module_list.5.BatchNorm2d.bias, %module_list.5.BatchNorm2d.running_mean, %module_list.5.BatchNorm2d.running_var)
%460 = LeakyRelualpha = 0.100000001490116
%461 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%460, %module_list.6.Conv2d.weight)
%462 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%461, %module_list.6.BatchNorm2d.weight, %module_list.6.BatchNorm2d.bias, %module_list.6.BatchNorm2d.running_mean, %module_list.6.BatchNorm2d.running_var)
%463 = LeakyRelualpha = 0.100000001490116
%464 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%463, %module_list.7.Conv2d.weight)
%465 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%464, %module_list.7.BatchNorm2d.weight, %module_list.7.BatchNorm2d.bias, %module_list.7.BatchNorm2d.running_mean, %module_list.7.BatchNorm2d.running_var)
%466 = LeakyRelualpha = 0.100000001490116
%467 = Add(%466, %460)
%468 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%467, %module_list.9.Conv2d.weight)
%469 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%468, %module_list.9.BatchNorm2d.weight, %module_list.9.BatchNorm2d.bias, %module_list.9.BatchNorm2d.running_mean, %module_list.9.BatchNorm2d.running_var)
%470 = LeakyRelualpha = 0.100000001490116
%471 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%470, %module_list.10.Conv2d.weight)
%472 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%471, %module_list.10.BatchNorm2d.weight, %module_list.10.BatchNorm2d.bias, %module_list.10.BatchNorm2d.running_mean, %module_list.10.BatchNorm2d.running_var)
%473 = LeakyRelualpha = 0.100000001490116
%474 = Add(%473, %467)
%475 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [2, 2]](%474, %module_list.12.Conv2d.weight)
%476 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%475, %module_list.12.BatchNorm2d.weight, %module_list.12.BatchNorm2d.bias, %module_list.12.BatchNorm2d.running_mean, %module_list.12.BatchNorm2d.running_var)
%477 = LeakyRelualpha = 0.100000001490116
%478 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%477, %module_list.13.Conv2d.weight)
%479 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%478, %module_list.13.BatchNorm2d.weight, %module_list.13.BatchNorm2d.bias, %module_list.13.BatchNorm2d.running_mean, %module_list.13.BatchNorm2d.running_var)
%480 = LeakyRelualpha = 0.100000001490116
%481 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%480, %module_list.14.Conv2d.weight)
%482 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%481, %module_list.14.BatchNorm2d.weight, %module_list.14.BatchNorm2d.bias, %module_list.14.BatchNorm2d.running_mean, %module_list.14.BatchNorm2d.running_var)
%483 = LeakyRelualpha = 0.100000001490116
%484 = Add(%483, %477)
%485 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%484, %module_list.16.Conv2d.weight)
%486 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%485, %module_list.16.BatchNorm2d.weight, %module_list.16.BatchNorm2d.bias, %module_list.16.BatchNorm2d.running_mean, %module_list.16.BatchNorm2d.running_var)
%487 = LeakyRelualpha = 0.100000001490116
%488 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%487, %module_list.17.Conv2d.weight)
%489 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%488, %module_list.17.BatchNorm2d.weight, %module_list.17.BatchNorm2d.bias, %module_list.17.BatchNorm2d.running_mean, %module_list.17.BatchNorm2d.running_var)
%490 = LeakyRelualpha = 0.100000001490116
%491 = Add(%490, %484)
%492 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%491, %module_list.19.Conv2d.weight)
%493 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%492, %module_list.19.BatchNorm2d.weight, %module_list.19.BatchNorm2d.bias, %module_list.19.BatchNorm2d.running_mean, %module_list.19.BatchNorm2d.running_var)
%494 = LeakyRelualpha = 0.100000001490116
%495 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%494, %module_list.20.Conv2d.weight)
%496 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%495, %module_list.20.BatchNorm2d.weight, %module_list.20.BatchNorm2d.bias, %module_list.20.BatchNorm2d.running_mean, %module_list.20.BatchNorm2d.running_var)
%497 = LeakyRelualpha = 0.100000001490116
%498 = Add(%497, %491)
%499 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%498, %module_list.22.Conv2d.weight)
%500 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%499, %module_list.22.BatchNorm2d.weight, %module_list.22.BatchNorm2d.bias, %module_list.22.BatchNorm2d.running_mean, %module_list.22.BatchNorm2d.running_var)
%501 = LeakyRelualpha = 0.100000001490116
%502 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%501, %module_list.23.Conv2d.weight)
%503 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%502, %module_list.23.BatchNorm2d.weight, %module_list.23.BatchNorm2d.bias, %module_list.23.BatchNorm2d.running_mean, %module_list.23.BatchNorm2d.running_var)
%504 = LeakyRelualpha = 0.100000001490116
%505 = Add(%504, %498)
%506 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%505, %module_list.25.Conv2d.weight)
%507 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%506, %module_list.25.BatchNorm2d.weight, %module_list.25.BatchNorm2d.bias, %module_list.25.BatchNorm2d.running_mean, %module_list.25.BatchNorm2d.running_var)
%508 = LeakyRelualpha = 0.100000001490116
%509 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%508, %module_list.26.Conv2d.weight)
%510 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%509, %module_list.26.BatchNorm2d.weight, %module_list.26.BatchNorm2d.bias, %module_list.26.BatchNorm2d.running_mean, %module_list.26.BatchNorm2d.running_var)
%511 = LeakyRelualpha = 0.100000001490116
%512 = Add(%511, %505)
%513 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%512, %module_list.28.Conv2d.weight)
%514 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%513, %module_list.28.BatchNorm2d.weight, %module_list.28.BatchNorm2d.bias, %module_list.28.BatchNorm2d.running_mean, %module_list.28.BatchNorm2d.running_var)
%515 = LeakyRelualpha = 0.100000001490116
%516 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%515, %module_list.29.Conv2d.weight)
%517 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%516, %module_list.29.BatchNorm2d.weight, %module_list.29.BatchNorm2d.bias, %module_list.29.BatchNorm2d.running_mean, %module_list.29.BatchNorm2d.running_var)
%518 = LeakyRelualpha = 0.100000001490116
%519 = Add(%518, %512)
%520 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%519, %module_list.31.Conv2d.weight)
%521 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%520, %module_list.31.BatchNorm2d.weight, %module_list.31.BatchNorm2d.bias, %module_list.31.BatchNorm2d.running_mean, %module_list.31.BatchNorm2d.running_var)
%522 = LeakyRelualpha = 0.100000001490116
%523 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%522, %module_list.32.Conv2d.weight)
%524 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%523, %module_list.32.BatchNorm2d.weight, %module_list.32.BatchNorm2d.bias, %module_list.32.BatchNorm2d.running_mean, %module_list.32.BatchNorm2d.running_var)
%525 = LeakyRelualpha = 0.100000001490116
%526 = Add(%525, %519)
%527 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%526, %module_list.34.Conv2d.weight)
%528 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%527, %module_list.34.BatchNorm2d.weight, %module_list.34.BatchNorm2d.bias, %module_list.34.BatchNorm2d.running_mean, %module_list.34.BatchNorm2d.running_var)
%529 = LeakyRelualpha = 0.100000001490116
%530 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%529, %module_list.35.Conv2d.weight)
%531 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%530, %module_list.35.BatchNorm2d.weight, %module_list.35.BatchNorm2d.bias, %module_list.35.BatchNorm2d.running_mean, %module_list.35.BatchNorm2d.running_var)
%532 = LeakyRelualpha = 0.100000001490116
%533 = Add(%532, %526)
%534 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [2, 2]](%533, %module_list.37.Conv2d.weight)
%535 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%534, %module_list.37.BatchNorm2d.weight, %module_list.37.BatchNorm2d.bias, %module_list.37.BatchNorm2d.running_mean, %module_list.37.BatchNorm2d.running_var)
%536 = LeakyRelualpha = 0.100000001490116
%537 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%536, %module_list.38.Conv2d.weight)
%538 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%537, %module_list.38.BatchNorm2d.weight, %module_list.38.BatchNorm2d.bias, %module_list.38.BatchNorm2d.running_mean, %module_list.38.BatchNorm2d.running_var)
%539 = LeakyRelualpha = 0.100000001490116
%540 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%539, %module_list.39.Conv2d.weight)
%541 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%540, %module_list.39.BatchNorm2d.weight, %module_list.39.BatchNorm2d.bias, %module_list.39.BatchNorm2d.running_mean, %module_list.39.BatchNorm2d.running_var)
%542 = LeakyRelualpha = 0.100000001490116
%543 = Add(%542, %536)
%544 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%543, %module_list.41.Conv2d.weight)
%545 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%544, %module_list.41.BatchNorm2d.weight, %module_list.41.BatchNorm2d.bias, %module_list.41.BatchNorm2d.running_mean, %module_list.41.BatchNorm2d.running_var)
%546 = LeakyRelualpha = 0.100000001490116
%547 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%546, %module_list.42.Conv2d.weight)
%548 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%547, %module_list.42.BatchNorm2d.weight, %module_list.42.BatchNorm2d.bias, %module_list.42.BatchNorm2d.running_mean, %module_list.42.BatchNorm2d.running_var)
%549 = LeakyRelualpha = 0.100000001490116
%550 = Add(%549, %543)
%551 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%550, %module_list.44.Conv2d.weight)
%552 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%551, %module_list.44.BatchNorm2d.weight, %module_list.44.BatchNorm2d.bias, %module_list.44.BatchNorm2d.running_mean, %module_list.44.BatchNorm2d.running_var)
%553 = LeakyRelualpha = 0.100000001490116
%554 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%553, %module_list.45.Conv2d.weight)
%555 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%554, %module_list.45.BatchNorm2d.weight, %module_list.45.BatchNorm2d.bias, %module_list.45.BatchNorm2d.running_mean, %module_list.45.BatchNorm2d.running_var)
%556 = LeakyRelualpha = 0.100000001490116
%557 = Add(%556, %550)
%558 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%557, %module_list.47.Conv2d.weight)
%559 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%558, %module_list.47.BatchNorm2d.weight, %module_list.47.BatchNorm2d.bias, %module_list.47.BatchNorm2d.running_mean, %module_list.47.BatchNorm2d.running_var)
%560 = LeakyRelualpha = 0.100000001490116
%561 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%560, %module_list.48.Conv2d.weight)
%562 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%561, %module_list.48.BatchNorm2d.weight, %module_list.48.BatchNorm2d.bias, %module_list.48.BatchNorm2d.running_mean, %module_list.48.BatchNorm2d.running_var)
%563 = LeakyRelualpha = 0.100000001490116
%564 = Add(%563, %557)
%565 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%564, %module_list.50.Conv2d.weight)
%566 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%565, %module_list.50.BatchNorm2d.weight, %module_list.50.BatchNorm2d.bias, %module_list.50.BatchNorm2d.running_mean, %module_list.50.BatchNorm2d.running_var)
%567 = LeakyRelualpha = 0.100000001490116
%568 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%567, %module_list.51.Conv2d.weight)
%569 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%568, %module_list.51.BatchNorm2d.weight, %module_list.51.BatchNorm2d.bias, %module_list.51.BatchNorm2d.running_mean, %module_list.51.BatchNorm2d.running_var)
%570 = LeakyRelualpha = 0.100000001490116
%571 = Add(%570, %564)
%572 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%571, %module_list.53.Conv2d.weight)
%573 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%572, %module_list.53.BatchNorm2d.weight, %module_list.53.BatchNorm2d.bias, %module_list.53.BatchNorm2d.running_mean, %module_list.53.BatchNorm2d.running_var)
%574 = LeakyRelualpha = 0.100000001490116
%575 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%574, %module_list.54.Conv2d.weight)
%576 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%575, %module_list.54.BatchNorm2d.weight, %module_list.54.BatchNorm2d.bias, %module_list.54.BatchNorm2d.running_mean, %module_list.54.BatchNorm2d.running_var)
%577 = LeakyRelualpha = 0.100000001490116
%578 = Add(%577, %571)
%579 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%578, %module_list.56.Conv2d.weight)
%580 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%579, %module_list.56.BatchNorm2d.weight, %module_list.56.BatchNorm2d.bias, %module_list.56.BatchNorm2d.running_mean, %module_list.56.BatchNorm2d.running_var)
%581 = LeakyRelualpha = 0.100000001490116
%582 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%581, %module_list.57.Conv2d.weight)
%583 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%582, %module_list.57.BatchNorm2d.weight, %module_list.57.BatchNorm2d.bias, %module_list.57.BatchNorm2d.running_mean, %module_list.57.BatchNorm2d.running_var)
%584 = LeakyRelualpha = 0.100000001490116
%585 = Add(%584, %578)
%586 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%585, %module_list.59.Conv2d.weight)
%587 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%586, %module_list.59.BatchNorm2d.weight, %module_list.59.BatchNorm2d.bias, %module_list.59.BatchNorm2d.running_mean, %module_list.59.BatchNorm2d.running_var)
%588 = LeakyRelualpha = 0.100000001490116
%589 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%588, %module_list.60.Conv2d.weight)
%590 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%589, %module_list.60.BatchNorm2d.weight, %module_list.60.BatchNorm2d.bias, %module_list.60.BatchNorm2d.running_mean, %module_list.60.BatchNorm2d.running_var)
%591 = LeakyRelualpha = 0.100000001490116
%592 = Add(%591, %585)
%593 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [2, 2]](%592, %module_list.62.Conv2d.weight)
%594 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%593, %module_list.62.BatchNorm2d.weight, %module_list.62.BatchNorm2d.bias, %module_list.62.BatchNorm2d.running_mean, %module_list.62.BatchNorm2d.running_var)
%595 = LeakyRelualpha = 0.100000001490116
%596 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%595, %module_list.63.Conv2d.weight)
%597 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%596, %module_list.63.BatchNorm2d.weight, %module_list.63.BatchNorm2d.bias, %module_list.63.BatchNorm2d.running_mean, %module_list.63.BatchNorm2d.running_var)
%598 = LeakyRelualpha = 0.100000001490116
%599 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%598, %module_list.64.Conv2d.weight)
%600 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%599, %module_list.64.BatchNorm2d.weight, %module_list.64.BatchNorm2d.bias, %module_list.64.BatchNorm2d.running_mean, %module_list.64.BatchNorm2d.running_var)
%601 = LeakyRelualpha = 0.100000001490116
%602 = Add(%601, %595)
%603 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%602, %module_list.66.Conv2d.weight)
%604 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%603, %module_list.66.BatchNorm2d.weight, %module_list.66.BatchNorm2d.bias, %module_list.66.BatchNorm2d.running_mean, %module_list.66.BatchNorm2d.running_var)
%605 = LeakyRelualpha = 0.100000001490116
%606 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%605, %module_list.67.Conv2d.weight)
%607 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%606, %module_list.67.BatchNorm2d.weight, %module_list.67.BatchNorm2d.bias, %module_list.67.BatchNorm2d.running_mean, %module_list.67.BatchNorm2d.running_var)
%608 = LeakyRelualpha = 0.100000001490116
%609 = Add(%608, %602)
%610 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%609, %module_list.69.Conv2d.weight)
%611 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%610, %module_list.69.BatchNorm2d.weight, %module_list.69.BatchNorm2d.bias, %module_list.69.BatchNorm2d.running_mean, %module_list.69.BatchNorm2d.running_var)
%612 = LeakyRelualpha = 0.100000001490116
%613 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%612, %module_list.70.Conv2d.weight)
%614 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%613, %module_list.70.BatchNorm2d.weight, %module_list.70.BatchNorm2d.bias, %module_list.70.BatchNorm2d.running_mean, %module_list.70.BatchNorm2d.running_var)
%615 = LeakyRelualpha = 0.100000001490116
%616 = Add(%615, %609)
%617 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%616, %module_list.72.Conv2d.weight)
%618 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%617, %module_list.72.BatchNorm2d.weight, %module_list.72.BatchNorm2d.bias, %module_list.72.BatchNorm2d.running_mean, %module_list.72.BatchNorm2d.running_var)
%619 = LeakyRelualpha = 0.100000001490116
%620 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%619, %module_list.73.Conv2d.weight)
%621 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%620, %module_list.73.BatchNorm2d.weight, %module_list.73.BatchNorm2d.bias, %module_list.73.BatchNorm2d.running_mean, %module_list.73.BatchNorm2d.running_var)
%622 = LeakyRelualpha = 0.100000001490116
%623 = Add(%622, %616)
%624 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%623, %module_list.75.Conv2d.weight)
%625 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%624, %module_list.75.BatchNorm2d.weight, %module_list.75.BatchNorm2d.bias, %module_list.75.BatchNorm2d.running_mean, %module_list.75.BatchNorm2d.running_var)
%626 = LeakyRelualpha = 0.100000001490116
%627 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%626, %module_list.76.Conv2d.weight)
%628 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%627, %module_list.76.BatchNorm2d.weight, %module_list.76.BatchNorm2d.bias, %module_list.76.BatchNorm2d.running_mean, %module_list.76.BatchNorm2d.running_var)
%629 = LeakyRelualpha = 0.100000001490116
%630 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%629, %module_list.77.Conv2d.weight)
%631 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%630, %module_list.77.BatchNorm2d.weight, %module_list.77.BatchNorm2d.bias, %module_list.77.BatchNorm2d.running_mean, %module_list.77.BatchNorm2d.running_var)
%632 = LeakyRelualpha = 0.100000001490116
%633 = MaxPoolceil_mode = 0, kernel_shape = [5, 5], pads = [2, 2, 2, 2], strides = [1, 1]
%634 = MaxPoolceil_mode = 0, kernel_shape = [9, 9], pads = [4, 4, 4, 4], strides = [1, 1]
%635 = MaxPoolceil_mode = 0, kernel_shape = [13, 13], pads = [6, 6, 6, 6], strides = [1, 1]
%636 = Concat[axis = 1](%635, %634, %633, %632)
%637 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%636, %module_list.84.Conv2d.weight)
%638 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%637, %module_list.84.BatchNorm2d.weight, %module_list.84.BatchNorm2d.bias, %module_list.84.BatchNorm2d.running_mean, %module_list.84.BatchNorm2d.running_var)
%639 = LeakyRelualpha = 0.100000001490116
%640 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%639, %module_list.85.Conv2d.weight)
%641 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%640, %module_list.85.BatchNorm2d.weight, %module_list.85.BatchNorm2d.bias, %module_list.85.BatchNorm2d.running_mean, %module_list.85.BatchNorm2d.running_var)
%642 = LeakyRelualpha = 0.100000001490116
%643 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%642, %module_list.86.Conv2d.weight)
%644 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%643, %module_list.86.BatchNorm2d.weight, %module_list.86.BatchNorm2d.bias, %module_list.86.BatchNorm2d.running_mean, %module_list.86.BatchNorm2d.running_var)
%645 = LeakyRelualpha = 0.100000001490116
%646 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%645, %module_list.87.Conv2d.weight)
%647 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%646, %module_list.87.BatchNorm2d.weight, %module_list.87.BatchNorm2d.bias, %module_list.87.BatchNorm2d.running_mean, %module_list.87.BatchNorm2d.running_var)
%648 = LeakyRelualpha = 0.100000001490116
%649 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%648, %module_list.88.Conv2d.weight, %module_list.88.Conv2d.bias)
%650 = Constantvalue =
%651 = Reshape(%649, %650)
%652 = Transposeperm = [0, 1, 3, 4, 2]
%653 = Constantvalue =
%654 = Reshape(%652, %653)
%655 = Constantvalue =
%656 = Constantvalue =
%657 = Constantvalue =
%658 = Constantvalue =
%659 = Slice(%654, %656, %657, %655, %658)
%660 = Sigmoid(%659)
%661 = Constantvalue =
%662 = Add(%660, %661)
%663 = Constantvalue =
%664 = Constantvalue =
%665 = Constantvalue =
%666 = Constantvalue =
%667 = Slice(%654, %664, %665, %663, %666)
%668 = Exp(%667)
%669 = Constantvalue =
%670 = Mul(%668, %669)
%671 = Constantvalue =
%672 = Constantvalue =
%673 = Constantvalue =
%674 = Constantvalue =
%675 = Slice(%654, %672, %673, %671, %674)
%676 = Sigmoid(%675)
%677 = Constantvalue =
%678 = Constantvalue =
%679 = Constantvalue =
%680 = Constantvalue =
%681 = Slice(%654, %678, %679, %677, %680)
%682 = Sigmoid(%681)
%683 = Mul(%676, %682)
%684 = Constantvalue =
%685 = Div(%662, %684)
%686 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%645, %module_list.91.Conv2d.weight)
%687 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%686, %module_list.91.BatchNorm2d.weight, %module_list.91.BatchNorm2d.bias, %module_list.91.BatchNorm2d.running_mean, %module_list.91.BatchNorm2d.running_var)
%688 = LeakyRelualpha = 0.100000001490116
%689 = Shape(%688)
%690 = Constantvalue = <Scalar Tensor []>
%691 = Gather[axis = 0](%689, %690)
%692 = Castto = 1
%693 = Constantvalue = <Scalar Tensor []>
%694 = Mul(%692, %693)
%695 = Castto = 1
%696 = Floor(%695)
%697 = Shape(%688)
%698 = Constantvalue = <Scalar Tensor []>
%699 = Gather[axis = 0](%697, %698)
%700 = Castto = 1
%701 = Constantvalue = <Scalar Tensor []>
%702 = Mul(%700, %701)
%703 = Castto = 1
%704 = Floor(%703)
%705 = Unsqueezeaxes = [0]
%706 = Unsqueezeaxes = [0]
%707 = Concat[axis = 0](%705, %706)
%708 = Constantvalue =
%709 = Shape(%688)
%710 = Constantvalue =
%711 = Constantvalue =
%712 = Constantvalue =
%713 = Slice(%709, %711, %712, %710)
%714 = Castto = 7
%715 = Concat[axis = 0](%713, %714)
%716 = Resize[coordinate_transformation_mode = ‘asymmetric’, cubic_coeff_a = -0.75, mode = ‘nearest’, nearest_mode = ‘floor’](%688, %708, %708, %715)
%717 = Concat[axis = 1](%716, %592)
%718 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%717, %module_list.94.Conv2d.weight)
%719 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%718, %module_list.94.BatchNorm2d.weight, %module_list.94.BatchNorm2d.bias, %module_list.94.BatchNorm2d.running_mean, %module_list.94.BatchNorm2d.running_var)
%720 = LeakyRelualpha = 0.100000001490116
%721 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%720, %module_list.95.Conv2d.weight)
%722 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%721, %module_list.95.BatchNorm2d.weight, %module_list.95.BatchNorm2d.bias, %module_list.95.BatchNorm2d.running_mean, %module_list.95.BatchNorm2d.running_var)
%723 = LeakyRelualpha = 0.100000001490116
%724 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%723, %module_list.96.Conv2d.weight)
%725 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%724, %module_list.96.BatchNorm2d.weight, %module_list.96.BatchNorm2d.bias, %module_list.96.BatchNorm2d.running_mean, %module_list.96.BatchNorm2d.running_var)
%726 = LeakyRelualpha = 0.100000001490116
%727 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%726, %module_list.97.Conv2d.weight)
%728 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%727, %module_list.97.BatchNorm2d.weight, %module_list.97.BatchNorm2d.bias, %module_list.97.BatchNorm2d.running_mean, %module_list.97.BatchNorm2d.running_var)
%729 = LeakyRelualpha = 0.100000001490116
%730 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%729, %module_list.98.Conv2d.weight)
%731 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%730, %module_list.98.BatchNorm2d.weight, %module_list.98.BatchNorm2d.bias, %module_list.98.BatchNorm2d.running_mean, %module_list.98.BatchNorm2d.running_var)
%732 = LeakyRelualpha = 0.100000001490116
%733 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%732, %module_list.99.Conv2d.weight)
%734 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%733, %module_list.99.BatchNorm2d.weight, %module_list.99.BatchNorm2d.bias, %module_list.99.BatchNorm2d.running_mean, %module_list.99.BatchNorm2d.running_var)
%735 = LeakyRelualpha = 0.100000001490116
%736 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%735, %module_list.100.Conv2d.weight, %module_list.100.Conv2d.bias)
%737 = Constantvalue =
%738 = Reshape(%736, %737)
%739 = Transposeperm = [0, 1, 3, 4, 2]
%740 = Constantvalue =
%741 = Reshape(%739, %740)
%742 = Constantvalue =
%743 = Constantvalue =
%744 = Constantvalue =
%745 = Constantvalue =
%746 = Slice(%741, %743, %744, %742, %745)
%747 = Sigmoid(%746)
%748 = Constantvalue =
%749 = Add(%747, %748)
%750 = Constantvalue =
%751 = Constantvalue =
%752 = Constantvalue =
%753 = Constantvalue =
%754 = Slice(%741, %751, %752, %750, %753)
%755 = Exp(%754)
%756 = Constantvalue =
%757 = Mul(%755, %756)
%758 = Constantvalue =
%759 = Constantvalue =
%760 = Constantvalue =
%761 = Constantvalue =
%762 = Slice(%741, %759, %760, %758, %761)
%763 = Sigmoid(%762)
%764 = Constantvalue =
%765 = Constantvalue =
%766 = Constantvalue =
%767 = Constantvalue =
%768 = Slice(%741, %765, %766, %764, %767)
%769 = Sigmoid(%768)
%770 = Mul(%763, %769)
%771 = Constantvalue =
%772 = Div(%749, %771)
%773 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%732, %module_list.103.Conv2d.weight)
%774 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%773, %module_list.103.BatchNorm2d.weight, %module_list.103.BatchNorm2d.bias, %module_list.103.BatchNorm2d.running_mean, %module_list.103.BatchNorm2d.running_var)
%775 = LeakyRelualpha = 0.100000001490116
%776 = Shape(%775)
%777 = Constantvalue = <Scalar Tensor []>
%778 = Gather[axis = 0](%776, %777)
%779 = Castto = 1
%780 = Constantvalue = <Scalar Tensor []>
%781 = Mul(%779, %780)
%782 = Castto = 1
%783 = Floor(%782)
%784 = Shape(%775)
%785 = Constantvalue = <Scalar Tensor []>
%786 = Gather[axis = 0](%784, %785)
%787 = Castto = 1
%788 = Constantvalue = <Scalar Tensor []>
%789 = Mul(%787, %788)
%790 = Castto = 1
%791 = Floor(%790)
%792 = Unsqueezeaxes = [0]
%793 = Unsqueezeaxes = [0]
%794 = Concat[axis = 0](%792, %793)
%795 = Constantvalue =
%796 = Shape(%775)
%797 = Constantvalue =
%798 = Constantvalue =
%799 = Constantvalue =
%800 = Slice(%796, %798, %799, %797)
%801 = Castto = 7
%802 = Concat[axis = 0](%800, %801)
%803 = Resize[coordinate_transformation_mode = ‘asymmetric’, cubic_coeff_a = -0.75, mode = ‘nearest’, nearest_mode = ‘floor’](%775, %795, %795, %802)
%804 = Concat[axis = 1](%803, %533)
%805 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%804, %module_list.106.Conv2d.weight)
%806 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%805, %module_list.106.BatchNorm2d.weight, %module_list.106.BatchNorm2d.bias, %module_list.106.BatchNorm2d.running_mean, %module_list.106.BatchNorm2d.running_var)
%807 = LeakyRelualpha = 0.100000001490116
%808 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%807, %module_list.107.Conv2d.weight)
%809 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%808, %module_list.107.BatchNorm2d.weight, %module_list.107.BatchNorm2d.bias, %module_list.107.BatchNorm2d.running_mean, %module_list.107.BatchNorm2d.running_var)
%810 = LeakyRelualpha = 0.100000001490116
%811 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%810, %module_list.108.Conv2d.weight)
%812 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%811, %module_list.108.BatchNorm2d.weight, %module_list.108.BatchNorm2d.bias, %module_list.108.BatchNorm2d.running_mean, %module_list.108.BatchNorm2d.running_var)
%813 = LeakyRelualpha = 0.100000001490116
%814 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%813, %module_list.109.Conv2d.weight)
%815 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%814, %module_list.109.BatchNorm2d.weight, %module_list.109.BatchNorm2d.bias, %module_list.109.BatchNorm2d.running_mean, %module_list.109.BatchNorm2d.running_var)
%816 = LeakyRelualpha = 0.100000001490116
%817 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%816, %module_list.110.Conv2d.weight)
%818 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%817, %module_list.110.BatchNorm2d.weight, %module_list.110.BatchNorm2d.bias, %module_list.110.BatchNorm2d.running_mean, %module_list.110.BatchNorm2d.running_var)
%819 = LeakyRelualpha = 0.100000001490116
%820 = Conv[dilations = [1, 1], group = 1, kernel_shape = [3, 3], pads = [1, 1, 1, 1], strides = [1, 1]](%819, %module_list.111.Conv2d.weight)
%821 = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.899999976158142](%820, %module_list.111.BatchNorm2d.weight, %module_list.111.BatchNorm2d.bias, %module_list.111.BatchNorm2d.running_mean, %module_list.111.BatchNorm2d.running_var)
%822 = LeakyRelualpha = 0.100000001490116
%823 = Conv[dilations = [1, 1], group = 1, kernel_shape = [1, 1], pads = [0, 0, 0, 0], strides = [1, 1]](%822, %module_list.112.Conv2d.weight, %module_list.112.Conv2d.bias)
%824 = Constantvalue =
%825 = Reshape(%823, %824)
%826 = Transposeperm = [0, 1, 3, 4, 2]
%827 = Constantvalue =
%828 = Reshape(%826, %827)
%829 = Constantvalue =
%830 = Constantvalue =
%831 = Constantvalue =
%832 = Constantvalue =
%833 = Slice(%828, %830, %831, %829, %832)
%834 = Sigmoid(%833)
%835 = Constantvalue =
%836 = Add(%834, %835)
%837 = Constantvalue =
%838 = Constantvalue =
%839 = Constantvalue =
%840 = Constantvalue =
%841 = Slice(%828, %838, %839, %837, %840)
%842 = Exp(%841)
%843 = Constantvalue =
%844 = Mul(%842, %843)
%845 = Constantvalue =
%846 = Constantvalue =
%847 = Constantvalue =
%848 = Constantvalue =
%849 = Slice(%828, %846, %847, %845, %848)
%850 = Sigmoid(%849)
%851 = Constantvalue =
%852 = Constantvalue =
%853 = Constantvalue =
%854 = Constantvalue =
%855 = Slice(%828, %852, %853, %851, %854)
%856 = Sigmoid(%855)
%857 = Mul(%850, %856)
%858 = Constantvalue =
%859 = Div(%836, %858)
%860 = Concat[axis = 0](%683, %770, %857)
%861 = Concat[axis = 0](%685, %772, %859)
%862 = Concat[axis = 0](%670, %757, %844)
%863 = Concat[axis = 1](%861, %862)
return %860, %863
}

Hi, the exported onnx model can be used with onnxruntime. below is inference code.

import torch
import torch.nn as nn
import torch.nn.functional as F
import onnx
import onnxruntime
import numpy as np

print(‘torch version %s’ % torch.version)
print(‘onnx version %s’ % onnx.version)

sess = onnxruntime.InferenceSession(’./weights/michael_export.onnx’, None)

input_name = sess.get_inputs()[0].name
print(“Input name :”, input_name)
input_shape = sess.get_inputs()[0].shape
print(“Input shape :”, input_shape)
input_type = sess.get_inputs()[0].type
print(“Input type :”, input_type)

output_name = sess.get_outputs()[0].name
print(“Output name :”, output_name)
output_shape = sess.get_outputs()[0].shape
print(“Output shape :”, output_shape)
output_type = sess.get_outputs()[0].type
print(“Output type :”, output_type)

output_name = sess.get_outputs()[1].name
print(“Output name :”, output_name)
output_shape = sess.get_outputs()[1].shape
print(“Output shape :”, output_shape)
output_type = sess.get_outputs()[1].type
print(“Output type :”, output_type)

x = np.random.random(input_shape)
x = x.astype(np.float32)

result = sess.run([output_name], {input_name: x})
print(result)

======================================
torch version 1.4.0
onnx version 1.6.0
Input name : input.1
Input shape : [1, 3, 320, 192]
Input type : tensor(float)
Output name : 860
Output shape : [3780, 1]
Output type : tensor(float)
Output name : 863
Output shape : [3780, 4]
Output type : tensor(float)
[array([[0.07807311, 0.05717309, 0.49423143, 0.13545902],
[0.23096414, 0.06182856, 0.63886625, 0.11188202],
[0.47037208, 0.06932298, 0.94525224, 0.1177386 ],
…,
[0.89407057, 0.9842566 , 0.43239728, 0.05691503],
[0.93542886, 0.9835764 , 0.3734816 , 0.06328472],
[0.977526 , 0.98460114, 0.3858035 , 0.08022577]], dtype=float32)]

Hi,

Please try updating the TRT and ONNX to latest version.

It seems to be due to below issue:
https://github.com/onnx/keras-onnx/issues/86

ONNX supported operators:
https://github.com/onnx/onnx-tensorrt/blob/master/operators.md#supported-onnx-operators

Thanks