Pytorch -> onnx -> tensorrt (trtexec) _for deeplabv3

Description

model(network) : deeplab v3

I export deeplabv3 to onnx. Then, using trtexec, we want to test the performance (speed) in TensorAlti.
The export to pytorch-> onnx was successful.
However, an error occurred in output.onnx (deeplabv3) with trtexec.
The code below is an error code.

terminate called after throwing an instance of ‘std :: out_of_range’
what (): Attribute not found: pads
Aborted (core dumped)

There was no answer through Google search, so I left this article. In addition, please tell me if you need to let me know.
I look forward to a successful response.

Environment

TensorRT Version: tensorrt 7.0.0.11
GPU Type: RTX 2080ti
Nvidia Driver Version: 440.64
CUDA Version: 10.2
CUDNN Version: i don’t know
Operating System + Version: ubuntu 18.04
Python Version (if applicable): 3.6x
TensorFlow Version (if applicable): X
PyTorch Version (if applicable): 1.4.0
Baremetal or Container (if container which image + tag): Ok ( _tensorrt git(url:https://github.com/NVIDIA/TensorRT))

Relevant Files

Please attach or include links to any models, data, files, or scripts necessary to reproduce your issue. (Github repo, Google Drive, Dropbox, etc.)

#deeplabv3.py#
import torch.nn as nn
from torch.nn import functional as F
import math
import torch.utils.model_zoo as model_zoo
import torch
import numpy as np
from torch.autograd import Variable

affine_par = True

import functools

import sys, os

BatchNorm2d = nn.BatchNorm2d

def conv3x3(in_planes, out_planes, stride=1):
“3x3 convolution with padding”
return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
padding=1, bias=False)

class Bottleneck(nn.Module):
expansion = 4
def init(self, inplanes, planes, stride=1, dilation=1, downsample=None, fist_dilation=1, multi_grid=1):
super(Bottleneck, self).init()
self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
self.bn1 = BatchNorm2d(planes)
self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride,
padding=dilationmulti_grid, dilation=dilationmulti_grid, bias=False)
self.bn2 = BatchNorm2d(planes)
self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False)
self.bn3 = BatchNorm2d(planes * 4)
self.relu = nn.ReLU(inplace=False)
self.relu_inplace = nn.ReLU(inplace=True)
self.downsample = downsample
self.dilation = dilation
self.stride = stride

def forward(self, x):
    residual = x

    out = self.conv1(x)
    out = self.bn1(out)
    out = self.relu(out)

    out = self.conv2(out)
    out = self.bn2(out)
    out = self.relu(out)

    out = self.conv3(out)
    out = self.bn3(out)

    if self.downsample is not None:
        residual = self.downsample(x)

    out = out + residual
    out = self.relu_inplace(out)

    return out

class ASPPModule(nn.Module):
“”"
Reference:
Chen, Liang-Chieh, et al. “Rethinking Atrous Convolution for Semantic Image Segmentation.”
“”"
def init(self, features, inner_features=256, out_features=512, dilations=(12, 24, 36)):
super(ASPPModule, self).init()
self.avg = torch.mean
self.conv1 = nn.Sequential(nn.AvgPool2d((129,257)),
nn.Conv2d(features, inner_features, kernel_size=1, padding=0, dilation=1, bias=False),
)
self.conv2 = nn.Sequential(nn.Conv2d(features, inner_features, kernel_size=1, padding=0, dilation=1, bias=False),
nn.BatchNorm2d(inner_features))
self.conv3 = nn.Sequential(nn.Conv2d(features, inner_features, kernel_size=3, padding=dilations[0], dilation=dilations[0], bias=False),
nn.BatchNorm2d(inner_features))
self.conv4 = nn.Sequential(nn.Conv2d(features, inner_features, kernel_size=3, padding=dilations[1], dilation=dilations[1], bias=False),
nn.BatchNorm2d(inner_features))
self.conv5 = nn.Sequential(nn.Conv2d(features, inner_features, kernel_size=3, padding=dilations[2], dilation=dilations[2], bias=False),
nn.BatchNorm2d(inner_features))

    self.bottleneck = nn.Sequential(
        nn.Conv2d(inner_features * 5, out_features, padding=0, kernel_size=1, dilation=1, bias=False),
        nn.BatchNorm2d(out_features),
        nn.Dropout2d(0.1)
        )
    self.conv1_batchnorm1d= nn.BatchNorm1d(256)

def forward(self, x):

    inter_x = self.conv1(x)
    inter_x = inter_x.view(1, -1)
    inter_x = self.conv1_batchnorm1d(inter_x)
    inter_x = inter_x.view(1, 256, 1, 1)

    feat1 = F.interpolate(inter_x, size=(129, 257), mode='bilinear', align_corners=True)
    feat2 = self.conv2(x)
    feat3 = self.conv3(x)
    feat4 = self.conv4(x)
    feat5 = self.conv5(x)

    out = torch.cat([feat1, feat2, feat3, feat4, feat5], 1)
    bottle = self.bottleneck(out)
    return bottle

class ResNet(nn.Module):
def init(self, block, layers, num_classes):
self.inplanes = 128
super(ResNet, self).init()
self.conv1 = conv3x3(3, 64, stride=2)
self.bn1 = BatchNorm2d(64)
self.relu1 = nn.ReLU(inplace=False)
self.conv2 = conv3x3(64, 64)
self.bn2 = BatchNorm2d(64)
self.relu2 = nn.ReLU(inplace=False)
self.conv3 = conv3x3(64, 128)
self.bn3 = BatchNorm2d(128)
self.relu3 = nn.ReLU(inplace=False)
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)

    self.relu = nn.ReLU(inplace=False)
    self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1, ceil_mode=True) # change
    self.layer1 = self._make_layer(block, 64, layers[0])
    self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
    self.layer3 = self._make_layer(block, 256, layers[2], stride=1, dilation=2)
    self.layer4 = self._make_layer(block, 512, layers[3], stride=1, dilation=4, multi_grid=(1,1,1))

    self.head = nn.Sequential(ASPPModule(2048),
                    nn.Conv2d(512, num_classes, kernel_size=1, stride=1, padding=0, bias=True))
def _make_layer(self, block, planes, blocks, stride=1, dilation=1, multi_grid=1):
    downsample = None
    if stride != 1 or self.inplanes != planes * block.expansion:
        downsample = nn.Sequential(
            nn.Conv2d(self.inplanes, planes * block.expansion,
                      kernel_size=1, stride=stride, bias=False),
            BatchNorm2d(planes * block.expansion))

    layers = []
    generate_multi_grid = lambda index, grids: grids[index%len(grids)] if isinstance(grids, tuple) else 1
    layers.append(block(self.inplanes, planes, stride,dilation=dilation, downsample=downsample, multi_grid=generate_multi_grid(0, multi_grid)))
    self.inplanes = planes * block.expansion
    for i in range(1, blocks):
        layers.append(block(self.inplanes, planes, dilation=dilation, multi_grid=generate_multi_grid(i, multi_grid)))

    return nn.Sequential(*layers)

def forward(self, x):
    x = self.relu1(self.bn1(self.conv1(x)))
    x = self.relu2(self.bn2(self.conv2(x)))
    x = self.relu3(self.bn3(self.conv3(x)))
    x = self.maxpool(x)
    x = self.layer1(x)
    x = self.layer2(x)
    x = self.layer3(x)
    x = self.layer4(x)
    x = self.head(x)

    return x

def Res_Deeplab(num_classes=21):
model = ResNet(Bottleneck,[3, 4, 23, 3], num_classes)
return model

##export.py##
from deeplabv3 import *
import torch

torch_model = Res_Deeplab()
torch_model.eval()
x = torch.randn(1, 3, 1024, 2048, requires_grad=True)
torch_out = torch_model(x)
orch.onnx.export(torch_model,
x,
“super_resolution.onnx”,
export_params=True,
opset_version=11,
do_constant_folding=True,
input_names = [‘input’],
output_names = [‘output’],
dynamic_axes={‘input’ : {0 : ‘batch_size’},
‘output’ : {0 : ‘batch_size’}})

Steps To Reproduce

i want : pytorch (deeplabv3.py) -> onnx(export.py) -> trtexec

command : trtexec --onnx=deeplabv3.onnx --maxBatch=1 --shapes=input:1x3x1024x2048 --iterations=500 --workspace 9000

error code :
terminate called after throwing an instance of ‘std :: out_of_range’
what (): Attribute not found: pads
Aborted (core dumped)

Hi,

Can you try running trtexec command with “–explicitBatch” flag in verbose mode?

Also, check ONNX model using checker function and see if it passes?
import onnx
model = onnx.load(“model.onnx”)
onnx.checker.check_model(model)

If issue persist, could you please share the ONNX model so we can better help.

Thanks

Thanks for the quick response. Unfortunately the problem was not solved.

Attached is a git url containing the used .py and exported .onnx files. The url is as follows.
url : https://github.com/modernkim/-NVIDIA_tensorrt_QnA.git (.py)

For .onnx, we will send you a Google link. The url is as follows.
url : https://drive.google.com/open?id=1YTQ8kqdOsDOy5L0dspnTUjlX27abfaoh [.onnx]

Please confirm the repository and comment.

I tried as I told you. However, the problem was not solved.
The checker function is said to have been exported normally.
The trtexec command I used is as follows.

** trtexec --onnx=output_deeplabv3.onnx --explicitBatch --verbose=True --workspace=9000 --shapes=input:1x3x1024x2048

Some of the verbose output is:
[04/15/2020-09:10:47] [V] [TRT] /workspace/TensorRT/parsers/onnx/builtin_op_importers.cpp:524: Convolution output dimensions: (-1, 2048, 129, 257)
[04/15/2020-09:10:47] [V] [TRT] /workspace/TensorRT/parsers/onnx/ImporterContext.hpp:122: Registering layer: (Unnamed Layer* 344) [Convolution] for ONNX node:
[04/15/2020-09:10:47] [V] [TRT] /workspace/TensorRT/parsers/onnx/ImporterContext.hpp:97: Registering tensor: 1019 for ONNX tensor: 1019
[04/15/2020-09:10:47] [V] [TRT] /workspace/TensorRT/parsers/onnx/ModelImporter.cpp:180: [Conv] outputs: [1019 -> (-1, 2048, 129, 257)],
[04/15/2020-09:10:47] [V] [TRT] /workspace/TensorRT/parsers/onnx/ModelImporter.cpp:107: Parsing node: [BatchNormalization]
[04/15/2020-09:10:47] [V] [TRT] /workspace/TensorRT/parsers/onnx/ModelImporter.cpp:123: Searching for input: 1019
[04/15/2020-09:10:47] [V] [TRT] /workspace/TensorRT/parsers/onnx/ModelImporter.cpp:123: Searching for input: layer4.2.bn3.weight
[04/15/2020-09:10:47] [V] [TRT] /workspace/TensorRT/parsers/onnx/ModelImporter.cpp:123: Searching for input: layer4.2.bn3.bias
[04/15/2020-09:10:47] [V] [TRT] /workspace/TensorRT/parsers/onnx/ModelImporter.cpp:123: Searching for input: layer4.2.bn3.running_mean
[04/15/2020-09:10:47] [V] [TRT] /workspace/TensorRT/parsers/onnx/ModelImporter.cpp:123: Searching for input: layer4.2.bn3.running_var
[04/15/2020-09:10:47] [V] [TRT] /workspace/TensorRT/parsers/onnx/ModelImporter.cpp:129: [BatchNormalization] inputs: [1019 -> (-1, 2048, 129, 257)], [layer4.2.bn3.weight -> (2048)], [layer4.2.bn3.bias -> (2048)], [layer4.2.bn3.running_mean -> (2048)], [layer4.2.bn3.running_var -> (2048)],
[04/15/2020-09:10:47] [V] [TRT] /workspace/TensorRT/parsers/onnx/ImporterContext.hpp:122: Registering layer: (Unnamed Layer* 345) [Scale] for ONNX node:
[04/15/2020-09:10:47] [V] [TRT] /workspace/TensorRT/parsers/onnx/ImporterContext.hpp:97: Registering tensor: 1020 for ONNX tensor: 1020
[04/15/2020-09:10:47] [V] [TRT] /workspace/TensorRT/parsers/onnx/ModelImporter.cpp:180: [BatchNormalization] outputs: [1020 -> (-1, 2048, 129, 257)],
[04/15/2020-09:10:47] [V] [TRT] /workspace/TensorRT/parsers/onnx/ModelImporter.cpp:107: Parsing node: [Add]
[04/15/2020-09:10:47] [V] [TRT] /workspace/TensorRT/parsers/onnx/ModelImporter.cpp:123: Searching for input: 1020
[04/15/2020-09:10:47] [V] [TRT] /workspace/TensorRT/parsers/onnx/ModelImporter.cpp:123: Searching for input: 1012
[04/15/2020-09:10:47] [V] [TRT] /workspace/TensorRT/parsers/onnx/ModelImporter.cpp:129: [Add] inputs: [1020 -> (-1, 2048, 129, 257)], [1012 -> (-1, 2048, 129, 257)],
[04/15/2020-09:10:47] [V] [TRT] /workspace/TensorRT/parsers/onnx/ImporterContext.hpp:122: Registering layer: (Unnamed Layer* 346) [ElementWise] for ONNX node:
[04/15/2020-09:10:47] [V] [TRT] /workspace/TensorRT/parsers/onnx/ImporterContext.hpp:97: Registering tensor: 1021 for ONNX tensor: 1021
[04/15/2020-09:10:47] [V] [TRT] /workspace/TensorRT/parsers/onnx/ModelImporter.cpp:180: [Add] outputs: [1021 -> (-1, 2048, 129, 257)],
[04/15/2020-09:10:47] [V] [TRT] /workspace/TensorRT/parsers/onnx/ModelImporter.cpp:107: Parsing node: [Relu]
[04/15/2020-09:10:47] [V] [TRT] /workspace/TensorRT/parsers/onnx/ModelImporter.cpp:123: Searching for input: 1021
[04/15/2020-09:10:47] [V] [TRT] /workspace/TensorRT/parsers/onnx/ModelImporter.cpp:129: [Relu] inputs: [1021 -> (-1, 2048, 129, 257)],
[04/15/2020-09:10:47] [V] [TRT] /workspace/TensorRT/parsers/onnx/ImporterContext.hpp:122: Registering layer: (Unnamed Layer* 347) [Activation] for ONNX node:
[04/15/2020-09:10:47] [V] [TRT] /workspace/TensorRT/parsers/onnx/ImporterContext.hpp:97: Registering tensor: 1022 for ONNX tensor: 1022
[04/15/2020-09:10:47] [V] [TRT] /workspace/TensorRT/parsers/onnx/ModelImporter.cpp:180: [Relu] outputs: [1022 -> (-1, 2048, 129, 257)],
[04/15/2020-09:10:47] [V] [TRT] /workspace/TensorRT/parsers/onnx/ModelImporter.cpp:107: Parsing node: [Constant]
[04/15/2020-09:10:47] [V] [TRT] /workspace/TensorRT/parsers/onnx/ModelImporter.cpp:129: [Constant] inputs:
[04/15/2020-09:10:47] [W] [TRT] /workspace/TensorRT/parsers/onnx/onnx2trt_utils.cpp:216: Your ONNX model has been generated with INT64 weights, while TensorRT does not natively support INT64. Attempting to cast down to INT32.
[04/15/2020-09:10:47] [V] [TRT] /workspace/TensorRT/parsers/onnx/ModelImporter.cpp:180: [Constant] outputs: [1023 -> (8)],
[04/15/2020-09:10:47] [V] [TRT] /workspace/TensorRT/parsers/onnx/ModelImporter.cpp:107: Parsing node: [Pad]
[04/15/2020-09:10:47] [V] [TRT] /workspace/TensorRT/parsers/onnx/ModelImporter.cpp:123: Searching for input: 1022
[04/15/2020-09:10:47] [V] [TRT] /workspace/TensorRT/parsers/onnx/ModelImporter.cpp:123: Searching for input: 1023
[04/15/2020-09:10:47] [V] [TRT] /workspace/TensorRT/parsers/onnx/ModelImporter.cpp:129: [Pad] inputs: [1022 -> (-1, 2048, 129, 257)], [1023 -> (8)],
terminate called after throwing an instance of ‘std::out_of_range’
what(): Attribute not found: pads
Aborted (core dumped)

Hi,

Please refer to this link in case it helps:

Thanks

Thanks for the quick response. Unfortunately the problem was not solved.

Another error has occurred. Please comment.

The error code is as follows.

[04/15/2020-17:53:49] [V] [TRT] /workspace/TensorRT/parsers/onnx/ModelImporter.cpp:129: [BatchNormalization] inputs: [1027 -> (-1, -1)], [head.0.conv1_batchnorm1d.weight -> (256)], [head.0.conv1_batchnorm1d.bias -> (256)], [head.0.conv1_batchnorm1d.running_mean -> (256)], [head.0.conv1_batchnorm1d.running_var -> (256)],
[04/15/2020-17:53:49] [E] [TRT] (Unnamed Layer* 364) [Shuffle]: at most one dimension may be inferred
While parsing node number 353 [BatchNormalization -> “1028”]:
— Begin node —
input: “1027”
input: “head.0.conv1_batchnorm1d.weight”
input: “head.0.conv1_batchnorm1d.bias”
input: “head.0.conv1_batchnorm1d.running_mean”
input: “head.0.conv1_batchnorm1d.running_var”
output: “1028”
op_type: “BatchNormalization”
attribute {
name: “epsilon”
f: 1e-05
type: FLOAT
}
attribute {
name: “momentum”
f: 0.9
type: FLOAT
}

— End node —
ERROR: /workspace/TensorRT/parsers/onnx/onnx2trt_utils.cpp:1379 In function scaleHelper:
[8] Assertion failed: dims.nbDims == 4 || dims.nbDims == 5
[04/15/2020-17:53:50] [E] Failed to parse onnx file
[04/15/2020-17:53:50] [E] Parsing model failed
[04/15/2020-17:53:50] [E] Engine creation failed
[04/15/2020-17:53:50] [E] Engine set up failed

Hi,

The TRT7 binary parser does not support opset 11 padding.
Looks like this padding opset11 support was just added to master here, did you try to build the latest open source parser and generate the model?:

Thanks